@agent-link/agent 0.1.326 → 0.1.328

package/dist/pi.js

@@ -14,6 +14,7 @@ import { piCapabilities, } from './backends/types.js';
 import { CONFIG_DIR } from './config.js';
 import { getCleanEnv, resetCachedExecutablePath, resolveWindowsNpmWrapper, } from './sdk.js';
 import { getProvider, resolveProviderCommand } from './providers.js';
+import { providerCommandsMessage, } from './provider-command-types.js';
 const conversations = new Map();
 const sendFns = new Set();
 const THINKING_LEVELS = new Set(['off', 'minimal', 'low', 'medium', 'high', 'xhigh', 'max']);
@@ -23,8 +24,15 @@ const MIME_PATTERN = /^[a-z0-9][a-z0-9!#$&^_.+-]*\/[a-z0-9][a-z0-9!#$&^_.+-]*$/i
 const IMAGE_MIME_PATTERN = /^image\/(?:png|jpeg|gif|webp)$/i;
 const TURN_HEARTBEAT_INTERVAL_MS = 15_000;
 const RPC_TIMEOUT_MS = 30_000;
+const DISCOVERY_TIMEOUT_MS = 15_000;
 const ABORT_TIMEOUT_MS = 5_000;
 const MAX_STDERR_CHARS = 64 * 1024;
+const MAX_DISCOVERY_STDOUT_CHARS = 1024 * 1024;
+const MAX_COMMAND_NAME_CHARS = 128;
+const MAX_COMMAND_DESCRIPTION_CHARS = 4096;
+const MAX_COMMAND_METADATA_CHARS = 4096;
+const PI_COMMAND_SOURCES = new Set(['skill', 'prompt', 'extension']);
+const PI_COMMAND_NAME_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._:-]*$/;
 const MAX_ATTACHMENTS = 5;
 const MAX_ATTACHMENT_BYTES = 10 * 1024 * 1024;
 const PI_SESSION_LIST_LIMIT = 150;
@@ -69,6 +77,8 @@ function createState(conversationId, workDir, providerId = 'pi') {
         model: null,
         thinking: null,
         availableModels: [],
+        commands: [],
+        commandCatalogGeneration: 0,
         sessionNotified: false,
         cancelRequested: false,
         protocolFailed: false,
@@ -103,6 +113,11 @@ export function rebindPiConversation(piSessionId, newConversationId, providerId
             conversations.delete(oldConversationId);
             state.conversationId = newConversationId;
             conversations.set(newConversationId, state);
+            if (state.child) {
+                const child = state.child;
+                invalidatePiCommands(state);
+                void refreshPiCommands(state, child, state.commandCatalogGeneration);
+            }
             return true;
         }
     }
@@ -244,10 +259,20 @@ function rejectPendingRpc(state, error) {
     }
     state.pendingRpc.clear();
 }
+function invalidatePiCommands(state) {
+    state.commandCatalogGeneration++;
+    state.commands = [];
+    sendFn(providerCommandsMessage({
+        providerId: state.providerId,
+        conversationId: state.conversationId,
+        workDir: state.workDir,
+    }, { commands: [] }));
+}
 function terminatePiChild(state) {
     const child = state.child;
     state.child = null;
     state.childProviderId = null;
+    invalidatePiCommands(state);
     rejectPendingRpc(state, new Error('PI RPC process was terminated'));
     if (!child)
         return;
@@ -324,16 +349,29 @@ function writeRpcRecord(state, record) {
 function handleRpcResponse(state, record) {
     const id = record.id;
     const command = record.command;
+    const pendingById = typeof id === 'string' ? state.pendingRpc.get(id) : undefined;
     if (typeof id !== 'string' || typeof command !== 'string' || typeof record.success !== 'boolean') {
+        if (pendingById?.command === 'get_commands') {
+            clearTimeout(pendingById.timer);
+            state.pendingRpc.delete(id);
+            pendingById.reject(new Error('PI RPC get_commands returned a malformed response'));
+            return;
+        }
         protocolFailure(state, 'malformed response record');
         return;
     }
-    const pending = state.pendingRpc.get(id);
+    const pending = pendingById;
     if (!pending) {
         protocolFailure(state, `unexpected response id ${id}`);
         return;
     }
     if (pending.command !== command) {
+        if (pending.command === 'get_commands') {
+            clearTimeout(pending.timer);
+            state.pendingRpc.delete(id);
+            pending.reject(new Error(`PI RPC get_commands response command mismatch for ${id}`));
+            return;
+        }
         protocolFailure(state, `response command mismatch for ${id}`);
         return;
     }
@@ -610,6 +648,84 @@ function attachStrictJsonlReader(state, child) {
             protocolFailure(state, 'stdout ended with an unterminated record');
     });
 }
+function normalizePiCommands(response) {
+    const data = asRecord(response.data);
+    if (!data || !Array.isArray(data.commands)) {
+        throw new Error('PI RPC get_commands returned malformed data');
+    }
+    const commands = [];
+    const seen = new Set();
+    for (const value of data.commands) {
+        const command = asRecord(value);
+        if (!command || !PI_COMMAND_SOURCES.has(command.source))
+            continue;
+        if (typeof command.name !== 'string'
+            || !command.name
+            || command.name.length > MAX_COMMAND_NAME_CHARS
+            || !PI_COMMAND_NAME_PATTERN.test(command.name)
+            || (command.source === 'skill' && !command.name.startsWith('skill:'))
+            || (command.source !== 'skill' && command.name.startsWith('skill:')))
+            continue;
+        if (command.description != null && typeof command.description !== 'string')
+            continue;
+        if (command.location != null && typeof command.location !== 'string')
+            continue;
+        if (command.path != null && typeof command.path !== 'string')
+            continue;
+        const description = typeof command.description === 'string'
+            ? command.description.trim().slice(0, MAX_COMMAND_DESCRIPTION_CHARS)
+            : '';
+        const location = typeof command.location === 'string'
+            ? command.location.trim().slice(0, MAX_COMMAND_METADATA_CHARS)
+            : '';
+        const sourcePath = typeof command.path === 'string'
+            ? command.path.slice(0, MAX_COMMAND_METADATA_CHARS)
+            : '';
+        const key = `${command.source}\u0000${command.name}`;
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        const source = command.source;
+        const name = source === 'skill' ? command.name.slice('skill:'.length) : command.name;
+        commands.push({
+            id: `${source}:${command.name}`,
+            name,
+            invocation: `/${command.name}`,
+            description,
+            kind: source,
+            ...(location ? { location } : {}),
+            ...(sourcePath ? { path: sourcePath } : {}),
+        });
+    }
+    return commands;
+}
+async function refreshPiCommands(state, child, generation) {
+    const scope = {
+        providerId: state.providerId,
+        conversationId: state.conversationId,
+        workDir: resolve(state.workDir),
+    };
+    try {
+        const response = await sendRpcCommand(state, { type: 'get_commands' });
+        const commands = normalizePiCommands(response);
+        if (state.child !== child
+            || state.commandCatalogGeneration !== generation
+            || state.providerId !== scope.providerId
+            || state.conversationId !== scope.conversationId
+            || normalizePathForCompare(state.workDir) !== normalizePathForCompare(scope.workDir))
+            return;
+        state.commands = commands;
+        sendFn(providerCommandsMessage(scope, { commands }));
+    }
+    catch (error) {
+        if (state.child !== child || state.commandCatalogGeneration !== generation)
+            return;
+        state.commands = [];
+        // Command discovery is optional. A valid RPC error or malformed command
+        // payload must not poison the persistent chat protocol.
+        sendFn(providerCommandsMessage(scope, { commands: [], error: error.message }));
+    }
+}
 function directSpawnCommand(command, prefixArgs) {
     const direct = resolveWindowsNpmWrapper(command);
     if (direct) {
@@ -655,6 +771,9 @@ async function launchPiProcess(state) {
         }
         state.child = child;
         state.childProviderId = state.providerId;
+        state.commandCatalogGeneration++;
+        const commandCatalogGeneration = state.commandCatalogGeneration;
+        state.commands = [];
         state.protocolFailed = false;
         state.stderrBuffer = '';
         attachStrictJsonlReader(state, child);
@@ -666,6 +785,7 @@ async function launchPiProcess(state) {
                 return;
             state.child = null;
             state.childProviderId = null;
+            invalidatePiCommands(state);
             const wrapped = new Error(`Failed to start PI: ${error.message}`);
             rejectPendingRpc(state, wrapped);
             if (state.turnActive)
@@ -677,6 +797,7 @@ async function launchPiProcess(state) {
                 return;
             state.child = null;
             state.childProviderId = null;
+            invalidatePiCommands(state);
             const diagnostic = state.stderrBuffer.trim();
             const error = new Error(diagnostic || `PI RPC process exited${code == null ? '' : ` with code ${code}`}`);
             rejectPendingRpc(state, error);
@@ -704,6 +825,7 @@ async function launchPiProcess(state) {
             });
         }
         void refreshAvailableModels(state);
+        void refreshPiCommands(state, child, commandCatalogGeneration);
     })();
     try {
         await state.launching;
@@ -739,6 +861,110 @@ async function refreshAvailableModels(state) {
         // Model discovery is optional and must not fail an otherwise healthy turn.
     }
 }
+export async function discoverPiCommands(conversationId, workDir, providerId = 'pi') {
+    const scope = { providerId, conversationId, workDir: resolve(workDir) };
+    let child = null;
+    try {
+        const provider = getProvider(providerId);
+        const resolvedCommand = resolveProviderCommand(provider);
+        // Pre-prompt discovery is deliberately ephemeral: it avoids allocating a
+        // persisted empty Pi session. Resources are loaded again by the eventual
+        // persistent conversation process, which publishes an authoritative refresh.
+        const direct = directSpawnCommand(resolvedCommand.command, [...resolvedCommand.prefixArgs, '--mode', 'rpc', '--no-session']);
+        child = spawn(direct.command, direct.args, {
+            cwd: scope.workDir,
+            stdio: ['pipe', 'pipe', 'pipe'],
+            env: { ...getCleanEnv(), ...(provider.env || {}) },
+            ...resolvedCommand.spawnOpts,
+            windowsHide: true,
+        });
+        child.stderr?.on('data', () => { });
+        const commandId = `agentlink-discovery-${randomUUID()}`;
+        const response = await new Promise((resolveResponse, rejectResponse) => {
+            const decoder = new StringDecoder('utf8');
+            let pending = '';
+            let totalChars = 0;
+            let settled = false;
+            const finish = (error, responseValue) => {
+                if (settled)
+                    return;
+                settled = true;
+                clearTimeout(timer);
+                if (error)
+                    rejectResponse(error);
+                else
+                    resolveResponse(responseValue);
+            };
+            const timer = setTimeout(() => finish(new Error(`PI RPC get_commands timed out after ${DISCOVERY_TIMEOUT_MS}ms`)), DISCOVERY_TIMEOUT_MS);
+            timer.unref?.();
+            child.on('error', error => finish(new Error(`Failed to start PI discovery: ${error.message}`)));
+            child.on('close', code => finish(new Error(`PI discovery process exited${code == null ? '' : ` with code ${code}`}`)));
+            child.stdout?.on('data', (chunk) => {
+                const text = typeof chunk === 'string' ? chunk : decoder.write(chunk);
+                totalChars += text.length;
+                if (totalChars > MAX_DISCOVERY_STDOUT_CHARS) {
+                    finish(new Error('PI discovery output exceeded the protocol limit'));
+                    return;
+                }
+                pending += text;
+                let newlineIndex = pending.indexOf('\n');
+                while (!settled && newlineIndex !== -1) {
+                    const line = pending.slice(0, newlineIndex);
+                    pending = pending.slice(newlineIndex + 1);
+                    if (line.trim()) {
+                        let record;
+                        try {
+                            const value = JSON.parse(line);
+                            const parsed = asRecord(value);
+                            if (!parsed)
+                                throw new Error('record is not an object');
+                            record = parsed;
+                        }
+                        catch (error) {
+                            finish(new Error(`PI discovery returned malformed JSONL: ${error.message}`));
+                            return;
+                        }
+                        if (record.type === 'response') {
+                            if (record.id !== commandId
+                                || record.command !== 'get_commands'
+                                || typeof record.success !== 'boolean') {
+                                finish(new Error('PI discovery returned a mismatched response'));
+                                return;
+                            }
+                            if (!record.success) {
+                                finish(new Error(typeof record.error === 'string' ? record.error : 'PI RPC get_commands failed'));
+                                return;
+                            }
+                            finish(undefined, record);
+                            return;
+                        }
+                    }
+                    newlineIndex = pending.indexOf('\n');
+                }
+            });
+            child.stdin?.write(`${JSON.stringify({ type: 'get_commands', id: commandId })}\n`, 'utf8', (error) => {
+                if (error)
+                    finish(error);
+            });
+        });
+        return { commands: normalizePiCommands(response) };
+    }
+    catch (error) {
+        return { commands: [], error: error.message };
+    }
+    finally {
+        if (child) {
+            try {
+                child.stdin?.end();
+            }
+            catch { /* already closed */ }
+            try {
+                child.kill('SIGTERM');
+            }
+            catch { /* already exited */ }
+        }
+    }
+}
 export function getPiAvailableModels(providerId = 'pi') {
     return [...new Set([...conversations.values()]
             .filter(state => state.providerId === providerId)
@@ -871,19 +1097,23 @@ export function handlePiChat(conversationId, text, workDir, options, files) {
         emitPiError(state, 'PI is already processing this conversation.');
         return;
     }
-    state.workDir = resolve(workDir);
+    const resolvedWorkDir = resolve(workDir);
+    const workDirChanged = normalizePathForCompare(state.workDir) !== normalizePathForCompare(resolvedWorkDir);
     const requestedProviderId = options?.providerId || state.providerId;
     const providerChanged = state.providerId !== requestedProviderId;
-    if (providerChanged) {
+    if (providerChanged || workDirChanged) {
         if (state.child)
             terminatePiChild(state);
+        state.workDir = resolvedWorkDir;
+        state.commands = [];
         state.piSessionId = null;
         state.lastPiSessionId = null;
         state.sessionFile = null;
         state.sessionNotified = false;
         state.model = null;
         state.thinking = null;
-        state.availableModels = [];
+        if (providerChanged)
+            state.availableModels = [];
     }
     else if (state.child && state.childProviderId !== requestedProviderId) {
         terminatePiChild(state);