@smartmemory/compose 0.1.0

package/server/connectors/codex-connector.js

@@ -0,0 +1,240 @@
+/**
+ * CodexConnector — spawns the official `codex exec --json` CLI for each prompt.
+ *
+ * Replaces the previous opencode-backed implementation. Uses the OpenAI Codex
+ * CLI (`codex`, installed via `npm i -g @openai/codex` or `brew install codex`)
+ * which streams structured JSONL events to stdout.
+ *
+ * Auth: run `codex login` once (ChatGPT OAuth), or set OPENAI_API_KEY.
+ *
+ * Model IDs use the form `<model>` or `<model>/<effort>` where effort is one
+ * of `minimal|low|medium|high|xhigh`. The effort suffix is split off and
+ * passed as `-c model_reasoning_effort=<effort>`.
+ */
+
+import { spawn } from 'node:child_process';
+import { createInterface } from 'node:readline';
+import { AgentConnector, injectSchema } from './agent-connector.js';
+
+// ---------------------------------------------------------------------------
+// Supported Codex model IDs (model + optional /effort suffix)
+// ---------------------------------------------------------------------------
+
+export const CODEX_MODEL_IDS = new Set([
+  'gpt-5.4',
+  'gpt-5.4/low',
+  'gpt-5.4/medium',
+  'gpt-5.4/high',
+  'gpt-5.4/xhigh',
+  'gpt-5.2-codex',
+  'gpt-5.2-codex/low',
+  'gpt-5.2-codex/medium',
+  'gpt-5.2-codex/high',
+  'gpt-5.2-codex/xhigh',
+  'gpt-5.1-codex-max',
+  'gpt-5.1-codex-max/low',
+  'gpt-5.1-codex-max/medium',
+  'gpt-5.1-codex-max/high',
+  'gpt-5.1-codex-max/xhigh',
+  'gpt-5.1-codex',
+  'gpt-5.1-codex/low',
+  'gpt-5.1-codex/medium',
+  'gpt-5.1-codex/high',
+  'gpt-5.1-codex-mini',
+  'gpt-5.1-codex-mini/medium',
+  'gpt-5.1-codex-mini/high',
+]);
+
+const DEFAULT_MODEL_ID = process.env.CODEX_MODEL || 'gpt-5.4';
+const AGENT_NAME = 'codex';
+
+// ---------------------------------------------------------------------------
+// CodexConnector
+// ---------------------------------------------------------------------------
+
+export class CodexConnector extends AgentConnector {
+  _defaultModelID;
+  _cwd;
+  #proc = null;
+
+  /**
+   * @param {object} [opts]
+   * @param {string} [opts.modelID] — Codex model ID; must be in CODEX_MODEL_IDS
+   * @param {string} [opts.cwd]     — default working directory
+   * @throws {Error} if modelID is not a recognized Codex model
+   */
+  constructor({ modelID = DEFAULT_MODEL_ID, cwd = process.cwd() } = {}) {
+    super();
+    _assertCodexModel(modelID);
+    this._defaultModelID = modelID;
+    this._cwd = cwd;
+  }
+
+  // ── Runtime ────────────────────────────────────────────────────────────────
+
+  async *run(prompt, { schema, modelID, cwd } = {}) {
+    if (this.#proc) {
+      throw new Error(`${AGENT_NAME}: run() already active. Call interrupt() first.`);
+    }
+
+    const resolvedModelID = modelID ?? this._defaultModelID;
+    _assertCodexModel(resolvedModelID);
+    const resolvedCwd = cwd ?? this._cwd;
+    const actualPrompt = schema ? injectSchema(prompt, schema) : prompt;
+
+    const [baseModel, effort] = resolvedModelID.split('/');
+
+    yield {
+      type: 'system', subtype: 'init',
+      agent: AGENT_NAME, model: resolvedModelID,
+    };
+
+    const args = [
+      'exec',
+      '--json',
+      '--skip-git-repo-check',
+      '--sandbox', 'read-only',
+      '-m', baseModel,
+      '-C', resolvedCwd,
+    ];
+    if (effort) {
+      args.push('-c', `model_reasoning_effort="${effort}"`);
+    }
+    args.push('-'); // read prompt from stdin
+
+    const proc = spawn('codex', args, {
+      cwd: resolvedCwd,
+      stdio: ['pipe', 'pipe', 'pipe'],
+      env: process.env,
+    });
+    this.#proc = proc;
+
+    // Write prompt via stdin to avoid argv length and quoting issues
+    proc.stdin.end(actualPrompt);
+
+    const rl = createInterface({ input: proc.stdout, crlfDelay: Infinity });
+    const textParts = [];
+    const stderrChunks = [];
+
+    // Stream stderr — surface auth/rate-limit errors immediately
+    proc.stderr.on('data', chunk => {
+      stderrChunks.push(chunk);
+      const text = chunk.toString();
+      const lower = text.toLowerCase();
+      if (lower.includes('rate limit') || lower.includes('rate_limit') ||
+          lower.includes('quota') || lower.includes('insufficient_quota') ||
+          lower.includes('unauthorized') || lower.includes('401') ||
+          lower.includes('403') || lower.includes('authentication') ||
+          lower.includes('not logged in') || lower.includes('login required') ||
+          lower.includes('billing') || lower.includes('exceeded')) {
+        process.stderr.write(`\n⚠ ${AGENT_NAME}: ${text.trim()}\n`);
+        process.stderr.write(`  → Check login: codex login status\n`);
+        process.stderr.write(`  → Re-auth:    codex login\n\n`);
+      }
+    });
+
+    // Stall detection — warn if no stdout events for 120s
+    let lastEventAt = Date.now();
+    const stallTimer = setInterval(() => {
+      const silent = Math.round((Date.now() - lastEventAt) / 1000);
+      if (silent >= 120) {
+        process.stderr.write(`\n⚠ ${AGENT_NAME}: no response for ${silent}s — may be stalled or rate-limited\n`);
+        process.stderr.write(`  → Press s to skip, or Ctrl+C to abort\n\n`);
+      }
+    }, 30_000);
+
+    try {
+      for await (const line of rl) {
+        if (!line.trim()) continue;
+        lastEventAt = Date.now();
+
+        let event;
+        try { event = JSON.parse(line); } catch { continue; }
+
+        // codex exec --json event shapes:
+        //   { type: 'thread.started', thread_id }
+        //   { type: 'turn.started' }
+        //   { type: 'item.started'   | 'item.updated' | 'item.completed', item: {...} }
+        //   { type: 'turn.completed', usage: { input_tokens, cached_input_tokens, output_tokens } }
+        //   { type: 'error', message }
+        const t = event.type;
+
+        if (t === 'item.completed' && event.item) {
+          const item = event.item;
+          if (item.type === 'agent_message' && item.text) {
+            textParts.push(item.text);
+            yield { type: 'assistant', content: item.text };
+          } else if (item.type === 'command_execution') {
+            const cmd = item.command ?? item.input?.command ?? '';
+            yield { type: 'tool_use', tool: 'bash', input: { command: cmd } };
+            const out = item.aggregated_output ?? item.output ?? '';
+            if (out) {
+              const short = out.length > 80 ? out.slice(0, 77) + '...' : out;
+              yield { type: 'tool_use_summary', summary: short, output: String(out).slice(0, 2048) };
+            }
+          } else if (item.type === 'file_change') {
+            yield { type: 'tool_use', tool: 'edit', input: { path: item.path ?? '' } };
+          } else if (item.type === 'reasoning' && item.text) {
+            // Surface reasoning as assistant content for visibility
+            yield { type: 'assistant', content: item.text };
+          }
+        } else if (t === 'turn.completed' && event.usage) {
+          const u = event.usage;
+          yield {
+            type: 'usage',
+            input_tokens: u.input_tokens ?? 0,
+            output_tokens: u.output_tokens ?? 0,
+            cache_creation_input_tokens: 0,
+            cache_read_input_tokens: u.cached_input_tokens ?? 0,
+            cost_usd: 0,
+            model: resolvedModelID,
+          };
+        } else if (t === 'error') {
+          yield { type: 'error', message: event.message || 'codex error' };
+        }
+      }
+
+      const exitCode = await new Promise(resolve => proc.on('close', resolve));
+
+      if (exitCode !== 0 && textParts.length === 0) {
+        const stderr = Buffer.concat(stderrChunks).toString();
+        yield { type: 'error', message: stderr || `codex exited with code ${exitCode}` };
+      } else {
+        const fullText = textParts.join('');
+        if (fullText) yield { type: 'result', content: fullText };
+        yield { type: 'system', subtype: 'complete', agent: AGENT_NAME };
+      }
+    } catch (err) {
+      if (err?.name !== 'AbortError') {
+        yield { type: 'error', message: err.message || String(err) };
+      }
+    } finally {
+      clearInterval(stallTimer);
+      this.#proc = null;
+    }
+  }
+
+  interrupt() {
+    if (this.#proc) {
+      try { this.#proc.kill('SIGTERM'); } catch { /* ignore */ }
+      this.#proc = null;
+    }
+  }
+
+  get isRunning() {
+    return this.#proc !== null;
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Guard
+// ---------------------------------------------------------------------------
+
+function _assertCodexModel(modelID) {
+  if (!CODEX_MODEL_IDS.has(modelID)) {
+    throw new Error(
+      `CodexConnector: '${modelID}' is not a supported Codex model.\n` +
+      `Supported models: ${[...CODEX_MODEL_IDS].join(', ')}`
+    );
+  }
+}

package/server/connectors/connector-discovery.js

@@ -0,0 +1,18 @@
+// compose/server/connectors/connector-discovery.js
+/**
+ * @interface ConnectorDiscovery
+ *
+ * Stateless vendor capability contract.
+ * Implementations must not hold execution state.
+ *
+ * All three concrete connectors (ClaudeSDKConnector, CodexConnector, OpencodeConnector)
+ * satisfy this interface. Shape verified by test/connector-shape.test.js.
+ */
+export const ConnectorDiscoveryInterface = {
+  /** @returns {string[]} model IDs available for this vendor */
+  listModels() {},
+  /** @param {string} modelId @returns {boolean} */
+  supportsModel(_modelId) {},
+  /** @param {string} sessionId @returns {Promise<object[]>} message history */
+  async loadHistory(_sessionId) { return []; },
+};

package/server/connectors/connector-runtime.js

@@ -0,0 +1,13 @@
+// compose/server/connectors/connector-runtime.js
+/**
+ * @interface ConnectorRuntime
+ *
+ * Stateful execution contract.
+ * See agent-connector.js for the message envelope spec.
+ */
+export const ConnectorRuntimeInterface = {
+  /** @yields typed message envelopes */
+  async *run(_prompt, _opts) {},
+  interrupt() {},
+  get isRunning() { return false; },
+};

package/server/connectors/opencode-connector.js

@@ -0,0 +1,200 @@
+/**
+ * OpencodeConnector — spawns `opencode run` for each prompt.
+ *
+ * Model-agnostic base for any non-Anthropic agent running through OpenCode.
+ * NOT exposed as an MCP tool directly — subclasses (e.g. CodexConnector)
+ * are exposed after constraining to a specific provider/model set.
+ *
+ * Uses `opencode run --format json` which streams structured JSON events
+ * (step_start, text, tool_use, step_finish) to stdout. This is more reliable
+ * than the SDK's serve mode which has event stream issues.
+ */
+
+import { spawn } from 'node:child_process';
+import { createInterface } from 'node:readline';
+import { AgentConnector, injectSchema } from './agent-connector.js';
+
+// ---------------------------------------------------------------------------
+// OpencodeConnector
+// ---------------------------------------------------------------------------
+
+export class OpencodeConnector extends AgentConnector {
+  // ── Discovery ──────────────────────────────────────────────────────────────
+  // No overrides — inherits stubs from AgentConnector. See agent-connector.js.
+
+  _defaultProviderID;
+  _defaultModelID;
+  _cwd;
+  _agentName;
+  #proc = null;
+
+  /**
+   * @param {object} opts
+   * @param {string} opts.providerID  — OpenCode provider ID (e.g. 'openai')
+   * @param {string} opts.modelID     — model ID (e.g. 'gpt-5.4')
+   * @param {string} [opts.cwd]       — default working directory
+   * @param {string} [opts.agentName] — label used in system messages
+   */
+  constructor({ providerID, modelID, cwd = process.cwd(), agentName = 'opencode' }) {
+    super();
+    this._defaultProviderID = providerID;
+    this._defaultModelID = modelID;
+    this._cwd = cwd;
+    this._agentName = agentName;
+  }
+
+  // ── Runtime ────────────────────────────────────────────────────────────────
+
+  async *run(prompt, { schema, modelID, providerID, cwd } = {}) {
+    if (this.#proc) {
+      throw new Error(`${this._agentName}: run() already active. Call interrupt() first.`);
+    }
+
+    const resolvedProviderID = providerID ?? this._defaultProviderID;
+    const resolvedModelID    = modelID    ?? this._defaultModelID;
+    const resolvedCwd        = cwd        ?? this._cwd;
+    const actualPrompt       = schema ? injectSchema(prompt, schema) : prompt;
+
+    yield {
+      type: 'system', subtype: 'init',
+      agent: this._agentName, model: `${resolvedProviderID}/${resolvedModelID}`,
+    };
+
+    // Build clean env: remove OPENAI_API_KEY so opencode uses OAuth
+    // (API key overrides OAuth and may lack Codex model access)
+    const cleanEnv = { ...process.env };
+    delete cleanEnv.OPENAI_API_KEY;
+
+    const proc = spawn('opencode', [
+      'run',
+      '-m', `${resolvedProviderID}/${resolvedModelID}`,
+      '--format', 'json',
+      actualPrompt,
+    ], {
+      cwd: resolvedCwd,
+      stdio: ['ignore', 'pipe', 'pipe'],
+      env: cleanEnv,
+    });
+    this.#proc = proc;
+
+    // Read JSON events line-by-line from stdout
+    const rl = createInterface({ input: proc.stdout, crlfDelay: Infinity });
+
+    const textParts = [];
+    let stderrChunks = [];
+
+    // Stream stderr live — detect rate-limit, auth, and quota errors immediately
+    proc.stderr.on('data', chunk => {
+      stderrChunks.push(chunk);
+      const text = chunk.toString();
+      const lower = text.toLowerCase();
+      // Check for actionable errors that should surface immediately
+      if (lower.includes('rate limit') || lower.includes('rate_limit') ||
+          lower.includes('quota') || lower.includes('insufficient_quota') ||
+          lower.includes('unauthorized') || lower.includes('401') ||
+          lower.includes('403') || lower.includes('authentication') ||
+          lower.includes('auth') || lower.includes('billing') ||
+          lower.includes('exceeded') || lower.includes('capacity')) {
+        process.stderr.write(`\n⚠ ${this._agentName}: ${text.trim()}\n`);
+        process.stderr.write(`  → Check account: opencode auth status\n`);
+        process.stderr.write(`  → Switch account: opencode auth login\n\n`);
+      }
+    });
+
+    // Stall detection — warn if no stdout events for 120s
+    let lastEventAt = Date.now();
+    const stallTimer = setInterval(() => {
+      const silent = Math.round((Date.now() - lastEventAt) / 1000);
+      if (silent >= 120) {
+        process.stderr.write(`\n⚠ ${this._agentName}: no response for ${silent}s — may be stalled or rate-limited\n`);
+        process.stderr.write(`  → Press s to skip, or Ctrl+C to abort\n\n`);
+      }
+    }, 30_000);
+
+    try {
+      for await (const line of rl) {
+        if (!line.trim()) continue;
+        lastEventAt = Date.now();
+
+        let event;
+        try {
+          event = JSON.parse(line);
+        } catch {
+          continue; // skip non-JSON lines
+        }
+
+        if (event.type === 'text') {
+          const text = event.part?.text ?? '';
+          if (text) {
+            textParts.push(text);
+            yield { type: 'assistant', content: text };
+          }
+        } else if (event.type === 'tool_use') {
+          const tool = event.part?.tool ?? event.part?.state?.input?.command ? 'bash' : 'unknown';
+          const input = event.part?.state?.input ?? {};
+          yield { type: 'tool_use', tool, input };
+
+          // If tool has output, yield a summary
+          const output = event.part?.state?.output;
+          if (output && typeof output === 'string') {
+            const short = output.length > 80 ? output.slice(0, 77) + '...' : output;
+            yield { type: 'tool_use_summary', summary: short, output: output.slice(0, 2048) };
+          }
+        } else if (event.type === 'step_finish') {
+          // step_finish includes cost and token info — forward as usage event
+          const part = event.part;
+          if (part && (part.cost != null || part.tokens != null)) {
+            if (process.env.COMPOSE_DEBUG) {
+              process.stderr.write(`  [${this._agentName}] cost=$${(part.cost ?? 0).toFixed(4)} tokens=${part.tokens?.total}\n`);
+            }
+            yield {
+              type: 'usage',
+              input_tokens: part.tokens?.input ?? 0,
+              output_tokens: part.tokens?.output ?? 0,
+              cache_creation_input_tokens: part.tokens?.cache_write ?? 0,
+              cache_read_input_tokens: part.tokens?.cache_read ?? 0,
+              cost_usd: part.cost ?? 0,
+              model: resolvedModelID,
+            };
+          }
+        }
+        // step_start is ignored (already yielded init)
+      }
+
+      // Wait for process to exit
+      const exitCode = await new Promise((resolve) => {
+        proc.on('close', resolve);
+      });
+
+      if (exitCode !== 0 && textParts.length === 0) {
+        const stderr = Buffer.concat(stderrChunks).toString();
+        yield { type: 'error', message: stderr || `opencode exited with code ${exitCode}` };
+      } else {
+        // Yield the full concatenated text as a result
+        const fullText = textParts.join('');
+        if (fullText) {
+          yield { type: 'result', content: fullText };
+        }
+        yield { type: 'system', subtype: 'complete', agent: this._agentName };
+      }
+    } catch (err) {
+      if (err?.name !== 'AbortError') {
+        yield { type: 'error', message: err.message || String(err) };
+      }
+    } finally {
+      clearInterval(stallTimer);
+      this.#proc = null;
+    }
+  }
+
+  interrupt() {
+    if (this.#proc) {
+      try { this.#proc.kill('SIGTERM'); } catch { /* ignore */ }
+      this.#proc = null;
+    }
+  }
+
+  get isRunning() {
+    return this.#proc !== null;
+  }
+}