Implement extension manifest hooks for lifecycle events (#5261) * Initial plan * Implement extension manifest hooks for install, delete, enable, disable Co-authored-by: Cohee1207 <18619528+Cohee1207@users.noreply.github.com> * Revert unrelated package-lock.json changes Co-authored-by: Cohee1207 <18619528+Cohee1207@users.noreply.github.com> * Address review: use Object.hasOwn, add activate hook, simplify await, return folderName from backend Co-authored-by: Cohee1207 <18619528+Cohee1207@users.noreply.github.com> * Add 'update' hook that triggers on extension update Co-authored-by: Cohee1207 <18619528+Cohee1207@users.noreply.github.com> * Revert package-lock * Add 5-second timeout for extension hook calls using delay and Promise.race Co-authored-by: Cohee1207 <18619528+Cohee1207@users.noreply.github.com> * Revert unintended package-lock.json changes Co-authored-by: Cohee1207 <18619528+Cohee1207@users.noreply.github.com> * Add timeout warning log when extension hook exceeds 5 seconds Co-authored-by: Cohee1207 <18619528+Cohee1207@users.noreply.github.com> * Refactor extension hook call to handle synchronous results * Refactor callExtensionHook to use constants for timeout results --------- Co-authored-by: copilot-swe-agent[bot] <198982749+Copilot@users.noreply.github.com> Co-authored-by: Cohee1207 <18619528+Cohee1207@users.noreply.github.com>

3ad9b05e274b0d822363a79d0c80e0e828d98e1a

Copilot <198982749+Copilot@users.noreply.github.com>

Signed

Parents: 92dd9ecab2b82ca97beaa79ccd8864a9976c9ff7

public/scripts/extensions.js+85 -1 Viewed

+}
 /**
+ * Calls a manifest hook for an extension.
+ * Hooks are optional function names exported from the extension's JS entry point module.
+ * The hook function can optionally return a Promise that will be awaited.
+ * @param {string} name Extension name
+ * @param {'install' | 'update' | 'delete' | 'enable' | 'disable' | 'activate'} hookName The hook to call
+ * @returns {Promise<void>}
+ */
+async function callExtensionHook(name, hookName) {
+    const manifest = manifests[name];
+    if (!manifest) {
+        console.debug(`callExtensionHook: Extension "${name}" has no manifest, skipping hook "${hookName}"`);
+        return;
+    }
+    if (!manifest.hooks || typeof manifest.hooks !== 'object') {
+        return;
+    }
+    if (!Object.hasOwn(manifest.hooks, hookName)) {
+        return;
+    }
+    const hookFunctionName = manifest.hooks[hookName];
+    if (typeof hookFunctionName !== 'string' || !hookFunctionName) {
+        console.warn(`callExtensionHook: Extension "${name}" hook "${hookName}" is not a valid string`);
+        return;
+    }
+    if (!manifest.js) {
+        console.warn(`callExtensionHook: Extension "${name}" has hook "${hookName}" but no JS entry point defined in manifest`);
+        return;
+    }
+    const url = `/scripts/extensions/${name}/${manifest.js}`;
+    console.debug(`callExtensionHook: Calling hook "${hookName}" (function "${hookFunctionName}") for extension "${name}"`);
+    try {
+        const module = await import(url);
+        if (typeof module[hookFunctionName] !== 'function') {
+            console.warn(`callExtensionHook: Extension "${name}" hook "${hookName}" references "${hookFunctionName}" which is not an exported function`);
+            return;
+        }
+        const hookCallResult = module[hookFunctionName]();
+        const HOOK_TIMEOUT = 5000;
+        const HOOK_RESULT = {
+            OK: 'ok',
+            TIMEOUT: 'timeout',
+        };
+        const result = await Promise.race([
+            (hookCallResult instanceof Promise ? hookCallResult : Promise.resolve(hookCallResult)).then(() => HOOK_RESULT.OK),
+            delay(HOOK_TIMEOUT).then(() => HOOK_RESULT.TIMEOUT),
+        ]);
+        if (result === HOOK_RESULT.TIMEOUT) {
+            console.warn(`callExtensionHook: Hook "${hookName}" for extension "${name}" timed out after ${HOOK_TIMEOUT}ms`);
+        } else {
+            console.debug(`callExtensionHook: Hook "${hookName}" completed for extension "${name}"`);
+        }
+    } catch (error) {
+        console.error(`callExtensionHook: Error calling hook "${hookName}" for extension "${name}":`, error);
+    }
+}
+/**
  * Enables an extension by name.
  * @param {string} name Extension name
  * @param {boolean} [reload=true] If true, reload the page after enabling the extension
  */
 export async function enableExtension(name, reload = true) {
+    await callExtensionHook(name, 'enable');
     extension_settings.disabledExtensions = extension_settings.disabledExtensions.filter(x => x !== name);
     stateChanged = true;
     await saveSettings();

  * @param {boolean} [reload=true] If true, reload the page after disabling the extension
  */
 export async function disableExtension(name, reload = true) {
+    await callExtensionHook(name, 'disable');
     extension_settings.disabledExtensions.push(name);
     stateChanged = true;
     await saveSettings();

                     Promise.all([addExtensionScript(name, manifest), addExtensionStyle(name, manifest)]),
                 );
                 await promise
-                    .then(() => activeExtensions.add(name))
+                    .then(() => {
+                        activeExtensions.add(name);
+                        return callExtensionHook(name, 'activate');
+                    })
                     .catch(err => {
                         console.log('Could not activate extension', name, err);
                         extensionLoadErrors.add(t`Extension "${displayName}" failed to load: ${err}`);

@@ -1147,6 +1222,8 @@ async function updateExtension(extensionName, quiet, timeout = null) {
1147	toastr.success('Extension is already up to date');	1222	toastr.success('Extension is already up to date');
1148	}	1223	}
1149	} else {	1224	} else {
		1225	const fullExtensionName = extensionName.startsWith('third-party') ? extensionName : `third-party${extensionName}`;
		1226	await callExtensionHook(fullExtensionName, 'update');
1150	toastr.success(t`Extension ${extensionName} updated to ${data.shortCommitHash}`, t`Reload the page to apply updates`);	1227	toastr.success(t`Extension ${extensionName} updated to ${data.shortCommitHash}`, t`Reload the page to apply updates`);
1151	}	1228	}
1152	} catch (error) {	1229	} catch (error) {

  * @param {string} extensionName Extension name to delete
  */
 export async function deleteExtension(extensionName) {
+    await callExtensionHook(extensionName, 'delete');
     try {
         await fetch('/api/extensions/delete', {
             method: 'POST',

     console.debug(`Extension "${response.display_name}" has been installed successfully at ${response.extensionPath}`);
     await loadExtensionSettings({}, false, false);
     await eventSource.emit(event_types.EXTENSION_SETTINGS_LOADED, response);
+    if (response.folderName) {
+        const extensionName = `third-party/${response.folderName}`;
+        await callExtensionHook(extensionName, 'install');
+    }
+}
 /**

src/endpoints/extensions.js+2 -1 Viewed

         console.info(`Extension has been cloned to ${extensionPath} from ${url} at ${branch || '(default)'} branch`);
         const { version, author, display_name } = await getManifest(extensionPath);
+        const folderName = path.basename(extensionPath);
-        return response.send({ version, author, display_name, extensionPath });
+        return response.send({ version, author, display_name, extensionPath, folderName });
     } catch (error) {
         console.error('Importing custom content failed', error);
         return response.status(500).send(`Server Error: ${error.message}`);