libretto 0.5.3-experimental.5 → 0.5.3

package/dist/cli/core/snapshot-analyzer.js

@@ -1,9 +1,4 @@
-import {
-  existsSync,
-  mkdtempSync,
-  readFileSync,
-  rmSync
-} from "node:fs";
+import { existsSync, mkdtempSync, readFileSync, rmSync } from "node:fs";
 import { extname, isAbsolute, join, resolve } from "node:path";
 import { spawn } from "node:child_process";
 import { tmpdir } from "node:os";
@@ -60,7 +55,12 @@ Screenshot file path: ${pngPath}
 Use the screenshot alongside the HTML snapshot context above.`;
   }
   async runAnalyzer(args, logger, stdinText) {
-    const result = await runExternalCommand(this.command, args, logger, stdinText);
+    const result = await runExternalCommand(
+      this.command,
+      args,
+      logger,
+      stdinText
+    );
     if (result.exitCode !== 0) {
       throw new Error(
         `Analyzer command failed (${[this.command, ...args].join(" ")}).
@@ -535,7 +535,9 @@ function buildInlinePromptSelection(args, fullHtmlContent, condensedHtmlContent,
     fullDomChars: fullHtmlContent.length,
     fullDomEstimatedTokens: estimateTokensFromChars(fullHtmlContent.length),
     condensedDomChars: condensedHtmlContent.length,
-    condensedDomEstimatedTokens: estimateTokensFromChars(condensedHtmlContent.length),
+    condensedDomEstimatedTokens: estimateTokensFromChars(
+      condensedHtmlContent.length
+    ),
     configuredModel: model
   };
   const buildCandidate = (domSource, htmlContent, selectionReason, truncated) => {
@@ -607,7 +609,10 @@ function buildInlinePromptSelection(args, fullHtmlContent, condensedHtmlContent,
     2e3,
     budget.promptBudgetTokens - estimateTokensFromChars(basePrompt.length)
   );
-  const truncatedHtml = truncateText(condensedHtmlContent, availableHtmlTokens * 4);
+  const truncatedHtml = truncateText(
+    condensedHtmlContent,
+    availableHtmlTokens * 4
+  );
   return buildCandidate(
     "condensed",
     truncatedHtml.text,
@@ -615,27 +620,6 @@ function buildInlinePromptSelection(args, fullHtmlContent, condensedHtmlContent,
     truncatedHtml.truncated
   );
 }
-function formatInterpretationOutput(parsed, header = "Interpretation:") {
-  const outputLines = [];
-  outputLines.push(header);
-  outputLines.push(`Answer: ${parsed.answer}`);
-  outputLines.push("");
-  if (parsed.selectors.length === 0) {
-    outputLines.push("Selectors: none found.");
-  } else {
-    outputLines.push("Selectors:");
-    parsed.selectors.forEach((selector, index) => {
-      outputLines.push(`  ${index + 1}. ${selector.label}`);
-      outputLines.push(`     selector: ${selector.selector}`);
-      outputLines.push(`     rationale: ${selector.rationale}`);
-    });
-  }
-  if (parsed.notes && parsed.notes.trim()) {
-    outputLines.push("");
-    outputLines.push(`Notes: ${parsed.notes.trim()}`);
-  }
-  return outputLines.join("\n");
-}
 async function runInterpret(args, logger) {
   logger.info("interpret-start", {
     objective: args.objective,
@@ -676,7 +660,6 @@ export {
   InterpretResultSchema,
   buildInlinePromptSelection,
   canAnalyzeSnapshots,
-  formatInterpretationOutput,
   getMimeType,
   readFileAsBase64,
   runInterpret

package/dist/cli/core/snapshot-api-config.js

@@ -1,8 +1,6 @@
 import { existsSync, readFileSync } from "node:fs";
 import { dirname, join, resolve } from "node:path";
-import {
-  readAiConfig
-} from "./ai-config.js";
+import { readAiConfig } from "./ai-config.js";
 import { LIBRETTO_CONFIG_PATH, REPO_ROOT } from "./context.js";
 import {
   hasProviderCredentials,
@@ -154,9 +152,7 @@ function resolveSnapshotApiModel(config = readAiConfig()) {
 function resolveSnapshotApiModelOrThrow(config = readAiConfig()) {
   const selection = resolveSnapshotApiModel(config);
   if (!selection) {
-    throw new SnapshotApiUnavailableError(
-      noSnapshotApiConfiguredMessage()
-    );
+    throw new SnapshotApiUnavailableError(noSnapshotApiConfiguredMessage());
   }
   if (!hasProviderCredentials(selection.provider)) {
     throw new SnapshotApiUnavailableError(

package/dist/cli/core/telemetry.js

@@ -1,4 +1,9 @@
-import { appendFileSync, existsSync, readFileSync, writeFileSync } from "node:fs";
+import {
+  appendFileSync,
+  existsSync,
+  readFileSync,
+  writeFileSync
+} from "node:fs";
 import {
   getSessionActionsLogPath,
   getSessionNetworkLogPath
@@ -56,7 +61,10 @@ function clearNetworkLog(session) {
 function parentLogAction(session, entry) {
   try {
     const record = { ts: (/* @__PURE__ */ new Date()).toISOString(), ...entry };
-    appendFileSync(getSessionActionsLogPath(session), JSON.stringify(record) + "\n");
+    appendFileSync(
+      getSessionActionsLogPath(session),
+      JSON.stringify(record) + "\n"
+    );
   } catch {
   }
 }
@@ -79,7 +87,7 @@ function readActionLog(session, opts = {}) {
   if (opts.filter) {
     const re = new RegExp(opts.filter, "i");
     entries = entries.filter(
-      (e) => re.test(e.action) || re.test(e.selector || "") || re.test(e.value || "") || re.test(e.url || "")
+      (e) => re.test(e.action) || re.test(e.selector || "") || re.test(e.bestSemanticSelector || "") || re.test(e.targetSelector || "") || re.test((e.ancestorSelectors || []).join(" ")) || re.test(e.nearbyText || "") || re.test((e.composedPath || []).join(" ")) || re.test(e.value || "") || re.test(e.url || "")
     );
   }
   if (opts.pageId) {
@@ -94,8 +102,16 @@ function readActionLog(session, opts = {}) {
 function formatActionEntry(e) {
   const time = e.ts.replace(/.*T/, "").replace(/\.\d+Z$/, "");
   const src = e.source.toUpperCase().padEnd(5);
+  const displaySelector = e.bestSemanticSelector || e.selector;
   const parts = [`[${time}]`, `[${src}]`, e.action];
-  if (e.selector) parts.push(e.selector);
+  if (displaySelector) parts.push(displaySelector);
+  if (e.targetSelector && e.targetSelector !== displaySelector) {
+    parts.push(`target=${e.targetSelector}`);
+  }
+  if (e.nearbyText) parts.push(`text="${e.nearbyText}"`);
+  if (e.coordinates) {
+    parts.push(`@(${e.coordinates.x},${e.coordinates.y})`);
+  }
   if (e.value) parts.push(`"${e.value}"`);
   if (e.url) parts.push(e.url);
   if (e.duration != null) parts.push(`${e.duration}ms`);

package/dist/cli/framework/simple-cli.js

@@ -1,4 +1,6 @@
 import { z } from "zod";
+const EXPERIMENTAL_COMMAND_PREFIX = "experimental";
+const EXPERIMENTAL_GROUP_DESCRIPTION = "Experimental commands";
 function toCamelCase(input2) {
   return input2.replace(
     /-([a-zA-Z0-9])/g,
@@ -214,7 +216,9 @@ class SimpleCLIApp {
     if (isHelpFlag(argsBeforePassthrough[0])) {
       return [];
     }
-    const helpFlagIndex = argsBeforePassthrough.findIndex((arg) => isHelpFlag(arg));
+    const helpFlagIndex = argsBeforePassthrough.findIndex(
+      (arg) => isHelpFlag(arg)
+    );
     if (helpFlagIndex >= 0) {
       return argsBeforePassthrough.slice(0, helpFlagIndex);
     }
@@ -229,7 +233,10 @@ class SimpleCLIApp {
       }
       throw new Error(`Unknown command: ${args.join(" ")}`);
     }
-    const rawInput = this.parseCommandInput(command2, args.slice(command2.path.length));
+    const rawInput = this.parseCommandInput(
+      command2,
+      args.slice(command2.path.length)
+    );
     return {
       routeKey: command2.routeKey,
       rawInput
@@ -239,7 +246,9 @@ class SimpleCLIApp {
     const inputDefinition = command2.input?.getDefinition();
     if (!inputDefinition) {
       if (args.length > 0) {
-        throw new Error(`Unexpected arguments for ${this.name} ${command2.path.join(" ")}.`);
+        throw new Error(
+          `Unexpected arguments for ${this.name} ${command2.path.join(" ")}.`
+        );
       }
       return {
         positionals: [],
@@ -256,11 +265,17 @@ class SimpleCLIApp {
       const arg = args[index];
       if (arg === "--") {
         if (!passthroughEntry) {
-          throw new Error(`Unexpected "--" for ${this.name} ${command2.path.join(" ")}.`);
+          throw new Error(
+            `Unexpected "--" for ${this.name} ${command2.path.join(" ")}.`
+          );
         }
         named["--"] = args.slice(index + 1);
         break;
       }
+      if (arg === "-") {
+        positionals.push(arg);
+        continue;
+      }
       if (arg.startsWith("--")) {
         const [rawName, inlineValue] = splitNamedArg(arg.slice(2));
         const namedEntry = namedSpecs.get(rawName);
@@ -305,7 +320,11 @@ class SimpleCLIApp {
       }
       positionals.push(arg);
     }
-    validateParsedPositionals(command2, inputDefinition.positionals, positionals);
+    validateParsedPositionals(
+      command2,
+      inputDefinition.positionals,
+      positionals
+    );
     validateRequiredNamedArgs(inputDefinition.named, named);
     return {
       positionals,
@@ -403,7 +422,7 @@ class SimpleCLIApp {
   }
   renderRootHelp() {
     const lines = [`Usage: ${this.name} <command>`, "", "Commands:"];
-    for (const entry of this.getImmediateRouteEntries([])) {
+    for (const entry of this.getRootHelpEntries()) {
       lines.push(formatListEntry(entry.label, entry.description));
     }
     return lines.join("\n");
@@ -483,6 +502,41 @@ class SimpleCLIApp {
     }
     return entries;
   }
+  getRootHelpEntries() {
+    return this.getImmediateRouteEntries([]).filter((entry) => {
+      const token = entry.label.replace(/\s+<subcommand>$/, "");
+      const group2 = this.findGroupByPath([token]);
+      if (!group2) {
+        return true;
+      }
+      if (token === EXPERIMENTAL_COMMAND_PREFIX) {
+        return this.groupHasExperimentalCommand(group2.path);
+      }
+      return this.groupHasVisibleNonExperimentalCommand(group2.path);
+    });
+  }
+  groupHasVisibleNonExperimentalCommand(path) {
+    for (const routeEntry of this.routeEntries) {
+      if (routeEntry.kind !== "command") continue;
+      if (!pathStartsWith(routeEntry.path, path)) continue;
+      const command2 = this.findCommandByPath(routeEntry.path);
+      if (command2 && !command2.experimental) {
+        return true;
+      }
+    }
+    return false;
+  }
+  groupHasExperimentalCommand(path) {
+    for (const routeEntry of this.routeEntries) {
+      if (routeEntry.kind !== "command") continue;
+      if (!pathStartsWith(routeEntry.path, path)) continue;
+      const command2 = this.findCommandByPath(routeEntry.path);
+      if (command2?.experimental) {
+        return true;
+      }
+    }
+    return false;
+  }
   findBestMatchingCommand(args) {
     let bestMatch = null;
     for (const command2 of this.resolvedCommands.values()) {
@@ -506,10 +560,7 @@ class SimpleCLIApp {
 function splitNamedArg(arg) {
   const separatorIndex = arg.indexOf("=");
   if (separatorIndex < 0) return [arg, void 0];
-  return [
-    arg.slice(0, separatorIndex),
-    arg.slice(separatorIndex + 1)
-  ];
+  return [arg.slice(0, separatorIndex), arg.slice(separatorIndex + 1)];
 }
 function readNamedArgValue(args, index, rawName, displayName, spec, inlineValue, namedSpecs) {
   if (spec.kind === "flag") {
@@ -549,22 +600,29 @@ function buildNamedArgLookup(namedDefinition) {
   return lookup;
 }
 function validateParsedPositionals(command2, definitions, positionals) {
-  const variadicDefinition = definitions.find((definition) => definition.variadic);
+  const variadicDefinition = definitions.find(
+    (definition) => definition.variadic
+  );
   if (!variadicDefinition && positionals.length > definitions.length) {
     throw new Error(`Unexpected arguments for ${command2.path.join(" ")}.`);
   }
   definitions.forEach((definition, index) => {
     const value = definition.variadic ? positionals.slice(index) : positionals[index];
-    if (value !== void 0 && (!Array.isArray(value) || value.length > 0)) return;
+    if (value !== void 0 && (!Array.isArray(value) || value.length > 0))
+      return;
     if (schemaAcceptsUndefined(definition.schema)) return;
     throw new Error(`Missing required argument <${definition.key}>.`);
   });
 }
 function validateInputDefinition(definition) {
-  const variadicIndex = definition.positionals.findIndex((positional2) => positional2.variadic);
+  const variadicIndex = definition.positionals.findIndex(
+    (positional2) => positional2.variadic
+  );
   if (variadicIndex < 0) return;
   if (variadicIndex !== definition.positionals.length - 1) {
-    throw new Error("Variadic positional arguments must be the last positional.");
+    throw new Error(
+      "Variadic positional arguments must be the last positional."
+    );
   }
 }
 function validateRequiredNamedArgs(definitions, named) {
@@ -578,59 +636,105 @@ function validateRequiredNamedArgs(definitions, named) {
     throw new Error(`Missing required option --${flagName}.`);
   }
 }
-function resolveRouteTree(routes, parentPath = [], parentMiddlewares = []) {
+function resolveRouteTree(routes) {
+  const collected = collectRouteTree(routes);
+  const { groups, routeEntries } = buildResolvedRouteEntries(
+    collected.commands,
+    collected.groupDescriptions
+  );
+  return {
+    commands: collected.commands,
+    groups,
+    routeEntries
+  };
+}
+function collectRouteTree(routes, parentPath = [], parentMiddlewares = []) {
   const resolved = {
     commands: [],
-    groups: [],
-    routeEntries: []
+    groupDescriptions: /* @__PURE__ */ new Map()
   };
   for (const [token, routeValue] of Object.entries(routes)) {
     if (isGroup(routeValue)) {
       const groupPath = [...parentPath, token];
-      resolved.groups.push({
-        routeKey: pathToRouteKey(groupPath),
-        path: groupPath,
-        description: routeValue.description
-      });
-      resolved.routeEntries.push({
-        kind: "group",
-        path: groupPath
-      });
-      const nested = resolveRouteTree(
-        routeValue.routes,
-        groupPath,
-        [...parentMiddlewares, ...routeValue.middlewares]
+      resolved.groupDescriptions.set(
+        pathToRouteKey(groupPath),
+        routeValue.description
       );
+      const nested = collectRouteTree(routeValue.routes, groupPath, [
+        ...parentMiddlewares,
+        ...routeValue.middlewares
+      ]);
       resolved.commands.push(...nested.commands);
-      resolved.groups.push(...nested.groups);
-      resolved.routeEntries.push(...nested.routeEntries);
+      for (const [routeKey, description] of nested.groupDescriptions) {
+        resolved.groupDescriptions.set(routeKey, description);
+      }
       continue;
     }
     const command2 = routeValue.getDefinition();
     if (!command2.handler) {
-      throw new Error(`Command "${[...parentPath, token].join(" ")}" is missing a handler.`);
+      throw new Error(
+        `Command "${[...parentPath, token].join(" ")}" is missing a handler.`
+      );
     }
-    const path = [...parentPath, token];
+    const rawPath = [...parentPath, token];
+    const path = command2.config.experimental ? [EXPERIMENTAL_COMMAND_PREFIX, ...rawPath] : rawPath;
     resolved.commands.push({
       routeKey: pathToRouteKey(path),
       path,
       description: command2.config.description,
+      experimental: command2.config.experimental,
       input: command2.input,
-      middlewares: mergeInheritedMiddlewares(parentMiddlewares, command2.middlewares),
+      middlewares: mergeInheritedMiddlewares(
+        parentMiddlewares,
+        command2.middlewares
+      ),
       handler: command2.handler
     });
-    resolved.routeEntries.push({
+  }
+  return resolved;
+}
+function buildResolvedRouteEntries(commands, groupDescriptions) {
+  const groups = /* @__PURE__ */ new Map();
+  const routeEntries = [];
+  for (const command2 of commands) {
+    for (let depth = 1; depth < command2.path.length; depth += 1) {
+      const path = command2.path.slice(0, depth);
+      const routeKey = pathToRouteKey(path);
+      if (groups.has(routeKey)) continue;
+      groups.set(routeKey, {
+        routeKey,
+        path,
+        description: resolveGroupDescription(path, groupDescriptions)
+      });
+      routeEntries.push({
+        kind: "group",
+        path
+      });
+    }
+    routeEntries.push({
       kind: "command",
-      path
+      path: command2.path
     });
   }
-  return resolved;
+  return {
+    groups: [...groups.values()],
+    routeEntries
+  };
+}
+function resolveGroupDescription(path, groupDescriptions) {
+  if (path.length === 1 && path[0] === EXPERIMENTAL_COMMAND_PREFIX) {
+    return EXPERIMENTAL_GROUP_DESCRIPTION;
+  }
+  const originalPath = path[0] === EXPERIMENTAL_COMMAND_PREFIX ? path.slice(1) : path;
+  return groupDescriptions.get(pathToRouteKey(originalPath));
 }
 function mergeInheritedMiddlewares(parentMiddlewares, commandMiddlewares) {
   if (parentMiddlewares.length === 0) {
     return [...commandMiddlewares];
   }
-  if (commandMiddlewares.length >= parentMiddlewares.length && parentMiddlewares.every((middleware, index) => commandMiddlewares[index] === middleware)) {
+  if (commandMiddlewares.length >= parentMiddlewares.length && parentMiddlewares.every(
+    (middleware, index) => commandMiddlewares[index] === middleware
+  )) {
     return [...commandMiddlewares];
   }
   return [...parentMiddlewares, ...commandMiddlewares];
@@ -653,10 +757,7 @@ function buildInputNormalizer(definition) {
         spec.name ? toCamelCase(spec.name) : "",
         ...(spec.aliases ?? []).flatMap((alias) => {
           const normalizedAlias = normalizeNamedArgToken(alias);
-          return [
-            normalizedAlias,
-            toCamelCase(normalizedAlias)
-          ];
+          return [normalizedAlias, toCamelCase(normalizedAlias)];
         }),
         toKebabCase(key),
         key

package/dist/cli/router.js

@@ -1,29 +1,24 @@
 import { aiCommands } from "./commands/ai.js";
-import { createBrowserCommands } from "./commands/browser.js";
-import { createExecutionCommands } from "./commands/execution.js";
+import { browserCommands } from "./commands/browser.js";
+import { deployCommand } from "./commands/deploy.js";
+import { executionCommands } from "./commands/execution.js";
 import { initCommand } from "./commands/init.js";
 import { logCommands } from "./commands/logs.js";
-import { sessionOption } from "./commands/shared.js";
-import { createSnapshotCommand } from "./commands/snapshot.js";
+import { snapshotCommand } from "./commands/snapshot.js";
 import { SimpleCLI } from "./framework/simple-cli.js";
-function buildCLIRoutes(logger) {
-  return {
-    ...createBrowserCommands(logger),
-    ...createExecutionCommands(logger),
-    ...logCommands,
-    ai: aiCommands,
-    init: initCommand,
-    snapshot: createSnapshotCommand(logger)
-  };
-}
-function createCLIApp(logger) {
-  return SimpleCLI.define("libretto", buildCLIRoutes(logger), {
-    globalNamed: {
-      session: sessionOption()
-    }
-  });
+const cliRoutes = {
+  ...browserCommands,
+  deploy: deployCommand,
+  ...executionCommands,
+  ...logCommands,
+  ai: aiCommands,
+  init: initCommand,
+  snapshot: snapshotCommand
+};
+function createCLIApp() {
+  return SimpleCLI.define("libretto", cliRoutes);
 }
 export {
-  buildCLIRoutes,
+  cliRoutes,
   createCLIApp
 };

package/dist/cli/workers/run-integration-runtime.js

@@ -4,6 +4,8 @@ import { cwd } from "node:process";
 import { isAbsolute, resolve } from "node:path";
 import { pathToFileURL } from "node:url";
 import {
+  getWorkflowFromModuleExports,
+  getWorkflowsFromModuleExports,
   instrumentContext,
   launchBrowser
 } from "../../index.js";
@@ -14,9 +16,11 @@ import {
   getSessionNetworkLogPath,
   getSessionStatePath
 } from "../core/context.js";
-import { getPauseSignalPaths, removeSignalIfExists } from "../core/pause-signals.js";
+import {
+  getPauseSignalPaths,
+  removeSignalIfExists
+} from "../core/pause-signals.js";
 import { installSessionTelemetry } from "../core/session-telemetry.js";
-const LIBRETTO_WORKFLOW_BRAND = /* @__PURE__ */ Symbol.for("libretto.workflow");
 const FAILURE_HOLD_POLL_INTERVAL_MS = 250;
 const TSCONFIG_HINT = "TypeScript compilation failed. Pass --tsconfig <path> to run against a specific tsconfig.";
 function isTsxCompileError(error) {
@@ -41,7 +45,7 @@ function readSessionStatePid(session) {
   const statePath = getSessionStatePath(session);
   if (!existsSync(statePath)) return null;
   try {
-    return parseSessionStateContent(readFileSync(statePath, "utf8"), statePath).pid;
+    return parseSessionStateContent(readFileSync(statePath, "utf8"), statePath).pid ?? null;
   } catch {
     return null;
   }
@@ -64,11 +68,6 @@ async function waitForFailureSessionRelease(args) {
     );
   }
 }
-function isLoadedLibrettoWorkflow(value) {
-  if (!value || typeof value !== "object") return false;
-  const candidate = value;
-  return candidate[LIBRETTO_WORKFLOW_BRAND] === true && typeof candidate.run === "function" && !!candidate.metadata && typeof candidate.metadata === "object";
-}
 function resolveLocalAuthProfilePath(domain) {
   return getProfilePath(normalizeDomain(domain));
 }
@@ -90,7 +89,7 @@ function getAbsoluteIntegrationPath(integrationPath) {
   }
   return absolutePath;
 }
-async function loadWorkflowExport(absolutePath, exportName) {
+async function loadWorkflowByName(absolutePath, workflowName) {
   let loadedModule;
   try {
     loadedModule = await import(pathToFileURL(absolutePath).href);
@@ -102,37 +101,17 @@ ${TSCONFIG_HINT}` : "";
       `Failed to import integration module at ${absolutePath}: ${message}${compileHint}`
     );
   }
-  const targetExport = loadedModule[exportName];
-  if (!targetExport) {
-    const availableExports = Object.keys(loadedModule);
-    const detail = availableExports.length > 0 ? ` Available exports: ${availableExports.join(", ")}` : " The module has no exports.";
-    throw new Error(
-      `Export "${exportName}" was not found in ${absolutePath}.${detail}`
-    );
+  const workflow = getWorkflowFromModuleExports(loadedModule, workflowName);
+  if (workflow) {
+    return workflow;
   }
-  if (!isLoadedLibrettoWorkflow(targetExport)) {
-    throw new Error(
-      [
-        `Export "${exportName}" in ${absolutePath} is not a valid Libretto workflow.`,
-        "",
-        'A workflow must be created using the workflow() function from "libretto":',
-        "",
-        '  import { workflow } from "libretto";',
-        "",
-        `  export const ${exportName} = workflow<InputType, OutputType>(`,
-        "    {},",
-        "    async (ctx, input) => {",
-        "      // ctx.page     \u2014 Playwright Page instance",
-        "      // ctx.logger   \u2014 MinimalLogger",
-        "      // ctx.services \u2014 injected dependencies (generic, default {})",
-        "      // input        \u2014 JSON-serializable input matching InputType",
-        "      return output; // must match OutputType",
-        "    },",
-        "  );"
-      ].join("\n")
-    );
-  }
-  return targetExport;
+  const availableWorkflows = getWorkflowsFromModuleExports(loadedModule).map(
+    (candidate) => candidate.name
+  );
+  const detail = availableWorkflows.length > 0 ? ` Available workflows: ${availableWorkflows.join(", ")}` : ' No workflows found in this file. Export a workflow() instance from "libretto" directly or via `export const workflows = { ... }`.';
+  throw new Error(
+    `Workflow "${workflowName}" not found in ${absolutePath}.${detail}`
+  );
 }
 async function installHeadedWorkflowVisualization(args) {
   await (args.instrument ?? instrumentContext)(args.context, {
@@ -143,7 +122,7 @@ async function installHeadedWorkflowVisualization(args) {
 async function runIntegrationInternal(args, options) {
   const { logger } = options;
   const absolutePath = getAbsoluteIntegrationPath(args.integrationPath);
-  const workflow = await loadWorkflowExport(absolutePath, args.exportName);
+  const workflow = await loadWorkflowByName(absolutePath, args.workflowName);
   const signalPaths = getPauseSignalPaths(args.session);
   await removeSignalIfExists(signalPaths.pausedSignalPath);
   await removeSignalIfExists(signalPaths.resumeSignalPath);
@@ -151,11 +130,11 @@ async function runIntegrationInternal(args, options) {
   await removeSignalIfExists(signalPaths.failedSignalPath);
   const restoreStdout = mirrorStdoutToFile(signalPaths.outputSignalPath);
   console.log(
-    `Running integration "${args.exportName}" from ${absolutePath} (${args.headless ? "headless" : "headed"})...`
+    `Running workflow "${args.workflowName}" from ${absolutePath} (${args.headless ? "headless" : "headed"})...`
   );
   const integrationLogger = logger.withScope("integration-run", {
     integrationPath: absolutePath,
-    integrationExport: args.exportName,
+    workflowName: args.workflowName,
     session: args.session
   });
   const authProfileDomain = args.authProfileDomain;
@@ -172,7 +151,8 @@ async function runIntegrationInternal(args, options) {
   const browserSession = await launchBrowser({
     sessionName: args.session,
     headless: args.headless,
-    storageStatePath
+    storageStatePath,
+    viewport: args.viewport
   });
   if (!args.headless && args.visualize !== false) {
     await installHeadedWorkflowVisualization({
@@ -194,9 +174,9 @@ async function runIntegrationInternal(args, options) {
     }
   });
   const workflowContext = {
+    session: args.session,
     logger: integrationLogger,
-    page: browserSession.page,
-    services: {}
+    page: browserSession.page
   };
   try {
     try {

package/dist/cli/workers/run-integration-worker-protocol.js

@@ -1,12 +1,13 @@
 import { z } from "zod";
 const RunIntegrationWorkerRequestSchema = z.object({
   integrationPath: z.string().min(1),
-  exportName: z.string().min(1),
+  workflowName: z.string().min(1),
   session: z.string().min(1),
   params: z.unknown(),
   headless: z.boolean(),
   visualize: z.boolean().default(true),
-  authProfileDomain: z.string().optional()
+  authProfileDomain: z.string().optional(),
+  viewport: z.object({ width: z.number(), height: z.number() }).optional()
 });
 export {
   RunIntegrationWorkerRequestSchema

package/dist/cli/workers/run-integration-worker.js

@@ -4,10 +4,7 @@ import {
   RunIntegrationWorkerRequestSchema
 } from "./run-integration-worker-protocol.js";
 import { runIntegrationFromFileInWorker } from "./run-integration-runtime.js";
-import {
-  ensureLibrettoSetup,
-  withSessionLogger
-} from "../core/context.js";
+import { ensureLibrettoSetup, withSessionLogger } from "../core/context.js";
 import { getPauseSignalPaths } from "../core/pause-signals.js";
 function parseWorkerRequest(argv) {
   const rawPayload = argv[2];