very-happy-cli 0.2.120 → 0.2.122

package/dist/{types-Di0o0BdV.mjs → types-q7wtjfxb.mjs}

@@ -29,7 +29,7 @@ import { SandboxManager } from '@anthropic-ai/sandbox-runtime';
 import { Expo } from 'expo-server-sdk';
 
 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 = [
@@ -142,12 +142,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:*",
@@ -720,6 +720,11 @@ const sessionProgressEventSchema = z.object({
   durationMs: z.number().optional(),
   summary: z.string().optional()
 });
+const sessionQueueCancelEventSchema = z.object({
+  t: z.literal("queue-cancel"),
+  targetLocalKeys: z.array(z.string().min(1)).min(1),
+  reason: z.string().min(1).optional()
+});
 const sessionEventSchema = z.discriminatedUnion("t", [
   sessionTextEventSchema,
   sessionServiceMessageEventSchema,
@@ -730,7 +735,8 @@ const sessionEventSchema = z.discriminatedUnion("t", [
   sessionStartEventSchema,
   sessionTurnEndEventSchema,
   sessionStopEventSchema,
-  sessionProgressEventSchema
+  sessionProgressEventSchema,
+  sessionQueueCancelEventSchema
 ]);
 const sessionEnvelopeSchema = z.object({
   id: z.string(),
@@ -1004,6 +1010,20 @@ const ReleaseDrainNoticeSchema = z$1.object({
   deadline: z$1.number().int().positive(),
   mode: z$1.literal("make-before-break")
 });
+const ConnectionDiagnosticEventSchema = z$1.object({
+  attemptId: z$1.string().uuid(),
+  machineId: z$1.string().min(1).max(256).regex(/^[A-Za-z0-9_-]+$/).optional(),
+  at: z$1.number().int().min(0).max(Number.MAX_SAFE_INTEGER),
+  stage: z$1.enum(["control", "relay_discovery", "relay_connect", "relay_probe", "machine_rpc", "terminal_open"]),
+  outcome: z$1.enum(["started", "success", "timeout", "error", "offline", "cancelled", "fallback"]),
+  durationMs: z$1.number().int().min(0).max(3e5),
+  deviceClass: z$1.enum(["mobile", "desktop", "unknown"]),
+  visibility: z$1.enum(["visible", "hidden"]),
+  client: z$1.string().regex(/^web\/(?:[a-f0-9]{7,40}|unknown)$/)
+}).strict();
+z$1.object({
+  events: z$1.array(ConnectionDiagnosticEventSchema).min(1).max(32)
+}).strict();
 
 z$1.object({
   host: z$1.string(),
@@ -3113,6 +3133,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;
 }
@@ -3756,8 +3818,75 @@ class ApiSessionClient extends 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) {
@@ -14369,28 +14498,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);
@@ -14398,25 +14549,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;
   }
@@ -14530,6 +14688,7 @@ async function withCodexAppServerClient(handler) {
     await client.disconnect();
   }
 }
+const CLI_AVAILABILITY_RECHECK_MS = 5 * 60 * 1e3;
 class ApiMachineClient {
   constructor(token, machine) {
     this.token = token;
@@ -14553,6 +14712,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;
@@ -15420,6 +15583,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();
@@ -16647,4 +16814,4 @@ const RawJSONLinesSchema = z$1.discriminatedUnion("type", [
   }).passthrough()
 ]);
 
-export { decideMirrorBinding as $, ApiClient as A, readCredentials as B, credentialRelayProblem as C, deriveLocalCliUpdateSummary as D, readSettingsOutcome as E, updateSettings as F, encodeBase64Url as G, decodeBase64 as H, InvalidateSync as I, writeCredentialsLegacy as J, writeCredentialsDataKey as K, readCredentialsForConfiguredRelay as L, MAX_CHAT_ATTACHMENT_SOURCE_BYTES as M, encrypt as N, isClaudeSessionId as O, getLocalHappyAgentCredentialPath as P, readLocalHappyAgentCredentials as Q, RawJSONLinesSchema as R, STREAM_DELTA_MAX_CHARS as S, decryptWithDataKey as T, decryptLegacy as U, compareExactVersions as V, extractCompleteLines as W, decideBackfill as X, parseTerminalHookPayload as Y, tmuxArgs as Z, scrubTmuxClientEnv as _, ApiSessionClient as a, MIRROR_BACKFILL_LINES_DEFAULT as a0, persistSession as a1, mirrorLineKey as a2, mirrorLocalId as a3, detectCLIAvailability as a4, detectResumeSupport as a5, acquireDaemonLock as a6, summarizeSpawnSessionForLog as a7, deletePersistedSessions as a8, shellescape as a9, decrypt as aa, writeDaemonState as ab, writeSettings as ac, fetchCliUpdateState as ad, resolveCliUpdateCheckInterval as ae, DEFAULT_CLI_UPDATE_CHECK_INTERVAL_MS as af, releaseDaemonLock as ag, listVhTerminals as ah, isValidTerminalId as ai, readVhTerminal as aj, sendToVhTerminal as ak, TITLE_PROMPT_PREFIX as al, BOARD_ANALYZER_PROMPT_PREFIX as am, startOfflineReconnection as an, clearCredentials as ao, clearMachineId as ap, SandboxConfigSchema as aq, CodexAppServerClient as ar, getLatestDaemonLog as as, persistence as at, api as au, createEnvelope as b, configuration as c, connectionState as d, readSettings as e, encodeBase64 as f, contentLogMetadata as g, errorLogMetadata as h, isValidSessionId as i, packageJson as j, delay as k, logger as l, ensurePrivateDirectorySync as m, hardenPrivateFileSync as n, readDaemonState as o, projectPath as p, clearDaemonState as q, readPersistedSessions as r, getProjectPath as s, initializeSandbox as t, wrapCommand as u, AsyncLock as v, writePrivateFileSync as w, ensurePrivateDirectory as x, hardenPrivateFile as y, commandOnPath as z };
+export { scrubTmuxClientEnv as $, ApiClient as A, commandOnPath as B, readCredentials as C, credentialRelayProblem as D, deriveLocalCliUpdateSummary as E, readSettingsOutcome as F, updateSettings as G, encodeBase64Url as H, InvalidateSync as I, decodeBase64 as J, writeCredentialsLegacy as K, writeCredentialsDataKey as L, MAX_CHAT_ATTACHMENT_SOURCE_BYTES as M, readCredentialsForConfiguredRelay as N, encrypt as O, isClaudeSessionId as P, getLocalHappyAgentCredentialPath as Q, RawJSONLinesSchema as R, STREAM_DELTA_MAX_CHARS as S, readLocalHappyAgentCredentials as T, decryptWithDataKey as U, decryptLegacy as V, compareExactVersions as W, extractCompleteLines as X, decideBackfill as Y, parseTerminalHookPayload as Z, tmuxArgs as _, ApiSessionClient as a, decideMirrorBinding as a0, MIRROR_BACKFILL_LINES_DEFAULT as a1, persistSession as a2, mirrorLineKey as a3, mirrorLocalId as a4, detectCLIAvailability as a5, detectResumeSupport as a6, acquireDaemonLock as a7, summarizeSpawnSessionForLog as a8, deletePersistedSessions as a9, shellescape as aa, decrypt as ab, writeDaemonState as ac, writeSettings as ad, fetchCliUpdateState as ae, resolveCliUpdateCheckInterval as af, DEFAULT_CLI_UPDATE_CHECK_INTERVAL_MS as ag, releaseDaemonLock as ah, listVhTerminals as ai, isValidTerminalId as aj, readVhTerminal as ak, sendToVhTerminal as al, TITLE_PROMPT_PREFIX as am, BOARD_ANALYZER_PROMPT_PREFIX as an, startOfflineReconnection as ao, clearCredentials as ap, clearMachineId as aq, SandboxConfigSchema as ar, CodexAppServerClient as as, getLatestDaemonLog as at, persistence as au, api as av, createEnvelope as b, configuration as c, connectionState as d, readSettings as e, encodeBase64 as f, contentLogMetadata as g, errorLogMetadata as h, isValidSessionId as i, packageJson as j, delay as k, logger as l, ensurePrivateDirectorySync as m, hardenPrivateFileSync as n, readDaemonState as o, projectPath as p, clearDaemonState as q, readPersistedSessions as r, streamKeyOf as s, getProjectPath as t, initializeSandbox as u, wrapCommand as v, writePrivateFileSync as w, AsyncLock as x, ensurePrivateDirectory as y, hardenPrivateFile as z };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "very-happy-cli",
-  "version": "0.2.120",
+  "version": "0.2.122",
   "description": "Remote multi-agent workspace CLI with deep Claude integration, native terminal streaming, and self-hosting.",
   "author": "Kirill Dubovitskiy",
   "contributors": [
@@ -113,12 +113,12 @@
     "zod": "^4.0.0"
   },
   "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"
   },
   "devDependencies": {
     "@slopus/happy-wire": "workspace:*",