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)){
 +                        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	1222	toastr.success('Extension is already up to date');
1148	1223	}
1149	1224	} else {
	1225	+ const fullExtensionName = extensionName.startsWith('third-party') ? extensionName : `third-party${extensionName}`;
	1226	+ await callExtensionHook(fullExtensionName, 'update');
1150	1227	toastr.success(t`Extension ${extensionName} updated to ${data.shortCommitHash}`, t`Reload the page to apply updates`);
1151	1228	}
1152	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, folderName });
     } catch (error) {
         console.error('Importing custom content failed', error);
         return response.status(500).send(`Server Error: ${error.message}`);