oh-my-codex 0.18.6 → 0.18.8

package/dist/team/tmux-session.js

@@ -1,8 +1,8 @@
 import { spawnSync, execFile } from 'child_process';
 import { promisify } from 'util';
-import { existsSync, readFileSync } from 'fs';
+import { chmodSync, existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
 import { homedir } from 'os';
-import { isAbsolute, join, resolve } from 'path';
+import { dirname, isAbsolute, join, resolve } from 'path';
 import { CODEX_BYPASS_FLAG, CLAUDE_SKIP_PERMISSIONS_FLAG, MADMAX_FLAG, CONFIG_FLAG, LONG_CONFIG_FLAG, MODEL_FLAG, } from '../cli/constants.js';
 import { getAgent } from '../agents/definitions.js';
 import { buildCapturePaneArgv as sharedBuildCapturePaneArgv, buildVisibleCapturePaneArgv as sharedBuildVisibleCapturePaneArgv, normalizeTmuxCapture as sharedNormalizeTmuxCapture, paneHasActiveTask as sharedPaneHasActiveTask, paneIsBootstrapping as sharedPaneIsBootstrapping, paneShowsCodexViewport as sharedPaneShowsCodexViewport, paneLooksReady as sharedPaneLooksReady, } from '../scripts/tmux-hook-engine.js';
@@ -14,7 +14,7 @@ import { resolveOmxCliEntryPath } from '../utils/paths.js';
 const execFileAsync = promisify(execFile);
 import { HUD_RESIZE_RECONCILE_DELAY_SECONDS, HUD_TMUX_TEAM_HEIGHT_LINES } from '../hud/constants.js';
 import { OMX_TMUX_HUD_OWNER_ENV } from '../hud/reconcile.js';
-import { OMX_TMUX_HUD_LEADER_PANE_ENV } from '../hud/tmux.js';
+import { findHudWatchPaneIds, OMX_TMUX_HUD_LEADER_PANE_ENV } from '../hud/tmux.js';
 const OMX_INSTANCE_OPTION = '@omx_instance_id';
 const OMX_PANE_INSTANCE_OPTION = '@omx_pane_instance_id';
 const INJECTION_MARKER = '[OMX_TMUX_INJECT]';
@@ -62,6 +62,7 @@ const TMUX_COPY_MODE_STYLE_OPTIONS = [
 const TMUX_PANE_STABILITY_POLL_MS = 60;
 const TMUX_PANE_STABILITY_POLLS_REQUIRED = 2;
 const TMUX_PANE_STABILITY_TIMEOUT_MS = 750;
+const OMX_TEAM_STATE_ROOT_ENV = 'OMX_TEAM_STATE_ROOT';
 function runTmux(args) {
     const { result } = spawnPlatformCommandSync('tmux', args, { encoding: 'utf-8' });
     if (result.error) {
@@ -122,8 +123,8 @@ export function mitigateCopyModeUnderlineArtifacts(sessionTarget) {
 export function hasCurrentTmuxClientContext() {
     const tmuxPaneTarget = process.env.TMUX_PANE?.trim();
     const displayArgs = tmuxPaneTarget
-        ? ['display-message', '-p', '-t', tmuxPaneTarget, '#S:#I #{pane_id}']
-        : ['display-message', '-p', '#S:#I #{pane_id}'];
+        ? ['display-message', '-p', '-t', tmuxPaneTarget, '#{session_name}:#{window_index} #{pane_id}']
+        : ['display-message', '-p', '#{session_name}:#{window_index} #{pane_id}'];
     const context = runTmux(displayArgs);
     if (!context.ok)
         return false;
@@ -232,6 +233,9 @@ function findHudPaneIds(target, leaderPaneId) {
         .filter((pane) => isHudWatchPane(pane))
         .map((pane) => pane.paneId);
 }
+function findOwnedHudPaneIds(target, leaderPaneId) {
+    return findHudWatchPaneIds(listPanes(target), leaderPaneId, { leaderPaneId });
+}
 const MAX_FRACTIONAL_SLEEP_MS = 60_000;
 function toFractionalSleepMs(seconds) {
     if (!Number.isFinite(seconds) || seconds <= 0)
@@ -280,6 +284,11 @@ async function captureVisiblePaneAsync(target) {
     return result.stdout;
 }
 async function isWorkerAliveAsync(sessionName, workerIndex, workerPaneId) {
+    if (workerPaneId?.startsWith('%')) {
+        const paneStatus = await readPaneLivenessByIdAsync(workerPaneId);
+        if (paneStatus !== null)
+            return paneStatus;
+    }
     const result = await runTmuxAsync([
         'list-panes',
         '-t', paneTarget(sessionName, workerIndex, workerPaneId),
@@ -308,6 +317,54 @@ async function isWorkerAliveAsync(sessionName, workerIndex, workerPaneId) {
         return false;
     }
 }
+function parsePaneLivenessLine(line, allowMissingPid) {
+    const parts = line.trim().split(/\s+/);
+    if (parts.length < 1 || parts[0] === '')
+        return null;
+    const paneDead = parts[0];
+    const pid = Number.parseInt(parts[1] ?? '', 10);
+    if (paneDead === '1')
+        return false;
+    if (!Number.isFinite(pid))
+        return allowMissingPid ? true : false;
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return allowMissingPid;
+    }
+}
+function readPaneLivenessById(paneId) {
+    const result = runTmux(['list-panes', '-a', '-F', '#{pane_id} #{pane_dead} #{pane_pid}']);
+    if (!result.ok)
+        return null;
+    for (const line of result.stdout.split('\n')) {
+        const trimmed = line.trim();
+        if (!trimmed)
+            continue;
+        const [id = '', ...rest] = trimmed.split(/\s+/);
+        if (id !== paneId)
+            continue;
+        return parsePaneLivenessLine(rest.join(' '), true);
+    }
+    return null;
+}
+async function readPaneLivenessByIdAsync(paneId) {
+    const result = await runTmuxAsync(['list-panes', '-a', '-F', '#{pane_id} #{pane_dead} #{pane_pid}']);
+    if (!result.ok)
+        return null;
+    for (const line of result.stdout.split('\n')) {
+        const trimmed = line.trim();
+        if (!trimmed)
+            continue;
+        const [id = '', ...rest] = trimmed.split(/\s+/);
+        if (id !== paneId)
+            continue;
+        return parsePaneLivenessLine(rest.join(' '), true);
+    }
+    return null;
+}
 function shellQuoteSingle(value) {
     return `'${value.replace(/'/g, `'\\''`)}'`;
 }
@@ -640,6 +697,20 @@ function commandExists(binary) {
     }
     return true;
 }
+export function trustWorkerMiseConfigIfAvailable(workerCwd) {
+    const miseConfigPath = join(workerCwd, '.mise.toml');
+    if (!existsSync(miseConfigPath))
+        return false;
+    if (!commandExists('mise'))
+        return false;
+    const { result } = spawnPlatformCommandSync('mise', ['trust', '--yes', miseConfigPath], { encoding: 'utf-8' });
+    if (result.error || result.status !== 0) {
+        const reason = result.error?.message || String(result.stderr || '').trim() || `mise exited ${result.status}`;
+        console.warn(`[omx] mise trust failed for team worker config ${miseConfigPath}: ${reason}; continuing.`);
+        return false;
+    }
+    return true;
+}
 /**
  * Resolve the absolute path of a binary from the leader's current environment.
  * Returns the absolute path or the bare command name as fallback.
@@ -798,6 +869,60 @@ export function buildWorkerStartupCommand(teamName, workerIndex, launchArgs = []
     const envParts = Object.entries(startupEnv).map(([key, value]) => `${key}=${value}`);
     return `env ${envParts.map(shellQuoteSingle).join(' ')} ${shellQuoteSingle(launchSpec.shell)} -c ${shellQuoteSingle(inner)}`;
 }
+function assertShellEnvKey(key) {
+    if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(key)) {
+        throw new Error(`invalid worker startup env key: ${key}`);
+    }
+}
+function buildWorkerStartupScriptContent(processSpec, startupEnv, startupArgs, cwd, extraEnv) {
+    const resolvedLeaderNodePath = processSpec.env[OMX_LEADER_NODE_PATH_ENV]?.trim() || resolveLeaderNodePath();
+    const leaderNodeDir = /[\\/]/.test(resolvedLeaderNodePath)
+        ? resolvedLeaderNodePath.replace(/[\\/][^\\/]+$/, '')
+        : '';
+    const launchSpec = buildWorkerLaunchSpec(process.env.SHELL);
+    const pathPrefix = leaderNodeDir ? `export PATH=${shellQuoteSingle(leaderNodeDir)}:$PATH\n` : '';
+    const quotedArgs = startupArgs.map(shellQuoteSingle).join(' ');
+    const quotedCommand = shellQuoteSingle(processSpec.command);
+    const cliInvocation = quotedArgs.length > 0 ? `exec ${quotedCommand} ${quotedArgs}` : `exec ${quotedCommand}`;
+    const rcPrefix = shouldSourceTeamWorkerShellRc({ ...process.env, ...extraEnv }) && launchSpec.rcFile
+        ? `if [ -f ${launchSpec.rcFile} ]; then . ${launchSpec.rcFile}; fi\n`
+        : '';
+    const envExports = Object.entries(startupEnv)
+        .map(([key, value]) => {
+        assertShellEnvKey(key);
+        return `export ${key}=${shellQuoteSingle(value)}`;
+    })
+        .join('\n');
+    return [
+        '#!/bin/sh',
+        'set -eu',
+        `cd ${shellQuoteSingle(cwd)}`,
+        envExports,
+        `exec ${shellQuoteSingle(launchSpec.shell)} -c ${shellQuoteSingle(`${rcPrefix}${pathPrefix}${cliInvocation}`)}`,
+        '',
+    ].filter((line) => line !== '').join('\n');
+}
+export function writeWorkerStartupScriptCommand(teamName, workerIndex, launchArgs = [], cwd = process.cwd(), extraEnv = {}, workerCliOverride, initialPrompt, workerRole) {
+    if (process.platform === 'win32')
+        return null;
+    const stateRoot = extraEnv[OMX_TEAM_STATE_ROOT_ENV]?.trim();
+    if (!stateRoot)
+        return null;
+    const processSpec = buildWorkerProcessLaunchSpec(teamName, workerIndex, launchArgs, cwd, extraEnv, workerCliOverride, initialPrompt, workerRole);
+    const startupEnv = {
+        ...readTmuxWorkerAmbientEnv(process.env),
+        ...processSpec.env,
+    };
+    const startupArgs = [...processSpec.args];
+    if (processSpec.workerCli === 'codex') {
+        appendTeamWorkerMcpDisableOverrides(startupArgs, { ...process.env, ...extraEnv });
+    }
+    const scriptPath = join(stateRoot, 'team', teamName, 'runtime', `worker-${workerIndex}-startup.sh`);
+    mkdirSync(dirname(scriptPath), { recursive: true });
+    writeFileSync(scriptPath, buildWorkerStartupScriptContent(processSpec, startupEnv, startupArgs, cwd, extraEnv), 'utf-8');
+    chmodSync(scriptPath, 0o700);
+    return `exec /bin/sh ${shellQuoteSingle(scriptPath)}`;
+}
 export function buildWorkerProcessLaunchSpec(teamName, workerIndex, launchArgs = [], cwd = process.cwd(), extraEnv = {}, workerCliOverride, initialPrompt, workerRole) {
     const effectiveEnv = { ...process.env, ...extraEnv };
     const fullLaunchArgs = resolveWorkerLaunchArgs(launchArgs, cwd, effectiveEnv);
@@ -934,8 +1059,8 @@ export function createTeamSession(teamName, workerCount, cwd, workerLaunchArgs =
     try {
         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}'];
+            ? ['display-message', '-p', '-t', tmuxPaneTarget, '#{session_name}:#{window_index} #{pane_id}']
+            : ['display-message', '-p', '#{session_name}:#{window_index} #{pane_id}'];
         const context = runTmux(displayArgs);
         if (!context.ok) {
             const paneHint = tmuxPaneTarget ? ` (TMUX_PANE=${tmuxPaneTarget})` : '';
@@ -976,7 +1101,8 @@ export function createTeamSession(teamName, workerCount, cwd, workerLaunchArgs =
             const tmuxWorkerCwd = translatePathForMsys(workerCwd);
             const workerEnv = startup.env || {};
             const launchArgsForWorker = startup.launchArgs || workerLaunchArgs;
-            const cmd = buildWorkerStartupCommand(safeTeamName, i, launchArgsForWorker, workerCwd, workerEnv, workerCliPlan[i - 1], startup.initialPrompt, startup.workerRole);
+            trustWorkerMiseConfigIfAvailable(workerCwd);
+            const cmd = writeWorkerStartupScriptCommand(safeTeamName, i, launchArgsForWorker, workerCwd, workerEnv, workerCliPlan[i - 1], startup.initialPrompt, startup.workerRole) ?? buildWorkerStartupCommand(safeTeamName, i, launchArgsForWorker, workerCwd, workerEnv, workerCliPlan[i - 1], startup.initialPrompt, startup.workerRole);
             // First split creates the right side from leader. Remaining splits stack on the right.
             const splitDirection = i === 1 ? '-h' : '-v';
             const splitTarget = i === 1 ? leaderPaneId : (rightStackRootPaneId ?? leaderPaneId);
@@ -1075,20 +1201,17 @@ export function createTeamSession(teamName, workerCount, cwd, workerLaunchArgs =
                         if (registerClientAttachedHook.ok) {
                             registeredClientAttachedHook = { name: clientAttachedHookName, target: hookTarget };
                         }
-                        else if (registerHook.ok) {
-                            throw new Error(`failed to register client-attached reconcile hook ${clientAttachedHookName}: ${registerClientAttachedHook.stderr}`);
-                        }
                         else {
                             console.warn(`[omx] tmux client-attached resize fallback unavailable for ${hookTarget} `
                                 + `(${clientAttachedHookName}): ${registerClientAttachedHook.stderr}; continuing with delayed HUD resize fallback.`);
                         }
                         const delayed = runTmux(buildScheduleDelayedHudResizeArgs(hudPaneId));
                         if (!delayed.ok) {
-                            throw new Error(`failed to schedule delayed HUD resize: ${delayed.stderr}`);
+                            console.warn(`[omx] tmux delayed HUD resize unavailable for ${hudPaneId}: ${delayed.stderr}; continuing.`);
                         }
                         const reconcile = runTmux(buildReconcileHudResizeArgs(hudPaneId));
                         if (!reconcile.ok) {
-                            throw new Error(`failed to reconcile HUD resize: ${reconcile.stderr}`);
+                            console.warn(`[omx] tmux HUD resize reconcile unavailable for ${hudPaneId}: ${reconcile.stderr}; continuing.`);
                         }
                     }
                 }
@@ -1135,6 +1258,21 @@ export function restoreStandaloneHudPane(leaderPaneId, cwd) {
     const omxEntry = resolveOmxCliEntryPath();
     if (!omxEntry || omxEntry.trim() === '')
         return null;
+    const [existingHudPaneId, ...duplicateHudPaneIds] = findOwnedHudPaneIds(normalizedLeaderPaneId, normalizedLeaderPaneId);
+    for (const paneId of duplicateHudPaneIds) {
+        runTmux(['kill-pane', '-t', paneId]);
+    }
+    if (existingHudPaneId) {
+        if (isNativeWindows()) {
+            runTmux(buildHudResizeArgs(existingHudPaneId));
+        }
+        else {
+            runTmux(buildScheduleDelayedHudResizeArgs(existingHudPaneId));
+            runTmux(buildReconcileHudResizeArgs(existingHudPaneId));
+        }
+        runTmux(['select-pane', '-t', normalizedLeaderPaneId]);
+        return existingHudPaneId;
+    }
     const hudCmd = `exec env ${formatHudEnvAssignments(process.env, { leaderPaneId: normalizedLeaderPaneId })} ${shellQuoteSingle(translatePathForMsys(resolveLeaderNodePath()))} ${shellQuoteSingle(translatePathForMsys(omxEntry))} hud --watch`;
     const hudCwd = translatePathForMsys(cwd);
     const hudResult = runTmux([
@@ -1703,6 +1841,11 @@ export function getWorkerPanePid(sessionName, workerIndex, workerPaneId) {
 }
 // Check if worker's tmux pane has a running process
 export function isWorkerAlive(sessionName, workerIndex, workerPaneId) {
+    if (workerPaneId?.startsWith('%')) {
+        const paneStatus = readPaneLivenessById(workerPaneId);
+        if (paneStatus !== null)
+            return paneStatus;
+    }
     const result = runTmux([
         'list-panes',
         '-t', paneTarget(sessionName, workerIndex, workerPaneId),
@@ -1732,6 +1875,11 @@ export function isWorkerAlive(sessionName, workerIndex, workerPaneId) {
     }
 }
 export function isWorkerPaneOpen(sessionName, workerIndex, workerPaneId) {
+    if (workerPaneId?.startsWith('%')) {
+        const paneStatus = readPaneLivenessById(workerPaneId);
+        if (paneStatus !== null)
+            return paneStatus;
+    }
     const result = runTmux([
         'list-panes',
         '-t', paneTarget(sessionName, workerIndex, workerPaneId),