ticlawk 0.1.12-dev.0

package/src/runtimes/codex/index.mjs

@@ -0,0 +1,306 @@
+/**
+ * Codex runtime entry point.
+ *
+ * Worker-first runtime surface: create sessions, run turns, stream events,
+ * and discover local sessions.
+ */
+
+import { existsSync } from 'node:fs';
+import { basename } from 'node:path';
+import {
+  createCodexSession,
+  runCodexPrompt,
+  streamCodexPrompt,
+  waitForCodexSessionById,
+  discoverCodexSessions,
+  CODEX_SESSIONS_DIR,
+  CODEX_MAX_AGE_MS,
+  getCodexRuntimeHealth,
+  requireCodexPath,
+} from './session.mjs';
+import { buildCodexInputFromInbound } 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,
+  isRuntimeGatewayFailure,
+} from '../../core/runtime-support.mjs';
+
+export const codexRuntime = {
+  name: 'codex',
+
+  // Spawn `codex exec` to create a new session; wait for it to appear in
+  // ~/.codex/sessions/**. Returns { sessionId, cwd, path }. `path` is the
+  // jsonl transcript file location.
+  async createSession({ cwd, text, codexPath }) {
+    const sessionId = await createCodexSession({ cwd, message: text, codexPath });
+    const session = await waitForCodexSessionById(sessionId);
+    return {
+      sessionId,
+      cwd: session?.cwd || cwd,
+      path: session?.path || null,
+    };
+  },
+
+  runTurn({ sessionId, cwd, codexPath }, text, opts = {}) {
+    return runCodexPrompt({
+      sessionId,
+      cwd,
+      message: text,
+      codexPath,
+      input: opts.input,
+      timeoutMs: opts.timeoutMs,
+    });
+  },
+
+  runTurnStream({ sessionId, cwd, codexPath }, text, opts = {}) {
+    return streamCodexPrompt({
+      sessionId,
+      cwd,
+      message: text,
+      codexPath,
+      input: opts.input,
+      timeoutMs: opts.timeoutMs,
+      onEvent: opts.onEvent,
+    });
+  },
+
+  // Enumerate local Codex sessions by walking ~/.codex/sessions/**.
+  // Each entry has { sessionId, cwd, path } from the session_meta line.
+  async listLocalSessions() {
+    return discoverCodexSessions();
+  },
+
+  async resolveBinding(payload) {
+    const requestedCwd = String(payload?.cwd || payload?.workdir || payload?.projectDir || '').trim();
+    const codexPath = requireCodexPath(payload?.codexPath || payload?.runtimePath);
+    const codexVersion = getCodexRuntimeHealth(codexPath).version;
+
+    if (payload?.sessionId) {
+      const sessions = await this.listLocalSessions();
+      const session = sessions.find((entry) => entry.sessionId === payload.sessionId);
+      if (!session) {
+        throw new Error('codex session not found locally');
+      }
+      return {
+        runtime: this.name,
+        displayName: payload.name || basename(session.cwd) || 'Codex',
+        runtimeMeta: {
+          sessionId: session.sessionId,
+          workdir: session.cwd,
+          cwd: session.cwd,
+          path: session.path || null,
+          runtimePath: codexPath,
+          codexPath,
+          codexVersion,
+          rotatePending: false,
+        },
+      };
+    }
+
+    if (!requestedCwd) {
+      throw new Error('cwd or sessionId is required for codex binding');
+    }
+    if (!existsSync(requestedCwd)) {
+      throw new Error(`codex cwd not found locally: ${requestedCwd}`);
+    }
+
+    return {
+      runtime: this.name,
+      displayName: payload.name || basename(requestedCwd) || 'Codex',
+      runtimeMeta: {
+        sessionId: null,
+        workdir: requestedCwd,
+        cwd: requestedCwd,
+        path: null,
+        runtimePath: codexPath,
+        codexPath,
+        codexVersion,
+        rotatePending: false,
+      },
+    };
+  },
+
+  async health(meta = {}) {
+    return getCodexRuntimeHealth(meta?.codexPath || meta?.runtimePath);
+  },
+
+  async deliverTurn(inbound, ctx) {
+    const binding = ctx.getBinding(inbound.bindingId);
+    if (!binding) return false;
+    const adapter = ctx.adapter;
+    const meta = binding.runtimeMeta || {};
+
+    if (!meta.cwd || !existsSync(meta.cwd)) {
+      await sendAdapterMessage(adapter, binding, {
+        type: 'assistant',
+        text: `⚠️ Codex cwd not found: ${meta.cwd || '(missing)'}`,
+        media: [],
+        replyToMessageId: inbound.messageId || null,
+      });
+      return true;
+    }
+
+    const codexInput = inbound.action === 'image'
+      ? await buildCodexInputFromInbound(inbound, 'codex')
+      : null;
+    const message = inbound.action === 'image'
+      ? (codexInput.find((item) => item?.type === 'text')?.text || inbound.text || '(image attached)')
+      : inbound.text;
+
+    const shouldRotate = !meta.sessionId || meta.rotatePending;
+    const deltaAggregator = createDeltaAggregator({
+      flushDelta: async ({ text, sessionId, turnId, cwd }) => {
+        await emitWorkerEvent({
+          adapter,
+          binding,
+          agent: this.name,
+          sessionId: sessionId || meta.sessionId || binding.id,
+          turnId: turnId || null,
+          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 runtimeCodexPath = requireCodexPath(meta.codexPath || meta.runtimePath);
+      const runtimeCodexVersion = getCodexRuntimeHealth(runtimeCodexPath).version || meta.codexVersion || null;
+      const result = (shouldRotate || inbound.action === 'image' || shouldStreamRuntime(this.name, this))
+        ? await this.runTurnStream({ sessionId: shouldRotate ? null : meta.sessionId, cwd: meta.cwd, codexPath: runtimeCodexPath }, message, {
+            input: codexInput,
+            onEvent: async (event) => {
+              if (event?.type === 'turn.started') {
+                await emitWorkerEvent({
+                  adapter,
+                  binding,
+                  agent: this.name,
+                  sessionId: event.sessionId || meta.sessionId || binding.id,
+                  turnId: event.turnId || null,
+                  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,
+                  turnId: event.turnId || null,
+                  cwd: meta.cwd,
+                });
+              }
+            },
+          })
+        : await this.runTurn({ sessionId: meta.sessionId, cwd: meta.cwd, codexPath: runtimeCodexPath }, message, {
+            input: codexInput,
+          });
+
+      await deltaAggregator.flush();
+      const nextBinding = await updateBindingRuntimeMeta(ctx, binding, {
+        sessionId: result?.sessionId || meta.sessionId,
+        cwd: result?.cwd || meta.cwd,
+        path: result?.path || meta.path || null,
+        runtimePath: runtimeCodexPath,
+        codexPath: runtimeCodexPath,
+        codexVersion: runtimeCodexVersion,
+        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,
+        turnId: result?.turnId || null,
+        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(() => {});
+      const failureInfo = err?.info || {
+        ok: false,
+        kind: 'exit-error',
+        errorMessage: err?.message || 'Codex failed',
+        durationMs: 0,
+      };
+      let failureBinding = binding;
+      if (isRuntimeGatewayFailure(failureInfo)) {
+        failureBinding = await updateBindingRuntimeMeta(ctx, binding, {
+          rotatePending: true,
+          lastGatewayFailureAt: new Date().toISOString(),
+          lastGatewayFailureReason: failureInfo.errorMessage || err?.message || 'Codex app-server error',
+        }, { status: 'degraded' }).catch(() => binding);
+      }
+      await emitWorkerEvent({
+        adapter,
+        binding: failureBinding,
+        agent: this.name,
+        sessionId: meta.sessionId || binding.id,
+        turnId: failureInfo?.turnId || null,
+        cwd: meta.cwd,
+        replyToMessageId: inbound.messageId || null,
+        event: {
+          hook_event_name: 'worker.turn.error',
+          worker_event_name: 'worker.turn.error',
+          error: err?.message || 'Codex failed',
+        },
+        logger: ctx.logger,
+      });
+      await reportSubprocessFailure({
+        adapter,
+        binding: failureBinding,
+        inbound,
+        runtimeName: 'Codex',
+        info: failureInfo,
+      });
+      return terminalRuntimeFailure(err?.message || 'Codex 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;
+  },
+
+  sessionsDir: CODEX_SESSIONS_DIR,
+  maxAgeMs: CODEX_MAX_AGE_MS,
+};
+
+export default codexRuntime;