@love-moon/conductor-cli 0.2.18 → 0.2.19

package/bin/conductor-config.js

@@ -8,6 +8,7 @@ import readline from "node:readline/promises";
 import { execSync } from "node:child_process";
 import yargs from "yargs/yargs";
 import { hideBin } from "yargs/helpers";
+import { RUNTIME_SUPPORTED_BACKENDS } from "../src/runtime-backends.js";
 
 const CONFIG_DIR = path.join(os.homedir(), ".conductor");
 const CONFIG_FILE = path.join(CONFIG_DIR, "config.yaml");
@@ -25,21 +26,16 @@ const DEFAULT_CLIs = {
     execArgs: "exec --dangerously-bypass-approvals-and-sandbox --skip-git-repo-check",
     description: "OpenAI Codex CLI"
   },
-  // copilot: {
-  //   command: "copilot",
-  //   execArgs: "--allow-all-paths --allow-all-tools",
-  //   description: "GitHub Copilot CLI"
-  // },
   // gemini: {
   //   command: "gemini",
   //   execArgs: "",
   //   description: "Google Gemini CLI"
   // },
-  // opencode: {
-  //   command: "opencode",
-  //   execArgs: "",
-  //   description: "OpenCode CLI"
-  // },
+  opencode: {
+    command: "opencode",
+    execArgs: "",
+    description: "OpenCode CLI (Conductor runs opencode serve with permission=allow)"
+  },
   // kimi: {
   //   command: "kimi",
   //   execArgs: "--yolo --print --prompt",
@@ -66,6 +62,22 @@ function colorize(text, color) {
   return `${COLORS[color] || ""}${text}${COLORS.reset}`;
 }
 
+function buildConfigEntryLines(cli, info, { commented = false } = {}) {
+  const fullCommand = info.execArgs
+    ? `${info.command} ${info.execArgs}`
+    : info.command;
+  const entryPrefix = commented ? "  # " : "  ";
+  const commentPrefix = commented ? "  # " : "  # ";
+  const lines = [];
+
+  if (cli === "opencode") {
+    lines.push(`${commentPrefix}opencode runs via ai-sdk server mode with permission=allow`);
+  }
+
+  lines.push(`${entryPrefix}${cli}: ${fullCommand}`);
+  return lines;
+}
+
 async function main() {
   // 解析命令行参数
   const argv = yargs(hideBin(process.argv))
@@ -170,19 +182,13 @@ async function main() {
   if (detectedCLIs.length > 0) {
     detectedCLIs.forEach(cli => {
       const info = DEFAULT_CLIs[cli];
-      const fullCommand = info.execArgs 
-        ? `${info.command} ${info.execArgs}` 
-        : info.command;
-      lines.push(`  ${cli}: ${fullCommand}`);
+      lines.push(...buildConfigEntryLines(cli, info));
     });
   } else {
     // 如果没有检测到任何 CLI，添加示例注释
     lines.push("  # No CLI detected. Add your installed CLI here:");
-    Object.entries(DEFAULT_CLIs).slice(0, 3).forEach(([key, info]) => {
-      const fullCommand = info.execArgs 
-        ? `${info.command} ${info.execArgs}` 
-        : info.command;
-      lines.push(`  # ${key}: ${fullCommand}`);
+    Object.entries(DEFAULT_CLIs).forEach(([key, info]) => {
+      lines.push(...buildConfigEntryLines(key, info, { commented: true }));
     });
   }
 
@@ -213,6 +219,9 @@ function detectInstalledCLIs() {
   const detected = [];
   
   for (const [key, info] of Object.entries(DEFAULT_CLIs)) {
+    if (!RUNTIME_SUPPORTED_BACKENDS.includes(key)) {
+      continue;
+    }
     if (isCommandAvailable(info.command)) {
       detected.push(key);
     }
@@ -282,16 +291,6 @@ function checkAlternativeInstallations(command) {
     );
   }
   
-  // // 特殊检查：Copilot CLI 可能是 gh copilot 扩展
-  // if (command === "copilot" || command === "copilot-chat") {
-  //   try {
-  //     execSync("gh copilot --help", { stdio: "pipe", timeout: 5000 });
-  //     return true;
-  //   } catch {
-  //     // gh copilot 未安装
-  //   }
-  // }
-  
   // 检查文件是否存在
   for (const checkPath of commonPaths) {
     if (fs.existsSync(checkPath)) {

package/bin/conductor-fire.js

@@ -26,6 +26,7 @@ import {
   resolveSessionRunDirectory as resolveCliSessionRunDirectory,
   resumeProviderForBackend as resumeProviderForCliBackend,
 } from "../src/fire/resume.js";
+import { filterRuntimeSupportedAllowCliList, normalizeRuntimeBackendName } from "../src/runtime-backends.js";
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
@@ -50,7 +51,7 @@ function loadAllowCliList(configFilePath) {
       const content = fs.readFileSync(configPath, "utf8");
       const parsed = yaml.load(content);
       if (parsed && typeof parsed === "object" && parsed.allow_cli_list) {
-        return parsed.allow_cli_list;
+        return filterRuntimeSupportedAllowCliList(parsed.allow_cli_list);
       }
     }
   } catch (error) {
@@ -59,6 +60,35 @@ function loadAllowCliList(configFilePath) {
   return {};
 }
 
+export function resolveAiSessionCommandLine(backend, allowCliList, env = process.env) {
+  const normalizedBackend = normalizeRuntimeBackendName(backend);
+  if (normalizedBackend !== "opencode") {
+    return "";
+  }
+
+  const opencodeEnvCommand =
+    typeof env?.CONDUCTOR_OPENCODE_COMMAND === "string" ? env.CONDUCTOR_OPENCODE_COMMAND.trim() : "";
+  if (opencodeEnvCommand) {
+    return opencodeEnvCommand;
+  }
+
+  const configuredCommand =
+    allowCliList && typeof allowCliList === "object" && typeof allowCliList.opencode === "string"
+      ? allowCliList.opencode.trim()
+      : "";
+  if (configuredCommand) {
+    return configuredCommand;
+  }
+
+  const daemonCommand =
+    typeof env?.CONDUCTOR_CLI_COMMAND === "string" ? env.CONDUCTOR_CLI_COMMAND.trim() : "";
+  if (daemonCommand) {
+    return daemonCommand;
+  }
+
+  return "";
+}
+
 const DEFAULT_POLL_INTERVAL_MS = parseInt(
   process.env.CONDUCTOR_CLI_POLL_INTERVAL_MS || process.env.CCODEX_POLL_INTERVAL_MS || "2000",
   10,
@@ -180,7 +210,7 @@ async function main() {
 
   if (cliArgs.listBackends) {
     if (supportedBackends.length === 0) {
-      process.stdout.write(`No backends configured.\n\nAdd allow_cli_list to your config file (~/.conductor/config.yaml):\n  allow_cli_list:\n    codex: codex --dangerously-bypass-approvals-and-sandbox\n    claude: claude --dangerously-skip-permissions\n    copilot: copilot --allow-all-paths --allow-all-tools\n    kimi: kimi\n`);
+      process.stdout.write(`No supported backends configured.\n\nAdd allow_cli_list to your config file (~/.conductor/config.yaml):\n  allow_cli_list:\n    codex: codex --dangerously-bypass-approvals-and-sandbox\n    claude: claude --dangerously-skip-permissions\n    opencode: opencode\n`);
     } else {
       process.stdout.write(`Supported backends (from config):\n`);
       for (const [name, command] of Object.entries(allowCliList)) {
@@ -333,11 +363,14 @@ async function main() {
 
     const resolvedResumeSessionId = cliArgs.resumeSessionId;
 
+    const sessionCommandLine = resolveAiSessionCommandLine(cliArgs.backend, allowCliList, process.env);
+
     backendSession = createAiSession(cliArgs.backend, {
       initialImages: cliArgs.initialImages,
       cwd: runtimeProjectPath,
       resumeSessionId: resolvedResumeSessionId,
       configFile: cliArgs.configFile,
+      ...(sessionCommandLine ? { commandLine: sessionCommandLine } : {}),
       logger: { log },
     });
 
@@ -359,6 +392,7 @@ async function main() {
       taskId: taskContext.taskId,
       pollIntervalMs: Math.max(cliArgs.pollIntervalMs, 500),
       initialPrompt: taskContext.shouldProcessInitialPrompt ? cliArgs.initialPrompt : "",
+      initialPromptDelivery: taskContext.initialPromptDelivery || "none",
       includeInitialImages: Boolean(cliArgs.initialPrompt && cliArgs.initialImages.length),
       cliArgs: cliArgs.rawBackendArgs,
       backendName: cliArgs.backend,
@@ -578,7 +612,6 @@ export function parseCliArgs(argvInput = process.argv) {
       alias: "b",
       type: "string",
       describe: `Backend to use (loaded from config: ${supportedBackends.join(", ") || "none configured"})`,
-      ...(supportedBackends.length > 0 ? { choices: supportedBackends } : {}),
     })
     .option("list-backends", {
       type: "boolean",
@@ -640,12 +673,12 @@ Config file format (~/.conductor/config.yaml):
   allow_cli_list:
     codex: codex --dangerously-bypass-approvals-and-sandbox
     claude: claude --dangerously-skip-permissions
-    copilot: copilot --allow-all-paths --allow-all-tools
+    opencode: opencode
 
 Examples:
   ${CLI_NAME} -- "fix the bug"                    # Use default backend
   ${CLI_NAME} --backend claude -- "fix the bug"   # Use Claude CLI backend
-  ${CLI_NAME} --backend copilot -- "fix the bug"  # Use GitHub Copilot CLI backend
+  ${CLI_NAME} --backend opencode -- "fix the bug" # Use OpenCode backend
   ${CLI_NAME} --backend codex --resume <id>       # Resume Codex session
   ${CLI_NAME} --list-backends                     # Show configured backends
   ${CLI_NAME} --config-file ~/.conductor/config.yaml -- "fix the bug"
@@ -668,7 +701,22 @@ Environment:
     })
     .parse();
   
-  const backend = conductorArgs.backend || supportedBackends[0];
+  const backend = conductorArgs.backend
+    ? normalizeRuntimeBackendName(conductorArgs.backend)
+    : supportedBackends[0];
+  const shouldRequireBackend =
+    !Boolean(conductorArgs.listBackends) &&
+    !listBackendsWithoutSeparator &&
+    !Boolean(conductorArgs.version) &&
+    !versionWithoutSeparator;
+  if (backend && !supportedBackends.includes(backend) && shouldRequireBackend) {
+    throw new Error(
+      `Unsupported backend "${backend}". Supported backends: ${supportedBackends.join(", ") || "none configured"}.`,
+    );
+  }
+  if (!backend && shouldRequireBackend) {
+    throw new Error("No supported backends configured. Add codex, claude, or opencode to allow_cli_list.");
+  }
 
   const prompt = (backendArgs._ || []).map((part) => String(part)).join(" ").trim();
   const initialImages = normalizeArray(backendArgs.image || backendArgs.i).map((img) => String(img));
@@ -806,6 +854,7 @@ async function ensureTaskContext(conductor, opts) {
       taskId: opts.providedTaskId,
       appUrl: null,
       shouldProcessInitialPrompt: Boolean(opts.initialPrompt),
+      initialPromptDelivery: opts.initialPrompt ? "synthetic" : "none",
     };
   }
 
@@ -837,6 +886,7 @@ async function ensureTaskContext(conductor, opts) {
     taskId: session.task_id,
     appUrl: session.app_url || null,
     shouldProcessInitialPrompt: Boolean(opts.initialPrompt),
+    initialPromptDelivery: opts.initialPrompt ? "queued" : "none",
   };
 }
 
@@ -1016,6 +1066,7 @@ export class BridgeRunner {
     taskId,
     pollIntervalMs,
     initialPrompt,
+    initialPromptDelivery,
     includeInitialImages,
     cliArgs,
     backendName,
@@ -1027,6 +1078,10 @@ export class BridgeRunner {
     this.taskId = taskId;
     this.pollIntervalMs = pollIntervalMs;
     this.initialPrompt = initialPrompt;
+    this.initialPromptDelivery =
+      typeof initialPromptDelivery === "string" && initialPromptDelivery.trim()
+        ? initialPromptDelivery.trim()
+        : "none";
     this.includeInitialImages = includeInitialImages;
     this.cliArgs = cliArgs;
     this.backendName = backendName || "codex";
@@ -1042,6 +1097,10 @@ export class BridgeRunner {
     this.runningTurn = false;
     this.processedMessageIds = new Set();
     this.inFlightMessageIds = new Set();
+    this.pendingInitialPrompt =
+      this.initialPromptDelivery === "queued" && typeof initialPrompt === "string" && initialPrompt.trim()
+        ? initialPrompt.trim()
+        : "";
     this.sessionStreamReplyCounts = new Map();
     this.lastRuntimeStatusSignature = null;
     this.lastRuntimeStatusPayload = null;
@@ -1230,8 +1289,8 @@ export class BridgeRunner {
       return;
     }
 
-    if (this.initialPrompt) {
-      this.copilotLog("processing initial prompt");
+    if (this.initialPrompt && this.initialPromptDelivery === "synthetic") {
+      this.copilotLog("processing initial prompt via synthetic attach flow");
       await this.handleSyntheticMessage(this.initialPrompt, {
         includeImages: this.includeInitialImages,
       });
@@ -1239,6 +1298,7 @@ export class BridgeRunner {
     if (this.stopped) {
       return;
     }
+
     while (!this.stopped) {
       if (this.needsReconnectRecovery && !this.runningTurn) {
         await this.recoverAfterReconnect();
@@ -1783,6 +1843,11 @@ export class BridgeRunner {
     if (replyTo) {
       this.inFlightMessageIds.add(replyTo);
     }
+    const isQueuedInitialPromptMessage =
+      Boolean(this.pendingInitialPrompt) &&
+      String(message.role || "").toLowerCase() === "user" &&
+      content === this.pendingInitialPrompt;
+    const useInitialImages = isQueuedInitialPromptMessage && this.includeInitialImages;
     if (
       this.useSessionFileReplyStream &&
       typeof this.backendSession?.setSessionReplyTarget === "function"
@@ -1830,6 +1895,7 @@ export class BridgeRunner {
       }
 
       const result = await this.backendSession.runTurn(content, {
+        useInitialImages,
         onProgress: (payload) => {
           void this.reportRuntimeStatus(payload, replyTo);
         },
@@ -1873,6 +1939,9 @@ export class BridgeRunner {
       if (replyTo) {
         this.processedMessageIds.add(replyTo);
       }
+      if (isQueuedInitialPromptMessage) {
+        this.pendingInitialPrompt = "";
+      }
       this.resetErrorLoop();
       if (this.useSessionFileReplyStream) {
         this.copilotLog(`session_file turn settled replyTo=${replyTo || "latest"}`);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@love-moon/conductor-cli",
-  "version": "0.2.18",
-  "gitCommitId": "942418b",
+  "version": "0.2.19",
+  "gitCommitId": "346e048",
   "type": "module",
   "bin": {
     "conductor": "bin/conductor.js"
@@ -17,11 +17,12 @@
     "test": "node --test test/*.test.js"
   },
   "dependencies": {
-    "@love-moon/ai-sdk": "0.2.18",
-    "@love-moon/conductor-sdk": "0.2.18",
+    "@love-moon/ai-sdk": "0.2.19",
+    "@love-moon/conductor-sdk": "0.2.19",
     "dotenv": "^16.4.5",
     "enquirer": "^2.4.1",
     "js-yaml": "^4.1.1",
+    "node-pty": "^1.0.0",
     "ws": "^8.18.0",
     "yargs": "^17.7.2",
     "chrome-launcher": "^1.2.1",

package/src/daemon.js

@@ -1,6 +1,7 @@
 import fs from "node:fs";
 import path from "node:path";
 import os from "node:os";
+import { createRequire } from "node:module";
 import { spawn } from "node:child_process";
 import { fileURLToPath } from "node:url";
 
@@ -9,11 +10,13 @@ import yaml from "js-yaml";
 
 import { ConductorWebSocketClient, ConductorConfig, loadConfig, ConfigFileNotFound } from "@love-moon/conductor-sdk";
 import { DaemonLogCollector } from "./log-collector.js";
+import { filterRuntimeSupportedAllowCliList, normalizeRuntimeBackendName } from "./runtime-backends.js";
 
 dotenv.config();
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
+const moduleRequire = createRequire(import.meta.url);
 const CLI_PATH = path.resolve(__dirname, "..", "bin", "conductor-fire.js");
 const DAEMON_LOG_DIR = path.join(os.homedir(), ".conductor", "logs");
 const DAEMON_LOG_PATH = path.join(DAEMON_LOG_DIR, "conductor-daemon.log");
@@ -22,6 +25,10 @@ const PLAN_LIMIT_MESSAGES = {
   app_active_task: "Free plan limit reached: only 1 active app task is allowed.",
   daemon_active_connection: "Free plan limit reached: only 1 active daemon connection is allowed.",
 };
+const DEFAULT_TERMINAL_COLS = 120;
+const DEFAULT_TERMINAL_ROWS = 40;
+const DEFAULT_TERMINAL_RING_BUFFER_MAX_BYTES = 2 * 1024 * 1024;
+let nodePtySpawnPromise = null;
 
 function appendDaemonLog(line) {
   try {
@@ -112,16 +119,118 @@ function getPlanLimitMessage(payload) {
 const DEFAULT_CLI_LIST = {
   codex: "codex --dangerously-bypass-approvals-and-sandbox",
   claude: "claude --dangerously-skip-permissions",
+  opencode: "opencode",
 };
 
 function getAllowCliList(userConfig) {
   // If user has configured allow_cli_list, use it; otherwise use defaults
   if (userConfig.allow_cli_list && typeof userConfig.allow_cli_list === "object") {
-    return userConfig.allow_cli_list;
+    return filterRuntimeSupportedAllowCliList(userConfig.allow_cli_list);
   }
   return DEFAULT_CLI_LIST;
 }
 
+async function defaultCreatePty(command, args, options) {
+  if (!nodePtySpawnPromise) {
+    const spawnHelperInfo = ensureNodePtySpawnHelperExecutable();
+    if (spawnHelperInfo?.updated) {
+      log(`Enabled execute permission on node-pty spawn-helper: ${spawnHelperInfo.helperPath}`);
+    }
+    nodePtySpawnPromise = import("node-pty").then((mod) => {
+      if (typeof mod.spawn === "function") {
+        return mod.spawn;
+      }
+      if (mod.default && typeof mod.default.spawn === "function") {
+        return mod.default.spawn.bind(mod.default);
+      }
+      throw new Error("node-pty spawn export not found");
+    });
+  }
+  const spawnPty = await nodePtySpawnPromise;
+  return spawnPty(command, args, options);
+}
+
+export function ensureNodePtySpawnHelperExecutable(deps = {}) {
+  const platform = deps.platform || process.platform;
+  if (platform === "win32") {
+    return null;
+  }
+
+  const arch = deps.arch || process.arch;
+  const existsSyncFn = deps.existsSync || fs.existsSync;
+  const statSyncFn = deps.statSync || fs.statSync;
+  const chmodSyncFn = deps.chmodSync || fs.chmodSync;
+  let packageJsonPath = deps.packageJsonPath || null;
+
+  if (!packageJsonPath) {
+    try {
+      packageJsonPath = moduleRequire.resolve("node-pty/package.json");
+    } catch {
+      return null;
+    }
+  }
+
+  const packageDir = path.dirname(packageJsonPath);
+  const helperCandidates = [
+    path.join(packageDir, "build", "Release", "spawn-helper"),
+    path.join(packageDir, "build", "Debug", "spawn-helper"),
+    path.join(packageDir, "prebuilds", `${platform}-${arch}`, "spawn-helper"),
+  ];
+  const helperPath = helperCandidates.find((candidate) => existsSyncFn(candidate));
+  if (!helperPath) {
+    return null;
+  }
+
+  const currentMode = statSyncFn(helperPath).mode & 0o777;
+  if ((currentMode & 0o111) !== 0) {
+    return { helperPath, updated: false };
+  }
+
+  const nextMode = currentMode | 0o111;
+  chmodSyncFn(helperPath, nextMode);
+  return { helperPath, updated: true };
+}
+
+function normalizeOptionalString(value) {
+  if (typeof value !== "string") {
+    return null;
+  }
+  const normalized = value.trim();
+  return normalized || null;
+}
+
+function normalizePositiveInt(value, fallback) {
+  const parsed = Number.parseInt(String(value ?? ""), 10);
+  if (Number.isFinite(parsed) && parsed > 0) {
+    return parsed;
+  }
+  return fallback;
+}
+
+function normalizeLaunchConfig(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return {};
+  }
+  return value;
+}
+
+function normalizeTerminalEnv(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return {};
+  }
+  const env = {};
+  for (const [key, raw] of Object.entries(value)) {
+    if (typeof raw === "string") {
+      env[key] = raw;
+      continue;
+    }
+    if (typeof raw === "number" || typeof raw === "boolean") {
+      env[key] = String(raw);
+    }
+  }
+  return env;
+}
+
 export function startDaemon(config = {}, deps = {}) {
   const exitFn = deps.exit || process.exit;
   const killFn = deps.kill || process.kill;
@@ -254,6 +363,10 @@ export function startDaemon(config = {}, deps = {}) {
     process.env.CONDUCTOR_DAEMON_WATCHDOG_MAX_SELF_HEALS,
     3,
   );
+  const TERMINAL_RING_BUFFER_MAX_BYTES = parsePositiveInt(
+    config.TERMINAL_RING_BUFFER_MAX_BYTES || process.env.CONDUCTOR_TERMINAL_RING_BUFFER_MAX_BYTES,
+    DEFAULT_TERMINAL_RING_BUFFER_MAX_BYTES,
+  );
 
   try {
     mkdirSyncFn(WORKSPACE_ROOT, { recursive: true });
@@ -389,6 +502,7 @@ export function startDaemon(config = {}, deps = {}) {
   let didRecoverStaleTasks = false;
   let daemonShuttingDown = false;
   const activeTaskProcesses = new Map();
+  const activePtySessions = new Map();
   const suppressedExitStatusReports = new Set();
   const seenCommandRequestIds = new Set();
   let lastConnectedAt = null;
@@ -406,10 +520,12 @@ export function startDaemon(config = {}, deps = {}) {
   let watchdogAwaitingHealthySignalAt = null;
   let watchdogTimer = null;
   const logCollector = createLogCollector(BACKEND_HTTP);
+  const createPtyFn = deps.createPty || defaultCreatePty;
   const client = createWebSocketClient(sdkConfig, {
     extraHeaders: {
       "x-conductor-host": AGENT_NAME,
       "x-conductor-backends": SUPPORTED_BACKENDS.join(","),
+      "x-conductor-capabilities": "pty_task",
     },
     onConnected: ({ isReconnect, connectedAt } = { isReconnect: false, connectedAt: Date.now() }) => {
       wsConnected = true;
@@ -626,6 +742,10 @@ export function startDaemon(config = {}, deps = {}) {
     }
   }
 
+  const getActiveTaskIds = () => [
+    ...new Set([...activeTaskProcesses.keys(), ...activePtySessions.keys()]),
+  ];
+
   async function recoverStaleTasks() {
     try {
       const response = await fetchFn(`${BACKEND_HTTP}/api/tasks`, {
@@ -701,7 +821,7 @@ export function startDaemon(config = {}, deps = {}) {
       if (!Array.isArray(tasks)) {
         return;
       }
-      const localTaskIds = new Set(activeTaskProcesses.keys());
+      const localTaskIds = new Set(getActiveTaskIds());
       const assigned = tasks.filter((task) => {
         const agentHost = String(task?.agent_host || "").trim();
         const status = String(task?.status || "").trim().toLowerCase();
@@ -746,7 +866,7 @@ export function startDaemon(config = {}, deps = {}) {
     await client.sendJson({
       type: "agent_resume",
       payload: {
-        active_tasks: [...activeTaskProcesses.keys()],
+        active_tasks: getActiveTaskIds(),
         source: "conductor-daemon",
         metadata: { is_reconnect: Boolean(isReconnect) },
       },
@@ -781,6 +901,442 @@ export function startDaemon(config = {}, deps = {}) {
     });
   }
 
+  function sendTerminalEvent(type, payload) {
+    return client.sendJson({
+      type,
+      payload,
+    });
+  }
+
+  function resolvePtyLaunchSpec(launchConfig, fallbackCwd) {
+    const normalizedLaunchConfig = normalizeLaunchConfig(launchConfig);
+    const entrypointType =
+      normalizeOptionalString(normalizedLaunchConfig.entrypoint_type) ||
+      normalizeOptionalString(normalizedLaunchConfig.entrypointType) ||
+      (normalizeOptionalString(normalizedLaunchConfig.tool_preset) ||
+      normalizeOptionalString(normalizedLaunchConfig.toolPreset)
+        ? "tool_preset"
+        : "shell");
+    const preferredShell =
+      normalizeOptionalString(normalizedLaunchConfig.shell) ||
+      process.env.SHELL ||
+      "/bin/zsh";
+    const cwd =
+      normalizeOptionalString(normalizedLaunchConfig.cwd) ||
+      fallbackCwd;
+    const env = normalizeTerminalEnv(normalizedLaunchConfig.env);
+    const cols = normalizePositiveInt(
+      normalizedLaunchConfig.cols ?? normalizedLaunchConfig.columns,
+      DEFAULT_TERMINAL_COLS,
+    );
+    const rows = normalizePositiveInt(
+      normalizedLaunchConfig.rows,
+      DEFAULT_TERMINAL_ROWS,
+    );
+
+    if (entrypointType === "tool_preset") {
+      const toolPreset =
+        normalizeOptionalString(normalizedLaunchConfig.tool_preset) ||
+        normalizeOptionalString(normalizedLaunchConfig.toolPreset) ||
+        SUPPORTED_BACKENDS[0] ||
+        "codex";
+      const cliCommand = ALLOW_CLI_LIST[toolPreset];
+      if (!cliCommand) {
+        throw new Error(`Unsupported tool preset: ${toolPreset}`);
+      }
+      return {
+        entrypointType,
+        toolPreset,
+        command: preferredShell,
+        args: ["-lc", cliCommand],
+        shell: preferredShell,
+        cwd,
+        env,
+        cols,
+        rows,
+      };
+    }
+
+    if (entrypointType === "custom") {
+      const command = normalizeOptionalString(normalizedLaunchConfig.command);
+      if (!command) {
+        throw new Error("launch_config.command is required for custom entrypoint");
+      }
+      const args = Array.isArray(normalizedLaunchConfig.args)
+        ? normalizedLaunchConfig.args.filter((value) => typeof value === "string")
+        : [];
+      return {
+        entrypointType,
+        toolPreset: null,
+        command,
+        args,
+        shell: preferredShell,
+        cwd,
+        env,
+        cols,
+        rows,
+      };
+    }
+
+    return {
+      entrypointType: "shell",
+      toolPreset: null,
+      command: preferredShell,
+      args: ["-l"],
+      shell: preferredShell,
+      cwd,
+      env,
+      cols,
+      rows,
+    };
+  }
+
+  function getTerminalChunkByteLength(data) {
+    return Buffer.byteLength(data, "utf8");
+  }
+
+  function trimTerminalChunkToTailBytes(data, maxBytes) {
+    const encoded = Buffer.from(data, "utf8");
+    if (encoded.length <= maxBytes) {
+      return data;
+    }
+    const tail = encoded.subarray(encoded.length - maxBytes);
+    let start = 0;
+    while (start < tail.length && (tail[start] & 0b1100_0000) === 0b1000_0000) {
+      start += 1;
+    }
+    return tail.subarray(start).toString("utf8");
+  }
+
+  function bufferTerminalOutput(record, data) {
+    record.outputSeq += 1;
+    let bufferedData = typeof data === "string" ? data : String(data ?? "");
+    let byteLength = getTerminalChunkByteLength(bufferedData);
+    if (byteLength > TERMINAL_RING_BUFFER_MAX_BYTES) {
+      bufferedData = trimTerminalChunkToTailBytes(bufferedData, TERMINAL_RING_BUFFER_MAX_BYTES);
+      byteLength = getTerminalChunkByteLength(bufferedData);
+    }
+    record.ringBuffer.push({ seq: record.outputSeq, data: bufferedData, byteLength });
+    record.ringBufferByteLength += byteLength;
+    while (record.ringBufferByteLength > TERMINAL_RING_BUFFER_MAX_BYTES && record.ringBuffer.length > 0) {
+      const removed = record.ringBuffer.shift();
+      record.ringBufferByteLength -= removed?.byteLength ?? 0;
+    }
+    return record.outputSeq;
+  }
+
+  function attachPtyStreamHandlers(taskId, record) {
+    const writeLogChunk = (chunk) => {
+      if (record.logStream) {
+        record.logStream.write(chunk);
+      }
+    };
+
+    record.pty.onData((data) => {
+      writeLogChunk(data);
+      const seq = bufferTerminalOutput(record, data);
+      sendTerminalEvent("terminal_output", {
+        task_id: taskId,
+        project_id: record.projectId,
+        pty_session_id: record.ptySessionId,
+        seq,
+        data,
+      }).catch((err) => {
+        logError(`Failed to report terminal_output for ${taskId}: ${err?.message || err}`);
+      });
+    });
+
+    record.pty.onExit(({ exitCode, signal }) => {
+      if (record.stopForceKillTimer) {
+        clearTimeout(record.stopForceKillTimer);
+      }
+      activePtySessions.delete(taskId);
+      if (record.logStream) {
+        const ts = new Date().toLocaleString("sv-SE", { timeZone: "Asia/Shanghai" }).replace(" ", "T");
+        record.logStream.write(
+          `[daemon ${ts}] pty exited exitCode=${exitCode ?? "null"} signal=${signal ?? "null"}\n`,
+        );
+        record.logStream.end();
+      }
+      const closedAt = new Date().toISOString();
+      log(`PTY task ${taskId} exited with code=${exitCode ?? "null"} signal=${signal ?? "null"}`);
+      sendTerminalEvent("terminal_exit", {
+        task_id: taskId,
+        project_id: record.projectId,
+        pty_session_id: record.ptySessionId,
+        exit_code: exitCode ?? null,
+        signal: signal ?? null,
+        seq: record.outputSeq,
+        closed_at: closedAt,
+      }).catch((err) => {
+        logError(`Failed to report terminal_exit for ${taskId}: ${err?.message || err}`);
+      });
+    });
+  }
+
+  function resizePty(record, cols, rows) {
+    const nextCols = normalizePositiveInt(cols, record.cols || DEFAULT_TERMINAL_COLS);
+    const nextRows = normalizePositiveInt(rows, record.rows || DEFAULT_TERMINAL_ROWS);
+    record.cols = nextCols;
+    record.rows = nextRows;
+    if (typeof record.pty.resize === "function") {
+      record.pty.resize(nextCols, nextRows);
+    }
+  }
+
+  async function handleCreatePtyTask(payload) {
+    const taskId = payload?.task_id ? String(payload.task_id) : "";
+    const projectId = payload?.project_id ? String(payload.project_id) : "";
+    const ptySessionId = payload?.pty_session_id ? String(payload.pty_session_id) : "";
+    const requestId = payload?.request_id ? String(payload.request_id) : "";
+    const launchConfig = normalizeLaunchConfig(payload?.launch_config);
+
+    if (!taskId || !projectId || !ptySessionId) {
+      logError(`Invalid create_pty_task payload: ${JSON.stringify(payload)}`);
+      sendAgentCommandAck({
+        requestId,
+        taskId,
+        eventType: "create_pty_task",
+        accepted: false,
+      }).catch(() => {});
+      return;
+    }
+
+    if (requestId && !markRequestSeen(requestId)) {
+      log(`Duplicate create_pty_task ignored for ${taskId} (request_id=${requestId})`);
+      sendAgentCommandAck({
+        requestId,
+        taskId,
+        eventType: "create_pty_task",
+        accepted: true,
+      }).catch(() => {});
+      return;
+    }
+
+    if (activeTaskProcesses.has(taskId) || activePtySessions.has(taskId)) {
+      log(`Duplicate create_pty_task ignored for ${taskId}: task already active`);
+      sendAgentCommandAck({
+        requestId,
+        taskId,
+        eventType: "create_pty_task",
+        accepted: true,
+      }).catch(() => {});
+      return;
+    }
+
+    let boundPath = await getProjectLocalPath(projectId);
+    let taskDir = normalizeOptionalString(launchConfig.cwd) || boundPath;
+    if (!taskDir) {
+      const now = new Date();
+      const dayDir = path.join(WORKSPACE_ROOT, formatWorkspaceDate(now));
+      const runTimestampPart = formatWorkspaceRunTimestamp(now);
+      const taskSuffix = taskId.replace(/[^a-zA-Z0-9]/g, "").slice(0, 8) || String(process.pid);
+      // PTY login shells can exit immediately if their cwd is renamed right after spawn.
+      const pendingRunDir = `${runTimestampPart}_pty_${taskSuffix}`;
+      taskDir = path.join(dayDir, pendingRunDir);
+    }
+
+    try {
+      mkdirSyncFn(taskDir, { recursive: true });
+    } catch (err) {
+      logError(`Failed to create PTY workspace ${taskDir}: ${err?.message || err}`);
+      sendAgentCommandAck({
+        requestId,
+        taskId,
+        eventType: "create_pty_task",
+        accepted: false,
+      }).catch(() => {});
+      return;
+    }
+
+    let launchSpec;
+    try {
+      launchSpec = resolvePtyLaunchSpec(launchConfig, taskDir);
+    } catch (error) {
+      logError(`Failed to resolve PTY launch config for ${taskId}: ${error?.message || error}`);
+      sendAgentCommandAck({
+        requestId,
+        taskId,
+        eventType: "create_pty_task",
+        accepted: false,
+      }).catch(() => {});
+      sendTerminalEvent("terminal_error", {
+        task_id: taskId,
+        project_id: projectId,
+        pty_session_id: ptySessionId,
+        message: error?.message || String(error),
+      }).catch(() => {});
+      return;
+    }
+
+    sendAgentCommandAck({
+      requestId,
+      taskId,
+      eventType: "create_pty_task",
+      accepted: true,
+    }).catch((err) => {
+      logError(`Failed to report agent_command_ack(create_pty_task) for ${taskId}: ${err?.message || err}`);
+    });
+
+    const env = {
+      ...process.env,
+      ...launchSpec.env,
+      CONDUCTOR_PROJECT_ID: projectId,
+      CONDUCTOR_TASK_ID: taskId,
+      CONDUCTOR_PTY_SESSION_ID: ptySessionId,
+    };
+    if (config.CONFIG_FILE) {
+      env.CONDUCTOR_CONFIG = config.CONFIG_FILE;
+    }
+    if (AGENT_TOKEN) {
+      env.CONDUCTOR_AGENT_TOKEN = AGENT_TOKEN;
+    }
+    if (BACKEND_HTTP) {
+      env.CONDUCTOR_BACKEND_URL = BACKEND_HTTP;
+    }
+
+    const logPath = path.join(launchSpec.cwd, "conductor-terminal.log");
+    let logStream;
+    try {
+      logStream = createWriteStreamFn(logPath, { flags: "a" });
+      if (logStream && typeof logStream.on === "function") {
+        const logPathSnapshot = logPath;
+        logStream.on("error", (err) => {
+          logError(`Terminal log stream error (${logPathSnapshot}): ${err?.message || err}`);
+        });
+      }
+    } catch (err) {
+      logError(`Failed to open PTY log file ${logPath}: ${err?.message || err}`);
+    }
+
+    try {
+      const pty = await createPtyFn(launchSpec.command, launchSpec.args, {
+        name: "xterm-256color",
+        cols: launchSpec.cols,
+        rows: launchSpec.rows,
+        cwd: launchSpec.cwd,
+        env,
+      });
+      const resolvedLogPath = path.join(taskDir, "conductor-terminal.log");
+
+      const startedAt = new Date().toISOString();
+      const record = {
+        kind: "pty",
+        pty,
+        ptySessionId,
+        projectId,
+        taskDir,
+        logPath: resolvedLogPath,
+        logStream,
+        cols: launchSpec.cols,
+        rows: launchSpec.rows,
+        shell: launchSpec.shell,
+        startedAt,
+        outputSeq: 0,
+        ringBuffer: [],
+        ringBufferByteLength: 0,
+        stopForceKillTimer: null,
+      };
+      activePtySessions.set(taskId, record);
+      attachPtyStreamHandlers(taskId, record);
+
+      log(`Created PTY task ${taskId} (${launchSpec.entrypointType}) cwd=${launchSpec.cwd}`);
+      sendTerminalEvent("terminal_opened", {
+        task_id: taskId,
+        project_id: projectId,
+        pty_session_id: ptySessionId,
+        pid: Number.isInteger(pty?.pid) ? pty.pid : null,
+        cwd: taskDir,
+        shell: launchSpec.shell,
+        cols: launchSpec.cols,
+        rows: launchSpec.rows,
+        started_at: startedAt,
+      }).catch((err) => {
+        logError(`Failed to report terminal_opened for ${taskId}: ${err?.message || err}`);
+      });
+    } catch (error) {
+      if (logStream) {
+        logStream.end();
+      }
+      logError(`Failed to create PTY task ${taskId}: ${error?.message || error}`);
+      sendTerminalEvent("terminal_error", {
+        task_id: taskId,
+        project_id: projectId,
+        pty_session_id: ptySessionId,
+        message: error?.message || String(error),
+      }).catch(() => {});
+    }
+  }
+
+  async function handleTerminalAttach(payload) {
+    const taskId = payload?.task_id ? String(payload.task_id) : "";
+    if (!taskId) return;
+    const record = activePtySessions.get(taskId);
+    if (!record) {
+      sendTerminalEvent("terminal_error", {
+        task_id: taskId,
+        pty_session_id: payload?.pty_session_id ? String(payload.pty_session_id) : null,
+        message: "terminal session not found",
+      }).catch(() => {});
+      return;
+    }
+
+    if (payload?.cols || payload?.rows) {
+      resizePty(record, payload?.cols, payload?.rows);
+    }
+
+    await sendTerminalEvent("terminal_opened", {
+      task_id: taskId,
+      project_id: record.projectId,
+      pty_session_id: record.ptySessionId,
+      pid: Number.isInteger(record.pty?.pid) ? record.pty.pid : null,
+      cwd: record.taskDir,
+      shell: record.shell,
+      cols: record.cols,
+      rows: record.rows,
+      started_at: record.startedAt,
+    }).catch((err) => {
+      logError(`Failed to report terminal_opened on attach for ${taskId}: ${err?.message || err}`);
+    });
+
+    const lastSeq = normalizePositiveInt(payload?.last_seq ?? payload?.lastSeq, 0);
+    for (const chunk of record.ringBuffer) {
+      if (chunk.seq <= lastSeq) continue;
+      await sendTerminalEvent("terminal_output", {
+        task_id: taskId,
+        project_id: record.projectId,
+        pty_session_id: record.ptySessionId,
+        seq: chunk.seq,
+        data: chunk.data,
+      }).catch((err) => {
+        logError(`Failed to replay terminal_output for ${taskId}: ${err?.message || err}`);
+      });
+    }
+  }
+
+  function handleTerminalInput(payload) {
+    const taskId = payload?.task_id ? String(payload.task_id) : "";
+    const data = typeof payload?.data === "string" ? payload.data : "";
+    if (!taskId || !data) return;
+    const record = activePtySessions.get(taskId);
+    if (!record || typeof record.pty.write !== "function") {
+      return;
+    }
+    record.pty.write(data);
+  }
+
+  function handleTerminalResize(payload) {
+    const taskId = payload?.task_id ? String(payload.task_id) : "";
+    if (!taskId) return;
+    const record = activePtySessions.get(taskId);
+    if (!record) return;
+    resizePty(record, payload?.cols, payload?.rows);
+  }
+
+  function handleTerminalDetach(_payload) {
+    // PTY sessions stay alive without viewers. Detach is currently a no-op.
+  }
+
   function handleEvent(event) {
     const receivedAt = Date.now();
     lastInboundAt = receivedAt;
@@ -805,10 +1361,30 @@ export function startDaemon(config = {}, deps = {}) {
       handleCreateTask(event.payload);
       return;
     }
+    if (event.type === "create_pty_task") {
+      void handleCreatePtyTask(event.payload);
+      return;
+    }
     if (event.type === "stop_task") {
       handleStopTask(event.payload);
       return;
     }
+    if (event.type === "terminal_attach") {
+      void handleTerminalAttach(event.payload);
+      return;
+    }
+    if (event.type === "terminal_input") {
+      handleTerminalInput(event.payload);
+      return;
+    }
+    if (event.type === "terminal_resize") {
+      handleTerminalResize(event.payload);
+      return;
+    }
+    if (event.type === "terminal_detach") {
+      handleTerminalDetach(event.payload);
+      return;
+    }
     if (event.type === "collect_logs") {
       void handleCollectLogs(event.payload);
     }
@@ -922,8 +1498,9 @@ export function startDaemon(config = {}, deps = {}) {
       });
     };
 
-    const record = activeTaskProcesses.get(taskId);
-    if (!record || !record.child) {
+    const processRecord = activeTaskProcesses.get(taskId);
+    const ptyRecord = activePtySessions.get(taskId);
+    if ((!processRecord || !processRecord.child) && !ptyRecord) {
       log(`Stop requested for task ${taskId}, but no active process found`);
       sendStopAck(false);
       return;
@@ -934,36 +1511,58 @@ export function startDaemon(config = {}, deps = {}) {
 
     sendStopAck(true);
 
-    if (record.stopForceKillTimer) {
-      clearTimeout(record.stopForceKillTimer);
-      record.stopForceKillTimer = null;
+    const activeRecord = processRecord || ptyRecord;
+    if (activeRecord?.stopForceKillTimer) {
+      clearTimeout(activeRecord.stopForceKillTimer);
+      activeRecord.stopForceKillTimer = null;
     }
 
-    try {
-      if (typeof record.child.kill === "function") {
-        record.child.kill("SIGTERM");
+    if (processRecord?.child) {
+      try {
+        if (typeof processRecord.child.kill === "function") {
+          processRecord.child.kill("SIGTERM");
+        }
+      } catch (error) {
+        logError(`Failed to stop task ${taskId}: ${error?.message || error}`);
+      }
+    } else if (ptyRecord?.pty) {
+      try {
+        if (typeof ptyRecord.pty.kill === "function") {
+          ptyRecord.pty.kill("SIGTERM");
+        }
+      } catch (error) {
+        logError(`Failed to stop PTY task ${taskId}: ${error?.message || error}`);
       }
-    } catch (error) {
-      logError(`Failed to stop task ${taskId}: ${error?.message || error}`);
     }
 
-    record.stopForceKillTimer = setTimeout(() => {
-      const latest = activeTaskProcesses.get(taskId);
-      if (!latest || latest.child !== record.child) {
+    activeRecord.stopForceKillTimer = setTimeout(() => {
+      const latestProcess = activeTaskProcesses.get(taskId);
+      const latestPty = activePtySessions.get(taskId);
+      if (latestProcess?.child && processRecord?.child && latestProcess.child === processRecord.child) {
+        try {
+          if (typeof latestProcess.child.kill === "function") {
+            log(`Task ${taskId} did not exit after SIGTERM, sending SIGKILL`);
+            latestProcess.child.kill("SIGKILL");
+          }
+        } catch (error) {
+          logError(`Failed to SIGKILL task ${taskId}: ${error?.message || error}`);
+        }
         return;
       }
-      try {
-        if (typeof latest.child.kill === "function") {
-          log(`Task ${taskId} did not exit after SIGTERM, sending SIGKILL`);
-          latest.child.kill("SIGKILL");
+      if (latestPty?.pty && ptyRecord?.pty && latestPty.pty === ptyRecord.pty) {
+        try {
+          if (typeof latestPty.pty.kill === "function") {
+            log(`PTY task ${taskId} did not exit after SIGTERM, sending SIGKILL`);
+            latestPty.pty.kill("SIGKILL");
+          }
+        } catch (error) {
+          logError(`Failed to SIGKILL PTY task ${taskId}: ${error?.message || error}`);
         }
-      } catch (error) {
-        logError(`Failed to SIGKILL task ${taskId}: ${error?.message || error}`);
       }
     }, STOP_FORCE_KILL_TIMEOUT_MS);
 
-    if (typeof record.stopForceKillTimer?.unref === "function") {
-      record.stopForceKillTimer.unref();
+    if (typeof activeRecord.stopForceKillTimer?.unref === "function") {
+      activeRecord.stopForceKillTimer.unref();
     }
   }
 
@@ -1067,7 +1666,7 @@ export function startDaemon(config = {}, deps = {}) {
     }
 
     // Validate and get CLI command for the backend
-    const effectiveBackend = backendType || SUPPORTED_BACKENDS[0];
+    const effectiveBackend = normalizeRuntimeBackendName(backendType || SUPPORTED_BACKENDS[0]);
     if (!SUPPORTED_BACKENDS.includes(effectiveBackend)) {
       logError(`Unsupported backend: ${effectiveBackend}. Supported: ${SUPPORTED_BACKENDS.join(", ")}`);
       sendAgentCommandAck({
@@ -1315,7 +1914,9 @@ export function startDaemon(config = {}, deps = {}) {
         clearInterval(watchdogTimer);
         watchdogTimer = null;
       }
-      const activeEntries = [...activeTaskProcesses.entries()];
+      const activeProcessEntries = [...activeTaskProcesses.entries()];
+      const activePtyEntries = [...activePtySessions.entries()];
+      const activeEntries = [...activeProcessEntries, ...activePtyEntries];
       if (activeEntries.length > 0) {
         log(`Shutdown requested (${reason}); stopping ${activeEntries.length} active task(s)`);
       }
@@ -1343,7 +1944,7 @@ export function startDaemon(config = {}, deps = {}) {
         }),
       );
 
-      for (const [taskId, record] of activeEntries) {
+      for (const [taskId, record] of activeProcessEntries) {
         if (record?.stopForceKillTimer) {
           clearTimeout(record.stopForceKillTimer);
         }
@@ -1356,7 +1957,21 @@ export function startDaemon(config = {}, deps = {}) {
         }
       }
 
+      for (const [taskId, record] of activePtyEntries) {
+        if (record?.stopForceKillTimer) {
+          clearTimeout(record.stopForceKillTimer);
+        }
+        try {
+          if (typeof record.pty?.kill === "function") {
+            record.pty.kill("SIGTERM");
+          }
+        } catch (error) {
+          logError(`Failed to stop PTY task ${taskId} on daemon close: ${error?.message || error}`);
+        }
+      }
+
       activeTaskProcesses.clear();
+      activePtySessions.clear();
 
       try {
         await withTimeout(

package/src/runtime-backends.js

@@ -0,0 +1,31 @@
+export const RUNTIME_SUPPORTED_BACKENDS = ["codex", "claude", "opencode"];
+
+export function normalizeRuntimeBackendName(backend) {
+  return String(backend || "").trim().toLowerCase();
+}
+
+export function isRuntimeSupportedBackend(backend) {
+  return RUNTIME_SUPPORTED_BACKENDS.includes(normalizeRuntimeBackendName(backend));
+}
+
+export function filterRuntimeSupportedAllowCliList(allowCliList) {
+  if (!allowCliList || typeof allowCliList !== "object") {
+    return {};
+  }
+
+  const filtered = {};
+  for (const [backend, command] of Object.entries(allowCliList)) {
+    const normalizedBackend = normalizeRuntimeBackendName(backend);
+    if (!RUNTIME_SUPPORTED_BACKENDS.includes(normalizedBackend)) {
+      continue;
+    }
+    if (typeof command !== "string" || !command.trim()) {
+      continue;
+    }
+    if (filtered[normalizedBackend] !== undefined) {
+      continue;
+    }
+    filtered[normalizedBackend] = command;
+  }
+  return filtered;
+}