@nocville/npc 0.0.0-stage → 0.2.0

package/dist/npcs/agent-common/hook-settings.js

@@ -0,0 +1,265 @@
+import { copyFileSync, existsSync, readFileSync, realpathSync, writeFileSync } from 'node:fs';
+import { delimiter, join } from 'node:path';
+import { SHIM_PATH } from './shim.js';
+/**
+ * Matcher-group hook config shared by Claude Code (`~/.claude/settings.json`)
+ * and Codex (`~/.codex/hooks.json`) — both use:
+ *
+ *   { "hooks": { "<Event>": [ { "matcher": "", "hooks": [ { "type": "command", "command": "…" } ] } ] } }
+ *
+ * Install/uninstall only ever touch entries whose command carries the
+ * `nocville-npc` marker; the user's own hooks are preserved verbatim.
+ */
+/** Marker used to identify nocville-npc hook commands (flat or nested). */
+export const HOOK_MARKER = 'nocville-npc';
+/**
+ * Trailing shell comment appended to hook commands. `/bin/sh` ignores it, but it
+ * guarantees the marker is present for idempotency regardless of install path.
+ */
+export const HOOK_MARKER_COMMENT = '# nocville-npc-hook';
+function isCommandHookWithMarker(hook) {
+    if (!hook ||
+        typeof hook !== 'object' ||
+        typeof hook.command !== 'string')
+        return false;
+    const command = hook.command;
+    if (command.includes(HOOK_MARKER) ||
+        /nocville-hook\.cmd"?\s+(?:claude-code|codex|gemini|cursor)\s+hook\b/.test(command))
+        return true;
+    // Recognize the legacy encoded Windows form so setup replaces it and uninstall removes it.
+    const encoded = /^powershell\.exe -NoProfile -NonInteractive -EncodedCommand ([A-Za-z0-9+/=]+)$/.exec(command);
+    if (!encoded)
+        return false;
+    const decoded = Buffer.from(encoded[1], 'base64').toString('utf16le');
+    return (decoded.startsWith(`& cmd.exe /d /s /c '`) &&
+        decoded.endsWith(` # ${HOOK_MARKER}`) &&
+        /nocville-hook\.cmd" (?:claude-code|codex|gemini|cursor) hook/.test(decoded));
+}
+function isGroup(entry) {
+    return (typeof entry === 'object' &&
+        entry !== null &&
+        Array.isArray(entry.hooks));
+}
+/** Old flat format: a bare command hook (no nested `hooks` array). */
+function isFlatNocvilleEntry(entry) {
+    return !isGroup(entry) && isCommandHookWithMarker(entry);
+}
+/** Strip nocville hooks from one event's entry list. Returns kept entries + removed count. */
+function stripNocville(entries) {
+    const kept = [];
+    let removed = 0;
+    let flat = 0;
+    for (const entry of entries) {
+        if (isFlatNocvilleEntry(entry)) {
+            removed++;
+            flat++;
+            continue;
+        }
+        if (isGroup(entry)) {
+            const keptHooks = entry.hooks.filter((h) => !isCommandHookWithMarker(h));
+            const diff = entry.hooks.length - keptHooks.length;
+            if (diff === 0)
+                kept.push(entry);
+            else {
+                removed += diff;
+                if (keptHooks.length > 0)
+                    kept.push({ ...entry, hooks: keptHooks });
+            }
+            continue;
+        }
+        kept.push(entry);
+    }
+    return { kept, removed, flat };
+}
+/**
+ * Install one nocville hook group into each of `events`. Idempotent: existing
+ * nocville entries (flat legacy or nested) are removed first, preserving the
+ * user's own hooks, then a single group per event is appended. Mutates `file`.
+ */
+export function installHookGroups(file, command, events, extra = {}) {
+    if (!file.hooks || typeof file.hooks !== 'object' || Array.isArray(file.hooks))
+        file.hooks = {};
+    const root = file.hooks;
+    let migrated = 0;
+    let installed = 0;
+    // Drop nocville entries from events we no longer install, too.
+    for (const ev of Object.keys(root)) {
+        if (events.includes(ev) || !Array.isArray(root[ev]))
+            continue;
+        const { kept } = stripNocville(root[ev]);
+        if (kept.length === 0)
+            delete root[ev];
+        else
+            root[ev] = kept;
+    }
+    for (const ev of events) {
+        const existing = Array.isArray(root[ev]) ? root[ev] : [];
+        const { kept, flat } = stripNocville(existing);
+        migrated += flat;
+        const hook = { type: 'command', command };
+        if (extra.timeout !== undefined)
+            hook.timeout = extra.timeout;
+        Object.assign(hook, extra.perEvent?.[ev]);
+        kept.push({ matcher: '', hooks: [hook] });
+        installed++;
+        root[ev] = kept;
+    }
+    return { migrated, installed };
+}
+/** Remove every nocville hook entry. Mutates `file`; returns the count removed. */
+export function removeHookGroups(file) {
+    if (!file.hooks || typeof file.hooks !== 'object')
+        return 0;
+    const root = file.hooks;
+    let removed = 0;
+    for (const ev of Object.keys(root)) {
+        const arr = root[ev];
+        if (!Array.isArray(arr))
+            continue;
+        const res = stripNocville(arr);
+        removed += res.removed;
+        if (res.kept.length === 0)
+            delete root[ev];
+        else
+            root[ev] = res.kept;
+    }
+    if (Object.keys(root).length === 0)
+        delete file.hooks;
+    return removed;
+}
+/** First nocville hook command found in any event (any format). */
+export function findNocvilleCommand(file) {
+    const root = file.hooks;
+    if (!root || typeof root !== 'object')
+        return undefined;
+    for (const ev of Object.keys(root)) {
+        const arr = root[ev];
+        if (!Array.isArray(arr))
+            continue;
+        for (const entry of arr) {
+            if (isFlatNocvilleEntry(entry))
+                return entry.command;
+            if (isGroup(entry)) {
+                const hook = entry.hooks.find(isCommandHookWithMarker);
+                if (hook)
+                    return hook.command;
+            }
+        }
+    }
+    return undefined;
+}
+/** Extract a `--flag` value from a command string; supports `=`, quotes, or the space form. */
+export function extractFlag(command, flag) {
+    const re = new RegExp(`--${flag}(?:=|\\s+)('([^']*)'|"([^"]*)"|([^\\s]+))`);
+    const m = command.match(re);
+    if (!m)
+        return undefined;
+    return m[2] ?? m[3] ?? m[4];
+}
+/** POSIX single-quote a string so /bin/sh treats it as one literal token. */
+export function shellQuote(s) {
+    return `'${s.replace(/'/g, `'\\''`)}'`;
+}
+/**
+ * Absolute hook command: `'<node>' '<cli.js>' <agent> hook # nocville-npc-hook`.
+ *
+ * Agents run hooks via `/bin/sh` without the user's interactive PATH (nvm /
+ * homebrew shims are absent), so a bare `nocville-npc` would fail; absolute
+ * paths fix that. No API key on the command line — the hook reads the saved
+ * user config (~/.config/nocville/config.json).
+ */
+export function buildAgentHookCommand(cliPath, agent, extraArgs = [], nodePath = stableNodePath()) {
+    const args = extraArgs.length ? ' ' + extraArgs.join(' ') : '';
+    return `${shellQuote(nodePath)} ${shellQuote(cliPath)} ${agent} hook${args} ${HOOK_MARKER_COMMENT}`;
+}
+/**
+ * The node binary to bake into hook commands. `process.execPath` is often a
+ * versioned path (e.g. Homebrew's /opt/homebrew/Cellar/node/24.4.1/bin/node)
+ * that disappears on upgrade, so prefer an unversioned PATH entry (e.g.
+ * /opt/homebrew/bin/node) that resolves to the same binary.
+ */
+export function stableNodePath(execPath = process.execPath, pathEnv = process.env['PATH'] ?? '') {
+    let target;
+    try {
+        target = realpathSync(execPath);
+    }
+    catch {
+        return execPath;
+    }
+    const exe = process.platform === 'win32' ? 'node.exe' : 'node';
+    for (const dir of pathEnv.split(delimiter)) {
+        if (!dir || /[\\/]Cellar[\\/]/.test(dir))
+            continue;
+        const candidate = join(dir, exe);
+        try {
+            if (candidate !== execPath && realpathSync(candidate) === target)
+                return candidate;
+        }
+        catch {
+            // not here
+        }
+    }
+    return execPath;
+}
+/** Realpath the running CLI (follows npm bin symlinks). */
+export function resolveCliPath(explicit) {
+    const candidate = explicit ?? process.argv[1];
+    if (candidate) {
+        try {
+            return realpathSync(candidate);
+        }
+        catch {
+            return candidate;
+        }
+    }
+    return 'nocville-npc';
+}
+/** Read a JSON hooks/settings file; missing → {}; unparsable → null (refuse to overwrite). */
+export function readJsonFile(path) {
+    if (!existsSync(path))
+        return {};
+    try {
+        const raw = readFileSync(path, 'utf-8');
+        if (!raw.trim())
+            return {};
+        const parsed = JSON.parse(raw);
+        if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed))
+            return null;
+        return parsed;
+    }
+    catch {
+        return null;
+    }
+}
+/** Write JSON, keeping a one-time `.nocville-backup` of the original file. */
+export function writeJsonFile(path, data) {
+    const backup = `${path}.nocville-backup`;
+    if (existsSync(path) && !existsSync(backup)) {
+        try {
+            copyFileSync(path, backup);
+        }
+        catch {
+            // best effort
+        }
+    }
+    writeFileSync(path, JSON.stringify(data, null, 2) + '\n', 'utf-8');
+}
+export function buildShimHookCommand(agent, platform = process.platform) {
+    if (platform === 'win32') {
+        const shim = `${SHIM_PATH()}.cmd`;
+        if (agent === 'claude-code') {
+            // installHooksInto sets shell: powershell, bypassing Git Bash detection.
+            return `& '${shim.replace(/['‘’‚‛]/g, '$&$&')}' ${agent} hook ${HOOK_MARKER_COMMENT}`;
+        }
+        const payload = `""${shim}" ${agent} hook"`;
+        if (agent === 'gemini') {
+            // Gemini uses PowerShell (7 or 5.1). Stop native-argument parsing so cmd
+            // receives its quotes intact. The newline ends --% before Gemini appends
+            // its own PowerShell exit-code check. No encoded command or policy bypass.
+            return `cmd.exe /d /s /c --% ${payload}\n`;
+        }
+        return `cmd.exe /d /s /c ${payload}`;
+    }
+    return `${shellQuote(SHIM_PATH())} ${agent} hook ${HOOK_MARKER_COMMENT}`;
+}
+//# sourceMappingURL=hook-settings.js.map

package/dist/npcs/agent-common/liveness.d.ts

@@ -0,0 +1,12 @@
+import type { AgentAdapter, AgentSessionState } from './session.js';
+export interface AgentProc {
+    pid: number;
+    startedAt?: number;
+}
+export declare function isAgentAlive(proc: AgentProc): boolean;
+export declare function claudePidFromStore(sessionId: string, dir?: string): AgentProc | null;
+export declare function ancestorPid(names: readonly string[], start?: number, nodeCommandPattern?: RegExp): AgentProc | null;
+export declare function resolveAgentPid(adapter: AgentAdapter, sessionId: string): AgentProc | null;
+/** Reserve under the state lock so simultaneous hooks cannot duplicate PID probes. */
+export declare function reserveAgentPidAttempt(state: AgentSessionState, now: number): boolean;
+//# sourceMappingURL=liveness.d.ts.map

package/dist/npcs/agent-common/liveness.js

@@ -0,0 +1,105 @@
+import { spawnSync } from 'node:child_process';
+import { readFileSync, readdirSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { basename, join } from 'node:path';
+function startTime(pid, timeout = 1000) {
+    if (process.platform === 'win32')
+        return undefined;
+    const out = spawnSync('ps', ['-o', 'lstart=', '-p', String(pid)], {
+        encoding: 'utf8',
+        timeout,
+    });
+    const value = Date.parse(out.stdout?.trim() ?? '');
+    return Number.isFinite(value) ? value : undefined;
+}
+export function isAgentAlive(proc) {
+    if (!Number.isSafeInteger(proc.pid) || proc.pid <= 0)
+        return false;
+    try {
+        process.kill(proc.pid, 0);
+    }
+    catch (error) {
+        return error.code === 'EPERM';
+    }
+    if (!proc.startedAt || process.platform === 'win32')
+        return true;
+    const actual = startTime(proc.pid);
+    return actual === undefined || Math.abs(actual - proc.startedAt) < 120_000;
+}
+export function claudePidFromStore(sessionId, dir = join(homedir(), '.claude', 'sessions')) {
+    try {
+        for (const file of readdirSync(dir)) {
+            if (!/^\d+\.json$/.test(file))
+                continue;
+            try {
+                const data = JSON.parse(readFileSync(join(dir, file), 'utf8'));
+                if (data.sessionId !== sessionId || !Number.isSafeInteger(data.pid) || data.pid <= 0)
+                    continue;
+                const proc = {
+                    pid: data.pid,
+                    startedAt: typeof data.startedAt === 'number' ? data.startedAt : undefined,
+                };
+                if (isAgentAlive(proc))
+                    return proc;
+            }
+            catch {
+                /* incomplete or old sidecar */
+            }
+        }
+    }
+    catch {
+        /* no session store */
+    }
+    return null;
+}
+export function ancestorPid(names, start = process.ppid, nodeCommandPattern) {
+    if (process.platform === 'win32')
+        return null;
+    const deadline = Date.now() + 750;
+    let pid = start;
+    for (let hop = 0; hop < 5 && pid > 1 && Date.now() < deadline; hop++) {
+        const out = spawnSync('ps', ['-o', 'ppid=,comm=', '-p', String(pid)], {
+            encoding: 'utf8',
+            timeout: Math.max(1, deadline - Date.now()),
+        });
+        const match = out.stdout?.trim().match(/^(\d+)\s+(.+)$/);
+        if (!match)
+            return null;
+        const command = basename(match[2]);
+        if (names.includes(command)) {
+            if (command !== 'node')
+                return { pid, startedAt: startTime(pid, Math.max(1, deadline - Date.now())) };
+            if (nodeCommandPattern) {
+                const argv = spawnSync('ps', ['-o', 'command=', '-p', String(pid)], {
+                    encoding: 'utf8',
+                    timeout: Math.max(1, deadline - Date.now()),
+                }).stdout?.trim();
+                if (argv && nodeCommandPattern.test(argv))
+                    return { pid, startedAt: startTime(pid, Math.max(1, deadline - Date.now())) };
+            }
+        }
+        const parent = Number(match[1]);
+        if (parent === pid)
+            return null;
+        pid = parent;
+    }
+    return null;
+}
+export function resolveAgentPid(adapter, sessionId) {
+    if (adapter.processNames?.length === 0)
+        return null;
+    return ((adapter.family === 'claude' ? claudePidFromStore(sessionId) : null) ??
+        ancestorPid(adapter.processNames ?? [adapter.command], process.ppid, adapter.nodeCommandPattern));
+}
+/** Reserve under the state lock so simultaneous hooks cannot duplicate PID probes. */
+export function reserveAgentPidAttempt(state, now) {
+    if (state.agentPid ||
+        state.offline ||
+        (state.agentPidResolveAttempts ?? 0) >= 5 ||
+        (state.agentPidLastResolveAt !== undefined && now - state.agentPidLastResolveAt < 60_000))
+        return false;
+    state.agentPidResolveAttempts = (state.agentPidResolveAttempts ?? 0) + 1;
+    state.agentPidLastResolveAt = now;
+    return true;
+}
+//# sourceMappingURL=liveness.js.map

package/dist/npcs/agent-common/lock.d.ts

@@ -0,0 +1,6 @@
+export declare const LOCK_STALE_MS = 5000;
+export declare const LOCK_WAIT_MS = 2000;
+export declare const LOCK_HARD_STALE_MS = 30000;
+/** Exclusive cross-process lock. A timeout skips the hook; it never permits an unlocked write. */
+export declare function withStateLock<T>(path: string, fn: () => T | Promise<T>, waitMs?: number): Promise<T>;
+//# sourceMappingURL=lock.d.ts.map

package/dist/npcs/agent-common/lock.js

@@ -0,0 +1,95 @@
+import { randomUUID } from 'node:crypto';
+import { closeSync, mkdirSync, openSync, readFileSync, statSync, unlinkSync, writeSync, } from 'node:fs';
+import { dirname } from 'node:path';
+export const LOCK_STALE_MS = 5000;
+export const LOCK_WAIT_MS = 2000;
+export const LOCK_HARD_STALE_MS = 30_000;
+function alive(pid) {
+    if (!Number.isSafeInteger(pid) || pid <= 0)
+        return false;
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        return error.code === 'EPERM';
+    }
+}
+/** Exclusive cross-process lock. A timeout skips the hook; it never permits an unlocked write. */
+export async function withStateLock(path, fn, waitMs = LOCK_WAIT_MS) {
+    mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
+    const lock = `${path}.lock`;
+    const token = `${process.pid}:${randomUUID()}`;
+    const deadline = Date.now() + waitMs;
+    for (;;) {
+        try {
+            const fd = openSync(lock, 'wx', 0o600);
+            try {
+                writeSync(fd, token);
+            }
+            finally {
+                closeSync(fd);
+            }
+            break;
+        }
+        catch (error) {
+            if (error.code !== 'EEXIST')
+                throw error;
+            // Serialize stale reclamation so two waiters cannot unlink each other's new lock.
+            let reaper;
+            try {
+                const reapPath = `${lock}.reap`;
+                try {
+                    const oldToken = readFileSync(reapPath, 'utf8');
+                    if (Date.now() - statSync(reapPath).mtimeMs > LOCK_STALE_MS &&
+                        readFileSync(reapPath, 'utf8') === oldToken)
+                        unlinkSync(reapPath);
+                }
+                catch {
+                    /* no stale reaper */
+                }
+                reaper = openSync(reapPath, 'wx', 0o600);
+                writeSync(reaper, token);
+                const owner = readFileSync(lock, 'utf8');
+                const age = Date.now() - statSync(lock).mtimeMs;
+                // PID reuse cannot block forever. State mutations are synchronous; the separate
+                // delivery lock bounds its HTTP request well below this hard ceiling.
+                if (age > LOCK_HARD_STALE_MS ||
+                    (age > LOCK_STALE_MS && !alive(Number(owner.split(':')[0]))))
+                    unlinkSync(lock);
+            }
+            catch {
+                /* owner released, or another waiter is reclaiming it */
+            }
+            finally {
+                if (reaper !== undefined) {
+                    closeSync(reaper);
+                    try {
+                        if (readFileSync(`${lock}.reap`, 'utf8') === token)
+                            unlinkSync(`${lock}.reap`);
+                    }
+                    catch {
+                        /* stale reaper already removed */
+                    }
+                }
+            }
+            if (Date.now() >= deadline)
+                throw new Error('Session state lock timed out');
+            await new Promise((resolve) => setTimeout(resolve, 10 + Math.random() * 15));
+        }
+    }
+    try {
+        return await fn();
+    }
+    finally {
+        // Never unlink a replacement lock owned by another writer.
+        try {
+            if (readFileSync(lock, 'utf8') === token)
+                unlinkSync(lock);
+        }
+        catch {
+            /* already gone */
+        }
+    }
+}
+//# sourceMappingURL=lock.js.map

package/dist/npcs/agent-common/runtime.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Hooks must point at a cli.js that will still exist tomorrow. When setup runs
+ * from an ephemeral location — `npx @nocville/npc …` executes out of the npm
+ * cache (`~/.npm/_npx/<hash>/…`), which npm may prune at any time — we copy
+ * the package (dist + its `@nocville/node` dependency) into
+ * `~/.config/nocville/runtime/<version>/` and point hooks there instead.
+ */
+/** True when the CLI is running from npm's npx cache (or another temp dir). */
+export declare function isEphemeralCliPath(cliPath: string): boolean;
+/**
+ * Always copy a valid installed runtime, including global installs removed by nvm uninstall.
+ */
+export declare function ensureStableCliPath(cliPath: string, _force?: boolean): string;
+/** Prune only old snapshots, never the active pointer target or unknown directories. */
+export declare function pruneOldRuntimes(runtimeDir: string, now?: number): number;
+//# sourceMappingURL=runtime.d.ts.map

package/dist/npcs/agent-common/runtime.js

@@ -0,0 +1,149 @@
+import { createHash, randomUUID } from 'node:crypto';
+import { cpSync, existsSync, mkdirSync, readFileSync, readdirSync, renameSync, rmSync, statSync, } from 'node:fs';
+import { createRequire } from 'node:module';
+import { dirname, join, sep, resolve } from 'node:path';
+import { userConfigPath } from '../../core/user-config.js';
+/**
+ * Hooks must point at a cli.js that will still exist tomorrow. When setup runs
+ * from an ephemeral location — `npx @nocville/npc …` executes out of the npm
+ * cache (`~/.npm/_npx/<hash>/…`), which npm may prune at any time — we copy
+ * the package (dist + its `@nocville/node` dependency) into
+ * `~/.config/nocville/runtime/<version>/` and point hooks there instead.
+ */
+/** True when the CLI is running from npm's npx cache (or another temp dir). */
+export function isEphemeralCliPath(cliPath) {
+    const p = cliPath.split(sep).join('/');
+    return p.includes('/_npx/') || p.includes('/.pnpm-store/') || p.includes('/dlx-');
+}
+function findPackageRoot(start, name) {
+    let dir = start;
+    for (let i = 0; i < 8; i++) {
+        const pkg = join(dir, 'package.json');
+        if (existsSync(pkg)) {
+            try {
+                const parsed = JSON.parse(readFileSync(pkg, 'utf-8'));
+                if (parsed.name === name)
+                    return dir;
+            }
+            catch {
+                // keep walking
+            }
+        }
+        const parent = dirname(dir);
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    return null;
+}
+function readVersion(root) {
+    try {
+        const parsed = JSON.parse(readFileSync(join(root, 'package.json'), 'utf-8'));
+        return parsed.version ?? '0.0.0';
+    }
+    catch {
+        return '0.0.0';
+    }
+}
+/**
+ * Always copy a valid installed runtime, including global installs removed by nvm uninstall.
+ */
+export function ensureStableCliPath(cliPath, _force = true) {
+    const pkgRoot = findPackageRoot(dirname(cliPath), '@nocville/npc');
+    if (!pkgRoot)
+        return cliPath;
+    let sdkRoot = null;
+    try {
+        const req = createRequire(cliPath);
+        sdkRoot = findPackageRoot(dirname(req.resolve('@nocville/node')), '@nocville/node');
+    }
+    catch {
+        sdkRoot = null;
+    }
+    if (!sdkRoot)
+        return cliPath;
+    const req = createRequire(cliPath);
+    const pngRoot = findPackageRoot(dirname(req.resolve('pngjs')), 'pngjs');
+    if (!pngRoot)
+        throw new Error('Cannot install hook runtime: pngjs is missing');
+    const version = readVersion(pkgRoot);
+    const hash = createHash('sha256');
+    const hashTree = (root) => {
+        for (const entry of readdirSync(root, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name))) {
+            hash.update(entry.name);
+            const path = join(root, entry.name);
+            if (entry.isDirectory())
+                hashTree(path);
+            else if (entry.isFile())
+                hash.update(readFileSync(path));
+        }
+    };
+    for (const root of [pkgRoot, sdkRoot]) {
+        hash.update(readFileSync(join(root, 'package.json')));
+        hashTree(join(root, 'dist'));
+    }
+    hash.update(readFileSync(join(pngRoot, 'package.json')));
+    hashTree(join(pngRoot, 'lib'));
+    // Immutable snapshots also support multiple development builds of one version.
+    // Never remove files a running watchdog or the current pointer may still use.
+    const dest = join(dirname(userConfigPath()), 'runtime', `${version}-${hash.digest('hex').slice(0, 16)}`);
+    if (existsSync(join(dest, 'dist', 'cli.js')))
+        return join(dest, 'dist', 'cli.js');
+    const stage = `${dest}.${randomUUID()}.tmp`;
+    try {
+        mkdirSync(stage, { recursive: true, mode: 0o700 });
+        cpSync(join(pkgRoot, 'package.json'), join(stage, 'package.json'));
+        cpSync(join(pkgRoot, 'dist'), join(stage, 'dist'), { recursive: true });
+        const sdkDest = join(stage, 'node_modules', '@nocville', 'node');
+        mkdirSync(sdkDest, { recursive: true });
+        cpSync(join(sdkRoot, 'package.json'), join(sdkDest, 'package.json'));
+        cpSync(join(sdkRoot, 'dist'), join(sdkDest, 'dist'), { recursive: true });
+        const pngDest = join(stage, 'node_modules', 'pngjs');
+        mkdirSync(pngDest, { recursive: true });
+        cpSync(join(pngRoot, 'package.json'), join(pngDest, 'package.json'));
+        cpSync(join(pngRoot, 'lib'), join(pngDest, 'lib'), { recursive: true });
+        try {
+            renameSync(stage, dest);
+        }
+        catch (error) {
+            if (!existsSync(join(dest, 'dist', 'cli.js')))
+                throw error;
+        }
+        return join(dest, 'dist', 'cli.js');
+    }
+    finally {
+        rmSync(stage, { recursive: true, force: true });
+    }
+}
+/** Prune only old snapshots, never the active pointer target or unknown directories. */
+export function pruneOldRuntimes(runtimeDir, now = Date.now()) {
+    let active;
+    try {
+        const pointer = JSON.parse(readFileSync(join(runtimeDir, 'current.json'), 'utf8'));
+        if (typeof pointer.cli !== 'string')
+            return 0;
+        active = resolve(pointer.cli);
+    }
+    catch {
+        return 0;
+    }
+    let removed = 0;
+    for (const entry of readdirSync(runtimeDir, { withFileTypes: true })) {
+        if (!entry.isDirectory() || !/^\d[^/]*-[a-f0-9]{16}$/.test(entry.name))
+            continue;
+        const path = resolve(runtimeDir, entry.name);
+        if (active === path || active.startsWith(path + sep))
+            continue;
+        try {
+            if (now - statSync(path).mtimeMs <= 7 * 86_400_000)
+                continue;
+            rmSync(path, { recursive: true, force: true });
+            removed++;
+        }
+        catch {
+            /* best-effort maintenance must not break setup */
+        }
+    }
+    return removed;
+}
+//# sourceMappingURL=runtime.js.map