@link-assistant/agent 0.3.1 → 0.5.0

package/README.md

@@ -181,6 +181,18 @@ See [MODELS.md](MODELS.md) for complete list of available models and pricing.
 See [docs/groq.md](docs/groq.md) for Groq provider documentation.
 See [docs/claude-oauth.md](docs/claude-oauth.md) for Claude OAuth provider documentation.
 
+### Direct Prompt Mode
+
+Use `-p`/`--prompt` to send a prompt directly without reading from stdin:
+
+```bash
+# Direct prompt (bypasses stdin)
+agent -p "What is 2+2?"
+
+# Useful in scripts
+result=$(agent -p "Summarize: $(cat file.txt)")
+```
+
 ### CLI Options
 
 ```bash
@@ -197,6 +209,19 @@ Options:
   --system-message-file          Full override of the system message from file
   --append-system-message        Append to the default system message
   --append-system-message-file   Append to the default system message from file
+
+Stdin Mode Options:
+  -p, --prompt                   Direct prompt (bypasses stdin reading)
+  --disable-stdin                Disable stdin streaming (requires --prompt)
+  --stdin-stream-timeout         Timeout in ms for stdin reading (default: none)
+  --interactive                  Accept plain text input (default: true)
+  --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
 
@@ -208,6 +233,8 @@ Commands:
   mcp                  MCP server commands
 ```
 
+See [docs/stdin-mode.md](docs/stdin-mode.md) for comprehensive stdin mode documentation.
+
 ### JSON Output Standards
 
 The agent supports two JSON output format standards via the `--json-standard` option:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@link-assistant/agent",
-  "version": "0.3.1",
+  "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/auth/plugins.ts

@@ -849,6 +849,8 @@ const GOOGLE_OAUTH_SCOPES = [
   'https://www.googleapis.com/auth/cloud-platform',
   'https://www.googleapis.com/auth/userinfo.email',
   'https://www.googleapis.com/auth/userinfo.profile',
+  'https://www.googleapis.com/auth/generative-language.tuning',
+  'https://www.googleapis.com/auth/generative-language.retriever',
 ];
 
 // Google OAuth endpoints

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/cli/input-queue.js

@@ -0,0 +1,197 @@
+/**
+ * Input queue for managing continuous stdin input.
+ * Supports queuing of multiple messages and auto-merging of rapidly arriving lines.
+ */
+export class InputQueue {
+  constructor(options = {}) {
+    this.queue = [];
+    this.autoMerge = options.autoMerge !== false; // enabled by default
+    this.mergeDelayMs = options.mergeDelayMs || 50; // delay to wait for more lines
+    this.pendingLines = [];
+    this.mergeTimer = null;
+    this.onMessage = options.onMessage || (() => {});
+    this.interactive = options.interactive !== false; // enabled by default
+  }
+
+  /**
+   * Parse input and determine if it's JSON or plain text
+   * @param {string} input - Raw input string
+   * @returns {object} - Parsed message object
+   */
+  parseInput(input) {
+    const trimmed = input.trim();
+    if (!trimmed) {
+      return null;
+    }
+
+    try {
+      const parsed = JSON.parse(trimmed);
+      // If it has a message field, use it directly
+      if (typeof parsed === 'object' && parsed !== null) {
+        return parsed;
+      }
+      // Otherwise wrap it
+      return { message: JSON.stringify(parsed) };
+    } catch (_e) {
+      // Not JSON, treat as plain text message
+      return { message: trimmed };
+    }
+  }
+
+  /**
+   * Add a line to the queue, potentially merging with pending lines
+   * @param {string} line - Input line
+   */
+  addLine(line) {
+    if (!this.interactive && !line.trim().startsWith('{')) {
+      // In non-interactive mode, only accept JSON
+      return;
+    }
+
+    if (this.autoMerge) {
+      // Add to pending lines and schedule merge
+      this.pendingLines.push(line);
+      this.scheduleMerge();
+    } else {
+      // No merging, queue immediately
+      const parsed = this.parseInput(line);
+      if (parsed) {
+        this.queue.push(parsed);
+        this.notifyMessage(parsed);
+      }
+    }
+  }
+
+  /**
+   * Schedule a merge of pending lines after a short delay
+   */
+  scheduleMerge() {
+    if (this.mergeTimer) {
+      clearTimeout(this.mergeTimer);
+    }
+    this.mergeTimer = setTimeout(() => {
+      this.flushPendingLines();
+    }, this.mergeDelayMs);
+  }
+
+  /**
+   * Flush pending lines into a single merged message
+   */
+  flushPendingLines() {
+    if (this.pendingLines.length === 0) {
+      return;
+    }
+
+    const mergedText = this.pendingLines.join('\n');
+    this.pendingLines = [];
+    this.mergeTimer = null;
+
+    const parsed = this.parseInput(mergedText);
+    if (parsed) {
+      this.queue.push(parsed);
+      this.notifyMessage(parsed);
+    }
+  }
+
+  /**
+   * Immediately flush any pending lines (for shutdown)
+   */
+  flush() {
+    if (this.mergeTimer) {
+      clearTimeout(this.mergeTimer);
+      this.mergeTimer = null;
+    }
+    this.flushPendingLines();
+  }
+
+  /**
+   * Get next message from the queue
+   * @returns {object|null} - Next message or null if queue is empty
+   */
+  dequeue() {
+    return this.queue.shift() || null;
+  }
+
+  /**
+   * Check if queue has messages
+   * @returns {boolean}
+   */
+  hasMessages() {
+    return this.queue.length > 0;
+  }
+
+  /**
+   * Notify listener of new message
+   * @param {object} message - The message object
+   */
+  notifyMessage(message) {
+    if (this.onMessage) {
+      this.onMessage(message);
+    }
+  }
+
+  /**
+   * Get queue size
+   * @returns {number}
+   */
+  size() {
+    return this.queue.length;
+  }
+}
+
+/**
+ * Create a continuous stdin reader that queues input lines
+ * @param {object} options - Options for the reader
+ * @returns {object} - Reader with queue and control methods
+ */
+// Note: This function is prepared for future continuous input mode
+export function createContinuousStdinReader(options = {}) {
+  const inputQueue = new InputQueue(options);
+  let isRunning = true;
+  let lineBuffer = '';
+
+  const handleData = (chunk) => {
+    if (!isRunning) {
+      return;
+    }
+
+    lineBuffer += chunk.toString();
+    const lines = lineBuffer.split('\n');
+
+    // Keep the last incomplete line in buffer
+    lineBuffer = lines.pop() || '';
+
+    // Process complete lines
+    for (const line of lines) {
+      if (line.trim()) {
+        inputQueue.addLine(line);
+      }
+    }
+  };
+
+  const handleEnd = () => {
+    // Process any remaining data in buffer
+    if (lineBuffer.trim()) {
+      inputQueue.addLine(lineBuffer);
+    }
+    inputQueue.flush();
+    isRunning = false;
+  };
+
+  process.stdin.on('data', handleData);
+  process.stdin.on('end', handleEnd);
+  process.stdin.on('error', () => {
+    isRunning = false;
+  });
+
+  return {
+    queue: inputQueue,
+    stop: () => {
+      isRunning = false;
+      inputQueue.flush();
+      process.stdin.removeListener('data', handleData);
+      process.stdin.removeListener('end', handleEnd);
+    },
+    isRunning: () => isRunning,
+  };
+}

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';
@@ -73,50 +77,80 @@ process.on('unhandledRejection', (reason, _promise) => {
   process.exit(1);
 });
 
-function readStdin() {
-  return new Promise((resolve, reject) => {
+/**
+ * Read stdin with optional timeout.
+ * @param {number|null} timeout - Timeout in milliseconds. If null, wait indefinitely until EOF.
+ * @returns {Promise<string>} - The stdin content
+ */
+function readStdinWithTimeout(timeout = null) {
+  return new Promise((resolve) => {
     let data = '';
+    let hasData = false;
+    let timer = null;
+
+    const cleanup = () => {
+      if (timer) {
+        clearTimeout(timer);
+      }
+      process.stdin.removeListener('data', onData);
+      process.stdin.removeListener('end', onEnd);
+      process.stdin.removeListener('error', onError);
+    };
+
     const onData = (chunk) => {
+      hasData = true;
+      if (timer) {
+        clearTimeout(timer);
+      }
       data += chunk;
     };
+
     const onEnd = () => {
       cleanup();
       resolve(data);
     };
-    const onError = (err) => {
+
+    const onError = () => {
       cleanup();
-      reject(err);
-    };
-    const cleanup = () => {
-      process.stdin.removeListener('data', onData);
-      process.stdin.removeListener('end', onEnd);
-      process.stdin.removeListener('error', onError);
+      resolve('');
     };
+
+    // Only set timeout if specified (not null)
+    if (timeout !== null) {
+      timer = setTimeout(() => {
+        if (!hasData) {
+          process.stdin.pause();
+          cleanup();
+          resolve('');
+        }
+      }, timeout);
+    }
+
     process.stdin.on('data', onData);
     process.stdin.on('end', onEnd);
     process.stdin.on('error', onError);
   });
 }
 
-async function runAgentMode(argv) {
-  // 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`
-    );
-  }
+/**
+ * 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, compact = false) {
+  const json = compact
+    ? JSON.stringify(status)
+    : JSON.stringify(status, null, 2);
+  console.error(json);
+}
 
+/**
+ * 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';
@@ -131,13 +165,15 @@ async function runAgentMode(argv) {
     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);
     }
@@ -152,26 +188,27 @@ async function runAgentMode(argv) {
       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'];
 
@@ -205,23 +242,43 @@ async function runAgentMode(argv) {
     appendSystemMessage = await file.text();
   }
 
-  // Logging is already initialized in middleware, no need to call Log.init() again
+  return { systemMessage, appendSystemMessage };
+}
 
-  // Read input from stdin
-  const input = await readStdin();
-  const trimmedInput = input.trim();
+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()
 
-  // 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, treat as plain text message
-    request = {
-      message: trimmedInput,
-    };
+  // 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
   await Instance.provide({
     directory: process.cwd(),
@@ -254,6 +311,81 @@ async function runAgentMode(argv) {
   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,
@@ -533,7 +665,7 @@ async function runDirectMode(
 async function main() {
   try {
     // Parse command line arguments with subcommands
-    const argv = await yargs(hideBin(process.argv))
+    const yargsInstance = yargs(hideBin(process.argv))
       .scriptName('agent')
       .usage('$0 [command] [options]')
       .version(pkg.version)
@@ -593,6 +725,46 @@ async function main() {
           '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,
+      })
       // Initialize logging early for all CLI commands
       // This prevents debug output from appearing in CLI unless --verbose is used
       .middleware(async (argv) => {
@@ -641,15 +813,125 @@ async function main() {
           process.exit(1);
         }
       })
-      .help().argv;
+      .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) {
-      // No command specified, run in default agent mode (stdin processing)
-      await runAgentMode(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 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;
+      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)
+      // 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.',
+          },
+          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);
     }
   } catch (error) {
     hasError = true;