@emqo/claudebridge 0.5.1 → 0.5.3

package/dist/adapters/discord.js

@@ -242,6 +242,13 @@ export class DiscordAdapter {
             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);
+            if (res.timedOut) {
+                this.store.markTaskResult(task.id, "failed");
+                if (res.text)
+                    this.store.setTaskResult(task.id, res.text.slice(0, 10000));
+                await channel.send(t(this.locale, "auto_failed", { id: task.id, err: "timed out" }));
+                return;
+            }
             this.store.markTaskResult(task.id, "done");
             if (res.text)
                 this.store.setTaskResult(task.id, res.text.slice(0, 10000));

package/dist/adapters/telegram.js

@@ -396,14 +396,28 @@ export class TelegramAdapter {
             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);
+            if (res.timedOut) {
+                this.store.markTaskResult(task.id, "failed");
+                if (res.text)
+                    this.store.setTaskResult(task.id, res.text.slice(0, 10000));
+                await this.reply(chatId, t(this.locale, "auto_failed", { id: task.id, err: "timed out" }));
+                return;
+            }
             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);
+            const rawChunks = chunkText(res.text || "(no output)", maxLen);
+            const mdChunks = chunkText(toTelegramMarkdown(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);
+            for (let i = 0; i < mdChunks.length; i++) {
+                try {
+                    await this.call("sendMessage", { chat_id: chatId, text: mdChunks[i], parse_mode: "MarkdownV2" });
+                }
+                catch {
+                    await this.reply(chatId, rawChunks[i] || mdChunks[i]);
+                }
+            }
             // Chain progress reporting
             if (task.parent_id) {
                 const progress = this.store.getChainProgress(task.parent_id);

package/dist/core/agent.d.ts

@@ -6,6 +6,7 @@ export interface AgentResponse {
     text: string;
     sessionId: string;
     cost?: number;
+    timedOut?: boolean;
 }
 export type StreamCallback = (chunk: string, full: string) => void | Promise<void>;
 export declare class AgentEngine {

package/dist/core/agent.js

@@ -1,6 +1,6 @@
 import { spawn } from "child_process";
 import { mkdirSync } from "fs";
-import { join, resolve as pathResolve } from "path";
+import { join } from "path";
 import { UserLock } from "./lock.js";
 import { AccessControl } from "./permissions.js";
 import { EndpointRotator } from "./keys.js";
@@ -146,11 +146,11 @@ export class AgentEngine {
                 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");
+            env.CLAUDEBRIDGE_DB = this.store.dbPath;
             const child = spawn("claude", args, { cwd, env, stdio: ["pipe", "pipe", "pipe"] });
             child.stdin.end();
             console.log(`[agent] spawned claude pid=${child.pid} cwd=${cwd} args=${args.join(" ")}`);
-            const timeoutMs = (this.config.agent.timeout_seconds || 300) * 1000;
+            const timeoutMs = (this.config.agent.timeout_seconds || 600) * 1000;
             const timer = setTimeout(() => { try {
                 child.kill("SIGTERM");
             }
@@ -205,9 +205,10 @@ export class AgentEngine {
                 clearTimeout(timer);
                 console.log(`[agent] claude exited code=${code} signal=${signal} fullText=${fullText.length}chars stderr=${stderr.slice(0, 200)}`);
                 if (signal === "SIGTERM") {
+                    console.warn(`[agent] claude timed out after ${timeoutMs / 1000}s`);
                     if (newSessionId)
                         this.store.setSession(userId, newSessionId, platform);
-                    resolve({ text: fullText.trim() || "(timed out)", sessionId: newSessionId, cost });
+                    resolve({ text: fullText.trim() || "(timed out)", sessionId: newSessionId, cost, timedOut: true });
                     return;
                 }
                 if (code === 0 || fullText.trim()) {
@@ -252,11 +253,11 @@ export class AgentEngine {
                 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");
+            env.CLAUDEBRIDGE_DB = this.store.dbPath;
             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 timeoutMs = (this.config.agent.timeout_seconds || 600) * 1000;
             const timer = setTimeout(() => { try {
                 child.kill("SIGTERM");
             }
@@ -301,8 +302,12 @@ export class AgentEngine {
             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 });
+                if (signal === "SIGTERM") {
+                    console.warn(`[agent] claude (parallel) timed out after ${timeoutMs / 1000}s`);
+                    resolve({ text: fullText.trim() || "(timed out)", sessionId, cost, timedOut: true });
+                }
+                else if (code === 0 || fullText.trim()) {
+                    resolve({ text: fullText.trim() || "(no response)", sessionId, cost });
                 }
                 else {
                     reject(new Error(`claude exited ${code}: ${stderr.slice(0, 500)}`));

package/dist/core/store.d.ts

@@ -1,6 +1,7 @@
 export declare class Store {
     private db;
-    constructor();
+    readonly dbPath: string;
+    constructor(dbPath?: string);
     getSession(userId: string): string | null;
     setSession(userId: string, sessionId: string, platform: string): void;
     clearSession(userId: string): void;

package/dist/core/store.js

@@ -1,12 +1,14 @@
 import Database from "better-sqlite3";
 import { mkdirSync } from "fs";
-import { dirname } from "path";
-const DB_PATH = "./data/claudebridge.db";
+import { dirname, resolve } from "path";
+const DEFAULT_DB_PATH = "./data/claudebridge.db";
 export class Store {
     db;
-    constructor() {
-        mkdirSync(dirname(DB_PATH), { recursive: true });
-        this.db = new Database(DB_PATH);
+    dbPath;
+    constructor(dbPath) {
+        this.dbPath = resolve(dbPath || DEFAULT_DB_PATH);
+        mkdirSync(dirname(this.dbPath), { recursive: true });
+        this.db = new Database(this.dbPath);
         this.db.pragma("journal_mode = WAL");
         this.db.exec(`
       CREATE TABLE IF NOT EXISTS sessions (

package/dist/index.js

@@ -1,6 +1,7 @@
 import { setDefaultAutoSelectFamily } from "net";
 setDefaultAutoSelectFamily(false);
 import { watch } from "fs";
+import { join, dirname, resolve } from "path";
 import { loadConfig, reloadConfig } from "./core/config.js";
 import { Store } from "./core/store.js";
 import { AgentEngine } from "./core/agent.js";
@@ -11,7 +12,10 @@ 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();
+    // Derive DB path from config file directory (not CWD)
+    const configDir = _cfgPath ? dirname(resolve(_cfgPath)) : process.cwd();
+    const dbPath = join(configDir, "data", "claudebridge.db");
+    const store = new Store(dbPath);
     const engine = new AgentEngine(config, store);
     const adapters = [];
     let webhookServer = null;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@emqo/claudebridge",
-  "version": "0.5.1",
+  "version": "0.5.3",
   "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": {