oh-my-codex 0.18.14 → 0.18.16

package/dist/cli/doctor.js

@@ -13,7 +13,7 @@ import { parse as parseToml } from "@iarna/toml";
 import { getBuiltinExploreHarnessUnsupportedReason, resolvePackagedExploreHarnessCommand, EXPLORE_BIN_ENV, } from "./explore.js";
 import { getPackageRoot } from "../utils/package.js";
 import { hasLegacyOmxTeamRunTable, getModelContextRecommendation, } from "../config/generator.js";
-import { MANAGED_HOOK_EVENTS, buildManagedCodexNativeHookCommand, discoverCodexHookConfigPaths, getManagedCodexHookCommandsForEvent, getMissingManagedCodexHookEvents, hasCodexHooksJsonTopLevelState, } from "../config/codex-hooks.js";
+import { MANAGED_HOOK_EVENTS, buildManagedCodexNativeHookCommand, discoverCodexHookConfigPaths, resolveWindowsPowerShellPath, getManagedCodexHookCommandsForEvent, getMissingManagedCodexHookEvents, hasCodexHooksJsonTopLevelState, } from "../config/codex-hooks.js";
 import { OMX_FIRST_PARTY_MCP_SERVER_NAMES } from "../config/omx-first-party-mcp.js";
 import { getDefaultBridge, isBridgeEnabled } from "../runtime/bridge.js";
 import { OMX_EXPLORE_CMD_ENV, isExploreCommandRoutingEnabled, } from "../hooks/explore-routing.js";
@@ -163,7 +163,10 @@ export async function doctor(options = {}) {
     // Check 2: Node.js version
     checks.push(checkNodeVersion());
     // Check 2.5: Explore harness readiness
-    checks.push(checkExploreHarness());
+    const exploreRoutingState = await resolveExploreRoutingState(paths.configPath);
+    checks.push(checkExploreHarness(process.platform, process.env, {
+        exploreRoutingEnabled: exploreRoutingState.enabled,
+    }));
     // Check 3: Codex home directory
     checks.push(checkDirectory("Codex home", paths.codexHomeDir));
     // Check 4: Config file
@@ -187,9 +190,13 @@ export async function doctor(options = {}) {
     if (runtimeMirrorCheck)
         checks.push(runtimeMirrorCheck);
     // Check 4.5: Explore routing default
-    checks.push(await checkExploreRouting(paths.configPath));
+    checks.push(checkExploreRoutingFromState(exploreRoutingState));
     // Check 4.6: Lore commit guard default
     checks.push(await checkLoreCommitGuard(paths.configPath));
+    // Check 4.7: External process guards
+    const externalProcessGuardCheck = await checkExternalCodexProcessGuards();
+    if (externalProcessGuardCheck)
+        checks.push(externalProcessGuardCheck);
     // Check 5: Prompts installed
     checks.push(await checkPrompts(paths.promptsDir, scopeResolution.installMode));
     // Check 6: Skills installed
@@ -582,7 +589,16 @@ function checkNodeVersion() {
         message: `v${process.versions.node} (need >= 20)`,
     };
 }
-export function checkExploreHarness(platform = process.platform, env = process.env) {
+export function checkExploreHarness(platform = process.platform, env = process.env, options = {}) {
+    const override = env[EXPLORE_BIN_ENV]?.trim();
+    const exploreRoutingEnabled = options.exploreRoutingEnabled ?? isExploreCommandRoutingEnabled(env);
+    if (!override && !exploreRoutingEnabled) {
+        return {
+            name: "Explore Harness",
+            status: "pass",
+            message: "skipped: omx explore is hard-deprecated and explore routing is disabled by default; use omx sparkshell for shell-native read-only evidence",
+        };
+    }
     const packageRoot = getPackageRoot();
     const manifestPath = join(packageRoot, "crates", "omx-explore", "Cargo.toml");
     if (!existsSync(manifestPath)) {
@@ -592,7 +608,6 @@ export function checkExploreHarness(platform = process.platform, env = process.e
             message: "Rust harness sources not found in this install (omx explore unavailable until packaged or OMX_EXPLORE_BIN is set)",
         };
     }
-    const override = env[EXPLORE_BIN_ENV]?.trim();
     if (override) {
         const resolved = join(packageRoot, override);
         if (existsSync(override) || existsSync(resolved)) {
@@ -683,6 +698,8 @@ function formatArtifactIssue(repoRoot, issue) {
     return `${formatArtifactPath(repoRoot, issue.path)} (${issue.reason}${owner})`;
 }
 function shouldReportOwnerMismatch(uid, currentUid) {
+    if (currentUid === 0)
+        return false;
     if (typeof uid !== "number")
         return false;
     if (uid === 0)
@@ -717,8 +734,10 @@ async function collectRepoArtifactOwnershipIssues(repoRoot, options = {}) {
         const uid = typeof info.uid === "number" ? info.uid : undefined;
         const gid = typeof info.gid === "number" ? info.gid : undefined;
         let reason = null;
-        if (uid === 0)
-            reason = "root-owned";
+        if (uid === 0) {
+            if (currentUid !== 0)
+                reason = "root-owned";
+        }
         else if (shouldReportOwnerMismatch(uid, currentUid))
             reason = "owner-mismatch";
         else {
@@ -921,10 +940,36 @@ async function checkModelContextRecommendation(configPath) {
         return null;
     }
 }
-async function checkExploreRouting(configPath) {
-    const envValue = process.env[OMX_EXPLORE_CMD_ENV];
+async function resolveExploreRoutingState(configPath, env = process.env) {
+    const envValue = env[OMX_EXPLORE_CMD_ENV];
     if (typeof envValue === "string") {
-        if (isExploreCommandRoutingEnabled(process.env)) {
+        return { source: "env", enabled: isExploreCommandRoutingEnabled(env) };
+    }
+    if (!existsSync(configPath)) {
+        return { source: "default", enabled: false, reason: "missing-config" };
+    }
+    try {
+        const content = await readFile(configPath, "utf-8");
+        const parsed = parseToml(content);
+        const configuredValue = parsed?.shell_environment_policy?.set?.USE_OMX_EXPLORE_CMD ??
+            parsed?.env?.USE_OMX_EXPLORE_CMD;
+        if (typeof configuredValue === "string") {
+            return {
+                source: "config",
+                enabled: isExploreCommandRoutingEnabled({
+                    USE_OMX_EXPLORE_CMD: configuredValue,
+                }),
+            };
+        }
+        return { source: "default", enabled: false, reason: "unset" };
+    }
+    catch {
+        return { source: "unreadable", enabled: false };
+    }
+}
+function checkExploreRoutingFromState(state) {
+    if (state.source === "env") {
+        if (state.enabled) {
             return {
                 name: "Explore routing",
                 status: "warn",
@@ -937,47 +982,34 @@ async function checkExploreRouting(configPath) {
             message: "deprecated compatibility routing disabled by environment override (recommended)",
         };
     }
-    if (!existsSync(configPath)) {
-        return {
-            name: "Explore routing",
-            status: "pass",
-            message: "deprecated by default (config.toml not found yet)",
-        };
-    }
-    try {
-        const content = await readFile(configPath, "utf-8");
-        const parsed = parseToml(content);
-        const configuredValue = parsed?.shell_environment_policy?.set?.USE_OMX_EXPLORE_CMD ??
-            parsed?.env?.USE_OMX_EXPLORE_CMD;
-        if (typeof configuredValue === "string") {
-            if (isExploreCommandRoutingEnabled({
-                USE_OMX_EXPLORE_CMD: configuredValue,
-            })) {
-                return {
-                    name: "Explore routing",
-                    status: "warn",
-                    message: 'deprecated compatibility routing enabled in config.toml; set USE_OMX_EXPLORE_CMD = "0" under [shell_environment_policy.set] and use normal Codex repo inspection or omx sparkshell instead',
-                };
-            }
+    if (state.source === "config") {
+        if (state.enabled) {
             return {
                 name: "Explore routing",
-                status: "pass",
-                message: "deprecated compatibility routing disabled in config.toml (recommended)",
+                status: "warn",
+                message: 'deprecated compatibility routing enabled in config.toml; set USE_OMX_EXPLORE_CMD = "0" under [shell_environment_policy.set] and use normal Codex repo inspection or omx sparkshell instead',
             };
         }
         return {
             name: "Explore routing",
             status: "pass",
-            message: "deprecated by default",
+            message: "deprecated compatibility routing disabled in config.toml (recommended)",
         };
     }
-    catch {
+    if (state.source === "unreadable") {
         return {
             name: "Explore routing",
             status: "fail",
             message: "cannot read config.toml for explore routing check",
         };
     }
+    return {
+        name: "Explore routing",
+        status: "pass",
+        message: state.reason === "missing-config"
+            ? "deprecated by default (config.toml not found yet)"
+            : "deprecated by default",
+    };
 }
 const LORE_COMMIT_GUARD_EXPLICIT_OPT_OUT_VALUES = new Set([
     "0",
@@ -1060,6 +1092,117 @@ async function checkLoreCommitGuard(configPath) {
 function isExplicitLoreCommitGuardOptOut(value) {
     return LORE_COMMIT_GUARD_EXPLICIT_OPT_OUT_VALUES.has(value.trim().toLowerCase());
 }
+function decodeBasicXmlEntities(value) {
+    return value
+        .replaceAll("&", "&")
+        .replaceAll("&lt;", "<")
+        .replaceAll("&gt;", ">")
+        .replaceAll("&quot;", '"')
+        .replaceAll("&apos;", "'");
+}
+function extractPlistStrings(content) {
+    return [...content.matchAll(/<string>([^<]+)<\/string>/g)].map((match) => decodeBasicXmlEntities(match[1]?.trim() ?? ""));
+}
+function extractPlistLabel(content, fallback) {
+    const labelMatch = content.match(/<key>Label<\/key>\s*<string>([^<]+)<\/string>/);
+    return decodeBasicXmlEntities(labelMatch?.[1]?.trim() || fallback);
+}
+async function readExistingTextFile(path) {
+    try {
+        return await readFile(path, "utf-8");
+    }
+    catch {
+        return "";
+    }
+}
+function expandLaunchAgentPath(value, homeDir) {
+    if (value === "~")
+        return homeDir;
+    if (value.startsWith("~/"))
+        return join(homeDir, value.slice(2));
+    if (value === "$HOME")
+        return homeDir;
+    if (value.startsWith("$HOME/"))
+        return join(homeDir, value.slice(6));
+    if (value === "${HOME}")
+        return homeDir;
+    if (value.startsWith("${HOME}/"))
+        return join(homeDir, value.slice(8));
+    return value;
+}
+function classifyExternalCodexProcessGuard(plistContent, combinedContent) {
+    const lowerPlist = plistContent.toLowerCase();
+    const lower = combinedContent.toLowerCase();
+    if (lower.includes("codex-mcp-child-guard") ||
+        lower.includes("codex_mcp_child_guard") ||
+        combinedContent.includes("CODEX_MCP_GUARD_DEDUPE_APP_CHILDREN") ||
+        (lower.includes("codex app-server") &&
+            lower.includes("pgrep -p") &&
+            lower.includes("kill"))) {
+        return "Codex app-server MCP child dedupe";
+    }
+    if ((lowerPlist.includes("codex-xcode-mcp-guard") ||
+        lowerPlist.includes("codex_xcode_mcp_guard")) &&
+        lower.includes("xcodebuildmcp") &&
+        lower.includes("kill")) {
+        return "XcodeBuildMCP cleanup";
+    }
+    return null;
+}
+export async function checkExternalCodexProcessGuards(options = {}) {
+    const platform = options.platform ?? process.platform;
+    if (platform !== "darwin")
+        return null;
+    const homeDir = options.homeDir ?? process.env.HOME;
+    if (!homeDir)
+        return null;
+    const launchAgentsDir = join(homeDir, "Library", "LaunchAgents");
+    if (!existsSync(launchAgentsDir))
+        return null;
+    let entries;
+    try {
+        entries = await readdir(launchAgentsDir);
+    }
+    catch {
+        return null;
+    }
+    const findings = [];
+    for (const entry of entries) {
+        if (!entry.endsWith(".plist"))
+            continue;
+        const plistPath = join(launchAgentsDir, entry);
+        const plistContent = await readExistingTextFile(plistPath);
+        if (plistContent.trim() === "")
+            continue;
+        const loweredPlist = plistContent.toLowerCase();
+        if (!loweredPlist.includes("codex") &&
+            !loweredPlist.includes("mcp") &&
+            !loweredPlist.includes("omx")) {
+            continue;
+        }
+        let combinedContent = plistContent;
+        for (const value of extractPlistStrings(plistContent)) {
+            const expandedValue = expandLaunchAgentPath(value, homeDir);
+            if (!expandedValue.startsWith("/"))
+                continue;
+            if (!existsSync(expandedValue))
+                continue;
+            combinedContent += `\n${await readExistingTextFile(expandedValue)}`;
+        }
+        const reason = classifyExternalCodexProcessGuard(plistContent, combinedContent);
+        if (!reason)
+            continue;
+        const label = extractPlistLabel(plistContent, entry);
+        findings.push(`${label} (${reason})`);
+    }
+    if (findings.length === 0)
+        return null;
+    return {
+        name: "External process guards",
+        status: "warn",
+        message: `external LaunchAgent(s) may terminate Codex/MCP helper processes outside OMX setup ownership: ${findings.join(", ")}; unload/remove them before attributing SIGTERM or transport resets to standard OMX MCP configuration`,
+    };
+}
 function isEnabledTomlValue(value) {
     return value === true || (typeof value === "string" && ["1", "true", "yes", "on"].includes(value.trim().toLowerCase()));
 }
@@ -1405,6 +1548,27 @@ export function classifyPostCompactHookStdout(stdout) {
         };
     }
 }
+export function buildPostCompactSmokeSpawnInvocation(expectedCommand, options = {}) {
+    const platform = options.platform ?? process.platform;
+    if (platform === "win32") {
+        return {
+            command: resolveWindowsPowerShellPath(options.env),
+            args: [
+                "-NoProfile",
+                "-ExecutionPolicy",
+                "Bypass",
+                "-Command",
+                expectedCommand,
+            ],
+            shell: false,
+        };
+    }
+    return {
+        command: expectedCommand,
+        args: [],
+        shell: true,
+    };
+}
 async function checkNativePostCompactHookRuntime(hooksPath, cwd, codexHomeDir) {
     if (!existsSync(hooksPath))
         return null;
@@ -1437,7 +1601,8 @@ async function checkNativePostCompactHookRuntime(hooksPath, cwd, codexHomeDir) {
             cwd: smokeCwd,
             session_id: "omx-doctor-postcompact-smoke",
         });
-        const result = spawnSync(expectedCommand, {
+        const smokeInvocation = buildPostCompactSmokeSpawnInvocation(expectedCommand);
+        const result = spawnSync(smokeInvocation.command, smokeInvocation.args, {
             cwd,
             encoding: "utf-8",
             env: {
@@ -1445,7 +1610,7 @@ async function checkNativePostCompactHookRuntime(hooksPath, cwd, codexHomeDir) {
                 OMX_NATIVE_HOOK_DOCTOR_SMOKE: "1",
             },
             input: payload,
-            shell: true,
+            shell: smokeInvocation.shell,
             timeout: 5_000,
         });
         if (result.error) {