@poolzin/pool-bot 2026.2.11 → 2026.2.18

package/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/commands/auth-choice-legacy.js

@@ -0,0 +1,20 @@
+export const AUTH_CHOICE_LEGACY_ALIASES_FOR_CLI = [
+    "setup-token",
+    "oauth",
+    "claude-cli",
+    "codex-cli",
+    "minimax-cloud",
+    "minimax",
+];
+export function normalizeLegacyOnboardAuthChoice(authChoice) {
+    if (authChoice === "oauth" || authChoice === "claude-cli") {
+        return "setup-token";
+    }
+    if (authChoice === "codex-cli") {
+        return "openai-codex";
+    }
+    return authChoice;
+}
+export function isDeprecatedAuthChoice(authChoice) {
+    return authChoice === "claude-cli" || authChoice === "codex-cli";
+}

package/dist/commands/auth-choice.apply-helpers.js

@@ -0,0 +1,8 @@
+export function createAuthChoiceAgentModelNoter(params) {
+    return async (model) => {
+        if (!params.agentId) {
+            return;
+        }
+        await params.prompter.note(`Default model set to ${model} for agent "${params.agentId}".`, "Model configured");
+    };
+}

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

@@ -0,0 +1,19 @@
+import { discordPlugin } from "../../extensions/discord/src/channel.js";
+import { imessagePlugin } from "../../extensions/imessage/src/channel.js";
+import { signalPlugin } from "../../extensions/signal/src/channel.js";
+import { slackPlugin } from "../../extensions/slack/src/channel.js";
+import { telegramPlugin } from "../../extensions/telegram/src/channel.js";
+import { whatsappPlugin } from "../../extensions/whatsapp/src/channel.js";
+import { setActivePluginRegistry } from "../plugins/runtime.js";
+import { createTestRegistry } from "../test-utils/channel-plugins.js";
+export function setDefaultChannelPluginRegistryForTests() {
+    const channels = [
+        { pluginId: "discord", plugin: discordPlugin, source: "test" },
+        { pluginId: "slack", plugin: slackPlugin, source: "test" },
+        { pluginId: "telegram", plugin: telegramPlugin, source: "test" },
+        { pluginId: "whatsapp", plugin: whatsappPlugin, source: "test" },
+        { pluginId: "signal", plugin: signalPlugin, source: "test" },
+        { pluginId: "imessage", plugin: imessagePlugin, source: "test" },
+    ];
+    setActivePluginRegistry(createTestRegistry(channels));
+}

package/dist/commands/cleanup-plan.js

@@ -0,0 +1,10 @@
+import { loadConfig, resolveConfigPath, resolveOAuthDir, resolveStateDir, } from "../config/config.js";
+import { buildCleanupPlan } from "./cleanup-utils.js";
+export function resolveCleanupPlanFromDisk() {
+    const cfg = loadConfig();
+    const stateDir = resolveStateDir();
+    const configPath = resolveConfigPath();
+    const oauthDir = resolveOAuthDir();
+    const plan = buildCleanupPlan({ cfg, stateDir, configPath, oauthDir });
+    return { cfg, stateDir, configPath, oauthDir, ...plan };
+}

package/dist/commands/cleanup-utils.js

@@ -20,6 +20,13 @@ export function collectWorkspaceDirs(cfg) {
     }
     return [...dirs];
 }
+export function buildCleanupPlan(params) {
+    return {
+        configInsideState: isPathWithin(params.configPath, params.stateDir),
+        oauthInsideState: isPathWithin(params.oauthDir, params.stateDir),
+        workspaceDirs: collectWorkspaceDirs(params.cfg),
+    };
+}
 export function isPathWithin(child, parent) {
     const relative = path.relative(parent, child);
     return relative === "" || (!relative.startsWith("..") && !path.isAbsolute(relative));

package/dist/commands/config-validation.js

@@ -0,0 +1,15 @@
+import { formatCliCommand } from "../cli/command-format.js";
+import { readConfigFileSnapshot } from "../config/config.js";
+export async function requireValidConfigSnapshot(runtime) {
+    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("openclaw doctor")}.`);
+        runtime.exit(1);
+        return null;
+    }
+    return snapshot.config;
+}

package/dist/commands/doctor-completion.js

@@ -0,0 +1,112 @@
+import { spawnSync } from "node:child_process";
+import path from "node:path";
+import { resolveCliName } from "../cli/cli-name.js";
+import { completionCacheExists, installCompletion, isCompletionInstalled, resolveCompletionCachePath, resolveShellFromEnv, usesSlowDynamicCompletion, } from "../cli/completion-cli.js";
+import { resolveOpenClawPackageRoot } from "../infra/openclaw-root.js";
+import { note } from "../terminal/note.js";
+/** Generate the completion cache by spawning the CLI. */
+async function generateCompletionCache() {
+    const root = await resolveOpenClawPackageRoot({
+        moduleUrl: import.meta.url,
+        argv1: process.argv[1],
+        cwd: process.cwd(),
+    });
+    if (!root) {
+        return false;
+    }
+    const binPath = path.join(root, "openclaw.mjs");
+    const result = spawnSync(process.execPath, [binPath, "completion", "--write-state"], {
+        cwd: root,
+        env: process.env,
+        encoding: "utf-8",
+    });
+    return result.status === 0;
+}
+/** Check the status of shell completion for the current shell. */
+export async function checkShellCompletionStatus(binName = "poolbot") {
+    const shell = resolveShellFromEnv();
+    const profileInstalled = await isCompletionInstalled(shell, binName);
+    const cacheExists = await completionCacheExists(shell, binName);
+    const cachePath = resolveCompletionCachePath(shell, binName);
+    const usesSlowPattern = await usesSlowDynamicCompletion(shell, binName);
+    return {
+        shell,
+        profileInstalled,
+        cacheExists,
+        cachePath,
+        usesSlowPattern,
+    };
+}
+/**
+ * Doctor check for shell completion.
+ * - If profile uses slow dynamic pattern: upgrade to cached version
+ * - If profile has completion but no cache: auto-generate cache and upgrade profile
+ * - If no completion at all: prompt to install (with user confirmation)
+ */
+export async function doctorShellCompletion(runtime, prompter, options = {}) {
+    const cliName = resolveCliName();
+    const status = await checkShellCompletionStatus(cliName);
+    // Profile uses slow dynamic pattern - upgrade to cached version
+    if (status.usesSlowPattern) {
+        note(`Your ${status.shell} profile uses slow dynamic completion (source <(...)).\nUpgrading to cached completion for faster shell startup...`, "Shell completion");
+        // Ensure cache exists first
+        if (!status.cacheExists) {
+            const generated = await generateCompletionCache();
+            if (!generated) {
+                note(`Failed to generate completion cache. Run \`${cliName} completion --write-state\` manually.`, "Shell completion");
+                return;
+            }
+        }
+        // Upgrade profile to use cached file
+        await installCompletion(status.shell, true, cliName);
+        note(`Shell completion upgraded. Restart your shell or run: source ~/.${status.shell === "zsh" ? "zshrc" : status.shell === "bash" ? "bashrc" : "config/fish/config.fish"}`, "Shell completion");
+        return;
+    }
+    // Profile has completion but no cache - auto-fix
+    if (status.profileInstalled && !status.cacheExists) {
+        note(`Shell completion is configured in your ${status.shell} profile but the cache is missing.\nRegenerating cache...`, "Shell completion");
+        const generated = await generateCompletionCache();
+        if (generated) {
+            note(`Completion cache regenerated at ${status.cachePath}`, "Shell completion");
+        }
+        else {
+            note(`Failed to regenerate completion cache. Run \`${cliName} completion --write-state\` manually.`, "Shell completion");
+        }
+        return;
+    }
+    // No completion at all - prompt to install
+    if (!status.profileInstalled) {
+        if (options.nonInteractive) {
+            // In non-interactive mode, just note that completion is not installed
+            return;
+        }
+        const shouldInstall = await prompter.confirm({
+            message: `Enable ${status.shell} shell completion for ${cliName}?`,
+            initialValue: true,
+        });
+        if (shouldInstall) {
+            // First generate the cache
+            const generated = await generateCompletionCache();
+            if (!generated) {
+                note(`Failed to generate completion cache. Run \`${cliName} completion --write-state\` manually.`, "Shell completion");
+                return;
+            }
+            // Then install to profile
+            await installCompletion(status.shell, true, cliName);
+            note(`Shell completion installed. Restart your shell or run: source ~/.${status.shell === "zsh" ? "zshrc" : status.shell === "bash" ? "bashrc" : "config/fish/config.fish"}`, "Shell completion");
+        }
+    }
+}
+/**
+ * Ensure completion cache exists. Used during onboarding/update to fix
+ * cases where profile has completion but no cache.
+ * This is a silent fix - no prompts.
+ */
+export async function ensureCompletionCacheExists(binName = "poolbot") {
+    const shell = resolveShellFromEnv();
+    const cacheExists = await completionCacheExists(shell, binName);
+    if (cacheExists) {
+        return true;
+    }
+    return generateCompletionCache();
+}

package/dist/commands/doctor-memory-search.js

@@ -0,0 +1,119 @@
+import fsSync from "node:fs";
+import { resolveAgentDir, resolveDefaultAgentId } from "../agents/agent-scope.js";
+import { resolveMemorySearchConfig } from "../agents/memory-search.js";
+import { resolveApiKeyForProvider } from "../agents/model-auth.js";
+import { formatCliCommand } from "../cli/command-format.js";
+import { note } from "../terminal/note.js";
+import { resolveUserPath } from "../utils.js";
+/**
+ * Check whether memory search has a usable embedding provider.
+ * Runs as part of `openclaw doctor` — config-only, no network calls.
+ */
+export async function noteMemorySearchHealth(cfg) {
+    const agentId = resolveDefaultAgentId(cfg);
+    const agentDir = resolveAgentDir(cfg, agentId);
+    const resolved = resolveMemorySearchConfig(cfg, agentId);
+    const hasRemoteApiKey = Boolean(resolved?.remote?.apiKey?.trim());
+    if (!resolved) {
+        note("Memory search is explicitly disabled (enabled: false).", "Memory search");
+        return;
+    }
+    // If a specific provider is configured (not "auto"), check only that one.
+    if (resolved.provider !== "auto") {
+        if (resolved.provider === "local") {
+            if (hasLocalEmbeddings(resolved.local)) {
+                return; // local model file exists
+            }
+            note([
+                'Memory search provider is set to "local" but no local model file was found.',
+                "",
+                "Fix (pick one):",
+                `- Install node-llama-cpp and set a local model path in config`,
+                `- Switch to a remote provider: ${formatCliCommand("openclaw config set agents.defaults.memorySearch.provider openai")}`,
+                "",
+                `Verify: ${formatCliCommand("openclaw memory status --deep")}`,
+            ].join("\n"), "Memory search");
+            return;
+        }
+        // Remote provider — check for API key
+        if (hasRemoteApiKey || (await hasApiKeyForProvider(resolved.provider, cfg, agentDir))) {
+            return;
+        }
+        const envVar = providerEnvVar(resolved.provider);
+        note([
+            `Memory search provider is set to "${resolved.provider}" but no API key was found.`,
+            `Semantic recall will not work without a valid API key.`,
+            "",
+            "Fix (pick one):",
+            `- Set ${envVar} in your environment`,
+            `- Add credentials: ${formatCliCommand(`openclaw auth add --provider ${resolved.provider}`)}`,
+            `- To disable: ${formatCliCommand("openclaw config set agents.defaults.memorySearch.enabled false")}`,
+            "",
+            `Verify: ${formatCliCommand("openclaw memory status --deep")}`,
+        ].join("\n"), "Memory search");
+        return;
+    }
+    // provider === "auto": check all providers in resolution order
+    if (hasLocalEmbeddings(resolved.local)) {
+        return;
+    }
+    for (const provider of ["openai", "gemini", "voyage"]) {
+        if (hasRemoteApiKey || (await hasApiKeyForProvider(provider, cfg, agentDir))) {
+            return;
+        }
+    }
+    note([
+        "Memory search is enabled but no embedding provider is configured.",
+        "Semantic recall will not work without an embedding provider.",
+        "",
+        "Fix (pick one):",
+        "- Set OPENAI_API_KEY or GEMINI_API_KEY in your environment",
+        `- Add credentials: ${formatCliCommand("openclaw auth add --provider openai")}`,
+        `- For local embeddings: configure agents.defaults.memorySearch.provider and local model path`,
+        `- To disable: ${formatCliCommand("openclaw config set agents.defaults.memorySearch.enabled false")}`,
+        "",
+        `Verify: ${formatCliCommand("openclaw memory status --deep")}`,
+    ].join("\n"), "Memory search");
+}
+function hasLocalEmbeddings(local) {
+    const modelPath = local.modelPath?.trim();
+    if (!modelPath) {
+        return false;
+    }
+    // Remote/downloadable models (hf: or http:) aren't pre-resolved on disk,
+    // so we can't confirm availability without a network call. Treat as
+    // potentially available — the user configured it intentionally.
+    if (/^(hf:|https?:)/i.test(modelPath)) {
+        return true;
+    }
+    const resolved = resolveUserPath(modelPath);
+    try {
+        return fsSync.statSync(resolved).isFile();
+    }
+    catch {
+        return false;
+    }
+}
+async function hasApiKeyForProvider(provider, cfg, agentDir) {
+    // Map embedding provider names to model-auth provider names
+    const authProvider = provider === "gemini" ? "google" : provider;
+    try {
+        await resolveApiKeyForProvider({ provider: authProvider, cfg, agentDir });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function providerEnvVar(provider) {
+    switch (provider) {
+        case "openai":
+            return "OPENAI_API_KEY";
+        case "gemini":
+            return "GEMINI_API_KEY";
+        case "voyage":
+            return "VOYAGE_API_KEY";
+        default:
+            return `${provider.toUpperCase()}_API_KEY`;
+    }
+}

package/dist/commands/doctor-session-locks.js

@@ -0,0 +1,73 @@
+import { resolveAgentSessionDirs } from "../agents/session-dirs.js";
+import { cleanStaleLockFiles } from "../agents/session-write-lock.js";
+import { resolveStateDir } from "../config/paths.js";
+import { note } from "../terminal/note.js";
+import { shortenHomePath } from "../utils.js";
+const DEFAULT_STALE_MS = 30 * 60 * 1000;
+function formatAge(ageMs) {
+    if (ageMs === null) {
+        return "unknown";
+    }
+    const seconds = Math.floor(ageMs / 1000);
+    if (seconds < 60) {
+        return `${seconds}s`;
+    }
+    const minutes = Math.floor(seconds / 60);
+    const remainingSeconds = seconds % 60;
+    if (minutes < 60) {
+        return `${minutes}m${remainingSeconds}s`;
+    }
+    const hours = Math.floor(minutes / 60);
+    const remainingMinutes = minutes % 60;
+    return `${hours}h${remainingMinutes}m`;
+}
+function formatLockLine(lock) {
+    const pidStatus = lock.pid === null ? "pid=missing" : `pid=${lock.pid} (${lock.pidAlive ? "alive" : "dead"})`;
+    const ageStatus = `age=${formatAge(lock.ageMs)}`;
+    const staleStatus = lock.stale
+        ? `stale=yes (${lock.staleReasons.join(", ") || "unknown"})`
+        : "stale=no";
+    const removedStatus = lock.removed ? " [removed]" : "";
+    return `- ${shortenHomePath(lock.lockPath)} ${pidStatus} ${ageStatus} ${staleStatus}${removedStatus}`;
+}
+export async function noteSessionLockHealth(params) {
+    const shouldRepair = params?.shouldRepair === true;
+    const staleMs = params?.staleMs ?? DEFAULT_STALE_MS;
+    let sessionDirs = [];
+    try {
+        sessionDirs = await resolveAgentSessionDirs(resolveStateDir(process.env));
+    }
+    catch (err) {
+        note(`- Failed to inspect session lock files: ${String(err)}`, "Session locks");
+        return;
+    }
+    if (sessionDirs.length === 0) {
+        return;
+    }
+    const allLocks = [];
+    for (const sessionsDir of sessionDirs) {
+        const result = await cleanStaleLockFiles({
+            sessionsDir,
+            staleMs,
+            removeStale: shouldRepair,
+        });
+        allLocks.push(...result.locks);
+    }
+    if (allLocks.length === 0) {
+        return;
+    }
+    const staleCount = allLocks.filter((lock) => lock.stale).length;
+    const removedCount = allLocks.filter((lock) => lock.removed).length;
+    const lines = [
+        `- Found ${allLocks.length} session lock file${allLocks.length === 1 ? "" : "s"}.`,
+        ...allLocks.toSorted((a, b) => a.lockPath.localeCompare(b.lockPath)).map(formatLockLine),
+    ];
+    if (staleCount > 0 && !shouldRepair) {
+        lines.push(`- ${staleCount} lock file${staleCount === 1 ? " is" : "s are"} stale.`);
+        lines.push('- Run "openclaw doctor --fix" to remove stale lock files automatically.');
+    }
+    if (shouldRepair && removedCount > 0) {
+        lines.push(`- Removed ${removedCount} stale session lock file${removedCount === 1 ? "" : "s"}.`);
+    }
+    note(lines.join("\n"), "Session locks");
+}