@love-moon/conductor-cli 0.2.30 → 0.2.32

package/bin/conductor-config.js

@@ -257,7 +257,8 @@ async function main() {
     "# envs:",
     "#   http_proxy: http://127.0.0.1:7890",
     "#   https_proxy: http://127.0.0.1:7890",
-    "#   all_proxy: socks5://127.0.0.1:7890"
+    "#   all_proxy: socks5://127.0.0.1:7890",
+    "#   AISDK_PROVIDER_PATH: path-to-private-aisdk-provider.js"
   );
 
   fs.writeFileSync(CONFIG_FILE, lines.join("\n"), "utf-8");

package/bin/conductor-fire.js

@@ -26,7 +26,13 @@ import {
   resolveSessionRunDirectory as resolveCliSessionRunDirectory,
   resumeProviderForBackend as resumeProviderForCliBackend,
 } from "../src/fire/resume.js";
-import { filterRuntimeSupportedAllowCliList, normalizeRuntimeBackendName } from "../src/runtime-backends.js";
+import {
+  filterRuntimeSupportedAllowCliList,
+  RUNTIME_SUPPORTED_BACKENDS,
+  listRuntimeSupportedBackends,
+  normalizeRuntimeBackendAlias,
+  normalizeRuntimeBackendName,
+} from "../src/runtime-backends.js";
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
@@ -34,7 +40,19 @@ 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;
+
+export function isLaunchedByDaemon(env = process.env) {
+  const daemonHostedValue =
+    typeof env?.CONDUCTOR_LAUNCHED_BY_DAEMON === "string" ? env.CONDUCTOR_LAUNCHED_BY_DAEMON.trim().toLowerCase() : "";
+  if (daemonHostedValue && daemonHostedValue !== "0" && daemonHostedValue !== "false" && daemonHostedValue !== "no") {
+    return true;
+  }
+  return Boolean(
+    typeof env?.CONDUCTOR_CLI_COMMAND === "string" && env.CONDUCTOR_CLI_COMMAND.trim(),
+  );
+}
+
+const ENABLE_FIRE_LOCAL_LOG = !isLaunchedByDaemon(process.env);
 
 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(
@@ -48,21 +66,36 @@ export function buildConductorConnectHeaders(version = pkgJson.version) {
   };
 }
 
+export function shouldRunReconnectRecovery({
+  isReconnect,
+  fireShuttingDown = false,
+  runner = null,
+} = {}) {
+  if (!isReconnect || fireShuttingDown) {
+    return false;
+  }
+  if (!runner || typeof runner.shouldSuppressReconnectRecovery !== "function") {
+    return true;
+  }
+  return !runner.shouldSuppressReconnectRecovery();
+}
+
 // Load allow_cli_list from config file (no defaults - must be configured)
-function loadAllowCliList(configFilePath) {
+async function loadAllowCliList(configFilePath) {
+  const home = os.homedir();
+  const configPath = configFilePath || process.env.CONDUCTOR_CONFIG || path.join(home, ".conductor", "config.yaml");
+  let parsed = null;
   try {
-    const home = os.homedir();
-    const configPath = configFilePath || process.env.CONDUCTOR_CONFIG || path.join(home, ".conductor", "config.yaml");
     if (fs.existsSync(configPath)) {
       const content = fs.readFileSync(configPath, "utf8");
-      const parsed = yaml.load(content);
-      if (parsed && typeof parsed === "object" && parsed.allow_cli_list) {
-        return filterRuntimeSupportedAllowCliList(parsed.allow_cli_list);
-      }
+      parsed = yaml.load(content);
     }
   } catch (error) {
     // ignore error
   }
+  if (parsed && typeof parsed === "object" && parsed.allow_cli_list) {
+    return await filterRuntimeSupportedAllowCliList(parsed.allow_cli_list, { configFilePath: configPath });
+  }
   return {};
 }
 
@@ -396,7 +429,7 @@ export class FireWatchdog {
 }
 
 async function main() {
-  const cliArgs = parseCliArgs();
+  const cliArgs = await parseCliArgs();
   let runtimeProjectPath = process.cwd();
   let backendSession = null;
 
@@ -409,18 +442,28 @@ async function main() {
     return;
   }
 
-  const allowCliList = loadAllowCliList(cliArgs.configFile);
+  const allowCliList = await loadAllowCliList(cliArgs.configFile);
   const supportedBackends = Object.keys(allowCliList);
+  const discoveredBackends = await listRuntimeSupportedBackends({ configFilePath: cliArgs.configFile });
+  const externalBackends = discoveredBackends.filter((backend) => !RUNTIME_SUPPORTED_BACKENDS.includes(backend));
 
   if (cliArgs.listBackends) {
-    if (supportedBackends.length === 0) {
+    if (supportedBackends.length === 0 && externalBackends.length === 0) {
       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    kimi: kimi\n    opencode: opencode\n`);
     } else {
-      process.stdout.write(`Supported backends (from config):\n`);
-      for (const [name, command] of Object.entries(allowCliList)) {
-        process.stdout.write(`  ${name}: ${command}\n`);
+      if (supportedBackends.length > 0) {
+        process.stdout.write(`Supported backends (from config):\n`);
+        for (const [name, command] of Object.entries(allowCliList)) {
+          process.stdout.write(`  ${name}: ${command}\n`);
+        }
+      }
+      if (externalBackends.length > 0) {
+        process.stdout.write(`${supportedBackends.length > 0 ? "\n" : ""}External backends (from AISDK_PROVIDER_PATH):\n`);
+        for (const name of externalBackends) {
+          process.stdout.write(`  ${name}\n`);
+        }
       }
-      process.stdout.write(`\nDefault: ${supportedBackends[0]}\n`);
+      process.stdout.write(`\nDefault: ${supportedBackends[0] || externalBackends[0]}\n`);
     }
     return;
   }
@@ -429,6 +472,7 @@ async function main() {
   if (cliArgs.resumeSessionId) {
     const bootstrap = await bootstrapResumeContextForFire({
       backend: cliArgs.backend,
+      configFile: cliArgs.configFile,
       resumeSessionId: cliArgs.resumeSessionId,
     });
     resumeContext = bootstrap.resumeContext;
@@ -436,7 +480,7 @@ async function main() {
   }
 
   const env = buildEnv();
-  const launchedByDaemon = Boolean(process.env.CONDUCTOR_CLI_COMMAND);
+  const launchedByDaemon = isLaunchedByDaemon(process.env);
   let reconnectRunner = null;
   let reconnectTaskId = null;
   let pendingRemoteStopEvent = null;
@@ -455,7 +499,13 @@ async function main() {
   fireWatchdog.start();
 
   const scheduleReconnectRecovery = ({ isReconnect }) => {
-    if (!isReconnect) {
+    if (
+      !shouldRunReconnectRecovery({
+        isReconnect,
+        fireShuttingDown,
+        runner: reconnectRunner,
+      })
+    ) {
       return;
     }
     log("Conductor connection restored");
@@ -712,7 +762,13 @@ async function main() {
                 summary: "conductor fire exited",
               };
         try {
-          await conductor.sendTaskStatus(taskContext.taskId, finalStatus);
+          const statusResult = await conductor.sendTaskStatus(taskContext.taskId, finalStatus);
+          if (statusResult?.pending && typeof conductor.flushPendingUpstreamEvents === "function") {
+            await conductor.flushPendingUpstreamEvents({
+              timeoutMs: 5_000,
+              retryIntervalMs: 250,
+            });
+          }
         } catch (error) {
           log(`Failed to report task status (${finalStatus.status}): ${error?.message || error}`);
         }
@@ -815,7 +871,7 @@ function stripConductorArgsFromArgv(argv = []) {
   return backendArgs;
 }
 
-export function parseCliArgs(argvInput = process.argv) {
+export async function parseCliArgs(argvInput = process.argv) {
   const rawArgv = Array.isArray(argvInput) ? argvInput : process.argv;
   const argv = hideBin(rawArgv);
   const separatorIndex = argv.indexOf("--");
@@ -833,8 +889,10 @@ export function parseCliArgs(argvInput = process.argv) {
   }
 
   const configFileFromArgs = extractConfigFileFromArgv(argv);
-  const allowCliList = loadAllowCliList(configFileFromArgs);
+  const allowCliList = await loadAllowCliList(configFileFromArgs);
   const supportedBackends = Object.keys(allowCliList);
+  const discoveredBackends = await listRuntimeSupportedBackends({ configFilePath: configFileFromArgs });
+  const externalBackends = discoveredBackends.filter((backend) => !RUNTIME_SUPPORTED_BACKENDS.includes(backend));
 
   const conductorArgs = yargs(conductorArgv)
     .scriptName(CLI_NAME)
@@ -886,14 +944,14 @@ export function parseCliArgs(argvInput = process.argv) {
 
   // Handle help early
   if (helpWithoutSeparator) {
-    const defaultBackend = supportedBackends[0] || "none";
+    const defaultBackend = supportedBackends[0] || externalBackends[0] || "none";
     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 (from config: ${supportedBackends.join(", ") || "none configured"}) [default: ${defaultBackend}]
-  --list-backends       List available backends from config and exit
+  -b, --backend <name>  Backend to use (from config or external providers: ${supportedBackends.join(", ") || externalBackends.join(", ") || "none configured"}) [default: ${defaultBackend}]
+  --list-backends       List available configured and external backends
   --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
@@ -937,20 +995,21 @@ Environment:
     .parse();
   
   const backend = conductorArgs.backend
-    ? normalizeRuntimeBackendName(conductorArgs.backend)
-    : supportedBackends[0];
+    ? await normalizeRuntimeBackendAlias(conductorArgs.backend, { configFilePath: configFileFromArgs })
+    : supportedBackends[0] || externalBackends[0];
   const shouldRequireBackend =
     !Boolean(conductorArgs.listBackends) &&
     !listBackendsWithoutSeparator &&
     !Boolean(conductorArgs.version) &&
     !versionWithoutSeparator;
-  if (backend && !supportedBackends.includes(backend) && shouldRequireBackend) {
+  const runtimeSupportedBackends = new Set(discoveredBackends);
+  if (backend && !runtimeSupportedBackends.has(backend) && shouldRequireBackend) {
     throw new Error(
-      `Unsupported backend "${backend}". Supported backends: ${supportedBackends.join(", ") || "none configured"}.`,
+      `Unsupported backend "${backend}". Supported backends: ${[...runtimeSupportedBackends].join(", ") || "none configured"}.`,
     );
   }
   if (!backend && shouldRequireBackend) {
-    throw new Error("No supported backends configured. Add codex, claude, kimi, or opencode to allow_cli_list.");
+    throw new Error("No supported backends configured. Add allow_cli_list entries or set AISDK_PROVIDER_PATH for external providers.");
   }
 
   const prompt = (backendArgs._ || []).map((part) => String(part)).join(" ").trim();
@@ -1225,6 +1284,7 @@ export async function resolveResumeContext(backend, sessionId, options = {}) {
 
 export async function bootstrapResumeContextForFire({
   backend,
+  configFile,
   resumeSessionId,
   env = process.env,
   resolveResumeContextFn = resolveResumeContext,
@@ -1247,10 +1307,11 @@ export async function bootstrapResumeContextForFire({
     return { resumeContext, runtimeProjectPath };
   }
 
-  resumeContext = await resolveResumeContextFn(backend, resumeSessionId);
-  logger(
-    `Validated --resume ${resumeContext.sessionId} (${resumeContext.provider}) at ${resumeContext.sessionPath}`,
-  );
+  resumeContext = await resolveResumeContextFn(backend, resumeSessionId, {
+    configFilePath: configFile,
+  });
+  const sessionLocation = resumeContext.sessionPath ? ` at ${resumeContext.sessionPath}` : "";
+  logger(`Validated --resume ${resumeContext.sessionId} (${resumeContext.provider})${sessionLocation}`);
   logger(`Resume will run backend from ${resumeContext.cwd}`);
   runtimeProjectPath = await applyWorkingDirectoryFn(resumeContext.cwd);
   logger(`Switched working directory to ${runtimeProjectPath} before Conductor connect`);
@@ -1459,10 +1520,24 @@ export class BridgeRunner {
     const fallbackSessionId = this.resumeSessionId;
     const sessionId = discoveredSessionId || fallbackSessionId;
     const sessionFilePath = sessionInfo?.sessionFilePath ? String(sessionInfo.sessionFilePath).trim() : "";
+    const sessionModel =
+      sessionInfo?.model && String(sessionInfo.model).trim()
+        ? String(sessionInfo.model).trim()
+        : this.backendSession.threadOptions?.model || this.backendName;
+    const sessionModelProvider =
+      sessionInfo?.modelProvider && String(sessionInfo.modelProvider).trim()
+        ? String(sessionInfo.modelProvider).trim()
+        : this.backendSession.threadOptions?.modelProvider || undefined;
     const hasRealSessionId = Boolean(sessionId);
+    const messageSuffix = [
+      sessionModel ? `model=${sessionModel}` : "",
+      sessionModelProvider ? `provider=${sessionModelProvider}` : "",
+    ]
+      .filter(Boolean)
+      .join(" ");
     const message = hasRealSessionId
-      ? `${this.backendName} session started: ${sessionId}`
-      : `${this.backendName} session started`;
+      ? `${this.backendName} session started: ${sessionId}${messageSuffix ? ` (${messageSuffix})` : ""}`
+      : `${this.backendName} session started${messageSuffix ? ` (${messageSuffix})` : ""}`;
     if (hasRealSessionId) {
       await this.persistTaskSessionBinding({
         sessionId,
@@ -1472,6 +1547,8 @@ export class BridgeRunner {
     try {
       await this.conductor.sendMessage(this.taskId, message, {
         backend: this.backendName,
+        model: sessionModel || undefined,
+        model_provider: sessionModelProvider || undefined,
         thread_id: hasRealSessionId ? sessionId : undefined,
         session_id: hasRealSessionId ? sessionId : undefined,
         session_file_path: sessionFilePath || undefined,
@@ -1593,6 +1670,10 @@ export class BridgeRunner {
     this.needsReconnectRecovery = true;
   }
 
+  shouldSuppressReconnectRecovery() {
+    return this.stopped || Boolean(this.remoteStopInfo);
+  }
+
   getRemoteStopSummary() {
     if (!this.remoteStopInfo) {
       return null;
@@ -1897,7 +1978,7 @@ export class BridgeRunner {
     this.copilotLog(
       `runtime replyTo=${replyTo || "latest"} state=${runtime.state || ""} phase=${runtime.phase || ""} inProgress=${Boolean(
         runtime.reply_in_progress,
-      )} status="${sanitizeForLog(runtime.status_line || "", 120)}" done="${sanitizeForLog(runtime.status_done_line || "", 120)}" preview="${sanitizeForLog(runtime.reply_preview || "", 120)}"`,
+      )} status="${sanitizeForLog(runtime.status_line || "", 120)}" done="${sanitizeForLog(runtime.status_done_line || "", 120)}" preview="${sanitizeForLog(runtime.reply_preview || "", 120)}" model="${sanitizeForLog(this.backendSession.threadOptions?.model || this.backendName, 80)}" provider="${sanitizeForLog(this.backendSession.threadOptions?.modelProvider || this.backendName, 80)}"`,
     );
 
     try {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@love-moon/conductor-cli",
-  "version": "0.2.30",
-  "gitCommitId": "e6a71ad",
+  "version": "0.2.32",
+  "gitCommitId": "c749d4b",
   "type": "module",
   "bin": {
     "conductor": "bin/conductor.js"
@@ -18,8 +18,8 @@
   },
   "dependencies": {
     "@love-moon/ai-bridge": "0.1.4",
-    "@love-moon/ai-sdk": "0.2.30",
-    "@love-moon/conductor-sdk": "0.2.30",
+    "@love-moon/ai-sdk": "0.2.32",
+    "@love-moon/conductor-sdk": "0.2.32",
     "chrome-launcher": "^1.2.1",
     "chrome-remote-interface": "^0.33.0",
     "dotenv": "^16.4.5",