momentic 0.0.17 → 0.0.18

package/bin/cli.js

@@ -1,9 +1,7 @@
 #!/usr/bin/env node
 var __defProp = Object.defineProperty;
 var __defProps = Object.defineProperties;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
-var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getOwnPropSymbols = Object.getOwnPropertySymbols;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __propIsEnum = Object.prototype.propertyIsEnumerable;
@@ -32,19 +30,6 @@ var __objRest = (source, exclude) => {
     }
   return target;
 };
-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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
 var __async = (__this, __arguments, generator) => {
   return new Promise((resolve, reject) => {
     var fulfilled = (value) => {
@@ -67,31 +52,8 @@ var __async = (__this, __arguments, generator) => {
 };
 
 // src/cli.ts
-import { Command as Command4, Option } from "commander";
-
-// package.json
-var version = "1.0.0";
-
-// src/install-browsers.ts
-import { registry } from "playwright-core/lib/server";
-function installBrowsers() {
-  return __async(this, null, function* () {
-    const executables = registry.defaultExecutables();
-    yield registry.install(executables, false);
-  });
-}
-
-// src/run-tests-locally.ts
-import exec from "@actions/exec";
-import io from "@actions/io";
-import chalk from "chalk";
-import quote from "quote";
-import parseArgsStringToArgv2 from "string-argv";
-import waitOnFn from "wait-on";
-
-// ../../packages/types/src/commands.ts
-import dedent from "dedent";
-import * as z2 from "zod";
+import { Command as Command3, Option as Option2 } from "commander";
+import { existsSync as existsSync4 } from "fs";
 
 // ../../packages/types/src/a11y-targets.ts
 import * as z from "zod";
@@ -102,12 +64,27 @@ var A11yTargetWithCacheSchema = z.object({
   // to assist in re-execution
   role: z.string().optional(),
   name: z.string().optional(),
+  numChildren: z.number().optional(),
   content: z.string().optional(),
   pathFromRoot: z.string().optional(),
   serializedForm: z.string().optional()
 });
 
+// ../../packages/types/src/assertions.ts
+import { z as z2 } from "zod";
+var AIAssertionResultSchema = z2.object({
+  thoughts: z2.string(),
+  result: z2.boolean(),
+  relevantElements: z2.array(z2.number()).optional()
+});
+
+// ../../packages/types/src/ai-command-generation.ts
+import parseArgsStringToArgv from "string-argv";
+import { z as z4 } from "zod";
+
 // ../../packages/types/src/commands.ts
+import dedent from "dedent";
+import * as z3 from "zod";
 var CommandType = /* @__PURE__ */ ((CommandType2) => {
   CommandType2["AI_ASSERTION"] = "AI_ASSERTION";
   CommandType2["CLICK"] = "CLICK";
@@ -123,130 +100,137 @@ var CommandType = /* @__PURE__ */ ((CommandType2) => {
   CommandType2["REFRESH"] = "REFRESH";
   CommandType2["TAB"] = "TAB";
   CommandType2["COOKIE"] = "COOKIE";
+  CommandType2["HOVER"] = "HOVER";
   CommandType2["SUCCESS"] = "SUCCESS";
   return CommandType2;
 })(CommandType || {});
-var ElementDescriptorSchema = z2.object({
+var ElementTargetSchema = z3.object({
   // natural language passed to LLM
-  elementDescriptor: z2.string(),
+  elementDescriptor: z3.string(),
   // Cached A11y target - when a user creates a preset action, this will not exist
   a11yData: A11yTargetWithCacheSchema.optional()
 });
-var CommonCommandSchema = z2.object({
+var CommonCommandSchema = z3.object({
   // If the command is suggested by AI, why it did so
-  thoughts: z2.string().optional()
+  thoughts: z3.string().optional()
 });
 var NavigateCommandSchema = CommonCommandSchema.merge(
-  z2.object({
-    type: z2.literal("NAVIGATE" /* NAVIGATE */),
-    url: z2.string()
+  z3.object({
+    type: z3.literal("NAVIGATE" /* NAVIGATE */),
+    url: z3.string()
   })
 ).describe("NAVIGATE <url> - Go to the specified url");
 var ScrollUpCommandSchema = CommonCommandSchema.merge(
-  z2.object({
-    type: z2.literal("SCROLL_UP" /* SCROLL_UP */)
+  z3.object({
+    type: z3.literal("SCROLL_UP" /* SCROLL_UP */)
   })
 ).describe("SCROLL_UP - Scroll up one page");
 var ScrollDownCommandSchema = CommonCommandSchema.merge(
-  z2.object({
-    type: z2.literal("SCROLL_DOWN" /* SCROLL_DOWN */)
+  z3.object({
+    type: z3.literal("SCROLL_DOWN" /* SCROLL_DOWN */)
   })
 ).describe("SCROLL_DOWN - Scroll down one page");
 var WaitCommandSchema = CommonCommandSchema.merge(
-  z2.object({
-    type: z2.literal("WAIT" /* WAIT */),
-    delay: z2.number()
+  z3.object({
+    type: z3.literal("WAIT" /* WAIT */),
+    delay: z3.number()
     // seconds
   })
 );
 var RefreshCommandSchema = CommonCommandSchema.merge(
-  z2.object({
-    type: z2.literal("REFRESH" /* REFRESH */)
+  z3.object({
+    type: z3.literal("REFRESH" /* REFRESH */)
   })
 );
 var GoBackCommandSchema = CommonCommandSchema.merge(
-  z2.object({
-    type: z2.literal("GO_BACK" /* GO_BACK */)
+  z3.object({
+    type: z3.literal("GO_BACK" /* GO_BACK */)
   })
 );
 var GoForwardCommandSchema = CommonCommandSchema.merge(
-  z2.object({
-    type: z2.literal("GO_FORWARD" /* GO_FORWARD */)
+  z3.object({
+    type: z3.literal("GO_FORWARD" /* GO_FORWARD */)
   })
 );
 var ClickCommandSchema = CommonCommandSchema.merge(
-  z2.object({
-    type: z2.literal("CLICK" /* CLICK */),
-    target: ElementDescriptorSchema,
-    doubleClick: z2.boolean().default(false),
-    rightClick: z2.boolean().default(false)
+  z3.object({
+    type: z3.literal("CLICK" /* CLICK */),
+    target: ElementTargetSchema,
+    doubleClick: z3.boolean().default(false),
+    rightClick: z3.boolean().default(false)
   })
 ).describe(
   dedent`CLICK <id> - click on the element that has the specified id.
   You are NOT allowed to click on disabled, hidden or StaticText elements.
   Only click on elements on the Current Page.
   Only click on elements with the following tag names: button, input, link, image, generic.
-  `.replace("\n", " ")
+  `.replaceAll("\n", " ")
+);
+var HoverCommandSchema = CommonCommandSchema.merge(
+  z3.object({
+    type: z3.literal("HOVER" /* HOVER */),
+    target: ElementTargetSchema
+  })
 );
 var SelectOptionCommandSchema = CommonCommandSchema.merge(
-  z2.object({
-    type: z2.literal("SELECT_OPTION" /* SELECT_OPTION */),
-    target: ElementDescriptorSchema,
-    option: z2.string()
+  z3.object({
+    type: z3.literal("SELECT_OPTION" /* SELECT_OPTION */),
+    target: ElementTargetSchema,
+    option: z3.string()
   })
 ).describe(
   // TODO: if we move to a non-mutative way of selecting elements (e.g. by selector), we should update this description
   `SELECT_OPTION <id> "<option>" - select the specified item from the select with the specified id. The item should exist on the page. Use the name of the item instead of the id. Make sure to include quotes around the option.`
 );
 var AIAssertionCommandSchema = CommonCommandSchema.merge(
-  z2.object({
-    type: z2.literal("AI_ASSERTION" /* AI_ASSERTION */),
-    assertion: z2.string(),
-    useVision: z2.boolean().default(false),
-    disableCache: z2.boolean().default(false)
+  z3.object({
+    type: z3.literal("AI_ASSERTION" /* AI_ASSERTION */),
+    assertion: z3.string(),
+    useVision: z3.boolean().default(false),
+    disableCache: z3.boolean().default(false)
   })
 );
-var TypeOptionsSchema = z2.object({
-  clearContent: z2.boolean().default(true),
-  pressKeysSequentially: z2.boolean().default(false)
+var TypeOptionsSchema = z3.object({
+  clearContent: z3.boolean().default(true),
+  pressKeysSequentially: z3.boolean().default(false)
 });
 var TypeCommandSchema = CommonCommandSchema.merge(
-  z2.object({
-    type: z2.literal("TYPE" /* TYPE */),
-    target: ElementDescriptorSchema,
-    value: z2.string(),
-    pressEnter: z2.boolean().default(false)
+  z3.object({
+    type: z3.literal("TYPE" /* TYPE */),
+    target: ElementTargetSchema,
+    value: z3.string(),
+    pressEnter: z3.boolean().default(false)
   })
 ).merge(TypeOptionsSchema).describe(
   `TYPE <id> "<text>" - type the specified text into the input with the specified id. The text should be specified by the user - do not use text from the EXAMPLES or generate text yourself. Make sure to include quotes around the text.`
 );
 var PressCommandSchema = CommonCommandSchema.merge(
-  z2.object({
-    type: z2.literal("PRESS" /* PRESS */),
-    value: z2.string()
+  z3.object({
+    type: z3.literal("PRESS" /* PRESS */),
+    value: z3.string()
   })
 ).describe(
   `PRESS <key> - press the specified key, such as "ArrowLeft", "Enter", or "a". You must specify at least one key.`
 );
 var TabCommandSchema = CommonCommandSchema.merge(
-  z2.object({
-    type: z2.literal("TAB" /* TAB */),
-    url: z2.string()
+  z3.object({
+    type: z3.literal("TAB" /* TAB */),
+    url: z3.string()
   })
 );
 var CookieCommandSchema = CommonCommandSchema.merge(
-  z2.object({
-    type: z2.literal("COOKIE" /* COOKIE */),
-    value: z2.string()
+  z3.object({
+    type: z3.literal("COOKIE" /* COOKIE */),
+    value: z3.string()
   })
 );
 var SuccessCommandSchema = CommonCommandSchema.merge(
-  z2.object({
-    type: z2.literal("SUCCESS" /* SUCCESS */),
+  z3.object({
+    type: z3.literal("SUCCESS" /* SUCCESS */),
     condition: AIAssertionCommandSchema.optional()
   })
 ).describe("SUCCESS - the user goal has been successfully achieved");
-var UserEditableAICommandSchema = z2.discriminatedUnion("type", [
+var UserEditableAICommandSchema = z3.discriminatedUnion("type", [
   ClickCommandSchema,
   TypeCommandSchema,
   PressCommandSchema,
@@ -256,119 +240,144 @@ var UserEditableAICommandSchema = z2.discriminatedUnion("type", [
   ScrollUpCommandSchema,
   SuccessCommandSchema
 ]);
-var UserEditablePresetCommandSchema = z2.discriminatedUnion("type", [
+var UserEditablePresetCommandSchema = z3.discriminatedUnion("type", [
   GoBackCommandSchema,
   GoForwardCommandSchema,
   RefreshCommandSchema,
   AIAssertionCommandSchema,
   WaitCommandSchema,
   TabCommandSchema,
-  CookieCommandSchema
+  CookieCommandSchema,
+  HoverCommandSchema
 ]);
-var CommandSchema = z2.discriminatedUnion("type", [
+var CommandSchema = z3.discriminatedUnion("type", [
   // Commands that can be either specified manually or auto-created by AI in an AI step
   ...UserEditableAICommandSchema.options,
   // Commands that can only be specified manually ("preset commands")
   ...UserEditablePresetCommandSchema.options
 ]);
 var FailureCommandSchema = CommonCommandSchema.merge(
-  z2.object({
-    type: z2.literal("FAILURE")
+  z3.object({
+    type: z3.literal("FAILURE")
   })
 ).describe(
   "FAILURE - there are no commands to suggest that could make progress that have not already been tried before"
 );
-var AICommandSchema = z2.discriminatedUnion("type", [
+var AICommandSchema = z3.discriminatedUnion("type", [
   ...UserEditableAICommandSchema.options,
   FailureCommandSchema
 ]);
 
+// ../../packages/types/src/errors.ts
+var BrowserExecutionError = class extends Error {
+  constructor(message, options = {}) {
+    super(message, options);
+    this.name = "BrowserExecutionError";
+  }
+};
+var EmptyA11yTreeError = class extends Error {
+  constructor(options = {}) {
+    super("Got empty a11y tree", options);
+    this.name = "EmptyA11yTreeError";
+  }
+};
+
+// ../../packages/types/src/ai-command-generation.ts
+var LLMOutputSchema = z4.object({
+  command: z4.string(),
+  thoughts: z4.string()
+});
+var NumericStringSchema = z4.string().pipe(z4.coerce.number());
+
 // ../../packages/types/src/steps.ts
-import * as z3 from "zod";
+import * as z5 from "zod";
+var LATEST_VERSION = "1.0.6";
 var StepType = /* @__PURE__ */ ((StepType2) => {
   StepType2["AI_ACTION"] = "AI_ACTION";
   StepType2["PRESET_ACTION"] = "PRESET_ACTION";
   StepType2["MODULE"] = "MODULE";
   return StepType2;
 })(StepType || {});
-var AIActionSchema = z3.object({
-  type: z3.literal("AI_ACTION" /* AI_ACTION */),
-  text: z3.string(),
+var AIActionSchema = z5.object({
+  type: z5.literal("AI_ACTION" /* AI_ACTION */),
+  text: z5.string(),
   // Cached commands for this step
-  commands: z3.array(UserEditableAICommandSchema).optional()
+  commands: z5.array(UserEditableAICommandSchema).optional()
 });
-var PresetActionSchema = z3.object({
-  type: z3.literal("PRESET_ACTION" /* PRESET_ACTION */),
+var PresetActionSchema = z5.object({
+  type: z5.literal("PRESET_ACTION" /* PRESET_ACTION */),
   command: CommandSchema
 });
-var ModuleStepSchema = z3.object({
-  type: z3.literal("MODULE" /* MODULE */),
-  moduleId: z3.string().uuid()
+var ModuleStepSchema = z5.object({
+  type: z5.literal("MODULE" /* MODULE */),
+  moduleId: z5.string().uuid()
 });
-var AllowedModuleStepSchema = z3.union([
+var AllowedModuleStepSchema = z5.union([
   AIActionSchema,
   PresetActionSchema
 ]);
-var ResolvedModuleStepSchema = z3.object({
-  type: z3.literal("RESOLVED_MODULE"),
-  moduleId: z3.string().uuid(),
-  name: z3.string(),
+var ResolvedModuleStepSchema = z5.object({
+  type: z5.literal("RESOLVED_MODULE"),
+  moduleId: z5.string().uuid(),
+  name: z5.string(),
   steps: AllowedModuleStepSchema.array()
 });
-var StepSchema = z3.union([
+var StepSchema = z5.union([
   AIActionSchema,
   PresetActionSchema,
   ModuleStepSchema
 ]);
-var ResolvedStepSchema = z3.union([
+var ResolvedStepSchema = z5.union([
   AIActionSchema,
   PresetActionSchema,
   ResolvedModuleStepSchema
 ]);
 
-// ../../node_modules/.pnpm/playwright@1.40.1/node_modules/playwright/index.mjs
-var playwright_exports = {};
-__export(playwright_exports, {
-  default: () => playwright_default
-});
-__reExport(playwright_exports, playwright_core_star);
-import * as playwright_core_star from "playwright-core";
-import playwright from "playwright-core";
-var playwright_default = playwright;
-
-// ../../packages/types/src/assertions.ts
-import { z as z4 } from "zod";
-var AIAssertionResultSchema = z4.object({
-  thoughts: z4.string(),
-  result: z4.boolean(),
-  relevantElements: z4.array(z4.number()).optional()
-});
-
-// ../../packages/types/src/ai-command-generation.ts
-import parseArgsStringToArgv from "string-argv";
-import { z as z5 } from "zod";
-
-// ../../packages/types/src/errors.ts
-var BrowserExecutionError = class extends Error {
-  constructor(message, options = {}) {
-    super(message, options);
-    this.name = "BrowserExecutionError";
-  }
+// ../../packages/types/src/card-display.ts
+var SELECTABLE_PRESET_COMMAND_OPTIONS_SET = new Set(
+  Object.values(CommandType)
+);
+var CARD_DISPLAY_NAMES = {
+  ["AI_ACTION" /* AI_ACTION */]: "AI action",
+  ["MODULE" /* MODULE */]: "Module",
+  ["AI_ASSERTION" /* AI_ASSERTION */]: "AI check",
+  ["CLICK" /* CLICK */]: "Click",
+  ["HOVER" /* HOVER */]: "Hover",
+  ["SELECT_OPTION" /* SELECT_OPTION */]: "Select",
+  ["TYPE" /* TYPE */]: "Type",
+  ["PRESS" /* PRESS */]: "Press",
+  ["NAVIGATE" /* NAVIGATE */]: "Navigate",
+  ["SCROLL_UP" /* SCROLL_UP */]: "Scroll up",
+  ["SCROLL_DOWN" /* SCROLL_DOWN */]: "Scroll down",
+  ["GO_BACK" /* GO_BACK */]: "Go back",
+  ["GO_FORWARD" /* GO_FORWARD */]: "Go forward",
+  ["WAIT" /* WAIT */]: "Wait",
+  ["REFRESH" /* REFRESH */]: "Refresh",
+  ["TAB" /* TAB */]: "Switch tab",
+  ["COOKIE" /* COOKIE */]: "Set cookie",
+  ["SUCCESS" /* SUCCESS */]: "Done"
 };
-var EmptyA11yTreeError = class extends Error {
-  constructor(options = {}) {
-    super("Got empty a11y tree", options);
-    this.name = "EmptyA11yTreeError";
-  }
+var CARD_DESCRIPTIONS = {
+  ["AI_ACTION" /* AI_ACTION */]: "Ask AI to plan and execute something on the page.",
+  ["MODULE" /* MODULE */]: "A list of steps that can be reused in multiple tests.",
+  ["AI_ASSERTION" /* AI_ASSERTION */]: "Ask AI whether something is true on the page.",
+  ["CLICK" /* CLICK */]: "Click on an element on the page based on a description.",
+  ["HOVER" /* HOVER */]: "Hover over an element on the page based on a description.",
+  ["SELECT_OPTION" /* SELECT_OPTION */]: "Select an option from a dropdown based on a description.",
+  ["TYPE" /* TYPE */]: "Type the specified text into an element.",
+  ["PRESS" /* PRESS */]: "Press the specified keys using the keyboard. (e.g. Ctrl+A)",
+  ["NAVIGATE" /* NAVIGATE */]: "Navigate to the specified URL.",
+  ["SCROLL_UP" /* SCROLL_UP */]: "Scroll up one page.",
+  ["SCROLL_DOWN" /* SCROLL_DOWN */]: "Scroll down one page.",
+  ["GO_BACK" /* GO_BACK */]: "Go back in browser history.",
+  ["GO_FORWARD" /* GO_FORWARD */]: "Go forward in browser history.",
+  ["WAIT" /* WAIT */]: "Wait for the specified number of seconds.",
+  ["REFRESH" /* REFRESH */]: "Refresh the page. This will not clear cookies or session data.",
+  ["TAB" /* TAB */]: "Switch to different tab in the browser.",
+  ["COOKIE" /* COOKIE */]: "Set a cookie that will persist throughout the browser session",
+  ["SUCCESS" /* SUCCESS */]: "Indicate the entire AI action has succeeded, optionally based on a condition."
 };
 
-// ../../packages/types/src/ai-command-generation.ts
-var LLMOutputSchema = z5.object({
-  command: z5.string(),
-  thoughts: z5.string()
-});
-var NumericStringSchema = z5.string().pipe(z5.coerce.number());
-
 // ../../packages/types/src/command-results.ts
 import * as z6 from "zod";
 var ResultStatus = /* @__PURE__ */ ((ResultStatus2) => {
@@ -441,6 +450,105 @@ var ResultSchema = z6.discriminatedUnion("type", [
   ModuleResultSchema
 ]);
 
+// ../../packages/types/src/command-serialization.ts
+function clampText(text, length) {
+  if (text.length < length) {
+    return text;
+  }
+  return text.slice(0, length - 3) + "[...]";
+}
+function serializeCommand(command) {
+  var _a, _b, _c;
+  switch (command.type) {
+    case "SUCCESS" /* SUCCESS */:
+      if ((_a = command.condition) == null ? void 0 : _a.assertion) {
+        return `Check success condition: ${command.condition.assertion}`;
+      }
+      return `All commands completed`;
+    case "NAVIGATE" /* NAVIGATE */:
+      return `Go to URL: ${clampText(command.url, 30)}`;
+    case "GO_BACK" /* GO_BACK */:
+      return `Go back to the previous page`;
+    case "GO_FORWARD" /* GO_FORWARD */:
+      return `Go forward to the next page`;
+    case "SCROLL_DOWN" /* SCROLL_DOWN */:
+      return `Scroll down one page`;
+    case "SCROLL_UP" /* SCROLL_UP */:
+      return `Scroll up one page`;
+    case "WAIT" /* WAIT */:
+      return `Wait for ${command.delay} seconds`;
+    case "REFRESH" /* REFRESH */:
+      return `Refresh the page`;
+    case "CLICK" /* CLICK */:
+      return `Click on '${command.target.elementDescriptor}'`;
+    case "TYPE" /* TYPE */: {
+      let serializedTarget = "";
+      if ((_b = command.target.a11yData) == null ? void 0 : _b.serializedForm) {
+        serializedTarget = ` in element ${command.target.a11yData.serializedForm}`;
+      } else if (command.target.elementDescriptor.length > 0) {
+        serializedTarget = ` in element ${command.target.elementDescriptor}`;
+      }
+      return `Type${serializedTarget}: '${command.value}'`;
+    }
+    case "HOVER" /* HOVER */: {
+      let serializedTarget = "";
+      if ((_c = command.target.a11yData) == null ? void 0 : _c.serializedForm) {
+        serializedTarget = ` over element: ${command.target.a11yData.serializedForm}`;
+      } else if (command.target.elementDescriptor.length > 0) {
+        serializedTarget = ` over element: ${command.target.elementDescriptor}`;
+      }
+      return `Hover${serializedTarget}`;
+    }
+    case "PRESS" /* PRESS */:
+      return `Press '${command.value}'`;
+    case "SELECT_OPTION" /* SELECT_OPTION */:
+      return `Select option '${command.option}' in '${command.target.elementDescriptor}'`;
+    case "TAB" /* TAB */:
+      return `Switch to tab: ${command.url}`;
+    case "COOKIE" /* COOKIE */:
+      return `Set cookie: ${command.value}`;
+    case "AI_ASSERTION" /* AI_ASSERTION */:
+      return `${command.useVision ? "Visual assertion" : "Assertion"}: '${command.assertion}'`;
+    default:
+      const assertUnreachable = (_x) => {
+        throw "If Typescript complains about the line below, you missed a case or break in the switch above";
+      };
+      return assertUnreachable(command);
+  }
+}
+
+// ../../packages/types/src/context.ts
+import * as z8 from "zod";
+
+// ../../packages/types/src/execute-results.ts
+import * as z7 from "zod";
+var ExecuteCommandHistoryEntrySchema = z7.object({
+  // type of command executed
+  type: z7.nativeEnum(StepType),
+  // if AI step type, what command was executed
+  generatedStep: UserEditableAICommandSchema.optional(),
+  // human readable descriptor for action taken, including element interacted with
+  serializedCommand: z7.string().optional(),
+  // human readable descriptor for element interacted with
+  elementInteracted: z7.string().optional()
+});
+
+// ../../packages/types/src/context.ts
+var DynamicContextSchema = z8.object({
+  // user goal or instruction
+  goal: z8.string(),
+  // current url of the browser
+  url: z8.string(),
+  // serialized page state
+  browserState: z8.string(),
+  // serialized history of previous commands
+  history: z8.string(),
+  // number of previously executed commands
+  numPrevious: z8.number(),
+  // last executed command, if any
+  lastCommand: ExecuteCommandHistoryEntrySchema.or(z8.null())
+});
+
 // ../../packages/types/src/cookies.ts
 import { parseString } from "set-cookie-parser";
 function parseCookieString(cookie) {
@@ -474,51 +582,156 @@ function parseCookieString(cookie) {
   return result;
 }
 
-// ../../packages/types/src/execute-results.ts
-import * as z7 from "zod";
-var ExecuteCommandHistoryEntrySchema = z7.object({
-  // type of command executed
-  type: z7.nativeEnum(StepType),
-  // if AI step type, what command was executed
-  generatedStep: UserEditableAICommandSchema.optional(),
-  // human readable descriptor for action taken, including element interacted with
-  serializedCommand: z7.string().optional(),
-  // human readable descriptor for element interacted with
-  elementInteracted: z7.string().optional()
-});
-
 // ../../packages/types/src/goal-splitter.ts
-import { z as z8 } from "zod";
-var InstructionsSchema = z8.string().array();
+import { z as z9 } from "zod";
+var InstructionsSchema = z9.string().array();
 
 // ../../packages/types/src/locator.ts
-import * as z9 from "zod";
-var AILocatorSchema = z9.object({
-  thoughts: z9.string(),
+import * as z10 from "zod";
+var AILocatorSchema = z10.object({
+  thoughts: z10.string(),
   // a11y id
-  id: z9.number().int(),
+  id: z10.number().int(),
   // dropdowns should have options
-  options: z9.array(z9.string()).optional()
+  options: z10.array(z10.string()).optional()
 });
 
+// ../../packages/types/src/logger.ts
+var stringToLogLevel = {
+  DEBUG: 0 /* DEBUG */,
+  INFO: 1 /* INFO */,
+  WARN: 2 /* WARN */,
+  ERROR: 3 /* ERROR */
+};
+var LogLevelTags = {
+  [0 /* DEBUG */]: "DEBUG",
+  [1 /* INFO */]: "INFO",
+  [2 /* WARN */]: "WARN",
+  [3 /* ERROR */]: "ERROR"
+};
+var LogLevelColors = {
+  [0 /* DEBUG */]: "\x1B[90m",
+  [1 /* INFO */]: "\x1B[32m",
+  [2 /* WARN */]: "\x1B[33m",
+  [3 /* ERROR */]: "\x1B[31m"
+};
+var ConsoleLogger = class _ConsoleLogger {
+  constructor(minLevel, bindings) {
+    this.minLogLevel = minLevel;
+    this.logBindings = bindings;
+  }
+  log(level, ...args) {
+    const levelName = LogLevelTags[level];
+    let objectArg;
+    if (Array.isArray(args[0])) {
+      objectArg = args[0];
+      args = args.slice(1);
+    } else if (typeof args[0] === "object") {
+      objectArg = __spreadValues(__spreadValues({}, args[0]), this.logBindings);
+      args = args.slice(1);
+    }
+    const colorSequence = LogLevelColors[level];
+    const logTokens = [
+      `${colorSequence}[${(/* @__PURE__ */ new Date()).toTimeString().slice(0, 8)}][${levelName}]`
+    ];
+    if (level !== 0 /* DEBUG */) {
+      logTokens.push("\x1B[39m");
+    }
+    logTokens.push(...args);
+    console.log(...logTokens);
+    if (objectArg && !Array.isArray(objectArg)) {
+      for (const [key, value] of Object.entries(objectArg)) {
+        let stringifiedValue = value;
+        if (typeof value === "object") {
+          stringifiedValue = JSON.stringify(value, void 0, 2);
+          stringifiedValue = stringifiedValue.split("\n").map(
+            (line, index) => index > 0 ? `  ${line}` : line
+          ).join("\n");
+        }
+        console.log(
+          level === 0 /* DEBUG */ ? `${colorSequence}  ${key}:` : `  ${key}:`,
+          stringifiedValue
+        );
+      }
+    } else if (objectArg) {
+      for (const value of objectArg) {
+        let stringifiedValue = value;
+        if (typeof value === "object") {
+          stringifiedValue = JSON.stringify(value, void 0, 2);
+          stringifiedValue = stringifiedValue.split("\n").map(
+            (line, index) => index > 0 ? `  ${line}` : line
+          ).join("\n");
+        }
+        console.log(
+          level === 0 /* DEBUG */ ? `${colorSequence}  ` : `  `,
+          stringifiedValue
+        );
+      }
+    }
+    if (level === 0 /* DEBUG */) {
+      process.stdout.write("\x1B[39m");
+    }
+  }
+  setMinLevel(level) {
+    this.minLogLevel = level;
+  }
+  info(...args) {
+    if (1 /* INFO */ < this.minLogLevel) {
+      return;
+    }
+    this.log(1 /* INFO */, ...args);
+  }
+  debug(...args) {
+    if (0 /* DEBUG */ < this.minLogLevel) {
+      return;
+    }
+    this.log(0 /* DEBUG */, ...args);
+  }
+  warn(...args) {
+    if (2 /* WARN */ < this.minLogLevel) {
+      return;
+    }
+    this.log(2 /* WARN */, ...args);
+  }
+  error(...args) {
+    if (3 /* ERROR */ < this.minLogLevel) {
+      return;
+    }
+    this.log(3 /* ERROR */, ...args);
+  }
+  child(bindings) {
+    return new _ConsoleLogger(this.minLogLevel, __spreadValues(__spreadValues({}, this.logBindings), bindings));
+  }
+  flush() {
+    return;
+  }
+  bindings() {
+    return this.logBindings;
+  }
+};
+var consoleLogger = new ConsoleLogger(1 /* INFO */, {});
+
 // ../../packages/types/src/modules.ts
-import { z as z10 } from "zod";
-var ModuleMetadataSchema = z10.object({
-  id: z10.string(),
-  createdAt: z10.coerce.date(),
-  createdBy: z10.string(),
-  organizationId: z10.string().or(z10.null()),
-  name: z10.string(),
-  schemaVersion: z10.string(),
+import { z as z11 } from "zod";
+var ModuleMetadataSchema = z11.object({
+  id: z11.string(),
+  createdAt: z11.coerce.date(),
+  createdBy: z11.string(),
+  organizationId: z11.string(),
+  name: z11.string(),
+  schemaVersion: z11.string(),
   // this is only used in the client and is not stored in the db
-  numSteps: z10.number()
+  numSteps: z11.number()
 });
-var ModuleSchema = z10.object({
+var ModuleSchema = z11.object({
   steps: AllowedModuleStepSchema.array()
 }).merge(ModuleMetadataSchema.omit({ numSteps: true }));
 
+// ../../packages/types/src/public-api.ts
+import * as z15 from "zod";
+
 // ../../packages/types/src/runs.ts
-import { z as z11 } from "zod";
+import { z as z12 } from "zod";
 var RunTriggerEnum = {
   WEBHOOK: "WEBHOOK",
   CRON: "CRON",
@@ -532,202 +745,144 @@ var RunStatusEnum = {
   FAILED: "FAILED",
   CANCELLED: "CANCELLED"
 };
-var DateOrStringSchema = z11.string().pipe(z11.coerce.date()).or(z11.date());
-var RunMetadataSchema = z11.object({
-  id: z11.string(),
+var DateOrStringSchema = z12.string().pipe(z12.coerce.date()).or(z12.date());
+var RunMetadataSchema = z12.object({
+  id: z12.string(),
   createdAt: DateOrStringSchema,
-  createdBy: z11.string(),
-  organizationId: z11.string().or(z11.null()),
-  scheduledAt: DateOrStringSchema.or(z11.null()),
-  startedAt: DateOrStringSchema.or(z11.null()),
-  finishedAt: DateOrStringSchema.or(z11.null()),
-  testId: z11.string().or(z11.null()),
-  status: z11.nativeEnum(RunStatusEnum),
-  trigger: z11.nativeEnum(RunTriggerEnum),
-  test: z11.object({
-    name: z11.string(),
-    id: z11.string()
-  }).or(z11.null())
+  createdBy: z12.string(),
+  organizationId: z12.string(),
+  scheduledAt: DateOrStringSchema.or(z12.null()),
+  startedAt: DateOrStringSchema.or(z12.null()),
+  finishedAt: DateOrStringSchema.or(z12.null()),
+  testId: z12.string().or(z12.null()),
+  status: z12.nativeEnum(RunStatusEnum),
+  trigger: z12.nativeEnum(RunTriggerEnum),
+  attempts: z12.number(),
+  test: z12.object({
+    name: z12.string(),
+    id: z12.string()
+  }).or(z12.null())
 });
 var RunWithTestSchema = RunMetadataSchema.merge(
-  z11.object({
+  z12.object({
     results: ResultSchema.array(),
-    test: z11.object({
-      name: z11.string(),
-      id: z11.string(),
-      baseUrl: z11.string()
-    }).or(z11.null())
+    test: z12.object({
+      name: z12.string(),
+      id: z12.string(),
+      baseUrl: z12.string()
+    }).or(z12.null())
   })
 );
 
-// ../../packages/types/src/serialization.ts
-function clampText(text, length) {
-  if (text.length < length) {
-    return text;
-  }
-  return text.slice(0, length - 3) + "[...]";
-}
-function serializeCommand(command) {
-  var _a, _b;
-  switch (command.type) {
-    case "SUCCESS" /* SUCCESS */:
-      if ((_a = command.condition) == null ? void 0 : _a.assertion) {
-        return `Check success condition: ${command.condition.assertion}`;
-      }
-      return `All commands completed`;
-    case "NAVIGATE" /* NAVIGATE */:
-      return `Go to URL: ${clampText(command.url, 30)}`;
-    case "GO_BACK" /* GO_BACK */:
-      return `Go back to the previous page`;
-    case "GO_FORWARD" /* GO_FORWARD */:
-      return `Go forward to the next page`;
-    case "SCROLL_DOWN" /* SCROLL_DOWN */:
-      return `Scroll down one page`;
-    case "SCROLL_UP" /* SCROLL_UP */:
-      return `Scroll up one page`;
-    case "WAIT" /* WAIT */:
-      return `Wait for ${command.delay} seconds`;
-    case "REFRESH" /* REFRESH */:
-      return `Refresh the page`;
-    case "CLICK" /* CLICK */:
-      return `Click on '${command.target.elementDescriptor}'`;
-    case "TYPE" /* TYPE */:
-      let serializedTarget = "";
-      if ((_b = command.target.a11yData) == null ? void 0 : _b.serializedForm) {
-        serializedTarget = ` in element ${command.target.a11yData.serializedForm}`;
-      } else if (command.target.elementDescriptor.length > 0) {
-        serializedTarget = ` in element ${command.target.elementDescriptor}`;
-      }
-      return `Type${serializedTarget}: '${command.value}'`;
-    case "PRESS" /* PRESS */:
-      return `Press '${command.value}'`;
-    case "SELECT_OPTION" /* SELECT_OPTION */:
-      return `Select option '${command.option}' in '${command.target.elementDescriptor}'`;
-    case "TAB" /* TAB */:
-      return `Switch to tab: ${command.url}`;
-    case "COOKIE" /* COOKIE */:
-      return `Set cookie: ${command.value}`;
-    case "AI_ASSERTION" /* AI_ASSERTION */:
-      return `${command.useVision ? "Visual assertion" : "Assertion"}: '${command.assertion}'`;
-    default:
-      const assertUnreachable = (_x) => {
-        throw "If Typescript complains about the line below, you missed a case or break in the switch above";
-      };
-      return assertUnreachable(command);
-  }
-}
-
-// ../../packages/types/src/card-display.ts
-var SELECTABLE_PRESET_COMMAND_OPTIONS_SET = new Set(
-  Object.values(CommandType)
-);
-var CARD_DISPLAY_NAMES = {
-  ["AI_ACTION" /* AI_ACTION */]: "AI action",
-  ["MODULE" /* MODULE */]: "Module",
-  ["AI_ASSERTION" /* AI_ASSERTION */]: "AI check",
-  ["CLICK" /* CLICK */]: "Click",
-  ["SELECT_OPTION" /* SELECT_OPTION */]: "Select",
-  ["TYPE" /* TYPE */]: "Type",
-  ["PRESS" /* PRESS */]: "Press",
-  ["NAVIGATE" /* NAVIGATE */]: "Navigate",
-  ["SCROLL_UP" /* SCROLL_UP */]: "Scroll up",
-  ["SCROLL_DOWN" /* SCROLL_DOWN */]: "Scroll down",
-  ["GO_BACK" /* GO_BACK */]: "Go back",
-  ["GO_FORWARD" /* GO_FORWARD */]: "Go forward",
-  ["WAIT" /* WAIT */]: "Wait",
-  ["REFRESH" /* REFRESH */]: "Refresh",
-  ["TAB" /* TAB */]: "Switch tab",
-  ["COOKIE" /* COOKIE */]: "Set cookie",
-  ["SUCCESS" /* SUCCESS */]: "Done"
-};
-var CARD_DESCRIPTIONS = {
-  ["AI_ACTION" /* AI_ACTION */]: "Ask AI to plan and execute something on the page.",
-  ["MODULE" /* MODULE */]: "A list of steps that can be reused in multiple tests.",
-  ["AI_ASSERTION" /* AI_ASSERTION */]: "Ask AI whether something is true on the page.",
-  ["CLICK" /* CLICK */]: "Click on an element on the page based on a description.",
-  ["SELECT_OPTION" /* SELECT_OPTION */]: "Select an option from a dropdown based on a description.",
-  ["TYPE" /* TYPE */]: "Type the specified text into an element.",
-  ["PRESS" /* PRESS */]: "Press the specified keys using the keyboard. (e.g. Ctrl+A)",
-  ["NAVIGATE" /* NAVIGATE */]: "Navigate to the specified URL.",
-  ["SCROLL_UP" /* SCROLL_UP */]: "Scroll up one page.",
-  ["SCROLL_DOWN" /* SCROLL_DOWN */]: "Scroll down one page.",
-  ["GO_BACK" /* GO_BACK */]: "Go back in browser history.",
-  ["GO_FORWARD" /* GO_FORWARD */]: "Go forward in browser history.",
-  ["WAIT" /* WAIT */]: "Wait for the specified number of seconds.",
-  ["REFRESH" /* REFRESH */]: "Refresh the page. This will not clear cookies or session data.",
-  ["TAB" /* TAB */]: "Switch to different tab in the browser.",
-  ["COOKIE" /* COOKIE */]: "Set a cookie that will persist throughout the browser session",
-  ["SUCCESS" /* SUCCESS */]: "Indicate the entire AI action has succeeded, optionally based on a condition."
-};
-
 // ../../packages/types/src/test.ts
-import { z as z13 } from "zod";
+import { z as z14 } from "zod";
 
 // ../../packages/types/src/test-settings.ts
 import { isValidCron } from "cron-validator";
-import { z as z12 } from "zod";
-var TestAdvancedSettingsSchema = z12.object({
-  availableAsModule: z12.boolean().default(false),
-  disableAICaching: z12.boolean().default(false)
+import { z as z13 } from "zod";
+var TestAdvancedSettingsSchema = z13.object({
+  availableAsModule: z13.boolean().default(false),
+  disableAICaching: z13.boolean().default(false)
 });
-var ScheduleSettingsSchema = z12.object({
-  cron: z12.string().refine(
+var ScheduleSettingsSchema = z13.object({
+  cron: z13.string().refine(
     (v) => {
       return isValidCron(v);
     },
     { message: "Invalid cron expression." }
   ).default("0 0 */1 * *"),
-  enabled: z12.boolean().default(false),
-  timeZone: z12.string().default("America/Los_Angeles"),
+  enabled: z13.boolean().default(false),
+  timeZone: z13.string().default("America/Los_Angeles"),
   // this is used for removing repeatable jobs (not set by user)
-  jobKey: z12.string().optional()
+  jobKey: z13.string().optional()
 });
-var WebhookSchema = z12.object({
-  lastStatus: z12.number().optional(),
-  url: z12.string().url()
-});
-var WebhookSettingsSchema = z12.array(WebhookSchema).default([]);
-var TestSettingsSchema = z12.object({
-  name: z12.string().min(1),
-  baseUrl: z12.string().url(),
-  advanced: TestAdvancedSettingsSchema
+var NotificationSettingsSchema = z13.object({
+  onSuccess: z13.boolean().default(false),
+  onFailure: z13.boolean().default(true)
 });
 
 // ../../packages/types/src/test.ts
-var ResolvedTestSchema = z13.object({
-  id: z13.string(),
-  name: z13.string(),
-  baseUrl: z13.string(),
-  steps: z13.array(ResolvedStepSchema),
-  createdAt: z13.coerce.date(),
-  updatedAt: z13.coerce.date(),
-  createdBy: z13.string(),
-  organizationId: z13.string().or(z13.null()),
-  schemaVersion: z13.string(),
+var TestNameSchema = z14.string().min(1).max(255).superRefine((v, ctx) => {
+  try {
+    validateTestOrModuleName(v);
+  } catch (err) {
+    ctx.addIssue({
+      code: z14.ZodIssueCode.custom,
+      message: err.message,
+      fatal: true
+    });
+    return z14.NEVER;
+  }
+});
+var BaseTestMetadataSchema = z14.object({
+  id: z14.string(),
+  name: TestNameSchema,
+  baseUrl: z14.string(),
+  schemaVersion: z14.string(),
   advanced: TestAdvancedSettingsSchema,
-  schedule: ScheduleSettingsSchema,
-  webhooks: WebhookSettingsSchema
+  retries: z14.number()
 });
-
-// ../../packages/types/src/context.ts
-import * as z14 from "zod";
-var DynamicContextSchema = z14.object({
-  // user goal or instruction
-  goal: z14.string(),
-  // current url of the browser
-  url: z14.string(),
-  // serialized page state
-  browserState: z14.string(),
-  // serialized history of previous commands
-  history: z14.string(),
-  // number of previously executed commands
-  numPrevious: z14.number(),
-  // last executed command, if any
-  lastCommand: ExecuteCommandHistoryEntrySchema.or(z14.null())
+var UserEditableTestSettingsSchema = BaseTestMetadataSchema.pick({
+  name: true,
+  baseUrl: true,
+  retries: true,
+  advanced: true
+});
+var ExtendedTestMetadataSchema = z14.object({
+  createdAt: z14.coerce.date(),
+  updatedAt: z14.coerce.date(),
+  schedule: ScheduleSettingsSchema,
+  notification: NotificationSettingsSchema,
+  createdBy: z14.string(),
+  organizationId: z14.string()
 });
+var ResolvedTestSchema = BaseTestMetadataSchema.merge(
+  ExtendedTestMetadataSchema
+).merge(
+  z14.object({
+    steps: z14.array(ResolvedStepSchema)
+  })
+);
+var MinimalRunnableResolvedTestSchema = BaseTestMetadataSchema.merge(
+  z14.object({
+    steps: z14.array(ResolvedStepSchema)
+  })
+);
+var UUID_REGEX = /^[a-f0-9]{8}-[a-f0-9]{4}-[1-5][a-f0-9]{3}-[89ab][a-f0-9]{3}-[a-f0-9]{12}$/;
+function validateTestOrModuleName(name) {
+  name = name.toLowerCase();
+  if (name.length === 0 || name.length > 255) {
+    throw new Error("Name must be between 1 and 255 characters long");
+  }
+  const invalidChars = /[<>:"\/\\|?*\x00]/;
+  if (invalidChars.test(name)) {
+    throw new Error(
+      "Name can only contain alphanumeric characters, dashes, and underscores."
+    );
+  }
+  const windowsReservedNames = /^(con|prn|aux|nul|com[0-9]|lpt[0-9])(\..*)?$/i;
+  if (windowsReservedNames.test(name)) {
+    throw new Error(
+      `"${name}" is a reserved name on Windows and cannot be used as a filename.`
+    );
+  }
+  if (/^\.+$/.test(name) || /^\s|\s$/.test(name)) {
+    throw new Error("Name cannot start or end with a space or dot.");
+  }
+  if (name.endsWith(".yaml")) {
+    throw new Error('Name cannot end with ".yaml".');
+  }
+  if (name === "modules") {
+    throw new Error(
+      "'modules' is a reserved folder name in Momentic. Please choose a different name."
+    );
+  }
+  if (name.match(UUID_REGEX)) {
+    throw new Error("Name cannot be a UUID. Please choose a different name.");
+  }
+}
 
 // ../../packages/types/src/public-api.ts
-import * as z15 from "zod";
 var GeneratorOptionsSchema = z15.object({
   disableCache: z15.boolean()
 });
@@ -763,14 +918,61 @@ var SplitGoalBodySchema = DynamicContextSchema.pick({
   url: true
 }).merge(GeneratorOptionsSchema);
 var SplitGoalResponseSchema = z15.string().array();
-var QueueTestsBodySchema = z15.object({
-  testIds: z15.string().array()
+var QueueTestsBodySchema = z15.union([
+  z15.object({
+    testPaths: z15.string().array(),
+    all: z15.boolean().optional()
+  }),
+  z15.object({
+    testIds: z15.string().array()
+  }).describe("deprecated - for backwards compatibility only")
+]);
+var QueueTestsResponseSchema = z15.object({
+  message: z15.string(),
+  queuedTests: z15.object({
+    name: z15.string(),
+    id: z15.string()
+  }).array()
 });
 var GetTestResponseSchema = ResolvedTestSchema;
-var CreateRunBodySchema = z15.object({
-  testId: z15.string(),
-  trigger: z15.nativeEnum(RunTriggerEnum)
+var GetAllTestIdsResponseSchema = z15.string().array();
+var ExportTestBodySchema = z15.union([
+  z15.object({
+    paths: z15.string().array().describe("run specific test paths (e.g. todo-test)")
+  }),
+  z15.object({
+    path: z15.string().describe("deprecated; present for backcompat")
+  }),
+  z15.object({
+    all: z15.boolean().describe("run all tests")
+  })
+]);
+var ExportTestResponseSchema = z15.object({
+  tests: z15.record(
+    z15.string().describe("Test name"),
+    z15.string().describe("Test YAML")
+  ),
+  modules: z15.record(
+    z15.string().describe("Module name"),
+    z15.string().describe("Module YAML")
+  )
 });
+var TestWithModulesYAMLSchema = z15.object({
+  test: z15.string().describe("test YAML"),
+  modules: z15.record(
+    z15.string().describe("moduleId"),
+    z15.string().describe("module YAML")
+  )
+});
+var UpdateTestsBodySchema = TestWithModulesYAMLSchema.array();
+var CreateRunBodySchema = z15.object({
+  testPath: z15.string(),
+  testId: z15.string()
+}).partial().merge(
+  z15.object({
+    trigger: z15.nativeEnum(RunTriggerEnum)
+  })
+);
 var CreateRunResponseSchema = RunWithTestSchema;
 var GetRunResponseSchema = RunWithTestSchema;
 var UpdateRunBodySchema = z15.object({
@@ -787,6 +989,416 @@ var CreateScreenshotResponseSchema = z15.object({
   key: z15.string()
 });
 
+// ../../packages/types/src/step-serialization.ts
+function serializeStep(step) {
+  switch (step.type) {
+    case "AI_ACTION" /* AI_ACTION */:
+      return `AI action: ${step.text}`;
+    case "PRESET_ACTION" /* PRESET_ACTION */:
+      return serializeCommand(step.command);
+    case "RESOLVED_MODULE":
+      return `Module: ${step.moduleId}`;
+  }
+}
+
+// ../../packages/types/src/test-serialization.ts
+import { stringify } from "yaml";
+import { z as z16 } from "zod";
+var TestSerializationResultSchema = z16.object({
+  test: z16.string().describe("YAML for the test, including metadata and steps"),
+  modules: z16.record(z16.string(), z16.string()).describe("Map of module name to YAML for the module")
+});
+var SerializedTestSchema = BaseTestMetadataSchema.merge(
+  z16.object({
+    steps: StepSchema.array(),
+    fileType: z16.literal("momentic/test" /* TEST */)
+  })
+);
+var SerializedModuleSchema = ResolvedModuleStepSchema.omit({
+  type: true
+}).merge(
+  z16.object({
+    schemaVersion: z16.string(),
+    fileType: z16.literal("momentic/module")
+  })
+);
+var DeserializedTestSchema = BaseTestMetadataSchema.merge(
+  z16.object({
+    steps: z16.array(z16.record(z16.string(), z16.unknown()))
+  })
+);
+var DeserializedModuleSchema = z16.object({
+  moduleId: z16.string().uuid(),
+  name: z16.string(),
+  schemaVersion: z16.string(),
+  steps: z16.array(z16.record(z16.string(), z16.unknown()))
+});
+
+// src/api-client.ts
+var API_VERSION = "v1";
+var APIClient = class {
+  constructor(params) {
+    this.baseURL = params.baseURL;
+    this.apiKey = params.apiKey;
+  }
+  getRun(runId) {
+    return __async(this, null, function* () {
+      const result = yield this.sendRequest(`/${API_VERSION}/runs/${runId}`, {
+        method: "GET"
+      });
+      return GetRunResponseSchema.parse(result);
+    });
+  }
+  createRun(body) {
+    return __async(this, null, function* () {
+      const result = yield this.sendRequest(`/${API_VERSION}/runs`, {
+        method: "POST",
+        body
+      });
+      return CreateRunResponseSchema.parse(result);
+    });
+  }
+  updateRun(runId, body) {
+    return __async(this, null, function* () {
+      yield this.sendRequest(`/${API_VERSION}/runs/${runId}`, {
+        method: "PATCH",
+        body
+      });
+    });
+  }
+  getTest(testPath) {
+    return __async(this, null, function* () {
+      const result = yield this.sendRequest(`/${API_VERSION}/tests/${testPath}`, {
+        method: "GET"
+      });
+      return GetTestResponseSchema.parse(result);
+    });
+  }
+  getAllTestIds() {
+    return __async(this, null, function* () {
+      const result = yield this.sendRequest(`/${API_VERSION}/tests`, {
+        method: "GET"
+      });
+      return GetAllTestIdsResponseSchema.parse(result);
+    });
+  }
+  getTestYAMLExport(body) {
+    return __async(this, null, function* () {
+      const result = yield this.sendRequest(`/${API_VERSION}/tests/export`, {
+        method: "POST",
+        body
+      });
+      return ExportTestResponseSchema.parse(result);
+    });
+  }
+  updateTestWithYAML(body) {
+    return __async(this, null, function* () {
+      yield this.sendRequest(`/${API_VERSION}/tests/update`, {
+        method: "POST",
+        body
+      });
+    });
+  }
+  queueTests(body) {
+    return __async(this, null, function* () {
+      const result = yield this.sendRequest(`/${API_VERSION}/tests/queue`, {
+        method: "POST",
+        body
+      });
+      return QueueTestsResponseSchema.parse(result);
+    });
+  }
+  uploadScreenshot(body) {
+    return __async(this, null, function* () {
+      const result = yield this.sendRequest(`/${API_VERSION}/screenshots`, {
+        method: "POST",
+        body
+      });
+      return CreateScreenshotResponseSchema.parse(result);
+    });
+  }
+  sendRequest(path3, options) {
+    return __async(this, null, function* () {
+      const response = yield fetch(`${this.baseURL}${path3}`, {
+        method: options.method,
+        body: options.body ? JSON.stringify(options.body) : void 0,
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${this.apiKey}`
+        }
+      });
+      if (!response.ok) {
+        let body;
+        try {
+          body = yield response.json();
+        } catch (err) {
+          body = yield response.text();
+        }
+        throw new Error(
+          `Request to ${path3} failed with status ${response.status}: ${JSON.stringify(body)}`
+        );
+      }
+      if (response.status === 204) {
+        return response.text();
+      }
+      return response.json();
+    });
+  }
+};
+
+// src/install-browsers.ts
+import { registry } from "playwright-core/lib/server";
+function installBrowsers() {
+  return __async(this, null, function* () {
+    const executables = registry.defaultExecutables();
+    yield registry.installDeps(executables, false);
+    yield registry.install(executables, false);
+  });
+}
+
+// src/options.ts
+import { Argument, Option } from "commander";
+
+// src/constants.ts
+var DEFAULT_FOLDER_PATH = "momentic";
+var MODULES_FOLDER_NAME = "modules";
+
+// src/options.ts
+var apiKeyOption = new Option(
+  "--api-key <key>",
+  "API key for authentication. If not supplied, attempts to read the MOMENTIC_API_KEY env var."
+).env("MOMENTIC_API_KEY").makeOptionMandatory(true);
+var serverAddressOption = new Option(
+  "--server <server>",
+  "Momentic server to use. Leave unchanged unless using Momentic on-premise."
+).default("https://api.momentic.ai");
+var yesOption = new Option("-y, --yes", "Skip confirmation prompts.");
+var testPathsVariadicArgument = new Argument(
+  "<tests...>",
+  "One or more test paths. A test path is a lowercased version of your test name where spaces are replaced with underscores (e.g. `hello-world`)"
+).argOptional();
+var testsOrFilesVariadicArgument = new Argument(
+  "<tests...>",
+  "One or more test identifiers. To use tests stored on your local file system, specify file paths to Momentic YAML files or folders to search (this requires the --local option as well). To use tests stored remotely, you may pass test UUIDs or test paths. A test path is a lowercased version of your test name where spaces are replaced with underscores (e.g. `hello-world`)."
+).argRequired();
+var filePathsVariadicArgument = new Argument(
+  "<paths...>",
+  "File paths pointing to one or more YAML files containing Momentic tests, or a directory of Momentic YAML files."
+);
+var outDirOption = new Option(
+  "-o --out-dir <outDir>",
+  "Root directory to write output files to. Can be absolute or relative to the current directory. Defaults to `momentic`."
+).default(DEFAULT_FOLDER_PATH);
+var allOption = new Option(
+  "-a --all",
+  "Select all tests from the cloud Momentic server. Cannot be used together with <tests> arguments."
+).default(false).preset(true);
+
+// src/package.json
+var version = "0.0.18";
+
+// src/prompt.ts
+import chalk from "chalk";
+import readline from "readline/promises";
+function promptForConfirmation(question, yellow) {
+  return __async(this, null, function* () {
+    if (process.env.CI)
+      return true;
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout
+    });
+    question = `${question} (y/N) `;
+    const questionContent = yellow ? chalk.bold.yellow(question) : question;
+    const answer = yield rl.question(questionContent);
+    rl.close();
+    if (answer.toLowerCase() === "y") {
+      return true;
+    } else {
+      return false;
+    }
+  });
+}
+
+// src/pull-test.ts
+import { existsSync, mkdirSync, writeFileSync } from "fs";
+import { join } from "path";
+function fetchAndSaveTestToDisk(_0) {
+  return __async(this, arguments, function* ({
+    testPaths,
+    client,
+    outDir,
+    all
+  }) {
+    const rootDir = outDir != null ? outDir : DEFAULT_FOLDER_PATH;
+    if (!existsSync(rootDir)) {
+      mkdirSync(rootDir, { recursive: true });
+    }
+    const rootModuleDir = join(rootDir, MODULES_FOLDER_NAME);
+    if (!existsSync(rootModuleDir)) {
+      mkdirSync(rootModuleDir, { recursive: true });
+    }
+    const { tests, modules } = yield client.getTestYAMLExport({
+      paths: testPaths,
+      all
+    });
+    const numTests = Object.keys(tests).length;
+    for (const [testName, testYAML] of Object.entries(tests)) {
+      const testFilePath = join(rootDir, nameToYAMLFileName(testName));
+      if (!(yield checkAndPromptForOverwrite(testFilePath))) {
+        consoleLogger.error("Pull cancelled");
+        return;
+      }
+      writeFileSync(testFilePath, testYAML, "utf-8");
+      consoleLogger.info(`Wrote '${testFilePath}'`);
+    }
+    const numModules = Object.keys(modules).length;
+    for (const [moduleName, moduleYAML] of Object.entries(modules)) {
+      const modulePath = join(rootModuleDir, nameToYAMLFileName(moduleName));
+      if (!(yield checkAndPromptForOverwrite(modulePath))) {
+        consoleLogger.error("Pull cancelled");
+        return;
+      }
+      writeFileSync(modulePath, moduleYAML, "utf-8");
+      consoleLogger.info(`Wrote '${modulePath}'`);
+    }
+    consoleLogger.info(
+      `Pulled ${numTests} test${numTests > 1 ? "s" : ""}${numModules ? ` and ${numModules} module${numModules > 1 ? "s" : ""}` : ""}!`
+    );
+  });
+}
+function checkAndPromptForOverwrite(path3) {
+  return __async(this, null, function* () {
+    if (!existsSync(path3)) {
+      return true;
+    }
+    return promptForConfirmation(
+      `File '${path3.replace(/(\s+)/g, "\\$1")}' already exists. Overwrite?`,
+      true
+    );
+  });
+}
+function nameToYAMLFileName(name) {
+  return `${name.toLowerCase().replaceAll(" ", "-")}.yaml`;
+}
+
+// src/push-test.ts
+import { existsSync as existsSync2, readFileSync, readdirSync, statSync } from "fs";
+import path from "path";
+function saveTestToServer(params) {
+  return __async(this, null, function* () {
+    const rootTestPaths = /* @__PURE__ */ new Set();
+    for (const testPathOrDir of params.paths) {
+      const fullPath = path.resolve(testPathOrDir);
+      if (fullPath && existsSync2(fullPath) && statSync(fullPath).isDirectory()) {
+        const files = readdirSync(fullPath);
+        for (const file of files) {
+          if (file.endsWith(".yaml")) {
+            rootTestPaths.add(path.join(fullPath, file));
+          }
+        }
+      }
+      if (fullPath.endsWith(".yaml")) {
+        if (!existsSync2(fullPath) || !statSync(fullPath).isFile()) {
+          throw new Error(`File not found or unreadable: ${fullPath}`);
+        }
+        rootTestPaths.add(fullPath);
+      }
+    }
+    consoleLogger.info(`Found ${rootTestPaths.size} test(s) to push:`);
+    rootTestPaths.forEach((testPath) => consoleLogger.info(`  - ${testPath}`));
+    consoleLogger.info(`Loading file contents and resolving dependent modules`);
+    const testUpdates = Array.from(rootTestPaths).map(readTestWithModules);
+    const moduleIds = new Set(
+      testUpdates.flatMap((update) => Object.keys(update.modules))
+    );
+    consoleLogger.info(
+      `Resolved ${rootTestPaths.size} test(s) and ${moduleIds.size} module(s)`
+    );
+    if (!params.yes) {
+      const warning = "Pushing tests overwrites tests on production and will instantly affect scheduled runs. Continue?";
+      if (!(yield promptForConfirmation(warning, true))) {
+        consoleLogger.error("Push cancelled");
+        return;
+      }
+    }
+    yield params.client.updateTestWithYAML(testUpdates);
+    consoleLogger.info("Update successful!");
+  });
+}
+function readTestWithModules(testFilePath) {
+  let testContent;
+  try {
+    testContent = readFileSync(testFilePath, "utf8");
+    testContent = testContent.replace(/\r\n|\r/g, "\n");
+  } catch (err) {
+    throw new Error(`Could not read test file ${testFilePath}: ${err}`);
+  }
+  const moduleIds = /* @__PURE__ */ new Set();
+  const moduleIdRegex = /moduleId: (.*)/g;
+  let moduleIdMatch;
+  while ((moduleIdMatch = moduleIdRegex.exec(testContent)) !== null) {
+    moduleIds.add(moduleIdMatch[1].trim());
+  }
+  const modules = {};
+  if (moduleIds.size > 0) {
+    const modulesDir = findModulesDir(testFilePath);
+    moduleIds.forEach((moduleId) => {
+      if (!modules[moduleId]) {
+        modules[moduleId] = getModuleFile(modulesDir, moduleId);
+      }
+    });
+  }
+  return {
+    test: testContent,
+    modules
+  };
+}
+function findModulesDir(startDir) {
+  let currentDir = startDir;
+  while (currentDir !== "/") {
+    const modulesDir = path.join(currentDir, MODULES_FOLDER_NAME);
+    if (existsSync2(modulesDir)) {
+      return modulesDir;
+    } else {
+      currentDir = path.dirname(currentDir);
+    }
+  }
+  throw new Error(
+    `No '${MODULES_FOLDER_NAME}' directory found in the path ${startDir} or any of its parents`
+  );
+}
+function getModuleFile(dir, moduleId) {
+  const files = readdirSync(dir);
+  for (const file of files) {
+    const filePath = path.join(dir, file);
+    const fileContent = readFileSync(filePath, "utf8");
+    if (fileContent.includes(moduleId)) {
+      return fileContent;
+    }
+  }
+  throw new Error(
+    `Could not find module file for module ${moduleId} in ${dir}`
+  );
+}
+
+// src/run-tests-locally.ts
+import exec from "@actions/exec";
+import io from "@actions/io";
+import { existsSync as existsSync3, statSync as statSync2 } from "fs";
+import quote from "quote";
+import parseArgsStringToArgv2 from "string-argv";
+import waitOnFn from "wait-on";
+
+// ../../packages/web-agent/src/browsers/chrome.ts
+import { distance as distance2 } from "fastest-levenshtein";
+import {
+  chromium,
+  devices
+} from "playwright";
+import { addExtra } from "playwright-extra";
+import pluginStealth from "puppeteer-extra-plugin-stealth";
+
 // ../../packages/web-agent/src/utils/url.ts
 var urlChanged = (url1, url2) => {
   const { hostname, pathname } = new URL(url1);
@@ -794,20 +1406,49 @@ var urlChanged = (url1, url2) => {
   return hostname !== hostname2 || pathname !== pathname2;
 };
 
+// ../../packages/web-agent/src/browsers/a11y.ts
+import { distance } from "fastest-levenshtein";
+
+// ../../packages/web-agent/src/browsers/constants.ts
+var RETINA_WINDOW_SCALE_FACTOR = 2;
+var MAX_LOAD_TIMEOUT_MS = 8e3;
+var NETWORK_STABLE_DURATION_MS = 1250;
+var NETWORK_IDLE_TIMEOUT_MS = 3e3;
+var CHECK_INTERVAL_MS = 250;
+var A11Y_LOAD_TIMEOUT_MS = 1e3;
+var A11Y_STABLE_TIMEOUT_MS = NETWORK_IDLE_TIMEOUT_MS;
+var A11Y_STABLE_DURATION_MS = NETWORK_STABLE_DURATION_MS;
+var BROWSER_ACTION_TIMEOUT_MS = MAX_LOAD_TIMEOUT_MS;
+var COMPLICATED_BROWSER_ACTION_TIMEOUT_MS = MAX_LOAD_TIMEOUT_MS;
+var HIGHLIGHT_DURATION_MS = 3e3;
+var MAX_LEVENSHTEIN_DISTANCE = 300;
+var MAX_LEVENSHTEIN_CHANGE_RATIO = 0.2;
+var MAX_LEVENSHTEIN_FIELD_CHANGE_RATIO = 0.1;
+var MIN_SIMILARITY_SCORE_TO_REUSE = 5;
+var CHROME_INTERNAL_URLS = /* @__PURE__ */ new Set([
+  "about:blank",
+  "chrome-error://chromewebdata/"
+]);
+var MAX_BROWSER_ACTION_ATTEMPTS = 2;
+
 // ../../packages/web-agent/src/browsers/a11y.ts
 var bannedProperties = /* @__PURE__ */ new Set(["focusable"]);
 var alwaysInterestingRoles = /* @__PURE__ */ new Set([
   "textbox",
   "checkbox",
+  "combobox",
   "button",
-  "link"
+  "link",
+  "combobox"
 ]);
-var rolesToOmitID = /* @__PURE__ */ new Set(["paragraph", "menuitem", "option"]);
+var rolesToOmitID = /* @__PURE__ */ new Set(["paragraph", "option"]);
 var defaultA11yNodeSerializeParams = {
   indentLevel: 0,
   noID: false,
   noChildren: false,
-  noProperties: false
+  noProperties: false,
+  maxLevel: void 0,
+  neighbors: void 0
 };
 var ProcessedA11yNode = class {
   constructor(params) {
@@ -841,6 +1482,7 @@ var ProcessedA11yNode = class {
     return !!this.name.trim() || !!this.content;
   }
   serialize(opts = defaultA11yNodeSerializeParams) {
+    var _a, _b;
     const { indentLevel, noChildren, noProperties, noID } = Object.assign(
       {},
       defaultA11yNodeSerializeParams,
@@ -878,17 +1520,32 @@ var ProcessedA11yNode = class {
         }
       });
     }
-    if (this.children.length === 0 || noChildren) {
+    const maxLevelExceeded = opts.maxLevel !== void 0 && indentLevel / 2 >= opts.maxLevel;
+    if (this.children.length === 0 || noChildren || maxLevelExceeded) {
       s += " />\n";
       return s;
     } else {
       s += ">\n";
+      for (const child of this.children) {
+        s += child.serialize(__spreadProps(__spreadValues({}, opts), { indentLevel: indentLevel + 2 }));
+      }
+      s += `${indent}</${this.role}>
+`;
     }
-    for (const child of this.children) {
-      s += child.serialize({ indentLevel: indentLevel + 2 });
+    if (opts.neighbors !== void 0 && opts.neighbors > 0 && this.parent) {
+      const currentIndex = this.parent.children.findIndex(
+        (n) => n.id === this.id
+      );
+      const before = currentIndex > 0 ? (_a = this.parent.children[currentIndex - 1]) == null ? void 0 : _a.serialize(__spreadProps(__spreadValues({}, opts), {
+        neighbors: 0
+      })) : "";
+      const after = currentIndex < this.parent.children.length - 1 ? (_b = this.parent.children[currentIndex + 1]) == null ? void 0 : _b.serialize(__spreadProps(__spreadValues({}, opts), {
+        neighbors: 0
+      })) : "";
+      return `${before ? before : ""}
+${s}
+${after ? after : ""}`;
     }
-    s += `${indent}</${this.role}>
-`;
     return s;
   }
 };
@@ -1043,6 +1700,61 @@ function processA11yTree(graph) {
   }
   return new ProcessedA11yTree(processedRoot[0], outputNodeMap);
 }
+var saveNodeDetailsToCache = (node, target) => {
+  target.id = parseInt(node.id);
+  target.content = node.content;
+  target.name = node.name;
+  target.role = node.role;
+  target.numChildren = node.children.length;
+  target.serializedForm = node.serialize({
+    noID: true,
+    maxLevel: 1,
+    neighbors: 1
+    // only 1 neighbor is supported right now
+  });
+};
+var getNodeComparisonScore = (node, target) => {
+  var _a;
+  let score = 1;
+  if (node.role === target.role) {
+    score++;
+  }
+  const attrs = ["name", "content"];
+  for (const attr of attrs) {
+    if (!((_a = node[attr]) == null ? void 0 : _a.trim())) {
+      continue;
+    }
+    const fieldChangeRatio = distance(node[attr], target[attr]) / Math.min(node[attr].length, target[attr].length);
+    if (fieldChangeRatio === 0) {
+      score += 2;
+    } else if (fieldChangeRatio <= MAX_LEVENSHTEIN_FIELD_CHANGE_RATIO) {
+      score++;
+    }
+  }
+  if (target.numChildren !== void 0) {
+    if (node.children.length === target.numChildren && target.numChildren > 0) {
+      score++;
+    } else if (target.numChildren > 0 && node.children.length === 0) {
+      score--;
+    } else if (Math.abs(node.children.length - target.numChildren) > 2) {
+      score--;
+    }
+  }
+  if (target.serializedForm) {
+    const serializedNode = node.serialize({
+      noID: true,
+      maxLevel: 1,
+      neighbors: 1
+    });
+    const levenshteinRatio = distance(serializedNode, target.serializedForm) / Math.min(serializedNode.length, target.serializedForm.length);
+    if (levenshteinRatio === 0) {
+      score += 2;
+    } else if (levenshteinRatio <= MAX_LEVENSHTEIN_FIELD_CHANGE_RATIO) {
+      score++;
+    }
+  }
+  return score;
+};
 
 // ../../packages/web-agent/src/browsers/cdp.ts
 var GREEN = { r: 147, g: 196, b: 125, a: 0.55 };
@@ -1062,24 +1774,6 @@ var NODE_HIGHLIGHT_CONFIG = {
   shapeMarginColor: GREEN
 };
 
-// ../../packages/web-agent/src/browsers/constants.ts
-var RETINA_WINDOW_SCALE_FACTOR = 2;
-var MAX_LOAD_TIMEOUT_MS = 8e3;
-var NETWORK_STABLE_DURATION_MS = 1250;
-var NETWORK_IDLE_TIMEOUT_MS = 3e3;
-var CHECK_INTERVAL_MS = 250;
-var A11Y_LOAD_TIMEOUT_MS = 1e3;
-var A11Y_STABLE_TIMEOUT_MS = NETWORK_IDLE_TIMEOUT_MS;
-var A11Y_STABLE_DURATION_MS = NETWORK_STABLE_DURATION_MS;
-var BROWSER_ACTION_TIMEOUT_MS = MAX_LOAD_TIMEOUT_MS;
-var COMPLICATED_BROWSER_ACTION_TIMEOUT_MS = MAX_LOAD_TIMEOUT_MS;
-var HIGHLIGHT_DURATION_MS = 3e3;
-var CHROME_INTERNAL_URLS = /* @__PURE__ */ new Set([
-  "about:blank",
-  "chrome-error://chromewebdata/"
-]);
-var MAX_BROWSER_ACTION_ATTEMPTS = 2;
-
 // ../../packages/web-agent/src/browsers/utils/time.ts
 var sleep = (ms = 1e3) => {
   return new Promise((resolve) => setTimeout(() => resolve(), ms));
@@ -1174,6 +1868,8 @@ function isRequestRelevantForPageLoad(request, currentURL) {
 }
 
 // ../../packages/web-agent/src/browsers/chrome.ts
+var chromiumWithExtra = addExtra(chromium);
+chromiumWithExtra.use(pluginStealth());
 function initCDPSession(cdpClient) {
   return __async(this, null, function* () {
     yield cdpClient.send("Accessibility.enable");
@@ -1204,7 +1900,10 @@ var _ChromeBrowser = class _ChromeBrowser {
    */
   static init(_0, _1, _2) {
     return __async(this, arguments, function* (baseURL, logger, onScreenshot, timeout = MAX_LOAD_TIMEOUT_MS) {
-      const browser = yield playwright_exports.chromium.launch({ headless: true });
+      const browser = yield chromiumWithExtra.launch({
+        headless: true,
+        handleSIGTERM: false
+      });
       const context = yield browser.newContext({
         viewport: {
           width: 1920,
@@ -1212,7 +1911,7 @@ var _ChromeBrowser = class _ChromeBrowser {
         },
         // comment out the below if you are on Mac OS but you're using a monitor
         deviceScaleFactor: process.platform === "darwin" ? RETINA_WINDOW_SCALE_FACTOR : 1,
-        userAgent: playwright_exports.devices["Desktop Chrome"].userAgent,
+        userAgent: devices["Desktop Chrome"].userAgent,
         geolocation: { latitude: 37.7749, longitude: -122.4194 },
         // san francisco
         locale: "en-US",
@@ -1367,7 +2066,11 @@ var _ChromeBrowser = class _ChromeBrowser {
     return __async(this, arguments, function* (text, options = {}) {
       const { clearContent = true, pressKeysSequentially = false } = options;
       if (clearContent) {
-        yield this.page.keyboard.press("Meta+A");
+        if (process.platform === "darwin") {
+          yield this.page.keyboard.press("Meta+A");
+        } else {
+          yield this.page.keyboard.press("Control+A");
+        }
         yield this.page.keyboard.press("Backspace");
       }
       if (pressKeysSequentially) {
@@ -1381,7 +2084,7 @@ var _ChromeBrowser = class _ChromeBrowser {
     return __async(this, arguments, function* (index, options = {}) {
       const node = this.nodeMap.get(`${index}`);
       if (!node) {
-        throw new Error(`Could not find node in DOM with index: ${index}`);
+        throw new Error(`Could not find DOM node during click: ${index}`);
       }
       const nodeClicked = yield this.clickUsingCDP(node, options);
       yield this.highlightNode(nodeClicked);
@@ -1392,7 +2095,9 @@ var _ChromeBrowser = class _ChromeBrowser {
     return __async(this, null, function* () {
       const node = this.nodeMap.get(`${index}`);
       if (!node) {
-        throw new Error(`Could not find node in DOM with index: ${index}`);
+        throw new Error(
+          `Could not find DOM node while selecting option: ${index}`
+        );
       }
       if (!node.backendNodeID) {
         throw new Error(
@@ -1407,27 +2112,41 @@ var _ChromeBrowser = class _ChromeBrowser {
       return node.serialize({ noChildren: true, noProperties: true, noID: true });
     });
   }
-  highlight(target) {
-    return __async(this, null, function* () {
-      try {
-        yield this.highlightByA11yID(target.id);
-      } catch (err) {
-        this.logger.warn({ err, target }, "Failed to highlight target");
-      }
-    });
-  }
-  highlightByA11yID(index) {
+  scrollIntoView(target) {
     return __async(this, null, function* () {
-      const node = this.nodeMap.get(`${index}`);
+      const id = yield this.resolveCachedTargetToID(target);
+      const node = this.nodeMap.get(`${id}`);
       if (!node) {
-        throw new Error(`Could not find node in DOM with index: ${index}`);
+        throw new Error(`Could not find node in DOM with a11y id: ${id}`);
       }
       if (!node.backendNodeID) {
         throw new Error(
-          `Select target missing backend node id: ${node.getLogForm()}`
+          `Focus target missing backend node id: ${node.getLogForm()}`
         );
       }
-      yield this.highlightNode(node);
+      const locator = yield this.getLocatorFromBackendID(node.backendNodeID);
+      yield locator.scrollIntoViewIfNeeded({
+        timeout: BROWSER_ACTION_TIMEOUT_MS
+      });
+    });
+  }
+  highlight(target) {
+    return __async(this, null, function* () {
+      try {
+        const id = yield this.resolveCachedTargetToID(target);
+        const node = this.nodeMap.get(`${id}`);
+        if (!node) {
+          throw new Error(`Could not find DOM node during highlight: ${id}`);
+        }
+        if (!node.backendNodeID) {
+          throw new Error(
+            `Select target missing backend node id: ${node.getLogForm()}`
+          );
+        }
+        yield this.highlightNode(node);
+      } catch (err) {
+        this.logger.warn({ err, target }, "Failed to highlight target");
+      }
     });
   }
   highlightNode(node) {
@@ -1438,7 +2157,9 @@ var _ChromeBrowser = class _ChromeBrowser {
           backendNodeId: node.backendNodeID
         });
       } catch (err) {
-        this.logger.warn({ err }, "Failed to add node highlight");
+        this.logger.warn(
+          "Failed to add node highlight, a page navigation likely occurred. This is non-fatal for tests."
+        );
       }
       const hideHighlight = () => __async(this, null, function* () {
         try {
@@ -1469,21 +2190,9 @@ var _ChromeBrowser = class _ChromeBrowser {
       const requestFiredListener = (request) => {
         var _a;
         if (!isRequestRelevantForPageLoad(request, this.url)) {
-          this.logger.debug(
-            {
-              uri: serializeRequest(request)
-            },
-            "Ignoring request for page load network stability"
-          );
           return;
         }
         const key = serializeRequest(request);
-        this.logger.debug(
-          {
-            uri: key
-          },
-          "Request fired on page load, delaying network stability"
-        );
         firedRequests.set(key, ((_a = firedRequests.get(key)) != null ? _a : 0) + 1);
         lastRequestReceived = Date.now();
       };
@@ -1515,7 +2224,6 @@ var _ChromeBrowser = class _ChromeBrowser {
           let anyDifference = false;
           for (const key of firedRequests.keys()) {
             if (firedRequests.get(key) !== finishedRequests.get(key)) {
-              this.logger.debug({ uri: key }, "Waiting on request to finish");
               anyDifference = true;
               unfinishedRequests.add(key);
             }
@@ -1531,11 +2239,13 @@ var _ChromeBrowser = class _ChromeBrowser {
             return true;
           }
         }
-        if (!rejected) {
+        if (!rejected && unfinishedRequests.size > 0) {
           this.logger.warn(
             {
               url: this.url,
-              requests: JSON.stringify(Array.from(unfinishedRequests.entries()))
+              unfinishedRequests: JSON.stringify(
+                Array.from(unfinishedRequests.entries())
+              )
             },
             "Timeout elapsed waiting for network idle, continuing anyways..."
           );
@@ -1550,33 +2260,146 @@ var _ChromeBrowser = class _ChromeBrowser {
       }
       if (!rejected && urlChanged(this.url, startURL)) {
         this.logger.debug(
+          { startURL, newURL: this.url },
           `Detected url change in wrapPossibleNavigation, waiting for load state`
         );
-        try {
-          yield this.page.waitForLoadState("load", {
-            timeout: timeoutMS - (Date.now() - startTime)
+        const remainingTimeout = Math.max(
+          timeoutMS - (Date.now() - startTime),
+          0
+        );
+        if (remainingTimeout > 0) {
+          try {
+            yield this.page.waitForLoadState("load", {
+              timeout: remainingTimeout
+            });
+          } catch (e) {
+            this.logger.warn(
+              { url: this.url },
+              "Timeout elapsed waiting for load state to fire, continuing anyways..."
+            );
+          }
+        }
+      }
+      return unwrapAndThrowError(retPromise);
+    });
+  }
+  /**
+   * Given a potentially cached a11y ID, resolve it to an actual ID, checking that it is still valid.
+   * If the ID is no longer valid, try to auto-heal with heuristics.
+   * Throws if no auto-healing is possible.
+   */
+  resolveCachedTargetToID(target) {
+    return __async(this, null, function* () {
+      if (!target.name && !target.role && !target.content) {
+        const node = this.nodeMap.get(`${target.id}`);
+        if (!node) {
+          throw new Error(
+            `Resolving target failed, fresh value did not exist in node map: ${target.id}`
+          );
+        }
+        saveNodeDetailsToCache(node, target);
+        return target.id;
+      }
+      yield this.getA11yTree();
+      const proposedNode = this.nodeMap.get(`${target.id}`);
+      if (proposedNode) {
+        const comparisonScore = getNodeComparisonScore(proposedNode, target);
+        if (comparisonScore >= MIN_SIMILARITY_SCORE_TO_REUSE) {
+          this.logger.debug(
+            { target, proposedNode: proposedNode.getLogForm(), comparisonScore },
+            "Resolved cached a11y target to node with exact same id"
+          );
+          saveNodeDetailsToCache(proposedNode, target);
+          return target.id;
+        }
+      }
+      let closestLevenshteinDistance = Infinity;
+      let smallestLevenshteinRatio = Infinity;
+      let closestNode;
+      for (const node of this.nodeMap.values()) {
+        const comparisonScore = getNodeComparisonScore(node, target);
+        if (comparisonScore >= MIN_SIMILARITY_SCORE_TO_REUSE) {
+          this.logger.debug(
+            { newNode: node.getLogForm(), target, comparisonScore },
+            "Resolved cached a11y target to new node with field comparison"
+          );
+          saveNodeDetailsToCache(node, target);
+          return parseInt(node.id);
+        }
+        if (target.serializedForm) {
+          const serializedNode = node.serialize({
+            noID: true,
+            maxLevel: 1,
+            neighbors: 1
           });
-        } catch (e) {
-          this.logger.warn(
-            { url: this.url },
-            "Timeout elapsed waiting for load state to fire, continuing anyways..."
+          if (Math.abs(serializedNode.length - target.serializedForm.length) > MAX_LEVENSHTEIN_DISTANCE) {
+            continue;
+          }
+          const levenshteinDistance = distance2(
+            target.serializedForm,
+            serializedNode
           );
+          const ratio = levenshteinDistance / Math.min(target.serializedForm.length, serializedNode.length);
+          if (levenshteinDistance < closestLevenshteinDistance && ratio < MAX_LEVENSHTEIN_CHANGE_RATIO) {
+            closestLevenshteinDistance = levenshteinDistance;
+            smallestLevenshteinRatio = ratio;
+            closestNode = node;
+          }
         }
       }
-      return unwrapAndThrowError(retPromise);
+      if (closestNode && closestLevenshteinDistance < MAX_LEVENSHTEIN_DISTANCE) {
+        this.logger.debug(
+          {
+            newNode: closestNode.getLogForm(),
+            target,
+            distance: closestLevenshteinDistance,
+            ratio: smallestLevenshteinRatio
+          },
+          "Resolved cached a11y target to new node with pure levenshtein distance"
+        );
+        saveNodeDetailsToCache(closestNode, target);
+        return parseInt(closestNode.id);
+      }
+      throw new Error(
+        `Could not find any relevant node given cached target: ${JSON.stringify(
+          target
+        )}`
+      );
     });
   }
   click(_0) {
     return __async(this, arguments, function* (target, options = {}) {
+      const id = yield this.resolveCachedTargetToID(target);
       const elementInteracted = yield this.wrapPossibleNavigation(
-        () => this.clickByA11yID(target.id, options)
+        () => this.clickByA11yID(id, options)
       );
       return elementInteracted;
     });
   }
+  hover(target) {
+    return __async(this, null, function* () {
+      const nodeId = yield this.resolveCachedTargetToID(target);
+      const node = this.nodeMap.get(`${nodeId}`);
+      if (!node) {
+        throw new Error(`Could not find DOM node for hover: ${nodeId}`);
+      }
+      if (!node.backendNodeID) {
+        throw new Error(
+          `Hover target missing backend node id: ${node.getLogForm()}`
+        );
+      }
+      const locator = yield this.getLocatorFromBackendID(node.backendNodeID);
+      yield locator.hover({
+        timeout: BROWSER_ACTION_TIMEOUT_MS
+      });
+      yield this.highlightNode(node);
+      return node.serialize({ noChildren: true, noProperties: true, noID: true });
+    });
+  }
   selectOption(target, option) {
     return __async(this, null, function* () {
-      return this.selectOptionByA11yID(target.id, option);
+      const id = yield this.resolveCachedTargetToID(target);
+      return this.selectOptionByA11yID(id, option);
     });
   }
   press(key) {
@@ -1633,7 +2456,7 @@ var _ChromeBrowser = class _ChromeBrowser {
       );
       let accessibilityTreeLoadFired = false;
       const accessibilityLoadListener = () => {
-        this.logger.info({ url }, `A11y tree load event fired`);
+        this.logger.info({ url }, `Load event fired on page`);
         accessibilityTreeLoadFired = true;
       };
       this.cdpClient.addListener(
@@ -1644,7 +2467,7 @@ var _ChromeBrowser = class _ChromeBrowser {
       let timeoutTriggered = true;
       while (Date.now() - a11yLoadStart < A11Y_STABLE_TIMEOUT_MS) {
         yield sleep(CHECK_INTERVAL_MS);
-        if (!accessibilityTreeLoadFired && Date.now() - a11yLoadStart < A11Y_LOAD_TIMEOUT_MS) {
+        if (!accessibilityTreeLoadFired && Date.now() - a11yLoadStart < A11Y_LOAD_TIMEOUT_MS && process.env.NODE_ENV !== "production") {
           this.logger.debug({ url }, `A11y tree not loaded yet, waiting...`);
           continue;
         }
@@ -1906,7 +2729,7 @@ var _ChromeBrowser = class _ChromeBrowser {
     });
   }
 };
-_ChromeBrowser.USER_AGENT = playwright_exports.devices["Desktop Chrome"].userAgent;
+_ChromeBrowser.USER_AGENT = devices["Desktop Chrome"].userAgent;
 var ChromeBrowser = _ChromeBrowser;
 
 // ../../packages/web-agent/src/configs/controller.ts
@@ -2069,6 +2892,9 @@ var AgentController = class {
   }
   locateElement(description, disableCache) {
     return __async(this, null, function* () {
+      if (!description) {
+        throw new Error("Cannot locate element with empty description");
+      }
       const locator = yield this.generator.getElementLocation(
         { browserState: yield this.getBrowserState(), goal: description },
         disableCache
@@ -2156,10 +2982,8 @@ var AgentController = class {
           command,
           disableCache
         );
-        this.logger.info(
-          { result, duration: Date.now() - executionStart },
-          "Got execution result"
-        );
+        const duration = Date.now() - executionStart;
+        this.logger.debug({ result, duration }, "Got execution result");
       } catch (e) {
         if (e instanceof Error) {
           throw new BrowserExecutionError(`Failed to execute command: ${e}`, {
@@ -2240,6 +3064,45 @@ var AgentController = class {
       };
     });
   }
+  wrapElementTargetingCommand(target, disableCache, action, newlyGenerated = false) {
+    return __async(this, null, function* () {
+      if (!target.a11yData) {
+        target.a11yData = A11yTargetWithCacheSchema.parse(
+          yield this.locateElement(target.elementDescriptor, disableCache)
+        );
+        newlyGenerated = true;
+      }
+      try {
+        const result = yield action(target.a11yData);
+        this.logger.debug(
+          { target },
+          "Successfully used cached target to perform action"
+        );
+        return result;
+      } catch (err) {
+        if (!newlyGenerated) {
+          this.logger.warn(
+            { err, target },
+            "Failed to execute action with cached target, retrying with AI"
+          );
+          target.a11yData = void 0;
+          return this.wrapElementTargetingCommand(
+            target,
+            disableCache,
+            action,
+            true
+          );
+        }
+        this.logger.error(
+          { err, target },
+          "Failed to target element even after all auto-healing"
+        );
+        throw new Error(
+          `Failed to find element with description: ${target.elementDescriptor}. Has your website changed significantly?`
+        );
+      }
+    });
+  }
   /**
    * Executes a preset command.
    * For most cases, the execution result contains metadata about the command executed.
@@ -2248,7 +3111,7 @@ var AgentController = class {
    */
   executePresetStep(command, disableCache) {
     return __async(this, null, function* () {
-      var _a, _b, _c;
+      var _a;
       const urlBeforeCommand = this.browser.url;
       switch (command.type) {
         case "SUCCESS" /* SUCCESS */:
@@ -2284,24 +3147,13 @@ var AgentController = class {
           yield this.browser.refresh();
           break;
         case "CLICK" /* CLICK */: {
-          let id;
-          if (command.target.a11yData) {
-            id = (_b = command.target.a11yData) == null ? void 0 : _b.id;
-          } else {
-            const locator = yield this.locateElement(
-              command.target.elementDescriptor,
-              disableCache
-            );
-            id = locator.id;
-          }
-          const elementInteracted = yield this.browser.click(
-            {
-              id
-            },
-            {
+          const elementInteracted = yield this.wrapElementTargetingCommand(
+            command.target,
+            disableCache,
+            (target) => this.browser.click(target, {
               doubleClick: command.doubleClick,
               rightClick: command.rightClick
-            }
+            })
           );
           const result2 = {
             urlAfterCommand: this.browser.url,
@@ -2315,21 +3167,10 @@ var AgentController = class {
           return result2;
         }
         case "SELECT_OPTION" /* SELECT_OPTION */: {
-          let id;
-          if (command.target.a11yData) {
-            id = (_c = command.target.a11yData) == null ? void 0 : _c.id;
-          } else {
-            const locator = yield this.locateElement(
-              command.target.elementDescriptor,
-              disableCache
-            );
-            id = locator.id;
-          }
-          const elementInteracted = yield this.browser.selectOption(
-            {
-              id
-            },
-            command.option
+          const elementInteracted = yield this.wrapElementTargetingCommand(
+            command.target,
+            disableCache,
+            (targetWithA11yData) => this.browser.selectOption(targetWithA11yData, command.option)
           );
           return {
             succeedImmediately: false,
@@ -2341,24 +3182,17 @@ var AgentController = class {
           yield this.browser.switchToPage(command.url);
           break;
         case "COOKIE" /* COOKIE */:
+          if (!command.value) {
+            break;
+          }
           yield this.browser.setCookie(command.value);
           break;
         case "TYPE" /* TYPE */: {
-          let elementInteracted;
-          const target = command.target;
-          if (target.a11yData) {
-            elementInteracted = yield this.browser.click({
-              id: target.a11yData.id
-            });
-          } else if (target.elementDescriptor.length > 0) {
-            const locator = yield this.locateElement(
-              command.target.elementDescriptor,
-              disableCache
-            );
-            elementInteracted = yield this.browser.click({
-              id: locator.id
-            });
-          }
+          const elementInteracted = yield this.wrapElementTargetingCommand(
+            command.target,
+            disableCache,
+            (target) => this.browser.click(target)
+          );
           yield this.browser.type(command.value, {
             clearContent: command.clearContent,
             pressKeysSequentially: command.pressKeysSequentially
@@ -2377,6 +3211,18 @@ var AgentController = class {
           }
           return result2;
         }
+        case "HOVER" /* HOVER */: {
+          const elementInteracted = yield this.wrapElementTargetingCommand(
+            command.target,
+            disableCache,
+            (target) => this.browser.hover(target)
+          );
+          return {
+            succeedImmediately: false,
+            urlAfterCommand: this.browser.url,
+            elementInteracted
+          };
+        }
         case "PRESS" /* PRESS */:
           yield this.browser.press(command.value);
           const result = {
@@ -2405,7 +3251,7 @@ var AgentController = class {
 // ../../packages/web-agent/src/generators/api-generator.ts
 import fetchRetry from "fetch-retry";
 var fetch2 = fetchRetry(global.fetch);
-var API_VERSION = "v1";
+var API_VERSION2 = "v1";
 var APIGenerator = class {
   constructor(params) {
     this.baseURL = params.baseURL;
@@ -2414,7 +3260,7 @@ var APIGenerator = class {
   getElementLocation(context, disableCache) {
     return __async(this, null, function* () {
       const result = yield this.sendRequest(
-        `/${API_VERSION}/web-agent/locate-element`,
+        `/${API_VERSION2}/web-agent/locate-element`,
         {
           browserState: context.browserState,
           goal: context.goal,
@@ -2429,7 +3275,7 @@ var APIGenerator = class {
       var _a;
       if (useVision) {
         const result2 = yield this.sendRequest(
-          `/${API_VERSION}/web-agent/assertion`,
+          `/${API_VERSION2}/web-agent/assertion`,
           {
             url: context.url,
             goal: context.goal,
@@ -2441,7 +3287,7 @@ var APIGenerator = class {
         return GetAssertionResponseSchema.parse(result2);
       }
       const result = yield this.sendRequest(
-        `/${API_VERSION}/web-agent/assertion`,
+        `/${API_VERSION2}/web-agent/assertion`,
         {
           url: context.url,
           browserState: context.browserState,
@@ -2459,117 +3305,40 @@ var APIGenerator = class {
   getProposedCommand(context, disableCache) {
     return __async(this, null, function* () {
       const result = yield this.sendRequest(
-        `/${API_VERSION}/web-agent/next-command`,
-        {
-          url: context.url,
-          browserState: context.browserState,
-          goal: context.goal,
-          history: context.history,
-          numPrevious: context.numPrevious,
-          lastCommand: context.lastCommand,
-          disableCache
-        }
-      );
-      return GetNextCommandResponseSchema.parse(result);
-    });
-  }
-  getGranularGoals(context, disableCache) {
-    return __async(this, null, function* () {
-      const result = yield this.sendRequest(
-        `/${API_VERSION}/web-agent/split-goal`,
+        `/${API_VERSION2}/web-agent/next-command`,
         {
           url: context.url,
-          goal: context.goal,
-          disableCache
-        }
-      );
-      return SplitGoalResponseSchema.parse(result);
-    });
-  }
-  sendRequest(path, body) {
-    return __async(this, null, function* () {
-      const response = yield fetch2(`${this.baseURL}${path}`, {
-        retries: 3,
-        retryDelay: 1e3,
-        method: "POST",
-        body: JSON.stringify(body),
-        headers: {
-          "Content-Type": "application/json",
-          Authorization: `Bearer ${this.apiKey}`
-        }
-      });
-      if (!response.ok) {
-        throw new Error(
-          `Request to ${path} failed with status ${response.status}: ${yield response.text()}`
-        );
-      }
-      return response.json();
-    });
-  }
-};
-
-// src/api-client.ts
-var API_VERSION2 = "v1";
-var APIClient = class {
-  constructor(params) {
-    this.baseURL = params.baseURL;
-    this.apiKey = params.apiKey;
-  }
-  getRun(runId) {
-    return __async(this, null, function* () {
-      const result = yield this.sendRequest(`/${API_VERSION2}/runs/${runId}`, {
-        method: "GET"
-      });
-      return GetRunResponseSchema.parse(result);
-    });
-  }
-  createRun(body) {
-    return __async(this, null, function* () {
-      const result = yield this.sendRequest(`/${API_VERSION2}/runs`, {
-        method: "POST",
-        body
-      });
-      return CreateRunResponseSchema.parse(result);
-    });
-  }
-  updateRun(runId, body) {
-    return __async(this, null, function* () {
-      yield this.sendRequest(`/${API_VERSION2}/runs/${runId}`, {
-        method: "PATCH",
-        body
-      });
-    });
-  }
-  getTest(testId) {
-    return __async(this, null, function* () {
-      const result = yield this.sendRequest(`/${API_VERSION2}/tests/${testId}`, {
-        method: "GET"
-      });
-      return GetTestResponseSchema.parse(result);
+          browserState: context.browserState,
+          goal: context.goal,
+          history: context.history,
+          numPrevious: context.numPrevious,
+          lastCommand: context.lastCommand,
+          disableCache
+        }
+      );
+      return GetNextCommandResponseSchema.parse(result);
     });
   }
-  queueTests(body) {
+  getGranularGoals(context, disableCache) {
     return __async(this, null, function* () {
-      yield this.sendRequest(`/${API_VERSION2}/tests/queue`, {
-        method: "POST",
-        body
-      });
+      const result = yield this.sendRequest(
+        `/${API_VERSION2}/web-agent/split-goal`,
+        {
+          url: context.url,
+          goal: context.goal,
+          disableCache
+        }
+      );
+      return SplitGoalResponseSchema.parse(result);
     });
   }
-  uploadScreenshot(body) {
+  sendRequest(path3, body) {
     return __async(this, null, function* () {
-      const result = yield this.sendRequest(`/${API_VERSION2}/screenshots`, {
+      const response = yield fetch2(`${this.baseURL}${path3}`, {
+        retries: 1,
+        retryDelay: 1e3,
         method: "POST",
-        body
-      });
-      return CreateScreenshotResponseSchema.parse(result);
-    });
-  }
-  sendRequest(path, options) {
-    return __async(this, null, function* () {
-      const response = yield fetch(`${this.baseURL}${path}`, {
-        method: options.method,
-        body: options.body ? JSON.stringify(options.body) : void 0,
+        body: JSON.stringify(body),
         headers: {
           "Content-Type": "application/json",
           Authorization: `Bearer ${this.apiKey}`
@@ -2577,17 +3346,68 @@ var APIClient = class {
       });
       if (!response.ok) {
         throw new Error(
-          `Request to ${path} failed with status ${response.status}: ${yield response.text()}`
+          `Request to ${path3} failed with status ${response.status}: ${yield response.text()}`
         );
       }
-      if (response.status === 204) {
-        return response.text();
-      }
       return response.json();
     });
   }
 };
 
+// src/get-tests.ts
+import fs from "fs";
+import path2 from "path";
+var bannedDirs = /* @__PURE__ */ new Set([
+  "modules",
+  // this is reserved directory
+  "node_modules",
+  "dist",
+  "bin",
+  ".git",
+  "logs",
+  ".npm",
+  ".next",
+  "out",
+  ".yarn",
+  "__pycache__",
+  "build",
+  ".env",
+  ".venv",
+  "venv",
+  "env",
+  "wheels"
+]);
+function getTestFilesRecursively(dir) {
+  var _a;
+  const dirName = (_a = dir.split(path2.sep).pop()) != null ? _a : "";
+  if (bannedDirs.has(dirName)) {
+    if (dirName !== "modules") {
+      consoleLogger.warn(
+        `Skipping directory '${dir}' because it is likely an artifact folder.`
+      );
+    }
+    return [];
+  }
+  const files = fs.readdirSync(dir);
+  let filePathList = [];
+  files.forEach((file) => {
+    const filepath = path2.join(dir, file);
+    if (fs.statSync(filepath).isDirectory()) {
+      filePathList = filePathList.concat(getTestFilesRecursively(filepath));
+    } else if (file.endsWith(".yaml")) {
+      const contents = fs.readFileSync(filepath, "utf-8");
+      if (contents.includes("momentic/test" /* TEST */)) {
+        filePathList.push(filepath);
+      } else {
+        consoleLogger.warn(
+          `Skipping file '${filepath}' because it does not appear to be a valid Momentic test.`
+        );
+      }
+    }
+  });
+  return filePathList;
+}
+
 // ../../packages/execute/src/constants.ts
 var MAX_COMMANDS_PER_STEP = 20;
 
@@ -2664,7 +3484,9 @@ var executeAIStep = (_a) => __async(void 0, null, function* () {
         status: "SUCCESS" /* SUCCESS */
       };
       logger.info(
-        `Executing command ${commandIndex}: ${serializeCommand(command)}`
+        `Starting sub-command ${commandIndex} within AI step: ${serializeCommand(
+          command
+        )}`
       );
       try {
         const executionResult = yield controller.executeCommand(
@@ -2672,6 +3494,7 @@ var executeAIStep = (_a) => __async(void 0, null, function* () {
           advanced.disableAICaching,
           useSavedCommands
         );
+        logger.info(`AI sub-command ${commandIndex} completed successfully`);
         cmdResult.elementInteracted = executionResult.elementInteracted;
         (_c = callbacks.onCommandExecuted) == null ? void 0 : _c.call(callbacks, {
           commandIndex,
@@ -2822,7 +3645,8 @@ var executePresetStep = (_a) => __async(void 0, null, function* () {
     (_b2 = callbacks.onSuccess) == null ? void 0 : _b2.call(callbacks, {
       message,
       startedAt: startedAt.getTime(),
-      durationMs: finishedAt.getTime() - startedAt.getTime()
+      durationMs: finishedAt.getTime() - startedAt.getTime(),
+      command: step.command
     });
     return result;
   } catch (err) {
@@ -2882,7 +3706,12 @@ var executeModuleStep = (_a) => __async(void 0, null, function* () {
   };
   for (let i = 0; i < step.steps.length; i++) {
     const moduleStep = step.steps[i];
-    logger.info({ i, moduleStep }, `Starting module step`);
+    logger.debug({ i, moduleStep }, `Starting module step`);
+    logger.info(
+      `Starting module sub-step ${i + 1}/${step.steps.length}: ${serializeStep(
+        moduleStep
+      )}`
+    );
     let moduleStepResult;
     switch (moduleStep.type) {
       case "PRESET_ACTION" /* PRESET_ACTION */:
@@ -3010,6 +3839,7 @@ var executeTest = (_0) => __async(void 0, [_0], function* ({
   onUpdateRun,
   onSaveScreenshot
 }) {
+  var _a;
   const advanced = TestAdvancedSettingsSchema.parse(test.advanced);
   logger.info(`Starting run ${runId} for test ${test.id}`);
   yield onUpdateRun({
@@ -3018,8 +3848,12 @@ var executeTest = (_0) => __async(void 0, [_0], function* ({
   });
   let failed = false;
   const results = [];
+  const runLogger = logger.child({ runId, testId: test.id });
   for (let i = 0; i < test.steps.length; i++) {
     const step = test.steps[i];
+    runLogger.info(
+      `Starting step ${i + 1}/${test.steps.length}: ${serializeStep(step)}`
+    );
     let result;
     switch (step.type) {
       case "PRESET_ACTION" /* PRESET_ACTION */:
@@ -3027,7 +3861,7 @@ var executeTest = (_0) => __async(void 0, [_0], function* ({
           controller,
           step,
           advanced,
-          logger,
+          logger: runLogger,
           onSaveScreenshot
         });
         break;
@@ -3036,7 +3870,7 @@ var executeTest = (_0) => __async(void 0, [_0], function* ({
           controller,
           step,
           advanced,
-          logger,
+          logger: runLogger,
           onSaveScreenshot
         });
         break;
@@ -3045,7 +3879,7 @@ var executeTest = (_0) => __async(void 0, [_0], function* ({
           controller,
           step,
           advanced,
-          logger,
+          logger: runLogger,
           onSaveScreenshot
         });
         break;
@@ -3060,6 +3894,13 @@ var executeTest = (_0) => __async(void 0, [_0], function* ({
       results
     });
     if (result.status === "FAILED" /* FAILED */) {
+      runLogger.error(`Step ${i + 1}/${test.steps.length} failed`);
+      runLogger.error(
+        {
+          message: (_a = results[results.length - 1]) == null ? void 0 : _a.message
+        },
+        `Last result:`
+      );
       failed = true;
       for (let j = i + 1; j < test.steps.length; j++) {
         const skippedStep = test.steps[j];
@@ -3093,6 +3934,8 @@ var executeTest = (_0) => __async(void 0, [_0], function* ({
           results.push(skippedResult);
         }
       }
+    } else {
+      runLogger.info(`Step ${i + 1}/${test.steps.length} succeeded`);
     }
     if (failed) {
       break;
@@ -3107,31 +3950,365 @@ var executeTest = (_0) => __async(void 0, [_0], function* ({
   return failed;
 });
 
-// src/logger.ts
-var consoleLogger = {
-  info: console.log,
-  error: console.error,
-  debug: console.debug,
-  warn: console.warn,
-  child: () => consoleLogger,
-  flush: () => {
-  }
+// ../../packages/test-migrations/src/index.ts
+import diffLines2 from "diff-lines";
+import semver from "semver";
+
+// ../../packages/test-migrations/src/2023-12-28-1.0.5-migrate-to-ai-step-v2.ts
+var migrateToAIStepV2 = {
+  name: "Migrate to ai step v2",
+  fromVersion: "1.0.4",
+  toVersion: "1.0.5",
+  recursiveKeys: /* @__PURE__ */ new Set(["results", "commands"]),
+  stopOnFailure: true,
+  execute: (steps) => __async(void 0, null, function* () {
+    steps = steps.filter(
+      (step) => !(step.status !== void 0 && step.type === "AI_ACTION")
+    );
+    steps = steps.map((step) => {
+      var _a, _b;
+      if (step.status === void 0) {
+        return step;
+      }
+      if (step.type === "PRESET_ACTION") {
+        step.results = (_b = (_a = step.commands) != null ? _a : step.results) != null ? _b : [];
+      }
+      return step;
+    });
+    return steps;
+  })
+};
+
+// ../../packages/test-migrations/src/2024-01-05-1.0.6-ensure-ai-step-has-done.ts
+var ensureAIStepHasDone = {
+  name: "Make sure ai step v2 has done command",
+  fromVersion: "1.0.5",
+  toVersion: "1.0.6",
+  recursiveKeys: /* @__PURE__ */ new Set(["results", "commands"]),
+  stopOnFailure: true,
+  execute: (steps) => __async(void 0, null, function* () {
+    return steps.map((step) => {
+      if (step.type !== "AI_ACTION") {
+        return step;
+      }
+      if (step.status !== void 0) {
+        return step;
+      }
+      if (!step.commands || !step.commands.length) {
+        return step;
+      }
+      const commands = step.commands;
+      const lastCommand = commands[commands.length - 1];
+      if (lastCommand && lastCommand["type"] !== "SUCCESS") {
+        commands.push({
+          type: "SUCCESS"
+        });
+      }
+      return step;
+    });
+  })
+};
+
+// ../../packages/test-migrations/src/migrate-assertions-to-preset.ts
+var migrateAssertionsToPresetActions = {
+  name: "Migrate AI assertions to preset actions",
+  fromVersion: "1.0.0",
+  toVersion: "1.0.1",
+  recursiveKeys: /* @__PURE__ */ new Set(),
+  execute: (steps) => __async(void 0, null, function* () {
+    return steps.map((record2) => {
+      if (record2["type"] !== "AI_ASSERTION") {
+        return record2;
+      }
+      const assertion = record2["text"];
+      const newPresetStep = {
+        type: "PRESET_ACTION",
+        command: {
+          type: "AI_ASSERTION",
+          assertion,
+          useVision: false,
+          disableCache: true
+        }
+      };
+      const migratedStep = __spreadValues(__spreadValues({}, record2), newPresetStep);
+      delete migratedStep["text"];
+      return migratedStep;
+    });
+  }),
+  stopOnFailure: true
+};
+
+// ../../packages/test-migrations/src/migrate-element-descriptor-to-target.ts
+var targetRequiredCommands = /* @__PURE__ */ new Set([
+  "CLICK",
+  "TYPE",
+  "SELECT_OPTION"
+]);
+var migrateElementDescriptorToTarget = {
+  name: "Migrate element descriptor to live in a target object",
+  fromVersion: "1.0.3",
+  toVersion: "1.0.4",
+  recursiveKeys: /* @__PURE__ */ new Set(),
+  execute: (steps) => __async(void 0, null, function* () {
+    return steps.map((step) => {
+      const command = step["command"];
+      const commandType = command == null ? void 0 : command["type"];
+      const elementDescriptor = command == null ? void 0 : command["elementDescriptor"];
+      if (elementDescriptor !== void 0 || targetRequiredCommands.has(commandType)) {
+        command["target"] = {
+          elementDescriptor: elementDescriptor != null ? elementDescriptor : ""
+        };
+      }
+      if (step["commands"] && Array.isArray(step["commands"])) {
+        const commands = step["commands"];
+        commands.forEach((command2) => {
+          const elementDescriptor2 = command2 == null ? void 0 : command2["elementDescriptor"];
+          const commandType2 = command2 == null ? void 0 : command2["type"];
+          if (elementDescriptor2 !== void 0 || targetRequiredCommands.has(commandType2)) {
+            command2["target"] = {
+              elementDescriptor: elementDescriptor2 != null ? elementDescriptor2 : ""
+            };
+          }
+        });
+      }
+      if (step["results"] && Array.isArray(step["results"])) {
+        const commandResults = step["results"];
+        commandResults.forEach((commandResult) => {
+          const command2 = commandResult["command"];
+          const elementDescriptor2 = command2 == null ? void 0 : command2["elementDescriptor"];
+          const commandType2 = command2 == null ? void 0 : command2["type"];
+          if (elementDescriptor2 !== void 0 || targetRequiredCommands.has(commandType2)) {
+            command2["target"] = {
+              elementDescriptor: elementDescriptor2 != null ? elementDescriptor2 : ""
+            };
+          }
+          if (commandResult["commands"] && Array.isArray(commandResult["commands"])) {
+            const commands = commandResult["commands"];
+            commands.forEach((command3) => {
+              const elementDescriptor3 = command3 == null ? void 0 : command3["elementDescriptor"];
+              const commandType3 = command3 == null ? void 0 : command3["type"];
+              if (elementDescriptor3 !== void 0 || targetRequiredCommands.has(commandType3)) {
+                command3["target"] = {
+                  elementDescriptor: elementDescriptor3 != null ? elementDescriptor3 : ""
+                };
+              }
+            });
+          }
+        });
+      }
+      return step;
+    });
+  }),
+  stopOnFailure: true
+};
+
+// ../../packages/test-migrations/src/migrate-failure-to-failed.ts
+var migrateFailureToFailed = {
+  name: "Migrate FAILURE status to FAILED",
+  fromVersion: "1.0.1",
+  toVersion: "1.0.2",
+  recursiveKeys: /* @__PURE__ */ new Set(),
+  execute: (steps) => __async(void 0, null, function* () {
+    return steps.map((step) => {
+      const record2 = step;
+      if (record2["status"] === "FAILURE") {
+        record2["status"] = "FAILED";
+      }
+      if (typeof record2.commands === "object" && Array.isArray(record2.commands)) {
+        record2.commands.forEach((command) => {
+          if (command && typeof command === "object") {
+            const commandObject = command;
+            if ((commandObject == null ? void 0 : commandObject.status) === "FAILURE") {
+              commandObject.status = "FAILED";
+            }
+          }
+        });
+      }
+      return record2;
+    });
+  }),
+  stopOnFailure: true
+};
+
+// ../../packages/test-migrations/src/migrate-preset-step-type.ts
+var migratePresetStepTypeToDropPrefix = {
+  name: "Migrate preset step types to use the same",
+  fromVersion: "1.0.2",
+  toVersion: "1.0.3",
+  recursiveKeys: /* @__PURE__ */ new Set(),
+  execute: (steps) => __async(void 0, null, function* () {
+    return steps.map((step) => {
+      const command = step["command"];
+      const commandType = command == null ? void 0 : command["type"];
+      if (commandType == null ? void 0 : commandType.startsWith("PRESET_")) {
+        command["type"] = commandType.slice(7);
+      }
+      if (step["commands"] && Array.isArray(step["commands"])) {
+        const commands = step["commands"];
+        commands.forEach((command2) => {
+          const commandType2 = command2["type"];
+          if (commandType2 == null ? void 0 : commandType2.startsWith("PRESET_")) {
+            command2["type"] = commandType2.slice(7);
+          }
+        });
+      }
+      if (step["results"] && Array.isArray(step["results"])) {
+        const commandResults = step["results"];
+        commandResults.forEach((commandResult) => {
+          const command2 = commandResult["command"];
+          const commandType2 = command2 == null ? void 0 : command2["type"];
+          if (commandType2 == null ? void 0 : commandType2.startsWith("PRESET_")) {
+            command2["type"] = commandType2.slice(7);
+          }
+          if (commandResult["commands"] && Array.isArray(commandResult["commands"])) {
+            const commands = commandResult["commands"];
+            commands.forEach((command3) => {
+              const commandType3 = command3["type"];
+              if (commandType3 == null ? void 0 : commandType3.startsWith("PRESET_")) {
+                command3["type"] = commandType3.slice(7);
+              }
+            });
+          }
+        });
+      }
+      return step;
+    });
+  }),
+  stopOnFailure: true
 };
 
+// ../../packages/test-migrations/src/index.ts
+var testMigrations = [
+  migrateAssertionsToPresetActions,
+  migrateFailureToFailed,
+  migratePresetStepTypeToDropPrefix,
+  migrateElementDescriptorToTarget,
+  migrateToAIStepV2,
+  ensureAIStepHasDone
+  // add new migrations here!
+];
+if (LATEST_VERSION !== testMigrations[testMigrations.length - 1].toVersion) {
+  throw new Error(
+    `Please bump LATEST_VERSION in types package after adding a migration`
+  );
+}
+testMigrations.forEach((migration, index) => {
+  if (!semver.valid(migration.toVersion) || !semver.valid(migration.fromVersion)) {
+    throw new Error(`Migration '${migration.name}' has invalid version`);
+  }
+  if (!semver.gt(migration.toVersion, migration.fromVersion)) {
+    throw new Error(
+      `Migration '${migration.name}' has toVersion <= fromVersion`
+    );
+  }
+  if (index === 0)
+    return;
+  const previousMigration = testMigrations[index - 1];
+  if (previousMigration.toVersion !== migration.fromVersion) {
+    throw new Error(
+      `Migration '${migration.name}' at index ${index} is not contiguous with previous migration`
+    );
+  }
+});
+function isArrayOfStepObjects(val) {
+  return val.every((v) => v && typeof v === "object" && !Array.isArray(v));
+}
+var runStepMigrations = (_0) => __async(void 0, [_0], function* ({
+  metadata,
+  steps: inputSteps,
+  logger
+}) {
+  let steps = inputSteps;
+  const { schemaVersion: currentVersion, id } = metadata;
+  const migrationIndex = testMigrations.findIndex(
+    (migration) => semver.gt(migration.toVersion, currentVersion)
+  );
+  if (migrationIndex === -1) {
+    logger.debug({ id }, "Step migrations up to date");
+    return { steps, newVersion: currentVersion };
+  }
+  let newVersion = currentVersion;
+  for (let i = migrationIndex; i < testMigrations.length; i++) {
+    const migration = testMigrations[i];
+    const logIdentifiers = {
+      id,
+      migration: migration.name,
+      toVersion: migration.toVersion
+    };
+    logger.debug(logIdentifiers, "Starting migration");
+    try {
+      steps = yield migrateStepLikeArrayRecursively(steps, migration);
+      newVersion = migration.toVersion;
+    } catch (err) {
+      logger.error(__spreadValues({ err }, logIdentifiers), "Migration failed");
+      throw new Error(`Step migration ${migration.name} failed: ${err}`);
+    }
+  }
+  const diffs = diffLines2(
+    JSON.stringify(inputSteps, void 0, 2),
+    JSON.stringify(steps, void 0, 2),
+    { n_surrounding: 1 }
+  );
+  logger.debug({ diffs, id }, "Migration diffs");
+  return {
+    newVersion,
+    steps
+  };
+});
+function migrateStepLikeArrayRecursively(inputSteps, migration) {
+  return __async(this, null, function* () {
+    const steps = yield migration.execute(inputSteps);
+    for (const step of steps) {
+      for (const key of Object.keys(step)) {
+        if (!migration.recursiveKeys.has(key)) {
+          continue;
+        }
+        const val = step[key];
+        if (!val || !Array.isArray(val)) {
+          continue;
+        }
+        if (!isArrayOfStepObjects(val)) {
+          continue;
+        }
+        step[key] = yield migrateStepLikeArrayRecursively(val, migration);
+      }
+    }
+    return steps;
+  });
+}
+
 // src/run-test.ts
+import { parse } from "yaml";
 function runTest(_0) {
   return __async(this, arguments, function* ({
-    testId,
+    path: path3,
     apiClient,
     generator,
-    newBaseURL
+    newBaseURL,
+    useLocalFiles
   }) {
-    const test = yield apiClient.getTest(testId);
+    let test;
+    if (useLocalFiles) {
+      consoleLogger.info(`Reading ${path3} from local filesystem`);
+      test = yield resolveLocalTest(path3);
+    } else {
+      consoleLogger.info(
+        `Fetching ${path3} from Momentic server (${apiClient.baseURL})`
+      );
+      test = yield apiClient.getTest(path3);
+    }
+    if (test.schemaVersion > LATEST_VERSION) {
+      consoleLogger.warn(
+        `Test ${path3} has schema version ${test.schemaVersion}, which is greater than what is currently supported by this SDK. Please update your momentic package version to avoid unexpected behavior.`
+      );
+    }
     const originalURL = new URL(test.baseUrl);
-    const newURL = new URL(newBaseURL);
-    originalURL.hostname = newURL.hostname;
-    originalURL.protocol = newURL.protocol;
-    originalURL.port = newURL.port;
+    if (newBaseURL) {
+      const newURL = new URL(newBaseURL);
+      originalURL.hostname = newURL.hostname;
+      originalURL.protocol = newURL.protocol;
+      originalURL.port = newURL.port;
+    }
     const browser = yield ChromeBrowser.init(
       originalURL.toString(),
       consoleLogger
@@ -3142,10 +4319,16 @@ function runTest(_0) {
       config: DEFAULT_CONTROLLER_CONFIG,
       logger: consoleLogger
     });
-    const run = yield apiClient.createRun({
-      testId,
-      trigger: "CLI"
-    });
+    let run;
+    try {
+      run = yield apiClient.createRun({
+        testId: test.id,
+        trigger: "CLI"
+      });
+    } catch (err) {
+      consoleLogger.info(err);
+      throw new Error(`Are you sure test ${test.name} exists on the server?`);
+    }
     let failed = true;
     try {
       failed = yield executeTest({
@@ -3173,6 +4356,83 @@ function runTest(_0) {
     return failed;
   });
 }
+function resolveLocalTest(filePath) {
+  return __async(this, null, function* () {
+    const { test, modules: unmigratedModules } = readTestWithModules(filePath);
+    const unmigratedTest = parse(test);
+    if (!unmigratedTest.steps || !Array.isArray(unmigratedTest.steps)) {
+      throw new Error(`Test ${filePath} is missing steps`);
+    }
+    if (!unmigratedTest.schemaVersion || !unmigratedTest.id) {
+      throw new Error(`Test ${filePath} is missing an ID or schema version`);
+    }
+    let steps;
+    if (unmigratedTest.schemaVersion < LATEST_VERSION) {
+      consoleLogger.warn(
+        `Test ${filePath} has schema version ${unmigratedTest.schemaVersion}, which is lower than the version used by this SDK, ${LATEST_VERSION}. Your test will be migrated to the latest version before execution.`
+      );
+      const { steps: migratedSteps } = yield runStepMigrations({
+        metadata: unmigratedTest,
+        steps: unmigratedTest.steps,
+        logger: consoleLogger
+      });
+      steps = StepSchema.array().parse(migratedSteps);
+    } else {
+      steps = StepSchema.array().parse(unmigratedTest.steps);
+    }
+    const migratedModules = {};
+    for (const [moduleId, unmigratedModuleYAML] of Object.entries(
+      unmigratedModules
+    )) {
+      const unmigratedModule = parse(unmigratedModuleYAML);
+      if (!unmigratedModule.schemaVersion || !unmigratedModule.moduleId) {
+        throw new Error(`Module ${moduleId} is missing an ID or schema version`);
+      }
+      if (!unmigratedModule.steps || !Array.isArray(unmigratedModule.steps)) {
+        throw new Error(`Module ${moduleId} is missing steps`);
+      }
+      if (unmigratedModule.schemaVersion < LATEST_VERSION) {
+        consoleLogger.warn(
+          `Module ${moduleId} has schema version ${unmigratedModule.schemaVersion}, which is lower than the version used by this SDK, ${LATEST_VERSION}. Your module will be migrated to the latest version before execution.`
+        );
+        const { steps: migratedSteps } = yield runStepMigrations({
+          metadata: {
+            id: unmigratedModule.moduleId,
+            schemaVersion: unmigratedModule.schemaVersion
+          },
+          steps: unmigratedModule.steps,
+          logger: consoleLogger
+        });
+        migratedModules[moduleId] = __spreadProps(__spreadValues({}, unmigratedModule), {
+          steps: AllowedModuleStepSchema.array().parse(migratedSteps)
+        });
+      } else {
+        migratedModules[moduleId] = unmigratedModule;
+      }
+    }
+    const resolvedTestSteps = steps.map((step) => {
+      if (step.type !== "MODULE" /* MODULE */) {
+        return step;
+      }
+      const resolvedModule = migratedModules[step.moduleId];
+      if (!resolvedModule) {
+        throw new Error(
+          `Could not resolve module ${step.moduleId} required in test ${filePath}`
+        );
+      }
+      const moduleStep = {
+        type: "RESOLVED_MODULE",
+        moduleId: step.moduleId,
+        name: resolvedModule.name,
+        steps: resolvedModule.steps
+      };
+      return moduleStep;
+    });
+    return MinimalRunnableResolvedTestSchema.parse(__spreadProps(__spreadValues({}, unmigratedTest), {
+      steps: resolvedTestSteps
+    }));
+  });
+}
 
 // src/run-tests-locally.ts
 function runTestsLocally(_0) {
@@ -3181,50 +4441,103 @@ function runTestsLocally(_0) {
     start,
     waitOn,
     waitOnTimeout,
-    server,
-    apiKey
+    client,
+    all,
+    parallelization = 1
   }) {
-    yield execCommand(start, false);
-    yield waitOnFn({
-      resources: [waitOn],
-      timeout: waitOnTimeout * 1e3
-    });
-    const apiClient = new APIClient({
-      baseURL: server,
-      apiKey
-    });
+    if (start) {
+      consoleLogger.info(`Running start command: ${start}`);
+      yield execCommand(start, false);
+    }
+    if (waitOn) {
+      consoleLogger.info(
+        `Waiting for ${waitOn} to be accessible (timeout: ${waitOnTimeout}s)`
+      );
+      yield waitOnFn({
+        resources: [waitOn],
+        timeout: waitOnTimeout * 1e3
+      });
+    }
     const apiGenerator = new APIGenerator({
-      baseURL: server,
-      apiKey
+      baseURL: client.baseURL,
+      apiKey: client.apiKey
     });
-    const promises = tests.map((testId) => __async(this, null, function* () {
-      let failed = true;
-      try {
-        failed = yield runTest({
-          testId,
-          apiClient,
-          generator: apiGenerator,
-          newBaseURL: waitOn
-        });
-      } catch (e) {
-        console.error(e);
+    let useLocalFiles = false;
+    if (tests.some((testPath) => testPath.endsWith(".yaml"))) {
+      useLocalFiles = true;
+    } else if (tests.some((testPath) => existsSync3(testPath))) {
+      useLocalFiles = true;
+    }
+    let testsToRun = [];
+    if (useLocalFiles) {
+      consoleLogger.info(
+        tests,
+        `Reading tests from the following local file paths:`
+      );
+      tests.forEach((testPath) => {
+        if (!existsSync3(testPath)) {
+          throw new Error(`Path '${testPath}' does not exist.`);
+        }
+        const statResult = statSync2(testPath);
+        if (statResult.isDirectory()) {
+          testsToRun = testsToRun.concat(getTestFilesRecursively(testPath));
+        } else if (testPath.endsWith(".yaml")) {
+          testsToRun.push(testPath);
+        } else {
+          throw new Error(
+            `Path '${testPath}' is not a directory or a .yaml file.`
+          );
+        }
+      });
+    } else {
+      consoleLogger.warn(
+        "The paths you specified are not files or directories that exist locally."
+      );
+      consoleLogger.info(
+        `Fetching tests from remote Momentic server (${client.baseURL})...`
+      );
+      if (all) {
+        testsToRun = yield client.getAllTestIds();
+      } else {
+        testsToRun = tests;
       }
-      return { failed, testId };
-    }));
-    const results = yield Promise.all(promises);
+    }
+    consoleLogger.info(
+      testsToRun,
+      `Identified ${testsToRun.length} tests to run locally:`
+    );
+    let results = [];
+    for (let i = 0; i < testsToRun.length; i += parallelization) {
+      const blockResults = yield Promise.all(
+        testsToRun.slice(i, i + parallelization).map((path3) => __async(this, null, function* () {
+          let failed = true;
+          try {
+            failed = yield runTest({
+              useLocalFiles,
+              path: path3,
+              apiClient: client,
+              generator: apiGenerator,
+              newBaseURL: waitOn
+            });
+          } catch (e) {
+            consoleLogger.error(`${e}`);
+          }
+          return { failed, path: path3 };
+        }))
+      );
+      results = results.concat(blockResults);
+    }
     const failedResults = results.filter((result) => result.failed);
     if (failedResults.length > 0) {
-      console.log(
-        chalk.red(
-          `Failed ${failedResults.length} out of ${results.length} tests:`
-        )
+      consoleLogger.error(
+        `Failed ${failedResults.length} out of ${results.length} tests:`
       );
       failedResults.forEach((result) => {
-        console.log(chalk.red(`- ${result.testId}`));
+        consoleLogger.error(`- ${result.path}`);
       });
       process.exit(1);
     }
-    console.log(chalk.green(`All ${results.length} tests passed!`));
+    consoleLogger.info(`All ${results.length} tests passed!`);
     process.exit(0);
   });
 }
@@ -3241,87 +4554,124 @@ function execCommand(fullCommand, waitToFinish = true) {
 }
 
 // src/run-tests-remotely.ts
-import chalk2 from "chalk";
 function runTestsRemotely(_0) {
   return __async(this, arguments, function* ({
     tests,
-    apiKey,
-    server
+    client,
+    all
   }) {
-    const apiClient = new APIClient({
-      baseURL: server,
-      apiKey
-    });
-    yield apiClient.queueTests({
-      testIds: tests
+    const { queuedTests } = yield client.queueTests({
+      testPaths: tests,
+      all
     });
-    console.log(chalk2.green(`Successfully queued ${tests.length} tests!`));
+    consoleLogger.info(`Successfully queued ${queuedTests.length} tests!`);
   });
 }
 
 // src/cli.ts
-var program = new Command4();
+var program = new Command3();
 program.name("momentic").description("Momentic CLI").version(version);
 program.command("install-browsers").action(() => __async(void 0, null, function* () {
   yield installBrowsers();
 }));
-program.command("run-tests").addOption(
-  new Option(
-    "--tests <tests...>",
-    "specify tests to run"
-  ).makeOptionMandatory(true)
-).addOption(
-  new Option("--api-key <key>", "API key for authenticating").env("MOMENTIC_API_KEY").makeOptionMandatory(true)
-).addOption(
-  new Option("--server <server>", "Momentic server to use").default(
-    "https://api.momentic.ai"
-  )
-).addOption(
-  new Option("--remote", "run tests remotely").default(true).conflicts(["start, waitOn, waitOnTimeout"]).implies({
+program.addOption(
+  new Option2("--log-level <level>").choices(["debug", "info", "warn", "error"]).default("info")
+).on("option:log-level", (level) => {
+  consoleLogger.setMinLevel(stringToLogLevel[level.toUpperCase()]);
+});
+program.command("run").alias("run-tests").addOption(apiKeyOption).addOption(serverAddressOption).addOption(allOption).addOption(
+  new Option2(
+    "-r, --remote",
+    "Run tests remotely. The production version of this test will be queued for execution."
+  ).default(true).conflicts(["start, waitOn, waitOnTimeout, local"]).implies({
     local: false
   })
 ).addOption(
-  new Option("--local", "run tests locally").implies({
-    start: "npm run start",
-    waitOn: "http://localhost:3000",
+  new Option2(
+    "-l, --local",
+    "Run tests locally. Useful for accessing apps on localhost. This option does not control where tests are read from (see <tests> argument documentation)."
+  ).implies({
     remote: false
   })
-).addOption(new Option("--start <command>", "specify start command")).addOption(new Option("--wait-on <url>", "specify URL to wait on")).addOption(
-  new Option(
+).addOption(
+  new Option2(
+    "--start <command>",
+    "Arbitrary setup command that will run before Momentic steps begin."
+  )
+).addOption(
+  new Option2(
+    "--wait-on <url>",
+    "URL to wait to become accessible before Momentic tests begin."
+  )
+).addOption(
+  new Option2(
     "--wait-on-timeout <timeout>",
-    "specify how long to wait on url"
+    "Max time to wait for the --wait-on URL to become accessible."
   ).default(60, "one minute")
-).action((options) => __async(void 0, null, function* () {
-  const {
-    tests,
-    apiKey,
-    server,
-    remote,
-    local,
-    start,
-    waitOn,
-    waitOnTimeout
-  } = options;
-  if (remote) {
-    yield runTestsRemotely({ tests, apiKey, server });
-    return;
-  }
+).addOption(
+  new Option2(
+    "-p, --parallel <parallelization>",
+    "When running with the --local flag, the number of tests to run in parallel. Defaults to 1."
+  ).default(1)
+).addArgument(testsOrFilesVariadicArgument).action((tests, options) => __async(void 0, null, function* () {
+  const { apiKey, server, remote, local, all } = options;
+  const client = new APIClient({
+    baseURL: server,
+    apiKey
+  });
   if (local) {
     try {
-      yield runTestsLocally({
+      yield runTestsLocally(__spreadValues({
         tests,
-        start,
-        waitOn,
-        waitOnTimeout,
-        server,
-        apiKey
-      });
+        client
+      }, options));
     } catch (e) {
-      console.error(e);
+      consoleLogger.error(e);
       process.exit(1);
     }
     return;
   }
+  if (remote) {
+    if (tests.some((test) => test.endsWith(".yaml") || existsSync4(test))) {
+      const prompt = "A local file path was provided without the --local flag. The production version of the specified test will be queued remotely. Continue?";
+      if (!(yield promptForConfirmation(prompt, true))) {
+        consoleLogger.info("Run cancelled");
+        process.exit(1);
+      }
+      tests = tests.map((test) => {
+        if (test.endsWith(".yaml")) {
+          test = test.slice(0, -5);
+        }
+        return test;
+      });
+    }
+    yield runTestsRemotely({ tests, client, all });
+    return;
+  }
+  throw new Error("One of remote or local must be specified");
+}));
+program.command("pull").description(
+  "Fetch one or more tests from your organization and save it in YAML format on local disk."
+).addOption(apiKeyOption).addOption(serverAddressOption).addOption(outDirOption).addOption(allOption).addArgument(testPathsVariadicArgument).action((tests, options) => __async(void 0, null, function* () {
+  const { apiKey, server, outDir, all } = options;
+  if (!all && !(tests == null ? void 0 : tests.length)) {
+    throw new Error("At least one test name or --all must be provided");
+  }
+  const client = new APIClient({
+    baseURL: server,
+    apiKey
+  });
+  yield fetchAndSaveTestToDisk({ testPaths: tests, client, outDir, all });
+}));
+program.command("push").description(
+  "Save a local YAML file containing a test to your cloud workspace."
+).addOption(yesOption).addOption(apiKeyOption).addOption(serverAddressOption).addArgument(filePathsVariadicArgument).action((paths, options) => __async(void 0, null, function* () {
+  const { apiKey, server, yes } = options;
+  const client = new APIClient({
+    baseURL: server,
+    apiKey
+  });
+  yield saveTestToServer({ paths, client, yes });
 }));
 function main() {
   return __async(this, null, function* () {