@buda-ai/connector 0.1.27 → 0.1.29

package/dist/cli.js

@@ -523,7 +523,7 @@ import path2 from "path";
 // package.json
 var package_default = {
   name: "@buda-ai/connector",
-  version: "0.1.27",
+  version: "0.1.29",
   private: false,
   type: "module",
   publishConfig: {
@@ -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");
@@ -4661,6 +4704,7 @@ var isAlreadyExists3 = (error) => error instanceof Error && "code" in error && e
 // src/relay.ts
 var RELAY_PING_INTERVAL_MS = 2e4;
 var RELAY_PONG_TIMEOUT_MS = 1e4;
+var RELAY_ACTIVE_REQUEST_PONG_TIMEOUT_LIMIT = 2;
 var RELAY_HANDSHAKE_TIMEOUT_MS = 1e4;
 var RELAY_RECONNECT_MAX_MS = 3e4;
 var RELAY_RECONNECT_JITTER = 0.2;
@@ -4766,6 +4810,7 @@ function startConnectorRelay(config, bunnyDaemon, relayProtocol, workspaceRegist
     socket = ws;
     const inflight = /* @__PURE__ */ new Map();
     currentInflight = inflight;
+    let consecutivePongTimeouts = 0;
     let detached = false;
     const detach = () => {
       if (detached) return;
@@ -4778,6 +4823,7 @@ function startConnectorRelay(config, bunnyDaemon, relayProtocol, workspaceRegist
       void writeLog("info", `relay connected ${relayUrl}`);
       hadOpenConnection = true;
       reconnectDelayMs = RELAY_RECONNECT_INTERVAL_MS;
+      consecutivePongTimeouts = 0;
       pingTimer = setInterval(() => {
         if (ws.readyState !== WebSocket2.OPEN) return;
         try {
@@ -4789,18 +4835,33 @@ function startConnectorRelay(config, bunnyDaemon, relayProtocol, workspaceRegist
         }
         if (pongTimer) clearTimeout(pongTimer);
         pongTimer = setTimeout(() => {
+          pongTimer = null;
+          consecutivePongTimeouts += 1;
+          if (inflight.size > 0 && consecutivePongTimeouts < RELAY_ACTIVE_REQUEST_PONG_TIMEOUT_LIMIT) {
+            void writeLog(
+              "warn",
+              `relay pong timeout deferred while ${inflight.size} request(s) are active`
+            );
+            return;
+          }
           void writeLog("warn", "relay pong timeout, terminating");
           ws.terminate();
         }, RELAY_PONG_TIMEOUT_MS);
       }, RELAY_PING_INTERVAL_MS);
     });
     ws.on("pong", () => {
+      consecutivePongTimeouts = 0;
       if (pongTimer) {
         clearTimeout(pongTimer);
         pongTimer = null;
       }
     });
     ws.on("message", (raw) => {
+      consecutivePongTimeouts = 0;
+      if (pongTimer) {
+        clearTimeout(pongTimer);
+        pongTimer = null;
+      }
       void handleRelayMessage(
         ws,
         bunnyDaemon,
@@ -4976,7 +5037,7 @@ async function handleRelayMessage(socket, bunnyDaemon, raw, inflight, expectedCo
       });
       executionIdentity = message.executionIdentity;
     } catch (error) {
-      sendRelayError(socket, message.requestId, error);
+      await sendRelayError(socket, message.requestId, error).catch(() => void 0);
       return;
     }
   }
@@ -5062,7 +5123,7 @@ async function handleRelayMessage(socket, bunnyDaemon, raw, inflight, expectedCo
         durationMs: Date.now() - codingRunStartedAt
       });
     }
-    sendRelayMessage(socket, {
+    await sendRelayMessage(socket, {
       type: "start",
       requestId: message.requestId,
       status: response.status,
@@ -5082,7 +5143,7 @@ async function handleRelayMessage(socket, bunnyDaemon, raw, inflight, expectedCo
         while (true) {
           const { value, done } = await reader.read();
           if (done) break;
-          sendRelayMessage(socket, {
+          await sendRelayMessage(socket, {
             type: "chunk",
             requestId: message.requestId,
             data: binaryResponse ? Buffer.from(value).toString("base64") : decoder?.decode(value, { stream: true }) ?? "",
@@ -5091,7 +5152,7 @@ async function handleRelayMessage(socket, bunnyDaemon, raw, inflight, expectedCo
         }
         const tail = decoder?.decode() ?? "";
         if (tail) {
-          sendRelayMessage(socket, {
+          await sendRelayMessage(socket, {
             type: "chunk",
             requestId: message.requestId,
             data: tail
@@ -5102,7 +5163,7 @@ async function handleRelayMessage(socket, bunnyDaemon, raw, inflight, expectedCo
         reader.releaseLock();
       }
     }
-    sendRelayMessage(socket, {
+    await sendRelayMessage(socket, {
       type: "end",
       requestId: message.requestId
     });
@@ -5114,14 +5175,16 @@ async function handleRelayMessage(socket, bunnyDaemon, raw, inflight, expectedCo
       });
     }
   } catch (error) {
+    controller.abort();
     if (codingRunTrace && codingRunStartedAt !== void 0) {
       await writeLog("error", "relay request coding run error", {
         ...codingRunTrace,
         status: codingRunStatus,
-        durationMs: Date.now() - codingRunStartedAt
+        durationMs: Date.now() - codingRunStartedAt,
+        error: formatConnectorRelayError(error)
       });
     }
-    sendRelayError(socket, message.requestId, error);
+    await sendRelayError(socket, message.requestId, error).catch(() => void 0);
   } finally {
     inflight.delete(message.requestId);
   }
@@ -5175,17 +5238,20 @@ var normalizeWorkspaceRequest = (request, mounts) => {
   if (!mount || relative === void 0) {
     throw new ConnectorRelayProtocolError("WORKSPACE_MISMATCH");
   }
-  const env = body.env && typeof body.env === "object" && !Array.isArray(body.env) ? body.env : {};
+  const systemEnv = body.systemEnv && typeof body.systemEnv === "object" && !Array.isArray(body.systemEnv) ? body.systemEnv : {};
+  const workspaceEnv = {
+    BUDA_AGENT_ROOT: mounts.agent,
+    BUDA_SPACE_ROOT: mounts.space,
+    BUDA_SYSTEM_ROOT: mounts.system
+  };
   return {
     ...request,
     body: {
       ...body,
       cwd: path12.join(mount, relative),
-      env: {
-        ...env,
-        BUDA_AGENT_ROOT: mounts.agent,
-        BUDA_SPACE_ROOT: mounts.space,
-        BUDA_SYSTEM_ROOT: mounts.system
+      systemEnv: {
+        ...systemEnv,
+        ...workspaceEnv
       }
     }
   };
@@ -5217,17 +5283,24 @@ var normalizeConnectorFilesystemRequest = (request, mounts) => {
   }
   return request;
 };
-function sendRelayError(socket, requestId, error) {
-  sendRelayMessage(socket, {
+async function sendRelayError(socket, requestId, error) {
+  await sendRelayMessage(socket, {
     type: "error",
     requestId,
     error: error instanceof Error ? error.message : String(error),
     ...error instanceof ConnectorRelayProtocolError ? { code: error.code } : {}
   });
 }
-function sendRelayMessage(socket, message) {
-  if (socket.readyState !== WebSocket2.OPEN) return;
-  socket.send(JSON.stringify(message));
+async function sendRelayMessage(socket, message) {
+  if (socket.readyState !== WebSocket2.OPEN) {
+    throw new Error(`Connector relay socket closed before ${message.type} could be sent.`);
+  }
+  await new Promise((resolve, reject) => {
+    socket.send(JSON.stringify(message), (error) => {
+      if (error) reject(error);
+      else resolve();
+    });
+  });
 }
 function headersToRecord(headers) {
   const result = {};
@@ -5743,7 +5816,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 +5959,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 +5997,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.27",
+  "version": "0.1.29",
   "private": false,
   "type": "module",
   "publishConfig": {