@poolzin/pool-bot 2026.2.11 → 2026.2.18

package/dist/commands/onboard-auth.config-shared.js

@@ -0,0 +1,116 @@
+function extractAgentDefaultModelFallbacks(model) {
+    if (!model || typeof model !== "object") {
+        return undefined;
+    }
+    if (!("fallbacks" in model)) {
+        return undefined;
+    }
+    const fallbacks = model.fallbacks;
+    return Array.isArray(fallbacks) ? fallbacks.map((v) => String(v)) : undefined;
+}
+export function applyOnboardAuthAgentModelsAndProviders(cfg, params) {
+    return {
+        ...cfg,
+        agents: {
+            ...cfg.agents,
+            defaults: {
+                ...cfg.agents?.defaults,
+                models: params.agentModels,
+            },
+        },
+        models: {
+            mode: cfg.models?.mode ?? "merge",
+            providers: params.providers,
+        },
+    };
+}
+export function applyAgentDefaultModelPrimary(cfg, primary) {
+    const existingFallbacks = extractAgentDefaultModelFallbacks(cfg.agents?.defaults?.model);
+    return {
+        ...cfg,
+        agents: {
+            ...cfg.agents,
+            defaults: {
+                ...cfg.agents?.defaults,
+                model: {
+                    ...(existingFallbacks ? { fallbacks: existingFallbacks } : undefined),
+                    primary,
+                },
+            },
+        },
+    };
+}
+export function applyProviderConfigWithDefaultModels(cfg, params) {
+    const providers = { ...cfg.models?.providers };
+    const existingProvider = providers[params.providerId];
+    const existingModels = Array.isArray(existingProvider?.models)
+        ? existingProvider.models
+        : [];
+    const defaultModels = params.defaultModels;
+    const defaultModelId = params.defaultModelId ?? defaultModels[0]?.id;
+    const hasDefaultModel = defaultModelId
+        ? existingModels.some((model) => model.id === defaultModelId)
+        : true;
+    const mergedModels = existingModels.length > 0
+        ? hasDefaultModel || defaultModels.length === 0
+            ? existingModels
+            : [...existingModels, ...defaultModels]
+        : defaultModels;
+    providers[params.providerId] = buildProviderConfig({
+        existingProvider,
+        api: params.api,
+        baseUrl: params.baseUrl,
+        mergedModels,
+        fallbackModels: defaultModels,
+    });
+    return applyOnboardAuthAgentModelsAndProviders(cfg, {
+        agentModels: params.agentModels,
+        providers,
+    });
+}
+export function applyProviderConfigWithDefaultModel(cfg, params) {
+    return applyProviderConfigWithDefaultModels(cfg, {
+        agentModels: params.agentModels,
+        providerId: params.providerId,
+        api: params.api,
+        baseUrl: params.baseUrl,
+        defaultModels: [params.defaultModel],
+        defaultModelId: params.defaultModelId ?? params.defaultModel.id,
+    });
+}
+export function applyProviderConfigWithModelCatalog(cfg, params) {
+    const providers = { ...cfg.models?.providers };
+    const existingProvider = providers[params.providerId];
+    const existingModels = Array.isArray(existingProvider?.models)
+        ? existingProvider.models
+        : [];
+    const catalogModels = params.catalogModels;
+    const mergedModels = existingModels.length > 0
+        ? [
+            ...existingModels,
+            ...catalogModels.filter((model) => !existingModels.some((existing) => existing.id === model.id)),
+        ]
+        : catalogModels;
+    providers[params.providerId] = buildProviderConfig({
+        existingProvider,
+        api: params.api,
+        baseUrl: params.baseUrl,
+        mergedModels,
+        fallbackModels: catalogModels,
+    });
+    return applyOnboardAuthAgentModelsAndProviders(cfg, {
+        agentModels: params.agentModels,
+        providers,
+    });
+}
+function buildProviderConfig(params) {
+    const { apiKey: existingApiKey, ...existingProviderRest } = (params.existingProvider ?? {});
+    const normalizedApiKey = typeof existingApiKey === "string" ? existingApiKey.trim() : undefined;
+    return {
+        ...existingProviderRest,
+        baseUrl: params.baseUrl,
+        api: params.api,
+        ...(normalizedApiKey ? { apiKey: normalizedApiKey } : {}),
+        models: params.mergedModels.length > 0 ? params.mergedModels : params.fallbackModels,
+    };
+}

package/dist/commands/onboard-config.js

@@ -0,0 +1,16 @@
+export function applyOnboardingLocalWorkspaceConfig(baseConfig, workspaceDir) {
+    return {
+        ...baseConfig,
+        agents: {
+            ...baseConfig.agents,
+            defaults: {
+                ...baseConfig.agents?.defaults,
+                workspace: workspaceDir,
+            },
+        },
+        gateway: {
+            ...baseConfig.gateway,
+            mode: "local",
+        },
+    };
+}

package/dist/commands/onboard-non-interactive.test-helpers.js

@@ -0,0 +1,31 @@
+import fs from "node:fs/promises";
+const NON_INTERACTIVE_DEFAULT_OPTIONS = {
+    nonInteractive: true,
+    skipHealth: true,
+    skipChannels: true,
+    json: true,
+};
+export function createThrowingRuntime() {
+    return {
+        log: () => { },
+        error: (...args) => {
+            throw new Error(args.map(String).join(" "));
+        },
+        exit: (code) => {
+            throw new Error(`exit:${code}`);
+        },
+    };
+}
+export async function runNonInteractiveOnboarding(options, runtime) {
+    const { runNonInteractiveOnboarding: run } = await import("./onboard-non-interactive.js");
+    await run(options, runtime);
+}
+export async function runNonInteractiveOnboardingWithDefaults(runtime, options) {
+    await runNonInteractiveOnboarding({
+        ...NON_INTERACTIVE_DEFAULT_OPTIONS,
+        ...options,
+    }, runtime);
+}
+export async function readJsonFile(filePath) {
+    return JSON.parse(await fs.readFile(filePath, "utf8"));
+}

package/dist/commands/onboard-provider-auth-flags.js

@@ -0,0 +1,136 @@
+// Shared source for provider API-key flags used by CLI registration + non-interactive inference.
+export const ONBOARD_PROVIDER_AUTH_FLAGS = [
+    {
+        optionKey: "anthropicApiKey",
+        authChoice: "apiKey",
+        cliFlag: "--anthropic-api-key",
+        cliOption: "--anthropic-api-key <key>",
+        description: "Anthropic API key",
+    },
+    {
+        optionKey: "openaiApiKey",
+        authChoice: "openai-api-key",
+        cliFlag: "--openai-api-key",
+        cliOption: "--openai-api-key <key>",
+        description: "OpenAI API key",
+    },
+    {
+        optionKey: "openrouterApiKey",
+        authChoice: "openrouter-api-key",
+        cliFlag: "--openrouter-api-key",
+        cliOption: "--openrouter-api-key <key>",
+        description: "OpenRouter API key",
+    },
+    {
+        optionKey: "aiGatewayApiKey",
+        authChoice: "ai-gateway-api-key",
+        cliFlag: "--ai-gateway-api-key",
+        cliOption: "--ai-gateway-api-key <key>",
+        description: "Vercel AI Gateway API key",
+    },
+    {
+        optionKey: "cloudflareAiGatewayApiKey",
+        authChoice: "cloudflare-ai-gateway-api-key",
+        cliFlag: "--cloudflare-ai-gateway-api-key",
+        cliOption: "--cloudflare-ai-gateway-api-key <key>",
+        description: "Cloudflare AI Gateway API key",
+    },
+    {
+        optionKey: "moonshotApiKey",
+        authChoice: "moonshot-api-key",
+        cliFlag: "--moonshot-api-key",
+        cliOption: "--moonshot-api-key <key>",
+        description: "Moonshot API key",
+    },
+    {
+        optionKey: "kimiCodeApiKey",
+        authChoice: "kimi-code-api-key",
+        cliFlag: "--kimi-code-api-key",
+        cliOption: "--kimi-code-api-key <key>",
+        description: "Kimi Coding API key",
+    },
+    {
+        optionKey: "geminiApiKey",
+        authChoice: "gemini-api-key",
+        cliFlag: "--gemini-api-key",
+        cliOption: "--gemini-api-key <key>",
+        description: "Gemini API key",
+    },
+    {
+        optionKey: "zaiApiKey",
+        authChoice: "zai-api-key",
+        cliFlag: "--zai-api-key",
+        cliOption: "--zai-api-key <key>",
+        description: "Z.AI API key",
+    },
+    {
+        optionKey: "xiaomiApiKey",
+        authChoice: "xiaomi-api-key",
+        cliFlag: "--xiaomi-api-key",
+        cliOption: "--xiaomi-api-key <key>",
+        description: "Xiaomi API key",
+    },
+    {
+        optionKey: "minimaxApiKey",
+        authChoice: "minimax-api",
+        cliFlag: "--minimax-api-key",
+        cliOption: "--minimax-api-key <key>",
+        description: "MiniMax API key",
+    },
+    {
+        optionKey: "syntheticApiKey",
+        authChoice: "synthetic-api-key",
+        cliFlag: "--synthetic-api-key",
+        cliOption: "--synthetic-api-key <key>",
+        description: "Synthetic API key",
+    },
+    {
+        optionKey: "veniceApiKey",
+        authChoice: "venice-api-key",
+        cliFlag: "--venice-api-key",
+        cliOption: "--venice-api-key <key>",
+        description: "Venice API key",
+    },
+    {
+        optionKey: "togetherApiKey",
+        authChoice: "together-api-key",
+        cliFlag: "--together-api-key",
+        cliOption: "--together-api-key <key>",
+        description: "Together AI API key",
+    },
+    {
+        optionKey: "huggingfaceApiKey",
+        authChoice: "huggingface-api-key",
+        cliFlag: "--huggingface-api-key",
+        cliOption: "--huggingface-api-key <key>",
+        description: "Hugging Face API key (HF token)",
+    },
+    {
+        optionKey: "opencodeZenApiKey",
+        authChoice: "opencode-zen",
+        cliFlag: "--opencode-zen-api-key",
+        cliOption: "--opencode-zen-api-key <key>",
+        description: "OpenCode Zen API key",
+    },
+    {
+        optionKey: "xaiApiKey",
+        authChoice: "xai-api-key",
+        cliFlag: "--xai-api-key",
+        cliOption: "--xai-api-key <key>",
+        description: "xAI API key",
+    },
+    {
+        optionKey: "litellmApiKey",
+        authChoice: "litellm-api-key",
+        cliFlag: "--litellm-api-key",
+        cliOption: "--litellm-api-key <key>",
+        description: "LiteLLM API key",
+    },
+    {
+        optionKey: "qianfanApiKey",
+        authChoice: "qianfan-api-key",
+        cliFlag: "--qianfan-api-key",
+        cliOption: "--qianfan-api-key <key>",
+        description: "QIANFAN API key",
+    },
+];

package/dist/commands/openai-codex-oauth.js

@@ -0,0 +1,40 @@
+import { loginOpenAICodex } from "@mariozechner/pi-ai";
+import { createVpsAwareOAuthHandlers } from "./oauth-flow.js";
+export async function loginOpenAICodexOAuth(params) {
+    const { prompter, runtime, isRemote, openUrl, localBrowserMessage } = params;
+    await prompter.note(isRemote
+        ? [
+            "You are running in a remote/VPS environment.",
+            "A URL will be shown for you to open in your LOCAL browser.",
+            "After signing in, paste the redirect URL back here.",
+        ].join("\n")
+        : [
+            "Browser will open for OpenAI authentication.",
+            "If the callback doesn't auto-complete, paste the redirect URL.",
+            "OpenAI OAuth uses localhost:1455 for the callback.",
+        ].join("\n"), "OpenAI Codex OAuth");
+    const spin = prompter.progress("Starting OAuth flow…");
+    try {
+        const { onAuth, onPrompt } = createVpsAwareOAuthHandlers({
+            isRemote,
+            prompter,
+            runtime,
+            spin,
+            openUrl,
+            localBrowserMessage: localBrowserMessage ?? "Complete sign-in in browser…",
+        });
+        const creds = await loginOpenAICodex({
+            onAuth,
+            onPrompt,
+            onProgress: (msg) => spin.update(msg),
+        });
+        spin.stop("OpenAI OAuth complete");
+        return creds ?? null;
+    }
+    catch (err) {
+        spin.stop("OpenAI OAuth failed");
+        runtime.error(String(err));
+        await prompter.note("Trouble with OAuth? See https://docs.openclaw.ai/start/faq", "OAuth help");
+        throw err;
+    }
+}

package/dist/commands/test-runtime-config-helpers.js

@@ -0,0 +1,21 @@
+import { vi } from "vitest";
+export const baseConfigSnapshot = {
+    path: "/tmp/poolbot.json",
+    exists: true,
+    raw: "{}",
+    parsed: {},
+    valid: true,
+    config: {},
+    issues: [],
+    legacyIssues: [],
+};
+export function createTestRuntime() {
+    const log = vi.fn();
+    const error = vi.fn();
+    const exit = vi.fn((_) => undefined);
+    return {
+        log,
+        error,
+        exit,
+    };
+}

package/dist/commands/test-wizard-helpers.js

@@ -0,0 +1,68 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { vi } from "vitest";
+import { makeTempWorkspace } from "../test-helpers/workspace.js";
+import { captureEnv } from "../test-utils/env.js";
+export const noopAsync = async () => { };
+export const noop = () => { };
+export function createExitThrowingRuntime() {
+    return {
+        log: vi.fn(),
+        error: vi.fn(),
+        exit: vi.fn((code) => {
+            throw new Error(`exit:${code}`);
+        }),
+    };
+}
+export function createWizardPrompter(overrides, options) {
+    return {
+        intro: vi.fn(noopAsync),
+        outro: vi.fn(noopAsync),
+        note: vi.fn(noopAsync),
+        select: vi.fn(async () => (options?.defaultSelect ?? "")),
+        multiselect: vi.fn(async () => []),
+        text: vi.fn(async () => ""),
+        confirm: vi.fn(async () => false),
+        progress: vi.fn(() => ({ update: noop, stop: noop })),
+        ...overrides,
+    };
+}
+export async function setupAuthTestEnv(prefix = "openclaw-auth-", options) {
+    const stateDir = await makeTempWorkspace(prefix);
+    const agentDir = path.join(stateDir, options?.agentSubdir ?? "agent");
+    process.env.POOLBOT_STATE_DIR = stateDir;
+    process.env.POOLBOT_AGENT_DIR = agentDir;
+    process.env.PI_CODING_AGENT_DIR = agentDir;
+    await fs.mkdir(agentDir, { recursive: true });
+    return { stateDir, agentDir };
+}
+export function createAuthTestLifecycle(envKeys) {
+    const envSnapshot = captureEnv(envKeys);
+    let stateDir = null;
+    return {
+        setStateDir(nextStateDir) {
+            stateDir = nextStateDir;
+        },
+        async cleanup() {
+            if (stateDir) {
+                await fs.rm(stateDir, { recursive: true, force: true });
+                stateDir = null;
+            }
+            envSnapshot.restore();
+        },
+    };
+}
+export function requireOpenClawAgentDir() {
+    const agentDir = process.env.POOLBOT_AGENT_DIR;
+    if (!agentDir) {
+        throw new Error("POOLBOT_AGENT_DIR not set");
+    }
+    return agentDir;
+}
+export function authProfilePathForAgent(agentDir) {
+    return path.join(agentDir, "auth-profiles.json");
+}
+export async function readAuthProfilesForAgent(agentDir) {
+    const raw = await fs.readFile(authProfilePathForAgent(agentDir), "utf8");
+    return JSON.parse(raw);
+}

package/dist/commands/vllm-setup.js

@@ -0,0 +1,66 @@
+import { upsertAuthProfileWithLock } from "../agents/auth-profiles.js";
+export const VLLM_DEFAULT_BASE_URL = "http://127.0.0.1:8000/v1";
+export const VLLM_DEFAULT_CONTEXT_WINDOW = 128000;
+export const VLLM_DEFAULT_MAX_TOKENS = 8192;
+export const VLLM_DEFAULT_COST = {
+    input: 0,
+    output: 0,
+    cacheRead: 0,
+    cacheWrite: 0,
+};
+export async function promptAndConfigureVllm(params) {
+    const baseUrlRaw = await params.prompter.text({
+        message: "vLLM base URL",
+        initialValue: VLLM_DEFAULT_BASE_URL,
+        placeholder: VLLM_DEFAULT_BASE_URL,
+        validate: (value) => (value?.trim() ? undefined : "Required"),
+    });
+    const apiKeyRaw = await params.prompter.text({
+        message: "vLLM API key",
+        placeholder: "sk-... (or any non-empty string)",
+        validate: (value) => (value?.trim() ? undefined : "Required"),
+    });
+    const modelIdRaw = await params.prompter.text({
+        message: "vLLM model",
+        placeholder: "meta-llama/Meta-Llama-3-8B-Instruct",
+        validate: (value) => (value?.trim() ? undefined : "Required"),
+    });
+    const baseUrl = String(baseUrlRaw ?? "")
+        .trim()
+        .replace(/\/+$/, "");
+    const apiKey = String(apiKeyRaw ?? "").trim();
+    const modelId = String(modelIdRaw ?? "").trim();
+    const modelRef = `vllm/${modelId}`;
+    await upsertAuthProfileWithLock({
+        profileId: "vllm:default",
+        credential: { type: "api_key", provider: "vllm", key: apiKey },
+        agentDir: params.agentDir,
+    });
+    const nextConfig = {
+        ...params.cfg,
+        models: {
+            ...params.cfg.models,
+            mode: params.cfg.models?.mode ?? "merge",
+            providers: {
+                ...params.cfg.models?.providers,
+                vllm: {
+                    baseUrl,
+                    api: "openai-completions",
+                    apiKey: "VLLM_API_KEY",
+                    models: [
+                        {
+                            id: modelId,
+                            name: modelId,
+                            reasoning: false,
+                            input: ["text"],
+                            cost: VLLM_DEFAULT_COST,
+                            contextWindow: VLLM_DEFAULT_CONTEXT_WINDOW,
+                            maxTokens: VLLM_DEFAULT_MAX_TOKENS,
+                        },
+                    ],
+                },
+            },
+        },
+    };
+    return { config: nextConfig, modelId, modelRef };
+}

package/dist/compat/legacy-names.js

@@ -1,5 +1,7 @@
 export const LEGACY_PROJECT_NAME = "poolbot";
 export const LEGACY_MANIFEST_KEY = LEGACY_PROJECT_NAME;
+export const MANIFEST_KEY = LEGACY_PROJECT_NAME;
+export const LEGACY_MANIFEST_KEYS = [LEGACY_MANIFEST_KEY];
 export const LEGACY_PLUGIN_MANIFEST_FILENAME = `${LEGACY_PROJECT_NAME}.plugin.json`;
 export const LEGACY_CANVAS_HANDLER_NAME = `${LEGACY_PROJECT_NAME}CanvasA2UIAction`;
 export const LEGACY_MACOS_APP_SOURCES_DIR = "apps/macos/Sources/Pool-Bot";

package/dist/config/backup-rotation.js

@@ -0,0 +1,19 @@
+export const CONFIG_BACKUP_COUNT = 5;
+export async function rotateConfigBackups(configPath, ioFs) {
+    if (CONFIG_BACKUP_COUNT <= 1) {
+        return;
+    }
+    const backupBase = `${configPath}.bak`;
+    const maxIndex = CONFIG_BACKUP_COUNT - 1;
+    await ioFs.unlink(`${backupBase}.${maxIndex}`).catch(() => {
+        // best-effort
+    });
+    for (let index = maxIndex - 1; index >= 1; index -= 1) {
+        await ioFs.rename(`${backupBase}.${index}`, `${backupBase}.${index + 1}`).catch(() => {
+            // best-effort
+        });
+    }
+    await ioFs.rename(backupBase, `${backupBase}.1`).catch(() => {
+        // best-effort
+    });
+}

package/dist/config/env-preserve.js

@@ -0,0 +1,122 @@
+/**
+ * Preserves `${VAR}` environment variable references during config write-back.
+ *
+ * When config is read, `${VAR}` references are resolved to their values.
+ * When writing back, callers pass the resolved config. This module detects
+ * values that match what a `${VAR}` reference would resolve to and restores
+ * the original reference, so env var references survive config round-trips.
+ *
+ * A value is restored only if:
+ * 1. The pre-substitution value contained a `${VAR}` pattern
+ * 2. Resolving that pattern with current env vars produces the incoming value
+ *
+ * If a caller intentionally set a new value (different from what the env var
+ * resolves to), the new value is kept as-is.
+ */
+const ENV_VAR_PATTERN = /\$\{[A-Z_][A-Z0-9_]*\}/;
+function isPlainObject(value) {
+    return (typeof value === "object" &&
+        value !== null &&
+        !Array.isArray(value) &&
+        Object.prototype.toString.call(value) === "[object Object]");
+}
+/**
+ * Check if a string contains any `${VAR}` env var references.
+ */
+function hasEnvVarRef(value) {
+    return ENV_VAR_PATTERN.test(value);
+}
+/**
+ * Resolve `${VAR}` references in a single string using the given env.
+ * Returns null if any referenced var is missing (instead of throwing).
+ *
+ * Mirrors the substitution semantics of `substituteString` in env-substitution.ts:
+ * - `${VAR}` → env value (returns null if missing)
+ * - `$${VAR}` → literal `${VAR}` (escape sequence)
+ */
+function tryResolveString(template, env) {
+    const ENV_VAR_NAME = /^[A-Z_][A-Z0-9_]*$/;
+    const chunks = [];
+    for (let i = 0; i < template.length; i++) {
+        if (template[i] === "$") {
+            // Escaped: $${VAR} -> literal ${VAR}
+            if (template[i + 1] === "$" && template[i + 2] === "{") {
+                const start = i + 3;
+                const end = template.indexOf("}", start);
+                if (end !== -1) {
+                    const name = template.slice(start, end);
+                    if (ENV_VAR_NAME.test(name)) {
+                        chunks.push(`\${${name}}`);
+                        i = end;
+                        continue;
+                    }
+                }
+            }
+            // Substitution: ${VAR} -> env value
+            if (template[i + 1] === "{") {
+                const start = i + 2;
+                const end = template.indexOf("}", start);
+                if (end !== -1) {
+                    const name = template.slice(start, end);
+                    if (ENV_VAR_NAME.test(name)) {
+                        const val = env[name];
+                        if (val === undefined || val === "") {
+                            return null;
+                        }
+                        chunks.push(val);
+                        i = end;
+                        continue;
+                    }
+                }
+            }
+        }
+        chunks.push(template[i]);
+    }
+    return chunks.join("");
+}
+/**
+ * Deep-walk the incoming config and restore `${VAR}` references from the
+ * pre-substitution parsed config wherever the resolved value matches.
+ *
+ * @param incoming - The resolved config about to be written
+ * @param parsed - The pre-substitution parsed config (from the current file on disk)
+ * @param env - Environment variables for verification
+ * @returns A new config object with env var references restored where appropriate
+ */
+export function restoreEnvVarRefs(incoming, parsed, env = process.env) {
+    // If parsed has no env var refs at this level, return incoming as-is
+    if (parsed === null || parsed === undefined) {
+        return incoming;
+    }
+    // String leaf: check if parsed was a ${VAR} template that resolves to incoming
+    if (typeof incoming === "string" && typeof parsed === "string") {
+        if (hasEnvVarRef(parsed)) {
+            const resolved = tryResolveString(parsed, env);
+            if (resolved === incoming) {
+                // The incoming value matches what the env var resolves to — restore the reference
+                return parsed;
+            }
+        }
+        return incoming;
+    }
+    // Arrays: walk element by element
+    if (Array.isArray(incoming) && Array.isArray(parsed)) {
+        return incoming.map((item, i) => i < parsed.length ? restoreEnvVarRefs(item, parsed[i], env) : item);
+    }
+    // Objects: walk key by key
+    if (isPlainObject(incoming) && isPlainObject(parsed)) {
+        const result = {};
+        for (const [key, value] of Object.entries(incoming)) {
+            if (key in parsed) {
+                result[key] = restoreEnvVarRefs(value, parsed[key], env);
+            }
+            else {
+                // New key added by caller — keep as-is
+                result[key] = value;
+            }
+        }
+        return result;
+    }
+    // Mismatched types or primitives — keep incoming
+    return incoming;
+}