claudemesh-cli 1.34.15 → 1.34.18

package/dist/entrypoints/cli.js

@@ -104,7 +104,7 @@ __export(exports_urls, {
   VERSION: () => VERSION,
   URLS: () => URLS
 });
-var URLS, VERSION = "1.34.15", env;
+var URLS, VERSION = "1.34.18", env;
 var init_urls = __esm(() => {
   URLS = {
     BROKER: process.env.CLAUDEMESH_BROKER_URL ?? "wss://ic.claudemesh.com/ws",
@@ -10899,6 +10899,10 @@ function connectWsWithBackoff(opts) {
     status = s;
     opts.onStatusChange?.(s);
   };
+  const PING_INTERVAL_MS = 30000;
+  const STALE_THRESHOLD_MS = 75000;
+  let lastActivity = Date.now();
+  let watchdogTimer = null;
   const openOnce = () => {
     if (closed)
       return Promise.reject(new Error("client_closed"));
@@ -10906,6 +10910,7 @@ function connectWsWithBackoff(opts) {
     log2("info", "ws_open_attempt", { url: opts.url });
     const sock = new WebSocket2(opts.url);
     ws = sock;
+    lastActivity = Date.now();
     return new Promise((resolve, reject) => {
       sock.on("open", () => {
         log2("info", "ws_open_ok", { url: opts.url });
@@ -10928,6 +10933,7 @@ function connectWsWithBackoff(opts) {
         })();
       });
       sock.on("message", (raw) => {
+        lastActivity = Date.now();
         let msg;
         try {
           msg = JSON.parse(raw.toString());
@@ -10942,16 +10948,43 @@ function connectWsWithBackoff(opts) {
           setStatus("open");
           reconnectAttempt = 0;
           log2("info", "ws_hello_acked", { url: opts.url });
+          if (watchdogTimer)
+            clearInterval(watchdogTimer);
+          watchdogTimer = setInterval(() => {
+            if (sock.readyState !== sock.OPEN)
+              return;
+            const idle = Date.now() - lastActivity;
+            if (idle > STALE_THRESHOLD_MS) {
+              log2("warn", "ws_stale_terminate", { url: opts.url, idle_ms: idle });
+              try {
+                sock.terminate();
+              } catch {}
+              return;
+            }
+            try {
+              sock.ping();
+            } catch {}
+          }, PING_INTERVAL_MS);
           resolve();
           return;
         }
         opts.onMessage(msg);
       });
+      sock.on("ping", () => {
+        lastActivity = Date.now();
+      });
+      sock.on("pong", () => {
+        lastActivity = Date.now();
+      });
       sock.on("close", (code, reason) => {
         if (helloTimer) {
           clearTimeout(helloTimer);
           helloTimer = null;
         }
+        if (watchdogTimer) {
+          clearInterval(watchdogTimer);
+          watchdogTimer = null;
+        }
         const reasonStr = reason.toString("utf8");
         log2("warn", "ws_closed", { url: opts.url, code, reason: reasonStr, status });
         opts.onBeforeReconnect?.(code, reasonStr);
@@ -10995,6 +11028,10 @@ function connectWsWithBackoff(opts) {
           clearTimeout(helloTimer);
           helloTimer = null;
         }
+        if (watchdogTimer) {
+          clearInterval(watchdogTimer);
+          watchdogTimer = null;
+        }
         try {
           ws?.close();
         } catch {}
@@ -11994,24 +12031,28 @@ var init_inbound = __esm(() => {
 // src/daemon/identity.ts
 var exports_identity = {};
 __export(exports_identity, {
+  pickStableMacFromInterfaces: () => pickStableMacFromInterfaces,
+  fingerprintV2: () => fingerprintV2,
   computeCurrentFingerprint: () => computeCurrentFingerprint,
   checkFingerprint: () => checkFingerprint,
-  acceptCurrentHost: () => acceptCurrentHost
+  acceptCurrentHost: () => acceptCurrentHost,
+  __resetHostIdCacheForTests: () => __resetHostIdCacheForTests,
+  __computeV1FingerprintForTests: () => __computeV1FingerprintForTests
 });
 import { existsSync as existsSync11, readFileSync as readFileSync9, writeFileSync as writeFileSync10 } from "node:fs";
 import { join as join7 } from "node:path";
 import { createHash as createHash2 } from "node:crypto";
+import { execFileSync } from "node:child_process";
 import { networkInterfaces } from "node:os";
 function path() {
   return join7(DAEMON_PATHS.DAEMON_DIR, FILE_NAME);
 }
 function computeCurrentFingerprint() {
-  const host_id = readHostId() ?? "";
-  const stable_mac = pickStableMac() ?? "";
-  const fp = createHash2("sha256").update(host_id, "utf8").update("\x00").update(stable_mac, "utf8").digest("hex");
+  const host_id = readHostIdV2() ?? "";
+  const stable_mac = pickStableMacFromInterfaces(networkInterfaces()) ?? "";
   return {
-    schema_version: 1,
-    fingerprint: fp,
+    schema_version: CURRENT_SCHEMA,
+    fingerprint: fingerprintV2(host_id, stable_mac),
     host_id,
     stable_mac,
     written_at: new Date().toISOString()
@@ -12029,16 +12070,74 @@ function checkFingerprint() {
   } catch {
     return { result: "unavailable", current };
   }
-  if (stored.fingerprint === current.fingerprint)
-    return { result: "match", current, stored };
-  return { result: "mismatch", current, stored };
+  if (stored.schema_version === 2) {
+    if (stored.fingerprint === current.fingerprint)
+      return { result: "match", current, stored };
+    if (stored.host_id && stored.host_id === current.host_id) {
+      writeFileSync10(path(), JSON.stringify(current, null, 2), { mode: 384 });
+      return { result: "match", current, stored };
+    }
+    return { result: "mismatch", current, stored };
+  }
+  if (stored.schema_version === 1) {
+    const v1 = computeCurrentFingerprintV1();
+    if (stored.fingerprint === v1.fingerprint) {
+      writeFileSync10(path(), JSON.stringify(current, null, 2), { mode: 384 });
+      return { result: "match", current, stored };
+    }
+    return { result: "mismatch", current, stored };
+  }
+  return { result: "unavailable", current };
 }
 function acceptCurrentHost() {
   const current = computeCurrentFingerprint();
   writeFileSync10(path(), JSON.stringify(current, null, 2), { mode: 384 });
   return current;
 }
-function readHostId() {
+function fingerprintV2(host_id, stable_mac) {
+  return createHash2("sha256").update("v2", "utf8").update("\x00").update(host_id, "utf8").update("\x00").update(stable_mac, "utf8").digest("hex");
+}
+function pickStableMacFromInterfaces(ifs) {
+  const hardware = [];
+  const fallback = [];
+  for (const [name, addrs] of Object.entries(ifs)) {
+    if (!addrs)
+      continue;
+    if (isIgnoredInterface(name))
+      continue;
+    for (const a of addrs) {
+      if (a.internal)
+        continue;
+      if (!a.mac || a.mac === "00:00:00:00:00:00")
+        continue;
+      const entry = { name, mac: a.mac };
+      if (isLocallyAdministered(a.mac)) {
+        fallback.push(entry);
+      } else {
+        hardware.push(entry);
+      }
+      break;
+    }
+  }
+  const pool = hardware.length > 0 ? hardware : fallback;
+  if (pool.length === 0)
+    return null;
+  pool.sort((a, b) => a.name.localeCompare(b.name));
+  return pool[0].mac;
+}
+function computeCurrentFingerprintV1() {
+  const host_id = readHostIdV1() ?? "";
+  const stable_mac = pickStableMacV1() ?? "";
+  const fp = createHash2("sha256").update(host_id, "utf8").update("\x00").update(stable_mac, "utf8").digest("hex");
+  return {
+    schema_version: 1,
+    fingerprint: fp,
+    host_id,
+    stable_mac,
+    written_at: new Date().toISOString()
+  };
+}
+function readHostIdV1() {
   if (process.platform === "linux") {
     for (const p of ["/etc/machine-id", "/var/lib/dbus/machine-id"]) {
       try {
@@ -12049,18 +12148,15 @@ function readHostId() {
     }
     return null;
   }
-  if (process.platform === "darwin") {
-    return null;
-  }
   return null;
 }
-function pickStableMac() {
+function pickStableMacV1() {
   const ifs = networkInterfaces();
   const candidates = [];
   for (const [name, addrs] of Object.entries(ifs)) {
     if (!addrs)
       continue;
-    if (isIgnoredInterface(name))
+    if (isIgnoredInterfaceV1(name))
       continue;
     for (const a of addrs) {
       if (a.internal)
@@ -12078,10 +12174,57 @@ function pickStableMac() {
   const idx = first.indexOf("::");
   return idx >= 0 ? first.slice(idx + 2) : first;
 }
-function isIgnoredInterface(name) {
+function isIgnoredInterfaceV1(name) {
   return /^(lo|docker|br-|veth|tap|tun|tailscale|wg|utun|ppp|vboxnet|vmnet|awdl|llw)/i.test(name);
 }
-var FILE_NAME = "host_fingerprint.json";
+function readHostIdV2() {
+  if (cachedHostIdV2 !== undefined)
+    return cachedHostIdV2;
+  cachedHostIdV2 = readHostIdV2Uncached();
+  return cachedHostIdV2;
+}
+function readHostIdV2Uncached() {
+  if (process.platform === "linux") {
+    for (const p of ["/etc/machine-id", "/var/lib/dbus/machine-id"]) {
+      try {
+        const raw = readFileSync9(p, "utf8").trim();
+        if (raw)
+          return `linux:${raw}`;
+      } catch {}
+    }
+    return null;
+  }
+  if (process.platform === "darwin") {
+    try {
+      const out = execFileSync("/usr/sbin/ioreg", ["-rd1", "-c", "IOPlatformExpertDevice"], {
+        encoding: "utf8",
+        timeout: 2000,
+        stdio: ["ignore", "pipe", "ignore"]
+      });
+      const m = out.match(/"IOPlatformUUID"\s*=\s*"([0-9A-Fa-f-]+)"/);
+      if (m && m[1])
+        return `darwin:${m[1]}`;
+    } catch {}
+    return null;
+  }
+  return null;
+}
+function isLocallyAdministered(mac) {
+  const firstByte = parseInt(mac.split(":")[0] ?? "0", 16);
+  if (Number.isNaN(firstByte))
+    return false;
+  return (firstByte & 2) !== 0;
+}
+function isIgnoredInterface(name) {
+  return /^(lo|docker|br-|bridge|veth|tap|tun|tailscale|wg|utun|ppp|vboxnet|vmnet|awdl|llw|anpi|ap\d)/i.test(name);
+}
+function __resetHostIdCacheForTests() {
+  cachedHostIdV2 = undefined;
+}
+function __computeV1FingerprintForTests() {
+  return computeCurrentFingerprintV1();
+}
+var FILE_NAME = "host_fingerprint.json", CURRENT_SCHEMA = 2, cachedHostIdV2;
 var init_identity = __esm(() => {
   init_paths2();
 });
@@ -21249,4 +21392,4 @@ main().catch((err) => {
   process.exit(EXIT.INTERNAL_ERROR);
 });
 
-//# debugId=89AC9B5F79C7438764756E2164756E21
+//# debugId=C8B9D377DC161E3E64756E2164756E21