cc-claw 0.18.3 → 0.18.4

package/dist/cli.js

@@ -33,7 +33,7 @@ var VERSION;
 var init_version = __esm({
   "src/version.ts"() {
     "use strict";
-    VERSION = true ? "0.18.3" : (() => {
+    VERSION = true ? "0.18.4" : (() => {
       try {
         return JSON.parse(readFileSync(join(process.cwd(), "package.json"), "utf-8")).version ?? "unknown";
       } catch {
@@ -11154,6 +11154,7 @@ var init_detect = __esm({
 // src/agent.ts
 var agent_exports = {};
 __export(agent_exports, {
+  CONTENT_SILENCE_TIMEOUT_ERROR: () => CONTENT_SILENCE_TIMEOUT_ERROR,
   FIRST_RESPONSE_TIMEOUT_ERROR: () => FIRST_RESPONSE_TIMEOUT_ERROR,
   FREE_SLOTS_EXHAUSTED: () => FREE_SLOTS_EXHAUSTED,
   askAgent: () => askAgent,
@@ -11277,6 +11278,20 @@ function spawnQuery(adapter, config2, model2, cancelState, thinkingLevel, timeou
         }
       }, frTimeoutMs);
     }
+    let contentSilenceTimer;
+    const silenceTimeoutMs = CONTENT_SILENCE_TIMEOUT_MS;
+    function resetContentSilenceTimer() {
+      if (silenceTimeoutMs <= 0) return;
+      if (contentSilenceTimer) clearTimeout(contentSilenceTimer);
+      contentSilenceTimer = setTimeout(() => {
+        if (cancelState.cancelled || timedOut) return;
+        warn(`[agent] Content silence timeout after ${silenceTimeoutMs / 1e3}s for ${adapter.id} \u2014 no content events, killing`);
+        timedOut = true;
+        cancelState.__contentSilenceTimeout = true;
+        killProcessGroup(proc, "SIGTERM");
+        sigkillTimer = setTimeout(() => killProcessGroup(proc, "SIGKILL"), 3e3);
+      }, silenceTimeoutMs);
+    }
     rl2.on("line", (line) => {
       if (!line.trim()) return;
       if (firstLine) {
@@ -11299,6 +11314,7 @@ function spawnQuery(adapter, config2, model2, cancelState, thinkingLevel, timeou
           case "init":
             log(`[agent] Session init at ${elapsed()}`);
             if (ev.sessionId) sessionId = ev.sessionId;
+            resetContentSilenceTimer();
             break;
           case "text":
             if (!gotModelContent) {
@@ -11308,6 +11324,7 @@ function spawnQuery(adapter, config2, model2, cancelState, thinkingLevel, timeou
                 firstResponseTimer = void 0;
               }
             }
+            resetContentSilenceTimer();
             if (ev.text) {
               accumulatedText = appendTextChunk(accumulatedText, ev.text);
               if (opts?.onStream) opts.onStream(ev.text);
@@ -11321,6 +11338,7 @@ function spawnQuery(adapter, config2, model2, cancelState, thinkingLevel, timeou
                 firstResponseTimer = void 0;
               }
             }
+            resetContentSilenceTimer();
             if (ev.text) {
               accumulatedThinking = appendTextChunk(accumulatedThinking, ev.text);
               if (opts?.onThinking) opts.onThinking(ev.text);
@@ -11334,6 +11352,7 @@ function spawnQuery(adapter, config2, model2, cancelState, thinkingLevel, timeou
                 firstResponseTimer = void 0;
               }
             }
+            resetContentSilenceTimer();
             sawToolEvents = true;
             if (opts?.onToolAction && ev.toolName) {
               const toolInput = ev.toolInput ?? {};
@@ -11360,6 +11379,7 @@ function spawnQuery(adapter, config2, model2, cancelState, thinkingLevel, timeou
             }
             break;
           case "tool_end":
+            resetContentSilenceTimer();
             if (opts?.onToolAction) {
               const pending = ev.toolId ? pendingTools.get(ev.toolId) : void 0;
               if (pending) {
@@ -11413,6 +11433,7 @@ function spawnQuery(adapter, config2, model2, cancelState, thinkingLevel, timeou
     proc.on("error", (err) => {
       clearTimeout(spawnTimeout);
       if (firstResponseTimer) clearTimeout(firstResponseTimer);
+      if (contentSilenceTimer) clearTimeout(contentSilenceTimer);
       if (sigkillTimer) clearTimeout(sigkillTimer);
       rl2.close();
       cancelState.process = void 0;
@@ -11424,6 +11445,10 @@ function spawnQuery(adapter, config2, model2, cancelState, thinkingLevel, timeou
         clearTimeout(firstResponseTimer);
         firstResponseTimer = void 0;
       }
+      if (contentSilenceTimer) {
+        clearTimeout(contentSilenceTimer);
+        contentSilenceTimer = void 0;
+      }
       if (sigkillTimer) {
         clearTimeout(sigkillTimer);
         sigkillTimer = void 0;
@@ -11444,6 +11469,11 @@ function spawnQuery(adapter, config2, model2, cancelState, thinkingLevel, timeou
           reject(new Error(`${FIRST_RESPONSE_TIMEOUT_ERROR}: No response from ${adapter.id} within ${frTimeoutMs / 1e3}s${stderr ? ` \u2014 ${stderr.slice(-300)}` : ""}`));
           return;
         }
+        if (cancelState.__contentSilenceTimeout) {
+          delete cancelState.__contentSilenceTimeout;
+          reject(new Error(`${CONTENT_SILENCE_TIMEOUT_ERROR}: ${adapter.id} produced no content events for ${silenceTimeoutMs / 1e3}s after init`));
+          return;
+        }
         let msg = `Spawn timeout after ${effectiveTimeout / 1e3}s`;
         if (pendingTools.size > 0) {
           const tools2 = Array.from(pendingTools.values()).map((t) => typeof t === "string" ? t : t.name).join(", ");
@@ -11796,6 +11826,26 @@ async function askAgentImpl(chatId, userMessage, opts) {
         })();
         result = await spawnQuery(adapter, baseConfig, resolvedModel, cancelState, thinkingLevel, timeoutMs, maxTurns, retryOpts);
       }
+    } else if (errMsg.startsWith(CONTENT_SILENCE_TIMEOUT_ERROR) && existingSessionId) {
+      warn(`[agent] Content silence on ${adapter.id} \u2014 clearing session ${existingSessionId} and retrying fresh`);
+      clearSession(chatId);
+      if (useGeminiRotation) {
+        const rotationCb = onSlotRotation ? (from, to) => onSlotRotation(chatId, from, to) : void 0;
+        const downgradeCb = onModelDowngrade ? (from, to, reason) => onModelDowngrade(chatId, from, to, reason) : void 0;
+        result = await spawnGeminiWithRotation(chatId, adapter, baseConfig, baseConfig, resolvedModel, cancelState, thinkingLevel, timeoutMs, maxTurns, geminiRotationMode, spawnOpts, rotationCb, settingsSourceChatId, downgradeCb);
+      } else if (useBackendRotation) {
+        const rotationCb = onSlotRotation ? (from, to) => onSlotRotation(chatId, from, to) : void 0;
+        result = await spawnWithSlotRotation(chatId, adapter, baseConfig, baseConfig, resolvedModel, cancelState, thinkingLevel, timeoutMs, maxTurns, backendRotationMode, allowPaid, spawnOpts, rotationCb);
+      } else {
+        const retryOpts = (() => {
+          if (adapter.id !== "gemini") return spawnOpts;
+          const geminiAdapter = adapter;
+          const { env, slot } = geminiAdapter.resolveSlotEnv(chatId);
+          if (slot) return { ...spawnOpts, envOverride: env };
+          return spawnOpts;
+        })();
+        result = await spawnQuery(adapter, baseConfig, resolvedModel, cancelState, thinkingLevel, timeoutMs, maxTurns, retryOpts);
+      }
     } else {
       if (!isSyntheticChatId(chatId)) {
         try {
@@ -11900,7 +11950,7 @@ function injectMcpConfig(adapterId, args, mcpConfigPath) {
   if (!flag) return args;
   return [...args, ...flag, mcpConfigPath];
 }
-var activeChats, chatLocks, SPAWN_TIMEOUT_MS, FIRST_RESPONSE_TIMEOUT_MS, FIRST_RESPONSE_TIMEOUT_ERROR, FREE_SLOTS_EXHAUSTED, GEMINI_FALLBACK_CHAIN, GEMINI_DOWNGRADE_MODELS, MCP_CONFIG_FLAG;
+var activeChats, chatLocks, SPAWN_TIMEOUT_MS, FIRST_RESPONSE_TIMEOUT_MS, CONTENT_SILENCE_TIMEOUT_MS, CONTENT_SILENCE_TIMEOUT_ERROR, FIRST_RESPONSE_TIMEOUT_ERROR, FREE_SLOTS_EXHAUSTED, GEMINI_FALLBACK_CHAIN, GEMINI_DOWNGRADE_MODELS, MCP_CONFIG_FLAG;
 var init_agent = __esm({
   "src/agent.ts"() {
     "use strict";
@@ -11925,6 +11975,8 @@ var init_agent = __esm({
     chatLocks = /* @__PURE__ */ new Map();
     SPAWN_TIMEOUT_MS = 10 * 60 * 1e3;
     FIRST_RESPONSE_TIMEOUT_MS = parseInt(process.env.GEMINI_FIRST_RESPONSE_TIMEOUT_MS ?? "30000", 10);
+    CONTENT_SILENCE_TIMEOUT_MS = parseInt(process.env.CONTENT_SILENCE_TIMEOUT_MS ?? "90000", 10);
+    CONTENT_SILENCE_TIMEOUT_ERROR = "CONTENT_SILENCE_TIMEOUT";
     FIRST_RESPONSE_TIMEOUT_ERROR = "FIRST_RESPONSE_TIMEOUT";
     FREE_SLOTS_EXHAUSTED = "FREE_SLOTS_EXHAUSTED";
     GEMINI_FALLBACK_CHAIN = {
@@ -19820,7 +19872,14 @@ var init_commands = __esm({
 
 // src/router/callbacks.ts
 import { readFile as readFile7 } from "fs/promises";
-async function handleCallback(chatId, data, channel) {
+async function handleCallback(chatId, data, channel, messageId) {
+  const replaceWithText = async (text) => {
+    if (messageId && channel.editText) {
+      await channel.editText(chatId, messageId, text, "plain");
+    } else {
+      await channel.sendText(chatId, text, { parseMode: "plain" });
+    }
+  };
   if (data.startsWith("menu:")) {
     const action = data.slice(5);
     const synth = { chatId, messageId: "", text: "", senderName: "User", type: "command", source: "telegram", command: "", commandArgs: "" };
@@ -20056,7 +20115,7 @@ ${PERM_MODES[chosen]}`,
       return;
     }
     removePendingPlan(chatId);
-    await channel.sendText(chatId, "\u2705 Approved. Executing...", { parseMode: "plain" });
+    await replaceWithText("\u2705 Approved. Executing...");
     bypassBusyCheck.add(chatId);
     const { handleMessage: handleMessage2 } = await Promise.resolve().then(() => (init_router(), router_exports));
     const overrideMsg = `[SYSTEM: Planning mode disabled. Execution APPROVED. Please execute the plan.]
@@ -20549,14 +20608,14 @@ ${rotationNote}`, { parseMode: "html" });
       }
     } else if (action === "discard") {
       pendingInterrupts.delete(targetChatId);
-      await channel.sendText(chatId, "\u{1F5D1} Message discarded.", { parseMode: "plain" });
+      await replaceWithText("\u{1F5D1} Message discarded.");
     } else {
       await channel.sendText(chatId, "Message already processed or expired.", { parseMode: "plain" });
     }
   } else if (data.startsWith("sq:cancel:")) {
     const sqId = data.slice("sq:cancel:".length);
     stopAgent(sqId);
-    await channel.sendText(chatId, "\u{1F5FA} Side quest cancelled.", { parseMode: "plain" });
+    await replaceWithText("\u{1F5FA} Side quest cancelled.");
   } else if (data.startsWith("fallback:")) {
     const parts = data.split(":");
     const targetBackend = parts[1];
@@ -21183,13 +21242,14 @@ function makeLiveStatus(chatId, channel, modelLabel, verboseLevel, showThinking)
   };
   return { liveStatus, toolCb };
 }
-var FLUSH_INTERVAL_MS, MAX_THINKING_CHARS, TRIM_THRESHOLD, MAX_ENTRIES, LiveStatusMessage;
+var FLUSH_INTERVAL_DM_MS, FLUSH_INTERVAL_GROUP_MS, MAX_THINKING_CHARS, TRIM_THRESHOLD, MAX_ENTRIES, LiveStatusMessage;
 var init_live_status = __esm({
   "src/router/live-status.ts"() {
     "use strict";
     init_log();
     init_helpers();
-    FLUSH_INTERVAL_MS = 1e3;
+    FLUSH_INTERVAL_DM_MS = 1e3;
+    FLUSH_INTERVAL_GROUP_MS = 3e3;
     MAX_THINKING_CHARS = 800;
     TRIM_THRESHOLD = 3500;
     MAX_ENTRIES = 200;
@@ -21211,6 +21271,11 @@ var init_live_status = __esm({
       nextFlushAllowedAt = 0;
       /** Tracks whether entries have been trimmed at least once (for display hint). */
       hasTrimmed = false;
+      /** Resolve flush interval based on chat type (group chats are rate-limited more aggressively). */
+      get flushIntervalMs() {
+        const numericId = parseInt(this.chatId);
+        return numericId < 0 ? FLUSH_INTERVAL_GROUP_MS : FLUSH_INTERVAL_DM_MS;
+      }
       /** Send the initial status message. Must be called before adding entries. */
       async init() {
         if (!this.channel.sendTextReturningId) return;
@@ -21219,7 +21284,7 @@ var init_live_status = __esm({
           this.messageId = await this.channel.sendTextReturningId(this.chatId, initial, "plain") ?? null;
           if (this.messageId) {
             this.flushTimer = setInterval(() => this.flush().catch(() => {
-            }), FLUSH_INTERVAL_MS);
+            }), this.flushIntervalMs);
           }
         } catch (err) {
           log(`[live-status] init failed: ${err}`);
@@ -22932,7 +22997,26 @@ ${body.replace(/<[^>]*>/g, "").trim()}</code>
 });
 
 // src/channels/telegram.ts
-import { Bot, InlineKeyboard, InputFile } from "grammy";
+import { Bot, GrammyError, InlineKeyboard, InputFile } from "grammy";
+async function withRetry(label2, fn) {
+  for (let attempt = 0; attempt <= MAX_RETRIES2; attempt++) {
+    try {
+      return await fn();
+    } catch (err) {
+      if (err instanceof GrammyError && err.error_code === 429) {
+        const retrySec = Math.min(err.parameters?.retry_after ?? FALLBACK_RETRY_SEC, MAX_RETRY_WAIT_SEC);
+        if (attempt < MAX_RETRIES2) {
+          warn(`[telegram] 429 on ${label2} (attempt ${attempt + 1}/${MAX_RETRIES2}) \u2014 retrying in ${retrySec}s`);
+          await new Promise((r) => setTimeout(r, retrySec * 1e3));
+          continue;
+        }
+        warn(`[telegram] 429 on ${label2} \u2014 exhausted ${MAX_RETRIES2} retries, giving up`);
+      }
+      throw err;
+    }
+  }
+  throw new Error(`withRetry: unreachable`);
+}
 function isFastPathMessage(msg) {
   if (msg.type === "command" && msg.command && FAST_PATH_COMMANDS.has(msg.command)) {
     return true;
@@ -22952,13 +23036,16 @@ function numericChatId(chatId) {
   const raw = chatId.includes(":") ? chatId.split(":").pop() : chatId;
   return parseInt(raw);
 }
-var FAST_PATH_COMMANDS, TelegramChannel;
+var MAX_RETRIES2, FALLBACK_RETRY_SEC, MAX_RETRY_WAIT_SEC, FAST_PATH_COMMANDS, TelegramChannel;
 var init_telegram2 = __esm({
   "src/channels/telegram.ts"() {
     "use strict";
     init_telegram();
     init_log();
     init_store5();
+    MAX_RETRIES2 = 3;
+    FALLBACK_RETRY_SEC = 3;
+    MAX_RETRY_WAIT_SEC = 30;
     FAST_PATH_COMMANDS = /* @__PURE__ */ new Set(["stop", "status", "new", "newchat"]);
     TelegramChannel = class {
       name = "telegram";
@@ -23109,11 +23196,12 @@ var init_telegram2 = __esm({
             return;
           }
           const data = ctx.callbackQuery.data;
+          const messageId = ctx.callbackQuery.message?.message_id?.toString();
           ctx.answerCallbackQuery().catch(() => {
           });
           (async () => {
             for (const handler2 of this.callbackHandlers) {
-              await handler2(chatId, data, this);
+              await handler2(chatId, data, this, messageId);
             }
           })().catch((err) => {
             error("[telegram] Callback handler error:", err);
@@ -23166,7 +23254,10 @@ var init_telegram2 = __esm({
         if (parseMode === "plain") {
           const plainChunks = splitMessage(text);
           for (const chunk of plainChunks) {
-            const sent = await this.bot.api.sendMessage(numericChatId(chatId), chunk, { ...threadOpts, ...replyOpts });
+            const sent = await withRetry(
+              "sendText:plain",
+              () => this.bot.api.sendMessage(numericChatId(chatId), chunk, { ...threadOpts, ...replyOpts })
+            );
             this.trackAgentMessage(sent.message_id, chatId);
           }
           return;
@@ -23175,32 +23266,44 @@ var init_telegram2 = __esm({
         const chunks = splitMessage(formatted);
         for (const chunk of chunks) {
           try {
-            const sent = await this.bot.api.sendMessage(numericChatId(chatId), chunk, {
-              parse_mode: "HTML",
-              ...threadOpts,
-              ...replyOpts
-            });
+            const sent = await withRetry(
+              "sendText:html",
+              () => this.bot.api.sendMessage(numericChatId(chatId), chunk, {
+                parse_mode: "HTML",
+                ...threadOpts,
+                ...replyOpts
+              })
+            );
             this.trackAgentMessage(sent.message_id, chatId);
           } catch {
-            const sent = await this.bot.api.sendMessage(
-              numericChatId(chatId),
-              chunk.replace(/<[^>]+>/g, ""),
-              { ...threadOpts, ...replyOpts }
+            const sent = await withRetry(
+              "sendText:fallback",
+              () => this.bot.api.sendMessage(
+                numericChatId(chatId),
+                chunk.replace(/<[^>]+>/g, ""),
+                { ...threadOpts, ...replyOpts }
+              )
             );
             this.trackAgentMessage(sent.message_id, chatId);
           }
         }
       }
       async sendVoice(chatId, audioBuffer, fileName) {
-        await this.bot.api.sendVoice(
-          numericChatId(chatId),
-          new InputFile(audioBuffer, fileName ?? "response.ogg")
+        await withRetry(
+          "sendVoice",
+          () => this.bot.api.sendVoice(
+            numericChatId(chatId),
+            new InputFile(audioBuffer, fileName ?? "response.ogg")
+          )
         );
       }
       async sendFile(chatId, buffer, fileName) {
-        await this.bot.api.sendDocument(
-          numericChatId(chatId),
-          new InputFile(buffer, fileName)
+        await withRetry(
+          "sendFile",
+          () => this.bot.api.sendDocument(
+            numericChatId(chatId),
+            new InputFile(buffer, fileName)
+          )
         );
       }
       async downloadFile(fileId) {
@@ -23213,7 +23316,10 @@ var init_telegram2 = __esm({
         try {
           const formatted = parseMode === "html" ? text : parseMode === "plain" ? text : formatForTelegram(text);
           const opts = parseMode === "plain" ? {} : { parse_mode: "HTML" };
-          const msg = await this.bot.api.sendMessage(numericChatId(chatId), formatted, opts);
+          const msg = await withRetry(
+            "sendTextReturningId",
+            () => this.bot.api.sendMessage(numericChatId(chatId), formatted, opts)
+          );
           return msg.message_id.toString();
         } catch {
           return void 0;
@@ -23222,16 +23328,22 @@ var init_telegram2 = __esm({
       async editText(chatId, messageId, text, parseMode) {
         const formatted = parseMode === "html" ? text : formatForTelegram(text);
         try {
-          await this.bot.api.editMessageText(numericChatId(chatId), parseInt(messageId), formatted, {
-            parse_mode: "HTML"
-          });
+          await withRetry(
+            "editText:html",
+            () => this.bot.api.editMessageText(numericChatId(chatId), parseInt(messageId), formatted, {
+              parse_mode: "HTML"
+            })
+          );
           return true;
         } catch {
           try {
-            await this.bot.api.editMessageText(
-              numericChatId(chatId),
-              parseInt(messageId),
-              formatted.replace(/<[^>]+>/g, "")
+            await withRetry(
+              "editText:fallback",
+              () => this.bot.api.editMessageText(
+                numericChatId(chatId),
+                parseInt(messageId),
+                formatted.replace(/<[^>]+>/g, "")
+              )
             );
             return true;
           } catch {
@@ -23261,16 +23373,22 @@ var init_telegram2 = __esm({
         const MAX_KEYBOARD_TEXT = 4e3;
         const safeText = text.length > MAX_KEYBOARD_TEXT ? text.slice(0, MAX_KEYBOARD_TEXT) + "\n\n\u2026(truncated)" : text;
         try {
-          const msg = await this.bot.api.sendMessage(numericChatId(chatId), safeText, {
-            reply_markup: keyboard
-          });
+          const msg = await withRetry(
+            "sendKeyboard",
+            () => this.bot.api.sendMessage(numericChatId(chatId), safeText, {
+              reply_markup: keyboard
+            })
+          );
           return msg.message_id.toString();
         } catch (err) {
           error(`[telegram] sendKeyboard failed (chat=${chatId}, textLen=${text.length}):`, err);
           try {
-            const fallbackMsg = await this.bot.api.sendMessage(numericChatId(chatId), "\u2B06\uFE0F (see above for details)", {
-              reply_markup: keyboard
-            });
+            const fallbackMsg = await withRetry(
+              "sendKeyboard:fallback",
+              () => this.bot.api.sendMessage(numericChatId(chatId), "\u2B06\uFE0F (see above for details)", {
+                reply_markup: keyboard
+              })
+            );
             return fallbackMsg.message_id.toString();
           } catch (fallbackErr) {
             error(`[telegram] sendKeyboard fallback also failed:`, fallbackErr);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cc-claw",
-  "version": "0.18.3",
+  "version": "0.18.4",
   "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",