claude-bridge-cli 2.0.23 → 2.0.25

package/lib/bridge.js

@@ -64,6 +64,16 @@ function dataDir() {
   return d;
 }
 
+let mcpHealth = { at: 0, data: {} };   // cached `claude mcp list` health
+
+// Where always-on personal skills live for THIS machine (a plugin dir, since
+// ~/.claude/skills is not discovered by the CLI). Shared by the turn builder
+// (--plugin-dir) and the /skills endpoint so they can never disagree.
+function globalSkillsDir() {
+  return process.env.CLAUDE_BRIDGE_GLOBAL_SKILLS_DIR ||
+         path.join(dataDir(), "global-skills");
+}
+
 function readJson(filePath, def) {
   try { return JSON.parse(fs.readFileSync(filePath, "utf8")); } catch { return def; }
 }
@@ -890,8 +900,7 @@ function askClaude(config, { prompt, session_id, images, cwd, plan_mode, allow_t
     // cwd. So personal always-on skills live in <data>/global-skills as a plugin
     // and are attached to every turn — global instead of per-project.
     try {
-      const gsDir = process.env.CLAUDE_BRIDGE_GLOBAL_SKILLS_DIR ||
-                    path.join(dataDir(), "global-skills");
+      const gsDir = globalSkillsDir();
       if (fs.existsSync(path.join(gsDir, "skills"))) args.push("--plugin-dir", gsDir);
     } catch {}
     // Optional model override from the extension's model picker (alias or id).
@@ -1200,6 +1209,129 @@ function startBridge(config) {
     }
 
     // ChatGPT bindings
+    // ── /skills — global-skills CRUD, per machine ────────────────────────────
+    // The extension's "/" autocomplete and Skills tab call this on whichever
+    // machine is active. Without it the request 404s, the host list comes back
+    // empty, and the menu silently shows ONLY the CLI built-ins — which reads
+    // as "this machine has no skills". Mirrors the Python bridge's contract.
+    // ── /mcp — configured MCP servers for THIS machine ───────────────────────
+    // Config read is instant; ?health=1 shells out to `claude mcp list`, which
+    // actually connects to each server (seconds), so it's cached — but it's the
+    // only way to distinguish Connected from needs-authentication.
+    if (url.pathname === "/mcp") {
+      const servers = {};
+      const bases = new Set([process.env.CLAUDE_CONFIG_DIR || homeDir(), homeDir()]);
+      for (const base of bases) {
+        let cfg; try { cfg = JSON.parse(fs.readFileSync(path.join(base, ".claude.json"), "utf8")); }
+        catch { continue; }
+        for (const [n, spec] of Object.entries(cfg.mcpServers || {}))
+          if (!(n in servers)) servers[n] = spec || {};
+        for (const proj of Object.values(cfg.projects || {}))
+          for (const [n, spec] of Object.entries((proj && proj.mcpServers) || {}))
+            if (!(n in servers)) servers[n] = spec || {};
+      }
+      const out = Object.keys(servers).sort().map((n) => ({
+        name: n,
+        transport: servers[n].type || (servers[n].url ? "http" : "stdio"),
+        target: servers[n].url || servers[n].command || "",
+      }));
+      const want = url.searchParams.get("health");
+      if (out.length && want && want !== "0" && want !== "false") {
+        const now = Date.now();
+        if (now - mcpHealth.at > 120000) {
+          const states = {};
+          try {
+            const p = execSync(`${JSON.stringify(config.claudeBin)} mcp list`,
+                               { encoding: "utf8", timeout: 60000, stdio: ["ignore", "pipe", "pipe"] });
+            for (const line of String(p).split("\n")) {
+              const m = /^\s*([A-Za-z0-9._-]+):\s*(.*?)\s*-\s*(.+?)\s*$/.exec(line);
+              if (m) states[m[1]] = m[3].replace(/[✔⚠○⏸]/g, "").trim();
+            }
+          } catch {}
+          mcpHealth = { at: now, data: states };
+        }
+        for (const s of out) s.state = mcpHealth.data[s.name];
+      }
+      send(200, { servers: out });
+      return;
+    }
+
+    if (url.pathname === "/skills" || url.pathname.startsWith("/skills/")) {
+      const skillsRoot = path.join(globalSkillsDir(), "skills");
+      const nameOf = decodeURIComponent(url.pathname.slice("/skills/".length) || "");
+      const validName = (n) => /^[a-z0-9][a-z0-9-]{0,63}$/.test(n);
+      const fileOf = (n) => path.join(skillsRoot, n, "SKILL.md");
+
+      if (req.method === "GET" && url.pathname === "/skills") {
+        const out = [];
+        let entries = [];
+        try { entries = fs.readdirSync(skillsRoot); } catch {}
+        for (const n of entries.sort()) {
+          const f = fileOf(n);
+          let md; try { md = fs.readFileSync(f, "utf8"); } catch { continue; }
+          const fm = /^---\s*\n([\s\S]*?)\n---\s*\n/.exec(md);
+          const desc = fm ? (/^description:\s*(.+)$/m.exec(fm[1]) || [])[1] : "";
+          let readonly = false;
+          try { readonly = fs.lstatSync(path.join(skillsRoot, n)).isSymbolicLink(); } catch {}
+          out.push({ name: n, description: (desc || "").trim().replace(/^["']|["']$/g, ""),
+                     size: md.length, readonly });
+        }
+        send(200, { skills: out, dir: skillsRoot });
+        return;
+      }
+      if (!validName(nameOf)) { send(404, { error: "no such skill" }); return; }
+      if (req.method === "GET") {
+        try {
+          const md = fs.readFileSync(fileOf(nameOf), "utf8");
+          let readonly = false;
+          try { readonly = fs.lstatSync(path.join(skillsRoot, nameOf)).isSymbolicLink(); } catch {}
+          send(200, { name: nameOf, content: md, readonly });
+        } catch { send(404, { error: "no such skill: " + nameOf }); }
+        return;
+      }
+      if (req.method === "POST") {
+        const body = await readBody(req);
+        const content = body && body.content;
+        if (typeof content !== "string" || !content.trim()) {
+          send(400, { error: "content is required" }); return;
+        }
+        const fm = /^---\s*\n([\s\S]*?)\n---\s*\n/.exec(content);
+        if (!fm || !/^description:\s*\S/m.test(fm[1])) {
+          send(400, { error: "SKILL.md must start with '---' frontmatter containing "
+                             + "name: and description: lines — description is what "
+                             + "makes Claude auto-select the skill" });
+          return;
+        }
+        const dir = path.join(skillsRoot, nameOf);
+        try {
+          if (fs.existsSync(dir) && fs.lstatSync(dir).isSymbolicLink()) {
+            send(400, { error: `'${nameOf}' is repo-owned (symlink) — edit it in its repo` });
+            return;
+          }
+          fs.mkdirSync(dir, { recursive: true });
+          const tmp = path.join(dir, ".SKILL.md.tmp");
+          fs.writeFileSync(tmp, content);
+          fs.renameSync(tmp, fileOf(nameOf));
+          send(200, { ok: true, name: nameOf });
+        } catch (e) { send(500, { error: "write failed: " + e.message }); }
+        return;
+      }
+      if (req.method === "DELETE") {
+        const dir = path.join(skillsRoot, nameOf);
+        try {
+          if (fs.lstatSync(dir).isSymbolicLink()) {
+            fs.unlinkSync(dir);                       // detach only; repo copy survives
+            send(200, { ok: true, name: nameOf, detached_symlink: true }); return;
+          }
+          fs.rmSync(dir, { recursive: true });
+          send(200, { ok: true, name: nameOf });
+        } catch { send(404, { error: "no such skill: " + nameOf }); }
+        return;
+      }
+      send(405, { error: "method not allowed" });
+      return;
+    }
+
     if (url.pathname === "/chatgpt-bindings") {
       const bindingsFile = path.join(dd, "bindings.json");
       if (req.method === "GET") {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-bridge-cli",
-  "version": "2.0.23",
+  "version": "2.0.25",
   "description": "Use Claude Code from your browser. Runs a local server that connects your browser tools to the Claude CLI.",
   "main": "lib/bridge.js",
   "bin": {