@link-assistant/agent 0.6.3 → 0.8.1

package/src/index.js

@@ -3,7 +3,7 @@
 import { Server } from './server/server.ts';
 import { Instance } from './project/instance.ts';
 import { Log } from './util/log.ts';
-import { Bus } from './bus/index.ts';
+// Bus is used via createBusEventSubscription in event-handler.js
 import { Session } from './session/index.ts';
 import { SessionPrompt } from './session/prompt.ts';
 // EOL is reserved for future use
@@ -21,7 +21,9 @@ import { UI } from './cli/ui.ts';
 import {
   runContinuousServerMode,
   runContinuousDirectMode,
+  resolveResumeSession,
 } from './cli/continuous-mode.js';
+import { createBusEventSubscription } from './cli/event-handler.js';
 import { createRequire } from 'module';
 import { readFileSync } from 'fs';
 import { dirname, join } from 'path';
@@ -285,6 +287,7 @@ async function runAgentMode(argv, request) {
       if (argv.server) {
         // SERVER MODE: Start server and communicate via HTTP
         await runServerMode(
+          argv,
           request,
           providerID,
           modelID,
@@ -295,6 +298,7 @@ async function runAgentMode(argv, request) {
       } else {
         // DIRECT MODE: Run everything in single process
         await runDirectMode(
+          argv,
           request,
           providerID,
           modelID,
@@ -382,6 +386,7 @@ async function runContinuousAgentMode(argv) {
 }
 
 async function runServerMode(
+  argv,
   request,
   providerID,
   modelID,
@@ -389,102 +394,52 @@ async function runServerMode(
   appendSystemMessage,
   jsonStandard
 ) {
+  const compactJson = argv['compact-json'] === true;
+
   // Start server like OpenCode does
   const server = Server.listen({ port: 0, hostname: '127.0.0.1' });
   let unsub = null;
 
   try {
-    // Create a session
-    const createRes = await fetch(
-      `http://${server.hostname}:${server.port}/session`,
-      {
-        method: 'POST',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({}),
-      }
-    );
-    const session = await createRes.json();
-    const sessionID = session.id;
+    // Check if we should resume an existing session
+    const resumeInfo = await resolveResumeSession(argv, compactJson);
+
+    let sessionID;
+
+    if (resumeInfo) {
+      // Use the resumed/forked session
+      sessionID = resumeInfo.sessionID;
+    } else {
+      // Create a new session
+      const createRes = await fetch(
+        `http://${server.hostname}:${server.port}/session`,
+        {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify({}),
+        }
+      );
+      const session = await createRes.json();
+      sessionID = session.id;
 
-    if (!sessionID) {
-      throw new Error('Failed to create session');
+      if (!sessionID) {
+        throw new Error('Failed to create session');
+      }
     }
 
     // Create event handler for the selected JSON standard
     const eventHandler = createEventHandler(jsonStandard, sessionID);
 
     // Subscribe to all bus events and output in selected format
-    const eventPromise = new Promise((resolve) => {
-      unsub = Bus.subscribeAll((event) => {
-        // Output events in selected JSON format
-        if (event.type === 'message.part.updated') {
-          const part = event.properties.part;
-          if (part.sessionID !== sessionID) {
-            return;
-          }
-
-          // Output different event types
-          if (part.type === 'step-start') {
-            eventHandler.output({
-              type: 'step_start',
-              timestamp: Date.now(),
-              sessionID,
-              part,
-            });
-          }
-
-          if (part.type === 'step-finish') {
-            eventHandler.output({
-              type: 'step_finish',
-              timestamp: Date.now(),
-              sessionID,
-              part,
-            });
-          }
-
-          if (part.type === 'text' && part.time?.end) {
-            eventHandler.output({
-              type: 'text',
-              timestamp: Date.now(),
-              sessionID,
-              part,
-            });
-          }
-
-          if (part.type === 'tool' && part.state.status === 'completed') {
-            eventHandler.output({
-              type: 'tool_use',
-              timestamp: Date.now(),
-              sessionID,
-              part,
-            });
-          }
-        }
-
-        // Handle session idle to know when to stop
-        if (
-          event.type === 'session.idle' &&
-          event.properties.sessionID === sessionID
-        ) {
-          resolve();
-        }
-
-        // Handle errors
-        if (event.type === 'session.error') {
-          const props = event.properties;
-          if (props.sessionID !== sessionID || !props.error) {
-            return;
-          }
+    const { unsub: eventUnsub, idlePromise: eventPromise } =
+      createBusEventSubscription({
+        sessionID,
+        eventHandler,
+        onError: () => {
           hasError = true;
-          eventHandler.output({
-            type: 'error',
-            timestamp: Date.now(),
-            sessionID,
-            error: props.error,
-          });
-        }
+        },
       });
-    });
+    unsub = eventUnsub;
 
     // Send message to session with specified model (default: opencode/grok-code)
     const message = request.message || 'hi';
@@ -529,6 +484,7 @@ async function runServerMode(
 }
 
 async function runDirectMode(
+  argv,
   request,
   providerID,
   modelID,
@@ -536,91 +492,41 @@ async function runDirectMode(
   appendSystemMessage,
   jsonStandard
 ) {
+  const compactJson = argv['compact-json'] === true;
+
   // DIRECT MODE: Run in single process without server
   let unsub = null;
 
   try {
-    // Create a session directly
-    const session = await Session.createNext({
-      directory: process.cwd(),
-    });
-    const sessionID = session.id;
+    // Check if we should resume an existing session
+    const resumeInfo = await resolveResumeSession(argv, compactJson);
+
+    let sessionID;
+
+    if (resumeInfo) {
+      // Use the resumed/forked session
+      sessionID = resumeInfo.sessionID;
+    } else {
+      // Create a new session directly
+      const session = await Session.createNext({
+        directory: process.cwd(),
+      });
+      sessionID = session.id;
+    }
 
     // Create event handler for the selected JSON standard
     const eventHandler = createEventHandler(jsonStandard, sessionID);
 
     // Subscribe to all bus events and output in selected format
-    const eventPromise = new Promise((resolve) => {
-      unsub = Bus.subscribeAll((event) => {
-        // Output events in selected JSON format
-        if (event.type === 'message.part.updated') {
-          const part = event.properties.part;
-          if (part.sessionID !== sessionID) {
-            return;
-          }
-
-          // Output different event types
-          if (part.type === 'step-start') {
-            eventHandler.output({
-              type: 'step_start',
-              timestamp: Date.now(),
-              sessionID,
-              part,
-            });
-          }
-
-          if (part.type === 'step-finish') {
-            eventHandler.output({
-              type: 'step_finish',
-              timestamp: Date.now(),
-              sessionID,
-              part,
-            });
-          }
-
-          if (part.type === 'text' && part.time?.end) {
-            eventHandler.output({
-              type: 'text',
-              timestamp: Date.now(),
-              sessionID,
-              part,
-            });
-          }
-
-          if (part.type === 'tool' && part.state.status === 'completed') {
-            eventHandler.output({
-              type: 'tool_use',
-              timestamp: Date.now(),
-              sessionID,
-              part,
-            });
-          }
-        }
-
-        // Handle session idle to know when to stop
-        if (
-          event.type === 'session.idle' &&
-          event.properties.sessionID === sessionID
-        ) {
-          resolve();
-        }
-
-        // Handle errors
-        if (event.type === 'session.error') {
-          const props = event.properties;
-          if (props.sessionID !== sessionID || !props.error) {
-            return;
-          }
+    const { unsub: eventUnsub, idlePromise: eventPromise } =
+      createBusEventSubscription({
+        sessionID,
+        eventHandler,
+        onError: () => {
           hasError = true;
-          eventHandler.output({
-            type: 'error',
-            timestamp: Date.now(),
-            sessionID,
-            error: props.error,
-          });
-        }
+        },
       });
-    });
+    unsub = eventUnsub;
 
     // Send message to session directly
     const message = request.message || 'hi';
@@ -765,6 +671,25 @@ async function main() {
               description:
                 'Output compact JSON (single line) instead of pretty-printed JSON (default: false). Useful for program-to-program communication.',
               default: false,
+            })
+            .option('resume', {
+              alias: 'r',
+              type: 'string',
+              description:
+                'Resume a specific session by ID. By default, forks the session with a new UUID. Use --no-fork to continue in the same session.',
+            })
+            .option('continue', {
+              alias: 'c',
+              type: 'boolean',
+              description:
+                'Continue the most recent session. By default, forks the session with a new UUID. Use --no-fork to continue in the same session.',
+              default: false,
+            })
+            .option('no-fork', {
+              type: 'boolean',
+              description:
+                'When used with --resume or --continue, continue in the same session without forking to a new UUID.',
+              default: false,
             }),
         handler: async (argv) => {
           const compactJson = argv['compact-json'] === true;

package/src/mcp/index.ts

@@ -13,6 +13,18 @@ import { withTimeout } from '../util/timeout';
 export namespace MCP {
   const log = Log.create({ service: 'mcp' });
 
+  /** Built-in default timeout for MCP tool execution (2 minutes) */
+  export const BUILTIN_DEFAULT_TOOL_CALL_TIMEOUT = 120000;
+
+  /** Built-in maximum timeout for MCP tool execution (10 minutes) */
+  export const BUILTIN_MAX_TOOL_CALL_TIMEOUT = 600000;
+
+  /** @deprecated Use BUILTIN_DEFAULT_TOOL_CALL_TIMEOUT instead */
+  export const DEFAULT_TOOL_CALL_TIMEOUT = BUILTIN_DEFAULT_TOOL_CALL_TIMEOUT;
+
+  /** @deprecated Use BUILTIN_MAX_TOOL_CALL_TIMEOUT instead */
+  export const MAX_TOOL_CALL_TIMEOUT = BUILTIN_MAX_TOOL_CALL_TIMEOUT;
+
   export const Failed = NamedError.create(
     'MCPFailed',
     z.object({
@@ -22,6 +34,22 @@ export namespace MCP {
 
   type Client = Awaited<ReturnType<typeof experimental_createMCPClient>>;
 
+  /** Global timeout defaults from configuration */
+  export interface GlobalTimeoutDefaults {
+    /** Global default timeout for MCP tool calls */
+    defaultTimeout: number;
+    /** Global maximum timeout for MCP tool calls */
+    maxTimeout: number;
+  }
+
+  /** Timeout configuration for an MCP server */
+  export interface TimeoutConfig {
+    /** Default timeout for all tool calls from this server */
+    defaultTimeout: number;
+    /** Per-tool timeout overrides */
+    toolTimeouts: Record<string, number>;
+  }
+
   export const Status = z
     .discriminatedUnion('status', [
       z
@@ -59,6 +87,26 @@ export namespace MCP {
       const config = cfg.mcp ?? {};
       const clients: Record<string, Client> = {};
       const status: Record<string, Status> = {};
+      const timeoutConfigs: Record<string, TimeoutConfig> = {};
+
+      // Determine global timeout defaults from config and environment variables
+      const envDefaultTimeout = process.env.MCP_DEFAULT_TOOL_CALL_TIMEOUT
+        ? parseInt(process.env.MCP_DEFAULT_TOOL_CALL_TIMEOUT, 10)
+        : undefined;
+      const envMaxTimeout = process.env.MCP_MAX_TOOL_CALL_TIMEOUT
+        ? parseInt(process.env.MCP_MAX_TOOL_CALL_TIMEOUT, 10)
+        : undefined;
+
+      const globalDefaults: GlobalTimeoutDefaults = {
+        defaultTimeout:
+          cfg.mcp_defaults?.tool_call_timeout ??
+          envDefaultTimeout ??
+          BUILTIN_DEFAULT_TOOL_CALL_TIMEOUT,
+        maxTimeout:
+          cfg.mcp_defaults?.max_tool_call_timeout ??
+          envMaxTimeout ??
+          BUILTIN_MAX_TOOL_CALL_TIMEOUT,
+      };
 
       await Promise.all(
         Object.entries(config).map(async ([key, mcp]) => {
@@ -67,6 +115,17 @@ export namespace MCP {
 
           status[key] = result.status;
 
+          // Store timeout configuration for this MCP server
+          // Per-server timeout overrides global default, but is capped at global max
+          const defaultTimeout = Math.min(
+            mcp.tool_call_timeout ?? globalDefaults.defaultTimeout,
+            globalDefaults.maxTimeout
+          );
+          timeoutConfigs[key] = {
+            defaultTimeout,
+            toolTimeouts: mcp.tool_timeouts ?? {},
+          };
+
           if (result.mcpClient) {
             clients[key] = result.mcpClient;
           }
@@ -75,6 +134,8 @@ export namespace MCP {
       return {
         status,
         clients,
+        timeoutConfigs,
+        globalDefaults,
       };
     },
     async (state) => {
@@ -310,4 +371,68 @@ export namespace MCP {
     }
     return result;
   }
+
+  /**
+   * Get the timeout configuration for all MCP servers
+   */
+  export async function getTimeoutConfigs(): Promise<
+    Record<string, TimeoutConfig>
+  > {
+    const s = await state();
+    return s.timeoutConfigs;
+  }
+
+  /**
+   * Get the global timeout defaults from configuration
+   */
+  export async function getGlobalDefaults(): Promise<GlobalTimeoutDefaults> {
+    const s = await state();
+    return s.globalDefaults;
+  }
+
+  /**
+   * Get the timeout for a specific MCP tool
+   * @param fullToolName The full tool name in format "serverName_toolName"
+   * @returns Timeout in milliseconds
+   */
+  export async function getToolTimeout(fullToolName: string): Promise<number> {
+    const s = await state();
+    const maxTimeout = s.globalDefaults.maxTimeout;
+
+    // Parse the full tool name to extract server name and tool name
+    // Format: serverName_toolName (where both are sanitized)
+    const underscoreIndex = fullToolName.indexOf('_');
+    if (underscoreIndex === -1) {
+      return s.globalDefaults.defaultTimeout;
+    }
+
+    const serverName = fullToolName.substring(0, underscoreIndex);
+    const toolName = fullToolName.substring(underscoreIndex + 1);
+
+    // Find the server config (need to handle sanitization)
+    const config = s.timeoutConfigs[serverName];
+    if (!config) {
+      // Try to find by iterating (in case of sanitization differences)
+      for (const [key, cfg] of Object.entries(s.timeoutConfigs)) {
+        const sanitizedKey = key.replace(/[^a-zA-Z0-9_-]/g, '_');
+        if (sanitizedKey === serverName) {
+          // Check for per-tool timeout override
+          const perToolTimeout = cfg.toolTimeouts[toolName];
+          if (perToolTimeout !== undefined) {
+            return Math.min(perToolTimeout, maxTimeout);
+          }
+          return cfg.defaultTimeout;
+        }
+      }
+      return s.globalDefaults.defaultTimeout;
+    }
+
+    // Check for per-tool timeout override
+    const perToolTimeout = config.toolTimeouts[toolName];
+    if (perToolTimeout !== undefined) {
+      return Math.min(perToolTimeout, maxTimeout);
+    }
+
+    return config.defaultTimeout;
+  }
 }