@poolzin/pool-bot 2026.3.30 → 2026.3.32

package/dist/dist/cli/update-cli/wizard.js

@@ -0,0 +1,124 @@
+import { confirm, isCancel } from "@clack/prompts";
+import { readConfigFileSnapshot } from "../../config/config.js";
+import { formatUpdateChannelLabel, normalizeUpdateChannel, resolveEffectiveUpdateChannel, } from "../../infra/update-channels.js";
+import { checkUpdateStatus } from "../../infra/update-check.js";
+import { defaultRuntime } from "../../runtime.js";
+import { selectStyled } from "../../terminal/prompt-select-styled.js";
+import { stylePromptMessage } from "../../terminal/prompt-style.js";
+import { theme } from "../../terminal/theme.js";
+import { pathExists } from "../../utils.js";
+import { isEmptyDir, isGitCheckout, parseTimeoutMsOrExit, resolveGitInstallDir, resolveUpdateRoot, } from "./shared.js";
+import { updateCommand } from "./update-command.js";
+export async function updateWizardCommand(opts = {}) {
+    if (!process.stdin.isTTY) {
+        defaultRuntime.error("Update wizard requires a TTY. Use `poolbot update --channel <stable|beta|dev>` instead.");
+        defaultRuntime.exit(1);
+        return;
+    }
+    const timeoutMs = parseTimeoutMsOrExit(opts.timeout);
+    if (timeoutMs === null) {
+        return;
+    }
+    const root = await resolveUpdateRoot();
+    const [updateStatus, configSnapshot] = await Promise.all([
+        checkUpdateStatus({
+            root,
+            timeoutMs: timeoutMs ?? 3500,
+            fetchGit: false,
+            includeRegistry: false,
+        }),
+        readConfigFileSnapshot(),
+    ]);
+    const configChannel = configSnapshot.valid
+        ? normalizeUpdateChannel(configSnapshot.config.update?.channel)
+        : null;
+    const channelInfo = resolveEffectiveUpdateChannel({
+        configChannel,
+        installKind: updateStatus.installKind,
+        git: updateStatus.git
+            ? { tag: updateStatus.git.tag, branch: updateStatus.git.branch }
+            : undefined,
+    });
+    const channelLabel = formatUpdateChannelLabel({
+        channel: channelInfo.channel,
+        source: channelInfo.source,
+        gitTag: updateStatus.git?.tag ?? null,
+        gitBranch: updateStatus.git?.branch ?? null,
+    });
+    const pickedChannel = await selectStyled({
+        message: "Update channel",
+        options: [
+            {
+                value: "keep",
+                label: `Keep current (${channelInfo.channel})`,
+                hint: channelLabel,
+            },
+            {
+                value: "stable",
+                label: "Stable",
+                hint: "Tagged releases (npm latest)",
+            },
+            {
+                value: "beta",
+                label: "Beta",
+                hint: "Prereleases (npm beta)",
+            },
+            {
+                value: "dev",
+                label: "Dev",
+                hint: "Git main",
+            },
+        ],
+        initialValue: "keep",
+    });
+    if (isCancel(pickedChannel)) {
+        defaultRuntime.log(theme.muted("Update cancelled."));
+        defaultRuntime.exit(0);
+        return;
+    }
+    const requestedChannel = pickedChannel === "keep" ? null : pickedChannel;
+    if (requestedChannel === "dev" && updateStatus.installKind !== "git") {
+        const gitDir = resolveGitInstallDir();
+        const hasGit = await isGitCheckout(gitDir);
+        if (!hasGit) {
+            const dirExists = await pathExists(gitDir);
+            if (dirExists) {
+                const empty = await isEmptyDir(gitDir);
+                if (!empty) {
+                    defaultRuntime.error(`POOLBOT_GIT_DIR points at a non-git directory: ${gitDir}. Set POOLBOT_GIT_DIR to an empty folder or an poolbot checkout.`);
+                    defaultRuntime.exit(1);
+                    return;
+                }
+            }
+            const ok = await confirm({
+                message: stylePromptMessage(`Create a git checkout at ${gitDir}? (override via POOLBOT_GIT_DIR)`),
+                initialValue: true,
+            });
+            if (isCancel(ok) || !ok) {
+                defaultRuntime.log(theme.muted("Update cancelled."));
+                defaultRuntime.exit(0);
+                return;
+            }
+        }
+    }
+    const restart = await confirm({
+        message: stylePromptMessage("Restart the gateway service after update?"),
+        initialValue: true,
+    });
+    if (isCancel(restart)) {
+        defaultRuntime.log(theme.muted("Update cancelled."));
+        defaultRuntime.exit(0);
+        return;
+    }
+    try {
+        await updateCommand({
+            channel: requestedChannel ?? undefined,
+            restart: Boolean(restart),
+            timeout: opts.timeout,
+        });
+    }
+    catch (err) {
+        defaultRuntime.error(String(err));
+        defaultRuntime.exit(1);
+    }
+}

package/dist/dist/cli/update-cli.js

@@ -0,0 +1,124 @@
+import { defaultRuntime } from "../runtime.js";
+import { formatDocsLink } from "../terminal/links.js";
+import { theme } from "../terminal/theme.js";
+import { inheritOptionFromParent } from "./command-options.js";
+import { formatHelpExamples } from "./help-format.js";
+import { updateStatusCommand } from "./update-cli/status.js";
+import { updateCommand } from "./update-cli/update-command.js";
+import { updateWizardCommand } from "./update-cli/wizard.js";
+export { updateCommand, updateStatusCommand, updateWizardCommand };
+function inheritedUpdateJson(command) {
+    return Boolean(inheritOptionFromParent(command, "json"));
+}
+function inheritedUpdateTimeout(opts, command) {
+    const timeout = opts.timeout;
+    if (timeout) {
+        return timeout;
+    }
+    return inheritOptionFromParent(command, "timeout");
+}
+export function registerUpdateCli(program) {
+    const update = program
+        .command("update")
+        .description("Update Pool Bot and inspect update channel status")
+        .option("--json", "Output result as JSON", false)
+        .option("--no-restart", "Skip restarting the gateway service after a successful update")
+        .option("--channel <stable|beta|dev>", "Persist update channel (git + npm)")
+        .option("--tag <dist-tag|version>", "Override npm dist-tag or version for this update")
+        .option("--timeout <seconds>", "Timeout for each update step in seconds (default: 1200)")
+        .option("--yes", "Skip confirmation prompts (non-interactive)", false)
+        .addHelpText("after", () => {
+        const examples = [
+            ["poolbot update", "Update a source checkout (git)"],
+            ["poolbot update --channel beta", "Switch to beta channel (git + npm)"],
+            ["poolbot update --channel dev", "Switch to dev channel (git + npm)"],
+            ["poolbot update --tag beta", "One-off update to a dist-tag or version"],
+            ["poolbot update --no-restart", "Update without restarting the service"],
+            ["poolbot update --json", "Output result as JSON"],
+            ["poolbot update --yes", "Non-interactive (accept downgrade prompts)"],
+            ["poolbot update wizard", "Interactive update wizard"],
+            ["poolbot --update", "Shorthand for poolbot update"],
+        ];
+        const fmtExamples = examples
+            .map(([cmd, desc]) => `  ${theme.command(cmd)} ${theme.muted(`# ${desc}`)}`)
+            .join("\n");
+        return `
+${theme.heading("What this does:")}
+  - Git checkouts: fetches, rebases, installs deps, builds, and runs doctor
+  - npm installs: updates via detected package manager
+
+${theme.heading("Switch channels:")}
+  - Use --channel stable|beta|dev to persist the update channel in config
+  - Run poolbot update status to see the active channel and source
+  - Use --tag <dist-tag|version> for a one-off npm update without persisting
+
+${theme.heading("Non-interactive:")}
+  - Use --yes to accept downgrade prompts
+  - Combine with --channel/--tag/--restart/--json/--timeout as needed
+
+${theme.heading("Examples:")}
+${fmtExamples}
+
+${theme.heading("Notes:")}
+  - Switch channels with --channel stable|beta|dev
+  - For global installs: auto-updates via detected package manager when possible (see docs/install/updating.md)
+  - Downgrades require confirmation (can break configuration)
+  - Skips update if the working directory has uncommitted changes
+
+${theme.muted("Docs:")} ${formatDocsLink("/cli/update", "docs.poolbot.dev/cli/update")}`;
+    })
+        .action(async (opts) => {
+        try {
+            await updateCommand({
+                json: Boolean(opts.json),
+                restart: Boolean(opts.restart),
+                channel: opts.channel,
+                tag: opts.tag,
+                timeout: opts.timeout,
+                yes: Boolean(opts.yes),
+            });
+        }
+        catch (err) {
+            defaultRuntime.error(String(err));
+            defaultRuntime.exit(1);
+        }
+    });
+    update
+        .command("wizard")
+        .description("Interactive update wizard")
+        .option("--timeout <seconds>", "Timeout for each update step in seconds (default: 1200)")
+        .addHelpText("after", `\n${theme.muted("Docs:")} ${formatDocsLink("/cli/update", "docs.poolbot.dev/cli/update")}\n`)
+        .action(async (opts, command) => {
+        try {
+            await updateWizardCommand({
+                timeout: inheritedUpdateTimeout(opts, command),
+            });
+        }
+        catch (err) {
+            defaultRuntime.error(String(err));
+            defaultRuntime.exit(1);
+        }
+    });
+    update
+        .command("status")
+        .description("Show update channel and version status")
+        .option("--json", "Output result as JSON", false)
+        .option("--timeout <seconds>", "Timeout for update checks in seconds (default: 3)")
+        .addHelpText("after", () => `\n${theme.heading("Examples:")}\n${formatHelpExamples([
+        ["poolbot update status", "Show channel + version status."],
+        ["poolbot update status --json", "JSON output."],
+        ["poolbot update status --timeout 10", "Custom timeout."],
+    ])}\n\n${theme.heading("Notes:")}\n${theme.muted("- Shows current update channel (stable/beta/dev) and source")}\n${theme.muted("- Includes git tag/branch/SHA for source checkouts")}\n\n${theme.muted("Docs:")} ${formatDocsLink("/cli/update", "docs.poolbot.dev/cli/update")}`)
+        .action(async (opts, command) => {
+        try {
+            await updateStatusCommand({
+                json: Boolean(opts.json) || inheritedUpdateJson(command),
+                timeout: inheritedUpdateTimeout(opts, command),
+            });
+        }
+        catch (err) {
+            defaultRuntime.error(String(err));
+            defaultRuntime.exit(1);
+        }
+    });
+}

package/dist/dist/cli/wait.js

@@ -0,0 +1,8 @@
+export function waitForever() {
+    // Keep event loop alive via an unref'ed interval plus a pending promise.
+    const interval = setInterval(() => { }, 1_000_000);
+    interval.unref();
+    return new Promise(() => {
+        /* never resolve */
+    });
+}

package/dist/dist/cli/webhooks-cli.js

@@ -0,0 +1,140 @@
+import { danger } from "../globals.js";
+import { DEFAULT_GMAIL_LABEL, DEFAULT_GMAIL_MAX_BYTES, DEFAULT_GMAIL_RENEW_MINUTES, DEFAULT_GMAIL_SERVE_BIND, DEFAULT_GMAIL_SERVE_PATH, DEFAULT_GMAIL_SERVE_PORT, DEFAULT_GMAIL_SUBSCRIPTION, DEFAULT_GMAIL_TOPIC, } from "../hooks/gmail.js";
+import { runGmailService, runGmailSetup, } from "../hooks/gmail-ops.js";
+import { defaultRuntime } from "../runtime.js";
+import { formatDocsLink } from "../terminal/links.js";
+import { theme } from "../terminal/theme.js";
+export function registerWebhooksCli(program) {
+    const webhooks = program
+        .command("webhooks")
+        .description("Webhook helpers and integrations")
+        .addHelpText("after", () => `\n${theme.muted("Docs:")} ${formatDocsLink("/cli/webhooks", "docs.molt.bot/cli/webhooks")}\n`);
+    const gmail = webhooks.command("gmail").description("Gmail Pub/Sub hooks (via gogcli)");
+    gmail
+        .command("setup")
+        .description("Configure Gmail watch + Pub/Sub + Poolbot hooks")
+        .requiredOption("--account <email>", "Gmail account to watch")
+        .option("--project <id>", "GCP project id (OAuth client owner)")
+        .option("--topic <name>", "Pub/Sub topic name", DEFAULT_GMAIL_TOPIC)
+        .option("--subscription <name>", "Pub/Sub subscription name", DEFAULT_GMAIL_SUBSCRIPTION)
+        .option("--label <label>", "Gmail label to watch", DEFAULT_GMAIL_LABEL)
+        .option("--hook-url <url>", "Poolbot hook URL")
+        .option("--hook-token <token>", "Poolbot hook token")
+        .option("--push-token <token>", "Push token for gog watch serve")
+        .option("--bind <host>", "gog watch serve bind host", DEFAULT_GMAIL_SERVE_BIND)
+        .option("--port <port>", "gog watch serve port", String(DEFAULT_GMAIL_SERVE_PORT))
+        .option("--path <path>", "gog watch serve path", DEFAULT_GMAIL_SERVE_PATH)
+        .option("--include-body", "Include email body snippets", true)
+        .option("--max-bytes <n>", "Max bytes for body snippets", String(DEFAULT_GMAIL_MAX_BYTES))
+        .option("--renew-minutes <n>", "Renew watch every N minutes", String(DEFAULT_GMAIL_RENEW_MINUTES))
+        .option("--tailscale <mode>", "Expose push endpoint via tailscale (funnel|serve|off)", "funnel")
+        .option("--tailscale-path <path>", "Path for tailscale serve/funnel")
+        .option("--tailscale-target <target>", "Tailscale serve/funnel target (port, host:port, or URL)")
+        .option("--push-endpoint <url>", "Explicit Pub/Sub push endpoint")
+        .option("--json", "Output JSON summary", false)
+        .action(async (opts) => {
+        try {
+            const parsed = parseGmailSetupOptions(opts);
+            await runGmailSetup(parsed);
+        }
+        catch (err) {
+            defaultRuntime.error(danger(String(err)));
+            defaultRuntime.exit(1);
+        }
+    });
+    gmail
+        .command("run")
+        .description("Run gog watch serve + auto-renew loop")
+        .option("--account <email>", "Gmail account to watch")
+        .option("--topic <topic>", "Pub/Sub topic path (projects/.../topics/..)")
+        .option("--subscription <name>", "Pub/Sub subscription name")
+        .option("--label <label>", "Gmail label to watch")
+        .option("--hook-url <url>", "Poolbot hook URL")
+        .option("--hook-token <token>", "Poolbot hook token")
+        .option("--push-token <token>", "Push token for gog watch serve")
+        .option("--bind <host>", "gog watch serve bind host")
+        .option("--port <port>", "gog watch serve port")
+        .option("--path <path>", "gog watch serve path")
+        .option("--include-body", "Include email body snippets")
+        .option("--max-bytes <n>", "Max bytes for body snippets")
+        .option("--renew-minutes <n>", "Renew watch every N minutes")
+        .option("--tailscale <mode>", "Expose push endpoint via tailscale (funnel|serve|off)")
+        .option("--tailscale-path <path>", "Path for tailscale serve/funnel")
+        .option("--tailscale-target <target>", "Tailscale serve/funnel target (port, host:port, or URL)")
+        .action(async (opts) => {
+        try {
+            const parsed = parseGmailRunOptions(opts);
+            await runGmailService(parsed);
+        }
+        catch (err) {
+            defaultRuntime.error(danger(String(err)));
+            defaultRuntime.exit(1);
+        }
+    });
+}
+function parseGmailSetupOptions(raw) {
+    const accountRaw = raw.account;
+    const account = typeof accountRaw === "string" ? accountRaw.trim() : "";
+    if (!account)
+        throw new Error("--account is required");
+    return {
+        account,
+        project: stringOption(raw.project),
+        topic: stringOption(raw.topic),
+        subscription: stringOption(raw.subscription),
+        label: stringOption(raw.label),
+        hookUrl: stringOption(raw.hookUrl),
+        hookToken: stringOption(raw.hookToken),
+        pushToken: stringOption(raw.pushToken),
+        bind: stringOption(raw.bind),
+        port: numberOption(raw.port),
+        path: stringOption(raw.path),
+        includeBody: booleanOption(raw.includeBody),
+        maxBytes: numberOption(raw.maxBytes),
+        renewEveryMinutes: numberOption(raw.renewMinutes),
+        tailscale: stringOption(raw.tailscale),
+        tailscalePath: stringOption(raw.tailscalePath),
+        tailscaleTarget: stringOption(raw.tailscaleTarget),
+        pushEndpoint: stringOption(raw.pushEndpoint),
+        json: Boolean(raw.json),
+    };
+}
+function parseGmailRunOptions(raw) {
+    return {
+        account: stringOption(raw.account),
+        topic: stringOption(raw.topic),
+        subscription: stringOption(raw.subscription),
+        label: stringOption(raw.label),
+        hookUrl: stringOption(raw.hookUrl),
+        hookToken: stringOption(raw.hookToken),
+        pushToken: stringOption(raw.pushToken),
+        bind: stringOption(raw.bind),
+        port: numberOption(raw.port),
+        path: stringOption(raw.path),
+        includeBody: booleanOption(raw.includeBody),
+        maxBytes: numberOption(raw.maxBytes),
+        renewEveryMinutes: numberOption(raw.renewMinutes),
+        tailscale: stringOption(raw.tailscale),
+        tailscalePath: stringOption(raw.tailscalePath),
+        tailscaleTarget: stringOption(raw.tailscaleTarget),
+    };
+}
+function stringOption(value) {
+    if (typeof value !== "string")
+        return undefined;
+    const trimmed = value.trim();
+    return trimmed ? trimmed : undefined;
+}
+function numberOption(value) {
+    if (value === undefined || value === null)
+        return undefined;
+    const n = typeof value === "number" ? value : Number(value);
+    if (!Number.isFinite(n) || n <= 0)
+        return undefined;
+    return Math.floor(n);
+}
+function booleanOption(value) {
+    if (value === undefined || value === null)
+        return undefined;
+    return Boolean(value);
+}

package/dist/dist/cli/windows-argv.js

@@ -0,0 +1,69 @@
+import fs from "node:fs";
+import path from "node:path";
+export function normalizeWindowsArgv(argv) {
+    if (process.platform !== "win32") {
+        return argv;
+    }
+    if (argv.length < 2) {
+        return argv;
+    }
+    const stripControlChars = (value) => {
+        let out = "";
+        for (let i = 0; i < value.length; i += 1) {
+            const code = value.charCodeAt(i);
+            if (code >= 32 && code !== 127) {
+                out += value[i];
+            }
+        }
+        return out;
+    };
+    const normalizeArg = (value) => stripControlChars(value)
+        .replace(/^['"]+|['"]+$/g, "")
+        .trim();
+    const normalizeCandidate = (value) => normalizeArg(value).replace(/^\\\\\\?\\/, "");
+    const execPath = normalizeCandidate(process.execPath);
+    const execPathLower = execPath.toLowerCase();
+    const execBase = path.basename(execPath).toLowerCase();
+    const isExecPath = (value) => {
+        if (!value) {
+            return false;
+        }
+        const normalized = normalizeCandidate(value);
+        if (!normalized) {
+            return false;
+        }
+        const lower = normalized.toLowerCase();
+        return (lower === execPathLower ||
+            path.basename(lower) === execBase ||
+            lower.endsWith("\\node.exe") ||
+            lower.endsWith("/node.exe") ||
+            lower.includes("node.exe") ||
+            (path.basename(lower) === "node.exe" && fs.existsSync(normalized)));
+    };
+    const next = [...argv];
+    for (let i = 1; i <= 3 && i < next.length;) {
+        if (isExecPath(next[i])) {
+            next.splice(i, 1);
+            continue;
+        }
+        i += 1;
+    }
+    const filtered = next.filter((arg, index) => index === 0 || !isExecPath(arg));
+    if (filtered.length < 3) {
+        return filtered;
+    }
+    const cleaned = [...filtered];
+    for (let i = 2; i < cleaned.length;) {
+        const arg = cleaned[i];
+        if (!arg || arg.startsWith("-")) {
+            i += 1;
+            continue;
+        }
+        if (isExecPath(arg)) {
+            cleaned.splice(i, 1);
+            continue;
+        }
+        break;
+    }
+    return cleaned;
+}

package/dist/dist/cli.disabled/acp-cli.js

@@ -0,0 +1,63 @@
+import { runAcpClientInteractive } from "../acp/client.js";
+import { serveAcpGateway } from "../acp/server.js";
+import { defaultRuntime } from "../runtime.js";
+import { formatDocsLink } from "../terminal/links.js";
+import { theme } from "../terminal/theme.js";
+import { inheritOptionFromParent } from "./command-options.js";
+export function registerAcpCli(program) {
+    const acp = program.command("acp").description("Run an ACP bridge backed by the Gateway");
+    acp
+        .option("--url <url>", "Gateway WebSocket URL (defaults to gateway.remote.url when configured)")
+        .option("--token <token>", "Gateway token (if required)")
+        .option("--password <password>", "Gateway password (if required)")
+        .option("--session <key>", "Default session key (e.g. agent:main:main)")
+        .option("--session-label <label>", "Default session label to resolve")
+        .option("--require-existing", "Fail if the session key/label does not exist", false)
+        .option("--reset-session", "Reset the session key before first use", false)
+        .option("--no-prefix-cwd", "Do not prefix prompts with the working directory", false)
+        .option("--verbose, -v", "Verbose logging to stderr", false)
+        .addHelpText("after", () => `\n${theme.muted("Docs:")} ${formatDocsLink("/cli/acp", "docs.poolbot.dev/cli/acp")}\n`)
+        .action(async (opts) => {
+        try {
+            await serveAcpGateway({
+                gatewayUrl: opts.url,
+                gatewayToken: opts.token,
+                gatewayPassword: opts.password,
+                defaultSessionKey: opts.session,
+                defaultSessionLabel: opts.sessionLabel,
+                requireExistingSession: Boolean(opts.requireExisting),
+                resetSession: Boolean(opts.resetSession),
+                prefixCwd: !opts.noPrefixCwd,
+                verbose: Boolean(opts.verbose),
+            });
+        }
+        catch (err) {
+            defaultRuntime.error(String(err));
+            defaultRuntime.exit(1);
+        }
+    });
+    acp
+        .command("client")
+        .description("Run an interactive ACP client against the local ACP bridge")
+        .option("--cwd <dir>", "Working directory for the ACP session")
+        .option("--server <command>", "ACP server command (default: poolbot)")
+        .option("--server-args <args...>", "Extra arguments for the ACP server")
+        .option("--server-verbose", "Enable verbose logging on the ACP server", false)
+        .option("--verbose, -v", "Verbose client logging", false)
+        .action(async (opts, command) => {
+        const inheritedVerbose = inheritOptionFromParent(command, "verbose");
+        try {
+            await runAcpClientInteractive({
+                cwd: opts.cwd,
+                serverCommand: opts.server,
+                serverArgs: opts.serverArgs,
+                serverVerbose: Boolean(opts.serverVerbose),
+                verbose: Boolean(opts.verbose || inheritedVerbose),
+            });
+        }
+        catch (err) {
+            defaultRuntime.error(String(err));
+            defaultRuntime.exit(1);
+        }
+    });
+}