@buda-ai/connector 0.1.28 → 0.1.30

package/dist/cli.js

@@ -523,7 +523,7 @@ import path2 from "path";
 // package.json
 var package_default = {
   name: "@buda-ai/connector",
-  version: "0.1.28",
+  version: "0.1.30",
   private: false,
   type: "module",
   publishConfig: {
@@ -2790,6 +2790,25 @@ var stopLiveDaemon = async (config, status, configRoot = getConfigRoot(), comman
   await stopUnresponsiveDaemonProcess(status.pid);
   return true;
 };
+var matchesDaemonIdentity = (config, status) => status.connectorId === config.connectorId && normalizeServerOrigin(status.serverUrl) === normalizeServerOrigin(config.serverUrl) && Number.isSafeInteger(status.pid) && status.pid > 0 && typeof status.instanceId === "string" && status.instanceId.length > 0;
+var readMatchingPersistedDaemonStatus = async (config, configRoot = getConfigRoot()) => {
+  const status = await readPersistedDaemonStatus(config, configRoot).catch(() => null);
+  return status && matchesDaemonIdentity(config, status) ? status : null;
+};
+var stopDaemonForIdentity = async (config, configRoot = getConfigRoot()) => {
+  const liveStatus = await readLiveStatus(config, configRoot);
+  if (liveStatus) {
+    await stopLiveDaemon(config, liveStatus, configRoot);
+    return;
+  }
+  const persistedStatus = await readMatchingPersistedDaemonStatus(config, configRoot);
+  if (!persistedStatus || !isProcessAlive2(persistedStatus.pid)) return;
+  const currentStatus = await readMatchingPersistedDaemonStatus(config, configRoot);
+  if (!currentStatus || currentStatus.pid !== persistedStatus.pid || currentStatus.instanceId !== persistedStatus.instanceId || !isProcessAlive2(currentStatus.pid)) {
+    return;
+  }
+  await stopUnresponsiveDaemonProcess(currentStatus.pid);
+};
 var shouldRestartUnhealthyDaemonForEnrollment = (status, explicitEnrollment) => explicitEnrollment && status.idle && status.heartbeatHealthy === false;
 var readDaemonLockOwnerPid = async (config) => {
   const lockPath = `${getConnectorDaemonLockTarget(
@@ -2978,9 +2997,7 @@ async function stopLocalConnectorDaemon(connectorId, serverUrl, configRoot = get
     (candidate) => candidate.connectorId === connectorId && normalizeServerOrigin(candidate.serverUrl) === serverOrigin
   );
   if (!config) throw new Error(`Local Connector ${connectorId} was not found`);
-  const status = await readLiveStatus(config, configRoot);
-  if (!status) return;
-  await stopLiveDaemon(config, status, configRoot);
+  await stopDaemonForIdentity(config, configRoot);
 }
 async function stopAllLocalConnectorDaemons(configRoot = getConfigRoot()) {
   const configs = await listDeviceConfigs(configRoot);
@@ -2991,10 +3008,7 @@ async function stopAllLocalConnectorDaemons(configRoot = getConfigRoot()) {
 ${config.connectorId}`, config);
   }
   const results = await Promise.allSettled(
-    [...identities.values()].map(async (config) => {
-      const status = await readLiveStatus(config, configRoot);
-      if (status) await stopLiveDaemon(config, status, configRoot);
-    })
+    [...identities.values()].map((config) => stopDaemonForIdentity(config, configRoot))
   );
   const failures = results.filter((result) => result.status === "rejected");
   if (failures.length) {
@@ -4704,6 +4718,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;
@@ -4809,6 +4824,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;
@@ -4821,6 +4837,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 {
@@ -4832,18 +4849,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,
@@ -5019,7 +5051,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;
     }
   }
@@ -5105,7 +5137,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,
@@ -5125,7 +5157,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 }) ?? "",
@@ -5134,7 +5166,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
@@ -5145,7 +5177,7 @@ async function handleRelayMessage(socket, bunnyDaemon, raw, inflight, expectedCo
         reader.releaseLock();
       }
     }
-    sendRelayMessage(socket, {
+    await sendRelayMessage(socket, {
       type: "end",
       requestId: message.requestId
     });
@@ -5157,14 +5189,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);
   }
@@ -5218,17 +5252,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
       }
     }
   };
@@ -5260,17 +5297,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 = {};

package/package.json

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