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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "beeos-claw",
-  "version": "0.5.65-staging.4",
+  "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,10 +38,10 @@ export async function withinDeadline(run, deadline) {
  * invoking start() again would create competing reconnect loops.
  */
 export async function startGatewayWithinDeadline(gateway, deadline) {
-  await withinDeadline((signal) => startAndObserveGateway(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) {
@@ -56,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;
@@ -113,20 +118,25 @@ function startAndObserveGateway(gateway, signal) {
   return new Promise((resolve, reject) => {
     let settled = false;
     let observedTransportFailure = false;
-    const cleanup = () => {
+    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
@@ -154,7 +164,7 @@ function startAndObserveGateway(gateway, signal) {
     Promise.resolve()
       .then(() => gateway.start())
       .then(
-        () => settle(resolve),
+        () => settle(resolve, releaseTransportObserver, true),
         (error) => {
           // Typed handshake UNAVAILABLE and a pre-auth transport failure both
           // leave GatewayClient's single bounded reconnect loop authoritative.

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; }
   }