@showrun/core 0.1.0

package/dist/dsl/builders.js

@@ -0,0 +1,416 @@
+/**
+ * Builder functions for creating DSL steps.
+ * These return plain objects that are JSON-serializable.
+ */
+/**
+ * Helper builders for creating Target objects
+ */
+export function targetCss(selector) {
+    return { kind: 'css', selector };
+}
+export function targetText(text, exact) {
+    return { kind: 'text', text, exact };
+}
+export function targetRole(role, name, exact) {
+    return { kind: 'role', role, name, exact };
+}
+export function targetLabel(text, exact) {
+    return { kind: 'label', text, exact };
+}
+export function targetPlaceholder(text, exact) {
+    return { kind: 'placeholder', text, exact };
+}
+export function targetAltText(text, exact) {
+    return { kind: 'altText', text, exact };
+}
+export function targetTestId(id) {
+    return { kind: 'testId', id };
+}
+export function targetAnyOf(...targets) {
+    return { anyOf: targets };
+}
+/**
+ * Helper builders for creating SkipCondition objects
+ */
+export const conditions = {
+    /**
+     * Skip if URL includes the given string
+     */
+    urlIncludes(value) {
+        return { url_includes: value };
+    },
+    /**
+     * Skip if URL matches the given regex pattern
+     */
+    urlMatches(pattern) {
+        return { url_matches: pattern };
+    },
+    /**
+     * Skip if element is visible
+     */
+    elementVisible(target) {
+        return { element_visible: target };
+    },
+    /**
+     * Skip if element exists in DOM
+     */
+    elementExists(target) {
+        return { element_exists: target };
+    },
+    /**
+     * Skip if variable equals the given value
+     */
+    varEquals(name, value) {
+        return { var_equals: { name, value } };
+    },
+    /**
+     * Skip if variable is truthy
+     */
+    varTruthy(name) {
+        return { var_truthy: name };
+    },
+    /**
+     * Skip if variable is falsy
+     */
+    varFalsy(name) {
+        return { var_falsy: name };
+    },
+    /**
+     * Skip if ALL conditions are true (AND)
+     */
+    all(...conditions) {
+        return { all: conditions };
+    },
+    /**
+     * Skip if ANY condition is true (OR)
+     */
+    any(...conditions) {
+        return { any: conditions };
+    },
+};
+/**
+ * Creates a navigate step
+ */
+export function navigate(id, params) {
+    return {
+        id,
+        type: 'navigate',
+        label: params.label,
+        timeoutMs: params.timeoutMs,
+        optional: params.optional,
+        onError: params.onError,
+        params: {
+            url: params.url,
+            waitUntil: params.waitUntil ?? 'networkidle',
+        },
+    };
+}
+/**
+ * Creates an extract_title step
+ */
+export function extractTitle(id, params) {
+    return {
+        id,
+        type: 'extract_title',
+        label: params.label,
+        timeoutMs: params.timeoutMs,
+        optional: params.optional,
+        onError: params.onError,
+        params: {
+            out: params.out,
+        },
+    };
+}
+/**
+ * Creates an extract_text step
+ */
+export function extractText(id, params) {
+    return {
+        id,
+        type: 'extract_text',
+        label: params.label,
+        timeoutMs: params.timeoutMs,
+        optional: params.optional,
+        onError: params.onError,
+        params: {
+            selector: params.selector,
+            target: params.target,
+            out: params.out,
+            first: params.first ?? true,
+            trim: params.trim ?? true,
+            default: params.default,
+            hint: params.hint,
+            scope: params.scope,
+            near: params.near,
+        },
+    };
+}
+/**
+ * Creates a sleep step
+ * @deprecated Prefer wait_for for deterministic waiting
+ */
+export function sleep(id, params) {
+    return {
+        id,
+        type: 'sleep',
+        label: params.label,
+        timeoutMs: params.timeoutMs,
+        optional: params.optional,
+        onError: params.onError,
+        params: {
+            durationMs: params.durationMs,
+        },
+    };
+}
+/**
+ * Creates a wait_for step
+ */
+export function waitFor(id, params) {
+    return {
+        id,
+        type: 'wait_for',
+        label: params.label,
+        timeoutMs: params.timeoutMs ?? params.timeoutMs,
+        optional: params.optional,
+        onError: params.onError,
+        params: {
+            selector: params.selector,
+            target: params.target,
+            visible: params.visible ?? true,
+            url: params.url,
+            loadState: params.loadState,
+            timeoutMs: params.timeoutMs ?? 30000,
+            hint: params.hint,
+            scope: params.scope,
+            near: params.near,
+        },
+    };
+}
+/**
+ * Creates a click step
+ */
+export function click(id, params) {
+    return {
+        id,
+        type: 'click',
+        label: params.label,
+        timeoutMs: params.timeoutMs,
+        optional: params.optional,
+        onError: params.onError,
+        params: {
+            selector: params.selector,
+            target: params.target,
+            first: params.first ?? true,
+            waitForVisible: params.waitForVisible ?? true,
+            hint: params.hint,
+            scope: params.scope,
+            near: params.near,
+        },
+    };
+}
+/**
+ * Creates a fill step
+ */
+export function fill(id, params) {
+    return {
+        id,
+        type: 'fill',
+        label: params.label,
+        timeoutMs: params.timeoutMs,
+        optional: params.optional,
+        onError: params.onError,
+        params: {
+            selector: params.selector,
+            target: params.target,
+            value: params.value,
+            first: params.first ?? true,
+            clear: params.clear ?? true,
+            hint: params.hint,
+            scope: params.scope,
+            near: params.near,
+        },
+    };
+}
+/**
+ * Creates an extract_attribute step
+ */
+export function extractAttribute(id, params) {
+    return {
+        id,
+        type: 'extract_attribute',
+        label: params.label,
+        timeoutMs: params.timeoutMs,
+        optional: params.optional,
+        onError: params.onError,
+        params: {
+            selector: params.selector,
+            target: params.target,
+            attribute: params.attribute,
+            out: params.out,
+            first: params.first ?? true,
+            default: params.default,
+            hint: params.hint,
+            scope: params.scope,
+            near: params.near,
+        },
+    };
+}
+/**
+ * Creates an assert step
+ */
+export function assert(id, params) {
+    return {
+        id,
+        type: 'assert',
+        label: params.label,
+        timeoutMs: params.timeoutMs,
+        optional: params.optional,
+        onError: params.onError,
+        params: {
+            selector: params.selector,
+            target: params.target,
+            visible: params.visible,
+            textIncludes: params.textIncludes,
+            urlIncludes: params.urlIncludes,
+            message: params.message,
+            hint: params.hint,
+            scope: params.scope,
+            near: params.near,
+        },
+    };
+}
+/**
+ * Creates a set_var step
+ */
+export function setVar(id, params) {
+    return {
+        id,
+        type: 'set_var',
+        label: params.label,
+        timeoutMs: params.timeoutMs,
+        optional: params.optional,
+        onError: params.onError,
+        params: {
+            name: params.name,
+            value: params.value,
+        },
+    };
+}
+/**
+ * Creates a select_option step
+ */
+export function selectOption(id, params) {
+    return {
+        id,
+        type: 'select_option',
+        label: params.label,
+        timeoutMs: params.timeoutMs,
+        optional: params.optional,
+        onError: params.onError,
+        params: {
+            selector: params.selector,
+            target: params.target,
+            value: params.value,
+            first: params.first ?? true,
+            hint: params.hint,
+            scope: params.scope,
+            near: params.near,
+        },
+    };
+}
+/**
+ * Creates a press_key step
+ */
+export function pressKey(id, params) {
+    return {
+        id,
+        type: 'press_key',
+        label: params.label,
+        timeoutMs: params.timeoutMs,
+        optional: params.optional,
+        onError: params.onError,
+        params: {
+            key: params.key,
+            selector: params.selector,
+            target: params.target,
+            times: params.times ?? 1,
+            delayMs: params.delayMs ?? 0,
+            hint: params.hint,
+            scope: params.scope,
+            near: params.near,
+        },
+    };
+}
+/**
+ * Creates an upload_file step
+ */
+export function uploadFile(id, params) {
+    return {
+        id,
+        type: 'upload_file',
+        label: params.label,
+        timeoutMs: params.timeoutMs,
+        optional: params.optional,
+        onError: params.onError,
+        params: {
+            selector: params.selector,
+            target: params.target,
+            files: params.files,
+            first: params.first ?? true,
+            hint: params.hint,
+            scope: params.scope,
+            near: params.near,
+        },
+    };
+}
+/**
+ * Creates a frame step
+ */
+export function frame(id, params) {
+    return {
+        id,
+        type: 'frame',
+        label: params.label,
+        timeoutMs: params.timeoutMs,
+        optional: params.optional,
+        onError: params.onError,
+        params: {
+            frame: params.frame,
+            action: params.action,
+        },
+    };
+}
+/**
+ * Creates a new_tab step
+ */
+export function newTab(id, params) {
+    return {
+        id,
+        type: 'new_tab',
+        label: params.label,
+        timeoutMs: params.timeoutMs,
+        optional: params.optional,
+        onError: params.onError,
+        params: {
+            url: params.url,
+            saveTabIndexAs: params.saveTabIndexAs,
+        },
+    };
+}
+/**
+ * Creates a switch_tab step
+ */
+export function switchTab(id, params) {
+    return {
+        id,
+        type: 'switch_tab',
+        label: params.label,
+        timeoutMs: params.timeoutMs,
+        optional: params.optional,
+        onError: params.onError,
+        params: {
+            tab: params.tab,
+            closeCurrentTab: params.closeCurrentTab ?? false,
+        },
+    };
+}

package/dist/dsl/conditions.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Condition evaluator for skip_if conditions
+ *
+ * Evaluates skip conditions to determine if a step should be skipped.
+ */
+import type { Page } from 'playwright';
+import type { SkipCondition } from './types.js';
+/**
+ * Context for condition evaluation
+ */
+export interface ConditionContext {
+    /**
+     * Playwright page
+     */
+    page: Page;
+    /**
+     * Current variable values
+     */
+    vars: Record<string, unknown>;
+}
+/**
+ * Evaluates a skip condition
+ *
+ * @param ctx - Condition context with page and vars
+ * @param condition - The condition to evaluate
+ * @returns true if the condition is met (step should be skipped), false otherwise
+ */
+export declare function evaluateCondition(ctx: ConditionContext, condition: SkipCondition): Promise<boolean>;
+/**
+ * Converts a condition to a human-readable string for logging
+ */
+export declare function conditionToString(condition: SkipCondition): string;
+//# sourceMappingURL=conditions.d.ts.map

package/dist/dsl/conditions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"conditions.d.ts","sourceRoot":"","sources":["../../src/dsl/conditions.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,YAAY,CAAC;AACvC,OAAO,KAAK,EAAE,aAAa,EAAyB,MAAM,YAAY,CAAC;AAQvE;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B;;OAEG;IACH,IAAI,EAAE,IAAI,CAAC;IACX;;OAEG;IACH,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAC/B;AAED;;;;;;GAMG;AACH,wBAAsB,iBAAiB,CACrC,GAAG,EAAE,gBAAgB,EACrB,SAAS,EAAE,aAAa,GACvB,OAAO,CAAC,OAAO,CAAC,CAgElB;AA2DD;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,SAAS,EAAE,aAAa,GAAG,MAAM,CA6BlE"}

package/dist/dsl/conditions.js

@@ -0,0 +1,169 @@
+/**
+ * Condition evaluator for skip_if conditions
+ *
+ * Evaluates skip conditions to determine if a step should be skipped.
+ */
+import { resolveTarget } from './target.js';
+/**
+ * Timeout for element checks (1 second - fast fail)
+ */
+const ELEMENT_CHECK_TIMEOUT_MS = 1000;
+/**
+ * Evaluates a skip condition
+ *
+ * @param ctx - Condition context with page and vars
+ * @param condition - The condition to evaluate
+ * @returns true if the condition is met (step should be skipped), false otherwise
+ */
+export async function evaluateCondition(ctx, condition) {
+    // URL conditions
+    if ('url_includes' in condition) {
+        const currentUrl = ctx.page.url();
+        return currentUrl.includes(condition.url_includes);
+    }
+    if ('url_matches' in condition) {
+        const currentUrl = ctx.page.url();
+        try {
+            const regex = new RegExp(condition.url_matches);
+            return regex.test(currentUrl);
+        }
+        catch {
+            console.warn(`[conditions] Invalid regex in url_matches: ${condition.url_matches}`);
+            return false;
+        }
+    }
+    // Element conditions
+    if ('element_visible' in condition) {
+        return await isElementVisible(ctx.page, condition.element_visible);
+    }
+    if ('element_exists' in condition) {
+        return await elementExists(ctx.page, condition.element_exists);
+    }
+    // Variable conditions
+    if ('var_equals' in condition) {
+        const { name, value } = condition.var_equals;
+        const actualValue = ctx.vars[name];
+        return actualValue === value;
+    }
+    if ('var_truthy' in condition) {
+        const value = ctx.vars[condition.var_truthy];
+        return Boolean(value);
+    }
+    if ('var_falsy' in condition) {
+        const value = ctx.vars[condition.var_falsy];
+        return !value;
+    }
+    // Compound conditions
+    if ('all' in condition) {
+        for (const subCondition of condition.all) {
+            const result = await evaluateCondition(ctx, subCondition);
+            if (!result)
+                return false;
+        }
+        return true;
+    }
+    if ('any' in condition) {
+        for (const subCondition of condition.any) {
+            const result = await evaluateCondition(ctx, subCondition);
+            if (result)
+                return true;
+        }
+        return false;
+    }
+    // Unknown condition type
+    console.warn('[conditions] Unknown condition type:', condition);
+    return false;
+}
+/**
+ * Resolves a TargetOrAnyOf to a Playwright Locator
+ * Handles both single targets and anyOf arrays
+ */
+function resolveTargetOrAnyOf(page, target) {
+    if ('anyOf' in target) {
+        // For anyOf, try the first one (we just need to check existence/visibility)
+        // The condition is met if ANY of the targets match
+        return target.anyOf.map((t) => resolveTarget(page, t));
+    }
+    return [resolveTarget(page, target)];
+}
+/**
+ * Checks if an element is visible on the page
+ */
+async function isElementVisible(page, target) {
+    try {
+        const locators = resolveTargetOrAnyOf(page, target);
+        // Check if any locator is visible
+        for (const locator of locators) {
+            try {
+                const isVisible = await locator.first().isVisible({ timeout: ELEMENT_CHECK_TIMEOUT_MS });
+                if (isVisible)
+                    return true;
+            }
+            catch {
+                // Continue to next locator
+            }
+        }
+        return false;
+    }
+    catch {
+        // Element not found or timeout - not visible
+        return false;
+    }
+}
+/**
+ * Checks if an element exists in the DOM (visible or not)
+ */
+async function elementExists(page, target) {
+    try {
+        const locators = resolveTargetOrAnyOf(page, target);
+        // Check if any locator has matches
+        for (const locator of locators) {
+            try {
+                const count = await locator.count();
+                if (count > 0)
+                    return true;
+            }
+            catch {
+                // Continue to next locator
+            }
+        }
+        return false;
+    }
+    catch {
+        // Error resolving target - doesn't exist
+        return false;
+    }
+}
+/**
+ * Converts a condition to a human-readable string for logging
+ */
+export function conditionToString(condition) {
+    if ('url_includes' in condition) {
+        return `url_includes("${condition.url_includes}")`;
+    }
+    if ('url_matches' in condition) {
+        return `url_matches("${condition.url_matches}")`;
+    }
+    if ('element_visible' in condition) {
+        return `element_visible(${JSON.stringify(condition.element_visible)})`;
+    }
+    if ('element_exists' in condition) {
+        return `element_exists(${JSON.stringify(condition.element_exists)})`;
+    }
+    if ('var_equals' in condition) {
+        return `var_equals(${condition.var_equals.name}, ${JSON.stringify(condition.var_equals.value)})`;
+    }
+    if ('var_truthy' in condition) {
+        return `var_truthy("${condition.var_truthy}")`;
+    }
+    if ('var_falsy' in condition) {
+        return `var_falsy("${condition.var_falsy}")`;
+    }
+    if ('all' in condition) {
+        return `all(${condition.all.map(conditionToString).join(', ')})`;
+    }
+    if ('any' in condition) {
+        return `any(${condition.any.map(conditionToString).join(', ')})`;
+    }
+    return JSON.stringify(condition);
+}

package/dist/dsl/interpreter.d.ts

@@ -0,0 +1,24 @@
+import type { RunContext, AuthConfig } from '../types.js';
+import type { DslStep, RunFlowOptions, RunFlowResult } from './types.js';
+/**
+ * Extended options for running a flow with auth resilience
+ */
+export interface RunFlowOptionsWithAuth extends RunFlowOptions {
+    inputs?: Record<string, unknown>;
+    auth?: AuthConfig;
+    sessionId?: string;
+    profileId?: string;
+    /**
+     * Directory for profile cache storage (typically the pack directory)
+     */
+    cacheDir?: string;
+    /**
+     * Secrets for template resolution ({{secret.NAME}})
+     */
+    secrets?: Record<string, string>;
+}
+/**
+ * Runs a flow of DSL steps sequentially with auth resilience support
+ */
+export declare function runFlow(ctx: RunContext, steps: DslStep[], options?: RunFlowOptionsWithAuth): Promise<RunFlowResult>;
+//# sourceMappingURL=interpreter.d.ts.map

package/dist/dsl/interpreter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"interpreter.d.ts","sourceRoot":"","sources":["../../src/dsl/interpreter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAa,UAAU,EAAE,MAAM,aAAa,CAAC;AACrE,OAAO,KAAK,EAAE,OAAO,EAAE,cAAc,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AA8DzE;;GAEG;AACH,MAAM,WAAW,sBAAuB,SAAQ,cAAc;IAC5D,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACjC,IAAI,CAAC,EAAE,UAAU,CAAC;IAClB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB;;OAEG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB;;OAEG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAClC;AAyBD;;GAEG;AACH,wBAAsB,OAAO,CAC3B,GAAG,EAAE,UAAU,EACf,KAAK,EAAE,OAAO,EAAE,EAChB,OAAO,CAAC,EAAE,sBAAsB,GAC/B,OAAO,CAAC,aAAa,CAAC,CAybxB"}