@link-assistant/agent 0.3.0 → 0.4.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,16 @@ 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
+
   --help                         Show help
   --version                      Show version number
 
@@ -208,6 +230,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.0",
+  "version": "0.4.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/bun/index.ts

@@ -5,10 +5,14 @@ import path from 'path';
 import { NamedError } from '../util/error';
 import { readableStreamToText } from 'bun';
 import { Flag } from '../flag/flag';
+import { Lock } from '../util/lock';
 
 export namespace BunProc {
   const log = Log.create({ service: 'bun' });
 
+  // Lock key for serializing package installations to prevent race conditions
+  const INSTALL_LOCK_KEY = 'bun-install';
+
   export async function run(
     cmd: string[],
     options?: Bun.SpawnOptions.OptionsObject<any, any, any>
@@ -65,8 +69,38 @@ export namespace BunProc {
     })
   );
 
+  // Maximum number of retry attempts for cache-related errors
+  const MAX_RETRIES = 3;
+  // Delay between retries in milliseconds
+  const RETRY_DELAY_MS = 500;
+
+  /**
+   * Check if an error is related to Bun cache issues
+   */
+  function isCacheRelatedError(errorMsg: string): boolean {
+    return (
+      errorMsg.includes('failed copying files from cache') ||
+      errorMsg.includes('FileNotFound') ||
+      errorMsg.includes('ENOENT') ||
+      errorMsg.includes('EACCES') ||
+      errorMsg.includes('EBUSY')
+    );
+  }
+
+  /**
+   * Wait for a specified duration
+   */
+  function delay(ms: number): Promise<void> {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+
   export async function install(pkg: string, version = 'latest') {
     const mod = path.join(Global.Path.cache, 'node_modules', pkg);
+
+    // Use a write lock to serialize all package installations
+    // This prevents race conditions when multiple packages are installed concurrently
+    using _ = await Lock.write(INSTALL_LOCK_KEY);
+
     const pkgjson = Bun.file(path.join(Global.Path.cache, 'package.json'));
     const parsed = await pkgjson.json().catch(async () => {
       const result = { dependencies: {} };
@@ -108,25 +142,78 @@ export namespace BunProc {
       version,
     });
 
-    await BunProc.run(args, {
-      cwd: Global.Path.cache,
-    }).catch((e) => {
-      log.error('package installation failed', {
+    // Retry logic for cache-related errors
+    let lastError: Error | undefined;
+    for (let attempt = 1; attempt <= MAX_RETRIES; attempt++) {
+      try {
+        await BunProc.run(args, {
+          cwd: Global.Path.cache,
+        });
+
+        log.info('package installed successfully', { pkg, version, attempt });
+        parsed.dependencies[pkg] = version;
+        await Bun.write(pkgjson.name!, JSON.stringify(parsed, null, 2));
+        return mod;
+      } catch (e) {
+        const errorMsg = e instanceof Error ? e.message : String(e);
+        const isCacheError = isCacheRelatedError(errorMsg);
+
+        log.warn('package installation attempt failed', {
+          pkg,
+          version,
+          attempt,
+          maxRetries: MAX_RETRIES,
+          error: errorMsg,
+          isCacheError,
+        });
+
+        if (isCacheError && attempt < MAX_RETRIES) {
+          log.info('retrying installation after cache-related error', {
+            pkg,
+            version,
+            attempt,
+            nextAttempt: attempt + 1,
+            delayMs: RETRY_DELAY_MS,
+          });
+          await delay(RETRY_DELAY_MS);
+          lastError = e instanceof Error ? e : new Error(errorMsg);
+          continue;
+        }
+
+        // Non-cache error or final attempt - log and throw
+        log.error('package installation failed', {
+          pkg,
+          version,
+          error: errorMsg,
+          stack: e instanceof Error ? e.stack : undefined,
+          possibleCacheCorruption: isCacheError,
+          attempts: attempt,
+        });
+
+        // Provide helpful recovery instructions for cache-related errors
+        if (isCacheError) {
+          log.error(
+            'Bun package cache may be corrupted. Try clearing the cache with: bun pm cache rm'
+          );
+        }
+
+        throw new InstallFailedError(
+          { pkg, version, details: errorMsg },
+          {
+            cause: e,
+          }
+        );
+      }
+    }
+
+    // This should not be reached, but handle it just in case
+    throw new InstallFailedError(
+      {
         pkg,
         version,
-        error: e instanceof Error ? e.message : String(e),
-        stack: e instanceof Error ? e.stack : undefined,
-      });
-      throw new InstallFailedError(
-        { pkg, version, details: e instanceof Error ? e.message : String(e) },
-        {
-          cause: e,
-        }
-      );
-    });
-    log.info('package installed successfully', { pkg, version });
-    parsed.dependencies[pkg] = version;
-    await Bun.write(pkgjson.name!, JSON.stringify(parsed, null, 2));
-    return mod;
+        details: lastError?.message ?? 'Installation failed after all retries',
+      },
+      { cause: lastError }
+    );
   }
 }

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

@@ -73,32 +73,71 @@ 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) {
+/**
+ * Output JSON status message to stderr
+ * This prevents the status message from interfering with JSON output parsing
+ * @param {object} status - Status object to output
+ */
+function outputStatus(status) {
+  console.error(JSON.stringify(status));
+}
+
+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()
 
@@ -207,21 +246,6 @@ async function runAgentMode(argv) {
 
   // Logging is already initialized in middleware, no need to call Log.init() again
 
-  // Read input from stdin
-  const input = await readStdin();
-  const trimmedInput = input.trim();
-
-  // 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,
-    };
-  }
-
   // Wrap in Instance.provide for OpenCode infrastructure
   await Instance.provide({
     directory: process.cwd(),
@@ -533,7 +557,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 +617,34 @@ 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,
+      })
       // Initialize logging early for all CLI commands
       // This prevents debug output from appearing in CLI unless --verbose is used
       .middleware(async (argv) => {
@@ -641,15 +693,100 @@ 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);
+      // 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);
     }
   } catch (error) {
     hasError = true;

package/src/provider/provider.ts

@@ -905,6 +905,10 @@ export namespace Provider {
     if (opencodeProvider) {
       const [model] = sort(Object.values(opencodeProvider.info.models));
       if (model) {
+        log.info('using opencode provider as default', {
+          provider: opencodeProvider.info.id,
+          model: model.id,
+        });
         return {
           providerID: opencodeProvider.info.id,
           modelID: model.id,
@@ -912,7 +916,7 @@ export namespace Provider {
       }
     }
 
-    // Fall back to any available provider
+    // Fall back to any available provider if opencode is not available
     const provider = providers.find(
       (p) => !cfg.provider || Object.keys(cfg.provider).includes(p.info.id)
     );

package/src/session/prompt.ts

@@ -290,10 +290,27 @@ export namespace SessionPrompt {
           history: msgs,
         });
 
-      const model = await Provider.getModel(
-        lastUser.model.providerID,
-        lastUser.model.modelID
-      );
+      let model;
+      try {
+        model = await Provider.getModel(
+          lastUser.model.providerID,
+          lastUser.model.modelID
+        );
+      } catch (error) {
+        log.warn(
+          'Failed to initialize specified model, falling back to default model',
+          {
+            providerID: lastUser.model.providerID,
+            modelID: lastUser.model.modelID,
+            error: error instanceof Error ? error.message : String(error),
+          }
+        );
+        const defaultModel = await Provider.defaultModel();
+        model = await Provider.getModel(
+          defaultModel.providerID,
+          defaultModel.modelID
+        );
+      }
       const task = tasks.pop();
 
       // pending subtask