@link-assistant/agent 0.22.10 → 0.24.0

package/README.md

@@ -293,6 +293,18 @@ Options:
   --append-system-message        Append to the default system message
   --append-system-message-file   Append to the default system message from file
 
+Permission Options:
+  --read-only                    Enforceable read-only / planning mode.
+                                 Disables all filesystem-mutating and shell
+                                 tools (bash, edit, write, multiedit, patch)
+                                 so the agent can only read, search and plan.
+                                 Env: LINK_ASSISTANT_AGENT_READ_ONLY=true
+  --disable-tools <list>         Comma-separated list of tool ids to disable
+                                 (e.g. "bash,write,edit"). Disabled tools are
+                                 never exposed to the model and are rejected if
+                                 invoked via batch.
+                                 Env: LINK_ASSISTANT_AGENT_DISABLE_TOOLS
+
 Stdin Mode Options:
   -p, --prompt                   Direct prompt (bypasses stdin reading)
   --disable-stdin                Disable stdin streaming (requires --prompt)

package/package.json

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

package/src/cli/continuous-mode.js

@@ -8,8 +8,9 @@ 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 { createEventHandler, serializeOutput } from '../json-standard/index.ts';
 import { createContinuousStdinReader } from './input-queue.js';
+import { Permission } from '../permission/index.ts';
 import { Log } from '../util/log.ts';
 import { config } from '../config/config.ts';
 import { createVerboseFetch } from '../util/verbose-fetch.ts';
@@ -40,6 +41,64 @@ export function getHasError() {
 // Logger for resume operations
 const log = Log.create({ service: 'resume' });
 
+function getInputFormat(argv) {
+  return argv['input-format'] || argv.inputFormat || 'text';
+}
+
+function outputConsumedInput({
+  message,
+  jsonStandard,
+  sessionID,
+  compactJson,
+}) {
+  const raw = message.raw || message.message || message.system || '';
+  if (
+    jsonStandard === 'claude' &&
+    message.kind === 'message' &&
+    message.format === 'stream-json'
+  ) {
+    process.stdout.write(
+      serializeOutput(
+        {
+          type: 'message',
+          timestamp: new Date().toISOString(),
+          session_id: sessionID,
+          role: 'user',
+          content: [{ type: 'text', text: message.message ?? '' }],
+        },
+        'claude'
+      )
+    );
+    return;
+  }
+
+  if (jsonStandard === 'claude') {
+    return;
+  }
+
+  outputInput(
+    {
+      raw,
+      parsed: message.parsed || message,
+      format: message.format || 'text',
+      kind: message.kind || 'message',
+    },
+    compactJson
+  );
+}
+
+function outputInputParseError(error, line, compactJson) {
+  hasError = true;
+  outputError(
+    {
+      errorType: 'ValidationError',
+      message: error instanceof Error ? error.message : String(error),
+      raw: line,
+    },
+    compactJson
+  );
+}
+
 /**
  * Resolve the session to use based on --resume, --continue, and --no-fork options.
  * Returns the session ID to use, handling forking as needed.
@@ -200,8 +259,12 @@ export async function runContinuousServerMode(
 ) {
   // Check both CLI flag and environment variable for compact JSON mode
   const compactJson = argv['compact-json'] === true || config.compactJson;
+  const inputFormat = getInputFormat(argv);
   const isInteractive = argv.interactive !== false;
-  const autoMerge = argv['auto-merge-queued-messages'] !== false;
+  const autoMerge =
+    inputFormat === 'stream-json'
+      ? false
+      : argv['auto-merge-queued-messages'] !== false;
 
   // Start server like OpenCode does
   const server = Server.listen({ port: 0, hostname: '127.0.0.1' });
@@ -244,9 +307,36 @@ export async function runContinuousServerMode(
     // Track if we're currently processing a message
     let isProcessing = false;
     const pendingMessages = [];
+    let currentSystemMessage = systemMessage;
+    const currentAppendSystemMessage = appendSystemMessage;
 
     // Process messages from the queue
     const processMessage = async (message) => {
+      if (message.kind === 'interrupt') {
+        SessionPrompt.cancel(sessionID);
+        outputConsumedInput({ message, jsonStandard, sessionID, compactJson });
+        return;
+      }
+
+      if (message.kind === 'system') {
+        currentSystemMessage = message.system;
+        outputConsumedInput({ message, jsonStandard, sessionID, compactJson });
+        return;
+      }
+
+      // Permission approval reply (issue #271). Resolve a pending tool
+      // permission request without interrupting the in-flight turn — this must
+      // bypass the `isProcessing` queue, since the turn is blocked waiting for it.
+      if (message.kind === 'permission_response') {
+        Permission.respond({
+          sessionID,
+          permissionID: message.permissionID,
+          response: message.response,
+        });
+        outputConsumedInput({ message, jsonStandard, sessionID, compactJson });
+        return;
+      }
+
       if (isProcessing) {
         pendingMessages.push(message);
         return;
@@ -255,16 +345,9 @@ export async function runContinuousServerMode(
       isProcessing = true;
 
       // Output input confirmation in JSON format
-      outputInput(
-        {
-          raw: message.raw || message.message,
-          parsed: message,
-          format: message.format || 'text',
-        },
-        compactJson
-      );
+      outputConsumedInput({ message, jsonStandard, sessionID, compactJson });
 
-      const messageText = message.message || 'hi';
+      const messageText = message.message ?? 'hi';
       const parts = [{ type: 'text', text: messageText }];
 
       // Create a promise to wait for this message to complete
@@ -290,8 +373,8 @@ export async function runContinuousServerMode(
             parts,
             model: { providerID, modelID },
             compactionModel,
-            system: systemMessage,
-            appendSystem: appendSystemMessage,
+            system: currentSystemMessage,
+            appendSystem: currentAppendSystemMessage,
             temperature,
           }),
         }
@@ -377,11 +460,15 @@ export async function runContinuousServerMode(
 
     // Create continuous stdin reader
     stdinReader = createContinuousStdinReader({
-      interactive: isInteractive,
+      interactive: inputFormat === 'stream-json' ? false : isInteractive,
       autoMerge,
+      inputFormat,
       onMessage: (message) => {
         processMessage(message);
       },
+      onError: (error, line) => {
+        outputInputParseError(error, line, compactJson);
+      },
     });
 
     // Wait for stdin to end (EOF or close)
@@ -454,8 +541,12 @@ export async function runContinuousDirectMode(
 ) {
   // Check both CLI flag and environment variable for compact JSON mode
   const compactJson = argv['compact-json'] === true || config.compactJson;
+  const inputFormat = getInputFormat(argv);
   const isInteractive = argv.interactive !== false;
-  const autoMerge = argv['auto-merge-queued-messages'] !== false;
+  const autoMerge =
+    inputFormat === 'stream-json'
+      ? false
+      : argv['auto-merge-queued-messages'] !== false;
 
   let unsub = null;
   let stdinReader = null;
@@ -483,9 +574,36 @@ export async function runContinuousDirectMode(
     // Track if we're currently processing a message
     let isProcessing = false;
     const pendingMessages = [];
+    let currentSystemMessage = systemMessage;
+    const currentAppendSystemMessage = appendSystemMessage;
 
     // Process messages from the queue
     const processMessage = async (message) => {
+      if (message.kind === 'interrupt') {
+        SessionPrompt.cancel(sessionID);
+        outputConsumedInput({ message, jsonStandard, sessionID, compactJson });
+        return;
+      }
+
+      if (message.kind === 'system') {
+        currentSystemMessage = message.system;
+        outputConsumedInput({ message, jsonStandard, sessionID, compactJson });
+        return;
+      }
+
+      // Permission approval reply (issue #271). Resolve a pending tool
+      // permission request without interrupting the in-flight turn — this must
+      // bypass the `isProcessing` queue, since the turn is blocked waiting for it.
+      if (message.kind === 'permission_response') {
+        Permission.respond({
+          sessionID,
+          permissionID: message.permissionID,
+          response: message.response,
+        });
+        outputConsumedInput({ message, jsonStandard, sessionID, compactJson });
+        return;
+      }
+
       if (isProcessing) {
         pendingMessages.push(message);
         return;
@@ -494,16 +612,9 @@ export async function runContinuousDirectMode(
       isProcessing = true;
 
       // Output input confirmation in JSON format
-      outputInput(
-        {
-          raw: message.raw || message.message,
-          parsed: message,
-          format: message.format || 'text',
-        },
-        compactJson
-      );
+      outputConsumedInput({ message, jsonStandard, sessionID, compactJson });
 
-      const messageText = message.message || 'hi';
+      const messageText = message.message ?? 'hi';
       const parts = [{ type: 'text', text: messageText }];
 
       // Create a promise to wait for this message to complete
@@ -525,8 +636,8 @@ export async function runContinuousDirectMode(
         parts,
         model: { providerID, modelID },
         compactionModel,
-        system: systemMessage,
-        appendSystem: appendSystemMessage,
+        system: currentSystemMessage,
+        appendSystem: currentAppendSystemMessage,
         temperature,
       }).catch((error) => {
         hasError = true;
@@ -610,11 +721,15 @@ export async function runContinuousDirectMode(
 
     // Create continuous stdin reader
     stdinReader = createContinuousStdinReader({
-      interactive: isInteractive,
+      interactive: inputFormat === 'stream-json' ? false : isInteractive,
       autoMerge,
+      inputFormat,
       onMessage: (message) => {
         processMessage(message);
       },
+      onError: (error, line) => {
+        outputInputParseError(error, line, compactJson);
+      },
     });
 
     // Wait for stdin to end (EOF or close)

package/src/cli/event-handler.js

@@ -81,6 +81,27 @@ export function createBusEventSubscription({
       }
     }
 
+    // Emit a JSON permission request when a tool needs approval (issue #271).
+    // The consumer replies with a `permission_response` frame over stdin which
+    // is routed to Permission.respond. No TUI is involved.
+    if (event.type === 'permission.updated') {
+      const permission = event.properties;
+      if (permission.sessionID !== sessionID) {
+        return;
+      }
+      eventHandler.output({
+        type: 'permission_request',
+        timestamp: Date.now(),
+        sessionID,
+        permissionID: permission.id,
+        callID: permission.callID,
+        tool: permission.type,
+        pattern: permission.pattern,
+        title: permission.title,
+        metadata: permission.metadata,
+      });
+    }
+
     // Handle session idle to know when to stop
     if (
       event.type === 'session.idle' &&

package/src/cli/input-queue.js

@@ -5,11 +5,13 @@
 export class InputQueue {
   constructor(options = {}) {
     this.queue = [];
+    this.inputFormat = options.inputFormat || 'text';
     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.onError = options.onError || (() => {});
     this.interactive = options.interactive !== false; // enabled by default
   }
 
@@ -24,18 +26,51 @@ export class InputQueue {
       return null;
     }
 
+    if (this.inputFormat === 'stream-json') {
+      return parseStreamJsonInput(trimmed);
+    }
+
+    let parsed;
     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) };
+      parsed = JSON.parse(trimmed);
     } catch (_e) {
       // Not JSON, treat as plain text message
       return { message: trimmed };
     }
+
+    // If it has a message field, use it directly
+    if (typeof parsed === 'object' && parsed !== null) {
+      // Permission approval reply (issue #271) — normalize to a `kind` frame
+      // so it is routed to Permission.respond, mirroring stream-json mode.
+      if (parsed.type === 'permission_response') {
+        const permissionID = parsed.permissionID ?? parsed.permission_id;
+        const response = parsed.response;
+        if (typeof permissionID !== 'string' || !permissionID) {
+          throw new Error(
+            'Invalid permission_response: expected string "permissionID"'
+          );
+        }
+        if (
+          response !== 'once' &&
+          response !== 'always' &&
+          response !== 'reject'
+        ) {
+          throw new Error(
+            'Invalid permission_response: "response" must be "once", "always" or "reject"'
+          );
+        }
+        return {
+          kind: 'permission_response',
+          permissionID,
+          response,
+          raw: trimmed,
+          parsed,
+        };
+      }
+      return parsed;
+    }
+    // Otherwise wrap it
+    return { message: JSON.stringify(parsed) };
   }
 
   /**
@@ -43,6 +78,11 @@ export class InputQueue {
    * @param {string} line - Input line
    */
   addLine(line) {
+    if (this.inputFormat === 'stream-json') {
+      this.queueLine(line);
+      return;
+    }
+
     if (!this.interactive && !line.trim().startsWith('{')) {
       // In non-interactive mode, only accept JSON
       return;
@@ -54,11 +94,7 @@ export class InputQueue {
       this.scheduleMerge();
     } else {
       // No merging, queue immediately
-      const parsed = this.parseInput(line);
-      if (parsed) {
-        this.queue.push(parsed);
-        this.notifyMessage(parsed);
-      }
+      this.queueLine(line);
     }
   }
 
@@ -130,6 +166,33 @@ export class InputQueue {
     }
   }
 
+  /**
+   * Notify listener of an input parse error
+   * @param {Error} error - Parse error
+   * @param {string} line - Raw input line
+   */
+  notifyError(error, line) {
+    if (this.onError) {
+      this.onError(error, line);
+    }
+  }
+
+  /**
+   * Parse and enqueue one complete input line
+   * @param {string} line - Raw input line
+   */
+  queueLine(line) {
+    try {
+      const parsed = this.parseInput(line);
+      if (parsed) {
+        this.queue.push(parsed);
+        this.notifyMessage(parsed);
+      }
+    } catch (error) {
+      this.notifyError(error, line);
+    }
+  }
+
   /**
    * Get queue size
    * @returns {number}
@@ -139,6 +202,163 @@ export class InputQueue {
   }
 }
 
+function extractContentText(content) {
+  if (typeof content === 'string') {
+    return content;
+  }
+
+  if (Array.isArray(content)) {
+    const parts = [];
+    for (const part of content) {
+      if (typeof part === 'string') {
+        parts.push(part);
+      } else if (part && typeof part === 'object') {
+        if (typeof part.text === 'string') {
+          parts.push(part.text);
+        } else if (typeof part.content === 'string') {
+          parts.push(part.content);
+        }
+      }
+    }
+    return parts.length > 0 ? parts.join('\n') : null;
+  }
+
+  if (content && typeof content === 'object') {
+    if (typeof content.text === 'string') {
+      return content.text;
+    }
+    if ('content' in content) {
+      return extractContentText(content.content);
+    }
+  }
+
+  return null;
+}
+
+function extractFrameText(frame) {
+  if (typeof frame.message === 'string') {
+    return frame.message;
+  }
+
+  if (frame.message && typeof frame.message === 'object') {
+    const messageText = extractContentText(frame.message.content);
+    if (messageText !== null) {
+      return messageText;
+    }
+    if (typeof frame.message.text === 'string') {
+      return frame.message.text;
+    }
+  }
+
+  const contentText = extractContentText(frame.content);
+  if (contentText !== null) {
+    return contentText;
+  }
+
+  if (typeof frame.text === 'string') {
+    return frame.text;
+  }
+
+  return null;
+}
+
+/**
+ * Parse one Claude-compatible stream-json input frame.
+ * @param {string} input - One JSONL frame
+ * @returns {object} Normalized queue message
+ */
+export function parseStreamJsonInput(input) {
+  let frame;
+  try {
+    frame = JSON.parse(input);
+  } catch (error) {
+    throw new Error(
+      `Invalid stream-json input frame: ${
+        error instanceof Error ? error.message : String(error)
+      }`
+    );
+  }
+
+  if (!frame || typeof frame !== 'object' || Array.isArray(frame)) {
+    throw new Error('Invalid stream-json input frame: expected JSON object');
+  }
+
+  const type = frame.type;
+
+  if (type === 'interrupt') {
+    return {
+      kind: 'interrupt',
+      raw: input,
+      parsed: frame,
+      format: 'stream-json',
+      inputType: type,
+    };
+  }
+
+  if (type === 'system') {
+    const system = extractFrameText(frame);
+    if (system === null) {
+      throw new Error(
+        'Invalid stream-json system frame: expected content text'
+      );
+    }
+    return {
+      kind: 'system',
+      system,
+      raw: input,
+      parsed: frame,
+      format: 'stream-json',
+      inputType: type,
+    };
+  }
+
+  // Permission approval reply (issue #271). Resolves a pending
+  // `permission_request` emitted by the agent. `response` is one of
+  // `once` | `always` | `reject`.
+  if (type === 'permission_response') {
+    const permissionID = frame.permissionID ?? frame.permission_id;
+    const response = frame.response;
+    if (typeof permissionID !== 'string' || !permissionID) {
+      throw new Error(
+        'Invalid permission_response frame: expected string "permissionID"'
+      );
+    }
+    if (response !== 'once' && response !== 'always' && response !== 'reject') {
+      throw new Error(
+        'Invalid permission_response frame: "response" must be "once", "always" or "reject"'
+      );
+    }
+    return {
+      kind: 'permission_response',
+      permissionID,
+      response,
+      raw: input,
+      parsed: frame,
+      format: 'stream-json',
+      inputType: type,
+    };
+  }
+
+  if (type === 'user' || type === 'user_prompt' || type === undefined) {
+    const message = extractFrameText(frame);
+    if (message === null) {
+      throw new Error(
+        'Invalid stream-json user frame: expected message content text'
+      );
+    }
+    return {
+      kind: 'message',
+      message,
+      raw: input,
+      parsed: frame,
+      format: 'stream-json',
+      inputType: type || 'message',
+    };
+  }
+
+  throw new Error(`Unsupported stream-json input frame type: ${String(type)}`);
+}
+
 /**
  * Create a continuous stdin reader that queues input lines
  * @param {object} options - Options for the reader

package/src/cli/output.ts

@@ -232,7 +232,7 @@ export function outputInput(
   input: {
     raw: string;
     parsed?: unknown;
-    format?: 'json' | 'text';
+    format?: 'json' | 'text' | 'stream-json';
     [key: string]: unknown;
   },
   compact?: boolean

package/src/cli/run-options.js

@@ -29,6 +29,19 @@ export function buildRunOptions(yargs, defaultOptions = {}) {
       default: 'opencode',
       choices: ['opencode', 'claude'],
     })
+    .option('output-format', {
+      type: 'string',
+      description:
+        'Claude-compatible output format alias: "json" (OpenCode JSON) or "stream-json" (Claude NDJSON)',
+      choices: ['json', 'stream-json'],
+    })
+    .option('input-format', {
+      type: 'string',
+      description:
+        'Input format: "text" (default) or Claude-compatible "stream-json" JSONL frames',
+      default: 'text',
+      choices: ['text', 'stream-json'],
+    })
     .option('system-message', {
       type: 'string',
       description: 'Full override of the system message',
@@ -135,6 +148,13 @@ export function buildRunOptions(yargs, defaultOptions = {}) {
             argv['no-fork'] = true;
             argv.noFork = true;
           }
+          if (argv.outputFormat === 'stream-json') {
+            argv['json-standard'] = 'claude';
+            argv.jsonStandard = 'claude';
+          } else if (argv.outputFormat === 'json') {
+            argv['json-standard'] = 'opencode';
+            argv.jsonStandard = 'opencode';
+          }
         }, true)
       : parser;
 
@@ -191,5 +211,28 @@ export function buildRunOptions(yargs, defaultOptions = {}) {
       type: 'number',
       description:
         'Override the temperature for model completions. When not set, the default per-model temperature is used.',
+    })
+    .option('read-only', {
+      type: 'boolean',
+      description:
+        'Enforceable read-only / planning mode. Disables all filesystem-mutating and shell tools (bash, edit, write, multiedit, patch) so the agent can only read, search and plan. Maps to agent-commander --read-only.',
+      default: false,
+    })
+    .option('disable-tools', {
+      type: 'string',
+      description:
+        'Comma-separated list of tool ids to disable (e.g. "bash,write,edit"). Disabled tools are never exposed to the model and are rejected if invoked via batch.',
+    })
+    .option('permission-mode', {
+      type: 'string',
+      choices: ['auto', 'plan', 'readonly', 'ask'],
+      description:
+        'Permission policy for mutating tools. "auto" (default) allows everything; "plan" allows read-only shell and asks before mutations; "readonly" denies all mutations; "ask" asks before every mutating tool. Approvals are driven over JSON (permission_request / permission_response).',
+      default: 'auto',
+    })
+    .option('permission', {
+      type: 'string',
+      description:
+        'OpenCode-compatible permission override as JSON, merged on top of --permission-mode. Example: \'{"edit":"ask","bash":{"git push*":"ask","*":"allow"},"webfetch":"allow"}\'.',
     });
 }