cc-claw 0.29.0 → 0.29.2

package/dist/cli.js

@@ -33,7 +33,7 @@ var VERSION;
 var init_version = __esm({
   "src/version.ts"() {
     "use strict";
-    VERSION = true ? "0.29.0" : (() => {
+    VERSION = true ? "0.29.2" : (() => {
       try {
         return JSON.parse(readFileSync(join(process.cwd(), "package.json"), "utf-8")).version ?? "unknown";
       } catch {
@@ -7593,7 +7593,7 @@ var init_telegram_throttle = __esm({
     RETRY_DELAY_MS = 1e3;
     MAX_QUEUE_SIZE = 60;
     EDIT_PRESSURE_THRESHOLD = MAX_QUEUE_SIZE / 2;
-    MAX_PER_CHAT_QUEUE = 15;
+    MAX_PER_CHAT_QUEUE = 30;
     MAX_TOTAL_PAUSE_MS = 5 * 60 * 1e3;
     CIRCUIT_TRIP_THRESHOLD = 3;
     CIRCUIT_TRIP_WINDOW_MS = 5 * 60 * 1e3;
@@ -14088,18 +14088,24 @@ function spawnQuery(adapter, config2, model2, cancelState, thinkingLevel, timeou
     let contentSilenceTimer;
     const silenceTimeoutMs = CONTENT_SILENCE_TIMEOUT_MS;
     let silenceResetCount = 0;
-    const MAX_SILENCE_RESETS = 20;
+    const MAX_SILENCE_RESETS = 3;
     function resetContentSilenceTimer() {
       if (silenceTimeoutMs <= 0) return;
       if (contentSilenceTimer) clearTimeout(contentSilenceTimer);
       contentSilenceTimer = setTimeout(() => {
         if (cancelState.cancelled || timedOut) return;
         if (pendingTools.size > 0 && silenceResetCount < MAX_SILENCE_RESETS) {
-          silenceResetCount++;
-          const tools2 = Array.from(pendingTools.values()).map((t) => typeof t === "string" ? t : t.name).join(", ");
-          log(`[agent] Content silence timer fired but ${pendingTools.size} tool(s) still running (${tools2}) \u2014 resetting (${silenceResetCount}/${MAX_SILENCE_RESETS})`);
-          resetContentSilenceTimer();
-          return;
+          const now = Date.now();
+          const hungTool = Array.from(pendingTools.values()).find((t) => now - t.startedAt > silenceTimeoutMs);
+          if (hungTool) {
+            warn(`[agent] Tool "${hungTool.name}" has been running for ${Math.round((now - hungTool.startedAt) / 1e3)}s \u2014 treating as hung, killing`);
+          } else {
+            silenceResetCount++;
+            const tools2 = Array.from(pendingTools.values()).map((t) => `${t.name} (${Math.round((now - t.startedAt) / 1e3)}s)`).join(", ");
+            log(`[agent] Content silence timer fired but ${pendingTools.size} tool(s) still running (${tools2}) \u2014 resetting (${silenceResetCount}/${MAX_SILENCE_RESETS})`);
+            resetContentSilenceTimer();
+            return;
+          }
         }
         warn(`[agent] Content silence timeout after ${silenceTimeoutMs / 1e3}s for ${adapter.id} \u2014 no content events, killing`);
         timedOut = true;
@@ -14178,7 +14184,7 @@ function spawnQuery(adapter, config2, model2, cancelState, thinkingLevel, timeou
             sawToolEvents = true;
             if (opts?.onToolAction && ev.toolName) {
               const toolInput = ev.toolInput ?? {};
-              if (ev.toolId) pendingTools.set(ev.toolId, { name: ev.toolName, input: toolInput });
+              if (ev.toolId) pendingTools.set(ev.toolId, { name: ev.toolName, input: toolInput, startedAt: Date.now() });
               opts.onToolAction(ev.toolName, toolInput, void 0, ev.toolId).catch((err) => {
                 error("[agent] tool action error:", err);
               });
@@ -24547,7 +24553,7 @@ function getEditCoordinator() {
 function resetEditCoordinator() {
   EditCoordinator.resetInstance();
 }
-var TICK_INTERVAL_MS, MAX_EDITS_PER_WINDOW, EDIT_WINDOW_MS, EditCoordinator;
+var TICK_INTERVAL_MS, MAX_EDITS_PER_WINDOW, EDIT_WINDOW_MS, MIN_FLUSH_GAP_DM_MS, MIN_FLUSH_GAP_GROUP_MS, EditCoordinator;
 var init_edit_coordinator = __esm({
   "src/channels/edit-coordinator.ts"() {
     "use strict";
@@ -24555,10 +24561,14 @@ var init_edit_coordinator = __esm({
     TICK_INTERVAL_MS = 1e3;
     MAX_EDITS_PER_WINDOW = 4;
     EDIT_WINDOW_MS = 6e4;
+    MIN_FLUSH_GAP_DM_MS = 2e3;
+    MIN_FLUSH_GAP_GROUP_MS = 4e3;
     EditCoordinator = class _EditCoordinator {
       static instance = null;
       /** Active streams indexed by messageId. */
       activeStreams = /* @__PURE__ */ new Map();
+      /** Last flush timestamp per stream — prevents flushing faster than the throttle can drain. */
+      lastFlushAt = /* @__PURE__ */ new Map();
       /** Per-message edit tracking for the sliding window cap. */
       perMessageEditCount = /* @__PURE__ */ new Map();
       /** Single flush timer shared across all streams. */
@@ -24599,6 +24609,7 @@ var init_edit_coordinator = __esm({
       unregister(messageId) {
         this.activeStreams.delete(messageId);
         this.perMessageEditCount.delete(messageId);
+        this.lastFlushAt.delete(messageId);
         this.rebuildKeys();
         log(`[edit-coordinator] unregistered stream ${messageId} (${this.activeStreams.size} remaining)`);
         if (this.activeStreams.size === 0 && this.flushTimer) {
@@ -24616,6 +24627,7 @@ var init_edit_coordinator = __esm({
         }
         this.activeStreams.clear();
         this.perMessageEditCount.clear();
+        this.lastFlushAt.clear();
         this.streamKeys = [];
         this.roundRobinIndex = 0;
       }
@@ -24644,6 +24656,17 @@ var init_edit_coordinator = __esm({
         }
       }
       // ── Internal ──────────────────────────────────────────────────────────
+      /** Check whether enough time has passed since the last flush for this stream.
+       * Group chats need longer gaps (4s) to match the throttle's group pacing (3.5s).
+       * Without this, the coordinator pushes edits faster than the throttle drains them,
+       * causing per-chat queue buildup. */
+      canFlushStream(messageId, stream) {
+        const last = this.lastFlushAt.get(messageId);
+        if (last === void 0) return true;
+        const chatId = stream.getChatId();
+        const minGap = parseInt(chatId) < 0 ? MIN_FLUSH_GAP_GROUP_MS : MIN_FLUSH_GAP_DM_MS;
+        return Date.now() - last >= minGap;
+      }
       /** Rebuild the ordered keys array after registration changes. */
       rebuildKeys() {
         this.streamKeys = Array.from(this.activeStreams.keys());
@@ -24663,11 +24686,12 @@ var init_edit_coordinator = __esm({
           const idx = (startIdx + tried) % this.streamKeys.length;
           const messageId = this.streamKeys[idx];
           const stream = this.activeStreams.get(messageId);
-          if (stream && this.canEditMessage(messageId)) {
+          if (stream && this.canEditMessage(messageId) && this.canFlushStream(messageId, stream)) {
             this.roundRobinIndex = (idx + 1) % this.streamKeys.length;
             try {
               await stream.flush();
               this.recordEdit(messageId);
+              this.lastFlushAt.set(messageId, Date.now());
             } catch {
             }
             return;
@@ -25360,10 +25384,12 @@ function getTypingManager() {
 function resetTypingManager() {
   TypingManager.resetInstance();
 }
-var TypingManager;
+var MAX_TYPING_DURATION_MS, TypingManager;
 var init_typing_manager = __esm({
   "src/channels/typing-manager.ts"() {
     "use strict";
+    init_log();
+    MAX_TYPING_DURATION_MS = 15 * 60 * 1e3;
     TypingManager = class _TypingManager {
       static instance = null;
       activeChats = /* @__PURE__ */ new Map();
@@ -25385,11 +25411,17 @@ var init_typing_manager = __esm({
         }
         channel.sendTyping?.(chatId).catch(() => {
         });
+        const acquiredAt = Date.now();
         const timer = setInterval(() => {
+          if (Date.now() - acquiredAt > MAX_TYPING_DURATION_MS) {
+            warn(`[typing-manager] Auto-releasing chat ${chatId} after ${MAX_TYPING_DURATION_MS / 6e4}min (likely leak)`);
+            this.forceRelease(chatId);
+            return;
+          }
           channel.sendTyping?.(chatId).catch(() => {
           });
         }, 4e3);
-        this.activeChats.set(chatId, { refCount: 1, timer });
+        this.activeChats.set(chatId, { refCount: 1, timer, acquiredAt });
       }
       /**
        * Stop showing typing for this agent's perspective.
@@ -25404,6 +25436,13 @@ var init_typing_manager = __esm({
           this.activeChats.delete(chatId);
         }
       }
+      /** Force-release a chat regardless of refCount (for leak recovery). */
+      forceRelease(chatId) {
+        const entry = this.activeChats.get(chatId);
+        if (!entry) return;
+        clearInterval(entry.timer);
+        this.activeChats.delete(chatId);
+      }
       /** Clean shutdown — clear all timers. */
       shutdown() {
         for (const [, entry] of this.activeChats) {
@@ -34568,6 +34607,28 @@ You're still in discussion mode \u2014 try again or click a button to exit.`, {
         }
       };
     }
+    const DRAFT_FLUSH_INTERVAL_MS = 500;
+    const useDraftStreaming = channel.sendMessageDraft && channel.isDraftCapable?.(chatId);
+    const draftState = useDraftStreaming ? { accumulated: "", draftId: Date.now() & 2147483647, dirty: false, flushTimer: null } : null;
+    let onStreamCb;
+    if (draftState) {
+      draftState.flushTimer = setInterval(() => {
+        if (draftState.dirty) {
+          draftState.dirty = false;
+          channel.sendMessageDraft(chatId, draftState.draftId, draftState.accumulated);
+        }
+      }, DRAFT_FLUSH_INTERVAL_MS);
+      onStreamCb = (chunk) => {
+        draftState.accumulated += chunk;
+        draftState.dirty = true;
+      };
+    }
+    const stopDraftTimer2 = () => {
+      if (draftState?.flushTimer) {
+        clearInterval(draftState.flushTimer);
+        draftState.flushTimer = null;
+      }
+    };
     let toolUseCount = 0;
     const sigT0 = Date.now();
     const response = await askAgent(chatId, cleanText || text, {
@@ -34580,6 +34641,7 @@ You're still in discussion mode \u2014 try again or click a button to exit.`, {
       agentMode: effectiveAgentMode,
       ...effectiveThinking ? { thinkingLevel: effectiveThinking } : {},
       chatContext: { chatTitle: msg.chatTitle, threadId: msg.threadId },
+      onStream: onStreamCb,
       onThinking: liveStatus || sessionLog ? (chunk) => {
         if (liveStatus) liveStatus.addThinking(chunk);
         if (sessionLog) sessionLog.logThinking(chunk);
@@ -34617,6 +34679,7 @@ You're still in discussion mode \u2014 try again or click a button to exit.`, {
         });
       }
     });
+    stopDraftTimer2();
     const elapsedMs = Date.now() - sigT0;
     const elapsedSec = (elapsedMs / 1e3).toFixed(1);
     if (liveStatus && response.thinkingText?.trim()) {
@@ -34782,6 +34845,7 @@ Approve paid usage for this session?`,
     const userMsg = diagnoseAgentError(errMsg, chatId);
     await channel.sendText(chatId, userMsg, { parseMode: "plain" });
   } finally {
+    stopDraftTimer();
     getTypingManager().release(chatId);
     const pending = pendingInterrupts.get(chatId);
     if (pending) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cc-claw",
-  "version": "0.29.0",
+  "version": "0.29.2",
   "description": "CC-Claw: Personal AI assistant on Telegram — multi-backend (Claude, Gemini, Codex, Cursor), sub-agent orchestration, MCP management",
   "type": "module",
   "main": "dist/cli.js",