@inetafrica/open-claudia 1.11.0 → 1.13.0

package/CHANGELOG.md

@@ -1,5 +1,10 @@
 # Changelog
 
+## v1.12.0
+- Cursor Agent tool progress: Shell, Read, Edit, Write, Grep, Glob calls now show in real-time Telegram updates
+- Plan output surfaced to Telegram: when Cursor creates a plan (`--mode plan`), the full plan markdown and task list are sent to the user
+- Handles all Cursor tool_call event types with fallback for unknown tools
+
 ## v1.11.0
 - Backend-aware plan mode: /plan passes `--mode plan` to Cursor Agent, `--permission-mode plan` to Claude
 - New /ask command: read-only Q&A mode (Cursor Agent only, `--mode ask`)

package/bot-agent.js

@@ -845,7 +845,6 @@ async function runClaude(prompt, cwd, replyToMsgId, opts = {}) {
           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("/");
@@ -857,6 +856,48 @@ async function runClaude(prompt, cwd, replyToMsgId, opts = {}) {
           }
         }
       }
+      // Cursor Agent tool_call events (different format from Claude's tool_use blocks)
+      if (evt.type === "tool_call" && evt.subtype === "started" && evt.tool_call) {
+        const tc = evt.tool_call;
+        if (tc.shellToolCall) {
+          const a = tc.shellToolCall.args || {};
+          currentTool = "Shell"; toolUses.push("Shell");
+          currentToolDetail = (a.description || a.command || "").slice(0, 80);
+        } else if (tc.readToolCall) {
+          currentTool = "Read"; toolUses.push("Read");
+          currentToolDetail = (tc.readToolCall.args?.path || "").split("/").slice(-2).join("/");
+        } else if (tc.editToolCall) {
+          currentTool = "Edit"; toolUses.push("Edit");
+          currentToolDetail = (tc.editToolCall.args?.filePath || "").split("/").slice(-2).join("/");
+        } else if (tc.writeToolCall) {
+          currentTool = "Write"; toolUses.push("Write");
+          currentToolDetail = (tc.writeToolCall.args?.filePath || "").split("/").slice(-2).join("/");
+        } else if (tc.grepToolCall) {
+          currentTool = "Grep"; toolUses.push("Grep");
+          currentToolDetail = (tc.grepToolCall.args?.pattern || "").slice(0, 40);
+        } else if (tc.globToolCall) {
+          currentTool = "Glob"; toolUses.push("Glob");
+          currentToolDetail = (tc.globToolCall.args?.globPattern || "").slice(0, 40);
+        } else if (tc.createPlanToolCall) {
+          currentTool = "Plan"; toolUses.push("Plan");
+          const plan = tc.createPlanToolCall.args || {};
+          let planText = "";
+          if (plan.name) planText += `**${plan.name}**\n\n`;
+          if (plan.plan) planText += plan.plan + "\n";
+          if (plan.todos && plan.todos.length) {
+            planText += "\n**Tasks:**\n";
+            for (const todo of plan.todos) {
+              planText += `• ${todo.content || todo.id}\n`;
+            }
+          }
+          if (planText) assistantText = planText;
+          currentToolDetail = plan.name || "creating plan";
+        } else {
+          const toolKey = Object.keys(tc)[0] || "unknown";
+          currentTool = toolKey.replace("ToolCall", ""); toolUses.push(currentTool);
+          currentToolDetail = "";
+        }
+      }
       if (evt.type === "result" && evt.session_id) {
         if (settings.backend === "cursor") { cursorSessionId = evt.session_id; }
         else { lastSessionId = evt.session_id; }

package/bot.js

@@ -861,7 +861,6 @@ async function runClaude(prompt, cwd, replyToMsgId, opts = {}) {
           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("/");
@@ -873,6 +872,48 @@ async function runClaude(prompt, cwd, replyToMsgId, opts = {}) {
           }
         }
       }
+      // Cursor Agent tool_call events (different format from Claude's tool_use blocks)
+      if (evt.type === "tool_call" && evt.subtype === "started" && evt.tool_call) {
+        const tc = evt.tool_call;
+        if (tc.shellToolCall) {
+          const a = tc.shellToolCall.args || {};
+          currentTool = "Shell"; toolUses.push("Shell");
+          currentToolDetail = (a.description || a.command || "").slice(0, 80);
+        } else if (tc.readToolCall) {
+          currentTool = "Read"; toolUses.push("Read");
+          currentToolDetail = (tc.readToolCall.args?.path || "").split("/").slice(-2).join("/");
+        } else if (tc.editToolCall) {
+          currentTool = "Edit"; toolUses.push("Edit");
+          currentToolDetail = (tc.editToolCall.args?.filePath || "").split("/").slice(-2).join("/");
+        } else if (tc.writeToolCall) {
+          currentTool = "Write"; toolUses.push("Write");
+          currentToolDetail = (tc.writeToolCall.args?.filePath || "").split("/").slice(-2).join("/");
+        } else if (tc.grepToolCall) {
+          currentTool = "Grep"; toolUses.push("Grep");
+          currentToolDetail = (tc.grepToolCall.args?.pattern || "").slice(0, 40);
+        } else if (tc.globToolCall) {
+          currentTool = "Glob"; toolUses.push("Glob");
+          currentToolDetail = (tc.globToolCall.args?.globPattern || "").slice(0, 40);
+        } else if (tc.createPlanToolCall) {
+          currentTool = "Plan"; toolUses.push("Plan");
+          const plan = tc.createPlanToolCall.args || {};
+          let planText = "";
+          if (plan.name) planText += `**${plan.name}**\n\n`;
+          if (plan.plan) planText += plan.plan + "\n";
+          if (plan.todos && plan.todos.length) {
+            planText += "\n**Tasks:**\n";
+            for (const todo of plan.todos) {
+              planText += `• ${todo.content || todo.id}\n`;
+            }
+          }
+          if (planText) assistantText = planText;
+          currentToolDetail = plan.name || "creating plan";
+        } else {
+          const toolKey = Object.keys(tc)[0] || "unknown";
+          currentTool = toolKey.replace("ToolCall", ""); toolUses.push(currentTool);
+          currentToolDetail = "";
+        }
+      }
       if (evt.type === "result" && evt.session_id) {
         if (settings.backend === "cursor") { cursorSessionId = evt.session_id; }
         else { lastSessionId = evt.session_id; }
@@ -1106,6 +1147,11 @@ bot.onText(/\/upgrade$/, async (msg) => {
       cwd: process.env.HOME || require("os").homedir(),
       env: { ...process.env, PATH: FULL_PATH, HOME: process.env.HOME || require("os").homedir() },
     });
+    // Run idempotent setup (install/configure tools like Playwright MCP)
+    try {
+      const { ensureSetup: postUpgradeSetup } = require("./health");
+      postUpgradeSetup();
+    } catch (e) { /* setup will run on next boot anyway */ }
     // Read version and changelog from newly installed package
     const root = execSync("npm root -g", { encoding: "utf-8", cwd: process.env.HOME || require("os").homedir(), env: { ...process.env, PATH: FULL_PATH } }).trim();
     const newPkg = JSON.parse(fs.readFileSync(path.join(root, "@inetafrica", "open-claudia", "package.json"), "utf-8"));
@@ -1204,7 +1250,8 @@ bot.onText(/\/plan$/, (msg) => {
   const p = settings.permissionMode === "plan";
   settings.permissionMode = p ? null : "plan";
   const label = settings.backend === "cursor" ? "read-only planning, no edits" : "plan permission mode";
-  send(p ? "Plan mode off." : `Plan mode on (${label}).`);
+  if (p) cursorSessionId = null; // reset session so next message doesn't resume plan-mode session
+  send(p ? "Plan mode off (session reset)." : `Plan mode on (${label}).`);
 });
 bot.onText(/\/ask$/, (msg) => {
   if (!isAuthorized(msg)) return;
@@ -1647,6 +1694,17 @@ bot.on("message", async (msg) => {
 });
 
 // ── Startup ─────────────────────────────────────────────────────────
+// Idempotent setup: ensure tools & config are in place (safe on every boot)
+try {
+  const { ensureSetup, formatSetupResults } = require("./health");
+  const setupResult = ensureSetup();
+  console.log("Setup check:");
+  console.log(formatSetupResults(setupResult));
+  if (!setupResult.ok) console.warn("Some setup steps failed — browser tools may be unavailable.");
+} catch (e) {
+  console.warn("Setup check skipped:", e.message);
+}
+
 initCrons();
 console.log("Claude Code Telegram bot running");
 console.log(`Workspace: ${WORKSPACE}`);

package/health.js

@@ -336,6 +336,34 @@ async function runHealthChecks(options = {}) {
     results.warnings.push(`FFmpeg not found at: ${env.FFMPEG} (voice notes disabled)`);
   }
 
+  // 12. Check Playwright MCP setup
+  try {
+    const root = execSync("npm root -g", { encoding: "utf-8", stdio: "pipe" }).trim();
+    const pwMcpPkg = path.join(root, "@playwright", "mcp", "package.json");
+    if (!fs.existsSync(pwMcpPkg)) {
+      results.warnings.push("@playwright/mcp not installed globally (browser tools unavailable)");
+    } else {
+      results.checks.playwright_mcp = { ok: true };
+    }
+  } catch (e) {
+    results.warnings.push("Could not check @playwright/mcp installation");
+  }
+
+  if (fs.existsSync(MCP_CONFIG_FILE)) {
+    try {
+      const mcpCfg = JSON.parse(fs.readFileSync(MCP_CONFIG_FILE, "utf-8"));
+      if (!mcpCfg.mcpServers || !mcpCfg.mcpServers.playwright) {
+        results.warnings.push("Playwright MCP not configured in ~/.claude/mcp.json");
+      } else {
+        results.checks.mcp_config = { ok: true };
+      }
+    } catch (e) {
+      results.warnings.push("~/.claude/mcp.json is malformed");
+    }
+  } else {
+    results.warnings.push("~/.claude/mcp.json not found (MCP tools unavailable)");
+  }
+
   return results;
 }
 
@@ -376,6 +404,144 @@ function formatResults(results, verbose = false) {
   return lines.join("\n");
 }
 
+// ── Idempotent setup: ensures required tools and config are in place ──
+
+const MCP_CONFIG_FILE = path.join(process.env.HOME || require("os").homedir(), ".claude", "mcp.json");
+
+/**
+ * Ensure @playwright/mcp is installed globally.
+ * Returns { installed: bool, alreadyInstalled: bool, error?: string }
+ */
+function ensurePlaywrightMcp() {
+  // Check if already installed
+  try {
+    const root = execSync("npm root -g", { encoding: "utf-8", stdio: "pipe" }).trim();
+    const pkgPath = path.join(root, "@playwright", "mcp", "package.json");
+    if (fs.existsSync(pkgPath)) {
+      return { installed: true, alreadyInstalled: true };
+    }
+  } catch (e) { /* not installed */ }
+
+  // Install it
+  try {
+    execSync("npm install -g @playwright/mcp@latest 2>&1", {
+      encoding: "utf-8",
+      timeout: 120000,
+      stdio: "pipe",
+      env: { ...process.env, PATH: process.env.PATH },
+    });
+    return { installed: true, alreadyInstalled: false };
+  } catch (e) {
+    return { installed: false, error: (e.stderr || e.message || "").slice(-300) };
+  }
+}
+
+/**
+ * Ensure ~/.claude/mcp.json has the Playwright MCP server configured.
+ * Idempotent — won't duplicate if already present.
+ * Returns { configured: bool, alreadyConfigured: bool, error?: string }
+ */
+function ensureMcpConfig() {
+  const claudeDir = path.dirname(MCP_CONFIG_FILE);
+
+  // Ensure ~/.claude directory exists
+  if (!fs.existsSync(claudeDir)) {
+    try {
+      fs.mkdirSync(claudeDir, { recursive: true });
+    } catch (e) {
+      return { configured: false, error: `Failed to create ${claudeDir}: ${e.message}` };
+    }
+  }
+
+  // Load existing config or start fresh
+  let mcpConfig = { mcpServers: {} };
+  if (fs.existsSync(MCP_CONFIG_FILE)) {
+    try {
+      mcpConfig = JSON.parse(fs.readFileSync(MCP_CONFIG_FILE, "utf-8"));
+      if (!mcpConfig.mcpServers) mcpConfig.mcpServers = {};
+    } catch (e) {
+      // Corrupted config — back up and start fresh
+      const backup = MCP_CONFIG_FILE + ".bak." + Date.now();
+      try { fs.copyFileSync(MCP_CONFIG_FILE, backup); } catch (e2) {}
+      mcpConfig = { mcpServers: {} };
+    }
+  }
+
+  // Check if Playwright MCP is already configured
+  if (mcpConfig.mcpServers.playwright) {
+    return { configured: true, alreadyConfigured: true };
+  }
+
+  // Find the installed binary
+  let mcpBin = "playwright-mcp";
+  try {
+    const resolved = execSync("which playwright-mcp", { encoding: "utf-8", stdio: "pipe" }).trim();
+    if (resolved) mcpBin = resolved;
+  } catch (e) {
+    // Try npx path
+    try {
+      const root = execSync("npm root -g", { encoding: "utf-8", stdio: "pipe" }).trim();
+      const binPath = path.join(root, "@playwright", "mcp", "cli.js");
+      if (fs.existsSync(binPath)) mcpBin = binPath;
+    } catch (e2) {}
+  }
+
+  // Add Playwright MCP server config
+  mcpConfig.mcpServers.playwright = {
+    command: "npx",
+    args: ["@playwright/mcp@latest", "--headless"],
+  };
+
+  // Write config
+  try {
+    fs.writeFileSync(MCP_CONFIG_FILE, JSON.stringify(mcpConfig, null, 2) + "\n", "utf-8");
+    return { configured: true, alreadyConfigured: false };
+  } catch (e) {
+    return { configured: false, error: `Failed to write ${MCP_CONFIG_FILE}: ${e.message}` };
+  }
+}
+
+/**
+ * Run all idempotent setup steps.
+ * Safe to call on every startup and after every upgrade.
+ * Returns { ok: bool, steps: { name: result } }
+ */
+function ensureSetup() {
+  const results = { ok: true, steps: {} };
+
+  // Step 1: Install Playwright MCP globally
+  results.steps.playwright_mcp = ensurePlaywrightMcp();
+  if (!results.steps.playwright_mcp.installed) {
+    results.ok = false;
+  }
+
+  // Step 2: Configure MCP in Claude Code config
+  results.steps.mcp_config = ensureMcpConfig();
+  if (!results.steps.mcp_config.configured) {
+    results.ok = false;
+  }
+
+  return results;
+}
+
+/**
+ * Format ensureSetup results for logging/display
+ */
+function formatSetupResults(results) {
+  const lines = [];
+  for (const [name, result] of Object.entries(results.steps)) {
+    const label = name.replace(/_/g, " ");
+    if (result.alreadyInstalled || result.alreadyConfigured) {
+      lines.push(`  ${label}: already set up`);
+    } else if (result.installed || result.configured) {
+      lines.push(`  ${label}: configured`);
+    } else {
+      lines.push(`  ${label}: FAILED — ${result.error || "unknown error"}`);
+    }
+  }
+  return lines.join("\n");
+}
+
 module.exports = {
   runHealthChecks,
   formatResults,
@@ -386,6 +552,10 @@ module.exports = {
   checkNodeVersion,
   checkForConflictingProcesses,
   binaryExists,
+  ensureSetup,
+  formatSetupResults,
+  ensurePlaywrightMcp,
+  ensureMcpConfig,
   REQUIRED_ENV_KEYS,
   OPTIONAL_ENV_KEYS,
 };

package/package.json

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