@openagents-org/agent-launcher 0.2.142 → 0.2.145

package/src/adapters/codex.js

@@ -19,6 +19,7 @@ const { execSync, spawn } = require('child_process');
 const http = require('http');
 const https = require('https');
 
+const { whereBinary } = require('../paths');
 const BaseAdapter = require('./base');
 const { buildOpenclawSystemPrompt } = require('./workspace-prompt');
 
@@ -49,7 +50,8 @@ class CodexAdapter extends BaseAdapter {
     this._loadSessions();
 
     // Determine mode:
-    // - CLI mode: only works with OpenAI's native Responses API (api.openai.com)
+    // - CLI mode: works with OpenAI's native Responses API (api.openai.com)
+    //   OR with subscription-based auth via 'codex login'
     // - Direct API mode: works with any OpenAI-compatible chat completions endpoint
     this._codexBin = this._findCodexBinary();
     this._directMode = false;
@@ -59,9 +61,10 @@ class CodexAdapter extends BaseAdapter {
     const isOpenAiNative = !this._directBaseUrl ||
       this._directBaseUrl.includes('api.openai.com');
 
-    if (this._codexBin && isOpenAiNative) {
+    if (this._codexBin && (isOpenAiNative || !this._directApiKey)) {
+      // CLI mode: either OpenAI native API or subscription auth (no API key)
       this._useCliMode = true;
-      this._log(`CLI mode: ${this._codexBin}`);
+      this._log(`CLI mode: ${this._codexBin}${!this._directApiKey ? ' (subscription auth)' : ''}`);
     } else if (this._directApiKey && this._directBaseUrl) {
       this._directMode = true;
       if (this._codexBin) {
@@ -70,7 +73,7 @@ class CodexAdapter extends BaseAdapter {
         this._log(`Direct LLM mode: ${this._directBaseUrl} model=${this._directModel || 'gpt-4o'}`);
       }
     } else if (this._codexBin) {
-      // CLI binary found, no custom base URL — assume OpenAI
+      // CLI binary found, no custom base URL — assume OpenAI or subscription auth
       this._useCliMode = true;
       this._log(`CLI mode: ${this._codexBin}`);
     } else {
@@ -123,17 +126,12 @@ class CodexAdapter extends BaseAdapter {
     const portableCandidate = path.join(home, '.openagents', 'nodejs', 'node_modules', '.bin', `codex${ext}`);
     if (fs.existsSync(portableCandidate)) return portableCandidate;
 
-    // Tier 1: PATH search
-    try {
-      if (IS_WINDOWS) {
-        const r = execSync('where codex.cmd 2>nul || where codex.exe 2>nul || where codex 2>nul', {
-          encoding: 'utf-8', timeout: 5000,
-        });
-        return r.split(/\r?\n/)[0].trim();
-      } else {
-        return execSync('which codex', { encoding: 'utf-8', timeout: 5000 }).trim();
-      }
-    } catch {}
+    // Tier 1: PATH search via a codepage-safe lookup (whereBinary forces UTF-8
+    // output + verifies existence so a non-ASCII/Chinese username isn't mangled
+    // into an ENOENT; it also no longer returns an empty string on a miss, which
+    // used to short-circuit the Node-derived fallback tiers below).
+    const viaWhere = whereBinary('codex');
+    if (viaWhere) return viaWhere;
 
     // Tier 2: Next to current Node.js interpreter (npm global)
     const nodeBinDir = path.dirname(process.execPath);
@@ -270,7 +268,7 @@ class CodexAdapter extends BaseAdapter {
     } else if (this._directMode) {
       await this._handleViaDirectApi(content, msgChannel);
     } else {
-      await this.sendError(msgChannel, 'codex CLI not found. Install with: npm install -g @openai/codex');
+      await this.sendError(msgChannel, 'codex CLI not found. Install with: npm install -g @openai/codex\n\nOr configure OPENAI_API_KEY + OPENAI_BASE_URL for direct API mode.');
     }
   }
 

package/src/adapters/copilot-stream-parser.js

@@ -0,0 +1,380 @@
+/**
+ * GitHub Copilot CLI — JSONL stream parser (pure, no I/O).
+ *
+ * This module turns the raw byte stream produced by
+ *   `copilot -p "<prompt>" --output-format=json`
+ * into a sequence of *normalized* events the CopilotAdapter can map onto
+ * OpenAgents workspace messages. It is deliberately split into two layers:
+ *
+ *   1. FRAMING (schema-agnostic) — `frameChunk()` / `CopilotStreamParser`
+ *      Reassembles complete text lines from arbitrary chunk boundaries. This
+ *      is the part that is fully specified regardless of the CLI version:
+ *      one JSON object per line (JSONL), lines may be split across chunks,
+ *      a single chunk may carry many lines, line endings may be `\n` or
+ *      `\r\n`, blank lines and non-JSON noise must be tolerated. This layer
+ *      is exhaustively unit-tested and does not depend on any field names.
+ *
+ *   2. CLASSIFICATION (schema-aware) — `classifyEvent()`
+ *      Maps one parsed JSON object onto a normalized event `{ kind, ... }`.
+ *      The concrete field/type names live in ONE table (`EVENT_KIND_BY_TYPE`
+ *      + the field extractors) so that, once the JSONL schema of the locally
+ *      installed `@github/copilot` build is captured, only this table needs
+ *      to change — the adapter and the framing layer stay untouched.
+ *
+ * ── Schema status ────────────────────────────────────────────────────────
+ * The GitHub Copilot CLI (`@github/copilot`, executable `copilot`) ships its
+ * structured output as JSONL via `--output-format=json`. The exact `type`
+ * strings and payload shapes evolve between releases and MUST be confirmed
+ * against the actually-installed build (see docs/agents/github-copilot-cli.md
+ * and the delivery report). Until then the mapping below recognizes the
+ * documented/observed families and ALWAYS degrades unknown objects to a
+ * redacted `unknown` event instead of throwing — so a schema drift downgrades
+ * fidelity, never crashes a task. Never infer an event's meaning from a field
+ * name alone; verify against real output or the official source.
+ *
+ * Normalized event kinds (the adapter's stable contract):
+ *   { kind: 'session',     sessionId }                  real CLI session id/name
+ *   { kind: 'text_delta',  text }                       streaming assistant text
+ *   { kind: 'text',        text }                       final/complete assistant text
+ *   { kind: 'reasoning',   text }                       thinking / status narration
+ *   { kind: 'tool_start',  tool, input }               a tool/command is starting
+ *   { kind: 'tool_result', tool, result, isError }     a tool/command finished
+ *   { kind: 'file_change', path, action }              a file was read/written
+ *   { kind: 'shell',       command, exitCode, output } a shell command ran
+ *   { kind: 'permission',  detail, granted }           a permission decision
+ *   { kind: 'ask_user',    question }                   CLI wants interactive input
+ *   { kind: 'usage',       model, usage }              model / token accounting
+ *   { kind: 'done',        status }                     turn completed (terminal)
+ *   { kind: 'error',       message, code }              failure (terminal)
+ *   { kind: 'unknown',     raw }                        unrecognized (redacted)
+ */
+
+'use strict';
+
+// ────────────────────────────────────────────────────────────────────────
+// Redaction (shared by the adapter for logs + unknown-event diagnostics)
+// ────────────────────────────────────────────────────────────────────────
+
+// GitHub tokens: ghp_/gho_/ghu_/ghs_/ghr_ (classic + fine-grained github_pat_),
+// plus generic bearer/secret shapes. Kept conservative to avoid mangling code.
+const TOKEN_PATTERNS = [
+  /\bgh[pousr]_[A-Za-z0-9]{20,}\b/g,
+  /\bgithub_pat_[A-Za-z0-9_]{20,}\b/g,
+  /\b(?:sk|pk|rk)-[A-Za-z0-9_-]{16,}\b/g,
+  /\bBearer\s+[A-Za-z0-9._-]{16,}\b/gi,
+  /\b[A-Fa-f0-9]{40,}\b/g, // long hex blobs (OAuth/refresh tokens)
+];
+
+// Env-style assignments of well-known secret-bearing variables — redact the
+// value, keep the key so logs still say *which* var was involved.
+const SECRET_ENV_KEYS = [
+  'COPILOT_GITHUB_TOKEN', 'GH_TOKEN', 'GITHUB_TOKEN', 'GH_COPILOT_TOKEN',
+  'GITHUB_COPILOT_TOKEN', 'OPENAI_API_KEY', 'ANTHROPIC_API_KEY',
+  'AZURE_API_KEY', 'GOOGLE_API_KEY', 'OA_WORKSPACE_TOKEN',
+];
+const SECRET_ENV_RE = new RegExp(
+  `\\b(${SECRET_ENV_KEYS.join('|')})(\\s*[=:]\\s*)("?)([^\\s"']+)`,
+  'gi',
+);
+const AUTH_HEADER_RE = /\b(authorization|x-api-key|x-github-token)(\s*:\s*)(\S+)/gi;
+
+/**
+ * Redact secrets from an arbitrary string for safe logging / diagnostics.
+ * Never throws; non-strings are coerced. Pure.
+ */
+function redactSensitive(value) {
+  let s;
+  if (typeof value === 'string') s = value;
+  else { try { s = JSON.stringify(value); } catch { s = String(value); } }
+  if (!s) return s;
+  s = s.replace(SECRET_ENV_RE, (_m, k, sep, q) => `${k}${sep}${q}***`);
+  s = s.replace(AUTH_HEADER_RE, (_m, k, sep) => `${k}${sep}***`);
+  for (const re of TOKEN_PATTERNS) s = s.replace(re, '***');
+  return s;
+}
+
+/**
+ * Produce a short, redacted, single-line diagnostic for an unknown event so a
+ * schema drift is observable in logs without dumping a full transcript or any
+ * secret. Pure.
+ */
+function diagnosticForUnknown(obj, maxLen = 300) {
+  let s;
+  try { s = JSON.stringify(obj); } catch { s = String(obj); }
+  s = redactSensitive(s).replace(/\s+/g, ' ').trim();
+  return s.length > maxLen ? s.slice(0, maxLen) + '…' : s;
+}
+
+// ────────────────────────────────────────────────────────────────────────
+// Framing (schema-agnostic) — pure
+// ────────────────────────────────────────────────────────────────────────
+
+/**
+ * Append `chunk` to `buffer` and split off every complete line.
+ * Returns `{ lines, rest }` where `lines` are complete lines (no trailing
+ * newline, `\r` stripped) and `rest` is the leftover partial line to carry
+ * into the next call. Handles `\n` and `\r\n`. Pure — no state retained.
+ *
+ * @param {string} buffer  carry-over from the previous call
+ * @param {string|Buffer} chunk  new bytes
+ * @returns {{ lines: string[], rest: string }}
+ */
+function frameChunk(buffer, chunk) {
+  const text = (buffer || '') + (chunk == null ? '' : chunk.toString('utf-8'));
+  const parts = text.split('\n');
+  const rest = parts.pop(); // last element is the incomplete tail (maybe '')
+  const lines = parts.map((l) => (l.endsWith('\r') ? l.slice(0, -1) : l));
+  return { lines, rest };
+}
+
+/**
+ * Parse one JSONL line into an object, or null when the line is blank or not
+ * valid JSON (CLIs occasionally interleave human-readable banners/noise). A
+ * single corrupt line must never abort the surrounding task. Pure.
+ *
+ * @param {string} line
+ * @returns {object|null}
+ */
+function parseLine(line) {
+  if (line == null) return null;
+  const trimmed = String(line).trim();
+  if (!trimmed) return null;
+  if (trimmed[0] !== '{' && trimmed[0] !== '[') return null; // fast reject noise
+  try {
+    const v = JSON.parse(trimmed);
+    return (v && typeof v === 'object') ? v : null;
+  } catch {
+    return null;
+  }
+}
+
+// ────────────────────────────────────────────────────────────────────────
+// Classification (schema-aware) — pure. SINGLE source of field/type mapping.
+// ────────────────────────────────────────────────────────────────────────
+
+/**
+ * Maps a Copilot CLI event `type` (lowercased) to a normalized kind.
+ *
+ * ── Verification status (IMPORTANT) ──────────────────────────────────────
+ * VERIFIED against real CLI v1.0.63: `--output-format json` is "JSONL, one JSON
+ * object per line"; auth/session/network failures print to STDERR with EMPTY
+ * stdout (no JSONL error event) — so those are NOT parsed here, the adapter
+ * classifies them from stderr. The success-path stdout event names below
+ * (text/tool/file/done/etc.) could NOT be captured (no Copilot subscription in
+ * CI), so they are BEST-EFFORT, intentionally focused rather than broad, and
+ * must be confirmed against a real authenticated run. The deliberately small
+ * alias set avoids misclassifying unrelated objects; anything unrecognized
+ * degrades to a redacted `unknown` event (never a crash, never a false `done`).
+ * When real samples are available, extend THIS table only.
+ */
+const EVENT_KIND_BY_TYPE = {
+  // session lifecycle / identity (kind only mapped when an id is also present)
+  session: 'session', 'session.created': 'session', 'session.started': 'session',
+  session_started: 'session', thread: 'session', 'thread.started': 'session',
+  // streaming assistant text (qualified names only — no bare 'delta'/'token')
+  'text.delta': 'text_delta', text_delta: 'text_delta',
+  'message.delta': 'text_delta', 'assistant.delta': 'text_delta',
+  content_block_delta: 'text_delta',
+  // final assistant text (qualified/explicit names only — no bare 'message')
+  text: 'text', 'message.completed': 'text', 'assistant.message': 'text',
+  assistant: 'text', completion: 'text', agent_message: 'text',
+  // reasoning / status narration
+  reasoning: 'reasoning', thinking: 'reasoning', thought: 'reasoning',
+  status: 'reasoning', progress: 'reasoning',
+  // tool calls
+  tool_call: 'tool_start', 'tool.call': 'tool_start', tool_use: 'tool_start',
+  'tool.started': 'tool_start', tool_start: 'tool_start', function_call: 'tool_start',
+  tool_result: 'tool_result', 'tool.result': 'tool_result',
+  'tool.completed': 'tool_result', tool_output: 'tool_result',
+  function_result: 'tool_result',
+  // file + shell specializations (may also arrive as generic tool events)
+  file_change: 'file_change', file_edit: 'file_change', 'file.changed': 'file_change',
+  file_write: 'file_change', file_read: 'file_change',
+  shell: 'shell', command_execution: 'shell', 'shell.exec': 'shell',
+  // permissions + interactive prompts
+  permission: 'permission', 'permission.request': 'permission',
+  permission_request: 'permission', permission_denied: 'permission',
+  approval: 'permission',
+  ask_user: 'ask_user', 'user.prompt': 'ask_user', input_request: 'ask_user',
+  // accounting (explicit only — bare 'model'/'tokens' are too generic)
+  usage: 'usage',
+  // terminal (no bare 'end'/'result' — 'result' collides with tool results)
+  done: 'done', completed: 'done', 'turn.completed': 'done', finish: 'done',
+  error: 'error', failure: 'error', 'turn.failed': 'error', failed: 'error',
+  fatal: 'error', aborted: 'error',
+};
+
+function _firstString(obj, keys) {
+  for (const k of keys) {
+    const v = obj[k];
+    if (typeof v === 'string' && v.length) return v;
+  }
+  return undefined;
+}
+
+function _coerceText(v) {
+  if (typeof v === 'string') return v;
+  if (v && typeof v === 'object') {
+    if (typeof v.text === 'string') return v.text;
+    if (Array.isArray(v.content)) {
+      return v.content
+        .map((b) => (typeof b === 'string' ? b : (b && typeof b.text === 'string' ? b.text : '')))
+        .join('');
+    }
+    if (typeof v.content === 'string') return v.content;
+  }
+  return undefined;
+}
+
+/**
+ * Classify a parsed JSON object into a normalized event. Never throws; an
+ * unrecognized shape becomes `{ kind: 'unknown', raw }` with a redacted
+ * diagnostic. Pure — the single place that knows Copilot field names.
+ *
+ * @param {object} obj
+ * @returns {{kind: string} & object}
+ */
+function classifyEvent(obj) {
+  if (!obj || typeof obj !== 'object') {
+    return { kind: 'unknown', raw: diagnosticForUnknown(obj) };
+  }
+
+  const rawType = _firstString(obj, ['type', 'event', 'event_type', 'kind', 'name']);
+  let kind = rawType ? EVENT_KIND_BY_TYPE[rawType.toLowerCase()] : undefined;
+
+  // Nested item types: some CLIs wrap the real type in `item.type`
+  // (e.g. { type: 'item.completed', item: { type: 'command_execution' } }).
+  const item = (obj.item && typeof obj.item === 'object') ? obj.item : null;
+  if (item) {
+    const itemType = _firstString(item, ['type', 'kind']);
+    const itemKind = itemType ? EVENT_KIND_BY_TYPE[itemType.toLowerCase()] : undefined;
+    if (itemKind) kind = itemKind;
+  }
+  const src = item || obj;
+
+  switch (kind) {
+    case 'session': {
+      const sessionId = _firstString(src, [
+        'session_id', 'sessionId', 'session', 'thread_id', 'threadId', 'id', 'name',
+      ]);
+      if (!sessionId) break; // not actually a session event → fall to unknown
+      return { kind: 'session', sessionId };
+    }
+    case 'text_delta': {
+      const text = _coerceText(src.delta) ?? _coerceText(src.text) ?? _coerceText(src.content) ?? _coerceText(src);
+      return { kind: 'text_delta', text: text || '' };
+    }
+    case 'text': {
+      const text = _coerceText(src.text) ?? _coerceText(src.message) ?? _coerceText(src.content) ?? _coerceText(src);
+      return { kind: 'text', text: text || '' };
+    }
+    case 'reasoning': {
+      const text = _coerceText(src.text) ?? _coerceText(src.reasoning) ?? _coerceText(src.message)
+        ?? _coerceText(src.content) ?? _firstString(src, ['status', 'label', 'title']) ?? '';
+      return { kind: 'reasoning', text };
+    }
+    case 'tool_start': {
+      const tool = _firstString(src, ['tool', 'tool_name', 'name', 'function']) || 'tool';
+      const input = src.input ?? src.arguments ?? src.args ?? src.parameters ?? src.params;
+      return { kind: 'tool_start', tool, input };
+    }
+    case 'tool_result': {
+      const tool = _firstString(src, ['tool', 'tool_name', 'name', 'function']) || 'tool';
+      const result = src.result ?? src.output ?? src.content ?? src.stdout;
+      const isError = !!(src.is_error ?? src.isError ?? src.error ?? (src.exit_code != null && src.exit_code !== 0));
+      return { kind: 'tool_result', tool, result, isError };
+    }
+    case 'file_change': {
+      const filePath = _firstString(src, ['path', 'file', 'file_path', 'filename', 'filePath']);
+      const action = _firstString(src, ['action', 'operation', 'change', 'mode'])
+        || (rawType && /read/i.test(rawType) ? 'read' : 'edit');
+      return { kind: 'file_change', path: filePath || '', action };
+    }
+    case 'shell': {
+      const command = _firstString(src, ['command', 'cmd', 'shell', 'script']) || '';
+      const exitCode = src.exit_code ?? src.exitCode ?? src.code ?? null;
+      const output = _coerceText(src.output) ?? _coerceText(src.stdout) ?? '';
+      return { kind: 'shell', command, exitCode, output };
+    }
+    case 'permission': {
+      const detail = _firstString(src, ['detail', 'message', 'tool', 'resource', 'reason'])
+        || diagnosticForUnknown(src, 120);
+      const granted = !!(src.granted ?? src.allowed ?? src.approved);
+      return { kind: 'permission', detail, granted };
+    }
+    case 'ask_user': {
+      const question = _firstString(src, ['question', 'prompt', 'message', 'text']) || '';
+      return { kind: 'ask_user', question };
+    }
+    case 'usage': {
+      const model = _firstString(src, ['model', 'model_id', 'modelName']);
+      const usage = src.usage ?? src.tokens ?? src.cost ?? null;
+      return { kind: 'usage', model, usage };
+    }
+    case 'done': {
+      const status = _firstString(src, ['status', 'reason', 'result']) || 'completed';
+      return { kind: 'done', status };
+    }
+    case 'error': {
+      const err = (src.error && typeof src.error === 'object') ? src.error : src;
+      const message = _firstString(err, ['message', 'error', 'detail', 'reason'])
+        || (typeof src.error === 'string' ? src.error : '')
+        || 'Copilot CLI reported an error';
+      const code = _firstString(err, ['code', 'type', 'status']) || null;
+      return { kind: 'error', message: redactSensitive(message), code };
+    }
+    default:
+      break;
+  }
+  return { kind: 'unknown', raw: diagnosticForUnknown(obj) };
+}
+
+// ────────────────────────────────────────────────────────────────────────
+// Stateful incremental parser — thin wrapper over the pure functions
+// ────────────────────────────────────────────────────────────────────────
+
+class CopilotStreamParser {
+  constructor() {
+    this._buffer = '';
+  }
+
+  /**
+   * Feed a stdout chunk; returns the normalized events newly completed by it.
+   * Partial trailing data is retained until the next push()/flush().
+   * @param {string|Buffer} chunk
+   * @returns {Array<object>}
+   */
+  push(chunk) {
+    const { lines, rest } = frameChunk(this._buffer, chunk);
+    this._buffer = rest;
+    const events = [];
+    for (const line of lines) {
+      const obj = parseLine(line);
+      if (obj === null) continue; // blank or non-JSON noise — skip, never throw
+      events.push(classifyEvent(obj));
+    }
+    return events;
+  }
+
+  /**
+   * Flush any buffered trailing line (e.g. last line without a newline at
+   * process exit). Returns the normalized events it yields. Idempotent.
+   * @returns {Array<object>}
+   */
+  flush() {
+    const tail = this._buffer;
+    this._buffer = '';
+    const obj = parseLine(tail);
+    return obj === null ? [] : [classifyEvent(obj)];
+  }
+}
+
+module.exports = {
+  CopilotStreamParser,
+  frameChunk,
+  parseLine,
+  classifyEvent,
+  redactSensitive,
+  diagnosticForUnknown,
+  EVENT_KIND_BY_TYPE,
+};