libretto 0.5.3-experimental.4 → 0.5.3-experimental.6

package/dist/cli/commands/deploy.js

@@ -1,6 +1,10 @@
+import { randomBytes } from "node:crypto";
 import { z } from "zod";
 import { buildHostedDeployTarball } from "../core/deploy-artifact.js";
 import { SimpleCLI } from "../framework/simple-cli.js";
+function generateDeploymentName() {
+  return `deploy-${Date.now().toString(36)}-${randomBytes(4).toString("hex")}`;
+}
 function getConfig() {
   const apiUrl = process.env.LIBRETTO_API_URL;
   const apiKey = process.env.LIBRETTO_API_KEY;
@@ -58,9 +62,6 @@ const deployInput = SimpleCLI.input({
     })
   ],
   named: {
-    name: SimpleCLI.option(z.string(), {
-      help: "Deployment name"
-    }),
     description: SimpleCLI.option(z.string().optional(), {
       help: "Deployment description"
     }),
@@ -83,15 +84,15 @@ const deployCommand = SimpleCLI.command({
   experimental: true
 }).input(deployInput).handle(async ({ input }) => {
   const { apiUrl, apiKey } = getConfig();
+  const deploymentName = generateDeploymentName();
   console.log("Bundling hosted deployment artifact...");
   const { entryPoint, source } = await buildHostedDeployTarball({
     additionalExternals: input.external,
-    deploymentName: input.name,
+    deploymentName,
     entryPoint: input.entryPoint,
     sourceDir: input.sourceDir
   });
   const createPayload = {
-    name: input.name,
     source,
     entry_point: entryPoint
   };
@@ -109,10 +110,8 @@ const deployCommand = SimpleCLI.command({
       `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})`
-  );
+  const { deployment_id, status } = body.json;
+  console.log(`Deployment created: ${deployment_id}`);
   console.log(`Status: ${status}`);
   if (status === "building") {
     process.stdout.write("Waiting for build");

package/dist/cli/core/deploy-artifact.js

@@ -1,6 +1,7 @@
 import { execFileSync } from "node:child_process";
 import { createHash } from "node:crypto";
 import {
+  cpSync,
   existsSync,
   mkdirSync,
   mkdtempSync,
@@ -39,6 +40,9 @@ const SOURCE_FILE_EXTENSIONS = [
   "/index.cjs"
 ];
 const CURRENT_LIBRETTO_VERSION = readCurrentLibrettoVersion();
+const CURRENT_LIBRETTO_PACKAGE_DIR = fileURLToPath(
+  new URL("../../..", import.meta.url)
+);
 function readCurrentLibrettoVersion() {
   const packageJsonPath = fileURLToPath(
     new URL("../../../package.json", import.meta.url)
@@ -103,7 +107,9 @@ function readWorkspacePatterns(rootDir) {
   if (existsSync(pnpmWorkspacePath)) {
     const patterns = [];
     let inPackagesBlock = false;
-    for (const rawLine of readFileSync(pnpmWorkspacePath, "utf8").split(/\r?\n/)) {
+    for (const rawLine of readFileSync(pnpmWorkspacePath, "utf8").split(
+      /\r?\n/
+    )) {
       const trimmed = rawLine.trim();
       if (!inPackagesBlock) {
         if (trimmed === "packages:") {
@@ -233,7 +239,11 @@ function resolveExportTarget(exportValue, packageDir, replacement) {
     if (!(condition in record)) {
       continue;
     }
-    const resolved = resolveExportTarget(record[condition], packageDir, replacement);
+    const resolved = resolveExportTarget(
+      record[condition],
+      packageDir,
+      replacement
+    );
     if (resolved) {
       return resolved;
     }
@@ -250,7 +260,7 @@ function resolveExportsSubpath(exportsField, packageDir, subpath) {
   if (!exportsField) {
     return null;
   }
-  if (subpath === ".") {
+  if (subpath === "." && (typeof exportsField === "string" || Array.isArray(exportsField))) {
     const rootExport = resolveExportTarget(exportsField, packageDir);
     if (rootExport) {
       return rootExport;
@@ -260,7 +270,9 @@ function resolveExportsSubpath(exportsField, packageDir, subpath) {
     return null;
   }
   const record = exportsField;
-  const hasExplicitSubpathKeys = Object.keys(record).some((key) => key.startsWith("."));
+  const hasExplicitSubpathKeys = Object.keys(record).some(
+    (key) => key.startsWith(".")
+  );
   if (!hasExplicitSubpathKeys) {
     return subpath === "." ? resolveExportTarget(record, packageDir) : null;
   }
@@ -278,7 +290,10 @@ function resolveExportsSubpath(exportsField, packageDir, subpath) {
     if (!subpath.startsWith(prefix) || !subpath.endsWith(suffix)) {
       continue;
     }
-    const replacement = subpath.slice(prefix.length, subpath.length - suffix.length);
+    const replacement = subpath.slice(
+      prefix.length,
+      subpath.length - suffix.length
+    );
     const resolved = resolveExportTarget(value, packageDir, replacement);
     if (resolved) {
       return resolved;
@@ -287,7 +302,11 @@ function resolveExportsSubpath(exportsField, packageDir, subpath) {
   return null;
 }
 function resolveWorkspaceSourcePath(info, subpath) {
-  const viaExports = resolveExportsSubpath(info.manifest.exports, info.dir, subpath);
+  const viaExports = resolveExportsSubpath(
+    info.manifest.exports,
+    info.dir,
+    subpath
+  );
   if (viaExports) {
     return viaExports;
   }
@@ -318,11 +337,17 @@ function workspaceSourcePlugin(workspacePackages, externalPackages) {
         if (externalPackages.has(args.path)) {
           return null;
         }
-        const match = findMatchingWorkspacePackage(args.path, workspacePackages);
+        const match = findMatchingWorkspacePackage(
+          args.path,
+          workspacePackages
+        );
         if (!match) {
           return null;
         }
-        const resolvedPath = resolveWorkspaceSourcePath(match.info, match.subpath);
+        const resolvedPath = resolveWorkspaceSourcePath(
+          match.info,
+          match.subpath
+        );
         if (!resolvedPath) {
           throw new Error(
             `Unable to resolve workspace import "${args.path}" from ${match.info.dir}.`
@@ -378,17 +403,12 @@ function resolveDependencyVersion(sourceDir, packageName, fallbackVersion) {
 }
 function writeDeployManifest(args) {
   const dependencies = Object.fromEntries(
-    [
-      ...BUILT_IN_MANIFEST_DEPENDENCIES,
-      ...args.additionalExternals
-    ].map((packageName) => [
-      packageName,
-      resolveDependencyVersion(
-        args.sourceDir,
+    [...BUILT_IN_MANIFEST_DEPENDENCIES, ...args.additionalExternals].map(
+      (packageName) => [
         packageName,
-        packageName === "libretto" ? CURRENT_LIBRETTO_VERSION : void 0
-      )
-    ])
+        packageName === "libretto" ? args.librettoDependency : resolveDependencyVersion(args.sourceDir, packageName)
+      ]
+    )
   );
   writeFileSync(
     join(args.outputDir, "package.json"),
@@ -404,6 +424,33 @@ function writeDeployManifest(args) {
     ) + "\n"
   );
 }
+function shouldVendorCurrentLibretto(versionSpec) {
+  return versionSpec.startsWith("file:") || versionSpec.startsWith("link:") || versionSpec.startsWith("workspace:") || versionSpec.startsWith("portal:") || versionSpec.includes("&path:");
+}
+function resolveLibrettoDependency(sourceDir) {
+  const versionSpec = resolveDependencyVersion(
+    sourceDir,
+    "libretto",
+    CURRENT_LIBRETTO_VERSION
+  );
+  if (shouldVendorCurrentLibretto(versionSpec)) {
+    return "file:./libretto";
+  }
+  return versionSpec;
+}
+function copyCurrentLibrettoPackage(outputDir) {
+  const bundledLibrettoDir = join(outputDir, "libretto");
+  mkdirSync(bundledLibrettoDir, { recursive: true });
+  cpSync(
+    join(CURRENT_LIBRETTO_PACKAGE_DIR, "dist"),
+    join(bundledLibrettoDir, "dist"),
+    { recursive: true }
+  );
+  cpSync(
+    join(CURRENT_LIBRETTO_PACKAGE_DIR, "package.json"),
+    join(bundledLibrettoDir, "package.json")
+  );
+}
 function formatBuildError(error) {
   if (!(error instanceof Error)) {
     return String(error);
@@ -450,7 +497,9 @@ function extractExportNamesFromEsmBundle(bundleSource) {
 }
 function createBootstrapSource(args) {
   const bundleHash = createHash("sha256").update(args.bundleBuffer).digest("hex").slice(0, 16);
-  const bundleBase64 = gzipSync(args.bundleBuffer, { level: 9 }).toString("base64");
+  const bundleBase64 = gzipSync(args.bundleBuffer, { level: 9 }).toString(
+    "base64"
+  );
   const outputPrefix = `${normalizePackageName(args.deploymentName)}-`;
   const hasDefaultExport = args.exportNames.includes("default");
   const exportLines = args.exportNames.filter((name) => name !== "default").map(
@@ -470,7 +519,9 @@ const BUNDLE_FILENAME = join(
   tmpdir(),
   ${JSON.stringify(outputPrefix)} + BUNDLE_HASH + ".cjs",
 );
-const require = createRequire(import.meta.url);
+const nativeRequire = createRequire(
+  join(tmpdir(), ${JSON.stringify("libretto-deploy-bootstrap.cjs")}),
+);
 
 function ensureBundleFile() {
   if (!existsSync(BUNDLE_FILENAME)) {
@@ -485,7 +536,7 @@ function ensureBundleFile() {
 
 function createWorkflowProxy(exportName) {
   return workflow(exportName, async (ctx, input) => {
-    const impl = require(ensureBundleFile());
+    const impl = nativeRequire(ensureBundleFile());
     const target = impl[exportName];
     if (!target || typeof target.run !== "function") {
       throw new Error(
@@ -500,29 +551,19 @@ ${exportLines}
 ${defaultExportLine}
 `;
 }
-async function createHostedDeployPackage(args) {
-  const absSourceDir = resolve(args.sourceDir);
-  ensureSourcePackageManifest(absSourceDir);
-  const absEntryPoint = resolveEntryPointPath(absSourceDir, args.entryPoint);
-  const tempRoot = mkdtempSync(join(tmpdir(), "libretto-deploy-"));
-  const outputDir = join(tempRoot, "deploy");
-  mkdirSync(outputDir, { recursive: true });
-  const additionalExternals = [...new Set(args.additionalExternals ?? [])];
-  const externalPackages = /* @__PURE__ */ new Set([
-    ...DEFAULT_RUNTIME_EXTERNALS,
-    ...additionalExternals
-  ]);
-  const workspacePackages = discoverWorkspacePackages(absSourceDir);
+async function writeBundledDeployEntrypoint(args) {
   try {
     const implementationBuild = await build({
-      absWorkingDir: absSourceDir,
+      absWorkingDir: args.absSourceDir,
       bundle: true,
-      entryPoints: [absEntryPoint],
-      external: [...externalPackages],
+      entryPoints: [args.absEntryPoint],
+      external: [...args.externalPackages],
       format: "cjs",
       outfile: "prebundled.cjs",
       platform: "node",
-      plugins: [workspaceSourcePlugin(workspacePackages, externalPackages)],
+      plugins: [
+        workspaceSourcePlugin(args.workspacePackages, args.externalPackages)
+      ],
       splitting: false,
       target: "node20",
       write: false
@@ -531,17 +572,21 @@ async function createHostedDeployPackage(args) {
       (file) => file.path.endsWith("prebundled.cjs")
     );
     if (!bundledImplementation) {
-      throw new Error("Bundler did not produce a deployment implementation file.");
+      throw new Error(
+        "Bundler did not produce a deployment implementation file."
+      );
     }
     const exportBuild = await build({
-      absWorkingDir: absSourceDir,
+      absWorkingDir: args.absSourceDir,
       bundle: true,
-      entryPoints: [absEntryPoint],
-      external: [...externalPackages],
+      entryPoints: [args.absEntryPoint],
+      external: [...args.externalPackages],
       format: "esm",
       outfile: "entry-exports.js",
       platform: "node",
-      plugins: [workspaceSourcePlugin(workspacePackages, externalPackages)],
+      plugins: [
+        workspaceSourcePlugin(args.workspacePackages, args.externalPackages)
+      ],
       splitting: false,
       target: "node20",
       write: false
@@ -555,11 +600,11 @@ async function createHostedDeployPackage(args) {
     const exportNames = extractExportNamesFromEsmBundle(bundledExports.text);
     if (exportNames.length === 0) {
       throw new Error(
-        `No named exports were found in ${absEntryPoint}. Hosted deploy expects the entry point to export one or more workflows.`
+        `No named exports were found in ${args.absEntryPoint}. Hosted deploy expects the entry point to export one or more workflows.`
       );
     }
     writeFileSync(
-      join(outputDir, "index.js"),
+      join(args.outputDir, "index.js"),
       createBootstrapSource({
         bundleBuffer: Buffer.from(bundledImplementation.contents),
         deploymentName: args.deploymentName,
@@ -567,25 +612,59 @@ async function createHostedDeployPackage(args) {
       })
     );
   } catch (error) {
-    rmSync(tempRoot, { force: true, recursive: true });
     throw new Error(
-      `Failed to bundle deploy entry point ${absEntryPoint}.
+      `Failed to bundle deploy entry point ${args.absEntryPoint}.
 ${formatBuildError(error)}`
     );
   }
-  writeDeployManifest({
-    additionalExternals,
-    deploymentName: args.deploymentName,
-    outputDir,
-    sourceDir: absSourceDir
-  });
-  return {
-    cleanup: () => {
+}
+async function createHostedDeployPackage(args) {
+  const absSourceDir = resolve(args.sourceDir);
+  ensureSourcePackageManifest(absSourceDir);
+  const absEntryPoint = resolveEntryPointPath(absSourceDir, args.entryPoint);
+  const tempRoot = mkdtempSync(join(tmpdir(), "libretto-deploy-"));
+  const outputDir = join(tempRoot, "deploy");
+  mkdirSync(outputDir, { recursive: true });
+  const librettoDependency = resolveLibrettoDependency(absSourceDir);
+  const additionalExternals = [...new Set(args.additionalExternals ?? [])];
+  const externalPackages = /* @__PURE__ */ new Set([
+    ...DEFAULT_RUNTIME_EXTERNALS,
+    ...additionalExternals
+  ]);
+  const workspacePackages = discoverWorkspacePackages(absSourceDir);
+  let callerOwnsTempRoot = false;
+  try {
+    await writeBundledDeployEntrypoint({
+      absEntryPoint,
+      absSourceDir,
+      deploymentName: args.deploymentName,
+      externalPackages,
+      outputDir,
+      workspacePackages
+    });
+    if (librettoDependency === "file:./libretto") {
+      copyCurrentLibrettoPackage(outputDir);
+    }
+    writeDeployManifest({
+      additionalExternals,
+      deploymentName: args.deploymentName,
+      librettoDependency,
+      outputDir,
+      sourceDir: absSourceDir
+    });
+    callerOwnsTempRoot = true;
+    return {
+      cleanup: () => {
+        rmSync(tempRoot, { force: true, recursive: true });
+      },
+      entryPoint: "index.js",
+      outputDir
+    };
+  } finally {
+    if (!callerOwnsTempRoot) {
       rmSync(tempRoot, { force: true, recursive: true });
-    },
-    entryPoint: "index.js",
-    outputDir
-  };
+    }
+  }
 }
 async function buildHostedDeployTarball(args) {
   const deployPackage = await createHostedDeployPackage(args);

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

@@ -177,7 +177,6 @@ async function runIntegrationInternal(args, options) {
     session: args.session,
     logger: integrationLogger,
     page: browserSession.page,
-    services: {},
     credentials: args.credentials
   };
   try {

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

@@ -2,20 +2,19 @@ import { Page } from 'playwright';
 import { MinimalLogger } from '../logger/logger.js';
 
 declare const LIBRETTO_WORKFLOW_BRAND: unique symbol;
-type LibrettoWorkflowContext<S = {}> = {
+type LibrettoWorkflowContext = {
     session: string;
     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 = {}> {
+type LibrettoWorkflowHandler<Input = unknown, Output = unknown> = (ctx: LibrettoWorkflowContext, input: Input) => Promise<Output>;
+declare class LibrettoWorkflow<Input = unknown, Output = unknown> {
     readonly [LIBRETTO_WORKFLOW_BRAND] = true;
     readonly name: string;
     private readonly handler;
-    constructor(name: string, handler: LibrettoWorkflowHandler<Input, Output, S>);
-    run(ctx: LibrettoWorkflowContext<S>, input: Input): Promise<Output>;
+    constructor(name: string, handler: LibrettoWorkflowHandler<Input, Output>);
+    run(ctx: LibrettoWorkflowContext, input: Input): Promise<Output>;
 }
 type ExportedLibrettoWorkflow = {
     readonly [LIBRETTO_WORKFLOW_BRAND]: true;
@@ -26,6 +25,6 @@ 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>;
+declare function workflow<Input = unknown, Output = unknown>(name: string, handler: LibrettoWorkflowHandler<Input, Output>): LibrettoWorkflow<Input, Output>;
 
 export { type ExportedLibrettoWorkflow, LIBRETTO_WORKFLOW_BRAND, LibrettoWorkflow, type LibrettoWorkflowContext, type LibrettoWorkflowHandler, getWorkflowFromModuleExports, getWorkflowsFromModuleExports, isLibrettoWorkflow, workflow };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "libretto",
-  "version": "0.5.3-experimental.4",
+  "version": "0.5.3-experimental.6",
   "description": "AI-powered browser automation library and CLI built on Playwright",
   "license": "MIT",
   "repository": {

package/skills/libretto/references/code-generation-rules.md

@@ -40,48 +40,12 @@ Key points:
 
 - `workflow(name, handler)` takes a unique workflow name and returns the workflow object that Libretto can run.
 - `npx libretto run ./file.ts myWorkflow` resolves `myWorkflow` from the workflows exported by `./file.ts`, so export or re-export the workflow from that file directly or through a `workflows` object, and make sure the run argument matches the name passed to `workflow("myWorkflow", ...)`.
-- `ctx` provides `session`, `page`, `logger`, and `services` (generic, default `{}`)
+- `ctx` provides `session`, `page`, `logger`, and optional `credentials`
 - `input` comes from `--params '{"query":"foo"}'` or `--params-file params.json` on the CLI
 - Use `await pause(ctx.session)` (or `await pause(session)`) to pause the workflow for debugging. It is a no-op in production.
 - After validation is complete and the workflow is confirmed working end to end, remove all `pause()` calls and pause-only workflow params unless the user explicitly says to keep them.
 - The browser is launched and closed automatically by the CLI. Do not launch or close it in the handler.
 
-## Passing Application Dependencies via Services
-
-Use the third generic on `workflow<Input, Output, Services>` to inject
-dependencies that exist in your application but not in libretto's runtime
-(DB transactions, API clients, caches, etc.):
-
-```typescript
-import { type Transaction } from "./db";
-
-type MyServices = { tx?: Transaction };
-
-export const myWorkflow = workflow<Input, Output, MyServices>(
-  "myWorkflow",
-  async (ctx, input) => {
-    if (ctx.services.tx) {
-      await ctx.services.tx.insert(/* ... */);
-    } else {
-      ctx.logger.info("No DB transaction — skipping write");
-    }
-    // ... browser automation ...
-  },
-);
-```
-
-In production, the caller passes services when invoking `.run()`:
-
-```typescript
-await myWorkflow.run(
-  { session: "debug-flow", page, logger, services: { tx } },
-  input,
-);
-```
-
-When running standalone via `npx libretto run`, services defaults to `{}`,
-so mark fields optional for anything unavailable in that context.
-
 ## Playwright DOM Interaction Rules
 
 Generated code must use Playwright locator APIs for all DOM interactions. Do not use `page.evaluate()` with `document.querySelector`, `querySelectorAll`, `textContent`, `click()`, or other DOM APIs when a Playwright locator can do the same thing.

package/src/cli/commands/deploy.ts

@@ -1,3 +1,4 @@
+import { randomBytes } from "node:crypto";
 import { z } from "zod";
 import { buildHostedDeployTarball } from "../core/deploy-artifact.js";
 import { SimpleCLI } from "../framework/simple-cli.js";
@@ -7,14 +8,16 @@ type DeploymentStatus = "building" | "ready" | "failed";
 type DeploymentResponse = {
   json: {
     deployment_id: string;
-    name: string;
-    version: number;
     status: DeploymentStatus;
     workflows?: string[] | null;
     build_error?: string | null;
   };
 };
 
+function generateDeploymentName(): string {
+  return `deploy-${Date.now().toString(36)}-${randomBytes(4).toString("hex")}`;
+}
+
 function getConfig() {
   const apiUrl = process.env.LIBRETTO_API_URL;
   const apiKey = process.env.LIBRETTO_API_KEY;
@@ -92,9 +95,6 @@ export const deployInput = SimpleCLI.input({
     }),
   ],
   named: {
-    name: SimpleCLI.option(z.string(), {
-      help: "Deployment name",
-    }),
     description: SimpleCLI.option(z.string().optional(), {
       help: "Deployment description",
     }),
@@ -127,6 +127,7 @@ export const deployCommand = SimpleCLI.command({
   .input(deployInput)
   .handle(async ({ input }) => {
     const { apiUrl, apiKey } = getConfig();
+    const deploymentName = generateDeploymentName();
 
     // Hosted deploy uploads a generated artifact with a deploy entrypoint and
     // a minimal manifest. Bundled code is embedded in the generated files;
@@ -134,13 +135,12 @@ export const deployCommand = SimpleCLI.command({
     console.log("Bundling hosted deployment artifact...");
     const { entryPoint, source } = await buildHostedDeployTarball({
       additionalExternals: input.external,
-      deploymentName: input.name,
+      deploymentName,
       entryPoint: input.entryPoint,
       sourceDir: input.sourceDir,
     });
 
     const createPayload: Record<string, unknown> = {
-      name: input.name,
       source,
       entry_point: entryPoint,
     };
@@ -160,10 +160,8 @@ export const deployCommand = SimpleCLI.command({
       );
     }
 
-    const { deployment_id, name, version, status } = body.json;
-    console.log(
-      `Deployment created: ${name} v${version} (${deployment_id})`,
-    );
+    const { deployment_id, status } = body.json;
+    console.log(`Deployment created: ${deployment_id}`);
     console.log(`Status: ${status}`);
 
     if (status === "building") {

package/src/cli/core/deploy-artifact.ts

@@ -1,6 +1,7 @@
 import { execFileSync } from "node:child_process";
 import { createHash } from "node:crypto";
 import {
+  cpSync,
   existsSync,
   mkdirSync,
   mkdtempSync,
@@ -77,6 +78,9 @@ const SOURCE_FILE_EXTENSIONS = [
   "/index.cjs",
 ] as const;
 const CURRENT_LIBRETTO_VERSION = readCurrentLibrettoVersion();
+const CURRENT_LIBRETTO_PACKAGE_DIR = fileURLToPath(
+  new URL("../../..", import.meta.url),
+);
 
 function readCurrentLibrettoVersion(): string {
   const packageJsonPath = fileURLToPath(
@@ -157,7 +161,9 @@ function readWorkspacePatterns(rootDir: string): string[] {
     const patterns: string[] = [];
     let inPackagesBlock = false;
 
-    for (const rawLine of readFileSync(pnpmWorkspacePath, "utf8").split(/\r?\n/)) {
+    for (const rawLine of readFileSync(pnpmWorkspacePath, "utf8").split(
+      /\r?\n/,
+    )) {
       const trimmed = rawLine.trim();
       if (!inPackagesBlock) {
         if (trimmed === "packages:") {
@@ -222,7 +228,9 @@ function expandWorkspacePattern(rootDir: string, pattern: string): string[] {
     .map((entry) => join(baseDir, entry.name));
 }
 
-function discoverWorkspacePackages(startDir: string): Map<string, WorkspacePackage> {
+function discoverWorkspacePackages(
+  startDir: string,
+): Map<string, WorkspacePackage> {
   const workspaceRoot = findWorkspaceRoot(startDir);
   if (!workspaceRoot) {
     return new Map();
@@ -253,8 +261,8 @@ function findMatchingWorkspacePackage(
   info: WorkspacePackage;
   subpath: string;
 } | null {
-  const names = [...workspacePackages.keys()].sort((left, right) =>
-    right.length - left.length,
+  const names = [...workspacePackages.keys()].sort(
+    (left, right) => right.length - left.length,
   );
 
   for (const name of names) {
@@ -331,7 +339,11 @@ function resolveExportTarget(
     if (!(condition in record)) {
       continue;
     }
-    const resolved = resolveExportTarget(record[condition], packageDir, replacement);
+    const resolved = resolveExportTarget(
+      record[condition],
+      packageDir,
+      replacement,
+    );
     if (resolved) {
       return resolved;
     }
@@ -356,7 +368,10 @@ function resolveExportsSubpath(
     return null;
   }
 
-  if (subpath === ".") {
+  if (
+    subpath === "." &&
+    (typeof exportsField === "string" || Array.isArray(exportsField))
+  ) {
     const rootExport = resolveExportTarget(exportsField, packageDir);
     if (rootExport) {
       return rootExport;
@@ -368,7 +383,9 @@ function resolveExportsSubpath(
   }
 
   const record = exportsField as Record<string, unknown>;
-  const hasExplicitSubpathKeys = Object.keys(record).some((key) => key.startsWith("."));
+  const hasExplicitSubpathKeys = Object.keys(record).some((key) =>
+    key.startsWith("."),
+  );
 
   if (!hasExplicitSubpathKeys) {
     return subpath === "." ? resolveExportTarget(record, packageDir) : null;
@@ -389,7 +406,10 @@ function resolveExportsSubpath(
     if (!subpath.startsWith(prefix) || !subpath.endsWith(suffix)) {
       continue;
     }
-    const replacement = subpath.slice(prefix.length, subpath.length - suffix.length);
+    const replacement = subpath.slice(
+      prefix.length,
+      subpath.length - suffix.length,
+    );
     const resolved = resolveExportTarget(value, packageDir, replacement);
     if (resolved) {
       return resolved;
@@ -403,7 +423,11 @@ function resolveWorkspaceSourcePath(
   info: WorkspacePackage,
   subpath: string,
 ): string | null {
-  const viaExports = resolveExportsSubpath(info.manifest.exports, info.dir, subpath);
+  const viaExports = resolveExportsSubpath(
+    info.manifest.exports,
+    info.dir,
+    subpath,
+  );
   if (viaExports) {
     return viaExports;
   }
@@ -449,12 +473,18 @@ function workspaceSourcePlugin(
           return null;
         }
 
-        const match = findMatchingWorkspacePackage(args.path, workspacePackages);
+        const match = findMatchingWorkspacePackage(
+          args.path,
+          workspacePackages,
+        );
         if (!match) {
           return null;
         }
 
-        const resolvedPath = resolveWorkspaceSourcePath(match.info, match.subpath);
+        const resolvedPath = resolveWorkspaceSourcePath(
+          match.info,
+          match.subpath,
+        );
         if (!resolvedPath) {
           throw new Error(
             `Unable to resolve workspace import "${args.path}" from ${match.info.dir}.`,
@@ -531,21 +561,19 @@ function resolveDependencyVersion(
 function writeDeployManifest(args: {
   additionalExternals: readonly string[];
   deploymentName: string;
+  librettoDependency: string;
   outputDir: string;
   sourceDir: string;
 }): void {
   const dependencies = Object.fromEntries(
-    [
-      ...BUILT_IN_MANIFEST_DEPENDENCIES,
-      ...args.additionalExternals,
-    ].map((packageName) => [
-      packageName,
-      resolveDependencyVersion(
-        args.sourceDir,
+    [...BUILT_IN_MANIFEST_DEPENDENCIES, ...args.additionalExternals].map(
+      (packageName) => [
         packageName,
-        packageName === "libretto" ? CURRENT_LIBRETTO_VERSION : undefined,
-      ),
-    ]),
+        packageName === "libretto"
+          ? args.librettoDependency
+          : resolveDependencyVersion(args.sourceDir, packageName),
+      ],
+    ),
   );
 
   writeFileSync(
@@ -563,13 +591,54 @@ function writeDeployManifest(args: {
   );
 }
 
+function shouldVendorCurrentLibretto(versionSpec: string): boolean {
+  return (
+    versionSpec.startsWith("file:") ||
+    versionSpec.startsWith("link:") ||
+    versionSpec.startsWith("workspace:") ||
+    versionSpec.startsWith("portal:") ||
+    versionSpec.includes("&path:")
+  );
+}
+
+function resolveLibrettoDependency(sourceDir: string): string {
+  const versionSpec = resolveDependencyVersion(
+    sourceDir,
+    "libretto",
+    CURRENT_LIBRETTO_VERSION,
+  );
+
+  if (shouldVendorCurrentLibretto(versionSpec)) {
+    return "file:./libretto";
+  }
+
+  return versionSpec;
+}
+
+function copyCurrentLibrettoPackage(outputDir: string): void {
+  const bundledLibrettoDir = join(outputDir, "libretto");
+  mkdirSync(bundledLibrettoDir, { recursive: true });
+  cpSync(
+    join(CURRENT_LIBRETTO_PACKAGE_DIR, "dist"),
+    join(bundledLibrettoDir, "dist"),
+    { recursive: true },
+  );
+  cpSync(
+    join(CURRENT_LIBRETTO_PACKAGE_DIR, "package.json"),
+    join(bundledLibrettoDir, "package.json"),
+  );
+}
+
 function formatBuildError(error: unknown): string {
   if (!(error instanceof Error)) {
     return String(error);
   }
 
   const candidate = error as Error & {
-    errors?: Array<{ location?: { file?: string; line?: number; column?: number }; text?: string }>;
+    errors?: Array<{
+      location?: { file?: string; line?: number; column?: number };
+      text?: string;
+    }>;
   };
   if (!Array.isArray(candidate.errors) || candidate.errors.length === 0) {
     return error.message;
@@ -630,13 +699,16 @@ function createBootstrapSource(args: {
     .update(args.bundleBuffer)
     .digest("hex")
     .slice(0, 16);
-  const bundleBase64 = gzipSync(args.bundleBuffer, { level: 9 }).toString("base64");
+  const bundleBase64 = gzipSync(args.bundleBuffer, { level: 9 }).toString(
+    "base64",
+  );
   const outputPrefix = `${normalizePackageName(args.deploymentName)}-`;
   const hasDefaultExport = args.exportNames.includes("default");
   const exportLines = args.exportNames
     .filter((name) => name !== "default")
     .map(
-      (name) => `export const ${name} = createWorkflowProxy(${JSON.stringify(name)});`,
+      (name) =>
+        `export const ${name} = createWorkflowProxy(${JSON.stringify(name)});`,
     )
     .join("\n");
   const defaultExportLine = hasDefaultExport
@@ -660,7 +732,9 @@ const BUNDLE_FILENAME = join(
   tmpdir(),
   ${JSON.stringify(outputPrefix)} + BUNDLE_HASH + ".cjs",
 );
-const require = createRequire(import.meta.url);
+const nativeRequire = createRequire(
+  join(tmpdir(), ${JSON.stringify("libretto-deploy-bootstrap.cjs")}),
+);
 
 function ensureBundleFile() {
   if (!existsSync(BUNDLE_FILENAME)) {
@@ -675,7 +749,7 @@ function ensureBundleFile() {
 
 function createWorkflowProxy(exportName) {
   return workflow(exportName, async (ctx, input) => {
-    const impl = require(ensureBundleFile());
+    const impl = nativeRequire(ensureBundleFile());
     const target = impl[exportName];
     if (!target || typeof target.run !== "function") {
       throw new Error(
@@ -691,64 +765,57 @@ ${defaultExportLine}
 `;
 }
 
-export async function createHostedDeployPackage(
-  args: CreateHostedDeployPackageArgs,
-): Promise<HostedDeployPackage> {
-  const absSourceDir = resolve(args.sourceDir);
-  ensureSourcePackageManifest(absSourceDir);
-
-  const absEntryPoint = resolveEntryPointPath(absSourceDir, args.entryPoint);
-  const tempRoot = mkdtempSync(join(tmpdir(), "libretto-deploy-"));
-  const outputDir = join(tempRoot, "deploy");
-  mkdirSync(outputDir, { recursive: true });
-
-  const additionalExternals = [...new Set(args.additionalExternals ?? [])];
-  // These packages stay out of the implementation bundle. The generated
-  // package.json carries them into deploy-time installation, and the deployed
-  // code resolves them from node_modules.
-  const externalPackages = new Set<string>([
-    ...DEFAULT_RUNTIME_EXTERNALS,
-    ...additionalExternals,
-  ]);
-  const workspacePackages = discoverWorkspacePackages(absSourceDir);
-
+async function writeBundledDeployEntrypoint(args: {
+  absEntryPoint: string;
+  absSourceDir: string;
+  deploymentName: string;
+  externalPackages: ReadonlySet<string>;
+  outputDir: string;
+  workspacePackages: Map<string, WorkspacePackage>;
+}): Promise<void> {
   try {
     // The implementation bundle is CommonJS so the bootstrap can load it lazily
     // with createRequire() after workflow discovery, while external packages
     // continue to load through normal Node module resolution.
     const implementationBuild = await build({
-      absWorkingDir: absSourceDir,
+      absWorkingDir: args.absSourceDir,
       bundle: true,
-      entryPoints: [absEntryPoint],
-      external: [...externalPackages],
+      entryPoints: [args.absEntryPoint],
+      external: [...args.externalPackages],
       format: "cjs",
       outfile: "prebundled.cjs",
       platform: "node",
-      plugins: [workspaceSourcePlugin(workspacePackages, externalPackages)],
+      plugins: [
+        workspaceSourcePlugin(args.workspacePackages, args.externalPackages),
+      ],
       splitting: false,
       target: "node20",
       write: false,
     });
 
-    const bundledImplementation = implementationBuild.outputFiles?.find((file) =>
-      file.path.endsWith("prebundled.cjs"),
+    const bundledImplementation = implementationBuild.outputFiles?.find(
+      (file) => file.path.endsWith("prebundled.cjs"),
     );
     if (!bundledImplementation) {
-      throw new Error("Bundler did not produce a deployment implementation file.");
+      throw new Error(
+        "Bundler did not produce a deployment implementation file.",
+      );
     }
 
     // A separate ESM bundle is used only to read the entry module's exported
     // workflow names. Scanning the CommonJS bundle would also see exports from
     // bundled dependencies, which is not the deploy surface.
     const exportBuild = await build({
-      absWorkingDir: absSourceDir,
+      absWorkingDir: args.absSourceDir,
       bundle: true,
-      entryPoints: [absEntryPoint],
-      external: [...externalPackages],
+      entryPoints: [args.absEntryPoint],
+      external: [...args.externalPackages],
       format: "esm",
       outfile: "entry-exports.js",
       platform: "node",
-      plugins: [workspaceSourcePlugin(workspacePackages, externalPackages)],
+      plugins: [
+        workspaceSourcePlugin(args.workspacePackages, args.externalPackages),
+      ],
       splitting: false,
       target: "node20",
       write: false,
@@ -764,12 +831,12 @@ export async function createHostedDeployPackage(
     const exportNames = extractExportNamesFromEsmBundle(bundledExports.text);
     if (exportNames.length === 0) {
       throw new Error(
-        `No named exports were found in ${absEntryPoint}. Hosted deploy expects the entry point to export one or more workflows.`,
+        `No named exports were found in ${args.absEntryPoint}. Hosted deploy expects the entry point to export one or more workflows.`,
       );
     }
 
     writeFileSync(
-      join(outputDir, "index.js"),
+      join(args.outputDir, "index.js"),
       createBootstrapSource({
         bundleBuffer: Buffer.from(bundledImplementation.contents),
         deploymentName: args.deploymentName,
@@ -777,29 +844,77 @@ export async function createHostedDeployPackage(
       }),
     );
   } catch (error) {
-    rmSync(tempRoot, { force: true, recursive: true });
     throw new Error(
-      `Failed to bundle deploy entry point ${absEntryPoint}.\n${formatBuildError(error)}`,
+      `Failed to bundle deploy entry point ${args.absEntryPoint}.\n${formatBuildError(error)}`,
     );
   }
+}
 
-  // The generated manifest lists only packages that stay outside the
-  // implementation bundle. Hosted deploy installs them into the deployed
-  // package, and the deployed code loads them from node_modules.
-  writeDeployManifest({
-    additionalExternals,
-    deploymentName: args.deploymentName,
-    outputDir,
-    sourceDir: absSourceDir,
-  });
+export async function createHostedDeployPackage(
+  args: CreateHostedDeployPackageArgs,
+): Promise<HostedDeployPackage> {
+  const absSourceDir = resolve(args.sourceDir);
+  ensureSourcePackageManifest(absSourceDir);
 
-  return {
-    cleanup: () => {
+  const absEntryPoint = resolveEntryPointPath(absSourceDir, args.entryPoint);
+  const tempRoot = mkdtempSync(join(tmpdir(), "libretto-deploy-"));
+  const outputDir = join(tempRoot, "deploy");
+  mkdirSync(outputDir, { recursive: true });
+  const librettoDependency = resolveLibrettoDependency(absSourceDir);
+
+  const additionalExternals = [...new Set(args.additionalExternals ?? [])];
+  // These packages stay out of the implementation bundle. The generated
+  // package.json carries them into deploy-time installation, and the deployed
+  // code resolves them from node_modules.
+  const externalPackages = new Set<string>([
+    ...DEFAULT_RUNTIME_EXTERNALS,
+    ...additionalExternals,
+  ]);
+  const workspacePackages = discoverWorkspacePackages(absSourceDir);
+  let callerOwnsTempRoot = false;
+
+  try {
+    await writeBundledDeployEntrypoint({
+      absEntryPoint,
+      absSourceDir,
+      deploymentName: args.deploymentName,
+      externalPackages,
+      outputDir,
+      workspacePackages,
+    });
+
+    if (librettoDependency === "file:./libretto") {
+      copyCurrentLibrettoPackage(outputDir);
+    }
+
+    // The generated manifest lists only packages that stay outside the
+    // implementation bundle. Hosted deploy installs them into the deployed
+    // package, and the deployed code loads them from node_modules.
+    writeDeployManifest({
+      additionalExternals,
+      deploymentName: args.deploymentName,
+      librettoDependency,
+      outputDir,
+      sourceDir: absSourceDir,
+    });
+
+    // Success transfers ownership of the temp directory to the caller, who is
+    // responsible for invoking cleanup() after the tarball/upload step.
+    callerOwnsTempRoot = true;
+    return {
+      cleanup: () => {
+        rmSync(tempRoot, { force: true, recursive: true });
+      },
+      entryPoint: "index.js",
+      outputDir,
+    };
+  } finally {
+    // On any failure before we return, this function still owns the temp dir
+    // and must remove it to avoid leaking deploy workspaces in /tmp.
+    if (!callerOwnsTempRoot) {
       rmSync(tempRoot, { force: true, recursive: true });
-    },
-    entryPoint: "index.js",
-    outputDir,
-  };
+    }
+  }
 }
 
 export async function buildHostedDeployTarball(

package/src/cli/workers/run-integration-runtime.ts

@@ -257,7 +257,6 @@ async function runIntegrationInternal(
     session: args.session,
     logger: integrationLogger,
     page: browserSession.page,
-    services: {},
     credentials: args.credentials,
   };
 

package/src/index.ts

@@ -112,7 +112,6 @@ export {
   type LibrettoWorkflowContext,
   type LibrettoWorkflowHandler,
 } from "./shared/workflow/workflow.js";
-
 const isDirectExecution = (): boolean => {
   const entryArg = process.argv[1];
   if (!entryArg) {

package/src/shared/workflow/workflow.ts

@@ -3,34 +3,32 @@ import type { MinimalLogger } from "../logger/logger.js";
 
 export const LIBRETTO_WORKFLOW_BRAND = Symbol.for("libretto.workflow");
 
-export type LibrettoWorkflowContext<S = {}> = {
+export type LibrettoWorkflowContext = {
   session: string;
   page: Page;
   logger: MinimalLogger;
-  services: S;
   credentials?: Record<string, unknown>;
 };
 
-export type LibrettoWorkflowHandler<
-  Input = unknown,
-  Output = unknown,
-  S = {},
-> = (ctx: LibrettoWorkflowContext<S>, input: Input) => Promise<Output>;
+export type LibrettoWorkflowHandler<Input = unknown, Output = unknown> = (
+  ctx: LibrettoWorkflowContext,
+  input: Input,
+) => Promise<Output>;
 
-export class LibrettoWorkflow<Input = unknown, Output = unknown, S = {}> {
+export class LibrettoWorkflow<Input = unknown, Output = unknown> {
   public readonly [LIBRETTO_WORKFLOW_BRAND] = true;
   public readonly name: string;
-  private readonly handler: LibrettoWorkflowHandler<Input, Output, S>;
+  private readonly handler: LibrettoWorkflowHandler<Input, Output>;
 
   constructor(
     name: string,
-    handler: LibrettoWorkflowHandler<Input, Output, S>,
+    handler: LibrettoWorkflowHandler<Input, Output>,
   ) {
     this.name = name;
     this.handler = handler;
   }
 
-  async run(ctx: LibrettoWorkflowContext<S>, input: Input): Promise<Output> {
+  async run(ctx: LibrettoWorkflowContext, input: Input): Promise<Output> {
     return this.handler(ctx, input);
   }
 }
@@ -114,9 +112,9 @@ export function getWorkflowFromModuleExports(
   return null;
 }
 
-export function workflow<Input = unknown, Output = unknown, S = {}>(
+export function workflow<Input = unknown, Output = unknown>(
   name: string,
-  handler: LibrettoWorkflowHandler<Input, Output, S>,
-): LibrettoWorkflow<Input, Output, S> {
+  handler: LibrettoWorkflowHandler<Input, Output>,
+): LibrettoWorkflow<Input, Output> {
   return new LibrettoWorkflow(name, handler);
 }