@link-assistant/agent 0.4.0 → 0.5.0

package/README.md

@@ -218,6 +218,9 @@ Stdin Mode Options:
   --no-interactive               Only accept JSON input
   --auto-merge-queued-messages   Merge rapidly arriving lines (default: true)
   --no-auto-merge-queued-messages Treat each line as separate message
+  --always-accept-stdin          Keep accepting input after agent finishes (default: true)
+  --no-always-accept-stdin       Single-message mode - exit after first response
+  --compact-json                 Output compact JSON for program-to-program use
 
   --help                         Show help
   --version                      Show version number

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@link-assistant/agent",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "description": "A minimal, public domain AI CLI agent compatible with OpenCode's JSON interface. Bun-only runtime.",
   "main": "src/index.js",
   "type": "module",

package/src/cli/continuous-mode.js

@@ -0,0 +1,450 @@
+/**
+ * Continuous stdin mode for the Agent CLI.
+ * Keeps the session alive and processes messages as they arrive.
+ */
+
+import { Server } from '../server/server.ts';
+import { Instance } from '../project/instance.ts';
+import { Bus } from '../bus/index.ts';
+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';
+
+// Shared error tracking
+let hasError = false;
+
+/**
+ * Set error state
+ * @param {boolean} value - Error state value
+ */
+export function setHasError(value) {
+  hasError = value;
+}
+
+/**
+ * Get error state
+ * @returns {boolean}
+ */
+export function getHasError() {
+  return hasError;
+}
+
+/**
+ * Output JSON status message to stderr
+ * @param {object} status - Status object to output
+ * @param {boolean} compact - If true, output compact JSON (single line)
+ */
+function outputStatus(status, compact = false) {
+  const json = compact
+    ? JSON.stringify(status)
+    : JSON.stringify(status, null, 2);
+  console.error(json);
+}
+
+/**
+ * Run server mode with continuous stdin input
+ * Keeps the session alive and processes messages as they arrive
+ */
+export async function runContinuousServerMode(
+  argv,
+  providerID,
+  modelID,
+  systemMessage,
+  appendSystemMessage,
+  jsonStandard
+) {
+  const compactJson = argv['compact-json'] === true;
+  const isInteractive = argv.interactive !== false;
+  const autoMerge = argv['auto-merge-queued-messages'] !== false;
+
+  // Start server like OpenCode does
+  const server = Server.listen({ port: 0, hostname: '127.0.0.1' });
+  let unsub = null;
+  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;
+
+    if (!sessionID) {
+      throw new Error('Failed to create session');
+    }
+
+    // Create event handler for the selected JSON standard
+    const eventHandler = createEventHandler(jsonStandard, sessionID);
+
+    // Track if we're currently processing a message
+    let isProcessing = false;
+    const pendingMessages = [];
+
+    // Process messages from the queue
+    const processMessage = async (message) => {
+      if (isProcessing) {
+        pendingMessages.push(message);
+        return;
+      }
+
+      isProcessing = true;
+      const messageText = message.message || 'hi';
+      const parts = [{ type: 'text', text: messageText }];
+
+      // Create a promise to wait for this message to complete
+      const messagePromise = new Promise((resolve) => {
+        const checkIdle = Bus.subscribeAll((event) => {
+          if (
+            event.type === 'session.idle' &&
+            event.properties.sessionID === sessionID
+          ) {
+            checkIdle();
+            resolve();
+          }
+        });
+      });
+
+      // Send message
+      fetch(
+        `http://${server.hostname}:${server.port}/session/${sessionID}/message`,
+        {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify({
+            parts,
+            model: { providerID, modelID },
+            system: systemMessage,
+            appendSystem: appendSystemMessage,
+          }),
+        }
+      ).catch((error) => {
+        hasError = true;
+        eventHandler.output({
+          type: 'error',
+          timestamp: Date.now(),
+          sessionID,
+          error: error instanceof Error ? error.message : String(error),
+        });
+      });
+
+      await messagePromise;
+      isProcessing = false;
+
+      // Process next pending message if any
+      if (pendingMessages.length > 0) {
+        const nextMessage = pendingMessages.shift();
+        processMessage(nextMessage);
+      }
+    };
+
+    // Subscribe to all bus events and output in selected format
+    unsub = Bus.subscribeAll((event) => {
+      if (event.type === 'message.part.updated') {
+        const part = event.properties.part;
+        if (part.sessionID !== sessionID) {
+          return;
+        }
+
+        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,
+          });
+        }
+      }
+
+      if (event.type === 'session.error') {
+        const props = event.properties;
+        if (props.sessionID !== sessionID || !props.error) {
+          return;
+        }
+        hasError = true;
+        eventHandler.output({
+          type: 'error',
+          timestamp: Date.now(),
+          sessionID,
+          error: props.error,
+        });
+      }
+    });
+
+    // Create continuous stdin reader
+    stdinReader = createContinuousStdinReader({
+      interactive: isInteractive,
+      autoMerge,
+      onMessage: (message) => {
+        processMessage(message);
+      },
+    });
+
+    // Wait for stdin to end (EOF or close)
+    await new Promise((resolve) => {
+      const checkRunning = setInterval(() => {
+        if (!stdinReader.isRunning()) {
+          clearInterval(checkRunning);
+          // Wait for any pending messages to complete
+          const waitForPending = () => {
+            if (!isProcessing && pendingMessages.length === 0) {
+              resolve();
+            } else {
+              setTimeout(waitForPending, 100);
+            }
+          };
+          waitForPending();
+        }
+      }, 100);
+
+      // Also handle SIGINT
+      process.on('SIGINT', () => {
+        outputStatus(
+          {
+            type: 'status',
+            message: 'Received SIGINT. Shutting down...',
+          },
+          compactJson
+        );
+        clearInterval(checkRunning);
+        resolve();
+      });
+    });
+  } finally {
+    if (stdinReader) {
+      stdinReader.stop();
+    }
+    if (unsub) {
+      unsub();
+    }
+    server.stop();
+    await Instance.dispose();
+  }
+}
+
+/**
+ * Run direct mode with continuous stdin input
+ * Keeps the session alive and processes messages as they arrive
+ */
+export async function runContinuousDirectMode(
+  argv,
+  providerID,
+  modelID,
+  systemMessage,
+  appendSystemMessage,
+  jsonStandard
+) {
+  const compactJson = argv['compact-json'] === true;
+  const isInteractive = argv.interactive !== false;
+  const autoMerge = argv['auto-merge-queued-messages'] !== false;
+
+  let unsub = null;
+  let stdinReader = null;
+
+  try {
+    // Create a session directly
+    const session = await Session.createNext({
+      directory: process.cwd(),
+    });
+    const sessionID = session.id;
+
+    // Create event handler for the selected JSON standard
+    const eventHandler = createEventHandler(jsonStandard, sessionID);
+
+    // Track if we're currently processing a message
+    let isProcessing = false;
+    const pendingMessages = [];
+
+    // Process messages from the queue
+    const processMessage = async (message) => {
+      if (isProcessing) {
+        pendingMessages.push(message);
+        return;
+      }
+
+      isProcessing = true;
+      const messageText = message.message || 'hi';
+      const parts = [{ type: 'text', text: messageText }];
+
+      // Create a promise to wait for this message to complete
+      const messagePromise = new Promise((resolve) => {
+        const checkIdle = Bus.subscribeAll((event) => {
+          if (
+            event.type === 'session.idle' &&
+            event.properties.sessionID === sessionID
+          ) {
+            checkIdle();
+            resolve();
+          }
+        });
+      });
+
+      // Send message directly
+      SessionPrompt.prompt({
+        sessionID,
+        parts,
+        model: { providerID, modelID },
+        system: systemMessage,
+        appendSystem: appendSystemMessage,
+      }).catch((error) => {
+        hasError = true;
+        eventHandler.output({
+          type: 'error',
+          timestamp: Date.now(),
+          sessionID,
+          error: error instanceof Error ? error.message : String(error),
+        });
+      });
+
+      await messagePromise;
+      isProcessing = false;
+
+      // Process next pending message if any
+      if (pendingMessages.length > 0) {
+        const nextMessage = pendingMessages.shift();
+        processMessage(nextMessage);
+      }
+    };
+
+    // Subscribe to all bus events and output in selected format
+    unsub = Bus.subscribeAll((event) => {
+      if (event.type === 'message.part.updated') {
+        const part = event.properties.part;
+        if (part.sessionID !== sessionID) {
+          return;
+        }
+
+        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,
+          });
+        }
+      }
+
+      if (event.type === 'session.error') {
+        const props = event.properties;
+        if (props.sessionID !== sessionID || !props.error) {
+          return;
+        }
+        hasError = true;
+        eventHandler.output({
+          type: 'error',
+          timestamp: Date.now(),
+          sessionID,
+          error: props.error,
+        });
+      }
+    });
+
+    // Create continuous stdin reader
+    stdinReader = createContinuousStdinReader({
+      interactive: isInteractive,
+      autoMerge,
+      onMessage: (message) => {
+        processMessage(message);
+      },
+    });
+
+    // Wait for stdin to end (EOF or close)
+    await new Promise((resolve) => {
+      const checkRunning = setInterval(() => {
+        if (!stdinReader.isRunning()) {
+          clearInterval(checkRunning);
+          // Wait for any pending messages to complete
+          const waitForPending = () => {
+            if (!isProcessing && pendingMessages.length === 0) {
+              resolve();
+            } else {
+              setTimeout(waitForPending, 100);
+            }
+          };
+          waitForPending();
+        }
+      }, 100);
+
+      // Also handle SIGINT
+      process.on('SIGINT', () => {
+        outputStatus(
+          {
+            type: 'status',
+            message: 'Received SIGINT. Shutting down...',
+          },
+          compactJson
+        );
+        clearInterval(checkRunning);
+        resolve();
+      });
+    });
+  } finally {
+    if (stdinReader) {
+      stdinReader.stop();
+    }
+    if (unsub) {
+      unsub();
+    }
+    await Instance.dispose();
+  }
+}

package/src/index.js

@@ -18,6 +18,10 @@ import { AuthCommand } from './cli/cmd/auth.ts';
 import { Flag } from './flag/flag.ts';
 import { FormatError } from './cli/error.ts';
 import { UI } from './cli/ui.ts';
+import {
+  runContinuousServerMode,
+  runContinuousDirectMode,
+} from './cli/continuous-mode.js';
 import { createRequire } from 'module';
 import { readFileSync } from 'fs';
 import { dirname, join } from 'path';
@@ -132,30 +136,21 @@ function readStdinWithTimeout(timeout = null) {
  * Output JSON status message to stderr
  * This prevents the status message from interfering with JSON output parsing
  * @param {object} status - Status object to output
+ * @param {boolean} compact - If true, output compact JSON (single line)
  */
-function outputStatus(status) {
-  console.error(JSON.stringify(status));
+function outputStatus(status, compact = false) {
+  const json = compact
+    ? JSON.stringify(status)
+    : JSON.stringify(status, null, 2);
+  console.error(json);
 }
 
-async function runAgentMode(argv, request) {
-  // Note: verbose flag and logging are now initialized in middleware
-  // See main() function for the middleware that sets up Flag and Log.init()
-
-  // Log version and command info in verbose mode
-  if (Flag.OPENCODE_VERBOSE) {
-    console.error(`Agent version: ${pkg.version}`);
-    console.error(`Command: ${process.argv.join(' ')}`);
-    console.error(`Working directory: ${process.cwd()}`);
-    console.error(`Script path: ${import.meta.path}`);
-  }
-
-  // Log dry-run mode if enabled
-  if (Flag.OPENCODE_DRY_RUN) {
-    console.error(
-      `[DRY RUN MODE] No actual API calls or package installations will be made`
-    );
-  }
-
+/**
+ * Parse model configuration from argv
+ * @param {object} argv - Command line arguments
+ * @returns {object} - { providerID, modelID }
+ */
+async function parseModelConfig(argv) {
   // Parse model argument (handle model IDs with slashes like groq/qwen/qwen3-32b)
   const modelParts = argv.model.split('/');
   let providerID = modelParts[0] || 'opencode';
@@ -170,13 +165,15 @@ async function runAgentMode(argv, request) {
     const creds = await ClaudeOAuth.getCredentials();
 
     if (!creds?.accessToken) {
-      console.error(
-        JSON.stringify({
+      const compactJson = argv['compact-json'] === true;
+      outputStatus(
+        {
           type: 'error',
           errorType: 'AuthenticationError',
           message:
             'No Claude OAuth credentials found in ~/.claude/.credentials.json. Either authenticate with Claude Code CLI first, or use: agent auth login (select Anthropic > Claude Pro/Max)',
-        })
+        },
+        compactJson
       );
       process.exit(1);
     }
@@ -191,26 +188,27 @@ async function runAgentMode(argv, request) {
       modelID = 'claude-sonnet-4-5';
     } else if (!['claude-oauth', 'anthropic'].includes(providerID)) {
       // If user specified a different provider, warn them
-      console.error(
-        JSON.stringify({
+      const compactJson = argv['compact-json'] === true;
+      outputStatus(
+        {
           type: 'warning',
           message: `--use-existing-claude-oauth is set but model uses provider "${providerID}". Using OAuth credentials anyway.`,
-        })
+        },
+        compactJson
       );
       providerID = 'claude-oauth';
     }
   }
 
-  // Validate and get JSON standard
-  const jsonStandard = argv['json-standard'];
-  if (!isValidJsonStandard(jsonStandard)) {
-    console.error(
-      `Invalid JSON standard: ${jsonStandard}. Use "opencode" or "claude".`
-    );
-    process.exit(1);
-  }
+  return { providerID, modelID };
+}
 
-  // Read system message files
+/**
+ * Read system message from files if specified
+ * @param {object} argv - Command line arguments
+ * @returns {object} - { systemMessage, appendSystemMessage }
+ */
+async function readSystemMessages(argv) {
   let systemMessage = argv['system-message'];
   let appendSystemMessage = argv['append-system-message'];
 
@@ -244,6 +242,41 @@ async function runAgentMode(argv, request) {
     appendSystemMessage = await file.text();
   }
 
+  return { systemMessage, appendSystemMessage };
+}
+
+async function runAgentMode(argv, request) {
+  // Note: verbose flag and logging are now initialized in middleware
+  // See main() function for the middleware that sets up Flag and Log.init()
+
+  // Log version and command info in verbose mode
+  if (Flag.OPENCODE_VERBOSE) {
+    console.error(`Agent version: ${pkg.version}`);
+    console.error(`Command: ${process.argv.join(' ')}`);
+    console.error(`Working directory: ${process.cwd()}`);
+    console.error(`Script path: ${import.meta.path}`);
+  }
+
+  // Log dry-run mode if enabled
+  if (Flag.OPENCODE_DRY_RUN) {
+    console.error(
+      `[DRY RUN MODE] No actual API calls or package installations will be made`
+    );
+  }
+
+  const { providerID, modelID } = await parseModelConfig(argv);
+
+  // Validate and get JSON standard
+  const jsonStandard = argv['json-standard'];
+  if (!isValidJsonStandard(jsonStandard)) {
+    console.error(
+      `Invalid JSON standard: ${jsonStandard}. Use "opencode" or "claude".`
+    );
+    process.exit(1);
+  }
+
+  const { systemMessage, appendSystemMessage } = await readSystemMessages(argv);
+
   // Logging is already initialized in middleware, no need to call Log.init() again
 
   // Wrap in Instance.provide for OpenCode infrastructure
@@ -278,6 +311,81 @@ async function runAgentMode(argv, request) {
   process.exit(hasError ? 1 : 0);
 }
 
+/**
+ * Run agent in continuous stdin mode
+ * Keeps accepting input until EOF or SIGINT
+ * @param {object} argv - Command line arguments
+ */
+async function runContinuousAgentMode(argv) {
+  // Note: verbose flag and logging are now initialized in middleware
+  // See main() function for the middleware that sets up Flag and Log.init()
+
+  const compactJson = argv['compact-json'] === true;
+
+  // Log version and command info in verbose mode
+  if (Flag.OPENCODE_VERBOSE) {
+    console.error(`Agent version: ${pkg.version}`);
+    console.error(`Command: ${process.argv.join(' ')}`);
+    console.error(`Working directory: ${process.cwd()}`);
+    console.error(`Script path: ${import.meta.path}`);
+  }
+
+  // Log dry-run mode if enabled
+  if (Flag.OPENCODE_DRY_RUN) {
+    console.error(
+      `[DRY RUN MODE] No actual API calls or package installations will be made`
+    );
+  }
+
+  const { providerID, modelID } = await parseModelConfig(argv);
+
+  // Validate and get JSON standard
+  const jsonStandard = argv['json-standard'];
+  if (!isValidJsonStandard(jsonStandard)) {
+    outputStatus(
+      {
+        type: 'error',
+        message: `Invalid JSON standard: ${jsonStandard}. Use "opencode" or "claude".`,
+      },
+      compactJson
+    );
+    process.exit(1);
+  }
+
+  const { systemMessage, appendSystemMessage } = await readSystemMessages(argv);
+
+  // Wrap in Instance.provide for OpenCode infrastructure
+  await Instance.provide({
+    directory: process.cwd(),
+    fn: async () => {
+      if (argv.server) {
+        // SERVER MODE: Start server and communicate via HTTP
+        await runContinuousServerMode(
+          argv,
+          providerID,
+          modelID,
+          systemMessage,
+          appendSystemMessage,
+          jsonStandard
+        );
+      } else {
+        // DIRECT MODE: Run everything in single process
+        await runContinuousDirectMode(
+          argv,
+          providerID,
+          modelID,
+          systemMessage,
+          appendSystemMessage,
+          jsonStandard
+        );
+      }
+    },
+  });
+
+  // Explicitly exit to ensure process terminates
+  process.exit(hasError ? 1 : 0);
+}
+
 async function runServerMode(
   request,
   providerID,
@@ -645,6 +753,18 @@ async function main() {
           'Enable interactive mode to accept manual input as plain text strings (default: true). Use --no-interactive to only accept JSON input.',
         default: true,
       })
+      .option('always-accept-stdin', {
+        type: 'boolean',
+        description:
+          'Keep accepting stdin input even after the agent finishes work (default: true). Use --no-always-accept-stdin for single-message mode.',
+        default: true,
+      })
+      .option('compact-json', {
+        type: 'boolean',
+        description:
+          'Output compact JSON (single line) instead of pretty-printed JSON (default: false). Useful for program-to-program communication.',
+        default: false,
+      })
       // Initialize logging early for all CLI commands
       // This prevents debug output from appearing in CLI unless --verbose is used
       .middleware(async (argv) => {
@@ -702,6 +822,8 @@ async function main() {
     const commandExecuted = argv._ && argv._.length > 0;
 
     if (!commandExecuted) {
+      const compactJson = argv['compact-json'] === true;
+
       // Check if --prompt flag was provided
       if (argv.prompt) {
         // Direct prompt mode - bypass stdin entirely
@@ -713,12 +835,15 @@ async function main() {
       // Check if --disable-stdin was set without --prompt
       if (argv['disable-stdin']) {
         // Output a helpful message suggesting to use --prompt
-        outputStatus({
-          type: 'error',
-          message:
-            'No prompt provided. Use -p/--prompt to specify a message, or remove --disable-stdin to read from stdin.',
-          hint: 'Example: agent -p "Hello, how are you?"',
-        });
+        outputStatus(
+          {
+            type: 'error',
+            message:
+              'No prompt provided. Use -p/--prompt to specify a message, or remove --disable-stdin to read from stdin.',
+            hint: 'Example: agent -p "Hello, how are you?"',
+          },
+          compactJson
+        );
         process.exit(1);
       }
 
@@ -733,32 +858,49 @@ async function main() {
       // Output status message to inform user what's happening
       const isInteractive = argv.interactive !== false;
       const autoMerge = argv['auto-merge-queued-messages'] !== false;
+      const alwaysAcceptStdin = argv['always-accept-stdin'] !== false;
 
-      outputStatus({
-        type: 'status',
-        mode: 'stdin-stream',
-        message:
-          'Agent CLI in stdin listening mode. Accepts JSON and plain text input.',
-        hint: 'Press CTRL+C to exit. Use --help for options.',
-        acceptedFormats: isInteractive
-          ? ['JSON object with "message" field', 'Plain text']
-          : ['JSON object with "message" field'],
-        options: {
-          interactive: isInteractive,
-          autoMergeQueuedMessages: autoMerge,
+      outputStatus(
+        {
+          type: 'status',
+          mode: 'stdin-stream',
+          message: alwaysAcceptStdin
+            ? 'Agent CLI in continuous listening mode. Accepts JSON and plain text input.'
+            : 'Agent CLI in single-message mode. Accepts JSON and plain text input.',
+          hint: 'Press CTRL+C to exit. Use --help for options.',
+          acceptedFormats: isInteractive
+            ? ['JSON object with "message" field', 'Plain text']
+            : ['JSON object with "message" field'],
+          options: {
+            interactive: isInteractive,
+            autoMergeQueuedMessages: autoMerge,
+            alwaysAcceptStdin,
+            compactJson,
+          },
         },
-      });
+        compactJson
+      );
 
+      // Use continuous mode if --always-accept-stdin is enabled (default)
+      if (alwaysAcceptStdin) {
+        await runContinuousAgentMode(argv);
+        return;
+      }
+
+      // Single-message mode (--no-always-accept-stdin)
       // Read stdin with optional timeout
       const timeout = argv['stdin-stream-timeout'] ?? null;
       const input = await readStdinWithTimeout(timeout);
       const trimmedInput = input.trim();
 
       if (trimmedInput === '') {
-        outputStatus({
-          type: 'status',
-          message: 'No input received. Exiting.',
-        });
+        outputStatus(
+          {
+            type: 'status',
+            message: 'No input received. Exiting.',
+          },
+          compactJson
+        );
         yargsInstance.showHelp();
         process.exit(0);
       }
@@ -771,12 +913,15 @@ async function main() {
         // Not JSON
         if (!isInteractive) {
           // In non-interactive mode, only accept JSON
-          outputStatus({
-            type: 'error',
-            message:
-              'Invalid JSON input. In non-interactive mode (--no-interactive), only JSON input is accepted.',
-            hint: 'Use --interactive to accept plain text, or provide valid JSON: {"message": "your text"}',
-          });
+          outputStatus(
+            {
+              type: 'error',
+              message:
+                'Invalid JSON input. In non-interactive mode (--no-interactive), only JSON input is accepted.',
+              hint: 'Use --interactive to accept plain text, or provide valid JSON: {"message": "your text"}',
+            },
+            compactJson
+          );
           process.exit(1);
         }
         // In interactive mode, treat as plain text message