@love-moon/conductor-cli 0.2.31 → 0.2.32

package/bin/conductor-fire.js

@@ -66,6 +66,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();
@@ -485,7 +499,13 @@ async function main() {
   fireWatchdog.start();
 
   const scheduleReconnectRecovery = ({ isReconnect }) => {
-    if (!isReconnect) {
+    if (
+      !shouldRunReconnectRecovery({
+        isReconnect,
+        fireShuttingDown,
+        runner: reconnectRunner,
+      })
+    ) {
       return;
     }
     log("Conductor connection restored");
@@ -742,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}`);
         }
@@ -1644,6 +1670,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.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.31",
-    "@love-moon/conductor-sdk": "0.2.31",
+    "@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",

package/src/daemon.js

@@ -59,6 +59,7 @@ const DEFAULT_TERMINAL_ROWS = 40;
 const DEFAULT_TERMINAL_RING_BUFFER_MAX_BYTES = 2 * 1024 * 1024;
 const DEFAULT_TERMINAL_RESUME_SNAPSHOT_MAX_BYTES = 128 * 1024;
 const DEFAULT_RTC_MODULE_CANDIDATES = ["@roamhq/wrtc", "wrtc"];
+const BLOCKING_SLEEP_BUFFER = new Int32Array(new SharedArrayBuffer(4));
 let nodePtySpawnPromise = null;
 
 function resolveNodePtySpawnExport(mod) {
@@ -117,6 +118,20 @@ function logError(message) {
   appendDaemonLog(line);
 }
 
+function sleepSync(ms) {
+  if (!Number.isFinite(ms) || ms <= 0) {
+    return;
+  }
+  try {
+    Atomics.wait(BLOCKING_SLEEP_BUFFER, 0, 0, ms);
+  } catch {
+    const deadline = Date.now() + ms;
+    while (Date.now() < deadline) {
+      // best-effort fallback for runtimes that disallow Atomics.wait
+    }
+  }
+}
+
 function getUserConfig(configFilePath) {
   try {
     const home = os.homedir();
@@ -560,6 +575,18 @@ export function startDaemon(config = {}, deps = {}) {
     process.env.CONDUCTOR_STOP_FORCE_KILL_TIMEOUT_MS,
     5000,
   );
+  const DAEMON_FORCE_STOP_GRACE_MS = parsePositiveInt(
+    process.env.CONDUCTOR_DAEMON_FORCE_STOP_GRACE_MS,
+    15_000,
+  );
+  const DAEMON_FORCE_STOP_POLL_INTERVAL_MS = parsePositiveInt(
+    process.env.CONDUCTOR_DAEMON_FORCE_STOP_POLL_INTERVAL_MS,
+    100,
+  );
+  const DAEMON_FORCE_KILL_WAIT_MS = parsePositiveInt(
+    process.env.CONDUCTOR_DAEMON_FORCE_KILL_WAIT_MS,
+    2_000,
+  );
   const SHUTDOWN_STATUS_REPORT_TIMEOUT_MS = parsePositiveInt(
     process.env.CONDUCTOR_SHUTDOWN_STATUS_REPORT_TIMEOUT_MS,
     1000,
@@ -648,6 +675,20 @@ export function startDaemon(config = {}, deps = {}) {
     return true;
   };
 
+  const waitForProcessExitSync = (pid, timeoutMs) => {
+    const deadline = Date.now() + timeoutMs;
+    while (true) {
+      if (!isProcessAlive(pid)) {
+        return true;
+      }
+      const remainingMs = deadline - Date.now();
+      if (remainingMs <= 0) {
+        return false;
+      }
+      sleepSync(Math.min(DAEMON_FORCE_STOP_POLL_INTERVAL_MS, remainingMs));
+    }
+  };
+
   try {
     mkdirSyncFn(WORKSPACE_ROOT, { recursive: true });
   } catch (err) {
@@ -670,17 +711,35 @@ export function startDaemon(config = {}, deps = {}) {
             if (alive) {
               if (config.FORCE) {
                 log(`Force enabled: stopping existing daemon PID ${pid}`);
+                let alreadyExited = false;
                 try {
                   killFn(pid, "SIGTERM");
                 } catch (killErr) {
-                  if (!killErr || killErr.code !== "ESRCH") {
+                  if (killErr?.code === "ESRCH") {
+                    alreadyExited = true;
+                  } else {
                     logError(`Failed to stop existing daemon PID ${pid}: ${killErr.message}`);
                     return exitAndReturn(1);
                   }
                 }
                 try {
-                  if (isProcessAlive(pid)) {
-                    logError(`Existing daemon PID ${pid} is still running; please stop it manually.`);
+                  let exited = alreadyExited || waitForProcessExitSync(pid, DAEMON_FORCE_STOP_GRACE_MS);
+                  if (!exited) {
+                    log(
+                      `Existing daemon PID ${pid} did not exit within ${DAEMON_FORCE_STOP_GRACE_MS}ms; sending SIGKILL`,
+                    );
+                    try {
+                      killFn(pid, "SIGKILL");
+                    } catch (killErr) {
+                      if (killErr?.code !== "ESRCH") {
+                        logError(`Failed to force kill existing daemon PID ${pid}: ${killErr.message}`);
+                        return exitAndReturn(1);
+                      }
+                    }
+                    exited = waitForProcessExitSync(pid, DAEMON_FORCE_KILL_WAIT_MS);
+                  }
+                  if (!exited) {
+                    logError(`Existing daemon PID ${pid} is still running after force restart; please stop it manually.`);
                     return exitAndReturn(1);
                   }
                 } catch (checkErr) {
@@ -688,7 +747,9 @@ export function startDaemon(config = {}, deps = {}) {
                   return exitAndReturn(1);
                 }
                 log("Removing lock file after force stop");
-                unlinkSyncFn(LOCK_FILE);
+                if (existsSyncFn(LOCK_FILE)) {
+                  unlinkSyncFn(LOCK_FILE);
+                }
               } else {
                 logError(`Daemon already running with PID ${pid}`);
                 return exitAndReturn(1);

package/src/runtime-backends.js

@@ -126,6 +126,14 @@ function registerExternalAlias(catalog, alias, backend, sourcePath) {
   catalog.aliasToBackend.set(alias, backend);
 }
 
+function formatExternalProviderLoadError(modulePath, error) {
+  const message = error?.message || String(error);
+  return [
+    `Failed to load external AI SDK provider module ${modulePath}: ${message}`,
+    "Help: if this provider comes from a local repo or workspace, did you forget to run pnpm install?",
+  ].join(" ");
+}
+
 async function loadExternalRuntimeCatalog(providerPathEnv) {
   const catalog = createEmptyExternalCatalog();
   for (const modulePath of listProviderModulePaths(providerPathEnv)) {
@@ -133,7 +141,7 @@ async function loadExternalRuntimeCatalog(providerPathEnv) {
     try {
       importedModule = await importExternalProviderModule(modulePath);
     } catch (error) {
-      throw new Error(`Failed to load external AI SDK provider module ${modulePath}: ${error?.message || error}`);
+      throw new Error(formatExternalProviderLoadError(modulePath, error));
     }
     const providers = Array.isArray(importedModule?.providers) ? importedModule.providers : [];
     if (providers.length === 0) {