commandmate 0.49.2 → 0.50.0

package/dist/server/src/lib/cli-tools/antigravity.js

@@ -27,6 +27,8 @@ const launch_dialog_1 = require("./launch-dialog");
 const sources_1 = require("../../lib/hooks/sources");
 const agent_session_lifecycle_1 = require("../../lib/session/agent-session-lifecycle");
 const logger_1 = require("../../lib/logger");
+const status_detector_1 = require("../detection/status-detector");
+const launch_answer_skips_1 = require("./launch-answer-skips");
 const cli_tool_timing_config_1 = require("../../config/cli-tool-timing-config");
 const launch_screen_1 = require("../../lib/session/launch-screen");
 const errors_1 = require("../../lib/errors");
@@ -97,6 +99,22 @@ function describeScreen(output) {
         screenTail: rows.slice(-SCREEN_TAIL_ROWS).map((row) => row.slice(0, SCREEN_TAIL_MAX_CHARS)),
     };
 }
+/**
+ * What held the pane when the wait for the prompt ran out and no trust screen is
+ * involved (Issue #4161), for the refusal `send` reports. Names the screen only.
+ *
+ * @param output - The last capture read; null when none could be
+ */
+function describeAntigravityPaneHold(output) {
+    if (output === null)
+        return 'the pane could not be read';
+    const status = (0, status_detector_1.detectSessionStatus)(output, 'antigravity');
+    if (status.hasActivePrompt)
+        return 'a prompt dialog is open: answer it in the terminal';
+    if ((0, status_detector_1.isGeneratingStatus)(status))
+        return 'a turn is still being generated';
+    return 'no input prompt on the pane: agy may still be starting';
+}
 /**
  * Log, once per reason per wait, why a trust screen was left without its Enter
  * (Issue #3776). Names the dialog and the cursor's row, never the screen.
@@ -305,6 +323,7 @@ class AntigravityTool extends base_1.BaseCLITool {
         // One-shot guard: capturePane keeps the dismissed dialog in scrollback, so
         // Enter must be sent at most once per dialog.
         let trustDialogHandled = false;
+        const answerSkips = (0, launch_answer_skips_1.newLaunchAnswerSkips)();
         const loggedTrustDecisions = new Set();
         let lastOutput = null;
         let captureErrors = 0;
@@ -330,14 +349,18 @@ class AntigravityTool extends base_1.BaseCLITool {
                         // Issue #3952: typed as the composer's writer, and only while the
                         // screen still asks for this key once a send holding it is over.
                         const key = decision.key;
-                        const outcome = await (0, instance_input_lock_1.answerUnderInstanceInputLock)(sessionName, readMark, () => this.isTrustPressStill(sessionName, key), () => (0, tmux_1.sendSpecialKey)(sessionName, key));
+                        // Issue #4189: the session's life before the answer's await; a decline of an older life writes no record for the new one.
+                        const answerLife = (0, instance_input_lock_1.instanceInputAnswerSkipLife)(sessionName);
+                        const outcome = await (0, instance_input_lock_1.answerUnderInstanceInputLock)(sessionName, readMark, () => this.isTrustPressStill(sessionName, key), () => (0, tmux_1.sendSpecialKey)(sessionName, key), 
+                        // Issue #4189: the lock's warn of a decline, once per streak in this wait.
+                        { repeatScope: answerSkips });
                         if (outcome.answered) {
                             trustDialogHandled = true;
                             logger.info('auto-trusted-folder-for-antigravity');
                             await new Promise((resolve) => setTimeout(resolve, ANTIGRAVITY_DIALOG_SETTLE_MS));
                             continue;
                         }
-                        logger.info('antigravity-trust-answer-skipped', { sessionName, reason: outcome.reason });
+                        (0, launch_answer_skips_1.noteLaunchAnswerSkipped)(logger, answerSkips, 'antigravity-trust-answer-skipped', { sessionName, reason: outcome.reason }, answerLife);
                     }
                     logTrustDecisionOnce(sessionName, decision, loggedTrustDecisions);
                 }
@@ -395,6 +418,7 @@ class AntigravityTool extends base_1.BaseCLITool {
             : ANTIGRAVITY_PROMPT_WAIT_TIMEOUT_MS);
         const pollInterval = 500;
         const loggedTrustDecisions = new Set();
+        const answerSkips = (0, launch_answer_skips_1.newLaunchAnswerSkips)();
         let lastOutput = null;
         let captureErrors = 0;
         let lastCaptureError;
@@ -420,17 +444,26 @@ class AntigravityTool extends base_1.BaseCLITool {
                 // made only once the screen has been read again after a send holding
                 // the composer, so a screen that moved meanwhile keeps the Enter owed.
                 const pressKey = trustDecision?.action === 'press' ? trustDecision.key : null;
+                // Issue #4189: the session's life before the answer's await; a decline of an older life writes no record for the new one.
+                const answerLife = (0, instance_input_lock_1.instanceInputAnswerSkipLife)(sessionName);
                 const claimed = pressKey !== null && (0, antigravity_startup_trust_1.isStartupTrustPending)(sessionName)
                     ? await (0, instance_input_lock_1.answerUnderInstanceInputLock)(sessionName, readMark, () => this.isTrustPressStill(sessionName, pressKey), async () => {
                         if (!(0, antigravity_startup_trust_1.claimStartupTrust)(sessionName))
                             return false;
                         await (0, tmux_1.sendSpecialKey)(sessionName, pressKey);
                         return true;
-                    })
+                    }, { repeatScope: answerSkips })
                     : null;
                 if (claimed !== null && !claimed.answered) {
-                    logger.info('antigravity-trust-answer-skipped', { sessionName, reason: claimed.reason, afterLaunchWindow: true });
+                    (0, launch_answer_skips_1.noteLaunchAnswerSkipped)(logger, answerSkips, 'antigravity-trust-answer-skipped', {
+                        sessionName,
+                        reason: claimed.reason,
+                        afterLaunchWindow: true,
+                    }, answerLife);
                 }
+                // Answered with `false`: another wait holds the claim, so the Enter is its to send.
+                if (claimed?.answered === true)
+                    (0, launch_answer_skips_1.forgetLaunchAnswerSkip)(answerSkips, 'antigravity-trust-answer-skipped');
                 if (claimed?.answered === true && claimed.value) {
                     logger.info('auto-trusted-folder-for-antigravity', { sessionName, afterLaunchWindow: true });
                     // A full ordinary window for agy to draw its prompt after the Enter.
@@ -459,10 +492,10 @@ class AntigravityTool extends base_1.BaseCLITool {
         // A live trust screen here is one whose Enter was already sent (or never
         // owed): it is a human's now.
         const cause = seen.screen === 'trust-dialog'
-            ? ' (the folder-trust confirmation "Do you trust the contents of this project?" is on screen and needs an answer)'
+            ? ` (the folder-trust confirmation "Do you trust the contents of this project?" is on screen and needs an answer${answerSkips.last === null ? '' : `; its Enter was not sent: ${answerSkips.last}`})`
             : trustPending
                 ? ' (startup-trust-unhandled: agy had not shown its folder-trust confirmation when the launch window ended, and it has not appeared since)'
-                : '';
+                : ` (${describeAntigravityPaneHold(lastOutput)})`;
         throw new Error(`Antigravity prompt not ready: timed out waiting for the input prompt before sending${cause}`);
     }
     /**

package/dist/server/src/lib/cli-tools/base.js

@@ -32,9 +32,13 @@ const cli_tool_timing_config_1 = require("../../config/cli-tool-timing-config");
 const tmux_pane_config_1 = require("../../config/tmux-pane-config");
 const session_starting_state_1 = require("../session/session-starting-state");
 const session_launch_flight_1 = require("../session/session-launch-flight");
+const role_launch_1 = require("../session/role-launch");
+const pane_env_1 = require("../agent-roles/pane-env");
 const launch_keys_1 = require("./launch-keys");
 const execAsync = (0, util_1.promisify)(child_process_1.exec);
 const logger = (0, logger_1.createLogger)('cli-tools/base');
+/** How much of a pane the role's evidence reads, right after a launch. */
+const LAUNCH_ROLE_SCREEN_LINES = 200;
 /**
  * `CM_HOOK_URL='…'` as a launch line spells it (Issue #2429).
  *
@@ -237,19 +241,44 @@ class BaseCLITool {
         catch {
             // fall through: launchSession throws on it, inside the reporting below
         }
-        const launch = () => this.startSessionOnce(worktreeId, worktreePath, instanceId, model);
+        const launch = (role) => this.startSessionOnce(worktreeId, worktreePath, instanceId, model, role);
         if (sessionName === null)
-            return launch();
-        return (0, session_launch_flight_1.runSessionLaunch)(sessionName, this.name, launch, { cliToolId: this.id, model });
+            return launch(null);
+        const flightName = sessionName;
+        const startWith = (role) => {
+            // Issue #4115: a role that cannot be applied may not join someone else's launch either.
+            if (role?.refusal && (0, session_launch_flight_1.isSessionLaunchInFlight)(flightName))
+                return Promise.reject(role.refusal);
+            return (0, session_launch_flight_1.runSessionLaunch)(flightName, this.name, () => launch(role), {
+                cliToolId: this.id,
+                model,
+                injectionFingerprint: role === null || role.refusal ? undefined : role.injectionFingerprint,
+            });
+        };
+        // Issue #4115: the one entry for the role, whoever started this: a send, or
+        // `relaunchIfToolExited` inside one. Synchronous when no role is configured
+        // anywhere, so the flight is still registered in this tick (R4). With roles
+        // configured it waits for git first; nothing has touched tmux yet.
+        const roleTarget = { worktreeId, cliToolId: this.id, instanceId };
+        const epoch = (0, role_launch_1.readLaunchRoleEpoch)(roleTarget);
+        const role = (0, role_launch_1.requestLaunchRole)(roleTarget, worktreePath, (0, pane_env_1.roleEnvReaderForPane)(roleTarget));
+        if (!(role instanceof Promise))
+            return startWith(role);
+        return role.then((resolved) => {
+            (0, role_launch_1.assertNotStoppedWhileResolving)(roleTarget, epoch);
+            return startWith(resolved);
+        });
     }
     /** {@link startSession}'s body: one launch, its failure reported once. */
-    async startSessionOnce(worktreeId, worktreePath, instanceId, model) {
+    async startSessionOnce(worktreeId, worktreePath, instanceId, model, role = null) {
         // Issue #3195: this launch's "starting" record is written under this token
         // (see `session-starting-state`), so the `finally` below clears this
         // launch's record and never a later launch's of the same instance.
         const startingToken = (0, session_starting_state_1.issueSessionStartingToken)();
         try {
-            await (0, session_starting_state_1.runWithSessionStartingToken)(startingToken, () => this.launchSession(worktreeId, worktreePath, instanceId, model));
+            await (0, session_starting_state_1.runWithSessionStartingToken)(startingToken, () => role === null
+                ? this.launchSession(worktreeId, worktreePath, instanceId, model)
+                : (0, role_launch_1.runWithLaunchRole)(role, () => this.launchSessionWithRole(worktreeId, worktreePath, instanceId, model)));
         }
         catch (error) {
             // Issue #2429: a launch that threw is reported as a failed start and as
@@ -277,6 +306,35 @@ class BaseCLITool {
         if (adopted !== null)
             await this.warnIfHookUrlIsStale(worktreeId, adopted, instanceId);
     }
+    /**
+     * {@link launchSession} inside a launch that resolved its role (Issue #4115).
+     *
+     * The file is prepared before the driver creates a pane, so a refusal leaves no
+     * empty pane behind for a later send to read as a running agent. A refusal does
+     * not stop a reconnect: a process already there keeps the role it started with,
+     * and the driver's reuse branch builds no launch line.
+     */
+    async launchSessionWithRole(worktreeId, worktreePath, instanceId, model) {
+        const sessionName = this.getSessionName(worktreeId, instanceId);
+        const refusal = (0, role_launch_1.gateLaunchRole)();
+        if (refusal !== null && !((await (0, tmux_1.hasSession)(sessionName)) && (await this.isToolLive(sessionName, { confirm: true })))) {
+            throw refusal;
+        }
+        await this.launchSession(worktreeId, worktreePath, instanceId, model);
+        await (0, role_launch_1.settleLaunchRole)({
+            isAlive: () => this.isToolLive(sessionName),
+            capture: () => (0, tmux_1.capturePane)(sessionName, LAUNCH_ROLE_SCREEN_LINES),
+            kill: () => this.killSession(worktreeId, instanceId),
+            readServerConfig: () => this.readServerConfig(worktreeId, worktreePath, instanceId),
+        });
+    }
+    /**
+     * The config this tool's own server answers, for the role's evidence (§14).
+     * Null for a tool with no server; never throws out of an override's failed request.
+     */
+    async readServerConfig(_worktreeId, _worktreePath, _instanceId) {
+        return null;
+    }
     /**
      * Repair geometry when reusing a tmux session that predates the current
      * defaults, and record that this launch reused one (Issue #2429).

package/dist/server/src/lib/cli-tools/claude-auto-default-nudge.js

@@ -0,0 +1,141 @@
+"use strict";
+/**
+ * Claude Code's "Make auto mode your default permission mode?" at launch
+ * (Issue #4134).
+ *
+ * Claude Code 2.1.318 puts it in front of the composer when the operator's
+ * `~/.claude/settings.json` holds a `permissions.defaultMode` other than `auto`
+ * and `hasSeenAutoDefaultNudge` is not set. A session start then waited out its
+ * 60-second budget and `send` ended in exit 99. The launch answers it the way it
+ * answers the folder trust, as a writer of the instance's input lock: one key,
+ * then read the screen again.
+ *
+ * The answer is No, whichever mode that keeps: No writes only
+ * `hasSeenAutoDefaultNudge`, Yes writes `permissions.defaultMode: "auto"` to the
+ * operator's settings (measured). The cursor starts on Yes, so a screen that does
+ * not show it on No gets no Enter (`resolveClaudeAutoDefaultNudgeKey`).
+ *
+ * Two callers, because a launch ends. {@link answerClaudeAutoDefaultNudgeUntil}
+ * runs beside a start; a process already parked on the dialog starts no launch,
+ * and is answered by the send that finds it there
+ * ({@link answerClaudeAutoDefaultNudgeBeforeSend}).
+ *
+ * @module lib/cli-tools/claude-auto-default-nudge
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.answerClaudeAutoDefaultNudgeUntil = answerClaudeAutoDefaultNudgeUntil;
+exports.answerClaudeAutoDefaultNudgeBeforeSend = answerClaudeAutoDefaultNudgeBeforeSend;
+exports.sendNudgeKey = sendNudgeKey;
+const tmux_1 = require("../tmux/tmux");
+const cli_patterns_1 = require("../detection/cli-patterns");
+const instance_input_lock_1 = require("../../lib/session/instance-input-lock");
+const logger_1 = require("../../lib/logger");
+const launch_answer_skips_1 = require("./launch-answer-skips");
+const logger = (0, logger_1.createLogger)('cli-tools/claude-auto-default-nudge');
+/** How often the pane is read. The dialog is there for as long as nobody answers. */
+const POLL_INTERVAL_MS = 500;
+/** Rows read: as the start's own loop. */
+const CAPTURE_LINES = 50;
+/** Keys one launch may spend. Two are enough; the rest are for a TUI not yet taking keys. */
+const MAX_KEYS = 5;
+/** Reads one send gives the dialog before it refuses: 10 seconds, as its own prompt wait. */
+const BEFORE_SEND_MAX_READS = 20;
+/** Read the pane while `start` runs and answer the dialog if it comes up. */
+async function answerClaudeAutoDefaultNudgeUntil(sessionName, start) {
+    let settled = false;
+    const over = Promise.resolve(start).then(() => {
+        settled = true;
+    }, () => {
+        settled = true;
+    });
+    let keys = 0;
+    // Issue #4189: one record for this wait, so a key declined on every poll is one warn.
+    const skips = (0, launch_answer_skips_1.newLaunchAnswerSkips)();
+    while (keys < MAX_KEYS) {
+        await Promise.race([over, new Promise((resolve) => setTimeout(resolve, POLL_INTERVAL_MS))]);
+        if (settled)
+            return;
+        const readMark = (0, instance_input_lock_1.instanceInputLaunchReadMark)();
+        let key;
+        try {
+            key = (0, cli_patterns_1.resolveClaudeAutoDefaultNudgeKey)((0, cli_patterns_1.stripAnsi)(await (0, tmux_1.capturePane)(sessionName, { startLine: -CAPTURE_LINES })));
+        }
+        catch {
+            // The session may not exist yet; the start reports what is wrong with it.
+            continue;
+        }
+        if (key === null)
+            continue;
+        if (await sendNudgeKey(sessionName, readMark, key, skips))
+            keys++;
+    }
+    logger.warn('claude-auto-default-nudge-unanswered', { sessionName, keys });
+}
+/**
+ * Answer the dialog if this pane is on it, before a send waits for the prompt.
+ * One read and no key on any other screen. Inside a send that holds the input
+ * lock the keys join it.
+ *
+ * @throws Error (`prompt not ready`: `not-sent`, nothing typed) when the dialog
+ *   stays open: its cursor cannot be read or it does not take the keys. Only the
+ *   screen is named, nothing captured.
+ */
+async function answerClaudeAutoDefaultNudgeBeforeSend(sessionName) {
+    let keys = 0;
+    // Issue #4189: one record for this send's wait, as the launch has its own.
+    const skips = (0, launch_answer_skips_1.newLaunchAnswerSkips)();
+    for (let reads = 0; reads < BEFORE_SEND_MAX_READS; reads++) {
+        const readMark = (0, instance_input_lock_1.instanceInputLaunchReadMark)();
+        let screen;
+        try {
+            screen = (0, cli_patterns_1.stripAnsi)(await (0, tmux_1.capturePane)(sessionName, { startLine: -CAPTURE_LINES }));
+        }
+        catch {
+            // The send's own check reports what is wrong with the session.
+            return;
+        }
+        if (!(0, cli_patterns_1.isClaudeAutoDefaultNudgeOpen)(screen))
+            return;
+        const key = (0, cli_patterns_1.resolveClaudeAutoDefaultNudgeKey)(screen);
+        if (key !== null && keys < MAX_KEYS && (await sendNudgeKey(sessionName, readMark, key, skips)))
+            keys++;
+        await new Promise((resolve) => setTimeout(resolve, POLL_INTERVAL_MS));
+    }
+    logger.warn('claude-auto-default-nudge-unanswered-at-send', { sessionName, keys });
+    throw new Error('Claude Code prompt not ready: "Make auto mode your default permission mode?" is open and did not take its keys. ' +
+        'Nothing was typed. Answer it in the terminal: No keeps the current mode');
+}
+/** The warn of a key that did not go out. */
+const KEY_SKIPPED = 'claude-auto-default-nudge-key-skipped';
+/**
+ * One key, as an `exclusive` writer of the input lock, as the folder trust's keys go.
+ *
+ * Issue #4189: `skips` is the calling wait's record. With it the key's skip warn,
+ * and the lock's own warn of the decline (`repeatScope`), are written once while
+ * the same reason goes on in that wait; a key that went out ends the streak. Without
+ * it every skip is a warn, as before.
+ *
+ * @internal Exported for the input lock's evidence test.
+ */
+async function sendNudgeKey(sessionName, readMark, key, skips) {
+    const record = skips ?? (0, launch_answer_skips_1.newLaunchAnswerSkips)();
+    // Issue #4189: the session's life before the answer's await; a decline of an older life writes no record for the new one.
+    const answerLife = (0, instance_input_lock_1.instanceInputAnswerSkipLife)(sessionName);
+    try {
+        const outcome = await (0, instance_input_lock_1.answerUnderInstanceInputLock)(sessionName, readMark, async () => (0, cli_patterns_1.resolveClaudeAutoDefaultNudgeKey)((0, cli_patterns_1.stripAnsi)(await (0, tmux_1.capturePane)(sessionName, { startLine: -CAPTURE_LINES }))) === key, () => (key === 'Enter' ? (0, tmux_1.sendKeys)(sessionName, '', true) : (0, tmux_1.sendSpecialKeys)(sessionName, [key])), { mode: 'exclusive', repeatScope: skips });
+        if (outcome.answered) {
+            (0, launch_answer_skips_1.forgetLaunchAnswerSkip)(record, KEY_SKIPPED);
+            logger.info('claude-auto-default-nudge-key', { sessionName, key, answered: true });
+        }
+        else {
+            // Issue #4149: at warn, as the folder trust's skipped key is. An ERROR-only setting still hides it.
+            (0, launch_answer_skips_1.noteLaunchAnswerSkipped)(logger, record, KEY_SKIPPED, { sessionName, key, reason: outcome.reason }, answerLife);
+        }
+        return outcome.answered;
+    }
+    catch {
+        // Left for a later poll, as the folder trust's key is.
+        (0, launch_answer_skips_1.noteLaunchAnswerSkipped)(logger, record, KEY_SKIPPED, { sessionName, key, reason: 'send-failed' }, answerLife);
+        return false;
+    }
+}

package/dist/server/src/lib/cli-tools/claude.js

@@ -6,6 +6,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ClaudeTool = void 0;
 const base_1 = require("./base");
+const claude_auto_default_nudge_1 = require("./claude-auto-default-nudge");
 const terminal_keys_1 = require("../../types/terminal-keys");
 const claude_session_1 = require("../session/claude-session");
 /**
@@ -68,7 +69,12 @@ class ClaudeTool extends base_1.BaseCLITool {
             instanceId,
             model,
         };
-        await (0, claude_session_1.startClaudeSession)(options);
+        // Issue #4134: the start only waits for the prompt, so a dialog in front of
+        // it costs the whole start budget. Both run: the start decides when it is over.
+        // A process already on the dialog starts no launch: `sendMessageToClaude` answers it.
+        const start = (0, claude_session_1.startClaudeSession)(options);
+        await (0, claude_auto_default_nudge_1.answerClaudeAutoDefaultNudgeUntil)(this.getSessionName(worktreeId, instanceId), start);
+        await start;
     }
     /**
      * Send a message to Claude session
@@ -97,9 +103,15 @@ class ClaudeTool extends base_1.BaseCLITool {
      * @param instanceId - Optional agent instance ID (defaults to primary)
      */
     async sendMessageWithImage(worktreeId, message, imagePath, instanceId) {
+        await this.sendMessage(worktreeId, this.imageMessageBody(message, imagePath), instanceId);
+    }
+    /**
+     * The body {@link sendMessageWithImage} types: the message with the image's
+     * markdown reference appended (Issue #4048: the send's record digests it).
+     */
+    imageMessageBody(message, imagePath) {
         const imageMarkdown = `\n![](${imagePath})`;
-        const fullMessage = message ? `${message}${imageMarkdown}` : imageMarkdown;
-        await this.sendMessage(worktreeId, fullMessage, instanceId);
+        return message ? `${message}${imageMarkdown}` : imageMarkdown;
     }
     /**
      * Kill Claude session