@amalgm/chat 0.1.1 → 0.2.0

package/host/adapters/opencode.js

@@ -0,0 +1,486 @@
+// OpenCode serve + SDK-over-HTTP/SSE adapter. The vendor SDK is imported
+// lazily because it is needed only when an OpenCode session starts.
+
+import { spawn, spawnSync } from 'node:child_process';
+import net from 'node:net';
+import os from 'node:os';
+import path from 'node:path';
+import { createEventConstructors } from '../../dist/events/index.js';
+import { createOpenCodeNormalizer } from '../../dist/normalizers/opencode.js';
+import { recordNativeEvent } from '../recorder.js';
+import { toOpenCodeMcpConfig } from '../tooling/mcp-bundle.js';
+import { bundledOpenCodeBinary, executableExists, findOnPath } from '../tooling/native-binaries.js';
+import { importPackage } from '../tooling/package-import.js';
+import { prepareHarnessRuntime } from '../tooling/runtime-home.js';
+import { composeSystemPrompt } from '../tooling/system-prompt.js';
+import { requestPermission } from '../permissions.js';
+import { nativeInputCapabilities, UnsupportedExecutionInputError } from './input-capabilities.js';
+import { openCodePromptParts } from './prompt.js';
+
+const events = createEventConstructors({ clockMs: () => Date.now() });
+const { done, errorEvent, reasoningStarted } = events;
+const { normalizeOpenCodeEvent, normalizeOpenCodePromptResult } = createOpenCodeNormalizer(events);
+
+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 selectedVariant(contract) {
+  const setting = contract.modelSettings?.find((candidate) => candidate.configId === 'variant');
+  if (!setting) return null;
+  if (typeof setting.value !== 'string' || !setting.value.trim()) {
+    throw new UnsupportedExecutionInputError(
+      'opencode',
+      'model.settings.variant',
+      'OpenCode requires a non-empty model-catalog variant id',
+    );
+  }
+  return setting.value.trim();
+}
+
+function configFor(contract) {
+  const model = splitModel(contract.cliModel || contract.usageModelId, contract.auth);
+  const variant = selectedVariant(contract);
+  const systemPrompt = composeSystemPrompt(contract);
+  const permission = contract.permissionMode === 'full_access' ? 'allow' : 'ask';
+  const config = {
+    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: {
+      '*': permission,
+      bash: permission,
+      edit: permission,
+      webfetch: permission,
+      question: permission,
+      plan_enter: permission,
+      plan_exit: permission,
+      external_directory: permission,
+    },
+    agent: {
+      build: {
+        mode: 'primary',
+        model: `${model.providerID}/${model.modelID}`,
+        ...(variant ? { variant } : {}),
+        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: permission,
+          bash: permission,
+          webfetch: permission,
+          external_directory: permission,
+        },
+      },
+      title: { disable: true },
+    },
+    mcp: toOpenCodeMcpConfig(contract),
+  };
+  if (contract.authMethod !== 'provider_auth') {
+    config.provider = {
+      [model.providerID]: {
+        options: {
+          baseURL: contract.auth.baseUrl,
+          baseUrl: contract.auth.baseUrl,
+          apiKey: contract.auth.tokenRef,
+          timeout: 300000,
+          chunkTimeout: 300000,
+        },
+      },
+    };
+  }
+  return config;
+}
+
+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',
+    findOnPath('opencode'),
+  ].filter(Boolean);
+  const failures = [];
+  for (const candidate of candidates) {
+    if (!executableExists(candidate)) {
+      failures.push(`${candidate} (missing or not executable)`);
+      continue;
+    }
+    const res = spawnSync(candidate, ['--version'], { stdio: ['ignore', 'pipe', 'ignore'], encoding: 'utf8' });
+    if (res.status === 0) return candidate;
+    failures.push(`${candidate} (--version failed: ${res.error?.message || res.status || res.signal || 'unknown'})`);
+  }
+  throw new Error(`OpenCode CLI binary is not available. Checked: ${failures.join(', ') || 'no candidates'}. Reinstall Amalgm or run amalgm update so the bundled OpenCode native package is present.`);
+}
+
+async function startOpenCodeServer(contract) {
+  const runtime = prepareHarnessRuntime(contract);
+  const binary = resolveBinary();
+  const config = configFor(contract);
+  const port = await freePort();
+  const env = {
+    ...runtime.env,
+    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.AMALGM_CHAT_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.AMALGM_CHAT_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 {
+  constructor(options = {}) {
+    this.permissionPort = options.requestPermission || null;
+    this.inputCapabilities = nativeInputCapabilities({
+      authModes: ['platform', 'subscription', 'byok'],
+      modelSettings: ['variant'],
+      tools: true,
+    });
+  }
+
+  validatePrepared(contract) {
+    selectedVariant(contract);
+  }
+
+  async startInstance(contract) {
+    const sdk = await importPackage('@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) {
+          const payload = raw?.payload || raw;
+          recordNativeEvent('opencode.sdk.event', raw, {
+            providerSessionId: session.providerSessionId,
+            sessionId: contract.sessionId,
+            assistantMessageId: contract.assistantMessageId,
+            eventType: payload?.type,
+          });
+          if (process.env.AMALGM_CHAT_DEBUG_OPENCODE_EVENTS === '1') {
+            console.warn('[OpenCode:event]', JSON.stringify(raw).slice(0, 4000));
+          }
+          if (payload?.type === 'permission.updated' || payload?.type === 'permission.asked') {
+            const permission = payload.properties || {};
+            if (permission.sessionID === session.providerSessionId) {
+              const decision = await requestPermission(this.permissionPort, {
+                adapterId: 'opencode',
+                providerSessionId: session.providerSessionId,
+                kind: permission.type || permission.permission || 'tool',
+                title: permission.title || `OpenCode requests ${permission.type || permission.permission || 'permission'}`,
+                input: permission.metadata || {},
+                permission,
+              });
+              const response = decision.outcome === 'allow_always'
+                ? 'always'
+                : decision.outcome === 'allow_once'
+                  ? 'once'
+                  : 'reject';
+              await session.instance.client.postSessionIdPermissionsPermissionId({
+                path: { id: session.providerSessionId, permissionID: permission.id },
+                query: { directory: contract.cwd },
+                body: { response },
+              });
+            }
+            continue;
+          }
+          pushNormalized(normalizeOpenCodeEvent(raw, state));
+          if (complete) break;
+        }
+        wakeLoop();
+      } catch (err) {
+        if (!controller.signal.aborted) {
+          if (process.env.AMALGM_CHAT_DEBUG_OPENCODE === '1') {
+            console.warn('[OpenCode] event stream ended:', err.message);
+          }
+        }
+        wakeLoop();
+      }
+    })();
+    const model = splitModel(contract.cliModel || contract.usageModelId, contract.auth);
+    const variant = selectedVariant(contract);
+    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,
+            ...(variant ? { variant } : {}),
+            agent: process.env.AMALGM_CHAT_OPENCODE_AGENT || 'build',
+            system: composeSystemPrompt(contract) || undefined,
+            parts: openCodePromptParts(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;
+    }
+  }
+}
+
+const __private = { configFor, selectedVariant };
+
+export { OpenCodeAdapter, splitModel, __private };