@lovrozagar/grunt 0.5.2 → 0.6.1

package/scripts/browser.mjs

@@ -1,12 +1,13 @@
 #!/usr/bin/env node
-/** Session browser rail: nav|snap|click|fill|shot|pdf|stop|doctor|ensure. Lightpanda default. */
-import { spawn } from "node:child_process";
+/** Session browser rail: nav|snap|click|fill|scroll|wait|hover|select|shot|pdf|stop|doctor|ensure. Lightpanda default. */
+import { spawn, spawnSync } from "node:child_process";
 import crypto from "node:crypto";
 import fs from "node:fs";
 import http from "node:http";
 import net from "node:net";
 import path from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
+import { writeStash } from "./grunt-job.mjs";
 import {
   CHROMIUM_BINS,
   LIGHTPANDA_REPO as DOCTOR_LP_REPO,
@@ -64,9 +65,21 @@ export function isPaintHost(url) {
   if ((h === "google.com" || h.endsWith(".google.com")) && u.pathname.startsWith("/earth")) {
     return true;
   }
+  if (/(^|\.)amazon\./.test(h)) return true;
   return false;
 }
 
+const BLOCKED_SNAP_RE =
+  /enable javascript|javascript (is )?(required|disabled)|checking your browser|just a moment|captcha|access denied|sorry.*robot|continue shopping|attention required|cf-browser-verification|verify you are a human/i;
+
+export function isBlockedSnap(markdown, lines) {
+  const refs = Array.isArray(lines) ? lines.length : 0;
+  const md = String(markdown || "").trim();
+  if (BLOCKED_SNAP_RE.test(md)) return true;
+  const body = md.replace(/^#\s+\S+\s*$/m, "").trim();
+  return refs === 0 && body.length < 80;
+}
+
 export function lookupBins(pathEnv, platform = process.platform) {
   const lightpanda = whichBin("lightpanda", pathEnv, platform);
   let chromium = "";
@@ -124,6 +137,21 @@ function alive(pid) {
 
 function reap(pid) {
   if (!pid) return;
+  if (process.platform === "win32") {
+    try {
+      process.kill(pid);
+    } catch {
+      /* ignore */
+    }
+    if (alive(pid)) {
+      spawnSync("taskkill", ["/PID", String(pid), "/T", "/F"], {
+        stdio: "ignore",
+        timeout: 1500,
+        windowsHide: true,
+      });
+    }
+    return;
+  }
   try {
     process.kill(-pid, "SIGTERM");
   } catch {
@@ -348,8 +376,10 @@ async function handleCdp(state, method, params = {}) {
       state.markdown = `# ${state.url}\n\nhello`;
       return { frameId: "f1" };
     case "LP.getMarkdown":
+      if (state.thinSnap) return { markdown: `# ${state.url || ""}\n` };
       return { markdown: state.markdown || `# ${state.url || ""}\n\nhello` };
     case "Accessibility.getFullAXTree":
+      if (state.thinSnap) return { nodes: [] };
       return { nodes: state.axNodes || defaultAx(state.url) };
     case "DOM.resolveNode": {
       const id = params.backendNodeId;
@@ -378,6 +408,7 @@ export async function serveCdp(state = {}, { port = 0 } = {}) {
     url: "about:blank",
     markdown: "",
     failProbe: false,
+    thinSnap: false,
     engine: "lightpanda",
     ...state,
   };
@@ -464,6 +495,19 @@ function engineBin(engine, bins) {
   return bins.chromium;
 }
 
+function spawnEngine(bin, args, opts) {
+  if (process.platform === "win32" && /\.(cmd|bat)$/i.test(bin)) {
+    const mjs = `${String(bin).replace(/\.(cmd|bat)$/i, "")}.mjs`;
+    try {
+      fs.accessSync(mjs, fs.constants.F_OK);
+      return spawn(process.execPath, [mjs, ...args], opts);
+    } catch {
+      return spawn(bin, args, { ...opts, shell: true });
+    }
+  }
+  return spawn(bin, args, opts);
+}
+
 function spawnArgs(engine, port, profile) {
   if (engine === "lightpanda") return ["serve", "--host", "127.0.0.1", "--port", String(port)];
   return [
@@ -485,7 +529,7 @@ async function launchEngine(engine, ctx) {
   const profile = path.join(dir, "profile");
   fs.mkdirSync(profile, { recursive: true });
   const port = await freePort();
-  const child = spawn(bin, spawnArgs(engine, port, profile), {
+  const child = spawnEngine(bin, spawnArgs(engine, port, profile), {
     detached: true,
     stdio: ["ignore", "pipe", "pipe"],
     env: ctx.env,
@@ -606,7 +650,7 @@ export async function runBrowser(argv, opts = {}) {
   const verb = String(argv[0] || "").toLowerCase();
   try {
     if (!verb || verb === "help" || verb === "-h" || verb === "--help") {
-      return ok("nav|snap|click|fill|shot|pdf|stop|doctor|ensure");
+      return ok("nav|snap|click|fill|scroll|wait|hover|select|shot|pdf|stop|doctor|ensure");
     }
     if (verb === "doctor" || verb === "ensure") {
       return runDoctor({ pathEnv: env.PATH, platform, cwd });
@@ -650,16 +694,79 @@ export async function runBrowser(argv, opts = {}) {
       return ok(`engine: ${session.engine}\nurl: ${session.lastURL}`);
     }
     if (verb === "snap") {
-      const session = readSession(cwd);
+      let session = readSession(cwd);
       if (!session || !alive(session.pid)) return fail("no browser session; run nav");
-      const { markdown, lines } = await snapshot(session);
+      let { markdown, lines } = await snapshot(session);
+      if (
+        session.engine === "lightpanda" &&
+        (session.swapCount || 0) < 1 &&
+        bins.chromium &&
+        isBlockedSnap(markdown, lines)
+      ) {
+        session = await swapToChromium(session, ctx);
+        ({ markdown, lines } = await snapshot(session));
+      }
       writeSession(cwd, session);
+      const raw = [markdown.trim(), "", ...lines].join("\n");
+      const headings = String(markdown || "")
+        .split(/\n/)
+        .filter((l) => /^#{1,6}\s/.test(l));
+      const shown = [...headings.slice(0, 6), ...lines.slice(0, 24)];
+      if (raw.length > 32 * 1024 || lines.length > 6) {
+        const stash = writeStash(cwd, "snap", raw);
+        return ok(
+          `engine: ${session.engine}\nurl: ${session.lastURL}\n${shown.length} shown. stash=${stash}\n${shown.join("\n")}`,
+        );
+      }
       const body = [markdown.trim(), "", ...lines].filter((x, i, a) => x !== "" || a[i - 1] !== "").join("\n");
       return ok(`engine: ${session.engine}\nurl: ${session.lastURL}\n\n${body}`);
     }
-    if (verb === "click" || verb === "fill") {
+    if (verb === "wait") {
       const session = readSession(cwd);
       if (!session || !alive(session.pid)) return fail("no browser session; run nav");
+      const raw = String(argv[1] || "1000");
+      const ms = Math.min(15000, Math.max(0, Number(raw) || 0));
+      await sleep(ms);
+      return ok(`wait: ${ms}`);
+    }
+    if (verb === "scroll") {
+      let session = readSession(cwd);
+      if (!session || !alive(session.pid)) return fail("no browser session; run nav");
+      const arg = String(argv[1] || "down");
+      const refs = session.lastRefs || {};
+      const rec = refs[arg];
+      const act = async (sess) =>
+        withCdp(sess, async (cdp) => {
+          if (rec) {
+            const resolved = await cdp.send("DOM.resolveNode", { backendNodeId: rec.backendNodeId });
+            const objectId = resolved.object && resolved.object.objectId;
+            if (!objectId) throw new Error("stale");
+            await cdp.send("Runtime.callFunctionOn", {
+              objectId,
+              functionDeclaration: "function() { this.scrollIntoView({ block: 'center' }); }",
+            });
+            return;
+          }
+          let dy = 600;
+          if (arg === "up") dy = -600;
+          else if (/^-?\d+$/.test(arg)) dy = Number(arg);
+          await cdp.send("Runtime.evaluate", {
+            expression: `window.scrollBy(0, ${dy})`,
+          });
+        });
+      try {
+        await act(session);
+      } catch (err) {
+        const msg = String(err && err.message ? err.message : err);
+        if (/stale|missing/i.test(msg)) return fail(`stale ref: ${arg}`);
+        return fail(msg);
+      }
+      writeSession(cwd, session);
+      return ok(`scroll: ${arg}`);
+    }
+    if (verb === "click" || verb === "fill" || verb === "hover" || verb === "select") {
+      let session = readSession(cwd);
+      if (!session || !alive(session.pid)) return fail("no browser session; run nav");
       const refs = session.lastRefs || {};
       if (!Object.keys(refs).length) return fail("no snap refs; run snap");
       const refId = String(argv[1] || "");
@@ -667,6 +774,7 @@ export async function runBrowser(argv, opts = {}) {
       if (!rec) return fail(`missing ref: ${refId}`);
       const text = argv.slice(2).join(" ");
       if (verb === "fill" && !text) return fail("fill <ref> <text>");
+      if (verb === "select" && !text) return fail("select <ref> <value>");
       const act = async (sess) =>
         withCdp(sess, async (cdp) => {
           const resolved = await cdp.send("DOM.resolveNode", { backendNodeId: rec.backendNodeId });
@@ -677,6 +785,19 @@ export async function runBrowser(argv, opts = {}) {
               objectId,
               functionDeclaration: "function() { this.click(); }",
             });
+          } else if (verb === "hover") {
+            await cdp.send("Runtime.callFunctionOn", {
+              objectId,
+              functionDeclaration:
+                "function() { this.dispatchEvent(new MouseEvent('mouseover', { bubbles: true })); }",
+            });
+          } else if (verb === "select") {
+            await cdp.send("Runtime.callFunctionOn", {
+              objectId,
+              arguments: [{ value: text }],
+              functionDeclaration:
+                "function(v) { this.value = v; this.dispatchEvent(new Event('change', { bubbles: true })); }",
+            });
           } else {
             await cdp.send("Runtime.callFunctionOn", {
               objectId,

package/scripts/doctor.mjs

@@ -2,6 +2,7 @@
 /** Unified prereq doctor. Print-only install hints. Never runs installs. */
 import { execFileSync } from "node:child_process";
 import fs from "node:fs";
+import os from "node:os";
 import path from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import {
@@ -41,20 +42,32 @@ export function nodeMajor(version) {
   return m ? Number(m[1]) : 0;
 }
 
+function winShim(bin) {
+  return process.platform === "win32" && /\.(cmd|bat)$/i.test(String(bin || ""));
+}
+
 export function whichBin(name, pathEnv = process.env.PATH, platform = process.platform) {
   if (!name) return "";
+  const hostWin = process.platform === "win32";
   const delim =
-    platform === "win32" && String(pathEnv || "").includes(";") ? ";" : path.delimiter;
+    (platform === "win32" || hostWin) && String(pathEnv || "").includes(";")
+      ? ";"
+      : path.delimiter;
   const dirs = String(pathEnv || "").split(delim);
-  const names = [name];
-  if (platform === "win32" && !path.extname(name)) {
-    const pathext = String(process.env.PATHEXT || ".EXE;.CMD;.BAT;.COM");
-    for (const raw of pathext.split(";")) {
-      if (!raw) continue;
-      names.push(name + raw);
-      names.push(name + raw.toLowerCase());
+  const names = [];
+  if ((hostWin || platform === "win32") && !path.extname(name)) {
+    if (hostWin) {
+      const pathext = String(process.env.PATHEXT || ".EXE;.CMD;.BAT;.COM");
+      for (const raw of pathext.split(";")) {
+        if (!raw) continue;
+        names.push(name + raw.toLowerCase());
+        names.push(name + raw);
+      }
     }
     names.push(`${name}.exe`);
+    names.push(name);
+  } else {
+    names.push(name);
   }
   const uniq = [...new Set(names)];
   for (const dir of dirs) {
@@ -65,7 +78,7 @@ export function whichBin(name, pathEnv = process.env.PATH, platform = process.pl
         fs.accessSync(candidate, fs.constants.X_OK);
         return candidate;
       } catch {
-        if (platform === "win32") {
+        if (hostWin) {
           try {
             fs.accessSync(candidate, fs.constants.F_OK);
             return candidate;
@@ -96,6 +109,7 @@ function readNodeVersion(bin) {
         encoding: "utf8",
         timeout: 8000,
         stdio: ["ignore", "pipe", "pipe"],
+        shell: winShim(bin),
       }),
     ).trim();
   } catch {
@@ -166,11 +180,72 @@ export function installHints(id, platform = process.platform) {
     }
     return ["sudo apt install chromium"];
   }
+  if (id === "ffmpeg") {
+    if (platform === "win32") return ["winget install Gyan.FFmpeg"];
+    if (platform === "darwin") return ["brew install ffmpeg"];
+    return ["sudo apt install ffmpeg"];
+  }
+  if (id === "whisper-cli") {
+    if (platform === "win32") {
+      return ["whisper.cpp release: whisper-cli.exe on PATH", "https://github.com/ggml-org/whisper.cpp"];
+    }
+    if (platform === "darwin") return ["brew install whisper-cpp"];
+    return ["https://github.com/ggml-org/whisper.cpp"];
+  }
   return [];
 }
 
+function isFile(abs) {
+  try {
+    return fs.statSync(abs).isFile();
+  } catch {
+    return false;
+  }
+}
+
+export function speakDoctorStatus({ env = process.env, home = os.homedir() } = {}) {
+  const names = [];
+  if (String(env.ELEVENLABS_API_KEY || "").trim()) names.push("elevenlabs");
+  if (String(env.OPENAI_API_KEY || "").trim()) names.push("openai");
+  const hasFile = isFile(path.join(home, ".grunt", "speak.json"));
+  if (!names.length && !hasFile) return { ok: false, extra: "" };
+  return { ok: true, extra: names.length ? names.join(",") : "config" };
+}
+
+const WORKSPACE_ACCOUNT_RE = /^[a-zA-Z0-9_-]{1,40}$/;
+const WORKSPACE_KIND_ORDER = ["oauth", "tokens", "adc", "clasprc"];
+
+export function workspaceDoctorStatus({ home = os.homedir() } = {}) {
+  const grunt = path.join(home, ".grunt");
+  const kinds = new Set();
+  const scanAccountDir = (dir) => {
+    if (isFile(path.join(dir, "google-oauth.json"))) kinds.add("oauth");
+    if (isFile(path.join(dir, "tokens.json"))) kinds.add("tokens");
+  };
+  if (isFile(path.join(grunt, "google-oauth.json"))) kinds.add("oauth");
+  if (isFile(path.join(grunt, "workspace-tokens.json"))) kinds.add("tokens");
+  scanAccountDir(path.join(grunt, "workspace", "default"));
+  const root = path.join(grunt, "workspace");
+  try {
+    for (const ent of fs.readdirSync(root, { withFileTypes: true })) {
+      if (!ent.isDirectory() || !WORKSPACE_ACCOUNT_RE.test(ent.name)) continue;
+      scanAccountDir(path.join(root, ent.name));
+    }
+  } catch {
+    /* none */
+  }
+  if (
+    isFile(path.join(home, ".config", "gcloud", "application_default_credentials.json"))
+  ) {
+    kinds.add("adc");
+  }
+  if (isFile(path.join(home, ".clasprc.json"))) kinds.add("clasprc");
+  if (!kinds.size) return { ok: false, extra: "" };
+  return { ok: true, extra: WORKSPACE_KIND_ORDER.filter((k) => kinds.has(k)).join(",") };
+}
+
 function row(name, status, extra = "") {
-  const a = String(name).padEnd(14);
+  const a = String(name).padEnd(18);
   const b = String(status).padEnd(18);
   const c = extra ? String(extra).trim() : "";
   return c ? `${a} ${b} ${c}` : `${a} ${b}`;
@@ -205,6 +280,8 @@ export function runDoctor({
   platform = process.platform,
   execPath = process.execPath,
   nodeVersion = process.version,
+  env = process.env,
+  home = os.homedir(),
 } = {}) {
   const nmPath = withNmBin(cwd, pathEnv, platform);
   const pathNode = whichBin("node", pathEnv, platform);
@@ -226,6 +303,10 @@ export function runDoctor({
   const lightpanda = whichBin("lightpanda", pathEnv, platform);
   const chromium = lookupChromium(pathEnv, platform);
   const gh = whichBin("gh", pathEnv, platform);
+  const clasp = whichBin("clasp", pathEnv, platform);
+  const ffmpeg = whichBin("ffmpeg", pathEnv, platform);
+  const whisperCli =
+    whichBin("whisper-cli", pathEnv, platform) || whichBin("whisper-cpp", pathEnv, platform);
 
   const found = {
     node: nodeOk ? nodeBin : "",
@@ -252,6 +333,19 @@ export function runDoctor({
   lines.push(lightpanda ? row("lightpanda", "ok", lightpanda) : row("lightpanda", "missing"));
   lines.push(chromium ? row("chromium", "ok", chromium) : row("chromium", "missing"));
   lines.push(gh ? row("gh", "ok", gh) : row("gh", "missing (optional)"));
+  lines.push(clasp ? row("clasp", "ok", clasp) : row("clasp", "missing (optional)"));
+  const workspace = workspaceDoctorStatus({ home });
+  lines.push(
+    workspace.ok
+      ? row("google-workspace", "ok", workspace.extra)
+      : row("google-workspace", "missing (optional)"),
+  );
+  lines.push(ffmpeg ? row("ffmpeg", "ok", ffmpeg) : row("ffmpeg", "missing (optional)"));
+  lines.push(
+    whisperCli ? row("whisper-cli", "ok", whisperCli) : row("whisper-cli", "missing (optional)"),
+  );
+  const speak = speakDoctorStatus({ env, home });
+  lines.push(speak.ok ? row("speak", "ok", speak.extra) : row("speak", "missing (optional)"));
 
   const missingRequired = REQUIRED.filter((k) => (k === "node" ? !nodeOk : !found[k]));
   if (missingRequired.length) {

package/scripts/emit-gemini.mjs

@@ -3,9 +3,9 @@
 import fs from "node:fs";
 import path from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
-import { guardedMarkdownDrift, writeMergedGuardedFile } from "../cli/init.mjs";
+import { guardedMarkdownDrift, writeMergedGuardedFile } from "./guarded-md.mjs";
 
-export const AGENT_IDS = ["orchestrator", "implementer", "thinker", "grunt"];
+export const AGENT_IDS = ["orchestrator", "grunt"];
 const SSOT_REL = ".rulesync/subagents";
 const GEMINI_MD_REL = "GEMINI.md";
 const AGENTS_REL = ".gemini/agents";

package/scripts/emit-mcp-policy.mjs

@@ -12,7 +12,7 @@ const MCP_JSON_REL = ".mcp.json";
 const CODEX_REL = ".codex/config.toml";
 const AGENTS_MCP_REL = ".agents/mcp_config.json";
 const GEMINI_SETTINGS_REL = ".gemini/settings.json";
-const AGENT_IDS = ["orchestrator", "implementer", "thinker", "grunt"];
+const AGENT_IDS = ["orchestrator", "grunt"];
 const MCP_DENY = "mcp__*";
 const AGENT_ORCHESTRATOR_DENY = "Agent(orchestrator)";
 const GROK_HEADER =