@fusengine/harness 0.1.89 → 0.1.91

package/src/util/runtime-io.ts

@@ -0,0 +1,85 @@
+/**
+ * Cross-runtime I/O helpers (Node + Bun). The published CLI ships a `node`
+ * shebang and is invoked via `npx`/`npm`/`bunx`/`bun`; using only `node:*` APIs
+ * here keeps the bundle runnable under EVERY runtime — replacing the Bun-only
+ * `Bun.file/write/spawn/sleep/stdin` calls and the `bun` `Glob` import that made
+ * the package crash with `Cannot find package 'bun'` under plain Node.
+ */
+import { readFileSync, writeFileSync, existsSync, mkdirSync, readdirSync, type Dirent } from "node:fs";
+import { dirname, join } from "node:path";
+import { spawnSync } from "node:child_process";
+
+/** Read a file as UTF-8 text (throws on missing/unreadable — callers catch). */
+export function readText(path: string): string {
+  return readFileSync(path, "utf8");
+}
+
+/** True when `path` exists. */
+export function pathExists(path: string): boolean {
+  return existsSync(path);
+}
+
+/** Write `data` to `path`, creating parent dirs (mirrors `Bun.write`). */
+export function writeText(path: string, data: string): void {
+  mkdirSync(dirname(path), { recursive: true });
+  writeFileSync(path, data, { encoding: "utf8" });
+}
+
+/** Resolve after `ms` milliseconds (`Bun.sleep` replacement). */
+export function sleep(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+/** Run `cmd args` in `cwd` and capture stdout text ("" on failure/non-zero). */
+export function spawnCapture(cmd: string, args: string[], cwd: string): string {
+  try {
+    const r = spawnSync(cmd, args, { cwd, encoding: "utf8" });
+    return r.status === 0 ? (r.stdout ?? "") : "";
+  } catch {
+    return "";
+  }
+}
+
+/**
+ * Read the full process stdin as UTF-8 text (works under Node and Bun).
+ * Synchronous fd-0 read — never `for await (const c of process.stdin)` —
+ * because Bun has a confirmed Linux-only bug where merely adding a new
+ * top-level module import shifts stdin's internal init order and makes
+ * that async iterator silently yield zero bytes (oven-sh/bun#25320,
+ * #27849): exactly what broke every `harness hook` invocation on CI the
+ * moment `figures` became this package's first runtime dependency.
+ * `readFileSync(0)` bypasses that stream/ownership machinery entirely and
+ * is well-supported for piped (non-TTY) stdin under both runtimes.
+ */
+export async function readStdin(): Promise<string> {
+  try {
+    return readFileSync(0, "utf8");
+  } catch {
+    return "";
+  }
+}
+
+/**
+ * Recursively collect files under `dir` whose extension is in `exts`, skipping
+ * `node_modules` and dot-dirs, capped at `cap`. `Bun.Glob().scan()` replacement.
+ * @param dir - Directory to walk.
+ * @param exts - Allowed extensions including the dot (e.g. `.ts`).
+ * @param out - Accumulator (mutated in place).
+ * @param cap - Max files to collect.
+ */
+export function collectFiles(dir: string, exts: ReadonlySet<string>, out: string[], cap: number): void {
+  if (out.length >= cap) return;
+  let entries: Dirent[];
+  try {
+    entries = readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const e of entries) {
+    if (out.length >= cap) return;
+    if (e.name === "node_modules" || e.name.startsWith(".")) continue;
+    const full = join(dir, e.name);
+    if (e.isDirectory()) collectFiles(full, exts, out, cap);
+    else if (exts.has(e.name.slice(e.name.lastIndexOf(".")))) out.push(full);
+  }
+}

package/src/util/semver.ts

@@ -0,0 +1,30 @@
+/**
+ * Dependency-free semver ordering. `Array.prototype.sort()` compares strings
+ * lexicographically — `"1.0.9" > "1.0.23"` — so versioned directories (plugin
+ * caches) must be ordered with a numeric, segment-by-segment comparison.
+ */
+
+/**
+ * Compare two dotted version strings numerically, segment by segment
+ * (shorter version wins when a prefix is equal: `1.0` < `1.0.1`). A segment
+ * that is not a plain integer (prerelease tag like `0-beta`) falls back to
+ * lexicographic comparison of that segment — never NaN, so `sort()` stays
+ * defined; identical strings compare 0.
+ * @returns Negative when `a < b`, positive when `a > b`, 0 when equal.
+ */
+export function compareSemver(a: string, b: string): number {
+  const pa = a.split("."), pb = b.split(".");
+  for (let i = 0; i < Math.max(pa.length, pb.length); i++) {
+    const sa = pa[i] ?? "0", sb = pb[i] ?? "0";
+    if (sa === sb) continue;
+    const na = Number(sa), nb = Number(sb);
+    if (Number.isInteger(na) && Number.isInteger(nb) && na !== nb) return na - nb;
+    return sa < sb ? -1 : 1;
+  }
+  return 0;
+}
+
+/** The highest version of the list, or null when empty. */
+export function maxSemver(versions: string[]): string | null {
+  return versions.length === 0 ? null : versions.reduce((a, b) => (compareSemver(a, b) >= 0 ? a : b));
+}

package/dist/permission-mode-B0MUl7FT.mjs

@@ -1,136 +0,0 @@
-//#region src/adapters/codex/apply-patch.ts
-const BEGIN = "*** Begin Patch";
-const END = "*** End Patch";
-const ADD = "*** Add File: ";
-const DEL = "*** Delete File: ";
-const UPD = "*** Update File: ";
-const MOVE = "*** Move to: ";
-const EOF = "*** End of File";
-const ENV = "*** Environment ID: ";
-/**
-* Parse a Codex freeform patch into its per-file changes. Lenient on whitespace
-* around structural markers (as Codex's own parser is); returns `[]` when no
-* recognizable hunk is present (malformed input fails open, not closed).
-* @param text - Raw patch body from `tool_input.command`.
-* @returns One {@link PatchedFile} per Add/Update/Delete hunk, in order.
-*/
-function parseApplyPatch(text) {
-	const files = [];
-	let cur = null;
-	let buf = [];
-	const flush = () => {
-		if (cur) {
-			cur.content = buf.join("\n");
-			files.push(cur);
-		}
-		cur = null;
-		buf = [];
-	};
-	for (const line of text.split("\n")) {
-		const marker = line.trimStart();
-		if (marker === BEGIN || marker.startsWith(ENV)) continue;
-		if (marker === END) {
-			flush();
-			continue;
-		}
-		if (marker.startsWith(ADD)) {
-			flush();
-			cur = {
-				path: marker.slice(14).trim(),
-				content: "",
-				op: "add"
-			};
-			continue;
-		}
-		if (marker.startsWith(DEL)) {
-			flush();
-			files.push({
-				path: marker.slice(17).trim(),
-				content: "",
-				op: "delete"
-			});
-			continue;
-		}
-		if (marker.startsWith(UPD)) {
-			flush();
-			cur = {
-				path: marker.slice(17).trim(),
-				content: "",
-				op: "update"
-			};
-			continue;
-		}
-		if (marker.startsWith(MOVE)) {
-			if (cur) cur.path = marker.slice(13).trim();
-			continue;
-		}
-		if (marker === EOF || !cur) continue;
-		if (cur.op === "add") {
-			if (line.startsWith("+")) buf.push(line.slice(1));
-			continue;
-		}
-		if (line.startsWith("@@")) continue;
-		if (line.startsWith("+")) buf.push(line.slice(1));
-		else if (line.startsWith("-")) continue;
-		else buf.push(line.startsWith(" ") ? line.slice(1) : line);
-	}
-	flush();
-	return files;
-}
-//#endregion
-//#region src/runtime/codex-shell-tool.ts
-/**
-* @module codex-shell-tool
-* Canonicalizes a Codex-only shell `tool_name` alias to `"Bash"`, so every
-* existing `tool === "Bash"` consumer (activity credit, explore-tools
-* classification, the protected-path guard, the design corpus read gate, …)
-* treats a Code Mode exec dispatch exactly like a native Bash call — no
-* per-consumer change needed.
-*
-* A Code Mode-wrapped call (`functions.exec` -> `tools.exec_command(...)`)
-* surfaces via the generic `CoreToolRuntime` hook default (openai/codex#23757,
-* commit 5c20513), which keeps the raw function-tool name `"exec_command"`
-* verbatim — unlike a DIRECT `exec_command` dispatch, which
-* `ExecCommandHandler`'s own `pre_tool_use_payload` override re-labels
-* `"Bash"` (`tool_name: HookToolName::bash()`). This is the exact call chain
-* a real Codex CLI 0.146.0 session was observed emitting for a `sed -n` skill
-* read. Only ONE alias is confirmed here — `ToolName::plain("exec_command")`
-* in `core/src/tools/handlers/unified_exec/exec_command.rs`; `shell`,
-* `unified_exec`, `local_shell`, and `shell_command` were audited but not
-* evidenced as a distinct hook `tool_name` value, so they are deliberately
-* left out rather than guessed.
-* @packageDocumentation
-*/
-/** Codex `tool_name` values that are a shell execution but not literally `"Bash"`. */
-const CODEX_SHELL_TOOL_ALIASES = /* @__PURE__ */ new Set(["exec_command"]);
-/**
-* Canonicalize a Codex-only shell tool alias to `"Bash"`. Scoped to
-* `id === "codex"` — every other harness id, and every non-aliased tool
-* name, passes through unchanged (see `test/codex-shell-read-credit.test.ts`
-* for the non-regression proof).
-* @param id - Harness adapter id (e.g. "codex", "claude-code", "kimi").
-* @param tool - Raw `tool_name` from the hook payload.
-*/
-function canonicalizeCodexShellTool(id, tool) {
-	return id === "codex" && CODEX_SHELL_TOOL_ALIASES.has(tool) ? "Bash" : tool;
-}
-//#endregion
-//#region src/adapters/codex/permission-mode.ts
-/**
-* Codex maps `AskForApproval::Never` -> `permission_mode: "bypassPermissions"`
-* in its hook payload (codex-rs/core/src/hook_runtime.rs::hook_permission_mode)
-* — the only value that isolates `never`; the other three approval policies
-* (`untrusted`, `on-failure`, `on-request`) all collapse to `"default"`.
-* Verified at openai/codex@342e4d4b, hook_runtime.rs run_pre_tool_use_hooks +
-* pre_tool_use.rs PreToolUseRequest. Undocumented implementation detail, not
-* a public contract — see the mapping-regression test that pins this string.
-* @param permissionMode - The payload's `permission_mode` field, if present.
-* @returns True only on an EXACT match — fail-closed. A near-miss
-* (`"BypassPermissions"`, `"bypassPermissions "`, or a substring match) must
-* never accidentally grant the neverApproval exemption.
-*/
-function isBypassPermissions(permissionMode) {
-	return permissionMode === "bypassPermissions";
-}
-//#endregion
-export { canonicalizeCodexShellTool as n, parseApplyPatch as r, isBypassPermissions as t };