botmux 2.74.0 → 2.75.1

package/dist/worker.js

@@ -22,7 +22,7 @@ import { shouldSuppressBridgeEmit } from './services/bridge-fallback-gate.js';
 import { shouldWriteNow } from './utils/input-gate.js';
 import { ReadyGate, shouldArmReadyGate } from './utils/ready-gate.js';
 import { InflightInputTracker } from './core/inflight-input-tracker.js';
-import { shouldRunQuietRotation, evaluatePidResolverPullback, decideFingerprintSwitch, sessionIdFromJsonlPath, SESSION_ID_FILENAME_RE, } from './services/bridge-rotation-policy.js';
+import { shouldRunQuietRotation, evaluatePidResolverPullback, decideFingerprintSwitch, shouldHealAbsentBaseline, sessionIdFromJsonlPath, SESSION_ID_FILENAME_RE, } from './services/bridge-rotation-policy.js';
 import { CodexBridgeQueue } from './services/codex-bridge-queue.js';
 import { drainCodexRollout, findCodexRolloutBySessionId, findCodexRolloutByPid, splitCodexEventsByCutoff, extractLastCodexTurn } from './services/codex-transcript.js';
 import { findTraexRolloutBySessionId, findTraexRolloutByPid } from './services/traex-transcript.js';
@@ -39,6 +39,7 @@ import { t, setDefaultLocale } from './i18n/index.js';
 import { TerminalRenderer } from './utils/terminal-renderer.js';
 import { DEFAULT_RENDER_COLS, DEFAULT_RENDER_ROWS, MAX_RENDER_COLS, MAX_RENDER_ROWS, MIN_RENDER_COLS, MIN_RENDER_ROWS, clamp, resolveRenderDimensions, } from './utils/render-dimensions.js';
 import { createCliAdapterSync, locateOnPath } from './adapters/cli/registry.js';
+import { buildWrappedLaunch } from './setup/cli-selection.js';
 import { claudeJsonlPathForSession, resolveJsonlFromPid, findOpenClaudeSessionIds, DEFAULT_CLAUDE_DATA_DIR } from './adapters/cli/claude-code.js';
 import { mtrSessionIdForBotmuxSession } from './adapters/cli/mtr.js';
 import { HerdrBackend } from './adapters/backend/herdr-backend.js';
@@ -147,6 +148,41 @@ let readySignalTimer = null;
  *  back. The real signal lands within ~ms of the input box rendering, so this is
  *  pure insurance against a missing/failed hook — generous but bounded. */
 const READY_SIGNAL_TIMEOUT_MS = 45_000;
+/** Epoch ms of the most recent PTY output — used to settle for quiescence
+ *  before the first flush (see settleThenFlush). */
+let lastPtyOutputAtMs = 0;
+/** After the SessionStart signal fires, the input box has appeared but Ink's
+ *  startup render isn't fully drained yet — typing immediately trips Claude's
+ *  paste-burst heuristic and the `\` soft-newline markers (claude-code
+ *  writeInput) get kept literally. This is pronounced under wrapperCli launchers
+ *  (e.g. `aiden x claude`) whose Claude renders more at startup. So we wait for
+ *  the PTY to fall quiet for SETTLE_MS before the first flush — the signal still
+ *  gates readiness (anti-selector), the settle just lets the render drain. */
+const READY_FLUSH_SETTLE_MS = 1_000;
+/** Upper bound on the settle so a chatty startup (spinners, periodic redraw)
+ *  can't stall the first prompt indefinitely. */
+const READY_FLUSH_SETTLE_CAP_MS = 6_000;
+let readyFlushSettleTimer = null;
+/** True while the post-signal quiescence settle is in progress — flushPending
+ *  holds (just like the gate) so a message arriving mid-settle can't type-ahead
+ *  past the settle and re-trigger paste-burst. */
+let isSettlingFirstFlush = false;
+/** Wait until the PTY has been quiet for READY_FLUSH_SETTLE_MS (Ink render
+ *  drained), capped at READY_FLUSH_SETTLE_CAP_MS, then flush the held prompt. */
+function settleThenFlush(startedAtMs) {
+    readyFlushSettleTimer = null;
+    const now = Date.now();
+    const quietForMs = now - lastPtyOutputAtMs;
+    if (quietForMs >= READY_FLUSH_SETTLE_MS || now - startedAtMs >= READY_FLUSH_SETTLE_CAP_MS) {
+        isSettlingFirstFlush = false;
+        log(`Ready-gate settle done (quiet ${quietForMs}ms); delivering held first prompt`);
+        void flushPending();
+        return;
+    }
+    const wait = Math.min(READY_FLUSH_SETTLE_MS - quietForMs, READY_FLUSH_SETTLE_CAP_MS - (now - startedAtMs));
+    readyFlushSettleTimer = setTimeout(() => settleThenFlush(startedAtMs), Math.max(50, wait));
+    readyFlushSettleTimer.unref?.();
+}
 /** Release the ready-gate and flush anything it held. No-op when the gate was
  *  never armed (other CLIs / adopt) or already released (idempotent). */
 function releaseReadyGate(reason) {
@@ -155,8 +191,13 @@ function releaseReadyGate(reason) {
         readySignalTimer = null;
     }
     if (readyGate.receive()) {
-        log(`Ready gate released (${reason}); delivering held first prompt`);
-        flushPending();
+        log(`Ready gate released (${reason}); settling for PTY quiescence before first flush`);
+        if (readyFlushSettleTimer) {
+            clearTimeout(readyFlushSettleTimer);
+            readyFlushSettleTimer = null;
+        }
+        isSettlingFirstFlush = true;
+        settleThenFlush(Date.now());
     }
 }
 const pendingMessages = [];
@@ -1375,8 +1416,28 @@ function bridgeMarkPendingTurn(messageText, preferredTurnId) {
     if (!bridgeJsonlPath)
         return undefined;
     if (!bridgeBaselineDone) {
-        log('Bridge baseline not ready — this turn will not have transcript-driven final_output');
-        return undefined;
+        // Self-heal a stuck baseline: the guessed transcript path never
+        // materialised (Claude wrote under a different sessionId, a stale resume
+        // id, or an /adopt sid persisted as the botmux sid). An absent file has
+        // no history to absorb, so arm fresh-empty readiness so THIS turn gets
+        // marked — the mark arms the per-tick exact-content fingerprint recovery,
+        // which finds the jsonl Claude actually wrote this message to and switches
+        // the bridge onto it (no dependence on Claude-internal pid files, so
+        // version-robust). See shouldHealAbsentBaseline for the full rationale.
+        if (shouldHealAbsentBaseline({
+            baselineDone: bridgeBaselineDone,
+            hasJsonlPath: !!bridgeJsonlPath,
+            jsonlFileExists: existsSyncSafe(bridgeJsonlPath),
+        })) {
+            bridgeOffset = 0;
+            bridgePendingTail = '';
+            bridgeBaselineDone = true;
+            log(`Bridge baseline self-healed: guessed transcript ${bridgeJsonlPath} absent; fresh-empty readiness armed for fingerprint recovery`);
+        }
+        else {
+            log('Bridge baseline not ready — this turn will not have transcript-driven final_output');
+            return undefined;
+        }
     }
     const fingerprint = makeFingerprint(messageText);
     // Full normalised content powers the unknown-sid recovery path. When a
@@ -2785,7 +2846,9 @@ function onPtyData(data) {
             return;
         }
     }
-    // Delegate idle detection to IdleDetector
+    // Track last PTY output time for the ready-gate quiescence settle (see
+    // settleThenFlush) and delegate idle detection to IdleDetector.
+    lastPtyOutputAtMs = Date.now();
     idleDetector?.feed(data);
 }
 function markPromptReady() {
@@ -2970,6 +3033,12 @@ async function flushPending() {
         log(`Holding ${pendingMessages.length} pending message(s) until SessionStart ready signal`);
         return;
     }
+    // Post-signal quiescence settle in progress — hold so the first write lands
+    // after Ink's startup render has drained (else paste-burst keeps `\` literal).
+    if (isSettlingFirstFlush) {
+        log(`Holding ${pendingMessages.length} pending message(s) until ready-gate settle completes`);
+        return;
+    }
     // Type-ahead adapters flush even while the CLI is busy; others wait for
     // idle. Claude bridge fallback used to also disable type-ahead because
     // BridgeTurnQueue.ingest didn't recognise the `attachment(queued_command)`
@@ -3838,6 +3907,23 @@ function spawnCli(cfg) {
             throw err;
         }
     }
+    // 通用启动前缀（wrapperCli）：把启动命令重写成 `<wrapperCli> <CLI 参数>`（首 token 当
+    // bin 走 PATH 解析），无需 wrapper 脚本、跨系统。aiden x claude 形态会剥掉 aiden 拒收的
+    // --settings（见 buildWrappedLaunch）。与文件沙盒互斥：沙盒已把命令重写成 bwrap，叠加
+    // 前缀会破坏隔离，故 sandboxOn 时跳过并告警（网关 + oncall 沙盒本就不是合理组合）。
+    if (cfg.wrapperCli && cfg.wrapperCli.trim()) {
+        if (sandboxOn) {
+            log(`wrapperCli="${cfg.wrapperCli}" ignored: file sandbox enabled and takes precedence (cannot combine launch prefix with bwrap)`);
+        }
+        else {
+            const launch = buildWrappedLaunch(cfg.wrapperCli, spawnArgs, (b) => locateOnPath(b) ?? b);
+            if (launch.bin) {
+                spawnBin = launch.bin;
+                spawnArgs = launch.args;
+                log(`Launch prefix: spawning ${spawnBin} ${spawnArgs.slice(0, 2).join(' ')} … (cliId=${cfg.cliId})`);
+            }
+        }
+    }
     backend.spawn(spawnBin, spawnArgs, {
         cwd: spawnCwd,
         cols: PTY_COLS,
@@ -4010,6 +4096,13 @@ function spawnCli(cfg) {
         clearTimeout(readySignalTimer);
         readySignalTimer = null;
     }
+    if (readyFlushSettleTimer) {
+        clearTimeout(readyFlushSettleTimer);
+        readyFlushSettleTimer = null;
+    }
+    isSettlingFirstFlush = false;
+    // Reset quiescence baseline so the settle measures silence from THIS spawn.
+    lastPtyOutputAtMs = Date.now();
     if (shouldArmReadyGate({
         injectsReadyHook: cliAdapter.injectsReadyHook === true,
         adoptMode: cfg.adoptMode === true,
@@ -4092,11 +4185,16 @@ function spawnCli(cfg) {
 function killCli() {
     idleDetector?.dispose();
     idleDetector = null;
-    // Cancel any pending ready-gate fallback timer; spawnCli re-arms on respawn.
+    // Cancel any pending ready-gate fallback / settle timers; spawnCli re-arms on respawn.
     if (readySignalTimer) {
         clearTimeout(readySignalTimer);
         readySignalTimer = null;
     }
+    if (readyFlushSettleTimer) {
+        clearTimeout(readyFlushSettleTimer);
+        readyFlushSettleTimer = null;
+    }
+    isSettlingFirstFlush = false;
     stopScreenAnalyzer();
     stopScreenUpdates();
     backend?.kill();