alvin-bot 4.4.1

package/dist/claude.js

@@ -0,0 +1,102 @@
+import { query } from "@anthropic-ai/claude-agent-sdk";
+import { readFileSync } from "fs";
+import { resolve, dirname } from "path";
+import { fileURLToPath } from "url";
+import { findClaudeBinary } from "./find-claude-binary.js";
+// Bot project root (one level up from src/)
+const BOT_PROJECT_ROOT = resolve(dirname(fileURLToPath(import.meta.url)), "..");
+// Load bot's CLAUDE.md at startup — personality, rules, memory instructions
+let botClaudeMd = "";
+try {
+    botClaudeMd = readFileSync(resolve(BOT_PROJECT_ROOT, "CLAUDE.md"), "utf-8");
+    // Replace relative docs/ paths with absolute paths so memory works from any CWD
+    botClaudeMd = botClaudeMd.replaceAll("docs/", `${BOT_PROJECT_ROOT}/docs/`);
+}
+catch {
+    // CLAUDE.md not found — continue without bot-specific instructions
+}
+// Checkpoint reminder thresholds
+const CHECKPOINT_TOOL_THRESHOLD = 15; // After N tool uses → inject checkpoint reminder
+const CHECKPOINT_MSG_THRESHOLD = 10; // After N messages → inject checkpoint reminder
+export async function runClaudeAgent(opts) {
+    // Remove env vars that prevent nested Claude Code sessions
+    const cleanEnv = { ...process.env };
+    delete cleanEnv.CLAUDECODE;
+    delete cleanEnv.CLAUDE_CODE_ENTRYPOINT;
+    // Build prompt — inject checkpoint reminder if thresholds exceeded
+    let prompt = opts.prompt;
+    const needsCheckpoint = opts.toolUseCount >= CHECKPOINT_TOOL_THRESHOLD ||
+        opts.messageCount >= CHECKPOINT_MSG_THRESHOLD;
+    if (needsCheckpoint) {
+        prompt = `[CHECKPOINT] Du hast bereits ${opts.toolUseCount} Tool-Aufrufe und ${opts.messageCount} Nachrichten in dieser Session. Schreibe jetzt einen Checkpoint in deine Memory-Datei (docs/memory/YYYY-MM-DD.md) bevor du diese Anfrage bearbeitest — fasse den bisherigen Kontext kurz zusammen.\n\n${prompt}`;
+    }
+    // Find the claude native binary path
+    const claudePath = findClaudeBinary();
+    const q = query({
+        prompt,
+        options: {
+            cwd: opts.workingDir,
+            abortController: opts.abortController,
+            resume: opts.sessionId ?? undefined,
+            pathToClaudeCodeExecutable: claudePath,
+            permissionMode: "bypassPermissions",
+            allowDangerouslySkipPermissions: true,
+            env: cleanEnv,
+            settingSources: ["user", "project"],
+            allowedTools: [
+                "Read", "Write", "Edit", "Bash", "Glob", "Grep",
+                "WebSearch", "WebFetch", "Task",
+            ],
+            systemPrompt: `You are an autonomous AI agent, controlled via Telegram.
+Keep answers short and concise, but thorough.
+Use Markdown formatting compatible with Telegram (bold, italic, code blocks).
+When you execute commands or edit files, briefly explain what you did.
+Reply in the language the user writes in.
+
+${botClaudeMd}`,
+            effort: opts.effort,
+            maxTurns: 50,
+        },
+    });
+    let accumulatedText = "";
+    let capturedSessionId = opts.sessionId || "";
+    let localToolUseCount = 0;
+    for await (const message of q) {
+        // System init message — capture session ID
+        if (message.type === "system" && "subtype" in message && message.subtype === "init") {
+            const sysMsg = message;
+            capturedSessionId = sysMsg.session_id;
+        }
+        // Assistant message — extract text and tool use
+        if (message.type === "assistant") {
+            const assistantMsg = message;
+            capturedSessionId = assistantMsg.session_id;
+            if (assistantMsg.message?.content) {
+                for (const block of assistantMsg.message.content) {
+                    if ("text" in block && block.text) {
+                        accumulatedText += block.text;
+                        await opts.onText(accumulatedText);
+                    }
+                    if ("name" in block) {
+                        localToolUseCount++;
+                        if (opts.onToolUse) {
+                            await opts.onToolUse(block.name);
+                        }
+                    }
+                }
+            }
+        }
+        // Result message — complete
+        if (message.type === "result") {
+            const resultMsg = message;
+            // Report tool use count back to caller for session tracking
+            if (opts.onToolUseCount) {
+                opts.onToolUseCount(localToolUseCount);
+            }
+            opts.onComplete({
+                sessionId: resultMsg.session_id || capturedSessionId,
+                cost: "total_cost_usd" in resultMsg ? resultMsg.total_cost_usd : 0,
+            });
+        }
+    }
+}

package/dist/config.js

@@ -0,0 +1,65 @@
+import dotenv from "dotenv";
+import { resolve } from "path";
+import os from "os";
+import { existsSync } from "fs";
+// Load .env from ~/.alvin-bot/.env (primary) with cwd fallback (dev mode)
+const dataEnv = resolve(process.env.ALVIN_DATA_DIR || resolve(os.homedir(), ".alvin-bot"), ".env");
+const cwdEnv = resolve(process.cwd(), ".env");
+if (existsSync(dataEnv)) {
+    dotenv.config({ path: dataEnv });
+}
+else if (existsSync(cwdEnv)) {
+    dotenv.config({ path: cwdEnv });
+}
+else {
+    dotenv.config(); // default behavior
+}
+export const config = {
+    // Telegram
+    botToken: process.env.BOT_TOKEN || "",
+    allowedUsers: (process.env.ALLOWED_USERS || "")
+        .split(",")
+        .map(Number)
+        .filter(Boolean),
+    telegramMaxLength: 4096,
+    streamThrottleMs: 1500,
+    // Agent
+    defaultWorkingDir: process.env.WORKING_DIR || os.homedir(),
+    maxBudgetUsd: Number(process.env.MAX_BUDGET_USD) || 5.0,
+    // Model provider (primary)
+    primaryProvider: process.env.PRIMARY_PROVIDER || "claude-sdk",
+    fallbackProviders: (process.env.FALLBACK_PROVIDERS || "")
+        .split(",")
+        .map(s => s.trim())
+        .filter(Boolean),
+    // API Keys (for multi-model support)
+    apiKeys: {
+        anthropic: process.env.ANTHROPIC_API_KEY || "",
+        groq: process.env.GROQ_API_KEY || "",
+        openai: process.env.OPENAI_API_KEY || "",
+        google: process.env.GOOGLE_API_KEY || "",
+        nvidia: process.env.NVIDIA_API_KEY || "",
+        openrouter: process.env.OPENROUTER_API_KEY || "",
+    },
+    // Compaction
+    compactionThreshold: Number(process.env.COMPACTION_THRESHOLD) || 80000,
+    // Sub-Agents
+    maxSubAgents: Number(process.env.MAX_SUBAGENTS) || 4,
+    subAgentTimeout: Number(process.env.SUBAGENT_TIMEOUT) || 300000, // 5 min
+    // TTS Provider
+    ttsProvider: (process.env.TTS_PROVIDER || "edge"),
+    elevenlabs: {
+        apiKey: process.env.ELEVENLABS_API_KEY || "",
+        voiceId: process.env.ELEVENLABS_VOICE_ID || "iP95p4xoKVk53GoZ742B",
+        modelId: process.env.ELEVENLABS_MODEL_ID || "eleven_v3",
+    },
+    authMode: (process.env.AUTH_MODE || "allowlist"),
+    sessionMode: (process.env.SESSION_MODE || "per-user"),
+    webhookEnabled: process.env.WEBHOOK_ENABLED === "true",
+    webhookToken: process.env.WEBHOOK_TOKEN || "",
+    // Browser
+    cdpUrl: process.env.CDP_URL || "",
+    browseServerPort: Number(process.env.BROWSE_SERVER_PORT) || 3800,
+    // Exec Security
+    execSecurity: (process.env.EXEC_SECURITY || "full"),
+};

package/dist/engine.js

@@ -0,0 +1,90 @@
+/**
+ * Engine — Central AI query dispatcher.
+ *
+ * Bridges the gap between Telegram handlers and the provider system.
+ * Handlers call engine.query(), engine routes to the right provider.
+ */
+import fs from "fs";
+import { config } from "./config.js";
+import { createRegistry } from "./providers/index.js";
+import { CUSTOM_MODELS as CUSTOM_MODELS_FILE } from "./paths.js";
+let registry = null;
+/**
+ * Load custom models from docs/custom-models.json
+ */
+function loadCustomProviders() {
+    try {
+        const models = JSON.parse(fs.readFileSync(CUSTOM_MODELS_FILE, "utf-8"));
+        const result = {};
+        for (const m of models) {
+            result[m.key] = {
+                type: "openai-compatible",
+                name: m.name,
+                model: m.model,
+                baseUrl: m.baseUrl,
+                apiKey: m.apiKeyEnv ? process.env[m.apiKeyEnv] : undefined,
+                supportsVision: m.supportsVision ?? false,
+                supportsStreaming: m.supportsStreaming ?? true,
+                maxTokens: m.maxTokens,
+                temperature: m.temperature,
+            };
+        }
+        return result;
+    }
+    catch {
+        return {};
+    }
+}
+/**
+ * Initialize the provider registry from config.
+ * Called once at bot startup.
+ */
+export function initEngine() {
+    const customProviders = loadCustomProviders();
+    registry = createRegistry({
+        primary: config.primaryProvider,
+        fallbacks: config.fallbackProviders.length > 0 ? config.fallbackProviders : undefined,
+        apiKeys: {
+            anthropic: config.apiKeys.anthropic || undefined,
+            groq: config.apiKeys.groq || undefined,
+            openai: config.apiKeys.openai || undefined,
+            google: config.apiKeys.google || undefined,
+            nvidia: config.apiKeys.nvidia || undefined,
+            openrouter: config.apiKeys.openrouter || undefined,
+        },
+        customProviders: Object.keys(customProviders).length > 0 ? customProviders : undefined,
+    });
+    if (Object.keys(customProviders).length > 0) {
+        console.log(`Custom models loaded: ${Object.keys(customProviders).join(", ")}`);
+    }
+    return registry;
+}
+/**
+ * Get the provider registry. Must call initEngine() first.
+ */
+export function getRegistry() {
+    if (!registry) {
+        throw new Error("Engine not initialized. Call initEngine() first.");
+    }
+    return registry;
+}
+/**
+ * Run a query through the active provider (with fallback).
+ * This is the main entry point for handlers.
+ */
+export async function* engineQuery(options) {
+    const reg = getRegistry();
+    yield* reg.queryWithFallback(options);
+}
+/**
+ * Get info about the current model setup for /status.
+ */
+export async function getEngineStatus() {
+    const reg = getRegistry();
+    const providers = await reg.listAll();
+    const lines = providers.map(p => {
+        const marker = p.active ? "→" : "  ";
+        return `${marker} ${p.key}: ${p.name} (${p.model}) ${p.status}`;
+    });
+    return `Model: ${reg.getActiveKey()}\n\n${lines.join("\n")}`;
+}

package/dist/find-claude-binary.js

@@ -0,0 +1,98 @@
+/**
+ * Find the Claude Code native binary path.
+ *
+ * The Agent SDK requires the native Mach-O/ELF binary, NOT the npm/node wrapper.
+ * Native installer: ~/.local/bin/claude → ~/.local/share/claude/versions/<ver>
+ */
+import { existsSync, openSync, readSync, closeSync, readdirSync, realpathSync, statSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+import { execSync } from "child_process";
+/** Check if a file is a node/shell script (NOT a native binary) */
+function isScript(filePath) {
+    try {
+        const buf = Buffer.alloc(64);
+        const fd = openSync(filePath, "r");
+        readSync(fd, buf, 0, 64, 0);
+        closeSync(fd);
+        const hdr = buf.toString("utf-8", 0, 64);
+        return hdr.startsWith("#!") && (hdr.includes("node") || hdr.includes("sh"));
+    }
+    catch {
+        return false;
+    }
+}
+/** Resolve a candidate path to the native binary, or undefined */
+function tryCandidate(p, label) {
+    try {
+        if (!existsSync(p))
+            return undefined;
+        const resolved = realpathSync(p);
+        if (!statSync(resolved).isFile())
+            return undefined;
+        if (isScript(resolved)) {
+            console.error(`[claude] ${label}: ${resolved} is a script wrapper, skipping`);
+            return undefined;
+        }
+        return resolved;
+    }
+    catch {
+        return undefined;
+    }
+}
+/** Find the native Claude Code binary. Returns the path or undefined. */
+export function findClaudeBinary() {
+    try {
+        const home = homedir();
+        // Strategy 1: ~/.local/bin/claude (native installer symlink)
+        let result = tryCandidate(join(home, ".local", "bin", "claude"), "Strategy 1 (~/.local/bin/claude)");
+        if (result) {
+            console.error(`[claude] Native binary: ${result}`);
+            return result;
+        }
+        // Strategy 2: Scan ~/.local/share/claude/versions/ (newest first)
+        const versionsDir = join(home, ".local", "share", "claude", "versions");
+        if (existsSync(versionsDir)) {
+            try {
+                const entries = readdirSync(versionsDir)
+                    .filter((f) => !f.startsWith("."))
+                    .sort()
+                    .reverse();
+                for (const entry of entries) {
+                    const entryPath = join(versionsDir, entry);
+                    // Entry might be the binary itself OR a directory containing it
+                    result = tryCandidate(entryPath, `Strategy 2 (versions/${entry})`);
+                    if (!result) {
+                        result = tryCandidate(join(entryPath, "claude"), `Strategy 2 (versions/${entry}/claude)`);
+                    }
+                    if (result) {
+                        console.error(`[claude] Native binary: ${result}`);
+                        return result;
+                    }
+                }
+            }
+            catch (e) {
+                console.error(`[claude] Strategy 2: can't read versions dir: ${e}`);
+            }
+        }
+        // Strategy 3: which claude → resolve → verify not a script
+        try {
+            const p = execSync("which claude", { encoding: "utf-8", stdio: "pipe" }).trim();
+            if (p) {
+                result = tryCandidate(p, `Strategy 3 (which → ${p})`);
+                if (result) {
+                    console.error(`[claude] Native binary: ${result}`);
+                    return result;
+                }
+            }
+        }
+        catch { /* not in PATH */ }
+        console.error("[claude] WARNING: Native binary not found — SDK will use default (may fail)");
+        console.error(`[claude] Checked: ~/.local/bin/claude, ~/.local/share/claude/versions/, which claude`);
+        return undefined;
+    }
+    catch (err) {
+        console.error(`[claude] Binary search error: ${err instanceof Error ? err.message : err}`);
+        return undefined;
+    }
+}