ticlawk 0.1.12-dev.0

package/src/runtimes/opencode/index.mjs

@@ -0,0 +1,318 @@
+/**
+ * opencode runtime entry point.
+ *
+ * Wraps the opencode CLI (https://opencode.ai). Exposes the runtime
+ * surface that adapters drive: resolve a binding, deliver a turn,
+ * reconcile after restart. Session lifecycle and the `opencode run`
+ * subprocess live in `./session.mjs`.
+ */
+
+import { existsSync } from 'node:fs';
+import { basename } from 'node:path';
+import {
+  createOpenCodeSession,
+  getOpenCodeRuntimeHealth,
+  runOpenCodePrompt,
+  streamOpenCodePrompt,
+  findOpenCodeSessionById,
+  discoverOpenCodeSessions,
+  OPENCODE_DATA_DIR,
+  OPENCODE_MAX_AGE_MS,
+  requireOpenCodePath,
+} from './session.mjs';
+import { buildOpenCodeInputFromInbound } from '../../core/media/inbound.mjs';
+import { normalizeOutboundMedia } from '../../core/media/outbound.mjs';
+import { emitWorkerEvent } from '../../core/events/worker-events.mjs';
+import {
+  shouldStreamRuntime,
+  createDeltaAggregator,
+  sendAdapterMessage,
+  sendResult,
+  reportSubprocessFailure,
+  terminalRuntimeFailure,
+  updateBindingRuntimeMeta,
+} from '../../core/runtime-support.mjs';
+
+export const openCodeRuntime = {
+  name: 'opencode',
+
+  async createSession({ cwd, text, opencodePath }) {
+    return createOpenCodeSession({ cwd, message: text, opencodePath });
+  },
+
+  runTurn({ sessionId, cwd, opencodePath }, text, opts = {}) {
+    return runOpenCodePrompt({
+      sessionId,
+      cwd,
+      message: text,
+      opencodePath,
+      files: opts.files,
+      timeoutMs: opts.timeoutMs,
+    });
+  },
+
+  runTurnStream({ sessionId, cwd, opencodePath }, text, opts = {}) {
+    return streamOpenCodePrompt({
+      sessionId,
+      cwd,
+      message: text,
+      opencodePath,
+      files: opts.files,
+      timeoutMs: opts.timeoutMs,
+      onEvent: opts.onEvent,
+    });
+  },
+
+  async listLocalSessions(cwd, opencodePath = null) {
+    return discoverOpenCodeSessions(cwd, { opencodePath });
+  },
+
+  async resolveBinding(payload) {
+    const requestedCwd = String(payload?.cwd || payload?.workdir || payload?.projectDir || '').trim();
+    const opencodePath = requireOpenCodePath(payload?.opencodePath || payload?.runtimePath);
+    const opencodeVersion = getOpenCodeRuntimeHealth(opencodePath).version;
+
+    if (payload?.sessionId) {
+      // opencode `session list` is project-scoped, so we need a cwd to
+      // verify the session even exists. Surface this requirement clearly
+      // rather than silently failing during the next turn.
+      if (!requestedCwd) {
+        throw new Error('opencode requires --workdir along with --session-id');
+      }
+      if (!existsSync(requestedCwd)) {
+        throw new Error(`opencode cwd not found locally: ${requestedCwd}`);
+      }
+      const session = await findOpenCodeSessionById(payload.sessionId, requestedCwd, { opencodePath });
+      if (!session) {
+        throw new Error(`opencode session ${payload.sessionId} not found in ${requestedCwd}`);
+      }
+      return {
+        runtime: this.name,
+        displayName: payload.name || session.title || basename(requestedCwd) || 'opencode',
+        runtimeMeta: {
+          sessionId: session.sessionId,
+          workdir: requestedCwd,
+          cwd: requestedCwd,
+          runtimePath: opencodePath,
+          opencodePath,
+          opencodeVersion,
+          rotatePending: false,
+        },
+      };
+    }
+
+    if (!requestedCwd) {
+      throw new Error('cwd or sessionId is required for opencode binding');
+    }
+    if (!existsSync(requestedCwd)) {
+      throw new Error(`opencode cwd not found locally: ${requestedCwd}`);
+    }
+
+    return {
+      runtime: this.name,
+      displayName: payload.name || basename(requestedCwd) || 'opencode',
+      runtimeMeta: {
+        sessionId: null,
+        workdir: requestedCwd,
+        cwd: requestedCwd,
+        runtimePath: opencodePath,
+        opencodePath,
+        opencodeVersion,
+        rotatePending: false,
+      },
+    };
+  },
+
+  async health(meta = {}) {
+    return getOpenCodeRuntimeHealth(meta?.opencodePath || meta?.runtimePath);
+  },
+
+  async deliverTurn(inbound, ctx) {
+    const binding = ctx.getBinding(inbound.bindingId);
+    if (!binding) return false;
+    const adapter = ctx.adapter;
+    const meta = binding.runtimeMeta || {};
+    const runtimeOpenCodePath = meta.opencodePath || meta.runtimePath || null;
+
+    if (!meta.cwd || !existsSync(meta.cwd)) {
+      await sendAdapterMessage(adapter, binding, {
+        type: 'assistant',
+        text: `⚠️ opencode cwd not found: ${meta.cwd || '(missing)'}`,
+        media: [],
+        replyToMessageId: inbound.messageId || null,
+      });
+      return true;
+    }
+
+    // For image inbound, resolve the attached media to local file paths
+    // and forward them to opencode via `--file` (mirrors how Codex uses
+    // buildCodexInputFromInbound). If downloads fail and there's no
+    // caption to fall back on, stop early — sending an empty prompt
+    // would burn tokens for no reason.
+    let files = [];
+    let message = inbound.text || '';
+    if (inbound.action === 'image') {
+      const ocInput = await buildOpenCodeInputFromInbound(inbound, 'opencode');
+      files = ocInput.files;
+      const captionText = (inbound.text || '').trim();
+
+      if (files.length === 0 && !captionText) {
+        await sendAdapterMessage(adapter, binding, {
+          type: 'assistant',
+          text: '⚠️ Image attached, but I could not access the image data and there is no caption to fall back to. Try sending the image again, or include a text caption.',
+          media: [],
+          replyToMessageId: inbound.messageId || null,
+        });
+        return true;
+      }
+
+      if (files.length === 0 && captionText) {
+        // Downloads all failed; tell the user we're proceeding with the caption alone.
+        await sendAdapterMessage(adapter, binding, {
+          type: 'assistant',
+          text: '⚠️ Could not access the attached image data; acting on the caption text only.',
+          media: [],
+          replyToMessageId: inbound.messageId || null,
+        });
+      }
+
+      // If user sent images with no caption, give the model a minimal
+      // instruction so it has something to anchor on.
+      message = captionText || 'Please analyze the attached image(s).';
+    }
+    const shouldRotate = !meta.sessionId || meta.rotatePending;
+
+    const deltaAggregator = createDeltaAggregator({
+      flushDelta: async ({ text, sessionId, cwd }) => {
+        await emitWorkerEvent({
+          adapter,
+          binding,
+          agent: this.name,
+          sessionId: sessionId || meta.sessionId || binding.id,
+          cwd: cwd || meta.cwd,
+          replyToMessageId: inbound.messageId || null,
+          event: {
+            hook_event_name: 'worker.message.delta',
+            worker_event_name: 'worker.message.delta',
+            delta: text,
+          },
+          logger: ctx.logger,
+        });
+      },
+    });
+
+    try {
+      const opencodePath = requireOpenCodePath(runtimeOpenCodePath);
+      const opencodeVersion = getOpenCodeRuntimeHealth(opencodePath).version || meta.opencodeVersion || null;
+      const result = shouldStreamRuntime(this.name, this)
+        ? await this.runTurnStream({ sessionId: shouldRotate ? null : meta.sessionId, cwd: meta.cwd, opencodePath }, message, {
+            files,
+            onEvent: async (event) => {
+              if (event?.type === 'turn.started') {
+                await emitWorkerEvent({
+                  adapter,
+                  binding,
+                  agent: this.name,
+                  sessionId: event.sessionId || meta.sessionId || binding.id,
+                  cwd: meta.cwd,
+                  replyToMessageId: inbound.messageId || null,
+                  event: {
+                    hook_event_name: 'worker.turn.start',
+                    worker_event_name: 'worker.turn.start',
+                  },
+                  logger: ctx.logger,
+                });
+              } else if (event?.type === 'message.delta' && event.text) {
+                deltaAggregator.push(event.text, {
+                  sessionId: event.sessionId || meta.sessionId || binding.id,
+                  cwd: meta.cwd,
+                });
+              }
+            },
+          })
+        : await this.runTurn({ sessionId: shouldRotate ? null : meta.sessionId, cwd: meta.cwd, opencodePath }, message, { files });
+
+      await deltaAggregator.flush();
+
+      const nextBinding = await updateBindingRuntimeMeta(ctx, binding, {
+        sessionId: result?.sessionId || meta.sessionId,
+        cwd: result?.cwd || meta.cwd,
+        runtimePath: opencodePath,
+        opencodePath,
+        opencodeVersion,
+        rotatePending: false,
+        lastRotatedAt: shouldRotate ? new Date().toISOString() : meta.lastRotatedAt,
+      }, { status: 'connected' });
+      await sendResult(adapter, nextBinding, inbound, {
+        ...result,
+        media: normalizeOutboundMedia(result),
+      });
+      await emitWorkerEvent({
+        adapter,
+        binding: nextBinding,
+        agent: this.name,
+        sessionId: result?.sessionId || meta.sessionId || binding.id,
+        cwd: result?.cwd || meta.cwd,
+        replyToMessageId: inbound.messageId || null,
+        event: {
+          hook_event_name: 'Stop',
+          worker_event_name: 'worker.turn.complete',
+        },
+        logger: ctx.logger,
+      });
+      return true;
+    } catch (err) {
+      await deltaAggregator.flush().catch(() => {});
+      await emitWorkerEvent({
+        adapter,
+        binding,
+        agent: this.name,
+        sessionId: meta.sessionId || binding.id,
+        cwd: meta.cwd,
+        replyToMessageId: inbound.messageId || null,
+        event: {
+          hook_event_name: 'worker.turn.error',
+          worker_event_name: 'worker.turn.error',
+          error: err?.message || 'opencode failed',
+        },
+        logger: ctx.logger,
+      });
+      await reportSubprocessFailure({
+        adapter,
+        binding,
+        inbound,
+        runtimeName: 'opencode',
+        info: err?.info || {
+          ok: false,
+          kind: 'exit-error',
+          errorMessage: err?.message || 'opencode failed',
+          durationMs: 0,
+        },
+      });
+      return terminalRuntimeFailure(err?.message || 'opencode failed');
+    }
+  },
+
+  async reconcileAfterRestart(binding, ctx) {
+    const meta = binding.runtimeMeta || {};
+    await emitWorkerEvent({
+      adapter: ctx.adapter,
+      binding,
+      agent: this.name,
+      sessionId: meta.sessionId || binding.id,
+      cwd: meta.cwd || '',
+      event: {
+        hook_event_name: 'Stop',
+        worker_event_name: 'worker.turn.complete',
+        reason: 'connector.restart.reconcile',
+      },
+      logger: ctx.logger,
+    });
+    return 1;
+  },
+
+  dataDir: OPENCODE_DATA_DIR,
+  maxAgeMs: OPENCODE_MAX_AGE_MS,
+};
+
+export default openCodeRuntime;