amalgm 0.0.0 → 0.0.1

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

@@ -0,0 +1,412 @@
+'use strict';
+
+const { spawn, spawnSync } = require('child_process');
+const fs = require('fs');
+const net = require('net');
+const os = require('os');
+const path = require('path');
+const { done, errorEvent, reasoningStarted } = require('../events');
+const { openCodeParts } = require('../input');
+const { runtimeEnv } = require('../auth');
+const { normalizeOpenCodeEvent, normalizeOpenCodePromptResult } = require('../normalizers/opencode');
+const { recordNativeEvent } = require('../recorder');
+const { toOpenCodeMcpConfig } = require('../tooling/mcp-bundle');
+const { bundledOpenCodeBinary, executableExists } = require('../tooling/native-binaries');
+const { composeSystemPrompt } = require('../tooling/system-prompt');
+
+function splitModel(model, auth) {
+  const raw = String(model || '');
+  if (auth?.method === 'byok' && auth?.providerKind === 'openai_compatible') {
+    const bare = raw.replace(/^vercel\//, '').replace(/^openai\//, '');
+    const modelID = bare.startsWith('openai/') ? bare.slice('openai/'.length) : bare;
+    return { providerID: 'openai', modelID };
+  }
+  if (auth?.method === 'byok' && auth?.providerKind === 'anthropic_compatible') {
+    const bare = raw.replace(/^vercel\//, '').replace(/^anthropic\//, '');
+    const modelID = bare.startsWith('anthropic/') ? bare.slice('anthropic/'.length) : bare;
+    return { providerID: 'anthropic', modelID };
+  }
+  if (raw.startsWith('vercel/')) {
+    return { providerID: 'vercel', modelID: raw.slice('vercel/'.length) };
+  }
+  const parts = raw.split('/');
+  if (parts.length >= 2) return { providerID: parts[0], modelID: parts.slice(1).join('/') };
+  if (!raw) throw new Error('OpenCode model is required');
+  return { providerID: 'openai', modelID: raw.replace(/^openai\//, '') };
+}
+
+function configFor(contract) {
+  const model = splitModel(contract.cliModel || contract.usageModelId, contract.auth);
+  const systemPrompt = composeSystemPrompt(contract);
+  return {
+    logLevel: process.env.OPENCODE_LOG_LEVEL || 'ERROR',
+    enabled_providers: [model.providerID],
+    disabled_providers: [],
+    model: `${model.providerID}/${model.modelID}`,
+    small_model: `${model.providerID}/${model.modelID}`,
+    share: 'disabled',
+    autoupdate: false,
+    snapshot: false,
+    formatter: false,
+    lsp: false,
+    permission: {
+      '*': 'allow',
+      bash: 'allow',
+      edit: 'allow',
+      webfetch: 'allow',
+      question: 'allow',
+      plan_enter: 'allow',
+      plan_exit: 'allow',
+      external_directory: 'allow',
+    },
+    agent: {
+      build: {
+        mode: 'primary',
+        model: `${model.providerID}/${model.modelID}`,
+        prompt: systemPrompt || 'You are an AI coding assistant running inside Amalgm. Answer the user directly, use tools when useful, and keep working directory changes scoped to the request. Do not reveal private planning or narrate intent with phrases like "The user is asking"; start with the answer or action.',
+        permission: {
+          edit: 'allow',
+          bash: 'allow',
+          webfetch: 'allow',
+          external_directory: 'allow',
+        },
+      },
+      title: { disable: true },
+    },
+    mcp: toOpenCodeMcpConfig(contract),
+    provider: {
+      [model.providerID]: {
+        options: {
+          baseURL: contract.auth.baseUrl,
+          baseUrl: contract.auth.baseUrl,
+          apiKey: contract.auth.tokenRef,
+          timeout: 300000,
+          chunkTimeout: 300000,
+        },
+      },
+    },
+  };
+}
+
+function resultData(result) {
+  if (result?.error) throw new Error(JSON.stringify(result.error));
+  return result?.data;
+}
+
+function resolveBinary() {
+  const home = process.env.HOME || os.homedir();
+  const candidates = [
+    process.env.OPENCODE_BINARY,
+    bundledOpenCodeBinary(),
+    path.join(home, '.npm-global/bin/opencode'),
+    '/opt/homebrew/bin/opencode',
+    '/usr/local/bin/opencode',
+    'opencode',
+  ].filter(Boolean);
+  for (const candidate of candidates) {
+    if (candidate.includes('/') && !executableExists(candidate)) continue;
+    const res = spawnSync(candidate, ['--version'], { stdio: ['ignore', 'pipe', 'ignore'], encoding: 'utf8' });
+    if (res.status === 0) return candidate;
+  }
+  return 'opencode';
+}
+
+async function startOpenCodeServer(contract) {
+  const binary = resolveBinary();
+  const config = configFor(contract);
+  const port = await freePort();
+  const env = {
+    ...runtimeEnv(contract),
+    OPENCODE_CONFIG_CONTENT: JSON.stringify(config),
+  };
+  const args = ['serve', '--pure', '--hostname=127.0.0.1', `--port=${port}`];
+  if (config.logLevel) args.push(`--log-level=${config.logLevel}`);
+  const child = spawn(binary, args, {
+    cwd: contract.cwd,
+    env,
+    stdio: ['ignore', 'pipe', 'pipe'],
+    detached: process.platform !== 'win32',
+    windowsHide: true,
+  });
+  let output = '';
+  let settled = false;
+  const url = await new Promise((resolve, reject) => {
+    const timer = setTimeout(() => {
+      settled = true;
+      try { child.kill('SIGTERM'); } catch {}
+      reject(new Error(`Timeout waiting for opencode server to start\n${output.slice(-1000)}`));
+    }, 10000);
+    const onData = (chunk) => {
+      const text = chunk.toString();
+      output += text;
+      if (settled && process.env.CHAT_CORE_DEBUG_OPENCODE === '1' && text.trim()) console.warn('[OpenCode]', text.trim());
+      for (const line of output.split('\n')) {
+        if (!line.startsWith('opencode server listening')) continue;
+        const match = line.match(/on\s+(https?:\/\/[^\s]+)/);
+        if (!match) continue;
+        clearTimeout(timer);
+        settled = true;
+        resolve(match[1]);
+        return;
+      }
+    };
+    child.stdout.on('data', onData);
+    child.stderr.on('data', (chunk) => {
+      const text = chunk.toString();
+      output += text;
+      if (settled && process.env.CHAT_CORE_DEBUG_OPENCODE === '1' && text.trim()) console.warn('[OpenCode]', text.trim());
+    });
+    child.on('error', (err) => {
+      if (settled) return;
+      clearTimeout(timer);
+      settled = true;
+      reject(err);
+    });
+    child.on('exit', (code, signal) => {
+      if (settled) return;
+      clearTimeout(timer);
+      settled = true;
+      reject(new Error(`opencode server exited (${code ?? signal ?? 'unknown'})\n${output.slice(-1000)}`));
+    });
+  });
+  return {
+    url,
+    close() {
+      try { process.kill(-child.pid, 'SIGTERM'); } catch {}
+      try { child.kill('SIGTERM'); } catch {}
+      setTimeout(() => {
+        try { process.kill(-child.pid, 'SIGKILL'); } catch {}
+        try { child.kill('SIGKILL'); } catch {}
+      }, 1500).unref?.();
+    },
+  };
+}
+
+function freePort() {
+  return new Promise((resolve, reject) => {
+    const server = net.createServer();
+    server.listen(0, '127.0.0.1', () => {
+      const address = server.address();
+      const port = typeof address === 'object' && address ? address.port : 0;
+      server.close(() => resolve(port));
+    });
+    server.on('error', reject);
+  });
+}
+
+function timeout(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+function isCompactCommand(text) {
+  return String(text || '').trim().toLowerCase() === '/compact';
+}
+
+class OpenCodeAdapter {
+  async startInstance(contract) {
+    const sdk = await import('@opencode-ai/sdk');
+    const server = await startOpenCodeServer(contract);
+    const client = sdk.createOpencodeClient({ baseUrl: server.url });
+    return { client, server, closed: false };
+  }
+
+  async create(contract) {
+    const instance = await this.startInstance(contract);
+    let created = null;
+    if (contract.providerSessionId) {
+      try {
+        created = resultData(await instance.client.session.get({
+          path: { id: contract.providerSessionId },
+          query: { directory: contract.cwd },
+        }));
+      } catch (err) {
+        console.warn('[OpenCode] Failed to resume persisted session; creating a new native session:', err.message);
+      }
+    }
+    if (!created) {
+      created = resultData(await instance.client.session.create({
+        body: { title: `Amalgm ${contract.sessionId}` },
+        query: { directory: contract.cwd },
+      }));
+    }
+    if (!created?.id) throw new Error('OpenCode SDK did not return a session id');
+    return {
+      sessionId: contract.sessionId,
+      providerSessionId: created.id,
+      instance,
+      abortController: null,
+      turnCount: 0,
+    };
+  }
+
+  async resume(session, contract) {
+    if (!session.instance || session.instance.closed) {
+      session.instance = await this.startInstance(contract);
+    }
+    return session;
+  }
+
+  async stop(session) {
+    session.abortController?.abort();
+    await Promise.race([session.instance.client.session.abort({
+      path: { id: session.providerSessionId },
+      query: { directory: session.cwd },
+    }).catch(() => {}), timeout(1500)]);
+  }
+
+  async destroy(session) {
+    await this.stop(session).catch(() => {});
+    session.instance?.server?.close();
+    if (session.instance) session.instance.closed = true;
+  }
+
+  async *prompt(session, input, contract) {
+    session.cwd = contract.cwd;
+    const controller = new AbortController();
+    session.abortController = controller;
+    const state = {
+      providerSessionId: session.providerSessionId,
+      userMessageId: null,
+      turnStartedAt: Date.now(),
+      contextLimit: Number(contract.contextWindow || 0) || undefined,
+      messageRoles: new Map(),
+      partTypes: new Map(),
+      partText: new Map(),
+      toolsStarted: new Set(),
+      toolsCompleted: new Set(),
+      assistantMessageIds: new Set(),
+      finishedAssistantIds: new Set(),
+      usageEmittedForAssistant: new Set(),
+      sawTurnActivity: false,
+      sawBusy: false,
+      doneEmitted: false,
+    };
+    const queue = [];
+    let complete = false;
+    let promptSettled = false;
+    let wake = null;
+    let promptController = null;
+    const wakeLoop = () => { if (wake) { wake(); wake = null; } };
+    const push = (e) => { queue.push(e); wakeLoop(); };
+    const pushNormalized = (events) => {
+      for (const e of events) {
+        if (e.type === 'done' || e.type === 'error') complete = true;
+        push(e);
+      }
+    };
+    push(reasoningStarted({ providerSessionId: session.providerSessionId }));
+    const finishCancelled = () => {
+      if (complete || state.doneEmitted) return;
+      state.doneEmitted = true;
+      complete = true;
+      push(done({ providerSessionId: session.providerSessionId, stopReason: 'cancelled' }));
+      try { promptController?.abort(); } catch {}
+    };
+    controller.signal.addEventListener('abort', finishCancelled, { once: true });
+    const usePromptAsync = typeof session.instance.client.session.promptAsync === 'function';
+    const events = await session.instance.client.global.event({
+      signal: controller.signal,
+      sseMaxRetryAttempts: 0,
+    });
+    const streamTask = (async () => {
+      try {
+        for await (const raw of events.stream) {
+          recordNativeEvent('opencode.sdk.event', raw, {
+            providerSessionId: session.providerSessionId,
+            sessionId: contract.sessionId,
+            assistantMessageId: contract.assistantMessageId,
+            eventType: raw?.payload?.type || raw?.type,
+          });
+          if (process.env.CHAT_CORE_DEBUG_OPENCODE_EVENTS === '1') {
+            console.warn('[OpenCode:event]', JSON.stringify(raw).slice(0, 4000));
+          }
+          pushNormalized(normalizeOpenCodeEvent(raw, state));
+          if (complete) break;
+        }
+        wakeLoop();
+      } catch (err) {
+        if (!controller.signal.aborted) {
+          if (process.env.CHAT_CORE_DEBUG_OPENCODE === '1') {
+            console.warn('[OpenCode] event stream ended:', err.message);
+          }
+        }
+        wakeLoop();
+      }
+    })();
+    const model = splitModel(contract.cliModel || contract.usageModelId, contract.auth);
+    promptController = new AbortController();
+    const promptMethod = usePromptAsync ? 'promptAsync' : 'prompt';
+    const compactCommand = isCompactCommand(input?.text);
+    const promptPromise = compactCommand
+      ? session.instance.client.session.summarize({
+          path: { id: session.providerSessionId },
+          query: { directory: contract.cwd },
+          signal: promptController.signal,
+          body: model,
+        })
+      : session.instance.client.session[promptMethod]({
+          path: { id: session.providerSessionId },
+          query: { directory: contract.cwd },
+          signal: promptController.signal,
+          body: {
+            model,
+            agent: process.env.CHAT_CORE_OPENCODE_AGENT || 'build',
+            system: composeSystemPrompt(contract) || undefined,
+            parts: openCodeParts(input),
+          },
+        });
+    promptPromise.then((result) => {
+      const data = resultData(result);
+      recordNativeEvent(compactCommand ? 'opencode.sdk.summarize_result' : `opencode.sdk.${promptMethod}_result`, data, {
+        providerSessionId: session.providerSessionId,
+        sessionId: contract.sessionId,
+        assistantMessageId: contract.assistantMessageId,
+      });
+      if (compactCommand) {
+        setTimeout(() => {
+          if (!state.doneEmitted) {
+            state.doneEmitted = true;
+            pushNormalized([done({ providerSessionId: session.providerSessionId, stopReason: 'end_turn' })]);
+          }
+        }, 500).unref?.();
+      } else if (!usePromptAsync) {
+        pushNormalized(normalizeOpenCodePromptResult(data, state));
+        if (!state.doneEmitted) {
+          state.doneEmitted = true;
+          pushNormalized([done({ providerSessionId: session.providerSessionId, stopReason: 'end_turn' })]);
+        }
+      }
+      promptSettled = true;
+      wakeLoop();
+      return data;
+    }).catch((err) => {
+      promptSettled = true;
+      if (promptController.signal.aborted) {
+        wakeLoop();
+        return null;
+      }
+      if (!state.doneEmitted) {
+        state.doneEmitted = true;
+        push(errorEvent(err.message, { providerSessionId: session.providerSessionId }));
+        push(done({ providerSessionId: session.providerSessionId, stopReason: 'error' }));
+      }
+      complete = true;
+      wakeLoop();
+    });
+    try {
+      while ((!complete && (compactCommand || usePromptAsync || !promptSettled)) || queue.length) {
+        if (!queue.length) await new Promise((resolve) => { wake = resolve; });
+        else yield queue.shift();
+      }
+    } finally {
+      controller.abort();
+      promptController.abort();
+      session.abortController = null;
+      await Promise.race([promptPromise.catch(() => {}), timeout(1500)]);
+      await Promise.race([streamTask.catch(() => {}), timeout(1500)]);
+      session.turnCount = (session.turnCount || 0) + 1;
+    }
+  }
+}
+
+module.exports = { OpenCodeAdapter, splitModel };

package/runtime/scripts/chat-core/auth.js

@@ -0,0 +1,177 @@
+'use strict';
+
+const crypto = require('crypto');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { resolveCredential } = require('./credentials/store');
+
+const AUTH_BY_HARNESS = {
+  claude_code: ['amalgm', 'byok', 'provider_auth'],
+  codex: ['amalgm', 'byok', 'provider_auth'],
+  opencode: ['amalgm', 'byok'],
+};
+
+function shellValue(raw) {
+  const value = String(raw ?? '').trim();
+  if ((value.startsWith('"') && value.endsWith('"')) || (value.startsWith("'") && value.endsWith("'"))) {
+    return value.slice(1, -1);
+  }
+  return value;
+}
+
+function readByokFile(amalgmDir) {
+  const out = {};
+  try {
+    const raw = fs.readFileSync(path.join(amalgmDir, '.amalgm-credentials'), 'utf8');
+    for (const line of raw.split(/\r?\n/)) {
+      const match = line.match(/^\s*(?:export\s+)?([A-Za-z_][A-Za-z0-9_]*)=(.*)$/);
+      if (match) out[match[1]] = shellValue(match[2]);
+    }
+  } catch {}
+  return out;
+}
+
+function byokKeyFor(harness, values) {
+  if (harness === 'claude_code') return values.ANTHROPIC_API_KEY || '';
+  if (harness === 'codex') return values.OPENAI_API_KEY || values.CODEX_API_KEY || '';
+  return '';
+}
+
+function providerKindForModel(modelId) {
+  const provider = String(modelId || '').split('/')[0];
+  if (provider === 'anthropic') return 'anthropic_compatible';
+  if (provider === 'openai') return 'openai_compatible';
+  return provider ? 'ai_gateway' : null;
+}
+
+function resolveByokCredential(amalgmDir, { credentialId, harness, modelId }) {
+  if (credentialId) return resolveCredential(amalgmDir, { credentialId, harness });
+  const preferred = providerKindForModel(modelId);
+  if (preferred) {
+    const credential = resolveCredential(amalgmDir, { harness, providerKind: preferred });
+    if (credential) return credential;
+    if (preferred === 'ai_gateway') return null;
+  }
+  if (harness === 'opencode' && preferred !== 'ai_gateway') {
+    const gatewayCredential = resolveCredential(amalgmDir, { harness, providerKind: 'ai_gateway' });
+    if (gatewayCredential) return gatewayCredential;
+  }
+  return resolveCredential(amalgmDir, { harness });
+}
+
+function fingerprint(value) {
+  return value ? crypto.createHash('sha256').update(String(value)).digest('hex').slice(0, 16) : null;
+}
+
+function coerceAuth(harness, requested) {
+  const supported = AUTH_BY_HARNESS[harness] || ['amalgm'];
+  return requested && supported.includes(requested) ? requested : supported[0];
+}
+
+function runtimeHome({ amalgmDir, sessionId, harness, authMethod, tokenFingerprint }) {
+  if (authMethod === 'provider_auth' && harness !== 'codex') return null;
+  const suffix = tokenFingerprint || 'default';
+  return path.join(amalgmDir, 'runtime', sessionId, harness, suffix);
+}
+
+function providerAuthFingerprint(harness) {
+  if (harness !== 'codex') return null;
+  try {
+    const raw = fs.readFileSync(path.join(os.homedir(), '.codex', 'auth.json'), 'utf8');
+    return fingerprint(raw);
+  } catch {
+    return null;
+  }
+}
+
+function authEnvelope({ harness, authMethod, sessionId, localBaseUrl, proxyToken, proxyBaseUrl, amalgmDir, credentialId, modelId }) {
+  const method = coerceAuth(harness, authMethod);
+  const byok = readByokFile(amalgmDir);
+  let baseUrl = null;
+  let forwardBaseUrl = null;
+  let tokenRef = null;
+  let tokenFingerprint = null;
+  let credential = null;
+  if (method === 'amalgm') {
+    const providerPath = harness === 'claude_code'
+      ? '/anthropic'
+      : harness === 'opencode'
+        ? '/ai_gateway/v3/ai'
+        : '/openai/v1';
+    forwardBaseUrl = `${String(proxyBaseUrl || '').replace(/\/$/, '')}${providerPath}`;
+    baseUrl = `${String(localBaseUrl || '').replace(/\/$/, '')}/egress/${encodeURIComponent(sessionId)}${providerPath}`;
+    tokenRef = `session-local-${fingerprint(`${sessionId}:${proxyToken}`) || 'token'}`;
+    tokenFingerprint = fingerprint(proxyToken);
+  } else if (method === 'byok') {
+    credential = resolveByokCredential(amalgmDir, { credentialId, harness, modelId });
+    tokenRef = credential?.key || byokKeyFor(harness, byok);
+    if (!tokenRef) {
+      throw new Error(`No BYOK credential configured for ${harness}`);
+    }
+    tokenFingerprint = fingerprint(tokenRef);
+    baseUrl = credential?.baseUrl || (harness === 'claude_code' ? 'https://api.anthropic.com' : 'https://api.openai.com/v1');
+  } else if (method === 'provider_auth') {
+    tokenFingerprint = providerAuthFingerprint(harness);
+  }
+  return {
+    method,
+    baseUrl,
+    credentialId: credential?.id || credentialId || null,
+    credentialName: credential?.name || null,
+    providerKind: credential?.providerKind || null,
+    forwardBaseUrl,
+    tokenRef,
+    tokenFingerprint,
+    runtimeHome: runtimeHome({ amalgmDir, sessionId, harness, authMethod: method, tokenFingerprint }),
+  };
+}
+
+function safeBaseEnv(baseEnv = process.env) {
+  const env = {};
+  for (const key of ['PATH', 'HOME', 'USER', 'LOGNAME', 'SHELL', 'LANG', 'LC_ALL', 'TERM', 'TMPDIR']) {
+    if (baseEnv[key]) env[key] = baseEnv[key];
+  }
+  return env;
+}
+
+function runtimeEnv(contract, baseEnv = process.env) {
+  const env = contract.authMethod === 'provider_auth' ? { ...baseEnv } : safeBaseEnv(baseEnv);
+  for (const key of ['OPENAI_API_KEY', 'OPENAI_BASE_URL', 'ANTHROPIC_API_KEY', 'ANTHROPIC_BASE_URL', 'AI_GATEWAY_API_KEY', 'AI_GATEWAY_BASE_URL']) {
+    delete env[key];
+  }
+  if (contract.auth.runtimeHome) {
+    fs.mkdirSync(contract.auth.runtimeHome, { recursive: true });
+    env.HOME = contract.auth.runtimeHome;
+    env.CODEX_HOME = contract.auth.runtimeHome;
+    env.CLAUDE_CONFIG_DIR = contract.auth.runtimeHome;
+    env.OPENCODE_CONFIG_DIR = contract.auth.runtimeHome;
+  }
+  env.IS_SANDBOX = '1';
+  if (baseEnv.AMALGM_RUNTIME_TOKEN) env.AMALGM_RUNTIME_TOKEN = baseEnv.AMALGM_RUNTIME_TOKEN;
+  if (contract.authMethod === 'amalgm' || contract.authMethod === 'byok') {
+    if (contract.harness === 'claude_code') {
+      if (contract.authMethod === 'amalgm') {
+        env.ANTHROPIC_AUTH_TOKEN = contract.auth.tokenRef || '';
+      } else {
+        env.ANTHROPIC_API_KEY = contract.auth.tokenRef || '';
+      }
+      if (contract.auth.baseUrl) env.ANTHROPIC_BASE_URL = contract.auth.baseUrl;
+    } else if (contract.harness === 'opencode') {
+      env.AI_GATEWAY_API_KEY = contract.auth.tokenRef || '';
+      if (contract.auth.baseUrl) env.AI_GATEWAY_BASE_URL = contract.auth.baseUrl;
+    } else {
+      env.OPENAI_API_KEY = contract.auth.tokenRef || '';
+      if (contract.auth.baseUrl) env.OPENAI_BASE_URL = contract.auth.baseUrl;
+    }
+  }
+  return env;
+}
+
+module.exports = {
+  AUTH_BY_HARNESS,
+  authEnvelope,
+  coerceAuth,
+  fingerprint,
+  runtimeEnv,
+};