@emqo/claudebridge 0.1.0

package/dist/adapters/telegram.js

@@ -0,0 +1,418 @@
+import { chunkText } from "./base.js";
+import { reloadConfig } from "../core/config.js";
+import { toTelegramMarkdown } from "../core/markdown.js";
+import { t, getCommandDescriptions } from "../core/i18n.js";
+import { detectIntent } from "../core/intent.js";
+const EDIT_INTERVAL = 1500;
+export class TelegramAdapter {
+    engine;
+    store;
+    config;
+    locale;
+    running = false;
+    offset = 0;
+    reminderTimer;
+    autoTimer;
+    autoRunning = false;
+    constructor(engine, store, config, locale = "en") {
+        this.engine = engine;
+        this.store = store;
+        this.config = config;
+        this.locale = locale;
+    }
+    get api() {
+        return `https://api.telegram.org/bot${this.config.token}`;
+    }
+    async call(method, body) {
+        for (let i = 0; i < 3; i++) {
+            try {
+                const ctrl = new AbortController();
+                const timer = setTimeout(() => ctrl.abort(), 15000);
+                const res = await fetch(`${this.api}/${method}`, {
+                    method: "POST",
+                    headers: { "Content-Type": "application/json" },
+                    body: body ? JSON.stringify(body) : undefined,
+                    signal: ctrl.signal,
+                });
+                clearTimeout(timer);
+                const json = await res.json();
+                return json.result;
+            }
+            catch (err) {
+                if (i === 2)
+                    throw err;
+                await new Promise(r => setTimeout(r, 1000 * (i + 1)));
+            }
+        }
+    }
+    async reply(chatId, text, parseMode) {
+        return this.call("sendMessage", {
+            chat_id: chatId,
+            text,
+            ...(parseMode ? { parse_mode: parseMode } : {}),
+        });
+    }
+    async editMsg(chatId, msgId, text, parseMode) {
+        try {
+            await this.call("editMessageText", {
+                chat_id: chatId,
+                message_id: msgId,
+                text,
+                ...(parseMode ? { parse_mode: parseMode } : {}),
+            });
+        }
+        catch { }
+    }
+    async handleUpdate(update) {
+        const msg = update.message;
+        if (!msg)
+            return;
+        const uid = msg.from?.id;
+        const chatId = msg.chat.id;
+        if (!uid)
+            return;
+        const groupId = msg.chat.type !== "private" ? String(chatId) : undefined;
+        if (!this.engine.access.isAllowed(String(uid), groupId)) {
+            console.log(`[telegram] user ${uid} not allowed`);
+            return;
+        }
+        const text = (msg.text || "").trim();
+        console.log(`[telegram] ${uid}: ${text.slice(0, 50)}`);
+        // Commands
+        if (text === "/start" || text === "/help") {
+            await this.reply(chatId, t(this.locale, "help"));
+            return;
+        }
+        if (text === "/new") {
+            this.store.clearSession(String(uid));
+            await this.reply(chatId, t(this.locale, "session_cleared"));
+            return;
+        }
+        if (text === "/usage") {
+            const u = this.store.getUsage(String(uid));
+            await this.reply(chatId, `Requests: ${u.count}\nCost: $${u.total_cost.toFixed(4)}`);
+            return;
+        }
+        if (text === "/allusage") {
+            const rows = this.store.getUsageAll();
+            if (!rows.length) {
+                await this.reply(chatId, t(this.locale, "no_usage"));
+                return;
+            }
+            await this.reply(chatId, rows.map(r => `${r.user_id}: ${r.count} reqs, $${r.total_cost.toFixed(4)}`).join("\n"));
+            return;
+        }
+        if (text === "/history") {
+            const rows = this.store.getHistory(String(uid), 5);
+            if (!rows.length) {
+                await this.reply(chatId, t(this.locale, "no_history"));
+                return;
+            }
+            const out = rows.reverse().map(r => `[${new Date(r.created_at).toLocaleString()}] ${r.role}: ${r.content.slice(0, 150)}`).join("\n\n");
+            await this.reply(chatId, out);
+            return;
+        }
+        if (text === "/model") {
+            const eps = this.engine.getEndpoints();
+            await this.reply(chatId, `Endpoints (${eps.length}):\n` + eps.map(e => `• ${e.name}: ${e.model || "default"}`).join("\n"));
+            return;
+        }
+        if (text === "/reload") {
+            try {
+                const c = reloadConfig();
+                this.engine.reloadConfig(c);
+                this.locale = c.locale;
+                await this.reply(chatId, t(this.locale, "config_reloaded"));
+            }
+            catch (e) {
+                await this.reply(chatId, t(this.locale, "reload_failed") + e.message);
+            }
+            return;
+        }
+        if (text.startsWith("/remember ")) {
+            const content = text.slice(10).trim();
+            if (!content) {
+                await this.reply(chatId, t(this.locale, "usage_remember"));
+                return;
+            }
+            this.store.addMemory(String(uid), content);
+            await this.reply(chatId, t(this.locale, "memory_saved"));
+            return;
+        }
+        if (text === "/memories") {
+            const mems = this.store.getMemories(String(uid));
+            if (!mems.length) {
+                await this.reply(chatId, t(this.locale, "no_memories"));
+                return;
+            }
+            await this.reply(chatId, mems.map(m => `[${m.source}] ${m.content}`).join("\n\n"));
+            return;
+        }
+        if (text === "/forget") {
+            this.store.clearMemories(String(uid));
+            await this.reply(chatId, t(this.locale, "memories_cleared"));
+            return;
+        }
+        if (text.startsWith("/task ")) {
+            const desc = text.slice(6).trim();
+            if (!desc) {
+                await this.reply(chatId, t(this.locale, "usage_task"));
+                return;
+            }
+            const id = this.store.addTask(String(uid), "telegram", String(chatId), desc);
+            await this.reply(chatId, t(this.locale, "task_added", { id }));
+            return;
+        }
+        if (text === "/tasks") {
+            const tasks = this.store.getTasks(String(uid));
+            if (!tasks.length) {
+                await this.reply(chatId, t(this.locale, "no_tasks"));
+                return;
+            }
+            await this.reply(chatId, tasks.map(t => `#${t.id} ${t.description}${t.remind_at ? ` ⏰${new Date(t.remind_at).toLocaleString()}` : ""}`).join("\n"));
+            return;
+        }
+        if (text.startsWith("/done ")) {
+            const id = parseInt(text.slice(6).trim());
+            if (isNaN(id)) {
+                await this.reply(chatId, t(this.locale, "usage_done"));
+                return;
+            }
+            const ok = this.store.completeTask(id, String(uid));
+            await this.reply(chatId, ok ? t(this.locale, "task_done", { id }) : t(this.locale, "task_not_found", { id }));
+            return;
+        }
+        if (text.startsWith("/remind ")) {
+            const match = text.match(/^\/remind\s+(\d+)m\s+(.+)$/);
+            if (!match) {
+                await this.reply(chatId, t(this.locale, "usage_remind"));
+                return;
+            }
+            const mins = parseInt(match[1]);
+            const desc = match[2].trim();
+            const remindAt = Date.now() + mins * 60000;
+            const id = this.store.addTask(String(uid), "telegram", String(chatId), desc, remindAt);
+            await this.reply(chatId, t(this.locale, "reminder_set", { id, mins }));
+            return;
+        }
+        if (text.startsWith("/auto ")) {
+            const desc = text.slice(6).trim();
+            if (!desc) {
+                await this.reply(chatId, t(this.locale, "usage_auto"));
+                return;
+            }
+            const id = this.store.addTask(String(uid), "telegram", String(chatId), desc, undefined, true);
+            await this.reply(chatId, t(this.locale, "auto_queued", { id }));
+            return;
+        }
+        if (text === "/autotasks") {
+            const all = this.store.getAutoTasks(String(uid));
+            if (!all.length) {
+                await this.reply(chatId, t(this.locale, "no_auto_tasks"));
+                return;
+            }
+            await this.reply(chatId, all.map(t => `#${t.id} [${t.status}] ${t.description}`).join("\n"));
+            return;
+        }
+        if (text.startsWith("/cancelauto ")) {
+            const id = parseInt(text.slice(12).trim());
+            if (isNaN(id)) {
+                await this.reply(chatId, t(this.locale, "usage_cancelauto"));
+                return;
+            }
+            this.store.markTaskResult(id, "cancelled");
+            await this.reply(chatId, t(this.locale, "auto_cancelled", { id }));
+            return;
+        }
+        // File upload
+        if (msg.document || msg.photo) {
+            let fileId;
+            let fileName;
+            if (msg.document) {
+                fileId = msg.document.file_id;
+                fileName = msg.document.file_name || "upload";
+            }
+            else {
+                const p = msg.photo[msg.photo.length - 1];
+                fileId = p.file_id;
+                fileName = "photo.jpg";
+            }
+            try {
+                const file = await this.call("getFile", { file_id: fileId });
+                const url = `https://api.telegram.org/file/bot${this.config.token}/${file.file_path}`;
+                const resp = await fetch(url);
+                const buf = Buffer.from(await resp.arrayBuffer());
+                const { mkdirSync, writeFileSync } = await import("fs");
+                const { join } = await import("path");
+                const ws = join("workspaces", String(uid));
+                mkdirSync(ws, { recursive: true });
+                writeFileSync(join(ws, fileName), buf);
+                const prompt = msg.caption || `Analyze the uploaded file: ${fileName}`;
+                await this.handlePrompt(chatId, String(uid), prompt);
+            }
+            catch (e) {
+                await this.reply(chatId, t(this.locale, "upload_failed") + e.message);
+            }
+            return;
+        }
+        // Intent detection (before sending to Claude)
+        if (text && !text.startsWith("/") && this.engine.getIntentConfig()?.enabled !== false) {
+            const intent = await detectIntent(text, this.engine.getRotator(), this.engine.getIntentConfig());
+            if (intent.type === "reminder" && intent.minutes && intent.description) {
+                const remindAt = Date.now() + intent.minutes * 60000;
+                const id = this.store.addTask(String(uid), "telegram", String(chatId), intent.description, remindAt);
+                await this.reply(chatId, t(this.locale, "intent_reminder_set", { mins: intent.minutes, desc: intent.description, id }));
+                return;
+            }
+            if (intent.type === "task" && intent.description) {
+                const id = this.store.addTask(String(uid), "telegram", String(chatId), intent.description);
+                await this.reply(chatId, t(this.locale, "intent_task_added", { id, desc: intent.description }));
+                return;
+            }
+            if (intent.type === "memory" && intent.description) {
+                this.store.addMemory(String(uid), intent.description, "nlp");
+                await this.reply(chatId, t(this.locale, "intent_memory_saved", { desc: intent.description }));
+                return;
+            }
+            if (intent.type === "forget") {
+                this.store.clearMemories(String(uid));
+                await this.reply(chatId, t(this.locale, "memories_cleared"));
+                return;
+            }
+            if (intent.type === "clear_session") {
+                this.store.clearSession(String(uid));
+                await this.reply(chatId, t(this.locale, "session_cleared"));
+                return;
+            }
+        }
+        // Text message
+        if (text)
+            await this.handlePrompt(chatId, String(uid), text);
+    }
+    async handlePrompt(chatId, uid, text) {
+        if (this.engine.isLocked(uid)) {
+            await this.reply(chatId, t(this.locale, "still_processing"));
+            return;
+        }
+        const placeholder = await this.reply(chatId, t(this.locale, "thinking"));
+        const msgId = placeholder.message_id;
+        let lastEdit = 0;
+        try {
+            console.log(`[telegram] running claude for ${uid}...`);
+            const res = await this.engine.runStream(uid, text, "telegram", async (_chunk, full) => {
+                const now = Date.now();
+                if (now - lastEdit < EDIT_INTERVAL)
+                    return;
+                lastEdit = now;
+                const preview = full.slice(-3500) + "\n\n⏳...";
+                await this.editMsg(chatId, msgId, preview);
+            });
+            console.log(`[telegram] claude done for ${uid}, cost=$${res.cost?.toFixed(4)}`);
+            const maxLen = this.config.chunk_size || 4000;
+            const md = toTelegramMarkdown(res.text);
+            const chunks = chunkText(md, maxLen);
+            try {
+                await this.editMsg(chatId, msgId, chunks[0], "MarkdownV2");
+            }
+            catch {
+                await this.editMsg(chatId, msgId, res.text);
+            }
+            for (let i = 1; i < chunks.length; i++) {
+                try {
+                    await this.reply(chatId, chunks[i], "MarkdownV2");
+                }
+                catch {
+                    await this.reply(chatId, chunks[i]);
+                }
+            }
+        }
+        catch (err) {
+            console.error("[telegram] claude error:", err);
+            await this.editMsg(chatId, msgId, `Error: ${err.message || "unknown"}`);
+        }
+    }
+    async start() {
+        this.running = true;
+        console.log("[telegram] starting long polling...");
+        this.reminderTimer = setInterval(() => this.checkReminders(), 30000);
+        this.autoTimer = setInterval(() => this.processAutoTasks(), 60000);
+        await this.registerCommands();
+        while (this.running) {
+            try {
+                const ctrl = new AbortController();
+                const timer = setTimeout(() => ctrl.abort(), 15000);
+                const res = await fetch(`${this.api}/getUpdates?offset=${this.offset}&timeout=5`, { signal: ctrl.signal });
+                clearTimeout(timer);
+                const json = await res.json();
+                if (!json.ok) {
+                    console.error("[telegram] poll error:", json);
+                    continue;
+                }
+                for (const update of json.result) {
+                    this.offset = update.update_id + 1;
+                    this.handleUpdate(update).catch(e => console.error("[telegram] handler error:", e));
+                }
+            }
+            catch (err) {
+                console.error("[telegram] poll fetch error:", err);
+                await new Promise(r => setTimeout(r, 3000));
+            }
+        }
+    }
+    stop() {
+        this.running = false;
+        if (this.reminderTimer)
+            clearInterval(this.reminderTimer);
+        if (this.autoTimer)
+            clearInterval(this.autoTimer);
+    }
+    async registerCommands() {
+        try {
+            await this.call("setMyCommands", { commands: getCommandDescriptions(this.locale) });
+            console.log("[telegram] commands registered");
+        }
+        catch (e) {
+            console.error("[telegram] failed to register commands:", e);
+        }
+    }
+    async checkReminders() {
+        try {
+            const due = this.store.getDueReminders().filter(r => r.platform === "telegram");
+            for (const r of due) {
+                await this.reply(Number(r.chat_id), t(this.locale, "reminder_notify", { desc: r.description }));
+                this.store.markReminderSent(r.id);
+            }
+        }
+        catch (e) {
+            console.error("[telegram] reminder error:", e);
+        }
+    }
+    async processAutoTasks() {
+        if (this.autoRunning)
+            return;
+        const task = this.store.getNextAutoTask();
+        if (!task)
+            return;
+        this.autoRunning = true;
+        this.store.markTaskRunning(task.id);
+        const chatId = Number(task.chat_id);
+        await this.reply(chatId, t(this.locale, "auto_starting", { id: task.id, desc: task.description }));
+        try {
+            console.log(`[telegram] auto-task #${task.id} for ${task.user_id}`);
+            const res = await this.engine.runStream(task.user_id, task.description, "telegram");
+            this.store.markTaskResult(task.id, "done");
+            const maxLen = this.config.chunk_size || 4000;
+            const chunks = chunkText(res.text || "(no output)", maxLen);
+            await this.reply(chatId, t(this.locale, "auto_done", { id: task.id, cost: (res.cost || 0).toFixed(4) }));
+            for (const c of chunks)
+                await this.reply(chatId, c);
+        }
+        catch (err) {
+            this.store.markTaskResult(task.id, "failed");
+            await this.reply(chatId, t(this.locale, "auto_failed", { id: task.id, err: err.message || "unknown" }));
+        }
+        finally {
+            this.autoRunning = false;
+        }
+    }
+}

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli.js

@@ -0,0 +1,111 @@
+#!/usr/bin/env node
+import { spawn } from "child_process";
+import { readFileSync, writeFileSync, unlinkSync, mkdirSync, copyFileSync, existsSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+import { fileURLToPath } from "url";
+import { dirname } from "path";
+const DIR = join(homedir(), ".claudebridge");
+const PID_FILE = join(DIR, "claudebridge.pid");
+const LOG_FILE = join(DIR, "claudebridge.log");
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const ENTRY = join(__dirname, "index.js");
+function ensureDir() { mkdirSync(DIR, { recursive: true }); }
+function readPid() {
+    try {
+        const pid = parseInt(readFileSync(PID_FILE, "utf-8").trim(), 10);
+        process.kill(pid, 0);
+        return pid;
+    }
+    catch {
+        return null;
+    }
+}
+function writePid(pid) { ensureDir(); writeFileSync(PID_FILE, String(pid)); }
+function removePid() { try {
+    unlinkSync(PID_FILE);
+}
+catch { } }
+const args = process.argv.slice(2);
+const cmd = args.find(a => !a.startsWith("-")) || "start";
+const cfgIdx = args.indexOf("--config");
+const cfgPath = cfgIdx !== -1 ? args[cfgIdx + 1] : undefined;
+const daemon = args.includes("--daemon") || args.includes("-d");
+switch (cmd) {
+    case "start": {
+        const existing = readPid();
+        if (existing) {
+            console.log(`Already running (PID ${existing})`);
+            process.exit(0);
+        }
+        const childArgs = [ENTRY, ...(cfgPath ? ["--config", cfgPath] : [])];
+        if (daemon) {
+            ensureDir();
+            const { openSync } = await import("fs");
+            const logFd = openSync(LOG_FILE, "a");
+            const child = spawn("node", childArgs, { detached: true, stdio: ["ignore", logFd, logFd] });
+            child.unref();
+            writePid(child.pid);
+            console.log(`Started in background (PID ${child.pid}), log: ${LOG_FILE}`);
+        }
+        else {
+            const child = spawn("node", childArgs, { stdio: "inherit" });
+            writePid(child.pid);
+            child.on("exit", (code) => { removePid(); process.exit(code ?? 0); });
+            for (const sig of ["SIGINT", "SIGTERM"])
+                process.on(sig, () => child.kill(sig));
+        }
+        break;
+    }
+    case "stop": {
+        const pid = readPid();
+        if (!pid) {
+            console.log("Not running");
+            process.exit(1);
+        }
+        process.kill(pid, "SIGTERM");
+        removePid();
+        console.log(`Stopped (PID ${pid})`);
+        break;
+    }
+    case "status": {
+        const pid = readPid();
+        if (pid) {
+            console.log(`Running (PID ${pid})`);
+            process.exit(0);
+        }
+        else {
+            console.log("Not running");
+            process.exit(1);
+        }
+        break;
+    }
+    case "reload": {
+        const pid = readPid();
+        if (!pid) {
+            console.log("Not running");
+            process.exit(1);
+        }
+        process.kill(pid, "SIGHUP");
+        console.log(`Reload signal sent (PID ${pid})`);
+        break;
+    }
+    case "init": {
+        if (existsSync("config.yaml")) {
+            console.log("config.yaml already exists");
+            process.exit(0);
+        }
+        const example = join(__dirname, "..", "config.yaml.example");
+        if (!existsSync(example)) {
+            console.error("config.yaml.example not found");
+            process.exit(1);
+        }
+        copyFileSync(example, "config.yaml");
+        console.log("Created config.yaml from template");
+        break;
+    }
+    default:
+        console.log("Usage: claudebridge <start|stop|status|reload|init> [--config path] [--daemon|-d]");
+        process.exit(1);
+}

package/dist/core/agent.d.ts

@@ -0,0 +1,32 @@
+import { Config } from "./config.js";
+import { Store } from "./store.js";
+import { AccessControl } from "./permissions.js";
+import { EndpointRotator } from "./keys.js";
+export interface AgentResponse {
+    text: string;
+    sessionId: string;
+    cost?: number;
+}
+export type StreamCallback = (chunk: string, full: string) => void | Promise<void>;
+export declare class AgentEngine {
+    private config;
+    private store;
+    private lock;
+    private rotator;
+    access: AccessControl;
+    constructor(config: Config, store: Store);
+    reloadConfig(config: Config): void;
+    getEndpoints(): {
+        name: string;
+        model: string;
+    }[];
+    getRotator(): EndpointRotator;
+    getIntentConfig(): import("./config.js").IntentConfig;
+    getEndpointCount(): number;
+    private getWorkDir;
+    isLocked(userId: string): boolean;
+    runStream(userId: string, prompt: string, platform: string, onChunk?: StreamCallback): Promise<AgentResponse>;
+    private _executeWithRetry;
+    private _execute;
+    private _autoSummarize;
+}