libretto 0.6.7-experimental.0 → 0.6.8

package/src/cli/core/providers/libretto-cloud.ts

@@ -13,6 +13,8 @@ export function createLibrettoCloudProvider(): ProviderApi {
     );
   const endpoint = apiUrl.replace(/\/$/, "");
 
+  // The Libretto Cloud API is an oRPC RPCHandler, not plain REST, so inputs
+  // must be wrapped as { json: ... } and outputs arrive the same way.
   return {
     async createSession() {
       const timeoutSeconds = Number(
@@ -24,7 +26,9 @@ export function createLibrettoCloudProvider(): ProviderApi {
           "x-api-key": apiKey,
           "Content-Type": "application/json",
         },
-        body: JSON.stringify({ timeout_seconds: timeoutSeconds }),
+        body: JSON.stringify({
+          json: { timeout_seconds: timeoutSeconds },
+        }),
       });
       if (!resp.ok) {
         const body = await resp.text();
@@ -32,9 +36,8 @@ export function createLibrettoCloudProvider(): ProviderApi {
           `Libretto Cloud API error (${resp.status}): ${body}`,
         );
       }
-      const json = (await resp.json()) as {
-        session_id: string;
-        cdp_url: string;
+      const { json } = (await resp.json()) as {
+        json: { session_id: string; cdp_url: string };
       };
       return {
         sessionId: json.session_id,
@@ -48,7 +51,7 @@ export function createLibrettoCloudProvider(): ProviderApi {
           "x-api-key": apiKey,
           "Content-Type": "application/json",
         },
-        body: JSON.stringify({ session_id: sessionId }),
+        body: JSON.stringify({ json: { session_id: sessionId } }),
       });
       if (!resp.ok) {
         const body = await resp.text();

package/src/cli/core/resolve-model.ts

@@ -1,6 +1,6 @@
 import type { LanguageModel } from "ai";
 
-export type Provider = "google" | "vertex" | "anthropic" | "openai";
+export type Provider = "google" | "vertex" | "anthropic" | "openai" | "openrouter";
 
 const GEMINI_API_KEY_ENV_VARS = [
   "GEMINI_API_KEY",
@@ -19,6 +19,7 @@ const SUPPORTED_PROVIDER_ALIASES = {
   anthropic: "anthropic",
   codex: "openai",
   openai: "openai",
+  openrouter: "openrouter",
 } as const satisfies Record<string, Provider>;
 
 function readFirstEnvValue(
@@ -51,7 +52,7 @@ export function parseModel(model: string): {
 
   if (!provider) {
     throw new Error(
-      `Unsupported provider "${providerInput}". Supported providers: openai/codex, anthropic, google (Gemini API), and vertex.`,
+      `Unsupported provider "${providerInput}". Supported providers: openai/codex, anthropic, google (Gemini API), vertex, and openrouter.`,
     );
   }
 
@@ -71,6 +72,8 @@ export function hasProviderCredentials(
       return Boolean(env.ANTHROPIC_API_KEY?.trim());
     case "openai":
       return Boolean(env.OPENAI_API_KEY?.trim());
+    case "openrouter":
+      return Boolean(env.OPENROUTER_API_KEY?.trim());
   }
 }
 
@@ -86,6 +89,9 @@ export function missingProviderCredentialsMessage(provider: Provider): string {
     case "openai": {
       return "OpenAI API key is missing. Set OPENAI_API_KEY.";
     }
+    case "openrouter": {
+      return "OpenRouter API key is missing. Set OPENROUTER_API_KEY.";
+    }
   }
 }
 
@@ -133,6 +139,18 @@ async function getProviderModel(
       const openai = createOpenAI({ apiKey });
       return openai(modelId);
     }
+    case "openrouter": {
+      const apiKey = process.env.OPENROUTER_API_KEY?.trim();
+      if (!apiKey) {
+        throw new Error(missingProviderCredentialsMessage(provider));
+      }
+      const { createOpenAI } = await import("@ai-sdk/openai");
+      const openrouter = createOpenAI({
+        apiKey,
+        baseURL: "https://openrouter.ai/api/v1",
+      });
+      return openrouter(modelId);
+    }
   }
 }
 

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

@@ -4,7 +4,7 @@ import { mkdir, writeFile } from "node:fs/promises";
 import { cwd } from "node:process";
 import { isAbsolute, resolve } from "node:path";
 import { pathToFileURL } from "node:url";
-import { loadProjectEnv } from "../../shared/env/load-env.js";
+import { loadEnv } from "../../shared/env/load-env.js";
 import {
   getDefaultWorkflowFromModuleExports,
   getWorkflowsFromModuleExports,
@@ -196,7 +196,7 @@ async function runIntegrationInternal(
   const { logger } = options;
   const absolutePath = getAbsoluteIntegrationPath(args.integrationPath);
 
-  const envPath = loadProjectEnv(absolutePath);
+  const envPath = loadEnv();
   if (envPath) {
     logger.info("loaded-env", { path: envPath });
   }
@@ -269,6 +269,16 @@ async function runIntegrationInternal(
     },
   });
 
+  // tsx/esbuild injects __name() wrappers when keepNames is true. Playwright
+  // serializes callbacks via Function#toString() into the browser context which
+  // lacks __name, causing ReferenceError. Inject a no-op polyfill into every page.
+  await browserSession.context.addInitScript(() => {
+    (globalThis as Record<string, unknown>).__name = (
+      target: unknown,
+      value: string,
+    ) => Object.defineProperty(target as object, "name", { value, configurable: true });
+  });
+
   const workflowContext: LibrettoWorkflowContext = {
     session: args.session,
     page: browserSession.page,

package/src/shared/dom-semantics.ts

@@ -58,7 +58,6 @@ export function isObfuscatedClass(cls: string): boolean {
   if (cls.length > 80) return true;
   if (/^_?[0-9a-f]{6,}$/i.test(cls)) return true;
   if (/^[a-z]+_[0-9a-f]{4,}$/i.test(cls)) return true;
-  if (/^[a-z]{1,2}[0-9]{2,}$/i.test(cls)) return true;
 
   const digits = (cls.match(/[0-9]/g) || []).length;
   const letters = (cls.match(/[a-zA-Z]/g) || []).length;

package/src/shared/env/load-env.ts

@@ -1,69 +1,91 @@
 import { existsSync, readFileSync } from "node:fs";
-import { dirname, join } from "node:path";
+import { dirname, join, resolve } from "node:path";
+import { resolveLibrettoRepoRoot } from "../paths/repo-root.js";
 
-/**
- * Walk up from `startDir` until a `.env` file is found.
- * Returns the full path to the `.env`, or `null` if the filesystem root is reached.
- */
-function findNearestEnv(startDir: string): string | null {
-  let dir = startDir;
-  while (true) {
-    const envPath = join(dir, ".env");
-    if (existsSync(envPath)) return envPath;
-    const parent = dirname(dir);
-    if (parent === dir) return null; // filesystem root
-    dir = parent;
+const REPO_ROOT = resolveLibrettoRepoRoot();
+
+export function parseDotEnvAssignment(
+  line: string,
+): { key: string; value: string } | null {
+  const trimmed = line.trim();
+  if (!trimmed || trimmed.startsWith("#")) return null;
+
+  const withoutExport = trimmed.startsWith("export ")
+    ? trimmed.slice("export ".length).trimStart()
+    : trimmed;
+  const eqIdx = withoutExport.indexOf("=");
+  if (eqIdx < 1) return null;
+
+  const key = withoutExport.slice(0, eqIdx).trim();
+  if (!key) return null;
+
+  const rawValue = withoutExport.slice(eqIdx + 1).trimStart();
+  if (!rawValue) {
+    return { key, value: "" };
   }
-}
 
-/**
- * Parse a `.env` file into key-value pairs.
- * Handles KEY=VALUE, KEY="VALUE", KEY='VALUE', comments (#), and blank lines.
- * Does not support multiline values or variable interpolation.
- */
-function parseEnvFile(content: string): Record<string, string> {
-  const vars: Record<string, string> = {};
-  for (const raw of content.split("\n")) {
-    const line = raw.trim();
-    if (!line || line.startsWith("#")) continue;
-    const withoutExport = line.startsWith("export ")
-      ? line.slice("export ".length).trimStart()
-      : line;
-    const eqIndex = withoutExport.indexOf("=");
-    if (eqIndex === -1) continue;
-    const key = withoutExport.slice(0, eqIndex).trim();
-    let value = withoutExport.slice(eqIndex + 1).trim();
-    // Strip matching quotes
-    if (
-      (value.startsWith('"') && value.endsWith('"')) ||
-      (value.startsWith("'") && value.endsWith("'"))
-    ) {
-      value = value.slice(1, -1);
-    } else {
-      // Strip inline comments from unquoted values
-      const commentIndex = value.search(/\s#/);
-      if (commentIndex >= 0) {
-        value = value.slice(0, commentIndex).trimEnd();
-      }
+  if (rawValue.startsWith('"')) {
+    const closeIdx = rawValue.indexOf('"', 1);
+    if (closeIdx > 0) {
+      return { key, value: rawValue.slice(1, closeIdx) };
     }
-    vars[key] = value;
+    return { key, value: rawValue.slice(1) };
+  }
+
+  if (rawValue.startsWith("'")) {
+    const closeIdx = rawValue.indexOf("'", 1);
+    if (closeIdx > 0) {
+      return { key, value: rawValue.slice(1, closeIdx) };
+    }
+    return { key, value: rawValue.slice(1) };
+  }
+
+  const inlineCommentIndex = rawValue.search(/\s#/);
+  const value =
+    inlineCommentIndex >= 0
+      ? rawValue.slice(0, inlineCommentIndex).trimEnd()
+      : rawValue.trim();
+  return { key, value };
+}
+
+function readWorktreeEnvPath(): string | null {
+  const gitPath = join(REPO_ROOT, ".git");
+  if (!existsSync(gitPath)) return null;
+
+  try {
+    const gitPointer = readFileSync(gitPath, "utf-8").trim();
+    const match = gitPointer.match(/^gitdir:\s*(.+)$/i);
+    if (!match?.[1]) return null;
+    const worktreeGitDir = resolve(REPO_ROOT, match[1].trim());
+    const commonGitDir = resolve(worktreeGitDir, "..", "..");
+    return join(dirname(commonGitDir), ".env");
+  } catch {
+    return null;
   }
-  return vars;
 }
 
 /**
- * Load the nearest `.env` file above `scriptPath`.
- * Existing `process.env` values are never overridden.
+ * Load the `.env` file at the repository root into `process.env`.
+ * Existing values are never overridden.
+ * Respects `LIBRETTO_DISABLE_DOTENV=1` to skip loading entirely.
  * Returns the path of the loaded `.env`, or `null` if none was found.
  */
-export function loadProjectEnv(scriptPath: string): string | null {
-  const envPath = findNearestEnv(dirname(scriptPath));
+export function loadEnv(): string | null {
+  if (process.env.LIBRETTO_DISABLE_DOTENV?.trim() === "1") return null;
+
+  const envPathCandidates = [
+    join(REPO_ROOT, ".env"),
+    readWorktreeEnvPath(),
+  ].filter((value): value is string => Boolean(value));
+
+  const envPath = envPathCandidates.find((candidate) => existsSync(candidate));
   if (!envPath) return null;
 
-  const vars = parseEnvFile(readFileSync(envPath, "utf8"));
-  for (const [key, value] of Object.entries(vars)) {
-    if (process.env[key] === undefined) {
-      process.env[key] = value;
+  for (const line of readFileSync(envPath, "utf-8").split("\n")) {
+    const parsed = parseDotEnvAssignment(line);
+    if (!parsed) continue;
+    if (!(parsed.key in process.env)) {
+      process.env[parsed.key] = parsed.value;
     }
   }
   return envPath;