@p697/clawket 0.6.0 → 0.6.2

package/dist/index.js

@@ -1447,6 +1447,7 @@ var HermesLocalBridge = class {
   hermesChild = null;
   modelStateCache = null;
   contextWindowCache = /* @__PURE__ */ new Map();
+  bridgeRequestSeq = 0;
   constructor(options = {}) {
     this.options = options;
     this.host = normalizeHost(options.host);
@@ -1491,6 +1492,12 @@ var HermesLocalBridge = class {
     if (this.httpServer) {
       return;
     }
+    this.logPerf("bridge_start_begin", {
+      apiBaseUrl: this.apiBaseUrl,
+      host: this.host,
+      port: this.port
+    });
+    const startStartedAt = Date.now();
     const hermesReady = await this.ensureHermesApiReady();
     this.httpServer = createServer((req, res) => {
       void this.handleHttpRequest(req, res);
@@ -1534,6 +1541,11 @@ var HermesLocalBridge = class {
       prewarmComplete: true,
       lastError: hermesReady ? null : this.snapshot.lastError
     });
+    this.logPerf("bridge_start_ready", {
+      elapsedMs: Date.now() - startStartedAt,
+      hermesReady,
+      hermesApiReachable: this.snapshot.hermesApiReachable
+    });
     this.log(hermesReady ? `hermes bridge listening on ${this.snapshot.bridgeUrl}` : `hermes bridge listening on ${this.snapshot.bridgeUrl} (degraded: Hermes API not ready yet)`);
   }
   async stop() {
@@ -1575,21 +1587,39 @@ var HermesLocalBridge = class {
     });
   }
   async ensureHermesApiReady() {
+    const startedAt = Date.now();
     if (await probeHermesApi(this.apiBaseUrl, this.apiKey)) {
       this.updateSnapshot({ hermesApiReachable: true, lastError: null });
+      this.logPerf("hermes_api_probe", {
+        result: "warm",
+        elapsedMs: Date.now() - startedAt
+      });
       this.log(`reusing Hermes API already running at ${this.apiBaseUrl}`);
       return true;
     }
     if (this.options.startHermesIfNeeded === false) {
       const error = `Hermes API is not reachable at ${this.apiBaseUrl}. Start Hermes gateway with API server enabled and retry.`;
       this.updateSnapshot({ hermesApiReachable: false, lastError: error });
+      this.logPerf("hermes_api_probe", {
+        result: "unreachable_no_autostart",
+        elapsedMs: Date.now() - startedAt
+      });
       this.log(error);
       return false;
     }
+    this.logPerf("hermes_api_probe", {
+      result: "cold_start_required",
+      elapsedMs: Date.now() - startedAt
+    });
     return this.startHermesGatewayProcess();
   }
   async startHermesGatewayProcess() {
     const command = this.options.hermesCommand?.trim() || "hermes";
+    const startedAt = Date.now();
+    this.logPerf("hermes_api_cold_start_begin", {
+      command,
+      apiBaseUrl: this.apiBaseUrl
+    });
     this.log(`starting hermes gateway via ${command}`);
     const verboseHermesStdio = process.env.CLAWKET_HERMES_VERBOSE === "1";
     const hermesChildEnv = {
@@ -1624,12 +1654,19 @@ var HermesLocalBridge = class {
     while (Date.now() - startMs < HERMES_BOOT_TIMEOUT_MS) {
       if (await probeHermesApi(this.apiBaseUrl, this.apiKey)) {
         this.updateSnapshot({ hermesApiReachable: true, lastError: null });
+        this.logPerf("hermes_api_cold_start_ready", {
+          elapsedMs: Date.now() - startedAt
+        });
         return true;
       }
       await delay2(500);
     }
     const error = `Hermes API did not become ready within ${HERMES_BOOT_TIMEOUT_MS}ms at ${this.apiBaseUrl}.`;
     this.updateSnapshot({ hermesApiReachable: false, lastError: error });
+    this.logPerf("hermes_api_cold_start_timeout", {
+      elapsedMs: Date.now() - startedAt,
+      timeoutMs: HERMES_BOOT_TIMEOUT_MS
+    });
     this.log(error);
     return false;
   }
@@ -1647,6 +1684,8 @@ var HermesLocalBridge = class {
     });
   }
   async prewarmBridgeState() {
+    const startedAt = Date.now();
+    this.logPerf("bridge_prewarm_begin");
     const tasks = [
       () => {
         this.listHermesSessions(24);
@@ -1665,6 +1704,9 @@ var HermesLocalBridge = class {
         this.log(`bridge prewarm skipped: ${formatError2(error)}`);
       }
     }));
+    this.logPerf("bridge_prewarm_done", {
+      elapsedMs: Date.now() - startedAt
+    });
   }
   async handleHttpRequest(req, res) {
     const pathname = readRequestPathname(req.url);
@@ -1739,23 +1781,34 @@ var HermesLocalBridge = class {
   }
   async dispatchRequest(method, params) {
     const payload = isRecord(params) ? params : {};
+    const shouldTracePerf = method === "health" || method === "last-heartbeat" || method === "sessions.list" || method === "chat.history" || method === "chat.send" || method === "models.list" || method === "model.current" || method === "model.get";
+    const requestStartedAt = shouldTracePerf ? Date.now() : 0;
+    const requestSeq = shouldTracePerf ? ++this.bridgeRequestSeq : 0;
+    if (shouldTracePerf) {
+      this.logPerf("bridge_request_begin", {
+        requestSeq,
+        method,
+        sessionKey: readString(payload.sessionKey) || void 0,
+        limit: readPositiveInt(payload.limit, 0) || void 0
+      });
+    }
     switch (method) {
       case "health":
       case "last-heartbeat":
-        return {
+        return this.traceBridgeRequest(method, requestStartedAt, requestSeq, {
           status: this.snapshot.hermesApiReachable ? "ok" : "degraded",
           ts: Date.now(),
           hermesApiReachable: this.snapshot.hermesApiReachable
-        };
+        });
       case "sessions.list":
-        return {
+        return this.traceBridgeRequest(method, requestStartedAt, requestSeq, {
           defaults: this.getHermesSessionListDefaults(),
           sessions: this.listHermesSessions(readPositiveInt(payload.limit, 100))
-        };
+        });
       case "chat.history":
-        return this.getHermesSessionHistory(readString(payload.sessionKey) || DEFAULT_SESSION_ID, readPositiveInt(payload.limit, 50));
+        return this.traceBridgeRequest(method, requestStartedAt, requestSeq, this.getHermesSessionHistory(readString(payload.sessionKey) || DEFAULT_SESSION_ID, readPositiveInt(payload.limit, 50)));
       case "chat.send":
-        return this.handleChatSend(payload);
+        return this.traceBridgeRequest(method, requestStartedAt, requestSeq, this.handleChatSend(payload));
       case "sessions.reset":
         this.cancelActiveRunsForSession(readString(payload.key) || DEFAULT_SESSION_ID);
         this.sessionStore.resetSession(readString(payload.key) || DEFAULT_SESSION_ID);
@@ -1875,6 +1928,17 @@ var HermesLocalBridge = class {
         throw new Error(`Unsupported Hermes bridge method: ${method}`);
     }
   }
+  async traceBridgeRequest(method, startedAt, requestSeq, value) {
+    const result = await value;
+    if (startedAt > 0) {
+      this.logPerf("bridge_request", {
+        requestSeq,
+        method,
+        elapsedMs: Date.now() - startedAt
+      });
+    }
+    return result;
+  }
   async handleChatSend(payload) {
     const sessionKey = readString(payload.sessionKey) || DEFAULT_SESSION_ID;
     const text = readString(payload.message);
@@ -4659,6 +4723,10 @@ var HermesLocalBridge = class {
   log(line) {
     this.options.onLog?.(line);
   }
+  logPerf(event, fields) {
+    const payload = fields ? Object.entries(fields).filter(([, value]) => value !== void 0).map(([key, value]) => `${key}=${String(value)}`).join(" ") : "";
+    this.log(`[perf] ${event}${payload ? ` ${payload}` : ""}`);
+  }
   async hydrateToolOutputsFromHermesState(params) {
     const toolOutputs = this.readHermesToolOutputsFromLocalState(params.sessionId, params.runStartedAtMs);
     if (toolOutputs.length === 0 || params.completedTools.length === 0) {
@@ -5943,10 +6011,29 @@ var HermesRelayRuntime = class {
     if (text == null)
       return;
     if (text.startsWith(RELAY_CONTROL_PREFIX)) {
+      this.handleRelayControl(text);
       return;
     }
     this.forwardOrQueueBridgeMessage({ text });
   }
+  handleRelayControl(text) {
+    try {
+      const parsed = JSON.parse(text.slice(RELAY_CONTROL_PREFIX.length));
+      if (parsed?.event !== "gateway_ping") {
+        return;
+      }
+      const relay = this.relaySocket;
+      if (!relay || relay.readyState !== WebSocket2.OPEN) {
+        return;
+      }
+      relay.send(`${RELAY_CONTROL_PREFIX}${JSON.stringify({
+        type: "control",
+        event: "gateway_pong",
+        ts: typeof parsed.ts === "number" ? parsed.ts : Date.now()
+      })}`);
+    } catch {
+    }
+  }
   handleBridgeMessage(data, isBinary) {
     const relay = this.relaySocket;
     if (isBinary) {
@@ -6065,9 +6152,8 @@ var HermesRelayRuntime = class {
       } else {
         const payload = await response.json();
         if (!payload?.hasBridge) {
-          this.log("bridge status probe reported hasBridge=false; restarting relay socket");
-          this.relaySocket?.close();
-          this.bridgeSocket?.close();
+          this.log("bridge status probe reported hasBridge=false; recycling relay socket");
+          this.recycleRelaySocket("bridge status probe reported hasBridge=false");
           return;
         }
       }
@@ -6157,6 +6243,26 @@ var HermesRelayRuntime = class {
     clearTimeout(this.pendingBridgeHealthProbe.timeout);
     this.pendingBridgeHealthProbe = null;
   }
+  recycleRelaySocket(reason) {
+    const relay = this.relaySocket;
+    if (!relay)
+      return;
+    this.relaySocket = null;
+    this.clearBridgeStatusProbe();
+    this.clearPendingBridgeHealthProbe();
+    this.updateSnapshot({
+      relayConnected: false,
+      bridgeConnected: this.bridgeSocket?.readyState === WebSocket2.OPEN,
+      lastError: reason
+    });
+    try {
+      relay.close();
+    } catch {
+    }
+    if (!this.stopped) {
+      this.scheduleRelayReconnect();
+    }
+  }
   isRelayOpen() {
     return this.relaySocket?.readyState === WebSocket2.OPEN;
   }
@@ -9162,6 +9268,7 @@ function decidePairServiceAction(paired, service) {
 }
 
 // apps/bridge-cli/src/index.ts
+var HERMES_SERVICE_WATCHDOG_INTERVAL_MS = 3e4;
 async function main() {
   const [, , command = "help", ...args] = process.argv;
   const isServiceMode = hasFlag(args, "--service");
@@ -9339,6 +9446,9 @@ async function main() {
       instanceId: config.instanceId,
       serviceMode: isServiceMode
     });
+    const hermesServiceWatchdog = isServiceMode ? startHermesServiceWatchdog((line) => {
+      emitRuntimeLine(`[hermes-service] ${line}`);
+    }) : null;
     if (isServiceMode) {
       await restoreHermesServiceRuntime((line) => {
         emitRuntimeLine(`[hermes-service] ${line}`);
@@ -9348,6 +9458,9 @@ async function main() {
       process.off("SIGINT", shutdown);
       process.off("SIGTERM", shutdown);
       await runtime.stop();
+      if (hermesServiceWatchdog) {
+        clearInterval(hermesServiceWatchdog);
+      }
       unregisterRuntimeProcess(process.pid);
       if (isServiceMode) {
         clearServiceState(process.pid);
@@ -9820,6 +9933,8 @@ async function performHermesLocalPairing(args) {
   };
 }
 async function performHermesRelayPairing(args) {
+  const pairingStartedAt = Date.now();
+  logHermesPerf("pair_relay_begin");
   const server = resolvePairServer(args, "hermes");
   const name = readFlag(args, "--name") ?? readFlag(args, "-n") ?? "Hermes";
   const qrFile = readFlag(args, "--qr-file");
@@ -9827,6 +9942,10 @@ async function performHermesRelayPairing(args) {
     serverUrl: server,
     displayName: name
   });
+  logHermesPerf("pair_relay_registered", {
+    elapsedMs: Date.now() - pairingStartedAt,
+    action: paired.action
+  });
   const qrImagePath = await writeRawQrPng(paired.qrPayload, "clawket-hermes-relay-pair", qrFile);
   if (paired.action === "registered") {
     const stalePids = listHermesRelayRuntimePids2();
@@ -9835,6 +9954,9 @@ async function performHermesRelayPairing(args) {
     }
   }
   const runtimeMessage = await ensureHermesRelayBackgroundRuntime(args);
+  logHermesPerf("pair_relay_ready", {
+    elapsedMs: Date.now() - pairingStartedAt
+  });
   return {
     backend: "hermes",
     transport: "relay",
@@ -10192,6 +10314,16 @@ async function keepHermesBridgeAlive(bridge) {
   });
 }
 async function restoreHermesServiceRuntime(log) {
+  await restoreHermesServiceRuntimeInternal(log, { silentIfHealthy: false });
+}
+function startHermesServiceWatchdog(log) {
+  const timer = setInterval(() => {
+    void restoreHermesServiceRuntimeInternal(log, { silentIfHealthy: true });
+  }, HERMES_SERVICE_WATCHDOG_INTERVAL_MS);
+  timer.unref?.();
+  return timer;
+}
+async function restoreHermesServiceRuntimeInternal(log, options) {
   const bridgeConfig = readHermesBridgeCliConfig();
   const relayConfig = readHermesRelayConfig();
   if (!bridgeConfig && !relayConfig) {
@@ -10206,9 +10338,11 @@ async function restoreHermesServiceRuntime(log) {
       config: bridgeConfig,
       replaceExisting: false
     });
-    log(
-      bridgePid == null ? "Hermes bridge runtime already running." : `Started Hermes bridge runtime (pid ${bridgePid}).`
-    );
+    if (bridgePid != null || !options.silentIfHealthy) {
+      log(
+        bridgePid == null ? "Hermes bridge runtime already running." : `Started Hermes bridge runtime (pid ${bridgePid}).`
+      );
+    }
   } catch (error) {
     log(`Hermes bridge restore failed: ${formatError3(error)}`);
     return;
@@ -10222,9 +10356,11 @@ async function restoreHermesServiceRuntime(log) {
       config: bridgeConfig,
       replaceExisting: false
     });
-    log(
-      relayPid == null ? "Hermes relay runtime already running." : `Started Hermes relay runtime (pid ${relayPid}).`
-    );
+    if (relayPid != null || !options.silentIfHealthy) {
+      log(
+        relayPid == null ? "Hermes relay runtime already running." : `Started Hermes relay runtime (pid ${relayPid}).`
+      );
+    }
   } catch (error) {
     log(`Hermes relay restore failed: ${formatError3(error)}`);
   }
@@ -10265,6 +10401,8 @@ async function keepHermesRelayRuntimeAlive(runtime) {
   });
 }
 async function ensureHermesRelayBackgroundRuntime(args) {
+  const startedAt = Date.now();
+  logHermesPerf("relay_runtime_ensure_begin");
   const relayConfig = readHermesRelayConfig();
   if (!relayConfig) {
     throw new Error("Hermes relay is not paired.");
@@ -10272,6 +10410,10 @@ async function ensureHermesRelayBackgroundRuntime(args) {
   const relayPids = listHermesRelayRuntimePids2();
   if (relayPids.length === 1) {
     await waitForHermesRelayCloudBridgeReady(relayConfig, 2e4);
+    logHermesPerf("relay_runtime_ensure_reused", {
+      elapsedMs: Date.now() - startedAt,
+      pid: relayPids[0]
+    });
     return `Hermes relay runtime already running (pid ${relayPids[0]}) and confirmed by relay.`;
   }
   if (relayPids.length > 1) {
@@ -10290,8 +10432,15 @@ async function ensureHermesRelayBackgroundRuntime(args) {
   await waitForHermesRelayCloudBridgeReady(relayConfig, 2e4);
   const startedPids = listHermesRelayRuntimePids2();
   if (startedPids.length === 0) {
+    logHermesPerf("relay_runtime_ensure_requested_no_pid", {
+      elapsedMs: Date.now() - startedAt
+    });
     return "Hermes relay runtime launch was requested. Run `clawket hermes relay run` manually if it did not stay up.";
   }
+  logHermesPerf("relay_runtime_ensure_started", {
+    elapsedMs: Date.now() - startedAt,
+    pid: startedPids[0]
+  });
   return `Auto-started Hermes relay runtime (pid ${startedPids[0]}) and confirmed cloud bridge attachment.`;
 }
 async function ensureHermesBridgeBackgroundRuntime(input) {
@@ -10506,6 +10655,8 @@ function resolveRequestedPairBackend(args) {
   throw new Error(`Unsupported local pairing backend "${backend}". Use --backend openclaw or --backend hermes.`);
 }
 async function ensureHermesPairingRuntimeReady(args) {
+  const startedAt = Date.now();
+  logHermesPerf("pairing_runtime_ready_begin");
   const saved = readHermesBridgeCliConfig();
   const host = readFlag(args, "--host") ?? saved?.host ?? "0.0.0.0";
   const port = Number(readFlag(args, "--port") ?? saved?.port ?? "4319");
@@ -10513,7 +10664,12 @@ async function ensureHermesPairingRuntimeReady(args) {
   const token = readFlag(args, "--token") ?? process.env.CLAWKET_HERMES_BRIDGE_TOKEN ?? saved?.token ?? randomUUID5();
   const existingBridgePids = listHermesBridgeRuntimePids2();
   if (existingBridgePids.length > 0) {
-    return await resolveExistingHermesPairingRuntime(saved);
+    const resolved = await resolveExistingHermesPairingRuntime(saved);
+    logHermesPerf("pairing_runtime_ready_reused", {
+      elapsedMs: Date.now() - startedAt,
+      port: resolved.port
+    });
+    return resolved;
   }
   if (!existsSync7(resolveDefaultHermesSourcePath())) {
     throw new Error(
@@ -10528,6 +10684,10 @@ async function ensureHermesPairingRuntimeReady(args) {
     restartHermes: hasFlag(args, "--restart-hermes")
   });
   await waitForHermesBridgeHealth(port);
+  logHermesPerf("pairing_runtime_ready_started", {
+    elapsedMs: Date.now() - startedAt,
+    port
+  });
   return { host, port, apiBaseUrl, token };
 }
 async function resolveExistingHermesPairingRuntime(saved) {
@@ -10602,17 +10762,27 @@ function startDetachedHermesRelayRuntime(input) {
   child.unref();
 }
 async function waitForHermesBridgeHealth(port, timeoutMs = 15e3) {
+  const startedAt = Date.now();
   const deadline = Date.now() + timeoutMs;
   while (Date.now() < deadline) {
     try {
       const health = await readHermesBridgeHealth2(port);
       if (health.ok && health.running) {
+        logHermesPerf("bridge_health_ready", {
+          elapsedMs: Date.now() - startedAt,
+          port
+        });
         return;
       }
     } catch {
     }
     await new Promise((resolve4) => setTimeout(resolve4, 250));
   }
+  logHermesPerf("bridge_health_timeout", {
+    elapsedMs: Date.now() - startedAt,
+    port,
+    timeoutMs
+  });
   throw new Error(`Hermes bridge did not become ready at http://127.0.0.1:${port}/health within ${timeoutMs}ms.`);
 }
 async function readHermesBridgeHealth2(port) {
@@ -10664,6 +10834,7 @@ async function waitForHermesRelayRuntimeReady(startedAtMs, timeoutMs) {
   }
 }
 async function waitForHermesRelayCloudBridgeReady(relayConfig, timeoutMs) {
+  const startedAt = Date.now();
   const statusUrl = buildHermesRelayBridgeStatusUrl2(relayConfig.relayUrl, relayConfig.bridgeId);
   const deadline = Date.now() + timeoutMs;
   let lastError = null;
@@ -10678,6 +10849,9 @@ async function waitForHermesRelayCloudBridgeReady(relayConfig, timeoutMs) {
       if (response.ok) {
         const payload = await response.json();
         if (payload?.hasBridge) {
+          logHermesPerf("relay_cloud_bridge_ready", {
+            elapsedMs: Date.now() - startedAt
+          });
           return;
         }
       } else {
@@ -10688,6 +10862,10 @@ async function waitForHermesRelayCloudBridgeReady(relayConfig, timeoutMs) {
     }
     await sleep(500);
   }
+  logHermesPerf("relay_cloud_bridge_timeout", {
+    elapsedMs: Date.now() - startedAt,
+    timeoutMs
+  });
   throw new Error(
     `Hermes relay did not observe the local bridge for ${relayConfig.bridgeId} within ${timeoutMs}ms` + (lastError ? ` (${lastError}).` : ".")
   );
@@ -10768,6 +10946,11 @@ function formatLocalTime(iso) {
 function formatError3(error) {
   return error instanceof Error ? error.message : String(error);
 }
+function logHermesPerf(event, fields) {
+  const payload = fields ? Object.entries(fields).filter(([, value]) => value !== void 0).map(([key, value]) => `${key}=${String(value)}`).join(" ") : "";
+  void event;
+  void payload;
+}
 async function followCliLogs(input) {
   const sources = getCliLogSourcePaths(input.includeErrorLog);
   const state = /* @__PURE__ */ new Map();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@p697/clawket",
-  "version": "0.6.0",
+  "version": "0.6.2",
   "private": false,
   "type": "module",
   "license": "AGPL-3.0-only",