libretto 0.6.7 → 0.6.8

package/src/cli/core/browser-daemon.ts

@@ -0,0 +1,198 @@
+/**
+ * Browser daemon process.
+ *
+ * Launched as a detached child process by `runOpen()` in `browser.ts`.
+ * Receives configuration as a JSON string in `process.argv[2]`.
+ *
+ * Responsibilities:
+ * - Launch Chromium with the specified settings
+ * - Create a browser context and page
+ * - Install session telemetry (network/action logging)
+ * - Navigate to the requested URL
+ * - Stay alive until the browser disconnects or a signal is received
+ */
+
+import { chromium } from "playwright";
+import { mkdir, unlink } from "node:fs/promises";
+import { appendFileSync } from "node:fs";
+import { installSessionTelemetry } from "./session-telemetry.js";
+import {
+  getSessionDir,
+  getSessionLogsPath,
+  getSessionNetworkLogPath,
+  getSessionActionsLogPath,
+  getSessionStatePath,
+} from "./context.js";
+
+// ── Config schema ──────────────────────────────────────────────────────
+
+type DaemonConfig = {
+  port: number;
+  url: string;
+  session: string;
+  headed: boolean;
+  viewport: { width: number; height: number };
+  storageStatePath?: string;
+  windowPosition?: { x: number; y: number };
+};
+
+const config: DaemonConfig = JSON.parse(process.argv[2]);
+
+// ── Derived paths ──────────────────────────────────────────────────────
+
+const sessionDir = getSessionDir(config.session);
+await mkdir(sessionDir, { recursive: true });
+
+const logFile = getSessionLogsPath(config.session);
+const networkLogFile = getSessionNetworkLogPath(config.session);
+const actionsLogFile = getSessionActionsLogPath(config.session);
+
+type TelemetryEntry = Record<string, unknown>;
+
+function childLog(
+  level: string,
+  event: string,
+  data: Record<string, unknown> = {},
+): void {
+  const entry = JSON.stringify({
+    timestamp: new Date().toISOString(),
+    id: Math.random().toString(36).slice(2, 10),
+    level,
+    scope: "libretto.child",
+    event,
+    data,
+  });
+  appendFileSync(logFile, entry + "\n");
+}
+
+function logAction(entry: TelemetryEntry): void {
+  appendFileSync(actionsLogFile, JSON.stringify(entry) + "\n");
+}
+
+function logNetwork(entry: TelemetryEntry): void {
+  appendFileSync(networkLogFile, JSON.stringify(entry) + "\n");
+}
+
+// ── Launch browser ─────────────────────────────────────────────────────
+
+const windowPositionArg = config.windowPosition
+  ? `--window-position=${config.windowPosition.x},${config.windowPosition.y}`
+  : undefined;
+
+const launchArgs = [
+  "--disable-blink-features=AutomationControlled",
+  `--remote-debugging-port=${config.port}`,
+  "--remote-debugging-address=127.0.0.1",
+  "--no-focus-on-check",
+  ...(windowPositionArg ? [windowPositionArg] : []),
+];
+
+const browser = await chromium.launch({
+  headless: !config.headed,
+  args: launchArgs,
+});
+
+async function cleanupSessionState(): Promise<void> {
+  const sessionStatePath = getSessionStatePath(config.session);
+  try {
+    await unlink(sessionStatePath);
+  } catch (err) {
+    if ((err as NodeJS.ErrnoException).code !== "ENOENT") throw err;
+  }
+}
+
+let shuttingDown = false;
+let wakeDaemon: () => void;
+const sleepPromise = new Promise<void>((resolve) => {
+  wakeDaemon = resolve;
+});
+
+async function shutdown(
+  reason: string,
+  closeBrowser: boolean,
+): Promise<void> {
+  if (shuttingDown) return;
+  shuttingDown = true;
+  try {
+    childLog("info", reason, { port: config.port });
+    await cleanupSessionState();
+    if (closeBrowser) await browser.close();
+  } finally {
+    wakeDaemon();
+  }
+}
+
+browser.on("disconnected", () => {
+  void shutdown("browser-disconnected-exiting", false);
+});
+
+// ── Create context & page ──────────────────────────────────────────────
+
+const context = await browser.newContext({
+  ...(config.storageStatePath ? { storageState: config.storageStatePath } : {}),
+  viewport: {
+    width: config.viewport.width,
+    height: config.viewport.height,
+  },
+  userAgent:
+    "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Safari/537.36",
+});
+
+const page = await context.newPage();
+
+// ── Page defaults & telemetry ──────────────────────────────────────────
+
+page.setDefaultTimeout(30000);
+page.setDefaultNavigationTimeout(45000);
+
+await installSessionTelemetry({
+  context,
+  initialPage: page,
+  includeUserDomActions: true,
+  logAction,
+  logNetwork,
+});
+
+// ── Navigate ───────────────────────────────────────────────────────────
+
+await page.goto(config.url);
+
+// ── Process lifecycle ──────────────────────────────────────────────────
+
+process.on("SIGTERM", () => {
+  void shutdown("child-sigterm", true);
+});
+
+process.on("SIGINT", () => {
+  void shutdown("child-sigint", true);
+});
+
+process.on("uncaughtException", (err) => {
+  childLog("error", "uncaught-exception", {
+    message: err.message,
+    stack: err.stack,
+  });
+  process.exit(1);
+});
+
+process.on("unhandledRejection", (reason) => {
+  childLog("warn", "unhandled-rejection", { reason: String(reason) });
+});
+
+process.on("exit", (code) => {
+  childLog("info", "child-exit", {
+    code,
+    pid: process.pid,
+    port: config.port,
+  });
+});
+
+childLog("info", "child-launched", {
+  port: config.port,
+  pid: process.pid,
+  session: config.session,
+});
+
+// Keep the daemon alive until the browser disconnects or a signal arrives.
+await sleepPromise;
+process.exit(0);

package/src/cli/core/browser.ts

@@ -5,27 +5,15 @@ import {
   type CDPSession,
   type Page,
 } from "playwright";
-import { openSync, existsSync, writeFileSync } from "node:fs";
-import { basename, dirname, join, resolve } from "node:path";
-import { fileURLToPath } from "node:url";
+import { openSync, closeSync, existsSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
 import { createRequire } from "node:module";
 import { createServer } from "node:net";
 import { spawn } from "node:child_process";
 import type { LoggerApi } from "../../shared/logger/index.js";
 import type { SessionAccessMode } from "../../shared/state/index.js";
-import {
-  filterSemanticClasses,
-  INTERACTIVE_ROLE_NAMES,
-  INTERACTIVE_TAG_NAMES,
-  isObfuscatedClass,
-  TEST_ATTRIBUTE_NAMES,
-  TRUSTED_ATTRIBUTE_NAMES,
-} from "../../shared/dom-semantics.js";
-import {
-  getSessionActionsLogPath,
-  getSessionNetworkLogPath,
-  PROFILES_DIR,
-} from "./context.js";
+import { PROFILES_DIR } from "./context.js";
 import { readLibrettoConfig } from "./config.js";
 import {
   assertSessionAvailableForStart,
@@ -39,7 +27,6 @@ import {
 } from "./session.js";
 import type { ProviderApi } from "./providers/types.js";
 import { getCloudProviderApi } from "./providers/index.js";
-import { installSessionTelemetry } from "./session-telemetry.js";
 
 const CLOSE_WAIT_MS = 1_500;
 const FORCE_CLOSE_WAIT_MS = 300;
@@ -434,8 +421,6 @@ export async function runOpen(
 
   const port = await pickFreePort();
   const runLogPath = logFileForSession(session);
-  const networkLogPath = getSessionNetworkLogPath(session);
-  const actionsLogPath = getSessionActionsLogPath(session);
 
   const browserMode = headed ? "headed" : "headless";
   const supportsSavedProfile =
@@ -459,178 +444,33 @@ export async function runOpen(
   }
   console.log(`Launching ${browserMode} browser (session: ${session})...`);
 
-  const escapedUrl = url.replace(/\\/g, "\\\\").replace(/'/g, "\\'");
-  const storageStateCode = useProfile
-    ? `storageState: '${profilePath!
-        .replace(/\\/g, "\\\\")
-        .replace(/'/g, "\\'")}',`
-    : "";
-
-  const escapedLogPath = runLogPath.replace(/\\/g, "\\\\").replace(/'/g, "\\'");
-  const escapedNetworkLogPath = networkLogPath
-    .replace(/\\/g, "\\\\")
-    .replace(/'/g, "\\'");
-  const escapedActionsLogPath = actionsLogPath
-    .replace(/\\/g, "\\\\")
-    .replace(/'/g, "\\'");
-  const windowPositionArg = windowPosition
-    ? `, '--window-position=${windowPosition.x},${windowPosition.y}'`
-    : "";
-  const windowBoundsSetupCode = windowPosition
-    ? `
-const requestedWindowBounds = { left: ${windowPosition.x}, top: ${windowPosition.y}, windowState: 'normal' };
-const pageCdp = await context.newCDPSession(page);
-let browserCdp;
-try {
-	const targetInfo = await pageCdp.send('Target.getTargetInfo');
-	const targetId = targetInfo?.targetInfo?.targetId;
-	browserCdp = await browser.newBrowserCDPSession();
-	const windowResult = await browserCdp.send(
-		'Browser.getWindowForTarget',
-		targetId ? { targetId } : {},
-	);
-	await browserCdp.send('Browser.setWindowBounds', {
-		windowId: windowResult.windowId,
-		bounds: requestedWindowBounds,
-	});
-	await new Promise((resolve) => setTimeout(resolve, 250));
-	const actualWindow = await browserCdp.send('Browser.getWindowBounds', {
-		windowId: windowResult.windowId,
-	});
-	childLog('info', 'window-bounds-set', {
-		windowId: windowResult.windowId,
-		requestedBounds: requestedWindowBounds,
-		actualBounds: actualWindow.bounds,
-	});
-} catch (error) {
-	childLog('warn', 'window-bounds-set-failed', {
-		requestedBounds: requestedWindowBounds,
-		message: error instanceof Error ? error.message : String(error),
-		stack: error instanceof Error ? error.stack : undefined,
-	});
-} finally {
-	await pageCdp.detach().catch(() => {});
-	if (browserCdp) {
-		await browserCdp.detach().catch(() => {});
-	}
-}
-`
-    : "";
-
-  const launcherCode = `
-import { chromium } from 'playwright';
-import { appendFileSync, mkdirSync } from 'node:fs';
-import { dirname } from 'node:path';
-
-const LOG_FILE = '${escapedLogPath}';
-const NETWORK_LOG = '${escapedNetworkLogPath}';
-const ACTIONS_LOG = '${escapedActionsLogPath}';
-mkdirSync(dirname(NETWORK_LOG), { recursive: true });
-
-// tsx/esbuild may emit __name() wrappers in Function#toString output.
-	const __name = (target, value) =>
-		Object.defineProperty(target, 'name', { value, configurable: true });
-
-	const TEST_ATTRIBUTE_NAMES = ${JSON.stringify([...TEST_ATTRIBUTE_NAMES])};
-	const TRUSTED_ATTRIBUTE_NAMES = ${JSON.stringify([...TRUSTED_ATTRIBUTE_NAMES])};
-	const INTERACTIVE_TAG_NAMES = ${JSON.stringify([...INTERACTIVE_TAG_NAMES])};
-	const INTERACTIVE_ROLE_NAMES = ${JSON.stringify([...INTERACTIVE_ROLE_NAMES])};
-	const filterSemanticClasses = ${filterSemanticClasses.toString()};
-	const isObfuscatedClass = ${isObfuscatedClass.toString()};
-
-	${installSessionTelemetry.toString()}
-
-	function logAction(entry) {
-		appendFileSync(ACTIONS_LOG, JSON.stringify(entry) + '\\n');
-	}
-
-function logNetwork(entry) {
-	appendFileSync(NETWORK_LOG, JSON.stringify(entry) + '\\n');
-}
-
-function childLog(level, event, data = {}) {
-	try {
-		const entry = JSON.stringify({
-			timestamp: new Date().toISOString(),
-			id: Math.random().toString(36).slice(2, 10),
-			level,
-			scope: 'libretto.child',
-			event,
-			data,
-		});
-		appendFileSync(LOG_FILE, entry + '\\n');
-	} catch {}
-}
-
-const browser = await chromium.launch({
-	headless: ${!headed},
-	args: ['--disable-blink-features=AutomationControlled', '--remote-debugging-port=${port}', '--remote-debugging-address=127.0.0.1', '--no-focus-on-check'${windowPositionArg}],
-});
-
-browser.on('disconnected', () => {
-	childLog('warn', 'browser-disconnected', { port: ${port} });
-});
-
-const context = await browser.newContext({
-	${storageStateCode}
-	viewport: { width: ${viewport.width}, height: ${viewport.height} },
-	userAgent: 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Safari/537.36',
-});
-
-const page = await context.newPage();
-${windowBoundsSetupCode}
-page.setDefaultTimeout(30000);
-page.setDefaultNavigationTimeout(45000);
-
-await installSessionTelemetry({
-	context,
-	initialPage: page,
-	includeUserDomActions: true,
-	logAction,
-	logNetwork,
-});
-
-
-await page.goto('${escapedUrl}');
-
-process.on('SIGTERM', async () => {
-	childLog('info', 'child-sigterm');
-	await browser.close();
-	process.exit(0);
-});
-
-process.on('SIGINT', async () => {
-	childLog('info', 'child-sigint');
-	await browser.close();
-	process.exit(0);
-});
-
-process.on('uncaughtException', (err) => {
-	childLog('error', 'uncaught-exception', { message: err.message, stack: err.stack });
-	process.exit(1);
-});
-
-process.on('unhandledRejection', (reason) => {
-	childLog('warn', 'unhandled-rejection', { reason: String(reason) });
-});
-
-process.on('exit', (code) => {
-	childLog('info', 'child-exit', { code, pid: process.pid, port: ${port} });
-});
-
-childLog('info', 'child-launched', { port: ${port}, pid: process.pid, session: '${session}' });
-
-await new Promise(() => {});
-`;
+  const daemonEntryPath = fileURLToPath(
+    new URL("./browser-daemon.js", import.meta.url),
+  );
+  const require = createRequire(import.meta.url);
+  const tsxImportPath = pathToFileURL(require.resolve("tsx/esm")).href;
+  const daemonConfig = {
+    port,
+    url,
+    session,
+    headed,
+    viewport,
+    storageStatePath: useProfile ? profilePath : undefined,
+    windowPosition,
+  };
 
   const childStderrFd = openSync(runLogPath, "a");
 
-  const child = spawn("node", ["--input-type=module", "-e", launcherCode], {
-    detached: true,
-    stdio: ["ignore", "ignore", childStderrFd],
-    cwd: resolve(dirname(fileURLToPath(import.meta.url)), "../../.."),
-  });
+  const child = spawn(
+    process.execPath,
+    ["--import", tsxImportPath, daemonEntryPath, JSON.stringify(daemonConfig)],
+    {
+      detached: true,
+      stdio: ["ignore", "ignore", childStderrFd],
+    },
+  );
   child.unref();
+  closeSync(childStderrFd);
 
   logger.info("open-child-spawned", { pid: child.pid, port, session });
 

package/src/cli/core/config.ts

@@ -67,7 +67,7 @@ function invalidConfigError(configPath: string, detail?: string): Error {
       '  - "snapshotModel", "viewport", "windowPosition", and "sessionMode" are optional.',
       '  - "snapshotModel" must be a provider/model string like "openai/gpt-5.4" or "anthropic/claude-sonnet-4-6".',
       "Fix the file to match this shape, or delete it and rerun:",
-      `  npx libretto ai configure openai | anthropic | gemini | vertex`,
+      `  npx libretto ai configure openai | anthropic | gemini | vertex | openrouter`,
     ]
       .filter(Boolean)
       .join("\n"),

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

@@ -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;