@link-assistant/agent 0.6.3 → 0.8.1

package/src/cli/continuous-mode.js

@@ -10,6 +10,7 @@ import { Session } from '../session/index.ts';
 import { SessionPrompt } from '../session/prompt.ts';
 import { createEventHandler } from '../json-standard/index.ts';
 import { createContinuousStdinReader } from './input-queue.js';
+import { Log } from '../util/log.ts';
 
 // Shared error tracking
 let hasError = false;
@@ -42,6 +43,155 @@ function outputStatus(status, compact = false) {
   console.error(json);
 }
 
+// Logger for resume operations
+const log = Log.create({ service: 'resume' });
+
+/**
+ * Resolve the session to use based on --resume, --continue, and --no-fork options.
+ * Returns the session ID to use, handling forking as needed.
+ * @param {object} argv - Command line arguments
+ * @param {boolean} compactJson - Whether to use compact JSON output
+ * @returns {Promise<{sessionID: string, wasResumed: boolean, wasForked: boolean} | null>} - Session info or null if new session should be created
+ * @export
+ */
+export async function resolveResumeSession(argv, compactJson) {
+  const resumeSessionID = argv.resume;
+  const shouldContinue = argv.continue === true;
+  const noFork = argv['no-fork'] === true;
+
+  // If neither --resume nor --continue is specified, return null to create new session
+  if (!resumeSessionID && !shouldContinue) {
+    return null;
+  }
+
+  let targetSessionID = resumeSessionID;
+
+  // If --continue is specified, find the most recent session
+  if (shouldContinue && !targetSessionID) {
+    let mostRecentSession = null;
+    let mostRecentTime = 0;
+
+    for await (const session of Session.list()) {
+      // Skip child sessions (those with parentID) - find top-level sessions only
+      if (session.parentID) {
+        continue;
+      }
+
+      if (session.time.updated > mostRecentTime) {
+        mostRecentTime = session.time.updated;
+        mostRecentSession = session;
+      }
+    }
+
+    if (!mostRecentSession) {
+      outputStatus(
+        {
+          type: 'error',
+          errorType: 'SessionNotFound',
+          message:
+            'No existing sessions found to continue. Start a new session first.',
+        },
+        compactJson
+      );
+      process.exit(1);
+    }
+
+    targetSessionID = mostRecentSession.id;
+    log.info(() => ({
+      message: 'Found most recent session to continue',
+      sessionID: targetSessionID,
+      title: mostRecentSession.title,
+    }));
+  }
+
+  // Verify the session exists
+  let existingSession;
+  try {
+    existingSession = await Session.get(targetSessionID);
+  } catch (_error) {
+    // Session.get throws an error when the session doesn't exist
+    outputStatus(
+      {
+        type: 'error',
+        errorType: 'SessionNotFound',
+        message: `Session not found: ${targetSessionID}`,
+      },
+      compactJson
+    );
+    process.exit(1);
+  }
+
+  if (!existingSession) {
+    outputStatus(
+      {
+        type: 'error',
+        errorType: 'SessionNotFound',
+        message: `Session not found: ${targetSessionID}`,
+      },
+      compactJson
+    );
+    process.exit(1);
+  }
+
+  log.info(() => ({
+    message: 'Resuming session',
+    sessionID: targetSessionID,
+    title: existingSession.title,
+    noFork,
+  }));
+
+  // If --no-fork is specified, continue in the same session
+  if (noFork) {
+    outputStatus(
+      {
+        type: 'status',
+        mode: 'resume',
+        message: `Continuing session without forking: ${targetSessionID}`,
+        sessionID: targetSessionID,
+        title: existingSession.title,
+        forked: false,
+      },
+      compactJson
+    );
+
+    return {
+      sessionID: targetSessionID,
+      wasResumed: true,
+      wasForked: false,
+    };
+  }
+
+  // Fork the session to a new UUID (default behavior)
+  const forkedSession = await Session.fork({
+    sessionID: targetSessionID,
+  });
+
+  outputStatus(
+    {
+      type: 'status',
+      mode: 'resume',
+      message: `Forked session ${targetSessionID} to new session: ${forkedSession.id}`,
+      originalSessionID: targetSessionID,
+      sessionID: forkedSession.id,
+      title: forkedSession.title,
+      forked: true,
+    },
+    compactJson
+  );
+
+  log.info(() => ({
+    message: 'Forked session',
+    originalSessionID: targetSessionID,
+    newSessionID: forkedSession.id,
+  }));
+
+  return {
+    sessionID: forkedSession.id,
+    wasResumed: true,
+    wasForked: true,
+  };
+}
+
 /**
  * Run server mode with continuous stdin input
  * Keeps the session alive and processes messages as they arrive
@@ -64,20 +214,30 @@ export async function runContinuousServerMode(
   let stdinReader = 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
@@ -275,11 +435,21 @@ export async function runContinuousDirectMode(
   let stdinReader = 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);

package/src/cli/event-handler.js

@@ -0,0 +1,99 @@
+/**
+ * Shared event handler logic for bus events.
+ * Used by both single-message mode (index.js) and continuous mode (continuous-mode.js).
+ */
+
+import { Bus } from '../bus/index.ts';
+
+/**
+ * Create a subscription for session bus events that outputs events in the selected JSON format.
+ * Returns an object with the unsubscribe function and a promise that resolves when session becomes idle.
+ *
+ * @param {object} options - Configuration options
+ * @param {string} options.sessionID - The session ID to filter events
+ * @param {object} options.eventHandler - The event handler (from createEventHandler)
+ * @param {function} options.onError - Callback when error occurs (sets hasError flag)
+ * @returns {{ unsub: function, idlePromise: Promise<void> }}
+ */
+export function createBusEventSubscription({
+  sessionID,
+  eventHandler,
+  onError,
+}) {
+  let idleResolve;
+  const idlePromise = new Promise((resolve) => {
+    idleResolve = resolve;
+  });
+
+  const 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
+    ) {
+      idleResolve();
+    }
+
+    // Handle errors
+    if (event.type === 'session.error') {
+      const props = event.properties;
+      if (props.sessionID !== sessionID || !props.error) {
+        return;
+      }
+      onError();
+      eventHandler.output({
+        type: 'error',
+        timestamp: Date.now(),
+        sessionID,
+        error: props.error,
+      });
+    }
+  });
+
+  return { unsub, idlePromise };
+}

package/src/config/config.ts

@@ -432,6 +432,20 @@ export namespace Config {
         .describe(
           'Timeout in ms for fetching tools from the MCP server. Defaults to 5000 (5 seconds) if not specified.'
         ),
+      tool_call_timeout: z
+        .number()
+        .int()
+        .positive()
+        .optional()
+        .describe(
+          'Default timeout in ms for MCP tool execution. Defaults to 120000 (2 minutes) if not specified. Set per-tool overrides in tool_timeouts.'
+        ),
+      tool_timeouts: z
+        .record(z.string(), z.number().int().positive())
+        .optional()
+        .describe(
+          'Per-tool timeout overrides in ms. Keys are tool names (e.g., "browser_run_code": 300000 for 5 minutes).'
+        ),
     })
     .strict()
     .meta({
@@ -458,6 +472,20 @@ export namespace Config {
         .describe(
           'Timeout in ms for fetching tools from the MCP server. Defaults to 5000 (5 seconds) if not specified.'
         ),
+      tool_call_timeout: z
+        .number()
+        .int()
+        .positive()
+        .optional()
+        .describe(
+          'Default timeout in ms for MCP tool execution. Defaults to 120000 (2 minutes) if not specified. Set per-tool overrides in tool_timeouts.'
+        ),
+      tool_timeouts: z
+        .record(z.string(), z.number().int().positive())
+        .optional()
+        .describe(
+          'Per-tool timeout overrides in ms. Keys are tool names (e.g., "browser_run_code": 300000 for 5 minutes).'
+        ),
     })
     .strict()
     .meta({
@@ -846,6 +874,29 @@ export namespace Config {
         .record(z.string(), Mcp)
         .optional()
         .describe('MCP (Model Context Protocol) server configurations'),
+      mcp_defaults: z
+        .object({
+          tool_call_timeout: z
+            .number()
+            .int()
+            .positive()
+            .optional()
+            .describe(
+              'Global default timeout in ms for MCP tool execution. Defaults to 120000 (2 minutes). Can be overridden per-server or per-tool.'
+            ),
+          max_tool_call_timeout: z
+            .number()
+            .int()
+            .positive()
+            .optional()
+            .describe(
+              'Maximum allowed timeout in ms for MCP tool execution. Defaults to 600000 (10 minutes). Tool timeouts will be capped at this value.'
+            ),
+        })
+        .optional()
+        .describe(
+          'Global default settings for MCP tool call timeouts. Can be overridden at the server level.'
+        ),
       formatter: z
         .union([
           z.literal(false),