@poolzin/pool-bot 2026.2.25 → 2026.2.26

package/dist/commands/channels/shared.js

@@ -1,25 +1,15 @@
 import { getChannelPlugin } from "../../channels/plugins/index.js";
-import { formatCliCommand } from "../../cli/command-format.js";
-import { readConfigFileSnapshot } from "../../config/config.js";
 import { DEFAULT_ACCOUNT_ID } from "../../routing/session-key.js";
 import { defaultRuntime } from "../../runtime.js";
+import { requireValidConfigSnapshot } from "../config-validation.js";
 export async function requireValidConfig(runtime = defaultRuntime) {
-    const snapshot = await readConfigFileSnapshot();
-    if (snapshot.exists && !snapshot.valid) {
-        const issues = snapshot.issues.length > 0
-            ? snapshot.issues.map((issue) => `- ${issue.path}: ${issue.message}`).join("\n")
-            : "Unknown validation issue.";
-        runtime.error(`Config invalid:\n${issues}`);
-        runtime.error(`Fix the config or run ${formatCliCommand("poolbot doctor")}.`);
-        runtime.exit(1);
-        return null;
-    }
-    return snapshot.config;
+    return await requireValidConfigSnapshot(runtime);
 }
 export function formatAccountLabel(params) {
     const base = params.accountId || DEFAULT_ACCOUNT_ID;
-    if (params.name?.trim())
+    if (params.name?.trim()) {
         return `${base} (${params.name.trim()})`;
+    }
     return base;
 }
 export const channelLabel = (channel) => {

package/dist/commands/configure.commands.js

@@ -1,4 +1,5 @@
 import { defaultRuntime } from "../runtime.js";
+import { CONFIGURE_WIZARD_SECTIONS, parseConfigureWizardSections } from "./configure.shared.js";
 import { runConfigureWizard } from "./configure.wizard.js";
 export async function configureCommand(runtime = defaultRuntime) {
     await runConfigureWizard({ command: "configure" }, runtime);
@@ -6,3 +7,16 @@ export async function configureCommand(runtime = defaultRuntime) {
 export async function configureCommandWithSections(sections, runtime = defaultRuntime) {
     await runConfigureWizard({ command: "configure", sections }, runtime);
 }
+export async function configureCommandFromSectionsArg(rawSections, runtime = defaultRuntime) {
+    const { sections, invalid } = parseConfigureWizardSections(rawSections);
+    if (sections.length === 0) {
+        await configureCommand(runtime);
+        return;
+    }
+    if (invalid.length > 0) {
+        runtime.error(`Invalid --section: ${invalid.join(", ")}. Expected one of: ${CONFIGURE_WIZARD_SECTIONS.join(", ")}.`);
+        runtime.exit(1);
+        return;
+    }
+    await configureCommandWithSections(sections, runtime);
+}

package/dist/commands/configure.gateway.js

@@ -92,10 +92,8 @@ export async function promptGatewayConfig(cfg, runtime) {
         note("Tailscale funnel requires password auth.", "Note");
         authMode = "password";
     }
-    if (authMode === "trusted-proxy" && bind === "loopback") {
-        note("Trusted proxy auth requires network bind. Adjusting bind to lan.", "Note");
-        bind = "lan";
-    }
+    // trusted-proxy + loopback is valid when the reverse proxy runs on the same
+    // host (e.g. cloudflared, nginx, Caddy). trustedProxies must include 127.0.0.1.
     if (authMode === "trusted-proxy" && tailscaleMode !== "off") {
         note("Trusted proxy auth is incompatible with Tailscale serve/funnel. Disabling Tailscale.", "Note");
         tailscaleMode = "off";

package/dist/commands/configure.js

@@ -1,4 +1,4 @@
-export { configureCommand, configureCommandWithSections } from "./configure.commands.js";
+export { configureCommand, configureCommandWithSections, configureCommandFromSectionsArg, } from "./configure.commands.js";
 export { buildGatewayAuthConfig } from "./configure.gateway-auth.js";
 export { CONFIGURE_WIZARD_SECTIONS } from "./configure.shared.js";
 export { runConfigureWizard } from "./configure.wizard.js";

package/dist/commands/configure.shared.js

@@ -10,6 +10,17 @@ export const CONFIGURE_WIZARD_SECTIONS = [
     "skills",
     "health",
 ];
+export function parseConfigureWizardSections(raw) {
+    const sectionsRaw = Array.isArray(raw)
+        ? raw.map((value) => (typeof value === "string" ? value.trim() : "")).filter(Boolean)
+        : [];
+    if (sectionsRaw.length === 0) {
+        return { sections: [], invalid: [] };
+    }
+    const invalid = sectionsRaw.filter((s) => !CONFIGURE_WIZARD_SECTIONS.includes(s));
+    const sections = sectionsRaw.filter((s) => CONFIGURE_WIZARD_SECTIONS.includes(s));
+    return { sections, invalid };
+}
 export const CONFIGURE_SECTION_OPTIONS = [
     { value: "workspace", label: "Workspace", hint: "Set workspace + sessions" },
     { value: "model", label: "Model", hint: "Pick provider + credentials" },

package/dist/commands/daemon-install-helpers.js

@@ -3,7 +3,7 @@ import { resolveGatewayProgramArguments } from "../daemon/program-args.js";
 import { renderSystemNodeWarning, resolvePreferredNodePath, resolveSystemNodeInfo, } from "../daemon/runtime-paths.js";
 import { buildServiceEnvironment } from "../daemon/service-env.js";
 import { formatCliCommand } from "../cli/command-format.js";
-import { collectConfigEnvVars } from "../config/env-vars.js";
+import { collectConfigServiceEnvVars } from "../config/env-vars.js";
 export function resolveGatewayDevMode(argv = process.argv) {
     const entry = argv[1];
     const normalizedEntry = entry?.replaceAll("\\", "/");
@@ -39,7 +39,7 @@ export async function buildGatewayInstallPlan(params) {
     // Merge config env vars into the service environment (vars + inline env keys).
     // Config env vars are added first so service-specific vars take precedence.
     const environment = {
-        ...collectConfigEnvVars(params.config),
+        ...collectConfigServiceEnvVars(params.config),
     };
     Object.assign(environment, serviceEnvironment);
     return { programArguments, workingDirectory, environment };

package/dist/commands/dashboard.js

@@ -9,26 +9,28 @@ export async function dashboardCommand(runtime = defaultRuntime, options = {}) {
     const bind = cfg.gateway?.bind ?? "loopback";
     const basePath = cfg.gateway?.controlUi?.basePath;
     const customBindHost = cfg.gateway?.customBindHost;
-    const token = cfg.gateway?.auth?.token ??
-        process.env.POOLBOT_GATEWAY_TOKEN ??
-        process.env.CLAWDBOT_GATEWAY_TOKEN ??
-        "";
+    const token = cfg.gateway?.auth?.token ?? process.env.POOLBOT_GATEWAY_TOKEN ?? "";
+    // LAN URLs fail secure-context checks in browsers.
+    // Coerce only lan->loopback and preserve other bind modes.
     const links = resolveControlUiLinks({
         port,
-        bind,
+        bind: bind === "lan" ? "loopback" : bind,
         customBindHost,
         basePath,
     });
-    const authedUrl = token ? `${links.httpUrl}?token=${encodeURIComponent(token)}` : links.httpUrl;
-    runtime.log(`Dashboard URL: ${authedUrl}`);
-    const copied = await copyToClipboard(authedUrl).catch(() => false);
+    // Prefer URL fragment to avoid leaking auth tokens via query params.
+    const dashboardUrl = token
+        ? `${links.httpUrl}#token=${encodeURIComponent(token)}`
+        : links.httpUrl;
+    runtime.log(`Dashboard URL: ${dashboardUrl}`);
+    const copied = await copyToClipboard(dashboardUrl).catch(() => false);
     runtime.log(copied ? "Copied to clipboard." : "Copy to clipboard unavailable.");
     let opened = false;
     let hint;
     if (!options.noOpen) {
         const browserSupport = await detectBrowserOpenSupport();
         if (browserSupport.ok) {
-            opened = await openUrl(authedUrl);
+            opened = await openUrl(dashboardUrl);
         }
         if (!opened) {
             hint = formatControlUiSshHint({
@@ -42,7 +44,7 @@ export async function dashboardCommand(runtime = defaultRuntime, options = {}) {
         hint = "Browser launch disabled (--no-open). Use the URL above.";
     }
     if (opened) {
-        runtime.log("Opened in your browser. Keep that tab to control Poolbot.");
+        runtime.log("Opened in your browser. Keep that tab to control Pool Bot.");
     }
     else if (hint) {
         runtime.log(hint);

package/dist/commands/docs.js

@@ -1,16 +1,18 @@
 import { hasBinary } from "../agents/skills.js";
+import { formatCliCommand } from "../cli/command-format.js";
 import { runCommandWithTimeout } from "../process/exec.js";
 import { formatDocsLink } from "../terminal/links.js";
 import { isRich, theme } from "../terminal/theme.js";
-import { formatCliCommand } from "../cli/command-format.js";
-const SEARCH_TOOL = "https://docs.molt.bot/mcp.SearchPoolbot";
+const SEARCH_TOOL = "https://docs.molt.bot/mcp.SearchPool Bot";
 const SEARCH_TIMEOUT_MS = 30_000;
 const DEFAULT_SNIPPET_MAX = 220;
 function resolveNodeRunner() {
-    if (hasBinary("pnpm"))
+    if (hasBinary("pnpm")) {
         return { cmd: "pnpm", args: ["dlx"] };
-    if (hasBinary("npx"))
+    }
+    if (hasBinary("npx")) {
         return { cmd: "npx", args: ["-y"] };
+    }
     throw new Error("Missing pnpm or npx; install a Node package runner.");
 }
 async function runNodeTool(tool, toolArgs, options = {}) {
@@ -32,17 +34,20 @@ async function runTool(tool, toolArgs, options = {}) {
 }
 function extractLine(lines, prefix) {
     const line = lines.find((value) => value.startsWith(prefix));
-    if (!line)
+    if (!line) {
         return undefined;
+    }
     return line.slice(prefix.length).trim();
 }
 function normalizeSnippet(raw, fallback) {
     const base = raw && raw.trim().length > 0 ? raw : fallback;
     const cleaned = base.replace(/\s+/g, " ").trim();
-    if (!cleaned)
+    if (!cleaned) {
         return "";
-    if (cleaned.length <= DEFAULT_SNIPPET_MAX)
+    }
+    if (cleaned.length <= DEFAULT_SNIPPET_MAX) {
         return cleaned;
+    }
     return `${cleaned.slice(0, DEFAULT_SNIPPET_MAX - 3)}...`;
 }
 function firstParagraph(text) {
@@ -63,8 +68,9 @@ function parseSearchOutput(raw) {
         const lines = block.split("\n");
         const title = extractLine(lines, "Title:");
         const link = extractLine(lines, "Link:");
-        if (!title || !link)
+        if (!title || !link) {
             continue;
+        }
         const content = extractLine(lines, "Content:");
         const contentIndex = lines.findIndex((line) => line.startsWith("Content:"));
         const body = contentIndex >= 0

package/dist/commands/doctor-config-flow.js

@@ -1,6 +1,7 @@
 import fs from "node:fs/promises";
 import path from "node:path";
 import { isNumericTelegramUserId, normalizeTelegramAllowFromEntry, } from "../channels/telegram/allow-from.js";
+import { fetchTelegramChatId } from "../channels/telegram/api.js";
 import { formatCliCommand } from "../cli/command-format.js";
 import { PoolBotSchema, CONFIG_PATH, migrateLegacyConfig, readConfigFileSnapshot, } from "../config/config.js";
 import { applyPluginAutoEnable } from "../config/plugin-auto-enable.js";
@@ -251,15 +252,13 @@ async function maybeRepairTelegramAllowFromUsernames(cfg) {
             const controller = new AbortController();
             const timeout = setTimeout(() => controller.abort(), 4000);
             try {
-                const url = `https://api.telegram.org/bot${token}/getChat?chat_id=${encodeURIComponent(username)}`;
-                const res = await fetch(url, { signal: controller.signal }).catch(() => null);
-                if (!res || !res.ok) {
-                    continue;
-                }
-                const data = (await res.json().catch(() => null));
-                const id = data?.ok ? data?.result?.id : undefined;
-                if (typeof id === "number" || typeof id === "string") {
-                    return String(id);
+                const id = await fetchTelegramChatId({
+                    token,
+                    chatId: username,
+                    signal: controller.signal,
+                });
+                if (id) {
+                    return id;
                 }
             }
             catch {
@@ -754,6 +753,9 @@ export async function loadAndMaybeMigrateDoctorConfig(params) {
             note(fixHints.join("\n"), "Doctor");
         }
     }
+    if (shouldRepair && pendingChanges) {
+        shouldWriteConfig = true;
+    }
     noteOpencodeProviderOverrides(cfg);
     return {
         cfg,

package/dist/commands/doctor-legacy-config.js

@@ -1,6 +1,287 @@
+import { resolveDiscordPreviewStreamMode, resolveSlackNativeStreaming, resolveSlackStreamingMode, resolveTelegramPreviewStreamMode, } from "../config/discord-preview-streaming.js";
 export function normalizeLegacyConfigValues(cfg) {
     const changes = [];
     let next = cfg;
+    const isRecord = (value) => Boolean(value) && typeof value === "object" && !Array.isArray(value);
+    const normalizeDmAliases = (params) => {
+        let changed = false;
+        let updated = params.entry;
+        const rawDm = updated.dm;
+        const dm = isRecord(rawDm) ? structuredClone(rawDm) : null;
+        let dmChanged = false;
+        const allowFromEqual = (a, b) => {
+            if (!Array.isArray(a) || !Array.isArray(b)) {
+                return false;
+            }
+            const na = a.map((v) => String(v).trim()).filter(Boolean);
+            const nb = b.map((v) => String(v).trim()).filter(Boolean);
+            if (na.length !== nb.length) {
+                return false;
+            }
+            return na.every((v, i) => v === nb[i]);
+        };
+        const topDmPolicy = updated.dmPolicy;
+        const legacyDmPolicy = dm?.policy;
+        if (topDmPolicy === undefined && legacyDmPolicy !== undefined) {
+            updated = { ...updated, dmPolicy: legacyDmPolicy };
+            changed = true;
+            if (dm) {
+                delete dm.policy;
+                dmChanged = true;
+            }
+            changes.push(`Moved ${params.pathPrefix}.dm.policy → ${params.pathPrefix}.dmPolicy.`);
+        }
+        else if (topDmPolicy !== undefined && legacyDmPolicy !== undefined) {
+            if (topDmPolicy === legacyDmPolicy) {
+                if (dm) {
+                    delete dm.policy;
+                    dmChanged = true;
+                    changes.push(`Removed ${params.pathPrefix}.dm.policy (dmPolicy already set).`);
+                }
+            }
+        }
+        const topAllowFrom = updated.allowFrom;
+        const legacyAllowFrom = dm?.allowFrom;
+        if (topAllowFrom === undefined && legacyAllowFrom !== undefined) {
+            updated = { ...updated, allowFrom: legacyAllowFrom };
+            changed = true;
+            if (dm) {
+                delete dm.allowFrom;
+                dmChanged = true;
+            }
+            changes.push(`Moved ${params.pathPrefix}.dm.allowFrom → ${params.pathPrefix}.allowFrom.`);
+        }
+        else if (topAllowFrom !== undefined && legacyAllowFrom !== undefined) {
+            if (allowFromEqual(topAllowFrom, legacyAllowFrom)) {
+                if (dm) {
+                    delete dm.allowFrom;
+                    dmChanged = true;
+                    changes.push(`Removed ${params.pathPrefix}.dm.allowFrom (allowFrom already set).`);
+                }
+            }
+        }
+        if (dm && isRecord(rawDm) && dmChanged) {
+            const keys = Object.keys(dm);
+            if (keys.length === 0) {
+                if (updated.dm !== undefined) {
+                    const { dm: _ignored, ...rest } = updated;
+                    updated = rest;
+                    changed = true;
+                    changes.push(`Removed empty ${params.pathPrefix}.dm after migration.`);
+                }
+            }
+            else {
+                updated = { ...updated, dm };
+                changed = true;
+            }
+        }
+        return { entry: updated, changed };
+    };
+    const normalizeTelegramStreamingAliases = (params) => {
+        let updated = params.entry;
+        const hadLegacyStreamMode = updated.streamMode !== undefined;
+        const beforeStreaming = updated.streaming;
+        const resolved = resolveTelegramPreviewStreamMode(updated);
+        const shouldNormalize = hadLegacyStreamMode ||
+            typeof beforeStreaming === "boolean" ||
+            (typeof beforeStreaming === "string" && beforeStreaming !== resolved);
+        if (!shouldNormalize) {
+            return { entry: updated, changed: false };
+        }
+        let changed = false;
+        if (beforeStreaming !== resolved) {
+            updated = { ...updated, streaming: resolved };
+            changed = true;
+        }
+        if (hadLegacyStreamMode) {
+            const { streamMode: _ignored, ...rest } = updated;
+            updated = rest;
+            changed = true;
+            changes.push(`Moved ${params.pathPrefix}.streamMode → ${params.pathPrefix}.streaming (${resolved}).`);
+        }
+        if (typeof beforeStreaming === "boolean") {
+            changes.push(`Normalized ${params.pathPrefix}.streaming boolean → enum (${resolved}).`);
+        }
+        else if (typeof beforeStreaming === "string" && beforeStreaming !== resolved) {
+            changes.push(`Normalized ${params.pathPrefix}.streaming (${beforeStreaming}) → (${resolved}).`);
+        }
+        return { entry: updated, changed };
+    };
+    const normalizeDiscordStreamingAliases = (params) => {
+        let updated = params.entry;
+        const hadLegacyStreamMode = updated.streamMode !== undefined;
+        const beforeStreaming = updated.streaming;
+        const resolved = resolveDiscordPreviewStreamMode(updated);
+        const shouldNormalize = hadLegacyStreamMode ||
+            typeof beforeStreaming === "boolean" ||
+            (typeof beforeStreaming === "string" && beforeStreaming !== resolved);
+        if (!shouldNormalize) {
+            return { entry: updated, changed: false };
+        }
+        let changed = false;
+        if (beforeStreaming !== resolved) {
+            updated = { ...updated, streaming: resolved };
+            changed = true;
+        }
+        if (hadLegacyStreamMode) {
+            const { streamMode: _ignored, ...rest } = updated;
+            updated = rest;
+            changed = true;
+            changes.push(`Moved ${params.pathPrefix}.streamMode → ${params.pathPrefix}.streaming (${resolved}).`);
+        }
+        if (typeof beforeStreaming === "boolean") {
+            changes.push(`Normalized ${params.pathPrefix}.streaming boolean → enum (${resolved}).`);
+        }
+        else if (typeof beforeStreaming === "string" && beforeStreaming !== resolved) {
+            changes.push(`Normalized ${params.pathPrefix}.streaming (${beforeStreaming}) → (${resolved}).`);
+        }
+        return { entry: updated, changed };
+    };
+    const normalizeSlackStreamingAliases = (params) => {
+        let updated = params.entry;
+        const hadLegacyStreamMode = updated.streamMode !== undefined;
+        const legacyStreaming = updated.streaming;
+        const beforeStreaming = updated.streaming;
+        const beforeNativeStreaming = updated.nativeStreaming;
+        const resolvedStreaming = resolveSlackStreamingMode(updated);
+        const resolvedNativeStreaming = resolveSlackNativeStreaming(updated);
+        const shouldNormalize = hadLegacyStreamMode ||
+            typeof legacyStreaming === "boolean" ||
+            (typeof legacyStreaming === "string" && legacyStreaming !== resolvedStreaming);
+        if (!shouldNormalize) {
+            return { entry: updated, changed: false };
+        }
+        let changed = false;
+        if (beforeStreaming !== resolvedStreaming) {
+            updated = { ...updated, streaming: resolvedStreaming };
+            changed = true;
+        }
+        if (typeof beforeNativeStreaming !== "boolean" ||
+            beforeNativeStreaming !== resolvedNativeStreaming) {
+            updated = { ...updated, nativeStreaming: resolvedNativeStreaming };
+            changed = true;
+        }
+        if (hadLegacyStreamMode) {
+            const { streamMode: _ignored, ...rest } = updated;
+            updated = rest;
+            changed = true;
+            changes.push(`Moved ${params.pathPrefix}.streamMode → ${params.pathPrefix}.streaming (${resolvedStreaming}).`);
+        }
+        if (typeof legacyStreaming === "boolean") {
+            changes.push(`Moved ${params.pathPrefix}.streaming (boolean) → ${params.pathPrefix}.nativeStreaming (${resolvedNativeStreaming}).`);
+        }
+        else if (typeof legacyStreaming === "string" && legacyStreaming !== resolvedStreaming) {
+            changes.push(`Normalized ${params.pathPrefix}.streaming (${legacyStreaming}) → (${resolvedStreaming}).`);
+        }
+        return { entry: updated, changed };
+    };
+    const normalizeProvider = (provider) => {
+        const channels = next.channels;
+        const rawEntry = channels?.[provider];
+        if (!isRecord(rawEntry)) {
+            return;
+        }
+        let updated = rawEntry;
+        let changed = false;
+        if (provider !== "telegram") {
+            const base = normalizeDmAliases({
+                provider,
+                entry: rawEntry,
+                pathPrefix: `channels.${provider}`,
+            });
+            updated = base.entry;
+            changed = base.changed;
+        }
+        if (provider === "telegram") {
+            const streaming = normalizeTelegramStreamingAliases({
+                entry: updated,
+                pathPrefix: `channels.${provider}`,
+            });
+            updated = streaming.entry;
+            changed = changed || streaming.changed;
+        }
+        else if (provider === "discord") {
+            const streaming = normalizeDiscordStreamingAliases({
+                entry: updated,
+                pathPrefix: `channels.${provider}`,
+            });
+            updated = streaming.entry;
+            changed = changed || streaming.changed;
+        }
+        else if (provider === "slack") {
+            const streaming = normalizeSlackStreamingAliases({
+                entry: updated,
+                pathPrefix: `channels.${provider}`,
+            });
+            updated = streaming.entry;
+            changed = changed || streaming.changed;
+        }
+        const rawAccounts = updated.accounts;
+        if (isRecord(rawAccounts)) {
+            let accountsChanged = false;
+            const accounts = { ...rawAccounts };
+            for (const [accountId, rawAccount] of Object.entries(rawAccounts)) {
+                if (!isRecord(rawAccount)) {
+                    continue;
+                }
+                let accountEntry = rawAccount;
+                let accountChanged = false;
+                if (provider !== "telegram") {
+                    const res = normalizeDmAliases({
+                        provider,
+                        entry: rawAccount,
+                        pathPrefix: `channels.${provider}.accounts.${accountId}`,
+                    });
+                    accountEntry = res.entry;
+                    accountChanged = res.changed;
+                }
+                if (provider === "telegram") {
+                    const streaming = normalizeTelegramStreamingAliases({
+                        entry: accountEntry,
+                        pathPrefix: `channels.${provider}.accounts.${accountId}`,
+                    });
+                    accountEntry = streaming.entry;
+                    accountChanged = accountChanged || streaming.changed;
+                }
+                else if (provider === "discord") {
+                    const streaming = normalizeDiscordStreamingAliases({
+                        entry: accountEntry,
+                        pathPrefix: `channels.${provider}.accounts.${accountId}`,
+                    });
+                    accountEntry = streaming.entry;
+                    accountChanged = accountChanged || streaming.changed;
+                }
+                else if (provider === "slack") {
+                    const streaming = normalizeSlackStreamingAliases({
+                        entry: accountEntry,
+                        pathPrefix: `channels.${provider}.accounts.${accountId}`,
+                    });
+                    accountEntry = streaming.entry;
+                    accountChanged = accountChanged || streaming.changed;
+                }
+                if (accountChanged) {
+                    accounts[accountId] = accountEntry;
+                    accountsChanged = true;
+                }
+            }
+            if (accountsChanged) {
+                updated = { ...updated, accounts };
+                changed = true;
+            }
+        }
+        if (changed) {
+            next = {
+                ...next,
+                channels: {
+                    ...next.channels,
+                    [provider]: updated,
+                },
+            };
+        }
+    };
+    normalizeProvider("telegram");
+    normalizeProvider("slack");
+    normalizeProvider("discord");
     const legacyAckReaction = cfg.messages?.ackReaction?.trim();
     const hasWhatsAppConfig = cfg.channels?.whatsapp !== undefined;
     if (legacyAckReaction && hasWhatsAppConfig) {