@showrun/core 0.1.0 → 0.1.1-b

package/dist/config.js

@@ -0,0 +1,268 @@
+/**
+ * System-wide configuration for ShowRun.
+ *
+ * Layered config discovery:
+ *   Built-in defaults < global config.json < project config.json < .env < real env vars
+ *
+ * Config directory search order (lowest → highest priority):
+ *   Linux/macOS: $XDG_CONFIG_HOME/showrun/ → ~/.showrun/ → ancestor .showrun/ → cwd/.showrun/
+ *   Windows:     %APPDATA%\showrun\        → ancestor .showrun\ → cwd\.showrun\
+ */
+import { existsSync, copyFileSync } from 'fs';
+import { resolve, join, parse as parsePath } from 'path';
+import { platform, homedir } from 'os';
+import { cwd } from 'process';
+import { ensureDir, readJsonFile } from './packUtils.js';
+// ── Deep merge helper ──────────────────────────────────────────────────────
+/**
+ * Recursively merge `override` into `base`, returning a new object.
+ * - Primitives and arrays in override replace base values.
+ * - Null/undefined values in override are skipped.
+ * - Nested plain objects are merged recursively.
+ */
+export function deepMerge(base, override) {
+    if (typeof base !== 'object' || base === null ||
+        typeof override !== 'object' || override === null ||
+        Array.isArray(base) || Array.isArray(override)) {
+        return override;
+    }
+    const result = { ...base };
+    const src = override;
+    for (const key of Object.keys(src)) {
+        const overrideVal = src[key];
+        if (overrideVal === null || overrideVal === undefined)
+            continue;
+        const baseVal = result[key];
+        if (typeof baseVal === 'object' && baseVal !== null && !Array.isArray(baseVal) &&
+            typeof overrideVal === 'object' && overrideVal !== null && !Array.isArray(overrideVal)) {
+            result[key] = deepMerge(baseVal, overrideVal);
+        }
+        else {
+            result[key] = overrideVal;
+        }
+    }
+    return result;
+}
+// ── Directory discovery ────────────────────────────────────────────────────
+/**
+ * Walk from `startDir` up toward the filesystem root, collecting every
+ * `.showrun/` directory encountered. Returns in bottom-up order (closest
+ * ancestor first) which is the *highest* priority order.
+ */
+function walkUpForShowrunDirs(startDir) {
+    const dirs = [];
+    let dir = resolve(startDir);
+    const root = parsePath(dir).root;
+    // Skip cwd itself — handled separately
+    dir = resolve(dir, '..');
+    while (dir !== root && dir.length > root.length) {
+        const candidate = join(dir, '.showrun');
+        if (existsSync(candidate)) {
+            dirs.push(candidate);
+        }
+        dir = resolve(dir, '..');
+    }
+    // Reverse so that farthest ancestor is first (lowest priority)
+    return dirs.reverse();
+}
+/**
+ * Returns an ordered list of config directories to search, lowest priority first.
+ */
+export function discoverConfigDirs() {
+    const dirs = [];
+    const os = platform();
+    const home = homedir();
+    const currentDir = cwd();
+    if (os === 'win32') {
+        // Windows: %APPDATA%\showrun
+        const appData = process.env.APPDATA;
+        if (appData) {
+            dirs.push(join(appData, 'showrun'));
+        }
+    }
+    else {
+        // Linux/macOS: XDG_CONFIG_HOME/showrun (default ~/.config/showrun)
+        const xdgConfig = process.env.XDG_CONFIG_HOME || join(home, '.config');
+        dirs.push(join(xdgConfig, 'showrun'));
+        // ~/.showrun
+        dirs.push(join(home, '.showrun'));
+    }
+    // Ancestor .showrun/ directories (farthest ancestor first = lowest priority)
+    dirs.push(...walkUpForShowrunDirs(currentDir));
+    // cwd/.showrun (highest priority)
+    dirs.push(join(currentDir, '.showrun'));
+    return dirs;
+}
+// ── Config loading ─────────────────────────────────────────────────────────
+const DEFAULT_CONFIG = {};
+/**
+ * Load all `config.json` files from discovered directories, merge them, and
+ * return the result along with metadata about which files were loaded.
+ */
+export function loadConfig() {
+    const searchedDirs = discoverConfigDirs();
+    let merged = { ...DEFAULT_CONFIG };
+    const loadedFiles = [];
+    for (const dir of searchedDirs) {
+        const configPath = join(dir, 'config.json');
+        if (existsSync(configPath)) {
+            try {
+                const fileConfig = readJsonFile(configPath);
+                merged = deepMerge(merged, fileConfig);
+                loadedFiles.push(configPath);
+            }
+            catch (err) {
+                console.warn(`[Config] Failed to load ${configPath}: ${err instanceof Error ? err.message : String(err)}`);
+            }
+        }
+    }
+    return { config: merged, loadedFiles, searchedDirs };
+}
+// ── Env var mapping ────────────────────────────────────────────────────────
+/** Map of config path → env var name */
+const CONFIG_TO_ENV = [
+    { path: ['llm', 'provider'], envVar: 'LLM_PROVIDER' },
+    { path: ['llm', 'anthropic', 'apiKey'], envVar: 'ANTHROPIC_API_KEY' },
+    { path: ['llm', 'anthropic', 'model'], envVar: 'ANTHROPIC_MODEL' },
+    { path: ['llm', 'anthropic', 'baseUrl'], envVar: 'ANTHROPIC_BASE_URL' },
+    { path: ['llm', 'openai', 'apiKey'], envVar: 'OPENAI_API_KEY' },
+    { path: ['llm', 'openai', 'model'], envVar: 'OPENAI_MODEL' },
+    { path: ['llm', 'openai', 'baseUrl'], envVar: 'OPENAI_BASE_URL' },
+    { path: ['agent', 'maxBrowserRounds'], envVar: 'MAX_BROWSER_ROUNDS' },
+    { path: ['agent', 'debug'], envVar: 'SHOWRUN_DEBUG' },
+    { path: ['agent', 'transcriptLogging'], envVar: 'SHOWRUN_TRANSCRIPT_LOGGING' },
+    { path: ['prompts', 'teachChatSystemPrompt'], envVar: 'TEACH_CHAT_SYSTEM_PROMPT' },
+    { path: ['prompts', 'explorationAgentPromptPath'], envVar: 'EXPLORATION_AGENT_PROMPT_PATH' },
+    { path: ['techniques', 'vectorStore', 'provider'], envVar: 'VECTORSTORE_PROVIDER' },
+    { path: ['techniques', 'vectorStore', 'url'], envVar: 'WEAVIATE_URL' },
+    { path: ['techniques', 'vectorStore', 'apiKey'], envVar: 'WEAVIATE_API_KEY' },
+    { path: ['techniques', 'vectorStore', 'vectorizer'], envVar: 'WEAVIATE_VECTORIZER' },
+    { path: ['techniques', 'embedding', 'apiKey'], envVar: 'EMBEDDING_API_KEY' },
+    { path: ['techniques', 'embedding', 'model'], envVar: 'EMBEDDING_MODEL' },
+    { path: ['techniques', 'embedding', 'baseUrl'], envVar: 'EMBEDDING_BASE_URL' },
+    { path: ['techniques', 'collectionName'], envVar: 'TECHNIQUES_COLLECTION' },
+];
+function getNestedValue(obj, path) {
+    let current = obj;
+    for (const key of path) {
+        if (current === null || current === undefined || typeof current !== 'object')
+            return undefined;
+        current = current[key];
+    }
+    return current;
+}
+/**
+ * Apply config values to `process.env`, only setting vars that are not already present.
+ */
+export function applyConfigToEnv(config) {
+    for (const { path, envVar } of CONFIG_TO_ENV) {
+        if (process.env[envVar])
+            continue; // real env / dotenv takes precedence
+        const value = getNestedValue(config, path);
+        if (value !== undefined && value !== null) {
+            process.env[envVar] = String(value);
+        }
+    }
+}
+// ── File resolution ────────────────────────────────────────────────────────
+/**
+ * Resolve a filename by searching local paths first (cwd, then ancestors),
+ * then config directories (highest priority first).
+ * Local files always win over config dir copies.
+ * Returns the first existing path, or null.
+ */
+export function resolveFilePath(filename) {
+    // 1. Search cwd first — local files take priority
+    const cwdPath = resolve(cwd(), filename);
+    if (existsSync(cwdPath))
+        return cwdPath;
+    // 2. Walk up from cwd looking for the file directly (not inside .showrun)
+    let dir = resolve(cwd(), '..');
+    const root = parsePath(dir).root;
+    while (dir !== root && dir.length > root.length) {
+        const candidate = resolve(dir, filename);
+        if (existsSync(candidate))
+            return candidate;
+        dir = resolve(dir, '..');
+    }
+    // 3. Fall back to config dirs from highest priority (last) to lowest (first)
+    const configDirs = discoverConfigDirs();
+    for (let i = configDirs.length - 1; i >= 0; i--) {
+        const candidate = join(configDirs[i], filename);
+        if (existsSync(candidate))
+            return candidate;
+    }
+    return null;
+}
+// ── System prompt helper ───────────────────────────────────────────────────
+/**
+ * Get the global config directory path for the current platform.
+ */
+export function getGlobalConfigDir() {
+    const os = platform();
+    if (os === 'win32') {
+        const appData = process.env.APPDATA;
+        if (appData)
+            return join(appData, 'showrun');
+        return join(homedir(), 'AppData', 'Roaming', 'showrun');
+    }
+    const xdgConfig = process.env.XDG_CONFIG_HOME || join(homedir(), '.config');
+    return join(xdgConfig, 'showrun');
+}
+/**
+ * Ensure a system prompt file exists in a config directory.
+ * If the prompt was found outside config dirs (e.g. repo root), copy it
+ * into the global config dir so it's available when running from any directory.
+ */
+export function ensureSystemPromptInConfigDir(filename, sourcePath) {
+    const configDirs = discoverConfigDirs();
+    // Check if the file already exists in any config dir
+    for (const dir of configDirs) {
+        const candidate = join(dir, filename);
+        if (existsSync(candidate))
+            return candidate;
+    }
+    // Not in any config dir — copy it to the global config dir
+    const globalDir = getGlobalConfigDir();
+    const destPath = join(globalDir, filename);
+    ensureDir(globalDir);
+    copyFileSync(sourcePath, destPath);
+    console.log(`[Config] Created config directory at ${globalDir}`);
+    console.log(`[Config] Copied ${filename} to ${destPath}`);
+    return destPath;
+}
+// ── Main entry point ───────────────────────────────────────────────────────
+/**
+ * Load config, merge, and apply to process.env.
+ * This is the single call sites should use (e.g. CLI bootstrap).
+ */
+export function initConfig() {
+    const result = loadConfig();
+    applyConfigToEnv(result.config);
+    if (result.loadedFiles.length > 0) {
+        console.log(`[Config] Loaded: ${result.loadedFiles.join(', ')}`);
+    }
+    return result;
+}
+// ── Default config template ────────────────────────────────────────────────
+export const DEFAULT_CONFIG_TEMPLATE = {
+    llm: {
+        provider: 'anthropic',
+        anthropic: { apiKey: '', model: '', baseUrl: '' },
+        openai: { apiKey: '', model: '', baseUrl: '' },
+    },
+    agent: {
+        maxBrowserRounds: 0,
+        debug: false,
+        transcriptLogging: false,
+    },
+    prompts: {
+        teachChatSystemPrompt: '',
+        explorationAgentPromptPath: '',
+    },
+    techniques: {
+        vectorStore: { provider: 'weaviate', url: '', apiKey: '', vectorizer: '' },
+        embedding: { apiKey: '', model: '', baseUrl: '' },
+        collectionName: '',
+    },
+};

package/dist/dsl/interpreter.d.ts

@@ -1,5 +1,6 @@
 import type { RunContext, AuthConfig } from '../types.js';
 import type { DslStep, RunFlowOptions, RunFlowResult } from './types.js';
+import type { SnapshotFile } from '../requestSnapshot.js';
 /**
  * Extended options for running a flow with auth resilience
  */
@@ -16,6 +17,14 @@ export interface RunFlowOptionsWithAuth extends RunFlowOptions {
      * Secrets for template resolution ({{secret.NAME}})
      */
     secrets?: Record<string, string>;
+    /**
+     * If true, run in HTTP-only mode (skip browser steps, replay from snapshots)
+     */
+    httpMode?: boolean;
+    /**
+     * Request snapshots for HTTP-first execution
+     */
+    snapshots?: SnapshotFile;
 }
 /**
  * Runs a flow of DSL steps sequentially with auth resilience support

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

@@ -1 +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"}
+{"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;AAgBzE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AA+C1D;;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;IACjC;;OAEG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB;;OAEG;IACH,SAAS,CAAC,EAAE,YAAY,CAAC;CAC1B;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,CAycxB"}

package/dist/dsl/interpreter.js

@@ -72,6 +72,8 @@ export async function runFlow(ctx, steps, options) {
     const profileId = options?.profileId;
     const cacheDir = options?.cacheDir;
     const secrets = options?.secrets ?? {};
+    const httpMode = options?.httpMode ?? false;
+    const snapshots = options?.snapshots;
     // Get secret values for redaction (only values >= 3 chars)
     const secretValues = Object.values(secrets).filter((v) => v && v.length >= 3);
     // Validate flow before execution
@@ -98,6 +100,9 @@ export async function runFlow(ctx, steps, options) {
         inputs,
         networkCapture: ctx.networkCapture,
         authMonitor: authMonitor ?? undefined,
+        httpMode,
+        snapshots: snapshots ?? undefined,
+        secrets,
     };
     if (authConfig?.authPolicy) {
         authMonitor = new AuthFailureMonitor(authConfig.authPolicy);
@@ -174,8 +179,13 @@ export async function runFlow(ctx, steps, options) {
                     }
                 }
                 catch (conditionError) {
-                    // Log condition evaluation error but continue with step execution
-                    console.warn(`[interpreter] Error evaluating skip_if for step ${step.id}:`, conditionError);
+                    const msg = `skip_if evaluation error for step "${step.id}": ${conditionError instanceof Error ? conditionError.message : String(conditionError)}`;
+                    console.warn(`[interpreter] ${msg}`);
+                    ctx.logger.log({ type: 'error', data: { error: msg, stepId: step.id, type: step.type } });
+                    // Push to hints so the agent can see the error
+                    if (!vars['__jmespath_hints'])
+                        vars['__jmespath_hints'] = [];
+                    vars['__jmespath_hints'].push(msg);
                 }
             }
             // Resolve templates in step params before execution
@@ -384,8 +394,8 @@ export async function runFlow(ctx, steps, options) {
                     stepsExecuted++;
                     continue;
                 }
-                // Capture artifacts on error if available
-                if (ctx.artifacts) {
+                // Capture artifacts on error if available (skip in HTTP mode — no browser)
+                if (ctx.artifacts && !httpMode) {
                     try {
                         await ctx.artifacts.saveScreenshot(`error-${step.id}`);
                         const html = await ctx.page.content();
@@ -396,12 +406,20 @@ export async function runFlow(ctx, steps, options) {
                         console.error('Failed to save artifacts:', artifactError);
                     }
                 }
+                // Attach partial results to the error for upstream consumers
+                if (error instanceof Error) {
+                    error.partialResult = {
+                        collectibles: { ...collectibles },
+                        stepsExecuted,
+                        failedStepId: step.id,
+                    };
+                }
                 // Stop on error (default behavior)
                 throw error;
             }
         }
         const durationMs = Date.now() - startTime;
-        const finalUrl = ctx.page.url();
+        const finalUrl = httpMode ? undefined : ctx.page.url();
         // Collect JMESPath hints from vars (stored by step handlers)
         const jmespathHints = vars['__jmespath_hints'] || [];
         const singleHint = vars['__jmespath_hint'];
@@ -418,6 +436,7 @@ export async function runFlow(ctx, steps, options) {
                 stepsExecuted,
                 stepsTotal: steps.length,
             },
+            _vars: { ...vars },
         };
         // Only include _hints if there are any
         if (uniqueHints.length > 0) {

package/dist/dsl/stepHandlers.d.ts

@@ -2,6 +2,7 @@ import type { Page, BrowserContext, Frame } from 'playwright';
 import type { DslStep } from './types.js';
 import type { NetworkCaptureApi } from '../networkCapture.js';
 import type { AuthFailureMonitor } from '../authResilience.js';
+import type { SnapshotFile } from '../requestSnapshot.js';
 /**
  * Step execution context
  */
@@ -24,6 +25,12 @@ export interface StepContext {
     previousTabIndex?: number;
     /** Task pack directory path (for resolving relative file paths) */
     packDir?: string;
+    /** If true, running in HTTP-only mode (no browser) */
+    httpMode?: boolean;
+    /** Request snapshots for HTTP-first execution */
+    snapshots?: SnapshotFile;
+    /** Secrets for template resolution in HTTP mode */
+    secrets?: Record<string, string>;
 }
 /**
  * Executes a single DSL step

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

@@ -1 +1 @@
-{"version":3,"file":"stepHandlers.d.ts","sourceRoot":"","sources":["../../src/dsl/stepHandlers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,cAAc,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AAC9D,OAAO,KAAK,EACV,OAAO,EAqBR,MAAM,YAAY,CAAC;AACpB,OAAO,KAAK,EAAE,iBAAiB,EAA4C,MAAM,sBAAsB,CAAC;AAGxG,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAG/D;;GAEG;AACH,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,IAAI,CAAC;IACX,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACtC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC9B,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAChC,mDAAmD;IACnD,cAAc,CAAC,EAAE,iBAAiB,CAAC;IACnC,kFAAkF;IAClF,WAAW,CAAC,EAAE,kBAAkB,CAAC;IACjC,gDAAgD;IAChD,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,+CAA+C;IAC/C,cAAc,CAAC,EAAE,cAAc,CAAC;IAChC,oDAAoD;IACpD,YAAY,CAAC,EAAE,KAAK,CAAC;IACrB,0DAA0D;IAC1D,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,mEAAmE;IACnE,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAw5BD;;GAEG;AACH,wBAAsB,WAAW,CAC/B,GAAG,EAAE,WAAW,EAChB,IAAI,EAAE,OAAO,GACZ,OAAO,CAAC,IAAI,CAAC,CAgEf"}
+{"version":3,"file":"stepHandlers.d.ts","sourceRoot":"","sources":["../../src/dsl/stepHandlers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,cAAc,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AAC9D,OAAO,KAAK,EACV,OAAO,EAqBR,MAAM,YAAY,CAAC;AACpB,OAAO,KAAK,EAAE,iBAAiB,EAA4C,MAAM,sBAAsB,CAAC;AAGxG,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAE/D,OAAO,KAAK,EAAE,YAAY,EAAmB,MAAM,uBAAuB,CAAC;AAI3E;;GAEG;AACH,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,IAAI,CAAC;IACX,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACtC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC9B,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAChC,mDAAmD;IACnD,cAAc,CAAC,EAAE,iBAAiB,CAAC;IACnC,kFAAkF;IAClF,WAAW,CAAC,EAAE,kBAAkB,CAAC;IACjC,gDAAgD;IAChD,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,+CAA+C;IAC/C,cAAc,CAAC,EAAE,cAAc,CAAC;IAChC,oDAAoD;IACpD,YAAY,CAAC,EAAE,KAAK,CAAC;IACrB,0DAA0D;IAC1D,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,mEAAmE;IACnE,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,sDAAsD;IACtD,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,iDAAiD;IACjD,SAAS,CAAC,EAAE,YAAY,CAAC;IACzB,mDAAmD;IACnD,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAClC;AAmiCD;;GAEG;AACH,wBAAsB,WAAW,CAC/B,GAAG,EAAE,WAAW,EAChB,IAAI,EAAE,OAAO,GACZ,OAAO,CAAC,IAAI,CAAC,CA4Ef"}

package/dist/dsl/stepHandlers.js

@@ -1,6 +1,8 @@
 import { resolveTemplate } from './templating.js';
 import { resolveTargetWithFallback, selectorToTarget } from './target.js';
 import { search as jmesSearch } from '@jmespath-community/jmespath';
+import { replayFromSnapshot } from '../httpReplay.js';
+import { validateResponse } from '../requestSnapshot.js';
 /**
  * Executes a navigate step
  */
@@ -284,18 +286,24 @@ function getByPath(obj, path) {
     }
     try {
         const result = jmesSearch(obj, trimmed);
-        // Check for null/undefined results and provide diagnostic hint
+        // Check for null/undefined results and provide diagnostic hint with data structure
         if (result === null || result === undefined) {
+            const topKeys = typeof obj === 'object' && obj !== null
+                ? Object.keys(obj).slice(0, 10).join(', ')
+                : typeof obj;
             return {
                 value: result,
-                hint: `JMESPath '${trimmed}' matched nothing (returned ${result}). Verify the path exists. Try a simpler path like 'data' or 'keys(@)' to inspect the structure.`,
+                hint: `JMESPath '${trimmed}' matched nothing (returned ${result}). Actual top-level keys: [${topKeys}]. Try a simpler path like 'data' or 'keys(@)' to inspect the structure.`,
             };
         }
         // Check for empty array results
         if (Array.isArray(result) && result.length === 0) {
+            const topKeys = typeof obj === 'object' && obj !== null
+                ? Object.keys(obj).slice(0, 10).join(', ')
+                : typeof obj;
             return {
                 value: result,
-                hint: `JMESPath '${trimmed}' returned an empty array. The path may be correct but no items matched.`,
+                hint: `JMESPath '${trimmed}' returned an empty array. Actual top-level keys: [${topKeys}]. The path may be correct but no items matched.`,
             };
         }
         return { value: result };
@@ -399,8 +407,13 @@ async function executeNetworkReplay(ctx, step) {
             setQuery: step.params.overrides.setQuery,
             setHeaders: step.params.overrides.setHeaders,
             body: step.params.overrides.body,
-            urlReplace: step.params.overrides.urlReplace,
-            bodyReplace: step.params.overrides.bodyReplace,
+            // Normalize urlReplace/bodyReplace to array (DSL type accepts single or array)
+            urlReplace: step.params.overrides.urlReplace
+                ? (Array.isArray(step.params.overrides.urlReplace) ? step.params.overrides.urlReplace : [step.params.overrides.urlReplace])
+                : undefined,
+            bodyReplace: step.params.overrides.bodyReplace
+                ? (Array.isArray(step.params.overrides.bodyReplace) ? step.params.overrides.bodyReplace : [step.params.overrides.bodyReplace])
+                : undefined,
         }
         : undefined;
     let result;
@@ -717,10 +730,133 @@ async function executeSwitchTab(ctx, step) {
     ctx.vars['__newPage'] = targetPage;
     await targetPage.bringToFront();
 }
+/** Step types that are skipped silently in HTTP mode (setup/trigger steps). */
+const HTTP_MODE_SKIP_STEPS = new Set([
+    'navigate', 'click', 'fill', 'select_option', 'press_key',
+    'upload_file', 'wait_for', 'assert', 'frame', 'new_tab',
+    'switch_tab', 'network_find',
+]);
+/**
+ * Merge flow-level step overrides with snapshot-level overrides.
+ * Step overrides take precedence for scalar fields (url, body).
+ * Array fields (bodyReplace, urlReplace) are concatenated: snapshot first, then step.
+ * Object fields (setQuery, setHeaders) are merged: step values override snapshot values.
+ */
+function mergeStepOverridesIntoSnapshot(snapshot, stepOverrides) {
+    if (!stepOverrides)
+        return snapshot;
+    // Normalize step overrides arrays
+    const stepBodyReplace = stepOverrides.bodyReplace
+        ? (Array.isArray(stepOverrides.bodyReplace) ? stepOverrides.bodyReplace : [stepOverrides.bodyReplace])
+        : [];
+    const stepUrlReplace = stepOverrides.urlReplace
+        ? (Array.isArray(stepOverrides.urlReplace) ? stepOverrides.urlReplace : [stepOverrides.urlReplace])
+        : [];
+    const snapshotOv = snapshot.overrides;
+    const bodyReplaceArr = [...(snapshotOv?.bodyReplace ?? []), ...stepBodyReplace];
+    const urlReplaceArr = [...(snapshotOv?.urlReplace ?? []), ...stepUrlReplace];
+    // Coerce step setQuery values to strings (step type allows string | number, snapshot expects string)
+    const stepSetQuery = stepOverrides.setQuery
+        ? Object.fromEntries(Object.entries(stepOverrides.setQuery).map(([k, v]) => [k, String(v)]))
+        : undefined;
+    const setQueryMerged = (snapshotOv?.setQuery || stepSetQuery)
+        ? { ...snapshotOv?.setQuery, ...stepSetQuery }
+        : undefined;
+    const setHeadersMerged = (snapshotOv?.setHeaders || stepOverrides.setHeaders)
+        ? { ...snapshotOv?.setHeaders, ...stepOverrides.setHeaders }
+        : undefined;
+    const merged = {
+        // Scalar overrides: step takes precedence
+        url: stepOverrides.url ?? snapshotOv?.url,
+        body: stepOverrides.body ?? snapshotOv?.body,
+        setQuery: setQueryMerged && Object.keys(setQueryMerged).length > 0 ? setQueryMerged : undefined,
+        setHeaders: setHeadersMerged && Object.keys(setHeadersMerged).length > 0 ? setHeadersMerged : undefined,
+        bodyReplace: bodyReplaceArr.length > 0 ? bodyReplaceArr : undefined,
+        urlReplace: urlReplaceArr.length > 0 ? urlReplaceArr : undefined,
+    };
+    const hasOverrides = merged.url || merged.body || merged.setQuery || merged.setHeaders || merged.bodyReplace || merged.urlReplace;
+    return { ...snapshot, overrides: hasOverrides ? merged : undefined };
+}
+/**
+ * Execute a network_replay step in HTTP-only mode using snapshot data.
+ */
+async function executeNetworkReplayHttp(ctx, step) {
+    if (!ctx.snapshots) {
+        throw new Error('network_replay in HTTP mode requires snapshots');
+    }
+    const snapshot = ctx.snapshots.snapshots[step.id];
+    if (!snapshot) {
+        throw new Error(`No snapshot found for step "${step.id}"`);
+    }
+    // Merge flow-level overrides (from step.params) with snapshot-level overrides.
+    // This ensures bodyReplace/urlReplace from the flow are applied in HTTP-only mode.
+    const mergedSnapshot = mergeStepOverridesIntoSnapshot(snapshot, step.params.overrides);
+    const result = await replayFromSnapshot(mergedSnapshot, ctx.inputs, ctx.vars, {
+        secrets: ctx.secrets,
+    });
+    // Validate the response — throw to trigger browser fallback if stale
+    const validation = validateResponse(snapshot, result);
+    if (!validation.valid) {
+        throw new Error(`Snapshot stale for step "${step.id}": ${validation.reason}`);
+    }
+    if (step.params.saveAs) {
+        ctx.vars[step.params.saveAs] = {
+            status: result.status,
+            contentType: result.contentType,
+            body: result.body,
+            bodySize: result.bodySize,
+        };
+    }
+    // Use 'path' with fallback to deprecated 'jsonPath'
+    const pathExpr = step.params.response.path || step.params.response.jsonPath;
+    let outValue;
+    if (step.params.response.as === 'json') {
+        try {
+            outValue = JSON.parse(result.body);
+        }
+        catch {
+            throw new Error(`network_replay (HTTP mode): response body is not valid JSON (status ${result.status})`);
+        }
+        if (pathExpr) {
+            const pathResult = getByPath(outValue, pathExpr);
+            outValue = pathResult.value;
+            if (pathResult.hint) {
+                ctx.vars['__jmespath_hint'] = pathResult.hint;
+            }
+        }
+    }
+    else {
+        if (pathExpr) {
+            const pathResult = getByPath(JSON.parse(result.body), pathExpr);
+            outValue = pathResult.value;
+            if (pathResult.hint) {
+                ctx.vars['__jmespath_hint'] = pathResult.hint;
+            }
+        }
+        else {
+            outValue = result.body;
+        }
+        if (typeof outValue === 'object' && outValue !== null) {
+            outValue = JSON.stringify(outValue);
+        }
+    }
+    ctx.collectibles[step.params.out] = outValue;
+}
 /**
  * Executes a single DSL step
  */
 export async function executeStep(ctx, step) {
+    // In HTTP mode, skip DOM/setup steps and use snapshot replay for network_replay
+    if (ctx.httpMode) {
+        if (HTTP_MODE_SKIP_STEPS.has(step.type)) {
+            return; // silently skip
+        }
+        if (step.type === 'network_replay') {
+            await executeNetworkReplayHttp(ctx, step);
+            return;
+        }
+        // network_extract, set_var, sleep execute normally below
+    }
     switch (step.type) {
         case 'navigate':
             await executeNavigate(ctx, step);

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

@@ -1 +1 @@
-{"version":3,"file":"templating.d.ts","sourceRoot":"","sources":["../../src/dsl/templating.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAIH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AA0BlD;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,eAAe,GAAG,MAAM,CAWlF;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,OAAO,EAAE,eAAe,GAAG,CAAC,CAkBvE;AAED;;GAEG;AACH,wBAAgB,WAAW,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAEhD"}
+{"version":3,"file":"templating.d.ts","sourceRoot":"","sources":["../../src/dsl/templating.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAIH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAuClD;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,eAAe,GAAG,MAAM,CAWlF;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,OAAO,EAAE,eAAe,GAAG,CAAC,CAkBvE;AAED;;GAEG;AACH,wBAAgB,WAAW,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAEhD"}

package/dist/dsl/templating.js

@@ -10,6 +10,17 @@ const env = new nunjucks.Environment(null, {
     autoescape: false,
     throwOnUndefined: false, // Allow undefined values to render as empty string
 });
+/**
+ * pctEncode filter: like urlencode but also encodes characters that
+ * encodeURIComponent leaves unescaped (parentheses, !, ', *, ~).
+ * Useful in URLs where those chars have structural meaning (e.g. LinkedIn Sales Navigator query syntax).
+ * Usage: {{inputs.company_name | pctEncode}}
+ */
+env.addFilter('pctEncode', (val) => {
+    if (val == null)
+        return '';
+    return encodeURIComponent(String(val)).replace(/[!'()*~]/g, (c) => '%' + c.charCodeAt(0).toString(16).toUpperCase());
+});
 /**
  * TOTP filter: generates a 6-digit TOTP code from a base32 secret.
  * Usage: {{secret.TOTP_KEY | totp}}

package/dist/dsl/types.d.ts

@@ -433,16 +433,22 @@ export interface NetworkReplayStep extends BaseDslStep {
             setQuery?: Record<string, string | number>;
             setHeaders?: Record<string, string>;
             body?: string;
-            /** Regex find/replace on captured URL; replace can use $1, $2. Supports {{vars.xxx}}/{{inputs.xxx}} (resolved before replace). */
+            /** Regex find/replace on captured URL; replace can use $1, $2. Supports {{vars.xxx}}/{{inputs.xxx}} (resolved before replace). Accepts single object or array. */
             urlReplace?: {
                 find: string;
                 replace: string;
-            };
-            /** Regex find/replace on captured body; replace can use $1, $2. Supports {{vars.xxx}}/{{inputs.xxx}} (resolved before replace). */
+            } | Array<{
+                find: string;
+                replace: string;
+            }>;
+            /** Regex find/replace on captured body; replace can use $1, $2. Supports {{vars.xxx}}/{{inputs.xxx}} (resolved before replace). Accepts single object or array. */
             bodyReplace?: {
                 find: string;
                 replace: string;
-            };
+            } | Array<{
+                find: string;
+                replace: string;
+            }>;
         };
         auth: 'browser_context';
         out: string;
@@ -691,5 +697,11 @@ export interface RunFlowResult {
      * These help AI agents understand why data extraction may have failed.
      */
     _hints?: string[];
+    /**
+     * Internal: resolved vars after flow execution. Used by snapshot capture
+     * to look up network entries by their runtime-resolved request IDs.
+     * Not part of the public API.
+     */
+    _vars?: Record<string, unknown>;
 }
 //# sourceMappingURL=types.d.ts.map