oh-my-codex 0.18.12 → 0.18.13

package/dist/cli/index.js

@@ -41,6 +41,7 @@ import { MADMAX_FLAG, CODEX_BYPASS_FLAG, HIGH_REASONING_FLAG, XHIGH_REASONING_FL
 import { getBaseStateDir, getStateDir, listModeStateFilesWithScopePreference, } from "../mcp/state-paths.js";
 import { evaluateRalphCompletionAuditEvidence, isRalphCompletePhase } from "../ralph/completion-audit.js";
 import { readPersistedSetupPreferences, resolveCodexConfigPathForLaunch, resolveCodexHomeForLaunch, resolveProjectLocalCodexHomeForLaunch, } from "./codex-home.js";
+import { discoverProjectRuntimeCodexHomes } from "./project-runtime-codex-homes.js";
 import { escapeTomlString, readTopLevelTomlString, upsertTopLevelTomlString } from "../utils/toml.js";
 export { readPersistedSetupPreferences, readPersistedSetupScope, resolveCodexConfigPathForLaunch, resolveCodexHomeForLaunch, resolveProjectLocalCodexHomeForLaunch, } from "./codex-home.js";
 import { SKILL_ACTIVE_STATE_MODE, extractSessionIdFromInitializedStatePath, getSkillActiveStatePathsForStateDir, listActiveSkills, readSkillActiveState, syncCanonicalSkillStateForMode, } from "../state/skill-active.js";
@@ -107,10 +108,10 @@ Usage:
   omx auth      Manage Codex OAuth auth slots (add|list|use)
   omx question  OMX-owned blocking question UI entrypoint for agent-invoked user questions
   omx adapt     Scaffold OMX-owned adapter foundations for persistent external targets
-  omx resume    Resume a previous interactive Codex session
+  omx resume    Resume Codex sessions (supports --project and --codex-home <path>)
   omx explore   DEPRECATED compatibility command; use normal repo inspection or omx sparkshell
   omx api       Run native omx-api localhost gateway commands (serve|status|stop|generate)
-  omx session   Search prior local session transcripts and history artifacts
+  omx session   Search prior local session transcripts (--codex-home <path> escape hatch)
   omx agents-init [path]
                 Bootstrap lightweight AGENTS.md files for a repo/subtree
   omx agents    Manage Codex native agent TOML files
@@ -563,14 +564,124 @@ const PROJECT_LAUNCH_PERSISTED_RUNTIME_ENTRY_NAMES = new Set([
     // log the contents.
     "auth.json",
 ]);
+const PROJECT_LAUNCH_DURABLE_HISTORY_ENTRY_NAMES = new Set([
+    "sessions",
+    "history.jsonl",
+    "session_index.jsonl",
+]);
 // Mirroring these files into the runtime CODEX_HOME would cause Codex to load
 // them as user-scope config alongside the canonical project-scope copies under
 // <cwd>/.codex, duplicating every native hook and asking the user to re-trust
 // hooks on every launch. See GH issue #2470.
 const PROJECT_LAUNCH_RUNTIME_SKIPPED_ENTRY_NAMES = new Set(["hooks.json"]);
+function shouldMirrorProjectLaunchRuntimeEntry(entryName, includeHistoryArtifacts) {
+    if (PROJECT_LAUNCH_DURABLE_HISTORY_ENTRY_NAMES.has(entryName))
+        return true;
+    if (isCodexSqliteArtifact(entryName))
+        return includeHistoryArtifacts;
+    return true;
+}
 function shouldPersistProjectLaunchRuntimeEntry(entryName) {
     return PROJECT_LAUNCH_PERSISTED_RUNTIME_ENTRY_NAMES.has(entryName);
 }
+function uniqueJsonlLines(contents) {
+    const seen = new Set();
+    const lines = [];
+    for (const line of contents.split(/\r?\n/)) {
+        if (line === "" || seen.has(line))
+            continue;
+        seen.add(line);
+        lines.push(line);
+    }
+    return lines;
+}
+async function persistProjectLaunchRuntimeJsonlArtifact(source, destination) {
+    const existing = existsSync(destination) ? await readFile(destination, "utf-8").catch(() => "") : "";
+    const sourceContents = await readFile(source, "utf-8");
+    const separator = existing === "" || existing.endsWith("\n") || sourceContents === "" ? "" : "\n";
+    const lines = uniqueJsonlLines(`${existing}${separator}${sourceContents}`);
+    await writeFile(destination, lines.length > 0 ? `${lines.join("\n")}\n` : "", "utf-8");
+}
+async function persistProjectLaunchRuntimeHistoryArtifacts(runtimeCodexHome, projectCodexHome) {
+    if (!runtimeCodexHome || !projectCodexHome)
+        return;
+    if (!existsSync(runtimeCodexHome))
+        return;
+    await mkdir(projectCodexHome, { recursive: true });
+    for (const entryName of PROJECT_LAUNCH_DURABLE_HISTORY_ENTRY_NAMES) {
+        const source = join(runtimeCodexHome, entryName);
+        if (!existsSync(source))
+            continue;
+        const sourceStat = await lstat(source);
+        if (sourceStat.isSymbolicLink())
+            continue;
+        const destination = join(projectCodexHome, entryName);
+        if (sourceStat.isDirectory()) {
+            await cp(source, destination, { recursive: true, force: true, verbatimSymlinks: true });
+            continue;
+        }
+        if (entryName === "history.jsonl" || entryName === "session_index.jsonl") {
+            await persistProjectLaunchRuntimeJsonlArtifact(source, destination);
+            continue;
+        }
+        if (sourceStat.isFile()) {
+            await copyFile(source, destination);
+        }
+    }
+}
+async function ensureProjectLaunchRuntimeHistoryLinks(runtimeCodexHome, projectCodexHome) {
+    await mkdir(projectCodexHome, { recursive: true });
+    for (const entryName of PROJECT_LAUNCH_DURABLE_HISTORY_ENTRY_NAMES) {
+        const runtimeEntry = join(runtimeCodexHome, entryName);
+        if (existsSync(runtimeEntry))
+            continue;
+        const projectEntry = join(projectCodexHome, entryName);
+        if (entryName === "sessions") {
+            await mkdir(projectEntry, { recursive: true });
+        }
+        else if (!existsSync(projectEntry)) {
+            await writeFile(projectEntry, "");
+        }
+        await linkOrCopyCodexHomeEntry(projectEntry, runtimeEntry);
+    }
+}
+async function materializeProjectLaunchRuntimeHistoryEntries(runtimeCodexHome, sourceCodexHome) {
+    for (const entryName of PROJECT_LAUNCH_DURABLE_HISTORY_ENTRY_NAMES) {
+        const source = join(sourceCodexHome, entryName);
+        if (!existsSync(source))
+            continue;
+        const destination = join(runtimeCodexHome, entryName);
+        await rm(destination, { recursive: true, force: true });
+        const sourceStat = await lstat(source);
+        if (sourceStat.isDirectory()) {
+            await cp(source, destination, { recursive: true, force: true, dereference: true });
+            continue;
+        }
+        await copyFile(source, destination);
+    }
+}
+async function mergeProjectLaunchRuntimeHistoryEntries(runtimeCodexHome, sourceCodexHome) {
+    for (const entryName of PROJECT_LAUNCH_DURABLE_HISTORY_ENTRY_NAMES) {
+        const source = join(sourceCodexHome, entryName);
+        if (!existsSync(source))
+            continue;
+        const destination = join(runtimeCodexHome, entryName);
+        const sourceStat = await lstat(source);
+        if (sourceStat.isDirectory()) {
+            await mkdir(destination, { recursive: true });
+            await cp(source, destination, { recursive: true, force: true, dereference: true });
+            continue;
+        }
+        if (existsSync(destination)) {
+            const existing = await readFile(destination, "utf-8").catch(() => "");
+            const addition = await readFile(source, "utf-8");
+            const separator = existing === "" || existing.endsWith("\n") || addition === "" ? "" : "\n";
+            await writeFile(destination, `${existing}${separator}${addition}`, "utf-8");
+            continue;
+        }
+        await copyFile(source, destination);
+    }
+}
 export async function persistProjectLaunchRuntimeAuthState(runtimeCodexHome, projectCodexHome) {
     if (!runtimeCodexHome || !projectCodexHome)
         return;
@@ -587,10 +698,12 @@ export async function prepareRuntimeCodexHomeForProjectLaunch(cwd, sessionId, pr
     const runtimeCodexHome = runtimeCodexHomePath(cwd, sessionId);
     await rm(runtimeCodexHome, { recursive: true, force: true });
     await mkdir(runtimeCodexHome, { recursive: true });
-    if (!existsSync(projectCodexHome))
+    if (!existsSync(projectCodexHome)) {
+        await ensureProjectLaunchRuntimeHistoryLinks(runtimeCodexHome, projectCodexHome);
         return runtimeCodexHome;
+    }
     for (const entry of await readdir(projectCodexHome, { withFileTypes: true })) {
-        if (isCodexSqliteArtifact(entry.name) && !options.includeHistoryArtifacts)
+        if (!shouldMirrorProjectLaunchRuntimeEntry(entry.name, options.includeHistoryArtifacts === true))
             continue;
         if (PROJECT_LAUNCH_RUNTIME_SKIPPED_ENTRY_NAMES.has(entry.name))
             continue;
@@ -608,6 +721,13 @@ export async function prepareRuntimeCodexHomeForProjectLaunch(cwd, sessionId, pr
         }
         await linkOrCopyCodexHomeEntry(source, destination);
     }
+    await ensureProjectLaunchRuntimeHistoryLinks(runtimeCodexHome, projectCodexHome);
+    if (options.includeHistoryArtifacts === true && (options.extraHistoryCodexHomes?.length ?? 0) > 0) {
+        await materializeProjectLaunchRuntimeHistoryEntries(runtimeCodexHome, projectCodexHome);
+        for (const extraCodexHome of options.extraHistoryCodexHomes ?? []) {
+            await mergeProjectLaunchRuntimeHistoryEntries(runtimeCodexHome, extraCodexHome);
+        }
+    }
     return runtimeCodexHome;
 }
 function resolveProjectSqliteHomeForLaunch(projectCodexHome, env) {
@@ -619,7 +739,7 @@ function resolveProjectSqliteHomeForLaunch(projectCodexHome, env) {
 export async function prepareCodexHomeForLaunch(cwd, sessionId, env = process.env, options = {}) {
     const projectLocalCodexHomeForCleanup = resolveProjectLocalCodexHomeForLaunch(cwd, env);
     if (projectLocalCodexHomeForCleanup) {
-        const runtimeCodexHome = await prepareRuntimeCodexHomeForProjectLaunch(cwd, sessionId, projectLocalCodexHomeForCleanup, { includeHistoryArtifacts: options.includeHistoryArtifacts });
+        const runtimeCodexHome = await prepareRuntimeCodexHomeForProjectLaunch(cwd, sessionId, projectLocalCodexHomeForCleanup, { includeHistoryArtifacts: options.includeHistoryArtifacts, extraHistoryCodexHomes: options.extraHistoryCodexHomes });
         return {
             codexHomeOverride: runtimeCodexHome,
             sqliteHomeOverride: resolveProjectSqliteHomeForLaunch(projectLocalCodexHomeForCleanup, env),
@@ -632,6 +752,81 @@ export async function prepareCodexHomeForLaunch(cwd, sessionId, env = process.en
         projectLocalCodexHomeForCleanup,
     };
 }
+export function parseResumeCodexHomeSelection(args) {
+    const nextArgs = [];
+    let explicitCodexHome;
+    let projectOnly = false;
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index];
+        if (arg === "--codex-home") {
+            const value = args[index + 1];
+            if (!value || value.startsWith("-")) {
+                throw new Error("Missing value after --codex-home.");
+            }
+            explicitCodexHome = value;
+            index += 1;
+            continue;
+        }
+        if (arg.startsWith("--codex-home=")) {
+            explicitCodexHome = arg.slice("--codex-home=".length);
+            if (explicitCodexHome.trim() === "") {
+                throw new Error("Missing value after --codex-home.");
+            }
+            continue;
+        }
+        if (arg === "--project") {
+            projectOnly = true;
+            continue;
+        }
+        nextArgs.push(arg);
+    }
+    return {
+        args: nextArgs,
+        explicitCodexHome,
+        projectOnly,
+    };
+}
+async function prepareResumeCodexHomeForLaunch(cwd, sessionId, args, env = process.env) {
+    const selection = parseResumeCodexHomeSelection(args);
+    if (selection.explicitCodexHome) {
+        return {
+            args: selection.args,
+            prepared: {
+                codexHomeOverride: resolve(selection.explicitCodexHome),
+            },
+        };
+    }
+    const projectHomes = await discoverProjectRuntimeCodexHomes(cwd);
+    if (selection.projectOnly) {
+        if (projectHomes.length === 0) {
+            const emptyRuntimeCodexHome = runtimeCodexHomePath(cwd, sessionId);
+            await rm(emptyRuntimeCodexHome, { recursive: true, force: true });
+            await mkdir(join(emptyRuntimeCodexHome, "sessions"), { recursive: true });
+            return {
+                args: selection.args,
+                prepared: {
+                    codexHomeOverride: emptyRuntimeCodexHome,
+                    runtimeCodexHomeForCleanup: emptyRuntimeCodexHome,
+                },
+            };
+        }
+        const runtimeCodexHome = await prepareRuntimeCodexHomeForProjectLaunch(cwd, sessionId, projectHomes[0].path, {
+            includeHistoryArtifacts: true,
+            extraHistoryCodexHomes: projectHomes.slice(1).map((home) => home.path),
+        });
+        return {
+            args: selection.args,
+            prepared: {
+                codexHomeOverride: runtimeCodexHome,
+            },
+        };
+    }
+    const prepared = await prepareCodexHomeForLaunch(cwd, sessionId, env, {
+        includeHistoryArtifacts: true,
+        extraHistoryCodexHomes: projectHomes.map((home) => home.path),
+    });
+    return { args: selection.args, prepared };
+}
 export async function persistProjectLaunchRuntimeProjectTrustState(runtimeCodexHome, projectCodexHome) {
     if (!runtimeCodexHome || !projectCodexHome)
         return;
@@ -654,6 +849,7 @@ export async function cleanupRuntimeCodexHome(runtimeCodexHomeForCleanup, projec
     if (!runtimeCodexHomeForCleanup)
         return;
     await persistProjectLaunchRuntimeAuthState(runtimeCodexHomeForCleanup, projectCodexHomeForPersistence);
+    await persistProjectLaunchRuntimeHistoryArtifacts(runtimeCodexHomeForCleanup, projectCodexHomeForPersistence);
     await persistProjectLaunchRuntimeProjectTrustState(runtimeCodexHomeForCleanup, projectCodexHomeForPersistence);
     await rm(runtimeCodexHomeForCleanup, { recursive: true, force: true });
 }
@@ -1891,7 +2087,7 @@ export async function launchWithHud(args) {
     const { launchPolicy, effectiveExplicitLaunchPolicy } = resolveTmuxAwareLaunchPolicy(explicitLaunchPolicy, isNativeWindows());
     const enableNotifyFallbackAuthority = launchPolicy === "direct";
     const workerSparkModel = resolveWorkerSparkModel(notifyTempResult.passthroughArgs, persistentCodexHomeForLaunch);
-    const normalizedArgs = normalizeCodexLaunchArgs(notifyTempResult.passthroughArgs);
+    let normalizedArgs = normalizeCodexLaunchArgs(notifyTempResult.passthroughArgs);
     let cwd = launchCwd;
     let worktreeDirty = false;
     let ensuredLaunchWorktree;
@@ -1949,7 +2145,13 @@ export async function launchWithHud(args) {
     catch {
         // Non-fatal: repair failure must not block launch
     }
-    const preparedCodexHome = await prepareCodexHomeForLaunch(launchCwd, sessionId, process.env, {
+    const resumePrepared = normalizedArgs[0] === "resume"
+        ? await prepareResumeCodexHomeForLaunch(launchCwd, sessionId, normalizedArgs, process.env)
+        : null;
+    if (resumePrepared) {
+        normalizedArgs = resumePrepared.args;
+    }
+    const preparedCodexHome = resumePrepared?.prepared ?? await prepareCodexHomeForLaunch(launchCwd, sessionId, process.env, {
         includeHistoryArtifacts: normalizedArgs[0] === "resume",
     });
     const codexHomeOverride = preparedCodexHome.codexHomeOverride;