@love-moon/conductor-cli 0.2.35 → 0.2.37

package/bin/conductor-daemon.js

@@ -48,19 +48,19 @@ function resolveLauncherConfig() {
 
   if (inheritedLauncherScript && inheritedSubcommand === "daemon" && inheritedSubcommandArgs) {
     return {
-      restartLauncherScript: inheritedLauncherScript,
-      restartLauncherArgs: ["daemon", ...stripNohupArgs(inheritedSubcommandArgs)],
-      versionCheckScript: inheritedLauncherScript,
-      versionCheckArgs: ["--version"],
+      RESTART_LAUNCHER_SCRIPT: inheritedLauncherScript,
+      RESTART_LAUNCHER_ARGS: ["daemon", ...stripNohupArgs(inheritedSubcommandArgs)],
+      VERSION_CHECK_SCRIPT: inheritedLauncherScript,
+      VERSION_CHECK_ARGS: ["--version"],
     };
   }
 
   const daemonScript = path.resolve(process.argv[1]);
   return {
-    restartLauncherScript: daemonScript,
-    restartLauncherArgs: argv,
-    versionCheckScript: inheritedLauncherScript,
-    versionCheckArgs: ["--version"],
+    RESTART_LAUNCHER_SCRIPT: daemonScript,
+    RESTART_LAUNCHER_ARGS: argv,
+    VERSION_CHECK_SCRIPT: inheritedLauncherScript,
+    VERSION_CHECK_ARGS: ["--version"],
   };
 }
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@love-moon/conductor-cli",
-  "version": "0.2.35",
-  "gitCommitId": "686ee4d",
+  "version": "0.2.37",
+  "gitCommitId": "c656a7d",
   "type": "module",
   "bin": {
     "conductor": "bin/conductor.js"
@@ -18,8 +18,9 @@
   },
   "dependencies": {
     "@love-moon/ai-bridge": "0.1.4",
-    "@love-moon/ai-sdk": "0.2.35",
-    "@love-moon/conductor-sdk": "0.2.35",
+    "@love-moon/ai-manager": "0.2.37",
+    "@love-moon/ai-sdk": "0.2.37",
+    "@love-moon/conductor-sdk": "0.2.37",
     "chrome-launcher": "^1.2.1",
     "chrome-remote-interface": "^0.33.0",
     "dotenv": "^16.4.5",
@@ -39,6 +40,7 @@
     ],
     "overrides": {
       "@love-moon/ai-sdk": "file:../modules/ai-sdk",
+      "@love-moon/ai-manager": "file:../modules/ai-manager",
       "@love-moon/conductor-sdk": "file:../modules/conductor-sdk"
     }
   }

package/src/ai-manager-handlers.js

@@ -0,0 +1,158 @@
+// Daemon-side glue between the realtime WebSocket and the @love-moon/ai-manager module.
+// The web backend sends `ai_manager_request`; we dispatch by `action`, run it, and
+// reply with `ai_manager_response` carrying the same `request_id`.
+
+import { AiManager } from "@love-moon/ai-manager";
+
+const VALID_ACTIONS = new Set(["status", "quota", "list_accounts", "switch_account"]);
+
+/**
+ * @param {object} opts
+ * @param {string} [opts.configPath] Path to ~/.conductor/config.yaml. Defaults to ai-manager's default.
+ */
+export function createAiManagerHandlers(opts = {}) {
+  const manager = new AiManager(opts.configPath ? { configPath: opts.configPath } : undefined);
+
+  async function status() {
+    // Probe install first; only check network for tools that are actually
+    // present so we don't pay an outbound HTTP timeout for a CLI the user
+    // never installed.
+    const [install, current] = await Promise.all([
+      manager.checkInstallAll(),
+      manager.getCurrentCodexAccount().catch(() => null),
+    ]);
+    const network = {};
+    const tools = ["codex", "claude", "kimi"];
+    await Promise.all(
+      tools.map(async (tool) => {
+        if (install[tool]?.installed) {
+          network[tool] = await manager.checkNetwork(tool);
+        } else {
+          network[tool] = {
+            reachable: false,
+            endpoint: "",
+            error: "not installed",
+          };
+        }
+      }),
+    );
+    return { install, network, currentCodexAccount: current };
+  }
+
+  async function quota(args = {}) {
+    const tools = pickToolFilter(args);
+    const out = {};
+    if (tools.has("codex")) {
+      try {
+        out.codex = await manager.getCodexQuota({
+          forceRefresh: Boolean(args.forceRefresh),
+        });
+      } catch (err) {
+        out.codex = { tool: "codex", error: errMsg(err), source: "unknown" };
+      }
+    }
+    if (tools.has("claude")) {
+      try {
+        out.claude = await manager.getClaudeQuota({
+          forceRefresh: Boolean(args.forceRefresh),
+        });
+      } catch (err) {
+        out.claude = { tool: "claude", error: errMsg(err), source: "unknown" };
+      }
+    }
+    if (tools.has("kimi")) {
+      try {
+        out.kimi = await manager.getKimiQuota({
+          forceRefresh: Boolean(args.forceRefresh),
+        });
+      } catch (err) {
+        out.kimi = { tool: "kimi", error: errMsg(err), source: "unknown" };
+      }
+    }
+    return out;
+  }
+
+  async function listAccounts() {
+    return { accounts: await manager.listCodexAccounts() };
+  }
+
+  async function switchAccount(args = {}) {
+    if (!args.name || typeof args.name !== "string") {
+      throw new Error("switch_account requires a `name` string");
+    }
+    return await manager.switchCodexAccount(args.name);
+  }
+
+  /**
+   * Run a single action and return a `result` object, never throwing.
+   * @param {{action:string,args?:object}} payload
+   */
+  async function dispatch(payload) {
+    const action = payload?.action;
+    if (!VALID_ACTIONS.has(action)) {
+      return { error: `unknown action: ${action}` };
+    }
+    try {
+      switch (action) {
+        case "status":
+          return { result: await status() };
+        case "quota":
+          return { result: await quota(payload?.args ?? {}) };
+        case "list_accounts":
+          return { result: await listAccounts() };
+        case "switch_account":
+          return { result: await switchAccount(payload?.args ?? {}) };
+        default:
+          return { error: `unhandled action: ${action}` };
+      }
+    } catch (err) {
+      return { error: errMsg(err) };
+    }
+  }
+
+  return { dispatch, manager };
+}
+
+/**
+ * Wire a handler against an event payload from the web backend, sending the
+ * response back through `client.sendJson` once the action completes.
+ *
+ * @param {object} client - conductor websocket client (must have sendJson)
+ * @param {ReturnType<typeof createAiManagerHandlers>} handlers
+ * @param {object} payload - event.payload with shape { request_id, action, args }
+ */
+export async function handleAiManagerRequest(client, handlers, payload) {
+  const requestId = payload?.request_id ? String(payload.request_id) : "";
+  const action = payload?.action ? String(payload.action) : "";
+  if (!requestId) {
+    // Without a request_id we cannot route the response anywhere; drop and log upstream.
+    return { error: "missing request_id" };
+  }
+
+  const out = await handlers.dispatch({ action, args: payload?.args });
+  await client
+    .sendJson({
+      type: "ai_manager_response",
+      payload: {
+        request_id: requestId,
+        action,
+        result: out.result,
+        error: out.error,
+      },
+    })
+    .catch(() => {});
+  return out;
+}
+
+function pickToolFilter(args) {
+  const t = args?.tool;
+  if (t === "codex") return new Set(["codex"]);
+  if (t === "claude") return new Set(["claude"]);
+  if (t === "kimi") return new Set(["kimi"]);
+  return new Set(["codex", "claude", "kimi"]);
+}
+
+function errMsg(err) {
+  if (err instanceof Error) return err.message;
+  return String(err);
+}

package/src/daemon.js

@@ -16,6 +16,7 @@ import {
   ProjectContext,
 } from "@love-moon/conductor-sdk";
 import { DaemonLogCollector } from "./log-collector.js";
+import { createAiManagerHandlers, handleAiManagerRequest } from "./ai-manager-handlers.js";
 import { resolveResumeContext } from "./fire/resume.js";
 import {
   filterRuntimeSupportedAllowCliList,
@@ -690,6 +691,17 @@ export function startDaemon(config = {}, deps = {}) {
     autoUpdateSupportedInstall &&
     (process.env.CONDUCTOR_AUTO_UPDATE !== "false") &&
     (userConfig.auto_update !== false);
+  // Auto-update respawn was historically broken in prod (camelCase/UPPER_SNAKE
+  // config-key mismatch between conductor-daemon.js and daemon.js), so no fleet
+  // has actually restarted itself via this path. The key mismatch is now fixed,
+  // which means auto-update would start respawning daemons globally. To avoid a
+  // silent activation, keep respawn gated behind an explicit opt-in until it
+  // has been validated on a canary.
+  const AUTO_UPDATE_RESPAWN_ENABLED =
+    config.AUTO_UPDATE_RESPAWN === true ||
+    config.AUTO_UPDATE_RESPAWN === "true" ||
+    process.env.CONDUCTOR_AUTO_UPDATE_RESPAWN === "true" ||
+    userConfig.auto_update_respawn === true;
   const UPDATE_WINDOW = parseUpdateWindowFn(
     process.env.CONDUCTOR_UPDATE_WINDOW || userConfig.update_window || "02:00-04:00"
   );
@@ -1449,13 +1461,15 @@ export function startDaemon(config = {}, deps = {}) {
     "x-conductor-backends": SUPPORTED_BACKENDS.join(","),
     "x-conductor-version": cliVersion,
   };
-  const advertisedCapabilities = ["project_path_validation"];
+  const advertisedCapabilities = ["project_path_validation", "restart_daemon"];
   if (ptyTaskCapabilityEnabled) {
     advertisedCapabilities.push("pty_task", "terminal_snapshot");
   }
   if (advertisedCapabilities.length > 0) {
     extraHeaders["x-conductor-capabilities"] = advertisedCapabilities.join(",");
   }
+  const aiManagerHandlers = createAiManagerHandlers({ configPath: config.CONFIG_FILE });
+
   const client = createWebSocketClient(sdkConfig, {
     extraHeaders,
     onConnected: ({ isReconnect, connectedAt } = { isReconnect: false, connectedAt: Date.now() }) => {
@@ -1894,7 +1908,7 @@ export function startDaemon(config = {}, deps = {}) {
     return newPkg.version || null;
   }
 
-  async function performAutoUpdate(targetVersion) {
+  async function installCliVersion(targetVersion, tag) {
     const pm = detectPackageManagerFn({
       launcherPath: restartLauncherScript || versionCheckScript,
       packageRoot: installedPackageRoot,
@@ -1902,7 +1916,7 @@ export function startDaemon(config = {}, deps = {}) {
     const pkgSpec = `${PACKAGE_NAME}@${targetVersion}`;
 
     if (pm === "pnpm") {
-      log("[auto-update] Preparing pnpm native dependency allowlist for node-pty");
+      log(`[${tag}] Preparing pnpm native dependency allowlist for node-pty`);
       await ensurePnpmOnlyBuiltDependencies({
         runCommand: runBufferedCommand,
         dependencies: ["node-pty"],
@@ -1910,9 +1924,7 @@ export function startDaemon(config = {}, deps = {}) {
       });
     }
 
-    log(`[auto-update] Installing ${pkgSpec} via ${pm}...`);
-
-    // Step 1: install
+    log(`[${tag}] Installing ${pkgSpec} via ${pm}...`);
     const result = await runInstallCommand(pm, pkgSpec);
     if (!result.success) {
       throw new Error(
@@ -1920,13 +1932,6 @@ export function startDaemon(config = {}, deps = {}) {
       );
     }
 
-    // Step 2: re-check active tasks — a task may have arrived during the install
-    if (hasActiveTasks()) {
-      log("[auto-update] Active tasks appeared during install; aborting restart (will retry later)");
-      return;
-    }
-
-    // Step 3: verify installed version using the globally resolved CLI entry point.
     try {
       const installedVersion = await readInstalledCliVersion();
       if (installedVersion !== targetVersion) {
@@ -1938,7 +1943,6 @@ export function startDaemon(config = {}, deps = {}) {
       throw new Error(`Version verification failed: ${verifyErr?.message || verifyErr}`);
     }
 
-    // Step 4: repair and verify native dependencies before shutting down the healthy daemon.
     try {
       await repairAndVerifyGlobalNodePty({
         packageManager: pm,
@@ -1950,26 +1954,33 @@ export function startDaemon(config = {}, deps = {}) {
       throw new Error(`Native dependency verification failed: ${verifyErr?.message || verifyErr}`);
     }
 
-    log(`[auto-update] Verified ${targetVersion} and node-pty. Restarting daemon...`);
+    log(`[${tag}] Installed and verified ${targetVersion} (node-pty OK)`);
+  }
+
+  async function restartDaemonProcess(reason, { allowForegroundRespawn = false } = {}) {
+    const shouldRespawn = isBackgroundProcess || allowForegroundRespawn;
+    if (shouldRespawn && !restartLauncherScript) {
+      throw new Error("Missing daemon restart launcher script");
+    }
 
     let logFd = null;
-    if (isBackgroundProcess) {
-      if (!restartLauncherScript) {
-        throw new Error("Missing daemon restart launcher script");
-      }
+    if (shouldRespawn) {
       try {
         mkdirSyncFn(DAEMON_LOG_DIR, { recursive: true });
       } catch {
         /* ignore */
       }
       logFd = fs.openSync(DAEMON_LOG_PATH, "a");
+      if (!isBackgroundProcess) {
+        log(
+          `[${reason}] Foreground daemon will be respawned in background. Logs: ${DAEMON_LOG_PATH}`
+        );
+      }
     }
 
-    // Step 5: graceful shutdown
-    await shutdownDaemon("auto-update");
+    await shutdownDaemon(reason);
 
-    // Step 6: re-spawn (only in background/nohup mode)
-    if (isBackgroundProcess) {
+    if (shouldRespawn) {
       const handoffToken = `${Date.now()}-${Math.random().toString(36).slice(2, 10)}`;
       const handoffExpiresAt = Date.now() + 15_000;
       try {
@@ -1989,7 +2000,7 @@ export function startDaemon(config = {}, deps = {}) {
           },
         });
         child.unref();
-        log(`[auto-update] New daemon spawned (PID ${child.pid})`);
+        log(`[${reason}] New daemon spawned (PID ${child.pid})`);
       } catch (error) {
         cleanupLock();
         exitFn(1);
@@ -2000,11 +2011,108 @@ export function startDaemon(config = {}, deps = {}) {
         }
       }
     } else {
+      log(`[${reason}] Foreground mode — please restart the daemon manually.`);
+    }
+    exitFn(0);
+  }
+
+  async function performAutoUpdate(targetVersion) {
+    await installCliVersion(targetVersion, "auto-update");
+
+    if (!AUTO_UPDATE_RESPAWN_ENABLED) {
       log(
-        `[auto-update] Updated to ${targetVersion}. Foreground mode — please restart the daemon.`
+        `[auto-update] Installed ${targetVersion}. Respawn is gated off (set CONDUCTOR_AUTO_UPDATE_RESPAWN=true to enable); new version will take effect on next manual restart.`
       );
+      return;
+    }
+
+    // Re-check active tasks — a task may have arrived during the install
+    if (hasActiveTasks()) {
+      log("[auto-update] Active tasks appeared during install; aborting restart (will retry later)");
+      return;
+    }
+
+    log(`[auto-update] Restarting daemon after upgrade to ${targetVersion}...`);
+    await restartDaemonProcess("auto-update");
+  }
+
+  async function handleRestartDaemon(payload) {
+    const requestId = payload?.request_id ? String(payload.request_id) : "";
+    const targetVersionRaw = payload?.target_version
+      ? String(payload.target_version).trim()
+      : "latest";
+
+    if (daemonShuttingDown) {
+      log(`[restart_daemon] Ignored (${requestId}): daemon already shutting down`);
+      sendAgentCommandAck({
+        requestId,
+        eventType: "restart_daemon",
+        accepted: false,
+      }).catch(() => {});
+      return;
+    }
+    if (autoUpdateInProgress) {
+      log(`[restart_daemon] Ignored (${requestId}): restart already in progress`);
+      sendAgentCommandAck({
+        requestId,
+        eventType: "restart_daemon",
+        accepted: false,
+      }).catch(() => {});
+      return;
+    }
+
+    autoUpdateInProgress = true;
+    try {
+      log(
+        `[restart_daemon] Received (request_id=${requestId}, target=${targetVersionRaw}, current=${cliVersion})`
+      );
+      // Ack receipt before blocking work so the server learns this daemon
+      // accepted the command even if install/shutdown takes several seconds.
+      await sendAgentCommandAck({
+        requestId,
+        eventType: "restart_daemon",
+        accepted: true,
+      }).catch(() => {});
+
+      let resolvedTarget = null;
+      if (targetVersionRaw === "latest") {
+        try {
+          const latest = await fetchLatestVersionFn();
+          if (latest && SEMVER_RE.test(latest) && isNewerVersionFn(latest, cliVersion)) {
+            resolvedTarget = latest;
+          } else if (latest) {
+            log(`[restart_daemon] Already on latest (${cliVersion}); plain restart`);
+          }
+        } catch (err) {
+          logError(`[restart_daemon] Failed to fetch latest version: ${err?.message || err}`);
+        }
+      } else if (SEMVER_RE.test(targetVersionRaw) && targetVersionRaw !== cliVersion) {
+        resolvedTarget = targetVersionRaw;
+      }
+
+      if (resolvedTarget) {
+        try {
+          await installCliVersion(resolvedTarget, "restart_daemon");
+        } catch (err) {
+          logError(
+            `[restart_daemon] Install failed, falling back to plain restart: ${err?.message || err}`
+          );
+        }
+      }
+
+      try {
+        await restartDaemonProcess("restart_daemon", { allowForegroundRespawn: true });
+      } catch (err) {
+        logError(`[restart_daemon] Restart failed after shutdown; exiting: ${err?.message || err}`);
+        cleanupLock();
+        exitFn(1);
+      }
+    } finally {
+      // Clear in case restartDaemonProcess never actually exited (e.g. in tests
+      // where exitFn is mocked). In real runtime exitFn is process.exit, so
+      // this line is unreachable on both success and failure paths.
+      autoUpdateInProgress = false;
     }
-    exitFn(0);
   }
 
   const getActiveTaskIds = () => [
@@ -3431,6 +3539,16 @@ export function startDaemon(config = {}, deps = {}) {
     if (event.type === "validate_project_path") {
       void handleValidateProjectPath(event.payload);
     }
+    if (event.type === "ai_manager_request") {
+      handleAiManagerRequest(client, aiManagerHandlers, event.payload).catch((error) => {
+        logError(`Unhandled ai_manager_request failure: ${error?.message || error}`);
+      });
+    }
+    if (event.type === "restart_daemon") {
+      void handleRestartDaemon(event.payload).catch((error) => {
+        logError(`Unhandled restart_daemon failure: ${error?.message || error}`);
+      });
+    }
   }
 
   function markWatchdogHealthy(signal, at = Date.now()) {