amalgm 0.0.0 → 0.0.32

package/runtime/scripts/chat-core/adapters/codex.js

@@ -0,0 +1,313 @@
+'use strict';
+
+const { spawn, spawnSync } = require('child_process');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { done, errorEvent } = require('../events');
+const { promptText } = require('../input');
+const { runtimeEnv } = require('../auth');
+const { codexErrorMessage, normalizeCodexNotification } = require('../normalizers/codex');
+const { recordNativeEvent } = require('../recorder');
+const { toCodexMcpToml } = require('../tooling/mcp-bundle');
+const { bundledCodexBinary, bundledCodexPathDirs, executableExists } = require('../tooling/native-binaries');
+const { composeSystemPrompt } = require('../tooling/system-prompt');
+
+class JsonLineRpc {
+  constructor({ binary, cwd, env }) {
+    this.id = 1;
+    this.pending = new Map();
+    this.handlers = new Set();
+    this.buffer = '';
+    this.child = spawn(binary, ['app-server'], {
+      cwd,
+      env,
+      stdio: ['pipe', 'pipe', 'pipe'],
+      detached: process.platform !== 'win32',
+      windowsHide: true,
+    });
+    this.child.stdout.setEncoding('utf8');
+    this.child.stdout.on('data', (chunk) => this.onData(chunk));
+    this.child.stderr.setEncoding('utf8');
+    this.child.stderr.on('data', (chunk) => {
+      const text = String(chunk || '').trim();
+      if (text && process.env.CHAT_CORE_DEBUG) console.warn('[Codex]', text.slice(0, 1000));
+    });
+    this.child.on('exit', (code, signal) => {
+      const err = new Error(`codex app-server exited (${code ?? signal ?? 'unknown'})`);
+      for (const pending of this.pending.values()) pending.reject(err);
+      this.pending.clear();
+    });
+  }
+
+  onData(chunk) {
+    this.buffer += chunk;
+    const lines = this.buffer.split('\n');
+    this.buffer = lines.pop() || '';
+    for (const line of lines) {
+      if (!line.trim()) continue;
+      let msg;
+      try { msg = JSON.parse(line); } catch { continue; }
+      if (msg.id !== undefined && (msg.result !== undefined || msg.error !== undefined)) {
+        const pending = this.pending.get(msg.id);
+        if (!pending) continue;
+        this.pending.delete(msg.id);
+        if (msg.error) pending.reject(new Error(msg.error.message || JSON.stringify(msg.error)));
+        else pending.resolve(msg.result);
+      } else {
+        if (process.env.CHAT_CORE_DEBUG_CODEX === '1') {
+          console.log('[Codex:event]', JSON.stringify(msg).slice(0, 4000));
+        }
+        for (const handler of this.handlers) handler(msg);
+      }
+    }
+  }
+
+  request(method, params = {}, timeoutMs = 180000) {
+    const id = this.id++;
+    this.child.stdin.write(`${JSON.stringify({ id, method, params })}\n`);
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        this.pending.delete(id);
+        reject(new Error(`${method} timed out`));
+      }, timeoutMs);
+      this.pending.set(id, {
+        resolve: (value) => { clearTimeout(timer); resolve(value); },
+        reject: (err) => { clearTimeout(timer); reject(err); },
+      });
+    });
+  }
+
+  notify(method, params) {
+    this.child.stdin.write(`${JSON.stringify(params === undefined ? { method } : { method, params })}\n`);
+  }
+
+  on(handler) {
+    this.handlers.add(handler);
+    return () => this.handlers.delete(handler);
+  }
+
+  close() {
+    try { this.child.stdin.end(); } catch {}
+    try {
+      if (process.platform !== 'win32' && this.child.pid) process.kill(-this.child.pid, 'SIGTERM');
+      else this.child.kill('SIGTERM');
+    } catch {}
+  }
+}
+
+function resolveBinary() {
+  const home = process.env.HOME || os.homedir();
+  for (const candidate of [process.env.CODEX_BINARY, bundledCodexBinary(), path.join(home, '.npm-global/bin/codex'), '/opt/homebrew/bin/codex', '/usr/local/bin/codex', 'codex'].filter(Boolean)) {
+    if (candidate.includes('/') && !executableExists(candidate)) continue;
+    const res = spawnSync(candidate, ['--version'], { stdio: ['ignore', 'pipe', 'ignore'], encoding: 'utf8' });
+    if (res.status === 0) return candidate;
+  }
+  return 'codex';
+}
+
+function codexEnv(contract, binary) {
+  const env = runtimeEnv(contract);
+  if (binary !== bundledCodexBinary()) return env;
+  const pathDirs = bundledCodexPathDirs();
+  if (pathDirs.length > 0) {
+    env.PATH = [...pathDirs, env.PATH].filter(Boolean).join(path.delimiter);
+  }
+  env.CODEX_MANAGED_BY_NPM = '1';
+  return env;
+}
+
+function positiveInteger(value) {
+  const number = Number(value);
+  return Number.isFinite(number) && number > 0 ? Math.floor(number) : null;
+}
+
+function modelWindowConfigLines(contract) {
+  const contextWindow = positiveInteger(contract.contextWindow);
+  if (!contextWindow) return [];
+  return [
+    `model_context_window = ${contextWindow}`,
+    `model_auto_compact_token_limit = ${Math.max(1, Math.floor(contextWindow * 0.9))}`,
+    '',
+  ];
+}
+
+function isCompactCommand(text) {
+  return String(text || '').trim().toLowerCase() === '/compact';
+}
+
+function writeConfig(contract) {
+  const home = contract.auth.runtimeHome;
+  if (!home) return;
+  fs.mkdirSync(home, { recursive: true });
+  const mcpToml = toCodexMcpToml(contract);
+  if (contract.authMethod === 'provider_auth') {
+    const sourceAuth = path.join(os.homedir(), '.codex', 'auth.json');
+    const targetAuth = path.join(home, 'auth.json');
+    if (fs.existsSync(sourceAuth)) {
+      fs.copyFileSync(sourceAuth, targetAuth);
+      fs.chmodSync(targetAuth, 0o600);
+    }
+    fs.writeFileSync(path.join(home, 'config.toml'), [
+      'model_provider = "openai"',
+      '',
+      mcpToml,
+    ].join('\n'), { mode: 0o600 });
+    return;
+  }
+  if (contract.authMethod === 'amalgm') {
+    fs.writeFileSync(path.join(home, 'config.toml'), [
+      'model_provider = "amalgm"',
+      ...modelWindowConfigLines(contract),
+      '',
+      '[model_providers.amalgm]',
+      'name = "amalgm"',
+      `base_url = "${contract.auth.baseUrl}"`,
+      'env_key = "OPENAI_API_KEY"',
+      'wire_api = "responses"',
+      'requires_openai_auth = false',
+      '',
+      mcpToml,
+    ].join('\n'), { mode: 0o600 });
+  } else {
+    fs.writeFileSync(path.join(home, 'config.toml'), [
+      'model_provider = "openai"',
+      '',
+      mcpToml,
+    ].join('\n'), { mode: 0o600 });
+  }
+  fs.writeFileSync(path.join(home, 'auth.json'), JSON.stringify({
+    auth_mode: 'apikey',
+    OPENAI_API_KEY: contract.auth.tokenRef,
+  }, null, 2), { mode: 0o600 });
+}
+
+class CodexAdapter {
+  async create(contract) {
+    writeConfig(contract);
+    const binary = resolveBinary();
+    const client = new JsonLineRpc({ binary, cwd: contract.cwd, env: codexEnv(contract, binary) });
+    await client.request('initialize', { clientInfo: { name: 'amalgm-chat-core', version: '1.0.0' }, capabilities: { experimentalApi: true } });
+    client.notify('initialized');
+    const threadOptions = {
+      cwd: contract.cwd,
+      approvalPolicy: 'never',
+      sandbox: 'danger-full-access',
+      modelProvider: contract.authMethod === 'amalgm' ? 'amalgm' : 'openai',
+      developerInstructions: composeSystemPrompt(contract) || null,
+      persistExtendedHistory: true,
+    };
+    const thread = contract.providerSessionId
+      ? await client.request('thread/resume', {
+          threadId: contract.providerSessionId,
+          ...threadOptions,
+          excludeTurns: true,
+        })
+      : await client.request('thread/start', threadOptions);
+    return { sessionId: contract.sessionId, providerSessionId: thread.thread.id, client, activeTurnId: null, activeTurnHadAssistant: false, cancelCurrentTurn: null, cancelRequested: false };
+  }
+
+  async resume(session) { return session; }
+
+  async stop(session) {
+    session.cancelRequested = true;
+    try { session.cancelCurrentTurn?.(); } catch {}
+    if (!session.activeTurnId) return;
+    await session.client.request('turn/interrupt', { threadId: session.providerSessionId, turnId: session.activeTurnId }).catch(() => {});
+  }
+
+  async destroy(session) { session.client.close(); }
+
+  async *prompt(session, input, contract) {
+    const queue = [];
+    let complete = false;
+    let compactCompletionTimer = null;
+    let wake = null;
+    const wakeLoop = () => { if (wake) { wake(); wake = null; } };
+    const push = (e) => { queue.push(e); wakeLoop(); };
+    session.cancelRequested = false;
+    session.cancelCurrentTurn = () => {
+      if (complete) return;
+      complete = true;
+      push(done({ providerSessionId: session.providerSessionId, stopReason: 'cancelled' }));
+    };
+    const off = session.client.on((msg) => {
+      const p = msg.params || {};
+      if (p.threadId && p.threadId !== session.providerSessionId) return;
+      recordNativeEvent('codex.app-server.notification', msg, {
+        providerSessionId: session.providerSessionId,
+        sessionId: contract.sessionId,
+        assistantMessageId: contract.assistantMessageId,
+        method: msg.method,
+      });
+      if (msg.method === 'turn/started' && p.turn?.id) {
+        session.activeTurnId = p.turn.id;
+        session.activeTurnHadAssistant = false;
+      }
+      if (p.turnId && !session.activeTurnId && msg.method !== 'turn/started') return;
+      if (p.turnId && session.activeTurnId && p.turnId !== session.activeTurnId) return;
+      if (msg.method === 'item/started' && ['agentMessage', 'reasoning', 'commandExecution', 'contextCompaction'].includes(p.item?.type)) {
+        session.activeTurnHadAssistant = true;
+      }
+      if (msg.method === 'thread/tokenUsage/updated' && !session.activeTurnHadAssistant) return;
+      for (const e of normalizeCodexNotification(msg, session.providerSessionId, session)) {
+        if (session.cancelRequested && e.type === 'done') e.stopReason = 'cancelled';
+        if (e.type === 'done' || e.type === 'error') complete = true;
+        push(e);
+      }
+      if (compactCommand && msg.method === 'item/completed' && p.item?.type === 'contextCompaction') {
+        if (compactCompletionTimer) clearTimeout(compactCompletionTimer);
+        compactCompletionTimer = setTimeout(() => {
+          push(done({ providerSessionId: session.providerSessionId, stopReason: 'end_turn' }));
+          complete = true;
+          wakeLoop();
+        }, 500);
+      }
+    });
+    session.activeTurnId = null;
+    session.activeTurnHadAssistant = false;
+    const prompt = promptText(input, contract);
+    const compactCommand = isCompactCommand(prompt);
+    const startRequest = compactCommand
+      ? session.client.request('thread/compact/start', { threadId: session.providerSessionId })
+      : session.client.request('turn/start', {
+          threadId: session.providerSessionId,
+          input: [{ type: 'text', text: prompt }],
+          cwd: contract.cwd,
+          model: contract.cliModel.replace(/\/(?:low|medium|high|xhigh)$/i, ''),
+          effort: contract.reasoningEffort || undefined,
+          approvalPolicy: 'never',
+        });
+    startRequest.then((result) => {
+      if (compactCommand) return;
+      session.activeTurnId = result?.turn?.id || session.activeTurnId;
+      const resultError = result?.error || result?.turn?.error || result?.turn?.lastError;
+      if (!resultError) return;
+      push(errorEvent(codexErrorMessage(resultError), { providerSessionId: session.providerSessionId }));
+      push(done({ providerSessionId: session.providerSessionId, stopReason: 'error' }));
+      complete = true;
+    }).catch((err) => {
+      if (session.cancelRequested) {
+        push(done({ providerSessionId: session.providerSessionId, stopReason: 'cancelled' }));
+        complete = true;
+        return;
+      }
+      push(errorEvent(err.message, { providerSessionId: session.providerSessionId }));
+      push(done({ providerSessionId: session.providerSessionId, stopReason: 'error' }));
+      complete = true;
+    });
+    try {
+      while (!complete || queue.length) {
+        if (!queue.length) await new Promise((resolve) => { wake = resolve; });
+        else yield queue.shift();
+      }
+    } finally {
+      if (compactCompletionTimer) clearTimeout(compactCompletionTimer);
+      off();
+      session.cancelCurrentTurn = null;
+      session.cancelRequested = false;
+    }
+  }
+}
+
+module.exports = { CodexAdapter, __private: { modelWindowConfigLines, writeConfig } };