oh-my-codex 0.16.1 → 0.16.3

package/dist/cli/__tests__/index.test.js

@@ -1,7 +1,7 @@
 import { afterEach, describe, it, mock } from "node:test";
 import assert from "node:assert/strict";
 import { existsSync, mkdirSync, utimesSync } from "node:fs";
-import { chmod, mkdir, mkdtemp, readFile, rm, stat, writeFile } from "node:fs/promises";
+import { chmod, lstat, mkdir, mkdtemp, readFile, rm, stat, writeFile } from "node:fs/promises";
 import { dirname, join } from "node:path";
 import { tmpdir } from "node:os";
 import { fileURLToPath } from "node:url";
@@ -450,6 +450,32 @@ describe("cleanupPostLaunchModeStateFiles", () => {
         }
         assert.deepEqual(warnings, []);
     });
+    it("marks active Ralph state cancelled with interrupted metadata during postLaunch cleanup", async () => {
+        const wd = await mkdtemp(join(tmpdir(), "omx-postlaunch-ralph-interrupted-"));
+        const sessionId = "sess-postlaunch-ralph-interrupted";
+        const sessionStateDir = join(wd, ".omx", "state", "sessions", sessionId);
+        await mkdir(sessionStateDir, { recursive: true });
+        await writeFile(join(sessionStateDir, "ralph-state.json"), JSON.stringify({
+            active: true,
+            mode: "ralph",
+            current_phase: "executing",
+            owner_omx_session_id: sessionId,
+        }, null, 2), "utf-8");
+        try {
+            await cleanupPostLaunchModeStateFiles(wd, sessionId, {
+                now: () => new Date("2026-05-09T08:00:00.000Z"),
+            });
+            const ralph = JSON.parse(await readFile(join(sessionStateDir, "ralph-state.json"), "utf-8"));
+            assert.equal(ralph.active, false);
+            assert.equal(ralph.current_phase, "cancelled");
+            assert.equal(ralph.completed_at, "2026-05-09T08:00:00.000Z");
+            assert.equal(ralph.interrupted_at, "2026-05-09T08:00:00.000Z");
+            assert.equal(ralph.stop_reason, "session_exit");
+        }
+        finally {
+            await rm(wd, { recursive: true, force: true });
+        }
+    });
     it("does not cancel root mode state during session-scoped postLaunch cleanup", async () => {
         const wd = await mkdtemp(join(tmpdir(), "omx-postlaunch-root-preserve-"));
         const sessionId = "sess-postlaunch-root-preserve";
@@ -1089,6 +1115,7 @@ describe("project launch scope helpers", () => {
             ].join("\n");
             await writeFile(configPath, originalConfig);
             await writeFile(join(projectCodexHome, "agents", "planner.toml"), 'name = "planner"\n');
+            await writeFile(join(projectCodexHome, "hooks.json"), '{"hooks":{}}\n');
             await writeFile(join(projectCodexHome, "state_5.sqlite"), "state db placeholder");
             await writeFile(join(projectCodexHome, "state_5.sqlite-wal"), "state db wal placeholder");
             await writeFile(join(projectCodexHome, "logs_2.sqlite-shm"), "logs db shm placeholder");
@@ -1101,6 +1128,8 @@ describe("project launch scope helpers", () => {
             assert.equal(prepared.runtimeCodexHomeForCleanup, runtimeCodexHome);
             assert.equal(await readFile(join(runtimeCodexHome, "config.toml"), "utf-8"), originalConfig);
             assert.equal(await readFile(join(runtimeCodexHome, "agents", "planner.toml"), "utf-8"), 'name = "planner"\n');
+            assert.equal(await readFile(join(runtimeCodexHome, "hooks.json"), "utf-8"), '{"hooks":{}}\n');
+            assert.equal((await lstat(join(runtimeCodexHome, "hooks.json"))).isSymbolicLink(), false);
             assert.equal(existsSync(join(runtimeCodexHome, "state_5.sqlite")), false);
             assert.equal(existsSync(join(runtimeCodexHome, "state_5.sqlite-wal")), false);
             assert.equal(existsSync(join(runtimeCodexHome, "logs_2.sqlite-shm")), false);
@@ -1116,6 +1145,36 @@ describe("project launch scope helpers", () => {
             await rm(wd, { recursive: true, force: true });
         }
     });
+    it("rewrites setup-owned hook trust state for the runtime CODEX_HOME mirror", async () => {
+        const wd = await mkdtemp(join(tmpdir(), "omx-launch-runtime-hook-trust-"));
+        try {
+            const projectCodexHome = join(wd, ".codex");
+            await mkdir(join(wd, ".omx"), { recursive: true });
+            await mkdir(projectCodexHome, { recursive: true });
+            await writeFile(join(wd, ".omx", "setup-scope.json"), JSON.stringify({ scope: "project" }));
+            await writeFile(join(projectCodexHome, "hooks.json"), '{"hooks":{}}\n');
+            await writeFile(join(projectCodexHome, "config.toml"), [
+                "[features]",
+                "codex_hooks = true",
+                "",
+                "# OMX-owned Codex hook trust state",
+                "# Trusts only setup-managed codex-native-hook.js wrappers.",
+                `[hooks.state."${join(projectCodexHome, "hooks.json")}:pre_tool_use:0:0"]`,
+                'trusted_hash = "stale"',
+                "# End OMX-owned Codex hook trust state",
+                "",
+            ].join("\n"));
+            await prepareCodexHomeForLaunch(wd, "session-trust", {});
+            const runtimeCodexHome = runtimeCodexHomePath(wd, "session-trust");
+            const runtimeConfig = await readFile(join(runtimeCodexHome, "config.toml"), "utf-8");
+            assert.match(runtimeConfig, new RegExp(`\\[hooks\\.state\\."${join(runtimeCodexHome, "hooks.json").replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}:pre_tool_use:0:0"\\]`));
+            assert.doesNotMatch(runtimeConfig, /trusted_hash = "stale"/);
+            assert.doesNotMatch(runtimeConfig, new RegExp(join(projectCodexHome, "hooks.json").replace(/[.*+?^${}()|[\]\\]/g, "\\$&")));
+        }
+        finally {
+            await rm(wd, { recursive: true, force: true });
+        }
+    });
     it("uses boxed runtime root for project-scope CODEX_HOME mirrors", async () => {
         const source = await mkdtemp(join(tmpdir(), "omx-launch-boxed-source-"));
         const boxedRoot = await mkdtemp(join(tmpdir(), "omx-launch-boxed-root-"));
@@ -1499,9 +1558,12 @@ describe("detached tmux new-session sequencing", () => {
         assert.match(leaderCmd, /wait "\$omx_codex_pid";/);
         assert.match(leaderCmd, /kill -TERM "\$omx_codex_pid"/);
         assert.match(leaderCmd, /releaseTmuxExtendedKeysLease/);
-        assert.match(leaderCmd, /if \[ "\$status" -lt 128 \]; then/);
+        assert.match(leaderCmd, /if \[ "\$status" -eq 0 \]; then/);
         assert.match(leaderCmd, /tmux kill-session -t/);
         assert.match(leaderCmd, /"omx-demo"/);
+        assert.match(leaderCmd, /codex exited immediately with code 0/);
+        assert.match(leaderCmd, /codex exited with code/);
+        assert.match(leaderCmd, /detached tmux session is being kept open/);
         assert.match(leaderCmd, /exit \$status/);
     });
     it("buildDetachedSessionBootstrapSteps finalizes postLaunch inside the detached leader when a session id is available", () => {
@@ -1514,7 +1576,7 @@ describe("detached tmux new-session sequencing", () => {
         assert.match(leaderCmd, /\/tmp\/project\/\.codex-project/);
         assert.match(leaderCmd, /\/tmp\/project\/\.omx\/runtime\/codex-home\/omx-session-123/);
         const helperIndex = leaderCmd.indexOf("runDetachedSessionPostLaunch");
-        const signalGateIndex = leaderCmd.indexOf('if [ "$status" -lt 128 ]');
+        const signalGateIndex = leaderCmd.indexOf('if [ "$status" -eq 0 ]');
         assert.ok(helperIndex >= 0);
         assert.ok(signalGateIndex >= 0);
         assert.ok(helperIndex < signalGateIndex, "detached postLaunch helper must run before the signal-derived tmux kill-session gate");
@@ -1684,6 +1746,114 @@ exit 0
             await rm(cwd, { recursive: true, force: true });
         }
     });
+    it("detached leader command keeps child startup errors visible instead of killing the session", async () => {
+        const cwd = await mkdtemp(join(tmpdir(), "omx-detached-leader-error-"));
+        const fakeBin = join(cwd, "bin");
+        const logPath = join(cwd, "leader.log");
+        try {
+            await mkdir(fakeBin, { recursive: true });
+            await writeFile(join(fakeBin, "codex"), `#!/bin/sh
+printf 'codex-stderr: unsupported startup flag\\n' >&2
+exit 42
+`);
+            await chmod(join(fakeBin, "codex"), 0o755);
+            await writeFile(join(fakeBin, "tmux"), `#!/bin/sh
+printf 'tmux:%s\\n' "$*" >> "${logPath}"
+case "$1" in
+  display-message)
+    if [ "$3" = '#{socket_path}' ] || [ "$4" = '#{socket_path}' ]; then
+      printf '/tmp/tmux-test.sock\\n'
+    else
+      printf '0\\n'
+    fi
+    ;;
+  show-options)
+    printf 'off\\n'
+    ;;
+  set-option|kill-session)
+    ;;
+esac
+exit 0
+`);
+            await chmod(join(fakeBin, "tmux"), 0o755);
+            const steps = buildDetachedSessionBootstrapSteps("omx-demo", cwd, buildTmuxPaneCommand("codex", ["--bad-startup-flag"], "/bin/sh"), "'node' '/tmp/omx.js' 'hud' '--watch'", null);
+            const leaderCmd = steps[0]?.args.at(-1);
+            assert.equal(typeof leaderCmd, "string");
+            const result = (await import("node:child_process")).spawnSync("/bin/sh", ["-c", leaderCmd], {
+                cwd,
+                env: {
+                    ...process.env,
+                    PATH: `${fakeBin}:/usr/bin:/bin`,
+                    HOME: cwd,
+                },
+                input: "\n",
+                encoding: "utf-8",
+            });
+            assert.equal(result.status, 42);
+            assert.match(result.stderr, /codex-stderr: unsupported startup flag/);
+            assert.match(result.stderr, /codex exited with code 42 during startup/);
+            assert.match(result.stderr, /detached tmux session is being kept open/);
+            const log = await readFile(logPath, "utf-8");
+            assert.doesNotMatch(log, /tmux:kill-session -t omx-demo/);
+        }
+        finally {
+            await rm(cwd, { recursive: true, force: true });
+        }
+    });
+    it("detached leader command keeps immediate zero-code exits visible instead of silently closing", async () => {
+        const cwd = await mkdtemp(join(tmpdir(), "omx-detached-leader-zero-"));
+        const fakeBin = join(cwd, "bin");
+        const logPath = join(cwd, "leader.log");
+        try {
+            await mkdir(fakeBin, { recursive: true });
+            await writeFile(join(fakeBin, "codex"), `#!/bin/sh
+printf 'codex-started-then-quit\\n' >&2
+exit 0
+`);
+            await chmod(join(fakeBin, "codex"), 0o755);
+            await writeFile(join(fakeBin, "tmux"), `#!/bin/sh
+printf 'tmux:%s\\n' "$*" >> "${logPath}"
+case "$1" in
+  display-message)
+    if [ "$3" = '#{socket_path}' ] || [ "$4" = '#{socket_path}' ]; then
+      printf '/tmp/tmux-test.sock\\n'
+    else
+      printf '0\\n'
+    fi
+    ;;
+  show-options)
+    printf 'off\\n'
+    ;;
+  set-option|kill-session)
+    ;;
+esac
+exit 0
+`);
+            await chmod(join(fakeBin, "tmux"), 0o755);
+            const steps = buildDetachedSessionBootstrapSteps("omx-demo", cwd, buildTmuxPaneCommand("codex", [], "/bin/sh"), "'node' '/tmp/omx.js' 'hud' '--watch'", null);
+            const leaderCmd = steps[0]?.args.at(-1);
+            assert.equal(typeof leaderCmd, "string");
+            const result = (await import("node:child_process")).spawnSync("/bin/sh", ["-c", leaderCmd], {
+                cwd,
+                env: {
+                    ...process.env,
+                    PATH: `${fakeBin}:/usr/bin:/bin`,
+                    HOME: cwd,
+                },
+                input: "\n",
+                encoding: "utf-8",
+            });
+            assert.equal(result.status, 0, result.stderr || result.stdout);
+            assert.match(result.stderr, /codex-started-then-quit/);
+            assert.match(result.stderr, /codex exited immediately with code 0 during startup/);
+            assert.match(result.stderr, /detached tmux session is being kept open/);
+            const log = await readFile(logPath, "utf-8");
+            assert.match(log, /tmux:kill-session -t omx-demo/);
+        }
+        finally {
+            await rm(cwd, { recursive: true, force: true });
+        }
+    });
     it("detached leader command terminates codex child on external SIGHUP", async () => {
         const cwd = await mkdtemp(join(tmpdir(), "omx-detached-leader-hup-"));
         const fakeBin = join(cwd, "bin");