@buda-ai/connector 0.1.26 → 0.1.28

package/dist/cli.js

@@ -523,7 +523,7 @@ import path2 from "path";
 // package.json
 var package_default = {
   name: "@buda-ai/connector",
-  version: "0.1.26",
+  version: "0.1.28",
   private: false,
   type: "module",
   publishConfig: {
@@ -550,7 +550,7 @@ var package_default = {
     "lint:err": "biome format . --write && biome check . --write --diagnostic-level=error"
   },
   dependencies: {
-    "@bunny-agent/daemon": "0.9.56",
+    "@bunny-agent/daemon": "0.9.57",
     "@clack/prompts": "^1.0.0",
     "playwright-core": "^1.52.0",
     ws: "^8.21.0"
@@ -2215,6 +2215,13 @@ var ConnectorDeletedError = class extends Error {
     this.name = "ConnectorDeletedError";
   }
 };
+var ConnectorUnauthorizedError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ConnectorUnauthorizedError";
+  }
+};
+var UNREGISTER_TIMEOUT_MS = 3e3;
 async function resolveConnectorScope(deviceId, launchConfig) {
   const serverUrl = normalizeServerOrigin(getServerUrl(launchConfig));
   const headers = { "Content-Type": "application/json" };
@@ -2301,14 +2308,15 @@ function buildAuthHeaders(config, launchConfig) {
   if (config.deviceToken) headers["X-Buda-Connector-Device-Token"] = config.deviceToken;
   return headers;
 }
-async function postJson(serverUrl, pathname, body, config, launchConfig) {
+async function postJson(serverUrl, pathname, body, config, launchConfig, options = {}) {
   const response = await fetch(`${serverUrl}${pathname}`, {
     method: "POST",
     headers: {
       "Content-Type": "application/json",
       ...buildAuthHeaders(config, launchConfig)
     },
-    body: JSON.stringify(body)
+    body: JSON.stringify(body),
+    ...options.timeoutMs ? { signal: AbortSignal.timeout(options.timeoutMs) } : {}
   });
   if (!response.ok) {
     const text2 = await response.text().catch(() => "");
@@ -2328,6 +2336,9 @@ async function postJson(serverUrl, pathname, body, config, launchConfig) {
     if (errorCode === "connector_deleted") {
       throw new ConnectorDeletedError(errorMessage3 || "Connector no longer exists");
     }
+    if (response.status === 401) {
+      throw new ConnectorUnauthorizedError(errorMessage3 || "Connector authentication failed");
+    }
     throw new Error(`${pathname} failed: ${response.status} ${errorMessage3}`);
   }
   return await response.json();
@@ -2403,7 +2414,8 @@ async function unregisterConnector(config, launchConfig) {
       connectorId: config.connectorId
     },
     config,
-    launchConfig
+    launchConfig,
+    { timeoutMs: UNREGISTER_TIMEOUT_MS }
   ).catch((error) => {
     void writeLog("warn", `unregister failed: ${error instanceof Error ? error.message : error}`);
   });
@@ -2601,6 +2613,7 @@ async function ensureStableConnectorRuntime() {
 // src/daemon-client.ts
 var START_TIMEOUT_MS = 45e3;
 var BOOTSTRAP_TIMEOUT_MS = 5 * 6e4;
+var GRACEFUL_STOP_TIMEOUT_MS = 3e3;
 var LOCK_ONLY_RECOVERY_MAX_AGE_MS = 5 * 6e4;
 var POLL_INTERVAL_MS = 250;
 var wait2 = (milliseconds) => new Promise((resolve) => setTimeout(resolve, milliseconds));
@@ -2754,6 +2767,30 @@ var stopUnresponsiveDaemonProcess = async (pid) => {
   if (await waitForProcessExit(pid, 3e3)) return;
   throw new Error(`Timed-out Connector daemon PID ${pid} could not be stopped safely`);
 };
+var waitForDaemonRelease = async (config, status, configRoot = getConfigRoot()) => {
+  const deadline = Date.now() + GRACEFUL_STOP_TIMEOUT_MS;
+  while (Date.now() < deadline) {
+    if (!isProcessAlive2(status.pid)) return true;
+    const current = await readPersistedDaemonStatus(config, configRoot).catch(() => null);
+    if (!current || current.pid !== status.pid || current.instanceId !== status.instanceId) {
+      return true;
+    }
+    await wait2(50);
+  }
+  return !isProcessAlive2(status.pid);
+};
+var stopLiveDaemon = async (config, status, configRoot = getConfigRoot(), command = "stop") => {
+  const stopStatus = await requestDaemonControl(config, command, configRoot);
+  if (command === "stop-if-idle" && !stopStatus.idle) return false;
+  if (await waitForDaemonRelease(config, status, configRoot)) return true;
+  const current = await readPersistedDaemonStatus(config, configRoot).catch(() => null);
+  if (!current || current.pid !== status.pid || current.instanceId !== status.instanceId) {
+    return true;
+  }
+  await stopUnresponsiveDaemonProcess(status.pid);
+  return true;
+};
+var shouldRestartUnhealthyDaemonForEnrollment = (status, explicitEnrollment) => explicitEnrollment && status.idle && status.heartbeatHealthy === false;
 var readDaemonLockOwnerPid = async (config) => {
   const lockPath = `${getConnectorDaemonLockTarget(
     config.serverUrl,
@@ -2817,6 +2854,12 @@ async function ensureConnectorDaemon(launchConfig, mode, options = {}) {
     if (existingConfig) {
       const existingStatus = await readLiveStatus(existingConfig);
       if (existingStatus) {
+        if (shouldRestartUnhealthyDaemonForEnrollment(
+          existingStatus,
+          Boolean(options.explicitEnrollment)
+        ) && await stopLiveDaemon(existingConfig, existingStatus, getConfigRoot(), "stop-if-idle")) {
+          return await startInternalDaemonWithRecovery(launchConfig, mode, void 0, options);
+        }
         const preparedRuntime = !shouldReplaceDaemonVersion(existingStatus.version, CONNECTOR_RUNTIME_VERSION) || !existingStatus.idle ? void 0 : await ensureStableConnectorRuntime();
         const replaced = await stopOlderIdleDaemon(existingConfig, existingStatus);
         if (!replaced) {
@@ -2937,7 +2980,7 @@ async function stopLocalConnectorDaemon(connectorId, serverUrl, configRoot = get
   if (!config) throw new Error(`Local Connector ${connectorId} was not found`);
   const status = await readLiveStatus(config, configRoot);
   if (!status) return;
-  await requestDaemonControl(config, "stop", configRoot);
+  await stopLiveDaemon(config, status, configRoot);
 }
 async function stopAllLocalConnectorDaemons(configRoot = getConfigRoot()) {
   const configs = await listDeviceConfigs(configRoot);
@@ -2950,7 +2993,7 @@ ${config.connectorId}`, config);
   const results = await Promise.allSettled(
     [...identities.values()].map(async (config) => {
       const status = await readLiveStatus(config, configRoot);
-      if (status) await requestDaemonControl(config, "stop", configRoot);
+      if (status) await stopLiveDaemon(config, status, configRoot);
     })
   );
   const failures = results.filter((result) => result.status === "rejected");
@@ -5743,7 +5786,30 @@ import { mkdir as mkdir12 } from "fs/promises";
 import path15 from "path";
 var RECOVERED_DAEMON_STOP_TIMEOUT_MS = 1e4;
 var RECOVERED_DAEMON_STOP_POLL_MS = 100;
+var SHUTDOWN_FORCE_EXIT_MS = 1e4;
+var SHUTDOWN_STEP_TIMEOUT_MS = 2e3;
 var wait3 = (milliseconds) => new Promise((resolve) => setTimeout(resolve, milliseconds));
+var runShutdownStep = async (label, operation) => {
+  let timeout;
+  try {
+    await Promise.race([
+      Promise.resolve().then(operation),
+      new Promise((_, reject) => {
+        timeout = setTimeout(
+          () => reject(new Error(`${label} timed out after ${SHUTDOWN_STEP_TIMEOUT_MS}ms`)),
+          SHUTDOWN_STEP_TIMEOUT_MS
+        );
+      })
+    ]);
+  } catch (error) {
+    await writeLog(
+      "warn",
+      `${label} failed during shutdown: ${error instanceof Error ? error.message : String(error)}`
+    ).catch(() => void 0);
+  } finally {
+    if (timeout) clearTimeout(timeout);
+  }
+};
 async function stopRecoveredIdleDaemon(config, configRoot) {
   const stopStatus = await requestDaemonControl(config, "stop-if-idle", configRoot).catch(
     () => null
@@ -5863,18 +5929,30 @@ async function runConnectorDaemon(launchConfig, options = {}) {
     const shutdown = async (shutdownOptions = {}) => {
       if (shuttingDown) return;
       shuttingDown = true;
+      const forceExit = options.exitOnShutdown === false ? void 0 : setTimeout(() => process.exit(0), SHUTDOWN_FORCE_EXIT_MS);
       if (interval) clearInterval(interval);
       relay.stop();
       try {
-        await closeAllBrowserSessions();
-        if (shutdownOptions.unregister !== false) {
-          await unregisterConnector(config, launchConfig);
-        }
-        await stopEmbeddedBunnyDaemon(activeBunnyDaemon);
+        await Promise.all([
+          runShutdownStep("browser session cleanup", closeAllBrowserSessions),
+          ...shutdownOptions.unregister === false ? [] : [
+            runShutdownStep(
+              "connector unregister",
+              () => unregisterConnector(config, launchConfig)
+            )
+          ],
+          runShutdownStep(
+            "embedded Bunny daemon shutdown",
+            () => stopEmbeddedBunnyDaemon(activeBunnyDaemon)
+          )
+        ]);
       } finally {
-        await control?.close();
-        await daemonLock.release();
-        await restoreConsole?.();
+        await Promise.all([
+          runShutdownStep("control channel shutdown", async () => control?.close()),
+          runShutdownStep("daemon lock release", () => daemonLock.release()),
+          runShutdownStep("console capture restore", async () => restoreConsole?.())
+        ]);
+        if (forceExit) clearTimeout(forceExit);
         if (options.exitOnShutdown !== false) process.exit(0);
       }
     };
@@ -5889,8 +5967,11 @@ async function runConnectorDaemon(launchConfig, options = {}) {
         });
       }).catch((error) => {
         heartbeatHealthy = false;
-        if (error instanceof ConnectorDeletedError) {
-          void writeLog("warn", "connector deleted remotely; stopping daemon");
+        if (error instanceof ConnectorDeletedError || error instanceof ConnectorUnauthorizedError) {
+          void writeLog(
+            "warn",
+            error instanceof ConnectorDeletedError ? "connector deleted remotely; stopping daemon" : "connector authentication rejected remotely; stopping daemon"
+          );
           void shutdown({ unregister: false });
           return;
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@buda-ai/connector",
-  "version": "0.1.26",
+  "version": "0.1.28",
   "private": false,
   "type": "module",
   "publishConfig": {
@@ -27,7 +27,7 @@
     "lint:err": "biome format . --write && biome check . --write --diagnostic-level=error"
   },
   "dependencies": {
-    "@bunny-agent/daemon": "0.9.56",
+    "@bunny-agent/daemon": "0.9.57",
     "@clack/prompts": "^1.0.0",
     "playwright-core": "^1.52.0",
     "ws": "^8.21.0"