@buda-ai/connector 0.1.24 → 0.1.25

package/dist/cli.js

@@ -523,7 +523,7 @@ import path2 from "path";
 // package.json
 var package_default = {
   name: "@buda-ai/connector",
-  version: "0.1.24",
+  version: "0.1.25",
   private: false,
   type: "module",
   publishConfig: {
@@ -2601,6 +2601,7 @@ async function ensureStableConnectorRuntime() {
 // src/daemon-client.ts
 var START_TIMEOUT_MS = 45e3;
 var BOOTSTRAP_TIMEOUT_MS = 5 * 6e4;
+var LOCK_ONLY_RECOVERY_MAX_AGE_MS = 5 * 6e4;
 var POLL_INTERVAL_MS = 250;
 var wait2 = (milliseconds) => new Promise((resolve) => setTimeout(resolve, milliseconds));
 var getConfigRoot = () => process.env.BUDA_CONNECTOR_CONFIG_ROOT;
@@ -2668,8 +2669,13 @@ async function spawnDetachedDaemonProcess(command, args, options, dependencies =
     });
     try {
       await waitForChildSpawn(child);
+      if (!child.pid) {
+        throw Object.assign(new Error("spawned Connector daemon did not expose a PID"), {
+          code: "NO_PID"
+        });
+      }
       child.unref();
-      return strategy.name;
+      return { pid: child.pid, strategy: strategy.name };
     } catch (error) {
       const code = getErrorCode(error);
       const shouldRetry = platform4 === "win32" && index === 0 && code === "EINVAL";
@@ -2688,14 +2694,18 @@ async function spawnDetachedDaemonProcess(command, args, options, dependencies =
   }
   throw new Error("Connector daemon process creation failed without a spawn attempt");
 }
+var readReadyDaemon = async (launchConfig) => {
+  const config = await readDeviceConfig(launchConfig, getConfigRoot());
+  if (!config) return null;
+  const status = await readLiveStatus(config);
+  return status ? { config, status } : null;
+};
 var waitForDaemon = async (launchConfig, deadline) => {
   let lastConfig = null;
   while (Date.now() < deadline) {
+    const ready = await readReadyDaemon(launchConfig);
+    if (ready) return ready;
     lastConfig = await readDeviceConfig(launchConfig, getConfigRoot());
-    if (lastConfig) {
-      const status = await readLiveStatus(lastConfig);
-      if (status) return { config: lastConfig, status };
-    }
     await wait2(POLL_INTERVAL_MS);
   }
   throw new Error(
@@ -2705,7 +2715,7 @@ var waitForDaemon = async (launchConfig, deadline) => {
 var spawnInternalDaemon = async (launchConfig, mode, preparedRuntime, options = {}) => {
   const runtime = preparedRuntime ?? await ensureStableConnectorRuntime();
   const debugDaemonStdio = process.env.BUDA_CONNECTOR_DEBUG_DAEMON_STDIO === "1";
-  await spawnDetachedDaemonProcess(
+  return spawnDetachedDaemonProcess(
     runtime.nodeExecutable,
     getRuntimeCommandArgs(runtime, mode, options),
     {
@@ -2717,6 +2727,70 @@ var spawnInternalDaemon = async (launchConfig, mode, preparedRuntime, options =
     }
   );
 };
+var waitForProcessExit = async (pid, timeoutMs) => {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    if (!isProcessAlive2(pid)) return true;
+    await wait2(50);
+  }
+  return !isProcessAlive2(pid);
+};
+var signalProcess = (pid, signal) => {
+  try {
+    process.kill(pid, signal);
+    return true;
+  } catch (error) {
+    if (typeof error === "object" && error !== null && "code" in error && error.code === "ESRCH") {
+      return false;
+    }
+    throw error;
+  }
+};
+var stopUnresponsiveDaemonProcess = async (pid) => {
+  if (!isProcessAlive2(pid)) return;
+  if (!signalProcess(pid, "SIGTERM")) return;
+  if (await waitForProcessExit(pid, 2e3)) return;
+  if (!signalProcess(pid, "SIGKILL")) return;
+  if (await waitForProcessExit(pid, 3e3)) return;
+  throw new Error(`Timed-out Connector daemon PID ${pid} could not be stopped safely`);
+};
+var readDaemonLockOwnerPid = async (config) => {
+  const lockPath = `${getConnectorDaemonLockTarget(
+    config.serverUrl,
+    config.connectorId,
+    getConfigRoot()
+  )}.lock`;
+  const raw = await readFile6(lockPath, "utf8").catch(() => "");
+  try {
+    const metadata = JSON.parse(raw);
+    const age = typeof metadata.createdAt === "number" && Number.isFinite(metadata.createdAt) ? Date.now() - metadata.createdAt : Number.POSITIVE_INFINITY;
+    return typeof metadata.pid === "number" && Number.isSafeInteger(metadata.pid) && metadata.pid > 0 && age >= 0 && age <= LOCK_ONLY_RECOVERY_MAX_AGE_MS ? metadata.pid : null;
+  } catch {
+    return null;
+  }
+};
+async function startDaemonWithRecovery(dependencies, maxAttempts = 2) {
+  let lastError;
+  for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
+    const spawned = await dependencies.spawnDaemon();
+    try {
+      return await dependencies.waitForReady();
+    } catch (error) {
+      lastError = error;
+      const lateReady = await dependencies.readReady().catch(() => null);
+      if (lateReady) return lateReady;
+      await dependencies.stopDaemon(spawned.pid);
+      if (attempt === maxAttempts) throw error;
+    }
+  }
+  throw lastError;
+}
+var startInternalDaemonWithRecovery = (launchConfig, mode, preparedRuntime, options = {}) => startDaemonWithRecovery({
+  readReady: () => readReadyDaemon(launchConfig),
+  spawnDaemon: () => spawnInternalDaemon(launchConfig, mode, preparedRuntime, options),
+  stopDaemon: stopUnresponsiveDaemonProcess,
+  waitForReady: () => waitForDaemon(launchConfig, Date.now() + START_TIMEOUT_MS)
+});
 var stopOlderIdleDaemon = async (config, status) => {
   if (!shouldReplaceDaemonVersion(status.version, CONNECTOR_RUNTIME_VERSION)) return false;
   if (!status.idle) return false;
@@ -2749,8 +2823,7 @@ async function ensureConnectorDaemon(launchConfig, mode, options = {}) {
           const status = mode === "persistent" ? await requestDaemonControl(existingConfig, "persist", getConfigRoot()) : existingStatus;
           return { config: existingConfig, status };
         }
-        await spawnInternalDaemon(launchConfig, mode, preparedRuntime, options);
-        return await waitForDaemon(launchConfig, Date.now() + START_TIMEOUT_MS);
+        return await startInternalDaemonWithRecovery(launchConfig, mode, preparedRuntime, options);
       }
       const persistedStatus = await readPersistedDaemonStatus(
         existingConfig,
@@ -2761,9 +2834,12 @@ async function ensureConnectorDaemon(launchConfig, mode, options = {}) {
           `Connector daemon PID ${persistedStatus.pid} is running but its local control channel is not responding. Stop that process and retry.`
         );
       }
+      const lockOwnerPid = await readDaemonLockOwnerPid(existingConfig);
+      if (lockOwnerPid && isProcessAlive2(lockOwnerPid)) {
+        await stopUnresponsiveDaemonProcess(lockOwnerPid);
+      }
     }
-    await spawnInternalDaemon(launchConfig, mode, void 0, options);
-    return await waitForDaemon(launchConfig, Date.now() + START_TIMEOUT_MS);
+    return await startInternalDaemonWithRecovery(launchConfig, mode, void 0, options);
   } finally {
     await bootstrapLock.release();
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@buda-ai/connector",
-  "version": "0.1.24",
+  "version": "0.1.25",
   "private": false,
   "type": "module",
   "publishConfig": {