botmux 3.4.2 → 3.4.3

package/dist/worker.js

@@ -13,7 +13,7 @@
  *   7. On 'restart', kills CLI and re-spawns with --resume
  */
 import { randomBytes } from 'node:crypto';
-import { mkdirSync, writeFileSync, unlinkSync, existsSync, statSync, lstatSync, readdirSync, readlinkSync, readFileSync, realpathSync, copyFileSync, watch as fsWatch, createWriteStream, openSync, closeSync, fstatSync, constants as fsConstants } from 'node:fs';
+import { mkdirSync, writeFileSync, unlinkSync, rmdirSync, existsSync, statSync, lstatSync, readdirSync, readlinkSync, readFileSync, realpathSync, copyFileSync, watch as fsWatch, createWriteStream, openSync, closeSync, fstatSync, constants as fsConstants } from 'node:fs';
 import { atomicWriteFileSync } from './utils/atomic-write.js';
 import { join, basename, dirname } from 'node:path';
 import { homedir, tmpdir } from 'node:os';
@@ -29,7 +29,7 @@ import { canStartInjectionFlush, shouldDeferUserFlush, shouldFlushInjectionsFirs
 import { stripAnsiForLog, tailChars } from './utils/crash-log.js';
 import { CodexUpdateDialogGuard } from './utils/codex-update-dialog.js';
 import { installStdioEpipeGuard, isIgnorableStreamError } from './utils/stdio-epipe-guard.js';
-import { mergeQueuedCliInput, pendingInputMayFlush, pendingInputAllowsTypeAhead, shouldDeferArgsBakedDurablePrompt, shouldDeferInitialPromptForArgLimit, shouldStopPendingBatch, terminalReleasesDurableTurn, } from './utils/pending-input-queue.js';
+import { mergeQueuedCliInput, pendingInputMayFlush, pendingInputAllowsTypeAhead, resolveInitialPromptDelivery, shouldDeferArgsBakedDurablePrompt, shouldDeferInitialPromptForArgLimit, shouldStopPendingBatch, terminalReleasesDurableTurn, } from './utils/pending-input-queue.js';
 import { ReadyGate, shouldArmReadyGate } from './utils/ready-gate.js';
 import { shouldRunStartupCommandsOnSpawn, shouldDeferInitialPromptForStartup } from './core/startup-commands.js';
 import { sanitizePerBotEnv } from './core/per-bot-env.js';
@@ -144,6 +144,36 @@ let remoteWsUrl;
 let remoteThreadId;
 let rpcDialogDismissTimer = null;
 let rpcEnginePidMarker = null;
+const piInitialPromptCleanupPaths = [];
+const piInitialPromptCleanupDirs = [];
+let piInitialPromptReadonlyRoots = [];
+let piInitialPromptAdditionalArgs = [];
+let piInitialPromptEnv = {};
+function cleanupPiInitialPromptFiles() {
+    while (piInitialPromptCleanupPaths.length > 0) {
+        const p = piInitialPromptCleanupPaths.pop();
+        if (!p)
+            continue;
+        try {
+            unlinkSync(p);
+        }
+        catch { /* best effort */ }
+    }
+    while (piInitialPromptCleanupDirs.length > 0) {
+        const dir = piInitialPromptCleanupDirs.pop();
+        if (!dir)
+            continue;
+        // Non-recursive on purpose: remove only an empty session-owned directory,
+        // never a shared root or a path that unexpectedly gained other content.
+        try {
+            rmdirSync(dir);
+        }
+        catch { /* best effort */ }
+    }
+    piInitialPromptReadonlyRoots = [];
+    piInitialPromptAdditionalArgs = [];
+    piInitialPromptEnv = {};
+}
 function stopCodexRpcEngine() {
     const engine = codexRpcEngine;
     codexRpcEngine = undefined;
@@ -672,6 +702,9 @@ let reattachIdleProbeTimer = null;
  *  adapter's hermesBridgeAttach reads the correct mode. */
 let lastSpawnEffectiveResume = false;
 let lastSpawnEffectiveCliSessionId;
+let lastSpawnDeferInitialPrompt = false;
+let lastSpawnQueuedInitialPrompt;
+let lastSpawnQueuedInitialPromptLogicalContent;
 let idleDetector = null;
 let isTmuxMode = false;
 /** True once a crash diagnostic tmux shell (bmx-diag-<sid>) is live. */
@@ -5068,6 +5101,7 @@ async function flushPending() {
             if (!codexRpcEngine)
                 inflightInputs.onWrite(item);
             const msg = item.content;
+            const logicalMsg = item.logicalContent ?? msg;
             currentBotmuxTurnId = item.turnId;
             currentBotmuxDispatchAttempt = item.dispatchAttempt;
             currentVcMeetingImTurnOrigin = item.vcMeetingImTurnOrigin;
@@ -5087,14 +5121,14 @@ async function flushPending() {
                     bridgeIngest();
                 }
                 catch { /* best-effort */ }
-                bridgeTurnId = bridgeMarkPendingTurn(msg, item.turnId, item.dispatchAttempt);
+                bridgeTurnId = bridgeMarkPendingTurn(logicalMsg, item.turnId, item.dispatchAttempt);
             }
             else if (codexBridgeActive) {
                 // Codex mark works even before the rollout path is known: the
                 // queue is path-agnostic, and the late-attach below will start
                 // ingest from offset 0 so the user_message that lands shortly
                 // after still fingerprint-matches this turn.
-                codexBridgeMarkPendingTurn(msg, item.turnId, item.dispatchAttempt);
+                codexBridgeMarkPendingTurn(logicalMsg, item.turnId, item.dispatchAttempt);
             }
             if (durableWrite
                 && cliAdapter.reliableTurnTerminal === true
@@ -5148,7 +5182,7 @@ async function flushPending() {
                 // do. Otherwise surface it as a submit failure so the message isn't
                 // silently lost.
                 if (backend)
-                    scheduleSubmitFailureNotify(msg, undefined, '会话 JSONL', bridgeTurnId, undefined, turnSeq, item);
+                    scheduleSubmitFailureNotify(logicalMsg, undefined, '会话 JSONL', bridgeTurnId, undefined, turnSeq, item);
                 break;
             }
             // Persist any sessionId the adapter observed via authoritative sources
@@ -5167,7 +5201,7 @@ async function flushPending() {
             // nulled backend) the user already got a "CLI exited" notice; don't also
             // nag that the submit wasn't confirmed.
             if (result && result.submitted === false && backend) {
-                scheduleSubmitFailureNotify(msg, result.recheck, '会话 JSONL', bridgeTurnId, result.failureReason, turnSeq, item);
+                scheduleSubmitFailureNotify(logicalMsg, result.recheck, '会话 JSONL', bridgeTurnId, result.failureReason, turnSeq, item);
             }
             // All structured bridges now drain every pending message in one flush:
             // Claude's BridgeTurnQueue handles `attachment(queued_command)` events
@@ -6340,6 +6374,30 @@ async function spawnCli(cfg, opts = {}) {
     // baking it into args would drop the message that triggered the resume.
     // Finally, defer adapter-declared over-limit prompts to avoid backend command
     // string limits (tmux "command too long") while preserving short argv prompts.
+    let preparedInitialPrompt;
+    let promptArgPreparationChanged = false;
+    let preparedDeferredInput;
+    if (cfg.prompt) {
+        const prepared = cliAdapter.prepareInitialPromptArg?.({
+            initialPrompt: cfg.prompt,
+            sessionId: effectiveAdapterSessionId,
+            sessionDataDir: process.env.SESSION_DATA_DIR,
+        });
+        if (prepared?.readonlyRoots?.length) {
+            piInitialPromptReadonlyRoots = [
+                ...new Set([...piInitialPromptReadonlyRoots, ...prepared.readonlyRoots]),
+            ];
+        }
+        if (prepared?.cleanupPaths?.length) {
+            piInitialPromptCleanupPaths.push(...prepared.cleanupPaths);
+        }
+        if (prepared?.cleanupDirs?.length) {
+            piInitialPromptCleanupDirs.push(...prepared.cleanupDirs);
+        }
+        preparedDeferredInput = prepared?.deferredInput;
+        preparedInitialPrompt = prepared?.initialPrompt ?? cfg.prompt;
+        promptArgPreparationChanged = preparedInitialPrompt !== cfg.prompt;
+    }
     const deferInitialPrompt = shouldDeferInitialPromptForStartup({
         hasStartupCommands: !!cfg.startupCommands?.length,
         adoptMode: cfg.adoptMode === true,
@@ -6349,11 +6407,25 @@ async function spawnCli(cfg, opts = {}) {
         adoptMode: cfg.adoptMode === true,
         dispatchAttempt: cfg.dispatchAttempt,
     }) || (effectiveResume && cliAdapter.initialPromptArgsIgnoredOnResume === true)
-        || shouldDeferInitialPromptForArgLimit({
+        || (!promptArgPreparationChanged && shouldDeferInitialPromptForArgLimit({
             passesInitialPromptViaArgs: cliAdapter.passesInitialPromptViaArgs === true,
             prompt: cfg.prompt,
             maxInitialPromptArgBytes: cliAdapter.maxInitialPromptArgBytes,
-        });
+        }));
+    const initialPromptDelivery = resolveInitialPromptDelivery({
+        originalPrompt: cfg.prompt,
+        preparedArg: preparedInitialPrompt,
+        preparedDeferredContent: preparedDeferredInput?.content,
+        defer: deferInitialPrompt,
+    });
+    preparedInitialPrompt = initialPromptDelivery.argvPrompt;
+    lastSpawnQueuedInitialPrompt = initialPromptDelivery.queuedContent;
+    lastSpawnQueuedInitialPromptLogicalContent = initialPromptDelivery.logicalContent;
+    if (deferInitialPrompt && preparedDeferredInput) {
+        piInitialPromptAdditionalArgs = [...(preparedDeferredInput.additionalArgs ?? [])];
+        piInitialPromptEnv = { ...(preparedDeferredInput.env ?? {}) };
+    }
+    lastSpawnDeferInitialPrompt = deferInitialPrompt;
     kiroSessionIdCaptureArmed = cfg.cliId === 'kiro-cli' && !effectiveCliSessionId && !willReattachPersistent;
     kiroSessionIdCaptureBuffer = '';
     // Per-bot local read isolation: assemble the Seatbelt profile context (the gate
@@ -6432,7 +6504,7 @@ async function spawnCli(cfg, opts = {}) {
         resume: effectiveResume,
         workingDir: cfg.workingDir,
         resumeSessionId: effectiveCliSessionId,
-        initialPrompt: deferInitialPrompt ? undefined : (cfg.prompt || undefined),
+        initialPrompt: preparedInitialPrompt,
         botName: cfg.botName,
         botOpenId: cfg.botOpenId,
         larkAppId: cfg.larkAppId,
@@ -6447,6 +6519,12 @@ async function spawnCli(cfg, opts = {}) {
         remoteWsUrl,
         remoteThreadId,
     });
+    // Pi's deferred long-first-prompt command is implemented by a session-scoped
+    // extension. Keep its launch args across owned process restarts while the
+    // queued/in-flight command may still need replay.
+    if (piInitialPromptAdditionalArgs.length > 0) {
+        args.unshift(...piInitialPromptAdditionalArgs);
+    }
     // Extra args from env (CLI_DISABLE_DEFAULT_ARGS is removed — adapters own their defaults)
     const extra = (process.env.CLI_EXTRA_ARGS ?? '').trim();
     if (extra)
@@ -6576,6 +6654,9 @@ async function spawnCli(cfg, opts = {}) {
     // them past the server's global env.
     if (cliAdapter.spawnEnv)
         Object.assign(childEnv, cliAdapter.spawnEnv);
+    if (Object.keys(piInitialPromptEnv).length > 0) {
+        Object.assign(childEnv, piInitialPromptEnv);
+    }
     // v2 read isolation: point the CLI at its PER-BOT config dir (set AFTER spawnEnv
     // so it overrides any adapter default). claude → CLAUDE_CONFIG_DIR, codex →
     // CODEX_HOME. Both are in BOTMUX_INJECTED_ENV_KEYS so the tmux backend forwards
@@ -6662,6 +6743,9 @@ async function spawnCli(cfg, opts = {}) {
                     cliId: cliAdapter.id,
                     resolvedBin: canonical(cliAdapter.resolvedBin),
                 }),
+                // buildV2DenyPaths masks the shared pi-initial-prompts root. Re-open
+                // only this session's private child directory for Pi's @file/extension.
+                ...piInitialPromptReadonlyRoots.map(canonical),
             ];
             finalDenyPaths = carve.finalDenyPaths.map(canonical);
             traverseDirs = carve.traverseDirs.map(canonical);
@@ -6908,6 +6992,7 @@ async function spawnCli(cfg, opts = {}) {
                     extraExecPaths: cliAdapter.sandboxExtraExecPaths?.(),
                     readonlyRoots: [
                         ...(cfg.skillReadonlyRoots ?? []),
+                        ...piInitialPromptReadonlyRoots,
                         ...(readIsoLinuxMasks?.ownReadOnlyPaths ?? []),
                     ],
                     mcpGatewaySocketPath: sessionMcpGatewayHost?.socketPath,
@@ -7661,6 +7746,8 @@ function killCli(opts = {}) {
     currentCliCredentialIsolated = false;
     stopSessionMcpGatewayHost();
     stopCodexRpcEngine();
+    if (!opts.preservePending)
+        cleanupPiInitialPromptFiles();
     destroyCrashDiagnosticTerminal('killCli');
     idleDetector?.dispose();
     idleDetector = null;
@@ -9133,20 +9220,7 @@ process.on('message', async (raw) => {
                 // Tier-1/Tier-2 fresh demotion, which clears the flag). Adopt spawns
                 // return from spawnCli before that write — exclude them explicitly so
                 // the stale module-level value can't leak in.
-                const deferInitialPrompt = shouldDeferInitialPromptForStartup({
-                    hasStartupCommands: !!msg.startupCommands?.length,
-                    adoptMode: msg.adoptMode === true,
-                    passesInitialPromptViaArgs: cliAdapter?.passesInitialPromptViaArgs === true,
-                }) || shouldDeferArgsBakedDurablePrompt({
-                    passesInitialPromptViaArgs: cliAdapter?.passesInitialPromptViaArgs === true,
-                    adoptMode: msg.adoptMode === true,
-                    dispatchAttempt: msg.dispatchAttempt,
-                }) || (msg.adoptMode !== true && lastSpawnEffectiveResume && cliAdapter?.initialPromptArgsIgnoredOnResume === true)
-                    || shouldDeferInitialPromptForArgLimit({
-                        passesInitialPromptViaArgs: cliAdapter?.passesInitialPromptViaArgs === true,
-                        prompt: msg.prompt,
-                        maxInitialPromptArgBytes: cliAdapter?.maxInitialPromptArgBytes,
-                    });
+                const deferInitialPrompt = lastSpawnDeferInitialPrompt;
                 if (msg.prompt && cliAdapter?.passesInitialPromptViaArgs && !deferInitialPrompt && codexBridgeFallbackActive()) {
                     // Args-baked first prompts (notably Pi) never pass through the normal
                     // 'message' IPC path, so the structured bridge would otherwise see the
@@ -9171,7 +9245,10 @@ process.on('message', async (raw) => {
                     deferInitialPrompt,
                 })) {
                     pendingMessages.push({
-                        content: msg.prompt,
+                        content: lastSpawnQueuedInitialPrompt ?? msg.prompt,
+                        ...(lastSpawnQueuedInitialPromptLogicalContent
+                            ? { logicalContent: lastSpawnQueuedInitialPromptLogicalContent }
+                            : {}),
                         turnId: msg.turnId,
                         dispatchAttempt: msg.dispatchAttempt,
                         vcMeetingImTurnOrigin: msg.vcMeetingImTurnOrigin,
@@ -9633,6 +9710,7 @@ process.on('message', async (raw) => {
 });
 // ─── Cleanup ─────────────────────────────────────────────────────────────────
 function cleanup() {
+    cleanupPiInitialPromptFiles();
     stopSessionMcpGatewayHost();
     if (tmuxRestartTimer) {
         clearTimeout(tmuxRestartTimer);