@emqo/claudebridge 0.4.0 → 0.5.1

package/dist/adapters/discord.js

@@ -13,7 +13,9 @@ export class DiscordAdapter {
     client;
     reminderTimer;
     autoTimer;
-    autoRunning = false;
+    approvalTimer;
+    activeAutoTasks = 0;
+    maxParallel = 1;
     constructor(engine, store, config, locale = "en") {
         this.engine = engine;
         this.store = store;
@@ -98,6 +100,30 @@ export class DiscordAdapter {
                 }
                 return;
             }
+            if (text.startsWith("!approve ")) {
+                const taskId = parseInt(text.split(" ")[1]);
+                if (isNaN(taskId)) {
+                    await msg.reply("Usage: !approve <task_id>");
+                    return;
+                }
+                const ok = this.store.approveTask(taskId);
+                await msg.reply(ok ? t(this.locale, "approval_approved", { id: taskId }) : t(this.locale, "approval_decided", { id: taskId }));
+                return;
+            }
+            if (text.startsWith("!reject ")) {
+                const taskId = parseInt(text.split(" ")[1]);
+                if (isNaN(taskId)) {
+                    await msg.reply("Usage: !reject <task_id>");
+                    return;
+                }
+                const ok = this.store.rejectTask(taskId);
+                await msg.reply(ok ? t(this.locale, "approval_rejected", { id: taskId }) : t(this.locale, "approval_decided", { id: taskId }));
+                return;
+            }
+            if (text === "!status") {
+                await this.handleStatusCommand(msg);
+                return;
+            }
             // File upload handling
             if (msg.attachments.size > 0) {
                 const ws = this.engine.getWorkDir(msg.author.id);
@@ -133,7 +159,7 @@ export class DiscordAdapter {
                 const now = Date.now();
                 if (now - lastEdit < EDIT_INTERVAL)
                     return;
-                const preview = full.slice(-1900) + "\n\n⏳...";
+                const preview = full.slice(-1900) + "\n\n...";
                 if (preview === lastText)
                     return;
                 lastText = preview;
@@ -165,14 +191,19 @@ export class DiscordAdapter {
         console.log("[discord] starting bot...");
         await this.client.login(this.config.token);
         console.log(`[discord] logged in as ${this.client.user?.tag}`);
+        this.maxParallel = this.engine.getMaxParallel();
+        console.log(`[discord] max_parallel=${this.maxParallel}`);
         this.reminderTimer = setInterval(() => this.checkReminders(), 30000);
         this.autoTimer = setInterval(() => this.processAutoTasks(), 60000);
+        this.approvalTimer = setInterval(() => this.checkApprovals(), 15000);
     }
     stop() {
         if (this.reminderTimer)
             clearInterval(this.reminderTimer);
         if (this.autoTimer)
             clearInterval(this.autoTimer);
+        if (this.approvalTimer)
+            clearInterval(this.approvalTimer);
         this.client.destroy();
     }
     async checkReminders() {
@@ -190,13 +221,17 @@ export class DiscordAdapter {
         }
     }
     async processAutoTasks() {
-        if (this.autoRunning)
+        const available = this.maxParallel - this.activeAutoTasks;
+        if (available <= 0)
             return;
-        const task = this.store.getNextAutoTask("discord");
-        if (!task)
-            return;
-        this.autoRunning = true;
-        this.store.markTaskRunning(task.id);
+        const tasks = this.store.getNextAutoTasks("discord", available);
+        for (const task of tasks) {
+            this.activeAutoTasks++;
+            this.store.markTaskRunning(task.id);
+            this.runAutoTask(task).finally(() => { this.activeAutoTasks--; });
+        }
+    }
+    async runAutoTask(task) {
         try {
             const ch = await this.client.channels.fetch(task.chat_id);
             if (!ch?.isTextBased() || !("send" in ch))
@@ -204,13 +239,23 @@ export class DiscordAdapter {
             const channel = ch;
             await channel.send(t(this.locale, "auto_starting", { id: task.id, desc: task.description }));
             console.log(`[discord] auto-task #${task.id} for ${task.user_id}`);
-            const res = await this.engine.runStream(task.user_id, task.description, "discord", task.chat_id);
+            const res = this.maxParallel > 1
+                ? await this.engine.runParallel(task.user_id, task.description, "discord", task.chat_id)
+                : await this.engine.runStream(task.user_id, task.description, "discord", task.chat_id);
             this.store.markTaskResult(task.id, "done");
+            if (res.text)
+                this.store.setTaskResult(task.id, res.text.slice(0, 10000));
             const maxLen = this.config.chunk_size || 1900;
             const chunks = chunkText(res.text || "(no output)", maxLen);
             await channel.send(t(this.locale, "auto_done", { id: task.id, cost: (res.cost || 0).toFixed(4) }));
             for (const c of chunks)
                 await channel.send(c);
+            // Chain progress reporting
+            if (task.parent_id) {
+                const progress = this.store.getChainProgress(task.parent_id);
+                const costSuffix = res.cost ? ` | Cost: $${res.cost.toFixed(4)}` : "";
+                await channel.send(t(this.locale, "chain_progress", { id: task.parent_id, done: progress.done, total: progress.total, cost: costSuffix }));
+            }
         }
         catch (err) {
             this.store.markTaskResult(task.id, "failed");
@@ -223,8 +268,40 @@ export class DiscordAdapter {
             }
             catch { }
         }
-        finally {
-            this.autoRunning = false;
+    }
+    async checkApprovals() {
+        try {
+            const pending = this.store.getPendingApprovals("discord");
+            for (const task of pending) {
+                const ch = await this.client.channels.fetch(task.chat_id);
+                if (ch?.isTextBased() && "send" in ch) {
+                    await ch.send(t(this.locale, "approval_request", { id: task.id, desc: task.description }) +
+                        `\n\nReply \`!approve ${task.id}\` or \`!reject ${task.id}\``);
+                }
+                this.store.markReminderSent(task.id);
+            }
         }
+        catch (e) {
+            console.error("[discord] approval check error:", e);
+        }
+    }
+    async handleStatusCommand(msg) {
+        const recent = this.store.getRecentAutoTasks("discord", 10);
+        if (!recent.length) {
+            await msg.reply(t(this.locale, "no_auto_tasks"));
+            return;
+        }
+        const statusEmoji = {
+            auto: "[queue]", running: "[run]", done: "[done]", failed: "[fail]",
+            approval_pending: "[pending]", cancelled: "[cancel]",
+        };
+        const lines = recent.map(task => {
+            const chain = task.parent_id ? ` (chain #${task.parent_id})` : "";
+            return `${statusEmoji[task.status] || "[?]"} #${task.id} [${task.status}] ${task.description.slice(0, 60)}${chain}`;
+        });
+        const stats = this.store.getAutoTaskStats();
+        const summary = stats.map(s => `${s.status}: ${s.count}`).join(" | ");
+        const report = `${t(this.locale, "status_report")}\n${lines.join("\n")}\n\nSummary: ${summary}`;
+        await msg.reply(report);
     }
 }

package/dist/adapters/telegram.d.ts

@@ -11,7 +11,9 @@ export declare class TelegramAdapter implements Adapter {
     private offset;
     private reminderTimer?;
     private autoTimer?;
-    private autoRunning;
+    private approvalTimer?;
+    private activeAutoTasks;
+    private maxParallel;
     private pages;
     private static PAGE_TTL;
     constructor(engine: AgentEngine, store: Store, config: TelegramConfig, locale?: string);
@@ -28,4 +30,8 @@ export declare class TelegramAdapter implements Adapter {
     private registerCommands;
     private checkReminders;
     private processAutoTasks;
+    private runAutoTask;
+    private checkApprovals;
+    private handleApprovalCallback;
+    private handleStatusCommand;
 }

package/dist/adapters/telegram.js

@@ -12,7 +12,9 @@ export class TelegramAdapter {
     offset = 0;
     reminderTimer;
     autoTimer;
-    autoRunning = false;
+    approvalTimer;
+    activeAutoTasks = 0;
+    maxParallel = 1;
     pages = new Map();
     static PAGE_TTL = 30 * 60 * 1000; // 30 minutes
     constructor(engine, store, config, locale = "en") {
@@ -72,7 +74,13 @@ export class TelegramAdapter {
     }
     async handleUpdate(update) {
         if (update.callback_query) {
-            await this.handlePageCallback(update.callback_query);
+            const data = update.callback_query.data || "";
+            if (data.startsWith("approve:") || data.startsWith("reject:")) {
+                await this.handleApprovalCallback(update.callback_query);
+            }
+            else {
+                await this.handlePageCallback(update.callback_query);
+            }
             return;
         }
         const msg = update.message;
@@ -140,6 +148,10 @@ export class TelegramAdapter {
             }
             return;
         }
+        if (text === "/status") {
+            await this.handleStatusCommand(chatId, String(uid));
+            return;
+        }
         // File upload
         if (msg.document || msg.photo) {
             let fileId;
@@ -254,7 +266,7 @@ export class TelegramAdapter {
                 if (now - lastEdit < EDIT_INTERVAL)
                     return;
                 lastEdit = now;
-                const preview = full.slice(-3500) + "\n\n⏳...";
+                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)}`);
@@ -307,9 +319,11 @@ export class TelegramAdapter {
     }
     async start() {
         this.running = true;
-        console.log("[telegram] starting long polling...");
+        this.maxParallel = this.engine.getMaxParallel();
+        console.log(`[telegram] starting long polling... (max_parallel=${this.maxParallel})`);
         this.reminderTimer = setInterval(() => this.checkReminders(), 30000);
         this.autoTimer = setInterval(() => this.processAutoTasks(), 60000);
+        this.approvalTimer = setInterval(() => this.checkApprovals(), 15000);
         await this.registerCommands();
         while (this.running) {
             try {
@@ -339,6 +353,8 @@ export class TelegramAdapter {
             clearInterval(this.reminderTimer);
         if (this.autoTimer)
             clearInterval(this.autoTimer);
+        if (this.approvalTimer)
+            clearInterval(this.approvalTimer);
     }
     async registerCommands() {
         try {
@@ -362,31 +378,134 @@ export class TelegramAdapter {
         }
     }
     async processAutoTasks() {
-        if (this.autoRunning)
-            return;
-        const task = this.store.getNextAutoTask("telegram");
-        if (!task)
+        const available = this.maxParallel - this.activeAutoTasks;
+        if (available <= 0)
             return;
-        this.autoRunning = true;
-        this.store.markTaskRunning(task.id);
+        const tasks = this.store.getNextAutoTasks("telegram", available);
+        for (const task of tasks) {
+            this.activeAutoTasks++;
+            this.store.markTaskRunning(task.id);
+            this.runAutoTask(task).finally(() => { this.activeAutoTasks--; });
+        }
+    }
+    async runAutoTask(task) {
         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", task.chat_id);
+            const res = this.maxParallel > 1
+                ? await this.engine.runParallel(task.user_id, task.description, "telegram", task.chat_id)
+                : await this.engine.runStream(task.user_id, task.description, "telegram", task.chat_id);
             this.store.markTaskResult(task.id, "done");
+            if (res.text)
+                this.store.setTaskResult(task.id, res.text.slice(0, 10000));
             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);
+            // Chain progress reporting
+            if (task.parent_id) {
+                const progress = this.store.getChainProgress(task.parent_id);
+                const costSuffix = res.cost ? ` | Cost: $${res.cost.toFixed(4)}` : "";
+                await this.reply(chatId, t(this.locale, "chain_progress", { id: task.parent_id, done: progress.done, total: progress.total, cost: costSuffix }));
+            }
         }
         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;
+    }
+    async checkApprovals() {
+        try {
+            const pending = this.store.getPendingApprovals("telegram");
+            for (const task of pending) {
+                const chatId = Number(task.chat_id);
+                const keyboard = {
+                    inline_keyboard: [[
+                            { text: "Approve", callback_data: `approve:${task.id}` },
+                            { text: "Reject", callback_data: `reject:${task.id}` },
+                        ]],
+                };
+                await this.call("sendMessage", {
+                    chat_id: chatId,
+                    text: t(this.locale, "approval_request", { id: task.id, desc: task.description }),
+                    reply_markup: keyboard,
+                });
+                this.store.markReminderSent(task.id); // reuse reminder_sent to avoid re-sending
+            }
+        }
+        catch (e) {
+            console.error("[telegram] approval check error:", e);
+        }
+    }
+    async handleApprovalCallback(cb) {
+        const data = cb.data || "";
+        const cbId = cb.id;
+        const answer = (text) => this.call("answerCallbackQuery", { callback_query_id: cbId, text, show_alert: true });
+        const [action, idStr] = data.split(":");
+        const taskId = parseInt(idStr);
+        if (isNaN(taskId)) {
+            await answer("Invalid task ID");
+            return;
+        }
+        if (action === "approve") {
+            const ok = this.store.approveTask(taskId);
+            if (ok) {
+                await answer(t(this.locale, "approval_approved", { id: taskId }));
+                // Edit the original message to show approved
+                if (cb.message) {
+                    try {
+                        await this.call("editMessageText", {
+                            chat_id: cb.message.chat.id,
+                            message_id: cb.message.message_id,
+                            text: t(this.locale, "approval_approved", { id: taskId }),
+                        });
+                    }
+                    catch { }
+                }
+            }
+            else {
+                await answer(t(this.locale, "approval_decided", { id: taskId }));
+            }
         }
+        else if (action === "reject") {
+            const ok = this.store.rejectTask(taskId);
+            if (ok) {
+                await answer(t(this.locale, "approval_rejected", { id: taskId }));
+                if (cb.message) {
+                    try {
+                        await this.call("editMessageText", {
+                            chat_id: cb.message.chat.id,
+                            message_id: cb.message.message_id,
+                            text: t(this.locale, "approval_rejected", { id: taskId }),
+                        });
+                    }
+                    catch { }
+                }
+            }
+            else {
+                await answer(t(this.locale, "approval_decided", { id: taskId }));
+            }
+        }
+    }
+    async handleStatusCommand(chatId, userId) {
+        const recent = this.store.getRecentAutoTasks("telegram", 10);
+        if (!recent.length) {
+            await this.reply(chatId, t(this.locale, "no_auto_tasks"));
+            return;
+        }
+        const statusEmoji = {
+            auto: "[queue]", running: "[run]", done: "[done]", failed: "[fail]",
+            approval_pending: "[pending]", cancelled: "[cancel]",
+        };
+        const lines = recent.map(task => {
+            const chain = task.parent_id ? ` (chain #${task.parent_id})` : "";
+            return `${statusEmoji[task.status] || "[?]"} #${task.id} [${task.status}] ${task.description.slice(0, 60)}${chain}`;
+        });
+        const stats = this.store.getAutoTaskStats();
+        const summary = stats.map(s => `${s.status}: ${s.count}`).join(" | ");
+        const report = `${t(this.locale, "status_report")}\n${lines.join("\n")}\n\nSummary: ${summary}`;
+        await this.reply(chatId, report);
     }
 }

package/dist/core/agent.d.ts

@@ -22,10 +22,13 @@ export declare class AgentEngine {
     }[];
     getRotator(): EndpointRotator;
     getEndpointCount(): number;
+    getMaxParallel(): number;
     getWorkDir(userId: string): string;
     isLocked(userId: string): boolean;
     runStream(userId: string, prompt: string, platform: string, chatId: string, onChunk?: StreamCallback): Promise<AgentResponse>;
+    runParallel(userId: string, prompt: string, platform: string, chatId: string, onChunk?: StreamCallback): Promise<AgentResponse>;
     private _executeWithRetry;
     private _execute;
+    private _executeNoSession;
     private _autoSummarize;
 }

package/dist/core/agent.js

@@ -32,6 +32,9 @@ export class AgentEngine {
     getEndpointCount() {
         return this.rotator.count;
     }
+    getMaxParallel() {
+        return this.config.agent.max_parallel || 1;
+    }
     getWorkDir(userId) {
         if (!this.config.workspace.isolation) {
             return this.config.agent.cwd || process.cwd();
@@ -60,6 +63,35 @@ export class AgentEngine {
             release();
         }
     }
+    async runParallel(userId, prompt, platform, chatId, onChunk) {
+        // No per-user lock — parallel tasks are independent
+        // No session resume — fresh session to prevent conflicts
+        const memories = this.config.agent.memory?.enabled ? this.store.getMemories(userId) : [];
+        const memoryPrompt = memories.length ? memories.map(m => `- ${m.content}`).join("\n") : "";
+        const maxRetries = Math.max(Math.min(this.rotator.count, 3), 1);
+        let lastErr;
+        for (let i = 0; i < maxRetries; i++) {
+            const ep = this.rotator.count
+                ? this.rotator.next()
+                : { name: "cli-default", api_key: "", base_url: "", model: "" };
+            try {
+                const res = await this._executeNoSession(userId, prompt, platform, chatId, ep, onChunk, memoryPrompt);
+                this.store.recordUsage(userId, platform, res.cost || 0);
+                return res;
+            }
+            catch (err) {
+                lastErr = err;
+                const msg = String(err?.message || "");
+                if (msg.includes("429") || msg.includes("401") || msg.includes("529")) {
+                    console.warn(`[agent] endpoint ${ep.name} failed (parallel), rotating`);
+                    this.rotator.markFailed(ep);
+                    continue;
+                }
+                throw err;
+            }
+        }
+        throw lastErr;
+    }
     async _executeWithRetry(userId, prompt, platform, chatId, onChunk, memoryPrompt) {
         const maxRetries = Math.max(Math.min(this.rotator.count, 3), 1);
         let lastErr;
@@ -192,6 +224,93 @@ export class AgentEngine {
             child.on("error", reject);
         });
     }
+    _executeNoSession(userId, prompt, platform, chatId, ep, onChunk, memoryPrompt) {
+        return new Promise((resolve, reject) => {
+            const cwd = this.getWorkDir(userId);
+            const args = ["-p", prompt, "--verbose", "--output-format", "stream-json", "--permission-mode", this.config.agent.permission_mode || "acceptEdits"];
+            if (ep.model)
+                args.push("--model", ep.model);
+            // No session resume — fresh session for parallel execution
+            if (this.config.agent.system_prompt)
+                args.push("--system-prompt", this.config.agent.system_prompt);
+            let appendPrompt = "";
+            if (memoryPrompt)
+                appendPrompt += `User memories:\n${memoryPrompt}\n\n`;
+            if (this.config.agent.skill?.enabled !== false) {
+                appendPrompt += generateSkillDoc({ userId, chatId, platform, locale: this.config.locale || "en" });
+            }
+            if (appendPrompt)
+                args.push("--append-system-prompt", appendPrompt.trim());
+            if (this.config.agent.allowed_tools?.length)
+                args.push("--allowed-tools", this.config.agent.allowed_tools.join(","));
+            if (this.config.agent.max_turns)
+                args.push("--max-turns", String(this.config.agent.max_turns));
+            if (this.config.agent.max_budget_usd)
+                args.push("--max-budget-usd", String(this.config.agent.max_budget_usd));
+            const env = { ...process.env };
+            if (ep.api_key)
+                env.ANTHROPIC_API_KEY = ep.api_key;
+            if (ep.base_url)
+                env.ANTHROPIC_BASE_URL = ep.base_url;
+            env.CLAUDEBRIDGE_DB = pathResolve("./data/claudebridge.db");
+            const child = spawn("claude", args, { cwd, env, stdio: ["pipe", "pipe", "pipe"] });
+            child.stdin.end();
+            console.log(`[agent] spawned claude (parallel) pid=${child.pid} cwd=${cwd}`);
+            const timeoutMs = (this.config.agent.timeout_seconds || 300) * 1000;
+            const timer = setTimeout(() => { try {
+                child.kill("SIGTERM");
+            }
+            catch { } }, timeoutMs);
+            let fullText = "";
+            let sessionId = "";
+            let cost = 0;
+            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 === "system" && msg.subtype === "init" && msg.session_id) {
+                            sessionId = msg.session_id;
+                        }
+                        if (msg.type === "assistant" && msg.message?.content) {
+                            for (const block of msg.message.content) {
+                                if (block.type === "text" && block.text) {
+                                    fullText += block.text + "\n";
+                                    if (onChunk)
+                                        onChunk(block.text, fullText);
+                                }
+                            }
+                        }
+                        if (msg.type === "result") {
+                            if (msg.result)
+                                fullText = msg.result;
+                            if (msg.total_cost_usd)
+                                cost = msg.total_cost_usd;
+                        }
+                    }
+                    catch { }
+                }
+            });
+            let stderr = "";
+            child.stderr.on("data", (data) => { stderr += data.toString(); });
+            child.on("close", (code, signal) => {
+                clearTimeout(timer);
+                console.log(`[agent] claude (parallel) exited code=${code} signal=${signal} text=${fullText.length}chars`);
+                if (code === 0 || fullText.trim() || signal === "SIGTERM") {
+                    resolve({ text: fullText.trim() || (signal === "SIGTERM" ? "(timed out)" : "(no response)"), sessionId, cost });
+                }
+                else {
+                    reject(new Error(`claude exited ${code}: ${stderr.slice(0, 500)}`));
+                }
+            });
+            child.on("error", reject);
+        });
+    }
     _autoSummarize(userId, prompt, response) {
         const ep = this.rotator.count
             ? this.rotator.next()

package/dist/core/config.d.ts

@@ -16,6 +16,7 @@ export interface AgentConfig {
     system_prompt: string;
     cwd: string;
     timeout_seconds: number;
+    max_parallel: number;
     memory: MemoryConfig;
     skill: SkillConfig;
 }
@@ -41,6 +42,19 @@ 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;
@@ -52,6 +66,8 @@ export interface Config {
         telegram: TelegramConfig;
         discord: DiscordConfig;
     };
+    webhook: WebhookConfig;
+    cron: CronEntry[];
 }
 export declare function loadConfig(path?: string): Config;
 export declare function reloadConfig(): Config;

package/dist/core/config.js

@@ -11,6 +11,7 @@ export function loadConfig(path) {
         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 },
         },
@@ -19,6 +20,8 @@ export function loadConfig(path) {
         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) {