commandmate 0.18.0 → 0.20.0

package/dist/server/src/lib/session/current-output-builder.js

@@ -15,6 +15,7 @@ const cli_session_1 = require("../../lib/session/cli-session");
 const status_detector_1 = require("../../lib/detection/status-detector");
 const auto_yes_manager_1 = require("../../lib/polling/auto-yes-manager");
 const status_capture_config_1 = require("../../config/status-capture-config");
+const tmux_capture_cache_1 = require("../../lib/tmux/tmux-capture-cache");
 const agent_event_state_1 = require("../../lib/session/agent-event-state");
 /**
  * Build the current-output payload for a worktree session.
@@ -46,7 +47,19 @@ async function buildCurrentOutput(db, worktreeId, cliToolId, instanceId) {
     const output = await (0, cli_session_1.captureSessionOutput)(worktreeId, cliToolId, status_capture_config_1.STATUS_CAPTURE_LINES, instanceId);
     const lines = output.split('\n');
     const totalLines = lines.length;
-    const newLines = lines.slice(Math.max(0, lastCapturedLine));
+    // Issue #1670: `content` is "everything the poller has not saved yet", which
+    // only works while `lastCapturedLine` indexes into `lines`. Once the capture is
+    // clipped by the window the cursor is stale by an unknown amount, and slicing at
+    // it collapses `content` to the last row or two — which is what `commandmate
+    // capture <id>` prints, so a long-lived codex session returned an empty capture.
+    // The window can only have slid forward, so 0 is the sole safe clamp; the result
+    // is a superset (it may repeat already-saved rows) and never drops new output.
+    //
+    // The effective window is the smaller of what this path asks for and what the
+    // capture layer will ever fetch — captureSessionOutput() reads at most
+    // CACHE_MAX_CAPTURE_LINES regardless of the request.
+    const captureWindowSaturated = (0, tmux_capture_cache_1.isCaptureWindowSaturated)(totalLines, Math.min(status_capture_config_1.STATUS_CAPTURE_LINES, tmux_capture_cache_1.CACHE_MAX_CAPTURE_LINES));
+    const newLines = captureWindowSaturated ? lines : lines.slice(Math.max(0, lastCapturedLine));
     const newContent = newLines.join('\n');
     const compositeKey = (0, auto_yes_manager_1.buildCompositeKey)(worktreeId, cliToolId, instanceId);
     const lastServerResponseTimestamp = (0, auto_yes_manager_1.getLastServerResponseTimestamp)(compositeKey);

package/dist/server/src/lib/session/session-start-error.js

@@ -0,0 +1,125 @@
+"use strict";
+/**
+ * Session-start failures whose text is safe to hand back to the caller
+ * (Issue #1637).
+ *
+ * A cold `commandmate send` used to come back as `Error: Server error. Check
+ * server logs for details.` (exit 99) while the tmux session and the CLI process
+ * it had just launched were both alive and still initializing. Nothing had
+ * failed: the server simply stopped watching before the prompt appeared. The
+ * caller could not tell that apart from a session that never started, so the
+ * observed workaround was to guess and re-send — four times across one
+ * orchestration, each time misdiagnosed as a session-creation race.
+ *
+ * `startClaudeSession()` answers unexpected failures with a fixed generic
+ * message on purpose (SEC-SF-002): an arbitrary error can carry a filesystem
+ * path or raw CLI output, and neither belongs in an HTTP response. The two
+ * errors here are the exception, and they earn it by construction — every
+ * message is assembled from a tool name, a tmux session name, a fixed pattern
+ * string from `cli-patterns.ts` and a number. Nothing that reaches them came
+ * from the environment, so passing them through leaks nothing while restoring
+ * the one thing the caller actually needed: what went wrong and what to do.
+ *
+ * Membership is duck-typed on `code` rather than tested with `instanceof`. The
+ * thrower, the API route and the CLI-tool wrapper are separate modules, and a
+ * check that depends on them sharing one class identity is exactly the kind
+ * that stops matching under bundling — silently reinstating the generic message
+ * this module exists to remove.
+ *
+ * @module lib/session/session-start-error
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SessionStartFailedError = exports.SessionStartTimeoutError = exports.SESSION_START_FAILED_CODE = exports.SESSION_STARTING_CODE = void 0;
+exports.isSessionStartTimeoutError = isSessionStartTimeoutError;
+exports.isSafeSessionStartError = isSafeSessionStartError;
+/** Code for a session that exists and is still coming up. */
+exports.SESSION_STARTING_CODE = 'SESSION_STARTING';
+/** Code for a session that started and then reported a terminal error. */
+exports.SESSION_START_FAILED_CODE = 'SESSION_START_FAILED';
+/** The codes {@link isSafeSessionStartError} recognises. */
+const SAFE_CODES = [exports.SESSION_STARTING_CODE, exports.SESSION_START_FAILED_CODE];
+/**
+ * The CLI tool's session exists and its process is running, but the interactive
+ * prompt was not observed within the start budget.
+ *
+ * Thrown *without* killing the session: the process is still coming up, and
+ * tearing it down would throw away the work that a retry a few seconds later
+ * gets for free.
+ */
+class SessionStartTimeoutError extends Error {
+    toolName;
+    sessionName;
+    timeoutMs;
+    /** @see SESSION_STARTING_CODE */
+    code = exports.SESSION_STARTING_CODE;
+    /**
+     * @param toolName - Display name of the CLI tool (e.g. `Claude Code`)
+     * @param sessionName - tmux session that was created and left running
+     * @param timeoutMs - Budget that elapsed without the prompt appearing
+     */
+    constructor(toolName, sessionName, timeoutMs) {
+        super(`${toolName} did not reach its input prompt within ${Math.round(timeoutMs / 1000)}s ` +
+            `(initialization timeout). The tmux session '${sessionName}' and its process are ` +
+            'still running, so this is a slow start, not a failed one — the message was not ' +
+            'delivered, but nothing needs repairing. Retry the send in a few seconds, or run ' +
+            '`commandmate capture <worktree-id>` to see what it is waiting on.');
+        this.toolName = toolName;
+        this.sessionName = sessionName;
+        this.timeoutMs = timeoutMs;
+        this.name = 'SessionStartTimeoutError';
+    }
+}
+exports.SessionStartTimeoutError = SessionStartTimeoutError;
+/**
+ * The CLI tool printed an error that startup cannot recover from.
+ *
+ * Distinct from {@link SessionStartTimeoutError} because retrying changes
+ * nothing: the reason is on screen already.
+ */
+class SessionStartFailedError extends Error {
+    toolName;
+    sessionName;
+    detectedPattern;
+    /** @see SESSION_START_FAILED_CODE */
+    code = exports.SESSION_START_FAILED_CODE;
+    /**
+     * @param toolName - Display name of the CLI tool (e.g. `Claude Code`)
+     * @param sessionName - tmux session the error was observed in
+     * @param detectedPattern - Matched entry from `cli-patterns.ts`; a fixed
+     *   string this repository authored, never captured output
+     */
+    constructor(toolName, sessionName, detectedPattern) {
+        super(`${toolName} reported an error while starting in tmux session '${sessionName}': ` +
+            `"${detectedPattern}". Retrying will not help until that is resolved; run ` +
+            '`commandmate capture <worktree-id>` to see the session output.');
+        this.toolName = toolName;
+        this.sessionName = sessionName;
+        this.detectedPattern = detectedPattern;
+        this.name = 'SessionStartFailedError';
+    }
+}
+exports.SessionStartFailedError = SessionStartFailedError;
+/**
+ * Whether `error` reports a session that is still initializing.
+ *
+ * @param error - Value caught from a `startSession()` call
+ */
+function isSessionStartTimeoutError(error) {
+    return readErrorCode(error) === exports.SESSION_STARTING_CODE;
+}
+/**
+ * Whether `error`'s message was built by this module and may be returned to the
+ * caller as-is.
+ *
+ * @param error - Value caught from a `startSession()` call
+ */
+function isSafeSessionStartError(error) {
+    const code = readErrorCode(error);
+    return code !== undefined && SAFE_CODES.includes(code);
+}
+function readErrorCode(error) {
+    if (typeof error !== 'object' || error === null)
+        return undefined;
+    const code = error.code;
+    return typeof code === 'string' ? code : undefined;
+}