@gakim-digital/dexter-bridge 0.5.21 → 0.11.0

package/src/providers/openCode.js

@@ -0,0 +1,607 @@
+import crypto from 'node:crypto';
+import net from 'node:net';
+import os from 'node:os';
+import path from 'node:path';
+import { mkdtempSync, rmSync } from 'node:fs';
+import crossSpawn from 'cross-spawn';
+import { createOpencodeClient } from '@opencode-ai/sdk';
+import { normalizeCompanionTokenUsage } from '../agentOutput.js';
+import {
+  assertOutcomeResponseContract,
+  STRUCTURED_RESPONSE_CONTRACTS,
+} from '../protocol.js';
+
+function availablePort() {
+  return new Promise((resolve, reject) => {
+    const server = net.createServer();
+    server.unref();
+    server.once('error', reject);
+    server.listen(0, '127.0.0.1', () => {
+      const address = server.address();
+      const port = typeof address === 'object' && address ? address.port : 0;
+      server.close((error) => (error ? reject(error) : resolve(port)));
+    });
+  });
+}
+
+function waitForServer(child, client, timeoutMs = 10_000) {
+  return new Promise((resolve, reject) => {
+    let settled = false;
+    const timer = setTimeout(() => {
+      settled = true;
+      cleanup();
+      reject(new Error('OpenCode server did not start before the timeout.'));
+    }, timeoutMs);
+    timer.unref?.();
+    const failed = (error) => {
+      if (settled) return;
+      settled = true;
+      cleanup();
+      reject(error instanceof Error ? error : new Error(String(error)));
+    };
+    const exited = (code) =>
+      failed(new Error(`OpenCode server exited before startup completed (${code ?? 'unknown'}).`));
+    function cleanup() {
+      clearTimeout(timer);
+      child.off('error', failed);
+      child.off('exit', exited);
+    }
+    child.once('error', failed);
+    child.once('exit', exited);
+    const probe = async () => {
+      while (!settled) {
+        try {
+          await client.provider.list();
+          settled = true;
+          cleanup();
+          resolve();
+          return;
+        } catch {
+          await new Promise((next) => setTimeout(next, 100));
+        }
+      }
+    };
+    void probe();
+  });
+}
+
+function basicAuth(password) {
+  return `Basic ${Buffer.from(`opencode:${password}`, 'utf8').toString('base64')}`;
+}
+
+function modelParts(value) {
+  const raw = String(value || '').trim();
+  const slash = raw.indexOf('/');
+  return slash > 0 ? { providerID: raw.slice(0, slash), modelID: raw.slice(slash + 1) } : undefined;
+}
+
+function responseText(response) {
+  const data = response?.data || response;
+  const parts = Array.isArray(data?.parts) ? data.parts : [];
+  return parts
+    .filter((part) => part?.type === 'text' && typeof part.text === 'string')
+    .map((part) => part.text)
+    .join('');
+}
+
+function openCodeEventSessionId(event) {
+  const properties = event?.properties || {};
+  return (
+    properties.sessionID ||
+    properties.sessionId ||
+    properties.info?.sessionID ||
+    properties.info?.sessionId ||
+    properties.part?.sessionID ||
+    properties.part?.sessionId ||
+    null
+  );
+}
+
+function openCodeProgressKind(event) {
+  if (event?.type === 'message.part.updated') {
+    return event.properties?.part?.type === 'reasoning' ? 'reasoning_delta' : 'output_delta';
+  }
+  if (event?.type === 'message.updated') return 'item_completed';
+  if (event?.type === 'session.status') {
+    return event.properties?.status?.type === 'retry' ? 'provider_retry' : 'item_started';
+  }
+  return null;
+}
+
+export function openCodeOutcomeConfig(harnessTools, directory) {
+  const framerHarness = Array.isArray(harnessTools?.definitions)
+    && harnessTools.definitions.some((tool) =>
+      String(tool?.name || '').startsWith('framer_'));
+  return {
+    share: 'disabled',
+    autoupdate: false,
+    snapshot: false,
+    plugin: [],
+    mcp: harnessTools?.mcpServer
+      ? {
+          instawebai: {
+            type: 'local',
+            command: [
+              harnessTools.mcpServer.command,
+              ...(harnessTools.mcpServer.args || []),
+            ],
+            cwd: harnessTools.mcpServer.cwd || directory,
+            environment: harnessTools.mcpServer.environment || {},
+            enabled: true,
+            timeout: 30_000,
+          },
+        }
+      : {},
+    lsp: false,
+    formatter: false,
+    instructions: [],
+    permission: {
+      edit: framerHarness ? 'deny' : 'allow',
+      bash: framerHarness ? 'deny' : 'allow',
+      webfetch: framerHarness ? 'deny' : 'allow',
+      doom_loop: 'deny',
+      external_directory: 'deny',
+    },
+    tools: {
+      bash: !framerHarness,
+      edit: !framerHarness,
+      write: !framerHarness,
+      read: !framerHarness,
+      glob: !framerHarness,
+      grep: !framerHarness,
+      webfetch: !framerHarness,
+      websearch: false,
+      codesearch: false,
+      task: false,
+    },
+  };
+}
+
+export function createOpenCodeAdapter({ profile, env = process.env, trace } = {}) {
+  if (!profile?.id) throw new Error('An OpenCode runtime profile is required.');
+  const command = profile.command || env.DEXTER_BRIDGE_OPENCODE_BIN || 'opencode';
+  const sessions = new Map();
+  const activeTurns = new Map();
+  let server = null;
+  let starting = null;
+  const workspace = mkdtempSync(path.join(os.tmpdir(), 'instawebai-opencode-'));
+
+  async function ensureServer() {
+    if (server) return server;
+    if (starting) return starting;
+    starting = (async () => {
+      const port = await availablePort();
+      const password = crypto.randomBytes(32).toString('base64url');
+      const config = {
+        share: 'disabled',
+        autoupdate: false,
+        snapshot: false,
+        plugin: [],
+        mcp: {},
+        lsp: false,
+        formatter: false,
+        instructions: [],
+        permission: {
+          edit: 'deny',
+          bash: 'deny',
+          webfetch: 'deny',
+          doom_loop: 'deny',
+          external_directory: 'deny',
+        },
+        tools: {
+          bash: false,
+          edit: false,
+          write: false,
+          read: false,
+          glob: false,
+          grep: false,
+          webfetch: false,
+          websearch: false,
+          codesearch: false,
+          task: false,
+        },
+      };
+      const child = crossSpawn(command, ['serve', '--hostname=127.0.0.1', `--port=${port}`], {
+        cwd: workspace,
+        env: {
+          ...env,
+          OPENCODE_SERVER_PASSWORD: password,
+          OPENCODE_CONFIG_CONTENT: JSON.stringify(config),
+        },
+        stdio: ['ignore', 'pipe', 'pipe'],
+      });
+      child.stdout?.resume();
+      child.stderr?.resume();
+      const url = `http://127.0.0.1:${port}`;
+      const client = createOpencodeClient({
+        baseUrl: url,
+        directory: workspace,
+        headers: { Authorization: basicAuth(password) },
+        throwOnError: true,
+      });
+      try {
+        await waitForServer(child, client);
+      } catch (error) {
+        if (!child.killed) child.kill('SIGTERM');
+        throw error;
+      }
+      server = { child, client, url };
+      child.once('exit', () => {
+        if (server?.child === child) server = null;
+      });
+      return server;
+    })();
+    try {
+      return await starting;
+    } finally {
+      starting = null;
+    }
+  }
+
+  async function detect() {
+    return new Promise((resolve) => {
+      const child = crossSpawn(command, ['--version'], {
+        env,
+        stdio: ['ignore', 'pipe', 'pipe'],
+      });
+      let output = '';
+      child.stdout?.on('data', (chunk) => {
+        output = `${output}${chunk.toString('utf8')}`.slice(-4096);
+      });
+      child.stderr?.on('data', (chunk) => {
+        output = `${output}${chunk.toString('utf8')}`.slice(-4096);
+      });
+      child.once('error', (error) =>
+        resolve({
+          ok: false,
+          installed: false,
+          signedIn: false,
+          agent: 'opencode',
+          error: error.message,
+        }),
+      );
+      child.once('exit', (code) =>
+        resolve({
+          ok: code === 0,
+          installed: code === 0,
+          signedIn: code === 0,
+          agent: 'opencode',
+          version: output.trim() || null,
+          ...(code === 0 ? {} : { error: output.trim() || 'OpenCode is unavailable.' }),
+        }),
+      );
+    });
+  }
+
+  async function models() {
+    const active = await ensureServer();
+    const response = await active.client.provider.list();
+    const data = response?.data || response;
+    const providers = Array.isArray(data?.all) ? data.all : Array.isArray(data) ? data : [];
+    const connected = new Set(Array.isArray(data?.connected) ? data.connected : []);
+    return providers
+      .filter((provider) => connected.has(provider.id))
+      .flatMap((provider) =>
+        Object.values(provider?.models || {}).map((model) => ({
+          id: `opencode:${provider.id}/${model.id}`,
+          agent: 'opencode',
+          provider: provider.id,
+          displayName: model.name || model.id,
+          invocationName: `${provider.id}/${model.id}`,
+          costTier: '$$',
+          description: `OpenCode ${provider.name || provider.id} model.`,
+          capabilities: {
+            tools: model.tool_call !== false,
+            vision: Boolean(model.attachment || model.modalities?.input?.includes?.('image')),
+            structuredOutput: true,
+            sessionResume: true,
+          },
+        })),
+      );
+  }
+
+  async function ensureSession(key) {
+    if (sessions.has(key)) return sessions.get(key);
+    const active = await ensureServer();
+    const response = await active.client.session.create({
+      body: {
+        title: 'InstaWebAI model session',
+      },
+    });
+    const sessionId = response?.data?.id || response?.id;
+    if (!sessionId) throw new Error('OpenCode did not create a session.');
+    sessions.set(key, sessionId);
+    return sessionId;
+  }
+
+  async function runModelTurn({
+    runId,
+    sessionId,
+    prompt,
+    model,
+    timeoutMs = 180_000,
+    maxDurationMs = 15 * 60_000,
+    onProgress,
+  } = {}) {
+    const turnKey = sessionId || runId;
+    if (!turnKey) throw new Error('OpenCode model turn requires a session id.');
+    const active = await ensureServer();
+    const openCodeSessionId = await ensureSession(turnKey);
+    const controller = new AbortController();
+    let deadlineReached = false;
+    let deadlineAbort = Promise.resolve();
+    const timer = setTimeout(() => {
+      deadlineReached = true;
+      controller.abort();
+      deadlineAbort = active.client.session
+        .abort({
+          path: { id: openCodeSessionId },
+        })
+        .catch(() => undefined);
+    }, maxDurationMs);
+    timer.unref?.();
+    activeTurns.set(turnKey, { controller, openCodeSessionId });
+    const eventController = new AbortController();
+    const eventMonitor = active.client.event
+      .subscribe({ signal: eventController.signal })
+      .then(async (subscription) => {
+        for await (const event of subscription.stream) {
+          if (openCodeEventSessionId(event) && openCodeEventSessionId(event) !== openCodeSessionId) {
+            continue;
+          }
+          const kind = openCodeProgressKind(event);
+          if (!kind) continue;
+          onProgress?.({
+            kind,
+            provider: 'opencode',
+            occurredAt: new Date().toISOString(),
+          });
+        }
+      })
+      .catch((error) => {
+        if (!eventController.signal.aborted) {
+          trace?.warn?.('opencode_progress_stream_failed', {
+            profileId: profile.id,
+            message: error instanceof Error ? error.message : String(error),
+          });
+        }
+      });
+    try {
+      onProgress?.({
+        kind: 'turn_started',
+        provider: 'opencode',
+        occurredAt: new Date().toISOString(),
+      });
+      const response = await active.client.session.prompt({
+        path: { id: openCodeSessionId },
+        body: {
+          ...(modelParts(model) ? { model: modelParts(model) } : {}),
+          tools: {
+            bash: false,
+            edit: false,
+            write: false,
+            read: false,
+            glob: false,
+            grep: false,
+            webfetch: false,
+            websearch: false,
+            codesearch: false,
+            task: false,
+          },
+          parts: [{ type: 'text', text: String(prompt || '') }],
+        },
+        signal: controller.signal,
+      });
+      const data = response?.data || response;
+      return {
+        text: responseText(response),
+        sessionId: openCodeSessionId,
+        tokenUsage: normalizeCompanionTokenUsage(data?.info?.tokens || {}),
+        usageAvailable: Boolean(data?.info?.tokens),
+        usageSource: 'opencode',
+        usageAccuracy: 'reported',
+      };
+    } catch (error) {
+      if (deadlineReached) {
+        await deadlineAbort;
+        throw Object.assign(new Error(`The model turn exceeded the ${maxDurationMs}ms safety limit.`), {
+          code: 'APP_AGENT_TURN_HARD_TIMEOUT',
+          retryable: true,
+        });
+      }
+      if (controller.signal.aborted) {
+        throw Object.assign(new Error('OpenCode model turn was cancelled.'), {
+          code: 'RUN_CANCELLED',
+        });
+      }
+      throw error;
+    } finally {
+      clearTimeout(timer);
+      eventController.abort();
+      await eventMonitor;
+      activeTurns.delete(turnKey);
+    }
+  }
+
+  async function runOutcome({
+    runId,
+    sessionId,
+    prompt,
+    model,
+    cwd,
+    maxDurationMs = 15 * 60_000,
+    onProgress,
+    harnessTools,
+    outputSchema,
+    responseContract = STRUCTURED_RESPONSE_CONTRACTS.OUTCOME,
+    resumeSessionId,
+  } = {}) {
+    assertOutcomeResponseContract(responseContract, outputSchema);
+    const turnKey = sessionId || runId;
+    if (!turnKey) throw new Error('OpenCode outcome run requires a session id.');
+    const directory = cwd || workspace;
+    const port = await availablePort();
+    const password = crypto.randomBytes(32).toString('base64url');
+    const config = openCodeOutcomeConfig(harnessTools, directory);
+    const framerHarness = Array.isArray(harnessTools?.definitions)
+      && harnessTools.definitions.some((tool) =>
+        String(tool?.name || '').startsWith('framer_'));
+    const child = crossSpawn(command, ['serve', '--hostname=127.0.0.1', `--port=${port}`], {
+      cwd: directory,
+      env: {
+        ...env,
+        OPENCODE_SERVER_PASSWORD: password,
+        OPENCODE_CONFIG_CONTENT: JSON.stringify(config),
+      },
+      stdio: ['ignore', 'pipe', 'pipe'],
+    });
+    child.stdout?.resume();
+    child.stderr?.resume();
+    const client = createOpencodeClient({
+      baseUrl: `http://127.0.0.1:${port}`,
+      directory,
+      headers: { Authorization: basicAuth(password) },
+      throwOnError: true,
+    });
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), maxDurationMs);
+    timer.unref?.();
+    activeTurns.set(turnKey, {
+      controller,
+      openCodeSessionId: null,
+      client,
+      child,
+    });
+    try {
+      await waitForServer(child, client);
+      let openCodeSessionId = sessions.get(turnKey) || resumeSessionId;
+      if (!openCodeSessionId) {
+        const created = await client.session.create({
+          body: { title: 'InstaWebAI app-builder session' },
+        });
+        openCodeSessionId = created?.data?.id || created?.id;
+        if (!openCodeSessionId) {
+          throw new Error('OpenCode did not create an outcome session.');
+        }
+        sessions.set(turnKey, openCodeSessionId);
+      }
+      activeTurns.set(turnKey, {
+        controller,
+        openCodeSessionId,
+        client,
+        child,
+      });
+      onProgress?.({
+        kind: 'turn_started',
+        provider: 'opencode',
+        occurredAt: new Date().toISOString(),
+      });
+      const response = await client.session.prompt({
+        path: { id: openCodeSessionId },
+        body: {
+          ...(modelParts(model) ? { model: modelParts(model) } : {}),
+          tools: {
+            bash: !framerHarness,
+            edit: !framerHarness,
+            write: !framerHarness,
+            read: !framerHarness,
+            glob: !framerHarness,
+            grep: !framerHarness,
+            webfetch: false,
+            websearch: false,
+            codesearch: false,
+            task: false,
+          },
+          parts: [{ type: 'text', text: String(prompt || '') }],
+        },
+        signal: controller.signal,
+      });
+      const data = response?.data || response;
+      return {
+        text: responseText(response),
+        sessionId: openCodeSessionId,
+        tokenUsage: normalizeCompanionTokenUsage(data?.info?.tokens || {}),
+        usageAvailable: Boolean(data?.info?.tokens),
+        usageSource: 'opencode',
+        usageAccuracy: 'reported',
+      };
+    } finally {
+      clearTimeout(timer);
+      activeTurns.delete(turnKey);
+      if (!child.killed) child.kill('SIGTERM');
+    }
+  }
+
+  async function cancel(sessionId) {
+    const active = activeTurns.get(sessionId);
+    if (!active) return;
+    active.controller.abort();
+    const runningClient = active.client || (await ensureServer().catch(() => null))?.client;
+    if (active.openCodeSessionId) {
+      await runningClient?.session
+        .abort({
+          path: { id: active.openCodeSessionId },
+        })
+        .catch(() => undefined);
+    }
+    if (active.child && !active.child.killed) active.child.kill('SIGTERM');
+  }
+
+  async function resetSession(sessionId) {
+    const openCodeSessionId = sessions.get(sessionId);
+    sessions.delete(sessionId);
+    if (!openCodeSessionId) return;
+    const active = await ensureServer().catch(() => null);
+    await active?.client.session
+      .delete({
+        path: { id: openCodeSessionId },
+      })
+      .catch(() => undefined);
+  }
+
+  function close() {
+    for (const { controller, child } of activeTurns.values()) {
+      controller.abort();
+      if (child && !child.killed) child.kill('SIGTERM');
+    }
+    activeTurns.clear();
+    sessions.clear();
+    if (server?.child && !server.child.killed) server.child.kill('SIGTERM');
+    server = null;
+    try {
+      rmSync(workspace, { recursive: true, force: true });
+    } catch {
+      // The operating system can clean the temporary directory.
+    }
+    trace?.info?.('opencode_adapter_closed', { profileId: profile.id });
+  }
+
+  return {
+    id: profile.id,
+    driverKind: 'opencode',
+    label: profile.label || 'OpenCode',
+    detect,
+    models,
+    runModelTurn,
+    runOutcome,
+    harnessCapabilities: {
+      outcomeExecution: true,
+      workspaceSnapshot: true,
+      workspaceWrite: true,
+      shell: true,
+      projectShell: true,
+      preview: true,
+      browser: true,
+      dataInspection: true,
+      verification: true,
+      standardTools: true,
+      structuredResult: true,
+      progress: true,
+      cancellation: true,
+      sessionResume: true,
+    },
+    cancel,
+    resetSession,
+    close,
+  };
+}