npm - @agentuity/browzer - Versions diffs - 0.1.0 - Mend

@agentuity/browzer 0.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (18) hide show

package/dist/cli/paths.js ADDED Viewed

@@ -0,0 +1,45 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.packageRoot = packageRoot;
+exports.browzerHome = browzerHome;
+exports.tracesDir = tracesDir;
+exports.activeDir = activeDir;
+exports.activePath = activePath;
+exports.traceDir = traceDir;
+exports.sanitize = sanitize;
+exports.newTraceId = newTraceId;
+const node_os_1 = require("node:os");
+const node_path_1 = __importDefault(require("node:path"));
+/** Repo or npm package root (parent of `cli/` or `dist/cli/`). */
+function packageRoot() {
+    const parent = node_path_1.default.basename(node_path_1.default.dirname(__dirname));
+    if (parent === "dist")
+        return node_path_1.default.resolve(__dirname, "..", "..");
+    return node_path_1.default.resolve(__dirname, "..");
+}
+function browzerHome() {
+    return process.env.BROWZER_HOME?.trim() || node_path_1.default.join((0, node_os_1.homedir)(), ".browzer");
+}
+function tracesDir(output) {
+    const raw = output?.trim() || process.env.BROWZER_OUTPUT?.trim() || process.cwd();
+    return node_path_1.default.resolve(raw);
+}
+function activeDir() {
+    return node_path_1.default.join(browzerHome(), "active");
+}
+function activePath(session) {
+    return node_path_1.default.join(activeDir(), `${sanitize(session)}.json`);
+}
+function traceDir(id, output) {
+    return node_path_1.default.join(tracesDir(output), id);
+}
+function sanitize(value) {
+    return value.replace(/[^a-zA-Z0-9._-]+/g, "-").replace(/^-+|-+$/g, "") || "default";
+}
+function newTraceId(session) {
+    const stamp = new Date().toISOString().replace(/[-:]/g, "").replace("T", "-").slice(0, 15);
+    return `${stamp}-${sanitize(session)}`;
+}

package/dist/cli/replay-html.js ADDED Viewed

@@ -0,0 +1,308 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderReplayHtml = renderReplayHtml;
+function renderReplayHtml(trace) {
+    const payload = {
+        id: trace.id,
+        session: trace.session,
+        title: trace.title || trace.session,
+        url: trace.lastUrl || trace.startUrl || "",
+        startedAt: trace.startedAt,
+        endedAt: trace.endedAt ?? null,
+        hasVideo: trace.hasVideo,
+        hasPoster: trace.hasPoster,
+        commands: trace.commands.map((cmd) => ({
+            id: cmd.id,
+            ts: cmd.ts,
+            label: cmd.label,
+            durationMs: cmd.durationMs,
+            exitCode: cmd.exitCode,
+        })),
+        console: trace.console,
+        errors: trace.errors,
+        network: trace.network,
+        snapshot: trace.snapshot,
+        urls: trace.urls,
+    };
+    const json = JSON.stringify(payload).replace(/</g, "\\u003c");
+    return `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="utf-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1" />
+  <title>Browzer · ${escapeHtml(payload.title)}</title>
+  <style>
+    :root {
+      --bg: oklch(0.155 0.02 250);
+      --raise: oklch(0.2 0.022 250);
+      --ink: oklch(0.94 0.012 250);
+      --muted: oklch(0.72 0.025 250);
+      --faint: oklch(0.55 0.02 250);
+      --line: oklch(0.3 0.02 250);
+      --panel: oklch(0.965 0.014 155);
+      --panel-ink: oklch(0.22 0.04 155);
+      --panel-muted: oklch(0.42 0.045 155);
+      --panel-line: oklch(0.88 0.02 155);
+      --panel-fill: oklch(0.94 0.018 155);
+      --live: oklch(0.42 0.12 155);
+      --live-bright: oklch(0.78 0.15 155);
+      --danger: oklch(0.63 0.19 25);
+      --chrome: oklch(0.22 0.012 250);
+      --chrome-ink: oklch(0.86 0.01 250);
+    }
+    * { box-sizing: border-box; }
+    html, body { margin: 0; min-height: 100%; background: var(--bg); color: var(--ink); }
+    body { font-family: ui-sans-serif, system-ui, sans-serif; letter-spacing: -0.011em; }
+    button { font: inherit; }
+    code, .mono { font-family: ui-monospace, SFMono-Regular, Menlo, monospace; }
+    .app { display: flex; flex-direction: column; gap: 16px; padding: 16px; height: 100dvh; overflow: hidden; }
+    .row { display: flex; flex-direction: column; gap: 16px; flex: 1; min-height: 0; }
+    .main { flex: 1; min-width: 0; min-height: 0; display: flex; flex-direction: column; gap: 12px; }
+    @media (min-width: 960px) {
+      .row { flex-direction: row; }
+    }
+    .top { display: flex; justify-content: space-between; padding: 0 4px; font-size: 12px; }
+    .kicker { text-transform: uppercase; letter-spacing: 0.16em; color: var(--muted); }
+    .meta { color: var(--faint); overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
+    .frame { flex: 1; min-height: 240px; display: flex; flex-direction: column; overflow: hidden; border-radius: 12px; background: var(--chrome); color: var(--chrome-ink); }
+    .chrome { display: flex; align-items: center; gap: 12px; padding: 10px 12px; }
+    .dots { display: flex; gap: 6px; padding-left: 4px; }
+    .dots span { width: 10px; height: 10px; border-radius: 50%; }
+    .url { flex: 1; min-width: 0; margin: 0; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; background: transparent; padding: 4px 0; font-size: 12px; }
+    .stage { position: relative; flex: 1; min-height: 0; background: #000; }
+    .stage video, .stage img { width: 100%; height: 100%; object-fit: contain; }
+    .empty { display: flex; height: 100%; align-items: center; justify-content: center; font-size: 12px; color: var(--faint); }
+    .rail { width: 100%; min-height: 0; display: flex; flex-direction: column; overflow: hidden; background: var(--panel); color: var(--panel-ink); border-radius: 12px; }
+    @media (min-width: 960px) { .rail { width: 300px; flex-shrink: 0; } }
+    @media (max-width: 959px) { .rail { max-height: 42dvh; } }
+    .rail-head { flex-shrink: 0; padding: 20px 24px 8px; }
+    .replay-kicker { font-size: 11px; font-weight: 500; letter-spacing: 0.18em; text-transform: uppercase; color: var(--live); }
+    .timer { margin: 8px 0 0; font-family: ui-monospace, Menlo, monospace; font-size: clamp(2.75rem, 5vw, 4.25rem); font-weight: 500; letter-spacing: -0.03em; line-height: 0.9; font-variant-numeric: tabular-nums; }
+    .secs { margin: 6px 0 0; font-size: 10px; letter-spacing: 0.16em; text-transform: uppercase; color: var(--panel-muted); }
+    .steps { flex: 1; min-height: 0; overflow-y: auto; padding: 0 20px 16px; margin: 0; list-style: none; }
+    .step { width: 100%; display: flex; gap: 12px; padding: 10px 8px; border: 0; background: transparent; text-align: left; border-radius: 6px; cursor: pointer; color: inherit; }
+    .step:hover, .step.current { background: var(--panel-fill); }
+    .dot { width: 14px; height: 14px; margin-top: 6px; flex-shrink: 0; border-radius: 50%; border: 2px solid var(--panel-line); }
+    .dot.done { background: var(--live); border-color: var(--live); }
+    .dot.error { background: var(--danger); border-color: var(--danger); }
+    .dot.running { border-color: var(--live); background: color-mix(in oklch, var(--live) 20%, white); box-shadow: 0 0 0 4px color-mix(in oklch, var(--live) 18%, transparent); }
+    .label { flex: 1; min-width: 0; font-size: 14px; line-height: 1.3; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
+    .label.pending { color: var(--panel-muted); }
+    .t { flex-shrink: 0; font-size: 11px; font-variant-numeric: tabular-nums; color: var(--panel-muted); }
+    .rail-foot { flex-shrink: 0; margin-top: auto; border-top: 1px solid var(--panel-line); padding: 12px 24px 16px; }
+    .count { margin: 0; font-size: 22px; font-weight: 500; letter-spacing: -0.02em; }
+    .hint { margin: 4px 0 0; font-size: 13px; color: var(--panel-muted); }
+    .detail-bar { flex: 0 0 auto; align-self: flex-start; border: 0; border-radius: 8px; background: var(--raise); color: var(--muted); padding: 8px 12px; cursor: pointer; font-size: 13px; }
+    .detail-bar:hover { color: var(--ink); }
+    .details { display: flex; flex-direction: column; flex: 0 0 240px; height: 240px; min-height: 240px; max-height: 240px; overflow: hidden; border-radius: 12px; background: var(--raise); }
+    .details[hidden] { display: none !important; }
+    .tabs { display: flex; align-items: center; gap: 4px; flex: 0 0 auto; border-bottom: 1px solid var(--line); padding: 8px 12px 0; }
+    .tabs button { border: 0; background: transparent; color: var(--muted); padding: 8px 12px; border-radius: 6px 6px 0 0; cursor: pointer; font-size: 13px; }
+    .tabs button.on { background: var(--bg); color: var(--ink); }
+    .tabs .hide { margin-left: auto; }
+    .panel { flex: 1; min-height: 0; overflow: auto; padding: 12px 16px; font-size: 12px; line-height: 1.55; font-family: ui-monospace, Menlo, monospace; }
+    .err { color: var(--danger); }
+    .muted { color: var(--muted); }
+    .faint { color: var(--faint); }
+    .net { display: grid; grid-template-columns: 2.5em 3.5em 1fr; gap: 8px; }
+  </style>
+</head>
+<body>
+  <div class="app">
+    <div class="row">
+      <div class="main">
+        <div class="top">
+          <span class="kicker mono">Browzer</span>
+          <span class="meta mono" id="heading"></span>
+        </div>
+        <section class="frame">
+          <header class="chrome">
+            <div class="dots" aria-hidden="true"><span style="background:#ff5f57"></span><span style="background:#febc2e"></span><span style="background:#28c840"></span></div>
+            <p class="url mono" id="url"></p>
+          </header>
+          <div class="stage" id="stage"></div>
+        </section>
+        <button type="button" class="detail-bar" id="show-details">Show details</button>
+        <section class="details" id="details" hidden>
+          <div class="tabs" id="tabs"></div>
+          <div class="panel" id="panel"></div>
+        </section>
+      </div>
+      <aside class="rail">
+        <div class="rail-head">
+          <p class="replay-kicker mono">Replay</p>
+          <p class="timer" id="timer">0.00</p>
+          <p class="secs mono">Seconds elapsed</p>
+        </div>
+        <ol class="steps" id="steps"></ol>
+        <div class="rail-foot">
+          <p class="count" id="count">0 actions executed</p>
+          <p class="hint" id="median"></p>
+        </div>
+      </aside>
+    </div>
+  </div>
+  <script id="data" type="application/json">${json}</script>
+  <script>
+    const T = JSON.parse(document.getElementById("data").textContent);
+    document.getElementById("heading").textContent = T.title + " · " + T.id;
+    document.getElementById("url").textContent = (T.urls && T.urls[0] && T.urls[0].url) || T.url || "about:blank";
+    const stage = document.getElementById("stage");
+    let video = null;
+    if (T.hasVideo) {
+      video = document.createElement("video");
+      video.controls = true;
+      video.playsInline = true;
+      video.src = "session.mp4";
+      if (T.hasPoster) video.poster = "poster.jpg";
+      stage.appendChild(video);
+    } else if (T.hasPoster) {
+      const img = document.createElement("img");
+      img.src = "poster.jpg";
+      img.alt = "Last captured frame";
+      stage.appendChild(img);
+    } else {
+      stage.innerHTML = '<div class="empty mono">No recording was saved</div>';
+    }
+    const origin = (T.commands[0] && T.commands[0].ts) || T.startedAt;
+    function scaleFor(duration) {
+      const maxT = T.commands.reduce((m, c) => Math.max(m, Math.max(0, (c.ts - origin) / 1000)), 0);
+      return duration > 0 && maxT > duration + 0.25 ? Math.max(0, duration - 0.08) / maxT : 1;
+    }
+    function cueList(duration) {
+      const scale = scaleFor(duration);
+      return T.commands.map((c) => ({ id: c.id, seconds: Math.max(0, (c.ts - origin) / 1000) * scale }));
+    }
+    function urlAt(t, duration) {
+      const scale = scaleFor(duration);
+      let url = (T.urls && T.urls[0] && T.urls[0].url) || T.url || "about:blank";
+      for (const point of T.urls || []) {
+        const seconds = Math.max(0, (point.ts - origin) / 1000) * scale;
+        if (seconds <= t + 0.04) url = point.url;
+      }
+      return url;
+    }
+    function visual(id, t, duration, cues) {
+      const cue = cues.find((c) => c.id === id);
+      if (!cue) return "pending";
+      if (duration > 0 && t >= Math.max(0, duration - 0.08)) return "done";
+      if (t + 0.04 < cue.seconds) return "pending";
+      let active = null;
+      for (const c of cues) if (c.seconds <= t + 0.04) active = c.id;
+      return active === id ? "running" : "done";
+    }
+    function clock(s) {
+      const m = Math.floor(Math.max(0, s) / 60);
+      const sec = Math.floor(Math.max(0, s) % 60);
+      return m + ":" + String(sec).padStart(2, "0");
+    }
+    const stepsEl = document.getElementById("steps");
+    T.commands.forEach((cmd) => {
+      const li = document.createElement("li");
+      li.innerHTML = '<button class="step" type="button"><span class="dot"></span><span class="label"></span><span class="t mono"></span></button>';
+      li.querySelector(".label").textContent = cmd.label;
+      li.querySelector("button").addEventListener("click", () => {
+        const cues = cueList(video && video.duration || 0);
+        const cue = cues.find((c) => c.id === cmd.id);
+        if (video && cue) { video.currentTime = cue.seconds; video.play(); }
+      });
+      stepsEl.appendChild(li);
+    });
+    function render(t) {
+      const duration = video && isFinite(video.duration) ? video.duration : 0;
+      const cues = cueList(duration);
+      document.getElementById("timer").textContent = t.toFixed(2);
+      document.getElementById("url").textContent = urlAt(t, duration);
+      let done = 0;
+      [...stepsEl.children].forEach((li, i) => {
+        const cmd = T.commands[i];
+        const cue = cues[i];
+        const state = visual(cmd.id, t, duration, cues);
+        if (state === "done") done += 1;
+        const dot = li.querySelector(".dot");
+        const label = li.querySelector(".label");
+        const btn = li.querySelector("button");
+        dot.className = "dot " + (cmd.exitCode && state === "done" ? "error" : state);
+        label.className = "label" + (state === "pending" ? " pending" : "");
+        btn.className = "step" + (state === "running" ? " current" : "");
+        li.querySelector(".t").textContent = cue ? clock(cue.seconds) : "";
+      });
+      document.getElementById("count").textContent = done + (done === 1 ? " action executed" : " actions executed");
+      const durs = T.commands.map((c) => c.durationMs).filter((n) => n > 0).sort((a,b) => a-b);
+      let med = "";
+      if (durs.length) {
+        const mid = Math.floor(durs.length / 2);
+        const ms = durs.length % 2 ? durs[mid] : (durs[mid-1] + durs[mid]) / 2;
+        med = (ms < 1000 ? Math.round(ms) + "ms" : (ms/1000).toFixed(1) + "s") + " median step";
+      }
+      document.getElementById("median").textContent = med;
+    }
+    if (video) {
+      video.addEventListener("timeupdate", () => render(video.currentTime));
+      video.addEventListener("loadedmetadata", () => render(video.currentTime || 0));
+      video.addEventListener("seeked", () => render(video.currentTime));
+      video.addEventListener("play", () => {
+        const tick = () => { if (!video.paused && !video.ended) { render(video.currentTime); requestAnimationFrame(tick); } };
+        requestAnimationFrame(tick);
+      });
+    }
+    render(0);
+    const details = document.getElementById("details");
+    const showBtn = document.getElementById("show-details");
+    function setDetails(open) {
+      details.hidden = !open;
+      showBtn.hidden = open;
+    }
+    showBtn.addEventListener("click", () => setDetails(true));
+    setDetails(false);
+    const tabs = ["Console", "Network", "Errors", "Snapshot"];
+    const tabsEl = document.getElementById("tabs");
+    const panel = document.getElementById("panel");
+    let on = "Console";
+    function paint() {
+      [...tabsEl.children].forEach((b) => b.classList.toggle("on", b.dataset.tab === on));
+      if (on === "Console") {
+        panel.innerHTML = T.console.length ? T.console.map((m) =>
+          '<div class="' + (m.type === "error" ? "err" : "muted") + '"><span class="faint">' + esc(m.type).toUpperCase() + "</span> " + esc(m.text) + "</div>"
+        ).join("") : '<p class="faint">No console output.</p>';
+      } else if (on === "Network") {
+        panel.innerHTML = T.network.length ? T.network.map((r) =>
+          '<div class="net ' + (r.status >= 400 ? "err" : "muted") + '"><span>' + (r.status || "—") + "</span><span class='faint'>" + esc(r.method) + "</span><span>" + esc(r.url) + "</span></div>"
+        ).join("") : '<p class="faint">No HAR was saved.</p>';
+      } else if (on === "Errors") {
+        const items = T.errors.map((e) => e.text).concat(T.console.filter((m) => m.type === "error").map((m) => m.text));
+        panel.innerHTML = items.length ? items.map((t) => '<div class="err">' + esc(t) + "</div>").join("") : '<p class="faint">No page or console errors.</p>';
+      } else {
+        panel.innerHTML = T.snapshot ? "<pre class='muted' style='white-space:pre-wrap;margin:0'>" + esc(T.snapshot) + "</pre>" : '<p class="faint">No snapshot was saved.</p>';
+      }
+    }
+    function esc(s) {
+      return String(s ?? "").replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+    }
+    tabs.forEach((name) => {
+      const b = document.createElement("button");
+      b.type = "button";
+      b.dataset.tab = name;
+      const extra = name === "Console" ? T.console.length : name === "Network" ? T.network.length : name === "Errors" ? (T.errors.length + T.console.filter((m)=>m.type==="error").length) : "";
+      b.textContent = extra === "" ? name : name + " " + extra;
+      b.addEventListener("click", () => { on = name; paint(); });
+      tabsEl.appendChild(b);
+    });
+    const hide = document.createElement("button");
+    hide.type = "button";
+    hide.className = "hide";
+    hide.textContent = "Hide";
+    hide.addEventListener("click", () => setDetails(false));
+    tabsEl.appendChild(hide);
+    paint();
+  </script>
+</body>
+</html>
+`;
+}
+function escapeHtml(value) {
+    return value.replace(/[&<>"']/g, (ch) => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#39;" })[ch] ?? ch);
+}

package/dist/cli/replay.js ADDED Viewed

@@ -0,0 +1,89 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.replayCommand = replayCommand;
+const node_fs_1 = require("node:fs");
+const promises_1 = require("node:fs/promises");
+const node_path_1 = __importDefault(require("node:path"));
+const node_child_process_1 = require("node:child_process");
+const paths_1 = require("./paths");
+const trace_store_1 = require("../lib/trace-store");
+const replay_html_1 = require("./replay-html");
+async function replayCommand(arg, output) {
+    const dir = await resolveTraceDir(arg, output);
+    const trace = await (0, trace_store_1.getTraceFromDir)(dir);
+    if (!trace) {
+        process.stderr.write(`No trace found at ${dir}\n`);
+        process.exitCode = 1;
+        return;
+    }
+    const htmlPath = node_path_1.default.join(dir, "replay.html");
+    await (0, promises_1.writeFile)(htmlPath, (0, replay_html_1.renderReplayHtml)(trace));
+    openPath(htmlPath);
+    process.stdout.write(`opened ${htmlPath}\n`);
+}
+async function resolveTraceDir(arg, output) {
+    const root = (0, paths_1.tracesDir)(output);
+    if (arg) {
+        const resolved = node_path_1.default.resolve(arg);
+        if ((0, node_fs_1.existsSync)(resolved)) {
+            if ((0, node_fs_1.statSync)(resolved).isDirectory())
+                return resolved;
+            return node_path_1.default.dirname(resolved);
+        }
+        const id = await matchId(arg, root);
+        if (id)
+            return node_path_1.default.join(root, id);
+        throw new Error(`Trace not found: ${arg}`);
+    }
+    const latest = await latestId(root);
+    if (!latest)
+        throw new Error("No traces yet. Record one with browzer <agent-browser command>.");
+    return node_path_1.default.join(root, latest);
+}
+async function latestId(dir) {
+    if (!(0, node_fs_1.existsSync)(dir))
+        return null;
+    let best = null;
+    for (const id of await (0, promises_1.readdir)(dir)) {
+        try {
+            const info = await (0, promises_1.stat)(node_path_1.default.join(dir, id));
+            if (!best || info.mtimeMs > best.mtime)
+                best = { id, mtime: info.mtimeMs };
+        }
+        catch {
+            /* skip */
+        }
+    }
+    return best?.id ?? null;
+}
+async function matchId(prefix, dir) {
+    if (!(0, node_fs_1.existsSync)(dir))
+        return null;
+    const ids = (await (0, promises_1.readdir)(dir)).filter((id) => id === prefix || id.startsWith(prefix) || id.endsWith(`-${prefix}`));
+    if (ids.length === 0)
+        return null;
+    if (ids.length === 1)
+        return ids[0];
+    let best = null;
+    for (const id of ids) {
+        const info = await (0, promises_1.stat)(node_path_1.default.join(dir, id));
+        if (!best || info.mtimeMs > best.mtime)
+            best = { id, mtime: info.mtimeMs };
+    }
+    return best?.id ?? null;
+}
+function openPath(file) {
+    const platform = process.platform;
+    if (platform === "darwin") {
+        (0, node_child_process_1.spawn)("open", [file], { detached: true, stdio: "ignore" }).unref();
+        return;
+    }
+    if (platform === "win32") {
+        (0, node_child_process_1.spawn)("cmd", ["/c", "start", "", file], { detached: true, stdio: "ignore" }).unref();
+        return;
+    }
+    (0, node_child_process_1.spawn)("xdg-open", [file], { detached: true, stdio: "ignore" }).unref();
+}

package/dist/cli/skills.js ADDED Viewed

@@ -0,0 +1,106 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.skillSourceDir = skillSourceDir;
+exports.skillsCommand = skillsCommand;
+const promises_1 = require("node:fs/promises");
+const node_fs_1 = require("node:fs");
+const node_os_1 = require("node:os");
+const node_path_1 = __importDefault(require("node:path"));
+const paths_1 = require("./paths");
+const SKILL_NAME = "browzer";
+const TARGETS = [
+    { name: "agents", global: node_path_1.default.join((0, node_os_1.homedir)(), ".agents", "skills"), project: ".agents/skills", always: true },
+    { name: "claude", global: node_path_1.default.join((0, node_os_1.homedir)(), ".claude", "skills"), project: ".claude/skills" },
+    { name: "cursor", global: node_path_1.default.join((0, node_os_1.homedir)(), ".cursor", "skills"), project: ".cursor/skills" },
+    { name: "codex", global: node_path_1.default.join((0, node_os_1.homedir)(), ".codex", "skills"), project: ".codex/skills" },
+    { name: "grok", global: node_path_1.default.join((0, node_os_1.homedir)(), ".grok", "skills"), project: ".grok/skills" },
+];
+function skillSourceDir() {
+    return node_path_1.default.join((0, paths_1.packageRoot)(), "skills", SKILL_NAME);
+}
+async function skillsCommand(argv, json) {
+    const rest = argv.slice(argv.indexOf("skills") + 1).filter((token) => !token.startsWith("-"));
+    const sub = rest[0] ?? "list";
+    if (sub === "list") {
+        await listSkills(json);
+        return;
+    }
+    if (sub === "get") {
+        await getSkill();
+        return;
+    }
+    if (sub === "path") {
+        process.stdout.write(`${skillSourceDir()}\n`);
+        return;
+    }
+    if (sub === "install") {
+        const project = argv.includes("--project");
+        await installSkill(project);
+        return;
+    }
+    process.stderr.write("Usage: browzer skills [list|get|path|install] [--project]\n");
+    process.exitCode = 1;
+}
+async function listSkills(json) {
+    const source = skillSourceDir();
+    const skill = {
+        name: SKILL_NAME,
+        path: source,
+        description: "agent-browser wrapper that records a replayable trace",
+    };
+    if (json) {
+        process.stdout.write(`${JSON.stringify({ skills: [skill] }, null, 2)}\n`);
+        return;
+    }
+    process.stdout.write(`${skill.name}  ${skill.path}\n`);
+}
+async function getSkill() {
+    const file = node_path_1.default.join(skillSourceDir(), "SKILL.md");
+    if (!(0, node_fs_1.existsSync)(file)) {
+        process.stderr.write(`Skill not found at ${file}\n`);
+        process.exitCode = 1;
+        return;
+    }
+    process.stdout.write(await (0, promises_1.readFile)(file, "utf8"));
+}
+async function installSkill(project) {
+    const source = node_path_1.default.join(skillSourceDir(), "SKILL.md");
+    if (!(0, node_fs_1.existsSync)(source)) {
+        process.stderr.write(`Skill not found at ${source}\n`);
+        process.exitCode = 1;
+        return;
+    }
+    const cwd = process.cwd();
+    const written = [];
+    for (const target of TARGETS) {
+        const root = project ? node_path_1.default.resolve(cwd, target.project) : target.global;
+        const marker = project
+            ? node_path_1.default.dirname(node_path_1.default.resolve(cwd, target.project))
+            : node_path_1.default.dirname(target.global);
+        if (!target.always && !(0, node_fs_1.existsSync)(marker) && !(0, node_fs_1.existsSync)(root))
+            continue;
+        const destDir = node_path_1.default.join(root, SKILL_NAME);
+        try {
+            const st = await (0, promises_1.lstat)(destDir);
+            if (!st.isDirectory() && !st.isSymbolicLink())
+                await (0, promises_1.mkdir)(destDir, { recursive: true });
+        }
+        catch {
+            await (0, promises_1.mkdir)(destDir, { recursive: true });
+        }
+        const dest = node_path_1.default.join(destDir, "SKILL.md");
+        await (0, promises_1.copyFile)(source, dest);
+        written.push(dest);
+    }
+    if (written.length === 0) {
+        process.stderr.write("No agent skill directories found. Pass --project from a repo, or create ~/.agents/skills.\n");
+        process.exitCode = 1;
+        return;
+    }
+    process.stdout.write(`Installed ${SKILL_NAME} to:\n`);
+    for (const dest of written)
+        process.stdout.write(`  ${dest}\n`);
+}

package/dist/cli/state.js ADDED Viewed

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadActive = loadActive;
+exports.saveActive = saveActive;
+exports.clearActive = clearActive;
+exports.listActive = listActive;
+const promises_1 = require("node:fs/promises");
+const node_fs_1 = require("node:fs");
+const paths_1 = require("./paths");
+async function loadActive(session) {
+    const file = (0, paths_1.activePath)(session);
+    if (!(0, node_fs_1.existsSync)(file))
+        return null;
+    try {
+        const data = JSON.parse(await (0, promises_1.readFile)(file, "utf8"));
+        if (!data.dir || !(0, node_fs_1.existsSync)(data.dir)) {
+            await clearActive(session);
+            return null;
+        }
+        return data;
+    }
+    catch {
+        return null;
+    }
+}
+async function saveActive(state) {
+    await (0, promises_1.mkdir)((0, paths_1.activeDir)(), { recursive: true });
+    await (0, promises_1.writeFile)((0, paths_1.activePath)(state.session), JSON.stringify(state, null, 2));
+}
+async function clearActive(session) {
+    await (0, promises_1.rm)((0, paths_1.activePath)(session), { force: true });
+}
+async function listActive() {
+    if (!(0, node_fs_1.existsSync)((0, paths_1.activeDir)()))
+        return [];
+    const names = await (0, promises_1.readdir)((0, paths_1.activeDir)());
+    const out = [];
+    for (const name of names) {
+        if (!name.endsWith(".json"))
+            continue;
+        const session = name.slice(0, -".json".length);
+        const active = await loadActive(session);
+        if (active)
+            out.push(active);
+    }
+    return out;
+}

package/dist/cli/stream.js ADDED Viewed

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.collectDuring = collectDuring;
+async function collectDuring(port, fn, onEvent) {
+    if (!port)
+        return fn();
+    const events = [];
+    let ws = null;
+    try {
+        ws = await connect(port);
+        ws.addEventListener("message", (ev) => {
+            try {
+                const msg = JSON.parse(String(ev.data));
+                if (msg.type === "frame")
+                    return;
+                events.push(msg);
+                onEvent?.(msg);
+            }
+            catch {
+                /* ignore */
+            }
+        });
+    }
+    catch {
+        ws = null;
+    }
+    try {
+        return await fn();
+    }
+    finally {
+        await wait(120);
+        ws?.close();
+        void events;
+    }
+}
+function connect(port) {
+    return new Promise((resolve, reject) => {
+        const ws = new WebSocket(`ws://127.0.0.1:${port}/`);
+        const timer = setTimeout(() => {
+            ws.close();
+            reject(new Error("stream connect timeout"));
+        }, 1500);
+        ws.addEventListener("open", () => {
+            clearTimeout(timer);
+            resolve(ws);
+        });
+        ws.addEventListener("error", () => {
+            clearTimeout(timer);
+            reject(new Error("stream connect failed"));
+        });
+    });
+}
+function wait(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}