akm-cli 0.7.0-rc1 → 0.7.1

package/dist/tests/bench/cleanup-sigint.test.js

@@ -1,83 +0,0 @@
-/**
- * Subprocess test: real SIGINT delivery cleans up registered fns before
- * exit (#267).
- *
- * The real handler calls `process.exit(130)` — fatal inside the test
- * runner. So we drive it from a child Bun process and assert via side
- * effects (touchstones written to a tmpdir) that every cleanup fn ran.
- */
-import { afterAll, describe, expect, test } from "bun:test";
-import { spawnSync } from "node:child_process";
-import fs from "node:fs";
-import path from "node:path";
-import { benchMkdtemp } from "./tmp";
-const tempDirs = [];
-function makeTempDir(prefix = "akm-bench-cleanup-sigint-") {
-    const dir = benchMkdtemp(prefix);
-    tempDirs.push(dir);
-    return dir;
-}
-afterAll(() => {
-    for (const dir of tempDirs) {
-        fs.rmSync(dir, { recursive: true, force: true });
-    }
-});
-const repoRoot = path.resolve(import.meta.dir, "..", "..");
-describe("SIGINT delivery → registered cleanups run (#267)", () => {
-    test("subprocess: SIGINT runs every registered cleanup fn before exit", () => {
-        const sigDir = makeTempDir();
-        const a = path.join(sigDir, "a.touchstone");
-        const b = path.join(sigDir, "b.touchstone");
-        const c = path.join(sigDir, "c.touchstone");
-        // Inline driver script. It registers three cleanup fns that each touch
-        // a unique file, then `process.kill(pid, 'SIGINT')` and waits long
-        // enough for the handler to fire `process.exit(130)`.
-        const driverScript = `
-import { registerCleanup } from ${JSON.stringify(path.join(repoRoot, "tests", "bench", "cleanup.ts"))};
-import fs from "node:fs";
-
-registerCleanup(() => fs.writeFileSync(${JSON.stringify(a)}, "a"));
-registerCleanup(() => fs.writeFileSync(${JSON.stringify(b)}, "b"));
-registerCleanup(async () => {
-  await new Promise((r) => setTimeout(r, 5));
-  fs.writeFileSync(${JSON.stringify(c)}, "c");
-});
-
-process.kill(process.pid, "SIGINT");
-// Stay alive until the signal handler fires + exits.
-await new Promise((r) => setTimeout(r, 2000));
-`;
-        const scriptPath = path.join(sigDir, "driver.mjs");
-        fs.writeFileSync(scriptPath, driverScript);
-        const result = spawnSync("bun", ["run", scriptPath], {
-            encoding: "utf8",
-            timeout: 10_000,
-        });
-        // Exit code 130 = signalled exit (POSIX convention 128 + SIGINT(2)).
-        expect(result.status).toBe(130);
-        // All three cleanup fns ran before exit.
-        expect(fs.existsSync(a)).toBe(true);
-        expect(fs.existsSync(b)).toBe(true);
-        expect(fs.existsSync(c)).toBe(true);
-    });
-    test("subprocess: SIGTERM also triggers cleanup", () => {
-        const sigDir = makeTempDir();
-        const a = path.join(sigDir, "term.touchstone");
-        const driverScript = `
-import { registerCleanup } from ${JSON.stringify(path.join(repoRoot, "tests", "bench", "cleanup.ts"))};
-import fs from "node:fs";
-
-registerCleanup(() => fs.writeFileSync(${JSON.stringify(a)}, "term"));
-process.kill(process.pid, "SIGTERM");
-await new Promise((r) => setTimeout(r, 2000));
-`;
-        const scriptPath = path.join(sigDir, "driver-term.mjs");
-        fs.writeFileSync(scriptPath, driverScript);
-        const result = spawnSync("bun", ["run", scriptPath], {
-            encoding: "utf8",
-            timeout: 10_000,
-        });
-        expect(result.status).toBe(130);
-        expect(fs.existsSync(a)).toBe(true);
-    });
-});

package/dist/tests/bench/cleanup.js

@@ -1,203 +0,0 @@
-/**
- * Shared cleanup registry for the bench harness (#267).
- *
- * The bench creates many tmp directories — per (task, arm, seed) workspace,
- * per-task fixture stash, per-fixture evolveStash + preStash. Each of these
- * is wrapped in a try/finally so happy-path runs leave nothing behind. But
- * an external SIGINT/SIGTERM (operator hits Ctrl-C, CI cancels the job)
- * bypasses `finally` blocks entirely on Bun, leaving orphan tmp dirs under
- * the bench tmp root (#276 redirected this from the OS temp dir to
- * `${AKM_CACHE_DIR}/bench/`) that nothing reaps.
- *
- * `registerCleanup(fn)` captures the cleanup intent on a process-wide
- * registry and returns a deregister function. The first `registerCleanup`
- * call also installs ONE pair of SIGINT/SIGTERM handlers — subsequent calls
- * never re-install. On signal we walk every registered fn (swallowing
- * errors), remove our own listeners (so a second Ctrl-C force-exits), and
- * `process.exit(130)`.
- *
- * The handler is idempotent: re-entrant signals while cleanup is in flight
- * are dropped. Per-tmp `try/finally` callers should:
- *   1. Register the cleanup at the top of `try`.
- *   2. Deregister it in `finally` *before* running cleanup themselves so the
- *      handler doesn't double-fire.
- *
- * Garbage-collection of orphan dirs (#276): the FIRST `registerCleanup` call
- * also sweeps `${AKM_CACHE_DIR}/bench/*` entries older than 6h. This catches
- * orphans from prior crashed runs that bypassed `finally`. Subsequent calls
- * never re-sweep — the GC is install-once.
- */
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { warn } from "../../src/core/warn";
-import { benchTmpRoot } from "./tmp";
-const registry = {
-    fns: new Set(),
-    installed: false,
-    running: false,
-};
-/**
- * Register a cleanup function. Returns a deregister thunk that removes the
- * function from the registry. Calling deregister after the function has
- * already run is a no-op.
- */
-export function registerCleanup(fn) {
-    registry.fns.add(fn);
-    installSignalHandlers();
-    return () => {
-        registry.fns.delete(fn);
-    };
-}
-/** GC threshold for orphan bench tmp dirs: 6 hours in milliseconds. */
-const BENCH_TMP_GC_MAX_AGE_MS = 6 * 60 * 60 * 1000;
-/**
- * Sweep `${AKM_CACHE_DIR}/bench/*` entries whose mtime is older than 6h.
- * Best-effort: any individual rmSync failure is swallowed (warned in
- * verbose mode) so a permission-bound entry does not kill the install.
- *
- * Idempotent because it only runs from the first-installer path in
- * `installSignalHandlers` — gated by `registry.installed`.
- */
-function gcOrphanBenchTmp() {
-    let root;
-    try {
-        root = benchTmpRoot();
-    }
-    catch {
-        // If the cache dir cannot be resolved (e.g. HOME unset in a sandboxed
-        // CI shell), skip GC silently — the bench will fail later on its own.
-        return;
-    }
-    let entries;
-    try {
-        entries = fs.readdirSync(root);
-    }
-    catch {
-        // Root does not yet exist or is unreadable — nothing to reap.
-        return;
-    }
-    const cutoff = Date.now() - BENCH_TMP_GC_MAX_AGE_MS;
-    for (const name of entries) {
-        const full = path.join(root, name);
-        let stat;
-        try {
-            stat = fs.lstatSync(full);
-        }
-        catch {
-            continue;
-        }
-        if (stat.mtimeMs > cutoff)
-            continue;
-        try {
-            fs.rmSync(full, { recursive: true, force: true });
-        }
-        catch (err) {
-            warn(`bench tmp GC: could not remove ${full}: ${err.message}`);
-        }
-    }
-}
-function installSignalHandlers() {
-    if (registry.installed)
-        return;
-    registry.installed = true;
-    // First-installer GC sweep: reap orphan bench tmp dirs older than 6h.
-    // Subsequent registerCleanup() calls never re-trigger this — the
-    // `registry.installed` guard above ensures install-once semantics.
-    gcOrphanBenchTmp();
-    const handler = () => {
-        // Re-entrant signals are dropped — a second Ctrl-C will hit our
-        // already-removed listeners and the runtime's default handler will
-        // force-exit. That is the documented escape hatch.
-        if (registry.running)
-            return;
-        registry.running = true;
-        // Snapshot then drop registrations. We invoke synchronously where
-        // possible; async fns get fired-and-forget but we still await them so
-        // the exit doesn't beat the rmdir on slow filesystems.
-        const fns = [...registry.fns];
-        registry.fns.clear();
-        void runAllAndExit(fns);
-    };
-    registry.handlerSigint = handler;
-    registry.handlerSigterm = handler;
-    process.on("SIGINT", handler);
-    process.on("SIGTERM", handler);
-}
-async function runAllAndExit(fns) {
-    // BUG-H5: wrap the body in try/finally so a synchronous throw outside the
-    // per-fn try/catch (e.g. an exception thrown by `process.off` on a
-    // pathological listener list) does not leave `registry.running = true`.
-    // Without this guard, a subsequent registerCleanup() call would re-install
-    // listeners but the new handler would short-circuit on the stale flag and
-    // skip cleanup on the next signal.
-    try {
-        for (const fn of fns) {
-            try {
-                await fn();
-            }
-            catch {
-                // Best-effort: cleanup must never throw out of the signal path.
-            }
-        }
-        // Remove our listeners so a second Ctrl-C force-exits via the default.
-        if (registry.handlerSigint)
-            process.off("SIGINT", registry.handlerSigint);
-        if (registry.handlerSigterm)
-            process.off("SIGTERM", registry.handlerSigterm);
-        registry.installed = false;
-        registry.handlerSigint = undefined;
-        registry.handlerSigterm = undefined;
-    }
-    finally {
-        registry.running = false;
-        // 128 + SIGINT(2) — POSIX convention for signal-induced exits.
-        process.exit(130);
-    }
-}
-// ── Test-only seam ──────────────────────────────────────────────────────────
-/**
- * Test-only: drive the cleanup path as if a signal arrived, *without*
- * calling `process.exit`. Returns a promise that resolves once every
- * registered fn has settled. Used by the unit test to assert ordering
- * without killing the test process.
- *
- * Resets the registry to an uninstalled state on completion so subsequent
- * tests can re-install handlers cleanly.
- */
-export async function _drainForTest() {
-    const fns = [...registry.fns];
-    registry.fns.clear();
-    registry.running = true;
-    for (const fn of fns) {
-        try {
-            await fn();
-        }
-        catch {
-            /* swallow */
-        }
-    }
-    if (registry.handlerSigint)
-        process.off("SIGINT", registry.handlerSigint);
-    if (registry.handlerSigterm)
-        process.off("SIGTERM", registry.handlerSigterm);
-    registry.installed = false;
-    registry.running = false;
-    registry.handlerSigint = undefined;
-    registry.handlerSigterm = undefined;
-}
-/** Test-only: reset the registry without firing cleanups (for unit setup). */
-export function _resetForTest() {
-    registry.fns.clear();
-    if (registry.handlerSigint)
-        process.off("SIGINT", registry.handlerSigint);
-    if (registry.handlerSigterm)
-        process.off("SIGTERM", registry.handlerSigterm);
-    registry.installed = false;
-    registry.running = false;
-    registry.handlerSigint = undefined;
-    registry.handlerSigterm = undefined;
-}
-/** Test-only: peek at the current registration count. */
-export function _registeredCountForTest() {
-    return registry.fns.size;
-}

package/dist/tests/bench/cleanup.test.js

@@ -1,166 +0,0 @@
-/**
- * Unit tests for the bench cleanup registry (#267).
- *
- * The shared registry installs ONE pair of SIGINT/SIGTERM handlers on first
- * registration and runs every registered fn when a signal fires. We use the
- * `_drainForTest` test seam so the assertions don't have to actually kill
- * the test process — but we also exercise the real handler installation
- * path to make sure it's idempotent.
- */
-import { afterEach, beforeEach, describe, expect, test } from "bun:test";
-import fs from "node:fs";
-import { _drainForTest, _registeredCountForTest, _resetForTest, registerCleanup } from "./cleanup";
-import { benchMkdtemp, benchTmpRoot } from "./tmp";
-beforeEach(() => {
-    _resetForTest();
-});
-afterEach(() => {
-    _resetForTest();
-});
-describe("registerCleanup (#267)", () => {
-    test("registers a cleanup fn and increments the count", () => {
-        expect(_registeredCountForTest()).toBe(0);
-        registerCleanup(() => { });
-        expect(_registeredCountForTest()).toBe(1);
-    });
-    test("returns a deregister thunk that drops the registration", () => {
-        const deregister = registerCleanup(() => { });
-        expect(_registeredCountForTest()).toBe(1);
-        deregister();
-        expect(_registeredCountForTest()).toBe(0);
-    });
-    test("drainForTest runs every registered cleanup once", async () => {
-        const calls = [];
-        registerCleanup(() => {
-            calls.push("a");
-        });
-        registerCleanup(() => {
-            calls.push("b");
-        });
-        registerCleanup(() => {
-            calls.push("c");
-        });
-        await _drainForTest();
-        expect(calls.sort()).toEqual(["a", "b", "c"]);
-        // Registry is empty after drain.
-        expect(_registeredCountForTest()).toBe(0);
-    });
-    test("drainForTest swallows errors so one bad fn doesn't block the rest", async () => {
-        const calls = [];
-        registerCleanup(() => {
-            calls.push("first");
-        });
-        registerCleanup(() => {
-            throw new Error("boom");
-        });
-        registerCleanup(() => {
-            calls.push("third");
-        });
-        await _drainForTest();
-        expect(calls.sort()).toEqual(["first", "third"]);
-    });
-    test("drainForTest awaits async cleanup fns", async () => {
-        const calls = [];
-        registerCleanup(async () => {
-            await new Promise((resolve) => setTimeout(resolve, 10));
-            calls.push("async-done");
-        });
-        await _drainForTest();
-        expect(calls).toEqual(["async-done"]);
-    });
-    test("idempotent installer: repeated registers do not multiply listeners", () => {
-        const initialSigint = process.listenerCount("SIGINT");
-        const initialSigterm = process.listenerCount("SIGTERM");
-        registerCleanup(() => { });
-        registerCleanup(() => { });
-        registerCleanup(() => { });
-        // Exactly one listener each, no matter how many cleanup fns we add.
-        expect(process.listenerCount("SIGINT")).toBe(initialSigint + 1);
-        expect(process.listenerCount("SIGTERM")).toBe(initialSigterm + 1);
-    });
-    test("deregister-all leaves the listeners installed (registry is sticky)", () => {
-        // The contract is: once installed, the handlers stay installed for the
-        // process lifetime. Subsequent register calls reuse them.
-        registerCleanup(() => { })();
-        expect(_registeredCountForTest()).toBe(0);
-        // Re-register: this MUST NOT add a second pair of listeners.
-        const initialSigint = process.listenerCount("SIGINT");
-        registerCleanup(() => { });
-        expect(process.listenerCount("SIGINT")).toBe(initialSigint);
-    });
-    test("deregistered fns do not run on drain", async () => {
-        const calls = [];
-        const dereg = registerCleanup(() => {
-            calls.push("kept");
-        });
-        const _wasted = registerCleanup(() => {
-            calls.push("dropped");
-        });
-        _wasted();
-        void dereg; // keep referenced
-        await _drainForTest();
-        expect(calls).toEqual(["kept"]);
-    });
-    test("simulated SIGINT path: handler runs cleanup before exit (via drain seam)", async () => {
-        // We can't actually `process.exit(130)` inside a unit test, so we use the
-        // drain seam (which mirrors the runAllAndExit path minus the exit call).
-        // This verifies the OBSERVABLE behaviour the brief asked for: signal →
-        // every registered cleanup fn ran.
-        const ran = [];
-        registerCleanup(() => {
-            ran.push("rmsync(workspace)");
-        });
-        registerCleanup(() => {
-            ran.push("rmsync(stash)");
-        });
-        await _drainForTest();
-        expect(ran.length).toBe(2);
-        expect(ran).toContain("rmsync(workspace)");
-        expect(ran).toContain("rmsync(stash)");
-    });
-    test("first registerCleanup sweeps bench tmp entries older than 6h (#276)", () => {
-        // Ensure root exists before populating.
-        benchTmpRoot();
-        // Stale entry: mtime backdated 7h.
-        const stale = benchMkdtemp("akm-bench-gc-stale-");
-        const sevenHoursAgo = (Date.now() - 7 * 60 * 60 * 1000) / 1000;
-        fs.utimesSync(stale, sevenHoursAgo, sevenHoursAgo);
-        // Fresh entry: untouched mtime (now).
-        const fresh = benchMkdtemp("akm-bench-gc-fresh-");
-        expect(fs.existsSync(stale)).toBe(true);
-        expect(fs.existsSync(fresh)).toBe(true);
-        // Trigger first-installer GC.
-        registerCleanup(() => { });
-        expect(fs.existsSync(stale)).toBe(false);
-        expect(fs.existsSync(fresh)).toBe(true);
-        // Cleanup the fresh entry ourselves.
-        fs.rmSync(fresh, { recursive: true, force: true });
-    });
-    test("GC is idempotent — second registerCleanup does not re-sweep", () => {
-        // Install once with a sentinel registered.
-        registerCleanup(() => { });
-        // Now create a stale entry AFTER install. Second registerCleanup must
-        // NOT sweep it because the GC only runs on first install.
-        const stale = benchMkdtemp("akm-bench-gc-postinstall-");
-        const sevenHoursAgo = (Date.now() - 7 * 60 * 60 * 1000) / 1000;
-        fs.utimesSync(stale, sevenHoursAgo, sevenHoursAgo);
-        registerCleanup(() => { });
-        expect(fs.existsSync(stale)).toBe(true);
-        fs.rmSync(stale, { recursive: true, force: true });
-    });
-    test("re-entrant signals during running cleanup are dropped", async () => {
-        // Drive the registered handler twice in sequence. The second drain
-        // should observe the cleared registry (running flag flipped) and run
-        // nothing extra. This protects against a Ctrl-C double-press
-        // interrupting cleanup mid-run.
-        const calls = [];
-        registerCleanup(() => {
-            calls.push("first");
-        });
-        await _drainForTest();
-        expect(calls).toEqual(["first"]);
-        // No further fns registered → second drain is a no-op.
-        await _drainForTest();
-        expect(calls).toEqual(["first"]);
-    });
-});