commandmate 0.34.1 → 0.36.0

package/dist/lib/detection/tools/verified-against.d.ts

@@ -109,6 +109,26 @@ export declare const ANTIGRAVITY_VERIFIED_AGAINST: {
  * tmux socket at the production geometry — the default pane size does not
  * reproduce the 200-column rules that fence the composer, and the status row
  * drops its `esc to interrupt` tail below 72 columns.
+ *
+ * ## Deliberately NOT advanced by Issues #2521 / #2522
+ *
+ * Both read the `AskUserQuestion` screen, and both did it from the anonymised
+ * capture in `tests/fixtures/command-code-askuserquestion-2521/` — whose rows
+ * 410-423 are verbatim from a live pane, but whose version is what the reporting
+ * session SAID it was (1.53.0) rather than something re-probed. #2522's own
+ * fixture directory is synthetic throughout, and the send mode
+ * (`submitMode: 'answer_only'`) was chosen from a STATIC reading of a locally
+ * installed 1.53.1 `QuestionPrompt` plus the safe-direction argument in
+ * `tools/command-code/dialog.ts` — not from a keystroke sent at a live pane.
+ *
+ * None of that is the measurement this stamp records. #2304 set the precedent in
+ * the other direction: seven frames re-captured live on 1.49.0 changed no rule,
+ * and the stamp still says 1.40.1 because that is the build the rules were READ
+ * OFF. Advancing it here on a reported version, a synthetic fixture and a
+ * package read off disk would make `getDetectorFreshness` claim a measurement
+ * nobody took. When a live 1.53.x session is probed — the question screen, the
+ * keys it accepts and what one of them advances — bump this to that exact
+ * version with its own `capturedAt`.
  */
 export declare const COMMAND_CODE_VERIFIED_AGAINST: {
     readonly version: "1.40.1";

package/dist/lib/detection/tools/verified-against.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"verified-against.d.ts","sourceRoot":"","sources":["../../../../src/lib/detection/tools/verified-against.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAEH,iEAAiE;AACjE,eAAO,MAAM,uBAAuB;;;;CAI1B,CAAC;AAEX,4EAA4E;AAC5E,eAAO,MAAM,sBAAsB;;;;CAIzB,CAAC;AAEX;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,wBAAwB;;;;CAI3B,CAAC;AAEX;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,yBAAyB;;;;CAI5B,CAAC;AAEX;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,eAAO,MAAM,4BAA4B;;;;CAI/B,CAAC;AAEX;;;;;;;GAOG;AACH,eAAO,MAAM,6BAA6B;;;;CAIhC,CAAC;AAEX;;;;;;;GAOG;AACH,eAAO,MAAM,2BAA2B;;;;CAI9B,CAAC;AAEX,iFAAiF;AACjF,MAAM,WAAW,oBAAoB;IACnC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;CAC/B;AAED;;;;;;GAMG;AACH,eAAO,MAAM,yBAAyB,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,oBAAoB,CAAC,CASpF,CAAC"}
+{"version":3,"file":"verified-against.d.ts","sourceRoot":"","sources":["../../../../src/lib/detection/tools/verified-against.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAEH,iEAAiE;AACjE,eAAO,MAAM,uBAAuB;;;;CAI1B,CAAC;AAEX,4EAA4E;AAC5E,eAAO,MAAM,sBAAsB;;;;CAIzB,CAAC;AAEX;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,wBAAwB;;;;CAI3B,CAAC;AAEX;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,yBAAyB;;;;CAI5B,CAAC;AAEX;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,eAAO,MAAM,4BAA4B;;;;CAI/B,CAAC;AAEX;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,eAAO,MAAM,6BAA6B;;;;CAIhC,CAAC;AAEX;;;;;;;GAOG;AACH,eAAO,MAAM,2BAA2B;;;;CAI9B,CAAC;AAEX,iFAAiF;AACjF,MAAM,WAAW,oBAAoB;IACnC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;CAC/B;AAED;;;;;;GAMG;AACH,eAAO,MAAM,yBAAyB,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,oBAAoB,CAAC,CASpF,CAAC"}

package/dist/lib/detection/tools/verified-against.js

@@ -112,6 +112,26 @@ exports.ANTIGRAVITY_VERIFIED_AGAINST = {
  * tmux socket at the production geometry — the default pane size does not
  * reproduce the 200-column rules that fence the composer, and the status row
  * drops its `esc to interrupt` tail below 72 columns.
+ *
+ * ## Deliberately NOT advanced by Issues #2521 / #2522
+ *
+ * Both read the `AskUserQuestion` screen, and both did it from the anonymised
+ * capture in `tests/fixtures/command-code-askuserquestion-2521/` — whose rows
+ * 410-423 are verbatim from a live pane, but whose version is what the reporting
+ * session SAID it was (1.53.0) rather than something re-probed. #2522's own
+ * fixture directory is synthetic throughout, and the send mode
+ * (`submitMode: 'answer_only'`) was chosen from a STATIC reading of a locally
+ * installed 1.53.1 `QuestionPrompt` plus the safe-direction argument in
+ * `tools/command-code/dialog.ts` — not from a keystroke sent at a live pane.
+ *
+ * None of that is the measurement this stamp records. #2304 set the precedent in
+ * the other direction: seven frames re-captured live on 1.49.0 changed no rule,
+ * and the stamp still says 1.40.1 because that is the build the rules were READ
+ * OFF. Advancing it here on a reported version, a synthetic fixture and a
+ * package read off disk would make `getDetectorFreshness` claim a measurement
+ * nobody took. When a live 1.53.x session is probed — the question screen, the
+ * keys it accepts and what one of them advances — bump this to that exact
+ * version with its own `capturedAt`.
  */
 exports.COMMAND_CODE_VERIFIED_AGAINST = {
     version: '1.40.1',

package/dist/server/src/config/websocket-config.js

@@ -0,0 +1,67 @@
+"use strict";
+/**
+ * WebSocket heartbeat / reconnect constants shared by the server and the browser.
+ *
+ * Issue #2502: the socket had no liveness probe at all, so a half-open path — a
+ * phone that walked out of range, a laptop resuming from sleep, a Wi-Fi/LTE
+ * handover — stayed `connected` on both ends while every frame fell on the
+ * floor. TCP alone does not notice: without traffic neither side gets a RST,
+ * and `readyState` keeps answering OPEN. The only way out is to put bytes on
+ * the wire on a schedule and treat silence as a disconnect.
+ *
+ * Server and client read the same numbers from here because the two halves are
+ * a single protocol: the client's patience has to be a multiple of the server's
+ * beat, or a healthy connection gets killed between beats.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WS_HALF_OPEN_CLOSE_CODE = exports.WS_RECONNECT_JITTER_RATIO = exports.WS_RECONNECT_MAX_DELAY_MS = exports.WS_RECONNECT_BASE_DELAY_MS = exports.WS_CLIENT_LIVENESS_TIMEOUT_MS = exports.WS_CLIENT_LIVENESS_CHECK_INTERVAL_MS = exports.WS_HEARTBEAT_MESSAGE_TYPE = exports.WS_SERVER_HEARTBEAT_INTERVAL_MS = void 0;
+/**
+ * How often the server pings every client and emits an application-level beat.
+ *
+ * 30s is the `ws` library's own recipe cadence and stays well inside the idle
+ * timeouts of the proxies CommandMate is tunnelled through (Cloudflare Quick
+ * Tunnel, Tailscale Serve), which is a second reason to send it at all.
+ */
+exports.WS_SERVER_HEARTBEAT_INTERVAL_MS = 30_000;
+/**
+ * Server → client application-level beat (Issue #2502).
+ *
+ * A protocol-level ping is invisible to a browser: the WebSocket API answers
+ * pings automatically and gives page JavaScript no way to observe either the
+ * ping or its own pong. So the server sends this frame alongside the protocol
+ * ping — same cadence, same sweep — purely so the tab has something it CAN see.
+ * The client consumes it for liveness and does not forward it to listeners.
+ */
+exports.WS_HEARTBEAT_MESSAGE_TYPE = 'heartbeat';
+/** How often the client checks how long it has been since anything arrived. */
+exports.WS_CLIENT_LIVENESS_CHECK_INTERVAL_MS = 5_000;
+/**
+ * Silence, in ms, after which the client declares the socket half-open.
+ *
+ * 2.5x the server beat: one lost or late heartbeat must not tear down a healthy
+ * connection, but two in a row is not something a live path does. Anything
+ * inbound refreshes the clock — a broadcast, a terminal chunk, the beat — so a
+ * busy socket never gets near this.
+ */
+exports.WS_CLIENT_LIVENESS_TIMEOUT_MS = 75_000;
+/** Default base delay for the client's reconnect backoff. */
+exports.WS_RECONNECT_BASE_DELAY_MS = 1_000;
+/** Default ceiling for the client's reconnect backoff. */
+exports.WS_RECONNECT_MAX_DELAY_MS = 30_000;
+/**
+ * Fraction of the computed backoff the client randomises by, +/- (Issue #2502).
+ *
+ * Without it every tab that was connected to a restarting server retries on the
+ * identical 1s/2s/4s grid and the thundering herd lands on the first socket the
+ * new process opens. +/-20% is enough to smear the herd across the window while
+ * keeping the backoff's shape recognisable.
+ */
+exports.WS_RECONNECT_JITTER_RATIO = 0.2;
+/**
+ * Close code the client uses when it gives up on a silent socket.
+ *
+ * In the application-private 4000-4999 range (1000-2999 are reserved by the
+ * protocol and browsers throw on most of them), so a server-side close log can
+ * tell "the tab decided this path was dead" apart from an ordinary goodbye.
+ */
+exports.WS_HALF_OPEN_CLOSE_CODE = 4001;

package/dist/server/src/lib/auto-yes-poller.js

@@ -49,6 +49,7 @@ exports.clearAllPollerStates = clearAllPollerStates;
 exports.getLastServerResponseTimestamp = getLastServerResponseTimestamp;
 exports.isPollerActive = isPollerActive;
 exports.validatePollingContext = validatePollingContext;
+exports.capturePollerFrame = capturePollerFrame;
 exports.captureAndCleanOutput = captureAndCleanOutput;
 exports.processStopConditionDelta = processStopConditionDelta;
 exports.detectAndRespondToPrompt = detectAndRespondToPrompt;
@@ -224,9 +225,28 @@ function validatePollingContext(compositeKey, pollerState) {
     }
     return 'valid';
 }
+/**
+ * Capture tmux session output once, keeping both spellings (Issue #2522).
+ *
+ * @internal Exported for testing purposes only.
+ * @param worktreeId - Worktree identifier
+ * @param cliToolId - CLI tool type being polled
+ * @param captureLines - Optional number of lines to capture
+ * @param instanceId - Optional agent instance ID (Issue #896; defaults to primary session)
+ * @returns The tick's raw capture and its cleaned form
+ */
+async function capturePollerFrame(worktreeId, cliToolId, captureLines, instanceId) {
+    const lines = captureLines ?? auto_yes_config_1.FULL_CAPTURE_LINES;
+    const output = await (0, cli_session_1.captureSessionOutput)(worktreeId, cliToolId, lines, instanceId);
+    return { raw: output, clean: (0, cli_patterns_1.stripBoxDrawing)((0, cli_patterns_1.stripAnsi)(output)) };
+}
 /**
  * Capture tmux session output and strip ANSI escape codes.
  *
+ * Kept as the cleaned half of {@link capturePollerFrame} so the many callers and
+ * tests that only ever wanted that string are untouched; `pollAutoYes` takes the
+ * pair. `stripBoxDrawing` still runs exactly once per capture either way.
+ *
  * @internal Exported for testing purposes only.
  * @param worktreeId - Worktree identifier
  * @param cliToolId - CLI tool type being polled
@@ -235,9 +255,7 @@ function validatePollingContext(compositeKey, pollerState) {
  * @returns Cleaned output string (ANSI stripped)
  */
 async function captureAndCleanOutput(worktreeId, cliToolId, captureLines, instanceId) {
-    const lines = captureLines ?? auto_yes_config_1.FULL_CAPTURE_LINES;
-    const output = await (0, cli_session_1.captureSessionOutput)(worktreeId, cliToolId, lines, instanceId);
-    return (0, cli_patterns_1.stripBoxDrawing)((0, cli_patterns_1.stripAnsi)(output));
+    return (await capturePollerFrame(worktreeId, cliToolId, captureLines, instanceId)).clean;
 }
 /**
  * Process stop condition check using delta-based approach.
@@ -276,9 +294,12 @@ function processStopConditionDelta(compositeKey, pollerState, cleanOutput) {
  * @param cleanOutput - ANSI-stripped terminal output
  * @param precomputedLines - Optional pre-split lines to reuse
  * @param instanceId - Optional agent instance ID (Issue #896; defaults to primary session)
+ * @param rawOutput - The SAME tick's capture with its box drawing intact
+ *   (Issue #2522). Omitting it costs Command Code's `AskUserQuestion` and
+ *   nothing else; see {@link capturePollerFrame}.
  * @returns 'responded' | 'no_prompt' | 'duplicate' | 'no_answer' | 'error'
  */
-async function detectAndRespondToPrompt(worktreeId, pollerState, cliToolId, cleanOutput, precomputedLines, instanceId) {
+async function detectAndRespondToPrompt(worktreeId, pollerState, cliToolId, cleanOutput, precomputedLines, instanceId, rawOutput) {
     const compositeKey = (0, auto_yes_state_1.buildCompositeKey)(worktreeId, cliToolId, instanceId);
     try {
         // 1. Detect prompt.
@@ -301,7 +322,15 @@ async function detectAndRespondToPrompt(worktreeId, pollerState, cliToolId, clea
         // `cleanOutput` is handed over already stripped, and the clean-frame entry
         // is the one that does not strip again (`stripBoxDrawing` is not
         // idempotent), so this poller and the response poller judge identical text.
-        const promptDetection = (0, response_checker_1.detectPromptOnCleanFrame)(cleanOutput, cliToolId, precomputedLines);
+        //
+        // Issue #2522 adds the fourth argument, and it is a WIRING change rather
+        // than a reader one: Command Code's `AskUserQuestion` is anchored on the
+        // rule row `captureAndCleanOutput` blanks, so teaching
+        // `detectPromptOnCleanFrame` to read it changed nothing on this path until
+        // the same tick's raw capture reached it. `precomputedLines` stays the split
+        // of `cleanOutput` — the stop-condition delta and every other tool's reading
+        // are measured on that string and must not move.
+        const promptDetection = (0, response_checker_1.detectPromptOnCleanFrame)(cleanOutput, cliToolId, precomputedLines, rawOutput);
         if (!promptDetection.isPrompt || !promptDetection.promptData) {
             pollerState.lastAnsweredPromptKey = null;
             pollerState.lastAnsweredAt = null;
@@ -519,14 +548,18 @@ async function pollAutoYes(worktreeId, cliToolId, instanceId) {
         const captureLines = autoYesState?.stopPattern
             ? auto_yes_config_1.FULL_CAPTURE_LINES
             : auto_yes_config_1.REDUCED_CAPTURE_LINES;
-        const cleanOutput = await captureAndCleanOutput(worktreeId, cliToolId, captureLines, instanceId);
+        // Issue #2522: one capture, both spellings. The cleaned string drives every
+        // step below exactly as it did; the raw one is carried to the prompt reading
+        // so a dialog anchored on box drawing is not invisible to the one path that
+        // can answer it without a human.
+        const { raw: rawOutput, clean: cleanOutput } = await capturePollerFrame(worktreeId, cliToolId, captureLines, instanceId);
         const lines = cleanOutput.split('\n');
         // 3. Stop condition delta check (Issue #314)
         if (processStopConditionDelta(compositeKey, pollerState, cleanOutput)) {
             return;
         }
         // 4. Detect and respond to prompt
-        const result = await detectAndRespondToPrompt(worktreeId, pollerState, cliToolId, cleanOutput, lines, instanceId);
+        const result = await detectAndRespondToPrompt(worktreeId, pollerState, cliToolId, cleanOutput, lines, instanceId, rawOutput);
         if (result === 'responded') {
             scheduleNextPoll(worktreeId, cliToolId, instanceId, auto_yes_state_1.COOLDOWN_INTERVAL_MS);
             return;

package/dist/server/src/lib/auto-yes-state.js

@@ -28,6 +28,7 @@ exports.getAutoYesStateCompositeKeys = getAutoYesStateCompositeKeys;
 exports.filterCompositeKeysByWorktree = filterCompositeKeysByWorktree;
 exports.getCompositeKeysByWorktree = getCompositeKeysByWorktree;
 exports.deleteAutoYesStateByWorktree = deleteAutoYesStateByWorktree;
+exports.getEnabledAutoYesByWorktree = getEnabledAutoYesByWorktree;
 exports.migrateAutoYesStateWorktreeIds = migrateAutoYesStateWorktreeIds;
 exports.calculateBackoffInterval = calculateBackoffInterval;
 const auto_yes_config_1 = require("../config/auto-yes-config");
@@ -464,6 +465,41 @@ function deleteAutoYesStateByWorktree(worktreeId) {
     keys.forEach(key => autoYesStates.delete(key));
     return keys.length;
 }
+/**
+ * Every enabled Auto-Yes state, grouped by worktree and keyed by instance, for
+ * the worktree list payload (Issue #2512).
+ *
+ * One pass over the map for the whole server rather than a
+ * {@link getCompositeKeysByWorktree} scan per row, so the list route stays
+ * O(states) however many worktrees it returns. Reads go through
+ * {@link getAutoYesState}, which resolves an expired state to disabled — the
+ * same read-time expiry `GET /api/worktrees/:id/auto-yes` applies — so the list
+ * never reports a countdown that has already run out on the server.
+ *
+ * Disabled states are left out: a reader renders "never enabled", "turned off"
+ * and "expired" identically, and the map keeps disabled entries around for
+ * inspection long after anyone needs them on the wire.
+ *
+ * @returns worktreeId -> instanceId -> summary; worktrees with nothing armed are absent
+ */
+function getEnabledAutoYesByWorktree() {
+    const byWorktree = new Map();
+    // A snapshot of the keys: an expired read below rewrites its own entry.
+    for (const key of Array.from(autoYesStates.keys())) {
+        const cliToolId = extractCliToolId(key);
+        if (!cliToolId)
+            continue;
+        const worktreeId = extractWorktreeId(key);
+        const instanceId = extractInstanceId(key) ?? cliToolId;
+        const state = getAutoYesState(worktreeId, cliToolId, instanceId);
+        if (!state?.enabled)
+            continue;
+        const entries = byWorktree.get(worktreeId) ?? {};
+        entries[instanceId] = { enabled: true, expiresAt: state.expiresAt };
+        byWorktree.set(worktreeId, entries);
+    }
+    return byWorktree;
+}
 /**
  * Re-key every auto-yes state whose worktree ID is being renamed
  * (Issue #1621 Phase 3).