@axhub/genie 0.2.6 → 0.2.8

package/server/opencode-cli.js

@@ -1,674 +1,102 @@
-import { spawn } from 'child_process';
-import crossSpawn from 'cross-spawn';
-import crypto from 'crypto';
-import readline from 'readline';
-import fetch from 'node-fetch';
-import { promises as fs } from 'fs';
-import path from 'path';
-import os from 'os';
+import {
+  abortAgentSession,
+  executeAgentPrompt,
+  getActiveAgentSessions,
+  isAgentSessionActive
+} from './acp-runtime/index.js';
+import { spawnCommand } from './utils/spawnCommand.js';
 import { resolveWorkingDirectory } from './utils/defaultWorkingDirectory.js';
 
-const spawnFunction = process.platform === 'win32' ? crossSpawn : spawn;
-
-const activeOpencodeRuns = new Map();
-
-const SERVER_READY_PREFIX = 'opencode server listening on ';
-const LOCAL_SESSION_DIR = path.join(os.homedir(), '.opencode', 'sessions');
-
-function generatePassword() {
-  return crypto.randomBytes(24).toString('base64url');
-}
-
-function parseModel(model) {
-  if (!model || typeof model !== 'string') return null;
-  const normalized = model.trim();
-  if (!normalized.includes('/')) return null;
-  const [providerID, modelID] = normalized.split('/');
-  if (!providerID || !modelID) return null;
-  return { providerID, modelID };
-}
-
-function getEventSessionId(payload) {
-  return (
-    payload?.properties?.sessionID ||
-    payload?.properties?.info?.sessionID ||
-    payload?.properties?.part?.sessionID ||
-    payload?.sessionID ||
-    null
-  );
-}
-
-function collectTextChunks(value) {
-  if (!value) return [];
-  if (typeof value === 'string') return value.trim() ? [value] : [];
-  if (Array.isArray(value)) return value.flatMap(collectTextChunks);
-  if (typeof value !== 'object') return [];
-
-  const chunks = [];
-  const candidates = [
-    value.text,
-    value.content,
-    value.message,
-    value.delta,
-    value.parts,
-    value.part,
-    value.properties,
-    value.data
-  ];
-  candidates.forEach((candidate) => {
-    chunks.push(...collectTextChunks(candidate));
-  });
-  return chunks;
-}
-
-function extractPartText(part) {
-  if (!part || typeof part !== 'object') return '';
-
-  if (typeof part.text === 'string') return part.text;
-  if (typeof part.content === 'string') return part.content;
-
-  if (Array.isArray(part.text)) {
-    return part.text
-      .map((item) => (typeof item === 'string' ? item : item?.text || item?.content || ''))
-      .join('');
-  }
-
-  if (Array.isArray(part.content)) {
-    return part.content
-      .map((item) => (typeof item === 'string' ? item : item?.text || item?.content || ''))
-      .join('');
-  }
-
-  return '';
-}
-
-function resolvePartRole(payload, part) {
-  return String(
-    part?.role ||
-    part?.message?.role ||
-    payload?.properties?.message?.role ||
-    payload?.properties?.info?.role ||
-    ''
-  ).toLowerCase();
-}
-
-function isReasoningPart(payload, part) {
-  const typeHints = [
-    part?.type,
-    part?.message?.type,
-    payload?.properties?.part?.type,
-    payload?.properties?.message?.type,
-    payload?.properties?.type,
-    payload?.type
-  ]
+function parseOpencodeModelList(stdout = '') {
+  return String(stdout)
+    .split(/\r?\n/)
+    .map((line) => line.trim())
     .filter(Boolean)
-    .map((value) => String(value).toLowerCase());
-
-  return typeHints.some((hint) =>
-    hint.includes('reasoning') || hint.includes('thinking') || hint.includes('thought')
-  );
-}
-
-function isUnsupportedImageInputText(text) {
-  return /this model does not support image input/i.test(String(text || ''));
-}
-
-function sendTextDelta(ws, sessionId, text) {
-  if (!text) return;
-  ws.send({
-    type: 'claude-response',
-    provider: 'opencode',
-    sessionId,
-    data: {
-      type: 'content_block_delta',
-      delta: {
-        type: 'text_delta',
-        text
-      }
-    }
-  });
-}
-
-function sendContentStop(ws, sessionId) {
-  ws.send({
-    type: 'claude-response',
-    provider: 'opencode',
-    sessionId,
-    data: { type: 'content_block_stop' }
-  });
-}
-
-function terminateProcess(child) {
-  if (!child || child.killed) return;
-  try {
-    child.kill('SIGTERM');
-  } catch {}
-}
-
-function localSessionFilePath(sessionId) {
-  return path.join(LOCAL_SESSION_DIR, `${sessionId}.jsonl`);
+    .filter((line) => line.includes('/'))
+    .filter((line) => !line.endsWith(':'))
+    .map((line) => line.split(/\s+/)[0])
+    .filter((line, index, list) => list.indexOf(line) === index);
 }
 
-async function appendLocalSessionEvent(sessionId, event) {
-  if (!sessionId) return;
-  try {
-    await fs.mkdir(LOCAL_SESSION_DIR, { recursive: true });
-    const line = `${JSON.stringify(event)}\n`;
-    await fs.appendFile(localSessionFilePath(sessionId), line, 'utf8');
-  } catch {
-  }
-}
+export async function listOpencodeModels(options = {}) {
+  const workingDir = resolveWorkingDirectory(options);
 
-async function waitForServerUrl(child, timeoutMs = 30000) {
-  return new Promise((resolve, reject) => {
+  return new Promise((resolve) => {
+    let stdout = '';
+    let stderr = '';
     let settled = false;
-    const captured = [];
-
-    const cleanup = () => {
-      clearTimeout(timer);
-      child.stdout?.off('error', onStreamError);
-      child.stderr?.off('error', onStreamError);
-      child.off('error', onProcessError);
-      child.off('close', onClose);
-      stdoutRl?.close();
-      stderrRl?.close();
-    };
 
-    const done = (fn) => {
-      if (settled) return;
-      settled = true;
-      cleanup();
-      fn();
-    };
-
-    const onStreamError = (error) => {
-      done(() => reject(error));
-    };
-
-    const onProcessError = (error) => {
-      done(() => reject(error));
-    };
-
-    const onClose = (code) => {
-      done(() => {
-        reject(new Error(`OpenCode server exited before ready (code ${code}). Output: ${captured.slice(-8).join(' | ')}`));
-      });
-    };
-
-    const onLine = (line) => {
-      if (!line) return;
-      captured.push(line);
-      if (captured.length > 64) captured.shift();
-
-      const trimmed = line.trim();
-      if (trimmed.startsWith(SERVER_READY_PREFIX)) {
-        const baseUrl = trimmed.slice(SERVER_READY_PREFIX.length).trim();
-        done(() => resolve(baseUrl));
+    const finalize = (result) => {
+      if (settled) {
+        return;
       }
+      settled = true;
+      resolve(result);
     };
 
-    const stdoutRl = child.stdout
-      ? readline.createInterface({ input: child.stdout })
-      : null;
-    const stderrRl = child.stderr
-      ? readline.createInterface({ input: child.stderr })
-      : null;
-
-    stdoutRl?.on('line', onLine);
-    stderrRl?.on('line', onLine);
-    child.stdout?.on('error', onStreamError);
-    child.stderr?.on('error', onStreamError);
-    child.on('error', onProcessError);
-    child.on('close', onClose);
-
-    const timer = setTimeout(() => {
-      done(() => {
-        reject(new Error(`Timed out waiting OpenCode server URL. Output: ${captured.slice(-8).join(' | ')}`));
-      });
-    }, timeoutMs);
-  });
-}
-
-function spawnServerCommand(command, args, workingDir, env) {
-  return spawnFunction(command, args, {
-    cwd: workingDir,
-    stdio: ['ignore', 'pipe', 'pipe'],
-    env
-  });
-}
-
-async function startOpenCodeServer(workingDir) {
-  const password = generatePassword();
-  const env = {
-    ...process.env,
-    NO_COLOR: '1',
-    NPM_CONFIG_LOGLEVEL: 'error',
-    NODE_NO_WARNINGS: '1',
-    OPENCODE_SERVER_USERNAME: 'opencode',
-    OPENCODE_SERVER_PASSWORD: password
-  };
-
-  const trySpawn = async (command, args) => {
-    const child = spawnServerCommand(command, args, workingDir, env);
-    const baseUrl = await waitForServerUrl(child);
-    return { child, baseUrl, password };
-  };
-
-  try {
-    return await trySpawn('opencode', ['serve', '--hostname', '127.0.0.1', '--port', '0']);
-  } catch (error) {
-    return trySpawn('npx', ['-y', 'opencode-ai@latest', 'serve', '--hostname', '127.0.0.1', '--port', '0']);
-  }
-}
-
-function authHeaders(password, workingDir) {
-  const basic = Buffer.from(`opencode:${password}`).toString('base64');
-  return {
-    Authorization: `Basic ${basic}`,
-    'x-opencode-directory': workingDir,
-    Accept: 'application/json'
-  };
-}
-
-async function requestJson(baseUrl, path, { method = 'GET', headers = {}, body, signal } = {}) {
-  const response = await fetch(`${baseUrl}${path}`, {
-    method,
-    headers: {
-      ...headers,
-      ...(body ? { 'Content-Type': 'application/json' } : {})
-    },
-    body: body ? JSON.stringify(body) : undefined,
-    signal
-  });
-
-  const text = await response.text();
-  if (!response.ok) {
-    throw new Error(`OpenCode request failed: ${response.status} ${text}`);
-  }
-
-  if (!text.trim()) return null;
-  try {
-    return JSON.parse(text);
-  } catch {
-    return null;
-  }
-}
-
-export async function listOpencodeModels(options = {}) {
-  const { cwd, projectPath } = options;
-  const workingDir = resolveWorkingDirectory({ cwd, projectPath });
-  let server = null;
-
-  try {
-    server = await startOpenCodeServer(workingDir);
-    const headers = authHeaders(server.password, workingDir);
-    const directoryParam = encodeURIComponent(workingDir);
-
-    const configProviders = await requestJson(
-      server.baseUrl,
-      `/config/providers?directory=${directoryParam}`,
-      { headers }
-    );
-
-    const providerList = await requestJson(
-      server.baseUrl,
-      `/provider?directory=${directoryParam}`,
-      { headers }
-    ).catch((err) => {
-      console.warn('OpenCode provider list fetch failed:', err.message);
-      return null;
-    });
-
-    const providers = Array.isArray(configProviders?.providers)
-      ? configProviders.providers
-      : [];
-
-    const models = providers
-      .slice()
-      .sort((a, b) => String(a?.id || '').localeCompare(String(b?.id || '')))
-      .flatMap((provider) => {
-        const providerId = String(provider?.id || '').trim();
-        if (!providerId) return [];
-
-        const modelIds = Object.keys(provider?.models || {}).sort();
-        return modelIds.map((modelId) => `${providerId}/${modelId}`);
-      });
-
-    return {
-      models,
-      defaults: configProviders?.default || {},
-      connected: Array.isArray(providerList?.connected) ? providerList.connected : []
-    };
-  } finally {
-    if (server?.child) {
-      terminateProcess(server.child);
-    }
-  }
-}
-
-async function createOrReuseSession({ baseUrl, headers, workingDir, sessionId }) {
-  if (sessionId) return sessionId;
-  const created = await requestJson(baseUrl, `/session?directory=${encodeURIComponent(workingDir)}`, {
-    method: 'POST',
-    headers,
-    body: {}
-  });
-  const id = created?.id;
-  if (!id) {
-    throw new Error('OpenCode session.create did not return session id');
-  }
-  return id;
-}
-
-function createSSEReader(responseBody) {
-  const decoder = new TextDecoder('utf-8');
-  let buffer = '';
-  let eventData = '';
-  let eventId = '';
-
-  const flushEvent = () => {
-    if (!eventData) return null;
-    const payload = eventData.endsWith('\n') ? eventData.slice(0, -1) : eventData;
-    const event = { id: eventId || null, data: payload };
-    eventData = '';
-    eventId = '';
-    return event;
-  };
-
-  return {
-    async *read() {
-      for await (const chunk of responseBody) {
-        buffer += decoder.decode(chunk, { stream: true });
-
-        while (true) {
-          const idx = buffer.indexOf('\n');
-          if (idx === -1) break;
-
-          const line = buffer.slice(0, idx).replace(/\r$/, '');
-          buffer = buffer.slice(idx + 1);
-
-          if (line === '') {
-            const evt = flushEvent();
-            if (evt) yield evt;
-            continue;
-          }
-
-          if (line.startsWith('id:')) {
-            eventId = line.slice(3).trim();
-          } else if (line.startsWith('data:')) {
-            eventData += `${line.slice(5).trim()}\n`;
-          }
-        }
-      }
-
-      if (buffer.trim()) {
-        if (buffer.startsWith('data:')) {
-          eventData += `${buffer.slice(5).trim()}\n`;
-        }
-      }
-
-      const evt = flushEvent();
-      if (evt) yield evt;
-    }
-  };
-}
-
-async function subscribeEventStream({ baseUrl, headers, workingDir, sessionId, ws, abortSignal, promptText }) {
-  const response = await fetch(`${baseUrl}/event?directory=${encodeURIComponent(workingDir)}`, {
-    method: 'GET',
-    headers: {
-      ...headers,
-      Accept: 'text/event-stream'
-    },
-    signal: abortSignal
-  });
-
-  if (!response.ok || !response.body) {
-    const text = await response.text().catch(() => '');
-    throw new Error(`OpenCode event stream failed: ${response.status} ${text}`);
-  }
-
-  let gotIdle = false;
-  const sentTextByPart = new Map();
-  let assistantText = '';
-  let hasSentUnsupportedImageNotice = false;
-  for await (const evt of createSSEReader(response.body).read()) {
-    if (!evt?.data) continue;
-    let payload;
+    let childProcess = null;
     try {
-      payload = JSON.parse(evt.data);
-    } catch {
-      continue;
-    }
-
-    const eventType = payload?.type;
-    const eventSessionId = getEventSessionId(payload);
-    if (eventSessionId && eventSessionId !== sessionId) {
-      continue;
-    }
-
-    if (eventType === 'session.error') {
-      const errorMessage =
-        payload?.properties?.error?.message ||
-        payload?.properties?.error?.data?.message ||
-        'OpenCode session error';
-      ws.send({
-        type: 'claude-error',
-        provider: 'opencode',
-        sessionId,
-        error: errorMessage
-      });
-      throw new Error(errorMessage);
-    }
-
-    if (eventType === 'session.idle') {
-      gotIdle = true;
-      break;
-    }
-
-    if (eventType === 'message.part.updated') {
-      const part = payload?.properties?.part;
-      if (isReasoningPart(payload, part)) {
-        continue;
-      }
-
-      const role = resolvePartRole(payload, part);
-      const isAssistantPart = role === 'assistant' || (!role && part?.type !== 'input_image');
-      if (!isAssistantPart) continue;
-
-      const partId = String(part?.id || part?.partID || part?.messageID || evt.id || 'unknown');
-      const currentText = extractPartText(part);
-      if (!currentText) continue;
-
-      if (isUnsupportedImageInputText(currentText)) {
-        if (!hasSentUnsupportedImageNotice) {
-          hasSentUnsupportedImageNotice = true;
-          ws.send({
-            type: 'claude-error',
-            provider: 'opencode',
-            sessionId,
-            error: 'Current model does not support image input. Remove attached images or switch to a vision-capable model.'
-          });
-        }
-        continue;
-      }
-
-      if (!role && promptText && currentText.trim() === promptText.trim()) {
-        continue;
-      }
-
-      const previousText = sentTextByPart.get(partId) || '';
-      let delta = '';
-
-      if (currentText.startsWith(previousText)) {
-        delta = currentText.slice(previousText.length);
-      } else if (currentText !== previousText) {
-        let commonPrefix = 0;
-        const maxPrefix = Math.min(previousText.length, currentText.length);
-        while (commonPrefix < maxPrefix && previousText[commonPrefix] === currentText[commonPrefix]) {
-          commonPrefix += 1;
-        }
-        delta = currentText.length > previousText.length
-          ? currentText.slice(commonPrefix)
-          : '';
-      }
-
-      sentTextByPart.set(partId, currentText);
-      if (delta) {
-        assistantText += delta;
-        sendTextDelta(ws, sessionId, delta);
-      }
-    }
-  }
-
-  if (!gotIdle && !abortSignal.aborted) {
-    throw new Error('OpenCode event stream closed before session.idle');
-  }
-
-  return { assistantText };
-}
-
-export async function queryOpencode(command, options = {}, ws) {
-  const {
-    sessionId,
-    cwd,
-    projectPath,
-    model,
-    permissionMode = 'default'
-  } = options;
-
-  const workingDir = resolveWorkingDirectory({ cwd, projectPath });
-  const abortController = new AbortController();
-  let server = null;
-  let resolvedSessionId = sessionId || null;
-
-  try {
-    server = await startOpenCodeServer(workingDir);
-    const headers = authHeaders(server.password, workingDir);
-
-    resolvedSessionId = await createOrReuseSession({
-      baseUrl: server.baseUrl,
-      headers,
-      workingDir,
-      sessionId
-    });
-
-    if (ws.setSessionId && typeof ws.setSessionId === 'function') {
-      ws.setSessionId(resolvedSessionId);
-    }
-
-    if (!sessionId) {
-      ws.send({
-        type: 'session-created',
-        provider: 'opencode',
-        sessionId: resolvedSessionId
+      childProcess = spawnCommand('opencode', ['models'], {
+        cwd: workingDir,
+        stdio: ['ignore', 'pipe', 'pipe'],
+        env: process.env
       });
+    } catch (error) {
+      finalize({ models: [], defaults: {}, connected: [], error: error.message });
+      return;
     }
 
-    await appendLocalSessionEvent(resolvedSessionId, {
-      sessionId: resolvedSessionId,
-      cwd: workingDir,
-      timestamp: new Date().toISOString(),
-      role: 'user',
-      content: command || 'Continue'
-    });
+    const timeoutId = setTimeout(() => {
+      try {
+        childProcess.kill('SIGTERM');
+      } catch {}
+      finalize({ models: [], defaults: {}, connected: [], error: 'Command timeout' });
+    }, 12000);
 
-    activeOpencodeRuns.set(resolvedSessionId, {
-      abortController,
-      server,
-      workingDir,
-      sessionId: resolvedSessionId
+    childProcess.stdout.on('data', (chunk) => {
+      stdout += chunk.toString();
     });
 
-    const eventTask = subscribeEventStream({
-      baseUrl: server.baseUrl,
-      headers,
-      workingDir,
-      sessionId: resolvedSessionId,
-      ws,
-      abortSignal: abortController.signal,
-      promptText: command || ''
+    childProcess.stderr.on('data', (chunk) => {
+      stderr += chunk.toString();
     });
 
-    const modelSpec = parseModel(model);
-    await requestJson(
-      server.baseUrl,
-      `/session/${encodeURIComponent(resolvedSessionId)}/message?directory=${encodeURIComponent(workingDir)}`,
-      {
-        method: 'POST',
-        headers,
-        body: {
-          ...(modelSpec ? { model: modelSpec } : {}),
-          parts: [{ type: 'text', text: command || 'Continue' }]
-        },
-        signal: abortController.signal
-      }
-    );
-
-    const eventResult = await eventTask;
-
-    if (eventResult?.assistantText?.trim()) {
-      await appendLocalSessionEvent(resolvedSessionId, {
-        sessionId: resolvedSessionId,
-        cwd: workingDir,
-        timestamp: new Date().toISOString(),
-        role: 'assistant',
-        content: eventResult.assistantText
+    childProcess.on('close', () => {
+      clearTimeout(timeoutId);
+      finalize({
+        models: parseOpencodeModelList(stdout),
+        defaults: {},
+        connected: [],
+        error: stderr.trim() || null
       });
-    }
-
-    sendContentStop(ws, resolvedSessionId);
-    ws.send({
-      type: 'claude-complete',
-      provider: 'opencode',
-      sessionId: resolvedSessionId,
-      exitCode: 0,
-      isNewSession: !sessionId
     });
-  } catch (error) {
-    if (abortController.signal.aborted) {
-      return;
-    }
 
-    ws.send({
-      type: 'claude-error',
-      provider: 'opencode',
-      sessionId: resolvedSessionId,
-      error: error.message || String(error)
+    childProcess.on('error', (error) => {
+      clearTimeout(timeoutId);
+      finalize({ models: [], defaults: {}, connected: [], error: error.message });
     });
-    throw error;
-  } finally {
-    if (resolvedSessionId) {
-      activeOpencodeRuns.delete(resolvedSessionId);
-    }
-    abortController.abort();
-    if (server?.child) {
-      terminateProcess(server.child);
-    }
-  }
+  });
 }
 
-export function abortOpencodeSession(sessionId) {
-  const run = activeOpencodeRuns.get(sessionId);
-  if (!run) return false;
-
-  run.abortController.abort();
-
-  const headers = authHeaders(run.server.password, run.workingDir || process.cwd());
-  fetch(`${run.server.baseUrl}/session/${encodeURIComponent(sessionId)}/abort?directory=${encodeURIComponent(run.workingDir || process.cwd())}`, {
-    method: 'POST',
-    headers
-  }).catch(() => {});
+export async function queryOpencode(command, options = {}, writer) {
+  return executeAgentPrompt({
+    agentKey: 'opencode',
+    command,
+    options: {
+      ...options
+    },
+    writer
+  });
+}
 
-  terminateProcess(run.server.child);
-  activeOpencodeRuns.delete(sessionId);
-  return true;
+export async function abortOpencodeSession(sessionId) {
+  return abortAgentSession('opencode', sessionId);
 }
 
 export function isOpencodeSessionActive(sessionId) {
-  return activeOpencodeRuns.has(sessionId);
+  return isAgentSessionActive('opencode', sessionId);
 }
 
 export function getActiveOpencodeSessions() {
-  return Array.from(activeOpencodeRuns.keys());
+  return getActiveAgentSessions('opencode');
 }