oh-my-codex 0.7.5 → 0.8.0

package/dist/team/tmux-session.js

@@ -1,13 +1,12 @@
-import { spawnSync } from 'child_process';
+import { spawnSync, execFile } from 'child_process';
+import { promisify } from 'util';
 import { readFileSync } from 'fs';
 import { join } from 'path';
+import { CODEX_BYPASS_FLAG, MADMAX_FLAG, CONFIG_FLAG, LONG_CONFIG_FLAG, MODEL_FLAG, } from '../cli/constants.js';
+import { sleep, sleepSync } from '../utils/sleep.js';
+const execFileAsync = promisify(execFile);
 import { HUD_RESIZE_RECONCILE_DELAY_SECONDS, HUD_TMUX_TEAM_HEIGHT_LINES } from '../hud/constants.js';
 const INJECTION_MARKER = '[OMX_TMUX_INJECT]';
-const CODEX_BYPASS_FLAG = '--dangerously-bypass-approvals-and-sandbox';
-const MADMAX_FLAG = '--madmax';
-const CONFIG_FLAG = '-c';
-const LONG_CONFIG_FLAG = '--config';
-const MODEL_FLAG = '--model';
 const MODEL_INSTRUCTIONS_FILE_KEY = 'model_instructions_file';
 const OMX_BYPASS_DEFAULT_SYSTEM_PROMPT_ENV = 'OMX_BYPASS_DEFAULT_SYSTEM_PROMPT';
 const OMX_MODEL_INSTRUCTIONS_FILE_ENV = 'OMX_MODEL_INSTRUCTIONS_FILE';
@@ -99,9 +98,6 @@ function findHudPaneIds(target, leaderPaneId) {
         .filter((pane) => isHudWatchPane(pane))
         .map((pane) => pane.paneId);
 }
-function sleepMs(ms) {
-    Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
-}
 const MAX_FRACTIONAL_SLEEP_MS = 60_000;
 function toFractionalSleepMs(seconds) {
     if (!Number.isFinite(seconds) || seconds <= 0)
@@ -114,12 +110,64 @@ function toFractionalSleepMs(seconds) {
 function sleepSeconds(seconds) {
     sleepFractionalSeconds(seconds);
 }
-export function sleepFractionalSeconds(seconds, sleepImpl = sleepMs) {
+export function sleepFractionalSeconds(seconds, sleepImpl = sleepSync) {
     const ms = toFractionalSleepMs(seconds);
     if (ms <= 0)
         return;
     sleepImpl(ms);
 }
+// ── Async tmux helpers ──────────────────────────────────────────────────────
+async function runTmuxAsync(args) {
+    try {
+        const { stdout } = await execFileAsync('tmux', args, { encoding: 'utf-8' });
+        return { ok: true, stdout: (stdout || '').trim() };
+    }
+    catch (error) {
+        const err = error;
+        return { ok: false, stderr: (err.stderr || err.message || '').trim() || 'tmux command failed' };
+    }
+}
+async function sendKeyAsync(target, key) {
+    const result = await runTmuxAsync(['send-keys', '-t', target, key]);
+    if (!result.ok) {
+        throw new Error(`sendKeyAsync: failed to send ${key}: ${result.stderr}`);
+    }
+}
+async function capturePaneAsync(target) {
+    const result = await runTmuxAsync(['capture-pane', '-t', target, '-p', '-S', '-80']);
+    if (!result.ok)
+        return '';
+    return result.stdout;
+}
+async function isWorkerAliveAsync(sessionName, workerIndex, workerPaneId) {
+    const result = await runTmuxAsync([
+        'list-panes',
+        '-t', paneTarget(sessionName, workerIndex, workerPaneId),
+        '-F',
+        '#{pane_dead} #{pane_pid}',
+    ]);
+    if (!result.ok)
+        return false;
+    const line = result.stdout.split('\n')[0]?.trim();
+    if (!line)
+        return false;
+    const parts = line.split(/\s+/);
+    if (parts.length < 2)
+        return false;
+    const paneDead = parts[0];
+    const pid = Number.parseInt(parts[1], 10);
+    if (paneDead === '1')
+        return false;
+    if (!Number.isFinite(pid))
+        return false;
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
 function shellQuoteSingle(value) {
     return `'${value.replace(/'/g, `'\\''`)}'`;
 }
@@ -489,9 +537,14 @@ export function createTeamSession(teamName, workerCount, cwd, workerLaunchArgs =
     let registeredResizeHook = null;
     const rollbackPaneIds = [];
     try {
-        const context = runTmux(['display-message', '-p', '#S:#I #{pane_id}']);
+        const tmuxPaneTarget = process.env.TMUX_PANE;
+        const displayArgs = tmuxPaneTarget
+            ? ['display-message', '-p', '-t', tmuxPaneTarget, '#S:#I #{pane_id}']
+            : ['display-message', '-p', '#S:#I #{pane_id}'];
+        const context = runTmux(displayArgs);
         if (!context.ok) {
-            throw new Error(`failed to detect current tmux target: ${context.stderr}`);
+            const paneHint = tmuxPaneTarget ? ` (TMUX_PANE=${tmuxPaneTarget})` : '';
+            throw new Error(`failed to detect current tmux target${paneHint}: ${context.stderr}`);
         }
         const [sessionAndWindow = '', detectedLeaderPaneId = ''] = context.stdout.split(' ');
         const [sessionName, windowIndex] = (sessionAndWindow || '').split(':');
@@ -706,7 +759,7 @@ export function paneIsBootstrapping(lines) {
         /\bmodel:\s*loading\b/i.test(line) ||
         /\bconnecting\s+to\b/i.test(line));
 }
-function paneLooksReady(captured) {
+export function paneLooksReady(captured) {
     const content = captured.trimEnd();
     if (content === '')
         return false;
@@ -730,6 +783,11 @@ function paneLooksReady(captured) {
     const hasClaudePromptLine = lines.some((line) => /^\s*❯\s*/u.test(line));
     if (hasCodexPromptLine || hasClaudePromptLine)
         return true;
+    // Custom per-issue prompts (e.g. "› IND-123 only..."). Capture output can
+    // occasionally omit the glyph, so accept both with/without leading prompt char.
+    const hasIssuePromptLine = lines.some((line) => /^\s*(?:[›>❯]\s*)?[A-Z][A-Z0-9]+-\d+\s+only(?:\s*(?:…|\.{3}))?\s*$/iu.test(line));
+    if (hasIssuePromptLine)
+        return true;
     // Status-only markers (model name in status bar, token budget) are NOT
     // sufficient on their own — they can appear during bootstrap before the CLI
     // accepts input.  Require an actual prompt character (checked above).
@@ -745,12 +803,15 @@ function paneHasTrustPrompt(captured) {
     const hasActiveChoices = tail.some((line) => /Yes,\s*continue|No,\s*quit|Press enter to continue/i.test(line));
     return hasQuestion && hasActiveChoices;
 }
-function paneHasActiveTask(captured) {
+export function paneHasActiveTask(captured) {
     const lines = captured
         .split('\n')
         .map((line) => line.replace(/\r/g, '').trim())
         .filter((line) => line.length > 0);
     const tail = lines.slice(-40);
+    // Codex v5 status line can appear without "esc to interrupt"; treat as busy first.
+    if (tail.some((line) => /\b\d+\s+background terminal running\b/i.test(line)))
+        return true;
     if (tail.some((line) => /esc to interrupt/i.test(line)))
         return true;
     if (tail.some((line) => /\bbackground terminal running\b/i.test(line)))
@@ -836,39 +897,34 @@ export function shouldAttemptAdaptiveRetry(strategy, paneBusyAtStart, allowAdapt
         return false;
     return true;
 }
-function sendKeyOrThrow(target, key, label) {
-    const result = runTmux(['send-keys', '-t', target, key]);
-    if (!result.ok) {
-        throw new Error(`sendToWorker: failed to send ${label}: ${result.stderr}`);
-    }
-}
 function sendLiteralTextOrThrow(target, text) {
     const send = runTmux(['send-keys', '-t', target, '-l', '--', text]);
     if (!send.ok) {
         throw new Error(`sendToWorker: failed to send text: ${send.stderr}`);
     }
 }
-function attemptSubmitRounds(target, text, rounds, queueFirstRound, submitKeyPressesPerRound) {
+async function attemptSubmitRounds(target, text, rounds, queueFirstRound, submitKeyPressesPerRound) {
     const presses = Math.max(1, Math.floor(submitKeyPressesPerRound));
     for (let round = 0; round < rounds; round++) {
-        sleepFractionalSeconds(0.1);
+        await sleep(100);
         if (round === 0 && queueFirstRound) {
-            sendKeyOrThrow(target, 'Tab', 'Tab');
-            sleepFractionalSeconds(0.08);
-            sendKeyOrThrow(target, 'C-m', 'C-m');
+            await sendKeyAsync(target, 'Tab');
+            await sleep(80);
+            await sendKeyAsync(target, 'C-m');
         }
         else {
             for (let press = 0; press < presses; press++) {
-                sendKeyOrThrow(target, 'C-m', 'C-m');
+                await sendKeyAsync(target, 'C-m');
                 if (press < presses - 1) {
-                    sleepFractionalSeconds(0.2);
+                    await sleep(200);
                 }
             }
         }
-        sleepFractionalSeconds(0.14);
-        if (!paneTailContainsLiteralLine(target, text))
+        await sleep(140);
+        const captured = await capturePaneAsync(target);
+        if (!normalizeTmuxCapture(captured).includes(normalizeTmuxCapture(text)))
             return true;
-        sleepFractionalSeconds(0.14);
+        await sleep(140);
     }
     return false;
 }
@@ -948,12 +1004,6 @@ export function dismissTrustPromptIfPresent(sessionName, workerIndex, workerPane
     runTmux(['send-keys', '-t', target, 'C-m']);
     return true;
 }
-function paneTailContainsLiteralLine(target, text) {
-    const result = runTmux(['capture-pane', '-t', target, '-p', '-S', '-80']);
-    if (!result.ok)
-        return false;
-    return normalizeTmuxCapture(result.stdout).includes(normalizeTmuxCapture(text));
-}
 export function normalizeTmuxCapture(value) {
     return value
         .replace(/\r/g, '')
@@ -981,47 +1031,46 @@ export function sendToWorkerStdin(stdin, text) {
 // Send SHORT text (<200 chars) to worker via tmux send-keys
 // Validates: text < 200 chars, no injection marker
 // Throws on violation
-export function sendToWorker(sessionName, workerIndex, text, workerPaneId, workerCli) {
+export async function sendToWorker(sessionName, workerIndex, text, workerPaneId, workerCli) {
     assertWorkerTriggerText(text);
     const target = paneTarget(sessionName, workerIndex, workerPaneId);
     const strategy = resolveSendStrategyFromEnv();
     const resolvedWorkerCli = resolveWorkerCliForSend(workerIndex, workerCli);
     // Guard: if the trust prompt is still present, advance it first so our trigger text
     // doesn't get typed into the trust screen and ignored.
-    const captured = runTmux(['capture-pane', '-t', target, '-p', '-S', '-80']);
-    const paneBusy = captured.ok ? paneHasActiveTask(captured.stdout) : false;
-    if (captured.ok && paneHasTrustPrompt(captured.stdout)) {
-        sendKeyOrThrow(target, 'C-m', 'C-m');
-        sleepFractionalSeconds(0.12);
-        sendKeyOrThrow(target, 'C-m', 'C-m');
-        sleepFractionalSeconds(0.2);
+    const capturedStr = await capturePaneAsync(target);
+    const paneBusy = paneHasActiveTask(capturedStr);
+    if (paneHasTrustPrompt(capturedStr)) {
+        await sendKeyAsync(target, 'C-m');
+        await sleep(120);
+        await sendKeyAsync(target, 'C-m');
+        await sleep(200);
     }
     sendLiteralTextOrThrow(target, text);
     // Allow the input buffer to settle before sending C-m
-    sleepFractionalSeconds(0.15);
+    await sleep(150);
     const allowAutoInterruptRetry = process.env[OMX_TEAM_AUTO_INTERRUPT_RETRY_ENV] !== '0';
     const submitPlan = buildWorkerSubmitPlan(strategy, resolvedWorkerCli, paneBusy, allowAutoInterruptRetry);
     if (submitPlan.shouldInterrupt) {
         // Explicit interrupt mode: abort current turn first, then submit the new command.
-        sendKeyOrThrow(target, 'C-c', 'C-c');
-        sleepFractionalSeconds(0.1);
+        await sendKeyAsync(target, 'C-c');
+        await sleep(100);
     }
     // Submit deterministically using CLI-specific plan:
     // - Codex: queue-first Tab+C-m when configured/busy, then double C-m rounds.
     // - Claude: direct C-m rounds only (never queue-first Tab).
-    if (attemptSubmitRounds(target, text, submitPlan.rounds, submitPlan.queueFirstRound, submitPlan.submitKeyPressesPerRound))
+    if (await attemptSubmitRounds(target, text, submitPlan.rounds, submitPlan.queueFirstRound, submitPlan.submitKeyPressesPerRound))
         return;
     // Adaptive escalation for "likely unsent trigger text at ready prompt" cases:
     // clear line, re-send trigger, then re-submit with deterministic C-m rounds.
-    const latestCaptureResult = runTmux(['capture-pane', '-t', target, '-p', '-S', '-80']);
-    const latestCapture = latestCaptureResult.ok ? latestCaptureResult.stdout : null;
-    if (shouldAttemptAdaptiveRetry(strategy, paneBusy, submitPlan.allowAdaptiveRetry, latestCapture, text)) {
+    const latestCapture = await capturePaneAsync(target);
+    if (shouldAttemptAdaptiveRetry(strategy, paneBusy, submitPlan.allowAdaptiveRetry, latestCapture || null, text)) {
         // Keep this branch non-interrupting to avoid canceling active turns on false positives.
-        sendKeyOrThrow(target, 'C-u', 'C-u');
-        sleepFractionalSeconds(0.08);
+        await sendKeyAsync(target, 'C-u');
+        await sleep(80);
         sendLiteralTextOrThrow(target, text);
-        sleepFractionalSeconds(0.12);
-        if (attemptSubmitRounds(target, text, 4, false, submitPlan.submitKeyPressesPerRound))
+        await sleep(120);
+        if (await attemptSubmitRounds(target, text, 4, false, submitPlan.submitKeyPressesPerRound))
             return;
     }
     // Fail-open by default: Codex may keep the last submitted line visible even after executing it.
@@ -1031,22 +1080,22 @@ export function sendToWorker(sessionName, workerIndex, text, workerPaneId, worke
         throw new Error('sendToWorker: submit_failed (trigger text still visible after retries)');
     }
     // One last best-effort double C-m nudge, then verify.
-    runTmux(['send-keys', '-t', target, 'C-m']);
-    sleepFractionalSeconds(0.12);
-    runTmux(['send-keys', '-t', target, 'C-m']);
+    await sendKeyAsync(target, 'C-m');
+    await sleep(120);
+    await sendKeyAsync(target, 'C-m');
     // Post-submit verification: wait briefly and confirm the worker consumed the
     // trigger (draft disappeared or active-task indicator appeared). Fixes #391.
-    sleepFractionalSeconds(0.3);
-    const verifyResult = runTmux(['capture-pane', '-t', target, '-p', '-S', '-80']);
-    if (verifyResult.ok) {
-        if (paneHasActiveTask(verifyResult.stdout))
+    await sleep(300);
+    const verifyCapture = await capturePaneAsync(target);
+    if (verifyCapture) {
+        if (paneHasActiveTask(verifyCapture))
             return;
-        if (!paneTailContainsLiteralLine(target, text))
+        if (!normalizeTmuxCapture(verifyCapture).includes(normalizeTmuxCapture(text)))
             return;
         // Draft still visible and no active task — one more C-m attempt.
-        sendKeyOrThrow(target, 'C-m', 'C-m');
-        sleepFractionalSeconds(0.15);
-        sendKeyOrThrow(target, 'C-m', 'C-m');
+        await sendKeyAsync(target, 'C-m');
+        await sleep(150);
+        await sendKeyAsync(target, 'C-m');
     }
 }
 export function notifyLeaderStatus(sessionName, message) {
@@ -1104,18 +1153,18 @@ export function isWorkerAlive(sessionName, workerIndex, workerPaneId) {
 }
 // Kill a specific worker: send C-c, then C-d, then kill-pane if still alive.
 // leaderPaneId: when provided, the kill is skipped entirely if workerPaneId matches it.
-export function killWorker(sessionName, workerIndex, workerPaneId, leaderPaneId) {
+export async function killWorker(sessionName, workerIndex, workerPaneId, leaderPaneId) {
     // Guard: never kill the leader's own pane.
     if (leaderPaneId && workerPaneId === leaderPaneId)
         return;
-    runTmux(['send-keys', '-t', paneTarget(sessionName, workerIndex, workerPaneId), 'C-c']);
-    sleepSeconds(1);
-    if (isWorkerAlive(sessionName, workerIndex, workerPaneId)) {
-        runTmux(['send-keys', '-t', paneTarget(sessionName, workerIndex, workerPaneId), 'C-d']);
-        sleepSeconds(1);
+    await runTmuxAsync(['send-keys', '-t', paneTarget(sessionName, workerIndex, workerPaneId), 'C-c']);
+    await sleep(1000);
+    if (await isWorkerAliveAsync(sessionName, workerIndex, workerPaneId)) {
+        await runTmuxAsync(['send-keys', '-t', paneTarget(sessionName, workerIndex, workerPaneId), 'C-d']);
+        await sleep(1000);
     }
-    if (isWorkerAlive(sessionName, workerIndex, workerPaneId)) {
-        runTmux(['kill-pane', '-t', paneTarget(sessionName, workerIndex, workerPaneId)]);
+    if (await isWorkerAliveAsync(sessionName, workerIndex, workerPaneId)) {
+        await runTmuxAsync(['kill-pane', '-t', paneTarget(sessionName, workerIndex, workerPaneId)]);
     }
 }
 // leaderPaneId: when provided, the kill is skipped if workerPaneId matches it.
@@ -1127,6 +1176,81 @@ export function killWorkerByPaneId(workerPaneId, leaderPaneId) {
         return;
     runTmux(['kill-pane', '-t', workerPaneId]);
 }
+export async function killWorkerByPaneIdAsync(workerPaneId, leaderPaneId) {
+    if (!workerPaneId.startsWith('%'))
+        return;
+    // Guard: never kill the leader's own pane.
+    if (leaderPaneId && workerPaneId === leaderPaneId)
+        return;
+    await runTmuxAsync(['kill-pane', '-t', workerPaneId]);
+}
+function normalizePaneTarget(value) {
+    if (typeof value !== 'string')
+        return null;
+    const trimmed = value.trim();
+    if (!trimmed.startsWith('%'))
+        return null;
+    return trimmed;
+}
+function normalizePaneTargets(paneIds, options = {}) {
+    const leaderPaneId = normalizePaneTarget(options.leaderPaneId);
+    const hudPaneId = normalizePaneTarget(options.hudPaneId);
+    const excluded = { leader: 0, hud: 0, invalid: 0 };
+    const deduped = new Set();
+    const killablePaneIds = [];
+    for (const paneId of paneIds) {
+        const normalized = normalizePaneTarget(paneId);
+        if (!normalized) {
+            excluded.invalid += 1;
+            continue;
+        }
+        if (leaderPaneId && normalized === leaderPaneId) {
+            excluded.leader += 1;
+            continue;
+        }
+        if (hudPaneId && normalized === hudPaneId) {
+            excluded.hud += 1;
+            continue;
+        }
+        if (deduped.has(normalized))
+            continue;
+        deduped.add(normalized);
+        killablePaneIds.push(normalized);
+    }
+    return { killablePaneIds, excluded };
+}
+/**
+ * Shared pane-id-direct teardown primitive for worker pane cleanup.
+ * Must remain liveness-agnostic: do not gate on isWorkerAlive/killWorker.
+ */
+export async function teardownWorkerPanes(paneIds, options = {}) {
+    const { killablePaneIds, excluded } = normalizePaneTargets(paneIds, options);
+    const graceMs = options.graceMs ?? 2000;
+    const perPaneGrace = killablePaneIds.length > 0
+        ? Math.max(100, Math.floor(graceMs / killablePaneIds.length))
+        : 0;
+    const summary = {
+        attemptedPaneIds: killablePaneIds,
+        excluded,
+        kill: {
+            attempted: killablePaneIds.length,
+            succeeded: 0,
+            failed: 0,
+        },
+    };
+    for (const paneId of killablePaneIds) {
+        const result = await runTmuxAsync(['kill-pane', '-t', paneId]);
+        if (result.ok)
+            summary.kill.succeeded += 1;
+        else
+            summary.kill.failed += 1;
+        await sleep(perPaneGrace);
+    }
+    return summary;
+}
+export async function killWorkerPanes(paneIds, leaderPaneId, graceMs = 2000, hudPaneId) {
+    return teardownWorkerPanes(paneIds, { leaderPaneId, hudPaneId: hudPaneId ?? null, graceMs });
+}
 // Kill entire tmux session. Tolerates already-dead sessions.
 export function destroyTeamSession(sessionName) {
     try {
@@ -1147,4 +1271,35 @@ export function listTeamSessions() {
         .filter(Boolean)
         .map(baseSessionName);
 }
+/**
+ * Send a trigger message directly to the leader pane via tmux send-keys.
+ * Used as the direct-inject fallback when hook-based dispatch to the leader
+ * times out. Unlike notifyLeaderMailboxAsync (which only writes to the
+ * mailbox file), this actually injects text into the leader's tmux pane
+ * so the leader sees it immediately. Fixes #437.
+ */
+export async function sendToLeaderPane(leaderPaneId, text) {
+    const send = runTmux(['send-keys', '-t', leaderPaneId, '-l', '--', text]);
+    if (!send.ok) {
+        throw new Error(`sendToLeaderPane: failed to send text: ${send.stderr}`);
+    }
+    await sleep(150);
+    await sendKeyAsync(leaderPaneId, 'C-m');
+    await sleep(100);
+    await sendKeyAsync(leaderPaneId, 'C-m');
+}
+/**
+ * Notify the leader via mailbox instead of tmux display-message.
+ * This is the async mailbox-based replacement for notifyLeaderStatus.
+ */
+export async function notifyLeaderMailboxAsync(teamName, fromWorker, message, cwd) {
+    try {
+        const { sendDirectMessage } = await import('./state.js');
+        await sendDirectMessage(teamName, fromWorker, 'leader-fixed', message, cwd);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
 //# sourceMappingURL=tmux-session.js.map