@poolzin/pool-bot 2026.2.11 → 2026.2.18

package/dist/cli/daemon-cli/lifecycle-core.js

@@ -0,0 +1,256 @@
+import { loadConfig } from "../../config/config.js";
+import { resolveIsNixMode } from "../../config/paths.js";
+import { checkTokenDrift } from "../../daemon/service-audit.js";
+import { renderSystemdUnavailableHints } from "../../daemon/systemd-hints.js";
+import { isSystemdUserServiceAvailable } from "../../daemon/systemd.js";
+import { isWSL } from "../../infra/wsl.js";
+import { defaultRuntime } from "../../runtime.js";
+import { buildDaemonServiceSnapshot, createNullWriter, emitDaemonActionJson, } from "./response.js";
+async function maybeAugmentSystemdHints(hints) {
+    if (process.platform !== "linux") {
+        return hints;
+    }
+    const systemdAvailable = await isSystemdUserServiceAvailable().catch(() => false);
+    if (systemdAvailable) {
+        return hints;
+    }
+    return [...hints, ...renderSystemdUnavailableHints({ wsl: await isWSL() })];
+}
+function createActionIO(params) {
+    const stdout = params.json ? createNullWriter() : process.stdout;
+    const emit = (payload) => {
+        if (!params.json) {
+            return;
+        }
+        emitDaemonActionJson({ action: params.action, ...payload });
+    };
+    const fail = (message, hints) => {
+        if (params.json) {
+            emit({ ok: false, error: message, hints });
+        }
+        else {
+            defaultRuntime.error(message);
+        }
+        defaultRuntime.exit(1);
+    };
+    return { stdout, emit, fail };
+}
+async function handleServiceNotLoaded(params) {
+    const hints = await maybeAugmentSystemdHints(params.renderStartHints());
+    params.emit({
+        ok: true,
+        result: "not-loaded",
+        message: `${params.serviceNoun} service ${params.service.notLoadedText}.`,
+        hints,
+        service: buildDaemonServiceSnapshot(params.service, params.loaded),
+    });
+    if (!params.json) {
+        defaultRuntime.log(`${params.serviceNoun} service ${params.service.notLoadedText}.`);
+        for (const hint of hints) {
+            defaultRuntime.log(`Start with: ${hint}`);
+        }
+    }
+}
+export async function runServiceUninstall(params) {
+    const json = Boolean(params.opts?.json);
+    const { stdout, emit, fail } = createActionIO({ action: "uninstall", json });
+    if (resolveIsNixMode(process.env)) {
+        fail("Nix mode detected; service uninstall is disabled.");
+        return;
+    }
+    let loaded = false;
+    try {
+        loaded = await params.service.isLoaded({ env: process.env });
+    }
+    catch {
+        loaded = false;
+    }
+    if (loaded && params.stopBeforeUninstall) {
+        try {
+            await params.service.stop({ env: process.env, stdout });
+        }
+        catch {
+            // Best-effort stop; final loaded check gates success when enabled.
+        }
+    }
+    try {
+        await params.service.uninstall({ env: process.env, stdout });
+    }
+    catch (err) {
+        fail(`${params.serviceNoun} uninstall failed: ${String(err)}`);
+        return;
+    }
+    loaded = false;
+    try {
+        loaded = await params.service.isLoaded({ env: process.env });
+    }
+    catch {
+        loaded = false;
+    }
+    if (loaded && params.assertNotLoadedAfterUninstall) {
+        fail(`${params.serviceNoun} service still loaded after uninstall.`);
+        return;
+    }
+    emit({
+        ok: true,
+        result: "uninstalled",
+        service: buildDaemonServiceSnapshot(params.service, loaded),
+    });
+}
+export async function runServiceStart(params) {
+    const json = Boolean(params.opts?.json);
+    const { stdout, emit, fail } = createActionIO({ action: "start", json });
+    let loaded = false;
+    try {
+        loaded = await params.service.isLoaded({ env: process.env });
+    }
+    catch (err) {
+        fail(`${params.serviceNoun} service check failed: ${String(err)}`);
+        return;
+    }
+    if (!loaded) {
+        await handleServiceNotLoaded({
+            serviceNoun: params.serviceNoun,
+            service: params.service,
+            loaded,
+            renderStartHints: params.renderStartHints,
+            json,
+            emit,
+        });
+        return;
+    }
+    try {
+        await params.service.restart({ env: process.env, stdout });
+    }
+    catch (err) {
+        const hints = params.renderStartHints();
+        fail(`${params.serviceNoun} start failed: ${String(err)}`, hints);
+        return;
+    }
+    let started = true;
+    try {
+        started = await params.service.isLoaded({ env: process.env });
+    }
+    catch {
+        started = true;
+    }
+    emit({
+        ok: true,
+        result: "started",
+        service: buildDaemonServiceSnapshot(params.service, started),
+    });
+}
+export async function runServiceStop(params) {
+    const json = Boolean(params.opts?.json);
+    const { stdout, emit, fail } = createActionIO({ action: "stop", json });
+    let loaded = false;
+    try {
+        loaded = await params.service.isLoaded({ env: process.env });
+    }
+    catch (err) {
+        fail(`${params.serviceNoun} service check failed: ${String(err)}`);
+        return;
+    }
+    if (!loaded) {
+        emit({
+            ok: true,
+            result: "not-loaded",
+            message: `${params.serviceNoun} service ${params.service.notLoadedText}.`,
+            service: buildDaemonServiceSnapshot(params.service, loaded),
+        });
+        if (!json) {
+            defaultRuntime.log(`${params.serviceNoun} service ${params.service.notLoadedText}.`);
+        }
+        return;
+    }
+    try {
+        await params.service.stop({ env: process.env, stdout });
+    }
+    catch (err) {
+        fail(`${params.serviceNoun} stop failed: ${String(err)}`);
+        return;
+    }
+    let stopped = false;
+    try {
+        stopped = await params.service.isLoaded({ env: process.env });
+    }
+    catch {
+        stopped = false;
+    }
+    emit({
+        ok: true,
+        result: "stopped",
+        service: buildDaemonServiceSnapshot(params.service, stopped),
+    });
+}
+export async function runServiceRestart(params) {
+    const json = Boolean(params.opts?.json);
+    const { stdout, emit, fail } = createActionIO({ action: "restart", json });
+    let loaded = false;
+    try {
+        loaded = await params.service.isLoaded({ env: process.env });
+    }
+    catch (err) {
+        fail(`${params.serviceNoun} service check failed: ${String(err)}`);
+        return false;
+    }
+    if (!loaded) {
+        await handleServiceNotLoaded({
+            serviceNoun: params.serviceNoun,
+            service: params.service,
+            loaded,
+            renderStartHints: params.renderStartHints,
+            json,
+            emit,
+        });
+        return false;
+    }
+    // Check for token drift before restart (service token vs config token)
+    const warnings = [];
+    try {
+        const command = await params.service.readCommand(process.env);
+        const serviceToken = command?.environment?.POOLBOT_GATEWAY_TOKEN;
+        const cfg = loadConfig();
+        const configToken = cfg.gateway?.auth?.token ||
+            process.env.POOLBOT_GATEWAY_TOKEN ||
+            process.env.CLAWDBOT_GATEWAY_TOKEN;
+        const driftIssue = checkTokenDrift({ serviceToken, configToken });
+        if (driftIssue) {
+            const warning = driftIssue.detail
+                ? `${driftIssue.message} ${driftIssue.detail}`
+                : driftIssue.message;
+            warnings.push(warning);
+            if (!json) {
+                defaultRuntime.log(`\n⚠️  ${driftIssue.message}`);
+                if (driftIssue.detail) {
+                    defaultRuntime.log(`   ${driftIssue.detail}\n`);
+                }
+            }
+        }
+    }
+    catch {
+        // Non-fatal: token drift check is best-effort
+    }
+    try {
+        await params.service.restart({ env: process.env, stdout });
+        let restarted = true;
+        try {
+            restarted = await params.service.isLoaded({ env: process.env });
+        }
+        catch {
+            restarted = true;
+        }
+        emit({
+            ok: true,
+            result: "restarted",
+            service: buildDaemonServiceSnapshot(params.service, restarted),
+            warnings: warnings.length ? warnings : undefined,
+        });
+        return true;
+    }
+    catch (err) {
+        const hints = params.renderStartHints();
+        fail(`${params.serviceNoun} restart failed: ${String(err)}`, hints);
+        return false;
+    }
+}

package/dist/cli/daemon-cli/register-service-commands.js

@@ -0,0 +1,60 @@
+import { runDaemonInstall, runDaemonRestart, runDaemonStart, runDaemonStatus, runDaemonStop, runDaemonUninstall, } from "./runners.js";
+export function addGatewayServiceCommands(parent, opts) {
+    parent
+        .command("status")
+        .description(opts?.statusDescription ?? "Show gateway service status + probe the Gateway")
+        .option("--url <url>", "Gateway WebSocket URL (defaults to config/remote/local)")
+        .option("--token <token>", "Gateway token (if required)")
+        .option("--password <password>", "Gateway password (password auth)")
+        .option("--timeout <ms>", "Timeout in ms", "10000")
+        .option("--no-probe", "Skip RPC probe")
+        .option("--deep", "Scan system-level services", false)
+        .option("--json", "Output JSON", false)
+        .action(async (cmdOpts) => {
+        await runDaemonStatus({
+            rpc: cmdOpts,
+            probe: Boolean(cmdOpts.probe),
+            deep: Boolean(cmdOpts.deep),
+            json: Boolean(cmdOpts.json),
+        });
+    });
+    parent
+        .command("install")
+        .description("Install the Gateway service (launchd/systemd/schtasks)")
+        .option("--port <port>", "Gateway port")
+        .option("--runtime <runtime>", "Daemon runtime (node|bun). Default: node")
+        .option("--token <token>", "Gateway token (token auth)")
+        .option("--force", "Reinstall/overwrite if already installed", false)
+        .option("--json", "Output JSON", false)
+        .action(async (cmdOpts) => {
+        await runDaemonInstall(cmdOpts);
+    });
+    parent
+        .command("uninstall")
+        .description("Uninstall the Gateway service (launchd/systemd/schtasks)")
+        .option("--json", "Output JSON", false)
+        .action(async (cmdOpts) => {
+        await runDaemonUninstall(cmdOpts);
+    });
+    parent
+        .command("start")
+        .description("Start the Gateway service (launchd/systemd/schtasks)")
+        .option("--json", "Output JSON", false)
+        .action(async (cmdOpts) => {
+        await runDaemonStart(cmdOpts);
+    });
+    parent
+        .command("stop")
+        .description("Stop the Gateway service (launchd/systemd/schtasks)")
+        .option("--json", "Output JSON", false)
+        .action(async (cmdOpts) => {
+        await runDaemonStop(cmdOpts);
+    });
+    parent
+        .command("restart")
+        .description("Restart the Gateway service (launchd/systemd/schtasks)")
+        .option("--json", "Output JSON", false)
+        .action(async (cmdOpts) => {
+        await runDaemonRestart(cmdOpts);
+    });
+}

package/dist/cli/daemon-cli-compat.js

@@ -0,0 +1,80 @@
+export const LEGACY_DAEMON_CLI_EXPORTS = [
+    "registerDaemonCli",
+    "runDaemonInstall",
+    "runDaemonRestart",
+    "runDaemonStart",
+    "runDaemonStatus",
+    "runDaemonStop",
+    "runDaemonUninstall",
+];
+const EXPORT_SPEC_RE = /^([A-Za-z_$][\w$]*)(?:\s+as\s+([A-Za-z_$][\w$]*))?$/;
+const REGISTER_CONTAINER_RE = /(?:var|const|let)\s+([A-Za-z_$][\w$]*)\s*=\s*(?:\/\*[\s\S]*?\*\/\s*)?__exportAll\(\{\s*registerDaemonCli\s*:\s*\(\)\s*=>\s*registerDaemonCli\s*\}\)/;
+function parseExportAliases(bundleSource) {
+    const matches = [...bundleSource.matchAll(/export\s*\{([^}]+)\}\s*;?/g)];
+    if (matches.length === 0) {
+        return null;
+    }
+    const last = matches.at(-1);
+    const body = last?.[1];
+    if (!body) {
+        return null;
+    }
+    const aliases = new Map();
+    for (const chunk of body.split(",")) {
+        const spec = chunk.trim();
+        if (!spec) {
+            continue;
+        }
+        const parsed = spec.match(EXPORT_SPEC_RE);
+        if (!parsed) {
+            return null;
+        }
+        const original = parsed[1];
+        const alias = parsed[2] ?? original;
+        aliases.set(original, alias);
+    }
+    return aliases;
+}
+function findRegisterContainerSymbol(bundleSource) {
+    return bundleSource.match(REGISTER_CONTAINER_RE)?.[1] ?? null;
+}
+export function resolveLegacyDaemonCliAccessors(bundleSource) {
+    const aliases = parseExportAliases(bundleSource);
+    if (!aliases) {
+        return null;
+    }
+    const registerContainer = findRegisterContainerSymbol(bundleSource);
+    const registerContainerAlias = registerContainer ? aliases.get(registerContainer) : undefined;
+    const registerDirectAlias = aliases.get("registerDaemonCli");
+    const runDaemonInstall = aliases.get("runDaemonInstall");
+    const runDaemonRestart = aliases.get("runDaemonRestart");
+    const runDaemonStart = aliases.get("runDaemonStart");
+    const runDaemonStatus = aliases.get("runDaemonStatus");
+    const runDaemonStop = aliases.get("runDaemonStop");
+    const runDaemonUninstall = aliases.get("runDaemonUninstall");
+    if (!(registerContainerAlias || registerDirectAlias) || !runDaemonRestart) {
+        return null;
+    }
+    const accessors = {
+        registerDaemonCli: registerContainerAlias
+            ? `${registerContainerAlias}.registerDaemonCli`
+            : registerDirectAlias,
+        runDaemonRestart,
+    };
+    if (runDaemonInstall) {
+        accessors.runDaemonInstall = runDaemonInstall;
+    }
+    if (runDaemonStart) {
+        accessors.runDaemonStart = runDaemonStart;
+    }
+    if (runDaemonStatus) {
+        accessors.runDaemonStatus = runDaemonStatus;
+    }
+    if (runDaemonStop) {
+        accessors.runDaemonStop = runDaemonStop;
+    }
+    if (runDaemonUninstall) {
+        accessors.runDaemonUninstall = runDaemonUninstall;
+    }
+    return accessors;
+}

package/dist/cli/nodes-cli/pairing-render.js

@@ -0,0 +1,26 @@
+import { formatTimeAgo } from "../../infra/format-time/format-relative.js";
+import { renderTable } from "../../terminal/table.js";
+export function renderPendingPairingRequestsTable(params) {
+    const { pending, now, tableWidth, theme } = params;
+    const rows = pending.map((r) => ({
+        Request: r.requestId,
+        Node: r.displayName?.trim() ? r.displayName.trim() : r.nodeId,
+        IP: r.remoteIp ?? "",
+        Requested: typeof r.ts === "number" ? formatTimeAgo(Math.max(0, now - r.ts)) : theme.muted("unknown"),
+        Repair: r.isRepair ? theme.warn("yes") : "",
+    }));
+    return {
+        heading: theme.heading("Pending"),
+        table: renderTable({
+            width: tableWidth,
+            columns: [
+                { key: "Request", header: "Request", minWidth: 8 },
+                { key: "Node", header: "Node", minWidth: 14, flex: true },
+                { key: "IP", header: "IP", minWidth: 10 },
+                { key: "Requested", header: "Requested", minWidth: 12 },
+                { key: "Repair", header: "Repair", minWidth: 6 },
+            ],
+            rows,
+        }).trimEnd(),
+    };
+}

package/dist/cli/program/action-reparse.js

@@ -0,0 +1,17 @@
+import { buildParseArgv } from "../argv.js";
+import { resolveActionArgs } from "./helpers.js";
+export async function reparseProgramFromActionArgs(program, actionArgs) {
+    const actionCommand = actionArgs.at(-1);
+    const root = actionCommand?.parent ?? program;
+    const rawArgs = root.rawArgs;
+    const actionArgsList = resolveActionArgs(actionCommand);
+    const fallbackArgv = actionCommand?.name()
+        ? [actionCommand.name(), ...actionArgsList]
+        : actionArgsList;
+    const parseArgv = buildParseArgv({
+        programName: program.name(),
+        rawArgs,
+        fallbackArgv,
+    });
+    await program.parseAsync(parseArgv);
+}

package/dist/cli/program/command-registry.js

@@ -135,6 +135,23 @@ export const commandRegistry = [
         register: ({ program }) => registerBrowserCli(program),
     },
 ];
+export function getCoreCliCommandNames() {
+    return commandRegistry.flatMap((entry) => [entry.id]);
+}
+export async function registerCoreCliByName(program, ctx, name, argv = process.argv) {
+    const entry = commandRegistry.find((candidate) => candidate.id === name);
+    if (!entry)
+        return false;
+    const existing = program.commands.find((c) => c.name() === name);
+    if (existing) {
+        const commands = program.commands;
+        const index = commands.indexOf(existing);
+        if (index >= 0)
+            commands.splice(index, 1);
+    }
+    entry.register({ program, ctx, argv });
+    return true;
+}
 export function registerProgramCommands(program, ctx, argv = process.argv) {
     for (const entry of commandRegistry) {
         entry.register({ program, ctx, argv });

package/dist/cli/program/program-context.js

@@ -0,0 +1,8 @@
+const PROGRAM_CONTEXT_SYMBOL = Symbol.for("poolbot.cli.programContext");
+export function setProgramContext(program, ctx) {
+    program[PROGRAM_CONTEXT_SYMBOL] =
+        ctx;
+}
+export function getProgramContext(program) {
+    return program[PROGRAM_CONTEXT_SYMBOL];
+}

package/dist/cli/program/register.subclis.js

@@ -218,6 +218,13 @@ function removeCommand(program, command) {
         commands.splice(index, 1);
     }
 }
+export function getSubCliEntries() {
+    return entries.map((e) => ({ name: e.name, description: e.description }));
+}
+export function getSubCliCommandsWithSubcommands() {
+    // Sub-CLI commands all potentially have subcommands
+    return entries.map((e) => e.name);
+}
 export async function registerSubCliByName(program, name) {
     const entry = entries.find((candidate) => candidate.name === name);
     if (!entry)