@axhub/genie 0.2.6 → 0.2.7

package/server/_legacy-providers/opencode-cli.js

@@ -0,0 +1,674 @@
+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 { 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
+  ]
+    .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`);
+}
+
+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 {
+  }
+}
+
+async function waitForServerUrl(child, timeoutMs = 30000) {
+  return new Promise((resolve, reject) => {
+    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 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;
+    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
+      });
+    }
+
+    await appendLocalSessionEvent(resolvedSessionId, {
+      sessionId: resolvedSessionId,
+      cwd: workingDir,
+      timestamp: new Date().toISOString(),
+      role: 'user',
+      content: command || 'Continue'
+    });
+
+    activeOpencodeRuns.set(resolvedSessionId, {
+      abortController,
+      server,
+      workingDir,
+      sessionId: resolvedSessionId
+    });
+
+    const eventTask = subscribeEventStream({
+      baseUrl: server.baseUrl,
+      headers,
+      workingDir,
+      sessionId: resolvedSessionId,
+      ws,
+      abortSignal: abortController.signal,
+      promptText: command || ''
+    });
+
+    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
+      });
+    }
+
+    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)
+    });
+    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(() => {});
+
+  terminateProcess(run.server.child);
+  activeOpencodeRuns.delete(sessionId);
+  return true;
+}
+
+export function isOpencodeSessionActive(sessionId) {
+  return activeOpencodeRuns.has(sessionId);
+}
+
+export function getActiveOpencodeSessions() {
+  return Array.from(activeOpencodeRuns.keys());
+}