@love-moon/conductor-cli 0.2.31 → 0.2.33

package/bin/conductor-fire.js

@@ -19,7 +19,7 @@ import yargs from "yargs/yargs";
 import { hideBin } from "yargs/helpers";
 import yaml from "js-yaml";
 import { createAiSession } from "@love-moon/ai-sdk";
-import { ConductorClient, loadConfig } from "@love-moon/conductor-sdk";
+import { ConductorClient, ProjectContext, loadConfig } from "@love-moon/conductor-sdk";
 import {
   buildResumeArgsForBackend as buildCliResumeArgsForBackend,
   resolveResumeContext as resolveCliResumeContext,
@@ -28,8 +28,9 @@ import {
 } from "../src/fire/resume.js";
 import {
   filterRuntimeSupportedAllowCliList,
-  RUNTIME_SUPPORTED_BACKENDS,
-  listRuntimeSupportedBackends,
+  isBuiltInRuntimeBackend,
+  listAdvertisedBackends,
+  resolveConfiguredRuntimeBackend,
   normalizeRuntimeBackendAlias,
   normalizeRuntimeBackendName,
 } from "../src/runtime-backends.js";
@@ -66,6 +67,20 @@ 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)
 async function loadAllowCliList(configFilePath) {
   const home = os.homedir();
@@ -85,37 +100,46 @@ async function loadAllowCliList(configFilePath) {
   return {};
 }
 
-export function resolveAiSessionCommandLine(backend, allowCliList, env = process.env) {
+export function resolveAiSessionCommandLine(backend, allowCliList, env = process.env, sessionBackend = backend) {
   const normalizedBackend = normalizeRuntimeBackendName(backend);
+  const normalizedSessionBackend = normalizeRuntimeBackendName(sessionBackend);
   const envKeyByBackend = {
+    codex: "CONDUCTOR_CODEX_APP_SERVER_COMMAND",
     opencode: "CONDUCTOR_OPENCODE_COMMAND",
     kimi: "CONDUCTOR_KIMI_COMMAND",
   };
-  const envKey = envKeyByBackend[normalizedBackend];
-  if (!envKey) {
-    return "";
-  }
+  const envKey = envKeyByBackend[normalizedSessionBackend];
 
-  const preferredEnvCommand = typeof env?.[envKey] === "string" ? env[envKey].trim() : "";
+  const preferredEnvCommand = envKey && typeof env?.[envKey] === "string" ? env[envKey].trim() : "";
   if (preferredEnvCommand) {
     return preferredEnvCommand;
   }
 
   const configuredCommand =
-    allowCliList && typeof allowCliList === "object" && typeof allowCliList[normalizedBackend] === "string"
-      ? allowCliList[normalizedBackend].trim()
+    allowCliList && typeof allowCliList === "object"
+      ? typeof allowCliList[normalizedBackend] === "string"
+        ? allowCliList[normalizedBackend].trim()
+        : typeof allowCliList[normalizedSessionBackend] === "string"
+          ? allowCliList[normalizedSessionBackend].trim()
+          : ""
       : "";
-  if (configuredCommand) {
-    return configuredCommand;
-  }
 
   const daemonCommand =
     typeof env?.CONDUCTOR_CLI_COMMAND === "string" ? env.CONDUCTOR_CLI_COMMAND.trim() : "";
-  if (daemonCommand) {
-    return daemonCommand;
+
+  const resolvedCommand = configuredCommand || daemonCommand;
+  if (!resolvedCommand) {
+    return "";
   }
 
-  return "";
+  if (normalizedSessionBackend === "codex") {
+    if (/\bapp-server\b/.test(resolvedCommand)) {
+      return resolvedCommand;
+    }
+    return `${resolvedCommand} app-server --listen stdio://`;
+  }
+
+  return resolvedCommand;
 }
 
 const DEFAULT_POLL_INTERVAL_MS = parseInt(
@@ -429,12 +453,15 @@ async function main() {
   }
 
   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));
+  const { supportedBackends, externalBackends, discoveryError } = await listAdvertisedBackends(allowCliList, {
+    configFilePath: cliArgs.configFile,
+  });
 
   if (cliArgs.listBackends) {
     if (supportedBackends.length === 0 && externalBackends.length === 0) {
+      if (discoveryError) {
+        throw discoveryError;
+      }
       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 {
       if (supportedBackends.length > 0) {
@@ -457,7 +484,7 @@ async function main() {
   let resumeContext = null;
   if (cliArgs.resumeSessionId) {
     const bootstrap = await bootstrapResumeContextForFire({
-      backend: cliArgs.backend,
+      backend: cliArgs.sessionBackend || cliArgs.backend,
       configFile: cliArgs.configFile,
       resumeSessionId: cliArgs.resumeSessionId,
     });
@@ -485,7 +512,13 @@ async function main() {
   fireWatchdog.start();
 
   const scheduleReconnectRecovery = ({ isReconnect }) => {
-    if (!isReconnect) {
+    if (
+      !shouldRunReconnectRecovery({
+        isReconnect,
+        fireShuttingDown,
+        runner: reconnectRunner,
+      })
+    ) {
       return;
     }
     log("Conductor connection restored");
@@ -591,6 +624,7 @@ async function main() {
       requestedTitle: requestedTaskTitle,
       backend: cliArgs.backend,
       daemonName: configuredDaemonName,
+      projectPath: runtimeProjectPath,
     });
     injectResolvedTaskId(taskContext.taskId);
     injectResolvedTaskId(taskContext.taskId, env);
@@ -621,9 +655,14 @@ async function main() {
 
     const resolvedResumeSessionId = cliArgs.resumeSessionId;
 
-    const sessionCommandLine = resolveAiSessionCommandLine(cliArgs.backend, allowCliList, process.env);
+    const sessionCommandLine = resolveAiSessionCommandLine(
+      cliArgs.backend,
+      allowCliList,
+      process.env,
+      cliArgs.sessionBackend,
+    );
 
-    backendSession = createAiSession(cliArgs.backend, {
+    backendSession = createAiSession(cliArgs.sessionBackend || cliArgs.backend, {
       initialImages: cliArgs.initialImages,
       cwd: runtimeProjectPath,
       resumeSessionId: resolvedResumeSessionId,
@@ -708,8 +747,8 @@ async function main() {
 
     let runnerError = null;
     try {
-      if (!resolvedResumeSessionId && String(cliArgs.backend).trim().toLowerCase() === "codex") {
-        await withFreshSessionBootstrapLock(cliArgs.backend, runtimeProjectPath, async () => {
+      if (!resolvedResumeSessionId && String(cliArgs.sessionBackend || cliArgs.backend).trim().toLowerCase() === "codex") {
+        await withFreshSessionBootstrapLock(cliArgs.sessionBackend || cliArgs.backend, runtimeProjectPath, async () => {
           await runner.announceBackendSession();
         });
       }
@@ -742,7 +781,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}`);
         }
@@ -864,9 +909,9 @@ export async function parseCliArgs(argvInput = process.argv) {
 
   const configFileFromArgs = extractConfigFileFromArgv(argv);
   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 { supportedBackends, externalBackends, discoveryError } = await listAdvertisedBackends(allowCliList, {
+    configFilePath: configFileFromArgs,
+  });
 
   const conductorArgs = yargs(conductorArgv)
     .scriptName(CLI_NAME)
@@ -968,21 +1013,36 @@ Environment:
     })
     .parse();
   
-  const backend = conductorArgs.backend
-    ? await normalizeRuntimeBackendAlias(conductorArgs.backend, { configFilePath: configFileFromArgs })
+  const requestedBackend = conductorArgs.backend
+    ? normalizeRuntimeBackendName(conductorArgs.backend)
     : supportedBackends[0] || externalBackends[0];
+  const configuredBackend = await resolveConfiguredRuntimeBackend(requestedBackend, allowCliList, {
+    configFilePath: configFileFromArgs,
+  });
+  const backend = configuredBackend?.requestedBackend || requestedBackend;
+  const sessionBackend =
+    configuredBackend?.runtimeBackend ||
+    (backend ? await normalizeRuntimeBackendAlias(backend, { configFilePath: configFileFromArgs }) : "");
   const shouldRequireBackend =
     !Boolean(conductorArgs.listBackends) &&
     !listBackendsWithoutSeparator &&
     !Boolean(conductorArgs.version) &&
     !versionWithoutSeparator;
-  const runtimeSupportedBackends = new Set(discoveredBackends);
-  if (backend && !runtimeSupportedBackends.has(backend) && shouldRequireBackend) {
+  const runtimeSupportedBackends = new Set(supportedBackends);
+  const advertisedExternalBackends = new Set(externalBackends);
+  const hasConfiguredEntry = Boolean(configuredBackend?.commandLine);
+  const isAllowedExternalBackend =
+    !isBuiltInRuntimeBackend(sessionBackend) &&
+    advertisedExternalBackends.has(sessionBackend);
+  if (backend && shouldRequireBackend && !hasConfiguredEntry && !isAllowedExternalBackend) {
     throw new Error(
       `Unsupported backend "${backend}". Supported backends: ${[...runtimeSupportedBackends].join(", ") || "none configured"}.`,
     );
   }
   if (!backend && shouldRequireBackend) {
+    if (discoveryError) {
+      throw discoveryError;
+    }
     throw new Error("No supported backends configured. Add allow_cli_list entries or set AISDK_PROVIDER_PATH for external providers.");
   }
 
@@ -1010,6 +1070,7 @@ Environment:
     taskTitle: typeof conductorArgs.title === "string" ? conductorArgs.title.trim() : "",
     hasExplicitTaskTitle: typeof conductorArgs.title === "string" && Boolean(conductorArgs.title.trim()),
     configFile: conductorArgs.configFile,
+    sessionBackend,
     resumeSessionId,
     showVersion: Boolean(conductorArgs.version) || versionWithoutSeparator,
     listBackends: Boolean(conductorArgs.listBackends) || listBackendsWithoutSeparator,
@@ -1126,7 +1187,10 @@ async function ensureTaskContext(conductor, opts) {
     };
   }
 
-  const projectId = await resolveProjectId(conductor, opts.requestedProjectId);
+  const projectId = await resolveProjectId(conductor, opts.requestedProjectId, {
+    daemonName: opts.daemonName,
+    projectPath: opts.projectPath,
+  });
   const payload = {
     project_id: projectId,
     task_title: deriveTaskTitle(opts.initialPrompt, opts.requestedTitle, opts.backend),
@@ -1141,15 +1205,6 @@ async function ensureTaskContext(conductor, opts) {
 
   const session = await conductor.createTaskSession(payload);
 
-  // Auto-bind current path to project if not already bound
-  try {
-    await conductor.bindProjectPath(projectId);
-    log(`Bound current path to project ${projectId}`);
-  } catch (error) {
-    // Ignore binding errors - it's not critical
-    log(`Note: Could not bind path to project: ${error.message}`);
-  }
-
   return {
     taskId: session.task_id,
     appUrl: session.app_url || null,
@@ -1158,51 +1213,155 @@ async function ensureTaskContext(conductor, opts) {
   };
 }
 
-async function resolveProjectId(conductor, explicit) {
+export async function resolveProjectId(conductor, explicit, opts = {}) {
   if (explicit) {
     return explicit;
   }
 
-  // First, try to match project by current path
+  const daemonHost = resolveDaemonHost(opts.daemonName);
+  const projectPath = typeof opts.projectPath === "string" && opts.projectPath.trim() ? opts.projectPath.trim() : process.cwd();
+
+  if (!daemonHost) {
+    return resolveDefaultProjectId(conductor);
+  }
+
+  const exists = await isExistingDirectory(projectPath);
+  if (!exists) {
+    throw new Error(`Workspace path does not exist: ${projectPath}`);
+  }
+
+  const snapshot = resolveWorkspaceSnapshot(projectPath);
+  const projectName = deriveProjectName(snapshot);
+
   try {
-    const matchResult = await conductor.matchProjectByPath();
+    const matchResult = await conductor.matchProjectByPath({
+      daemon_host: daemonHost,
+      project_path: snapshot.projectRoot,
+    });
     if (matchResult?.project_id) {
       log(`Matched project ${matchResult.project_name || matchResult.project_id} by path ${matchResult.matched_path}`);
-      return matchResult.project_id;
+      let resolvedProjectId = matchResult.project_id;
+      try {
+        const bindResult = await conductor.bindProjectPath(matchResult.project_id, {
+          daemon_host: daemonHost,
+          project_path: snapshot.projectRoot,
+        });
+        if (typeof bindResult?.project_id === "string" && bindResult.project_id.trim()) {
+          resolvedProjectId = bindResult.project_id.trim();
+        }
+      } catch (error) {
+        log(`Unable to backfill bound workspace path: ${error.message}`);
+        try {
+          const rebound = await conductor.matchProjectByPath({
+            daemon_host: daemonHost,
+            project_path: snapshot.projectRoot,
+          });
+          if (rebound?.project_id) {
+            resolvedProjectId = rebound.project_id;
+          }
+        } catch {
+          // ignore retry match failures
+        }
+      }
+      return resolvedProjectId;
     }
   } catch (error) {
     log(`Unable to match project by path: ${error.message}`);
   }
 
   try {
-    const record = await conductor.getLocalProjectRecord();
-    if (record?.project_id) {
-      try {
-        const listing = await conductor.listProjects();
-        const exists = Array.isArray(listing?.projects)
-          ? listing.projects.some((project) => String(project?.id || "") === String(record.project_id))
-          : false;
-        if (exists) {
-          return record.project_id;
-        }
-        log(`Local session project ${record.project_id} no longer exists; falling back to server project list`);
-      } catch (verifyError) {
-        log(`Unable to verify local project record; using cached project id: ${verifyError.message}`);
-        return record.project_id;
-      }
+    const created = await conductor.createProject({
+      name: projectName,
+      bindingConfirmed: true,
+      daemonHost,
+      workspacePath: snapshot.projectRoot,
+      repoRoot: snapshot.repoRoot,
+      worktreeBranch: snapshot.worktreeBranch,
+      lastCommit: snapshot.lastCommit,
+      fileCount: snapshot.fileCount,
+    });
+    if (created?.id) {
+      log(`Created bound project ${created.name || created.id} for ${daemonHost}:${snapshot.projectRoot}`);
+      return created.id;
     }
+    throw new Error("create_project returned no id");
   } catch (error) {
-    log(`Unable to resolve project via local session: ${error.message}`);
+    log(`Unable to create bound project: ${error.message}`);
+  }
+
+  try {
+    const retryMatch = await conductor.matchProjectByPath({
+      daemon_host: daemonHost,
+      project_path: snapshot.projectRoot,
+    });
+    if (retryMatch?.project_id) {
+      return retryMatch.project_id;
+    }
+  } catch {
+    // ignore retry match failures
+  }
+
+  log(`Unable to resolve bound project for ${daemonHost}:${snapshot.projectRoot}, falling back to default`);
+  return resolveDefaultProjectId(conductor);
+}
+
+function resolveDaemonHost(daemonName) {
+  if (typeof daemonName === "string" && daemonName.trim()) {
+    return daemonName.trim();
+  }
+  const fromEnv = typeof process.env.CONDUCTOR_DAEMON_NAME === "string" ? process.env.CONDUCTOR_DAEMON_NAME.trim() : "";
+  if (fromEnv) {
+    return fromEnv;
   }
+  const fromAgent = typeof process.env.CONDUCTOR_AGENT_NAME === "string" ? process.env.CONDUCTOR_AGENT_NAME.trim() : "";
+  if (fromAgent) {
+    return fromAgent;
+  }
+  try {
+    return os.hostname();
+  } catch {
+    return "";
+  }
+}
+
+function resolveWorkspaceSnapshot(projectPath) {
+  try {
+    const context = new ProjectContext(projectPath);
+    return context.snapshot();
+  } catch {
+    return {
+      projectRoot: path.resolve(projectPath),
+    };
+  }
+}
+
+function deriveProjectName(snapshot) {
+  const basePath = snapshot.repoRoot || snapshot.projectRoot;
+  const name = basePath ? path.basename(basePath) : "";
+  const baseName = name || "New Project";
+  const digest = createHash("sha1").update(basePath || baseName).digest("hex").slice(0, 8);
+  return `${baseName}-${digest}`;
+}
 
-  const listing = await conductor.listProjects();
-  const first = listing?.projects?.[0];
-  if (first?.id) {
-    return first.id;
+async function resolveDefaultProjectId(conductor) {
+  try {
+    const listing = await conductor.listProjects();
+    const defaultProject = Array.isArray(listing?.projects)
+      ? listing.projects.find((project) => Boolean(project?.isDefault))
+      : null;
+    if (defaultProject?.id) {
+      return defaultProject.id;
+    }
+  } catch {
+    // ignore list failures
   }
-  log("No projects available; creating default project...");
+
+  log("No bound daemon available; creating default project...");
   try {
-    const created = await conductor.createProject("default", "Auto-created by conductor-fire");
+    const created = await conductor.createProject({
+      name: "Default Project",
+      isDefault: true,
+    });
     if (created?.id) {
       log(`Created default project ${created.id}`);
       return created.id;
@@ -1644,6 +1803,10 @@ export class BridgeRunner {
     this.needsReconnectRecovery = true;
   }
 
+  shouldSuppressReconnectRecovery() {
+    return this.stopped || Boolean(this.remoteStopInfo);
+  }
+
   getRemoteStopSummary() {
     if (!this.remoteStopInfo) {
       return null;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@love-moon/conductor-cli",
-  "version": "0.2.31",
-  "gitCommitId": "7e0bd83",
+  "version": "0.2.33",
+  "gitCommitId": "db7f9bf",
   "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.31",
-    "@love-moon/conductor-sdk": "0.2.31",
+    "@love-moon/ai-sdk": "0.2.33",
+    "@love-moon/conductor-sdk": "0.2.33",
     "chrome-launcher": "^1.2.1",
     "chrome-remote-interface": "^0.33.0",
     "dotenv": "^16.4.5",