@emqo/claudebridge 0.7.0 → 0.9.0

package/dist/core/config.d.ts

@@ -1,73 +1,5 @@
 import "dotenv/config";
-import { Endpoint } from "./keys.js";
-export interface MemoryConfig {
-    enabled: boolean;
-    auto_summary: boolean;
-    max_memories: number;
-}
-export interface SkillConfig {
-    enabled: boolean;
-}
-export interface AgentConfig {
-    allowed_tools: string[];
-    permission_mode: string;
-    max_turns: number;
-    max_budget_usd: number;
-    system_prompt: string;
-    cwd: string;
-    timeout_seconds: number;
-    max_parallel: number;
-    memory: MemoryConfig;
-    skill: SkillConfig;
-}
-export interface WorkspaceConfig {
-    base_dir: string;
-    isolation: boolean;
-}
-export interface AccessConfig {
-    allowed_users: string[];
-    allowed_groups: string[];
-}
-export interface TelegramConfig {
-    enabled: boolean;
-    token: string;
-    chunk_size: number;
-}
-export interface DiscordConfig {
-    enabled: boolean;
-    token: string;
-    chunk_size: number;
-}
-export interface RedisConfig {
-    enabled: boolean;
-    url: string;
-}
-export interface WebhookConfig {
-    enabled: boolean;
-    port: number;
-    token: string;
-    github_secret: string;
-}
-export interface CronEntry {
-    schedule_minutes: number;
-    user_id: string;
-    platform: string;
-    chat_id: string;
-    description: string;
-}
-export interface Config {
-    endpoints: Endpoint[];
-    agent: AgentConfig;
-    workspace: WorkspaceConfig;
-    access: AccessConfig;
-    redis: RedisConfig;
-    locale: string;
-    platforms: {
-        telegram: TelegramConfig;
-        discord: DiscordConfig;
-    };
-    webhook: WebhookConfig;
-    cron: CronEntry[];
-}
+export type { Config, Endpoint, AgentConfig, MemoryConfig, SkillConfig, SessionConfig, WorkspaceConfig, AccessConfig, TelegramConfig, DiscordConfig, RedisConfig, WebhookConfig, CronEntry, } from "./schema.js";
+import type { Config } from "./schema.js";
 export declare function loadConfig(path?: string): Config;
 export declare function reloadConfig(): Config;

package/dist/core/config.js

@@ -1,50 +1,21 @@
 import { readFileSync } from "fs";
 import { parse } from "yaml";
 import "dotenv/config";
+import { ConfigSchema } from "./schema.js";
 let _configPath = "config.yaml";
 export function loadConfig(path) {
     if (path)
         _configPath = path;
-    const raw = parse(readFileSync(_configPath, "utf-8"));
-    const c = {
-        endpoints: raw.endpoints || [],
-        agent: {
-            ...raw.agent,
-            timeout_seconds: raw.agent?.timeout_seconds ?? 300,
-            max_parallel: raw.agent?.max_parallel ?? 1,
-            memory: { enabled: true, auto_summary: true, max_memories: 50, ...raw.agent?.memory },
-            skill: { enabled: true, ...raw.agent?.skill },
-        },
-        workspace: raw.workspace,
-        access: raw.access || { allowed_users: [], allowed_groups: [] },
-        redis: raw.redis || { enabled: false, url: "" },
-        locale: raw.locale || "en",
-        platforms: raw.platforms,
-        webhook: { enabled: false, port: 3100, token: "", github_secret: "", ...raw.webhook },
-        cron: raw.cron || [],
-    };
-    // defaults for each endpoint
-    for (const ep of c.endpoints) {
-        ep.name = ep.name || "default";
-        ep.base_url = ep.base_url || "";
-        ep.api_key = ep.api_key || "";
-        ep.model = ep.model || "";
-    }
-    // env fallback: single endpoint from env vars
-    if (!c.endpoints.length && process.env.ANTHROPIC_API_KEY) {
-        c.endpoints.push({
-            name: "env-default",
-            base_url: process.env.ANTHROPIC_BASE_URL || "",
-            api_key: process.env.ANTHROPIC_API_KEY,
-            model: process.env.ANTHROPIC_MODEL || "",
-        });
+    const raw = parse(readFileSync(_configPath, "utf-8")) || {};
+    const result = ConfigSchema.safeParse(raw);
+    if (!result.success) {
+        const issues = result.error.issues.map(i => `  ${i.path.join(".")}: ${i.message}`).join("\n");
+        throw new Error(`Config validation failed:\n${issues}`);
     }
+    const c = result.data;
     c.redis.url = c.redis.url || process.env.REDIS_URL || "";
-    c.platforms.telegram.token =
-        c.platforms.telegram.token || process.env.TELEGRAM_BOT_TOKEN || "";
-    c.platforms.discord = c.platforms.discord || { enabled: false, token: "", chunk_size: 1900 };
-    c.platforms.discord.token =
-        c.platforms.discord.token || process.env.DISCORD_BOT_TOKEN || "";
+    c.platforms.telegram.token = c.platforms.telegram.token || process.env.TELEGRAM_BOT_TOKEN || "";
+    c.platforms.discord.token = c.platforms.discord.token || process.env.DISCORD_BOT_TOKEN || "";
     return c;
 }
 export function reloadConfig() {

package/dist/core/i18n.js

@@ -1,6 +1,6 @@
 const messages = {
     en: {
-        help: "ClaudeBridge ready.\n\nManagement commands:\n/new - clear session\n/usage - your stats\n/allusage - all stats\n/history - recent chats\n/model - endpoints info\n/status - auto task status\n/reload - reload config\n/help - show this help\n\nJust chat naturally to manage memories, tasks, reminders, and more — Claude handles it all.",
+        help: "ClaudeBridge ready.\n\nManagement commands:\n/new - clear session\n/usage - your stats\n/allusage - all stats\n/history - recent chats\n/model - endpoints info\n/status - auto task status\n/sessions - active sessions\n/reload - reload config\n/help - show this help\n\nJust chat naturally to manage memories, tasks, reminders, and more — Claude handles it all.",
         session_cleared: "Session cleared.",
         no_usage: "No usage data.",
         no_history: "No history.",
@@ -23,9 +23,13 @@ const messages = {
         no_auto_tasks: "No auto tasks found.",
         status_report: "Auto Task Status:",
         chain_progress: "Chain #{id} progress: {done}/{total} done{cost}",
+        sessions_list: "Active sessions:",
+        no_sessions: "No active sessions.",
+        session_created: "New session created: {label}",
+        session_limit: "Session limit reached. Oldest idle session closed.",
     },
     zh: {
-        help: "ClaudeBridge 就绪。\n\n管理命令：\n/new - 清除会话\n/usage - 你的用量\n/allusage - 所有用量\n/history - 最近对话\n/model - 端点信息\n/status - 自动任务状态\n/reload - 重载配置\n/help - 显示帮助\n\n直接对话即可管理记忆、任务、提醒等 — Claude 会自动处理。",
+        help: "ClaudeBridge 就绪。\n\n管理命令：\n/new - 清除会话\n/usage - 你的用量\n/allusage - 所有用量\n/history - 最近对话\n/model - 端点信息\n/status - 自动任务状态\n/sessions - 活跃会话\n/reload - 重载配置\n/help - 显示帮助\n\n直接对话即可管理记忆、任务、提醒等 — Claude 会自动处理。",
         session_cleared: "会话已清除。",
         no_usage: "暂无用量数据。",
         no_history: "暂无历史记录。",
@@ -48,18 +52,22 @@ const messages = {
         no_auto_tasks: "暂无自动任务。",
         status_report: "自动任务状态：",
         chain_progress: "任务链 #{id} 进度：{done}/{total} 完成{cost}",
+        sessions_list: "活跃会话：",
+        no_sessions: "暂无活跃会话。",
+        session_created: "新会话已创建：{label}",
+        session_limit: "会话数已达上限，已关闭最旧的空闲会话。",
     },
 };
 const commandDescriptions = {
     en: {
         new: "Clear session", usage: "Your usage stats", allusage: "All users usage",
         history: "Recent conversations", model: "Current model/endpoints", status: "Auto task status",
-        reload: "Reload config", help: "Show all commands",
+        sessions: "Active sessions", reload: "Reload config", help: "Show all commands",
     },
     zh: {
         new: "清除会话", usage: "你的用量", allusage: "所有用量",
         history: "最近对话", model: "端点信息", status: "自动任务状态",
-        reload: "重载配置", help: "显示帮助",
+        sessions: "活跃会话", reload: "重载配置", help: "显示帮助",
     },
 };
 export function t(locale, key, vars) {

package/dist/core/keys.d.ts

@@ -1,18 +1,10 @@
-export interface Endpoint {
-    name: string;
-    base_url: string;
-    api_key: string;
-    model: string;
-}
-/** Round-robin endpoint rotation with cooldown on failure */
+import type { Endpoint } from "./config.js";
+/** Simple round-robin endpoint selector — CLI handles its own auth */
 export declare class EndpointRotator {
     private endpoints;
     private index;
-    private cooldowns;
-    private cooldownMs;
     constructor(endpoints: Endpoint[]);
     next(): Endpoint;
-    markFailed(ep: Endpoint): void;
     get count(): number;
     list(): {
         name: string;

package/dist/core/keys.js

@@ -1,31 +1,17 @@
-/** Round-robin endpoint rotation with cooldown on failure */
+/** Simple round-robin endpoint selector — CLI handles its own auth */
 export class EndpointRotator {
     endpoints;
     index = 0;
-    cooldowns = new Map();
-    cooldownMs = 60_000;
     constructor(endpoints) {
-        this.endpoints = endpoints.filter(e => e.api_key);
+        this.endpoints = endpoints;
     }
     next() {
-        const now = Date.now();
-        const len = this.endpoints.length;
-        for (let i = 0; i < len; i++) {
-            const idx = (this.index + i) % len;
-            if ((this.cooldowns.get(idx) || 0) <= now) {
-                this.index = (idx + 1) % len;
-                return this.endpoints[idx];
-            }
-        }
-        const idx = this.index;
-        this.index = (idx + 1) % len;
+        if (!this.endpoints.length)
+            throw new Error("No endpoints configured");
+        const idx = this.index % this.endpoints.length;
+        this.index = (idx + 1) % this.endpoints.length;
         return this.endpoints[idx];
     }
-    markFailed(ep) {
-        const idx = this.endpoints.indexOf(ep);
-        if (idx >= 0)
-            this.cooldowns.set(idx, Date.now() + this.cooldownMs);
-    }
     get count() {
         return this.endpoints.length;
     }
@@ -33,8 +19,7 @@ export class EndpointRotator {
         return this.endpoints.map(e => ({ name: e.name, model: e.model }));
     }
     reload(endpoints) {
-        this.endpoints = endpoints.filter(e => e.api_key);
+        this.endpoints = endpoints;
         this.index = 0;
-        this.cooldowns.clear();
     }
 }

package/dist/core/lock.d.ts

@@ -1,12 +1,16 @@
-/** Per-user lock with Redis backend, memory fallback */
-export declare class UserLock {
+/** Per-session lock with Redis backend, memory fallback.
+ *  Renamed from UserLock to SessionLock — key is now subSessionId, not userId.
+ *  Multiple sub-sessions for the same user can run concurrently. */
+export declare class SessionLock {
     private memLocks;
     private redis;
     private prefix;
     private ttl;
     constructor(redisUrl?: string);
-    acquire(userId: string): Promise<() => void>;
-    isLocked(userId: string): boolean;
+    acquire(sessionId: string): Promise<() => void>;
+    isLocked(sessionId: string): boolean;
+    /** Return which of the given keys are currently locked (memory backend only) */
+    isAnyLocked(keys: string[]): string[];
     private _acquireMem;
     private _acquireRedis;
 }

package/dist/core/lock.js

@@ -1,16 +1,20 @@
 import Redis from "ioredis";
-/** Per-user lock with Redis backend, memory fallback */
-export class UserLock {
+import { log as rootLog } from "./logger.js";
+const log = rootLog.child("lock");
+/** Per-session lock with Redis backend, memory fallback.
+ *  Renamed from UserLock to SessionLock — key is now subSessionId, not userId.
+ *  Multiple sub-sessions for the same user can run concurrently. */
+export class SessionLock {
     memLocks = new Map();
     redis = null;
-    prefix = "claudebridge:lock:";
+    prefix = "claudebridge:lock:session:";
     ttl = 300; // 5 min max lock
     constructor(redisUrl) {
         if (redisUrl) {
             try {
                 this.redis = new Redis(redisUrl, { maxRetriesPerRequest: 1, lazyConnect: true });
                 this.redis.connect().catch(() => {
-                    console.warn("[lock] Redis unavailable, falling back to memory");
+                    log.warn("Redis unavailable, falling back to memory");
                     this.redis = null;
                 });
             }
@@ -19,35 +23,42 @@ export class UserLock {
             }
         }
     }
-    async acquire(userId) {
+    async acquire(sessionId) {
         if (this.redis)
-            return this._acquireRedis(userId);
-        return this._acquireMem(userId);
+            return this._acquireRedis(sessionId);
+        return this._acquireMem(sessionId);
     }
-    isLocked(userId) {
+    isLocked(sessionId) {
         if (this.redis)
             return false; // can't sync-check redis, rely on acquire
-        return this.memLocks.has(userId);
+        return this.memLocks.has(sessionId);
     }
-    async _acquireMem(userId) {
-        while (this.memLocks.has(userId)) {
-            await this.memLocks.get(userId);
+    /** Return which of the given keys are currently locked (memory backend only) */
+    isAnyLocked(keys) {
+        return keys.filter(k => this.memLocks.has(k));
+    }
+    async _acquireMem(sessionId) {
+        while (this.memLocks.has(sessionId)) {
+            await this.memLocks.get(sessionId);
         }
         let release;
         const p = new Promise((r) => (release = r));
-        this.memLocks.set(userId, p);
+        this.memLocks.set(sessionId, p);
         return () => {
-            this.memLocks.delete(userId);
+            this.memLocks.delete(sessionId);
             release();
         };
     }
-    async _acquireRedis(userId) {
-        const key = this.prefix + userId;
-        // spin until acquired
+    async _acquireRedis(sessionId) {
+        const key = this.prefix + sessionId;
+        const maxWait = this.ttl * 1000 + 5000; // TTL + 5s grace
+        const start = Date.now();
         while (true) {
             const ok = await this.redis.set(key, "1", "EX", this.ttl, "NX");
             if (ok)
                 break;
+            if (Date.now() - start > maxWait)
+                throw new Error(`Lock timeout for session ${sessionId}`);
             await new Promise((r) => setTimeout(r, 500));
         }
         return async () => {

package/dist/core/logger.d.ts

@@ -0,0 +1,11 @@
+export type LogLevel = "debug" | "info" | "warn" | "error";
+export declare function setLogLevel(level: LogLevel): void;
+export declare function getLogLevel(): LogLevel;
+export interface Logger {
+    debug(msg: string, extra?: Record<string, unknown>): void;
+    info(msg: string, extra?: Record<string, unknown>): void;
+    warn(msg: string, extra?: Record<string, unknown>): void;
+    error(msg: string, extra?: Record<string, unknown>): void;
+    child(module: string): Logger;
+}
+export declare const log: Logger;

package/dist/core/logger.js

@@ -0,0 +1,24 @@
+const LEVELS = { debug: 0, info: 1, warn: 2, error: 3 };
+let globalLevel = "info";
+export function setLogLevel(level) { globalLevel = level; }
+export function getLogLevel() { return globalLevel; }
+function emit(level, module, msg, extra) {
+    if (LEVELS[level] < LEVELS[globalLevel])
+        return;
+    const entry = { ts: new Date().toISOString(), level, module, msg, pid: process.pid, ...extra };
+    const line = JSON.stringify(entry);
+    if (level === "warn" || level === "error")
+        process.stderr.write(line + "\n");
+    else
+        process.stdout.write(line + "\n");
+}
+function createLogger(module) {
+    return {
+        debug: (msg, extra) => emit("debug", module, msg, extra),
+        info: (msg, extra) => emit("info", module, msg, extra),
+        warn: (msg, extra) => emit("warn", module, msg, extra),
+        error: (msg, extra) => emit("error", module, msg, extra),
+        child: (sub) => createLogger(`${module}:${sub}`),
+    };
+}
+export const log = createLogger("bridge");

package/dist/core/router.d.ts

@@ -0,0 +1,25 @@
+import { SessionManager } from "./session.js";
+import { EndpointRotator } from "./keys.js";
+import { SessionConfig } from "./config.js";
+export interface RouterDecision {
+    action: "route" | "create";
+    subSessionId?: string;
+    label?: string;
+}
+export declare class SessionRouter {
+    private sessionMgr;
+    private rotator;
+    private config;
+    constructor(sessionMgr: SessionManager, rotator: EndpointRotator, config: SessionConfig);
+    /**
+     * 3-tier routing:
+     *   Tier 1: reply-to → direct route ($0)
+     *   Tier 2: 0-1 active sessions → bypass ($0)
+     *   Tier 3: 2+ active sessions → Claude classifier (~$0.002)
+     */
+    route(userId: string, platform: string, chatId: string, messageText: string, replyToMsgId?: string): Promise<RouterDecision>;
+    /** Single-turn Claude call to classify which session a message belongs to */
+    private _classify;
+    /** Spawn claude CLI for single-turn classification (no tools, no session) */
+    private _callClassifier;
+}

package/dist/core/router.js

@@ -0,0 +1,125 @@
+import { spawn } from "child_process";
+import { log as rootLog } from "./logger.js";
+const log = rootLog.child("router");
+export class SessionRouter {
+    sessionMgr;
+    rotator;
+    config;
+    constructor(sessionMgr, rotator, config) {
+        this.sessionMgr = sessionMgr;
+        this.rotator = rotator;
+        this.config = config;
+    }
+    /**
+     * 3-tier routing:
+     *   Tier 1: reply-to → direct route ($0)
+     *   Tier 2: 0-1 active sessions → bypass ($0)
+     *   Tier 3: 2+ active sessions → Claude classifier (~$0.002)
+     */
+    async route(userId, platform, chatId, messageText, replyToMsgId) {
+        // Tier 1: reply-to routing
+        if (replyToMsgId) {
+            const sessId = this.sessionMgr.getSessionByMessage(replyToMsgId, chatId);
+            if (sessId) {
+                const sess = this.sessionMgr.get(sessId);
+                if (sess && this.sessionMgr.isUsable(sess)) {
+                    return { action: "route", subSessionId: sessId };
+                }
+            }
+            // reply-to pointed to closed/expired session — fall through to Tier 2/3
+        }
+        // Tier 2: 0-1 active sessions → direct
+        const active = this.sessionMgr.getActive(userId, platform);
+        if (active.length === 0) {
+            return { action: "create", label: messageText.slice(0, 50) };
+        }
+        if (active.length === 1) {
+            return { action: "route", subSessionId: active[0].id };
+        }
+        // Tier 3: 2+ sessions → Claude classifier
+        return await this._classify(userId, platform, messageText, active);
+    }
+    /** Single-turn Claude call to classify which session a message belongs to */
+    async _classify(userId, platform, text, sessions) {
+        try {
+            const sessionList = sessions
+                .map(s => {
+                const ago = Math.round((Date.now() - s.lastActiveAt) / 60000);
+                return `[${s.id.slice(0, 8)}] "${s.label || "(no topic)"}" (${ago}min ago)`;
+            })
+                .join("\n");
+            const prompt = `You are a message router. Active conversations:\n${sessionList}\n\nUser message: "${text.slice(0, 200)}"\n\nReply with ONLY the 8-char session ID to route to, or "new" for a new conversation. No explanation.`;
+            const result = await this._callClassifier(prompt);
+            const cleaned = result.trim().toLowerCase();
+            if (cleaned === "new") {
+                return { action: "create", label: text.slice(0, 50) };
+            }
+            // Match against active sessions (first 8 chars of ID)
+            const match = sessions.find(s => s.id.slice(0, 8) === cleaned);
+            if (match) {
+                return { action: "route", subSessionId: match.id };
+            }
+            // Fallback: if classifier returned something unexpected, route to most recently active
+            log.warn("classifier returned unexpected, falling back", { result: cleaned });
+            return { action: "route", subSessionId: sessions[0].id };
+        }
+        catch (err) {
+            // Classifier failed — fallback: create new session
+            log.warn("classifier error, creating new session", { error: err.message });
+            return { action: "create", label: text.slice(0, 50) };
+        }
+    }
+    /** Spawn claude CLI for single-turn classification (no tools, no session) */
+    _callClassifier(prompt) {
+        return new Promise((resolve, reject) => {
+            const args = ["-p", prompt, "--output-format", "stream-json", "--max-turns", "1"];
+            if (this.config.classifier_budget)
+                args.push("--max-budget-usd", String(this.config.classifier_budget));
+            if (this.config.classifier_model)
+                args.push("--model", this.config.classifier_model);
+            const env = { ...process.env };
+            // Use the first available endpoint for the classifier model
+            if (this.rotator.count) {
+                const ep = this.rotator.next();
+                if (!this.config.classifier_model && ep.model)
+                    args.push("--model", ep.model);
+            }
+            const child = spawn("claude", args, { env, stdio: ["pipe", "pipe", "pipe"] });
+            child.stdin.end();
+            const timer = setTimeout(() => { try {
+                child.kill("SIGTERM");
+            }
+            catch { } }, 15000);
+            let result = "";
+            let buffer = "";
+            child.stdout.on("data", (data) => {
+                buffer += data.toString();
+                const lines = buffer.split("\n");
+                buffer = lines.pop() || "";
+                for (const line of lines) {
+                    if (!line.trim())
+                        continue;
+                    try {
+                        const msg = JSON.parse(line);
+                        if (msg.type === "result" && msg.result)
+                            result = msg.result;
+                    }
+                    catch { }
+                }
+            });
+            let stderr = "";
+            child.stderr.on("data", (data) => { stderr += data.toString(); });
+            child.on("close", (code) => {
+                clearTimeout(timer);
+                if (result)
+                    resolve(result);
+                else
+                    reject(new Error(`classifier exited ${code}: ${stderr.slice(0, 200)}`));
+            });
+            child.on("error", (err) => {
+                clearTimeout(timer);
+                reject(err);
+            });
+        });
+    }
+}