@emqo/claudebridge 0.1.0

package/dist/core/markdown.js

@@ -0,0 +1,51 @@
+/** Escape text for Telegram MarkdownV2 */
+export function escapeMarkdownV2(text) {
+    // Characters that must be escaped outside code blocks
+    return text.replace(/([_*\[\]()~`>#+\-=|{}.!\\])/g, "\\$1");
+}
+/**
+ * Convert standard markdown to Telegram MarkdownV2.
+ * Handles code blocks (preserve as-is), inline code, bold, italic, links.
+ */
+export function toTelegramMarkdown(text) {
+    const parts = [];
+    // Split by code blocks first (``` ... ```)
+    const segments = text.split(/(```[\s\S]*?```)/g);
+    for (const seg of segments) {
+        if (seg.startsWith("```")) {
+            // Code block: extract lang and content, only escape backslash and backtick inside
+            const match = seg.match(/^```(\w*)\n?([\s\S]*?)```$/);
+            if (match) {
+                const lang = match[1];
+                const code = match[2].replace(/([\\`])/g, "\\$1");
+                parts.push(`\`\`\`${lang}\n${code}\`\`\``);
+            }
+            else {
+                parts.push(seg);
+            }
+        }
+        else {
+            // Process inline elements
+            let s = seg;
+            // Protect inline code first
+            const inlineCodes = [];
+            s = s.replace(/`([^`]+)`/g, (_, code) => {
+                const escaped = code.replace(/([\\`])/g, "\\$1");
+                inlineCodes.push(`\`${escaped}\``);
+                return `\x00IC${inlineCodes.length - 1}\x00`;
+            });
+            // Escape special chars in normal text
+            s = escapeMarkdownV2(s);
+            // Restore bold **text** → *text*
+            s = s.replace(/\\\*\\\*(.+?)\\\*\\\*/g, "*$1*");
+            // Restore italic _text_ (single underscore)
+            s = s.replace(/\\_(.+?)\\_/g, "_$1_");
+            // Restore links [text](url)
+            s = s.replace(/\\\[(.+?)\\\]\\\((.+?)\\\)/g, "[$1]($2)");
+            // Restore inline codes
+            s = s.replace(/\x00IC(\d+)\x00/g, (_, i) => inlineCodes[Number(i)]);
+            parts.push(s);
+        }
+    }
+    return parts.join("");
+}

package/dist/core/permissions.d.ts

@@ -0,0 +1,8 @@
+/** Simple whitelist: allowed users + groups. Empty = allow all. */
+export declare class AccessControl {
+    private users;
+    private groups;
+    constructor(users?: string[], groups?: string[]);
+    isAllowed(userId: string, groupId?: string): boolean;
+    reload(users: string[], groups: string[]): void;
+}

package/dist/core/permissions.js

@@ -0,0 +1,22 @@
+/** Simple whitelist: allowed users + groups. Empty = allow all. */
+export class AccessControl {
+    users;
+    groups;
+    constructor(users = [], groups = []) {
+        this.users = new Set(users.map(String));
+        this.groups = new Set(groups.map(String));
+    }
+    isAllowed(userId, groupId) {
+        if (!this.users.size && !this.groups.size)
+            return true;
+        if (this.users.has(String(userId)))
+            return true;
+        if (groupId && this.groups.has(String(groupId)))
+            return true;
+        return false;
+    }
+    reload(users, groups) {
+        this.users = new Set(users.map(String));
+        this.groups = new Set(groups.map(String));
+    }
+}

package/dist/core/store.d.ts

@@ -0,0 +1,64 @@
+export declare class Store {
+    private db;
+    constructor();
+    getSession(userId: string): string | null;
+    setSession(userId: string, sessionId: string, platform: string): void;
+    clearSession(userId: string): void;
+    recordUsage(userId: string, platform: string, costUsd: number): void;
+    getUsage(userId: string): {
+        total_cost: number;
+        count: number;
+    };
+    getUsageAll(): {
+        user_id: string;
+        total_cost: number;
+        count: number;
+    }[];
+    addHistory(userId: string, platform: string, role: string, content: string): void;
+    getHistory(userId: string, limit?: number): {
+        role: string;
+        content: string;
+        created_at: number;
+    }[];
+    addMemory(userId: string, content: string, source?: string): void;
+    getMemories(userId: string): {
+        id: number;
+        content: string;
+        source: string;
+        created_at: number;
+    }[];
+    clearMemories(userId: string): void;
+    trimMemories(userId: string, max: number): void;
+    addTask(userId: string, platform: string, chatId: string, description: string, remindAt?: number, auto?: boolean): number;
+    getTasks(userId: string): {
+        id: number;
+        description: string;
+        status: string;
+        remind_at: number | null;
+        created_at: number;
+    }[];
+    completeTask(taskId: number, userId: string): boolean;
+    getDueReminders(): {
+        id: number;
+        user_id: string;
+        platform: string;
+        chat_id: string;
+        description: string;
+    }[];
+    markReminderSent(taskId: number): void;
+    getNextAutoTask(): {
+        id: number;
+        user_id: string;
+        platform: string;
+        chat_id: string;
+        description: string;
+    } | null;
+    markTaskRunning(taskId: number): void;
+    markTaskResult(taskId: number, status: string): void;
+    getAutoTasks(userId: string): {
+        id: number;
+        description: string;
+        status: string;
+        created_at: number;
+    }[];
+}

package/dist/core/store.js

@@ -0,0 +1,145 @@
+import Database from "better-sqlite3";
+import { mkdirSync } from "fs";
+import { dirname } from "path";
+const DB_PATH = "./data/claudebridge.db";
+export class Store {
+    db;
+    constructor() {
+        mkdirSync(dirname(DB_PATH), { recursive: true });
+        this.db = new Database(DB_PATH);
+        this.db.pragma("journal_mode = WAL");
+        this.db.exec(`
+      CREATE TABLE IF NOT EXISTS sessions (
+        user_id TEXT PRIMARY KEY,
+        session_id TEXT NOT NULL,
+        platform TEXT NOT NULL,
+        updated_at INTEGER NOT NULL
+      );
+      CREATE TABLE IF NOT EXISTS usage (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        user_id TEXT NOT NULL,
+        platform TEXT NOT NULL,
+        cost_usd REAL NOT NULL DEFAULT 0,
+        created_at INTEGER NOT NULL
+      );
+      CREATE TABLE IF NOT EXISTS history (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        user_id TEXT NOT NULL,
+        platform TEXT NOT NULL,
+        role TEXT NOT NULL,
+        content TEXT NOT NULL,
+        created_at INTEGER NOT NULL
+      );
+      CREATE INDEX IF NOT EXISTS idx_usage_user ON usage(user_id);
+      CREATE INDEX IF NOT EXISTS idx_history_user ON history(user_id, created_at);
+      CREATE TABLE IF NOT EXISTS memories (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        user_id TEXT NOT NULL,
+        content TEXT NOT NULL,
+        source TEXT NOT NULL DEFAULT 'manual',
+        created_at INTEGER NOT NULL
+      );
+      CREATE TABLE IF NOT EXISTS tasks (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        user_id TEXT NOT NULL,
+        platform TEXT NOT NULL,
+        chat_id TEXT NOT NULL,
+        description TEXT NOT NULL,
+        status TEXT NOT NULL DEFAULT 'pending',
+        remind_at INTEGER,
+        reminder_sent INTEGER NOT NULL DEFAULT 0,
+        created_at INTEGER NOT NULL
+      );
+      CREATE INDEX IF NOT EXISTS idx_memories_user ON memories(user_id);
+      CREATE INDEX IF NOT EXISTS idx_tasks_user ON tasks(user_id, status);
+    `);
+    }
+    // --- sessions ---
+    getSession(userId) {
+        const row = this.db
+            .prepare("SELECT session_id FROM sessions WHERE user_id = ?")
+            .get(userId);
+        return row?.session_id ?? null;
+    }
+    setSession(userId, sessionId, platform) {
+        this.db
+            .prepare(`INSERT INTO sessions (user_id, session_id, platform, updated_at)
+         VALUES (?, ?, ?, ?)
+         ON CONFLICT(user_id) DO UPDATE SET session_id=?, updated_at=?`)
+            .run(userId, sessionId, platform, Date.now(), sessionId, Date.now());
+    }
+    clearSession(userId) {
+        this.db.prepare("DELETE FROM sessions WHERE user_id = ?").run(userId);
+    }
+    // --- usage ---
+    recordUsage(userId, platform, costUsd) {
+        this.db
+            .prepare("INSERT INTO usage (user_id, platform, cost_usd, created_at) VALUES (?, ?, ?, ?)")
+            .run(userId, platform, costUsd, Date.now());
+    }
+    getUsage(userId) {
+        const row = this.db
+            .prepare("SELECT COALESCE(SUM(cost_usd),0) as total_cost, COUNT(*) as count FROM usage WHERE user_id = ?")
+            .get(userId);
+        return row;
+    }
+    getUsageAll() {
+        return this.db
+            .prepare("SELECT user_id, COALESCE(SUM(cost_usd),0) as total_cost, COUNT(*) as count FROM usage GROUP BY user_id ORDER BY total_cost DESC")
+            .all();
+    }
+    // --- history ---
+    addHistory(userId, platform, role, content) {
+        this.db
+            .prepare("INSERT INTO history (user_id, platform, role, content, created_at) VALUES (?, ?, ?, ?, ?)")
+            .run(userId, platform, role, content, Date.now());
+    }
+    getHistory(userId, limit = 10) {
+        return this.db
+            .prepare("SELECT role, content, created_at FROM history WHERE user_id = ? ORDER BY created_at DESC LIMIT ?")
+            .all(userId, limit);
+    }
+    // --- memories ---
+    addMemory(userId, content, source = "manual") {
+        this.db.prepare("INSERT INTO memories (user_id, content, source, created_at) VALUES (?, ?, ?, ?)").run(userId, content, source, Date.now());
+    }
+    getMemories(userId) {
+        return this.db.prepare("SELECT id, content, source, created_at FROM memories WHERE user_id = ? ORDER BY created_at DESC").all(userId);
+    }
+    clearMemories(userId) {
+        this.db.prepare("DELETE FROM memories WHERE user_id = ?").run(userId);
+    }
+    trimMemories(userId, max) {
+        this.db.prepare("DELETE FROM memories WHERE user_id = ? AND id NOT IN (SELECT id FROM memories WHERE user_id = ? ORDER BY created_at DESC LIMIT ?)").run(userId, userId, max);
+    }
+    // --- tasks ---
+    addTask(userId, platform, chatId, description, remindAt, auto = false) {
+        const r = this.db.prepare("INSERT INTO tasks (user_id, platform, chat_id, description, status, remind_at, created_at) VALUES (?, ?, ?, ?, ?, ?, ?)").run(userId, platform, chatId, description, auto ? "auto" : "pending", remindAt ?? null, Date.now());
+        return Number(r.lastInsertRowid);
+    }
+    getTasks(userId) {
+        return this.db.prepare("SELECT id, description, status, remind_at, created_at FROM tasks WHERE user_id = ? AND status = 'pending' ORDER BY created_at DESC").all(userId);
+    }
+    completeTask(taskId, userId) {
+        const r = this.db.prepare("UPDATE tasks SET status = 'done' WHERE id = ? AND user_id = ? AND status = 'pending'").run(taskId, userId);
+        return r.changes > 0;
+    }
+    getDueReminders() {
+        return this.db.prepare("SELECT id, user_id, platform, chat_id, description FROM tasks WHERE status = 'pending' AND remind_at IS NOT NULL AND remind_at <= ? AND reminder_sent = 0").all(Date.now());
+    }
+    markReminderSent(taskId) {
+        this.db.prepare("UPDATE tasks SET reminder_sent = 1 WHERE id = ?").run(taskId);
+    }
+    getNextAutoTask() {
+        return this.db.prepare("SELECT id, user_id, platform, chat_id, description FROM tasks WHERE status = 'auto' ORDER BY created_at ASC LIMIT 1").get() ?? null;
+    }
+    markTaskRunning(taskId) {
+        this.db.prepare("UPDATE tasks SET status = 'running' WHERE id = ?").run(taskId);
+    }
+    markTaskResult(taskId, status) {
+        this.db.prepare("UPDATE tasks SET status = ? WHERE id = ?").run(status, taskId);
+    }
+    getAutoTasks(userId) {
+        return this.db.prepare("SELECT id, description, status, created_at FROM tasks WHERE user_id = ? AND status IN ('auto','running') ORDER BY created_at DESC").all(userId);
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/index.js

@@ -0,0 +1,75 @@
+import { setDefaultAutoSelectFamily } from "net";
+setDefaultAutoSelectFamily(false);
+import { watch } from "fs";
+import { loadConfig, reloadConfig } from "./core/config.js";
+import { Store } from "./core/store.js";
+import { AgentEngine } from "./core/agent.js";
+import { TelegramAdapter } from "./adapters/telegram.js";
+import { DiscordAdapter } from "./adapters/discord.js";
+async function main() {
+    const _cfgIdx = process.argv.indexOf("--config");
+    const _cfgPath = _cfgIdx !== -1 ? process.argv[_cfgIdx + 1] : undefined;
+    let config = loadConfig(_cfgPath);
+    const store = new Store();
+    const engine = new AgentEngine(config, store);
+    const adapters = [];
+    if (config.platforms.telegram.enabled) {
+        if (!config.platforms.telegram.token) {
+            console.error("[fatal] TELEGRAM_BOT_TOKEN not set");
+            process.exit(1);
+        }
+        adapters.push(new TelegramAdapter(engine, store, config.platforms.telegram, config.locale));
+    }
+    if (config.platforms.discord.enabled) {
+        if (!config.platforms.discord.token) {
+            console.error("[fatal] DISCORD_BOT_TOKEN not set");
+            process.exit(1);
+        }
+        adapters.push(new DiscordAdapter(engine, store, config.platforms.discord, config.locale));
+    }
+    if (!adapters.length) {
+        console.error("[fatal] no platform enabled");
+        process.exit(1);
+    }
+    for (const a of adapters)
+        await a.start();
+    console.log(`[claudebridge] running with ${adapters.length} adapter(s)`);
+    // Hot reload config.yaml
+    let reloadTimer = null;
+    watch(_cfgPath || "config.yaml", () => {
+        if (reloadTimer)
+            clearTimeout(reloadTimer);
+        reloadTimer = setTimeout(() => {
+            try {
+                config = reloadConfig();
+                engine.reloadConfig(config);
+                console.log("[claudebridge] config reloaded");
+            }
+            catch (err) {
+                console.error("[claudebridge] config reload failed:", err);
+            }
+        }, 500); // debounce
+    });
+    const shutdown = () => {
+        console.log("[claudebridge] shutting down...");
+        for (const a of adapters)
+            a.stop();
+        process.exit(0);
+    };
+    process.on("SIGINT", shutdown);
+    process.on("SIGTERM", shutdown);
+    process.on("SIGHUP", () => {
+        try {
+            config = reloadConfig();
+            engine.reloadConfig(config);
+            console.log("[claudebridge] config reloaded (SIGHUP)");
+        }
+        catch (err) {
+            console.error("[claudebridge] config reload failed:", err);
+        }
+    });
+}
+main().catch((err) => {
+    console.error("[fatal]", err);
+    process.exit(1);
+});

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "@emqo/claudebridge",
+  "version": "0.1.0",
+  "description": "Bridge Claude Code Agent SDK to chat platforms (Telegram, Discord, etc.)",
+  "main": "dist/index.js",
+  "bin": {
+    "claudebridge": "dist/cli.js"
+  },
+  "type": "module",
+  "scripts": {
+    "build": "tsc",
+    "start": "node dist/index.js",
+    "dev": "tsx src/index.ts"
+  },
+  "keywords": [
+    "claude",
+    "claude-code",
+    "telegram",
+    "bridge",
+    "agent"
+  ],
+  "files": [
+    "dist",
+    "config.yaml.example"
+  ],
+  "license": "MIT",
+  "dependencies": {
+    "@anthropic-ai/claude-agent-sdk": "^0.2.50",
+    "better-sqlite3": "^12.6.2",
+    "discord.js": "^14.25.1",
+    "dotenv": "^17.3.1",
+    "grammy": "^1.40.0",
+    "ioredis": "^5.9.3",
+    "yaml": "^2.8.2"
+  },
+  "devDependencies": {
+    "@types/better-sqlite3": "^7.6.13",
+    "@types/ioredis": "^4.28.10",
+    "@types/node": "^25.3.0",
+    "tsx": "^4.21.0",
+    "typescript": "^5.9.3"
+  },
+  "overrides": {
+    "undici": ">=6.23.0"
+  }
+}