libretto 0.5.2 → 0.5.3-experimental.1

package/README.md

@@ -63,8 +63,9 @@ You can also use Libretto directly from the command line. All commands accept `-
 npx libretto init                          # interactive; run yourself, not through an agent
 npx libretto open <url>                    # launch browser and open a URL (headed by default)
 npx libretto snapshot --objective "..." --context "..."  # capture PNG + HTML and analyze with an LLM
-npx libretto exec "<code>"                 # execute Playwright TypeScript against the open page
-npx libretto run <file> <export>           # run an exported workflow from a file
+npx libretto exec "<code>"                 # execute Playwright TypeScript against the open page (single quoted argument)
+echo "<code>" | npx libretto exec -        # intentionally read Playwright TypeScript from stdin
+npx libretto run <file> <workflowName>     # run an exported workflow from a file
 npx libretto resume                        # resume a paused workflow
 npx libretto network                       # view captured network requests
 npx libretto actions                       # view captured user/agent actions

package/dist/cli/commands/deploy.js

@@ -0,0 +1,162 @@
+import { execSync } from "node:child_process";
+import {
+  cpSync,
+  mkdirSync,
+  readFileSync
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { join, resolve } from "node:path";
+import { z } from "zod";
+import { SimpleCLI } from "../framework/simple-cli.js";
+function getConfig() {
+  const apiUrl = process.env.LIBRETTO_API_URL;
+  const apiKey = process.env.LIBRETTO_API_KEY;
+  if (!apiUrl) {
+    throw new Error(
+      "LIBRETTO_API_URL environment variable is required."
+    );
+  }
+  if (!apiKey) {
+    throw new Error(
+      "LIBRETTO_API_KEY environment variable is required."
+    );
+  }
+  return { apiUrl: apiUrl.replace(/\/$/, ""), apiKey };
+}
+async function postJson(apiUrl, apiKey, path, input = {}) {
+  return fetch(`${apiUrl}${path}`, {
+    method: "POST",
+    headers: {
+      "x-api-key": apiKey,
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify({ json: input })
+  });
+}
+function buildSourceTarball(sourceDir) {
+  const absSourceDir = resolve(sourceDir);
+  const pkgJsonPath = join(absSourceDir, "package.json");
+  try {
+    readFileSync(pkgJsonPath, "utf8");
+  } catch {
+    throw new Error(
+      `No package.json found in ${absSourceDir}. Deploy source must contain a package.json.`
+    );
+  }
+  const dir = join(tmpdir(), `libretto-deploy-${Date.now()}`);
+  mkdirSync(dir, { recursive: true });
+  cpSync(absSourceDir, dir, { recursive: true });
+  const tarPath = join(dir, "source.tar.gz");
+  execSync(
+    `tar czf "${tarPath}" --exclude=source.tar.gz --exclude=node_modules --exclude=.git -C "${dir}" .`
+  );
+  return readFileSync(tarPath).toString("base64");
+}
+async function pollDeployment(apiUrl, apiKey, deploymentId, pollIntervalMs, maxWaitMs) {
+  const start = Date.now();
+  let status = "building";
+  let deployment;
+  while (status === "building" && Date.now() - start < maxWaitMs) {
+    await new Promise((r) => setTimeout(r, pollIntervalMs));
+    const res = await postJson(apiUrl, apiKey, "/v1/deployments/get", {
+      id: deploymentId
+    });
+    const body = await res.json();
+    if (res.status !== 200) {
+      throw new Error(
+        `Failed to get deployment status (${res.status}): ${JSON.stringify(body)}`
+      );
+    }
+    status = body.json.status;
+    deployment = body.json;
+    process.stdout.write(".");
+  }
+  console.log();
+  if (!deployment) {
+    throw new Error("Deployment timed out before receiving a status update.");
+  }
+  return deployment;
+}
+const deployInput = SimpleCLI.input({
+  positionals: [
+    SimpleCLI.positional("sourceDir", z.string().default("."), {
+      help: "Path to source directory (default: current directory)"
+    })
+  ],
+  named: {
+    name: SimpleCLI.option(z.string(), {
+      help: "Deployment name"
+    }),
+    description: SimpleCLI.option(z.string().optional(), {
+      help: "Deployment description"
+    }),
+    entryPoint: SimpleCLI.option(z.string().optional(), {
+      name: "entry-point",
+      help: "Entry point file (default: index.ts)"
+    })
+  }
+});
+const deployCommand = SimpleCLI.command({
+  description: "[experimental] Deploy workflows to the hosted platform",
+  experimental: true
+}).input(deployInput).handle(async ({ input }) => {
+  const { apiUrl, apiKey } = getConfig();
+  console.log(`Packaging source from ${resolve(input.sourceDir)}...`);
+  const source = buildSourceTarball(input.sourceDir);
+  const createPayload = {
+    name: input.name,
+    source
+  };
+  if (input.description) createPayload.description = input.description;
+  if (input.entryPoint) createPayload.entry_point = input.entryPoint;
+  console.log("Uploading deployment...");
+  const res = await postJson(
+    apiUrl,
+    apiKey,
+    "/v1/deployments/create",
+    createPayload
+  );
+  const body = await res.json();
+  if (res.status !== 200) {
+    throw new Error(
+      `Failed to create deployment (${res.status}): ${JSON.stringify(body)}`
+    );
+  }
+  const { deployment_id, name, version, status } = body.json;
+  console.log(
+    `Deployment created: ${name} v${version} (${deployment_id})`
+  );
+  console.log(`Status: ${status}`);
+  if (status === "building") {
+    process.stdout.write("Waiting for build");
+    const deployment = await pollDeployment(
+      apiUrl,
+      apiKey,
+      deployment_id,
+      1e4,
+      5 * 60 * 1e3
+    );
+    if (deployment.status === "failed") {
+      throw new Error(
+        `Build failed: ${deployment.build_error ?? "unknown error"}`
+      );
+    }
+    if (deployment.status === "ready") {
+      console.log(`Build complete.`);
+      if (deployment.workflows?.length) {
+        console.log(
+          `Workflows: ${deployment.workflows.join(", ")}`
+        );
+      }
+    } else {
+      console.log(
+        `Build still in progress (timed out waiting). Check status with deployment ID: ${deployment_id}`
+      );
+    }
+  }
+  return deployment_id;
+});
+export {
+  deployCommand,
+  deployInput
+};

package/dist/cli/commands/execution.js

@@ -445,9 +445,10 @@ async function runIntegrationFromFile(args, logger) {
   );
   const payload = JSON.stringify({
     integrationPath: args.integrationPath,
-    exportName: args.exportName,
+    workflowName: args.workflowName,
     session: args.session,
     params: args.params,
+    credentials: args.credentials,
     headless: args.headless,
     visualize: args.visualize,
     authProfileDomain: args.authProfileDomain,
@@ -496,11 +497,19 @@ Browser is still open. You can use \`exec\` to inspect it. Call \`run\` to re-ru
   setSessionStatus(args.session, "completed", logger);
   console.log("Integration completed.");
 }
+function readStdinSync() {
+  if (process.stdin.isTTY === true) return null;
+  try {
+    const content = readFileSync(0, "utf8");
+    return content.trim().length > 0 ? content : null;
+  } catch {
+    return null;
+  }
+}
 const execInput = SimpleCLI.input({
   positionals: [
-    SimpleCLI.positional("codeParts", z.array(z.string()).default([]), {
-      help: "Playwright TypeScript code to execute",
-      variadic: true
+    SimpleCLI.positional("code", z.string().optional(), {
+      help: "Playwright TypeScript code to execute"
     })
   ],
   named: {
@@ -511,28 +520,36 @@ const execInput = SimpleCLI.input({
     page: pageOption()
   }
 }).refine(
-  (input) => input.codeParts.length > 0,
-  `Usage: libretto exec <code> [--session <name>] [--visualize]`
+  (input) => input.code !== void 0,
+  `Usage: libretto exec <code|-> [--session <name>] [--visualize]
+       echo '<code>' | libretto exec - [--session <name>] [--visualize]`
 );
 const execCommand = SimpleCLI.command({
   description: "Execute Playwright TypeScript code"
 }).input(execInput).use(withRequiredSession()).handle(async ({ input, ctx }) => {
+  const code = input.code;
+  const codeFromArgsOrStdin = code === "-" ? readStdinSync() : code;
+  if (codeFromArgsOrStdin === null) {
+    throw new Error(
+      "Missing stdin input for `exec -`. Pipe Playwright code into stdin."
+    );
+  }
   await runExec(
-    input.codeParts.join(" "),
+    codeFromArgsOrStdin,
     ctx.session,
     ctx.logger,
     input.visualize,
     input.page
   );
 });
-const runUsage = `Usage: libretto run <integrationFile> <integrationExport> [--params <json> | --params-file <path>] [--tsconfig <path>] [--headed|--headless] [--no-visualize] [--viewport WxH]`;
+const runUsage = `Usage: libretto run <integrationFile> <workflowName> [--params <json> | --params-file <path>] [--credentials <json>] [--tsconfig <path>] [--headed|--headless] [--no-visualize] [--viewport WxH]`;
 const runInput = SimpleCLI.input({
   positionals: [
     SimpleCLI.positional("integrationFile", z.string().optional(), {
       help: "Path to the integration file"
     }),
-    SimpleCLI.positional("integrationExport", z.string().optional(), {
-      help: "Named workflow export to run"
+    SimpleCLI.positional("workflowName", z.string().optional(), {
+      help: "Workflow name to run (from workflow(name, handler))"
     })
   ],
   named: {
@@ -544,6 +561,9 @@ const runInput = SimpleCLI.input({
       name: "params-file",
       help: "Path to a JSON params file"
     }),
+    credentials: SimpleCLI.option(z.string().optional(), {
+      help: "Inline JSON credentials passed to ctx.credentials"
+    }),
     tsconfig: SimpleCLI.option(z.string().optional(), {
       help: "Path to a tsconfig used for workflow module resolution"
     }),
@@ -562,7 +582,7 @@ const runInput = SimpleCLI.input({
     })
   }
 }).refine(
-  (input) => Boolean(input.integrationFile && input.integrationExport),
+  (input) => Boolean(input.integrationFile && input.workflowName),
   runUsage
 ).refine(
   (input) => !(input.params && input.paramsFile),
@@ -594,6 +614,11 @@ const runCommand = SimpleCLI.command({
   await stopExistingFailedRunSession(ctx.session, ctx.logger);
   assertSessionAvailableForStart(ctx.session, ctx.logger);
   const params = resolveRunParams(input.params, input.paramsFile);
+  const rawCredentials = input.credentials ? parseJsonArg("--credentials", input.credentials) : void 0;
+  if (rawCredentials !== void 0 && (typeof rawCredentials !== "object" || rawCredentials === null || Array.isArray(rawCredentials))) {
+    throw new Error(`--credentials must be a JSON object (e.g., '{"key": "value"}').`);
+  }
+  const credentials = rawCredentials;
   const headlessMode = input.headed ? false : input.headless ? true : void 0;
   const visualize = !input.noVisualize;
   const viewport = resolveViewport(
@@ -603,9 +628,10 @@ const runCommand = SimpleCLI.command({
   await runIntegrationFromFile(
     {
       integrationPath: input.integrationFile,
-      exportName: input.integrationExport,
+      workflowName: input.workflowName,
       session: ctx.session,
       params,
+      credentials,
       tsconfigPath: input.tsconfig,
       headless: headlessMode ?? false,
       visualize,

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

@@ -270,6 +270,10 @@ class SimpleCLIApp {
         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);
@@ -489,6 +493,7 @@ class SimpleCLIApp {
         continue;
       }
       const command2 = this.findCommandByPath(routeEntry.path);
+      if (command2?.experimental) continue;
       entries.push({
         label: token,
         description: command2?.description
@@ -633,6 +638,7 @@ function resolveRouteTree(routes, parentPath = [], parentMiddlewares = []) {
       routeKey: pathToRouteKey(path),
       path,
       description: command2.config.description,
+      experimental: command2.config.experimental,
       input: command2.input,
       middlewares: mergeInheritedMiddlewares(
         parentMiddlewares,

package/dist/cli/router.js

@@ -1,5 +1,6 @@
 import { aiCommands } from "./commands/ai.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";
@@ -11,7 +12,8 @@ const cliRoutes = {
   ...logCommands,
   ai: aiCommands,
   init: initCommand,
-  snapshot: snapshotCommand
+  snapshot: snapshotCommand,
+  deploy: deployCommand
 };
 function createCLIApp() {
   return SimpleCLI.define("libretto", cliRoutes);

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";
@@ -19,7 +21,6 @@ import {
   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) {
@@ -67,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";
-}
 function resolveLocalAuthProfilePath(domain) {
   return getProfilePath(normalizeDomain(domain));
 }
@@ -93,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);
@@ -105,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}`
-    );
-  }
-  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.session  \u2014 libretto session name",
-        "      // 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")
-    );
+  const workflow = getWorkflowFromModuleExports(loadedModule, workflowName);
+  if (workflow) {
+    return workflow;
   }
-  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, {
@@ -146,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);
@@ -154,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;
@@ -201,7 +177,8 @@ async function runIntegrationInternal(args, options) {
     session: args.session,
     logger: integrationLogger,
     page: browserSession.page,
-    services: {}
+    services: {},
+    credentials: args.credentials
   };
   try {
     try {

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

@@ -1,9 +1,10 @@
 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(),
+  credentials: z.record(z.string(), z.unknown()).optional(),
   headless: z.boolean(),
   visualize: z.boolean().default(true),
   authProfileDomain: z.string().optional(),

package/dist/index.d.ts

@@ -14,7 +14,7 @@ export { InstrumentationOptions, InstrumentedPage, installInstrumentation, instr
 export { GhostCursorOptions, ensureGhostCursor, ghostClick, hideGhostCursor, moveGhostCursor } from './shared/visualization/ghost-cursor.js';
 export { HighlightOptions, clearHighlights, ensureHighlightLayer, showHighlight } from './shared/visualization/highlight.js';
 export { BrowserSession, LaunchBrowserArgs, launchBrowser } from './shared/run/browser.js';
-export { LIBRETTO_WORKFLOW_BRAND, LibrettoWorkflow, LibrettoWorkflowContext, LibrettoWorkflowHandler, workflow } from './shared/workflow/workflow.js';
+export { ExportedLibrettoWorkflow, LIBRETTO_WORKFLOW_BRAND, LibrettoWorkflow, LibrettoWorkflowContext, LibrettoWorkflowHandler, getWorkflowFromModuleExports, getWorkflowsFromModuleExports, isLibrettoWorkflow, workflow } from './shared/workflow/workflow.js';
 import 'zod';
 import 'ai';
 import 'playwright';

package/dist/index.js

@@ -54,6 +54,9 @@ import {
   launchBrowser
 } from "./shared/run/api.js";
 import {
+  getWorkflowFromModuleExports,
+  getWorkflowsFromModuleExports,
+  isLibrettoWorkflow,
   LibrettoWorkflow,
   LIBRETTO_WORKFLOW_BRAND,
   workflow
@@ -92,11 +95,14 @@ export {
   ensureHighlightLayer,
   executeRecoveryAgent,
   extractFromPage,
+  getWorkflowFromModuleExports,
+  getWorkflowsFromModuleExports,
   ghostClick,
   hideGhostCursor,
   installInstrumentation,
   instrumentContext,
   instrumentPage,
+  isLibrettoWorkflow,
   jsonlConsoleSink,
   launchBrowser,
   moveGhostCursor,

package/dist/shared/workflow/workflow.d.ts

@@ -7,14 +7,25 @@ type LibrettoWorkflowContext<S = {}> = {
     page: Page;
     logger: MinimalLogger;
     services: S;
+    credentials?: Record<string, unknown>;
 };
 type LibrettoWorkflowHandler<Input = unknown, Output = unknown, S = {}> = (ctx: LibrettoWorkflowContext<S>, input: Input) => Promise<Output>;
 declare class LibrettoWorkflow<Input = unknown, Output = unknown, S = {}> {
     readonly [LIBRETTO_WORKFLOW_BRAND] = true;
+    readonly name: string;
     private readonly handler;
-    constructor(handler: LibrettoWorkflowHandler<Input, Output, S>);
+    constructor(name: string, handler: LibrettoWorkflowHandler<Input, Output, S>);
     run(ctx: LibrettoWorkflowContext<S>, input: Input): Promise<Output>;
 }
-declare function workflow<Input = unknown, Output = unknown, S = {}>(handler: LibrettoWorkflowHandler<Input, Output, S>): LibrettoWorkflow<Input, Output, S>;
+type ExportedLibrettoWorkflow = {
+    readonly [LIBRETTO_WORKFLOW_BRAND]: true;
+    readonly name: string;
+    run: (ctx: LibrettoWorkflowContext, input: unknown) => Promise<unknown>;
+};
+type WorkflowModuleExports = Record<string, unknown>;
+declare function isLibrettoWorkflow(value: unknown): value is ExportedLibrettoWorkflow;
+declare function getWorkflowsFromModuleExports(moduleExports: WorkflowModuleExports): ExportedLibrettoWorkflow[];
+declare function getWorkflowFromModuleExports(moduleExports: WorkflowModuleExports, workflowName: string): ExportedLibrettoWorkflow | null;
+declare function workflow<Input = unknown, Output = unknown, S = {}>(name: string, handler: LibrettoWorkflowHandler<Input, Output, S>): LibrettoWorkflow<Input, Output, S>;
 
-export { LIBRETTO_WORKFLOW_BRAND, LibrettoWorkflow, type LibrettoWorkflowContext, type LibrettoWorkflowHandler, workflow };
+export { type ExportedLibrettoWorkflow, LIBRETTO_WORKFLOW_BRAND, LibrettoWorkflow, type LibrettoWorkflowContext, type LibrettoWorkflowHandler, getWorkflowFromModuleExports, getWorkflowsFromModuleExports, isLibrettoWorkflow, workflow };

package/dist/shared/workflow/workflow.js

@@ -1,19 +1,66 @@
 const LIBRETTO_WORKFLOW_BRAND = /* @__PURE__ */ Symbol.for("libretto.workflow");
 class LibrettoWorkflow {
   [LIBRETTO_WORKFLOW_BRAND] = true;
+  name;
   handler;
-  constructor(handler) {
+  constructor(name, handler) {
+    this.name = name;
     this.handler = handler;
   }
   async run(ctx, input) {
     return this.handler(ctx, input);
   }
 }
-function workflow(handler) {
-  return new LibrettoWorkflow(handler);
+function isLibrettoWorkflow(value) {
+  if (!value || typeof value !== "object") return false;
+  const candidate = value;
+  return candidate[LIBRETTO_WORKFLOW_BRAND] === true && typeof candidate.name === "string" && typeof candidate.run === "function";
+}
+function addWorkflowOrThrow(workflowsByName, value) {
+  if (!isLibrettoWorkflow(value)) return;
+  const existing = workflowsByName.get(value.name);
+  if (existing && existing !== value) {
+    throw new Error(
+      `Duplicate workflow name: "${value.name}". Each workflow() call must use a unique name.`
+    );
+  }
+  workflowsByName.set(value.name, value);
+}
+function getWorkflowsFromModuleExports(moduleExports) {
+  const workflowsByName = /* @__PURE__ */ new Map();
+  for (const [exportName, value] of Object.entries(moduleExports)) {
+    if (exportName === "workflows" && value && typeof value === "object") {
+      if (isLibrettoWorkflow(value)) {
+        addWorkflowOrThrow(workflowsByName, value);
+      } else {
+        for (const nestedValue of Object.values(
+          value
+        )) {
+          addWorkflowOrThrow(workflowsByName, nestedValue);
+        }
+      }
+      continue;
+    }
+    addWorkflowOrThrow(workflowsByName, value);
+  }
+  return [...workflowsByName.values()];
+}
+function getWorkflowFromModuleExports(moduleExports, workflowName) {
+  for (const workflow2 of getWorkflowsFromModuleExports(moduleExports)) {
+    if (workflow2.name === workflowName) {
+      return workflow2;
+    }
+  }
+  return null;
+}
+function workflow(name, handler) {
+  return new LibrettoWorkflow(name, handler);
 }
 export {
   LIBRETTO_WORKFLOW_BRAND,
   LibrettoWorkflow,
+  getWorkflowFromModuleExports,
+  getWorkflowsFromModuleExports,
+  isLibrettoWorkflow,
   workflow
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "libretto",
-  "version": "0.5.2",
+  "version": "0.5.3-experimental.1",
   "description": "AI-powered browser automation library and CLI built on Playwright",
   "license": "MIT",
   "repository": {
@@ -36,11 +36,9 @@
     "build": "tsup --config tsup.config.ts",
     "type-check": "tsc --noEmit",
     "test": "pnpm run build && vitest run",
-    "eval": "pnpm run build && vitest run --config vitest.evals.config.ts",
-    "benchmark": "pnpm run build && tsx benchmarks/run.ts",
     "test:watch": "vitest",
     "cli": "node dist/index.js",
-    "prepare-release": "bash ./scripts/prepare-release.sh",
+    "generate-changelog": "tsx scripts/generate-changelog.ts",
     "prepack": "pnpm run build"
   },
   "peerDependencies": {
@@ -69,8 +67,13 @@
     "@ai-sdk/google-vertex": "^4.0.80",
     "@ai-sdk/openai": "^3.0.41",
     "@anthropic-ai/claude-agent-sdk": "^0.2.75",
+    "@mariozechner/pi-agent-core": "^0.62.0",
+    "@mariozechner/pi-ai": "^0.62.0",
+    "@mariozechner/pi-coding-agent": "^0.62.0",
+    "@sinclair/typebox": "^0.34.48",
     "@types/node": "^25.5.0",
     "glimpseui": "^0.5.1",
+    "google-auth-library": "^10.6.1",
     "openai": "^6.29.0",
     "tsup": "^8.5.1",
     "typescript": "^5.9.3",

package/scripts/check-skills-sync.mjs

@@ -6,7 +6,7 @@ import { fileURLToPath } from "node:url";
 import { compareSkillDirs, SKILL_DIRS } from "./skills-libretto.mjs";
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
-const repoRoot = join(__dirname, "..");
+const repoRoot = join(__dirname, "..", "..", "..");
 const result = compareSkillDirs(repoRoot);
 
 if (result.ok) {