@skyramp/mcp 0.2.1 → 0.2.3

package/node_modules/playwright/lib/mcp/skyramp/loadTraceTool.js

@@ -0,0 +1,359 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var loadTraceTool_exports = {};
+__export(loadTraceTool_exports, {
+  decodeModifiers: () => decodeModifiers,
+  describeStep: () => describeStep,
+  describeStopReason: () => describeStopReason,
+  listStepsFrom: () => listStepsFrom,
+  loadTraceMcpTool: () => loadTraceMcpTool,
+  loadTraceSchema: () => loadTraceSchema,
+  replayActions: () => replayActions,
+  urlMatchesPattern: () => urlMatchesPattern
+});
+module.exports = __toCommonJS(loadTraceTool_exports);
+var import_mcpBundle = require("playwright-core/lib/mcpBundle");
+var import_utils = require("playwright-core/lib/utils");
+var import_tool = require("../sdk/tool");
+var import_mouseActions = require("./common/mouseActions");
+const loadTraceSchema = {
+  name: "skyramp_load_trace",
+  title: "Load and replay a Skyramp trace",
+  description: [
+    "Load a previously recorded Skyramp trace (.zip or .jsonl/.txt) and replay its actions against the live browser to restore state, then continue recording from that point.",
+    "The replayed actions are merged into the current recording, so subsequent browser_* steps append to them and skyramp_export_zip writes a combined trace.",
+    "STOPPING EARLY: when the user wants to stop partway through the loaded trace before continuing, set ONE of stopAtStep / stopAtUrl / stopBefore based on their prompt. Omit all three to replay the whole trace.",
+    "- stopAtStep: replay steps 1..N then stop (N is 1-based, from the numbered step list).",
+    "- stopAtUrl: stop once the active page URL matches this glob/regex/substring (checked after each action).",
+    '- stopBefore: stop right BEFORE the first action whose description contains this text (case-insensitive), e.g. "Checkout" to stop before clicking Checkout.',
+    "If unsure where to stop, first call with dryRun:true to read the numbered step list, then call again with the chosen stop parameter."
+  ].join(" "),
+  inputSchema: import_mcpBundle.z.object({
+    path: import_mcpBundle.z.string().describe("Absolute path to the trace file (.zip, .jsonl, or .txt)."),
+    stopAtStep: import_mcpBundle.z.number().int().positive().optional().describe("Replay steps 1..N (1-based), then stop before continuing."),
+    stopAtUrl: import_mcpBundle.z.string().optional().describe("Stop once the active page URL matches this glob/regex/substring."),
+    stopBefore: import_mcpBundle.z.string().optional().describe("Stop before the first action whose description contains this text (case-insensitive)."),
+    dryRun: import_mcpBundle.z.boolean().optional().describe("Parse and list the steps WITHOUT replaying. Use to choose a stop point."),
+    speed: import_mcpBundle.z.enum(["fast", "slow"]).optional().describe('Replay speed. "slow" adds a 1s delay between actions (default "fast").')
+  }),
+  // Replaying drives the live browser and mutates the recording, so this is an
+  // action tool (readOnlyHint:false / destructiveHint:true), not readOnly.
+  type: "action"
+};
+function loadTraceMcpTool() {
+  return (0, import_tool.toMcpTool)(loadTraceSchema);
+}
+function decodeModifiers(mask) {
+  if (!mask)
+    return [];
+  const out = [];
+  if (mask & 1) out.push("Alt");
+  if ((mask & 6) === 6) {
+    out.push("ControlOrMeta");
+  } else {
+    if (mask & 2) out.push("Control");
+    if (mask & 4) out.push("Meta");
+  }
+  if (mask & 8) out.push("Shift");
+  return out;
+}
+const METADATA_ONLY_ACTIONS = /* @__PURE__ */ new Set([
+  "marker",
+  "comment",
+  "beginBlock",
+  "endBlock",
+  "openPage",
+  "closePage",
+  "modalOpen",
+  "modalClose",
+  "iframeLoad",
+  "visualSnapshot",
+  "tableSnapshot",
+  "domSnapshot",
+  "selectArea",
+  "penTool",
+  "assertApiRequest"
+]);
+function describeStep(action, index) {
+  const a = action.action;
+  const onPage = action.frame.pageAlias && action.frame.pageAlias !== "page" ? ` [${action.frame.pageAlias}]` : "";
+  let detail = "";
+  if (a.name === "navigate")
+    detail = a.url;
+  else if (a.selector)
+    detail = (0, import_utils.asLocator)("javascript", a.selector);
+  if ((a.name === "fill" || a.name === "assertText") && a.text !== void 0)
+    detail += ` = ${JSON.stringify(a.text)}`;
+  else if (a.name === "assertValue" && a.value !== void 0)
+    detail += ` = ${JSON.stringify(a.value)}`;
+  else if (a.name === "press" && a.key !== void 0)
+    detail += ` ${a.key}`;
+  return `#${index + 1} ${a.name}${onPage}${detail ? ` ${detail}` : ""}`;
+}
+function listStepsFrom(allActions, fromIndex) {
+  if (fromIndex >= allActions.length)
+    return "(none remaining)";
+  return allActions.slice(fromIndex).map((a, i) => describeStep(a, fromIndex + i)).join("\n");
+}
+const ENTER_FRAME = " >> internal:control=enter-frame >> ";
+function buildFullSelector(framePath, selector) {
+  return [...framePath ?? [], selector].join(ENTER_FRAME);
+}
+function describeStopReason(result) {
+  switch (result.stopReason) {
+    case "done":
+      return "Reached the end of the trace.";
+    case "stopAtStep":
+      return `Stopped at the requested step (${result.completedCount}).`;
+    case "stopAtUrl":
+      return "Stopped because the active page URL matched the requested pattern.";
+    case "stopBefore":
+      return "Stopped just before the requested action.";
+    case "error":
+      return "Stopped because an action failed.";
+  }
+}
+async function replayActions(actionsList, callbacks, params) {
+  const delay = params.speed === "slow" ? 1e3 : 0;
+  const stopBefore = params.stopBefore?.toLowerCase();
+  let completedCount = 0;
+  for (let i = 0; i < actionsList.length; i++) {
+    const action = actionsList[i];
+    if (stopBefore && describeStep(action, i).toLowerCase().includes(stopBefore))
+      return { completedCount, stopIndex: i, stopReason: "stopBefore" };
+    const alias = action.frame.pageAlias || "page";
+    const page = callbacks.pageForAlias(alias);
+    if (!METADATA_ONLY_ACTIONS.has(action.action.name)) {
+      if (!page) {
+        return {
+          completedCount,
+          stopIndex: i,
+          stopReason: "error",
+          error: { message: `No live page for alias "${alias}"`, actionName: action.action.name, stepIndex: i + 1 }
+        };
+      }
+      try {
+        await performClientAction(page, action);
+      } catch (e) {
+        return {
+          completedCount,
+          stopIndex: i,
+          stopReason: "error",
+          error: { message: e.message, actionName: action.action.name, stepIndex: i + 1 }
+        };
+      }
+    }
+    completedCount = i + 1;
+    if (params.stopAtStep !== void 0 && completedCount >= params.stopAtStep)
+      return { completedCount, stopIndex: i + 1, stopReason: "stopAtStep" };
+    if (params.stopAtUrl) {
+      const currentUrl = page?.url() ?? "";
+      if (urlMatchesPattern(currentUrl, params.stopAtUrl))
+        return { completedCount, stopIndex: i + 1, stopReason: "stopAtUrl" };
+    }
+    if (delay)
+      await new Promise((resolve) => setTimeout(resolve, delay));
+  }
+  return { completedCount, stopIndex: actionsList.length, stopReason: "done" };
+}
+function urlMatchesPattern(currentUrl, pattern) {
+  const regexLiteral = /^\/(.*)\/([a-z]*)$/i.exec(pattern);
+  if (regexLiteral) {
+    try {
+      return new RegExp(regexLiteral[1], regexLiteral[2]).test(currentUrl);
+    } catch {
+    }
+  }
+  if (/[*{]/.test(pattern))
+    return (0, import_utils.urlMatches)(void 0, currentUrl, pattern);
+  return currentUrl.toLowerCase().includes(pattern.toLowerCase());
+}
+async function withMouseModifiers(page, mask, fn) {
+  const keys = (0, import_mouseActions.decodeModifierKeys)(mask);
+  for (const k of keys)
+    await page.keyboard.down(k);
+  try {
+    await fn();
+  } finally {
+    for (const k of [...keys].reverse())
+      await page.keyboard.up(k);
+  }
+}
+const DEFAULT_ACTION_TIMEOUT = 15e3;
+async function performClientAction(page, actionInContext) {
+  const action = actionInContext.action;
+  const opts = { timeout: DEFAULT_ACTION_TIMEOUT };
+  if (action.name === "navigate") {
+    await page.goto(action.url, { ...opts, waitUntil: "domcontentloaded" });
+    return;
+  }
+  if (action.name === "waitForTimeout") {
+    await new Promise((resolve) => setTimeout(resolve, action.duration ?? 0));
+    return;
+  }
+  if (action.name === "waitForSelector") {
+    const state = action.state === "hidden" ? "hidden" : "visible";
+    const waitSelector = buildFullSelector(actionInContext.frame.framePath, action.selector);
+    await page.locator(waitSelector).first().waitFor({ state, ...opts }).catch(() => {
+    });
+    return;
+  }
+  if (action.name === "dragAndDrop" || action.name === "dragTo") {
+    const fp = actionInContext.frame.framePath;
+    const sourceSel = buildFullSelector(fp, action.source ?? action.selector);
+    const targetSel = buildFullSelector(fp, action.target ?? action.targetSelector);
+    await page.locator(sourceSel).dragTo(page.locator(targetSel), opts);
+    return;
+  }
+  if (action.name === "press" && !action.selector) {
+    const modifiers = decodeModifiers(action.modifiers);
+    const shortcut = [...modifiers, action.key].join("+");
+    await page.keyboard.press(shortcut);
+    return;
+  }
+  if (action.name === "mouse.move") {
+    if (!action.position)
+      return;
+    if (action.steps !== void 0)
+      await page.mouse.move(action.position.x, action.position.y, { steps: action.steps });
+    else
+      await page.mouse.move(action.position.x, action.position.y);
+    return;
+  }
+  if (action.name === "mouse.down") {
+    if (action.button && action.button !== "left")
+      await page.mouse.down({ button: action.button });
+    else
+      await page.mouse.down();
+    return;
+  }
+  if (action.name === "mouse.up") {
+    if (action.button && action.button !== "left")
+      await page.mouse.up({ button: action.button });
+    else
+      await page.mouse.up();
+    return;
+  }
+  if (action.name === "mouse.wheel") {
+    await withMouseModifiers(page, action.modifiers, () => page.mouse.wheel(action.deltaX ?? 0, action.deltaY ?? 0));
+    return;
+  }
+  if (action.name === "click" && action.position && (!action.selector || action.selector === "body")) {
+    const button = action.button ?? "left";
+    const clickCount = action.clickCount ?? 1;
+    const needsOpts = button !== "left" || clickCount !== 1;
+    await withMouseModifiers(page, action.modifiers, () => needsOpts ? page.mouse.click(action.position.x, action.position.y, { button, clickCount }) : page.mouse.click(action.position.x, action.position.y));
+    return;
+  }
+  if (!action.selector)
+    return;
+  const selector = buildFullSelector(actionInContext.frame.framePath, action.selector);
+  const locator = page.locator(selector);
+  switch (action.name) {
+    case "click": {
+      const clickOpts = { ...opts };
+      if (action.button && action.button !== "left")
+        clickOpts.button = action.button;
+      if (action.clickCount && action.clickCount > 1)
+        clickOpts.clickCount = action.clickCount;
+      if (action.position)
+        clickOpts.position = action.position;
+      const modifiers = decodeModifiers(action.modifiers);
+      if (modifiers.length)
+        clickOpts.modifiers = modifiers;
+      await locator.click(clickOpts);
+      return;
+    }
+    case "hover":
+      await locator.hover({ ...opts, ...action.position ? { position: action.position } : {} });
+      return;
+    case "fill":
+      await locator.fill(action.text ?? "", opts);
+      return;
+    case "pressSequentially":
+      await locator.pressSequentially(action.text ?? "", opts);
+      return;
+    case "press": {
+      const modifiers = decodeModifiers(action.modifiers);
+      const shortcut = [...modifiers, action.key].join("+");
+      await locator.press(shortcut, opts);
+      return;
+    }
+    case "check":
+      await locator.check(opts);
+      return;
+    case "uncheck":
+      await locator.uncheck(opts);
+      return;
+    case "select":
+      await locator.selectOption(action.options ?? [], opts);
+      return;
+    case "setInputFiles":
+      await locator.setInputFiles(action.files ?? [], opts);
+      return;
+    case "fileChooser": {
+      const fileChooserPromise = page.waitForEvent("filechooser");
+      await locator.click(opts);
+      const fileChooser = await fileChooserPromise;
+      await fileChooser.setFiles(action.files ?? []);
+      return;
+    }
+    // Assertions: re-run against the live page so a drifted trace fails loudly
+    // (faithful to the manual recorder's replay).
+    case "assertText": {
+      const actual = await locator.textContent(opts) ?? "";
+      const substring = action.substring !== false;
+      const ok = substring ? actual.includes(action.text) : actual.trim() === String(action.text).trim();
+      if (!ok)
+        throw new Error(`assertText failed: expected text to ${substring ? "contain" : "equal"} ${JSON.stringify(action.text)}, got ${JSON.stringify(actual)}`);
+      return;
+    }
+    case "assertValue": {
+      const actual = await locator.inputValue(opts);
+      if (actual !== action.value)
+        throw new Error(`assertValue failed: expected ${JSON.stringify(action.value)}, got ${JSON.stringify(actual)}`);
+      return;
+    }
+    case "assertChecked": {
+      const checked = await locator.isChecked(opts);
+      if (checked !== !!action.checked)
+        throw new Error(`assertChecked failed: expected checked=${!!action.checked}, got ${checked}`);
+      return;
+    }
+    case "assertVisible": {
+      const visible = await locator.isVisible(opts);
+      if (!visible)
+        throw new Error(`assertVisible failed: element is not visible`);
+      return;
+    }
+    default:
+      return;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  decodeModifiers,
+  describeStep,
+  describeStopReason,
+  listStepsFrom,
+  loadTraceMcpTool,
+  loadTraceSchema,
+  replayActions,
+  urlMatchesPattern
+});

package/node_modules/playwright/lib/mcp/skyramp/mouseActionTool.js

@@ -0,0 +1,131 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var mouseActionTool_exports = {};
+__export(mouseActionTool_exports, {
+  _schema: () => mouseActionSchema,
+  executeMouseAction: () => executeMouseAction,
+  mouseActionMcpTool: () => mouseActionMcpTool,
+  mouseActionSchema: () => mouseActionSchema
+});
+module.exports = __toCommonJS(mouseActionTool_exports);
+var import_mcpBundle = require("playwright-core/lib/mcpBundle");
+var import_tool = require("../sdk/tool");
+var import_mouseActions = require("./common/mouseActions");
+const mouseActionSchema = {
+  name: "browser_mouse_action",
+  title: "Mouse action (coordinate-based)",
+  description: [
+    "Perform coordinate-based mouse interactions: drag-and-drop, slider adjustment, canvas/diagram manipulation, scrolling, and other gestures that operate on viewport pixel positions rather than element references.",
+    "Primary uses: drag an item between positions (drag), move a slider thumb (drag), pan/draw on a canvas (move/down/up), and scroll a region (wheel).",
+    "The `action` parameter selects the gesture:",
+    "- drag: press at (x, y), move to (endX, endY), release. Decomposed into low-level mouse events (move\u2192down\u2192move\u2192up) so it works for sliders, canvas, and custom drag-handles where high-level element drag fails.",
+    "- move / down / up: individual pointer steps for composing custom gestures.",
+    "- wheel: scroll by deltaX / deltaY at the pointer position.",
+    '- click: a single position click at (x, y). Use for canvas hotspots, or as a fallback for an interactive element that has no usable accessibility ref or is occluded by an overlay (where browser_click reports "intercepts pointer events"). For ordinary elements, prefer browser_click.',
+    "Coordinates are viewport pixels, obtained from a snapshot or screenshot."
+  ].join(" "),
+  inputSchema: import_mcpBundle.z.object({
+    action: import_mcpBundle.z.enum(["move", "down", "up", "click", "wheel", "drag"]).describe("The mouse action to perform."),
+    x: import_mcpBundle.z.number().optional().describe("X coordinate (viewport px). Required for move/click/wheel; the start X for drag."),
+    y: import_mcpBundle.z.number().optional().describe("Y coordinate (viewport px). Required for move/click/wheel; the start Y for drag."),
+    endX: import_mcpBundle.z.number().optional().describe("End X coordinate for drag."),
+    endY: import_mcpBundle.z.number().optional().describe("End Y coordinate for drag."),
+    button: import_mcpBundle.z.enum(["left", "right", "middle"]).optional().describe("Mouse button for down/up/click. Defaults to left."),
+    clickCount: import_mcpBundle.z.number().int().positive().optional().describe("Number of clicks for click (e.g. 2 for double-click). Defaults to 1."),
+    deltaX: import_mcpBundle.z.number().optional().describe("Horizontal scroll delta for wheel."),
+    deltaY: import_mcpBundle.z.number().optional().describe("Vertical scroll delta for wheel."),
+    steps: import_mcpBundle.z.number().int().positive().optional().describe("Intermediate move steps for move/drag (smoother movement)."),
+    modifiers: import_mcpBundle.z.number().int().min(0).max(15).optional().describe("Modifier bitmask (Alt=1, Control=2, Meta=4, Shift=8) for click/wheel. Range 0-15.")
+  }),
+  type: "action"
+};
+function mouseActionMcpTool() {
+  return (0, import_tool.toMcpTool)(mouseActionSchema);
+}
+async function executeMouseAction(page, params) {
+  const built = (0, import_mouseActions.mouseActionToJsonl)(params);
+  if ("error" in built)
+    return { result: { content: [{ type: "text", text: `### Error
+${built.error}` }], isError: true }, actions: [] };
+  if (!page)
+    return { result: { content: [{ type: "text", text: "### Error\nNo open page. Call browser_navigate first." }], isError: true }, actions: [] };
+  const code = [];
+  try {
+    for (const a of built.actions) {
+      code.push(...(0, import_mouseActions.mouseJsonlToCode)(a));
+      await runOne(page, a);
+    }
+  } catch (e) {
+    return { result: { content: [{ type: "text", text: `### Error
+Mouse action failed: ${e.message}` }], isError: true }, actions: [] };
+  }
+  return {
+    result: { content: [{ type: "text", text: `### Ran Playwright code
+${code.join("\n")}` }] },
+    actions: built.actions
+  };
+}
+async function runOne(page, a) {
+  switch (a.name) {
+    case "mouse.move":
+      if (a.steps !== void 0)
+        await page.mouse.move(a.position.x, a.position.y, { steps: a.steps });
+      else
+        await page.mouse.move(a.position.x, a.position.y);
+      return;
+    case "mouse.down":
+      if (a.button && a.button !== "left")
+        await page.mouse.down({ button: a.button });
+      else
+        await page.mouse.down();
+      return;
+    case "mouse.up":
+      if (a.button && a.button !== "left")
+        await page.mouse.up({ button: a.button });
+      else
+        await page.mouse.up();
+      return;
+    case "mouse.wheel":
+      await withModifiers(page, a.modifiers, () => page.mouse.wheel(a.deltaX, a.deltaY));
+      return;
+    case "click": {
+      const needsOpts = a.button !== "left" || a.clickCount !== 1;
+      await withModifiers(page, a.modifiers, () => needsOpts ? page.mouse.click(a.position.x, a.position.y, { button: a.button, clickCount: a.clickCount }) : page.mouse.click(a.position.x, a.position.y));
+      return;
+    }
+  }
+}
+async function withModifiers(page, mask, fn) {
+  const keys = (0, import_mouseActions.decodeModifierKeys)(mask);
+  for (const k of keys)
+    await page.keyboard.down(k);
+  try {
+    await fn();
+  } finally {
+    for (const k of [...keys].reverse())
+      await page.keyboard.up(k);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  _schema,
+  executeMouseAction,
+  mouseActionMcpTool,
+  mouseActionSchema
+});

package/node_modules/playwright/lib/mcp/skyramp/skyRampImport.js

@@ -0,0 +1,146 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var skyRampImport_exports = {};
+__export(skyRampImport_exports, {
+  actionsFromFile: () => actionsFromFile,
+  actionsFromPath: () => actionsFromPath,
+  actionsFromZip: () => actionsFromZip,
+  parseJsonl: () => parseJsonl
+});
+module.exports = __toCommonJS(skyRampImport_exports);
+var import_fs = __toESM(require("fs"));
+var import_utils = require("playwright-core/lib/utils");
+const SKYRAMP_ACTIVITIES_FILE = "skyramp_playwright.txt";
+const ACTION_NAMES = /* @__PURE__ */ new Set([
+  "marker",
+  "comment",
+  "beginBlock",
+  "endBlock",
+  "check",
+  "click",
+  "hover",
+  "closePage",
+  "fill",
+  "pressSequentially",
+  "navigate",
+  "openPage",
+  "press",
+  "select",
+  "uncheck",
+  "setInputFiles",
+  "assertText",
+  "assertValue",
+  "assertChecked",
+  "assertVisible",
+  "assertSnapshot",
+  "visualSnapshot",
+  "assertTableCell",
+  "dragTo",
+  "dragAndDrop",
+  "diagramNodeAdd",
+  "diagramLinkAdd",
+  "selectArea",
+  "tableSnapshot",
+  "domSnapshot",
+  "fileChooser",
+  "penTool",
+  "mouse.wheel",
+  "mouse.move",
+  "mouse.down",
+  "mouse.up",
+  "modalOpen",
+  "modalClose",
+  "iframeLoad",
+  "assertApiRequest",
+  "waitForSelector",
+  "waitForTimeout"
+]);
+function isActionName(name) {
+  return ACTION_NAMES.has(name);
+}
+async function actionsFromZip(zipPath) {
+  const zip = new import_utils.ZipFile(zipPath);
+  try {
+    const entries = await zip.entries();
+    const entry = entries.find((e) => e === SKYRAMP_ACTIVITIES_FILE) ?? entries.find((e) => e.endsWith(".jsonl")) ?? entries.find((e) => e.endsWith(".txt"));
+    if (!entry)
+      throw new Error(`No activities file found in ${zipPath}. Expected '${SKYRAMP_ACTIVITIES_FILE}' or a .jsonl/.txt file.`);
+    const buffer = await zip.read(entry);
+    return parseJsonl(buffer.toString("utf-8"));
+  } finally {
+    zip.close();
+  }
+}
+function actionsFromFile(jsonlPath) {
+  return parseJsonl(import_fs.default.readFileSync(jsonlPath, "utf-8"));
+}
+async function actionsFromPath(tracePath) {
+  return tracePath.endsWith(".zip") ? await actionsFromZip(tracePath) : actionsFromFile(tracePath);
+}
+function parseJsonl(content) {
+  const result = [];
+  for (const line of content.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed)
+      continue;
+    const action = parseLine(trimmed);
+    if (action)
+      result.push(action);
+  }
+  return result;
+}
+function parseLine(line) {
+  let entry;
+  try {
+    entry = JSON.parse(line);
+  } catch {
+    return null;
+  }
+  if (!entry.name || !isActionName(entry.name))
+    return null;
+  const { pageGuid, pageAlias, framePath, locator: _locator, ...actionFields } = entry;
+  const frame = {
+    pageGuid: pageGuid ?? "",
+    pageAlias: pageAlias ?? "page",
+    framePath: framePath ?? []
+  };
+  const ts = typeof entry.timestamp === "number" ? entry.timestamp : typeof entry.timestamp === "string" && /^\d+$/.test(entry.timestamp.trim()) ? Number(entry.timestamp.trim()) : Date.now();
+  return {
+    frame,
+    action: actionFields,
+    startTime: ts
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  actionsFromFile,
+  actionsFromPath,
+  actionsFromZip,
+  parseJsonl
+});