oh-my-codex 0.17.3 → 0.18.1

package/src/scripts/__tests__/notify-dispatcher.test.ts

@@ -1,6 +1,6 @@
 import { describe, it } from "node:test";
 import assert from "node:assert/strict";
-import { existsSync } from "node:fs";
+import { chmodSync, existsSync } from "node:fs";
 import { mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
@@ -91,6 +91,228 @@ describe("notify dispatcher previousNotify guard", () => {
 		}
 	});
 
+	it("skips stale turn-ended wrappers whose previousNotify is an OMX dispatcher", () => {
+		const wd = mkdtempSync(join(tmpdir(), "omx-notify-dispatcher-wrapper-"));
+		try {
+			const oldPkgScripts = join(wd, "global", "oh-my-codex", "dist", "scripts");
+			mkdirSync(oldPkgScripts, { recursive: true });
+			const stalePreviousMarker = join(wd, "stale-wrapper-ran");
+			const omxMarker = join(wd, "omx-ran");
+			const staleDispatcher = join(oldPkgScripts, "notify-dispatcher.js");
+			const turnEndedWrapper = join(wd, "SkyComputerUseClient");
+			const omxHook = join(wd, "current-notify-hook.js");
+			writeFileSync(
+				turnEndedWrapper,
+				`import { writeFileSync } from "node:fs"; writeFileSync(${JSON.stringify(stalePreviousMarker)}, "ran");\n`,
+			);
+			writeFileSync(omxHook, `import { writeFileSync } from "node:fs"; writeFileSync(${JSON.stringify(omxMarker)}, "ran");\n`);
+			const metadataPath = join(wd, "notify-dispatch.json");
+			writeFileSync(
+				metadataPath,
+				JSON.stringify({
+					managedBy: "oh-my-codex",
+					version: 1,
+					previousNotify: [
+						process.execPath,
+						turnEndedWrapper,
+						"turn-ended",
+						"--previous-notify",
+						JSON.stringify([
+							process.execPath,
+							staleDispatcher,
+							"--metadata",
+							metadataPath,
+						]),
+					],
+					omxNotify: [process.execPath, omxHook],
+				}),
+			);
+
+			runDispatcher(metadataPath);
+
+			assert.equal(existsSync(stalePreviousMarker), false);
+			assert.equal(readFileSync(omxMarker, "utf-8"), "ran");
+		} finally {
+			rmSync(wd, { recursive: true, force: true });
+		}
+	});
+
+	it("skips stale turn-ended wrappers whose previousNotify text is an OMX hook", () => {
+		const wd = mkdtempSync(join(tmpdir(), "omx-notify-dispatcher-wrapper-text-"));
+		try {
+			const oldPkgScripts = join(wd, "global", "oh-my-codex", "dist", "scripts");
+			mkdirSync(oldPkgScripts, { recursive: true });
+			const stalePreviousMarker = join(wd, "stale-wrapper-ran");
+			const omxMarker = join(wd, "omx-ran");
+			const staleHook = join(oldPkgScripts, "notify-hook.js");
+			const turnEndedWrapper = join(wd, "SkyComputerUseClient");
+			const omxHook = join(wd, "current-notify-hook.js");
+			writeFileSync(
+				turnEndedWrapper,
+				`import { writeFileSync } from "node:fs"; writeFileSync(${JSON.stringify(stalePreviousMarker)}, "ran");\n`,
+			);
+			writeFileSync(omxHook, `import { writeFileSync } from "node:fs"; writeFileSync(${JSON.stringify(omxMarker)}, "ran");\n`);
+			const metadataPath = join(wd, "notify-dispatch.json");
+			writeFileSync(
+				metadataPath,
+				JSON.stringify({
+					managedBy: "oh-my-codex",
+					version: 1,
+					previousNotify: [
+						process.execPath,
+						turnEndedWrapper,
+						"turn-ended",
+						`--previous-notify=node ${staleHook}`,
+					],
+					omxNotify: [process.execPath, omxHook],
+				}),
+			);
+
+			runDispatcher(metadataPath);
+
+			assert.equal(existsSync(stalePreviousMarker), false);
+			assert.equal(readFileSync(omxMarker, "utf-8"), "ran");
+		} finally {
+			rmSync(wd, { recursive: true, force: true });
+		}
+	});
+
+	it("skips SkyComputerUseClient wrappers with quoted nested previousNotify self-references", () => {
+		const wd = mkdtempSync(join(tmpdir(), "omx-notify-dispatcher-nested-wrapper-"));
+		try {
+			const oldPkgScripts = join(wd, "global", "oh-my-codex", "dist", "scripts");
+			mkdirSync(oldPkgScripts, { recursive: true });
+			const stalePreviousMarker = join(wd, "nested-wrapper-ran");
+			const omxMarker = join(wd, "omx-ran");
+			const staleDispatcher = join(oldPkgScripts, "notify-dispatcher.js");
+			const turnEndedWrapper = join(wd, "SkyComputerUseClient");
+			const omxHook = join(wd, "current-notify-hook.js");
+			writeFileSync(
+				turnEndedWrapper,
+				`import { writeFileSync } from "node:fs"; writeFileSync(${JSON.stringify(stalePreviousMarker)}, "ran");\n`,
+			);
+			writeFileSync(omxHook, `import { writeFileSync } from "node:fs"; writeFileSync(${JSON.stringify(omxMarker)}, "ran");\n`);
+			const metadataPath = join(wd, "notify-dispatch.json");
+			const nestedSelfReference = JSON.stringify([
+				process.execPath,
+				turnEndedWrapper,
+				"turn-ended",
+				"--previous-notify",
+				JSON.stringify([process.execPath, staleDispatcher, "--metadata", metadataPath]),
+			]);
+			writeFileSync(
+				metadataPath,
+				JSON.stringify({
+					managedBy: "oh-my-codex",
+					version: 1,
+					previousNotify: [
+						process.execPath,
+						turnEndedWrapper,
+						"turn-ended",
+						"--previous-notify",
+						JSON.stringify(nestedSelfReference),
+					],
+					omxNotify: [process.execPath, omxHook],
+				}),
+			);
+
+			runDispatcher(metadataPath);
+
+			assert.equal(existsSync(stalePreviousMarker), false);
+			assert.equal(readFileSync(omxMarker, "utf-8"), "ran");
+		} finally {
+			rmSync(wd, { recursive: true, force: true });
+		}
+	});
+
+	it("skips wrapper metadata objects with encoded OMX dispatcher payloads", () => {
+		const wd = mkdtempSync(join(tmpdir(), "omx-notify-dispatcher-object-wrapper-"));
+		try {
+			const oldPkgScripts = join(wd, "global", "oh-my-codex", "dist", "scripts");
+			mkdirSync(oldPkgScripts, { recursive: true });
+			const stalePreviousMarker = join(wd, "object-wrapper-ran");
+			const omxMarker = join(wd, "omx-ran");
+			const staleDispatcher = join(oldPkgScripts, "notify-dispatcher.js");
+			const turnEndedWrapper = join(wd, "SkyComputerUseClient");
+			const omxHook = join(wd, "current-notify-hook.js");
+			writeFileSync(
+				turnEndedWrapper,
+				`import { writeFileSync } from "node:fs"; writeFileSync(${JSON.stringify(stalePreviousMarker)}, "ran");\n`,
+			);
+			writeFileSync(omxHook, `import { writeFileSync } from "node:fs"; writeFileSync(${JSON.stringify(omxMarker)}, "ran");\n`);
+			const metadataPath = join(wd, "notify-dispatch.json");
+			writeFileSync(
+				metadataPath,
+				JSON.stringify({
+					managedBy: "oh-my-codex",
+					version: 1,
+					previousNotify: [
+						process.execPath,
+						turnEndedWrapper,
+						"turn-ended",
+						`--previous-notify=${JSON.stringify({ previousNotify: JSON.stringify([process.execPath, staleDispatcher]) })}`,
+					],
+					omxNotify: [process.execPath, omxHook],
+				}),
+			);
+
+			runDispatcher(metadataPath);
+
+			assert.equal(existsSync(stalePreviousMarker), false);
+			assert.equal(readFileSync(omxMarker, "utf-8"), "ran");
+		} finally {
+			rmSync(wd, { recursive: true, force: true });
+		}
+	});
+
+	it("skips reporter-shaped SkyComputerUseClient previousNotify dispatcher recursion", () => {
+		const wd = mkdtempSync(join(tmpdir(), "omx-notify-dispatcher-reporter-wrapper-"));
+		try {
+			const pkgScripts = join(wd, "pkg-without-managed-name", "dist", "scripts");
+			mkdirSync(pkgScripts, { recursive: true });
+			const stalePreviousMarker = join(wd, "skycomputer-ran");
+			const omxMarker = join(wd, "omx-ran");
+			const dispatcher = join(pkgScripts, "notify-dispatcher.js");
+			const turnEndedWrapper = join(wd, "SkyComputerUseClient");
+			const omxHook = join(wd, "current-notify-hook.js");
+			writeFileSync(dispatcher, `import { writeFileSync } from "node:fs"; writeFileSync(${JSON.stringify(stalePreviousMarker)}, "dispatcher");\n`);
+			writeFileSync(
+				turnEndedWrapper,
+				`#!/usr/bin/env node\nimport { appendFileSync } from "node:fs"; appendFileSync(${JSON.stringify(stalePreviousMarker)}, "wrapper\\n");\n`,
+			);
+			chmodSync(turnEndedWrapper, 0o755);
+			writeFileSync(omxHook, `import { appendFileSync } from "node:fs"; appendFileSync(${JSON.stringify(omxMarker)}, "omx\\n");\n`);
+			const metadataPath = join(wd, "notify-dispatch.json");
+			writeFileSync(
+				metadataPath,
+				JSON.stringify({
+					managedBy: "oh-my-codex",
+					version: 1,
+					previousNotify: [
+						turnEndedWrapper,
+						"turn-ended",
+						"--previous-notify",
+						JSON.stringify([
+							"node",
+							dispatcher,
+							"--metadata",
+							metadataPath,
+						]),
+					],
+					omxNotify: [process.execPath, omxHook],
+					dispatcherNotify: ["node", dispatcher, "--metadata", metadataPath],
+				}),
+			);
+
+			runDispatcher(metadataPath);
+
+			assert.equal(existsSync(stalePreviousMarker), false);
+			assert.equal(readFileSync(omxMarker, "utf-8"), "omx\n");
+		} finally {
+			rmSync(wd, { recursive: true, force: true });
+		}
+	});
+
 	it("preserves and runs real user previousNotify entries", () => {
 		const wd = mkdtempSync(join(tmpdir(), "omx-notify-dispatcher-user-"));
 		try {

package/src/scripts/__tests__/smoke-packed-install.test.ts

@@ -7,20 +7,57 @@ import { test } from 'node:test';
 import {
   ensureRepoDependencies,
   hasUsableNodeModules,
+  buildNativeHookSmokePayload,
+  PACKED_INSTALL_NATIVE_HOOK_SMOKE_EVENTS,
   PACKED_INSTALL_SMOKE_CORE_COMMANDS,
   parseNpmPackJsonOutput,
   resolveGitCommonDir,
   resolveReusableNodeModulesSource,
+  validateHookStdout,
 } from '../smoke-packed-install.js';
 
 test('packed install smoke stays limited to boot + core commands', () => {
   assert.deepEqual(PACKED_INSTALL_SMOKE_CORE_COMMANDS, [
     ['--help'],
     ['version'],
+    ['api', '--help'],
+    ['sparkshell', '--help'],
   ]);
   assert.equal(
-    PACKED_INSTALL_SMOKE_CORE_COMMANDS.some((argv) => argv.includes('explore') || argv.includes('sparkshell')),
-    false,
+    PACKED_INSTALL_SMOKE_CORE_COMMANDS.some((argv) => argv.includes('api')),
+    true,
+  );
+  assert.equal(
+    PACKED_INSTALL_SMOKE_CORE_COMMANDS.some((argv) => argv.includes('sparkshell')),
+    true,
+  );
+});
+
+test('packed install smoke covers every installed native hook event with minimal payloads', () => {
+  assert.deepEqual(PACKED_INSTALL_NATIVE_HOOK_SMOKE_EVENTS, [
+    'SessionStart',
+    'PreToolUse',
+    'PostToolUse',
+    'UserPromptSubmit',
+    'PreCompact',
+    'PostCompact',
+    'Stop',
+  ]);
+
+  for (const eventName of PACKED_INSTALL_NATIVE_HOOK_SMOKE_EVENTS) {
+    const payload = buildNativeHookSmokePayload(eventName, '/tmp/omx-packed-hook-smoke');
+    assert.equal(payload.hook_event_name, eventName);
+    assert.equal(typeof payload.session_id, 'string');
+    assert.equal(payload.cwd, '/tmp/omx-packed-hook-smoke');
+  }
+});
+
+test('packed install native hook stdout validation allows empty or JSON output only', () => {
+  assert.doesNotThrow(() => validateHookStdout('PostCompact', ''));
+  assert.doesNotThrow(() => validateHookStdout('Stop', '{}\n'));
+  assert.throws(
+    () => validateHookStdout('UserPromptSubmit', '{not json'),
+    /native hook UserPromptSubmit emitted invalid JSON stdout/,
   );
 });
 

package/src/scripts/__tests__/verify-native-agents.test.ts

@@ -53,7 +53,7 @@ describe("verify-native-agents", () => {
       ]),
       definitions: { executor: definition, "style-reviewer": { ...definition, name: "style-reviewer" } },
       promptNames: new Set(["executor", "style-reviewer", "explore-harness"]),
-      pluginManifest: { skills: "./skills/" },
+      pluginManifest: { skills: "./skills/", hooks: "./hooks/hooks.json" },
     });
 
     assert.deepEqual(result.installableAgentNames, ["executor"]);
@@ -183,6 +183,26 @@ describe("verify-native-agents", () => {
         pluginManifest: { agents: "./agents/" },
       }),
     );
+
+    await rejectsWithCode("native_agent_plugin_boundary_violation", () =>
+      verifyNativeAgents({
+        manifest: manifest([{ name: "executor", category: "build", status: "active" }]),
+        definitions: { executor: definition },
+        promptNames: new Set(["executor"]),
+        pluginManifest: { prompts: "./prompts/" },
+      }),
+    );
+  });
+
+  it("allows plugin-scoped lifecycle hooks without treating them as native agents", async () => {
+    const result = await verifyNativeAgents({
+      manifest: manifest([{ name: "executor", category: "build", status: "active" }]),
+      definitions: { executor: definition },
+      promptNames: new Set(["executor"]),
+      pluginManifest: { hooks: "./hooks/hooks.json" },
+    });
+
+    assert.deepEqual(result.installableAgentNames, ["executor"]);
   });
 
   it("keeps merged prompt-backed agents out of the installable set", () => {

package/src/scripts/build-api.ts

@@ -0,0 +1,48 @@
+import { chmodSync, copyFileSync, existsSync, mkdirSync } from 'node:fs';
+import { arch, platform } from 'node:os';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { spawnSync } from 'node:child_process';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const projectRoot = join(__dirname, '..', '..');
+const nativeRoot = join(projectRoot, 'crates', 'omx-api');
+const manifestPath = process.env.OMX_API_MANIFEST ?? join(nativeRoot, 'Cargo.toml');
+const binaryName = platform() === 'win32' ? 'omx-api.exe' : 'omx-api';
+const releaseBinaryPath = join(projectRoot, 'target', 'release', binaryName);
+const stagedBinaryRoot = process.env.OMX_API_STAGE_DIR
+  ? join(process.env.OMX_API_STAGE_DIR, `${platform()}-${arch()}`)
+  : join(projectRoot, 'bin', 'native', `${platform()}-${arch()}`);
+const packagedBinaryDir = stagedBinaryRoot;
+const packagedBinaryPath = join(packagedBinaryDir, binaryName);
+const extraArgs = process.argv.slice(2);
+const args = ['build', '--manifest-path', manifestPath, '--release', ...extraArgs];
+
+if (!existsSync(manifestPath)) {
+  console.error(`omx api build: missing Rust manifest at ${manifestPath}`);
+  process.exit(1);
+}
+
+const result = spawnSync('cargo', args, {
+  cwd: projectRoot,
+  stdio: 'inherit',
+  env: process.env,
+});
+
+if (result.error) {
+  console.error(`omx api build: failed to launch cargo: ${result.error.message}`);
+  process.exit(1);
+}
+
+if ((result.status ?? 1) !== 0) process.exit(result.status ?? 1);
+
+if (!existsSync(releaseBinaryPath)) {
+  console.error(`omx api build: expected release binary at ${releaseBinaryPath}`);
+  process.exit(1);
+}
+
+mkdirSync(packagedBinaryDir, { recursive: true });
+copyFileSync(releaseBinaryPath, packagedBinaryPath);
+if (platform() !== 'win32') chmodSync(packagedBinaryPath, 0o755);
+console.log(`omx api build: staged native binary at ${packagedBinaryPath}`);

package/src/scripts/cleanup-explore-harness.ts

@@ -12,6 +12,7 @@ for (const path of [
   join(root, 'bin', 'omx-explore-harness.exe'),
   join(root, 'bin', 'omx-explore-harness.meta.json'),
   join(root, 'bin', 'native'),
+  join(root, 'crates', 'omx-sparkshell', '.omx'),
 ]) {
   await rm(path, { recursive: true, force: true });
 }