@inetafrica/open-claudia 1.12.1 → 1.13.0

package/bot.js

@@ -1147,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"));
@@ -1689,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.12.1",
+  "version": "1.13.0",
   "description": "Your always-on AI coding assistant — Claude Code via Telegram",
   "main": "bot.js",
   "bin": {