alvin-bot 4.4.1

package/dist/services/custom-tools.js

@@ -0,0 +1,317 @@
+/**
+ * Custom Tool Registration — Users define their own tools via Markdown.
+ *
+ * Configuration via TOOLS.md (Markdown format):
+ *
+ * ## tool_name
+ * Tool description (first line after heading)
+ * ```
+ * shell command here
+ * ```
+ * **Type:** http (optional, default: shell)
+ * **URL:** https://example.com/api (for HTTP tools)
+ * **Method:** GET|POST|PUT|DELETE (default: GET)
+ * **Headers:** Key: Value (one per line)
+ * **Body:** request body
+ * **Timeout:** 30s, 5m, or milliseconds
+ * **Parameters:**
+ * - `name` (type, required): description
+ *
+ * Legacy: Also supports docs/tools.json as fallback.
+ */
+import fs from "fs";
+import { execSync } from "child_process";
+import { isSelfRestartCommand, scheduleGracefulRestart } from "./restart.js";
+import { TOOLS_MD, TOOLS_JSON, TOOLS_EXAMPLE_MD, TOOLS_EXAMPLE_JSON } from "../paths.js";
+// Auto-initialize TOOLS.md from example if missing (prefer MD over JSON)
+if (!fs.existsSync(TOOLS_MD) && fs.existsSync(TOOLS_EXAMPLE_MD)) {
+    fs.copyFileSync(TOOLS_EXAMPLE_MD, TOOLS_MD);
+}
+// Legacy fallback: also init tools.json if someone depends on it
+if (!fs.existsSync(TOOLS_JSON) && fs.existsSync(TOOLS_EXAMPLE_JSON)) {
+    fs.copyFileSync(TOOLS_EXAMPLE_JSON, TOOLS_JSON);
+}
+// ── Markdown Parser ─────────────────────────────────────
+function parseTimeout(value) {
+    const trimmed = value.trim().toLowerCase();
+    const match = trimmed.match(/^(\d+(?:\.\d+)?)\s*(ms|s|m|h)?$/);
+    if (!match)
+        return 30000;
+    const num = parseFloat(match[1]);
+    switch (match[2]) {
+        case "h": return num * 3600000;
+        case "m": return num * 60000;
+        case "s": return num * 1000;
+        case "ms": return num;
+        default: return num > 1000 ? num : num * 1000; // bare number: assume seconds if small
+    }
+}
+function parseToolsMd(content) {
+    const tools = [];
+    // Split by ## headings (tool boundaries)
+    const sections = content.split(/^## /m).slice(1); // skip preamble before first ##
+    for (const section of sections) {
+        const lines = section.split("\n");
+        const name = lines[0].trim().replace(/\s+/g, "_").toLowerCase();
+        if (!name)
+            continue;
+        const tool = { name, description: "" };
+        // First non-empty line after heading = description
+        let i = 1;
+        while (i < lines.length && !lines[i].trim())
+            i++;
+        if (i < lines.length && !lines[i].startsWith("```") && !lines[i].startsWith("**")) {
+            tool.description = lines[i].trim();
+            i++;
+        }
+        // Parse remaining lines
+        let inCodeBlock = false;
+        let codeLines = [];
+        let inHeaders = false;
+        const headerLines = [];
+        let inParams = false;
+        const paramEntries = [];
+        for (; i < lines.length; i++) {
+            const line = lines[i];
+            // Code block (command)
+            if (line.startsWith("```")) {
+                if (inCodeBlock) {
+                    tool.command = codeLines.join("\n").trim();
+                    inCodeBlock = false;
+                    codeLines = [];
+                }
+                else {
+                    inCodeBlock = true;
+                }
+                continue;
+            }
+            if (inCodeBlock) {
+                codeLines.push(line);
+                continue;
+            }
+            // Bold-key fields: **Key:** value
+            const boldMatch = line.match(/^\*\*(\w[\w\s]*):\*\*\s*(.*)/);
+            if (boldMatch) {
+                const key = boldMatch[1].trim().toLowerCase();
+                const value = boldMatch[2].trim();
+                // End previous multi-line sections
+                if (key !== "headers")
+                    inHeaders = false;
+                if (key !== "parameters")
+                    inParams = false;
+                switch (key) {
+                    case "type":
+                        tool.type = value.toLowerCase();
+                        break;
+                    case "url":
+                        tool.url = value;
+                        break;
+                    case "method":
+                        tool.method = value.toUpperCase();
+                        break;
+                    case "headers":
+                        inHeaders = true;
+                        if (value)
+                            headerLines.push(value);
+                        break;
+                    case "body":
+                        tool.body = value;
+                        break;
+                    case "timeout":
+                        tool.timeout = parseTimeout(value);
+                        break;
+                    case "parameters":
+                        inParams = true;
+                        break;
+                }
+                continue;
+            }
+            // Header continuation lines (Key: Value)
+            if (inHeaders && line.match(/^\s*-?\s*\S+:\s/)) {
+                headerLines.push(line.replace(/^\s*-?\s*/, "").trim());
+                continue;
+            }
+            else if (inHeaders && line.trim()) {
+                inHeaders = false;
+            }
+            // Parameter entries: - `name` (type, required): description
+            if (inParams && line.match(/^\s*-\s*`/)) {
+                const paramMatch = line.match(/^\s*-\s*`(\w+)`\s*\(([^)]+)\)\s*:?\s*(.*)/);
+                if (paramMatch) {
+                    const pName = paramMatch[1];
+                    const pMeta = paramMatch[2];
+                    const pDesc = paramMatch[3].trim();
+                    const parts = pMeta.split(",").map(s => s.trim().toLowerCase());
+                    const pType = parts.find(p => ["string", "number", "boolean", "integer"].includes(p)) || "string";
+                    const pRequired = parts.includes("required");
+                    paramEntries.push({ name: pName, type: pType, description: pDesc, required: pRequired });
+                }
+                continue;
+            }
+            else if (inParams && line.trim() && !line.startsWith(" ")) {
+                inParams = false;
+            }
+        }
+        // Assemble headers
+        if (headerLines.length > 0) {
+            tool.headers = {};
+            for (const h of headerLines) {
+                const colonIdx = h.indexOf(":");
+                if (colonIdx > 0) {
+                    tool.headers[h.slice(0, colonIdx).trim()] = h.slice(colonIdx + 1).trim();
+                }
+            }
+        }
+        // Assemble parameters
+        if (paramEntries.length > 0) {
+            tool.parameters = {};
+            for (const p of paramEntries) {
+                tool.parameters[p.name] = { type: p.type, description: p.description, required: p.required };
+            }
+        }
+        tools.push(tool);
+    }
+    return tools;
+}
+// ── Config Loading ──────────────────────────────────────
+function loadToolsConfig() {
+    // Prefer TOOLS.md (Markdown format)
+    if (fs.existsSync(TOOLS_MD)) {
+        try {
+            const content = fs.readFileSync(TOOLS_MD, "utf-8");
+            const tools = parseToolsMd(content);
+            return { tools };
+        }
+        catch {
+            // Fall through to JSON
+        }
+    }
+    // Legacy fallback: docs/tools.json
+    if (fs.existsSync(TOOLS_JSON)) {
+        try {
+            const raw = fs.readFileSync(TOOLS_JSON, "utf-8");
+            return JSON.parse(raw);
+        }
+        catch {
+            // ignore
+        }
+    }
+    return { tools: [] };
+}
+/**
+ * Get the path of the active tools config file.
+ */
+export function getToolsConfigPath() {
+    if (fs.existsSync(TOOLS_MD))
+        return TOOLS_MD;
+    return TOOLS_JSON;
+}
+// ── Template Substitution ───────────────────────────────
+function substituteParams(template, params) {
+    let result = template;
+    for (const [key, value] of Object.entries(params)) {
+        result = result.replace(new RegExp(`\\{\\{${key}\\}\\}`, "g"), String(value));
+    }
+    return result;
+}
+// ── Execution ───────────────────────────────────────────
+async function executeShellTool(tool, params) {
+    if (!tool.command)
+        throw new Error("No command defined");
+    const cmd = substituteParams(tool.command, params);
+    // Intercept self-restart: use graceful internal restart instead of pm2 kill
+    if (isSelfRestartCommand(cmd)) {
+        scheduleGracefulRestart();
+        return "Bot restart scheduled. Grammy will commit the Telegram offset before exiting.";
+    }
+    try {
+        const result = execSync(cmd, {
+            stdio: "pipe",
+            timeout: tool.timeout || 30000,
+            env: process.env,
+        });
+        return result.toString().trim() || "(no output)";
+    }
+    catch (err) {
+        const error = err;
+        throw new Error(error.stderr?.toString()?.trim() || error.message);
+    }
+}
+async function executeHttpTool(tool, params) {
+    if (!tool.url)
+        throw new Error("No URL defined");
+    const url = substituteParams(tool.url, params);
+    const method = tool.method || "GET";
+    const headers = {};
+    if (tool.headers) {
+        for (const [key, value] of Object.entries(tool.headers)) {
+            headers[key] = substituteParams(value, params);
+        }
+    }
+    const fetchOpts = { method, headers };
+    if (tool.body && method !== "GET") {
+        fetchOpts.body = substituteParams(tool.body, params);
+        if (!headers["Content-Type"]) {
+            headers["Content-Type"] = "application/json";
+        }
+    }
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), tool.timeout || 30000);
+    fetchOpts.signal = controller.signal;
+    try {
+        const response = await fetch(url, fetchOpts);
+        clearTimeout(timeoutId);
+        const text = await response.text();
+        return `HTTP ${response.status}: ${text.slice(0, 2000)}`;
+    }
+    catch (err) {
+        clearTimeout(timeoutId);
+        throw err;
+    }
+}
+// ── Public API ──────────────────────────────────────────
+/**
+ * Get all custom tools for display/registration.
+ */
+export function getCustomTools() {
+    const config = loadToolsConfig();
+    return config.tools.map(t => ({
+        name: t.name,
+        description: t.description,
+        parameters: t.parameters || {},
+    }));
+}
+/**
+ * Execute a custom tool by name.
+ */
+export async function executeCustomTool(name, params) {
+    const config = loadToolsConfig();
+    const tool = config.tools.find(t => t.name === name);
+    if (!tool)
+        throw new Error(`Custom tool "${name}" not found`);
+    const type = tool.type || (tool.url ? "http" : "shell");
+    switch (type) {
+        case "http":
+            return executeHttpTool(tool, params);
+        case "shell":
+        default:
+            return executeShellTool(tool, params);
+    }
+}
+/**
+ * List custom tools for the /tools command.
+ */
+export function listCustomTools() {
+    const config = loadToolsConfig();
+    return config.tools.map(t => ({
+        name: t.name,
+        description: t.description,
+        type: t.type || (t.url ? "http" : "shell"),
+    }));
+}
+/**
+ * Check if custom tools config exists.
+ */
+export function hasCustomTools() {
+    return fs.existsSync(TOOLS_MD) || fs.existsSync(TOOLS_JSON);
+}

package/dist/services/delivery-queue.js

@@ -0,0 +1,154 @@
+/**
+ * Delivery Queue — Reliable message delivery with retry + exponential backoff.
+ *
+ * Instead of fire-and-forget sends, messages are enqueued and processed
+ * on a 30s interval. Failed deliveries are retried with exponential backoff
+ * (10s, 30s, 90s, 270s, 810s). Persisted to ~/.alvin-bot/delivery-queue.json.
+ */
+import fs from "fs";
+import crypto from "crypto";
+import { DELIVERY_QUEUE_FILE } from "../paths.js";
+// ── State ───────────────────────────────────────────────
+let senders = {};
+// ── File I/O ────────────────────────────────────────────
+function readQueue() {
+    try {
+        const raw = fs.readFileSync(DELIVERY_QUEUE_FILE, "utf-8");
+        return JSON.parse(raw);
+    }
+    catch (err) {
+        if (fs.existsSync(DELIVERY_QUEUE_FILE)) {
+            console.error("Delivery queue: failed to parse queue file, starting fresh:", err);
+        }
+        return [];
+    }
+}
+function writeQueue(entries) {
+    const tmp = DELIVERY_QUEUE_FILE + ".tmp";
+    fs.writeFileSync(tmp, JSON.stringify(entries, null, 2));
+    fs.renameSync(tmp, DELIVERY_QUEUE_FILE);
+}
+// ── Backoff ─────────────────────────────────────────────
+function getBackoffMs(attempts) {
+    return Math.min(10000 * Math.pow(3, attempts), 810000);
+}
+// ── Public API ──────────────────────────────────────────
+/**
+ * Register send functions for each platform.
+ * Must be called before processQueue() can deliver anything.
+ */
+export function setSenders(newSenders) {
+    senders = { ...senders, ...newSenders };
+}
+/**
+ * Enqueue a message for reliable delivery.
+ * Writes immediately to disk and returns the entry ID.
+ */
+export function enqueue(channel, chatId, content, options) {
+    const id = crypto.randomUUID();
+    const entry = {
+        id,
+        channel,
+        chatId,
+        content,
+        mediaPath: options?.mediaPath,
+        createdAt: Date.now(),
+        attempts: 0,
+        lastAttempt: 0,
+        maxAttempts: options?.maxAttempts ?? 5,
+        status: "pending",
+    };
+    const queue = readQueue();
+    queue.push(entry);
+    writeQueue(queue);
+    return id;
+}
+/**
+ * Process all pending entries in the queue.
+ * Respects exponential backoff and max attempts.
+ * Returns counts of delivered, failed, and still-pending entries.
+ */
+export async function processQueue() {
+    const queue = readQueue();
+    const now = Date.now();
+    let delivered = 0;
+    let failed = 0;
+    let pending = 0;
+    let modified = false;
+    for (const entry of queue) {
+        if (entry.status !== "pending")
+            continue;
+        // Check backoff — skip if too soon since last attempt
+        if (entry.attempts > 0) {
+            const backoff = getBackoffMs(entry.attempts);
+            if (now - entry.lastAttempt < backoff) {
+                pending++;
+                continue;
+            }
+        }
+        // Check if we have a sender for this channel
+        const sender = senders[entry.channel];
+        if (!sender) {
+            // No sender registered — leave pending, don't count as attempt
+            pending++;
+            continue;
+        }
+        // Attempt delivery
+        try {
+            await sender(entry.chatId, entry.content, entry.mediaPath);
+            entry.status = "delivered";
+            entry.attempts++;
+            entry.lastAttempt = now;
+            delivered++;
+            modified = true;
+        }
+        catch (err) {
+            entry.attempts++;
+            entry.lastAttempt = now;
+            entry.error = err instanceof Error ? err.message : String(err);
+            modified = true;
+            if (entry.attempts >= entry.maxAttempts) {
+                entry.status = "failed";
+                failed++;
+                console.error(`Delivery failed permanently [${entry.channel}:${entry.chatId}]: ${entry.error} (${entry.attempts} attempts)`);
+            }
+            else {
+                pending++;
+                const nextBackoff = getBackoffMs(entry.attempts);
+                console.warn(`Delivery retry scheduled [${entry.channel}:${entry.chatId}]: attempt ${entry.attempts}/${entry.maxAttempts}, next in ${Math.round(nextBackoff / 1000)}s`);
+            }
+        }
+    }
+    if (modified) {
+        writeQueue(queue);
+    }
+    return { delivered, failed, pending };
+}
+/**
+ * Get counts by status for monitoring.
+ */
+export function getQueueStatus() {
+    const queue = readQueue();
+    const pending = queue.filter(e => e.status === "pending").length;
+    const delivered = queue.filter(e => e.status === "delivered").length;
+    const failed = queue.filter(e => e.status === "failed").length;
+    return { pending, delivered, failed, total: queue.length };
+}
+/**
+ * Remove old entries: delivered > 24h, failed > 7d.
+ */
+export function cleanupQueue() {
+    const queue = readQueue();
+    const now = Date.now();
+    const DAY = 86400000;
+    const cleaned = queue.filter(entry => {
+        if (entry.status === "delivered" && now - entry.lastAttempt > DAY)
+            return false;
+        if (entry.status === "failed" && now - entry.lastAttempt > 7 * DAY)
+            return false;
+        return true;
+    });
+    if (cleaned.length !== queue.length) {
+        writeQueue(cleaned);
+    }
+}

package/dist/services/elevenlabs.js

@@ -0,0 +1,58 @@
+import https from "https";
+import fs from "fs";
+import path from "path";
+import os from "os";
+import { config } from "../config.js";
+const TEMP_DIR = path.join(os.tmpdir(), "alvin-bot");
+if (!fs.existsSync(TEMP_DIR))
+    fs.mkdirSync(TEMP_DIR, { recursive: true });
+/**
+ * Generate speech via ElevenLabs API.
+ * Returns path to the mp3 file.
+ */
+export async function elevenLabsTTS(text, voiceId, modelId) {
+    const voice = voiceId || config.elevenlabs.voiceId;
+    const model = modelId || config.elevenlabs.modelId;
+    const apiKey = config.elevenlabs.apiKey;
+    if (!apiKey)
+        throw new Error("ELEVENLABS_API_KEY not set");
+    const outputPath = path.join(TEMP_DIR, `tts_el_${Date.now()}.mp3`);
+    const body = JSON.stringify({
+        text,
+        model_id: model,
+        voice_settings: {
+            stability: 0.5,
+            similarity_boost: 0.75,
+        },
+    });
+    return new Promise((resolve, reject) => {
+        const req = https.request({
+            hostname: "api.elevenlabs.io",
+            path: `/v1/text-to-speech/${voice}`,
+            method: "POST",
+            headers: {
+                "Accept": "audio/mpeg",
+                "Content-Type": "application/json",
+                "xi-api-key": apiKey,
+                "Content-Length": Buffer.byteLength(body),
+            },
+        }, (res) => {
+            if (res.statusCode !== 200) {
+                let data = "";
+                res.on("data", chunk => data += chunk);
+                res.on("end", () => reject(new Error(`ElevenLabs API error ${res.statusCode}: ${data}`)));
+                return;
+            }
+            const file = fs.createWriteStream(outputPath);
+            res.pipe(file);
+            file.on("finish", () => {
+                file.close();
+                resolve(outputPath);
+            });
+            file.on("error", reject);
+        });
+        req.on("error", reject);
+        req.write(body);
+        req.end();
+    });
+}