libretto 0.5.4 → 0.5.6

package/src/cli/core/context.ts

@@ -1,6 +1,4 @@
 import { Logger, createFileLogSink } from "../../shared/logger/index.js";
-import type { LLMClient } from "../../shared/llm/index.js";
-import type { LoggerApi } from "../../shared/logger/index.js";
 import { existsSync, mkdirSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { resolveLibrettoRepoRoot } from "../../shared/paths/repo-root.js";
@@ -72,13 +70,6 @@ export function createLoggerForSession(session: string): Logger {
   );
 }
 
-export async function closeLogger(
-  logger: Logger | null | undefined,
-): Promise<void> {
-  if (!logger) return;
-  await logger.close();
-}
-
 export async function withSessionLogger<T>(
   session: string,
   run: (logger: Logger) => Promise<T>,
@@ -87,41 +78,6 @@ export async function withSessionLogger<T>(
   try {
     return await run(logger);
   } finally {
-    await closeLogger(logger);
+    await logger.close();
   }
 }
-
-let llmClientFactory:
-  | ((logger: LoggerApi, model: string) => Promise<LLMClient>)
-  | null = null;
-
-export function setLLMClientFactory(
-  factory: (logger: LoggerApi, model: string) => Promise<LLMClient>,
-): void {
-  llmClientFactory = factory;
-}
-
-export function getLLMClientFactory():
-  | ((logger: LoggerApi, model: string) => Promise<LLMClient>)
-  | null {
-  return llmClientFactory;
-}
-
-export function maybeConfigureLLMClientFactoryFromEnv(): void {
-  if (llmClientFactory) return;
-
-  const hasAnyCreds =
-    process.env.GOOGLE_CLOUD_PROJECT ||
-    process.env.GCLOUD_PROJECT ||
-    process.env.ANTHROPIC_API_KEY ||
-    process.env.OPENAI_API_KEY ||
-    process.env.GEMINI_API_KEY ||
-    process.env.GOOGLE_GENERATIVE_AI_API_KEY;
-
-  if (!hasAnyCreds) return;
-
-  setLLMClientFactory(async (_logger, model) => {
-    const { createLLMClient } = await import("../../shared/llm/index.js");
-    return createLLMClient(model);
-  });
-}

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

@@ -10,11 +10,17 @@ import {
   rmSync,
   writeFileSync,
 } from "node:fs";
+import { createRequire, Module } from "node:module";
 import { tmpdir } from "node:os";
 import { dirname, isAbsolute, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { gzipSync } from "node:zlib";
 import { build } from "esbuild";
+import {
+  getWorkflowFromModuleExports,
+  getWorkflowsFromModuleExports,
+  LIBRETTO_WORKFLOW_BRAND,
+} from "../../shared/workflow/workflow.js";
 
 type PackageManifest = {
   name?: string;
@@ -81,6 +87,7 @@ const CURRENT_LIBRETTO_VERSION = readCurrentLibrettoVersion();
 const CURRENT_LIBRETTO_PACKAGE_DIR = fileURLToPath(
   new URL("../../..", import.meta.url),
 );
+const require = createRequire(import.meta.url);
 
 function readCurrentLibrettoVersion(): string {
   const packageJsonPath = fileURLToPath(
@@ -654,46 +661,141 @@ function formatBuildError(error: unknown): string {
     .join("\n");
 }
 
-function extractExportNamesFromEsmBundle(bundleSource: string): string[] {
-  const exportNames = new Set<string>();
+function getGeneratedWorkflowExportName(index: number): string {
+  return `workflow_${index}`;
+}
 
-  for (const entry of bundleSource.matchAll(
-    /export\s+(?:const|let|var|function|class)\s+([A-Za-z_$][\w$]*)/g,
-  )) {
-    exportNames.add(entry[1]!);
+function getPackageNameFromImportPath(importPath: string): string {
+  if (importPath.startsWith("@")) {
+    return importPath.split("/").slice(0, 2).join("/");
   }
+  return importPath.split("/")[0] ?? importPath;
+}
 
-  for (const entry of bundleSource.matchAll(/export\s+\{([^}]+)\};/g)) {
-    const specifiers = entry[1]?.split(",") ?? [];
-    for (const specifier of specifiers) {
-      const trimmed = specifier.trim();
-      if (!trimmed) {
-        continue;
+function createExternalDiscoveryStub(): object {
+  const stub = (() => createExternalDiscoveryStub()) as unknown as ((
+    ...args: unknown[]
+  ) => object) &
+    Record<PropertyKey, unknown>;
+
+  return new Proxy(stub, {
+    apply: () => createExternalDiscoveryStub(),
+    construct: () => createExternalDiscoveryStub(),
+    get: (_target, property) => {
+      if (property === "__esModule") {
+        return true;
       }
-      const aliasMatch = trimmed.match(
-        /^([A-Za-z_$][\w$]*)\s+as\s+([A-Za-z_$][\w$]*|default)$/,
-      );
-      if (aliasMatch?.[2]) {
-        exportNames.add(aliasMatch[2]);
-        continue;
+      if (property === "default") {
+        return createExternalDiscoveryStub();
       }
-      if (/^[A-Za-z_$][\w$]*$/.test(trimmed)) {
-        exportNames.add(trimmed);
+      if (property === Symbol.toPrimitive) {
+        return () => "";
       }
-    }
+      return createExternalDiscoveryStub();
+    },
+  });
+}
+
+function createDiscoveryLibrettoModule(workflowNames: Set<string>): object {
+  const moduleShape: Record<PropertyKey, unknown> = {
+    LIBRETTO_WORKFLOW_BRAND,
+    workflow: (name: string) => {
+      workflowNames.add(name);
+      return {
+        [LIBRETTO_WORKFLOW_BRAND]: true,
+        name,
+        async run() {
+          return undefined;
+        },
+      };
+    },
+  };
+
+  return new Proxy(moduleShape, {
+    get(target, property) {
+      if (property in target) {
+        return target[property];
+      }
+      if (property === "__esModule") {
+        return true;
+      }
+      return createExternalDiscoveryStub();
+    },
+  });
+}
+
+function discoverBundledWorkflowNames(args: {
+  absEntryPoint: string;
+  absSourceDir: string;
+  bundleBuffer: Buffer;
+  externalPackages: ReadonlySet<string>;
+}): string[] {
+  const discoveryPath = join(
+    args.absSourceDir,
+    `.libretto-deploy-discovery-${process.pid}-${Date.now()}.cjs`,
+  );
+  const originalRequire = Module.prototype.require;
+  const workflowNames = new Set<string>();
+  const discoveryLibrettoModule = createDiscoveryLibrettoModule(workflowNames);
+  let loadedModuleExports: Record<string, unknown> | null = null;
+
+  try {
+    writeFileSync(discoveryPath, args.bundleBuffer);
+    Module.prototype.require = function patchedRequire(id: string) {
+      const packageName = getPackageNameFromImportPath(id);
+      if (packageName === "libretto") {
+        return discoveryLibrettoModule;
+      }
+      if (packageName !== "libretto" && args.externalPackages.has(packageName)) {
+        return createExternalDiscoveryStub();
+      }
+      return originalRequire.call(this, id);
+    };
+    loadedModuleExports = require(discoveryPath) as Record<string, unknown>;
+  } catch (error) {
+    throw new Error(
+      `Failed to evaluate deploy entry point ${args.absEntryPoint} while discovering workflows.\n${formatBuildError(error)}`,
+    );
+  } finally {
+    Module.prototype.require = originalRequire;
+    delete (require.cache as Record<string, unknown> | undefined)?.[
+      discoveryPath
+    ];
+    rmSync(discoveryPath, { force: true });
   }
 
-  if (/\bexport\s+default\b/m.test(bundleSource)) {
-    exportNames.add("default");
+  const discoveredWorkflowNames = [...workflowNames].sort((left, right) =>
+    left.localeCompare(right),
+  );
+
+  if (discoveredWorkflowNames.length === 0) {
+    throw new Error(
+      `No workflows were found in ${args.absEntryPoint}. Import the workflow files you want to deploy from the entry point, or export a workflow directly from it.`,
+    );
   }
 
-  return [...exportNames];
+  const exportedWorkflowNames = new Set(
+    getWorkflowsFromModuleExports(loadedModuleExports ?? {}).map(
+      (workflow) => workflow.name,
+    ),
+  );
+  const nonExportedWorkflowNames = discoveredWorkflowNames.filter(
+    (name) => !exportedWorkflowNames.has(name),
+  );
+
+  if (nonExportedWorkflowNames.length > 0) {
+    throw new Error(
+      `Workflows discovered in ${args.absEntryPoint} must be exported from the deploy entry point. Re-export them from the entry point or export them through a \`workflows\` object. Non-exported workflows: ${nonExportedWorkflowNames.join(", ")}`,
+    );
+  }
+
+  return discoveredWorkflowNames;
 }
 
 function createBootstrapSource(args: {
   bundleBuffer: Buffer;
   deploymentName: string;
-  exportNames: readonly string[];
+  workflowNames: readonly string[];
 }): string {
   const bundleHash = createHash("sha256")
     .update(args.bundleBuffer)
@@ -703,17 +805,12 @@ function createBootstrapSource(args: {
     "base64",
   );
   const outputPrefix = `${normalizePackageName(args.deploymentName)}-`;
-  const hasDefaultExport = args.exportNames.includes("default");
-  const exportLines = args.exportNames
-    .filter((name) => name !== "default")
+  const exportLines = args.workflowNames
     .map(
-      (name) =>
-        `export const ${name} = createWorkflowProxy(${JSON.stringify(name)});`,
+      (name, index) =>
+        `export const ${getGeneratedWorkflowExportName(index)} = createWorkflowProxy(${JSON.stringify(name)});`,
     )
     .join("\n");
-  const defaultExportLine = hasDefaultExport
-    ? 'export default createWorkflowProxy("default");'
-    : "";
 
   // The deploy entrypoint is tiny on purpose. Hosted build imports this module
   // to discover workflow exports. The implementation bundle stays embedded in
@@ -724,7 +821,7 @@ import { existsSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { gunzipSync } from "node:zlib";
-import { workflow } from "libretto";
+import { getWorkflowFromModuleExports, workflow } from "libretto";
 
 const BUNDLE_HASH = ${JSON.stringify(bundleHash)};
 const BUNDLE_GZIP_BASE64 = ${JSON.stringify(bundleBase64)};
@@ -747,13 +844,13 @@ function ensureBundleFile() {
   return BUNDLE_FILENAME;
 }
 
-function createWorkflowProxy(exportName) {
-  return workflow(exportName, async (ctx, input) => {
+function createWorkflowProxy(workflowName) {
+  return workflow(workflowName, async (ctx, input) => {
     const impl = nativeRequire(ensureBundleFile());
-    const target = impl[exportName];
+    const target = getWorkflowFromModuleExports(impl, workflowName);
     if (!target || typeof target.run !== "function") {
       throw new Error(
-        \`Expected workflow export "\${exportName}" to be available in the bundled deployment implementation.\`,
+        \`Expected exported workflow "\${workflowName}" to be available in the bundled deployment implementation.\`,
       );
     }
     return await target.run(ctx, input);
@@ -761,7 +858,6 @@ function createWorkflowProxy(exportName) {
 }
 
 ${exportLines}
-${defaultExportLine}
 `;
 }
 
@@ -802,45 +898,19 @@ async function writeBundledDeployEntrypoint(args: {
       );
     }
 
-    // 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: args.absSourceDir,
-      bundle: true,
-      entryPoints: [args.absEntryPoint],
-      external: [...args.externalPackages],
-      format: "esm",
-      outfile: "entry-exports.js",
-      platform: "node",
-      plugins: [
-        workspaceSourcePlugin(args.workspacePackages, args.externalPackages),
-      ],
-      splitting: false,
-      target: "node20",
-      write: false,
+    const workflowNames = discoverBundledWorkflowNames({
+      absEntryPoint: args.absEntryPoint,
+      absSourceDir: args.absSourceDir,
+      bundleBuffer: Buffer.from(bundledImplementation.contents),
+      externalPackages: args.externalPackages,
     });
 
-    const bundledExports = exportBuild.outputFiles?.find((file) =>
-      file.path.endsWith("entry-exports.js"),
-    );
-    if (!bundledExports) {
-      throw new Error("Bundler did not produce an export analysis file.");
-    }
-
-    const exportNames = extractExportNamesFromEsmBundle(bundledExports.text);
-    if (exportNames.length === 0) {
-      throw new Error(
-        `No named exports were found in ${args.absEntryPoint}. Hosted deploy expects the entry point to export one or more workflows.`,
-      );
-    }
-
     writeFileSync(
       join(args.outputDir, "index.js"),
       createBootstrapSource({
         bundleBuffer: Buffer.from(bundledImplementation.contents),
         deploymentName: args.deploymentName,
-        exportNames,
+        workflowNames,
       }),
     );
   } catch (error) {

package/src/cli/core/readonly-exec.ts

@@ -0,0 +1,284 @@
+import type { Locator, Page } from "playwright";
+
+const PAGE_READ_METHODS = new Set([
+  "url",
+  "title",
+  "content",
+  "pageErrors",
+  "viewportSize",
+  "waitForLoadState",
+  "waitForRequest",
+  "waitForResponse",
+  "waitForURL",
+]);
+const PAGE_LOCATOR_FACTORY_METHODS = new Set([
+  "locator",
+  "getByRole",
+  "getByText",
+  "getByLabel",
+  "getByPlaceholder",
+  "getByAltText",
+  "getByTitle",
+  "getByTestId",
+]);
+
+const PAGE_ALLOWED_PROPERTIES = new Set<string>([]);
+
+const LOCATOR_READ_METHODS = new Set([
+  "textContent",
+  "innerText",
+  "allTextContents",
+  "allInnerTexts",
+  "ariaSnapshot",
+  "boundingBox",
+  "count",
+  "getAttribute",
+  "inputValue",
+  "isChecked",
+  "isDisabled",
+  "isEditable",
+  "isEnabled",
+  "isVisible",
+  "isHidden",
+  "waitFor",
+]);
+
+const LOCATOR_FACTORY_METHODS = new Set([
+  "locator",
+  "getByRole",
+  "getByText",
+  "getByLabel",
+  "getByPlaceholder",
+  "getByAltText",
+  "getByTitle",
+  "getByTestId",
+  "filter",
+  "and",
+  "or",
+  "first",
+  "last",
+  "nth",
+]);
+
+const LOCATOR_COLLECTION_FACTORY_METHODS = new Set(["all"]);
+
+const LOCATOR_SCROLL_METHODS = new Set(["scrollIntoViewIfNeeded"]);
+
+const LOCATOR_ALLOWED_PROPERTIES = new Set<string>([]);
+
+type ReadonlyExecOptions = {
+  onActivity?: () => void;
+};
+
+const readonlyPageCache = new WeakMap<Page, Page>();
+const readonlyLocatorCache = new WeakMap<Locator, Locator>();
+
+function markActivity(onActivity?: () => void): void {
+  onActivity?.();
+}
+
+export class ReadonlyExecDeniedError extends Error {
+  constructor(message: string) {
+    super(`ReadonlyExecDenied: ${message}`);
+    this.name = "ReadonlyExecDenied";
+  }
+}
+
+function denyOperation(targetName: "page" | "locator", method: string): never {
+  throw new ReadonlyExecDeniedError(
+    `${targetName}.${method} is blocked in readonly-exec`,
+  );
+}
+
+export function wrapLocatorForReadonlyExec(
+  locator: Locator,
+  options: ReadonlyExecOptions = {},
+): Locator {
+  const cached = readonlyLocatorCache.get(locator);
+  if (cached) return cached;
+
+  const proxy = new Proxy(locator, {
+    get(target, prop, receiver) {
+      if (typeof prop !== "string") {
+        return Reflect.get(target, prop, receiver);
+      }
+
+      const value = Reflect.get(target, prop, target);
+      if (typeof value !== "function") {
+        if (LOCATOR_ALLOWED_PROPERTIES.has(prop)) {
+          return value;
+        }
+        return denyOperation("locator", prop);
+      }
+
+      if (LOCATOR_READ_METHODS.has(prop)) {
+        return (...args: unknown[]) => {
+          const result = value.apply(target, args);
+          markActivity(options.onActivity);
+          return result;
+        };
+      }
+
+      if (LOCATOR_FACTORY_METHODS.has(prop)) {
+        return (...args: unknown[]) => {
+          const nextLocator = value.apply(target, args) as Locator;
+          markActivity(options.onActivity);
+          return wrapLocatorForReadonlyExec(nextLocator, options);
+        };
+      }
+
+      if (LOCATOR_COLLECTION_FACTORY_METHODS.has(prop)) {
+        return async (...args: unknown[]) => {
+          const locators = (await value.apply(target, args)) as Locator[];
+          markActivity(options.onActivity);
+          return locators.map((locator) =>
+            wrapLocatorForReadonlyExec(locator, options),
+          );
+        };
+      }
+
+      if (LOCATOR_SCROLL_METHODS.has(prop)) {
+        return async (...args: unknown[]) => {
+          await value.apply(target, args);
+          markActivity(options.onActivity);
+        };
+      }
+
+      return (..._args: unknown[]) => denyOperation("locator", prop);
+    },
+  });
+
+  readonlyLocatorCache.set(locator, proxy as Locator);
+  return proxy as Locator;
+}
+
+export function wrapPageForReadonlyExec(
+  page: Page,
+  options: ReadonlyExecOptions = {},
+): Page {
+  const cached = readonlyPageCache.get(page);
+  if (cached) return cached;
+
+  const proxy = new Proxy(page, {
+    get(target, prop, receiver) {
+      if (typeof prop !== "string") {
+        return Reflect.get(target, prop, receiver);
+      }
+
+      const value = Reflect.get(target, prop, target);
+      if (typeof value !== "function") {
+        if (PAGE_ALLOWED_PROPERTIES.has(prop)) {
+          return value;
+        }
+        return denyOperation("page", prop);
+      }
+
+      if (PAGE_READ_METHODS.has(prop)) {
+        return (...args: unknown[]) => {
+          const result = value.apply(target, args);
+          markActivity(options.onActivity);
+          return result;
+        };
+      }
+
+      if (PAGE_LOCATOR_FACTORY_METHODS.has(prop)) {
+        return (...args: unknown[]) => {
+          const locator = value.apply(target, args) as Locator;
+          markActivity(options.onActivity);
+          return wrapLocatorForReadonlyExec(locator, options);
+        };
+      }
+
+      return (..._args: unknown[]) => denyOperation("page", prop);
+    },
+  });
+
+  readonlyPageCache.set(page, proxy as Page);
+  return proxy as Page;
+}
+
+function resolveRequestMethod(
+  input: RequestInfo | URL,
+  init?: RequestInit,
+): string {
+  const requestMethod =
+    typeof Request !== "undefined" && input instanceof Request
+      ? input.method
+      : undefined;
+  return (init?.method ?? requestMethod ?? "GET").toUpperCase();
+}
+
+function assertReadonlyRequestBodyAllowed(
+  input: RequestInfo | URL,
+  init?: RequestInit,
+): void {
+  if (init?.body !== undefined) {
+    throw new ReadonlyExecDeniedError(
+      "request bodies are blocked in readonly-exec",
+    );
+  }
+
+  if (
+    typeof Request !== "undefined" &&
+    input instanceof Request &&
+    input.body !== null
+  ) {
+    throw new ReadonlyExecDeniedError(
+      "request bodies are blocked in readonly-exec",
+    );
+  }
+}
+
+export function createReadonlyExecHelpers(
+  page: Page,
+  options: ReadonlyExecOptions = {},
+) {
+  const readonlyPage = wrapPageForReadonlyExec(page, options);
+  const execState: Record<string, unknown> = {};
+
+  return {
+    page: readonlyPage,
+    state: execState,
+    // Playwright has no native viewport scroll method — only locator.scrollIntoViewIfNeeded().
+    // Arbitrary scrolling requires page.evaluate(), which is blocked by the readonly proxy
+    // since it can run arbitrary code. This helper calls evaluate on the raw (unwrapped) page,
+    // scoped to just window.scrollBy.
+    scrollBy: async (deltaX: number, deltaY: number) => {
+      await page.evaluate(
+        ([x, y]) => {
+          window.scrollBy(x, y);
+        },
+        [deltaX, deltaY] as const,
+      );
+      markActivity(options.onActivity);
+    },
+    get: async (input: RequestInfo | URL, init?: RequestInit) => {
+      const method = resolveRequestMethod(input, init);
+      if (method !== "GET" && method !== "HEAD") {
+        throw new ReadonlyExecDeniedError(
+          `${method} requests are blocked in readonly-exec`,
+        );
+      }
+      assertReadonlyRequestBodyAllowed(input, init);
+      markActivity(options.onActivity);
+      return await fetch(input, {
+        ...init,
+        method,
+      });
+    },
+    // Shadows the global Node.js fetch to prevent unrestricted HTTP access.
+    // Without this, agent code would fall through to the global fetch (POST, PUT, DELETE, etc.).
+    fetch: () => {
+      throw new ReadonlyExecDeniedError(
+        "fetch is blocked in readonly-exec; use get() instead",
+      );
+    },
+    console,
+    setTimeout,
+    setInterval,
+    clearTimeout,
+    clearInterval,
+    URL,
+    Buffer,
+  };
+}