@link-assistant/agent 0.4.0 → 0.5.1

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.1",
   "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,
@@ -565,85 +673,253 @@ async function main() {
       .command(McpCommand)
       // Auth subcommand
       .command(AuthCommand)
-      // Default run mode (when piping stdin)
-      .option('model', {
-        type: 'string',
-        description: 'Model to use in format providerID/modelID',
-        default: 'opencode/grok-code',
-      })
-      .option('json-standard', {
-        type: 'string',
-        description:
-          'JSON output format standard: "opencode" (default) or "claude" (experimental)',
-        default: 'opencode',
-        choices: ['opencode', 'claude'],
-      })
-      .option('system-message', {
-        type: 'string',
-        description: 'Full override of the system message',
-      })
-      .option('system-message-file', {
-        type: 'string',
-        description: 'Full override of the system message from file',
-      })
-      .option('append-system-message', {
-        type: 'string',
-        description: 'Append to the default system message',
-      })
-      .option('append-system-message-file', {
-        type: 'string',
-        description: 'Append to the default system message from file',
-      })
-      .option('server', {
-        type: 'boolean',
-        description: 'Run in server mode (default)',
-        default: true,
-      })
-      .option('verbose', {
-        type: 'boolean',
-        description:
-          'Enable verbose mode to debug API requests (shows system prompt, token counts, etc.)',
-        default: false,
-      })
-      .option('dry-run', {
-        type: 'boolean',
-        description:
-          'Simulate operations without making actual API calls or package installations (useful for testing)',
-        default: false,
-      })
-      .option('use-existing-claude-oauth', {
-        type: 'boolean',
-        description:
-          'Use existing Claude OAuth credentials from ~/.claude/.credentials.json (from Claude Code CLI)',
-        default: false,
-      })
-      .option('prompt', {
-        alias: 'p',
-        type: 'string',
-        description: 'Prompt message to send directly (bypasses stdin reading)',
-      })
-      .option('disable-stdin', {
-        type: 'boolean',
-        description:
-          'Disable stdin streaming mode (requires --prompt or shows help)',
-        default: false,
-      })
-      .option('stdin-stream-timeout', {
-        type: 'number',
-        description:
-          'Optional timeout in milliseconds for stdin reading (default: no timeout)',
-      })
-      .option('auto-merge-queued-messages', {
-        type: 'boolean',
-        description:
-          'Enable auto-merging of rapidly arriving input lines into single messages (default: true)',
-        default: true,
-      })
-      .option('interactive', {
-        type: 'boolean',
-        description:
-          'Enable interactive mode to accept manual input as plain text strings (default: true). Use --no-interactive to only accept JSON input.',
-        default: true,
+      // Default command for agent mode (when no subcommand specified)
+      .command({
+        command: '$0',
+        describe: 'Run agent in interactive or stdin mode (default)',
+        builder: (yargs) =>
+          yargs
+            .option('model', {
+              type: 'string',
+              description: 'Model to use in format providerID/modelID',
+              default: 'opencode/grok-code',
+            })
+            .option('json-standard', {
+              type: 'string',
+              description:
+                'JSON output format standard: "opencode" (default) or "claude" (experimental)',
+              default: 'opencode',
+              choices: ['opencode', 'claude'],
+            })
+            .option('system-message', {
+              type: 'string',
+              description: 'Full override of the system message',
+            })
+            .option('system-message-file', {
+              type: 'string',
+              description: 'Full override of the system message from file',
+            })
+            .option('append-system-message', {
+              type: 'string',
+              description: 'Append to the default system message',
+            })
+            .option('append-system-message-file', {
+              type: 'string',
+              description: 'Append to the default system message from file',
+            })
+            .option('server', {
+              type: 'boolean',
+              description: 'Run in server mode (default)',
+              default: true,
+            })
+            .option('verbose', {
+              type: 'boolean',
+              description:
+                'Enable verbose mode to debug API requests (shows system prompt, token counts, etc.)',
+              default: false,
+            })
+            .option('dry-run', {
+              type: 'boolean',
+              description:
+                'Simulate operations without making actual API calls or package installations (useful for testing)',
+              default: false,
+            })
+            .option('use-existing-claude-oauth', {
+              type: 'boolean',
+              description:
+                'Use existing Claude OAuth credentials from ~/.claude/.credentials.json (from Claude Code CLI)',
+              default: false,
+            })
+            .option('prompt', {
+              alias: 'p',
+              type: 'string',
+              description:
+                'Prompt message to send directly (bypasses stdin reading)',
+            })
+            .option('disable-stdin', {
+              type: 'boolean',
+              description:
+                'Disable stdin streaming mode (requires --prompt or shows help)',
+              default: false,
+            })
+            .option('stdin-stream-timeout', {
+              type: 'number',
+              description:
+                'Optional timeout in milliseconds for stdin reading (default: no timeout)',
+            })
+            .option('auto-merge-queued-messages', {
+              type: 'boolean',
+              description:
+                'Enable auto-merging of rapidly arriving input lines into single messages (default: true)',
+              default: true,
+            })
+            .option('interactive', {
+              type: 'boolean',
+              description:
+                '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,
+            }),
+        handler: async (argv) => {
+          const compactJson = argv['compact-json'] === true;
+
+          // Check if --prompt flag was provided
+          if (argv.prompt) {
+            // Direct prompt mode - bypass stdin entirely
+            const request = { message: argv.prompt };
+            await runAgentMode(argv, request);
+            return;
+          }
+
+          // 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?"',
+              },
+              compactJson
+            );
+            process.exit(1);
+          }
+
+          // Check if stdin is a TTY (interactive terminal)
+          if (process.stdin.isTTY) {
+            // Enter interactive terminal mode with continuous listening
+            const isInteractive = argv.interactive !== false;
+            const autoMerge = argv['auto-merge-queued-messages'] !== false;
+            const alwaysAcceptStdin = argv['always-accept-stdin'] !== false;
+
+            // Exit if --no-always-accept-stdin is set (single message mode not supported in TTY)
+            if (!alwaysAcceptStdin) {
+              outputStatus(
+                {
+                  type: 'error',
+                  message:
+                    'Single message mode (--no-always-accept-stdin) is not supported in interactive terminal mode.',
+                  hint: 'Use piped input or --prompt for single messages.',
+                },
+                compactJson
+              );
+              process.exit(1);
+            }
+
+            outputStatus(
+              {
+                type: 'status',
+                mode: 'interactive-terminal',
+                message:
+                  'Agent CLI in interactive terminal mode. Type your message and press Enter.',
+                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 for interactive terminal
+            await runContinuousAgentMode(argv);
+            return;
+          }
+
+          // stdin is piped - enter stdin listening mode
+          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: 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)
+          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.',
+              },
+              compactJson
+            );
+            yargsInstance.showHelp();
+            process.exit(0);
+          }
+
+          // Try to parse as JSON, if it fails treat it as plain text message
+          let request;
+          try {
+            request = JSON.parse(trimmedInput);
+          } catch (_e) {
+            // 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"}',
+                },
+                compactJson
+              );
+              process.exit(1);
+            }
+            // In interactive mode, treat as plain text message
+            request = {
+              message: trimmedInput,
+            };
+          }
+
+          // Run agent mode
+          await runAgentMode(argv, request);
+        },
       })
       // Initialize logging early for all CLI commands
       // This prevents debug output from appearing in CLI unless --verbose is used
@@ -695,99 +971,8 @@ async function main() {
       })
       .help();
 
-    const argv = await yargsInstance.argv;
-
-    // If a command was executed (like mcp), yargs handles it
-    // Otherwise, check if we should run in agent mode (stdin piped)
-    const commandExecuted = argv._ && argv._.length > 0;
-
-    if (!commandExecuted) {
-      // Check if --prompt flag was provided
-      if (argv.prompt) {
-        // Direct prompt mode - bypass stdin entirely
-        const request = { message: argv.prompt };
-        await runAgentMode(argv, request);
-        return;
-      }
-
-      // 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?"',
-        });
-        process.exit(1);
-      }
-
-      // Check if stdin is a TTY (interactive terminal)
-      // If it is, show help instead of waiting for input
-      if (process.stdin.isTTY) {
-        yargsInstance.showHelp();
-        process.exit(0);
-      }
-
-      // stdin is piped - enter stdin listening mode
-      // Output status message to inform user what's happening
-      const isInteractive = argv.interactive !== false;
-      const autoMerge = argv['auto-merge-queued-messages'] !== 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,
-        },
-      });
-
-      // 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.',
-        });
-        yargsInstance.showHelp();
-        process.exit(0);
-      }
-
-      // Try to parse as JSON, if it fails treat it as plain text message
-      let request;
-      try {
-        request = JSON.parse(trimmedInput);
-      } catch (_e) {
-        // 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"}',
-          });
-          process.exit(1);
-        }
-        // In interactive mode, treat as plain text message
-        request = {
-          message: trimmedInput,
-        };
-      }
-
-      // Run agent mode
-      await runAgentMode(argv, request);
-    }
+    // Parse arguments (handlers will be called automatically)
+    await yargsInstance.argv;
   } catch (error) {
     hasError = true;
     console.error(