@inetafrica/open-claudia 1.4.4 → 1.5.0

package/bot.js

@@ -7,10 +7,40 @@ const cron = require("node-cron");
 const Vault = require("./vault");
 const CONFIG_DIR = require("./config-dir");
 
-// ── Graceful shutdown ──────────────────────────────────────────────
+// ── Graceful shutdown & error handling ─────────────────────────────
 process.on("SIGINT", () => process.exit(0));
 process.on("SIGTERM", () => process.exit(0));
 
+// Notify user of crashes via Telegram before exiting
+function notifyError(label, err) {
+  const msg = `${label}: ${err?.message || err}`.slice(0, 1000);
+  console.error(msg, err?.stack || "");
+  try {
+    // Synchronous-style notification using the Telegram API directly
+    const token = process.env.TELEGRAM_BOT_TOKEN;
+    const chatId = process.env.TELEGRAM_CHAT_ID?.split(",")[0];
+    if (token && chatId) {
+      const data = JSON.stringify({ chat_id: chatId, text: msg });
+      const req = require("https").request({
+        hostname: "api.telegram.org", path: `/bot${token}/sendMessage`,
+        method: "POST", headers: { "Content-Type": "application/json", "Content-Length": data.length },
+      });
+      req.write(data);
+      req.end();
+    }
+  } catch (e) { /* last resort — ignore */ }
+}
+
+process.on("uncaughtException", (err) => {
+  notifyError("Uncaught exception", err);
+  // Give the notification a moment to send before exiting
+  setTimeout(() => process.exit(1), 2000);
+});
+
+process.on("unhandledRejection", (reason) => {
+  notifyError("Unhandled rejection", reason);
+});
+
 // ── Load Config from .env ───────────────────────────────────────────
 function loadEnv() {
   const envPath = path.join(CONFIG_DIR, ".env");
@@ -524,19 +554,41 @@ async function send(text, opts = {}) {
   if (opts.parseMode) o.parse_mode = opts.parseMode;
   if (opts.keyboard) o.reply_markup = opts.keyboard;
   if (opts.replyTo) o.reply_to_message_id = opts.replyTo;
-  try {
-    const msg = await bot.sendMessage(CHAT_ID, text, o);
-    return msg.message_id;
-  } catch (e) {
-    if (opts.parseMode) {
-      try {
-        const f = {}; if (opts.keyboard) f.reply_markup = opts.keyboard;
-        return (await bot.sendMessage(CHAT_ID, text, f)).message_id;
-      } catch (e2) { /* ignore */ }
+
+  for (let attempt = 0; attempt < 3; attempt++) {
+    try {
+      const msg = await bot.sendMessage(CHAT_ID, text, o);
+      return msg.message_id;
+    } catch (e) {
+      const errMsg = e.message || "";
+
+      // replyTo message was deleted or not found — retry without it
+      if (o.reply_to_message_id && errMsg.includes("message to be replied not found")) {
+        delete o.reply_to_message_id;
+        continue;
+      }
+
+      // Rate limited — wait and retry
+      const retryMatch = errMsg.match(/retry after (\d+)/i);
+      if (retryMatch) {
+        const waitSec = Math.min(parseInt(retryMatch[1], 10), 30);
+        console.error(`Send: rate limited, waiting ${waitSec}s`);
+        await new Promise((r) => setTimeout(r, waitSec * 1000));
+        continue;
+      }
+
+      // Parse mode failed — retry without it
+      if (opts.parseMode && o.parse_mode) {
+        delete o.parse_mode;
+        continue;
+      }
+
+      console.error("Send error:", errMsg);
+      return null;
     }
-    console.error("Send error:", e.message);
-    return null;
   }
+  console.error("Send: exhausted retries");
+  return null;
 }
 
 async function editMessage(messageId, text, opts = {}) {
@@ -544,7 +596,17 @@ async function editMessage(messageId, text, opts = {}) {
     const o = { chat_id: CHAT_ID, message_id: messageId };
     if (opts.keyboard) o.reply_markup = opts.keyboard;
     await bot.editMessageText(text, o);
-  } catch (e) { /* ignore */ }
+  } catch (e) {
+    const errMsg = e.message || "";
+    // Rate limited — skip this update (next interval will catch up)
+    if (errMsg.includes("retry after")) return;
+    // Message unchanged — ignore
+    if (errMsg.includes("message is not modified")) return;
+    // Log anything unexpected
+    if (!errMsg.includes("message to edit not found")) {
+      console.error("Edit error:", errMsg);
+    }
+  }
 }
 
 function splitMessage(text, maxLen = 4000) {
@@ -619,6 +681,7 @@ async function runClaude(prompt, cwd, replyToMsgId, opts = {}) {
   let assistantText = "";
   let toolUses = [];
   let currentTool = null;
+  let currentToolDetail = "";
 
   const args = buildClaudeArgs(prompt, opts);
   const proc = spawn(CLAUDE_PATH, args, {
@@ -633,24 +696,36 @@ async function runClaude(prompt, cwd, replyToMsgId, opts = {}) {
   let longRunningNotified = false;
 
   let lastUpdate = "";
-  streamInterval = setInterval(async () => {
-    bot.sendChatAction(CHAT_ID, "typing");
+  // Adaptive update interval: 2s for first 2min, then 5s to avoid rate limits
+  const scheduleUpdate = () => {
     const elapsed = Math.floor((Date.now() - startTime) / 1000);
-    const display = formatProgress(assistantText, toolUses, currentTool, elapsed);
-    if (display && display !== lastUpdate) {
-      if (!statusMessageId && assistantText) {
-        statusMessageId = await send(display.length > 4000 ? display.slice(-4000) : display, { replyTo: replyToMsgId });
-      } else if (statusMessageId) {
-        await editMessage(statusMessageId, display.length > 4000 ? display.slice(-4000) : display);
+    const interval = elapsed > 120 ? 5000 : 2000;
+    streamInterval = setTimeout(updateProgress, interval);
+  };
+  const updateProgress = async () => {
+    const elapsed = Math.floor((Date.now() - startTime) / 1000);
+    try {
+      bot.sendChatAction(CHAT_ID, "typing").catch(() => {});
+      const display = formatProgress(assistantText, toolUses, currentTool, elapsed, currentToolDetail);
+      if (display && display !== lastUpdate) {
+        if (!statusMessageId && assistantText) {
+          statusMessageId = await send(display.length > 4000 ? display.slice(-4000) : display, { replyTo: replyToMsgId });
+        } else if (statusMessageId) {
+          await editMessage(statusMessageId, display.length > 4000 ? display.slice(-4000) : display);
+        }
+        lastUpdate = display;
       }
-      lastUpdate = display;
-    }
-    // Notify after 5 minutes that it's still running
-    if (elapsed > 300 && !longRunningNotified) {
-      longRunningNotified = true;
-      await send(`Still working (${Math.floor(elapsed / 60)}min)... Send /stop to cancel.`);
+      // Notify after 5 minutes that it's still running
+      if (elapsed > 300 && !longRunningNotified) {
+        longRunningNotified = true;
+        await send(`Still working (${Math.floor(elapsed / 60)}min)... Send /stop to cancel.`);
+      }
+    } catch (e) {
+      console.error("Progress update error:", e.message);
     }
-  }, 1500);
+    if (runningProcess) scheduleUpdate();
+  };
+  scheduleUpdate();
 
   proc.stdout.on("data", (data) => {
     streamBuffer += data.toString();
@@ -661,7 +736,19 @@ async function runClaude(prompt, cwd, replyToMsgId, opts = {}) {
       if (evt.type === "assistant" && evt.message?.content) {
         for (const block of evt.message.content) {
           if (block.type === "text") assistantText += block.text;
-          else if (block.type === "tool_use") { currentTool = block.name; toolUses.push(block.name); }
+          else if (block.type === "tool_use") {
+            currentTool = block.name;
+            toolUses.push(block.name);
+            // Extract useful detail from tool input
+            const input = block.input || {};
+            if (block.name === "Bash" && input.command) currentToolDetail = input.command.slice(0, 80);
+            else if (block.name === "Read" && input.file_path) currentToolDetail = input.file_path.split("/").slice(-2).join("/");
+            else if (block.name === "Edit" && input.file_path) currentToolDetail = input.file_path.split("/").slice(-2).join("/");
+            else if (block.name === "Write" && input.file_path) currentToolDetail = input.file_path.split("/").slice(-2).join("/");
+            else if (block.name === "Grep" && input.pattern) currentToolDetail = input.pattern.slice(0, 40);
+            else if (block.name === "Glob" && input.pattern) currentToolDetail = input.pattern;
+            else currentToolDetail = "";
+          }
         }
       }
       if (evt.type === "result" && evt.session_id) { lastSessionId = evt.session_id; saveState(); }
@@ -673,16 +760,25 @@ async function runClaude(prompt, cwd, replyToMsgId, opts = {}) {
 
   proc.on("close", async (code) => {
     runningProcess = null;
-    clearInterval(streamInterval); streamInterval = null;
-    const finalText = assistantText || "(no output)";
-    const chunks = splitMessage(finalText);
-    // Keep the streaming progress message and send final result as a new message
-    // This ensures the user gets a notification for the final answer
-    await send(chunks[0], { replyTo: replyToMsgId });
-    for (let i = 1; i < chunks.length; i++) {
-      await send(chunks[i]);
+    clearTimeout(streamInterval); streamInterval = null;
+    try {
+      const finalText = assistantText || "(no output)";
+      const chunks = splitMessage(finalText);
+      // Send final result as a new message (triggers notification)
+      const sent = await send(chunks[0], { replyTo: replyToMsgId });
+      if (!sent) {
+        // Fallback: if the first send failed completely, try without any options
+        await send(chunks[0]);
+      }
+      for (let i = 1; i < chunks.length; i++) {
+        await send(chunks[i]);
+      }
+      if (code !== 0 && code !== null) await send(`Exit code: ${code}`);
+    } catch (e) {
+      console.error("Final message delivery failed:", e.message);
+      // Last-resort attempt to notify user something went wrong
+      await send("Task completed but failed to deliver the response. Send /continue to see the result.");
     }
-    if (code !== 0 && code !== null) await send(`Exit code: ${code}`);
     if (settings.budget) settings.budget = null;
     statusMessageId = null;
 
@@ -699,7 +795,7 @@ async function runClaude(prompt, cwd, replyToMsgId, opts = {}) {
   });
 
   proc.on("error", async (err) => {
-    runningProcess = null; clearInterval(streamInterval);
+    runningProcess = null; clearTimeout(streamInterval);
     await send(`Error: ${err.message}`); statusMessageId = null;
   });
 }
@@ -724,15 +820,16 @@ async function runClaudeSilent(prompt, cwd, label) {
   });
 }
 
-function formatProgress(text, tools, currentTool, elapsed) {
+function formatProgress(text, tools, currentTool, elapsed, toolDetail) {
   const mins = Math.floor(elapsed / 60);
   const secs = elapsed % 60;
   const time = mins > 0 ? `${mins}m ${secs}s` : `${secs}s`;
 
   const parts = [];
-  const status = currentTool ? `Working: ${currentTool}` : (tools.length > 0 ? "Processing..." : "Thinking...");
+  let status = currentTool ? `Working: ${currentTool}` : (tools.length > 0 ? "Processing..." : "Thinking...");
+  if (currentTool && toolDetail) status += ` — ${toolDetail}`;
   parts.push(`${status} (${time})`);
-  if (tools.length > 0) parts.push(`Steps: ${[...new Set(tools)].join(" > ")}`);
+  if (tools.length > 1) parts.push(`Steps: ${[...new Set(tools)].join(" > ")}`);
   if (text) parts.push(text.length > 800 ? "..." + text.slice(-800) : text);
   return parts.join("\n\n");
 }
@@ -936,7 +1033,7 @@ bot.onText(/\/stop/, async (msg) => {
       try { process.kill(-pid, "SIGKILL"); } catch (e) {}
     }, 3000);
     runningProcess = null;
-    if (streamInterval) clearInterval(streamInterval);
+    if (streamInterval) clearTimeout(streamInterval);
     messageQueue = [];
     await send("Cancelled.");
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@inetafrica/open-claudia",
-  "version": "1.4.4",
+  "version": "1.5.0",
   "description": "Your always-on AI coding assistant — Claude Code via Telegram",
   "main": "bot.js",
   "bin": {