@poolzin/pool-bot 2026.2.20 → 2026.2.22

package/dist/agents/session-write-lock.js

@@ -3,16 +3,26 @@ import fs from "node:fs/promises";
 import path from "node:path";
 import { isPidAlive } from "../shared/pid-alive.js";
 import { resolveProcessScopedMap } from "../shared/process-scoped-map.js";
+const CLEANUP_SIGNALS = ["SIGINT", "SIGTERM", "SIGQUIT", "SIGABRT"];
+const CLEANUP_STATE_KEY = Symbol.for("poolbot.sessionWriteLockCleanupState");
 const HELD_LOCKS_KEY = Symbol.for("poolbot.sessionWriteLockHeldLocks");
 const WATCHDOG_STATE_KEY = Symbol.for("poolbot.sessionWriteLockWatchdogState");
-const CLEANUP_SIGNALS = ["SIGINT", "SIGTERM", "SIGQUIT", "SIGABRT"];
 const DEFAULT_STALE_MS = 30 * 60 * 1000;
 const DEFAULT_MAX_HOLD_MS = 5 * 60 * 1000;
 const DEFAULT_WATCHDOG_INTERVAL_MS = 60_000;
 const DEFAULT_TIMEOUT_GRACE_MS = 2 * 60 * 1000;
 const MAX_LOCK_HOLD_MS = 2_147_000_000;
-const cleanupHandlers = new Map();
 const HELD_LOCKS = resolveProcessScopedMap(HELD_LOCKS_KEY);
+function resolveCleanupState() {
+    const proc = process;
+    if (!proc[CLEANUP_STATE_KEY]) {
+        proc[CLEANUP_STATE_KEY] = {
+            registered: false,
+            cleanupHandlers: new Map(),
+        };
+    }
+    return proc[CLEANUP_STATE_KEY];
+}
 function resolveWatchdogState() {
     const proc = process;
     if (!proc[WATCHDOG_STATE_KEY]) {
@@ -79,11 +89,11 @@ async function releaseHeldLock(normalizedSessionFile, held, opts = {}) {
     })();
     try {
         await held.releasePromise;
+        return true;
     }
     finally {
         held.releasePromise = undefined;
     }
-    return true;
 }
 /**
  * Synchronously release all held locks.
@@ -92,8 +102,8 @@ async function releaseHeldLock(normalizedSessionFile, held, opts = {}) {
 function releaseAllLocksSync() {
     for (const [sessionFile, held] of HELD_LOCKS) {
         try {
-            if (typeof held.handle.fd === "number") {
-                fsSync.closeSync(held.handle.fd);
+            if (typeof held.handle.close === "function") {
+                void held.handle.close().catch(() => { });
             }
         }
         catch {
@@ -108,42 +118,6 @@ function releaseAllLocksSync() {
         HELD_LOCKS.delete(sessionFile);
     }
 }
-let cleanupRegistered = false;
-function handleTerminationSignal(signal) {
-    releaseAllLocksSync();
-    const shouldReraise = process.listenerCount(signal) === 1;
-    if (shouldReraise) {
-        const handler = cleanupHandlers.get(signal);
-        if (handler)
-            process.off(signal, handler);
-        try {
-            process.kill(process.pid, signal);
-        }
-        catch {
-            // Ignore errors during shutdown
-        }
-    }
-}
-function registerCleanupHandlers() {
-    if (cleanupRegistered)
-        return;
-    cleanupRegistered = true;
-    // Cleanup on normal exit and process.exit() calls
-    process.on("exit", () => {
-        releaseAllLocksSync();
-    });
-    // Handle termination signals
-    for (const signal of CLEANUP_SIGNALS) {
-        try {
-            const handler = () => handleTerminationSignal(signal);
-            cleanupHandlers.set(signal, handler);
-            process.on(signal, handler);
-        }
-        catch {
-            // Ignore unsupported signals on this platform.
-        }
-    }
-}
 async function runLockWatchdogCheck(nowMs = Date.now()) {
     let released = 0;
     for (const [sessionFile, held] of HELD_LOCKS.entries()) {
@@ -174,6 +148,49 @@ function ensureWatchdogStarted(intervalMs) {
     }, intervalMs);
     watchdogState.timer.unref?.();
 }
+function handleTerminationSignal(signal) {
+    releaseAllLocksSync();
+    const cleanupState = resolveCleanupState();
+    const shouldReraise = process.listenerCount(signal) === 1;
+    if (shouldReraise) {
+        const handler = cleanupState.cleanupHandlers.get(signal);
+        if (handler) {
+            process.off(signal, handler);
+            cleanupState.cleanupHandlers.delete(signal);
+        }
+        try {
+            process.kill(process.pid, signal);
+        }
+        catch {
+            // Ignore errors during shutdown
+        }
+    }
+}
+function registerCleanupHandlers() {
+    const cleanupState = resolveCleanupState();
+    if (!cleanupState.registered) {
+        cleanupState.registered = true;
+        // Cleanup on normal exit and process.exit() calls
+        process.on("exit", () => {
+            releaseAllLocksSync();
+        });
+    }
+    ensureWatchdogStarted(DEFAULT_WATCHDOG_INTERVAL_MS);
+    // Handle termination signals
+    for (const signal of CLEANUP_SIGNALS) {
+        if (cleanupState.cleanupHandlers.has(signal)) {
+            continue;
+        }
+        try {
+            const handler = () => handleTerminationSignal(signal);
+            cleanupState.cleanupHandlers.set(signal, handler);
+            process.on(signal, handler);
+        }
+        catch {
+            // Ignore unsupported signals on this platform.
+        }
+    }
+}
 async function readLockPayload(lockPath) {
     try {
         const raw = await fs.readFile(lockPath, "utf8");
@@ -261,7 +278,6 @@ export async function cleanStaleLockFiles(params) {
 }
 export async function acquireSessionWriteLock(params) {
     registerCleanupHandlers();
-    ensureWatchdogStarted(DEFAULT_WATCHDOG_INTERVAL_MS);
     const timeoutMs = resolvePositiveMs(params.timeoutMs, 10_000, { allowInfinity: true });
     const staleMs = resolvePositiveMs(params.staleMs, DEFAULT_STALE_MS);
     const maxHoldMs = resolvePositiveMs(params.maxHoldMs, DEFAULT_MAX_HOLD_MS);
@@ -277,8 +293,9 @@ export async function acquireSessionWriteLock(params) {
     }
     const normalizedSessionFile = path.join(normalizedDir, path.basename(sessionFile));
     const lockPath = `${normalizedSessionFile}.lock`;
+    const allowReentrant = params.allowReentrant ?? true;
     const held = HELD_LOCKS.get(normalizedSessionFile);
-    if (held) {
+    if (allowReentrant && held) {
         held.count += 1;
         return {
             release: async () => {
@@ -310,8 +327,9 @@ export async function acquireSessionWriteLock(params) {
         }
         catch (err) {
             const code = err.code;
-            if (code !== "EEXIST")
+            if (code !== "EEXIST") {
                 throw err;
+            }
             const payload = await readLockPayload(lockPath);
             const inspected = inspectLockPayload(payload, staleMs, Date.now());
             if (inspected.stale) {

package/dist/agents/skills/frontmatter.js

@@ -1,118 +1,79 @@
-import JSON5 from "json5";
-import { LEGACY_MANIFEST_KEY } from "../../compat/legacy-names.js";
 import { parseFrontmatterBlock } from "../../markdown/frontmatter.js";
-import { parseBooleanValue } from "../../utils/boolean.js";
+import { getFrontmatterString, normalizeStringList, parsePoolbotManifestInstallBase, parseFrontmatterBool, resolvePoolbotManifestBlock, resolvePoolbotManifestInstall, resolvePoolbotManifestOs, resolvePoolbotManifestRequires, } from "../../shared/frontmatter.js";
 export function parseFrontmatter(content) {
     return parseFrontmatterBlock(content);
 }
-function normalizeStringList(input) {
-    if (!input)
-        return [];
-    if (Array.isArray(input)) {
-        return input.map((value) => String(value).trim()).filter(Boolean);
-    }
-    if (typeof input === "string") {
-        return input
-            .split(",")
-            .map((value) => value.trim())
-            .filter(Boolean);
-    }
-    return [];
-}
 function parseInstallSpec(input) {
-    if (!input || typeof input !== "object")
-        return undefined;
-    const raw = input;
-    const kindRaw = typeof raw.kind === "string" ? raw.kind : typeof raw.type === "string" ? raw.type : "";
-    const kind = kindRaw.trim().toLowerCase();
-    if (kind !== "brew" && kind !== "node" && kind !== "go" && kind !== "uv" && kind !== "download") {
+    const parsed = parsePoolbotManifestInstallBase(input, ["brew", "node", "go", "uv", "download"]);
+    if (!parsed) {
         return undefined;
     }
+    const { raw } = parsed;
     const spec = {
-        kind: kind,
+        kind: parsed.kind,
     };
-    if (typeof raw.id === "string")
-        spec.id = raw.id;
-    if (typeof raw.label === "string")
-        spec.label = raw.label;
-    const bins = normalizeStringList(raw.bins);
-    if (bins.length > 0)
-        spec.bins = bins;
+    if (parsed.id) {
+        spec.id = parsed.id;
+    }
+    if (parsed.label) {
+        spec.label = parsed.label;
+    }
+    if (parsed.bins) {
+        spec.bins = parsed.bins;
+    }
     const osList = normalizeStringList(raw.os);
-    if (osList.length > 0)
+    if (osList.length > 0) {
         spec.os = osList;
-    if (typeof raw.formula === "string")
+    }
+    if (typeof raw.formula === "string") {
         spec.formula = raw.formula;
-    if (typeof raw.package === "string")
+    }
+    if (typeof raw.package === "string") {
         spec.package = raw.package;
-    if (typeof raw.module === "string")
+    }
+    if (typeof raw.module === "string") {
         spec.module = raw.module;
-    if (typeof raw.url === "string")
+    }
+    if (typeof raw.url === "string") {
         spec.url = raw.url;
-    if (typeof raw.archive === "string")
+    }
+    if (typeof raw.archive === "string") {
         spec.archive = raw.archive;
-    if (typeof raw.extract === "boolean")
+    }
+    if (typeof raw.extract === "boolean") {
         spec.extract = raw.extract;
-    if (typeof raw.stripComponents === "number")
+    }
+    if (typeof raw.stripComponents === "number") {
         spec.stripComponents = raw.stripComponents;
-    if (typeof raw.targetDir === "string")
+    }
+    if (typeof raw.targetDir === "string") {
         spec.targetDir = raw.targetDir;
+    }
     return spec;
 }
-function getFrontmatterValue(frontmatter, key) {
-    const raw = frontmatter[key];
-    return typeof raw === "string" ? raw : undefined;
-}
-function parseFrontmatterBool(value, fallback) {
-    const parsed = parseBooleanValue(value);
-    return parsed === undefined ? fallback : parsed;
-}
 export function resolvePoolbotMetadata(frontmatter) {
-    const raw = getFrontmatterValue(frontmatter, "metadata");
-    if (!raw)
-        return undefined;
-    try {
-        const parsed = JSON5.parse(raw);
-        if (!parsed || typeof parsed !== "object")
-            return undefined;
-        const metadataRaw = parsed.poolbot ?? parsed[LEGACY_MANIFEST_KEY];
-        if (!metadataRaw || typeof metadataRaw !== "object")
-            return undefined;
-        const metadataObj = metadataRaw;
-        const requiresRaw = typeof metadataObj.requires === "object" && metadataObj.requires !== null
-            ? metadataObj.requires
-            : undefined;
-        const installRaw = Array.isArray(metadataObj.install) ? metadataObj.install : [];
-        const install = installRaw
-            .map((entry) => parseInstallSpec(entry))
-            .filter((entry) => Boolean(entry));
-        const osRaw = normalizeStringList(metadataObj.os);
-        return {
-            always: typeof metadataObj.always === "boolean" ? metadataObj.always : undefined,
-            emoji: typeof metadataObj.emoji === "string" ? metadataObj.emoji : undefined,
-            homepage: typeof metadataObj.homepage === "string" ? metadataObj.homepage : undefined,
-            skillKey: typeof metadataObj.skillKey === "string" ? metadataObj.skillKey : undefined,
-            primaryEnv: typeof metadataObj.primaryEnv === "string" ? metadataObj.primaryEnv : undefined,
-            os: osRaw.length > 0 ? osRaw : undefined,
-            requires: requiresRaw
-                ? {
-                    bins: normalizeStringList(requiresRaw.bins),
-                    anyBins: normalizeStringList(requiresRaw.anyBins),
-                    env: normalizeStringList(requiresRaw.env),
-                    config: normalizeStringList(requiresRaw.config),
-                }
-                : undefined,
-            install: install.length > 0 ? install : undefined,
-        };
-    }
-    catch {
+    const metadataObj = resolvePoolbotManifestBlock({ frontmatter });
+    if (!metadataObj) {
         return undefined;
     }
+    const requires = resolvePoolbotManifestRequires(metadataObj);
+    const install = resolvePoolbotManifestInstall(metadataObj, parseInstallSpec);
+    const osRaw = resolvePoolbotManifestOs(metadataObj);
+    return {
+        always: typeof metadataObj.always === "boolean" ? metadataObj.always : undefined,
+        emoji: typeof metadataObj.emoji === "string" ? metadataObj.emoji : undefined,
+        homepage: typeof metadataObj.homepage === "string" ? metadataObj.homepage : undefined,
+        skillKey: typeof metadataObj.skillKey === "string" ? metadataObj.skillKey : undefined,
+        primaryEnv: typeof metadataObj.primaryEnv === "string" ? metadataObj.primaryEnv : undefined,
+        os: osRaw.length > 0 ? osRaw : undefined,
+        requires: requires,
+        install: install.length > 0 ? install : undefined,
+    };
 }
 export function resolveSkillInvocationPolicy(frontmatter) {
     return {
-        userInvocable: parseFrontmatterBool(getFrontmatterValue(frontmatter, "user-invocable"), true),
-        disableModelInvocation: parseFrontmatterBool(getFrontmatterValue(frontmatter, "disable-model-invocation"), false),
+        userInvocable: parseFrontmatterBool(getFrontmatterString(frontmatter, "user-invocable"), true),
+        disableModelInvocation: parseFrontmatterBool(getFrontmatterString(frontmatter, "disable-model-invocation"), false),
     };
 }
 export function resolveSkillKey(skill, entry) {