pursr 0.6.0 → 0.7.0

package/src/interact.js

@@ -1,138 +1,138 @@
-// click, type, wait, seq — interaction primitives.
-
-import { launch, newPage } from "./runway.js";
-import { DEFAULT_VIEWPORT } from "./viewport.js";
-import { gotoOrThrow, settle, CLICK_TIMEOUT_MS, WAIT_DEFAULT_TIMEOUT_MS } from "./overlays.js";
-import { resolveLocator } from "./selector.js";
-import { requireArg } from "./util.js";
-
-export async function runClick(url, selector, out) {
-  requireArg("url", url, "string");
-  requireArg("selector", selector, "string");
-  const browser = await launch();
-  try {
-    const page = await newPage(browser, DEFAULT_VIEWPORT);
-    const r = await gotoOrThrow(page, url); await settle(page);
-    const loc = await resolveLocator(page, selector);
-    await loc.first().waitFor({ state: "visible", timeout: CLICK_TIMEOUT_MS });
-    await loc.first().click({ timeout: CLICK_TIMEOUT_MS });
-    await settle(page);
-    if (out) await page.screenshot({ path: out, fullPage: false });
-    return { ...r, url, out, selector, clicked: true };
-  } finally { try { await browser.close(); } catch {} }
-}
-
-export async function runType(url, selector, text, out) {
-  requireArg("url", url, "string");
-  requireArg("selector", selector, "string");
-  const browser = await launch();
-  try {
-    const page = await newPage(browser, DEFAULT_VIEWPORT);
-    const r = await gotoOrThrow(page, url); await settle(page);
-    const loc = await resolveLocator(page, selector);
-    await loc.first().waitFor({ state: "visible", timeout: CLICK_TIMEOUT_MS });
-    await loc.first().click({ timeout: CLICK_TIMEOUT_MS });
-    await page.keyboard.type(String(text ?? ""), { delay: 10 });
-    await settle(page);
-    if (out) await page.screenshot({ path: out, fullPage: false });
-    return { ...r, url, out, selector, text, typed: true };
-  } finally { try { await browser.close(); } catch {} }
-}
-
-export async function runWait(url, selector, timeoutMs) {
-  requireArg("url", url, "string");
-  requireArg("selector", selector, "string");
-  const browser = await launch();
-  try {
-    const page = await newPage(browser, DEFAULT_VIEWPORT);
-    const r = await gotoOrThrow(page, url);
-    const loc = await resolveLocator(page, selector);
-    const t = timeoutMs || WAIT_DEFAULT_TIMEOUT_MS;
-    try {
-      await loc.first().waitFor({ state: "visible", timeout: t });
-      return { ...r, url, selector, found: true, timeoutMs: t };
-    } catch {
-      return { ...r, url, selector, found: false, timeoutMs: t };
-    }
-  } finally { try { await browser.close(); } catch {} }
-}
-
-export async function runSeq(url, actionsJson, out) {
-  requireArg("url", url, "string");
-  let actions;
-  try { actions = JSON.parse(actionsJson); }
-  catch (e) { throw new Error(`invalid actions JSON: ${e.message}`, { cause: e }); }
-  if (!Array.isArray(actions)) throw new Error("actions must be a JSON array");
-  if (!actions.length) throw new Error("actions array is empty");
-  const browser = await launch();
-  try {
-    const page = await newPage(browser, DEFAULT_VIEWPORT);
-    const r = await gotoOrThrow(page, url); await settle(page);
-    const trace = [];
-    let failed = false;
-    for (let i = 0; i < actions.length; i++) {
-      const a = actions[i] || {};
-      const step = { i, op: a.op };
-      try {
-        switch (a.op) {
-          case "click": {
-            const loc = await resolveLocator(page, a.selector);
-            await loc.first().waitFor({ state: "visible", timeout: CLICK_TIMEOUT_MS });
-            await loc.first().click({ timeout: CLICK_TIMEOUT_MS });
-            step.selector = a.selector; break;
-          }
-          case "type": {
-            const loc = await resolveLocator(page, a.selector);
-            await loc.first().waitFor({ state: "visible", timeout: CLICK_TIMEOUT_MS });
-            await loc.first().click({ timeout: CLICK_TIMEOUT_MS });
-            await page.keyboard.type(String(a.text ?? ""), { delay: 10 });
-            step.selector = a.selector; step.text = a.text; break;
-          }
-          case "wait": {
-            const t = a.timeoutMs ? Number(a.timeoutMs) : WAIT_DEFAULT_TIMEOUT_MS;
-            const loc = await resolveLocator(page, a.selector);
-            await loc.first().waitFor({ state: "visible", timeout: t });
-            step.selector = a.selector; step.timeoutMs = t; break;
-          }
-          case "eval": { step.result = await page.evaluate(String(a.js ?? "")); break; }
-          case "shot": {
-            await page.screenshot({ path: a.out, fullPage: !!a.fullPage });
-            step.out = a.out; step.fullPage = !!a.fullPage; break;
-          }
-          case "scroll": {
-            const vp = page.viewportSize();
-            await page.mouse.move((vp?.width || 640) / 2, (vp?.height || 400) / 2);
-            await page.mouse.wheel(a.deltaX || 0, a.deltaY || 0);
-            step.deltaX = a.deltaX; step.deltaY = a.deltaY; break;
-          }
-          case "navigate": { await gotoOrThrow(page, a.url); step.url = a.url; break; }
-          case "press": {
-            // a.key can be a single key ("Escape") or comma-separated ("Tab,Enter")
-            const raw = String(a.key ?? "").trim();
-            if (!raw) throw new Error("press: missing key");
-            const keys = raw.split(",").map(k => k.trim()).filter(Boolean);
-            for (const k of keys) await page.keyboard.press(k);
-            step.key = raw; step.count = keys.length; break;
-          }
-          case "sleep": { await page.waitForTimeout(Number(a.ms ?? 1000)); step.ms = a.ms; break; }
-          case "hover": {
-            const loc = await resolveLocator(page, a.selector);
-            await loc.first().waitFor({ state: "visible", timeout: CLICK_TIMEOUT_MS });
-            await loc.first().hover({ timeout: CLICK_TIMEOUT_MS });
-            step.selector = a.selector; break;
-          }
-          default: throw new Error(`unknown op: ${a.op}`);
-        }
-        if (a.settleMs !== undefined) await page.waitForTimeout(Number(a.settleMs));
-        else await settle(page);
-        step.ok = true;
-      } catch (e) {
-        step.ok = false; step.error = e.message; failed = true;
-      }
-      trace.push(step);
-      if (failed) break;
-    }
-    if (out) await page.screenshot({ path: out, fullPage: false });
-    return { ...r, url, out, steps: trace, failed };
-  } finally { try { await browser.close(); } catch {} }
+// click, type, wait, seq — interaction primitives.
+
+import { launch, newPage } from "./runway.js";
+import { DEFAULT_VIEWPORT } from "./viewport.js";
+import { gotoOrThrow, settle, CLICK_TIMEOUT_MS, WAIT_DEFAULT_TIMEOUT_MS } from "./overlays.js";
+import { resolveLocator } from "./selector.js";
+import { requireArg } from "./util.js";
+
+export async function runClick(url, selector, out) {
+  requireArg("url", url, "string");
+  requireArg("selector", selector, "string");
+  const browser = await launch();
+  try {
+    const page = await newPage(browser, DEFAULT_VIEWPORT);
+    const r = await gotoOrThrow(page, url); await settle(page);
+    const loc = await resolveLocator(page, selector);
+    await loc.first().waitFor({ state: "visible", timeout: CLICK_TIMEOUT_MS });
+    await loc.first().click({ timeout: CLICK_TIMEOUT_MS });
+    await settle(page);
+    if (out) await page.screenshot({ path: out, fullPage: false });
+    return { ...r, url, out, selector, clicked: true };
+  } finally { try { await browser.close(); } catch {} }
+}
+
+export async function runType(url, selector, text, out) {
+  requireArg("url", url, "string");
+  requireArg("selector", selector, "string");
+  const browser = await launch();
+  try {
+    const page = await newPage(browser, DEFAULT_VIEWPORT);
+    const r = await gotoOrThrow(page, url); await settle(page);
+    const loc = await resolveLocator(page, selector);
+    await loc.first().waitFor({ state: "visible", timeout: CLICK_TIMEOUT_MS });
+    await loc.first().click({ timeout: CLICK_TIMEOUT_MS });
+    await page.keyboard.type(String(text ?? ""), { delay: 10 });
+    await settle(page);
+    if (out) await page.screenshot({ path: out, fullPage: false });
+    return { ...r, url, out, selector, text, typed: true };
+  } finally { try { await browser.close(); } catch {} }
+}
+
+export async function runWait(url, selector, timeoutMs) {
+  requireArg("url", url, "string");
+  requireArg("selector", selector, "string");
+  const browser = await launch();
+  try {
+    const page = await newPage(browser, DEFAULT_VIEWPORT);
+    const r = await gotoOrThrow(page, url);
+    const loc = await resolveLocator(page, selector);
+    const t = timeoutMs || WAIT_DEFAULT_TIMEOUT_MS;
+    try {
+      await loc.first().waitFor({ state: "visible", timeout: t });
+      return { ...r, url, selector, found: true, timeoutMs: t };
+    } catch {
+      return { ...r, url, selector, found: false, timeoutMs: t };
+    }
+  } finally { try { await browser.close(); } catch {} }
+}
+
+export async function runSeq(url, actionsJson, out) {
+  requireArg("url", url, "string");
+  let actions;
+  try { actions = JSON.parse(actionsJson); }
+  catch (e) { throw new Error(`invalid actions JSON: ${e.message}`, { cause: e }); }
+  if (!Array.isArray(actions)) throw new Error("actions must be a JSON array");
+  if (!actions.length) throw new Error("actions array is empty");
+  const browser = await launch();
+  try {
+    const page = await newPage(browser, DEFAULT_VIEWPORT);
+    const r = await gotoOrThrow(page, url); await settle(page);
+    const trace = [];
+    let failed = false;
+    for (let i = 0; i < actions.length; i++) {
+      const a = actions[i] || {};
+      const step = { i, op: a.op };
+      try {
+        switch (a.op) {
+          case "click": {
+            const loc = await resolveLocator(page, a.selector);
+            await loc.first().waitFor({ state: "visible", timeout: CLICK_TIMEOUT_MS });
+            await loc.first().click({ timeout: CLICK_TIMEOUT_MS });
+            step.selector = a.selector; break;
+          }
+          case "type": {
+            const loc = await resolveLocator(page, a.selector);
+            await loc.first().waitFor({ state: "visible", timeout: CLICK_TIMEOUT_MS });
+            await loc.first().click({ timeout: CLICK_TIMEOUT_MS });
+            await page.keyboard.type(String(a.text ?? ""), { delay: 10 });
+            step.selector = a.selector; step.text = a.text; break;
+          }
+          case "wait": {
+            const t = a.timeoutMs ? Number(a.timeoutMs) : WAIT_DEFAULT_TIMEOUT_MS;
+            const loc = await resolveLocator(page, a.selector);
+            await loc.first().waitFor({ state: "visible", timeout: t });
+            step.selector = a.selector; step.timeoutMs = t; break;
+          }
+          case "eval": { step.result = await page.evaluate(String(a.js ?? "")); break; }
+          case "shot": {
+            await page.screenshot({ path: a.out, fullPage: !!a.fullPage });
+            step.out = a.out; step.fullPage = !!a.fullPage; break;
+          }
+          case "scroll": {
+            const vp = page.viewportSize();
+            await page.mouse.move((vp?.width || 640) / 2, (vp?.height || 400) / 2);
+            await page.mouse.wheel(a.deltaX || 0, a.deltaY || 0);
+            step.deltaX = a.deltaX; step.deltaY = a.deltaY; break;
+          }
+          case "navigate": { await gotoOrThrow(page, a.url); step.url = a.url; break; }
+          case "press": {
+            // a.key can be a single key ("Escape") or comma-separated ("Tab,Enter")
+            const raw = String(a.key ?? "").trim();
+            if (!raw) throw new Error("press: missing key");
+            const keys = raw.split(",").map(k => k.trim()).filter(Boolean);
+            for (const k of keys) await page.keyboard.press(k);
+            step.key = raw; step.count = keys.length; break;
+          }
+          case "sleep": { await page.waitForTimeout(Number(a.ms ?? 1000)); step.ms = a.ms; break; }
+          case "hover": {
+            const loc = await resolveLocator(page, a.selector);
+            await loc.first().waitFor({ state: "visible", timeout: CLICK_TIMEOUT_MS });
+            await loc.first().hover({ timeout: CLICK_TIMEOUT_MS });
+            step.selector = a.selector; break;
+          }
+          default: throw new Error(`unknown op: ${a.op}`);
+        }
+        if (a.settleMs !== undefined) await page.waitForTimeout(Number(a.settleMs));
+        else await settle(page);
+        step.ok = true;
+      } catch (e) {
+        step.ok = false; step.error = e.message; failed = true;
+      }
+      trace.push(step);
+      if (failed) break;
+    }
+    if (out) await page.screenshot({ path: out, fullPage: false });
+    return { ...r, url, out, steps: trace, failed };
+  } finally { try { await browser.close(); } catch {} }
 }

package/src/mcp-resources.js

@@ -1,111 +1,112 @@
-// pursor — MCP resources adapter.
-//
-// Exposes run results as MCP resources so hosts (Claude Code, Cursor, etc.)
-// can browse, preview, and re-read captures without re-running captures.
-//
-// Resource shape (per MCP spec):
-//   uri:        pursor://<kind>/<id>
-//   name:       <human label>
-//   description: <what it is>
-//   mimeType:   image/png | application/json | text/html
-//
-// We track "recent" sweep outputs in-memory + persist an index at
-// $PURSOR_MCP_STATE/mcp-index.json so resources survive restarts.
-
-import { existsSync, readFileSync, writeFileSync, mkdirSync, readdirSync, statSync } from "node:fs";
-import { join, basename, dirname } from "node:path";
-import { homedir } from "node:os";
-import { nowIso } from "./util.js";
-
-function stateDir() {
-  const root = process.env.PURSOR_MCP_STATE || join(homedir(), ".pursor", "mcp");
-  mkdirSync(root, { recursive: true });
-  return root;
-}
-
-function indexPath() { return join(stateDir(), "mcp-index.json"); }
-
-function loadIndex() {
-  const p = indexPath();
-  if (!existsSync(p)) return { resources: [] };
-  try { return JSON.parse(readFileSync(p, "utf8")); } catch { return { resources: [] }; }
-}
-
-function saveIndex(idx) {
-  writeFileSync(indexPath(), JSON.stringify(idx, null, 2), "utf8");
-}
-
-export function recordResource({ kind, id, name, description, uri, mimeType, file, meta }) {
-  const idx = loadIndex();
-  // De-dup by uri
-  idx.resources = idx.resources.filter(r => r.uri !== uri);
-  idx.resources.unshift({
-    kind, id, name, description, uri, mimeType, file, meta: meta || null, ts: nowIso(),
-  });
-  // Cap index size
-  if (idx.resources.length > 200) idx.resources = idx.resources.slice(0, 200);
-  saveIndex(idx);
-  return idx.resources[0];
-}
-
-export function listResources() {
-  // Combine persisted index + any in-memory scan of recent sweep dirs
-  const idx = loadIndex();
-  // Also include sidecars sitting next to a sweep.json under cwd
-  try {
-    const cwd = process.cwd();
-    for (const f of readdirSync(cwd)) {
-      if (f === "sweep.json") {
-        const sweepPath = join(cwd, f);
-        try {
-          const s = JSON.parse(readFileSync(sweepPath, "utf8"));
-          const dirUri = `pursor://sweep/${encodeURIComponent(s.name || basename(cwd))}`;
-          if (!idx.resources.some(r => r.uri === dirUri)) {
-            idx.resources.push({
-              kind: "sweep", id: s.name || basename(cwd),
-              name: `sweep: ${s.name || basename(cwd)}`,
-              description: `Sweep summary: ${(s.steps || []).length} steps`,
-              uri: dirUri, mimeType: "application/json",
-              file: sweepPath, meta: { steps: (s.steps || []).length, ts: s.ts }, ts: s.ts || nowIso(),
-            });
-          }
-        } catch {}
-      }
-    }
-  } catch {}
-  return idx.resources;
-}
-
-export function readResource(uri) {
-  if (typeof uri !== "string") return null;
-  if (!uri.startsWith("pursor://")) return null;
-  // Parse kind/id
-  const rest = uri.slice("pursor://".length);
-  const [kind, ...restParts] = rest.split("/");
-  const id = restParts.join("/");
-  const idx = loadIndex();
-  const r = idx.resources.find(x => x.uri === uri);
-  if (r) {
-    return readResourceFile(r);
-  }
-  // Resolve by kind/id from filesystem fallback
-  if (kind === "sweep") {
-    const file = join(process.cwd(), decodeURIComponent(id), "sweep.json");
-    if (existsSync(file)) {
-      return { uri, mimeType: "application/json", text: readFileSync(file, "utf8") };
-    }
-  }
-  return null;
-}
-
-function readResourceFile(r) {
-  if (!r.file || !existsSync(r.file)) return { uri: r.uri, mimeType: r.mimeType, error: "file not found" };
-  const data = readFileSync(r.file);
-  if (r.mimeType && r.mimeType.startsWith("image/")) {
-    return { uri: r.uri, mimeType: r.mimeType, blob: data.toString("base64") };
-  }
-  if (r.mimeType === "application/json" || r.mimeType === "text/html") {
-    return { uri: r.uri, mimeType: r.mimeType, text: data.toString("utf8") };
-  }
-  return { uri: r.uri, mimeType: r.mimeType || "application/octet-stream", blob: data.toString("base64") };
+//  pursr — MCP resources adapter.
+//
+// Exposes run results as MCP resources so hosts (Claude Code, Cursor, etc.)
+// can browse, preview, and re-read captures without re-running captures.
+//
+// Resource shape (per MCP spec):
+//   uri:        pursr://<kind>/<id>
+//   name:       <human label>
+//   description: <what it is>
+//   mimeType:   image/png | application/json | text/html
+//
+// We track "recent" sweep outputs in-memory + persist an index at
+// $PURSR_MCP_STATE/mcp-index.json so resources survive restarts.
+
+import { existsSync, readFileSync, writeFileSync, mkdirSync, readdirSync, statSync } from "node:fs";
+import { join, basename, dirname } from "node:path";
+import { homedir } from "node:os";
+import { nowIso } from "./util.js";
+import { __PURSR_GET } from "./util.js";
+
+function stateDir() {
+  const root = __PURSR_GET("PURSR_MCP_STATE") || join(homedir(), ".pursr", "mcp");
+  mkdirSync(root, { recursive: true });
+  return root;
+}
+
+function indexPath() { return join(stateDir(), "mcp-index.json"); }
+
+function loadIndex() {
+  const p = indexPath();
+  if (!existsSync(p)) return { resources: [] };
+  try { return JSON.parse(readFileSync(p, "utf8")); } catch { return { resources: [] }; }
+}
+
+function saveIndex(idx) {
+  writeFileSync(indexPath(), JSON.stringify(idx, null, 2), "utf8");
+}
+
+export function recordResource({ kind, id, name, description, uri, mimeType, file, meta }) {
+  const idx = loadIndex();
+  // De-dup by uri
+  idx.resources = idx.resources.filter(r => r.uri !== uri);
+  idx.resources.unshift({
+    kind, id, name, description, uri, mimeType, file, meta: meta || null, ts: nowIso(),
+  });
+  // Cap index size
+  if (idx.resources.length > 200) idx.resources = idx.resources.slice(0, 200);
+  saveIndex(idx);
+  return idx.resources[0];
+}
+
+export function listResources() {
+  // Combine persisted index + any in-memory scan of recent sweep dirs
+  const idx = loadIndex();
+  // Also include sidecars sitting next to a sweep.json under cwd
+  try {
+    const cwd = process.cwd();
+    for (const f of readdirSync(cwd)) {
+      if (f === "sweep.json") {
+        const sweepPath = join(cwd, f);
+        try {
+          const s = JSON.parse(readFileSync(sweepPath, "utf8"));
+          const dirUri = `pursr://sweep/${encodeURIComponent(s.name || basename(cwd))}`;
+          if (!idx.resources.some(r => r.uri === dirUri)) {
+            idx.resources.push({
+              kind: "sweep", id: s.name || basename(cwd),
+              name: `sweep: ${s.name || basename(cwd)}`,
+              description: `Sweep summary: ${(s.steps || []).length} steps`,
+              uri: dirUri, mimeType: "application/json",
+              file: sweepPath, meta: { steps: (s.steps || []).length, ts: s.ts }, ts: s.ts || nowIso(),
+            });
+          }
+        } catch {}
+      }
+    }
+  } catch {}
+  return idx.resources;
+}
+
+export function readResource(uri) {
+  if (typeof uri !== "string") return null;
+  if (!uri.startsWith("pursr://")) return null;
+  // Parse kind/id
+  const rest = uri.slice("pursr://".length);
+  const [kind, ...restParts] = rest.split("/");
+  const id = restParts.join("/");
+  const idx = loadIndex();
+  const r = idx.resources.find(x => x.uri === uri);
+  if (r) {
+    return readResourceFile(r);
+  }
+  // Resolve by kind/id from filesystem fallback
+  if (kind === "sweep") {
+    const file = join(process.cwd(), decodeURIComponent(id), "sweep.json");
+    if (existsSync(file)) {
+      return { uri, mimeType: "application/json", text: readFileSync(file, "utf8") };
+    }
+  }
+  return null;
+}
+
+function readResourceFile(r) {
+  if (!r.file || !existsSync(r.file)) return { uri: r.uri, mimeType: r.mimeType, error: "file not found" };
+  const data = readFileSync(r.file);
+  if (r.mimeType && r.mimeType.startsWith("image/")) {
+    return { uri: r.uri, mimeType: r.mimeType, blob: data.toString("base64") };
+  }
+  if (r.mimeType === "application/json" || r.mimeType === "text/html") {
+    return { uri: r.uri, mimeType: r.mimeType, text: data.toString("utf8") };
+  }
+  return { uri: r.uri, mimeType: r.mimeType || "application/octet-stream", blob: data.toString("base64") };
 }