@love-moon/conductor-cli 0.2.17 → 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,12 +26,14 @@ 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);
 const PKG_ROOT = path.join(__dirname, "..");
 const INITIAL_CLI_PROJECT_PATH = process.cwd();
 const FIRE_LOG_PATH = path.join(INITIAL_CLI_PROJECT_PATH, "conductor.log");
+const FIRE_TASK_MARKER_PREFIX = "active-fire";
 const ENABLE_FIRE_LOCAL_LOG = !process.env.CONDUCTOR_CLI_COMMAND;
 
 const pkgJson = JSON.parse(fs.readFileSync(path.join(PKG_ROOT, "package.json"), "utf-8"));
@@ -49,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) {
@@ -58,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,
@@ -179,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)) {
@@ -303,6 +334,13 @@ async function main() {
       backend: cliArgs.backend,
       daemonName: configuredDaemonName,
     });
+    injectResolvedTaskId(taskContext.taskId);
+    injectResolvedTaskId(taskContext.taskId, env);
+    try {
+      writeFireTaskMarker(taskContext.taskId, runtimeProjectPath);
+    } catch (error) {
+      log(`Note: Could not persist local task marker: ${error.message}`);
+    }
 
     log(
       `Attached to Conductor task ${taskContext.taskId}${
@@ -325,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 },
     });
 
@@ -351,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,
@@ -570,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",
@@ -632,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"
@@ -660,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));
@@ -711,6 +767,73 @@ export function resolveRequestedTaskTitle({
   return resolveTaskTitle(explicit, runtimeProjectPath);
 }
 
+function normalizeTaskId(value) {
+  if (typeof value !== "string") {
+    return "";
+  }
+  return value.trim();
+}
+
+function resolveFireStateDir(workingDirectory = process.cwd()) {
+  const baseDir =
+    typeof workingDirectory === "string" && workingDirectory.trim()
+      ? path.resolve(workingDirectory.trim())
+      : process.cwd();
+  return path.join(baseDir, ".conductor", "state");
+}
+
+export function injectResolvedTaskId(taskId, env = process.env) {
+  const normalizedTaskId = normalizeTaskId(taskId);
+  if (!normalizedTaskId) {
+    return "";
+  }
+  env.CONDUCTOR_TASK_ID = normalizedTaskId;
+  return normalizedTaskId;
+}
+
+export function writeFireTaskMarker(taskId, workingDirectory = process.cwd()) {
+  const normalizedTaskId = normalizeTaskId(taskId);
+  if (!normalizedTaskId) {
+    return "";
+  }
+
+  const stateDir = resolveFireStateDir(workingDirectory);
+  const markerFileName = `${FIRE_TASK_MARKER_PREFIX}.task_${normalizedTaskId}.json`;
+  const markerPath = path.join(stateDir, markerFileName);
+
+  fs.mkdirSync(stateDir, { recursive: true });
+  fs.writeFileSync(
+    markerPath,
+    `${JSON.stringify(
+      {
+        source: "conductor-fire",
+        taskId: normalizedTaskId,
+        cwd: path.resolve(workingDirectory),
+        updatedAt: new Date().toISOString(),
+      },
+      null,
+      2,
+    )}\n`,
+    "utf8",
+  );
+
+  for (const entry of fs.readdirSync(stateDir)) {
+    if (entry === markerFileName) {
+      continue;
+    }
+    if (!entry.startsWith(`${FIRE_TASK_MARKER_PREFIX}.task_`) || !entry.endsWith(".json")) {
+      continue;
+    }
+    try {
+      fs.unlinkSync(path.join(stateDir, entry));
+    } catch {
+      // ignore stale marker cleanup failures
+    }
+  }
+
+  return markerPath;
+}
+
 function normalizeArray(value) {
   if (!value) {
     return [];
@@ -731,6 +854,7 @@ async function ensureTaskContext(conductor, opts) {
       taskId: opts.providedTaskId,
       appUrl: null,
       shouldProcessInitialPrompt: Boolean(opts.initialPrompt),
+      initialPromptDelivery: opts.initialPrompt ? "synthetic" : "none",
     };
   }
 
@@ -762,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",
   };
 }
 
@@ -941,6 +1066,7 @@ export class BridgeRunner {
     taskId,
     pollIntervalMs,
     initialPrompt,
+    initialPromptDelivery,
     includeInitialImages,
     cliArgs,
     backendName,
@@ -952,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";
@@ -967,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;
@@ -992,6 +1126,7 @@ export class BridgeRunner {
     this.needsReconnectRecovery = false;
     this.remoteStopInfo = null;
     this.sessionAnnouncementSent = false;
+    this.boundSessionId = "";
     this.errorLoop = null;
     this.errorLoopWindowMs = getBoundedEnvInt(
       "CONDUCTOR_ERROR_LOOP_WINDOW_MS",
@@ -1058,16 +1193,11 @@ export class BridgeRunner {
     const message = hasRealSessionId
       ? `${this.backendName} session started: ${sessionId}`
       : `${this.backendName} session started`;
-    if (hasRealSessionId && typeof this.conductor?.bindTaskSession === "function") {
-      try {
-        await this.conductor.bindTaskSession(this.taskId, {
-          session_id: sessionId,
-          session_file_path: sessionFilePath || undefined,
-          backend_type: this.backendName,
-        });
-      } catch (error) {
-        log(`Failed to persist task session binding for ${this.taskId}: ${error?.message || error}`);
-      }
+    if (hasRealSessionId) {
+      await this.persistTaskSessionBinding({
+        sessionId,
+        sessionFilePath,
+      });
     }
     try {
       await this.conductor.sendMessage(this.taskId, message, {
@@ -1101,6 +1231,51 @@ export class BridgeRunner {
     }
   }
 
+  async persistTaskSessionBinding({ sessionId, sessionFilePath } = {}) {
+    const normalizedSessionId = typeof sessionId === "string" ? sessionId.trim() : "";
+    if (!normalizedSessionId || normalizedSessionId === this.boundSessionId) {
+      return false;
+    }
+    if (typeof this.conductor?.bindTaskSession !== "function") {
+      return false;
+    }
+    try {
+      await this.conductor.bindTaskSession(this.taskId, {
+        session_id: normalizedSessionId,
+        session_file_path:
+          typeof sessionFilePath === "string" && sessionFilePath.trim() ? sessionFilePath.trim() : undefined,
+        backend_type: this.backendName,
+      });
+      this.boundSessionId = normalizedSessionId;
+      return true;
+    } catch (error) {
+      log(`Failed to persist task session binding for ${this.taskId}: ${error?.message || error}`);
+      return false;
+    }
+  }
+
+  async syncBackendSessionBinding() {
+    if (!this.backendSession) {
+      return false;
+    }
+    let sessionInfo = null;
+    try {
+      if (typeof this.backendSession.getSessionInfo === "function") {
+        sessionInfo = this.backendSession.getSessionInfo();
+      }
+      if (!sessionInfo && typeof this.backendSession.ensureSessionInfo === "function") {
+        sessionInfo = await this.backendSession.ensureSessionInfo();
+      }
+    } catch (error) {
+      this.copilotLog(`session binding sync skipped: ${sanitizeForLog(error?.message || error, 160)}`);
+      return false;
+    }
+    return this.persistTaskSessionBinding({
+      sessionId: sessionInfo?.sessionId,
+      sessionFilePath: sessionInfo?.sessionFilePath,
+    });
+  }
+
   async start(abortSignal) {
     abortSignal?.addEventListener("abort", () => {
       this.stopped = true;
@@ -1114,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,
       });
@@ -1123,6 +1298,7 @@ export class BridgeRunner {
     if (this.stopped) {
       return;
     }
+
     while (!this.stopped) {
       if (this.needsReconnectRecovery && !this.runningTurn) {
         await this.recoverAfterReconnect();
@@ -1505,6 +1681,11 @@ export class BridgeRunner {
       return;
     }
 
+    await this.persistTaskSessionBinding({
+      sessionId,
+      sessionFilePath,
+    });
+
     logBackendReply(this.backendName, normalizedText, {
       usage: null,
       replyTo: replyTo || "latest",
@@ -1662,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"
@@ -1709,6 +1895,7 @@ export class BridgeRunner {
       }
 
       const result = await this.backendSession.runTurn(content, {
+        useInitialImages,
         onProgress: (payload) => {
           void this.reportRuntimeStatus(payload, replyTo);
         },
@@ -1748,9 +1935,13 @@ export class BridgeRunner {
           cli_args: this.cliArgs,
         });
       }
+      await this.syncBackendSessionBinding();
       if (replyTo) {
         this.processedMessageIds.add(replyTo);
       }
+      if (isQueuedInitialPromptMessage) {
+        this.pendingInitialPrompt = "";
+      }
       this.resetErrorLoop();
       if (this.useSessionFileReplyStream) {
         this.copilotLog(`session_file turn settled replyTo=${replyTo || "latest"}`);
@@ -1877,6 +2068,7 @@ export class BridgeRunner {
       } else {
         this.copilotLog("synthetic session_file turn settled");
       }
+      await this.syncBackendSessionBinding();
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : String(error);
       if (this.stopped && (this.remoteStopInfo || isSessionClosedError(error))) {