@ymdvsymd/tornado 0.5.0

package/sdk/codex-adapter.mts

@@ -0,0 +1,140 @@
+import { Codex } from "@openai/codex-sdk";
+import type {
+  AdapterEmission,
+  AdapterStartResult,
+  AgentAdapter,
+  RunnerOptions,
+} from "./agent-adapter.mjs";
+import {
+  formatTurnCompletedLog,
+  formatTurnFailedLog,
+  normalizeItemComplete,
+  normalizeItemStart,
+  normalizeTurnCompleted,
+  normalizeTurnFailed,
+} from "./codex-normalizer.mjs";
+
+type CodexThreadOptions = {
+  model?: string;
+  workingDirectory: string;
+  approvalPolicy: "never";
+};
+
+type CodexThread = {
+  id: string;
+  runStreamed(prompt: string): Promise<{ events: AsyncIterable<CodexEvent> }>;
+};
+
+type CodexClient = {
+  startThread(opts: CodexThreadOptions): CodexThread;
+  resumeThread(threadId: string, opts: CodexThreadOptions): CodexThread;
+};
+
+type CodexItem = {
+  type?: string;
+  _display?: string;
+  [key: string]: unknown;
+};
+
+type CodexEvent = {
+  type?: string;
+  usage?: {
+    input_tokens?: number;
+    output_tokens?: number;
+    cached_input_tokens?: number;
+  };
+  error?: { message?: string };
+  item?: CodexItem;
+};
+
+export function createCodexAdapter(
+  client: CodexClient = new Codex() as unknown as CodexClient,
+): AgentAdapter<CodexEvent> {
+  return {
+    tag: "Codex",
+    async start(opts: RunnerOptions): Promise<AdapterStartResult<CodexEvent>> {
+      const threadOpts: CodexThreadOptions = {
+        model: opts.model || undefined,
+        workingDirectory: opts.cwd || process.cwd(),
+        approvalPolicy: "never",
+      };
+
+      const logs: string[] = [];
+      const thread = opts.threadId
+        ? resumeThread(client, opts.threadId, threadOpts, logs)
+        : startThread(client, threadOpts, logs);
+
+      logs.push(`Thread: ${thread.id}`);
+      const run = await thread.runStreamed(opts.prompt);
+
+      return {
+        sessionId: thread.id,
+        initEvents: [
+          {
+            type: "system",
+            subtype: "init",
+            session_id: thread.id,
+            model: opts.model || "default",
+          },
+        ],
+        initLogs: logs,
+        stream: run.events,
+      };
+    },
+    emit(raw: CodexEvent, sessionId: string): readonly AdapterEmission[] {
+      switch (raw.type) {
+        case "item.started":
+          return emitItemStart(raw.item);
+        case "item.completed":
+          return emitItemComplete(raw.item);
+        case "turn.completed": {
+          const resultEvent = normalizeTurnCompleted(raw, sessionId);
+          return [{ event: resultEvent, log: formatTurnCompletedLog(raw) }];
+        }
+        case "turn.failed": {
+          const errorEvent = normalizeTurnFailed(raw, sessionId);
+          return [{ event: errorEvent, log: formatTurnFailedLog(raw) }];
+        }
+        default:
+          return [];
+      }
+    },
+  };
+}
+
+function resumeThread(
+  client: CodexClient,
+  threadId: string,
+  opts: CodexThreadOptions,
+  logs: string[],
+): CodexThread {
+  logs.push(`Resuming thread: ${threadId}`);
+  return client.resumeThread(threadId, opts);
+}
+
+function startThread(
+  client: CodexClient,
+  opts: CodexThreadOptions,
+  logs: string[],
+): CodexThread {
+  logs.push("Starting new thread");
+  return client.startThread(opts);
+}
+
+function emitItemStart(item: CodexItem | undefined): readonly AdapterEmission[] {
+  const normalized = normalizeItemStart(item || {});
+  if (!normalized) return [];
+  const display = typeof normalized._display === "string"
+    ? normalized._display
+    : item?.type || "item.started";
+  return [{ event: normalized, log: display }];
+}
+
+function emitItemComplete(item: CodexItem | undefined): readonly AdapterEmission[] {
+  const normalized = normalizeItemComplete(item || {});
+  if (!normalized) return [];
+  const display = typeof normalized._display === "string"
+    ? normalized._display
+    : item?.type || "item.completed";
+  return [{ event: normalized, log: `Done: ${display}` }];
+}

package/sdk/codex-normalizer.mjs

@@ -0,0 +1,152 @@
+function truncate(value, max = 80) {
+    return String(value || "").slice(0, max);
+}
+export function normalizeItemStart(item) {
+    switch (item?.type) {
+        case "command_execution":
+            return {
+                type: "assistant",
+                message: {
+                    content: [
+                        {
+                            type: "tool_use",
+                            name: "Bash",
+                            input: { command: item.command || "" },
+                        },
+                    ],
+                },
+                _display: `Bash(${truncate(item.command)})`,
+            };
+        case "file_change": {
+            const changes = item.changes || [];
+            const paths = changes.map((change) => change.path).join(", ");
+            return {
+                type: "assistant",
+                message: {
+                    content: [
+                        {
+                            type: "tool_use",
+                            name: "Edit",
+                            input: { file_path: paths },
+                        },
+                    ],
+                },
+                _display: `Edit(${truncate(paths)})`,
+            };
+        }
+        case "mcp_tool_call":
+            return {
+                type: "assistant",
+                message: {
+                    content: [
+                        {
+                            type: "tool_use",
+                            name: item.server_name || "mcp",
+                            input: item.arguments || {},
+                        },
+                    ],
+                },
+                _display: `MCP(${item.server_name || "?"})`,
+            };
+        case "agent_message":
+            return {
+                type: "content_block_start",
+                content_block: { type: "text" },
+                _display: "Generating...",
+            };
+        case "reasoning":
+            return {
+                type: "content_block_start",
+                content_block: { type: "thinking" },
+                _display: "Thinking...",
+            };
+        default:
+            return null;
+    }
+}
+export function normalizeItemComplete(item) {
+    switch (item?.type) {
+        case "command_execution":
+            return {
+                type: "tool_result",
+                tool_name: "Bash",
+                content: item.output || `exit_code=${item.exit_code || 0}`,
+                _display: `Bash: exit=${item.exit_code || 0}`,
+            };
+        case "file_change": {
+            const changes = item.changes || [];
+            const summary = changes
+                .map((change) => `${change.kind}: ${change.path}`)
+                .join(", ");
+            return {
+                type: "tool_result",
+                tool_name: "Edit",
+                content: summary || "file changed",
+                _display: `Edit: ${truncate(summary)}`,
+            };
+        }
+        case "mcp_tool_call": {
+            const output = item.result || item.error || "";
+            return {
+                type: "tool_result",
+                tool_name: item.server_name || "mcp",
+                content: output,
+                _display: `MCP: ${truncate(output)}`,
+            };
+        }
+        case "agent_message": {
+            const text = item.text || "";
+            return {
+                type: "assistant",
+                message: {
+                    content: [
+                        {
+                            type: "text",
+                            text,
+                        },
+                    ],
+                },
+                _display: `Message: ${truncate(text)}`,
+            };
+        }
+        default:
+            return null;
+    }
+}
+export function normalizeTurnCompleted(event, sessionId) {
+    const usage = event?.usage || {};
+    return {
+        type: "result",
+        subtype: "success",
+        session_id: sessionId,
+        usage: {
+            input_tokens: usage.input_tokens || 0,
+            output_tokens: usage.output_tokens || 0,
+            cache_read_input_tokens: usage.cached_input_tokens || 0,
+            cache_creation_input_tokens: 0,
+        },
+    };
+}
+export function normalizeTurnFailed(event, sessionId) {
+    return {
+        type: "result",
+        subtype: "error",
+        session_id: sessionId,
+        is_error: true,
+        result: event?.error?.message || "Turn failed",
+    };
+}
+export function formatTurnCompletedLog(event) {
+    const usage = event?.usage || {};
+    const parts = ["Result: success"];
+    if (usage.input_tokens || usage.output_tokens) {
+        parts.push(`${usage.input_tokens || 0}in/${usage.output_tokens || 0}out`);
+        if (usage.cached_input_tokens) {
+            parts.push(`cached=${usage.cached_input_tokens}`);
+        }
+    }
+    return parts.join(", ");
+}
+export function formatTurnFailedLog(event) {
+    return `Failed: ${event?.error?.message || "unknown error"}`;
+}

package/sdk/codex-normalizer.mts

@@ -0,0 +1,190 @@
+type UnknownRecord = Record<string, unknown>;
+
+type CodexItem = {
+  type?: string;
+  command?: string;
+  changes?: Array<{ kind?: string; path?: string }>;
+  server_name?: string;
+  arguments?: UnknownRecord;
+  output?: string;
+  exit_code?: number;
+  result?: string;
+  error?: string;
+  text?: string;
+};
+
+type CodexTurnUsage = {
+  input_tokens?: number;
+  output_tokens?: number;
+  cached_input_tokens?: number;
+};
+
+type CodexTurnEvent = {
+  usage?: CodexTurnUsage;
+  error?: { message?: string };
+};
+
+function truncate(value: unknown, max = 80): string {
+  return String(value || "").slice(0, max);
+}
+
+export function normalizeItemStart(item: CodexItem): UnknownRecord | null {
+  switch (item?.type) {
+    case "command_execution":
+      return {
+        type: "assistant",
+        message: {
+          content: [
+            {
+              type: "tool_use",
+              name: "Bash",
+              input: { command: item.command || "" },
+            },
+          ],
+        },
+        _display: `Bash(${truncate(item.command)})`,
+      };
+    case "file_change": {
+      const changes = item.changes || [];
+      const paths = changes.map((change) => change.path).join(", ");
+      return {
+        type: "assistant",
+        message: {
+          content: [
+            {
+              type: "tool_use",
+              name: "Edit",
+              input: { file_path: paths },
+            },
+          ],
+        },
+        _display: `Edit(${truncate(paths)})`,
+      };
+    }
+    case "mcp_tool_call":
+      return {
+        type: "assistant",
+        message: {
+          content: [
+            {
+              type: "tool_use",
+              name: item.server_name || "mcp",
+              input: item.arguments || {},
+            },
+          ],
+        },
+        _display: `MCP(${item.server_name || "?"})`,
+      };
+    case "agent_message":
+      return {
+        type: "content_block_start",
+        content_block: { type: "text" },
+        _display: "Generating...",
+      };
+    case "reasoning":
+      return {
+        type: "content_block_start",
+        content_block: { type: "thinking" },
+        _display: "Thinking...",
+      };
+    default:
+      return null;
+  }
+}
+
+export function normalizeItemComplete(item: CodexItem): UnknownRecord | null {
+  switch (item?.type) {
+    case "command_execution":
+      return {
+        type: "tool_result",
+        tool_name: "Bash",
+        content: item.output || `exit_code=${item.exit_code || 0}`,
+        _display: `Bash: exit=${item.exit_code || 0}`,
+      };
+    case "file_change": {
+      const changes = item.changes || [];
+      const summary = changes
+        .map((change) => `${change.kind}: ${change.path}`)
+        .join(", ");
+      return {
+        type: "tool_result",
+        tool_name: "Edit",
+        content: summary || "file changed",
+        _display: `Edit: ${truncate(summary)}`,
+      };
+    }
+    case "mcp_tool_call": {
+      const output = item.result || item.error || "";
+      return {
+        type: "tool_result",
+        tool_name: item.server_name || "mcp",
+        content: output,
+        _display: `MCP: ${truncate(output)}`,
+      };
+    }
+    case "agent_message": {
+      const text = item.text || "";
+      return {
+        type: "assistant",
+        message: {
+          content: [
+            {
+              type: "text",
+              text,
+            },
+          ],
+        },
+        _display: `Message: ${truncate(text)}`,
+      };
+    }
+    default:
+      return null;
+  }
+}
+
+export function normalizeTurnCompleted(
+  event: CodexTurnEvent,
+  sessionId: string,
+): UnknownRecord {
+  const usage = event?.usage || {};
+  return {
+    type: "result",
+    subtype: "success",
+    session_id: sessionId,
+    usage: {
+      input_tokens: usage.input_tokens || 0,
+      output_tokens: usage.output_tokens || 0,
+      cache_read_input_tokens: usage.cached_input_tokens || 0,
+      cache_creation_input_tokens: 0,
+    },
+  };
+}
+
+export function normalizeTurnFailed(
+  event: CodexTurnEvent,
+  sessionId: string,
+): UnknownRecord {
+  return {
+    type: "result",
+    subtype: "error",
+    session_id: sessionId,
+    is_error: true,
+    result: event?.error?.message || "Turn failed",
+  };
+}
+
+export function formatTurnCompletedLog(event: CodexTurnEvent): string {
+  const usage = event?.usage || {};
+  const parts = ["Result: success"];
+  if (usage.input_tokens || usage.output_tokens) {
+    parts.push(`${usage.input_tokens || 0}in/${usage.output_tokens || 0}out`);
+    if (usage.cached_input_tokens) {
+      parts.push(`cached=${usage.cached_input_tokens}`);
+    }
+  }
+  return parts.join(", ");
+}
+
+export function formatTurnFailedLog(event: CodexTurnEvent): string {
+  return `Failed: ${event?.error?.message || "unknown error"}`;
+}

package/sdk/codex-normalizer.test.mjs

@@ -0,0 +1,126 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+
+import {
+  formatTurnCompletedLog,
+  formatTurnFailedLog,
+  normalizeItemStart,
+  normalizeItemComplete,
+  normalizeTurnCompleted,
+  normalizeTurnFailed,
+} from './codex-normalizer.mjs';
+
+test('normalizeItemStart: command_execution -> Bash tool_use event', () => {
+  const event = normalizeItemStart({
+    type: 'command_execution',
+    command: 'npm test',
+  });
+
+  assert.equal(event.type, 'assistant');
+  assert.equal(event.message.content[0].type, 'tool_use');
+  assert.equal(event.message.content[0].name, 'Bash');
+  assert.deepEqual(event.message.content[0].input, { command: 'npm test' });
+  assert.equal(event._display, 'Bash(npm test)');
+});
+
+test('normalizeItemStart: Task-style subagent event keeps Task tool name', () => {
+  const event = normalizeItemStart({
+    type: 'mcp_tool_call',
+    server_name: 'Task',
+    arguments: { subagent_type: 'Explore', description: 'scan repo' },
+  });
+
+  assert.equal(event.type, 'assistant');
+  assert.equal(event.message.content[0].type, 'tool_use');
+  assert.equal(event.message.content[0].name, 'Task');
+});
+
+test('normalizeItemStart: unknown item type returns null', () => {
+  const event = normalizeItemStart({ type: 'unknown_type' });
+  assert.equal(event, null);
+});
+
+test('normalizeItemComplete: command_execution uses output if present', () => {
+  const event = normalizeItemComplete({
+    type: 'command_execution',
+    output: 'ok',
+    exit_code: 0,
+  });
+
+  assert.equal(event.type, 'tool_result');
+  assert.equal(event.tool_name, 'Bash');
+  assert.equal(event.content, 'ok');
+});
+
+test('normalizeItemComplete: command_execution falls back to exit code', () => {
+  const event = normalizeItemComplete({
+    type: 'command_execution',
+    output: '',
+    exit_code: 7,
+  });
+
+  assert.equal(event.content, 'exit_code=7');
+});
+
+test('normalizeItemComplete: Task result keeps tool_name Task', () => {
+  const event = normalizeItemComplete({
+    type: 'mcp_tool_call',
+    server_name: 'Task',
+    result: 'done',
+  });
+
+  assert.equal(event.type, 'tool_result');
+  assert.equal(event.tool_name, 'Task');
+  assert.equal(event.content, 'done');
+});
+
+test('normalizeTurnCompleted maps usage fields to tornado format', () => {
+  const event = normalizeTurnCompleted(
+    {
+      usage: {
+        input_tokens: 120,
+        output_tokens: 30,
+        cached_input_tokens: 77,
+      },
+    },
+    'thread-1',
+  );
+
+  assert.equal(event.type, 'result');
+  assert.equal(event.subtype, 'success');
+  assert.equal(event.session_id, 'thread-1');
+  assert.equal(event.usage.input_tokens, 120);
+  assert.equal(event.usage.output_tokens, 30);
+  assert.equal(event.usage.cache_read_input_tokens, 77);
+  assert.equal(event.usage.cache_creation_input_tokens, 0);
+});
+
+test('normalizeTurnFailed creates error result event', () => {
+  const event = normalizeTurnFailed(
+    { error: { message: 'boom' } },
+    'thread-9',
+  );
+
+  assert.equal(event.type, 'result');
+  assert.equal(event.subtype, 'error');
+  assert.equal(event.session_id, 'thread-9');
+  assert.equal(event.is_error, true);
+  assert.equal(event.result, 'boom');
+});
+
+test('formatTurnCompletedLog includes token and cache info', () => {
+  const message = formatTurnCompletedLog({
+    usage: {
+      input_tokens: 10,
+      output_tokens: 4,
+      cached_input_tokens: 7,
+    },
+  });
+
+  assert.equal(message, 'Result: success, 10in/4out, cached=7');
+});
+
+test('formatTurnFailedLog falls back to unknown error', () => {
+  const message = formatTurnFailedLog({});
+  assert.equal(message, 'Failed: unknown error');
+});

package/sdk/codex-runner.mjs

@@ -0,0 +1,3 @@
+import { runAdapterFromArgv } from "./agent-runner.mjs";
+import { createCodexAdapter } from "./codex-adapter.mjs";
+await runAdapterFromArgv(createCodexAdapter());

package/sdk/codex-runner.mts

@@ -0,0 +1,4 @@
+import { runAdapterFromArgv } from "./agent-runner.mjs";
+import { createCodexAdapter } from "./codex-adapter.mjs";
+
+await runAdapterFromArgv(createCodexAdapter());

package/sdk/runner-io.mjs

@@ -0,0 +1,8 @@
+export function writeJsonl(event, stream = process.stdout) {
+    stream.write(`${JSON.stringify(event)}\n`);
+}
+export function createLogger(tag, stream = process.stderr) {
+    return function log(message) {
+        stream.write(`[${tag}] ${message}\n`);
+    };
+}

package/sdk/runner-io.mts

@@ -0,0 +1,12 @@
+export function writeJsonl(event: unknown, stream: NodeJS.WritableStream = process.stdout): void {
+  stream.write(`${JSON.stringify(event)}\n`);
+}
+
+export function createLogger(
+  tag: string,
+  stream: NodeJS.WritableStream = process.stderr,
+): (message: string) => void {
+  return function log(message: string): void {
+    stream.write(`[${tag}] ${message}\n`);
+  };
+}

package/sdk/stdin-watcher.mjs

@@ -0,0 +1,34 @@
+// Background stdin watcher - reads user input and writes to interrupt file
+// Spawned by the main process with stdio: ['inherit', 'pipe', 'inherit']
+import { createInterface } from "readline";
+import { appendFileSync, mkdirSync, writeFileSync } from "fs";
+
+const INTERRUPT_FILE = ".tornado/interrupt.txt";
+
+try {
+  mkdirSync(".tornado", { recursive: true });
+} catch {}
+// Clear stale interrupt
+try {
+  writeFileSync(INTERRUPT_FILE, "", "utf-8");
+} catch {}
+
+const rl = createInterface({
+  input: process.stdin,
+  output: process.stderr,
+  terminal: true,
+  prompt: "",
+});
+
+rl.on("line", (line) => {
+  const trimmed = line.trim();
+  if (trimmed) {
+    appendFileSync(INTERRUPT_FILE, trimmed + "\n", "utf-8");
+    process.stderr.write(`\x1b[33m[USER] Queued: ${trimmed}\x1b[0m\n`);
+  }
+});
+
+rl.on("close", () => process.exit(0));
+
+// Exit when parent dies
+process.on("disconnect", () => process.exit(0));