@showrun/core 0.1.10 → 0.2.0-rc.0

package/dist/__tests__/playwrightJsExecutor.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=playwrightJsExecutor.test.d.ts.map

package/dist/__tests__/playwrightJsExecutor.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"playwrightJsExecutor.test.d.ts","sourceRoot":"","sources":["../../src/__tests__/playwrightJsExecutor.test.ts"],"names":[],"mappings":""}

package/dist/__tests__/playwrightJsExecutor.test.js

@@ -0,0 +1,191 @@
+import { describe, it, expect, vi } from 'vitest';
+import { executePlaywrightJs, extractFunctionBody } from '../dsl/playwrightJsExecutor.js';
+// Minimal mock page/context/frame for testing
+function createMockScope(overrides) {
+    const mockPage = {
+        goto: vi.fn().mockResolvedValue(undefined),
+        title: vi.fn().mockResolvedValue('Test Title'),
+        url: vi.fn().mockReturnValue('https://example.com'),
+        locator: vi.fn().mockReturnValue({
+            evaluateAll: vi.fn().mockResolvedValue([]),
+        }),
+        screenshot: vi.fn().mockResolvedValue(Buffer.from('')),
+        mouse: { click: vi.fn().mockResolvedValue(undefined) },
+        waitForTimeout: vi.fn().mockResolvedValue(undefined),
+    };
+    return {
+        page: mockPage,
+        context: {},
+        frame: {},
+        inputs: { query: 'hello' },
+        secrets: { apiKey: 'secret123' },
+        showrun: {
+            network: {
+                list: vi.fn().mockResolvedValue([]),
+                find: vi.fn().mockResolvedValue(null),
+                get: vi.fn().mockResolvedValue(null),
+                replay: vi.fn().mockResolvedValue({ status: 200, contentType: 'application/json', body: '{}', bodySize: 2 }),
+            },
+        },
+        util: {
+            detectCloudflareTurnstile: vi.fn().mockResolvedValue({ found: false }),
+            solveCloudflareTurnstile: vi.fn().mockResolvedValue({ success: false, detected: false }),
+        },
+        ...overrides,
+    };
+}
+describe('extractFunctionBody', () => {
+    it('extracts body from async function export', () => {
+        const code = `module.exports = async function({ page }) {
+      await page.goto('https://example.com');
+      return { title: 'test' };
+    };`;
+        const body = extractFunctionBody(code);
+        expect(body).toContain("await page.goto('https://example.com')");
+        expect(body).toContain("return { title: 'test' }");
+    });
+    it('extracts body from async arrow export', () => {
+        const code = `module.exports = async ({ page }) => {
+      return { title: await page.title() };
+    };`;
+        const body = extractFunctionBody(code);
+        expect(body).toContain('return { title: await page.title() }');
+    });
+    it('throws on invalid format', () => {
+        expect(() => extractFunctionBody('const x = 1;')).toThrow('Could not parse flow.playwright.js');
+    });
+});
+describe('executePlaywrightJs', () => {
+    it('returns collectibles from user code', async () => {
+        const code = `module.exports = async function({ page, inputs }) {
+      return { result: inputs.query + '_processed' };
+    };`;
+        const scope = createMockScope();
+        const result = await executePlaywrightJs(code, scope);
+        expect(result.collectibles).toEqual({ result: 'hello_processed' });
+        expect(result.logs).toEqual([]);
+    });
+    it('can call page methods', async () => {
+        const code = `module.exports = async function({ page }) {
+      const t = await page.title();
+      return { title: t };
+    };`;
+        const scope = createMockScope();
+        const result = await executePlaywrightJs(code, scope);
+        expect(result.collectibles).toEqual({ title: 'Test Title' });
+        expect(scope.page.title).toHaveBeenCalled();
+    });
+    it('blocks dangerous globals', async () => {
+        const code = `module.exports = async function({ page }) {
+      return {
+        hasProcess: typeof process !== 'undefined',
+        hasRequire: typeof require !== 'undefined',
+        hasBuffer: typeof Buffer !== 'undefined',
+        hasGlobal: typeof global !== 'undefined',
+        hasGlobalThis: typeof globalThis !== 'undefined',
+        hasFetch: typeof fetch !== 'undefined',
+        hasEval: typeof eval !== 'undefined',
+        hasFunction: typeof Function !== 'undefined',
+        hasSetTimeout: typeof setTimeout !== 'undefined',
+      };
+    };`;
+        const scope = createMockScope();
+        const result = await executePlaywrightJs(code, scope);
+        expect(result.collectibles.hasProcess).toBe(false);
+        expect(result.collectibles.hasRequire).toBe(false);
+        expect(result.collectibles.hasBuffer).toBe(false);
+        expect(result.collectibles.hasGlobal).toBe(false);
+        expect(result.collectibles.hasGlobalThis).toBe(false);
+        expect(result.collectibles.hasFetch).toBe(false);
+        expect(result.collectibles.hasEval).toBe(false);
+        expect(result.collectibles.hasFunction).toBe(false);
+        expect(result.collectibles.hasSetTimeout).toBe(false);
+    });
+    it('freezes inputs (mutations do not propagate)', async () => {
+        const code = `module.exports = async function({ inputs }) {
+      inputs.query = 'modified';
+      return { value: inputs.query };
+    };`;
+        const scope = createMockScope();
+        const result = await executePlaywrightJs(code, scope);
+        // Frozen object silently ignores assignment in sloppy mode
+        expect(result.collectibles.value).toBe('hello');
+        // Original scope inputs are also unmodified
+        expect(scope.inputs.query).toBe('hello');
+    });
+    it('freezes secrets (mutations do not propagate)', async () => {
+        const code = `module.exports = async function({ secrets }) {
+      secrets.apiKey = 'hacked';
+      return { value: secrets.apiKey };
+    };`;
+        const scope = createMockScope();
+        const result = await executePlaywrightJs(code, scope);
+        expect(result.collectibles.value).toBe('secret123');
+        expect(scope.secrets.apiKey).toBe('secret123');
+    });
+    it('returns empty object when code returns undefined', async () => {
+        const code = `module.exports = async function({ page }) {
+      // no return
+    };`;
+        const scope = createMockScope();
+        const result = await executePlaywrightJs(code, scope);
+        expect(result.collectibles).toEqual({});
+    });
+    it('can access showrun.network.replay', async () => {
+        const code = `module.exports = async function({ showrun }) {
+      const res = await showrun.network.replay('req-1');
+      return { status: res.status };
+    };`;
+        const scope = createMockScope();
+        const result = await executePlaywrightJs(code, scope);
+        expect(result.collectibles).toEqual({ status: 200 });
+        expect(scope.showrun.network.replay).toHaveBeenCalledWith('req-1');
+    });
+    it('can access showrun.network.list', async () => {
+        const code = `module.exports = async function({ showrun }) {
+      const entries = await showrun.network.list();
+      return { count: entries.length };
+    };`;
+        const scope = createMockScope();
+        const result = await executePlaywrightJs(code, scope);
+        expect(result.collectibles).toEqual({ count: 0 });
+        expect(scope.showrun.network.list).toHaveBeenCalled();
+    });
+    it('can access showrun.network.find', async () => {
+        const code = `module.exports = async function({ showrun }) {
+      const entry = await showrun.network.find({ urlIncludes: '/api' });
+      return { found: entry !== null };
+    };`;
+        const scope = createMockScope();
+        const result = await executePlaywrightJs(code, scope);
+        expect(result.collectibles).toEqual({ found: false });
+        expect(scope.showrun.network.find).toHaveBeenCalledWith({ urlIncludes: '/api' });
+    });
+    it('captures console.log output', async () => {
+        const code = `module.exports = async function({ page }) {
+      console.log('hello', 'world');
+      console.warn('a warning');
+      console.error('an error');
+      console.info('info message');
+      return { done: true };
+    };`;
+        const scope = createMockScope();
+        const result = await executePlaywrightJs(code, scope);
+        expect(result.collectibles).toEqual({ done: true });
+        expect(result.logs).toEqual([
+            'hello world',
+            '[warn] a warning',
+            '[error] an error',
+            'info message',
+        ]);
+    });
+    it('times out on long-running code', async () => {
+        const code = `module.exports = async function({ page }) {
+      await new Promise(() => {}); // never resolves
+      return {};
+    };`;
+        const scope = createMockScope();
+        await expect(executePlaywrightJs(code, scope, 100) // 100ms timeout
+        ).rejects.toThrow('timed out');
+    });
+});

package/dist/dsl/playwrightJsExecutor.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Sandboxed executor for playwright-js task packs.
+ *
+ * Runs user-provided Playwright JavaScript in a best-effort sandbox:
+ * - Dangerous Node.js globals are shadowed via AsyncFunction parameters
+ * - inputs and secrets are passed as frozen copies (read-only)
+ * - page, context, frame have full Playwright access
+ *
+ * NOTE: This is NOT a hard security boundary. A determined attacker could
+ * escape via prototype chain tricks. Trust is managed at the registry level.
+ */
+import type { Page, BrowserContext, Frame } from 'playwright';
+import type { NetworkCaptureApi } from '../networkCapture.js';
+import { type PlaywrightJsUtil } from '../util/index.js';
+/**
+ * Scope provided to user code.
+ */
+export interface PlaywrightJsScope {
+    page: Page;
+    context: BrowserContext;
+    frame: Frame;
+    inputs: Record<string, unknown>;
+    secrets: Record<string, string>;
+    showrun: {
+        network: {
+            list: NetworkCaptureApi['list'];
+            find: NetworkCaptureApi['find'];
+            get: NetworkCaptureApi['get'];
+            replay: NetworkCaptureApi['replay'];
+        };
+    };
+    util: PlaywrightJsUtil;
+}
+/**
+ * Result from executing a playwright-js flow.
+ */
+export interface PlaywrightJsResult {
+    collectibles: Record<string, unknown>;
+    logs: string[];
+    error?: string;
+}
+/**
+ * Extract the function body from a `module.exports = async function(...) { BODY }` pattern.
+ * Also supports `module.exports = async (...) => { BODY }` arrow functions.
+ */
+export declare function extractFunctionBody(code: string): string;
+/**
+ * Execute a playwright-js flow in a sandboxed context.
+ *
+ * @param code       Raw source of flow.playwright.js
+ * @param scope      Playwright objects + inputs/secrets
+ * @param timeoutMs  Maximum execution time (default 5 minutes)
+ * @returns          The return value from the user function (collectibles object)
+ */
+export declare function executePlaywrightJs(code: string, scope: PlaywrightJsScope, timeoutMs?: number): Promise<PlaywrightJsResult>;
+//# sourceMappingURL=playwrightJsExecutor.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"playwrightJsExecutor.d.ts","sourceRoot":"","sources":["../../src/dsl/playwrightJsExecutor.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EAAE,IAAI,EAAE,cAAc,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AAC9D,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AAC9D,OAAO,EAA0B,KAAK,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AAajF;;GAEG;AACH,MAAM,WAAW,iBAAiB;IAChC,IAAI,EAAE,IAAI,CAAC;IACX,OAAO,EAAE,cAAc,CAAC;IACxB,KAAK,EAAE,KAAK,CAAC;IACb,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAChC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAChC,OAAO,EAAE;QACP,OAAO,EAAE;YACP,IAAI,EAAE,iBAAiB,CAAC,MAAM,CAAC,CAAC;YAChC,IAAI,EAAE,iBAAiB,CAAC,MAAM,CAAC,CAAC;YAChC,GAAG,EAAE,iBAAiB,CAAC,KAAK,CAAC,CAAC;YAC9B,MAAM,EAAE,iBAAiB,CAAC,QAAQ,CAAC,CAAC;SACrC,CAAC;KACH,CAAC;IACF,IAAI,EAAE,gBAAgB,CAAC;CACxB;AAED;;GAEG;AACH,MAAM,WAAW,kBAAkB;IACjC,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACtC,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED;;;GAGG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CA+BxD;AAMD;;;;;;;GAOG;AACH,wBAAsB,mBAAmB,CACvC,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,iBAAiB,EACxB,SAAS,SAAgB,GACxB,OAAO,CAAC,kBAAkB,CAAC,CA4E7B"}

package/dist/dsl/playwrightJsExecutor.js

@@ -0,0 +1,134 @@
+/**
+ * Sandboxed executor for playwright-js task packs.
+ *
+ * Runs user-provided Playwright JavaScript in a best-effort sandbox:
+ * - Dangerous Node.js globals are shadowed via AsyncFunction parameters
+ * - inputs and secrets are passed as frozen copies (read-only)
+ * - page, context, frame have full Playwright access
+ *
+ * NOTE: This is NOT a hard security boundary. A determined attacker could
+ * escape via prototype chain tricks. Trust is managed at the registry level.
+ */
+/**
+ * Globals shadowed inside user code (passed as undefined).
+ */
+const BLOCKED_GLOBALS = [
+    'process', 'require', 'module', 'exports',
+    '__dirname', '__filename', 'global', 'globalThis',
+    'Buffer', 'setTimeout', 'setInterval', 'setImmediate',
+    'clearTimeout', 'clearInterval', 'clearImmediate',
+    'fetch', 'XMLHttpRequest', 'eval', 'Function', 'Deno', 'Bun',
+];
+/**
+ * Extract the function body from a `module.exports = async function(...) { BODY }` pattern.
+ * Also supports `module.exports = async (...) => { BODY }` arrow functions.
+ */
+export function extractFunctionBody(code) {
+    // Match module.exports = async function(...) { BODY }
+    // or module.exports = async (...) => { BODY }
+    const patterns = [
+        // async function with destructuring or params
+        /module\.exports\s*=\s*async\s+function\s*\([^)]*\)\s*\{/,
+        // async arrow with destructuring or params
+        /module\.exports\s*=\s*async\s*\([^)]*\)\s*=>\s*\{/,
+    ];
+    for (const pattern of patterns) {
+        const match = code.match(pattern);
+        if (match) {
+            const startIdx = match.index + match[0].length;
+            // Find matching closing brace
+            let depth = 1;
+            let i = startIdx;
+            while (i < code.length && depth > 0) {
+                if (code[i] === '{')
+                    depth++;
+                else if (code[i] === '}')
+                    depth--;
+                i++;
+            }
+            if (depth === 0) {
+                return code.slice(startIdx, i - 1).trim();
+            }
+        }
+    }
+    throw new Error('Could not parse flow.playwright.js: expected `module.exports = async function({ page, context, frame, inputs, secrets }) { ... }` pattern.');
+}
+// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+const AsyncFunction = Object.getPrototypeOf(async function () { }).constructor;
+/**
+ * Execute a playwright-js flow in a sandboxed context.
+ *
+ * @param code       Raw source of flow.playwright.js
+ * @param scope      Playwright objects + inputs/secrets
+ * @param timeoutMs  Maximum execution time (default 5 minutes)
+ * @returns          The return value from the user function (collectibles object)
+ */
+export async function executePlaywrightJs(code, scope, timeoutMs = 5 * 60 * 1000) {
+    const functionBody = extractFunctionBody(code);
+    // Capture console.log output from user code
+    const logs = [];
+    const customConsole = {
+        log: (...args) => logs.push(args.map(String).join(' ')),
+        warn: (...args) => logs.push(`[warn] ${args.map(String).join(' ')}`),
+        error: (...args) => logs.push(`[error] ${args.map(String).join(' ')}`),
+        info: (...args) => logs.push(args.map(String).join(' ')),
+    };
+    // Build the sandboxed function:
+    // Blocked globals are function parameters, passed as undefined to shadow them.
+    // Scope variables (page, context, etc.) are also parameters.
+    const fn = new AsyncFunction(...BLOCKED_GLOBALS, 'page', 'context', 'frame', 'inputs', 'secrets', 'showrun', 'util', 'console', functionBody);
+    // Freeze inputs and secrets so user code cannot mutate them
+    const frozenInputs = Object.freeze({ ...scope.inputs });
+    const frozenSecrets = Object.freeze({ ...scope.secrets });
+    // Build args: undefined for each blocked global, then scope values
+    const blockedArgs = BLOCKED_GLOBALS.map(() => undefined);
+    const args = [
+        ...blockedArgs,
+        scope.page,
+        scope.context,
+        scope.frame,
+        frozenInputs,
+        frozenSecrets,
+        scope.showrun,
+        scope.util,
+        customConsole,
+    ];
+    // Execute with timeout, wrapped in try-catch to handle browser/page closure errors
+    let result;
+    try {
+        result = await Promise.race([
+            fn(...args),
+            new Promise((_, reject) => {
+                const timer = globalThis.setTimeout(() => {
+                    reject(new Error(`playwright-js execution timed out after ${timeoutMs}ms`));
+                }, timeoutMs);
+                // Allow Node.js to exit even if timer is pending
+                if (typeof timer === 'object' && 'unref' in timer) {
+                    timer.unref();
+                }
+            }),
+        ]);
+    }
+    catch (error) {
+        // Handle flow execution errors gracefully instead of crashing
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        logs.push(`[error] Flow execution failed: ${errorMessage}`);
+        return {
+            collectibles: {},
+            logs,
+            error: errorMessage,
+        };
+    }
+    // Normalize result: if null/undefined, return empty object
+    let collectibles;
+    if (result == null) {
+        collectibles = {};
+    }
+    else if (typeof result !== 'object' || Array.isArray(result)) {
+        collectibles = { _result: result };
+    }
+    else {
+        collectibles = result;
+    }
+    return { collectibles, logs };
+}

package/dist/index.d.ts

@@ -24,4 +24,6 @@ export * from './dsl/validation.js';
 export * from './dsl/templating.js';
 export * from './dsl/target.js';
 export * from './dsl/conditions.js';
+export * from './dsl/playwrightJsExecutor.js';
+export * from './util/index.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,qBAAqB,CAAC;AACpC,cAAc,YAAY,CAAC;AAC3B,cAAc,aAAa,CAAC;AAC5B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,cAAc,CAAC;AAC7B,cAAc,aAAa,CAAC;AAC5B,cAAc,wBAAwB,CAAC;AACvC,cAAc,qBAAqB,CAAC;AACpC,cAAc,sBAAsB,CAAC;AACrC,cAAc,yBAAyB,CAAC;AACxC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,qBAAqB,CAAC;AACpC,cAAc,aAAa,CAAC;AAC5B,cAAc,sBAAsB,CAAC;AACrC,cAAc,iBAAiB,CAAC;AAGhC,cAAc,qBAAqB,CAAC;AAGpC,cAAc,kBAAkB,CAAC;AAGjC,cAAc,sBAAsB,CAAC;AAGrC,cAAc,oBAAoB,CAAC;AAGnC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,mBAAmB,CAAC;AAClC,cAAc,sBAAsB,CAAC;AACrC,cAAc,qBAAqB,CAAC;AACpC,cAAc,qBAAqB,CAAC;AACpC,cAAc,iBAAiB,CAAC;AAChC,cAAc,qBAAqB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,qBAAqB,CAAC;AACpC,cAAc,YAAY,CAAC;AAC3B,cAAc,aAAa,CAAC;AAC5B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,cAAc,CAAC;AAC7B,cAAc,aAAa,CAAC;AAC5B,cAAc,wBAAwB,CAAC;AACvC,cAAc,qBAAqB,CAAC;AACpC,cAAc,sBAAsB,CAAC;AACrC,cAAc,yBAAyB,CAAC;AACxC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,qBAAqB,CAAC;AACpC,cAAc,aAAa,CAAC;AAC5B,cAAc,sBAAsB,CAAC;AACrC,cAAc,iBAAiB,CAAC;AAGhC,cAAc,qBAAqB,CAAC;AAGpC,cAAc,kBAAkB,CAAC;AAGjC,cAAc,sBAAsB,CAAC;AAGrC,cAAc,oBAAoB,CAAC;AAGnC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,mBAAmB,CAAC;AAClC,cAAc,sBAAsB,CAAC;AACrC,cAAc,qBAAqB,CAAC;AACpC,cAAc,qBAAqB,CAAC;AACpC,cAAc,iBAAiB,CAAC;AAChC,cAAc,qBAAqB,CAAC;AACpC,cAAc,+BAA+B,CAAC;AAC9C,cAAc,iBAAiB,CAAC"}

package/dist/index.js

@@ -29,3 +29,5 @@ export * from './dsl/validation.js';
 export * from './dsl/templating.js';
 export * from './dsl/target.js';
 export * from './dsl/conditions.js';
+export * from './dsl/playwrightJsExecutor.js';
+export * from './util/index.js';

package/dist/loader.d.ts

@@ -19,9 +19,17 @@ export declare class TaskPackLoader {
      */
     static loadManifest(packPath: string): TaskPackManifest;
     /**
-     * Load task pack from directory (json-dsl format only)
+     * Load task pack from directory
      */
     static loadTaskPack(packPath: string): Promise<TaskPack>;
+    /**
+     * Load a json-dsl task pack
+     */
+    private static loadJsonDslPack;
+    /**
+     * Load a playwright-js task pack
+     */
+    private static loadPlaywrightJsPack;
     /**
      * Load secrets from .secrets.json file in pack directory
      * Returns empty object if file doesn't exist

package/dist/loader.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"loader.d.ts","sourceRoot":"","sources":["../src/loader.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,QAAQ,EAAE,gBAAgB,EAAsC,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAInH;;GAEG;AACH,MAAM,WAAW,WAAW;IAC1B,OAAO,EAAE,CAAC,CAAC;IACX,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CACjC;AAED;;;;;;GAMG;AACH,qBAAa,cAAc;IACzB;;OAEG;IACH,MAAM,CAAC,YAAY,CAAC,QAAQ,EAAE,MAAM,GAAG,gBAAgB;IA4BvD;;OAEG;WACU,YAAY,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,QAAQ,CAAC;IA4C9D;;;OAGG;IACH,MAAM,CAAC,WAAW,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IAwB5D;;OAEG;IACH,MAAM,CAAC,oBAAoB,CAAC,QAAQ,EAAE,MAAM,GAAG,gBAAgB,EAAE;CAQlE"}
+{"version":3,"file":"loader.d.ts","sourceRoot":"","sources":["../src/loader.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,QAAQ,EAAE,gBAAgB,EAAsC,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAInH;;GAEG;AACH,MAAM,WAAW,WAAW;IAC1B,OAAO,EAAE,CAAC,CAAC;IACX,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CACjC;AAED;;;;;;GAMG;AACH,qBAAa,cAAc;IACzB;;OAEG;IACH,MAAM,CAAC,YAAY,CAAC,QAAQ,EAAE,MAAM,GAAG,gBAAgB;IA6BvD;;OAEG;WACU,YAAY,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,QAAQ,CAAC;IAU9D;;OAEG;IACH,OAAO,CAAC,MAAM,CAAC,eAAe;IA0C9B;;OAEG;IACH,OAAO,CAAC,MAAM,CAAC,oBAAoB;IAyBnC;;;OAGG;IACH,MAAM,CAAC,WAAW,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IAwB5D;;OAEG;IACH,MAAM,CAAC,oBAAoB,CAAC,QAAQ,EAAE,MAAM,GAAG,gBAAgB,EAAE;CAQlE"}

package/dist/loader.js

@@ -29,17 +29,27 @@ export class TaskPackLoader {
         if (!manifest.id || !manifest.name || !manifest.version) {
             throw new Error('taskpack.json missing required fields: id, name, version');
         }
-        // Only json-dsl format is supported
-        if (manifest.kind !== 'json-dsl') {
-            throw new Error('taskpack.json must have "kind": "json-dsl". Other formats are no longer supported.');
+        // Validate kind
+        const validKinds = ['json-dsl', 'playwright-js'];
+        if (!validKinds.includes(manifest.kind)) {
+            throw new Error(`taskpack.json "kind" must be one of: ${validKinds.join(', ')}. Got: "${manifest.kind}"`);
         }
         return manifest;
     }
     /**
-     * Load task pack from directory (json-dsl format only)
+     * Load task pack from directory
      */
     static async loadTaskPack(packPath) {
         const manifest = this.loadManifest(packPath);
+        if (manifest.kind === 'playwright-js') {
+            return this.loadPlaywrightJsPack(packPath, manifest);
+        }
+        return this.loadJsonDslPack(packPath, manifest);
+    }
+    /**
+     * Load a json-dsl task pack
+     */
+    static loadJsonDslPack(packPath, manifest) {
         const flowPath = join(packPath, 'flow.json');
         if (!existsSync(flowPath)) {
             throw new Error(`flow.json not found for json-dsl pack: ${flowPath}`);
@@ -72,6 +82,31 @@ export class TaskPackLoader {
             ...(snapshots ? { snapshots } : {}),
         };
     }
+    /**
+     * Load a playwright-js task pack
+     */
+    static loadPlaywrightJsPack(packPath, manifest) {
+        const flowPath = join(packPath, 'flow.playwright.js');
+        if (!existsSync(flowPath)) {
+            throw new Error(`flow.playwright.js not found for playwright-js pack: ${flowPath}`);
+        }
+        const source = readFileSync(flowPath, 'utf-8');
+        return {
+            metadata: {
+                id: manifest.id,
+                name: manifest.name,
+                version: manifest.version,
+                description: manifest.description,
+            },
+            kind: 'playwright-js',
+            inputs: manifest.inputs || {},
+            collectibles: manifest.collectibles || [],
+            flow: [], // Not used for playwright-js packs
+            playwrightJsSource: source,
+            auth: manifest.auth,
+            browser: manifest.browser,
+        };
+    }
     /**
      * Load secrets from .secrets.json file in pack directory
      * Returns empty object if file doesn't exist

package/dist/packUtils.d.ts

@@ -33,4 +33,8 @@ export declare function writeFlowJson(packDir: string, flowData: {
     collectibles?: CollectibleDefinition[];
     flow: DslStep[];
 }, skipValidation?: boolean): void;
+/**
+ * Write flow.playwright.js
+ */
+export declare function writePlaywrightJs(packDir: string, source: string): void;
 //# sourceMappingURL=packUtils.d.ts.map

package/dist/packUtils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"packUtils.d.ts","sourceRoot":"","sources":["../src/packUtils.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,gBAAgB,EAAE,WAAW,EAAE,qBAAqB,EAAE,MAAM,YAAY,CAAC;AACvF,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,gBAAgB,CAAC;AAG9C;;GAEG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAGrD;AAED;;GAEG;AACH,wBAAgB,SAAS,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAE/C;AAED;;GAEG;AACH,wBAAgB,WAAW,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,IAAI,CAgBnE;AAED;;GAEG;AACH,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,IAAI,CAO/E;AAED;;GAEG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAAE,QAAQ,EAAE,MAAM,GAAG,CAAC,CAUnD;AAED;;GAEG;AACH,wBAAgB,qBAAqB,CACnC,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,gBAAgB,GACzB,IAAI,CAIN;AAED;;;GAGG;AACH,wBAAgB,aAAa,CAC3B,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE;IACR,MAAM,CAAC,EAAE,WAAW,CAAC;IACrB,YAAY,CAAC,EAAE,qBAAqB,EAAE,CAAC;IACvC,IAAI,EAAE,OAAO,EAAE,CAAC;CACjB,EACD,cAAc,UAAQ,GACrB,IAAI,CAoBN"}
+{"version":3,"file":"packUtils.d.ts","sourceRoot":"","sources":["../src/packUtils.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,gBAAgB,EAAE,WAAW,EAAE,qBAAqB,EAAE,MAAM,YAAY,CAAC;AACvF,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,gBAAgB,CAAC;AAG9C;;GAEG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAGrD;AAED;;GAEG;AACH,wBAAgB,SAAS,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAE/C;AAED;;GAEG;AACH,wBAAgB,WAAW,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,IAAI,CAgBnE;AAED;;GAEG;AACH,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,IAAI,CAO/E;AAED;;GAEG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAAE,QAAQ,EAAE,MAAM,GAAG,CAAC,CAUnD;AAED;;GAEG;AACH,wBAAgB,qBAAqB,CACnC,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,gBAAgB,GACzB,IAAI,CAIN;AAED;;;GAGG;AACH,wBAAgB,aAAa,CAC3B,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE;IACR,MAAM,CAAC,EAAE,WAAW,CAAC;IACrB,YAAY,CAAC,EAAE,qBAAqB,EAAE,CAAC;IACvC,IAAI,EAAE,OAAO,EAAE,CAAC;CACjB,EACD,cAAc,UAAQ,GACrB,IAAI,CAoBN;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI,CAGvE"}

package/dist/packUtils.js

@@ -95,3 +95,10 @@ export function writeFlowJson(packDir, flowData, skipValidation = false) {
     const content = JSON.stringify(flowData, null, 2) + '\n';
     atomicWrite(flowPath, content);
 }
+/**
+ * Write flow.playwright.js
+ */
+export function writePlaywrightJs(packDir, source) {
+    const flowPath = join(packDir, 'flow.playwright.js');
+    atomicWrite(flowPath, source);
+}

package/dist/registry/client.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../src/registry/client.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAMH,OAAO,KAAK,EACV,eAAe,EACf,kBAAkB,EAClB,gBAAgB,EAGhB,WAAW,EACX,aAAa,EACb,aAAa,EACb,WAAW,EAEX,iBAAiB,EACjB,WAAW,EACX,YAAY,EAEb,MAAM,YAAY,CAAC;AAMpB,qBAAa,aAAc,SAAQ,KAAK;aAGpB,MAAM,EAAE,MAAM;aACd,IAAI,CAAC,EAAE,OAAO;gBAF9B,OAAO,EAAE,MAAM,EACC,MAAM,EAAE,MAAM,EACd,IAAI,CAAC,EAAE,OAAO,YAAA;CAKjC;AAyCD,qBAAa,cAAe,YAAW,eAAe;IACpD,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAS;gBAEzB,WAAW,CAAC,EAAE,MAAM;IAQ1B,gBAAgB,IAAI,OAAO,CAAC,kBAAkB,CAAC;IAS/C,eAAe,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,gBAAgB,CAAC;IA+C9D,MAAM,IAAI,OAAO,CAAC,IAAI,CAAC;IAIvB,MAAM,IAAI,OAAO,CAAC,WAAW,CAAC;IAIpC,eAAe,IAAI,OAAO;IAOpB,WAAW,CAAC,MAAM,EAAE,aAAa,GAAG,OAAO,CAAC,aAAa,CAAC;IA4E1D,WAAW,CAAC,KAAK,EAAE,WAAW,GAAG,OAAO,CAAC,iBAAiB,CAAC,WAAW,CAAC,CAAC;IAWxE,WAAW,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IA4B1E,UAAU,CAAC,MAAM,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC;YAcvC,OAAO;IAwCrB;;;OAGG;YACW,mBAAmB;YAkCnB,kBAAkB;CAcjC"}
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../src/registry/client.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAOH,OAAO,KAAK,EACV,eAAe,EACf,kBAAkB,EAClB,gBAAgB,EAGhB,WAAW,EACX,aAAa,EACb,aAAa,EACb,WAAW,EAEX,iBAAiB,EACjB,WAAW,EACX,YAAY,EAEb,MAAM,YAAY,CAAC;AAMpB,qBAAa,aAAc,SAAQ,KAAK;aAGpB,MAAM,EAAE,MAAM;aACd,IAAI,CAAC,EAAE,OAAO;gBAF9B,OAAO,EAAE,MAAM,EACC,MAAM,EAAE,MAAM,EACd,IAAI,CAAC,EAAE,OAAO,YAAA;CAKjC;AAyCD,qBAAa,cAAe,YAAW,eAAe;IACpD,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAS;gBAEzB,WAAW,CAAC,EAAE,MAAM;IAQ1B,gBAAgB,IAAI,OAAO,CAAC,kBAAkB,CAAC;IAS/C,eAAe,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,gBAAgB,CAAC;IA+C9D,MAAM,IAAI,OAAO,CAAC,IAAI,CAAC;IAIvB,MAAM,IAAI,OAAO,CAAC,WAAW,CAAC;IAIpC,eAAe,IAAI,OAAO;IAOpB,WAAW,CAAC,MAAM,EAAE,aAAa,GAAG,OAAO,CAAC,aAAa,CAAC;IA+G1D,WAAW,CAAC,KAAK,EAAE,WAAW,GAAG,OAAO,CAAC,iBAAiB,CAAC,WAAW,CAAC,CAAC;IAWxE,WAAW,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IA4B1E,UAAU,CAAC,MAAM,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC;YAcvC,OAAO;IAwCrB;;;OAGG;YACW,mBAAmB;YAkCnB,kBAAkB;CAcjC"}

package/dist/registry/client.js

@@ -6,6 +6,7 @@
  * automatically refreshes access tokens before they expire.
  */
 import { join } from 'path';
+import { readFileSync } from 'fs';
 import { TaskPackLoader } from '../loader.js';
 import { readJsonFile, ensureDir, writeTaskPackManifest, writeFlowJson } from '../packUtils.js';
 import { loadTokens, saveTokens, clearTokens } from './tokenStore.js';
@@ -125,8 +126,22 @@ export class RegistryClient {
         const warnings = [];
         // Load local pack
         const manifest = TaskPackLoader.loadManifest(packPath);
-        const flowPath = join(packPath, 'flow.json');
-        const flowData = readJsonFile(flowPath);
+        // Load flow data based on pack kind
+        let flowData;
+        let playwrightJsSource;
+        if (manifest.kind === 'playwright-js') {
+            // playwright-js packs use flow.playwright.js (raw source code)
+            // The registry expects 'playwrightJsSource' at top level, not inside 'flow'
+            const flowPath = join(packPath, 'flow.playwright.js');
+            playwrightJsSource = readFileSync(flowPath, 'utf-8');
+            // For playwright-js, no flow object is needed
+            flowData = undefined;
+        }
+        else {
+            // json-dsl packs use flow.json
+            const flowPath = join(packPath, 'flow.json');
+            flowData = readJsonFile(flowPath);
+        }
         const slug = userSlug || manifest.id;
         // Try to get existing pack; create if 404.
         // Publish uses the short slug — server infers the @username scope from the
@@ -149,19 +164,37 @@ export class RegistryClient {
                 throw err;
             }
         }
-        // Publish version
-        const versionData = await this.request('POST', `/api/packs/${encodeURIComponent(slug)}/versions`, {
+        // Build the manifest payload for the registry
+        // For playwright-js packs, inputs and collectibles must be included in the manifest
+        // (the registry validates this)
+        const manifestPayload = {
+            id: manifest.id,
+            name: manifest.name,
+            version: manifest.version,
+            description: manifest.description,
+            kind: manifest.kind,
+        };
+        // Include inputs and collectibles for playwright-js packs (required by registry)
+        if (manifest.kind === 'playwright-js') {
+            manifestPayload.inputs = manifest.inputs || {};
+            manifestPayload.collectibles = manifest.collectibles || [];
+        }
+        // Build the version request body
+        // For playwright-js, playwrightJsSource goes at top level
+        // For json-dsl, flow data goes under 'flow' key
+        const versionBody = {
             version: manifest.version,
-            manifest: {
-                id: manifest.id,
-                name: manifest.name,
-                version: manifest.version,
-                description: manifest.description,
-                kind: manifest.kind,
-            },
-            flow: flowData,
+            manifest: manifestPayload,
             changelog,
-        }, true);
+        };
+        if (manifest.kind === 'playwright-js') {
+            versionBody.playwrightJsSource = playwrightJsSource;
+        }
+        else {
+            versionBody.flow = flowData;
+        }
+        // Publish version
+        const versionData = await this.request('POST', `/api/packs/${encodeURIComponent(slug)}/versions`, versionBody, true);
         // The API may return version as a string or as an object with a nested version field
         const rawVersion = versionData.version;
         const version = typeof rawVersion === 'string'

package/dist/runner.d.ts

@@ -1,5 +1,7 @@
+import { type Page } from 'playwright';
 import type { TaskPack, RunResult } from './types.js';
 import type { Logger } from './types.js';
+import type { NetworkCaptureApi } from './networkCapture.js';
 /**
  * Options for running a task pack
  */
@@ -45,6 +47,29 @@ export interface RunTaskPackOptions {
      * instead of launching a new one.
      */
     cdpUrl?: string;
+    /**
+     * Executor for playwright-js packs.
+     * If not provided, playwright-js packs will throw an error.
+     */
+    playwrightJsExecutor?: (source: string, scope: {
+        page: Page;
+        context: import('playwright').BrowserContext;
+        frame: import('playwright').Frame;
+        inputs: Record<string, unknown>;
+        secrets: Record<string, string>;
+        showrun: {
+            network: {
+                list: NetworkCaptureApi['list'];
+                find: NetworkCaptureApi['find'];
+                get: NetworkCaptureApi['get'];
+                replay: NetworkCaptureApi['replay'];
+            };
+        };
+        util: import('./util/index.js').PlaywrightJsUtil;
+    }, timeoutMs?: number) => Promise<{
+        collectibles: Record<string, unknown>;
+        logs: string[];
+    }>;
 }
 /**
  * Result of running a task pack with paths