@nocville/npc 0.0.0-stage → 0.2.1

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

@@ -0,0 +1,112 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isAgentAlive = isAgentAlive;
+exports.claudePidFromStore = claudePidFromStore;
+exports.ancestorPid = ancestorPid;
+exports.resolveAgentPid = resolveAgentPid;
+exports.reserveAgentPidAttempt = reserveAgentPidAttempt;
+const node_child_process_1 = require("node:child_process");
+const node_fs_1 = require("node:fs");
+const node_os_1 = require("node:os");
+const node_path_1 = require("node:path");
+function startTime(pid, timeout = 1000) {
+    if (process.platform === 'win32')
+        return undefined;
+    const out = (0, node_child_process_1.spawnSync)('ps', ['-o', 'lstart=', '-p', String(pid)], {
+        encoding: 'utf8',
+        timeout,
+    });
+    const value = Date.parse(out.stdout?.trim() ?? '');
+    return Number.isFinite(value) ? value : undefined;
+}
+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;
+}
+function claudePidFromStore(sessionId, dir = (0, node_path_1.join)((0, node_os_1.homedir)(), '.claude', 'sessions')) {
+    try {
+        for (const file of (0, node_fs_1.readdirSync)(dir)) {
+            if (!/^\d+\.json$/.test(file))
+                continue;
+            try {
+                const data = JSON.parse((0, node_fs_1.readFileSync)((0, node_path_1.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;
+}
+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 = (0, node_child_process_1.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 = (0, node_path_1.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 = (0, node_child_process_1.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;
+}
+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. */
+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/cjs/npcs/agent-common/lock.js

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LOCK_HARD_STALE_MS = exports.LOCK_WAIT_MS = exports.LOCK_STALE_MS = void 0;
+exports.withStateLock = withStateLock;
+const node_crypto_1 = require("node:crypto");
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+exports.LOCK_STALE_MS = 5000;
+exports.LOCK_WAIT_MS = 2000;
+exports.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. */
+async function withStateLock(path, fn, waitMs = exports.LOCK_WAIT_MS) {
+    (0, node_fs_1.mkdirSync)((0, node_path_1.dirname)(path), { recursive: true, mode: 0o700 });
+    const lock = `${path}.lock`;
+    const token = `${process.pid}:${(0, node_crypto_1.randomUUID)()}`;
+    const deadline = Date.now() + waitMs;
+    for (;;) {
+        try {
+            const fd = (0, node_fs_1.openSync)(lock, 'wx', 0o600);
+            try {
+                (0, node_fs_1.writeSync)(fd, token);
+            }
+            finally {
+                (0, node_fs_1.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 = (0, node_fs_1.readFileSync)(reapPath, 'utf8');
+                    if (Date.now() - (0, node_fs_1.statSync)(reapPath).mtimeMs > exports.LOCK_STALE_MS &&
+                        (0, node_fs_1.readFileSync)(reapPath, 'utf8') === oldToken)
+                        (0, node_fs_1.unlinkSync)(reapPath);
+                }
+                catch {
+                    /* no stale reaper */
+                }
+                reaper = (0, node_fs_1.openSync)(reapPath, 'wx', 0o600);
+                (0, node_fs_1.writeSync)(reaper, token);
+                const owner = (0, node_fs_1.readFileSync)(lock, 'utf8');
+                const age = Date.now() - (0, node_fs_1.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 > exports.LOCK_HARD_STALE_MS ||
+                    (age > exports.LOCK_STALE_MS && !alive(Number(owner.split(':')[0]))))
+                    (0, node_fs_1.unlinkSync)(lock);
+            }
+            catch {
+                /* owner released, or another waiter is reclaiming it */
+            }
+            finally {
+                if (reaper !== undefined) {
+                    (0, node_fs_1.closeSync)(reaper);
+                    try {
+                        if ((0, node_fs_1.readFileSync)(`${lock}.reap`, 'utf8') === token)
+                            (0, node_fs_1.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 ((0, node_fs_1.readFileSync)(lock, 'utf8') === token)
+                (0, node_fs_1.unlinkSync)(lock);
+        }
+        catch {
+            /* already gone */
+        }
+    }
+}
+//# sourceMappingURL=lock.js.map

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

@@ -0,0 +1,154 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isEphemeralCliPath = isEphemeralCliPath;
+exports.ensureStableCliPath = ensureStableCliPath;
+exports.pruneOldRuntimes = pruneOldRuntimes;
+const node_crypto_1 = require("node:crypto");
+const node_fs_1 = require("node:fs");
+const node_module_1 = require("node:module");
+const node_path_1 = require("node:path");
+const user_config_js_1 = require("../../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). */
+function isEphemeralCliPath(cliPath) {
+    const p = cliPath.split(node_path_1.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 = (0, node_path_1.join)(dir, 'package.json');
+        if ((0, node_fs_1.existsSync)(pkg)) {
+            try {
+                const parsed = JSON.parse((0, node_fs_1.readFileSync)(pkg, 'utf-8'));
+                if (parsed.name === name)
+                    return dir;
+            }
+            catch {
+                // keep walking
+            }
+        }
+        const parent = (0, node_path_1.dirname)(dir);
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    return null;
+}
+function readVersion(root) {
+    try {
+        const parsed = JSON.parse((0, node_fs_1.readFileSync)((0, node_path_1.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.
+ */
+function ensureStableCliPath(cliPath, _force = true) {
+    const pkgRoot = findPackageRoot((0, node_path_1.dirname)(cliPath), '@nocville/npc');
+    if (!pkgRoot)
+        return cliPath;
+    let sdkRoot = null;
+    try {
+        const req = (0, node_module_1.createRequire)(cliPath);
+        sdkRoot = findPackageRoot((0, node_path_1.dirname)(req.resolve('@nocville/node')), '@nocville/node');
+    }
+    catch {
+        sdkRoot = null;
+    }
+    if (!sdkRoot)
+        return cliPath;
+    const req = (0, node_module_1.createRequire)(cliPath);
+    const pngRoot = findPackageRoot((0, node_path_1.dirname)(req.resolve('pngjs')), 'pngjs');
+    if (!pngRoot)
+        throw new Error('Cannot install hook runtime: pngjs is missing');
+    const version = readVersion(pkgRoot);
+    const hash = (0, node_crypto_1.createHash)('sha256');
+    const hashTree = (root) => {
+        for (const entry of (0, node_fs_1.readdirSync)(root, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name))) {
+            hash.update(entry.name);
+            const path = (0, node_path_1.join)(root, entry.name);
+            if (entry.isDirectory())
+                hashTree(path);
+            else if (entry.isFile())
+                hash.update((0, node_fs_1.readFileSync)(path));
+        }
+    };
+    for (const root of [pkgRoot, sdkRoot]) {
+        hash.update((0, node_fs_1.readFileSync)((0, node_path_1.join)(root, 'package.json')));
+        hashTree((0, node_path_1.join)(root, 'dist'));
+    }
+    hash.update((0, node_fs_1.readFileSync)((0, node_path_1.join)(pngRoot, 'package.json')));
+    hashTree((0, node_path_1.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 = (0, node_path_1.join)((0, node_path_1.dirname)((0, user_config_js_1.userConfigPath)()), 'runtime', `${version}-${hash.digest('hex').slice(0, 16)}`);
+    if ((0, node_fs_1.existsSync)((0, node_path_1.join)(dest, 'dist', 'cli.js')))
+        return (0, node_path_1.join)(dest, 'dist', 'cli.js');
+    const stage = `${dest}.${(0, node_crypto_1.randomUUID)()}.tmp`;
+    try {
+        (0, node_fs_1.mkdirSync)(stage, { recursive: true, mode: 0o700 });
+        (0, node_fs_1.cpSync)((0, node_path_1.join)(pkgRoot, 'package.json'), (0, node_path_1.join)(stage, 'package.json'));
+        (0, node_fs_1.cpSync)((0, node_path_1.join)(pkgRoot, 'dist'), (0, node_path_1.join)(stage, 'dist'), { recursive: true });
+        const sdkDest = (0, node_path_1.join)(stage, 'node_modules', '@nocville', 'node');
+        (0, node_fs_1.mkdirSync)(sdkDest, { recursive: true });
+        (0, node_fs_1.cpSync)((0, node_path_1.join)(sdkRoot, 'package.json'), (0, node_path_1.join)(sdkDest, 'package.json'));
+        (0, node_fs_1.cpSync)((0, node_path_1.join)(sdkRoot, 'dist'), (0, node_path_1.join)(sdkDest, 'dist'), { recursive: true });
+        const pngDest = (0, node_path_1.join)(stage, 'node_modules', 'pngjs');
+        (0, node_fs_1.mkdirSync)(pngDest, { recursive: true });
+        (0, node_fs_1.cpSync)((0, node_path_1.join)(pngRoot, 'package.json'), (0, node_path_1.join)(pngDest, 'package.json'));
+        (0, node_fs_1.cpSync)((0, node_path_1.join)(pngRoot, 'lib'), (0, node_path_1.join)(pngDest, 'lib'), { recursive: true });
+        try {
+            (0, node_fs_1.renameSync)(stage, dest);
+        }
+        catch (error) {
+            if (!(0, node_fs_1.existsSync)((0, node_path_1.join)(dest, 'dist', 'cli.js')))
+                throw error;
+        }
+        return (0, node_path_1.join)(dest, 'dist', 'cli.js');
+    }
+    finally {
+        (0, node_fs_1.rmSync)(stage, { recursive: true, force: true });
+    }
+}
+/** Prune only old snapshots, never the active pointer target or unknown directories. */
+function pruneOldRuntimes(runtimeDir, now = Date.now()) {
+    let active;
+    try {
+        const pointer = JSON.parse((0, node_fs_1.readFileSync)((0, node_path_1.join)(runtimeDir, 'current.json'), 'utf8'));
+        if (typeof pointer.cli !== 'string')
+            return 0;
+        active = (0, node_path_1.resolve)(pointer.cli);
+    }
+    catch {
+        return 0;
+    }
+    let removed = 0;
+    for (const entry of (0, node_fs_1.readdirSync)(runtimeDir, { withFileTypes: true })) {
+        if (!entry.isDirectory() || !/^\d[^/]*-[a-f0-9]{16}$/.test(entry.name))
+            continue;
+        const path = (0, node_path_1.resolve)(runtimeDir, entry.name);
+        if (active === path || active.startsWith(path + node_path_1.sep))
+            continue;
+        try {
+            if (now - (0, node_fs_1.statSync)(path).mtimeMs <= 7 * 86_400_000)
+                continue;
+            (0, node_fs_1.rmSync)(path, { recursive: true, force: true });
+            removed++;
+        }
+        catch {
+            /* best-effort maintenance must not break setup */
+        }
+    }
+    return removed;
+}
+//# sourceMappingURL=runtime.js.map