@fusengine/harness 0.1.90 → 0.1.92

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));
+}