@bjoernrochel/sevro 1.0.0 → 1.1.0

package/src/run-owner.ts

@@ -1,5 +1,6 @@
+import { spawnSync } from "./runtime-process";
 import { isRecord } from "./value-guards";
-import { Database } from "bun:sqlite";
+import { openLockDatabase } from "./sqlite-lock";
 import { randomUUID } from "node:crypto";
 import {
   mkdirSync,
@@ -115,11 +116,16 @@ function atomicJson(path: string, value: unknown): void {
 function withClaimLock<T>(claimPath: string, action: () => T): T {
   const locks = join(dirname(dirname(claimPath)), "locks");
   mkdirSync(locks, { recursive: true, mode: 0o700 });
-  const database = new Database(join(locks, `${basename(claimPath)}.sqlite`));
+  const database = openLockDatabase(
+    join(locks, `${basename(claimPath)}.sqlite`),
+  );
   try {
-    database.run("PRAGMA busy_timeout = 5000");
-    database.run("CREATE TABLE IF NOT EXISTS mutex (id INTEGER PRIMARY KEY)");
-    return database.transaction(action).immediate();
+    database.exec("PRAGMA busy_timeout = 5000");
+    database.exec("CREATE TABLE IF NOT EXISTS mutex (id INTEGER PRIMARY KEY)");
+    database.exec("BEGIN IMMEDIATE");
+    const result = action();
+    database.exec("COMMIT");
+    return result;
   } finally {
     database.close();
   }
@@ -159,16 +165,16 @@ function identityEnvironment(windows: boolean) {
     : { PATH: "/usr/bin:/bin", LC_ALL: "C" };
 }
 
-function processStartTime(result: ReturnType<typeof Bun.spawnSync>): string {
-  return result.stdout?.toString().trim() ?? "";
+function processStartTime(result: ReturnType<typeof spawnSync>): string {
+  return result.stdout.toString().trim();
 }
 
 export function processIdentity(pid: number): ProcessIdentity | null {
   const windows = process.platform === "win32";
   const argv = identityCommand(pid, windows);
-  let result: ReturnType<typeof Bun.spawnSync>;
+  let result: ReturnType<typeof spawnSync>;
   try {
-    result = Bun.spawnSync(argv, {
+    result = spawnSync(argv, {
       env: identityEnvironment(windows),
       stdout: "pipe",
       stderr: "ignore",

package/src/runner-paths.ts

@@ -0,0 +1,21 @@
+import { resolve, join } from "node:path";
+
+export const sourceRuntime = import.meta.filename.endsWith(".ts");
+export const runnerRoot = resolve(
+  import.meta.dirname,
+  sourceRuntime ? ".." : "../..",
+);
+
+export function examplePath(...parts: string[]): string {
+  const path = join(
+    runnerRoot,
+    ...(sourceRuntime ? [] : ["dist"]),
+    "examples",
+    ...parts,
+  );
+  return runtimeModule(path);
+}
+
+export function runtimeModule(path: string): string {
+  return sourceRuntime ? path : path.replace(/\.ts$/, ".js");
+}

package/src/runtime/hook-processes.ts

@@ -1,3 +1,4 @@
+import { spawn } from "../runtime-process";
 import { readFile, readdir, writeFile } from "node:fs/promises";
 import { basename, dirname, join } from "node:path";
 import { isRecord } from "../value-guards";
@@ -22,7 +23,7 @@ export async function hookExecutions(
 }
 
 async function processOutput(argv: string[]): Promise<string> {
-  const child = Bun.spawn(argv, { stdout: "pipe", stderr: "ignore" });
+  const child = spawn(argv, { stdout: "pipe", stderr: "ignore" });
   const output = await new Response(child.stdout).text();
   await child.exited;
   if (Buffer.byteLength(output) > 1024 * 1024)

package/src/runtime/hooks.ts

@@ -1,3 +1,5 @@
+import { parse as parseYaml, stringify as stringifyYaml } from "yaml";
+import { existsSync } from "node:fs";
 import {
   cp,
   mkdir,
@@ -253,23 +255,23 @@ async function rewritePlugin(
   manifest: Record<string, unknown>,
   state: HookRewrite,
 ): Promise<void> {
-  await requireHookOnlyPlugin(state.root);
+  requireHookOnlyPlugin(state.root);
   await rewriteManifest(manifest, state, ".claude-plugin/plugin.json");
   const native = join(state.root, ".codex-plugin/plugin.json");
-  if (await Bun.file(native).exists())
+  if (existsSync(native))
     await rewriteManifest(
       object(JSON.parse(await readFile(native, "utf8"))),
       state,
       ".codex-plugin/plugin.json",
     );
   const standard = join(state.root, "hooks/hooks.json");
-  if (await Bun.file(standard).exists()) await hookFile(standard, state);
+  if (existsSync(standard)) await hookFile(standard, state);
   await rewriteFrontmatter(state.root, state);
 }
 
-async function requireHookOnlyPlugin(root: string): Promise<void> {
+function requireHookOnlyPlugin(root: string): void {
   for (const name of [".mcp.json", ".lsp.json"])
-    if (await Bun.file(join(root, name)).exists())
+    if (existsSync(join(root, name)))
       throw new Error("runtime auxiliary plugin execution is unsupported");
 }
 
@@ -432,7 +434,7 @@ async function rewriteMarkdown(
   else delete metadata.hooks;
   await writeFile(
     path,
-    `---\n${Bun.YAML.stringify(metadata)}\n---\n${body.slice(header[0].length)}`,
+    `---\n${stringifyYaml(metadata)}\n---\n${body.slice(header[0].length)}`,
   );
 }
 
@@ -440,7 +442,7 @@ function hookFrontmatter(
   header: string | undefined,
 ): Record<string, unknown> | undefined {
   if (!header?.includes("hooks")) return undefined;
-  const metadata = object(Bun.YAML.parse(header));
+  const metadata = object(parseYaml(header));
   return metadata.hooks === undefined ? undefined : metadata;
 }
 

package/src/runtime-process.ts

@@ -0,0 +1,194 @@
+import {
+  spawn as nodeSpawn,
+  spawnSync as nodeSpawnSync,
+  type ChildProcess,
+} from "node:child_process";
+import { Readable, Writable } from "node:stream";
+import { constants } from "node:os";
+
+interface ProcessWriter {
+  write(data: string | Uint8Array): unknown;
+  end(): unknown;
+}
+
+export interface Subprocess {
+  pid: number;
+  stdin: ProcessWriter | null;
+  stdout: ReadableStream<Uint8Array>;
+  stderr: ReadableStream<Uint8Array>;
+  exited: Promise<number>;
+  readonly signalCode: string | null;
+  kill(signal: NodeJS.Signals): void;
+}
+
+interface SpawnOptions {
+  cwd?: string;
+  env?: NodeJS.ProcessEnv;
+  detached?: boolean;
+  stdin?: "pipe" | "ignore" | Uint8Array;
+  stdout?: "pipe" | "ignore";
+  stderr?: "pipe" | "ignore";
+}
+
+function emptyStream(): ReadableStream<Uint8Array> {
+  return new ReadableStream({
+    start(controller) {
+      controller.close();
+    },
+  });
+}
+
+function readable(stream: Readable | null): ReadableStream<Uint8Array> {
+  // Node and Bun declare different overloads for the same Web Streams API.
+  return stream
+    ? (Readable.toWeb(stream) as unknown as ReadableStream<Uint8Array>)
+    : emptyStream();
+}
+
+function output(
+  stream: ReadableStream<Uint8Array> | null | undefined,
+): ReadableStream<Uint8Array> {
+  return stream ?? emptyStream();
+}
+
+function writer(stream: Writable | null): ProcessWriter | null {
+  if (!stream) return null;
+  const destination = Writable.toWeb(stream).getWriter();
+  return {
+    write: (data) =>
+      destination.write(typeof data === "string" ? Buffer.from(data) : data),
+    end: () => destination.close(),
+  };
+}
+
+function commandName(argv: string[]): string {
+  const name = argv[0];
+  if (!name) throw new Error("process command must be nonempty");
+  return name;
+}
+
+function stdinMode(input: SpawnOptions["stdin"]) {
+  return input === "pipe" || input instanceof Uint8Array ? "pipe" : "ignore";
+}
+
+function processId(child: ChildProcess): number {
+  if (child.pid !== undefined) return child.pid;
+  child.once("error", () => {});
+  throw new Error("could not start process");
+}
+
+function exitCode(code: number | null, signal: NodeJS.Signals | null): number {
+  return code ?? 128 + (signal ? constants.signals[signal] : 0);
+}
+
+function completion(child: ChildProcess): Promise<number> {
+  return new Promise((resolve, reject) => {
+    child.once("error", reject);
+    child.once("exit", (code, signal) => {
+      resolve(exitCode(code, signal));
+    });
+  });
+}
+
+async function initialInput(
+  stdin: ProcessWriter | null,
+  input: SpawnOptions["stdin"],
+) {
+  if (!(input instanceof Uint8Array)) return;
+  if (!stdin) throw new Error("process input pipe unavailable");
+  await stdin.write(input);
+  await stdin.end();
+}
+
+function nodeProcess(argv: string[], options: SpawnOptions): Subprocess {
+  const child = nodeSpawn(commandName(argv), argv.slice(1), {
+    cwd: options.cwd,
+    env: options.env,
+    detached: options.detached,
+    stdio: [
+      stdinMode(options.stdin),
+      options.stdout ?? "pipe",
+      options.stderr ?? "pipe",
+    ],
+  });
+  const pid = processId(child);
+  const exited = completion(child);
+  const stdin = writer(child.stdin);
+  return {
+    pid,
+    stdin,
+    stdout: readable(child.stdout),
+    stderr: readable(child.stderr),
+    exited: Promise.all([exited, initialInput(stdin, options.stdin)]).then(
+      ([code]) => code,
+    ),
+    get signalCode() {
+      return child.signalCode;
+    },
+    kill(signal) {
+      child.kill(signal);
+    },
+  };
+}
+
+function bunProcess(argv: string[], options: SpawnOptions): Subprocess {
+  const child = Bun.spawn(argv, {
+    ...options,
+    stdin: options.stdin ?? "ignore",
+    stderr: options.stderr ?? "pipe",
+  });
+  return {
+    pid: child.pid,
+    stdin: typeof child.stdin === "object" ? child.stdin : null,
+    stdout: output(child.stdout),
+    stderr: output(child.stderr),
+    exited: child.exited,
+    get signalCode() {
+      return child.signalCode ?? null;
+    },
+    kill(signal) {
+      child.kill(signal);
+    },
+  };
+}
+
+/** Keep the runner's process/stream contract independent of its JS runtime. */
+export function spawn(argv: string[], options: SpawnOptions = {}): Subprocess {
+  return process.versions.bun
+    ? bunProcess(argv, options)
+    : nodeProcess(argv, options);
+}
+
+function buffer(bytes: Buffer | null | undefined): Buffer {
+  return bytes ?? Buffer.alloc(0);
+}
+
+function bunSync(argv: string[], options: SpawnOptions) {
+  const result = Bun.spawnSync(argv, options);
+  return {
+    exitCode: result.exitCode,
+    stdout: buffer(result.stdout),
+    stderr: buffer(result.stderr),
+  };
+}
+
+function nodeSync(argv: string[], options: SpawnOptions) {
+  const result = nodeSpawnSync(commandName(argv), argv.slice(1), {
+    cwd: options.cwd,
+    env: options.env,
+    stdio: ["ignore", options.stdout ?? "pipe", options.stderr ?? "pipe"],
+    maxBuffer: 64 * 1024 * 1024,
+  });
+  if (result.error) throw result.error;
+  return {
+    exitCode: result.status ?? 1,
+    stdout: buffer(result.stdout),
+    stderr: buffer(result.stderr),
+  };
+}
+
+export function spawnSync(argv: string[], options: SpawnOptions = {}) {
+  return process.versions.bun
+    ? bunSync(argv, options)
+    : nodeSync(argv, options);
+}

package/src/sqlite-lock.ts

@@ -0,0 +1,25 @@
+import { createRequire } from "node:module";
+
+const require = createRequire(import.meta.url);
+
+interface LockDatabase {
+  exec(sql: string): unknown;
+  close(): void;
+}
+
+/** Both drivers use SQLite file locks, including across Node and Bun runners. */
+export function openLockDatabase(path: string): LockDatabase {
+  if (process.versions.bun) {
+    const { Database } = require("bun:sqlite") as typeof import("bun:sqlite");
+    const database = new Database(path);
+    return {
+      exec: (sql) => database.run(sql),
+      close() {
+        database.close();
+      },
+    };
+  }
+  const { DatabaseSync } =
+    require("node:sqlite") as typeof import("node:sqlite");
+  return new DatabaseSync(path);
+}