@poolzin/pool-bot 2026.3.7 → 2026.3.10

package/dist/commands/doctor-checks.js

@@ -0,0 +1,498 @@
+/**
+ * Helper to safely get config
+ */
+async function safeLoadConfig() {
+    try {
+        const { loadConfig } = await import("../config/config.js");
+        return (await loadConfig());
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Registry of all doctor checks
+ */
+export const doctorCheckRegistry = {
+    config: async () => {
+        const start = Date.now();
+        try {
+            const { readConfigFileSnapshot } = await import("../config/config.js");
+            const snapshot = await readConfigFileSnapshot();
+            if (!snapshot.exists) {
+                return {
+                    name: "config",
+                    status: "error",
+                    message: "Configuration file not found",
+                    durationMs: Date.now() - start,
+                    suggestions: ["Run `poolbot setup` to create initial configuration"],
+                };
+            }
+            if (!snapshot.valid) {
+                const issues = snapshot.issues?.map((i) => i.message).join("; ") ?? "Unknown issues";
+                return {
+                    name: "config",
+                    status: "error",
+                    message: `Configuration invalid: ${issues}`,
+                    durationMs: Date.now() - start,
+                    suggestions: ["Run `poolbot doctor --fix` to auto-repair configuration"],
+                    details: { issues: snapshot.issues },
+                };
+            }
+            return {
+                name: "config",
+                status: "ok",
+                message: "Configuration is valid",
+                durationMs: Date.now() - start,
+                details: { path: snapshot.path },
+            };
+        }
+        catch (err) {
+            return {
+                name: "config",
+                status: "error",
+                message: `Failed to check config: ${String(err)}`,
+                durationMs: Date.now() - start,
+            };
+        }
+    },
+    auth: async () => {
+        const start = Date.now();
+        try {
+            const cfg = await safeLoadConfig();
+            if (!cfg) {
+                return {
+                    name: "auth",
+                    status: "skipped",
+                    message: "Could not load configuration",
+                    durationMs: Date.now() - start,
+                };
+            }
+            // Check auth profiles
+            const authProfiles = cfg.authProfiles;
+            if (!authProfiles || authProfiles.length === 0) {
+                return {
+                    name: "auth",
+                    status: "warning",
+                    message: "No authentication profiles configured",
+                    durationMs: Date.now() - start,
+                    suggestions: ["Run `poolbot configure` to set up authentication"],
+                };
+            }
+            const validProfiles = authProfiles.filter((p) => p?.credential);
+            if (validProfiles.length === 0) {
+                return {
+                    name: "auth",
+                    status: "error",
+                    message: "Auth profiles exist but none have valid credentials",
+                    durationMs: Date.now() - start,
+                    suggestions: ["Run `poolbot configure` to re-authenticate"],
+                };
+            }
+            return {
+                name: "auth",
+                status: "ok",
+                message: `${validProfiles.length} authentication profile(s) configured`,
+                durationMs: Date.now() - start,
+                details: { profileCount: validProfiles.length },
+            };
+        }
+        catch (err) {
+            return {
+                name: "auth",
+                status: "error",
+                message: `Failed to check auth: ${String(err)}`,
+                durationMs: Date.now() - start,
+            };
+        }
+    },
+    completion: async () => {
+        const start = Date.now();
+        try {
+            const { checkShellCompletionStatus } = await import("./doctor-completion.js");
+            const status = await checkShellCompletionStatus();
+            if (!status.cacheExists) {
+                return {
+                    name: "completion",
+                    status: "warning",
+                    message: "Completion cache not found",
+                    durationMs: Date.now() - start,
+                    suggestions: [
+                        "Run `poolbot completion --write-state` to generate cache",
+                        "Run `poolbot completion --install` to install to shell profile",
+                    ],
+                    details: { shell: status.shell },
+                };
+            }
+            if (!status.profileInstalled) {
+                return {
+                    name: "completion",
+                    status: "warning",
+                    message: `Completion cache exists but not installed in ${status.shell} profile`,
+                    durationMs: Date.now() - start,
+                    suggestions: ["Run `poolbot completion --install` to enable completion"],
+                    details: { shell: status.shell, cachePath: status.cachePath },
+                };
+            }
+            if (status.usesSlowPattern) {
+                return {
+                    name: "completion",
+                    status: "warning",
+                    message: "Using slow dynamic completion pattern",
+                    durationMs: Date.now() - start,
+                    suggestions: ["Run `poolbot doctor --fix` to upgrade to cached completion"],
+                    details: { shell: status.shell },
+                };
+            }
+            return {
+                name: "completion",
+                status: "ok",
+                message: `Shell completion installed and cached for ${status.shell}`,
+                durationMs: Date.now() - start,
+                details: { shell: status.shell, cachePath: status.cachePath },
+            };
+        }
+        catch (err) {
+            return {
+                name: "completion",
+                status: "error",
+                message: `Failed to check completion: ${String(err)}`,
+                durationMs: Date.now() - start,
+            };
+        }
+    },
+    gateway: async ({ runtime, options }) => {
+        const start = Date.now();
+        try {
+            const cfg = await safeLoadConfig();
+            if (!cfg) {
+                return {
+                    name: "gateway",
+                    status: "skipped",
+                    message: "Could not load configuration",
+                    durationMs: Date.now() - start,
+                };
+            }
+            const { checkGatewayHealth } = await import("./doctor-gateway-health.js");
+            const result = await checkGatewayHealth({
+                runtime,
+                cfg: cfg,
+                timeoutMs: options.nonInteractive ? 3000 : 10_000,
+            });
+            if (!result.healthOk) {
+                return {
+                    name: "gateway",
+                    status: "error",
+                    message: "Gateway health check failed",
+                    durationMs: Date.now() - start,
+                    suggestions: [
+                        "Run `poolbot gateway status` for detailed status",
+                        "Run `poolbot gateway restart` to restart the gateway",
+                    ],
+                };
+            }
+            return {
+                name: "gateway",
+                status: "ok",
+                message: "Gateway is healthy",
+                durationMs: Date.now() - start,
+            };
+        }
+        catch (err) {
+            return {
+                name: "gateway",
+                status: "error",
+                message: `Failed to check gateway: ${String(err)}`,
+                durationMs: Date.now() - start,
+            };
+        }
+    },
+    security: async () => {
+        const start = Date.now();
+        try {
+            const cfg = await safeLoadConfig();
+            if (!cfg) {
+                return {
+                    name: "security",
+                    status: "skipped",
+                    message: "Could not load configuration",
+                    durationMs: Date.now() - start,
+                };
+            }
+            // Check for security warnings
+            const warnings = [];
+            const suggestions = [];
+            // Check gateway auth
+            const gateway = cfg.gateway;
+            const auth = gateway?.auth;
+            const authMode = auth?.mode;
+            if (authMode === "off") {
+                warnings.push("Gateway authentication is disabled");
+                suggestions.push("Enable token auth: poolbot config set gateway.auth.mode token");
+            }
+            // Check channel allowlists
+            const channels = cfg.channels;
+            if (channels) {
+                for (const [name, channel] of Object.entries(channels)) {
+                    if (channel && typeof channel === "object") {
+                        const ch = channel;
+                        if (!ch.allowFrom || ch.allowFrom.length === 0) {
+                            warnings.push(`Channel ${name} has no allowlist configured`);
+                        }
+                    }
+                }
+            }
+            if (warnings.length > 0) {
+                return {
+                    name: "security",
+                    status: "warning",
+                    message: `${warnings.length} security warning(s) found`,
+                    durationMs: Date.now() - start,
+                    suggestions,
+                    details: { warnings },
+                };
+            }
+            return {
+                name: "security",
+                status: "ok",
+                message: "No security warnings detected",
+                durationMs: Date.now() - start,
+            };
+        }
+        catch (err) {
+            return {
+                name: "security",
+                status: "error",
+                message: `Failed to check security: ${String(err)}`,
+                durationMs: Date.now() - start,
+            };
+        }
+    },
+    plugins: async () => {
+        const start = Date.now();
+        // This is a simplified check - real implementation would load plugin registry
+        return {
+            name: "plugins",
+            status: "ok",
+            message: "Plugin check not yet implemented",
+            durationMs: Date.now() - start,
+        };
+    },
+    memory: async () => {
+        const start = Date.now();
+        try {
+            const cfg = await safeLoadConfig();
+            if (!cfg) {
+                return {
+                    name: "memory",
+                    status: "skipped",
+                    message: "Could not load configuration",
+                    durationMs: Date.now() - start,
+                };
+            }
+            const agents = cfg.agents;
+            const defaults = agents?.defaults;
+            const memorySearch = defaults?.memorySearch;
+            const memoryEnabled = memorySearch?.enabled ?? false;
+            if (!memoryEnabled) {
+                return {
+                    name: "memory",
+                    status: "warning",
+                    message: "Memory search is disabled",
+                    durationMs: Date.now() - start,
+                    suggestions: [
+                        "Enable memory: poolbot config set agents.defaults.memorySearch.enabled true",
+                    ],
+                };
+            }
+            return {
+                name: "memory",
+                status: "ok",
+                message: "Memory search is enabled",
+                durationMs: Date.now() - start,
+            };
+        }
+        catch (err) {
+            return {
+                name: "memory",
+                status: "error",
+                message: `Failed to check memory: ${String(err)}`,
+                durationMs: Date.now() - start,
+            };
+        }
+    },
+    workspace: async () => {
+        const start = Date.now();
+        try {
+            const agentScope = await import("../agents/agent-scope.js");
+            const cfg = await safeLoadConfig();
+            if (!cfg) {
+                return {
+                    name: "workspace",
+                    status: "skipped",
+                    message: "Could not load configuration",
+                    durationMs: Date.now() - start,
+                };
+            }
+            const agentId = agentScope.resolveDefaultAgentId(cfg);
+            const workspaceDir = agentScope.resolveAgentWorkspaceDir(cfg, agentId);
+            // Check if workspace exists
+            const fs = await import("node:fs");
+            if (!fs.existsSync(workspaceDir)) {
+                return {
+                    name: "workspace",
+                    status: "warning",
+                    message: `Workspace directory does not exist`,
+                    durationMs: Date.now() - start,
+                    suggestions: ["The workspace will be created on first agent run"],
+                    details: { path: workspaceDir },
+                };
+            }
+            return {
+                name: "workspace",
+                status: "ok",
+                message: `Workspace ready`,
+                durationMs: Date.now() - start,
+                details: { path: workspaceDir },
+            };
+        }
+        catch (err) {
+            return {
+                name: "workspace",
+                status: "error",
+                message: `Failed to check workspace: ${String(err)}`,
+                durationMs: Date.now() - start,
+            };
+        }
+    },
+    state: async () => {
+        const start = Date.now();
+        try {
+            const { resolveStateDir } = await import("../config/paths.js");
+            const path = await import("node:path");
+            const fs = await import("node:fs");
+            const stateDir = resolveStateDir();
+            const checks = {
+                stateDir: fs.existsSync(stateDir),
+                completions: fs.existsSync(path.join(stateDir, "completions")),
+                sessions: fs.existsSync(path.join(stateDir, "sessions")),
+            };
+            const missing = Object.entries(checks)
+                .filter(([, exists]) => !exists)
+                .map(([name]) => name);
+            if (missing.length > 0) {
+                return {
+                    name: "state",
+                    status: "warning",
+                    message: `Missing state directories: ${missing.join(", ")}`,
+                    durationMs: Date.now() - start,
+                    suggestions: ["Run `poolbot doctor --fix` to create missing directories"],
+                    details: { checks },
+                };
+            }
+            return {
+                name: "state",
+                status: "ok",
+                message: "All state directories present",
+                durationMs: Date.now() - start,
+                details: { checks },
+            };
+        }
+        catch (err) {
+            return {
+                name: "state",
+                status: "error",
+                message: `Failed to check state: ${String(err)}`,
+                durationMs: Date.now() - start,
+            };
+        }
+    },
+};
+/**
+ * Run a specific check by name
+ */
+export async function runDoctorCheck(name, params) {
+    const checkFn = doctorCheckRegistry[name];
+    if (!checkFn) {
+        return {
+            name,
+            status: "error",
+            message: `Unknown check: ${name}`,
+            durationMs: 0,
+        };
+    }
+    return checkFn(params);
+}
+/**
+ * Run all checks and generate report
+ */
+export async function runAllDoctorChecks(params) {
+    const checks = [
+        "config",
+        "auth",
+        "completion",
+        "gateway",
+        "security",
+        "memory",
+        "workspace",
+        "state",
+    ];
+    const results = [];
+    for (const checkName of checks) {
+        const result = await runDoctorCheck(checkName, params);
+        results.push(result);
+    }
+    // Calculate health score
+    const weights = { ok: 1, warning: 0.5, error: 0, skipped: 0.75 };
+    const totalWeight = results.reduce((sum, r) => sum + weights[r.status], 0);
+    const healthScore = Math.round((totalWeight / results.length) * 100);
+    return {
+        timestamp: new Date().toISOString(),
+        version: "2026.3.9", // Should be dynamic
+        checks: results,
+        summary: {
+            total: results.length,
+            ok: results.filter((r) => r.status === "ok").length,
+            warning: results.filter((r) => r.status === "warning").length,
+            error: results.filter((r) => r.status === "error").length,
+            skipped: results.filter((r) => r.status === "skipped").length,
+            autoFixed: results.filter((r) => r.autoFixed).length,
+        },
+        healthScore,
+    };
+}
+/**
+ * Format report for console output
+ */
+export function formatDoctorReport(report) {
+    const lines = [];
+    // Header
+    lines.push("╔════════════════════════════════════════════════════════╗");
+    lines.push("║           🏥 PoolBot Doctor Report                     ║");
+    lines.push("╚════════════════════════════════════════════════════════╝");
+    lines.push("");
+    // Health score
+    const scoreColor = report.healthScore >= 80 ? "🟢" : report.healthScore >= 50 ? "🟡" : "🔴";
+    lines.push(`Health Score: ${scoreColor} ${report.healthScore}/100`);
+    lines.push("");
+    // Summary
+    lines.push("Summary:");
+    lines.push(`  ✅ OK:       ${report.summary.ok}/${report.summary.total}`);
+    lines.push(`  ⚠️  Warning:  ${report.summary.warning}/${report.summary.total}`);
+    lines.push(`  ❌ Error:    ${report.summary.error}/${report.summary.total}`);
+    if (report.summary.autoFixed > 0) {
+        lines.push(`  🔧 Auto-fixed: ${report.summary.autoFixed}`);
+    }
+    lines.push("");
+    // Individual checks
+    for (const check of report.checks) {
+        const icon = check.status === "ok" ? "✅" : check.status === "warning" ? "⚠️" : "❌";
+        lines.push(`${icon} ${check.name.padEnd(12)} ${check.message}`);
+        if (check.suggestions && check.suggestions.length > 0) {
+            for (const suggestion of check.suggestions) {
+                lines.push(`   💡 ${suggestion}`);
+            }
+        }
+    }
+    return lines.join("\n");
+}

package/dist/config/config.js

@@ -2,6 +2,7 @@ export { createConfigIO, loadConfig, parseConfigJson5, readConfigFileSnapshot, r
 export { migrateLegacyConfig } from "./legacy-migrate.js";
 export * from "./paths.js";
 export * from "./runtime-overrides.js";
+export * from "./secrets-integration.js";
 export * from "./types.js";
 export { validateConfigObject, validateConfigObjectWithPlugins } from "./validation.js";
 export { PoolBotSchema } from "./zod-schema.js";

package/dist/config/secrets-integration.js

@@ -0,0 +1,88 @@
+/**
+ * Config Secrets Integration
+ *
+ * Integrates the secrets management system with config loading.
+ * Resolves SecretRefs in config values at runtime.
+ */
+import { SecretsRuntime } from "../secrets/index.js";
+const SECRET_PATHS = [
+    "agent.model",
+    "agent.apiKey",
+    "channels.telegram.botToken",
+    "channels.discord.token",
+    "channels.slack.botToken",
+    "channels.slack.appToken",
+    "gateway.auth.token",
+    "gateway.auth.password",
+    "memory.apiKey",
+    "tools.browser.apiKey",
+];
+/**
+ * Deeply traverse config and resolve secret references
+ */
+export function resolveConfigSecrets(config, secretsRuntime) {
+    const resolved = { ...config };
+    // Resolve specific known secret paths
+    for (const path of SECRET_PATHS) {
+        resolvePath(resolved, path.split("."), secretsRuntime);
+    }
+    // Also scan for any string values that look like secret refs
+    scanAndResolveSecrets(resolved, "", secretsRuntime);
+    return resolved;
+}
+function resolvePath(obj, path, runtime) {
+    if (path.length === 0)
+        return;
+    const [head, ...tail] = path;
+    if (!(head in obj))
+        return;
+    if (tail.length === 0) {
+        // Leaf node - resolve if it's a string
+        const value = obj[head];
+        if (typeof value === "string") {
+            const result = runtime.resolve(head, value);
+            if (result.value !== undefined) {
+                obj[head] = result.value;
+            }
+        }
+    }
+    else {
+        // Traverse deeper
+        const child = obj[head];
+        if (typeof child === "object" && child !== null && !Array.isArray(child)) {
+            resolvePath(child, tail, runtime);
+        }
+    }
+}
+function scanAndResolveSecrets(obj, path, runtime) {
+    if (typeof obj === "string") {
+        // Check if it looks like a secret ref
+        if (obj.startsWith("env:") || obj.startsWith("file:")) {
+            runtime.resolve(path || "unknown", obj);
+        }
+        return;
+    }
+    if (Array.isArray(obj)) {
+        obj.forEach((item, index) => {
+            scanAndResolveSecrets(item, `${path}[${index}]`, runtime);
+        });
+        return;
+    }
+    if (typeof obj === "object" && obj !== null) {
+        for (const [key, value] of Object.entries(obj)) {
+            const newPath = path ? `${path}.${key}` : key;
+            scanAndResolveSecrets(value, newPath, runtime);
+        }
+    }
+}
+/**
+ * Create a secrets runtime from config
+ */
+export function createSecretsRuntimeFromConfig(_config, secretsConfig) {
+    return new SecretsRuntime({
+        allowDirectValues: true,
+        warnOnDirectValues: true,
+        failOnUnresolved: false,
+        ...secretsConfig,
+    });
+}

package/dist/context-engine/index.js

@@ -0,0 +1,33 @@
+/**
+ * Context Engine - Pluggable conversation context management
+ *
+ * @example
+ * ```typescript
+ * import { LegacyContextEngine, globalContextEngineRegistry } from './context-engine/index.js';
+ *
+ * // Register the legacy engine
+ * globalContextEngineRegistry.register('legacy', LegacyContextEngine);
+ *
+ * // Get engine instance
+ * const engine = globalContextEngineRegistry.getEngine('legacy');
+ *
+ * // Bootstrap for a session
+ * await engine.bootstrap({ sessionId: 'session-123' });
+ *
+ * // Ingest a message
+ * await engine.ingest({
+ *   sessionId: 'session-123',
+ *   message: { role: 'user', content: 'Hello!' }
+ * });
+ *
+ * // Assemble context
+ * const result = await engine.assemble({
+ *   sessionId: 'session-123',
+ *   messages: []
+ * });
+ * ```
+ */
+// Registry
+export { ContextEngineRegistry, globalContextEngineRegistry, resolveContextEngine, } from "./registry.js";
+// Legacy Engine
+export { LegacyContextEngine, createLegacyContextEngine } from "./legacy.js";