@phi-code-admin/phi-code 0.74.2 → 0.75.0

package/dist/core/extensions/runner.js

@@ -2,37 +2,44 @@
  * Extension runner - executes extensions and manages their lifecycle.
  */
 import { theme } from "../../modes/interactive/theme/theme.js";
-// Keybindings for these actions cannot be overridden by extensions
-const RESERVED_ACTIONS_FOR_EXTENSION_CONFLICTS = [
-    "interrupt",
-    "clear",
-    "exit",
-    "suspend",
-    "cycleThinkingLevel",
-    "cycleModelForward",
-    "cycleModelBackward",
-    "selectModel",
-    "expandTools",
-    "toggleThinking",
-    "externalEditor",
-    "followUp",
-    "submit",
-    "selectConfirm",
-    "selectCancel",
-    "copy",
-    "deleteToLineEnd",
+// Extension shortcuts compete with canonical keybinding ids from keybindings.json.
+// Only editor-global shortcuts are reserved here. Picker-specific bindings are not.
+const RESERVED_KEYBINDINGS_FOR_EXTENSION_CONFLICTS = [
+    "app.interrupt",
+    "app.clear",
+    "app.exit",
+    "app.suspend",
+    "app.thinking.cycle",
+    "app.model.cycleForward",
+    "app.model.cycleBackward",
+    "app.model.select",
+    "app.tools.expand",
+    "app.thinking.toggle",
+    "app.editor.external",
+    "app.message.followUp",
+    "tui.input.submit",
+    "tui.select.confirm",
+    "tui.select.cancel",
+    "tui.input.copy",
+    "tui.editor.deleteToLineEnd",
 ];
-const buildBuiltinKeybindings = (effectiveKeybindings) => {
+const buildBuiltinKeybindings = (resolvedKeybindings) => {
     const builtinKeybindings = {};
-    for (const [action, keys] of Object.entries(effectiveKeybindings)) {
-        const keyAction = action;
+    for (const [keybinding, keys] of Object.entries(resolvedKeybindings)) {
+        if (keys === undefined)
+            continue;
         const keyList = Array.isArray(keys) ? keys : [keys];
-        const restrictOverride = RESERVED_ACTIONS_FOR_EXTENSION_CONFLICTS.includes(keyAction);
+        const restrictOverride = RESERVED_KEYBINDINGS_FOR_EXTENSION_CONFLICTS.includes(keybinding);
         for (const key of keyList) {
             const normalizedKey = key.toLowerCase();
+            // If multiple actions bind the same key, the reserved action wins so extensions
+            // remain blocked by reserved shortcuts regardless of iteration order.
+            const existing = builtinKeybindings[normalizedKey];
+            if (existing?.restrictOverride && !restrictOverride)
+                continue;
             builtinKeybindings[normalizedKey] = {
-                action: keyAction,
-                restrictOverride: restrictOverride,
+                keybinding,
+                restrictOverride,
             };
         }
     }
@@ -42,11 +49,9 @@ const buildBuiltinKeybindings = (effectiveKeybindings) => {
  * Helper function to emit session_shutdown event to extensions.
  * Returns true if the event was emitted, false if there were no handlers.
  */
-export async function emitSessionShutdownEvent(extensionRunner) {
-    if (extensionRunner?.hasHandlers("session_shutdown")) {
-        await extensionRunner.emit({
-            type: "session_shutdown",
-        });
+export async function emitSessionShutdownEvent(extensionRunner, event) {
+    if (extensionRunner.hasHandlers("session_shutdown")) {
+        await extensionRunner.emit(event);
         return true;
     }
     return false;
@@ -59,6 +64,9 @@ const noOpUIContext = {
     onTerminalInput: () => () => { },
     setStatus: () => { },
     setWorkingMessage: () => { },
+    setWorkingVisible: () => { },
+    setWorkingIndicator: () => { },
+    setHiddenThinkingLabel: () => { },
     setWidget: () => { },
     setFooter: () => { },
     setHeader: () => { },
@@ -68,7 +76,9 @@ const noOpUIContext = {
     setEditorText: () => { },
     getEditorText: () => "",
     editor: async () => undefined,
+    addAutocompleteProvider: () => { },
     setEditorComponent: () => { },
+    getEditorComponent: () => undefined,
     get theme() {
         return theme;
     },
@@ -79,24 +89,32 @@ const noOpUIContext = {
     setToolsExpanded: () => { },
 };
 export class ExtensionRunner {
+    extensions;
+    runtime;
+    uiContext;
+    cwd;
+    sessionManager;
+    modelRegistry;
+    errorListeners = new Set();
+    getModel = () => undefined;
+    isIdleFn = () => true;
+    getSignalFn = () => undefined;
+    waitForIdleFn = async () => { };
+    abortFn = () => { };
+    hasPendingMessagesFn = () => false;
+    getContextUsageFn = () => undefined;
+    compactFn = () => { };
+    getSystemPromptFn = () => "";
+    newSessionHandler = async () => ({ cancelled: false });
+    forkHandler = async () => ({ cancelled: false });
+    navigateTreeHandler = async () => ({ cancelled: false });
+    switchSessionHandler = async () => ({ cancelled: false });
+    reloadHandler = async () => { };
+    shutdownHandler = () => { };
+    shortcutDiagnostics = [];
+    commandDiagnostics = [];
+    staleMessage;
     constructor(extensions, runtime, cwd, sessionManager, modelRegistry) {
-        this.errorListeners = new Set();
-        this.getModel = () => undefined;
-        this.isIdleFn = () => true;
-        this.waitForIdleFn = async () => { };
-        this.abortFn = () => { };
-        this.hasPendingMessagesFn = () => false;
-        this.getContextUsageFn = () => undefined;
-        this.compactFn = () => { };
-        this.getSystemPromptFn = () => "";
-        this.newSessionHandler = async () => ({ cancelled: false });
-        this.forkHandler = async () => ({ cancelled: false });
-        this.navigateTreeHandler = async () => ({ cancelled: false });
-        this.switchSessionHandler = async () => ({ cancelled: false });
-        this.reloadHandler = async () => { };
-        this.shutdownHandler = () => { };
-        this.shortcutDiagnostics = [];
-        this.commandDiagnostics = [];
         this.extensions = extensions;
         this.runtime = runtime;
         this.uiContext = noOpUIContext;
@@ -104,7 +122,7 @@ export class ExtensionRunner {
         this.sessionManager = sessionManager;
         this.modelRegistry = modelRegistry;
     }
-    bindCore(actions, contextActions) {
+    bindCore(actions, contextActions, providerActions) {
         // Copy actions into the shared runtime (all extension APIs reference this)
         this.runtime.sendMessage = actions.sendMessage;
         this.runtime.sendUserMessage = actions.sendUserMessage;
@@ -123,6 +141,7 @@ export class ExtensionRunner {
         // Context actions (required)
         this.getModel = contextActions.getModel;
         this.isIdleFn = contextActions.isIdle;
+        this.getSignalFn = contextActions.getSignal;
         this.abortFn = contextActions.abort;
         this.hasPendingMessagesFn = contextActions.hasPendingMessages;
         this.shutdownHandler = contextActions.shutdown;
@@ -130,14 +149,41 @@ export class ExtensionRunner {
         this.compactFn = contextActions.compact;
         this.getSystemPromptFn = contextActions.getSystemPrompt;
         // Flush provider registrations queued during extension loading
-        for (const { name, config } of this.runtime.pendingProviderRegistrations) {
-            this.modelRegistry.registerProvider(name, config);
+        for (const { name, config, extensionPath } of this.runtime.pendingProviderRegistrations) {
+            try {
+                if (providerActions?.registerProvider) {
+                    providerActions.registerProvider(name, config);
+                }
+                else {
+                    this.modelRegistry.registerProvider(name, config);
+                }
+            }
+            catch (err) {
+                this.emitError({
+                    extensionPath,
+                    event: "register_provider",
+                    error: err instanceof Error ? err.message : String(err),
+                    stack: err instanceof Error ? err.stack : undefined,
+                });
+            }
         }
         this.runtime.pendingProviderRegistrations = [];
         // From this point on, provider registration/unregistration takes effect immediately
         // without requiring a /reload.
-        this.runtime.registerProvider = (name, config) => this.modelRegistry.registerProvider(name, config);
-        this.runtime.unregisterProvider = (name) => this.modelRegistry.unregisterProvider(name);
+        this.runtime.registerProvider = (name, config) => {
+            if (providerActions?.registerProvider) {
+                providerActions.registerProvider(name, config);
+                return;
+            }
+            this.modelRegistry.registerProvider(name, config);
+        };
+        this.runtime.unregisterProvider = (name) => {
+            if (providerActions?.unregisterProvider) {
+                providerActions.unregisterProvider(name);
+                return;
+            }
+            this.modelRegistry.unregisterProvider(name);
+        };
     }
     bindCommandContext(actions) {
         if (actions) {
@@ -207,9 +253,9 @@ export class ExtensionRunner {
     getFlagValues() {
         return new Map(this.runtime.flagValues);
     }
-    getShortcuts(effectiveKeybindings) {
+    getShortcuts(resolvedKeybindings) {
         this.shortcutDiagnostics = [];
-        const builtinKeybindings = buildBuiltinKeybindings(effectiveKeybindings);
+        const builtinKeybindings = buildBuiltinKeybindings(resolvedKeybindings);
         const extensionShortcuts = new Map();
         const addDiagnostic = (message, extensionPath) => {
             this.shortcutDiagnostics.push({ type: "warning", message, path: extensionPath });
@@ -226,7 +272,7 @@ export class ExtensionRunner {
                     continue;
                 }
                 if (builtInKeybinding?.restrictOverride === false) {
-                    addDiagnostic(`Extension shortcut conflict: '${key}' is built-in shortcut for ${builtInKeybinding.action} and ${shortcut.extensionPath}. Using ${shortcut.extensionPath}.`, shortcut.extensionPath);
+                    addDiagnostic(`Extension shortcut conflict: '${key}' is built-in shortcut for ${builtInKeybinding.keybinding} and ${shortcut.extensionPath}. Using ${shortcut.extensionPath}.`, shortcut.extensionPath);
                 }
                 const existingExtensionShortcut = extensionShortcuts.get(normalizedKey);
                 if (existingExtensionShortcut) {
@@ -240,6 +286,17 @@ export class ExtensionRunner {
     getShortcutDiagnostics() {
         return this.shortcutDiagnostics;
     }
+    invalidate(message = "This extension ctx is stale after session replacement or reload. Do not use a captured pi or command ctx after ctx.newSession(), ctx.fork(), ctx.switchSession(), or ctx.reload(). For newSession, fork, and switchSession, move post-replacement work into withSession and use the ctx passed to withSession. For reload, do not use the old ctx after await ctx.reload().") {
+        if (!this.staleMessage) {
+            this.staleMessage = message;
+            this.runtime.invalidate(message);
+        }
+    }
+    assertActive() {
+        if (this.staleMessage) {
+            throw new Error(this.staleMessage);
+        }
+    }
     onError(listener) {
         this.errorListeners.add(listener);
         return () => this.errorListeners.delete(listener);
@@ -267,55 +324,44 @@ export class ExtensionRunner {
         }
         return undefined;
     }
-    getRegisteredCommands(reserved) {
-        this.commandDiagnostics = [];
+    resolveRegisteredCommands() {
         const commands = [];
-        const commandOwners = new Map();
+        const counts = new Map();
         for (const ext of this.extensions) {
             for (const command of ext.commands.values()) {
-                if (reserved?.has(command.name)) {
-                    const message = `Extension command '${command.name}' from ${ext.path} conflicts with built-in commands. Skipping.`;
-                    this.commandDiagnostics.push({ type: "warning", message, path: ext.path });
-                    if (!this.hasUI()) {
-                        console.warn(message);
-                    }
-                    continue;
-                }
-                const existingOwner = commandOwners.get(command.name);
-                if (existingOwner) {
-                    const message = `Extension command '${command.name}' from ${ext.path} conflicts with ${existingOwner}. Skipping.`;
-                    this.commandDiagnostics.push({ type: "warning", message, path: ext.path });
-                    if (!this.hasUI()) {
-                        console.warn(message);
-                    }
-                    continue;
-                }
-                commandOwners.set(command.name, ext.path);
                 commands.push(command);
+                counts.set(command.name, (counts.get(command.name) ?? 0) + 1);
             }
         }
-        return commands;
+        const seen = new Map();
+        const takenInvocationNames = new Set();
+        return commands.map((command) => {
+            const occurrence = (seen.get(command.name) ?? 0) + 1;
+            seen.set(command.name, occurrence);
+            let invocationName = (counts.get(command.name) ?? 0) > 1 ? `${command.name}:${occurrence}` : command.name;
+            if (takenInvocationNames.has(invocationName)) {
+                let suffix = occurrence;
+                do {
+                    suffix++;
+                    invocationName = `${command.name}:${suffix}`;
+                } while (takenInvocationNames.has(invocationName));
+            }
+            takenInvocationNames.add(invocationName);
+            return {
+                ...command,
+                invocationName,
+            };
+        });
+    }
+    getRegisteredCommands() {
+        this.commandDiagnostics = [];
+        return this.resolveRegisteredCommands();
     }
     getCommandDiagnostics() {
         return this.commandDiagnostics;
     }
-    getRegisteredCommandsWithPaths() {
-        const result = [];
-        for (const ext of this.extensions) {
-            for (const command of ext.commands.values()) {
-                result.push({ command, extensionPath: ext.path });
-            }
-        }
-        return result;
-    }
     getCommand(name) {
-        for (const ext of this.extensions) {
-            const command = ext.commands.get(name);
-            if (command) {
-                return command;
-            }
-        }
-        return undefined;
+        return this.resolveRegisteredCommands().find((command) => command.invocationName === name);
     }
     /**
      * Request a graceful shutdown. Called by extension tools and event handlers.
@@ -329,35 +375,97 @@ export class ExtensionRunner {
      * Context values are resolved at call time, so changes via bindCore/bindUI are reflected.
      */
     createContext() {
+        const runner = this;
         const getModel = this.getModel;
         return {
-            ui: this.uiContext,
-            hasUI: this.hasUI(),
-            cwd: this.cwd,
-            sessionManager: this.sessionManager,
-            modelRegistry: this.modelRegistry,
+            get ui() {
+                runner.assertActive();
+                return runner.uiContext;
+            },
+            get hasUI() {
+                runner.assertActive();
+                return runner.hasUI();
+            },
+            get cwd() {
+                runner.assertActive();
+                return runner.cwd;
+            },
+            get sessionManager() {
+                runner.assertActive();
+                return runner.sessionManager;
+            },
+            get modelRegistry() {
+                runner.assertActive();
+                return runner.modelRegistry;
+            },
             get model() {
+                runner.assertActive();
                 return getModel();
             },
-            isIdle: () => this.isIdleFn(),
-            abort: () => this.abortFn(),
-            hasPendingMessages: () => this.hasPendingMessagesFn(),
-            shutdown: () => this.shutdownHandler(),
-            getContextUsage: () => this.getContextUsageFn(),
-            compact: (options) => this.compactFn(options),
-            getSystemPrompt: () => this.getSystemPromptFn(),
+            isIdle: () => {
+                runner.assertActive();
+                return runner.isIdleFn();
+            },
+            get signal() {
+                runner.assertActive();
+                return runner.getSignalFn();
+            },
+            abort: () => {
+                runner.assertActive();
+                runner.abortFn();
+            },
+            hasPendingMessages: () => {
+                runner.assertActive();
+                return runner.hasPendingMessagesFn();
+            },
+            shutdown: () => {
+                runner.assertActive();
+                runner.shutdownHandler();
+            },
+            getContextUsage: () => {
+                runner.assertActive();
+                return runner.getContextUsageFn();
+            },
+            compact: (options) => {
+                runner.assertActive();
+                runner.compactFn(options);
+            },
+            getSystemPrompt: () => {
+                runner.assertActive();
+                return runner.getSystemPromptFn();
+            },
         };
     }
     createCommandContext() {
-        return {
-            ...this.createContext(),
-            waitForIdle: () => this.waitForIdleFn(),
-            newSession: (options) => this.newSessionHandler(options),
-            fork: (entryId) => this.forkHandler(entryId),
-            navigateTree: (targetId, options) => this.navigateTreeHandler(targetId, options),
-            switchSession: (sessionPath) => this.switchSessionHandler(sessionPath),
-            reload: () => this.reloadHandler(),
+        // Use property descriptors instead of object spread so the guarded getters from
+        // createContext() stay lazy. A spread would eagerly read them once and freeze the
+        // old values into the returned object, bypassing stale-instance checks.
+        const context = Object.defineProperties({}, Object.getOwnPropertyDescriptors(this.createContext()));
+        context.waitForIdle = () => {
+            this.assertActive();
+            return this.waitForIdleFn();
+        };
+        context.newSession = (options) => {
+            this.assertActive();
+            return this.newSessionHandler(options);
+        };
+        context.fork = (entryId, options) => {
+            this.assertActive();
+            return this.forkHandler(entryId, options);
+        };
+        context.navigateTree = (targetId, options) => {
+            this.assertActive();
+            return this.navigateTreeHandler(targetId, options);
+        };
+        context.switchSession = (sessionPath, options) => {
+            this.assertActive();
+            return this.switchSessionHandler(sessionPath, options);
+        };
+        context.reload = () => {
+            this.assertActive();
+            return this.reloadHandler();
         };
+        return context;
     }
     isSessionBeforeEvent(event) {
         return (event.type === "session_before_switch" ||
@@ -396,6 +504,45 @@ export class ExtensionRunner {
         }
         return result;
     }
+    async emitMessageEnd(event) {
+        const ctx = this.createContext();
+        let currentMessage = event.message;
+        let modified = false;
+        for (const ext of this.extensions) {
+            const handlers = ext.handlers.get("message_end");
+            if (!handlers || handlers.length === 0)
+                continue;
+            for (const handler of handlers) {
+                try {
+                    const currentEvent = { ...event, message: currentMessage };
+                    const handlerResult = (await handler(currentEvent, ctx));
+                    if (!handlerResult?.message)
+                        continue;
+                    if (handlerResult.message.role !== currentMessage.role) {
+                        this.emitError({
+                            extensionPath: ext.path,
+                            event: "message_end",
+                            error: "message_end handlers must return a message with the same role",
+                        });
+                        continue;
+                    }
+                    currentMessage = handlerResult.message;
+                    modified = true;
+                }
+                catch (err) {
+                    const message = err instanceof Error ? err.message : String(err);
+                    const stack = err instanceof Error ? err.stack : undefined;
+                    this.emitError({
+                        extensionPath: ext.path,
+                        event: "message_end",
+                        error: message,
+                        stack,
+                    });
+                }
+            }
+        }
+        return modified ? currentMessage : undefined;
+    }
     async emitToolResult(event) {
         const ctx = this.createContext();
         const currentEvent = { ...event };
@@ -518,10 +665,46 @@ export class ExtensionRunner {
         }
         return currentMessages;
     }
-    async emitBeforeAgentStart(prompt, images, systemPrompt) {
+    async emitBeforeProviderRequest(payload) {
         const ctx = this.createContext();
-        const messages = [];
+        let currentPayload = payload;
+        for (const ext of this.extensions) {
+            const handlers = ext.handlers.get("before_provider_request");
+            if (!handlers || handlers.length === 0)
+                continue;
+            for (const handler of handlers) {
+                try {
+                    const event = {
+                        type: "before_provider_request",
+                        payload: currentPayload,
+                    };
+                    const handlerResult = await handler(event, ctx);
+                    if (handlerResult !== undefined) {
+                        currentPayload = handlerResult;
+                    }
+                }
+                catch (err) {
+                    const message = err instanceof Error ? err.message : String(err);
+                    const stack = err instanceof Error ? err.stack : undefined;
+                    this.emitError({
+                        extensionPath: ext.path,
+                        event: "before_provider_request",
+                        error: message,
+                        stack,
+                    });
+                }
+            }
+        }
+        return currentPayload;
+    }
+    async emitBeforeAgentStart(prompt, images, systemPrompt, systemPromptOptions) {
         let currentSystemPrompt = systemPrompt;
+        const ctx = Object.defineProperties({}, Object.getOwnPropertyDescriptors(this.createContext()));
+        ctx.getSystemPrompt = () => {
+            this.assertActive();
+            return currentSystemPrompt;
+        };
+        const messages = [];
         let systemPromptModified = false;
         for (const ext of this.extensions) {
             const handlers = ext.handlers.get("before_agent_start");
@@ -534,6 +717,7 @@ export class ExtensionRunner {
                         prompt,
                         images,
                         systemPrompt: currentSystemPrompt,
+                        systemPromptOptions,
                     };
                     const handlerResult = await handler(event, ctx);
                     if (handlerResult) {