beecork 2.7.1 → 2.8.0

package/dist/index.js

@@ -1296,7 +1296,8 @@ function killAllTasks() {
 
 // src/skills.ts
 import { readdir, readFile as readFile2 } from "node:fs/promises";
-import { join as join2 } from "node:path";
+import { join as join2, dirname as dirname2 } from "node:path";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
 import { homedir as homedir3 } from "node:os";
 function parseSkill(raw) {
   let body = raw;
@@ -1331,9 +1332,11 @@ function getSkill(name) {
 }
 async function loadSkills() {
   registry.clear();
+  const bundledDir = join2(dirname2(fileURLToPath2(import.meta.url)), "..", "skills");
   const dirs = [
     [join2(homedir3(), ".beecork", "skills"), "global"],
-    [join2(process.cwd(), ".beecork", "skills"), "project"]
+    [join2(process.cwd(), ".beecork", "skills"), "project"],
+    [bundledDir, "bundled"]
   ];
   for (const [dir, source] of dirs) {
     let entries;
@@ -1346,13 +1349,13 @@ async function loadSkills() {
       if (!e.isFile() || !e.name.endsWith(".md")) continue;
       const name = e.name.slice(0, -3);
       if (!/^[a-z0-9][a-z0-9_-]*$/i.test(name)) continue;
+      if (registry.has(name)) {
+        if (source === "project") console.error(color.yellow(`\u26A0 project skill /${name} ignored \u2014 a global skill of that name takes precedence`));
+        continue;
+      }
       try {
         const raw = (await readFile2(join2(dir, e.name), "utf8")).trim();
         if (!raw) continue;
-        if (source === "project" && registry.has(name)) {
-          console.error(color.yellow(`\u26A0 project skill /${name} ignored \u2014 a global skill of that name takes precedence`));
-          continue;
-        }
         const { description, modelInvocable, body } = parseSkill(raw);
         registry.set(name, { name, content: body, description, modelInvocable, path: join2(dir, e.name), source });
       } catch {
@@ -1991,6 +1994,16 @@ async function readLineWindow(abs, offset1, limit) {
   }
   return { lines, startLine: start + 1, hasMore, empty: i === 0 };
 }
+var DEV_SIGNALS_SETUP = `The browser link isn't connected yet (nothing is responding on localhost:8317).
+
+This is "Beecork Skeleton" \u2014 a Chrome extension that sends the app's console errors and failed network requests to me, so I can see what the browser sees instead of guessing. One-time, local-only setup (no account, no signup).
+
+Walk the user through connecting it:
+1. Start the local inbox: run \`node bridge/server.mjs\` in the beecork-extension folder, and leave it running.
+2. Load the extension: Chrome \u2192 chrome://extensions \u2192 turn on "Developer mode" \u2192 "Load unpacked" \u2192 select the beecork-extension/extension folder. Pin the icon.
+3. Click the icon (it auto-connects), tick "Capture enabled", open the app in a tab, and click "Pair this site".
+
+Then call read_dev_signals again. Full step-by-step + troubleshooting is in the "browser-signals" skill.`;
 var toolDefs = [
   {
     name: "read_file",
@@ -2496,6 +2509,85 @@ ${skill.content}`;
       }
       return `No interactive user is available (headless run). Proceed with the most reasonable option for "${question}" and state the assumption you made.`;
     }
+  },
+  {
+    name: "read_dev_signals",
+    description: "Read the browser's recent console errors and failed network requests for the user's app (localhost or production), captured live by the Beecork Skeleton extension \u2014 so you can SEE what's actually happening instead of guessing. Call this whenever the user reports a bug a browser would surface (blank page, broken button, failed save, a 500, a visual glitch). If it isn't connected yet it returns setup steps to relay to the user. Pull on demand; don't spam it.",
+    parameters: {
+      type: "object",
+      properties: {
+        kind: { type: "string", description: 'Filter: "network", "console", "pageError", "log", or "all" (default all).' },
+        since_minutes: { type: "number", description: "Only signals from the last N minutes (optional)." },
+        limit: { type: "number", description: "Max signals to return (default 30, max 200)." }
+      },
+      required: []
+    },
+    run: async (args, signal) => {
+      const base = process.env.BEECORK_DEV_SIGNALS_URL || "http://localhost:8317";
+      const kind = args.kind ? String(args.kind) : "";
+      const limit = Math.min(Math.max(Number(args.limit) || 30, 1), 200);
+      const sinceMin = Number(args.since_minutes) || 0;
+      const params = new URLSearchParams({ limit: String(limit) });
+      if (kind && kind !== "all") params.set("kind", kind);
+      if (sinceMin > 0) params.set("since", String(Date.now() - sinceMin * 6e4));
+      const timeout = AbortSignal.timeout(Math.min(config.webTimeoutMs, 5e3));
+      let data;
+      try {
+        const res = await fetch(`${base}/signals?${params}`, { signal: signal ? AbortSignal.any([signal, timeout]) : timeout });
+        if (!res.ok) return `The browser link responded with HTTP ${res.status}. The bridge may be unhealthy \u2014 try restarting it (node bridge/server.mjs).`;
+        data = await res.json();
+      } catch {
+        return DEV_SIGNALS_SETUP;
+      }
+      const now = Date.now();
+      const signals = (data.signals ?? []).filter((s) => s && s.kind !== "watch");
+      if (signals.length === 0) {
+        return `The browser link is connected, but no ${kind && kind !== "all" ? `"${kind}" ` : ""}signals were captured${sinceMin ? ` in the last ${sinceMin} min` : ""}. The watched tab just hasn't hit the error yet \u2014 reproduce the issue in the browser (or open the app), then call this again.`;
+      }
+      const ago2 = (ts) => ts ? `${Math.max(0, Math.round((now - ts) / 1e3))}s ago` : "";
+      const lines = signals.map((s) => {
+        if (s.kind === "network") return `[network] ${s.method || "GET"} ${s.url ?? ""} \u2192 ${s.status || s.text || "failed"}  (${ago2(s.ts)})`;
+        const text = String(s.text ?? "").replace(/\s+/g, " ").slice(0, 300);
+        return `[${s.kind}] ${text}${s.url ? `  @ ${s.url}` : ""}  (${ago2(s.ts)})`;
+      });
+      return `${signals.length} browser signal(s), newest last:
+${lines.join("\n")}`;
+    }
+  },
+  {
+    name: "watch_site",
+    description: "Ask the Beecork Skeleton extension to start watching an APPROVED site's tab right now \u2014 use for an on-demand or production site you need to investigate (localhost/dev sites are watched automatically, so you don't need this for them). Only sites the user already approved are honored. After calling this, reproduce the issue (or open the site), then read_dev_signals.",
+    parameters: {
+      type: "object",
+      properties: {
+        url: { type: "string", description: "The site to watch, e.g. https://app.example.com (its origin is used)." },
+        minutes: { type: "number", description: "How long to keep watching (default 10, max 120)." }
+      },
+      required: ["url"]
+    },
+    run: async (args, signal) => {
+      const base = process.env.BEECORK_DEV_SIGNALS_URL || "http://localhost:8317";
+      let origin;
+      try {
+        origin = new URL(String(args.url ?? "")).origin;
+      } catch {
+        return `Error: "${args.url}" is not a valid URL.`;
+      }
+      const minutes = Math.min(Math.max(Number(args.minutes) || 10, 1), 120);
+      const timeout = AbortSignal.timeout(Math.min(config.webTimeoutMs, 5e3));
+      try {
+        const res = await fetch(`${base}/request-watch`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ origin, ttlMs: minutes * 6e4 }),
+          signal: signal ? AbortSignal.any([signal, timeout]) : timeout
+        });
+        if (!res.ok) return `The browser link responded with HTTP ${res.status}.`;
+      } catch {
+        return DEV_SIGNALS_SETUP;
+      }
+      return `Requested watching ${origin} for ${minutes} min. If the user has approved that site in the extension, it will start capturing shortly \u2014 have them reproduce the issue in a tab on ${origin} (or open it), then call read_dev_signals. If nothing shows up, the site isn't approved yet: ask the user to open it and click "Pair this site" in the Beecork Skeleton popup.`;
+    }
   }
 ];
 var TOOLS = toolDefs.map((t) => ({
@@ -2861,15 +2953,15 @@ ${summary}` }, ...recent];
 // src/memory.ts
 import { readFile as readFile4, writeFile as writeFile3, readdir as readdir3, mkdir as mkdir3, chmod as chmod2, rename as rename2, unlink } from "node:fs/promises";
 import { homedir as homedir5 } from "node:os";
-import { join as join4, dirname as dirname2 } from "node:path";
+import { join as join4, dirname as dirname3 } from "node:path";
 var BEECORK = ".beecork";
 function ancestorDirs() {
   const home = homedir5();
   const dirs = [];
   let dir = process.cwd();
-  while (dir !== home && dir !== dirname2(dir)) {
+  while (dir !== home && dir !== dirname3(dir)) {
     dirs.push(dir);
-    dir = dirname2(dir);
+    dir = dirname3(dir);
   }
   return dirs.reverse();
 }
@@ -2944,7 +3036,7 @@ async function loadUserConfig() {
 }
 async function saveUserConfig(patch) {
   const file = userConfigPath();
-  await mkdir3(dirname2(file), { recursive: true });
+  await mkdir3(dirname3(file), { recursive: true });
   const merged = { ...await loadUserConfig(), ...patch };
   const tmp = `${file}.tmp`;
   await writeFile3(tmp, JSON.stringify(merged, null, 2), { encoding: "utf8", mode: 384 });
@@ -2955,7 +3047,7 @@ async function saveUserConfig(patch) {
 async function saveModelPreference(model) {
   try {
     const file = join4(homedir5(), BEECORK, "settings.json");
-    await mkdir3(dirname2(file), { recursive: true });
+    await mkdir3(dirname3(file), { recursive: true });
     const current = await readJsonFile(file) ?? {};
     await writeFile3(file, JSON.stringify({ ...current, model }, null, 2), "utf8");
   } catch {
@@ -2964,7 +3056,7 @@ async function saveModelPreference(model) {
 async function saveReasoningPreference(reasoningEffort) {
   try {
     const file = join4(homedir5(), BEECORK, "settings.json");
-    await mkdir3(dirname2(file), { recursive: true });
+    await mkdir3(dirname3(file), { recursive: true });
     const current = await readJsonFile(file) ?? {};
     await writeFile3(file, JSON.stringify({ ...current, reasoningEffort }, null, 2), "utf8");
   } catch {
@@ -3080,7 +3172,7 @@ async function loadProjectApprovals() {
 async function addProjectApproval(tool) {
   try {
     const file = projectApprovalsPath();
-    await mkdir3(dirname2(file), { recursive: true });
+    await mkdir3(dirname3(file), { recursive: true });
     const all = await readJsonFile(file) ?? {};
     const list = new Set(Array.isArray(all[projectRoot]) ? all[projectRoot] : []);
     list.add(tool);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "beecork",
-  "version": "2.7.1",
+  "version": "2.8.0",
   "description": "beecork — a from-scratch CLI coding agent: multi-model (OpenRouter), BYOK, path-confined tools, built part by part.",
   "type": "module",
   "bin": {
@@ -8,7 +8,8 @@
   },
   "main": "dist/index.js",
   "files": [
-    "dist/"
+    "dist/",
+    "skills/"
   ],
   "engines": {
     "node": ">=20.12"

package/skills/browser-signals.md

@@ -0,0 +1,59 @@
+---
+description: Set up / use the browser link so beecork sees the app's console + network errors (read_dev_signals)
+---
+
+# Browser signals — let beecork see the running app
+
+You can read the user's app **console errors** and **failed network requests** straight
+from the browser — on localhost *or* production, in their real logged-in session — with the
+`read_dev_signals` tool. No copy-pasting errors. This is the **Beecork Skeleton** Chrome
+extension plus a tiny local inbox (the "bridge").
+
+## When to use `read_dev_signals`
+
+Call it whenever the user reports something a browser would surface — a blank page, a broken
+button, a form that won't submit, a save that 500s, a visual glitch. Instead of guessing, pull
+the real errors:
+
+- `read_dev_signals({ kind: "network" })` — failed requests (status ≥ 400 / network failures)
+- `read_dev_signals({ since_minutes: 5 })` — everything captured in the last 5 minutes
+- `read_dev_signals({})` — the most recent signals of any kind
+
+Pull it **on demand** while debugging — don't call it in a loop or on every turn.
+
+## Watching an on-demand / production site
+
+Localhost/dev sites the user approved are watched automatically. A **production** (or
+any "on-demand") approved site is idle until asked. To investigate one, call
+`watch_site({ url })` — it asks the extension to watch that site for a while. Only sites
+the user already approved are honored (beecork can't start watching a brand-new site on
+its own). Then have the user reproduce the issue (or open the site) and call
+`read_dev_signals`.
+
+## If it says "not connected" — one-time setup
+
+The tool returns setup steps when the bridge isn't running. Relay them to the user:
+
+1. **Start the local inbox (bridge):** run `node bridge/server.mjs` in the `beecork-extension`
+   folder and leave it running. It listens on `localhost:8317`.
+2. **Load the extension:** Chrome → `chrome://extensions` → enable **Developer mode** →
+   **Load unpacked** → select the `beecork-extension/extension` folder → pin the icon.
+3. **Connect + approve:** click the icon (it auto-connects — no token to paste), tick
+   **Capture enabled**, open the app in a tab, and click **Pair this site**.
+
+Then call `read_dev_signals` again.
+
+## Empty result
+
+If it connects but returns nothing, the watched tab just hasn't hit the error yet. Either ask
+the user to reproduce it, or open the app yourself to trigger it — e.g.
+`open -a "Google Chrome" http://localhost:3000` (macOS) — then reproduce the action and call
+`read_dev_signals` again.
+
+## How it stays safe
+
+- **Approved sites only** — nothing is watched except sites the user approved in the popup.
+- **Secrets redacted in the browser** — tokens, API keys, passwords, and Authorization values
+  are stripped *before* any signal leaves the tab, so they never reach the inbox.
+- **Local + authenticated** — the inbox is `127.0.0.1` only, and only the extension can write to
+  it (an automatic local token; a web page you visit cannot).