alvin-bot 4.4.1

package/dist/providers/registry.js

@@ -0,0 +1,209 @@
+/**
+ * Provider Registry — Model selection, fallback chain, and runtime switching.
+ *
+ * This is the central hub for multi-model support. It manages:
+ * - Which providers are configured and available
+ * - The active provider (switchable at runtime via /model)
+ * - Fallback chain when the active provider fails
+ */
+import { ClaudeSDKProvider } from "./claude-sdk-provider.js";
+import { CodexCLIProvider } from "./codex-cli-provider.js";
+import { OpenAICompatibleProvider } from "./openai-compatible.js";
+import { PROVIDER_PRESETS } from "./types.js";
+export class ProviderRegistry {
+    providers = new Map();
+    primaryKey;
+    fallbackKeys;
+    activeKey;
+    constructor(config) {
+        this.primaryKey = config.primary;
+        this.fallbackKeys = config.fallbacks || [];
+        this.activeKey = config.primary;
+        // Register all configured providers
+        for (const [key, providerConfig] of Object.entries(config.providers)) {
+            this.register(key, providerConfig);
+        }
+    }
+    /**
+     * Register a provider by key.
+     */
+    register(key, config) {
+        const provider = this.createProvider(config);
+        this.providers.set(key, provider);
+    }
+    /**
+     * Get the currently active provider.
+     */
+    getActive() {
+        const provider = this.providers.get(this.activeKey);
+        if (!provider) {
+            throw new Error(`Active provider "${this.activeKey}" not found`);
+        }
+        return provider;
+    }
+    /**
+     * Get a specific provider by key.
+     */
+    get(key) {
+        return this.providers.get(key);
+    }
+    /**
+     * Switch the active provider (e.g., via /model command).
+     */
+    switchTo(key) {
+        if (!this.providers.has(key))
+            return false;
+        this.activeKey = key;
+        return true;
+    }
+    /**
+     * Get the active provider key.
+     */
+    getActiveKey() {
+        return this.activeKey;
+    }
+    /**
+     * List all registered providers with their status.
+     */
+    async listAll() {
+        const result = [];
+        for (const [key, provider] of this.providers) {
+            const info = provider.getInfo();
+            result.push({
+                key,
+                ...info,
+                active: key === this.activeKey,
+            });
+        }
+        return result;
+    }
+    /**
+     * Query with automatic fallback.
+     * Tries the active provider first, then fallbacks in order.
+     */
+    async *queryWithFallback(options) {
+        const chain = [this.activeKey, ...this.fallbackKeys.filter(k => k !== this.activeKey)];
+        const errors = [];
+        for (const key of chain) {
+            const provider = this.providers.get(key);
+            if (!provider)
+                continue;
+            // Check availability before trying
+            const available = await provider.isAvailable().catch(() => false);
+            if (!available) {
+                console.log(`Provider "${key}" not available, trying next...`);
+                errors.push({ key, error: "not available (check auth/config)" });
+                continue;
+            }
+            let hadError = false;
+            let lastError = "";
+            try {
+                for await (const chunk of provider.query(options)) {
+                    if (chunk.type === "error") {
+                        hadError = true;
+                        lastError = chunk.error || "Unknown error";
+                        break;
+                    }
+                    yield chunk;
+                    if (chunk.type === "done")
+                        return;
+                }
+            }
+            catch (err) {
+                hadError = true;
+                lastError = err instanceof Error ? err.message : String(err);
+            }
+            if (hadError) {
+                console.log(`Provider "${key}" failed: ${lastError}. Trying next...`);
+                errors.push({ key, error: lastError });
+                // Find next provider to notify about fallback
+                const nextIdx = chain.indexOf(key) + 1;
+                if (nextIdx < chain.length) {
+                    const nextProvider = this.providers.get(chain[nextIdx]);
+                    if (nextProvider) {
+                        yield {
+                            type: "fallback",
+                            failedProvider: provider.getInfo().name,
+                            providerName: nextProvider.getInfo().name,
+                            error: lastError,
+                        };
+                    }
+                }
+                continue;
+            }
+            // If we got here without done or error, something's off
+            return;
+        }
+        // All providers failed — show specific errors
+        const errorDetail = errors.map(e => `  ${e.key}: ${e.error}`).join("\n");
+        yield {
+            type: "error",
+            error: `No provider available.\n${errorDetail}\n\nFix: alvin-bot setup | Telegram: /model`,
+        };
+    }
+    /**
+     * Reset to primary provider.
+     */
+    resetToDefault() {
+        this.activeKey = this.primaryKey;
+    }
+    // ── Private ─────────────────────────────────────────
+    createProvider(config) {
+        switch (config.type) {
+            case "claude-sdk":
+                return new ClaudeSDKProvider(config);
+            case "codex-cli":
+                return new CodexCLIProvider(config);
+            case "openai-compatible":
+                return new OpenAICompatibleProvider(config);
+            default:
+                throw new Error(`Unknown provider type: ${config.type}`);
+        }
+    }
+}
+/**
+ * Create a ProviderRegistry from a simple, user-friendly config.
+ * Auto-configures providers based on available API keys.
+ */
+export function createRegistry(config) {
+    const providers = {};
+    // Register Codex CLI if referenced
+    if (config.primary === "codex-cli" || config.fallbacks?.includes("codex-cli")) {
+        providers["codex-cli"] = {
+            ...PROVIDER_PRESETS["codex-cli"],
+            type: "codex-cli",
+            name: "Codex CLI (OpenAI)",
+            model: "gpt-5.4",
+        };
+    }
+    // Always register Claude SDK if it's referenced
+    if (config.primary === "claude-sdk" || config.fallbacks?.includes("claude-sdk")) {
+        providers["claude-sdk"] = {
+            ...PROVIDER_PRESETS["claude-sdk"],
+            type: "claude-sdk",
+            name: "Claude (Agent SDK)",
+            model: "claude-opus-4-6",
+        };
+    }
+    // Auto-register Google Gemini (single model) if key is available
+    if (config.apiKeys?.google) {
+        providers["google"] = {
+            ...PROVIDER_PRESETS["gemini-2.5-flash"],
+            name: "Google Gemini",
+            apiKey: config.apiKeys.google,
+        };
+    }
+    // Always try to detect local Ollama
+    providers["ollama"] = {
+        ...PROVIDER_PRESETS["ollama"],
+    };
+    // Add custom providers
+    if (config.customProviders) {
+        Object.assign(providers, config.customProviders);
+    }
+    return new ProviderRegistry({
+        primary: config.primary,
+        fallbacks: config.fallbacks,
+        providers,
+    });
+}

package/dist/providers/tool-executor.js

@@ -0,0 +1,450 @@
+/**
+ * Tool Executor — Executes tool calls for non-SDK providers.
+ *
+ * Provides core agent capabilities (shell, file read/write, web fetch)
+ * to any OpenAI-compatible provider that supports function calling.
+ *
+ * This bridges the gap between Claude SDK (built-in tools) and other
+ * providers (Groq, NVIDIA, Gemini, etc.) — giving them all agent powers.
+ */
+import { execSync } from "child_process";
+import fs from "fs";
+import { resolve } from "path";
+import { isSelfRestartCommand, scheduleGracefulRestart } from "../services/restart.js";
+// ── Tool Definitions (OpenAI function calling format) ───────────────────────
+export const AGENT_TOOLS = [
+    {
+        type: "function",
+        function: {
+            name: "run_shell",
+            description: "Execute a shell command and return the output. Use for: running CLI tools, checking system state, installing packages, processing files, git operations, etc. Timeout: 30 seconds.",
+            parameters: {
+                type: "object",
+                properties: {
+                    command: {
+                        type: "string",
+                        description: "The shell command to execute (bash). Example: 'ls -la', 'which ffmpeg', 'curl wttr.in/Berlin'"
+                    },
+                    workingDir: {
+                        type: "string",
+                        description: "Working directory (optional, defaults to user's configured dir)"
+                    }
+                },
+                required: ["command"],
+            },
+        },
+    },
+    {
+        type: "function",
+        function: {
+            name: "read_file",
+            description: "Read the contents of a file. Returns the text content. Use for: reading configs, code files, documents, logs, memory files, etc.",
+            parameters: {
+                type: "object",
+                properties: {
+                    path: {
+                        type: "string",
+                        description: "Absolute or relative path to the file"
+                    },
+                    maxLines: {
+                        type: "number",
+                        description: "Maximum number of lines to read (optional, default: all)"
+                    }
+                },
+                required: ["path"],
+            },
+        },
+    },
+    {
+        type: "function",
+        function: {
+            name: "write_file",
+            description: "Write content to a file. Creates the file if it doesn't exist, overwrites if it does. Use for: creating files, saving results, writing memory, updating configs.",
+            parameters: {
+                type: "object",
+                properties: {
+                    path: {
+                        type: "string",
+                        description: "Absolute or relative path to the file"
+                    },
+                    content: {
+                        type: "string",
+                        description: "Content to write"
+                    },
+                    append: {
+                        type: "boolean",
+                        description: "Append instead of overwrite (default: false)"
+                    }
+                },
+                required: ["path", "content"],
+            },
+        },
+    },
+    {
+        type: "function",
+        function: {
+            name: "web_fetch",
+            description: "Fetch a URL and return the content as text/markdown. Use for: reading web pages, APIs, documentation, search results.",
+            parameters: {
+                type: "object",
+                properties: {
+                    url: {
+                        type: "string",
+                        description: "URL to fetch (http or https)"
+                    },
+                    maxChars: {
+                        type: "number",
+                        description: "Maximum characters to return (default: 10000)"
+                    }
+                },
+                required: ["url"],
+            },
+        },
+    },
+    {
+        type: "function",
+        function: {
+            name: "web_search",
+            description: "Search the web and return results. Use for: looking up information, finding answers, research.",
+            parameters: {
+                type: "object",
+                properties: {
+                    query: {
+                        type: "string",
+                        description: "Search query"
+                    }
+                },
+                required: ["query"],
+            },
+        },
+    },
+    {
+        type: "function",
+        function: {
+            name: "list_directory",
+            description: "List files and directories at a given path. Returns names, types (file/dir), and sizes. Use for: exploring project structures, finding files, checking what exists.",
+            parameters: {
+                type: "object",
+                properties: {
+                    path: {
+                        type: "string",
+                        description: "Directory path to list (default: current working directory)"
+                    },
+                    recursive: {
+                        type: "boolean",
+                        description: "List recursively (max 3 levels deep, default: false)"
+                    }
+                },
+                required: [],
+            },
+        },
+    },
+    {
+        type: "function",
+        function: {
+            name: "python_execute",
+            description: "Execute a Python 3 script and return stdout/stderr. Use for: data processing, creating Excel/CSV files, complex calculations, JSON/XML transformation, image processing, PDF generation, chart creation, and any task that benefits from Python libraries (openpyxl, pandas, matplotlib, Pillow, etc.).",
+            parameters: {
+                type: "object",
+                properties: {
+                    code: {
+                        type: "string",
+                        description: "Python 3 code to execute. Can use installed pip packages. Use print() for output."
+                    },
+                    workingDir: {
+                        type: "string",
+                        description: "Working directory for the script (optional)"
+                    }
+                },
+                required: ["code"],
+            },
+        },
+    },
+    {
+        type: "function",
+        function: {
+            name: "edit_file",
+            description: "Make a precise edit to a file by replacing exact text. More surgical than write_file — preserves the rest of the file. Use for: fixing bugs, updating configs, changing specific lines.",
+            parameters: {
+                type: "object",
+                properties: {
+                    path: {
+                        type: "string",
+                        description: "Path to the file to edit"
+                    },
+                    oldText: {
+                        type: "string",
+                        description: "Exact text to find (must match exactly including whitespace)"
+                    },
+                    newText: {
+                        type: "string",
+                        description: "Replacement text"
+                    }
+                },
+                required: ["path", "oldText", "newText"],
+            },
+        },
+    },
+];
+/**
+ * Execute a tool call and return the result.
+ */
+export function executeTool(name, args, workingDir) {
+    try {
+        switch (name) {
+            case "run_shell":
+                return executeShell(args.command, args.workingDir || workingDir);
+            case "read_file":
+                return executeReadFile(args.path, args.maxLines, workingDir);
+            case "write_file":
+                return executeWriteFile(args.path, args.content, args.append, workingDir);
+            case "web_fetch":
+                return executeWebFetch(args.url, args.maxChars);
+            case "web_search":
+                return executeWebSearch(args.query);
+            case "list_directory":
+                return executeListDirectory(args.path || workingDir, args.recursive, workingDir);
+            case "python_execute":
+                return executePython(args.code, args.workingDir || workingDir);
+            case "edit_file":
+                return executeEditFile(args.path, args.oldText, args.newText, workingDir);
+            default:
+                return { name, result: `Unknown tool: ${name}`, error: true };
+        }
+    }
+    catch (err) {
+        return {
+            name,
+            result: `Error: ${err instanceof Error ? err.message : String(err)}`,
+            error: true,
+        };
+    }
+}
+// ── Individual Tool Implementations ─────────────────────────────────────────
+function executeShell(command, cwd) {
+    // Intercept self-restart: use graceful internal restart instead of pm2 kill
+    if (isSelfRestartCommand(command)) {
+        scheduleGracefulRestart();
+        return { name: "run_shell", result: "Bot restart scheduled. Grammy will commit the Telegram offset before exiting." };
+    }
+    // Security: block obviously dangerous commands
+    const blocked = ["rm -rf /", "mkfs", "dd if=/dev/zero", "> /dev/sda"];
+    if (blocked.some(b => command.includes(b))) {
+        return { name: "run_shell", result: "Command blocked for safety.", error: true };
+    }
+    try {
+        const output = execSync(command, {
+            encoding: "utf-8",
+            cwd: cwd || process.cwd(),
+            timeout: 30_000,
+            maxBuffer: 1024 * 1024, // 1MB
+            env: { ...process.env, LANG: "en_US.UTF-8" },
+        });
+        // Truncate very long output
+        const truncated = output.length > 8000
+            ? output.substring(0, 8000) + `\n... (truncated, ${output.length} chars total)`
+            : output;
+        return { name: "run_shell", result: truncated || "(no output)" };
+    }
+    catch (err) {
+        const stderr = err.stderr ? err.stderr.toString().substring(0, 2000) : "";
+        const stdout = err.stdout ? err.stdout.toString().substring(0, 2000) : "";
+        return {
+            name: "run_shell",
+            result: `Exit code ${err.status || 1}\n${stdout}\n${stderr}`.trim(),
+            error: true,
+        };
+    }
+}
+function executeReadFile(path, maxLines, cwd) {
+    const fullPath = path.startsWith("/") ? path : resolve(cwd || process.cwd(), path);
+    try {
+        let content = fs.readFileSync(fullPath, "utf-8");
+        if (maxLines && maxLines > 0) {
+            const lines = content.split("\n");
+            if (lines.length > maxLines) {
+                content = lines.slice(0, maxLines).join("\n") + `\n... (${lines.length} lines total)`;
+            }
+        }
+        if (content.length > 20000) {
+            content = content.substring(0, 20000) + `\n... (truncated, ${content.length} chars)`;
+        }
+        return { name: "read_file", result: content };
+    }
+    catch (err) {
+        return { name: "read_file", result: `File not found or not readable: ${fullPath}`, error: true };
+    }
+}
+function executeWriteFile(path, content, append, cwd) {
+    const fullPath = path.startsWith("/") ? path : resolve(cwd || process.cwd(), path);
+    try {
+        // Ensure directory exists
+        const dir = fullPath.substring(0, fullPath.lastIndexOf("/"));
+        if (dir && !fs.existsSync(dir)) {
+            fs.mkdirSync(dir, { recursive: true });
+        }
+        if (append) {
+            fs.appendFileSync(fullPath, content);
+        }
+        else {
+            fs.writeFileSync(fullPath, content);
+        }
+        return { name: "write_file", result: `✅ Written to ${fullPath} (${content.length} chars)` };
+    }
+    catch (err) {
+        return { name: "write_file", result: `Write failed: ${err instanceof Error ? err.message : err}`, error: true };
+    }
+}
+function executeWebFetch(url, maxChars) {
+    try {
+        // Use curl for simplicity and reliability
+        const max = maxChars || 10000;
+        const output = execSync(`curl -sL --max-time 15 --max-filesize 5000000 "${url}" | head -c ${max * 2}`, { encoding: "utf-8", timeout: 20_000, maxBuffer: 5 * 1024 * 1024 });
+        // Basic HTML → text conversion
+        let text = output
+            .replace(/<script[^>]*>[\s\S]*?<\/script>/gi, "")
+            .replace(/<style[^>]*>[\s\S]*?<\/style>/gi, "")
+            .replace(/<[^>]+>/g, " ")
+            .replace(/\s+/g, " ")
+            .trim();
+        if (text.length > max)
+            text = text.substring(0, max) + "...";
+        return { name: "web_fetch", result: text || "(empty response)" };
+    }
+    catch (err) {
+        return { name: "web_fetch", result: `Fetch failed: ${err instanceof Error ? err.message : err}`, error: true };
+    }
+}
+function executeWebSearch(query) {
+    try {
+        // Use DuckDuckGo instant answer API (no key needed)
+        const encoded = encodeURIComponent(query);
+        const output = execSync(`curl -sL "https://api.duckduckgo.com/?q=${encoded}&format=json&no_html=1&skip_disambig=1"`, { encoding: "utf-8", timeout: 10_000 });
+        const data = JSON.parse(output);
+        const results = [];
+        if (data.AbstractText) {
+            results.push(`📝 ${data.AbstractText}`);
+            if (data.AbstractURL)
+                results.push(`   Source: ${data.AbstractURL}`);
+        }
+        if (data.RelatedTopics) {
+            for (const topic of data.RelatedTopics.slice(0, 5)) {
+                if (topic.Text) {
+                    results.push(`• ${topic.Text}`);
+                    if (topic.FirstURL)
+                        results.push(`  ${topic.FirstURL}`);
+                }
+            }
+        }
+        if (results.length === 0) {
+            // Fallback: use curl with a search engine
+            const fallback = execSync(`curl -sL "https://html.duckduckgo.com/html/?q=${encoded}" | grep -oP '<a rel="nofollow" class="result__a" href="[^"]*">[^<]*</a>' | head -5 | sed 's/<[^>]*>//g'`, { encoding: "utf-8", timeout: 10_000 }).trim();
+            if (fallback)
+                return { name: "web_search", result: fallback };
+            return { name: "web_search", result: `No results for "${query}". Try a different query or use web_fetch with a specific URL.` };
+        }
+        return { name: "web_search", result: results.join("\n") };
+    }
+    catch (err) {
+        return { name: "web_search", result: `Search failed: ${err instanceof Error ? err.message : err}`, error: true };
+    }
+}
+function executeListDirectory(dirPath, recursive, cwd) {
+    const fullPath = dirPath?.startsWith("/") ? dirPath : resolve(cwd || process.cwd(), dirPath || ".");
+    try {
+        if (!fs.existsSync(fullPath)) {
+            return { name: "list_directory", result: `Directory not found: ${fullPath}`, error: true };
+        }
+        const entries = [];
+        function listDir(dir, depth) {
+            const items = fs.readdirSync(dir, { withFileTypes: true });
+            const indent = "  ".repeat(depth);
+            for (const item of items) {
+                if (item.name.startsWith(".") && depth === 0 && items.length > 20)
+                    continue; // skip dotfiles in large dirs
+                const itemPath = resolve(dir, item.name);
+                if (item.isDirectory()) {
+                    entries.push(`${indent}📁 ${item.name}/`);
+                    if (recursive && depth < 3) {
+                        listDir(itemPath, depth + 1);
+                    }
+                }
+                else {
+                    try {
+                        const stats = fs.statSync(itemPath);
+                        const size = stats.size < 1024 ? `${stats.size}B`
+                            : stats.size < 1048576 ? `${(stats.size / 1024).toFixed(1)}KB`
+                                : `${(stats.size / 1048576).toFixed(1)}MB`;
+                        entries.push(`${indent}📄 ${item.name} (${size})`);
+                    }
+                    catch {
+                        entries.push(`${indent}📄 ${item.name}`);
+                    }
+                }
+            }
+        }
+        listDir(fullPath, 0);
+        const result = entries.length > 0
+            ? `${fullPath}:\n${entries.join("\n")}`
+            : `${fullPath}: (empty directory)`;
+        // Truncate if huge
+        return { name: "list_directory", result: result.length > 8000 ? result.substring(0, 8000) + "\n..." : result };
+    }
+    catch (err) {
+        return { name: "list_directory", result: `Error listing directory: ${err instanceof Error ? err.message : err}`, error: true };
+    }
+}
+function executePython(code, cwd) {
+    try {
+        // Write code to temp file to avoid shell escaping issues
+        const tmpFile = `/tmp/alvin-bot-py-${Date.now()}.py`;
+        fs.writeFileSync(tmpFile, code);
+        try {
+            const output = execSync(`python3 "${tmpFile}"`, {
+                encoding: "utf-8",
+                cwd: cwd || process.cwd(),
+                timeout: 60_000, // 60s for Python (may need to install packages, process data)
+                maxBuffer: 5 * 1024 * 1024, // 5MB
+                env: { ...process.env, LANG: "en_US.UTF-8", PYTHONIOENCODING: "utf-8" },
+            });
+            const truncated = output.length > 10000
+                ? output.substring(0, 10000) + `\n... (truncated, ${output.length} chars total)`
+                : output;
+            return { name: "python_execute", result: truncated || "(no output)" };
+        }
+        finally {
+            // Cleanup temp file
+            try {
+                fs.unlinkSync(tmpFile);
+            }
+            catch { /* ignore */ }
+        }
+    }
+    catch (err) {
+        const stderr = err.stderr ? err.stderr.toString().substring(0, 3000) : "";
+        const stdout = err.stdout ? err.stdout.toString().substring(0, 3000) : "";
+        return {
+            name: "python_execute",
+            result: `Python error (exit ${err.status || 1}):\n${stderr}\n${stdout}`.trim(),
+            error: true,
+        };
+    }
+}
+function executeEditFile(filePath, oldText, newText, cwd) {
+    const fullPath = filePath.startsWith("/") ? filePath : resolve(cwd || process.cwd(), filePath);
+    try {
+        if (!fs.existsSync(fullPath)) {
+            return { name: "edit_file", result: `File not found: ${fullPath}`, error: true };
+        }
+        const content = fs.readFileSync(fullPath, "utf-8");
+        if (!content.includes(oldText)) {
+            return { name: "edit_file", result: `oldText not found in ${fullPath}. Make sure it matches exactly (including whitespace).`, error: true };
+        }
+        const newContent = content.replace(oldText, newText);
+        fs.writeFileSync(fullPath, newContent);
+        return { name: "edit_file", result: `✅ Edited ${fullPath} — replaced ${oldText.length} chars with ${newText.length} chars` };
+    }
+    catch (err) {
+        return { name: "edit_file", result: `Edit failed: ${err instanceof Error ? err.message : err}`, error: true };
+    }
+}