sentinel: Support selfpatching

Author: PartMan7

src/discord/loaders/commands.ts

@@ -4,7 +4,7 @@ import { promises as fs } from 'fs';
 import { DiscCommands } from '@/cache';
 import { resetCache } from '@/cache/reset';
 import { clientId, token } from '@/config/discord';
-import { cachebuster } from '@/utils/cachebuster';
+import { cachebust } from '@/utils/cachebust';
 import { fsPath } from '@/utils/fsPath';
 import { log } from '@/utils/logger';
 
@@ -66,7 +66,7 @@ export async function loadCommands(): Promise<void> {
 
 export function unloadCommands(): void {
 	// Delete require cache for commands
-	Object.values(DiscCommands).forEach(({ path }) => cachebuster(path));
+	Object.values(DiscCommands).forEach(({ path }) => cachebust(path));
 	resetCache('DiscCommands');
 }
 

src/eval.ts

@@ -3,9 +3,10 @@ import _path from 'path';
 import { inspect } from 'util';
 
 import * as _cache from '@/cache';
+import _Sentinel from '@/sentinel';
 import * as _Tools from '@/tools';
 import { ansiToHtml } from '@/utils/ansiToHtml';
-import { cachebuster as _cachebuster } from '@/utils/cachebuster';
+import { cachebust as _cachebuster } from '@/utils/cachebust';
 import { $ as _$ } from '@/utils/child_process';
 import { fsPath as _fsPath } from '@/utils/fsPath';
 import { log as _log } from '@/utils/logger';
@@ -23,9 +24,10 @@ const log = _log;
 const path = _path;
 const Tools = _Tools;
 const $ = _$;
+const Sentinel = _Sentinel;
 
 // Storing in context for eval()
-const _evalContext = [cache, cachebuster, fs, fsSync, fsPath, log, path, Tools, $];
+const _evalContext = [cache, cachebuster, fs, fsSync, fsPath, log, path, Tools, $, Sentinel];
 
 export type EvalModes = 'COLOR_OUTPUT' | 'FULL_OUTPUT' | 'ABBR_OUTPUT' | 'NO_OUTPUT';
 export type EvalOutput = {

src/ps/loaders/commands.ts

@@ -4,7 +4,7 @@ import path from 'path';
 import { PSAliases, PSCommands } from '@/cache';
 import { resetCache } from '@/cache/reset';
 import getSecretCommands from '@/secrets/ps';
-import { cachebuster } from '@/utils/cachebuster';
+import { cachebust } from '@/utils/cachebust';
 import { fsPath } from '@/utils/fsPath';
 
 import type { PSCommand } from '@/types/chat';
@@ -67,7 +67,7 @@ export async function loadCommands(): Promise<void> {
 
 export function unloadCommands(): void {
 	// Delete cached commands
-	Object.values(PSCommands).forEach(({ path }) => cachebuster(path));
+	Object.values(PSCommands).forEach(({ path }) => cachebust(path));
 	// Delete command data and aliases
 	resetCache('PSCommands', 'PSAliases');
 }

src/sentinel/sentinel.ts src/sentinel/create.tssrc/sentinel/sentinel.ts renamed to src/sentinel/create.ts

@@ -1,25 +1,12 @@
-import { watch } from 'chokidar';
-import EventEmitter from 'events';
+import { type FSWatcher, watch } from 'chokidar';
 
 import { registers } from '@/sentinel/registers';
 import { debounce } from '@/utils/debounce';
 import { fsPath } from '@/utils/fsPath';
 
-import type { EmitterEvents, Listener, Register } from '@/sentinel/types';
-import type { FSWatcher } from 'chokidar';
-
-class Emitter extends EventEmitter {
-	emit<K extends keyof EmitterEvents>(event: K, ...args: EmitterEvents[K]): boolean {
-		return super.emit(event, ...args);
-	}
-	on<K extends keyof EmitterEvents>(event: K, listener: (...args: EmitterEvents[K]) => void): this {
-		return super.on(event, listener);
-	}
-}
-
-export default function createSentinel(): { emitter: Emitter; sentinel: FSWatcher } {
-	const emitter = new Emitter();
+import type { Emitter, Listener, Register } from '@/sentinel/types';
 
+export function create(emitter: Emitter): FSWatcher {
 	const listeners: Listener[] = registers.list
 		.map(
 			// Add debouncing
@@ -52,5 +39,5 @@ export default function createSentinel(): { emitter: Emitter; sentinel: FSWatche
 	sentinel.on('all', async (event, filepath) => {
 		listeners.find(({ pattern }) => pattern.test(filepath))?.reload(filepath);
 	});
-	return { emitter, sentinel };
+	return sentinel;
 }

src/sentinel/hotpatch.ts

@@ -1,15 +1,18 @@
 import { promises as fs } from 'fs';
 import path from 'path';
-import { update } from 'ps-client/tools';
+import { update as updatePSData } from 'ps-client/tools';
 
 import { registers } from '@/sentinel/registers';
+import { cachebust, cachebustDir } from '@/utils/cachebust';
 import { $ } from '@/utils/child_process';
 import { fsPath } from '@/utils/fsPath';
 import { errorLog, log } from '@/utils/logger';
 
+import type { Sentinel } from '@/sentinel/types';
+
 export type HotpatchType = 'code' | 'data' | string;
 
-export async function hotpatch(hotpatchType: HotpatchType, by: string | symbol): Promise<void> {
+export async function hotpatch(this: Sentinel, hotpatchType: HotpatchType, by: string | symbol): Promise<void> {
 	if (!hotpatchType) throw new TypeError('Missing hotpatchType');
 	try {
 		// Hardcoded variants
@@ -19,10 +22,18 @@ export async function hotpatch(hotpatchType: HotpatchType, by: string | symbol):
 				break;
 			}
 			case 'data': {
-				await update();
+				await updatePSData();
 				// TODO: cachebust
 				break;
 			}
+			case 'sentinel': {
+				cachebust('@/sentinel/create');
+				await cachebustDir(fsPath('sentinel', 'registers'));
+				const newSentinel = await import('@/sentinel/create');
+				this.sentinel.close();
+				this.sentinel = newSentinel.create(this.emitter);
+				break;
+			}
 			default:
 				const register = registers.list.find(register => register.label === hotpatchType);
 				if (register) {

src/sentinel/index.ts

@@ -1,6 +1,14 @@
-import createSentinel from '@/sentinel/sentinel';
+import EventEmitter from 'events';
+
+import { create } from '@/sentinel/create';
+import { hotpatch } from '@/sentinel/hotpatch';
+import { Sentinel } from '@/sentinel/types';
 import { log } from '@/utils/logger';
-const { emitter, sentinel } = createSentinel();
+
+import type { Emitter } from '@/sentinel/types';
+
+const emitter = new EventEmitter() as Emitter;
+const sentinel = create(emitter);
 
 emitter.on('complete', (label, files) => {
 	log(`Reloaded ${label} with ${files.join(', ')}`);
@@ -10,4 +18,6 @@ emitter.on('error', (err, label, files) => {
 	log(`Ran into an error while reloading ${label} for ${files.join(', ')}`, err);
 });
 
-export { emitter, sentinel };
+const Sentinel: Sentinel = { hotpatch, sentinel, emitter };
+
+export default Sentinel;

src/sentinel/registers/ps.ts

@@ -3,7 +3,7 @@ import { promises as fs } from 'fs';
 import { Games } from '@/ps/games';
 import { reloadCommands } from '@/ps/loaders/commands';
 import { LivePS } from '@/sentinel/live';
-import { cachebuster } from '@/utils/cachebuster';
+import { cachebust } from '@/utils/cachebust';
 import { fsPath } from '@/utils/fsPath';
 
 import type { GamesList, Meta } from '@/ps/games/common';
@@ -23,7 +23,7 @@ export const PS_REGISTERS: Register[] = [
 		label: 'commands',
 		pattern: /\/ps\/commands\//,
 		reload: async filepaths => {
-			filepaths.forEach(cachebuster);
+			filepaths.forEach(cachebust);
 			return reloadCommands();
 		},
 	},
@@ -32,15 +32,15 @@ export const PS_REGISTERS: Register[] = [
 		label: 'games',
 		pattern: /\/ps\/games\//,
 		reload: async () => {
-			['common', 'game', 'index', 'render'].forEach(file => cachebuster(`@/ps/games/${file}`));
+			['common', 'game', 'index', 'render'].forEach(file => cachebust(`@/ps/games/${file}`));
 			const games = await fs.readdir(fsPath('ps', 'games'), { withFileTypes: true });
 			await Promise.all(
 				games
 					.filter(game => game.isDirectory())
 					.map(async game => {
 						const gameDir = game.name as GamesList;
 						const files = await fs.readdir(fsPath('ps', 'games', gameDir));
-						files.forEach(file => cachebuster(fsPath('ps', 'games', gameDir, file)));
+						files.forEach(file => cachebust(fsPath('ps', 'games', gameDir, file)));
 
 						const gameImport = await import(`@/ps/games/${gameDir}`);
 						const { meta }: { meta: Meta } = gameImport;
@@ -51,7 +51,7 @@ export const PS_REGISTERS: Register[] = [
 			);
 
 			const gameCommands = await fs.readdir(fsPath('ps', 'commands', 'games'));
-			gameCommands.forEach(commandFile => cachebuster(fsPath('ps', 'commands', 'games', commandFile)));
+			gameCommands.forEach(commandFile => cachebust(fsPath('ps', 'commands', 'games', commandFile)));
 			await reloadCommands();
 		},
 	},
@@ -63,17 +63,17 @@ export const PS_REGISTERS: Register[] = [
 			await Promise.all(
 				(<const>['parse', 'permissions', 'spoof']).map(async file => {
 					const importPath = `@/ps/handlers/commands/${file}`;
-					cachebuster(importPath);
+					cachebust(importPath);
 					const hotHandler = await import(importPath);
 					LivePS.commands[file] = hotHandler[file];
 				})
 			);
 
-			cachebuster('@/ps/handlers/commands/customPerms');
+			cachebust('@/ps/handlers/commands/customPerms');
 			const { GROUPED_PERMS: newGroupedPerms } = await import('@/ps/handlers/commands/customPerms');
 			LivePS.commands.GROUPED_PERMS = newGroupedPerms;
 
-			cachebuster('@/ps/handlers/commands');
+			cachebust('@/ps/handlers/commands');
 			const { commandHandler } = await import('@/ps/handlers/commands');
 			LivePS.commands.commandHandler = commandHandler;
 		},
@@ -84,7 +84,7 @@ export const PS_REGISTERS: Register[] = [
 		label,
 		pattern: new RegExp(`\\/ps\\/handlers\\/${handlerData.fileName}`),
 		reload: async () => {
-			cachebuster(handlerData.importPath);
+			cachebust(handlerData.importPath);
 			const hotHandler = await import(handlerData.importPath);
 			handlerData.imports.forEach(namedImport => (LivePS[namedImport] = hotHandler[namedImport]));
 		},

src/sentinel/types.ts

@@ -1,9 +1,19 @@
+import type { hotpatch } from '@/sentinel/hotpatch';
+import type { FSWatcher } from 'chokidar';
+import type EventEmitter from 'events';
+
 export interface EmitterEvents {
 	trigger: [label: string, file: string];
 	start: [label: string, files: string[]];
 	complete: [label: string, files: string[]];
 	error: [error: Error, label: string, files: string[]];
 }
 
+export interface Emitter extends EventEmitter {
+	emit<K extends keyof EmitterEvents>(event: K, ...args: EmitterEvents[K]): boolean;
+	on<K extends keyof EmitterEvents>(event: K, listener: (...args: EmitterEvents[K]) => void): this;
+}
+export type Sentinel = { emitter: Emitter; sentinel: FSWatcher; hotpatch: typeof hotpatch };
+
 export type Register = { label: string; pattern: RegExp; reload: (filepaths: string[]) => Promise<void> | void; debounce?: number };
 export type Listener = { label: string; pattern: RegExp; reload: (filepaths: string) => Promise<void> | void };

src/utils/cachebust.ts

@@ -0,0 +1,26 @@
+import { promises as fs } from 'fs';
+import path from 'path';
+
+import { emptyObject } from '@/utils/emptyObject';
+
+export function cachebust(_filepath: string): boolean {
+	const filepath = _filepath.startsWith('/') ? _filepath : require.resolve(_filepath);
+	const cache = require.cache[filepath];
+	if (!cache) return false;
+	emptyObject(cache.exports);
+	cache.children.length = 0;
+	emptyObject(cache);
+	delete require.cache[filepath];
+	return true;
+}
+
+export async function cachebustDir(_dir: string): Promise<boolean> {
+	const entries = await fs.readdir(_dir, { withFileTypes: true, recursive: true });
+	const files = entries.filter(entry => entry.isFile());
+	if (files.length === 0) return false;
+
+	files.forEach(file => {
+		cachebust(path.join(file.parentPath, file.name));
+	});
+	return true;
+}