claudemesh-cli 1.29.0 → 1.30.0

package/dist/entrypoints/cli.js

@@ -92,7 +92,8 @@ var init_exit_codes = __esm(() => {
     ALREADY_EXISTS: 6,
     PERMISSION_DENIED: 7,
     INTERNAL_ERROR: 8,
-    CLAUDE_MISSING: 9
+    CLAUDE_MISSING: 9,
+    IO_ERROR: 10
   };
 });
 
@@ -103,7 +104,7 @@ __export(exports_urls, {
   VERSION: () => VERSION,
   URLS: () => URLS
 });
-var URLS, VERSION = "1.29.0", env;
+var URLS, VERSION = "1.30.0", env;
 var init_urls = __esm(() => {
   URLS = {
     BROKER: process.env.CLAUDEMESH_BROKER_URL ?? "wss://ic.claudemesh.com/ws",
@@ -3941,6 +3942,38 @@ var init_lifecycle = __esm(() => {
   init_paths2();
 });
 
+// src/services/broker/session-hello-sig.ts
+var exports_session_hello_sig = {};
+__export(exports_session_hello_sig, {
+  signSessionHello: () => signSessionHello,
+  signParentAttestation: () => signParentAttestation,
+  DEFAULT_ATTESTATION_TTL_MS: () => DEFAULT_ATTESTATION_TTL_MS
+});
+async function signParentAttestation(args) {
+  const s = await ensureSodium();
+  const expiresAt = (args.now ?? Date.now()) + (args.ttlMs ?? DEFAULT_ATTESTATION_TTL_MS);
+  const canonical = `claudemesh-session-attest|${args.parentMemberPubkey}|${args.sessionPubkey}|${expiresAt}`;
+  const sig = s.crypto_sign_detached(s.from_string(canonical), s.from_hex(args.parentSecretKey));
+  return {
+    sessionPubkey: args.sessionPubkey,
+    parentMemberPubkey: args.parentMemberPubkey,
+    expiresAt,
+    signature: s.to_hex(sig)
+  };
+}
+async function signSessionHello(args) {
+  const s = await ensureSodium();
+  const timestamp2 = args.now ?? Date.now();
+  const canonical = `claudemesh-session-hello|${args.meshId}|${args.parentMemberPubkey}|${args.sessionPubkey}|${timestamp2}`;
+  const sig = s.crypto_sign_detached(s.from_string(canonical), s.from_hex(args.sessionSecretKey));
+  return { timestamp: timestamp2, signature: s.to_hex(sig) };
+}
+var DEFAULT_ATTESTATION_TTL_MS;
+var init_session_hello_sig = __esm(() => {
+  init_keypair();
+  DEFAULT_ATTESTATION_TTL_MS = 12 * 60 * 60 * 1000;
+});
+
 // src/commands/launch.ts
 var exports_launch = {};
 __export(exports_launch, {
@@ -4344,6 +4377,8 @@ async function runLaunch(flags, rawArgs) {
   };
   writeFileSync7(join5(tmpDir, "config.json"), JSON.stringify(sessionConfig, null, 2) + `
 `, "utf-8");
+  const isResume = args.resume !== null || args.continueSession;
+  const claudeSessionId = isResume ? undefined : randomUUID();
   let sessionTokenFilePath = null;
   let sessionTokenForCleanup = null;
   try {
@@ -4351,6 +4386,27 @@ async function runLaunch(flags, rawArgs) {
     const minted = mintSessionToken2(tmpDir);
     sessionTokenFilePath = minted.filePath;
     sessionTokenForCleanup = minted.token;
+    let presencePayload;
+    try {
+      const { generateKeypair: generateKeypair4 } = await Promise.resolve().then(() => (init_facade7(), exports_facade4));
+      const { signParentAttestation: signParentAttestation2 } = await Promise.resolve().then(() => (init_session_hello_sig(), exports_session_hello_sig));
+      const sessionKp = await generateKeypair4();
+      const att = await signParentAttestation2({
+        parentMemberPubkey: mesh.pubkey,
+        parentSecretKey: mesh.secretKey,
+        sessionPubkey: sessionKp.publicKey
+      });
+      presencePayload = {
+        session_pubkey: sessionKp.publicKey,
+        session_secret_key: sessionKp.secretKey,
+        parent_attestation: {
+          session_pubkey: att.sessionPubkey,
+          parent_member_pubkey: att.parentMemberPubkey,
+          expires_at: att.expiresAt,
+          signature: att.signature
+        }
+      };
+    } catch {}
     const { ipc: ipc2 } = await Promise.resolve().then(() => (init_client3(), exports_client));
     const sessionIdForRegister = claudeSessionId ?? randomUUID();
     await ipc2({
@@ -4365,7 +4421,8 @@ async function runLaunch(flags, rawArgs) {
         pid: process.pid,
         cwd: process.cwd(),
         ...role ? { role } : {},
-        ...parsedGroups.length > 0 ? { groups: parsedGroups.map((g) => `@${g.name}${g.role ? `:${g.role}` : ""}`) } : {}
+        ...parsedGroups.length > 0 ? { groups: parsedGroups.map((g) => `@${g.name}${g.role ? `:${g.role}` : ""}`) } : {},
+        ...presencePayload ? { presence: presencePayload } : {}
       }
     }).catch(() => null);
     process._claudemeshTokenEnv = {
@@ -4429,8 +4486,6 @@ async function runLaunch(flags, rawArgs) {
     }
     filtered.push(args.claudeArgs[i]);
   }
-  const isResume = args.resume !== null || args.continueSession;
-  const claudeSessionId = isResume ? undefined : randomUUID();
   const claudeArgs = [
     "--dangerously-load-development-channels",
     "server:claudemesh",
@@ -8440,7 +8495,7 @@ async function runMsgStatus(id, opts) {
       console.log(JSON.stringify(result, null, 2));
       return EXIT.SUCCESS;
     }
-    render.section(`message ${id.slice(0, 12)}…`);
+    render.section(`message ${lookupId.slice(0, 12)}…`);
     render.kv([
       ["target", result.targetSpec],
       ["delivered", result.delivered ? "yes" : "no"],
@@ -9258,13 +9313,27 @@ function startReaper() {
     return;
   reaperHandle = setInterval(reapDead, REAPER_INTERVAL_MS).unref?.() ?? reaperHandle;
 }
+function setRegistryHooks(next) {
+  hooks.onRegister = next.onRegister;
+  hooks.onDeregister = next.onDeregister;
+}
 function registerSession(info) {
   const priorToken = bySessionId.get(info.sessionId);
-  if (priorToken && priorToken !== info.token)
-    byToken.delete(priorToken);
+  if (priorToken && priorToken !== info.token) {
+    const prior = byToken.get(priorToken);
+    if (prior) {
+      byToken.delete(priorToken);
+      try {
+        hooks.onDeregister?.(prior);
+      } catch {}
+    }
+  }
   const stored = { ...info, registeredAt: Date.now() };
   byToken.set(info.token, stored);
   bySessionId.set(info.sessionId, info.token);
+  try {
+    hooks.onRegister?.(stored);
+  } catch {}
   return stored;
 }
 function deregisterByToken(token) {
@@ -9274,6 +9343,9 @@ function deregisterByToken(token) {
   byToken.delete(token);
   if (bySessionId.get(entry.sessionId) === token)
     bySessionId.delete(entry.sessionId);
+  try {
+    hooks.onDeregister?.(entry);
+  } catch {}
   return true;
 }
 function resolveToken(token) {
@@ -9305,12 +9377,13 @@ function reapDead() {
   for (const t of dead)
     deregisterByToken(t);
 }
-var TTL_MS, REAPER_INTERVAL_MS, byToken, bySessionId, reaperHandle = null;
+var TTL_MS, REAPER_INTERVAL_MS, byToken, bySessionId, hooks, reaperHandle = null;
 var init_session_registry = __esm(() => {
   TTL_MS = 24 * 60 * 60 * 1000;
   REAPER_INTERVAL_MS = 30 * 1000;
   byToken = new Map;
   bySessionId = new Map;
+  hooks = {};
 });
 
 // src/daemon/ipc/server.ts
@@ -9461,6 +9534,28 @@ function makeHandler(opts) {
         const cwd = typeof body.cwd === "string" ? body.cwd : undefined;
         const role = typeof body.role === "string" ? body.role : undefined;
         const groups = Array.isArray(body.groups) ? body.groups.filter((g) => typeof g === "string") : undefined;
+        let presence;
+        const rawPresence = body.presence;
+        if (rawPresence && typeof rawPresence === "object") {
+          const p = rawPresence;
+          const sessionPubkey = typeof p.session_pubkey === "string" ? p.session_pubkey.toLowerCase() : "";
+          const sessionSecretKey = typeof p.session_secret_key === "string" ? p.session_secret_key.toLowerCase() : "";
+          const att = p.parent_attestation;
+          if (/^[0-9a-f]{64}$/.test(sessionPubkey) && /^[0-9a-f]{128}$/.test(sessionSecretKey) && att && typeof att === "object" && typeof att.session_pubkey === "string" && typeof att.parent_member_pubkey === "string" && typeof att.expires_at === "number" && typeof att.signature === "string") {
+            presence = {
+              sessionPubkey,
+              sessionSecretKey,
+              parentAttestation: {
+                sessionPubkey: att.session_pubkey.toLowerCase(),
+                parentMemberPubkey: att.parent_member_pubkey.toLowerCase(),
+                expiresAt: att.expires_at,
+                signature: att.signature.toLowerCase()
+              }
+            };
+          } else {
+            opts.log("warn", "session_register_presence_malformed", { mesh });
+          }
+        }
         const stored = registerSession({
           token: token.toLowerCase(),
           sessionId,
@@ -9469,10 +9564,20 @@ function makeHandler(opts) {
           pid,
           cwd,
           role,
-          groups
+          groups,
+          ...presence ? { presence } : {}
+        });
+        opts.log("info", "session_registered", {
+          sessionId,
+          mesh,
+          pid,
+          presence: presence ? "yes" : "no"
+        });
+        respond(res, 200, {
+          ok: true,
+          registered_at: stored.registeredAt,
+          presence_accepted: !!presence
         });
-        opts.log("info", "session_registered", { sessionId, mesh, pid });
-        respond(res, 200, { ok: true, registered_at: stored.registeredAt });
       } catch (e) {
         respond(res, 400, { error: String(e) });
       }
@@ -10573,9 +10678,168 @@ var init_broker = __esm(() => {
   BACKOFF_CAPS_MS = [1000, 2000, 4000, 8000, 16000, 30000];
 });
 
+// src/daemon/session-broker.ts
+import { hostname as osHostname } from "node:os";
+import WebSocket3 from "ws";
+
+class SessionBrokerClient {
+  opts;
+  ws = null;
+  _status = "closed";
+  closed = false;
+  reconnectAttempt = 0;
+  reconnectTimer = null;
+  helloTimer = null;
+  constructor(opts) {
+    this.opts = opts;
+  }
+  get status() {
+    return this._status;
+  }
+  get meshSlug() {
+    return this.opts.mesh.slug;
+  }
+  get sessionPubkey() {
+    return this.opts.sessionPubkey;
+  }
+  log = (level, msg, meta) => {
+    (this.opts.log ?? defaultLog2)(level, msg, {
+      mesh: this.opts.mesh.slug,
+      session_pubkey: this.opts.sessionPubkey.slice(0, 12),
+      ...meta
+    });
+  };
+  setStatus(s) {
+    if (this._status === s)
+      return;
+    this._status = s;
+    this.opts.onStatusChange?.(s);
+  }
+  async connect() {
+    if (this.closed)
+      throw new Error("client_closed");
+    if (this._status === "connecting" || this._status === "open")
+      return;
+    this.setStatus("connecting");
+    const ws = new WebSocket3(this.opts.mesh.brokerUrl);
+    this.ws = ws;
+    return new Promise((resolve, reject) => {
+      ws.on("open", async () => {
+        try {
+          const { timestamp: timestamp2, signature } = await signSessionHello({
+            meshId: this.opts.mesh.meshId,
+            parentMemberPubkey: this.opts.mesh.pubkey,
+            sessionPubkey: this.opts.sessionPubkey,
+            sessionSecretKey: this.opts.sessionSecretKey
+          });
+          ws.send(JSON.stringify({
+            type: "session_hello",
+            meshId: this.opts.mesh.meshId,
+            parentMemberId: this.opts.mesh.memberId,
+            parentMemberPubkey: this.opts.mesh.pubkey,
+            sessionPubkey: this.opts.sessionPubkey,
+            parentAttestation: this.opts.parentAttestation,
+            displayName: this.opts.displayName,
+            sessionId: this.opts.sessionId,
+            pid: this.opts.pid,
+            cwd: this.opts.cwd ?? process.cwd(),
+            hostname: osHostname(),
+            peerType: "ai",
+            channel: "claudemesh-session",
+            ...this.opts.groups && this.opts.groups.length > 0 ? { groups: this.opts.groups } : {},
+            ...this.opts.role ? { role: this.opts.role } : {},
+            timestamp: timestamp2,
+            signature
+          }));
+          this.helloTimer = setTimeout(() => {
+            this.log("warn", "session_hello_ack_timeout");
+            try {
+              ws.close();
+            } catch {}
+            reject(new Error("session_hello_ack_timeout"));
+          }, HELLO_ACK_TIMEOUT_MS3);
+        } catch (e) {
+          reject(e instanceof Error ? e : new Error(String(e)));
+        }
+      });
+      ws.on("message", (raw) => {
+        let msg;
+        try {
+          msg = JSON.parse(raw.toString());
+        } catch {
+          return;
+        }
+        if (msg.type === "hello_ack") {
+          if (this.helloTimer)
+            clearTimeout(this.helloTimer);
+          this.helloTimer = null;
+          this.setStatus("open");
+          this.reconnectAttempt = 0;
+          resolve();
+          return;
+        }
+        if (msg.type === "error") {
+          this.log("warn", "broker_error", { code: msg.code, message: msg.message });
+          if (msg.code === "unknown_message_type") {
+            this.closed = true;
+          }
+          return;
+        }
+      });
+      ws.on("close", (code, reason) => {
+        if (this.helloTimer) {
+          clearTimeout(this.helloTimer);
+          this.helloTimer = null;
+        }
+        if (this.closed) {
+          this.setStatus("closed");
+          return;
+        }
+        this.setStatus("reconnecting");
+        const wait = BACKOFF_CAPS_MS2[Math.min(this.reconnectAttempt, BACKOFF_CAPS_MS2.length - 1)] ?? 30000;
+        this.reconnectAttempt++;
+        this.log("info", "session_broker_reconnect_scheduled", { wait_ms: wait, code, reason: reason.toString("utf8") });
+        this.reconnectTimer = setTimeout(() => this.connect().catch((err) => this.log("warn", "session_broker_reconnect_failed", { err: String(err) })), wait);
+        if (this._status === "connecting")
+          reject(new Error(`closed_before_hello_${code}`));
+      });
+      ws.on("error", (err) => this.log("warn", "session_broker_ws_error", { err: err.message }));
+    });
+  }
+  async close() {
+    this.closed = true;
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+    if (this.helloTimer) {
+      clearTimeout(this.helloTimer);
+      this.helloTimer = null;
+    }
+    try {
+      this.ws?.close();
+    } catch {}
+    this.setStatus("closed");
+  }
+}
+function defaultLog2(level, msg, meta) {
+  const line = JSON.stringify({ level, msg, ...meta, ts: new Date().toISOString() });
+  if (level === "info")
+    process.stdout.write(line + `
+`);
+  else
+    process.stderr.write(line + `
+`);
+}
+var HELLO_ACK_TIMEOUT_MS3 = 5000, BACKOFF_CAPS_MS2;
+var init_session_broker = __esm(() => {
+  init_session_hello_sig();
+  BACKOFF_CAPS_MS2 = [1000, 2000, 4000, 8000, 16000, 30000];
+});
+
 // src/daemon/drain.ts
 function startDrainWorker(opts) {
-  const log2 = opts.log ?? defaultLog2;
+  const log2 = opts.log ?? defaultLog3;
   let stopped = false;
   let wakeResolve = null;
   let wakePromise = new Promise((r) => {
@@ -10719,7 +10983,7 @@ async function randomNonce2() {
   const { randomBytes: randomBytes6 } = await import("node:crypto");
   return randomBytes6(24).toString("base64");
 }
-function defaultLog2(level, msg, meta) {
+function defaultLog3(level, msg, meta) {
   const line = JSON.stringify({ level, msg, ...meta, ts: new Date().toISOString() });
   if (level === "info")
     process.stdout.write(line + `
@@ -11062,6 +11326,56 @@ async function runDaemon(opts = {}) {
   }
   let drain = null;
   drain = startDrainWorker({ db: outboxDb, brokers });
+  const sessionBrokers = new Map;
+  setRegistryHooks({
+    onRegister: (info) => {
+      if (!info.presence)
+        return;
+      const meshConfig = meshConfigs.get(info.mesh);
+      if (!meshConfig) {
+        process.stderr.write(JSON.stringify({
+          level: "warn",
+          msg: "session_broker_no_mesh_config",
+          mesh: info.mesh,
+          ts: new Date().toISOString()
+        }) + `
+`);
+        return;
+      }
+      const prior = sessionBrokers.get(info.token);
+      if (prior) {
+        sessionBrokers.delete(info.token);
+        prior.close().catch(() => {});
+      }
+      const client = new SessionBrokerClient({
+        mesh: meshConfig,
+        sessionPubkey: info.presence.sessionPubkey,
+        sessionSecretKey: info.presence.sessionSecretKey,
+        parentAttestation: info.presence.parentAttestation,
+        sessionId: info.sessionId,
+        displayName: info.displayName,
+        ...info.role ? { role: info.role } : {},
+        ...info.cwd ? { cwd: info.cwd } : {},
+        pid: info.pid
+      });
+      sessionBrokers.set(info.token, client);
+      client.connect().catch((err) => process.stderr.write(JSON.stringify({
+        level: "warn",
+        msg: "session_broker_connect_failed",
+        mesh: info.mesh,
+        err: String(err),
+        ts: new Date().toISOString()
+      }) + `
+`));
+    },
+    onDeregister: (info) => {
+      const client = sessionBrokers.get(info.token);
+      if (!client)
+        return;
+      sessionBrokers.delete(info.token);
+      client.close().catch(() => {});
+    }
+  });
   startReaper();
   const ipc2 = startIpcServer({
     localToken,
@@ -11105,6 +11419,12 @@ async function runDaemon(opts = {}) {
         await b.close();
       } catch {}
     }
+    for (const b of sessionBrokers.values()) {
+      try {
+        await b.close();
+      } catch {}
+    }
+    sessionBrokers.clear();
     await ipc2.close();
     try {
       outboxDb.close();
@@ -11126,6 +11446,7 @@ var init_run = __esm(() => {
   init_server();
   init_session_registry();
   init_broker();
+  init_session_broker();
   init_drain();
   init_inbound();
   init_identity();
@@ -11831,11 +12152,11 @@ function uninstallAllowedTools() {
 }
 function installHooks() {
   const settings = readClaudeSettings();
-  const hooks = (settings.hooks ??= {}) ?? {};
+  const hooks2 = (settings.hooks ??= {}) ?? {};
   let added = 0;
   let unchanged = 0;
   const ensure = (event, command) => {
-    const list = hooks[event] ??= [];
+    const list = hooks2[event] ??= [];
     const alreadyPresent = list.some((entry) => (entry.hooks ?? []).some((h) => h.command === command));
     if (alreadyPresent) {
       unchanged += 1;
@@ -11846,7 +12167,7 @@ function installHooks() {
   };
   ensure("Stop", HOOK_COMMAND_STOP);
   ensure("UserPromptSubmit", HOOK_COMMAND_USER_PROMPT);
-  settings.hooks = hooks;
+  settings.hooks = hooks2;
   writeClaudeSettings(settings);
   return { added, unchanged };
 }
@@ -11854,24 +12175,24 @@ function uninstallHooks() {
   if (!existsSync13(CLAUDE_SETTINGS))
     return 0;
   const settings = readClaudeSettings();
-  const hooks = settings.hooks;
-  if (!hooks)
+  const hooks2 = settings.hooks;
+  if (!hooks2)
     return 0;
   let removed = 0;
-  for (const event of Object.keys(hooks)) {
+  for (const event of Object.keys(hooks2)) {
     const kept = [];
-    for (const entry of hooks[event] ?? []) {
+    for (const entry of hooks2[event] ?? []) {
       const filtered = (entry.hooks ?? []).filter((h) => !(h.command ?? "").includes(HOOK_MARKER));
       removed += (entry.hooks ?? []).length - filtered.length;
       if (filtered.length > 0)
         kept.push({ ...entry, hooks: filtered });
     }
     if (kept.length === 0)
-      delete hooks[event];
+      delete hooks2[event];
     else
-      hooks[event] = kept;
+      hooks2[event] = kept;
   }
-  settings.hooks = hooks;
+  settings.hooks = hooks2;
   writeClaudeSettings(settings);
   return removed;
 }
@@ -12176,10 +12497,10 @@ async function uninstall() {
     try {
       const raw = readFileSync13(PATHS.CLAUDE_SETTINGS, "utf-8");
       const config = JSON.parse(raw);
-      const hooks = config.hooks;
-      if (hooks) {
+      const hooks2 = config.hooks;
+      if (hooks2) {
         let removedHooks = 0;
-        for (const [event, entries] of Object.entries(hooks)) {
+        for (const [event, entries] of Object.entries(hooks2)) {
           if (!Array.isArray(entries))
             continue;
           const filtered = entries.filter((h) => {
@@ -12189,9 +12510,9 @@ async function uninstall() {
           if (filtered.length < entries.length) {
             removedHooks += entries.length - filtered.length;
             if (filtered.length === 0)
-              delete hooks[event];
+              delete hooks2[event];
             else
-              hooks[event] = filtered;
+              hooks2[event] = filtered;
           }
         }
         if (removedHooks > 0) {
@@ -12393,8 +12714,8 @@ async function checkBrokerWs() {
   const wsUrl = URLS.BROKER;
   const start = Date.now();
   try {
-    const WebSocket3 = (await import("ws")).default;
-    const ws = new WebSocket3(wsUrl);
+    const WebSocket4 = (await import("ws")).default;
+    const ws = new WebSocket4(wsUrl);
     const result = await new Promise((resolve2) => {
       const timer = setTimeout(() => {
         try {
@@ -12505,11 +12826,11 @@ __export(exports_status, {
   runStatus: () => runStatus2
 });
 import { statSync as statSync4, existsSync as existsSync16 } from "node:fs";
-import WebSocket3 from "ws";
+import WebSocket4 from "ws";
 async function probeBroker(url, timeoutMs = 4000) {
   return new Promise((resolve2) => {
     const started = Date.now();
-    const ws = new WebSocket3(url);
+    const ws = new WebSocket4(url);
     const timer = setTimeout(() => {
       try {
         ws.terminate();
@@ -14530,17 +14851,17 @@ async function runUnwatch(id, opts) {
 }
 async function runWebhookList(opts) {
   return await withMesh({ meshSlug: opts.mesh ?? null }, async (client) => {
-    const hooks = await client.listWebhooks();
+    const hooks2 = await client.listWebhooks();
     if (opts.json) {
-      emitJson(hooks);
+      emitJson(hooks2);
       return EXIT.SUCCESS;
     }
-    if (hooks.length === 0) {
+    if (hooks2.length === 0) {
       render.info(dim("(no webhooks)"));
       return EXIT.SUCCESS;
     }
-    render.section(`webhooks (${hooks.length})`);
-    for (const h of hooks) {
+    render.section(`webhooks (${hooks2.length})`);
+    for (const h of hooks2) {
       const dot = h.active ? "●" : dim("○");
       process.stdout.write(`  ${dot} ${bold(h.name)} ${dim("· " + h.url)}
 `);
@@ -15511,7 +15832,7 @@ __export(exports_file, {
   runFileShare: () => runFileShare,
   runFileGet: () => runFileGet
 });
-import { hostname as osHostname } from "node:os";
+import { hostname as osHostname2 } from "node:os";
 import { resolve as resolvePath, basename, dirname as dirname9 } from "node:path";
 import { statSync as statSync7, existsSync as existsSync26, writeFileSync as writeFileSync17, mkdirSync as mkdirSync11 } from "node:fs";
 function emitJson2(data) {
@@ -15543,7 +15864,7 @@ async function runFileShare(filePath, opts) {
   return await withMesh({ meshSlug: opts.mesh ?? null }, async (client, mesh) => {
     if (opts.to && !opts.upload) {
       const peers = await client.listPeers();
-      const myHost = osHostname();
+      const myHost = osHostname2();
       const target = peers.find((p) => {
         if (!p.hostname || p.hostname !== myHost)
           return false;
@@ -15705,7 +16026,7 @@ var require_client = __commonJS((exports) => {
   var ws_1 = __importDefault(__require("ws"));
   var crypto_js_1 = require_crypto();
   var MAX_QUEUED2 = 100;
-  var HELLO_ACK_TIMEOUT_MS3 = 5000;
+  var HELLO_ACK_TIMEOUT_MS4 = 5000;
   var BACKOFF_CAPS2 = [1000, 2000, 4000, 8000, 16000, 30000];
 
   class MeshClient extends node_events_1.EventEmitter {
@@ -15770,7 +16091,7 @@ var require_client = __commonJS((exports) => {
             this.debug("hello_ack timeout");
             ws.close();
             reject(new Error("hello_ack timeout"));
-          }, HELLO_ACK_TIMEOUT_MS3);
+          }, HELLO_ACK_TIMEOUT_MS4);
         };
         const onMessage = (raw) => {
           let msg;
@@ -19550,4 +19871,4 @@ main().catch((err) => {
   process.exit(EXIT.INTERNAL_ERROR);
 });
 
-//# debugId=FBD494B01BF81C7164756E2164756E21
+//# debugId=A7687DD2912DA01C64756E2164756E21