@emqo/claudebridge 0.3.1 → 0.5.0

package/dist/ctl.js

@@ -101,11 +101,40 @@ else if (category === "auto") {
     if (action === "add") {
         const [userId, platform, chatId, ...descParts] = rest;
         if (!userId || !platform || !chatId || !descParts.length)
-            fail("Usage: auto add <user_id> <platform> <chat_id> <description>");
+            fail("Usage: auto add <user_id> <platform> <chat_id> <description> [--parent <id>]");
+        // Parse optional --parent flag
+        let parentId = null;
+        const parentIdx = descParts.indexOf("--parent");
+        if (parentIdx !== -1 && descParts[parentIdx + 1]) {
+            parentId = parseInt(descParts[parentIdx + 1]);
+            descParts.splice(parentIdx, 2);
+        }
         const desc = descParts.join(" ");
-        const r = db.prepare("INSERT INTO tasks (user_id, platform, chat_id, description, status, created_at) VALUES (?, ?, ?, ?, 'auto', ?)").run(userId, platform, chatId, desc, Date.now());
+        const r = db.prepare("INSERT INTO tasks (user_id, platform, chat_id, description, status, parent_id, created_at) VALUES (?, ?, ?, ?, 'auto', ?, ?)").run(userId, platform, chatId, desc, parentId, Date.now());
         output({ ok: true, id: Number(r.lastInsertRowid), message: "Auto task queued" });
     }
+    else if (action === "add-approval") {
+        const [userId, platform, chatId, ...descParts] = rest;
+        if (!userId || !platform || !chatId || !descParts.length)
+            fail("Usage: auto add-approval <user_id> <platform> <chat_id> <description> [--parent <id>]");
+        let parentId = null;
+        const parentIdx = descParts.indexOf("--parent");
+        if (parentIdx !== -1 && descParts[parentIdx + 1]) {
+            parentId = parseInt(descParts[parentIdx + 1]);
+            descParts.splice(parentIdx, 2);
+        }
+        const desc = descParts.join(" ");
+        const r = db.prepare("INSERT INTO tasks (user_id, platform, chat_id, description, status, parent_id, created_at) VALUES (?, ?, ?, ?, 'approval_pending', ?, ?)").run(userId, platform, chatId, desc, parentId, Date.now());
+        output({ ok: true, id: Number(r.lastInsertRowid), message: "Auto task queued for approval" });
+    }
+    else if (action === "result") {
+        const [taskId, ...resultParts] = rest;
+        if (!taskId || !resultParts.length)
+            fail("Usage: auto result <task_id> <result_text>");
+        const resultText = resultParts.join(" ");
+        db.prepare("UPDATE tasks SET result = ? WHERE id = ?").run(resultText, parseInt(taskId));
+        output({ ok: true, message: "Task result saved" });
+    }
     else if (action === "list") {
         const [userId] = rest;
         if (!userId)
@@ -121,7 +150,7 @@ else if (category === "auto") {
         output({ ok: true, message: "Auto task cancelled" });
     }
     else {
-        fail("Usage: auto <add|list|cancel> ...");
+        fail("Usage: auto <add|add-approval|result|list|cancel> ...");
     }
 }
 else {

package/dist/index.js

@@ -6,6 +6,7 @@ import { Store } from "./core/store.js";
 import { AgentEngine } from "./core/agent.js";
 import { TelegramAdapter } from "./adapters/telegram.js";
 import { DiscordAdapter } from "./adapters/discord.js";
+import { WebhookServer } from "./webhook.js";
 async function main() {
     const _cfgIdx = process.argv.indexOf("--config");
     const _cfgPath = _cfgIdx !== -1 ? process.argv[_cfgIdx + 1] : undefined;
@@ -13,6 +14,7 @@ async function main() {
     const store = new Store();
     const engine = new AgentEngine(config, store);
     const adapters = [];
+    let webhookServer = null;
     if (config.platforms.telegram.enabled) {
         if (!config.platforms.telegram.token) {
             console.error("[fatal] TELEGRAM_BOT_TOKEN not set");
@@ -31,11 +33,18 @@ async function main() {
         console.error("[fatal] no platform enabled");
         process.exit(1);
     }
+    // Start webhook server if enabled
+    if (config.webhook?.enabled) {
+        webhookServer = new WebhookServer(store, config.webhook, config.cron || []);
+        webhookServer.start();
+    }
     // --- Register signal handlers and hot-reload BEFORE starting adapters ---
     const shutdown = () => {
         console.log("[claudebridge] shutting down...");
         for (const a of adapters)
             a.stop();
+        if (webhookServer)
+            webhookServer.stop();
         setTimeout(() => process.exit(0), 1000);
     };
     process.on("SIGINT", shutdown);

package/dist/skills/bridge.js

@@ -52,6 +52,29 @@ export function generateSkillDoc(ctx) {
             `  2. "优化模块A：[具体描述，包含文件路径和修改内容]"`,
             `  3. "优化模块B：[具体描述]"`,
             `  4. "运行测试验证所有修改，提交代码，生成优化报告"`,
+            ``,
+            `### 跨任务记忆传递`,
+            `- 每个 auto-task 完成关键分析后，用 memory add 保存结论`,
+            `- 下一个 auto-task 会自动加载记忆，可以读取前序任务的成果`,
+            `- 示例：分析完成后调用 \`${ctl} memory add ${ctx.userId} "模块A优化点：1.重构API 2.添加缓存 3.修复N+1查询"\``,
+            `- 最后一个 auto-task 完成后，清理临时工作记忆（可选）`,
+            `- 重要：描述中包含"先用 memory list 查看前序任务的分析结果"可确保链式上下文不断`,
+            ``,
+            `### 需要审批的自动任务 (Human-in-the-Loop)`,
+            `- 关键/破坏性任务用 add-approval: \`${ctl} auto add-approval ${ctx.userId} ${ctx.platform} ${ctx.chatId} "任务描述"\``,
+            `- 适用场景：部署、删除、大规模重构、生产环境变更`,
+            `- 普通分析/读取任务用 add: \`${ctl} auto add ...\``,
+            `- 审批任务会发送给用户确认，批准后才进入执行队列`,
+            ``,
+            `### 条件分支（侦查模式）`,
+            `- 用 --parent <id> 关联子任务: \`${ctl} auto add ${ctx.userId} ${ctx.platform} ${ctx.chatId} "子任务描述" --parent 42\``,
+            `- 侦查模式：任务1分析 → 存记忆 → 根据结果动态创建后续任务`,
+            `- 保存任务结果: \`${ctl} auto result <taskId> "结论摘要"\``,
+            `- 示例：`,
+            `  1. 任务#1(侦查): "分析性能瓶颈" → 发现3个问题 → 创建#2,#3,#4 --parent 1`,
+            `  2. 任务#2: "修复N+1查询" (--parent 1)`,
+            `  3. 任务#3: "添加缓存层" (--parent 1)`,
+            `  4. 任务#4: "运行基准测试" (--parent 1)`,
         ].join("\n");
     }
     return [
@@ -100,5 +123,28 @@ export function generateSkillDoc(ctx) {
         `  2. "Optimize module A: [specific file paths and changes]"`,
         `  3. "Optimize module B: [specific description]"`,
         `  4. "Run tests, commit changes, generate optimization report"`,
+        ``,
+        `### Cross-Task Memory Bridging`,
+        `- After completing key analysis in an auto-task, save conclusions via memory add`,
+        `- The next auto-task automatically loads memories, accessing prior task findings`,
+        `- Example: after analysis, call \`${ctl} memory add ${ctx.userId} "Module A needs: 1.refactor API 2.add cache 3.fix N+1 queries"\``,
+        `- Optionally clean up temporary work memories after the final auto-task`,
+        `- Tip: include "first run memory list to review prior task findings" in descriptions to ensure chain continuity`,
+        ``,
+        `### Human-in-the-Loop Auto Tasks`,
+        `- For critical/destructive tasks, use add-approval: \`${ctl} auto add-approval ${ctx.userId} ${ctx.platform} ${ctx.chatId} "description"\``,
+        `- Use cases: deployments, deletions, large-scale refactors, production changes`,
+        `- For analysis/read-only tasks, use regular add: \`${ctl} auto add ...\``,
+        `- Approval tasks are sent to the user for confirmation before entering the execution queue`,
+        ``,
+        `### Conditional Branching (Scout Pattern)`,
+        `- Link child tasks with --parent <id>: \`${ctl} auto add ${ctx.userId} ${ctx.platform} ${ctx.chatId} "subtask" --parent 42\``,
+        `- Scout pattern: task 1 analyzes → saves memory → dynamically creates follow-up tasks`,
+        `- Save task results: \`${ctl} auto result <taskId> "conclusion summary"\``,
+        `- Example:`,
+        `  1. Task #1 (scout): "Analyze performance bottlenecks" → finds 3 issues → creates #2,#3,#4 --parent 1`,
+        `  2. Task #2: "Fix N+1 queries" (--parent 1)`,
+        `  3. Task #3: "Add caching layer" (--parent 1)`,
+        `  4. Task #4: "Run benchmarks" (--parent 1)`,
     ].join("\n");
 }

package/dist/webhook.d.ts

@@ -0,0 +1,18 @@
+import { Store } from "./core/store.js";
+import { WebhookConfig, CronEntry } from "./core/config.js";
+export declare class WebhookServer {
+    private store;
+    private config;
+    private cronEntries;
+    private server;
+    private cronTimers;
+    constructor(store: Store, config: WebhookConfig, cronEntries?: CronEntry[]);
+    start(): void;
+    stop(): void;
+    private handleRequest;
+    private authenticateBearer;
+    private verifyGitHubSignature;
+    private buildGitHubDescription;
+    private readBody;
+    private json;
+}

package/dist/webhook.js

@@ -0,0 +1,160 @@
+import { createServer } from "node:http";
+import { createHmac, timingSafeEqual } from "node:crypto";
+export class WebhookServer {
+    store;
+    config;
+    cronEntries;
+    server = null;
+    cronTimers = [];
+    constructor(store, config, cronEntries = []) {
+        this.store = store;
+        this.config = config;
+        this.cronEntries = cronEntries;
+    }
+    start() {
+        this.server = createServer((req, res) => this.handleRequest(req, res));
+        this.server.listen(this.config.port, () => {
+            console.log(`[webhook] HTTP server listening on port ${this.config.port}`);
+        });
+        // Start cron schedulers
+        for (const entry of this.cronEntries) {
+            const ms = entry.schedule_minutes * 60000;
+            const timer = setInterval(() => {
+                try {
+                    const id = this.store.addTask(entry.user_id, entry.platform, entry.chat_id, entry.description, undefined, true);
+                    console.log(`[cron] created auto-task #${id}: ${entry.description}`);
+                }
+                catch (e) {
+                    console.error(`[cron] failed to create task:`, e);
+                }
+            }, ms);
+            this.cronTimers.push(timer);
+            console.log(`[cron] scheduled every ${entry.schedule_minutes}min: ${entry.description}`);
+        }
+    }
+    stop() {
+        if (this.server)
+            this.server.close();
+        for (const timer of this.cronTimers)
+            clearInterval(timer);
+        this.cronTimers = [];
+    }
+    async handleRequest(req, res) {
+        const url = new URL(req.url || "/", `http://localhost:${this.config.port}`);
+        // GET /health
+        if (req.method === "GET" && url.pathname === "/health") {
+            this.json(res, 200, { ok: true, timestamp: new Date().toISOString() });
+            return;
+        }
+        // POST /api/task — Bearer token auth
+        if (req.method === "POST" && url.pathname === "/api/task") {
+            if (!this.authenticateBearer(req)) {
+                this.json(res, 401, { error: "Unauthorized" });
+                return;
+            }
+            try {
+                const body = await this.readBody(req);
+                const data = JSON.parse(body);
+                if (!data.user_id || !data.platform || !data.chat_id || !data.description) {
+                    this.json(res, 400, { error: "Missing required fields: user_id, platform, chat_id, description" });
+                    return;
+                }
+                let id;
+                if (data.approval) {
+                    id = this.store.addApprovalTask(data.user_id, data.platform, data.chat_id, data.description, data.parent_id);
+                }
+                else {
+                    id = this.store.addTask(data.user_id, data.platform, data.chat_id, data.description, undefined, true, data.parent_id);
+                }
+                this.json(res, 201, { ok: true, id, status: data.approval ? "approval_pending" : "auto" });
+            }
+            catch (e) {
+                this.json(res, 400, { error: e.message || "Invalid JSON" });
+            }
+            return;
+        }
+        // POST /webhook/github — GitHub webhook with HMAC verification
+        if (req.method === "POST" && url.pathname === "/webhook/github") {
+            const userId = url.searchParams.get("user_id");
+            const platform = url.searchParams.get("platform") || "telegram";
+            const chatId = url.searchParams.get("chat_id");
+            if (!userId || !chatId) {
+                this.json(res, 400, { error: "Missing user_id or chat_id query params" });
+                return;
+            }
+            const body = await this.readBody(req);
+            // Verify GitHub signature if secret is configured
+            if (this.config.github_secret) {
+                const signature = req.headers["x-hub-signature-256"];
+                if (!signature || !this.verifyGitHubSignature(body, signature)) {
+                    this.json(res, 403, { error: "Invalid signature" });
+                    return;
+                }
+            }
+            try {
+                const payload = JSON.parse(body);
+                const event = req.headers["x-github-event"] || "unknown";
+                const description = this.buildGitHubDescription(event, payload);
+                const id = this.store.addTask(userId, platform, chatId, description, undefined, true);
+                console.log(`[webhook] github ${event} → auto-task #${id}`);
+                this.json(res, 201, { ok: true, id, event });
+            }
+            catch (e) {
+                this.json(res, 400, { error: e.message || "Invalid payload" });
+            }
+            return;
+        }
+        this.json(res, 404, { error: "Not found" });
+    }
+    authenticateBearer(req) {
+        if (!this.config.token)
+            return false;
+        const auth = req.headers.authorization || "";
+        const token = auth.startsWith("Bearer ") ? auth.slice(7) : "";
+        return token === this.config.token;
+    }
+    verifyGitHubSignature(body, signature) {
+        const expected = "sha256=" + createHmac("sha256", this.config.github_secret).update(body).digest("hex");
+        try {
+            return timingSafeEqual(Buffer.from(signature), Buffer.from(expected));
+        }
+        catch {
+            return false;
+        }
+    }
+    buildGitHubDescription(event, payload) {
+        const repo = payload.repository?.full_name || "unknown";
+        switch (event) {
+            case "push": {
+                const branch = (payload.ref || "").replace("refs/heads/", "");
+                const count = payload.commits?.length || 0;
+                const msg = payload.head_commit?.message?.split("\n")[0] || "";
+                return `[GitHub Push] ${repo}:${branch} — ${count} commit(s). Latest: "${msg}". Review changes and summarize impact.`;
+            }
+            case "pull_request": {
+                const pr = payload.pull_request || {};
+                const action = payload.action || "opened";
+                return `[GitHub PR #${pr.number}] ${repo} — ${action}: "${pr.title}". Review PR description and provide analysis.`;
+            }
+            case "issues": {
+                const issue = payload.issue || {};
+                const action = payload.action || "opened";
+                return `[GitHub Issue #${issue.number}] ${repo} — ${action}: "${issue.title}". Analyze and suggest next steps.`;
+            }
+            default:
+                return `[GitHub ${event}] ${repo} — Event received. Analyze and summarize.`;
+        }
+    }
+    readBody(req) {
+        return new Promise((resolve, reject) => {
+            let data = "";
+            req.on("data", (chunk) => { data += chunk.toString(); });
+            req.on("end", () => resolve(data));
+            req.on("error", reject);
+        });
+    }
+    json(res, status, data) {
+        res.writeHead(status, { "Content-Type": "application/json" });
+        res.end(JSON.stringify(data));
+    }
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@emqo/claudebridge",
-  "version": "0.3.1",
-  "description": "Bridge Claude Code Agent SDK to chat platforms (Telegram, Discord, etc.)",
+  "version": "0.5.0",
+  "description": "Bridge claude CLI to chat platforms (Telegram, Discord) with HITL approval, conditional branching, webhook triggers, parallel execution, and observability",
   "main": "dist/index.js",
   "bin": {
     "claudebridge": "dist/cli.js",
@@ -17,20 +17,28 @@
     "claude",
     "claude-code",
     "telegram",
+    "discord",
     "bridge",
-    "agent"
+    "agent",
+    "chatbot",
+    "hitl",
+    "webhook",
+    "multi-agent"
   ],
   "files": [
     "dist",
     "config.yaml.example"
   ],
   "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Emqo/ClaudeBridge.git"
+  },
+  "homepage": "https://github.com/Emqo/ClaudeBridge#readme",
   "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"
   },