@poolzin/pool-bot 2026.2.21 → 2026.2.23

package/dist/daemon/inspect.js

@@ -1,12 +1,10 @@
-import { execFile } from "node:child_process";
 import fs from "node:fs/promises";
 import path from "node:path";
-import { promisify } from "node:util";
-import { GATEWAY_SERVICE_KIND, GATEWAY_SERVICE_MARKER, LEGACY_GATEWAY_LAUNCH_AGENT_LABELS, LEGACY_GATEWAY_SYSTEMD_SERVICE_NAMES, LEGACY_GATEWAY_WINDOWS_TASK_NAMES, resolveGatewayLaunchAgentLabel, resolveGatewaySystemdServiceName, resolveGatewayWindowsTaskName, } from "./constants.js";
-const EXTRA_MARKERS = ["poolbot"];
-const execFileAsync = promisify(execFile);
+import { GATEWAY_SERVICE_KIND, GATEWAY_SERVICE_MARKER, resolveGatewayLaunchAgentLabel, resolveGatewaySystemdServiceName, resolveGatewayWindowsTaskName, } from "./constants.js";
+import { execSchtasks } from "./schtasks-exec.js";
+const EXTRA_MARKERS = ["poolbot", "clawdbot", "moltbot"];
 export function renderGatewayServiceCleanupHints(env = process.env) {
-    const profile = env.POOLBOT_PROFILE || env.CLAWDBOT_PROFILE;
+    const profile = env.POOLBOT_PROFILE;
     switch (process.platform) {
         case "darwin": {
             const label = resolveGatewayLaunchAgentLabel(profile);
@@ -29,127 +27,173 @@ export function renderGatewayServiceCleanupHints(env = process.env) {
 }
 function resolveHomeDir(env) {
     const home = env.HOME?.trim() || env.USERPROFILE?.trim();
-    if (!home)
+    if (!home) {
         throw new Error("Missing HOME");
+    }
     return home;
 }
-function containsMarker(content) {
+function detectMarker(content) {
     const lower = content.toLowerCase();
-    return EXTRA_MARKERS.some((marker) => lower.includes(marker));
+    for (const marker of EXTRA_MARKERS) {
+        if (lower.includes(marker)) {
+            return marker;
+        }
+    }
+    return null;
 }
 function hasGatewayServiceMarker(content) {
     const lower = content.toLowerCase();
-    return (lower.includes("poolbot_service_marker") &&
-        lower.includes(GATEWAY_SERVICE_MARKER.toLowerCase()) &&
-        lower.includes("poolbot_service_kind") &&
+    const markerKeys = ["poolbot_service_marker"];
+    const kindKeys = ["poolbot_service_kind"];
+    const markerValues = [GATEWAY_SERVICE_MARKER.toLowerCase()];
+    const hasMarkerKey = markerKeys.some((key) => lower.includes(key));
+    const hasKindKey = kindKeys.some((key) => lower.includes(key));
+    const hasMarkerValue = markerValues.some((value) => lower.includes(value));
+    return (hasMarkerKey &&
+        hasKindKey &&
+        hasMarkerValue &&
         lower.includes(GATEWAY_SERVICE_KIND.toLowerCase()));
 }
-function isPoolbotGatewayLaunchdService(label, contents) {
-    if (hasGatewayServiceMarker(contents))
+function isPoolBotGatewayLaunchdService(label, contents) {
+    if (hasGatewayServiceMarker(contents)) {
         return true;
+    }
     const lowerContents = contents.toLowerCase();
-    if (!lowerContents.includes("gateway"))
+    if (!lowerContents.includes("gateway")) {
         return false;
-    return label.startsWith("com.poolbot.");
+    }
+    return label.startsWith("ai.poolbot.");
 }
-function isPoolbotGatewaySystemdService(name, contents) {
-    if (hasGatewayServiceMarker(contents))
+function isPoolBotGatewaySystemdService(name, contents) {
+    if (hasGatewayServiceMarker(contents)) {
         return true;
-    if (!name.startsWith("poolbot-gateway"))
+    }
+    if (!name.startsWith("poolbot-gateway")) {
         return false;
+    }
     return contents.toLowerCase().includes("gateway");
 }
-function isPoolbotGatewayTaskName(name) {
+function isPoolBotGatewayTaskName(name) {
     const normalized = name.trim().toLowerCase();
-    if (!normalized)
+    if (!normalized) {
         return false;
+    }
     const defaultName = resolveGatewayWindowsTaskName().toLowerCase();
     return normalized === defaultName || normalized.startsWith("poolbot gateway");
 }
 function tryExtractPlistLabel(contents) {
     const match = contents.match(/<key>Label<\/key>\s*<string>([\s\S]*?)<\/string>/i);
-    if (!match)
+    if (!match) {
         return null;
+    }
     return match[1]?.trim() || null;
 }
 function isIgnoredLaunchdLabel(label) {
-    return (label === resolveGatewayLaunchAgentLabel() || LEGACY_GATEWAY_LAUNCH_AGENT_LABELS.includes(label));
+    return label === resolveGatewayLaunchAgentLabel();
 }
 function isIgnoredSystemdName(name) {
-    return (name === resolveGatewaySystemdServiceName() ||
-        LEGACY_GATEWAY_SYSTEMD_SERVICE_NAMES.includes(name));
+    return name === resolveGatewaySystemdServiceName();
 }
-async function scanLaunchdDir(params) {
-    const results = [];
-    let entries = [];
+function isLegacyLabel(label) {
+    const lower = label.toLowerCase();
+    return lower.includes("clawdbot") || lower.includes("moltbot");
+}
+async function readDirEntries(dir) {
     try {
-        entries = await fs.readdir(params.dir);
+        return await fs.readdir(dir);
     }
     catch {
-        return results;
+        return [];
+    }
+}
+async function readUtf8File(filePath) {
+    try {
+        return await fs.readFile(filePath, "utf8");
+    }
+    catch {
+        return null;
     }
+}
+async function scanLaunchdDir(params) {
+    const results = [];
+    const entries = await readDirEntries(params.dir);
     for (const entry of entries) {
-        if (!entry.endsWith(".plist"))
+        if (!entry.endsWith(".plist")) {
             continue;
+        }
         const labelFromName = entry.replace(/\.plist$/, "");
-        if (isIgnoredLaunchdLabel(labelFromName))
+        if (isIgnoredLaunchdLabel(labelFromName)) {
             continue;
-        const fullPath = path.join(params.dir, entry);
-        let contents = "";
-        try {
-            contents = await fs.readFile(fullPath, "utf8");
         }
-        catch {
+        const fullPath = path.join(params.dir, entry);
+        const contents = await readUtf8File(fullPath);
+        if (contents === null) {
             continue;
         }
-        if (!containsMarker(contents))
-            continue;
+        const marker = detectMarker(contents);
         const label = tryExtractPlistLabel(contents) ?? labelFromName;
-        if (isIgnoredLaunchdLabel(label))
+        if (!marker) {
+            const legacyLabel = isLegacyLabel(labelFromName) || isLegacyLabel(label);
+            if (!legacyLabel) {
+                continue;
+            }
+            results.push({
+                platform: "darwin",
+                label,
+                detail: `plist: ${fullPath}`,
+                scope: params.scope,
+                marker: isLegacyLabel(label) ? "clawdbot" : "moltbot",
+                legacy: true,
+            });
+            continue;
+        }
+        if (isIgnoredLaunchdLabel(label)) {
             continue;
-        if (isPoolbotGatewayLaunchdService(label, contents))
+        }
+        if (marker === "poolbot" && isPoolBotGatewayLaunchdService(label, contents)) {
             continue;
+        }
         results.push({
             platform: "darwin",
             label,
             detail: `plist: ${fullPath}`,
             scope: params.scope,
+            marker,
+            legacy: marker !== "poolbot" || isLegacyLabel(label),
         });
     }
     return results;
 }
 async function scanSystemdDir(params) {
     const results = [];
-    let entries = [];
-    try {
-        entries = await fs.readdir(params.dir);
-    }
-    catch {
-        return results;
-    }
+    const entries = await readDirEntries(params.dir);
     for (const entry of entries) {
-        if (!entry.endsWith(".service"))
+        if (!entry.endsWith(".service")) {
             continue;
+        }
         const name = entry.replace(/\.service$/, "");
-        if (isIgnoredSystemdName(name))
+        if (isIgnoredSystemdName(name)) {
             continue;
-        const fullPath = path.join(params.dir, entry);
-        let contents = "";
-        try {
-            contents = await fs.readFile(fullPath, "utf8");
         }
-        catch {
+        const fullPath = path.join(params.dir, entry);
+        const contents = await readUtf8File(fullPath);
+        if (contents === null) {
             continue;
         }
-        if (!containsMarker(contents))
+        const marker = detectMarker(contents);
+        if (!marker) {
             continue;
-        if (isPoolbotGatewaySystemdService(name, contents))
+        }
+        if (marker === "poolbot" && isPoolBotGatewaySystemdService(name, contents)) {
             continue;
+        }
         results.push({
             platform: "linux",
             label: entry,
             detail: `unit: ${fullPath}`,
             scope: params.scope,
+            marker,
+            legacy: marker !== "poolbot",
         });
     }
     return results;
@@ -167,56 +211,41 @@ function parseSchtasksList(output) {
             continue;
         }
         const idx = line.indexOf(":");
-        if (idx <= 0)
+        if (idx <= 0) {
             continue;
+        }
         const key = line.slice(0, idx).trim().toLowerCase();
         const value = line.slice(idx + 1).trim();
-        if (!value)
+        if (!value) {
             continue;
+        }
         if (key === "taskname") {
-            if (current)
+            if (current) {
                 tasks.push(current);
+            }
             current = { name: value };
             continue;
         }
-        if (!current)
+        if (!current) {
             continue;
+        }
         if (key === "task to run") {
             current.taskToRun = value;
         }
     }
-    if (current)
+    if (current) {
         tasks.push(current);
-    return tasks;
-}
-async function execSchtasks(args) {
-    try {
-        const { stdout, stderr } = await execFileAsync("schtasks", args, {
-            encoding: "utf8",
-            windowsHide: true,
-        });
-        return {
-            stdout: String(stdout ?? ""),
-            stderr: String(stderr ?? ""),
-            code: 0,
-        };
-    }
-    catch (error) {
-        const e = error;
-        return {
-            stdout: typeof e.stdout === "string" ? e.stdout : "",
-            stderr: typeof e.stderr === "string" ? e.stderr : typeof e.message === "string" ? e.message : "",
-            code: typeof e.code === "number" ? e.code : 1,
-        };
     }
+    return tasks;
 }
 export async function findExtraGatewayServices(env, opts = {}) {
     const results = [];
     const seen = new Set();
     const push = (svc) => {
         const key = `${svc.platform}:${svc.label}:${svc.detail}:${svc.scope}`;
-        if (seen.has(key))
+        if (seen.has(key)) {
             return;
+        }
         seen.add(key);
         results.push(svc);
     };
@@ -281,30 +310,41 @@ export async function findExtraGatewayServices(env, opts = {}) {
         return results;
     }
     if (process.platform === "win32") {
-        if (!opts.deep)
+        if (!opts.deep) {
             return results;
+        }
         const res = await execSchtasks(["/Query", "/FO", "LIST", "/V"]);
-        if (res.code !== 0)
+        if (res.code !== 0) {
             return results;
+        }
         const tasks = parseSchtasksList(res.stdout);
         for (const task of tasks) {
             const name = task.name.trim();
-            if (!name)
+            if (!name) {
                 continue;
-            if (isPoolbotGatewayTaskName(name))
-                continue;
-            if (LEGACY_GATEWAY_WINDOWS_TASK_NAMES.includes(name))
+            }
+            if (isPoolBotGatewayTaskName(name)) {
                 continue;
+            }
             const lowerName = name.toLowerCase();
             const lowerCommand = task.taskToRun?.toLowerCase() ?? "";
-            const matches = EXTRA_MARKERS.some((marker) => lowerName.includes(marker) || lowerCommand.includes(marker));
-            if (!matches)
+            let marker = null;
+            for (const candidate of EXTRA_MARKERS) {
+                if (lowerName.includes(candidate) || lowerCommand.includes(candidate)) {
+                    marker = candidate;
+                    break;
+                }
+            }
+            if (!marker) {
                 continue;
+            }
             push({
                 platform: "win32",
                 label: name,
                 detail: task.taskToRun ? `task: ${name}, run: ${task.taskToRun}` : name,
                 scope: "system",
+                marker,
+                legacy: marker !== "poolbot",
             });
         }
         return results;

package/dist/daemon/runtime-paths.js

@@ -16,6 +16,11 @@ const VERSION_MANAGER_MARKERS = [
 function getPathModule(platform) {
     return platform === "win32" ? path.win32 : path.posix;
 }
+function isNodeExecPath(execPath, platform) {
+    const pathModule = getPathModule(platform);
+    const base = pathModule.basename(execPath).toLowerCase();
+    return base === "node" || base === "node.exe";
+}
 function normalizeForCompare(input, platform) {
     const pathModule = getPathModule(platform);
     const normalized = pathModule.normalize(input).replaceAll("\\", "/");
@@ -83,8 +88,9 @@ export async function resolveSystemNodeInfo(params) {
     const env = params.env ?? process.env;
     const platform = params.platform ?? process.platform;
     const systemNode = await resolveSystemNodePath(env, platform);
-    if (!systemNode)
+    if (!systemNode) {
         return null;
+    }
     const version = await resolveNodeVersion(systemNode, params.execFile ?? execFileAsync);
     return {
         path: systemNode,
@@ -93,17 +99,32 @@ export async function resolveSystemNodeInfo(params) {
     };
 }
 export function renderSystemNodeWarning(systemNode, selectedNodePath) {
-    if (!systemNode || systemNode.supported)
+    if (!systemNode || systemNode.supported) {
         return null;
+    }
     const versionLabel = systemNode.version ?? "unknown";
     const selectedLabel = selectedNodePath ? ` Using ${selectedNodePath} for the daemon.` : "";
     return `System Node ${versionLabel} at ${systemNode.path} is below the required Node 22+.${selectedLabel} Install Node 22+ from nodejs.org or Homebrew.`;
 }
 export async function resolvePreferredNodePath(params) {
-    if (params.runtime !== "node")
+    if (params.runtime !== "node") {
         return undefined;
+    }
+    // Prefer the node that is currently running `poolbot gateway install`.
+    // This respects the user's active version manager (fnm/nvm/volta/etc.).
+    const platform = params.platform ?? process.platform;
+    const currentExecPath = params.execPath ?? process.execPath;
+    if (currentExecPath && isNodeExecPath(currentExecPath, platform)) {
+        const execFileImpl = params.execFile ?? execFileAsync;
+        const version = await resolveNodeVersion(currentExecPath, execFileImpl);
+        if (isSupportedNodeVersion(version)) {
+            return currentExecPath;
+        }
+    }
+    // Fall back to system node.
     const systemNode = await resolveSystemNodeInfo(params);
-    if (!systemNode?.supported)
+    if (!systemNode?.supported) {
         return undefined;
+    }
     return systemNode.path;
 }

package/dist/daemon/service-audit.js

@@ -10,15 +10,16 @@ export const SERVICE_AUDIT_CODES = {
     gatewayPathMissing: "gateway-path-missing",
     gatewayPathMissingDirs: "gateway-path-missing-dirs",
     gatewayPathNonMinimal: "gateway-path-nonminimal",
+    gatewayTokenMismatch: "gateway-token-mismatch",
     gatewayRuntimeBun: "gateway-runtime-bun",
     gatewayRuntimeNodeVersionManager: "gateway-runtime-node-version-manager",
     gatewayRuntimeNodeSystemMissing: "gateway-runtime-node-system-missing",
+    gatewayTokenDrift: "gateway-token-drift",
     launchdKeepAlive: "launchd-keep-alive",
     launchdRunAtLoad: "launchd-run-at-load",
     systemdAfterNetworkOnline: "systemd-after-network-online",
     systemdRestartSec: "systemd-restart-sec",
     systemdWantsNetworkOnline: "systemd-wants-network-online",
-    gatewayTokenDrift: "gateway-token-drift",
 };
 export function needsNodeRuntimeMigration(issues) {
     return issues.some((issue) => issue.code === SERVICE_AUDIT_CODES.gatewayRuntimeBun ||
@@ -33,29 +34,36 @@ function parseSystemdUnit(content) {
     let restartSec;
     for (const rawLine of content.split(/\r?\n/)) {
         const line = rawLine.trim();
-        if (!line)
+        if (!line) {
             continue;
-        if (line.startsWith("#") || line.startsWith(";"))
+        }
+        if (line.startsWith("#") || line.startsWith(";")) {
             continue;
-        if (line.startsWith("["))
+        }
+        if (line.startsWith("[")) {
             continue;
+        }
         const idx = line.indexOf("=");
-        if (idx <= 0)
+        if (idx <= 0) {
             continue;
+        }
         const key = line.slice(0, idx).trim();
         const value = line.slice(idx + 1).trim();
-        if (!value)
+        if (!value) {
             continue;
+        }
         if (key === "After") {
             for (const entry of value.split(/\s+/)) {
-                if (entry)
+                if (entry) {
                     after.add(entry);
+                }
             }
         }
         else if (key === "Wants") {
             for (const entry of value.split(/\s+/)) {
-                if (entry)
+                if (entry) {
                     wants.add(entry);
+                }
             }
         }
         else if (key === "RestartSec") {
@@ -65,11 +73,13 @@ function parseSystemdUnit(content) {
     return { after, wants, restartSec };
 }
 function isRestartSecPreferred(value) {
-    if (!value)
+    if (!value) {
         return false;
+    }
     const parsed = Number.parseFloat(value);
-    if (!Number.isFinite(parsed))
+    if (!Number.isFinite(parsed)) {
         return false;
+    }
     return Math.abs(parsed - 5) < 0.01;
 }
 async function auditSystemdUnit(env, issues) {
@@ -136,8 +146,9 @@ async function auditLaunchdPlist(env, issues) {
     }
 }
 function auditGatewayCommand(programArguments, issues) {
-    if (!programArguments || programArguments.length === 0)
+    if (!programArguments || programArguments.length === 0) {
         return;
+    }
     if (!hasGatewaySubcommand(programArguments)) {
         issues.push({
             code: SERVICE_AUDIT_CODES.gatewayCommandMissing,
@@ -146,6 +157,22 @@ function auditGatewayCommand(programArguments, issues) {
         });
     }
 }
+function auditGatewayToken(command, issues, expectedGatewayToken) {
+    const expectedToken = expectedGatewayToken?.trim();
+    if (!expectedToken) {
+        return;
+    }
+    const serviceToken = command?.environment?.POOLBOT_GATEWAY_TOKEN?.trim();
+    if (serviceToken === expectedToken) {
+        return;
+    }
+    issues.push({
+        code: SERVICE_AUDIT_CODES.gatewayTokenMismatch,
+        message: "Gateway service POOLBOT_GATEWAY_TOKEN does not match gateway.auth.token in poolbot.json",
+        detail: serviceToken ? "service token is stale" : "service token is missing",
+        level: "recommended",
+    });
+}
 function isNodeRuntime(execPath) {
     const base = path.basename(execPath).toLowerCase();
     return base === "node" || base === "node.exe";
@@ -166,8 +193,9 @@ function normalizePathEntry(entry, platform) {
     return normalized;
 }
 function auditGatewayServicePath(command, issues, env, platform) {
-    if (platform === "win32")
+    if (platform === "win32") {
         return;
+    }
     const servicePath = command?.environment?.PATH;
     if (!servicePath) {
         issues.push({
@@ -182,11 +210,11 @@ function auditGatewayServicePath(command, issues, env, platform) {
         .split(getPathModule(platform).delimiter)
         .map((entry) => entry.trim())
         .filter(Boolean);
-    const normalizedParts = parts.map((entry) => normalizePathEntry(entry, platform));
+    const normalizedParts = new Set(parts.map((entry) => normalizePathEntry(entry, platform)));
     const normalizedExpected = new Set(expected.map((entry) => normalizePathEntry(entry, platform)));
     const missing = expected.filter((entry) => {
         const normalized = normalizePathEntry(entry, platform);
-        return !normalizedParts.includes(normalized);
+        return !normalizedParts.has(normalized);
     });
     if (missing.length > 0) {
         issues.push({
@@ -223,8 +251,9 @@ function auditGatewayServicePath(command, issues, env, platform) {
 }
 async function auditGatewayRuntime(env, command, issues, platform) {
     const execPath = command?.programArguments?.[0];
-    if (!execPath)
+    if (!execPath) {
         return;
+    }
     if (isBunRuntime(execPath)) {
         issues.push({
             code: SERVICE_AUDIT_CODES.gatewayRuntimeBun,
@@ -234,8 +263,9 @@ async function auditGatewayRuntime(env, command, issues, platform) {
         });
         return;
     }
-    if (!isNodeRuntime(execPath))
+    if (!isNodeRuntime(execPath)) {
         return;
+    }
     if (isVersionManagedNodePath(execPath, platform)) {
         issues.push({
             code: SERVICE_AUDIT_CODES.gatewayRuntimeNodeVersionManager,
@@ -280,6 +310,7 @@ export async function auditGatewayServiceConfig(params) {
     const issues = [];
     const platform = params.platform ?? process.platform;
     auditGatewayCommand(params.command?.programArguments, issues);
+    auditGatewayToken(params.command, issues, params.expectedGatewayToken);
     auditGatewayServicePath(params.command, issues, params.env, platform);
     await auditGatewayRuntime(params.env, params.command, issues, platform);
     if (platform === "linux") {

package/dist/discord/accounts.js

@@ -1,27 +1,14 @@
-import { DEFAULT_ACCOUNT_ID, normalizeAccountId } from "../routing/session-key.js";
+import { createAccountListHelpers } from "../channels/plugins/account-helpers.js";
+import { normalizeAccountId } from "../routing/session-key.js";
 import { resolveDiscordToken } from "./token.js";
-function listConfiguredAccountIds(cfg) {
-    const accounts = cfg.channels?.discord?.accounts;
-    if (!accounts || typeof accounts !== "object")
-        return [];
-    return Object.keys(accounts).filter(Boolean);
-}
-export function listDiscordAccountIds(cfg) {
-    const ids = listConfiguredAccountIds(cfg);
-    if (ids.length === 0)
-        return [DEFAULT_ACCOUNT_ID];
-    return ids.sort((a, b) => a.localeCompare(b));
-}
-export function resolveDefaultDiscordAccountId(cfg) {
-    const ids = listDiscordAccountIds(cfg);
-    if (ids.includes(DEFAULT_ACCOUNT_ID))
-        return DEFAULT_ACCOUNT_ID;
-    return ids[0] ?? DEFAULT_ACCOUNT_ID;
-}
+const { listAccountIds, resolveDefaultAccountId } = createAccountListHelpers("discord");
+export const listDiscordAccountIds = listAccountIds;
+export const resolveDefaultDiscordAccountId = resolveDefaultAccountId;
 function resolveAccountConfig(cfg, accountId) {
     const accounts = cfg.channels?.discord?.accounts;
-    if (!accounts || typeof accounts !== "object")
+    if (!accounts || typeof accounts !== "object") {
         return undefined;
+    }
     return accounts[accountId];
 }
 function mergeDiscordAccountConfig(cfg, accountId) {
@@ -29,6 +16,22 @@ function mergeDiscordAccountConfig(cfg, accountId) {
     const account = resolveAccountConfig(cfg, accountId) ?? {};
     return { ...base, ...account };
 }
+export function createDiscordActionGate(params) {
+    const accountId = normalizeAccountId(params.accountId);
+    const baseActions = params.cfg.channels?.discord?.actions;
+    const accountActions = resolveAccountConfig(params.cfg, accountId)?.actions;
+    return (key, defaultValue = true) => {
+        const accountValue = accountActions?.[key];
+        if (accountValue !== undefined) {
+            return accountValue;
+        }
+        const baseValue = baseActions?.[key];
+        if (baseValue !== undefined) {
+            return baseValue;
+        }
+        return defaultValue;
+    };
+}
 export function resolveDiscordAccount(params) {
     const accountId = normalizeAccountId(params.accountId);
     const baseEnabled = params.cfg.channels?.discord?.enabled !== false;