libretto 0.5.4 → 0.5.6

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

@@ -10,11 +10,16 @@ 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 {
+  getWorkflowsFromModuleExports,
+  LIBRETTO_WORKFLOW_BRAND
+} from "../../shared/workflow/workflow.js";
 const DEFAULT_RUNTIME_EXTERNALS = [
   "libretto",
   "playwright",
@@ -43,6 +48,7 @@ const CURRENT_LIBRETTO_VERSION = readCurrentLibrettoVersion();
 const CURRENT_LIBRETTO_PACKAGE_DIR = fileURLToPath(
   new URL("../../..", import.meta.url)
 );
+const require2 = createRequire(import.meta.url);
 function readCurrentLibrettoVersion() {
   const packageJsonPath = fileURLToPath(
     new URL("../../../package.json", import.meta.url)
@@ -464,36 +470,114 @@ function formatBuildError(error) {
     return `${location} ${entry.text ?? error.message}`;
   }).join("\n");
 }
-function extractExportNamesFromEsmBundle(bundleSource) {
-  const exportNames = /* @__PURE__ */ new Set();
-  for (const entry of bundleSource.matchAll(
-    /export\s+(?:const|let|var|function|class)\s+([A-Za-z_$][\w$]*)/g
-  )) {
-    exportNames.add(entry[1]);
-  }
-  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 getGeneratedWorkflowExportName(index) {
+  return `workflow_${index}`;
+}
+function getPackageNameFromImportPath(importPath) {
+  if (importPath.startsWith("@")) {
+    return importPath.split("/").slice(0, 2).join("/");
+  }
+  return importPath.split("/")[0] ?? importPath;
+}
+function createExternalDiscoveryStub() {
+  const stub = (() => createExternalDiscoveryStub());
+  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) {
+  const moduleShape = {
+    LIBRETTO_WORKFLOW_BRAND,
+    workflow: (name) => {
+      workflowNames.add(name);
+      return {
+        [LIBRETTO_WORKFLOW_BRAND]: true,
+        name,
+        async run() {
+          return void 0;
+        }
+      };
+    }
+  };
+  return new Proxy(moduleShape, {
+    get(target, property) {
+      if (property in target) {
+        return target[property];
+      }
+      if (property === "__esModule") {
+        return true;
+      }
+      return createExternalDiscoveryStub();
+    }
+  });
+}
+function discoverBundledWorkflowNames(args) {
+  const discoveryPath = join(
+    args.absSourceDir,
+    `.libretto-deploy-discovery-${process.pid}-${Date.now()}.cjs`
+  );
+  const originalRequire = Module.prototype.require;
+  const workflowNames = /* @__PURE__ */ new Set();
+  const discoveryLibrettoModule = createDiscoveryLibrettoModule(workflowNames);
+  let loadedModuleExports = null;
+  try {
+    writeFileSync(discoveryPath, args.bundleBuffer);
+    Module.prototype.require = function patchedRequire(id) {
+      const packageName = getPackageNameFromImportPath(id);
+      if (packageName === "libretto") {
+        return discoveryLibrettoModule;
+      }
+      if (packageName !== "libretto" && args.externalPackages.has(packageName)) {
+        return createExternalDiscoveryStub();
+      }
+      return originalRequire.call(this, id);
+    };
+    loadedModuleExports = require2(discoveryPath);
+  } catch (error) {
+    throw new Error(
+      `Failed to evaluate deploy entry point ${args.absEntryPoint} while discovering workflows.
+${formatBuildError(error)}`
+    );
+  } finally {
+    Module.prototype.require = originalRequire;
+    delete require2.cache?.[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.`
+    );
+  }
+  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 [...exportNames];
+  return discoveredWorkflowNames;
 }
 function createBootstrapSource(args) {
   const bundleHash = createHash("sha256").update(args.bundleBuffer).digest("hex").slice(0, 16);
@@ -501,17 +585,15 @@ function createBootstrapSource(args) {
     "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)});`
+  const exportLines = args.workflowNames.map(
+    (name, index) => `export const ${getGeneratedWorkflowExportName(index)} = createWorkflowProxy(${JSON.stringify(name)});`
   ).join("\n");
-  const defaultExportLine = hasDefaultExport ? 'export default createWorkflowProxy("default");' : "";
   return `import { createRequire } from "node:module";
 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)};
@@ -534,13 +616,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);
@@ -548,7 +630,6 @@ function createWorkflowProxy(exportName) {
 }
 
 ${exportLines}
-${defaultExportLine}
 `;
 }
 async function writeBundledDeployEntrypoint(args) {
@@ -576,39 +657,18 @@ async function writeBundledDeployEntrypoint(args) {
         "Bundler did not produce a deployment implementation file."
       );
     }
-    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/dist/cli/core/readonly-exec.js

@@ -0,0 +1,231 @@
+const PAGE_READ_METHODS = /* @__PURE__ */ new Set([
+  "url",
+  "title",
+  "content",
+  "pageErrors",
+  "viewportSize",
+  "waitForLoadState",
+  "waitForRequest",
+  "waitForResponse",
+  "waitForURL"
+]);
+const PAGE_LOCATOR_FACTORY_METHODS = /* @__PURE__ */ new Set([
+  "locator",
+  "getByRole",
+  "getByText",
+  "getByLabel",
+  "getByPlaceholder",
+  "getByAltText",
+  "getByTitle",
+  "getByTestId"
+]);
+const PAGE_ALLOWED_PROPERTIES = /* @__PURE__ */ new Set([]);
+const LOCATOR_READ_METHODS = /* @__PURE__ */ new Set([
+  "textContent",
+  "innerText",
+  "allTextContents",
+  "allInnerTexts",
+  "ariaSnapshot",
+  "boundingBox",
+  "count",
+  "getAttribute",
+  "inputValue",
+  "isChecked",
+  "isDisabled",
+  "isEditable",
+  "isEnabled",
+  "isVisible",
+  "isHidden",
+  "waitFor"
+]);
+const LOCATOR_FACTORY_METHODS = /* @__PURE__ */ new Set([
+  "locator",
+  "getByRole",
+  "getByText",
+  "getByLabel",
+  "getByPlaceholder",
+  "getByAltText",
+  "getByTitle",
+  "getByTestId",
+  "filter",
+  "and",
+  "or",
+  "first",
+  "last",
+  "nth"
+]);
+const LOCATOR_COLLECTION_FACTORY_METHODS = /* @__PURE__ */ new Set(["all"]);
+const LOCATOR_SCROLL_METHODS = /* @__PURE__ */ new Set(["scrollIntoViewIfNeeded"]);
+const LOCATOR_ALLOWED_PROPERTIES = /* @__PURE__ */ new Set([]);
+const readonlyPageCache = /* @__PURE__ */ new WeakMap();
+const readonlyLocatorCache = /* @__PURE__ */ new WeakMap();
+function markActivity(onActivity) {
+  onActivity?.();
+}
+class ReadonlyExecDeniedError extends Error {
+  constructor(message) {
+    super(`ReadonlyExecDenied: ${message}`);
+    this.name = "ReadonlyExecDenied";
+  }
+}
+function denyOperation(targetName, method) {
+  throw new ReadonlyExecDeniedError(
+    `${targetName}.${method} is blocked in readonly-exec`
+  );
+}
+function wrapLocatorForReadonlyExec(locator, options = {}) {
+  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) => {
+          const result = value.apply(target, args);
+          markActivity(options.onActivity);
+          return result;
+        };
+      }
+      if (LOCATOR_FACTORY_METHODS.has(prop)) {
+        return (...args) => {
+          const nextLocator = value.apply(target, args);
+          markActivity(options.onActivity);
+          return wrapLocatorForReadonlyExec(nextLocator, options);
+        };
+      }
+      if (LOCATOR_COLLECTION_FACTORY_METHODS.has(prop)) {
+        return async (...args) => {
+          const locators = await value.apply(target, args);
+          markActivity(options.onActivity);
+          return locators.map(
+            (locator2) => wrapLocatorForReadonlyExec(locator2, options)
+          );
+        };
+      }
+      if (LOCATOR_SCROLL_METHODS.has(prop)) {
+        return async (...args) => {
+          await value.apply(target, args);
+          markActivity(options.onActivity);
+        };
+      }
+      return (..._args) => denyOperation("locator", prop);
+    }
+  });
+  readonlyLocatorCache.set(locator, proxy);
+  return proxy;
+}
+function wrapPageForReadonlyExec(page, options = {}) {
+  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) => {
+          const result = value.apply(target, args);
+          markActivity(options.onActivity);
+          return result;
+        };
+      }
+      if (PAGE_LOCATOR_FACTORY_METHODS.has(prop)) {
+        return (...args) => {
+          const locator = value.apply(target, args);
+          markActivity(options.onActivity);
+          return wrapLocatorForReadonlyExec(locator, options);
+        };
+      }
+      return (..._args) => denyOperation("page", prop);
+    }
+  });
+  readonlyPageCache.set(page, proxy);
+  return proxy;
+}
+function resolveRequestMethod(input, init) {
+  const requestMethod = typeof Request !== "undefined" && input instanceof Request ? input.method : void 0;
+  return (init?.method ?? requestMethod ?? "GET").toUpperCase();
+}
+function assertReadonlyRequestBodyAllowed(input, init) {
+  if (init?.body !== void 0) {
+    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"
+    );
+  }
+}
+function createReadonlyExecHelpers(page, options = {}) {
+  const readonlyPage = wrapPageForReadonlyExec(page, options);
+  const execState = {};
+  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, deltaY) => {
+      await page.evaluate(
+        ([x, y]) => {
+          window.scrollBy(x, y);
+        },
+        [deltaX, deltaY]
+      );
+      markActivity(options.onActivity);
+    },
+    get: async (input, init) => {
+      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
+  };
+}
+export {
+  ReadonlyExecDeniedError,
+  createReadonlyExecHelpers,
+  wrapLocatorForReadonlyExec,
+  wrapPageForReadonlyExec
+};

package/dist/{shared/llm/client.js → cli/core/resolve-model.js}

@@ -1,4 +1,3 @@
-import { generateObject } from "ai";
 const GEMINI_API_KEY_ENV_VARS = [
   "GEMINI_API_KEY",
   "GOOGLE_GENERATIVE_AI_API_KEY"
@@ -108,76 +107,13 @@ async function getProviderModel(provider, modelId) {
     }
   }
 }
-function convertUserContentParts(parts) {
-  return parts.map((part) => {
-    if (part.type === "text") {
-      return { type: "text", text: part.text };
-    }
-    return {
-      type: "image",
-      image: part.image,
-      ...part.mediaType ? { mediaType: part.mediaType } : {}
-    };
-  });
-}
-function convertAssistantContentParts(parts) {
-  return parts.filter(
-    (part) => part.type === "text"
-  ).map((part) => ({ type: "text", text: part.text }));
-}
-function convertMessages(messages) {
-  return messages.map((msg) => {
-    if (msg.role === "user") {
-      if (typeof msg.content === "string") {
-        return { role: "user", content: msg.content };
-      }
-      return {
-        role: "user",
-        content: convertUserContentParts(msg.content)
-      };
-    }
-    if (typeof msg.content === "string") {
-      return { role: "assistant", content: msg.content };
-    }
-    return {
-      role: "assistant",
-      content: convertAssistantContentParts(msg.content)
-    };
-  });
-}
-function createLLMClient(model) {
+async function resolveModel(model) {
   const { provider, modelId } = parseModel(model);
-  let modelPromise = null;
-  const getModel = () => {
-    modelPromise ??= getProviderModel(provider, modelId);
-    return modelPromise;
-  };
-  return {
-    async generateObject(opts) {
-      const aiModel = await getModel();
-      const result = await generateObject({
-        model: aiModel,
-        prompt: opts.prompt,
-        schema: opts.schema,
-        temperature: opts.temperature ?? 0
-      });
-      return result.object;
-    },
-    async generateObjectFromMessages(opts) {
-      const aiModel = await getModel();
-      const result = await generateObject({
-        model: aiModel,
-        messages: convertMessages(opts.messages),
-        schema: opts.schema,
-        temperature: opts.temperature ?? 0
-      });
-      return result.object;
-    }
-  };
+  return getProviderModel(provider, modelId);
 }
 export {
-  createLLMClient,
   hasProviderCredentials,
   missingProviderCredentialsMessage,
-  parseModel
+  parseModel,
+  resolveModel
 };

package/dist/cli/core/session.js

@@ -13,6 +13,7 @@ import {
   LIBRETTO_SESSIONS_DIR
 } from "./context.js";
 import {
+  SessionAccessModeSchema,
   SESSION_STATE_VERSION,
   parseSessionStateContent,
   serializeSessionState
@@ -28,6 +29,9 @@ function generateSessionName() {
   }
   return `ses-${id}`;
 }
+function resolveSessionAccessMode(state) {
+  return SessionAccessModeSchema.parse(state?.mode);
+}
 function logFileForSession(session) {
   validateSessionName(session);
   const dir = getSessionDir(session);
@@ -85,6 +89,17 @@ function listSessionsWithStateFile() {
 function listActiveSessions() {
   return listSessionsWithStateFile();
 }
+function listRunningSessions() {
+  const sessions = listSessionsWithStateFile();
+  const running = [];
+  for (const name of sessions) {
+    const state = readSessionState(name);
+    if (!state) continue;
+    if (state.pid == null || !isPidRunning(state.pid)) continue;
+    running.push(state);
+  }
+  return running;
+}
 function throwSessionNotFoundError(session) {
   const active = listActiveSessions();
   const lines = [`No session "${session}" found.`];
@@ -132,10 +147,34 @@ function writeSessionState(state, logger) {
   logger?.info("session-state-write", {
     session: state.session,
     stateFile,
+    mode: state.mode,
     port: state.port,
     pid: state.pid
   });
 }
+function setSessionMode(session, mode, logger) {
+  const state = readSessionStateOrThrow(session);
+  const normalizedMode = SessionAccessModeSchema.parse(mode);
+  if (state.mode === normalizedMode) {
+    return state;
+  }
+  const nextState = {
+    ...state,
+    mode: normalizedMode
+  };
+  writeSessionState(nextState, logger);
+  return nextState;
+}
+function assertSessionAllowsCommand(state, commandName, allowedModes) {
+  const mode = resolveSessionAccessMode(state);
+  if (allowedModes.includes(mode)) {
+    return;
+  }
+  const supportedModes = [...allowedModes].join(", ");
+  throw new Error(
+    `Command "${commandName}" is blocked for session "${state.session}" because it is in ${mode} mode. Allowed modes for this command: ${supportedModes}. Run \`libretto session-mode write-access --session ${state.session}\` to unlock the session.`
+  );
+}
 function clearSessionState(session, logger) {
   const stateFile = getStateFilePath(session);
   if (!existsSync(stateFile)) {
@@ -181,15 +220,20 @@ export {
   SESSION_BROWSER_AGENT,
   SESSION_DEV_SERVER,
   SESSION_STATE_VERSION,
+  assertSessionAllowsCommand,
   assertSessionAvailableForStart,
   assertSessionStateExistsOrThrow,
   clearSessionState,
   generateSessionName,
   getStateFilePath,
+  isPidRunning,
+  listRunningSessions,
   listSessionsWithStateFile,
   logFileForSession,
   readSessionState,
   readSessionStateOrThrow,
+  resolveSessionAccessMode,
+  setSessionMode,
   setSessionStatus,
   validateSessionName,
   writeSessionState