@poolzin/pool-bot 2026.2.0 → 2026.2.2

package/dist/infra/update-runner.js

@@ -2,32 +2,37 @@ import fs from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
 import { runCommandWithTimeout } from "../process/exec.js";
-import { compareSemverStrings } from "./update-check.js";
-import { DEV_BRANCH, isBetaTag, isStableTag } from "./update-channels.js";
-import { detectGlobalInstallManagerForRoot, globalInstallArgs } from "./update-global.js";
+import { resolveControlUiDistIndexHealth, resolveControlUiDistIndexPathForRoot, } from "./control-ui-assets.js";
 import { trimLogTail } from "./restart-sentinel.js";
+import { channelToNpmTag, DEFAULT_PACKAGE_CHANNEL, DEV_BRANCH, isBetaTag, isStableTag, } from "./update-channels.js";
+import { compareSemverStrings } from "./update-check.js";
+import { cleanupGlobalRenameDirs, detectGlobalInstallManagerForRoot, globalInstallArgs, } from "./update-global.js";
 const DEFAULT_TIMEOUT_MS = 20 * 60_000;
 const MAX_LOG_CHARS = 8000;
 const PREFLIGHT_MAX_COMMITS = 10;
 const START_DIRS = ["cwd", "argv1", "process"];
 const DEFAULT_PACKAGE_NAME = "poolbot";
-const CORE_PACKAGE_NAMES = new Set([DEFAULT_PACKAGE_NAME, "poolbot"]);
+const CORE_PACKAGE_NAMES = new Set([DEFAULT_PACKAGE_NAME]);
 function normalizeDir(value) {
-    if (!value)
+    if (!value) {
         return null;
+    }
     const trimmed = value.trim();
-    if (!trimmed)
+    if (!trimmed) {
         return null;
+    }
     return path.resolve(trimmed);
 }
 function resolveNodeModulesBinPackageRoot(argv1) {
     const normalized = path.resolve(argv1);
     const parts = normalized.split(path.sep);
     const binIndex = parts.lastIndexOf(".bin");
-    if (binIndex <= 0)
+    if (binIndex <= 0) {
         return null;
-    if (parts[binIndex - 1] !== "node_modules")
+    }
+    if (parts[binIndex - 1] !== "node_modules") {
         return null;
+    }
     const binName = path.basename(normalized);
     const nodeModulesDir = parts.slice(0, binIndex).join(path.sep);
     return path.join(nodeModulesDir, binName);
@@ -35,18 +40,21 @@ function resolveNodeModulesBinPackageRoot(argv1) {
 function buildStartDirs(opts) {
     const dirs = [];
     const cwd = normalizeDir(opts.cwd);
-    if (cwd)
+    if (cwd) {
         dirs.push(cwd);
+    }
     const argv1 = normalizeDir(opts.argv1);
     if (argv1) {
         dirs.push(path.dirname(argv1));
         const packageRoot = resolveNodeModulesBinPackageRoot(argv1);
-        if (packageRoot)
+        if (packageRoot) {
             dirs.push(packageRoot);
+        }
     }
     const proc = normalizeDir(process.cwd());
-    if (proc)
+    if (proc) {
         dirs.push(proc);
+    }
     return Array.from(new Set(dirs));
 }
 async function readPackageVersion(root) {
@@ -74,8 +82,9 @@ async function readBranchName(runCommand, root, timeoutMs) {
     const res = await runCommand(["git", "-C", root, "rev-parse", "--abbrev-ref", "HEAD"], {
         timeoutMs,
     }).catch(() => null);
-    if (!res || res.code !== 0)
+    if (!res || res.code !== 0) {
         return null;
+    }
     const branch = res.stdout.trim();
     return branch || null;
 }
@@ -83,8 +92,9 @@ async function listGitTags(runCommand, root, timeoutMs, pattern = "v*") {
     const res = await runCommand(["git", "-C", root, "tag", "--list", pattern, "--sort=-v:refname"], {
         timeoutMs,
     }).catch(() => null);
-    if (!res || res.code !== 0)
+    if (!res || res.code !== 0) {
         return [];
+    }
     return res.stdout
         .split("\n")
         .map((line) => line.trim())
@@ -95,13 +105,16 @@ async function resolveChannelTag(runCommand, root, timeoutMs, channel) {
     if (channel === "beta") {
         const betaTag = tags.find((tag) => isBetaTag(tag)) ?? null;
         const stableTag = tags.find((tag) => isStableTag(tag)) ?? null;
-        if (!betaTag)
+        if (!betaTag) {
             return stableTag;
-        if (!stableTag)
+        }
+        if (!stableTag) {
             return betaTag;
+        }
         const cmp = compareSemverStrings(betaTag, stableTag);
-        if (cmp != null && cmp < 0)
+        if (cmp != null && cmp < 0) {
             return stableTag;
+        }
         return betaTag;
     }
     return tags.find((tag) => isStableTag(tag)) ?? null;
@@ -113,8 +126,9 @@ async function resolveGitRoot(runCommand, candidates, timeoutMs) {
         });
         if (res.code === 0) {
             const root = res.stdout.trim();
-            if (root)
+            if (root) {
                 return root;
+            }
         }
     }
     return null;
@@ -128,15 +142,17 @@ async function findPackageRoot(candidates) {
                 const raw = await fs.readFile(pkgPath, "utf-8");
                 const parsed = JSON.parse(raw);
                 const name = parsed?.name?.trim();
-                if (name && CORE_PACKAGE_NAMES.has(name))
+                if (name && CORE_PACKAGE_NAMES.has(name)) {
                     return current;
+                }
             }
             catch {
                 // ignore
             }
             const parent = path.dirname(current);
-            if (parent === current)
+            if (parent === current) {
                 break;
+            }
             current = parent;
         }
     }
@@ -147,19 +163,23 @@ async function detectPackageManager(root) {
         const raw = await fs.readFile(path.join(root, "package.json"), "utf-8");
         const parsed = JSON.parse(raw);
         const pm = parsed?.packageManager?.split("@")[0]?.trim();
-        if (pm === "pnpm" || pm === "bun" || pm === "npm")
+        if (pm === "pnpm" || pm === "bun" || pm === "npm") {
             return pm;
+        }
     }
     catch {
         // ignore
     }
     const files = await fs.readdir(root).catch(() => []);
-    if (files.includes("pnpm-lock.yaml"))
+    if (files.includes("pnpm-lock.yaml")) {
         return "pnpm";
-    if (files.includes("bun.lockb"))
+    }
+    if (files.includes("bun.lockb")) {
         return "bun";
-    if (files.includes("package-lock.json"))
+    }
+    if (files.includes("package-lock.json")) {
         return "npm";
+    }
     return "npm";
 }
 async function runStep(opts) {
@@ -193,27 +213,34 @@ async function runStep(opts) {
     };
 }
 function managerScriptArgs(manager, script, args = []) {
-    if (manager === "pnpm")
+    if (manager === "pnpm") {
         return ["pnpm", script, ...args];
-    if (manager === "bun")
+    }
+    if (manager === "bun") {
         return ["bun", "run", script, ...args];
-    if (args.length > 0)
+    }
+    if (args.length > 0) {
         return ["npm", "run", script, "--", ...args];
+    }
     return ["npm", "run", script];
 }
 function managerInstallArgs(manager) {
-    if (manager === "pnpm")
+    if (manager === "pnpm") {
         return ["pnpm", "install"];
-    if (manager === "bun")
+    }
+    if (manager === "bun") {
         return ["bun", "install"];
+    }
     return ["npm", "install"];
 }
 function normalizeTag(tag) {
     const trimmed = tag?.trim();
-    if (!trimmed)
+    if (!trimmed) {
         return "latest";
-    if (trimmed.startsWith("poolbot@"))
+    }
+    if (trimmed.startsWith("poolbot@")) {
         return trimmed.slice("poolbot@".length);
+    }
     if (trimmed.startsWith(`${DEFAULT_PACKAGE_NAME}@`)) {
         return trimmed.slice(`${DEFAULT_PACKAGE_NAME}@`.length);
     }
@@ -392,20 +419,24 @@ export async function runGatewayUpdate(opts = {}) {
                     const shortSha = sha.slice(0, 8);
                     const checkoutStep = await runStep(step(`preflight checkout (${shortSha})`, ["git", "-C", worktreeDir, "checkout", "--detach", sha], worktreeDir));
                     steps.push(checkoutStep);
-                    if (checkoutStep.exitCode !== 0)
+                    if (checkoutStep.exitCode !== 0) {
                         continue;
+                    }
                     const depsStep = await runStep(step(`preflight deps install (${shortSha})`, managerInstallArgs(manager), worktreeDir));
                     steps.push(depsStep);
-                    if (depsStep.exitCode !== 0)
-                        continue;
-                    const lintStep = await runStep(step(`preflight lint (${shortSha})`, managerScriptArgs(manager, "lint"), worktreeDir));
-                    steps.push(lintStep);
-                    if (lintStep.exitCode !== 0)
+                    if (depsStep.exitCode !== 0) {
                         continue;
+                    }
                     const buildStep = await runStep(step(`preflight build (${shortSha})`, managerScriptArgs(manager, "build"), worktreeDir));
                     steps.push(buildStep);
-                    if (buildStep.exitCode !== 0)
+                    if (buildStep.exitCode !== 0) {
+                        continue;
+                    }
+                    const lintStep = await runStep(step(`preflight lint (${shortSha})`, managerScriptArgs(manager, "lint"), worktreeDir));
+                    steps.push(lintStep);
+                    if (lintStep.exitCode !== 0) {
                         continue;
+                    }
                     selectedSha = sha;
                     break;
                 }
@@ -504,12 +535,81 @@ export async function runGatewayUpdate(opts = {}) {
         steps.push(buildStep);
         const uiBuildStep = await runStep(step("ui:build", managerScriptArgs(manager, "ui:build"), gitRoot));
         steps.push(uiBuildStep);
-        // Restore dist/control-ui/ to committed state to prevent dirty repo after update
-        // (ui:build regenerates assets with new hashes, which would block future updates)
-        const restoreUiStep = await runStep(step("restore control-ui", ["git", "-C", gitRoot, "checkout", "--", "dist/control-ui/"], gitRoot));
-        steps.push(restoreUiStep);
-        const doctorStep = await runStep(step("poolbot doctor", managerScriptArgs(manager, "poolbot", ["doctor", "--non-interactive"]), gitRoot, { CLAWDBOT_UPDATE_IN_PROGRESS: "1" }));
+        const doctorEntry = path.join(gitRoot, "poolbot.mjs");
+        const doctorEntryExists = await fs
+            .stat(doctorEntry)
+            .then(() => true)
+            .catch(() => false);
+        if (!doctorEntryExists) {
+            steps.push({
+                name: "poolbot doctor entry",
+                command: `verify ${doctorEntry}`,
+                cwd: gitRoot,
+                durationMs: 0,
+                exitCode: 1,
+                stderrTail: `missing ${doctorEntry}`,
+            });
+            return {
+                status: "error",
+                mode: "git",
+                root: gitRoot,
+                reason: "doctor-entry-missing",
+                before: { sha: beforeSha, version: beforeVersion },
+                steps,
+                durationMs: Date.now() - startedAt,
+            };
+        }
+        const doctorArgv = [process.execPath, doctorEntry, "doctor", "--non-interactive"];
+        const doctorStep = await runStep(step("poolbot doctor", doctorArgv, gitRoot, { CLAWDBOT_UPDATE_IN_PROGRESS: "1" }));
         steps.push(doctorStep);
+        const uiIndexHealth = await resolveControlUiDistIndexHealth({ root: gitRoot });
+        if (!uiIndexHealth.exists) {
+            const repairArgv = managerScriptArgs(manager, "ui:build");
+            const started = Date.now();
+            const repairResult = await runCommand(repairArgv, { cwd: gitRoot, timeoutMs });
+            const repairStep = {
+                name: "ui:build (post-doctor repair)",
+                command: repairArgv.join(" "),
+                cwd: gitRoot,
+                durationMs: Date.now() - started,
+                exitCode: repairResult.code,
+                stdoutTail: trimLogTail(repairResult.stdout, MAX_LOG_CHARS),
+                stderrTail: trimLogTail(repairResult.stderr, MAX_LOG_CHARS),
+            };
+            steps.push(repairStep);
+            if (repairResult.code !== 0) {
+                return {
+                    status: "error",
+                    mode: "git",
+                    root: gitRoot,
+                    reason: repairStep.name,
+                    before: { sha: beforeSha, version: beforeVersion },
+                    steps,
+                    durationMs: Date.now() - startedAt,
+                };
+            }
+            const repairedUiIndexHealth = await resolveControlUiDistIndexHealth({ root: gitRoot });
+            if (!repairedUiIndexHealth.exists) {
+                const uiIndexPath = repairedUiIndexHealth.indexPath ?? resolveControlUiDistIndexPathForRoot(gitRoot);
+                steps.push({
+                    name: "ui assets verify",
+                    command: `verify ${uiIndexPath}`,
+                    cwd: gitRoot,
+                    durationMs: 0,
+                    exitCode: 1,
+                    stderrTail: `missing ${uiIndexPath}`,
+                });
+                return {
+                    status: "error",
+                    mode: "git",
+                    root: gitRoot,
+                    reason: "ui-assets-missing",
+                    before: { sha: beforeSha, version: beforeVersion },
+                    steps,
+                    durationMs: Date.now() - startedAt,
+                };
+            }
+        }
         const failedStep = steps.find((s) => s.exitCode !== 0);
         const afterShaStep = await runStep(step("git rev-parse HEAD (after)", ["git", "-C", gitRoot, "rev-parse", "HEAD"], gitRoot));
         steps.push(afterShaStep);
@@ -541,7 +641,13 @@ export async function runGatewayUpdate(opts = {}) {
     const globalManager = await detectGlobalInstallManagerForRoot(runCommand, pkgRoot, timeoutMs);
     if (globalManager) {
         const packageName = (await readPackageName(pkgRoot)) ?? DEFAULT_PACKAGE_NAME;
-        const spec = `${packageName}@${normalizeTag(opts.tag)}`;
+        await cleanupGlobalRenameDirs({
+            globalRoot: path.dirname(pkgRoot),
+            packageName,
+        });
+        const channel = opts.channel ?? DEFAULT_PACKAGE_CHANNEL;
+        const tag = normalizeTag(opts.tag ?? channelToNpmTag(channel));
+        const spec = `${packageName}@${tag}`;
         const updateStep = await runStep({
             runCommand,
             name: "global update",

package/dist/infra/warning-filter.js

@@ -0,0 +1,65 @@
+const warningFilterKey = Symbol.for("poolbot.warning-filter");
+export function shouldIgnoreWarning(warning) {
+    if (warning.code === "DEP0040" && warning.message?.includes("punycode")) {
+        return true;
+    }
+    if (warning.code === "DEP0060" && warning.message?.includes("util._extend")) {
+        return true;
+    }
+    if (warning.name === "ExperimentalWarning" &&
+        warning.message?.includes("SQLite is an experimental feature")) {
+        return true;
+    }
+    return false;
+}
+function normalizeWarningArgs(args) {
+    const warningArg = args[0];
+    const secondArg = args[1];
+    const thirdArg = args[2];
+    let name;
+    let code;
+    let message;
+    if (warningArg instanceof Error) {
+        name = warningArg.name;
+        message = warningArg.message;
+        code = warningArg.code;
+    }
+    else if (typeof warningArg === "string") {
+        message = warningArg;
+    }
+    if (secondArg && typeof secondArg === "object" && !Array.isArray(secondArg)) {
+        const options = secondArg;
+        if (typeof options.type === "string") {
+            name = options.type;
+        }
+        if (typeof options.code === "string") {
+            code = options.code;
+        }
+    }
+    else {
+        if (typeof secondArg === "string") {
+            name = secondArg;
+        }
+        if (typeof thirdArg === "string") {
+            code = thirdArg;
+        }
+    }
+    return { name, code, message };
+}
+export function installProcessWarningFilter() {
+    const globalState = globalThis;
+    if (globalState[warningFilterKey]?.installed) {
+        return;
+    }
+    const originalEmitWarning = process.emitWarning.bind(process);
+    const wrappedEmitWarning = ((...args) => {
+        if (shouldIgnoreWarning(normalizeWarningArgs(args))) {
+            return;
+        }
+        return Reflect.apply(originalEmitWarning, process, args);
+    });
+    process.emitWarning = wrappedEmitWarning;
+    globalState[warningFilterKey] = {
+        installed: true,
+    };
+}

package/dist/infra/widearea-dns.js

@@ -2,10 +2,23 @@ import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import { CONFIG_DIR, ensureDir } from "../utils.js";
-export const WIDE_AREA_DISCOVERY_DOMAIN = "poolbot.internal.";
-export const WIDE_AREA_ZONE_FILENAME = "poolbot.internal.db";
-export function getWideAreaZonePath() {
-    return path.join(CONFIG_DIR, "dns", WIDE_AREA_ZONE_FILENAME);
+export function normalizeWideAreaDomain(raw) {
+    const trimmed = raw?.trim();
+    if (!trimmed) {
+        return null;
+    }
+    return trimmed.endsWith(".") ? trimmed : `${trimmed}.`;
+}
+export function resolveWideAreaDiscoveryDomain(params) {
+    const env = params?.env ?? process.env;
+    const candidate = params?.configDomain ?? env.CLAWDBOT_WIDE_AREA_DOMAIN ?? null;
+    return normalizeWideAreaDomain(candidate);
+}
+function zoneFilenameForDomain(domain) {
+    return `${domain.replace(/\.$/, "")}.db`;
+}
+export function getWideAreaZonePath(domain) {
+    return path.join(CONFIG_DIR, "dns", zoneFilenameForDomain(domain));
 }
 function dnsLabel(raw, fallback) {
     const normalized = raw
@@ -30,17 +43,20 @@ function formatYyyyMmDd(date) {
 function nextSerial(existingSerial, now) {
     const today = formatYyyyMmDd(now);
     const base = Number.parseInt(`${today}01`, 10);
-    if (!existingSerial || !Number.isFinite(existingSerial))
+    if (!existingSerial || !Number.isFinite(existingSerial)) {
         return base;
+    }
     const existing = String(existingSerial);
-    if (existing.startsWith(today))
+    if (existing.startsWith(today)) {
         return existingSerial + 1;
+    }
     return base;
 }
 function extractSerial(zoneText) {
     const match = zoneText.match(/^\s*@\s+IN\s+SOA\s+\S+\s+\S+\s+(\d+)\s+/m);
-    if (!match)
+    if (!match) {
         return null;
+    }
     const parsed = Number.parseInt(match[1], 10);
     return Number.isFinite(parsed) ? parsed : null;
 }
@@ -61,6 +77,7 @@ function renderZone(opts) {
     const hostname = os.hostname().split(".")[0] ?? "poolbot";
     const hostLabel = dnsLabel(opts.hostLabel ?? hostname, "poolbot");
     const instanceLabel = dnsLabel(opts.instanceLabel ?? `${hostname}-gateway`, "poolbot-gw");
+    const domain = normalizeWideAreaDomain(opts.domain) ?? "local.";
     const txt = [
         `displayName=${opts.displayName.trim() || hostname}`,
         `role=gateway`,
@@ -83,7 +100,7 @@ function renderZone(opts) {
         txt.push(`cliPath=${opts.cliPath.trim()}`);
     }
     const records = [];
-    records.push(`$ORIGIN ${WIDE_AREA_DISCOVERY_DOMAIN}`);
+    records.push(`$ORIGIN ${domain}`);
     records.push(`$TTL 60`);
     const soaLine = `@ IN SOA ns1 hostmaster ${opts.serial} 7200 3600 1209600 60`;
     records.push(soaLine);
@@ -107,7 +124,11 @@ export function renderWideAreaGatewayZoneText(opts) {
     return renderZone(opts);
 }
 export async function writeWideAreaGatewayZone(opts) {
-    const zonePath = getWideAreaZonePath();
+    const domain = normalizeWideAreaDomain(opts.domain);
+    if (!domain) {
+        throw new Error("wide-area discovery domain is required");
+    }
+    const zonePath = getWideAreaZonePath(domain);
     await ensureDir(path.dirname(zonePath));
     const existing = (() => {
         try {

package/dist/logging/redact-identifier.js

@@ -0,0 +1,12 @@
+import crypto from "node:crypto";
+export function sha256HexPrefix(value, len = 12) {
+    const safeLen = Number.isFinite(len) ? Math.max(1, Math.floor(len)) : 12;
+    return crypto.createHash("sha256").update(value).digest("hex").slice(0, safeLen);
+}
+export function redactIdentifier(value, opts) {
+    const trimmed = value?.trim();
+    if (!trimmed) {
+        return "-";
+    }
+    return `sha256:${sha256HexPrefix(trimmed, opts?.len ?? 12)}`;
+}