ocuclaw 1.3.0 → 1.3.2

package/dist/runtime/relay-service.js

@@ -1,5 +1,10 @@
 import { createRuntimeConfig } from "../config/runtime-config.js";
 import { createPluginOpenclawClient } from "../gateway/openclaw-client.js";
+import {
+  composeContainerLoopbackWarning,
+  isContainerEnvironment,
+  isLoopbackBindAddress,
+} from "./container-env.js";
 import { createRelay as createPluginOwnedRelay } from "./relay-core.js";
 
 function normalizeLogger(logger) {
@@ -158,6 +163,13 @@ export function createOcuClawRelayService(opts = {}) {
       logger.info(
         `[ocuclaw] relay service started on ws://${config.wsBind}:${config.wsPort}`,
       );
+      const containerEnvProbe =
+        typeof opts.isContainerEnvironment === "function"
+          ? opts.isContainerEnvironment
+          : isContainerEnvironment;
+      if (isLoopbackBindAddress(config.wsBind) && containerEnvProbe()) {
+        logger.warn(composeContainerLoopbackWarning(config.wsBind, config.wsPort));
+      }
       return nextRelay;
     } catch (err) {
       clearSharedRelay(nextRelay);
@@ -291,34 +303,128 @@ export function createOcuClawRelayService(opts = {}) {
         trackedThrowawayKeys: [],
       };
     },
+    // These reads back the session-title tool, the distiller gates, and the
+    // Channel-2 before_prompt_build hook — all of which can run in a sibling
+    // plugin-register context whose own `relay` is null. Resolve the live
+    // (possibly shared) relay so they reach the running instance, mirroring
+    // hasConnectedAppClient(); otherwise the distiller skips every run and the
+    // Channel-2 stop-notices never fire.
     getSessionTitle(sessionKey) {
-      if (relay && typeof relay.getSessionTitle === "function") {
-        return relay.getSessionTitle(sessionKey);
+      const liveRelay = resolveLiveRelay();
+      if (liveRelay && typeof liveRelay.getSessionTitle === "function") {
+        return liveRelay.getSessionTitle(sessionKey);
       }
       return null;
     },
     hasRecordedUserMessage(sessionKey) {
-      if (relay && typeof relay.hasRecordedUserMessage === "function") {
-        return relay.hasRecordedUserMessage(sessionKey);
+      const liveRelay = resolveLiveRelay();
+      if (liveRelay && typeof liveRelay.hasRecordedUserMessage === "function") {
+        return liveRelay.hasRecordedUserMessage(sessionKey);
       }
-      // Fail-closed when the relay isn't running: block titling.
+      // Fail-closed when no relay is running: block titling.
       return false;
     },
     isNeuralSessionNamesEnabled(sessionKey) {
-      if (relay && typeof relay.isNeuralSessionNamesEnabled === "function") {
-        return relay.isNeuralSessionNamesEnabled(sessionKey);
+      const liveRelay = resolveLiveRelay();
+      if (liveRelay && typeof liveRelay.isNeuralSessionNamesEnabled === "function") {
+        return liveRelay.isNeuralSessionNamesEnabled(sessionKey);
       }
       return true;
     },
     isSessionUserLocked(sessionKey) {
-      if (relay && typeof relay.isSessionUserLocked === "function") {
-        return relay.isSessionUserLocked(sessionKey);
+      const liveRelay = resolveLiveRelay();
+      if (liveRelay && typeof liveRelay.isSessionUserLocked === "function") {
+        return liveRelay.isSessionUserLocked(sessionKey);
+      }
+      return false;
+    },
+    getDisplayStartStates(sessionKey) {
+      const liveRelay = resolveLiveRelay();
+      if (liveRelay && typeof liveRelay.getDisplayStartStates === "function") {
+        return liveRelay.getDisplayStartStates(sessionKey);
+      }
+      return { emoji: false, pace: false };
+    },
+    getDisplayCurrentStates(sessionKey) {
+      const liveRelay = resolveLiveRelay();
+      if (liveRelay && typeof liveRelay.getDisplayCurrentStates === "function") {
+        return liveRelay.getDisplayCurrentStates(sessionKey);
+      }
+      return { emoji: false, pace: false };
+    },
+    // Distiller-sidecar passthroughs. Use the live relay (possibly a sibling
+    // register-context's shared relay) since the distiller may fire from a
+    // context whose own `relay` is null.
+    getSessionTitleRecord(sessionKey) {
+      const liveRelay = resolveLiveRelay();
+      if (liveRelay && typeof liveRelay.getSessionTitleRecord === "function") {
+        return liveRelay.getSessionTitleRecord(sessionKey);
+      }
+      return null;
+    },
+    isEvenAiSessionKey(sessionKey) {
+      const liveRelay = resolveLiveRelay();
+      if (liveRelay && typeof liveRelay.isEvenAiSessionKey === "function") {
+        return liveRelay.isEvenAiSessionKey(sessionKey);
       }
       return false;
     },
+    getRawMessages() {
+      const liveRelay = resolveLiveRelay();
+      if (liveRelay && typeof liveRelay.getRawMessages === "function") {
+        return liveRelay.getRawMessages();
+      }
+      return [];
+    },
+    getDistillerBudget() {
+      const liveRelay = resolveLiveRelay();
+      if (liveRelay && typeof liveRelay.getDistillerBudget === "function") {
+        return liveRelay.getDistillerBudget();
+      }
+      return null;
+    },
+    deleteDistillerSession(sessionKey) {
+      const liveRelay = resolveLiveRelay();
+      if (liveRelay && typeof liveRelay.deleteDistillerSession === "function") {
+        return liveRelay.deleteDistillerSession(sessionKey);
+      }
+      return Promise.resolve(null);
+    },
+    getStateDir() {
+      const liveRelay = resolveLiveRelay();
+      if (liveRelay && typeof liveRelay.getStateDir === "function") {
+        return liveRelay.getStateDir();
+      }
+      return opts.stateDir;
+    },
+    emitDebug(...args) {
+      const liveRelay = resolveLiveRelay();
+      if (liveRelay && typeof liveRelay.emitDebug === "function") {
+        return liveRelay.emitDebug(...args);
+      }
+      return undefined;
+    },
+    gatewayRequest(method, params, requestOpts) {
+      const liveRelay = resolveLiveRelay();
+      if (liveRelay && typeof liveRelay.gatewayRequest === "function") {
+        return liveRelay.gatewayRequest(method, params, requestOpts);
+      }
+      return Promise.reject(new Error("relay_not_running"));
+    },
+    onGatewayEvent(eventName, listener) {
+      const liveRelay = resolveLiveRelay();
+      if (liveRelay && typeof liveRelay.onGatewayEvent === "function") {
+        return liveRelay.onGatewayEvent(eventName, listener);
+      }
+      return () => {};
+    },
     peekSessionKey() {
-      if (relay && typeof relay.peekSessionKey === "function") {
-        return relay.peekSessionKey();
+      // The set_session_title tool reads this before writing; like the adjacent
+      // session-title accessors it must reach the live (possibly shared) relay,
+      // or an explicit rename from a sibling tool context fails no_active_session.
+      const liveRelay = resolveLiveRelay();
+      if (liveRelay && typeof liveRelay.peekSessionKey === "function") {
+        return liveRelay.peekSessionKey();
       }
       return null;
     },
@@ -328,8 +434,9 @@ export function createOcuClawRelayService(opts = {}) {
       }
     },
     setSessionTitle(sessionKey, title, opts) {
-      if (relay && typeof relay.setSessionTitle === "function") {
-        return relay.setSessionTitle(sessionKey, title, opts);
+      const liveRelay = resolveLiveRelay();
+      if (liveRelay && typeof liveRelay.setSessionTitle === "function") {
+        return liveRelay.setSessionTitle(sessionKey, title, opts);
       }
       return { ok: false, code: "relay_not_running" };
     },

package/dist/runtime/relay-worker-entry.js

@@ -5,10 +5,36 @@ if (!parentPort) {
   throw new Error("relay worker entry requires parentPort");
 }
 
+function formatLogArgs(args) {
+  return args
+    .map((arg) => {
+      if (typeof arg === "string") return arg;
+      if (arg instanceof Error) return arg.message;
+      try {
+        return JSON.stringify(arg);
+      } catch {
+        return String(arg);
+      }
+    })
+    .join(" ");
+}
+
+function postWorkerLog(level, args) {
+  parentPort.postMessage({ kind: "worker.log", level, message: formatLogArgs(args) });
+}
+
 const transport = createRelayWorkerTransport({
   postToMain(message) {
     parentPort.postMessage(message);
   },
+  // Worker-thread console output never reaches the gateway's log file;
+  // forward log lines to the supervisor, which owns the real plugin logger.
+  logger: {
+    info(...args) { postWorkerLog("info", args); },
+    warn(...args) { postWorkerLog("warn", args); },
+    error(...args) { postWorkerLog("error", args); },
+    debug(...args) { postWorkerLog("debug", args); },
+  },
 });
 
 parentPort.on("message", async (message) => {

package/dist/runtime/relay-worker-protocol.js

@@ -16,10 +16,6 @@ export const APP_PROTOCOL = Object.freeze({
   readinessProbeAck: "ocuclaw.readiness.probe.ack",
   automationStateGet: "ocuclaw.automation.state.get",
   automationStateSnapshot: "ocuclaw.automation.state.snapshot",
-  restartGateway: "ocuclaw.restartGateway",
-  restartGatewayAck: "ocuclaw.restartGatewayAck",
-  updatePlugin: "ocuclaw.updatePlugin",
-  updatePluginResult: "ocuclaw.updatePluginResult",
   approvalRequest: "ocuclaw.approval.request",
   approvalResolved: "ocuclaw.approval.resolved",
   sessionContextSnapshot: "ocuclaw.session.context.snapshot",

package/dist/runtime/relay-worker-supervisor.js

@@ -92,33 +92,6 @@ function parseRequestIdFromRaw(raw) {
   return normalizeRequestId((parseFrame(raw) || {}).requestId);
 }
 
-function formatUpdatePluginResult(requestId, result) {
-  const payload = { type: APP_PROTOCOL.updatePluginResult };
-  if (requestId) payload.requestId = requestId;
-  if (result && result.ok === true) {
-    payload.ok = true;
-  } else {
-    payload.ok = false;
-    if (result && typeof result.reason === "string") payload.reason = result.reason;
-    if (result && typeof result.exitCode === "number") payload.exitCode = result.exitCode;
-    if (result && typeof result.stderrTail === "string" && result.stderrTail.length > 0) {
-      payload.stderrTail = result.stderrTail;
-    }
-  }
-  return JSON.stringify(payload);
-}
-
-function formatRestartGatewayAck(requestId, result) {
-  const payload = {
-    type: APP_PROTOCOL.restartGatewayAck,
-    ok: !!(result && result.ok),
-    started: !!(result && result.started),
-  };
-  if (requestId) payload.requestId = requestId;
-  if (result && typeof result.reason === "string") payload.reason = result.reason;
-  return JSON.stringify(payload);
-}
-
 export function createRelayWorkerSupervisor(options = {}) {
   const logger = normalizeLogger(options.logger);
   const handler = options.handler || options.downstreamHandler || null;
@@ -546,57 +519,17 @@ export function createRelayWorkerSupervisor(options = {}) {
       logger.warn(`[relay-worker] ${message.message || "worker error"}`);
       return;
     }
+    if (message.kind === "worker.log") {
+      // Worker-thread console output never reaches the gateway's structured
+      // log file, so the worker forwards its log lines here instead.
+      const level =
+        message.level === "warn" || message.level === "error" || message.level === "debug"
+          ? message.level
+          : "info";
+      logger[level](typeof message.message === "string" ? message.message : String(message.message));
+      return;
+    }
     if (message.kind === "app.message") {
-      if (message.operation === APP_PROTOCOL.updatePlugin) {
-        if (typeof options.runPluginUpdate !== "function") {
-          logger.warn("[relay-worker] updatePlugin requested but no runPluginUpdate is configured");
-          return;
-        }
-        const requestId = parseRequestIdFromRaw(message.raw);
-        (async () => {
-          try {
-            const result = await Promise.resolve(options.runPluginUpdate());
-            postMainFrame("unicast", formatUpdatePluginResult(requestId, result), message.clientId);
-          } catch (err) {
-            logger.error(
-              `[relay-worker] updatePlugin threw: ${err && err.message ? err.message : err}`,
-            );
-            postMainFrame(
-              "unicast",
-              formatUpdatePluginResult(requestId, { ok: false, reason: "spawn_failed" }),
-              message.clientId,
-            );
-          }
-        })();
-        return;
-      }
-      if (message.operation === APP_PROTOCOL.restartGateway) {
-        if (typeof options.runGatewayRestart !== "function") {
-          logger.warn("[relay-worker] restartGateway requested but no runGatewayRestart is configured");
-          return;
-        }
-        const requestId = parseRequestIdFromRaw(message.raw);
-        (async () => {
-          try {
-            const result = await Promise.resolve(options.runGatewayRestart());
-            postMainFrame("unicast", formatRestartGatewayAck(requestId, result), message.clientId);
-          } catch (err) {
-            logger.error(
-              `[relay-worker] restartGateway threw: ${err && err.message ? err.message : err}`,
-            );
-            postMainFrame(
-              "unicast",
-              formatRestartGatewayAck(requestId, {
-                ok: false,
-                started: false,
-                reason: "spawn_failed",
-              }),
-              message.clientId,
-            );
-          }
-        })();
-        return;
-      }
       if (!handler || typeof handler.handleMessage !== "function") return;
       const processOptions = {};
       if (message.operation === "message.send" && message.requestId) {
@@ -658,7 +591,7 @@ export function createRelayWorkerSupervisor(options = {}) {
         clientName: message.clientName || null,
         clientVersion: message.clientVersion || null,
         sessionKey: message.sessionKey || null,
-        readinessSnapshot: message.readinessSnapshot || null,
+        readinessSnapshot: normalizeIngestedReadinessSnapshot(message.readinessSnapshot),
         connectedAtMs: Number.isFinite(message.connectedAtMs)
           ? message.connectedAtMs
           : Date.now(),
@@ -758,7 +691,7 @@ export function createRelayWorkerSupervisor(options = {}) {
     if (message.kind === "client.readinessSnapshot") {
       const entry = clients.get(message.clientId);
       if (entry) {
-        entry.readinessSnapshot = message.readinessSnapshot || null;
+        entry.readinessSnapshot = normalizeIngestedReadinessSnapshot(message.readinessSnapshot);
         entry.updatedAtMs = Number.isFinite(message.updatedAtMs)
           ? message.updatedAtMs
           : Date.now();
@@ -772,6 +705,21 @@ export function createRelayWorkerSupervisor(options = {}) {
       const pending = requestId ? pendingReadinessProbeRequests.get(requestId) : null;
       if (!pending || pending.targetClientId !== message.clientId) return;
       pendingReadinessProbeRequests.delete(requestId);
+      // Probe acks carry the app's CURRENT activeSessionKey — ground truth.
+      // Refresh the registry entry with it: the app's standalone snapshot
+      // republication can race a reconnecting socket and get lost, leaving the
+      // hello-frozen key here until the next app boot (quirk 8's second layer).
+      if (ack && ack.ok !== false && typeof ack.activeSessionKey === "string" && ack.activeSessionKey) {
+        const ackEntry = clients.get(message.clientId);
+        if (ackEntry && ackEntry.readinessSnapshot) {
+          ackEntry.readinessSnapshot = {
+            ...ackEntry.readinessSnapshot,
+            activeSessionKey: ack.activeSessionKey,
+            emittedAtMs: Number.isFinite(ack.emittedAtMs) ? ack.emittedAtMs : Date.now(),
+          };
+          ackEntry.updatedAtMs = Date.now();
+        }
+      }
       const protocol = clients.get(message.clientId) || {};
       const frame =
         handler && typeof handler.formatReadinessProbeAck === "function"
@@ -988,6 +936,22 @@ export function createRelayWorkerSupervisor(options = {}) {
     });
   }
 
+  // The WebUI's reconnect hello embeds its readiness snapshot WITHOUT
+  // emittedAtMs (toProtocolHelloReadinessSnapshotJson omits it), but the
+  // automation-state gate requires a finite emittedAtMs to count the client
+  // as published. Stamp ingest time so a reconnect hello counts as a
+  // publication — otherwise every relay restart leaves `inspect state`
+  // returning snapshot_unavailable until the sim/app client is cycled.
+  function normalizeIngestedReadinessSnapshot(snapshot) {
+    if (!snapshot || typeof snapshot !== "object") {
+      return null;
+    }
+    if (Number.isFinite(snapshot.emittedAtMs)) {
+      return snapshot;
+    }
+    return { ...snapshot, emittedAtMs: Date.now() };
+  }
+
   function getReadinessSnapshot() {
     const appClients = getConnectedAppEntries();
     const updatedAtMs = appClients.reduce((latest, entry) => {

package/dist/runtime/relay-worker-transport.js

@@ -56,6 +56,36 @@ export function createRelayWorkerTransport(options = {}) {
   let httpServer = null;
   let wss = null;
   let nextClientId = 1;
+  // Invalid-token rejects are the one connection log an internet-facing
+  // misconfiguration could flood, so they are rate-limited per remote address.
+  const TOKEN_REJECT_LOG_WINDOW_MS = 60000;
+  const TOKEN_REJECT_LOG_MAX_ADDRESSES = 100;
+  const tokenRejectLogState = new Map();
+
+  function logTokenReject(remoteAddress) {
+    const at = now();
+    let state = tokenRejectLogState.get(remoteAddress);
+    if (!state) {
+      if (tokenRejectLogState.size >= TOKEN_REJECT_LOG_MAX_ADDRESSES) {
+        tokenRejectLogState.clear();
+      }
+      state = { lastLogAtMs: null, suppressedCount: 0 };
+      tokenRejectLogState.set(remoteAddress, state);
+    }
+    if (state.lastLogAtMs !== null && at - state.lastLogAtMs < TOKEN_REJECT_LOG_WINDOW_MS) {
+      state.suppressedCount += 1;
+      return;
+    }
+    const suffix =
+      state.suppressedCount > 0
+        ? ` (+${state.suppressedCount} more rejected from this address since last log)`
+        : "";
+    state.lastLogAtMs = at;
+    state.suppressedCount = 0;
+    logger.warn(
+      `[ocuclaw] relay rejected connection: invalid token remote=${remoteAddress}${suffix}`,
+    );
+  }
   let expireTimer = null;
   let healthTimer = null;
   let loopDelayMonitor = null;
@@ -894,11 +924,17 @@ export function createRelayWorkerTransport(options = {}) {
     });
     wss.on("connection", (ws, req) => {
       const requestUrl = new URL(req.url || "/", `http://${req.headers.host || "127.0.0.1"}`);
+      const remoteAddress = (req.socket && req.socket.remoteAddress) || "unknown";
       if (requestUrl.searchParams.get("token") !== manifest.relayToken) {
+        logTokenReject(remoteAddress);
         ws.close(4001, "invalid_token");
         return;
       }
       const clientId = `worker-client-${nextClientId++}`;
+      const connectedAtMs = now();
+      logger.info(
+        `[ocuclaw] relay client connected clientId=${clientId} remote=${remoteAddress}`,
+      );
       clients.set(clientId, ws);
       protocolState.set(clientId, {
         protocolVersion: null,
@@ -925,6 +961,11 @@ export function createRelayWorkerTransport(options = {}) {
             : Buffer.isBuffer(reason)
               ? reason.toString("utf8")
               : String(reason);
+        logger.info(
+          `[ocuclaw] relay client disconnected clientId=${clientId} remote=${remoteAddress} code=${
+            Number.isFinite(code) ? code : "none"
+          } lifetimeMs=${Math.max(0, now() - connectedAtMs)}`,
+        );
         postToMain({
           kind: "client.disconnected",
           clientId,