ashlr-plugin 1.36.4

package/scripts/install-genome-hooks.ts

@@ -0,0 +1,196 @@
+#!/usr/bin/env bun
+/**
+ * install-genome-hooks — wire the genome commit-watcher into `.git/hooks/post-commit`.
+ *
+ * Opt-in. Called from `scripts/genome-init.ts` after a successful init (or
+ * manually). Idempotent — running it twice is a no-op.
+ *
+ * Strategy:
+ *   1. Locate the git directory (honors `core.hooksPath`).
+ *   2. If no post-commit hook exists, write a fresh one that invokes
+ *      `bun run scripts/genome-commit-watcher.ts` against the repo root.
+ *   3. If a post-commit hook already exists AND already calls the watcher,
+ *      do nothing.
+ *   4. Otherwise, APPEND a chained block that runs the watcher. We never
+ *      overwrite a user's existing hook content.
+ *
+ * Performance contract: the appended shim runs the watcher in <1s typical.
+ * We `&` the watcher to background it so even a degenerate case (cold bun
+ * startup) doesn't block the commit. Errors are swallowed via `|| true`.
+ *
+ * Usage:
+ *   bun run scripts/install-genome-hooks.ts [--cwd <dir>] [--force]
+ */
+
+import { execFileSync } from "child_process";
+import { chmodSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { dirname, join, relative, resolve } from "path";
+
+export const HOOK_MARKER_BEGIN = "# >>> ashlr genome-commit-watcher >>>";
+export const HOOK_MARKER_END = "# <<< ashlr genome-commit-watcher <<<";
+
+export interface InstallerArgs {
+  cwd: string;
+  force: boolean;
+}
+
+export function parseInstallerArgs(argv: string[]): InstallerArgs {
+  let cwd = process.cwd();
+  let force = false;
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === "--cwd" && argv[i + 1]) cwd = resolve(argv[++i]!);
+    else if (a === "--force") force = true;
+  }
+  return { cwd, force };
+}
+
+/**
+ * Discover the hooks dir for the repo rooted at `cwd`.
+ *
+ * Honors core.hooksPath (e.g. when a project uses lefthook / husky). Returns
+ * null when `cwd` is not inside a git repo.
+ *
+ * Exported so the installer can be tested against a fixture repo.
+ */
+export function findHooksDir(cwd: string): string | null {
+  try {
+    const gitCommonDir = execFileSync("git", ["rev-parse", "--git-common-dir"], {
+      cwd,
+      encoding: "utf-8",
+      stdio: ["ignore", "pipe", "pipe"],
+    }).trim();
+    if (!gitCommonDir) return null;
+    const gitDir = resolve(cwd, gitCommonDir);
+
+    // Respect core.hooksPath when set.
+    let configured = "";
+    try {
+      configured = execFileSync("git", ["config", "--get", "core.hooksPath"], {
+        cwd,
+        encoding: "utf-8",
+        stdio: ["ignore", "pipe", "pipe"],
+      }).trim();
+    } catch {
+      configured = "";
+    }
+    if (configured) {
+      return resolve(cwd, configured);
+    }
+    return join(gitDir, "hooks");
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Render the shell block we inject into post-commit.
+ *
+ * The shim resolves the watcher path relative to the repo root (passed as
+ * argument) so it works regardless of where the user runs git from.
+ */
+export function renderHookBlock(repoRoot: string, watcherPath: string): string {
+  const rel = relative(repoRoot, watcherPath) || "scripts/genome-commit-watcher.ts";
+  return [
+    HOOK_MARKER_BEGIN,
+    "# Auto-installed by scripts/install-genome-hooks.ts — see that file for details.",
+    "# Backgrounded + best-effort so it never blocks or fails a commit.",
+    `if command -v bun >/dev/null 2>&1; then`,
+    `  ( cd "$(git rev-parse --show-toplevel)" && bun run "${rel}" >/dev/null 2>&1 & ) || true`,
+    `fi`,
+    HOOK_MARKER_END,
+  ].join("\n");
+}
+
+export interface InstallResult {
+  installed: boolean;
+  /** Reason for skipping when installed === false. */
+  reason?: "no-git" | "already-installed";
+  hookPath?: string;
+}
+
+/**
+ * Install (or re-install) the post-commit hook for the repo at `cwd`.
+ *
+ * Idempotent: if the marker block is already present, returns
+ * `{ installed: false, reason: "already-installed" }`.
+ *
+ * When --force is passed we replace any existing marker block with a fresh one.
+ */
+export function installPostCommitHook(args: InstallerArgs): InstallResult {
+  const hooksDir = findHooksDir(args.cwd);
+  if (!hooksDir) return { installed: false, reason: "no-git" };
+
+  if (!existsSync(hooksDir)) {
+    mkdirSync(hooksDir, { recursive: true });
+  }
+
+  const hookPath = join(hooksDir, "post-commit");
+  const watcherAbs = resolve(args.cwd, "scripts", "genome-commit-watcher.ts");
+  const block = renderHookBlock(args.cwd, watcherAbs);
+
+  let existing = "";
+  if (existsSync(hookPath)) {
+    existing = readFileSync(hookPath, "utf-8");
+  }
+
+  const hasMarker = existing.includes(HOOK_MARKER_BEGIN);
+
+  if (hasMarker && !args.force) {
+    return { installed: false, reason: "already-installed", hookPath };
+  }
+
+  let next: string;
+  if (!existing.trim()) {
+    // Fresh hook — write a complete shebang script.
+    next = `#!/usr/bin/env bash\n# Managed in part by ashlr-plugin. Custom logic below the marker is preserved.\n\n${block}\n`;
+  } else if (hasMarker) {
+    // Replace the marker block (force path).
+    const re = new RegExp(
+      `${escapeRegex(HOOK_MARKER_BEGIN)}[\\s\\S]*?${escapeRegex(HOOK_MARKER_END)}\\n?`,
+      "g",
+    );
+    next = existing.replace(re, `${block}\n`);
+  } else {
+    // Chain — append at the end, preserving any existing logic above.
+    const sep = existing.endsWith("\n") ? "" : "\n";
+    next = `${existing}${sep}\n${block}\n`;
+  }
+
+  writeFileSync(hookPath, next, "utf-8");
+  try {
+    chmodSync(hookPath, 0o755);
+  } catch {
+    // chmod may fail on Windows — the file is still written.
+  }
+  return { installed: true, hookPath };
+}
+
+function escapeRegex(s: string): string {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+// ---------------------------------------------------------------------------
+// CLI
+// ---------------------------------------------------------------------------
+
+export function main(argv: string[] = process.argv.slice(2)): number {
+  const args = parseInstallerArgs(argv);
+  const res = installPostCommitHook(args);
+  if (res.installed) {
+    // eslint-disable-next-line no-console
+    console.log(`installed post-commit hook → ${res.hookPath}`);
+    return 0;
+  }
+  if (res.reason === "no-git") {
+    console.error("not a git repo — skipped");
+    return 1;
+  }
+  // eslint-disable-next-line no-console
+  console.log(`post-commit hook already installed at ${res.hookPath}`);
+  return 0;
+}
+
+if ((import.meta as { main?: boolean }).main) {
+  process.exit(main());
+}

package/scripts/install-onnx-model.ts

@@ -0,0 +1,154 @@
+#!/usr/bin/env bun
+/**
+ * Install the ONNX summarization model for ashlr's offline provider.
+ *
+ * Target model: Xenova/distilbart-cnn-6-6 (seq2seq text summarization, ~300MB)
+ * Source:        https://huggingface.co/Xenova/distilbart-cnn-6-6
+ * Model dir:     ~/.ashlr/models/distilbart/
+ *
+ * After running this script:
+ *   - The ONNX provider activates automatically when ANTHROPIC_API_KEY is absent.
+ *   - Or force it: ASHLR_LLM_PROVIDER=onnx
+ *
+ * Note: onnxruntime-node must be installed first (optional dependency):
+ *   bun add onnxruntime-node   # or: npm install onnxruntime-node
+ *
+ * Disk space: ~300MB total (encoder ~200MB + decoder ~100MB + tokenizer files).
+ * This is why the model is NOT bundled by default — run this script only if you
+ * want offline summarization without an Anthropic API key.
+ */
+
+import { mkdir, writeFile } from "fs/promises";
+import { existsSync, statSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+
+function home(): string {
+  return process.env.HOME ?? homedir();
+}
+
+const MODEL_DIR = join(home(), ".ashlr", "models", "distilbart");
+
+// Hugging Face ONNX-exported files from the Xenova/transformers.js project.
+const HF_BASE = "https://huggingface.co/Xenova/distilbart-cnn-6-6/resolve/main";
+const MODEL_FILES = [
+  { name: "config.json",                        path: "config.json",                          sizeMB: "<1" },
+  { name: "tokenizer.json",                     path: "tokenizer.json",                       sizeMB: "1"  },
+  { name: "tokenizer_config.json",              path: "tokenizer_config.json",                sizeMB: "<1" },
+  { name: "onnx/encoder_model.onnx",            path: "onnx/encoder_model.onnx",              sizeMB: "195" },
+  { name: "onnx/decoder_model_merged.onnx",     path: "onnx/decoder_model_merged.onnx",       sizeMB: "107" },
+];
+
+function fmtBytes(bytes: number): string {
+  if (bytes >= 1_000_000) return `${(bytes / 1_000_000).toFixed(1)} MB`;
+  if (bytes >= 1_000) return `${(bytes / 1_000).toFixed(1)} KB`;
+  return `${bytes} B`;
+}
+
+async function downloadFile(url: string, dest: string): Promise<void> {
+  const dir = join(dest, "..");
+  await mkdir(dir, { recursive: true });
+  const ctl = new AbortController();
+  const timeout = setTimeout(() => ctl.abort(), 10 * 60 * 1000); // 10min per file
+  try {
+    const res = await fetch(url, { signal: ctl.signal });
+    if (!res.ok) throw new Error(`HTTP ${res.status} ${res.statusText} for ${url}`);
+    const buf = await res.arrayBuffer();
+    await writeFile(dest, new Uint8Array(buf));
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+
+async function main(): Promise<void> {
+  console.log("ashlr ONNX model installer");
+  console.log("Model: Xenova/distilbart-cnn-6-6 (seq2seq summarization)");
+  console.log(`Model directory: ${MODEL_DIR}`);
+  console.log("");
+
+  // Check onnxruntime-node
+  let onnxInstalled = false;
+  try {
+    require("onnxruntime-node");
+    console.log("✓ onnxruntime-node: installed");
+    onnxInstalled = true;
+  } catch {
+    console.log("⚠ onnxruntime-node: NOT installed");
+    console.log("");
+    console.log("The ONNX provider requires onnxruntime-node. Install it with:");
+    console.log("  bun add onnxruntime-node");
+    console.log("  # or: npm install onnxruntime-node");
+    console.log("");
+    console.log("Continuing to download the model files — you can install onnxruntime-node after.");
+    console.log("");
+  }
+
+  await mkdir(join(MODEL_DIR, "onnx"), { recursive: true });
+
+  console.log(`Downloading ${MODEL_FILES.length} files from Hugging Face (~300MB total)...`);
+  console.log("This will take several minutes on a typical connection.");
+  console.log("");
+
+  let downloaded = 0;
+  let skipped = 0;
+  let failed = 0;
+
+  for (const file of MODEL_FILES) {
+    const dest = join(MODEL_DIR, file.name);
+    if (existsSync(dest)) {
+      const size = statSync(dest).size;
+      console.log(`  SKIP  ${file.name}  (${fmtBytes(size)}, already exists)`);
+      skipped++;
+      continue;
+    }
+    const url = `${HF_BASE}/${file.path}`;
+    process.stdout.write(`  DL    ${file.name} (~${file.sizeMB} MB) ... `);
+    try {
+      await downloadFile(url, dest);
+      const size = statSync(dest).size;
+      console.log(`done (${fmtBytes(size)})`);
+      downloaded++;
+    } catch (e) {
+      console.log(`FAILED: ${e instanceof Error ? e.message : String(e)}`);
+      failed++;
+    }
+  }
+
+  console.log("");
+
+  if (failed > 0) {
+    console.log(`✗ ${failed} file(s) failed to download. Check your connection and retry.`);
+    process.exit(1);
+  }
+
+  // Total size
+  let totalBytes = 0;
+  for (const file of MODEL_FILES) {
+    const dest = join(MODEL_DIR, file.name);
+    if (existsSync(dest)) totalBytes += statSync(dest).size;
+  }
+
+  console.log(`✓ Model installed: ${fmtBytes(totalBytes)} in ${MODEL_DIR}`);
+  if (downloaded > 0) console.log(`  ${downloaded} file(s) downloaded, ${skipped} skipped`);
+  console.log("");
+
+  if (!onnxInstalled) {
+    console.log("Next step: install onnxruntime-node to activate the ONNX provider:");
+    console.log("  bun add onnxruntime-node");
+    console.log("  # or: npm install onnxruntime-node");
+    console.log("");
+  } else {
+    console.log("ONNX provider is ready. It activates automatically when:");
+    console.log("  - ANTHROPIC_API_KEY is not set");
+    console.log("  - ASHLR_LLM_URL is not set");
+    console.log("");
+    console.log("Or force it: ASHLR_LLM_PROVIDER=onnx");
+  }
+
+  console.log("Verify the install: bun run /ashlr-doctor");
+}
+
+main().catch((e) => {
+  console.error("Fatal:", e instanceof Error ? e.message : String(e));
+  process.exit(1);
+});

package/scripts/install-permissions.ts

@@ -0,0 +1,276 @@
+#!/usr/bin/env bun
+/**
+ * install-permissions.ts — add ashlr MCP tool wildcards to ~/.claude/settings.json
+ * so Claude Code stops prompting on every mcp__ashlr-*__ call in bypassPermissions mode.
+ *
+ * Usage:
+ *   bun run scripts/install-permissions.ts            # add entries
+ *   bun run scripts/install-permissions.ts --dry-run  # preview without writing
+ *   bun run scripts/install-permissions.ts --remove   # undo (strip ashlr entries)
+ *   bun run scripts/install-permissions.ts --settings /path/to/settings.json
+ *
+ * Exits 0 on success; 1 only on unrecoverable I/O errors.
+ */
+
+import { existsSync } from "fs";
+import { mkdir, readFile, realpath, rename, writeFile } from "fs/promises";
+import { homedir } from "os";
+import { dirname, join } from "path";
+import { randomBytes } from "crypto";
+import { fileURLToPath } from "url";
+
+// ---------- types ----------
+
+export interface PermissionsResult {
+  added: string[];
+  alreadyPresent: string[];
+  removed: string[];
+  dryRun: boolean;
+  settingsPath: string;
+}
+
+// ---------- plugin.json helpers ----------
+
+function findPluginRoot(startDir: string): string | null {
+  const envRoot = process.env.CLAUDE_PLUGIN_ROOT;
+  if (envRoot && existsSync(join(envRoot, ".claude-plugin/plugin.json"))) return envRoot;
+  let dir = startDir;
+  for (let i = 0; i < 10; i++) {
+    if (existsSync(join(dir, ".claude-plugin/plugin.json"))) return dir;
+    const parent = dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return null;
+}
+
+export async function readMcpServerNames(pluginRoot: string): Promise<string[]> {
+  try {
+    const raw = await readFile(join(pluginRoot, ".claude-plugin/plugin.json"), "utf8");
+    const parsed = JSON.parse(raw) as { mcpServers?: Record<string, unknown> };
+    if (parsed.mcpServers && typeof parsed.mcpServers === "object") {
+      const keys = Object.keys(parsed.mcpServers);
+      // v1.13 router consolidation: a single "ashlr" entry fronts every tool.
+      // Existing user settings.json blocks (mcp__ashlr-efficiency__*, etc.)
+      // still need the per-server wildcards to match, so fall through to the
+      // hardcoded list below when the manifest is collapsed.
+      if (!(keys.length === 1 && keys[0] === "ashlr")) {
+        return keys;
+      }
+    }
+  } catch {
+    // fall through to default list
+  }
+  // fallback: hard-coded list in case plugin.json is unreadable
+  return [
+    "ashlr-efficiency",
+    "ashlr-sql",
+    "ashlr-bash",
+    "ashlr-tree",
+    "ashlr-http",
+    "ashlr-diff",
+    "ashlr-logs",
+    "ashlr-genome",
+    "ashlr-orient",
+    "ashlr-github",
+    "ashlr-glob",
+    "ashlr-webfetch",
+  ];
+}
+
+/** Build the full list of allow entries we manage: per-server wildcards + catch-all. */
+export function buildAshlrEntries(serverNames: string[]): string[] {
+  const entries: string[] = serverNames.map((name) => `mcp__${name}__*`);
+  // Legacy catch-all for pre-router `mcp__ashlr-<server>__*` names.
+  entries.push("mcp__ashlr-*");
+  // v1.13+ router canonical names are `mcp__plugin_ashlr_ashlr__ashlr__<tool>`.
+  // Without this entry /ashlr-allow silently fails to stop Claude Code from
+  // prompting on every tool call. Covers every future router-exposed tool.
+  entries.push("mcp__plugin_ashlr_*");
+  return entries;
+}
+
+/** Returns true if `entry` is one we own (matches ashlr pattern). */
+export function isAshlrEntry(entry: string): boolean {
+  // Both catch-all literals (`mcp__ashlr-*`, `mcp__plugin_ashlr_*`) are covered
+  // by these prefix regexes — no need for explicit string equality checks.
+  return /^mcp__ashlr(-|__)/.test(entry) || /^mcp__plugin_ashlr_/.test(entry);
+}
+
+// ---------- settings.json I/O ----------
+
+export async function readSettings(settingsPath: string): Promise<Record<string, unknown>> {
+  try {
+    // Resolve symlinks so rename() lands at the real path
+    const resolved = await realpath(settingsPath).catch(() => settingsPath);
+    const raw = await readFile(resolved, "utf8");
+    const parsed = JSON.parse(raw);
+    if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+      return parsed as Record<string, unknown>;
+    }
+  } catch {
+    // missing file or malformed JSON → start fresh
+  }
+  return {};
+}
+
+async function writeSettingsAtomic(settingsPath: string, data: Record<string, unknown>): Promise<void> {
+  await mkdir(dirname(settingsPath), { recursive: true });
+  const tmp = settingsPath + ".tmp." + process.pid + "." + randomBytes(3).toString("hex");
+  await writeFile(tmp, JSON.stringify(data, null, 2) + "\n", "utf8");
+  try {
+    // If the file is a symlink resolve to target for the rename
+    const target = await realpath(settingsPath).catch(() => settingsPath);
+    await rename(tmp, target);
+  } catch (err) {
+    // best-effort: temp file cleanup on a failed rename — if unlink itself fails (e.g. file already gone) the original rename error is still what the caller needs to see, so swallow this.
+    await import("fs/promises").then((m) => m.unlink(tmp)).catch(() => {});
+    throw err;
+  }
+}
+
+// ---------- core logic ----------
+
+export interface InstallOptions {
+  dryRun?: boolean;
+  remove?: boolean;
+  settingsPath?: string;
+  pluginRoot?: string;
+  /**
+   * When true, suppress any stdin prompts and proceed with the write
+   * unconditionally. Used by `hooks/session-start.ts` first-run
+   * auto-consent flow so the hook never blocks waiting for input.
+   */
+  nonInteractive?: boolean;
+}
+
+export async function installPermissions(opts: InstallOptions = {}): Promise<PermissionsResult> {
+  const here = dirname(fileURLToPath(import.meta.url));
+  const resolvedRoot = opts.pluginRoot ?? findPluginRoot(here) ?? here;
+  const settingsPath = opts.settingsPath ?? join(homedir(), ".claude/settings.json");
+
+  const serverNames = await readMcpServerNames(resolvedRoot);
+  const ashlrEntries = buildAshlrEntries(serverNames);
+
+  const settings = await readSettings(settingsPath);
+
+  // Ensure permissions.allow exists
+  if (!settings.permissions || typeof settings.permissions !== "object" || Array.isArray(settings.permissions)) {
+    settings.permissions = {};
+  }
+  const perms = settings.permissions as Record<string, unknown>;
+  if (!Array.isArray(perms.allow)) {
+    perms.allow = [];
+  }
+  const allow = perms.allow as string[];
+
+  const result: PermissionsResult = {
+    added: [],
+    alreadyPresent: [],
+    removed: [],
+    dryRun: opts.dryRun ?? false,
+    settingsPath,
+  };
+
+  if (opts.remove) {
+    // Strip all ashlr entries
+    const before = allow.length;
+    const kept = allow.filter((e) => !isAshlrEntry(e));
+    result.removed = allow.filter((e) => isAshlrEntry(e));
+    if (!opts.dryRun && result.removed.length > 0) {
+      perms.allow = kept;
+      await writeSettingsAtomic(settingsPath, settings);
+    }
+    return result;
+  }
+
+  // Add mode: idempotent. Per-server wildcards (e.g. `mcp__ashlr-foo__*`) are
+  // subsumed by the catch-alls `mcp__ashlr-*` / `mcp__plugin_ashlr_*` — when
+  // a catch-all is already present, skip the per-server entries it covers
+  // instead of re-adding them on every invocation.
+  const hasAshlrCatchAll = allow.includes("mcp__ashlr-*");
+  const hasPluginCatchAll = allow.includes("mcp__plugin_ashlr_*");
+  for (const entry of ashlrEntries) {
+    const isCatchAll = entry === "mcp__ashlr-*" || entry === "mcp__plugin_ashlr_*";
+    const subsumed =
+      !isCatchAll &&
+      ((hasAshlrCatchAll && entry.startsWith("mcp__ashlr-")) ||
+        (hasPluginCatchAll && entry.startsWith("mcp__plugin_ashlr_")));
+    if (allow.includes(entry) || subsumed) {
+      result.alreadyPresent.push(entry);
+    } else {
+      result.added.push(entry);
+    }
+  }
+
+  if (!opts.dryRun && result.added.length > 0) {
+    for (const entry of result.added) {
+      allow.push(entry);
+    }
+    await writeSettingsAtomic(settingsPath, settings);
+  }
+
+  return result;
+}
+
+// ---------- main ----------
+
+function formatResult(r: PermissionsResult): string {
+  const lines: string[] = [];
+  const prefix = r.dryRun ? "[dry-run] " : "";
+
+  if (r.removed.length > 0) {
+    lines.push(`${prefix}Removed ${r.removed.length} ashlr permission entr${r.removed.length === 1 ? "y" : "ies"}:`);
+    for (const e of r.removed) lines.push(`  - ${e}`);
+  } else if (r.added.length === 0 && r.alreadyPresent.length === 0 && !r.removed.length) {
+    // remove mode, nothing to do
+    lines.push(`${prefix}No ashlr permission entries found to remove.`);
+  }
+
+  if (r.added.length > 0) {
+    lines.push(`${prefix}Added ${r.added.length} entr${r.added.length === 1 ? "y" : "ies"} to ${r.settingsPath}:`);
+    for (const e of r.added) lines.push(`  + ${e}`);
+  }
+
+  if (r.alreadyPresent.length > 0) {
+    lines.push(`Already present (${r.alreadyPresent.length}): ${r.alreadyPresent.join(", ")}`);
+  }
+
+  if (r.added.length === 0 && r.alreadyPresent.length > 0 && r.removed.length === 0) {
+    lines.push("All ashlr MCP tool entries already in allowlist. Nothing to do.");
+  }
+
+  if (!r.dryRun && r.added.length > 0) {
+    lines.push("");
+    lines.push("Restart Claude Code (or run /reload-plugins) to pick up the new permissions.");
+  }
+
+  return lines.join("\n");
+}
+
+async function main(): Promise<number> {
+  const args = process.argv.slice(2);
+  const dryRun = args.includes("--dry-run");
+  const remove = args.includes("--remove");
+
+  let settingsPath: string | undefined;
+  const settingsIdx = args.indexOf("--settings");
+  if (settingsIdx !== -1 && args[settingsIdx + 1]) {
+    settingsPath = args[settingsIdx + 1];
+  }
+
+  try {
+    const result = await installPermissions({ dryRun, remove, settingsPath });
+    process.stdout.write(formatResult(result) + "\n");
+    return 0;
+  } catch (err) {
+    process.stderr.write(
+      `ashlr install-permissions: I/O error — ${err instanceof Error ? err.message : String(err)}\n`,
+    );
+    return 1;
+  }
+}
+
+if (import.meta.main) {
+  main().then((code) => process.exit(code));
+}