commandmate 0.47.0 → 0.48.0

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

@@ -0,0 +1,35 @@
+"use strict";
+/**
+ * Auto-Yes poller: which composite keys have a poller entry (Issue #525)
+ * (Issue #3893: split out of `auto-yes-poller.ts`, which re-exports these).
+ *
+ * Reads `autoYesPollerStates`, owned by `polling/auto-yes-poller-generation`.
+ * Does not import `auto-yes-poller.ts` (no cycle).
+ *
+ * @module lib/auto-yes-poller-keys
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAutoYesPollerCompositeKeys = getAutoYesPollerCompositeKeys;
+exports.isAnyPollerActiveForWorktree = isAnyPollerActiveForWorktree;
+const auto_yes_state_1 = require("./auto-yes-state");
+const auto_yes_poller_generation_1 = require("./polling/auto-yes-poller-generation");
+/**
+ * Get all composite keys that have active auto-yes poller entries.
+ *
+ * Issue #525: Returns composite keys (worktreeId:cliToolId).
+ *
+ * @returns Array of composite keys present in the autoYesPollerStates Map
+ */
+function getAutoYesPollerCompositeKeys() {
+    return Array.from(auto_yes_poller_generation_1.autoYesPollerStates.keys());
+}
+/**
+ * Check if any auto-yes poller is active for a given worktreeId.
+ * Uses shared filterCompositeKeysByWorktree (DRY).
+ *
+ * @param worktreeId - Worktree identifier
+ * @returns true if any poller is active for this worktree
+ */
+function isAnyPollerActiveForWorktree(worktreeId) {
+    return (0, auto_yes_state_1.filterCompositeKeysByWorktree)(Array.from(auto_yes_poller_generation_1.autoYesPollerStates.keys()), worktreeId).length > 0;
+}

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

@@ -0,0 +1,26 @@
+"use strict";
+/**
+ * Auto-Yes poller: whether the session a failed capture was for is gone
+ * (Issue #3329) (Issue #3893: split out of `auto-yes-poller.ts`).
+ *
+ * Does not import `auto-yes-poller.ts` (no cycle).
+ *
+ * @module lib/auto-yes-poller-session-presence
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isSessionMissing = isSessionMissing;
+const cli_session_1 = require("./session/cli-session");
+/**
+ * Whether a failed capture failed because the session does not exist
+ * (Issue #3329). Asked of tmux (`has-session`'s exit code), not read off the
+ * error text. `unknown` — tmux timed out or could not be run — is not "absent":
+ * the failure is counted as before, so a broken tmux still stops Auto-Yes.
+ */
+async function isSessionMissing(worktreeId, cliToolId, instanceId) {
+    try {
+        return (await (0, cli_session_1.getSessionPresence)(worktreeId, cliToolId, instanceId)) === 'absent';
+    }
+    catch {
+        return false;
+    }
+}

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

@@ -0,0 +1,233 @@
+"use strict";
+/**
+ * Auto-Yes poller: what one tick reads off its frame and records about it —
+ * the prompt reading, the no-prompt bookkeeping, the decision recorder and the
+ * ledger's labels (Issue #3893: split out of `auto-yes-poller.ts`).
+ *
+ * Does not import `auto-yes-poller.ts` (no cycle). Nor `polling/response-checker`:
+ * that module reaches the poller back through `auto-yes-manager`, so the frame
+ * reader is handed in by the poller (`detectPromptOnCleanFrame` below).
+ *
+ * @module lib/auto-yes-poller-tick
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readPromptFrame = readPromptFrame;
+exports.captureTopOf = captureTopOf;
+exports.noteNoPromptOnScreen = noteNoPromptOnScreen;
+exports.tickDecisionRecorder = tickDecisionRecorder;
+exports.ledgerCallOf = ledgerCallOf;
+exports.attemptResultOfThrow = attemptResultOfThrow;
+exports.answerBasisOf = answerBasisOf;
+const antigravity_receipt_episodes_1 = require("./polling/antigravity-receipt-episodes");
+const frame_1 = require("./detection/tools/frame");
+const dialog_1 = require("./detection/tools/antigravity/dialog");
+const auto_yes_decision_state_1 = require("./polling/auto-yes-decision-state");
+const auto_yes_suppression_state_1 = require("./polling/auto-yes-suppression-state");
+const manager_1 = require("./cli-tools/manager");
+const auto_yes_state_1 = require("./auto-yes-state");
+const auto_yes_poller_state_1 = require("./polling/auto-yes-poller-state");
+const auto_yes_prompt_suppression_1 = require("./polling/auto-yes-prompt-suppression");
+const auto_yes_poller_generation_1 = require("./polling/auto-yes-poller-generation");
+const auto_yes_poller_receipt_log_1 = require("./polling/auto-yes-poller-receipt-log");
+const prompt_screen_reading_1 = require("./polling/prompt-screen-reading");
+const auto_yes_confirmation_ledger_1 = require("./polling/auto-yes-confirmation-ledger");
+/**
+ * Step 1 of `detectAndRespondToPrompt`: normalise the tick's frame once and
+ * read the prompt on it.
+ */
+function readPromptFrame(worktreeId, cliToolId, cleanOutput, precomputedLines, instanceId, rawOutput, captureExtent, detectPromptOnCleanFrame) {
+    const receiptScope = { worktreeId, instanceId };
+    // Issue #3183: the ONE frame every judgement below reads — normalised once,
+    // from the capture as captured (the input-box markers are rule rows the
+    // cleaned spelling has blanked), and handed as the same object to the
+    // prompt reading, the codex launch guards and the dialog gate. That is what
+    // makes "the status chain and Auto-Yes read the same live region" a fact
+    // rather than a hope: there is no second normalisation to disagree with.
+    const frame = (0, frame_1.normalizeFrame)(rawOutput ?? cleanOutput, cliToolId);
+    // Issue #3767: bracket the read so the receipt gate can tell when an agy
+    // dialog first appeared, not only what time this tick is.
+    if (cliToolId === 'antigravity')
+        (0, antigravity_receipt_episodes_1.beginAntigravityFrameRead)(worktreeId, instanceId);
+    const promptDetection = detectPromptOnCleanFrame(cleanOutput, cliToolId, precomputedLines, rawOutput, receiptScope, frame);
+    if (cliToolId === 'antigravity')
+        (0, antigravity_receipt_episodes_1.endAntigravityFrameRead)(worktreeId, instanceId);
+    return {
+        frame,
+        promptDetection: withCaptureTop(promptDetection, cliToolId, rawOutput ?? cleanOutput, captureExtent),
+    };
+}
+/**
+ * Issue #3881 (review P2-1): an approval target whose upward scan reached the
+ * top of a capture that filled its window is marked `top-unknown`, so the
+ * resolver does not answer on a deny miss. Without the window (a direct
+ * caller, a test) the capture's extent is not known and nothing is added, as
+ * before.
+ */
+function withCaptureTop(detection, cliToolId, capture, captureExtent) {
+    const captureTop = captureTopOf(capture, captureExtent, cliToolId);
+    return captureTop === undefined ? detection : (0, prompt_screen_reading_1.withCaptureTopCompleteness)(detection, captureTop);
+}
+/**
+ * Where a poller capture's first row sits (Issue #3881 review P2-1): on a
+ * scrollback pane the capture is the last `windowLines` rows, so one
+ * that came back with fewer rows holds the pane's whole history, and one that
+ * filled the window may be cut at its top (#1670's `isCaptureWindowSaturated`)
+ * unless the capture layer said it was not (the fourth review's N5: `headCut`);
+ * an alternate-screen pane has no history and is read off its screen (the
+ * second review's N1, `captureTopOf` in `prompt-screen-reading`), unless the
+ * window cut it (the third review's N4: `headCut`).
+ * Undefined when the window is not known.
+ */
+function captureTopOf(capture, captureExtent, cliToolId) {
+    return captureExtent === undefined
+        ? undefined
+        : (0, prompt_screen_reading_1.captureTopOf)(capture, captureExtent.windowLines, cliToolId, captureExtent.headCut);
+}
+/**
+ * What `detectAndRespondToPrompt` does to the poller state on a frame with no
+ * prompt to answer, before it returns `no_prompt`.
+ *
+ * @returns agy's dialog the ungated reading still sees past the receipt gate
+ *   (Issue #3821: the decision published for it), else null
+ */
+function noteNoPromptOnScreen(tick) {
+    const { worktreeId, cliToolId, instanceId, compositeKey, epoch, pollerState, frame, promptDetection, cleanOutput, precomputedLines, rawOutput, captureExtent, detectPromptOnCleanFrame, } = tick;
+    // Issue #3880: a person's hold, which agy's dialog past the receipt window
+    // keeps (below) — the gated reading's "no prompt" is not the dialog gone.
+    const personHold = cliToolId === 'antigravity' ? (0, auto_yes_poller_state_1.getPartialAnswer)(compositeKey, epoch) : null;
+    // The same for a person's send still in flight: one at the dialog the
+    // ungated reading still shows is not expired, so its outcome, coming back
+    // unknown, still holds the dialog. The ungated reading is taken once.
+    // Issue #3881: with the same capture-top reading as the tick's prompt, so the
+    // receipt log judges the contract on the frame's known top. The screen key
+    // (`partialAnswerScreenKey`) does not read `approvalTargetCompleteness`, so
+    // the in-flight sends are matched as before.
+    let ungated;
+    const readWithoutGate = () => (ungated ??= withCaptureTop(detectPromptOnCleanFrame(cleanOutput, cliToolId, precomputedLines, rawOutput), cliToolId, rawOutput ?? cleanOutput, captureExtent));
+    const personSends = cliToolId === 'antigravity' ? (0, auto_yes_poller_state_1.personSendsInFlight)(compositeKey, epoch) : [];
+    const dialogUp = personSends.length > 0 ? readWithoutGate() : null;
+    const dialogUpKey = dialogUp?.isPrompt && dialogUp.promptData ? (0, auto_yes_poller_state_1.partialAnswerScreenKey)(dialogUp.promptData) : null;
+    (0, auto_yes_poller_state_1.forgetPartialAnswer)(compositeKey, undefined, new Set(dialogUpKey === null
+        ? []
+        : personSends.filter((attempt) => (0, auto_yes_poller_state_1.partialAnswerCovers)(attempt.screenKey, dialogUpKey))));
+    pollerState.lastAnsweredPromptKey = null;
+    pollerState.lastAnsweredAt = null;
+    // Issue #3757: agy's trust screen reads as no prompt (unnumbered: neither
+    // reader takes it), but it is one nobody here answers — record why, still
+    // as `no_prompt`. Before the warn key is cleared, so the WARN stays once
+    // per screen.
+    // Issue #3820: the trust screen records itself in the ledger when it records
+    // its reason (`suppressAntigravityTrustScreen`).
+    if (cliToolId === 'antigravity' &&
+        (0, auto_yes_prompt_suppression_1.suppressAntigravityTrustScreen)(worktreeId, instanceId, pollerState, frame, manager_1.CLIToolManager.getInstance().getTool(cliToolId).getSessionName(worktreeId, instanceId))) {
+        return null;
+    }
+    pollerState.lastSkipWarnKey = null;
+    if (cliToolId === 'antigravity' && !promptDetection.isPrompt) {
+        const seen = (0, auto_yes_poller_receipt_log_1.logIfWithheldForWantOfReceipt)(worktreeId, instanceId, compositeKey, readWithoutGate, personHold?.byPerson ? personHold.screenKey : null);
+        if (personHold?.byPerson && seen?.keptPersonHold) {
+            (0, auto_yes_poller_state_1.keepPartialAnswerByPerson)(compositeKey, personHold, (0, auto_yes_poller_state_1.partialAnswerScreenKey)(seen.promptData));
+        }
+        // Issue #3820: past the receipt window the gated reading says "no prompt"
+        // while the dialog is still up. The ungated reading says it is, so the
+        // ledger keeps the same confirmation (and the same withheld interval)
+        // rather than closing it on every tick outside the window.
+        if (seen !== null) {
+            const scope = { compositeKey, worktreeId, cliToolId, instanceId };
+            (0, auto_yes_confirmation_ledger_1.observeLedgerScreen)(scope, (0, auto_yes_poller_state_1.ledgerScreenKey)(seen.promptData), seen.promptData.type, ledgerCallOf(cliToolId, worktreeId, instanceId));
+            if (seen.reason !== null)
+                (0, auto_yes_confirmation_ledger_1.withholdLedgerConfirmation)(scope, seen.reason);
+        }
+        return seen;
+    }
+    return null;
+}
+/**
+ * Issue #3821: records what one tick decided about the prompt it read, for
+ * `current-output` to publish (`autoYesDecision`, see
+ * `polling/auto-yes-decision-state`). Tied to the grant and the session epoch
+ * the tick read under, and to the confirmation (the prompt, and for agy the
+ * hook call its receipt was accepted for); a tick that lost its generation
+ * (#3706) records nothing, because the grant or the session it decided for is
+ * gone.
+ */
+function tickDecisionRecorder(tick) {
+    const { worktreeId, cliToolId, instanceId, compositeKey, promptData, epoch, generation, startedAt } = tick;
+    const grantOf = () => generation?.grant ?? (0, auto_yes_state_1.getAutoYesState)(worktreeId, cliToolId, instanceId);
+    const callId = ledgerCallOf(cliToolId, worktreeId, instanceId).callId ?? null;
+    const record = (state, reason) => {
+        if (generation !== undefined && !(0, auto_yes_poller_generation_1.isTickCurrent)(generation))
+            return;
+        (0, auto_yes_decision_state_1.recordAutoYesDecision)(compositeKey, { state, reason, promptData, callId, grant: grantOf(), epoch });
+    };
+    return {
+        answering: () => record('answering', null),
+        // The duplicate guard's "answered recently" compares the question only, so
+        // it is not evidence this confirmation is the one answered: `answering`
+        // stands only when the record the send made is about this confirmation,
+        // under the same grant and session (review 2). Otherwise nothing stands.
+        reaffirmAnswering: () => {
+            if (generation !== undefined && !(0, auto_yes_poller_generation_1.isTickCurrent)(generation)) {
+                (0, auto_yes_decision_state_1.forgetAutoYesDecision)(compositeKey);
+                return;
+            }
+            (0, auto_yes_decision_state_1.reaffirmAutoYesAnswering)(compositeKey, { promptData, callId, grant: grantOf(), epoch });
+        },
+        // The reason the step that withheld it recorded on this tick (the #1684
+        // record), else the step's own: a stop the policy record never carries.
+        withheld: (fallback) => {
+            const recorded = (0, auto_yes_suppression_state_1.getLastPolicySuppression)(worktreeId, cliToolId, instanceId);
+            record('withheld', recorded !== null && recorded.at >= startedAt ? recorded.reason : fallback);
+        },
+    };
+}
+/**
+ * Issue #3820 (design §2.4, PR 3): the agy call the receipt episode on screen
+ * was accepted for, for the ledger to tie the confirmation to. Asked after the
+ * frame was judged; read only to record, and never throws.
+ */
+function ledgerCallOf(cliToolId, worktreeId, instanceId) {
+    if (cliToolId !== 'antigravity')
+        return {};
+    try {
+        const callId = (0, antigravity_receipt_episodes_1.getAntigravityAcceptedReceiptCallId)(worktreeId, instanceId);
+        return callId === null ? {} : { callId };
+    }
+    catch {
+        // Recording only: a failure here ties nothing and changes nothing else.
+        return {};
+    }
+}
+/**
+ * Issue #3820: the result of a send that threw, as the ledger counts it.
+ * `keysSent` is what the sender said (#3706); a throw that says nothing is a
+ * failure whose keys may or may not be on the pane.
+ */
+function attemptResultOfThrow(keysSent) {
+    if (keysSent === true)
+        return 'partial';
+    if (keysSent === false)
+        return 'no-keys-sent';
+    return 'failed';
+}
+/**
+ * Issue #3820: the evidence an answer on the screen path is given on (design
+ * §7 PR 1). A tool's own dialog detector vouched for the frame: `L3`. The
+ * gate did not judge it (a `legacy` tool, a non-multiple-choice prompt): the
+ * generic reading alone, `L4`.
+ *
+ * agy's gate is `legacy` (`gated: false`), yet its prompts are read by its own
+ * reader first (`detectPromptOnCleanFrame` returns that reader's result
+ * whenever it reads the frame). Which reader it was is not on the detection
+ * result, so it is asked of the same reader on the same text here — for the
+ * label only; the answer was decided before this is called. Read by agy's own
+ * reader, and through the receipt gate (the tick's reading carried the
+ * receipt scope): `L3`, with `receiptAccepted` on the attempt.
+ */
+function answerBasisOf(prompt, cleanOutput) {
+    if (prompt.cliToolId === 'antigravity') {
+        return (0, dialog_1.detectAntigravityNumberedDialogPrompt)(cleanOutput) !== null ? 'L3' : 'L4';
+    }
+    const gate = prompt.dialogGate;
+    return gate !== undefined && gate.gated && gate.allowed && gate.dialog !== null ? 'L3' : 'L4';
+}