@love-moon/conductor-cli 0.2.36 → 0.2.38

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/bin/conductor-fire.js

@@ -53,6 +53,14 @@ export function isLaunchedByDaemon(env = process.env) {
   );
 }
 
+export function syncPwdEnvWithProcessCwdForDaemonLaunch(env = process.env, cwdFn = process.cwd) {
+  if (!isLaunchedByDaemon(env)) {
+    return false;
+  }
+  env.PWD = cwdFn();
+  return true;
+}
+
 const ENABLE_FIRE_LOCAL_LOG = !isLaunchedByDaemon(process.env);
 
 const pkgJson = JSON.parse(fs.readFileSync(path.join(PKG_ROOT, "package.json"), "utf-8"));
@@ -570,6 +578,7 @@ export class FireWatchdog {
 }
 
 async function main() {
+  syncPwdEnvWithProcessCwdForDaemonLaunch();
   const cliArgs = await parseCliArgs();
   let runtimeProjectPath = process.cwd();
   let backendSession = null;

package/bin/conductor-update.js

@@ -6,13 +6,14 @@
 
 import { fileURLToPath } from "node:url";
 import path from "node:path";
-import { createRequire } from "node:module";
 import fs from "node:fs";
 import { spawn } from "node:child_process";
 import process from "node:process";
 import readline from "node:readline/promises";
 import {
   PACKAGE_NAME,
+  buildUpgradeCommand,
+  resolveInstallMethod,
   fetchLatestVersion,
   isNewerVersion,
   detectPackageManager,
@@ -24,11 +25,14 @@ import {
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
-const require = createRequire(import.meta.url);
 const PKG_ROOT = path.join(__dirname, "..");
 
 const pkgJson = JSON.parse(fs.readFileSync(path.join(PKG_ROOT, "package.json"), "utf-8"));
 const CURRENT_VERSION = pkgJson.version;
+const INSTALL_METHOD = resolveInstallMethod({
+  env: process.env,
+  packageRoot: PKG_ROOT,
+});
 
 // ANSI 颜色代码
 const COLORS = {
@@ -56,6 +60,13 @@ async function main() {
     process.exit(0);
   }
 
+  if (INSTALL_METHOD === "homebrew") {
+    console.log(colorize("🍺 Homebrew-managed install detected", "cyan"));
+    console.log("");
+    console.log(`   Use ${colorize(buildUpgradeCommand({ env: process.env }), "green")} to upgrade conductor.`);
+    process.exit(0);
+  }
+
   console.log(colorize(`📦 ${PACKAGE_NAME}`, "cyan"));
   console.log(`   Current version: ${CURRENT_VERSION}`);
   console.log("");

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@love-moon/conductor-cli",
-  "version": "0.2.36",
-  "gitCommitId": "54d9de4",
+  "version": "0.2.38",
+  "gitCommitId": "6bf5515",
   "type": "module",
   "bin": {
     "conductor": "bin/conductor.js"
@@ -18,9 +18,9 @@
   },
   "dependencies": {
     "@love-moon/ai-bridge": "0.1.4",
-    "@love-moon/ai-manager": "0.2.36",
-    "@love-moon/ai-sdk": "0.2.36",
-    "@love-moon/conductor-sdk": "0.2.36",
+    "@love-moon/ai-manager": "0.2.38",
+    "@love-moon/ai-sdk": "0.2.38",
+    "@love-moon/conductor-sdk": "0.2.38",
     "chrome-launcher": "^1.2.1",
     "chrome-remote-interface": "^0.33.0",
     "dotenv": "^16.4.5",

package/src/cli-update-notifier.js

@@ -2,7 +2,7 @@ import fs from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
 
-import { fetchLatestVersion, isNewerVersion } from "./version-check.js";
+import { buildUpgradeCommand, fetchLatestVersion, isNewerVersion } from "./version-check.js";
 
 export const DEFAULT_VERSION_CHECK_INTERVAL_MS = 12 * 60 * 60 * 1000;
 export const DEFAULT_VERSION_NOTIFY_INTERVAL_MS = 24 * 60 * 60 * 1000;
@@ -115,8 +115,13 @@ export function shouldSkipVersionCheck(options = {}) {
   return { skip: false, reason: null };
 }
 
-export function buildUpdateNotice({ currentVersion, latestVersion }) {
-  return `New conductor version available: ${currentVersion} -> ${latestVersion}. Run: conductor update`;
+export function buildUpdateNotice({ currentVersion, latestVersion, installMethod, env }) {
+  const noticeEnv =
+    installMethod && !env?.CONDUCTOR_INSTALL_METHOD
+      ? { ...env, CONDUCTOR_INSTALL_METHOD: installMethod }
+      : env;
+  const upgradeCommand = buildUpgradeCommand({ env: noticeEnv });
+  return `New conductor version available: ${currentVersion} -> ${latestVersion}. Run: ${upgradeCommand}`;
 }
 
 function shouldNotifyVersion({ latestVersion, currentVersion, cache, nowMs, notifyIntervalMs }) {
@@ -147,6 +152,7 @@ export async function maybeCheckForUpdates(options = {}) {
   const env = options.env || process.env;
   const currentVersion = normalizeOptionalString(options.currentVersion);
   const subcommand = normalizeOptionalString(options.subcommand);
+  const installMethod = normalizeOptionalString(env.CONDUCTOR_INSTALL_METHOD);
   const nowMs = options.nowMs ?? Date.now();
   const checkIntervalMs = options.checkIntervalMs ?? DEFAULT_VERSION_CHECK_INTERVAL_MS;
   const notifyIntervalMs = options.notifyIntervalMs ?? DEFAULT_VERSION_NOTIFY_INTERVAL_MS;
@@ -182,7 +188,12 @@ export async function maybeCheckForUpdates(options = {}) {
       nowMs,
       notifyIntervalMs,
     })) {
-      writeNotice(buildUpdateNotice({ currentVersion, latestVersion: cache.latestVersion }));
+      writeNotice(buildUpdateNotice({
+        currentVersion,
+        latestVersion: cache.latestVersion,
+        installMethod,
+        env,
+      }));
       cache = createUpdatedCache(cache, {
         lastNotifiedVersion: cache.latestVersion,
         lastNotifiedAt: new Date(nowMs).toISOString(),
@@ -223,7 +234,12 @@ export async function maybeCheckForUpdates(options = {}) {
     nowMs,
     notifyIntervalMs,
   })) {
-    writeNotice(buildUpdateNotice({ currentVersion, latestVersion: versionToNotify }));
+      writeNotice(buildUpdateNotice({
+        currentVersion,
+        latestVersion: versionToNotify,
+        installMethod,
+        env,
+      }));
     cache = createUpdatedCache(cache, {
       lastNotifiedVersion: versionToNotify,
       lastNotifiedAt: new Date(nowMs).toISOString(),

package/src/daemon.js

@@ -29,12 +29,14 @@ import {
 } from "./runtime-backends.js";
 import {
   PACKAGE_NAME,
+  buildUpgradeCommand,
   fetchLatestVersion,
   isNewerVersion,
   detectPackageManager,
   parseUpdateWindow,
   isInUpdateWindow,
   isManagedInstallPath,
+  resolveInstallMethod,
 } from "./version-check.js";
 import {
   ensurePnpmOnlyBuiltDependencies,
@@ -662,12 +664,22 @@ export function startDaemon(config = {}, deps = {}) {
   const parseUpdateWindowFn = deps.parseUpdateWindow || parseUpdateWindow;
   const isInUpdateWindowFn = deps.isInUpdateWindow || isInUpdateWindow;
   const isManagedInstallPathFn = deps.isManagedInstallPath || isManagedInstallPath;
+  const resolveInstallMethodFn = deps.resolveInstallMethod || resolveInstallMethod;
   const installedPackageRoot = deps.packageRoot || PACKAGE_ROOT;
   const cliVersion = deps.cliVersion || CLI_VERSION;
   const isBackgroundProcess = deps.isBackgroundProcess ?? !process.stdout.isTTY;
   const autoUpdateForceLocal = parseBooleanEnv(process.env.CONDUCTOR_AUTO_UPDATE_FORCE_LOCAL);
+  const installMethod = resolveInstallMethodFn({
+    env: process.env,
+    packageRoot: installedPackageRoot,
+    readFileSync: deps.readFileSync || fs.readFileSync,
+  });
   const autoUpdateSupportedInstall =
-    autoUpdateForceLocal || isManagedInstallPathFn(installedPackageRoot);
+    (installMethod !== "homebrew") &&
+    (autoUpdateForceLocal || isManagedInstallPathFn(installedPackageRoot, {
+      env: process.env,
+      readFileSync: deps.readFileSync || fs.readFileSync,
+    }));
   const skipPidLockCheck = parseBooleanEnv(process.env.CONDUCTOR_TUI_DEBUG);
   const lockHandoffToken =
     normalizeOptionalString(config.LOCK_HANDOFF_TOKEN) ||
@@ -691,6 +703,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"
   );
@@ -1450,7 +1473,7 @@ 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");
   }
@@ -1559,7 +1582,11 @@ export function startDaemon(config = {}, deps = {}) {
     });
 
     if (!AUTO_UPDATE_ENABLED && autoUpdateSupportedInstall === false) {
-      log("[auto-update] Disabled for local/dev install; set CONDUCTOR_AUTO_UPDATE_FORCE_LOCAL=true to override");
+      if (installMethod === "homebrew") {
+        log(`[auto-update] Disabled for Homebrew install; use ${buildUpgradeCommand({ env: process.env })}`);
+      } else {
+        log("[auto-update] Disabled for local/dev install; set CONDUCTOR_AUTO_UPDATE_FORCE_LOCAL=true to override");
+      }
     }
 
     watchdogTimer = setInterval(() => {
@@ -1897,7 +1924,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,
@@ -1905,7 +1932,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"],
@@ -1913,9 +1940,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(
@@ -1923,13 +1948,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) {
@@ -1941,7 +1959,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,
@@ -1953,26 +1970,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 {
@@ -1992,7 +2016,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);
@@ -2003,11 +2027,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 = () => [
@@ -3439,6 +3560,11 @@ export function startDaemon(config = {}, deps = {}) {
         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()) {
@@ -4136,6 +4262,7 @@ export function startDaemon(config = {}, deps = {}) {
 
       const env = {
         ...process.env,
+        PWD: taskDir,
         CONDUCTOR_PROJECT_ID: projectId,
         CONDUCTOR_TASK_ID: taskId,
         CONDUCTOR_LAUNCHED_BY_DAEMON: "1",

package/src/version-check.js

@@ -2,14 +2,17 @@
  * Shared version-check utilities used by both `conductor update` and the daemon auto-update flow.
  */
 
+import fs from "node:fs";
 import http from "node:http";
 import https from "node:https";
 import path from "node:path";
 import { execFileSync, execSync } from "node:child_process";
 
 export const PACKAGE_NAME = "@love-moon/conductor-cli";
+export const DEFAULT_HOMEBREW_FORMULA = "lovemoon-ai/tap/conductor";
 const DEFAULT_UPDATE_WINDOW = { startMinutes: 120, endMinutes: 240 };
 const REQUEST_TIMEOUT_MS = 10_000;
+const INSTALL_METHOD_FILENAME = ".install-method";
 
 function resolveTimeoutMs(value) {
   const parsed = Number.parseInt(String(value ?? ""), 10);
@@ -100,6 +103,50 @@ function getRegistryBaseUrl(overrideRegistryUrl) {
   return candidate;
 }
 
+function normalizeInstallMethod(value) {
+  if (typeof value !== "string") {
+    return null;
+  }
+  const normalized = value.trim().toLowerCase();
+  return normalized || null;
+}
+
+export function resolveHomebrewFormula(env = process.env) {
+  const configured = typeof env?.CONDUCTOR_HOMEBREW_FORMULA === "string"
+    ? env.CONDUCTOR_HOMEBREW_FORMULA.trim()
+    : "";
+  return configured || DEFAULT_HOMEBREW_FORMULA;
+}
+
+export function resolveInstallMethod(options = {}) {
+  const env = options.env || process.env;
+  const envMethod = normalizeInstallMethod(env?.CONDUCTOR_INSTALL_METHOD);
+  if (envMethod) {
+    return envMethod;
+  }
+
+  const packageRoot = typeof options.packageRoot === "string" ? options.packageRoot.trim() : "";
+  if (!packageRoot) {
+    return null;
+  }
+
+  const readFileSyncFn = options.readFileSync || fs.readFileSync;
+  const installMethodPath = path.join(path.resolve(packageRoot), INSTALL_METHOD_FILENAME);
+  try {
+    return normalizeInstallMethod(readFileSyncFn(installMethodPath, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+
+export function buildUpgradeCommand(options = {}) {
+  const installMethod = resolveInstallMethod(options);
+  if (installMethod === "homebrew") {
+    return `brew upgrade ${resolveHomebrewFormula(options.env || process.env)}`;
+  }
+  return "conductor update";
+}
+
 /**
  * Compare two semver-like version strings.
  * Returns `true` when `latest` is strictly newer than `current`.
@@ -217,7 +264,10 @@ export function parseUpdateWindow(str) {
  * Auto-update should only mutate managed/global installs. Local repo runs and pnpm-linked
  * worktrees are treated as development installs and are skipped by default.
  */
-export function isManagedInstallPath(packageRoot) {
+export function isManagedInstallPath(packageRoot, options = {}) {
+  if (resolveInstallMethod({ ...options, packageRoot }) === "homebrew") {
+    return false;
+  }
   if (typeof packageRoot !== "string" || !packageRoot.trim()) {
     return false;
   }