@love-moon/conductor-cli 0.1.0

package/bin/conductor-fire.js

@@ -0,0 +1,903 @@
+#!/usr/bin/env node
+
+/**
+ * conductor-fire - Conductor-aware AI coding agent runner.
+ *
+ * Supports multiple backends: codex, claude, copilot, tmates, cursor, gemini.
+ * This CLI bridges various AI coding agents with Conductor via MCP.
+ */
+
+import fs from "node:fs";
+import { createRequire } from "node:module";
+import path from "node:path";
+import process from "node:process";
+import { setTimeout as delay } from "node:timers/promises";
+import { fileURLToPath } from "node:url";
+
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+import yargs from "yargs/yargs";
+import { hideBin } from "yargs/helpers";
+import { cli2sdk } from "@conductor/cli2sdk";
+import { loadConfig } from "@conductor/sdk";
+import {
+  loadHistoryFromSpec,
+  parseFromSpec,
+  selectHistorySession,
+  SUPPORTED_FROM_PROVIDERS,
+} from "../src/fire/history.js";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const require = createRequire(import.meta.url);
+const PKG_ROOT = path.join(__dirname, "..");
+const CLI_PROJECT_PATH = process.cwd();
+const REPO_ROOT_FALLBACK = path.resolve(__dirname, "..", "..");
+const SDK_FALLBACK_PATH = path.join(REPO_ROOT_FALLBACK, "sdk", "typescript");
+const SDK_ROOT =
+  process.env.CONDUCTOR_SDK_PATH ||
+  (() => {
+    try {
+      return path.dirname(require.resolve("@conductor/sdk/package.json"));
+    } catch {
+      return SDK_FALLBACK_PATH;
+    }
+  })();
+const MCP_SERVER_SCRIPT = path.join(SDK_ROOT, "dist", "bin", "mcp-server.js");
+
+const pkgJson = JSON.parse(fs.readFileSync(path.join(PKG_ROOT, "package.json"), "utf-8"));
+const CLI_NAME = (process.env.CONDUCTOR_CLI_NAME || path.basename(process.argv[1] || "conductor-fire")).replace(
+  /\.js$/,
+  "",
+);
+
+// Supported backends
+const SUPPORTED_BACKENDS = ["codex", "claude", "copilot", "tmates", "cursor", "gemini"];
+const DEFAULT_BACKEND = process.env.CONDUCTOR_BACKEND || "codex";
+
+const DEFAULT_POLL_INTERVAL_MS = parseInt(
+  process.env.CONDUCTOR_CLI_POLL_INTERVAL_MS || process.env.CCODEX_POLL_INTERVAL_MS || "2000",
+  10,
+);
+
+const MCP_SERVER_LAUNCH = {
+  command: "node",
+  args: [MCP_SERVER_SCRIPT],
+  cwd: SDK_ROOT,
+};
+
+async function main() {
+  const cliArgs = parseCliArgs();
+
+  if (cliArgs.showHelp) {
+    return;
+  }
+
+  if (cliArgs.showVersion) {
+    process.stdout.write(`${CLI_NAME} version ${pkgJson.version}\n`);
+    return;
+  }
+
+  if (cliArgs.listBackends) {
+    process.stdout.write(`Supported backends: ${SUPPORTED_BACKENDS.join(", ")}\n`);
+    process.stdout.write(`Default: ${DEFAULT_BACKEND}\n`);
+    return;
+  }
+
+  let fromHistory = { history: [], provider: null, sessionId: null };
+  if (cliArgs.fromSpec) {
+    const provider = cliArgs.fromSpec.provider;
+    if (!SUPPORTED_FROM_PROVIDERS.includes(provider)) {
+      throw new Error(`--from only supports: ${SUPPORTED_FROM_PROVIDERS.join(", ")}`);
+    }
+
+    let resolvedSpec = cliArgs.fromSpec;
+    if (!resolvedSpec.sessionId) {
+      const selected = await selectHistorySession(provider);
+      if (!selected) {
+        log("No session selected. Starting a new conversation.");
+        resolvedSpec = null;
+      } else {
+        resolvedSpec = parseFromSpec(`${provider}:${selected.sessionId}`);
+      }
+    }
+
+    if (resolvedSpec) {
+      if (cliArgs.backend !== resolvedSpec.provider) {
+        log(
+          `Ignoring --from ${resolvedSpec.provider}:${resolvedSpec.sessionId} because backend is ${cliArgs.backend}`,
+        );
+      } else {
+        fromHistory = await loadHistoryFromSpec(resolvedSpec);
+        if (fromHistory.warning) {
+          log(fromHistory.warning);
+        } else {
+          log(
+            `Loaded ${fromHistory.history.length} history messages from ${fromHistory.provider} session ${fromHistory.sessionId}`,
+          );
+        }
+      }
+    }
+  }
+
+  // Create backend session based on selected backend
+  const backendSession = createBackendSession(cliArgs.backend, {
+    threadOptions: cliArgs.threadOptions,
+    initialImages: cliArgs.initialImages,
+    cwd: CLI_PROJECT_PATH,
+    initialHistory: fromHistory.history,
+    resumeSessionId: fromHistory.sessionId,
+  });
+
+  log(`Using backend: ${cliArgs.backend}`);
+
+  const env = buildEnv();
+  if (cliArgs.configFile) {
+    env.CONDUCTOR_CONFIG = cliArgs.configFile;
+  }
+  try {
+    const config = loadConfig(cliArgs.configFile);
+    if (config.backendUrl && !env.CONDUCTOR_BACKEND_URL) {
+      env.CONDUCTOR_BACKEND_URL = config.backendUrl;
+    }
+    if (config.websocketUrl && !env.CONDUCTOR_WS_URL) {
+      env.CONDUCTOR_WS_URL = config.websocketUrl;
+    }
+  } catch (error) {
+    // Ignore config loading errors, rely on env vars or defaults
+  }
+
+  const conductor = await ConductorClient.connect({
+    launcher: MCP_SERVER_LAUNCH,
+    workingDirectory: CLI_PROJECT_PATH,
+    projectPath: CLI_PROJECT_PATH,
+    extraEnv: env,
+  });
+
+  const taskContext = await ensureTaskContext(conductor, {
+    initialPrompt: cliArgs.initialPrompt,
+    requestedProjectId: process.env.CONDUCTOR_PROJECT_ID,
+    providedTaskId: process.env.CONDUCTOR_TASK_ID,
+    requestedTitle: cliArgs.taskTitle || process.env.CONDUCTOR_TASK_TITLE,
+    backend: cliArgs.backend,
+  });
+
+  log(
+    `Attached to Conductor task ${taskContext.taskId}${
+      taskContext.appUrl ? ` (${taskContext.appUrl})` : ""
+    }`,
+  );
+
+  const runner = new BridgeRunner({
+    backendSession,
+    conductor,
+    taskId: taskContext.taskId,
+    pollIntervalMs: Math.max(cliArgs.pollIntervalMs, 500),
+    initialPrompt: taskContext.shouldProcessInitialPrompt ? cliArgs.initialPrompt : "",
+    includeInitialImages: Boolean(cliArgs.initialPrompt && cliArgs.initialImages.length),
+    cliArgs: cliArgs.rawBackendArgs,
+    backendName: cliArgs.backend,
+  });
+
+  const signals = new AbortController();
+  process.on("SIGINT", () => signals.abort());
+  process.on("SIGTERM", () => signals.abort());
+
+  try {
+    await runner.start(signals.signal);
+  } finally {
+    await conductor.close();
+  }
+}
+
+/**
+ * Create a backend session based on the selected backend type.
+ */
+function createBackendSession(backend, options) {
+  // Use cli2sdk for all backends including codex
+  return new Cli2SdkSession(backend, options);
+}
+
+function parseCliArgs() {
+  const argv = hideBin(process.argv);
+  const separatorIndex = argv.indexOf("--");
+  
+  // When no separator, parse all args first to check for conductor-specific options
+  const conductorArgv = separatorIndex === -1 ? argv : argv.slice(0, separatorIndex);
+  const backendArgv = separatorIndex === -1 ? argv : argv.slice(separatorIndex + 1);
+  
+  // Check for version/list-backends/help without separator
+  const versionWithoutSeparator = separatorIndex === -1 && (argv.includes("--version") || argv.includes("-v"));
+  const listBackendsWithoutSeparator = separatorIndex === -1 && argv.includes("--list-backends");
+  const helpWithoutSeparator = separatorIndex === -1 && (argv.includes("--help") || argv.includes("-h"));
+
+  const conductorArgs = yargs(conductorArgv)
+    .scriptName(CLI_NAME)
+    .usage("Usage: $0 [--backend <name>] -- [backend options and prompt]")
+    .version(false)
+    .option("backend", {
+      alias: "b",
+      type: "string",
+      describe: `Backend to use (${SUPPORTED_BACKENDS.join(", ")})`,
+      default: DEFAULT_BACKEND,
+      choices: SUPPORTED_BACKENDS,
+    })
+    .option("list-backends", {
+      type: "boolean",
+      describe: "List available backends and exit",
+    })
+    .option("config-file", {
+      type: "string",
+      describe: "Path to Conductor config file",
+    })
+    .option("poll-interval", {
+      type: "number",
+      describe: "Polling interval (ms) when waiting for Conductor messages",
+    })
+    .option("title", {
+      alias: "t",
+      type: "string",
+      describe: "Optional task title shown in the app task list",
+    })
+    .option("from", {
+      alias: "f",
+      type: "string",
+      describe: "Resume from local history (optional session id; otherwise pick interactively)",
+    })
+    .option("from-provider", {
+      type: "string",
+      describe: "Provider for --from picker (defaults to --backend)",
+      choices: SUPPORTED_FROM_PROVIDERS,
+    })
+    .option("prefill", {
+      type: "string",
+      describe: "Optional initial prompt forwarded to Conductor on task creation",
+      hidden: true,
+    })
+    .option("version", {
+      alias: "v",
+      type: "boolean",
+      describe: "Show Conductor CLI version and exit",
+    })
+    .help()
+    .strict(false)
+    .parserConfiguration({
+      "unknown-options-as-args": true,
+      "camel-case-expansion": true,
+    })
+    .parse();
+
+  // Handle help early
+  if (helpWithoutSeparator) {
+    process.stdout.write(`${CLI_NAME} - Conductor-aware AI coding agent runner
+
+Usage: ${CLI_NAME} [options] -- [backend options and prompt]
+
+Options:
+  -b, --backend <name>  Backend to use (${SUPPORTED_BACKENDS.join(", ")}) [default: ${DEFAULT_BACKEND}]
+  --list-backends       List available backends and exit
+  --config-file <path>  Path to Conductor config file
+  --poll-interval <ms>  Polling interval when waiting for Conductor messages
+  -t, --title <text>    Optional task title shown in the app task list
+  -f, --from [id]       Resume from local history (pick if id omitted)
+  --from-provider <p>   Provider for --from picker (codex or claude)
+  -v, --version         Show Conductor CLI version and exit
+  -h, --help            Show this help message
+
+Examples:
+  ${CLI_NAME} -- "fix the bug"                    # Use default backend (codex)
+  ${CLI_NAME} --backend claude -- "fix the bug"   # Use Claude CLI backend
+  ${CLI_NAME} --backend tmates -- "fix the bug"   # Use TMates CLI backend
+  ${CLI_NAME} --backend copilot -- "fix the bug"  # Use Copilot CLI backend
+  ${CLI_NAME} --config-file ~/.conductor/config.yaml -- "fix the bug"
+  ${CLI_NAME} --backend codex --from -- "continue"
+  ${CLI_NAME} --backend codex --from codex-session-id -- "continue"
+
+Environment:
+  CONDUCTOR_BACKEND     Default backend (overrides codex)
+  CONDUCTOR_PROJECT_ID  Project ID to attach to
+  CONDUCTOR_TASK_ID     Attach to existing task instead of creating new one
+`);
+    return { showHelp: true };
+  }
+
+  const backendArgs = yargs(backendArgv)
+    .help(false)
+    .version(false)
+    .strict(false)
+    .parserConfiguration({
+      "unknown-options-as-args": true,
+      "camel-case-expansion": true,
+    })
+    .parse();
+  
+  // Apply codex-specific defaults when using codex backend
+  const backend = conductorArgs.backend || DEFAULT_BACKEND;
+  if (backend === "codex") {
+    backendArgs.sandboxMode ||= "danger-full-access";
+    backendArgs.approvalPolicy ||= "never";
+    backendArgs.skipGitRepoCheck ||= true;
+  }
+
+  const prompt = (backendArgs._ || []).map((part) => String(part)).join(" ").trim();
+  const initialImages = normalizeArray(backendArgs.image || backendArgs.i).map((img) => String(img));
+  const pollIntervalMs = Number.isFinite(conductorArgs.pollInterval)
+     ? Number(conductorArgs.pollInterval)
+     : DEFAULT_POLL_INTERVAL_MS;
+
+  let fromSpec = null;
+  try {
+    fromSpec = parseFromSpec(conductorArgs.from, conductorArgs.fromProvider, backend);
+  } catch (error) {
+    throw new Error(error.message);
+  }
+
+  return {
+    backend,
+    initialPrompt: prompt || conductorArgs.prefill || "",
+    initialImages,
+    threadOptions: deriveThreadOptions(backendArgs, CLI_PROJECT_PATH),
+    pollIntervalMs,
+    rawBackendArgs: backendArgv,
+    taskTitle: resolveTaskTitle(conductorArgs.title),
+    configFile: conductorArgs.configFile,
+    fromSpec,
+    showVersion: Boolean(conductorArgs.version) || versionWithoutSeparator,
+    listBackends: Boolean(conductorArgs.listBackends) || listBackendsWithoutSeparator,
+  };
+}
+
+function resolveTaskTitle(titleFlag) {
+  if (typeof titleFlag === "string" && titleFlag.trim()) {
+    return titleFlag.trim();
+  }
+  const cwdName = path.basename(CLI_PROJECT_PATH || process.cwd());
+  return cwdName || "";
+}
+
+function deriveThreadOptions(codexArgs, defaultWorkingDirectory = CLI_PROJECT_PATH) {
+  const options = {};
+  const allowedKeys = new Set([
+    "model",
+    "sandboxMode",
+    "workingDirectory",
+    "skipGitRepoCheck",
+    "modelReasoningEffort",
+    "networkAccessEnabled",
+    "webSearchEnabled",
+    "approvalPolicy",
+  ]);
+
+  Object.entries(codexArgs || {}).forEach(([key, value]) => {
+    if (key === "_" || key === "$0") {
+      return;
+    }
+    const optionKey = mapCodexFlagToThreadOption(key);
+    if (allowedKeys.has(optionKey)) {
+      options[optionKey] = value;
+    }
+  });
+
+  if (codexArgs.fullAuto) {
+    options.sandboxMode ||= "workspace-write";
+    options.approvalPolicy ||= "on-request";
+  }
+
+  if (codexArgs.dangerouslyBypassApprovalsAndSandbox) {
+    options.sandboxMode = "danger-full-access";
+    options.approvalPolicy = "never";
+  }
+
+  if (!options.workingDirectory && defaultWorkingDirectory) {
+    options.workingDirectory = defaultWorkingDirectory;
+  }
+
+  return options;
+}
+
+function mapCodexFlagToThreadOption(flag) {
+  const normalized = toCamelCase(flag);
+  if (normalized === "sandbox") {
+    return "sandboxMode";
+  }
+  if (normalized === "askForApproval" || normalized === "approval") {
+    return "approvalPolicy";
+  }
+  if (normalized === "cd" || normalized === "c" || normalized === "workingDirectory") {
+    return "workingDirectory";
+  }
+  if (normalized === "search" || normalized === "webSearch") {
+    return "webSearchEnabled";
+  }
+  if (normalized === "networkAccess" || normalized === "network") {
+    return "networkAccessEnabled";
+  }
+  return normalized;
+}
+
+function toCamelCase(value) {
+  return String(value || "")
+     .replace(/^[\s-_]+|[\s-_]+$/g, "")
+     .replace(/[-_]+(.)/g, (_, chr) => (chr ? chr.toUpperCase() : ""))
+     .replace(/^[A-Z]/, (chr) => chr.toLowerCase());
+}
+
+function normalizeArray(value) {
+  if (!value) {
+    return [];
+  }
+  return Array.isArray(value) ? value : [value];
+}
+
+function buildEnv() {
+  const env = { ...process.env };
+  env.NO_PROXY = env.NO_PROXY || "127.0.0.1,localhost";
+  env.no_proxy = env.no_proxy || env.NO_PROXY;
+  return env;
+}
+
+async function ensureTaskContext(conductor, opts) {
+  if (opts.providedTaskId) {
+    return {
+      taskId: opts.providedTaskId,
+      appUrl: null,
+      shouldProcessInitialPrompt: Boolean(opts.initialPrompt),
+    };
+  }
+
+  const projectId = await resolveProjectId(conductor, opts.requestedProjectId);
+  const payload = {
+    project_id: projectId,
+    task_title: deriveTaskTitle(opts.initialPrompt, opts.requestedTitle, opts.backend),
+  };
+  if (opts.initialPrompt) {
+    payload.prefill = opts.initialPrompt;
+  }
+
+  const session = await conductor.createTaskSession(payload);
+  return {
+    taskId: session.task_id,
+    appUrl: session.app_url || null,
+    shouldProcessInitialPrompt: Boolean(opts.initialPrompt),
+  };
+}
+
+async function resolveProjectId(conductor, explicit) {
+  if (explicit) {
+    return explicit;
+  }
+
+  try {
+    const record = await conductor.getLocalProjectRecord();
+    if (record?.project_id) {
+      return record.project_id;
+    }
+  } catch (error) {
+    log(`Unable to resolve project via local session: ${error.message}`);
+  }
+
+  const listing = await conductor.listProjects();
+  const first = listing?.projects?.[0];
+  if (first?.id) {
+    return first.id;
+  }
+  log("No projects available; creating default project...");
+  try {
+    const created = await conductor.createProject("default", "Auto-created by conductor-fire");
+    if (created?.id) {
+      log(`Created default project ${created.id}`);
+      return created.id;
+    }
+    throw new Error("create_project returned no id");
+  } catch (error) {
+    throw new Error(`Unable to resolve project and failed to create default: ${error.message}`);
+  }
+}
+
+function deriveTaskTitle(prompt, explicit, backend = "codex") {
+  if (explicit && explicit.trim()) {
+    return explicit.trim();
+  }
+  if (prompt) {
+    const compact = prompt.replace(/\s+/g, " ").trim();
+    if (compact) {
+      return compact.slice(0, 80);
+    }
+  }
+  const backendName = backend.charAt(0).toUpperCase() + backend.slice(1);
+  return `${backendName} Task`;
+}
+
+/**
+ * Cli2SdkSession - Backend session using cli2sdk providers (all backends including codex).
+ */
+class Cli2SdkSession {
+  constructor(backend, options = {}) {
+    this.backend = backend;
+    this.options = options;
+
+    // For codex, pass threadOptions as config
+    const config = backend === "codex"
+      ? { provider: backend, codex: options.threadOptions }
+      : { provider: backend };
+
+    this.sdk = cli2sdk(config);
+    this.sessionId = options.resumeSessionId || `${backend}-${Date.now()}`;
+    this.history = Array.isArray(options.initialHistory) ? [...options.initialHistory] : [];
+  }
+
+  get threadId() {
+    return this.sessionId;
+  }
+
+  get threadOptions() {
+    return this.backend === "codex" ? this.options.threadOptions : { model: this.backend };
+  }
+
+  async runTurn(promptText, { useInitialImages = false } = {}) {
+    if (!promptText || !promptText.trim()) {
+      return {
+        text: "",
+        usage: null,
+        items: [],
+        events: [],
+      };
+    }
+
+    log(`[${this.backend}] Running prompt: ${promptText.slice(0, 100)}...`);
+
+    try {
+      if (this.backend === "codex" && useInitialImages && this.options.initialImages?.length > 0) {
+        log("[codex] Initial images are not supported via codex CLI; ignoring images.");
+      }
+
+      const cwd =
+        this.backend === "codex" && this.options.threadOptions?.workingDirectory
+          ? this.options.threadOptions.workingDirectory
+          : this.options.cwd;
+
+      const result = await this.sdk.run(promptText, {
+        provider: this.backend,
+        history: this.history,
+        cwd,
+      });
+
+      // Update history for multi-turn conversations
+      this.history.push({ role: "user", content: promptText });
+      this.history.push({ role: "assistant", content: result.text });
+
+      log(`[${this.backend}] Response received: ${result.text.slice(0, 100)}...`);
+
+      return {
+        text: result.text || "",
+        usage: result.usage || null,
+        items: result.metadata?.items || [],
+        events: result.metadata?.events || [],
+        provider: this.backend,
+        metadata: result.metadata,
+      };
+    } catch (error) {
+      log(`[${this.backend}] Error: ${error.message}`);
+      throw error;
+    }
+  }
+}
+
+class ConductorClient {
+  constructor(client, transport, options = {}) {
+    this.client = client;
+    this.transport = transport;
+    this.closed = false;
+    this.projectPath = options.projectPath || process.cwd();
+  }
+
+  static async connect({ launcher, workingDirectory, extraEnv, projectPath }) {
+    if (!fs.existsSync(launcher.args[0])) {
+      throw new Error(`Conductor MCP server not found at ${launcher.args[0]}`);
+    }
+
+    const transport = new StdioClientTransport({
+      command: launcher.command,
+      args: launcher.args,
+      env: extraEnv,
+      cwd: launcher.cwd || workingDirectory,
+      stderr: "pipe",
+    });
+
+    const client = new Client({
+      name: CLI_NAME,
+      version: pkgJson.version,
+    });
+
+    client.onerror = (err) => {
+      log(`MCP client error: ${err.message}`);
+    };
+
+    const stderr = transport.stderr;
+    if (stderr) {
+      stderr.setEncoding("utf-8");
+      stderr.on("data", (chunk) => {
+        const text = chunk.toString();
+        const ts = new Date().toLocaleString("sv-SE", { timeZone: "Asia/Shanghai" }).replace(" ", "T");
+        text
+          .split(/\r?\n/)
+          .filter(Boolean)
+          .forEach((line) => process.stderr.write(`[conductor ${ts}] ${line}\n`));
+      });
+    }
+
+    await client.connect(transport);
+    return new ConductorClient(client, transport, { projectPath });
+  }
+
+  async close() {
+    if (this.closed) {
+      return;
+    }
+    this.closed = true;
+    await this.client.close();
+    await this.transport.close();
+  }
+
+  injectProjectPath(payload = {}) {
+    if (!this.projectPath || payload.project_path) {
+      return payload;
+    }
+    return { ...payload, project_path: this.projectPath };
+  }
+
+  async createTaskSession(payload) {
+    const args = payload ? { ...payload } : {};
+    return this.callTool("create_task_session", this.injectProjectPath(args));
+  }
+
+  async sendMessage(taskId, content, metadata) {
+    return this.callTool("send_message", {
+      task_id: taskId,
+      content,
+      metadata,
+    });
+  }
+
+  async receiveMessages(taskId, limit = 20) {
+    return this.callTool("receive_messages", {
+      task_id: taskId,
+      limit,
+    });
+  }
+
+  async ackMessages(taskId, ackToken) {
+    if (!ackToken) {
+      return;
+    }
+    await this.callTool("ack_messages", { task_id: taskId, ack_token: ackToken });
+  }
+
+  async listProjects() {
+    return this.callTool("list_projects", {});
+  }
+
+  async createProject(name, description, metadata) {
+    return this.callTool("create_project", {
+      name,
+      description,
+      metadata,
+    });
+  }
+
+  async getLocalProjectRecord() {
+    return this.callTool("get_local_project_id", this.injectProjectPath({}));
+  }
+
+  async callTool(name, args) {
+    const result = await this.client.callTool({
+      name,
+      arguments: args || {},
+    });
+    if (result?.isError) {
+      const message = extractFirstText(result?.content) || `tool ${name} failed`;
+      throw new Error(message);
+    }
+    const structured = result?.structuredContent;
+    if (structured && Object.keys(structured).length > 0) {
+      return structured;
+    }
+    const textPayload = extractFirstText(result?.content);
+    if (!textPayload) {
+      return undefined;
+    }
+    try {
+      return JSON.parse(textPayload);
+    } catch {
+      return textPayload;
+    }
+  }
+}
+
+function extractFirstText(blocks) {
+  if (!Array.isArray(blocks)) {
+    return "";
+  }
+  for (const block of blocks) {
+    if (block?.type === "text" && typeof block.text === "string") {
+      const trimmed = block.text.trim();
+      if (trimmed) {
+        return trimmed;
+      }
+    }
+  }
+  return "";
+}
+
+class BridgeRunner {
+  constructor({
+    backendSession,
+    conductor,
+    taskId,
+    pollIntervalMs,
+    initialPrompt,
+    includeInitialImages,
+    cliArgs,
+    backendName,
+  }) {
+    this.backendSession = backendSession;
+    this.conductor = conductor;
+    this.taskId = taskId;
+    this.pollIntervalMs = pollIntervalMs;
+    this.initialPrompt = initialPrompt;
+    this.includeInitialImages = includeInitialImages;
+    this.cliArgs = cliArgs;
+    this.backendName = backendName || "codex";
+    this.stopped = false;
+    this.runningTurn = false;
+  }
+
+  async start(abortSignal) {
+    abortSignal?.addEventListener("abort", () => {
+      this.stopped = true;
+    });
+
+    if (this.initialPrompt) {
+      await this.handleSyntheticMessage(this.initialPrompt, {
+        includeImages: this.includeInitialImages,
+      });
+    }
+
+    while (!this.stopped) {
+      let processed = false;
+      try {
+        processed = await this.processIncomingBatch();
+      } catch (error) {
+        log(`Error while processing messages: ${error.message}`);
+        await this.reportError(`处理任务失败: ${error.message}`);
+      }
+      if (!processed) {
+        await delay(this.pollIntervalMs);
+      }
+    }
+  }
+
+  async processIncomingBatch() {
+    const result = await this.conductor.receiveMessages(this.taskId, 20);
+    const messages = Array.isArray(result?.messages) ? result.messages : [];
+    if (messages.length === 0) {
+      return false;
+    }
+
+    for (const message of messages) {
+      if (!this.shouldRespond(message)) {
+        continue;
+      }
+      await this.respondToMessage(message);
+    }
+
+    const ackToken = result.next_ack_token || result.nextAckToken;
+    if (ackToken) {
+      await this.conductor.ackMessages(this.taskId, ackToken);
+    }
+    const hasMore = Boolean(result?.has_more);
+    return hasMore;
+  }
+
+  shouldRespond(message) {
+    if (!message || typeof message !== "object") {
+      return false;
+    }
+    const role = String(message.role || "").toLowerCase();
+    return role === "user" || role === "action";
+  }
+
+  async respondToMessage(message) {
+    const content = String(message.content || "").trim();
+    if (!content) {
+      return;
+    }
+    const replyTo = message.message_id;
+    log(`Processing message ${replyTo} (${message.role})`);
+    try {
+      const result = await this.backendSession.runTurn(content);
+      const responseText =
+        result.text || extractAgentTextFromItems(result.items) || `(${this.backendName} 未返回任何文本)`;
+      logBackendReply(this.backendName, responseText, { usage: result.usage, replyTo: replyTo || "latest" });
+      await this.conductor.sendMessage(this.taskId, responseText, {
+        model: this.backendSession.threadOptions?.model || this.backendName,
+        backend: this.backendName,
+        usage: result.usage || null,
+        thread_id: this.backendSession.threadId,
+        items: result.items,
+        reply_to: replyTo,
+        cli_args: this.cliArgs,
+      });
+    } catch (error) {
+      await this.reportError(`${this.backendName} 处理失败: ${error.message}`, replyTo);
+    }
+  }
+
+  async handleSyntheticMessage(content, { includeImages }) {
+    try {
+      const result = await this.backendSession.runTurn(content, {
+        useInitialImages: includeImages,
+      });
+      const backendLabel = this.backendName.charAt(0).toUpperCase() + this.backendName.slice(1);
+      const intro = `${backendLabel} 已根据初始提示给出回复：`;
+      const replyText = result.text || extractAgentTextFromItems(result.items);
+      const text = replyText ? `${intro}\n\n${replyText}` : intro;
+      logBackendReply(this.backendName, replyText || "(无文本输出)", {
+        usage: result.usage,
+        replyTo: "initial",
+      });
+      await this.conductor.sendMessage(this.taskId, text, {
+        model: this.backendSession.threadOptions?.model || this.backendName,
+        backend: this.backendName,
+        usage: result.usage || null,
+        thread_id: this.backendSession.threadId,
+        cli_args: this.cliArgs,
+        synthetic: true,
+      });
+    } catch (error) {
+      await this.reportError(`初始提示执行失败: ${error.message}`);
+    }
+  }
+
+  async reportError(message, replyTo) {
+    try {
+      await this.conductor.sendMessage(this.taskId, message, {
+        severity: "error",
+        backend: this.backendName,
+        reply_to: replyTo,
+        cli_args: this.cliArgs,
+      });
+    } catch (err) {
+      log(`Failed to report error to Conductor: ${err.message}`);
+    }
+  }
+}
+
+function extractAgentTextFromItems(items) {
+  if (!Array.isArray(items)) {
+    return "";
+  }
+  for (let index = items.length - 1; index >= 0; index -= 1) {
+    const item = items[index];
+    if (item?.type === "agent_message" && typeof item.text === "string" && item.text.trim()) {
+      return item.text.trim();
+    }
+  }
+  return "";
+}
+
+function log(message) {
+  const ts = new Date().toLocaleString("sv-SE", { timeZone: "Asia/Shanghai" }).replace(" ", "T");
+  process.stdout.write(`[${CLI_NAME} ${ts}] ${message}\n`);
+}
+
+function logBackendReply(backend, text, { usage, replyTo }) {
+  const usageSuffix = usage?.total_tokens ? ` (tokens: ${usage.total_tokens})` : "";
+  log(`${backend} reply (${replyTo}): ${text}${usageSuffix}`);
+}
+
+main().catch((error) => {
+  const ts = new Date().toLocaleString("sv-SE", { timeZone: "Asia/Shanghai" }).replace(" ", "T");
+  process.stderr.write(`[${CLI_NAME} ${ts}] failed: ${error.stack || error.message}\n`);
+  process.exitCode = 1;
+});