beeos-claw 0.5.65-staging.3 → 0.5.65-staging.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "beeos-claw",
-  "version": "0.5.65-staging.3",
+  "version": "0.5.65-staging.5",
   "description": "OpenClaw plugin that bridges the BeeOS platform with the local OpenClaw Gateway, providing file transfer, ACP bridge, and observability.",
   "license": "MIT",
   "author": "BeeOS <dev@beeos.ai>",

package/scripts/runtime-blackbox-worker-lifecycle.mjs

@@ -38,17 +38,10 @@ export async function withinDeadline(run, deadline) {
  * invoking start() again would create competing reconnect loops.
  */
 export async function startGatewayWithinDeadline(gateway, deadline) {
-  try {
-    await withinDeadline(() => gateway.start(), deadline);
-    return;
-  } catch (error) {
-    if (!isRetryableGatewayHandshake(error)) throw error;
-  }
-
-  await withinDeadline((signal) => waitForGatewayConnection(gateway, signal), deadline);
+  return await withinDeadline((signal) => startAndObserveGateway(gateway, signal), deadline);
 }
 
-export async function closeRuntimeResources({ consumer, gateway }, cleanupTimeoutMs = 5_000) {
+export async function closeRuntimeResources({ consumer, gateway, releaseGatewayTransportObserver }, cleanupTimeoutMs = 5_000) {
   let cleanupError;
   try {
     if (consumer) {
@@ -63,6 +56,11 @@ export async function closeRuntimeResources({ consumer, gateway }, cleanupTimeou
       }
     } catch (error) {
       cleanupError ??= new Error(WORKER_CLEANUP_MESSAGE, { cause: error });
+    } finally {
+      // The retained observer is only needed while GatewayClient can still
+      // emit a transport error. Release it after the bounded stop completes,
+      // including the consumer-stop failure path.
+      releaseGatewayTransportObserver?.();
     }
   }
   return cleanupError;
@@ -116,32 +114,41 @@ function isRetryableGatewayHandshake(error) {
     ((error.retryable === true) || error.code === "UNAVAILABLE");
 }
 
-function waitForGatewayConnection(gateway, signal) {
+function startAndObserveGateway(gateway, signal) {
   return new Promise((resolve, reject) => {
     let settled = false;
-    const cleanup = () => {
+    let observedTransportFailure = false;
+    const cleanup = (retainTransportObserver = false) => {
       gateway.off("connected", onConnected);
       gateway.off("auth-failed", onAuthFailed);
-      gateway.off("error", onError);
+      if (!retainTransportObserver) gateway.off("error", onError);
+      gateway.off("disconnected", onDisconnected);
       signal.removeEventListener("abort", onAbort);
     };
-    const settle = (callback, value) => {
+    const releaseTransportObserver = () => gateway.off("error", onError);
+    const settle = (callback, value, retainTransportObserver = false) => {
       if (settled) return;
       settled = true;
-      cleanup();
+      cleanup(retainTransportObserver);
       callback(value);
     };
-    const onConnected = () => settle(resolve);
+    // `error` has special EventEmitter semantics: after the initial handshake
+    // succeeds, a later WebSocket transport error must stay observed until the
+    // worker shuts the Gateway down. GatewayClient owns reconnects; this
+    // observer only prevents that owned transient from becoming process-fatal.
+    const onConnected = () => settle(resolve, releaseTransportObserver, true);
     const onAuthFailed = (failure) => {
       const reason = failure && typeof failure.reason === "string"
         ? failure.reason
         : "Gateway authentication failed";
       settle(reject, new Error(reason));
     };
-    // GatewayClient emits `error` for each failed reconnect before scheduling
-    // the next one. Keep an error listener while waiting so EventEmitter does
-    // not crash the worker; auth-failed remains the immediate terminal signal.
-    const onError = () => {};
+    // GatewayClient owns reconnect scheduling for a WebSocket-level startup
+    // failure. Install this observer before `start()` so its first error cannot
+    // become EventEmitter's fatal unhandled `error` event. The subsequent
+    // `start()` rejection is intentionally held open for that owned retry.
+    const onError = () => { observedTransportFailure = true; };
+    const onDisconnected = () => { observedTransportFailure = true; };
     const onAbort = () => settle(reject, signal.reason ?? new Error("Gateway connection aborted"));
 
     if (signal.aborted) {
@@ -151,7 +158,22 @@ function waitForGatewayConnection(gateway, signal) {
     gateway.on("connected", onConnected);
     gateway.on("auth-failed", onAuthFailed);
     gateway.on("error", onError);
+    gateway.on("disconnected", onDisconnected);
     signal.addEventListener("abort", onAbort, { once: true });
+
+    Promise.resolve()
+      .then(() => gateway.start())
+      .then(
+        () => settle(resolve, releaseTransportObserver, true),
+        (error) => {
+          // Typed handshake UNAVAILABLE and a pre-auth transport failure both
+          // leave GatewayClient's single bounded reconnect loop authoritative.
+          // A nonretryable handshake instead emits auth-failed and settles
+          // above without waiting for the worker deadline.
+          if (isRetryableGatewayHandshake(error) || observedTransportFailure) return;
+          settle(reject, error);
+        },
+      );
   });
 }
 

package/scripts/runtime-blackbox-worker-main.mjs

@@ -114,13 +114,14 @@ export async function main() {
     retry: { baseMs: 100, maxMs: 500, maxAttempts: 60 } });
   let consumer;
   let primaryError;
+  let releaseGatewayTransportObserver;
   const runtimeLease = () => ({ instanceId, leaseId: nonempty(authority.leaseId, "authority.leaseId"),
     handlerIdentity: nonempty(authority.handlerIdentity, "authority.handlerIdentity"),
     runtimeEpoch: decimal(authority.runtimeEpoch, "authority.runtimeEpoch"),
     runtimeLeaseCredential: nonempty(authority.runtimeLeaseCredential, "authority.runtimeLeaseCredential"),
     leaseExpiresAt: new Date(Number(leaseClaims.exp) * 1_000).toISOString() });
   try {
-    await startGatewayWithinDeadline(gateway, deadline);
+    releaseGatewayTransportObserver = await startGatewayWithinDeadline(gateway, deadline);
     const identities = new FileRuntimeAgentIdentityRegistry(`${statePrefix}-identities.json`);
     const dispatcher = new OpenClawRuntimeCommandDispatcher({ getGateway: () => gateway,
       resources: rejectingResources(), identities,
@@ -150,7 +151,7 @@ export async function main() {
     primaryError = error;
   } finally {
     primaryError = selectRuntimeError(primaryError,
-      await closeRuntimeResources({ consumer, gateway }));
+      await closeRuntimeResources({ consumer, gateway, releaseGatewayTransportObserver }));
     try { completionGate.assertNoFailure(); }
     catch (error) { primaryError ??= error; }
   }