oh-my-codex 0.16.2 → 0.16.4

package/dist/cli/index.js

@@ -5,9 +5,9 @@
 import { execFileSync, spawn } from "child_process";
 import { basename, dirname, join, posix, win32 } from "path";
 import { existsSync, mkdirSync, readFileSync, rmSync, statSync, writeFileSync } from "fs";
-import { copyFile, cp, lstat, mkdir, readdir, rm, symlink } from "fs/promises";
+import { copyFile, cp, lstat, mkdir, readFile, readdir, rm, symlink, writeFile } from "fs/promises";
 import { constants as osConstants, homedir } from "os";
-import { setup, SETUP_SCOPES } from "./setup.js";
+import { setup, SETUP_MCP_MODES, SETUP_SCOPES, } from "./setup.js";
 import { uninstall } from "./uninstall.js";
 import { version } from "./version.js";
 import { tmuxHookCommand } from "./tmux-hook.js";
@@ -35,9 +35,10 @@ import { adaptCommand } from "./adapt.js";
 import { listCommand } from "./list.js";
 import { MADMAX_FLAG, CODEX_BYPASS_FLAG, HIGH_REASONING_FLAG, XHIGH_REASONING_FLAG, SPARK_FLAG, MADMAX_SPARK_FLAG, CONFIG_FLAG, LONG_CONFIG_FLAG, } from "./constants.js";
 import { getBaseStateDir, getStateDir, listModeStateFilesWithScopePreference, } from "../mcp/state-paths.js";
-import { resolveCodexConfigPathForLaunch, resolveCodexHomeForLaunch, resolveProjectLocalCodexHomeForLaunch, } from "./codex-home.js";
+import { evaluateRalphCompletionAuditEvidence, isRalphCompletePhase } from "../ralph/completion-audit.js";
+import { readPersistedSetupPreferences, resolveCodexConfigPathForLaunch, resolveCodexHomeForLaunch, resolveProjectLocalCodexHomeForLaunch, } from "./codex-home.js";
 export { readPersistedSetupPreferences, readPersistedSetupScope, resolveCodexConfigPathForLaunch, resolveCodexHomeForLaunch, resolveProjectLocalCodexHomeForLaunch, } from "./codex-home.js";
-import { SKILL_ACTIVE_STATE_MODE, extractSessionIdFromInitializedStatePath, getSkillActiveStatePaths, listActiveSkills, readSkillActiveState, syncCanonicalSkillStateForMode, } from "../state/skill-active.js";
+import { SKILL_ACTIVE_STATE_MODE, extractSessionIdFromInitializedStatePath, getSkillActiveStatePathsForStateDir, listActiveSkills, readSkillActiveState, syncCanonicalSkillStateForMode, } from "../state/skill-active.js";
 import { isTrackedWorkflowMode } from "../state/workflow-transition.js";
 import { maybeCheckAndPromptUpdate, runImmediateUpdate } from "./update.js";
 import { maybePromptGithubStar } from "./star-prompt.js";
@@ -46,7 +47,8 @@ import { readSessionState, writeSessionStart, writeSessionEnd, resetSessionMetri
 import { buildClientAttachedReconcileHookName, buildReconcileHudResizeArgs, buildRegisterClientAttachedReconcileArgs, buildRegisterResizeHookArgs, buildResizeHookName, buildResizeHookTarget, buildScheduleDelayedHudResizeArgs, buildUnregisterClientAttachedReconcileArgs, buildUnregisterResizeHookArgs, enableMouseScrolling, isMsysOrGitBash, isNativeWindows, isTmuxAvailable, mitigateCopyModeUnderlineArtifacts, } from "../team/tmux-session.js";
 import { getPackageRoot } from "../utils/package.js";
 import { codexConfigPath, omxRoot, rememberOmxLaunchContext, resolveOmxEntryPath } from "../utils/paths.js";
-import { cleanCodexModelAvailabilityNuxIfNeeded, repairConfigIfNeeded } from "../config/generator.js";
+import { cleanCodexModelAvailabilityNuxIfNeeded, extractSharedMcpRegistryServersFromConfig, repairConfigIfNeeded, upsertManagedCodexHookTrustState } from "../config/generator.js";
+import { OMX_FIRST_PARTY_MCP_SERVER_NAMES } from "../config/omx-first-party-mcp.js";
 import { HUD_TMUX_HEIGHT_LINES } from "../hud/constants.js";
 import { OMX_TMUX_HUD_OWNER_ENV } from "../hud/reconcile.js";
 import { createHudWatchPane as createSharedHudWatchPane, killTmuxPane as killSharedTmuxPane, listCurrentWindowHudPaneIds, parsePaneIdFromTmuxOutput, } from "../hud/tmux.js";
@@ -83,7 +85,7 @@ Usage:
                 Queue audited follow-up instructions for a running non-interactive exec job
   omx imagegen continuation <session-id> --artifact <name>
                 Queue a Stop-hook continuation for built-in image generation turns
-  omx setup     Install skills, prompts, MCP servers, and scope-specific AGENTS.md
+  omx setup     Install skills, prompts, CLI-first config, and scope-specific AGENTS.md
                 (user scope prompts for legacy vs plugin skill delivery when needed)
   omx update    Check npm now, update the global install immediately, then refresh setup
   omx uninstall Remove OMX configuration and clean up installed artifacts
@@ -116,13 +118,13 @@ Usage:
   omx hud       Show HUD statusline (--watch, --json, --preset=NAME)
   omx sidecar   Show read-only team/multi-agent visualization (--watch, --json, --tmux)
   omx state     Read/write/list OMX mode state via CLI parity surface
-  omx notepad   CLI parity for OMX notepad MCP tools
+  omx notepad   JSON CLI surface for OMX notepad operations
   omx project-memory
-                CLI parity for OMX project-memory MCP tools
-  omx trace     CLI parity for OMX trace MCP tools
+                JSON CLI surface for OMX project-memory operations
+  omx trace     JSON CLI surface for OMX trace operations
   omx code-intel
-                CLI parity for OMX code-intel MCP tools
-  omx wiki      CLI parity for OMX wiki MCP tools
+                JSON CLI surface for OMX code-intel operations
+  omx wiki      JSON CLI surface for OMX wiki operations
   omx mcp-serve Launch an OMX stdio MCP server target (plugin/runtime use)
   omx sparkshell <command> [args...]
   omx sparkshell --tmux-pane <pane-id> [--tail-lines <100-1000>]
@@ -164,6 +166,10 @@ Options:
   --legacy      Use legacy setup delivery for omx setup, overriding persisted plugin mode
   --install-mode <legacy|plugin>
                 Explicit setup install mode (canonical form; --legacy/--plugin are aliases)
+  --mcp <none|compat>
+                Explicit setup MCP mode (default: none; compat enables first-party MCP compatibility and shared registry sync)
+  --no-mcp      Alias for --mcp=none
+  --with-mcp    Alias for --mcp=compat
   --keep-config Skip config.toml cleanup during uninstall
   --purge       Remove .omx/ cache directory during uninstall
   --verbose     Show detailed output
@@ -288,6 +294,45 @@ export function resolveSetupInstallModeArg(args) {
     }
     return value;
 }
+export function resolveSetupMcpModeArg(args) {
+    let value;
+    const setValue = (next, source) => {
+        if (value && value !== next) {
+            throw new Error(`Conflicting setup MCP mode flags: ${source} selects ${next}, but another flag already selected ${value}`);
+        }
+        value = next;
+    };
+    const parseValue = (next) => {
+        if (!SETUP_MCP_MODES.includes(next)) {
+            throw new Error(`Invalid setup MCP mode: ${next}. Expected one of: none, compat`);
+        }
+        return next;
+    };
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index];
+        if (arg === "--no-mcp") {
+            setValue("none", arg);
+            continue;
+        }
+        if (arg === "--with-mcp") {
+            setValue("compat", arg);
+            continue;
+        }
+        if (arg === "--mcp") {
+            const next = args[index + 1];
+            if (!next || next.startsWith("-")) {
+                throw new Error(`Missing setup MCP mode value after --mcp. Expected one of: none, compat`);
+            }
+            setValue(parseValue(next), arg);
+            index += 1;
+            continue;
+        }
+        if (arg.startsWith("--mcp=")) {
+            setValue(parseValue(arg.slice("--mcp=".length)), "--mcp");
+        }
+    }
+    return value;
+}
 export function resolveSetupScopeArg(args) {
     let value;
     for (let index = 0; index < args.length; index += 1) {
@@ -447,12 +492,20 @@ export async function prepareRuntimeCodexHomeForProjectLaunch(cwd, sessionId, pr
             continue;
         const source = join(projectCodexHome, entry.name);
         const destination = join(runtimeCodexHome, entry.name);
-        if (entry.name === "config.toml") {
+        if (entry.name === "config.toml" || entry.name === "hooks.json") {
             await copyFile(source, destination);
             continue;
         }
         await linkOrCopyCodexHomeEntry(source, destination);
     }
+    const runtimeConfigPath = join(runtimeCodexHome, "config.toml");
+    const runtimeHooksPath = join(runtimeCodexHome, "hooks.json");
+    if (existsSync(runtimeConfigPath) && existsSync(runtimeHooksPath)) {
+        const runtimeConfig = await readFile(runtimeConfigPath, "utf-8");
+        if (runtimeConfig.includes("# OMX-owned Codex hook trust state")) {
+            await writeFile(runtimeConfigPath, upsertManagedCodexHookTrustState(runtimeConfig, getPackageRoot(), runtimeHooksPath), "utf-8");
+        }
+    }
     return runtimeCodexHome;
 }
 function resolveProjectSqliteHomeForLaunch(projectCodexHome, env) {
@@ -629,6 +682,39 @@ export function classifyCodexExecFailure(error) {
         message,
     };
 }
+export async function resolveLaunchConfigRepairOptions(cwd, configPath) {
+    let content;
+    const readConfig = async () => {
+        if (content !== undefined)
+            return content;
+        if (!existsSync(configPath))
+            return undefined;
+        content = await readFile(configPath, "utf-8");
+        return content;
+    };
+    const existingContent = await readConfig();
+    const sharedMcpRegistry = existingContent
+        ? extractSharedMcpRegistryServersFromConfig(existingContent)
+        : { servers: [] };
+    const sharedMcpOptions = sharedMcpRegistry.servers.length > 0
+        ? {
+            sharedMcpServers: sharedMcpRegistry.servers,
+            sharedMcpRegistrySource: sharedMcpRegistry.sourcePath,
+        }
+        : {};
+    if (readPersistedSetupPreferences(cwd)?.mcpMode === "compat") {
+        return { includeFirstPartyMcp: true, ...sharedMcpOptions };
+    }
+    if (existingContent) {
+        const hasExistingFirstPartyMcp = OMX_FIRST_PARTY_MCP_SERVER_NAMES.some((name) => new RegExp(`^\\s*\\[mcp_servers\\.${name}\\]\\s*$`, "m").test(existingContent));
+        if (hasExistingFirstPartyMcp || sharedMcpRegistry.servers.length > 0) {
+            return { includeFirstPartyMcp: hasExistingFirstPartyMcp, ...sharedMcpOptions };
+        }
+    }
+    return {
+        includeFirstPartyMcp: false,
+    };
+}
 function runCodexBlocking(cwd, launchArgs, codexEnv) {
     const { result } = spawnPlatformCommandSync("codex", launchArgs, {
         cwd,
@@ -658,6 +744,9 @@ function runCodexBlocking(cwd, launchArgs, codexEnv) {
         if (result.signal) {
             console.error(`[omx] codex exited due to signal ${result.signal}`);
         }
+        else if (typeof result.status === "number") {
+            console.error(`[omx] codex exited with code ${result.status}`);
+        }
     }
 }
 export function buildHudPaneCleanupTargets(existingPaneIds, createdPaneId, leaderPaneId) {
@@ -805,6 +894,7 @@ export async function main(args) {
                     verbose: options.verbose,
                     scope: resolveSetupScopeArg(args.slice(1)),
                     installMode: resolveSetupInstallModeArg(args.slice(1)),
+                    mcpMode: resolveSetupMcpModeArg(args.slice(1)),
                 });
                 break;
             case "update":
@@ -1096,7 +1186,8 @@ export async function launchWithHud(args) {
     // have written a config.toml with duplicate [tui] sections.  Codex CLI's
     // TOML parser rejects duplicates, so we repair before spawning the CLI.
     try {
-        const repaired = await repairConfigIfNeeded(resolveCodexConfigPathForLaunch(launchCwd, process.env), getPackageRoot());
+        const configPath = resolveCodexConfigPathForLaunch(launchCwd, process.env);
+        const repaired = await repairConfigIfNeeded(configPath, getPackageRoot(), await resolveLaunchConfigRepairOptions(launchCwd, configPath));
         if (repaired) {
             console.log("[omx] Repaired managed config.toml compatibility issue.");
         }
@@ -1180,7 +1271,8 @@ export async function execWithOverlay(args) {
         logCliOperationFailure(err);
     }
     try {
-        const repaired = await repairConfigIfNeeded(resolveCodexConfigPathForLaunch(launchCwd, process.env), getPackageRoot());
+        const configPath = resolveCodexConfigPathForLaunch(launchCwd, process.env);
+        const repaired = await repairConfigIfNeeded(configPath, getPackageRoot(), await resolveLaunchConfigRepairOptions(launchCwd, configPath));
         if (repaired) {
             console.log("[omx] Repaired managed config.toml compatibility issue.");
         }
@@ -1759,15 +1851,30 @@ function buildDetachedSessionLeaderCommand(cwd, sessionName, codexCmd, sessionId
         'exec 3<&- 2>/dev/null || true;',
         buildTmuxExtendedKeysReleaseShellSnippet(cwd),
         detachedPostLaunchHelper,
-        'if [ "$status" -lt 128 ]; then',
+        'if [ "$status" -eq 0 ]; then',
         `tmux kill-session -t "${escapeShellDoubleQuotedValue(sessionName)}" >/dev/null 2>&1 || true;`,
         "fi;",
         "exit $status;",
         "};",
         "trap omx_detached_session_cleanup 0 INT TERM HUP;",
+        "omx_codex_started_at=$(date +%s 2>/dev/null || printf 0);",
         `${codexCmd} <&3 &`,
         "omx_codex_pid=$!;",
         'wait "$omx_codex_pid";',
+        "omx_codex_status=$?;",
+        "omx_codex_finished_at=$(date +%s 2>/dev/null || printf 0);",
+        'omx_codex_elapsed=$((omx_codex_finished_at - omx_codex_started_at));',
+        'if [ "$omx_codex_status" -eq 0 ] && [ "$omx_codex_elapsed" -le 2 ]; then',
+        'printf "\\n[omx] codex exited immediately with code 0 during startup. The detached tmux session is being kept open so any output above remains visible. Press Enter to close this OMX session.\\n" >&2;',
+        'IFS= read -r _omx_close || true;',
+        'elif [ "$omx_codex_status" -gt 0 ] && [ "$omx_codex_status" -lt 128 ] && [ "$omx_codex_elapsed" -le 2 ]; then',
+        'printf "\\n[omx] codex exited with code %s during startup. The detached tmux session is being kept open so the error above remains visible. Press Enter to close this OMX session.\\n" "$omx_codex_status" >&2;',
+        'IFS= read -r _omx_close || true;',
+        'elif [ "$omx_codex_status" -gt 0 ] && [ "$omx_codex_status" -lt 128 ]; then',
+        'printf "\\n[omx] codex exited with code %s. The detached tmux session is being kept open so the error above remains visible. Press Enter to close this OMX session.\\n" "$omx_codex_status" >&2;',
+        'IFS= read -r _omx_close || true;',
+        "fi;",
+        'exit "$omx_codex_status";',
     ].join(" ");
     return `/bin/sh -c ${quoteShellArg(wrapped)}`;
 }
@@ -2145,11 +2252,11 @@ function cleanPostLaunchString(value) {
 function postLaunchUniqueStrings(values) {
     return [...new Set(values.map((value) => value.trim()).filter(Boolean))];
 }
-async function scrubPostLaunchRootSkillActiveForSession(cwd, sessionId, nowIso, writeFileFn, rootStateBeforeCleanup) {
+async function scrubPostLaunchRootSkillActiveForSession(stateDir, sessionId, nowIso, writeFileFn, rootStateBeforeCleanup) {
     const normalizedSessionId = cleanPostLaunchString(sessionId);
     if (!normalizedSessionId)
         return;
-    const { rootPath } = getSkillActiveStatePaths(cwd);
+    const { rootPath } = getSkillActiveStatePathsForStateDir(stateDir);
     const rootState = rootStateBeforeCleanup ?? await readSkillActiveState(rootPath);
     if (!rootState)
         return;
@@ -2200,6 +2307,23 @@ function buildRecoveredPostLaunchSkillActiveState(completedAt) {
         active_skills: [],
     };
 }
+function markRalphCompletionAuditBlockedForPostLaunch(state, cwd, nowIso) {
+    if (!isRalphCompletePhase(state.current_phase ?? state.currentPhase))
+        return false;
+    const audit = evaluateRalphCompletionAuditEvidence(state, cwd);
+    if (audit.complete)
+        return false;
+    state.active = false;
+    state.current_phase = "cancelled";
+    state.completed_at = nowIso;
+    state.last_turn_at = nowIso;
+    state.interrupted_at = nowIso;
+    state.stop_reason = `missing_completion_audit:${audit.reason}`;
+    state.completion_audit_gate = "blocked";
+    state.completion_audit_missing_reason = audit.reason;
+    state.completion_audit_blocked_at = nowIso;
+    return true;
+}
 export async function cleanupPostLaunchModeStateFiles(cwd, sessionId, dependencies = {}) {
     const readdir = dependencies.readdir ?? (await import("fs/promises")).readdir;
     const writeFile = dependencies.writeFile ?? (await import("fs/promises")).writeFile;
@@ -2208,8 +2332,9 @@ export async function cleanupPostLaunchModeStateFiles(cwd, sessionId, dependenci
     const scopedDirs = sessionId
         ? [getStateDir(cwd, sessionId)]
         : [getBaseStateDir(cwd)];
+    const rootStateDir = getBaseStateDir(cwd);
     const rootSkillActiveStateBeforeCleanup = sessionId
-        ? await readSkillActiveState(getSkillActiveStatePaths(cwd).rootPath)
+        ? await readSkillActiveState(getSkillActiveStatePathsForStateDir(rootStateDir).rootPath)
         : null;
     for (const stateDir of scopedDirs) {
         const files = await readdir(stateDir).catch(() => []);
@@ -2229,6 +2354,7 @@ export async function cleanupPostLaunchModeStateFiles(cwd, sessionId, dependenci
                         if (isTrackedWorkflowMode(mode)) {
                             await syncCanonicalSkillStateForMode({
                                 cwd,
+                                baseStateDir: rootStateDir,
                                 mode,
                                 active: false,
                                 currentPhase: "cancelled",
@@ -2250,8 +2376,25 @@ export async function cleanupPostLaunchModeStateFiles(cwd, sessionId, dependenci
             const skillStateStillVisible = mode === SKILL_ACTIVE_STATE_MODE
                 && Array.isArray(result.state.active_skills)
                 && result.state.active_skills.length > 0;
-            if (result.state.active !== true && !skillStateStillVisible)
+            if (result.state.active !== true && !skillStateStillVisible) {
+                if (mode === "ralph") {
+                    const completedAt = now().toISOString();
+                    if (markRalphCompletionAuditBlockedForPostLaunch(result.state, cwd, completedAt)) {
+                        await writeFile(path, JSON.stringify(result.state, null, 2));
+                        await syncCanonicalSkillStateForMode({
+                            cwd,
+                            baseStateDir: rootStateDir,
+                            mode,
+                            active: false,
+                            currentPhase: "cancelled",
+                            sessionId: stateDir === getStateDir(cwd, sessionId) ? sessionId : undefined,
+                            nowIso: completedAt,
+                            source: "postLaunchCleanup",
+                        });
+                    }
+                }
                 continue;
+            }
             try {
                 const completedAt = now().toISOString();
                 if (mode === SKILL_ACTIVE_STATE_MODE) {
@@ -2265,10 +2408,15 @@ export async function cleanupPostLaunchModeStateFiles(cwd, sessionId, dependenci
                 result.state.active = false;
                 result.state.current_phase = "cancelled";
                 result.state.completed_at = completedAt;
+                if (mode === "ralph") {
+                    result.state.interrupted_at = completedAt;
+                    result.state.stop_reason = cleanPostLaunchString(result.state.stop_reason) || "session_exit";
+                }
                 await writeFile(path, JSON.stringify(result.state, null, 2));
                 if (isTrackedWorkflowMode(mode)) {
                     await syncCanonicalSkillStateForMode({
                         cwd,
+                        baseStateDir: rootStateDir,
                         mode,
                         active: false,
                         currentPhase: "cancelled",
@@ -2285,7 +2433,7 @@ export async function cleanupPostLaunchModeStateFiles(cwd, sessionId, dependenci
     }
     if (sessionId) {
         try {
-            await scrubPostLaunchRootSkillActiveForSession(cwd, sessionId, now().toISOString(), writeFile, rootSkillActiveStateBeforeCleanup);
+            await scrubPostLaunchRootSkillActiveForSession(rootStateDir, sessionId, now().toISOString(), writeFile, rootSkillActiveStateBeforeCleanup);
         }
         catch (err) {
             writeWarn(`[omx] postLaunch: failed to reconcile root skill-active state: ${err instanceof Error ? err.message : err}`);