very-happy-cli 0.2.120 → 0.2.122

package/dist/{types-7ZSxm6Pi.cjs → types-Jag0GwhO.cjs}

@@ -51,7 +51,7 @@ var z__namespace = /*#__PURE__*/_interopNamespaceDefault(z);
 var pty__namespace = /*#__PURE__*/_interopNamespaceDefault(pty);
 
 var name = "very-happy-cli";
-var version = "0.2.120";
+var version = "0.2.122";
 var description = "Remote multi-agent workspace CLI with deep Claude integration, native terminal streaming, and self-hosting.";
 var author = "Kirill Dubovitskiy";
 var contributors = [
@@ -164,12 +164,12 @@ var dependencies = {
 	zod: "^4.0.0"
 };
 var optionalDependencies = {
-	"very-happy-tools-arm64-darwin": "0.2.120",
-	"very-happy-tools-x64-darwin": "0.2.120",
-	"very-happy-tools-arm64-linux": "0.2.120",
-	"very-happy-tools-x64-linux": "0.2.120",
-	"very-happy-tools-arm64-win32": "0.2.120",
-	"very-happy-tools-x64-win32": "0.2.120"
+	"very-happy-tools-arm64-darwin": "0.2.122",
+	"very-happy-tools-x64-darwin": "0.2.122",
+	"very-happy-tools-arm64-linux": "0.2.122",
+	"very-happy-tools-x64-linux": "0.2.122",
+	"very-happy-tools-arm64-win32": "0.2.122",
+	"very-happy-tools-x64-win32": "0.2.122"
 };
 var devDependencies = {
 	"@slopus/happy-wire": "workspace:*",
@@ -742,6 +742,11 @@ const sessionProgressEventSchema = z__namespace.object({
   durationMs: z__namespace.number().optional(),
   summary: z__namespace.string().optional()
 });
+const sessionQueueCancelEventSchema = z__namespace.object({
+  t: z__namespace.literal("queue-cancel"),
+  targetLocalKeys: z__namespace.array(z__namespace.string().min(1)).min(1),
+  reason: z__namespace.string().min(1).optional()
+});
 const sessionEventSchema = z__namespace.discriminatedUnion("t", [
   sessionTextEventSchema,
   sessionServiceMessageEventSchema,
@@ -752,7 +757,8 @@ const sessionEventSchema = z__namespace.discriminatedUnion("t", [
   sessionStartEventSchema,
   sessionTurnEndEventSchema,
   sessionStopEventSchema,
-  sessionProgressEventSchema
+  sessionProgressEventSchema,
+  sessionQueueCancelEventSchema
 ]);
 const sessionEnvelopeSchema = z__namespace.object({
   id: z__namespace.string(),
@@ -1026,6 +1032,20 @@ const ReleaseDrainNoticeSchema = z.z.object({
   deadline: z.z.number().int().positive(),
   mode: z.z.literal("make-before-break")
 });
+const ConnectionDiagnosticEventSchema = z.z.object({
+  attemptId: z.z.string().uuid(),
+  machineId: z.z.string().min(1).max(256).regex(/^[A-Za-z0-9_-]+$/).optional(),
+  at: z.z.number().int().min(0).max(Number.MAX_SAFE_INTEGER),
+  stage: z.z.enum(["control", "relay_discovery", "relay_connect", "relay_probe", "machine_rpc", "terminal_open"]),
+  outcome: z.z.enum(["started", "success", "timeout", "error", "offline", "cancelled", "fallback"]),
+  durationMs: z.z.number().int().min(0).max(3e5),
+  deviceClass: z.z.enum(["mobile", "desktop", "unknown"]),
+  visibility: z.z.enum(["visible", "hidden"]),
+  client: z.z.string().regex(/^web\/(?:[a-f0-9]{7,40}|unknown)$/)
+}).strict();
+z.z.object({
+  events: z.z.array(ConnectionDiagnosticEventSchema).min(1).max(32)
+}).strict();
 
 z.z.object({
   host: z.z.string(),
@@ -1685,7 +1705,7 @@ class RpcHandlerManager {
   }
 }
 
-const __dirname$1 = path$1.dirname(url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('types-7ZSxm6Pi.cjs', document.baseURI).href))));
+const __dirname$1 = path$1.dirname(url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('types-Jag0GwhO.cjs', document.baseURI).href))));
 function projectPath() {
   const path = path$1.resolve(__dirname$1, "..");
   return path;
@@ -3135,6 +3155,48 @@ class InvalidateSync {
   };
 }
 
+function sessionEnvelopeOf(body) {
+  if (!body || typeof body !== "object") return null;
+  const record = body;
+  if (record.role !== "session" || !record.content || typeof record.content !== "object") return null;
+  const content = record.content;
+  if (content.type === "session" && content.data && typeof content.data === "object") {
+    return content.data;
+  }
+  if (content.ev !== void 0) return content;
+  return null;
+}
+function isQueuedUserText(body) {
+  if (!body || typeof body !== "object") return false;
+  const record = body;
+  return record.role === "user" && record.content?.type === "text" && typeof record.meta?.queuedAt === "number";
+}
+function scanUndeliveredQueuedInputs(records, prior) {
+  const canceled = prior?.canceled ?? /* @__PURE__ */ new Set();
+  const undelivered = [];
+  let reachedBoundary = false;
+  for (const record of records) {
+    const envelope = sessionEnvelopeOf(record.body);
+    if (envelope) {
+      const t = envelope.ev?.t;
+      if (t === "turn-end") {
+        reachedBoundary = true;
+        break;
+      }
+      if (t === "queue-cancel" && Array.isArray(envelope.ev?.targetLocalKeys)) {
+        for (const key of envelope.ev.targetLocalKeys) {
+          if (typeof key === "string") canceled.add(key);
+        }
+      }
+      continue;
+    }
+    if (isQueuedUserText(record.body) && record.localId && !canceled.has(record.localId)) {
+      undelivered.push(record.localId);
+    }
+  }
+  return { undeliveredLocalKeys: undelivered, reachedBoundary, canceled };
+}
+
 function record(value) {
   return value && typeof value === "object" && !Array.isArray(value) ? value : null;
 }
@@ -3778,8 +3840,75 @@ class ApiSessionClient extends node_events.EventEmitter {
       this.sendSync.invalidate();
     }
   }
+  /** B-332: emit a queue-cancel tombstone, mirroring the web's own signal. */
+  sendQueueCancelReason(localKeys, reason) {
+    if (localKeys.length === 0) return;
+    const envelope = createEnvelope("user", { t: "queue-cancel", targetLocalKeys: localKeys, reason });
+    this.sendSessionProtocolMessage(envelope);
+  }
   /**
-   * Send message to session
+   * B-332 site ③: find queued user input this wrapper destroyed (it was still
+   * in the previous wrapper's in-memory queue when it died) and tell the web.
+   *
+   * Walks NEWEST → OLDEST via `before_seq`, decrypting each page, and stops at
+   * the first turn-end. The runner calls this on EVERY reconnect (runClaude /
+   * runCodex), seeded or not: a cursor seeded at the server's latest seq skips
+   * the undelivered tail just as thoroughly as skipExistingMessages does —
+   * and the daemon's resume/restart always seeds, so gating on the skip path
+   * would miss the common case. Best-effort: a failed scan must not take a
+   * session down. Needs no socket; POSTs through the same session-message
+   * channel so the web receives it identically to a cancel-button tombstone.
+   */
+  async cancelUndeliveredQueuedInputs() {
+    const MAX_SCAN_PAGES = 10;
+    const canceled = /* @__PURE__ */ new Set();
+    const undelivered = [];
+    let beforeSeq = 2147483647;
+    let reachedBoundary = false;
+    let pages = 0;
+    try {
+      while (!reachedBoundary && pages < MAX_SCAN_PAGES) {
+        pages += 1;
+        const response = await axios.get(
+          `${configuration.serverUrl}/v3/sessions/${encodeURIComponent(this.sessionId)}/messages`,
+          {
+            params: { before_seq: beforeSeq, limit: 100 },
+            headers: this.authHeaders(),
+            timeout: 6e4
+          }
+        );
+        const messages = Array.isArray(response.data.messages) ? response.data.messages : [];
+        if (messages.length === 0) break;
+        const records = messages.map((message) => {
+          let body = null;
+          try {
+            body = message.content?.t === "encrypted" ? decrypt(this.encryptionKey, this.encryptionVariant, decodeBase64(message.content.c)) : null;
+          } catch (error) {
+            logger.debug("[API] Failed to decrypt during undelivered scan:", error);
+          }
+          return { seq: message.seq, localId: message.localId, body };
+        });
+        const scan = scanUndeliveredQueuedInputs(records, { canceled });
+        for (const key of scan.canceled) canceled.add(key);
+        undelivered.push(...scan.undeliveredLocalKeys);
+        reachedBoundary = scan.reachedBoundary;
+        const oldest = records.at(-1)?.seq;
+        if (oldest === void 0 || messages.length < 100) break;
+        beforeSeq = oldest;
+      }
+    } catch (error) {
+      logger.debug("[API] cancelUndeliveredQueuedInputs scan failed:", error);
+      return;
+    }
+    if (!reachedBoundary) {
+      logger.debug("[API] cancelUndeliveredQueuedInputs found no turn boundary; leaving messages as-is");
+      return;
+    }
+    undelivered.reverse();
+    this.sendQueueCancelReason(undelivered, "restarted");
+  }
+  /**
+   * Send a message to session
    * @param body - Message body (can be MessageContent or raw content for agent messages)
    */
   sendClaudeSessionMessage(body, opts) {
@@ -14391,28 +14520,50 @@ function selectStableRelay(candidates, probes, connectedRelayId, tracker = null)
     tracker: { challengerRelayId: fastest.id, consecutiveWins }
   };
 }
+const RELAY_REFRESH_TIMEOUT_MS = 8e3;
+async function withinDeadline(timeoutMs, operation, parent) {
+  const controller = new AbortController();
+  let timer;
+  let cancel;
+  const deadline = new Promise((_, reject) => {
+    cancel = () => {
+      reject(new Error("relay request deadline exceeded"));
+      controller.abort();
+    };
+    timer = setTimeout(cancel, timeoutMs);
+    parent?.addEventListener("abort", cancel, { once: true });
+    if (parent?.aborted) cancel();
+  });
+  try {
+    return await Promise.race([Promise.resolve().then(() => {
+      controller.signal.throwIfAborted();
+      return operation(controller.signal);
+    }), deadline]);
+  } finally {
+    clearTimeout(timer);
+    parent?.removeEventListener("abort", cancel);
+  }
+}
 async function probeRelayCandidates(candidates, options = {}) {
   const timeoutMs = options.timeoutMs ?? 2e3;
   const fetchImpl = options.fetchImpl ?? fetch;
   const now = options.now ?? (() => performance.now());
   const measured = await Promise.all(candidates.map(async (candidate) => {
-    const controller = new AbortController();
-    const timeout = setTimeout(() => controller.abort(), timeoutMs);
     const startedAt = now();
     try {
-      const response = await fetchImpl(`${candidate.url}/health`, {
-        method: "GET",
-        cache: "no-store",
-        signal: controller.signal
-      });
-      if (!response.ok) return null;
-      const body = await response.json();
-      if (body.ok !== true || body.relayId !== candidate.id) return null;
-      return { relayId: candidate.id, rttMs: Math.max(0, now() - startedAt) };
+      return await withinDeadline(timeoutMs, async (signal) => {
+        const response = await fetchImpl(`${candidate.url}/health`, {
+          method: "GET",
+          cache: "no-store",
+          signal
+        });
+        if (!response.ok) return null;
+        const body = await response.json();
+        if (body.ok !== true || body.relayId !== candidate.id) return null;
+        return { relayId: candidate.id, rttMs: Math.max(0, now() - startedAt) };
+      }, options.signal);
     } catch {
       return null;
-    } finally {
-      clearTimeout(timeout);
     }
   }));
   return measured.filter((probe) => probe !== null);
@@ -14420,25 +14571,32 @@ async function probeRelayCandidates(candidates, options = {}) {
 async function discoverAndClaimRelay(input) {
   const fetchImpl = input.fetchImpl ?? fetch;
   try {
-    const discoveryResponse = await fetchImpl(`${input.controlUrl}/v1/relays`, {
-      headers: { Authorization: `Bearer ${input.token}` },
-      cache: "no-store"
-    });
-    if (!discoveryResponse.ok) return null;
-    const discovery = RelayCandidatesResponseSchema.parse(await discoveryResponse.json());
-    if (!discovery.enabled || discovery.candidates.length === 0) return null;
-    const probes = await probeRelayCandidates(discovery.candidates, { fetchImpl });
-    const decision = selectStableRelay(discovery.candidates, probes, input.connectedRelayId, input.switchTracker);
-    const selected = decision.candidate;
-    if (!selected) return null;
-    const claimResponse = await fetchImpl(`${input.controlUrl}/v1/relays/machines/${encodeURIComponent(input.machineId)}/claim`, {
-      method: "POST",
-      headers: { Authorization: `Bearer ${input.token}`, "Content-Type": "application/json" },
-      body: JSON.stringify({ relayId: selected.id, probes })
+    return await withinDeadline(RELAY_REFRESH_TIMEOUT_MS, async (signal) => {
+      const discoveryResponse = await fetchImpl(`${input.controlUrl}/v1/relays`, {
+        headers: { Authorization: `Bearer ${input.token}` },
+        cache: "no-store",
+        signal
+      });
+      if (!discoveryResponse.ok) return null;
+      const discovery = RelayCandidatesResponseSchema.parse(await discoveryResponse.json());
+      signal.throwIfAborted();
+      if (!discovery.enabled || discovery.candidates.length === 0) return null;
+      const probes = await probeRelayCandidates(discovery.candidates, { fetchImpl, signal });
+      signal.throwIfAborted();
+      const decision = selectStableRelay(discovery.candidates, probes, input.connectedRelayId, input.switchTracker);
+      const selected = decision.candidate;
+      if (!selected) return null;
+      const claimResponse = await fetchImpl(`${input.controlUrl}/v1/relays/machines/${encodeURIComponent(input.machineId)}/claim`, {
+        method: "POST",
+        signal,
+        headers: { Authorization: `Bearer ${input.token}`, "Content-Type": "application/json" },
+        body: JSON.stringify({ relayId: selected.id, probes })
+      });
+      if (!claimResponse.ok) return null;
+      const claimed = RelayAssignmentResponseSchema.parse(await claimResponse.json());
+      signal.throwIfAborted();
+      return claimed.assignment ? { assignment: claimed.assignment, probes, switchTracker: decision.tracker } : null;
     });
-    if (!claimResponse.ok) return null;
-    const claimed = RelayAssignmentResponseSchema.parse(await claimResponse.json());
-    return claimed.assignment ? { assignment: claimed.assignment, probes, switchTracker: decision.tracker } : null;
   } catch {
     return null;
   }
@@ -14552,6 +14710,7 @@ async function withCodexAppServerClient(handler) {
     await client.disconnect();
   }
 }
+const CLI_AVAILABILITY_RECHECK_MS = 5 * 60 * 1e3;
 class ApiMachineClient {
   constructor(token, machine) {
     this.token = token;
@@ -14575,6 +14734,10 @@ class ApiMachineClient {
   keepAliveInterval = null;
   lastKnownCLIAvailability = null;
   lastKnownResumeSupport = null;
+  /** Wall-clock of the last CLI availability probe. Initialised as "already
+   *  stale" so the FIRST keep-alive tick always probes and populates the
+   *  machine metadata that a connecting/reconnecting web client reads. */
+  lastCliProbeAt = Date.now() - CLI_AVAILABILITY_RECHECK_MS;
   cliUpdateState = null;
   cliUpdatePushChain = Promise.resolve();
   claudeAuthState = null;
@@ -15442,6 +15605,10 @@ class ApiMachineClient {
       }
       this.socket.emit("machine-alive", payload);
       void this.refreshRelayConnection();
+      if (Date.now() - this.lastCliProbeAt < CLI_AVAILABILITY_RECHECK_MS) {
+        return;
+      }
+      this.lastCliProbeAt = Date.now();
       const newAvailability = detectCLIAvailability();
       const prev = this.lastKnownCLIAvailability;
       const newResumeSupport = detectResumeSupport();
@@ -16745,6 +16912,7 @@ exports.scrubTmuxClientEnv = scrubTmuxClientEnv;
 exports.sendToVhTerminal = sendToVhTerminal;
 exports.shellescape = shellescape;
 exports.startOfflineReconnection = startOfflineReconnection;
+exports.streamKeyOf = streamKeyOf;
 exports.summarizeSpawnSessionForLog = summarizeSpawnSessionForLog;
 exports.tmuxArgs = tmuxArgs;
 exports.updateSettings = updateSettings;