libretto 0.5.0 → 0.5.2

package/dist/cli/core/browser.js

@@ -1,9 +1,19 @@
-import { chromium } from "playwright";
+import {
+  chromium
+} from "playwright";
 import { openSync, existsSync } from "node:fs";
 import { dirname, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { createServer } from "node:net";
 import { spawn } from "node:child_process";
+import {
+  filterSemanticClasses,
+  INTERACTIVE_ROLE_NAMES,
+  INTERACTIVE_TAG_NAMES,
+  isObfuscatedClass,
+  TEST_ATTRIBUTE_NAMES,
+  TRUSTED_ATTRIBUTE_NAMES
+} from "../../shared/dom-semantics.js";
 import {
   getSessionActionsLogPath,
   getSessionNetworkLogPath,
@@ -57,9 +67,8 @@ function getProfilePath(domain) {
 function hasProfile(domain) {
   return existsSync(getProfilePath(domain));
 }
-async function tryConnectToPort(port, logger, timeoutMs = 5e3) {
-  const endpoint = `http://localhost:${port}`;
-  logger.info("cdp-connect-attempt", { port, endpoint, timeoutMs });
+async function tryConnectToCDP(endpoint, logger, timeoutMs = 5e3) {
+  logger.info("cdp-connect-attempt", { endpoint, timeoutMs });
   try {
     const connectPromise = chromium.connectOverCDP(endpoint);
     const timeoutPromise = new Promise(
@@ -68,16 +77,15 @@ async function tryConnectToPort(port, logger, timeoutMs = 5e3) {
     const browser = await Promise.race([connectPromise, timeoutPromise]);
     if (browser) {
       logger.info("cdp-connect-success", {
-        port,
         endpoint,
         contexts: browser.contexts().length
       });
     } else {
-      logger.warn("cdp-connect-timeout", { port, endpoint, timeoutMs });
+      logger.warn("cdp-connect-timeout", { endpoint, timeoutMs });
     }
     return browser;
   } catch (err) {
-    logger.error("cdp-connect-error", { error: err, port, endpoint });
+    logger.error("cdp-connect-error", { error: err, endpoint });
     return null;
   }
 }
@@ -102,7 +110,9 @@ async function resolvePageId(page) {
     const targetInfo = await cdpSession.send("Target.getTargetInfo");
     const targetId = targetInfo?.targetInfo?.targetId;
     if (typeof targetId !== "string" || targetId.length === 0) {
-      throw new Error(`Could not resolve target id for page at URL "${page.url()}".`);
+      throw new Error(
+        `Could not resolve target id for page at URL "${page.url()}".`
+      );
     }
     return targetId;
   } finally {
@@ -135,21 +145,22 @@ async function listOpenPages(session, logger) {
 async function connect(session, logger, timeoutMs = 1e4, options) {
   logger.info("connect", { session, timeoutMs });
   const state = readSessionStateOrThrow(session);
-  const browser = await tryConnectToPort(state.port, logger, timeoutMs);
+  const endpoint = state.cdpEndpoint ?? `http://localhost:${state.port}`;
+  const browser = await tryConnectToCDP(endpoint, logger, timeoutMs);
   if (!browser) {
     logger.error("connect-no-browser", {
       session,
-      port: state.port,
+      endpoint,
       pid: state.pid
     });
-    if (!isPidRunning(state.pid)) {
+    if (state.pid == null || !isPidRunning(state.pid)) {
       clearSessionState(session, logger);
       throw new Error(
         `No browser running for session "${session}". Run 'libretto open <url> --session ${session}' first.`
       );
     }
     throw new Error(
-      `Could not connect to the browser for session "${session}" at http://127.0.0.1:${state.port}, but the session process (pid ${state.pid}) is still running. Try the command again, or close and reopen the session if it stays stuck.`
+      `Could not connect to the browser for session "${session}" at ${endpoint}, but the session process (pid ${state.pid}) is still running. Try the command again, or close and reopen the session if it stays stuck.`
     );
   }
   const contexts = browser.contexts();
@@ -230,16 +241,34 @@ function resolveViewport(cliViewport, logger) {
   }
   const config = readLibrettoConfig();
   if (config.viewport) {
-    logger.info("viewport-source", { source: "config", viewport: config.viewport });
+    logger.info("viewport-source", {
+      source: "config",
+      viewport: config.viewport
+    });
     return config.viewport;
   }
-  logger.info("viewport-source", { source: "default", viewport: DEFAULT_VIEWPORT });
+  logger.info("viewport-source", {
+    source: "default",
+    viewport: DEFAULT_VIEWPORT
+  });
   return DEFAULT_VIEWPORT;
 }
+function resolveWindowPosition(logger) {
+  const config = readLibrettoConfig();
+  if (config.windowPosition) {
+    logger.info("window-position-source", {
+      source: "config",
+      windowPosition: config.windowPosition
+    });
+    return config.windowPosition;
+  }
+  return void 0;
+}
 async function runOpen(rawUrl, headed, session, logger, options) {
   const url = normalizeUrl(rawUrl);
   const viewport = resolveViewport(options?.viewport, logger);
-  logger.info("open-start", { url, headed, session, viewport });
+  const windowPosition = headed ? resolveWindowPosition(logger) : void 0;
+  logger.info("open-start", { url, headed, session, viewport, windowPosition });
   assertSessionAvailableForStart(session, logger);
   const port = await pickFreePort();
   const runLogPath = logFileForSession(session);
@@ -268,6 +297,45 @@ async function runOpen(rawUrl, headed, session, logger, options) {
   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';
@@ -279,14 +347,21 @@ 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 __name = (target, value) =>
+		Object.defineProperty(target, 'name', { value, configurable: true });
 
-${installSessionTelemetry.toString()}
+	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()};
 
-function logAction(entry) {
-	appendFileSync(ACTIONS_LOG, JSON.stringify(entry) + '\\n');
-}
+	${installSessionTelemetry.toString()}
+
+	function logAction(entry) {
+		appendFileSync(ACTIONS_LOG, JSON.stringify(entry) + '\\n');
+	}
 
 function logNetwork(entry) {
 	appendFileSync(NETWORK_LOG, JSON.stringify(entry) + '\\n');
@@ -308,7 +383,7 @@ function childLog(level, event, data = {}) {
 
 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'],
+	args: ['--disable-blink-features=AutomationControlled', '--remote-debugging-port=${port}', '--remote-debugging-address=127.0.0.1', '--no-focus-on-check'${windowPositionArg}],
 });
 
 browser.on('disconnected', () => {
@@ -322,6 +397,7 @@ const context = await browser.newContext({
 });
 
 const page = await context.newPage();
+${windowBoundsSetupCode}
 page.setDefaultTimeout(30000);
 page.setDefaultNavigationTimeout(45000);
 
@@ -414,14 +490,17 @@ await new Promise(() => {});
       logger.info("open-waiting-for-cdp", { attempt: i, port, session });
     }
     if (ready) {
-      writeSessionState({
-        port,
-        pid: child.pid,
-        session,
-        startedAt: (/* @__PURE__ */ new Date()).toISOString(),
-        status: "active",
-        viewport
-      }, logger);
+      writeSessionState(
+        {
+          port,
+          pid: child.pid,
+          session,
+          startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+          status: "active",
+          viewport
+        },
+        logger
+      );
       logger.info("open-success", {
         url,
         mode: browserMode,
@@ -517,8 +596,10 @@ async function runClose(session, logger) {
     return;
   }
   logger.info("close-killing", { session, pid: state.pid, port: state.port });
-  sendSignalToProcessGroupOrPid(state.pid, "SIGTERM", logger, session);
-  await waitForCloseSignalWindow(CLOSE_WAIT_MS);
+  if (state.pid != null) {
+    sendSignalToProcessGroupOrPid(state.pid, "SIGTERM", logger, session);
+    await waitForCloseSignalWindow(CLOSE_WAIT_MS);
+  }
   clearSessionState(session, logger);
   logger.info("close-success", { session });
   console.log(`Browser closed (session: ${session}).`);
@@ -575,7 +656,7 @@ function resolveClosableSessions(logger) {
 function clearStoppedSessionStates(sessions, logger) {
   let cleared = 0;
   for (const session of sessions) {
-    if (!isPidRunning(session.pid)) {
+    if (session.pid == null || !isPidRunning(session.pid)) {
       clearSessionState(session.session, logger);
       cleared += 1;
     }
@@ -601,10 +682,19 @@ async function runCloseAll(logger, options) {
       pid: target.pid,
       port: target.port
     });
-    sendSignalToProcessGroupOrPid(target.pid, "SIGTERM", logger, target.session);
+    if (target.pid != null) {
+      sendSignalToProcessGroupOrPid(
+        target.pid,
+        "SIGTERM",
+        logger,
+        target.session
+      );
+    }
   }
   await waitForCloseSignalWindow(CLOSE_WAIT_MS);
-  let survivors = closable.filter((target) => isPidRunning(target.pid));
+  let survivors = closable.filter(
+    (target) => target.pid != null && isPidRunning(target.pid)
+  );
   if (survivors.length > 0 && !force) {
     const closed = clearStoppedSessionStates(closable, logger);
     throw new Error(
@@ -622,11 +712,20 @@ async function runCloseAll(logger, options) {
         session: survivor.session,
         pid: survivor.pid
       });
-      sendSignalToProcessGroupOrPid(survivor.pid, "SIGKILL", logger, survivor.session);
+      if (survivor.pid != null) {
+        sendSignalToProcessGroupOrPid(
+          survivor.pid,
+          "SIGKILL",
+          logger,
+          survivor.session
+        );
+      }
       forceKilled += 1;
     }
     await waitForCloseSignalWindow(FORCE_CLOSE_WAIT_MS);
-    survivors = survivors.filter((target) => isPidRunning(target.pid));
+    survivors = survivors.filter(
+      (target) => target.pid != null && isPidRunning(target.pid)
+    );
     if (survivors.length > 0) {
       const closed = clearStoppedSessionStates(closable, logger);
       throw new Error(
@@ -648,6 +747,75 @@ async function runCloseAll(logger, options) {
     console.log(`Force-killed ${forceKilled} session(s).`);
   }
 }
+async function runConnect(cdpUrl, session, logger) {
+  logger.info("connect-start", { cdpUrl, session });
+  assertSessionAvailableForStart(session, logger);
+  let parsedUrl;
+  try {
+    parsedUrl = new URL(cdpUrl);
+  } catch {
+    throw new Error(
+      [
+        `Invalid CDP URL: ${cdpUrl}`,
+        ``,
+        `Expected an HTTP URL pointing to a Chrome DevTools Protocol endpoint, for example:`,
+        `  libretto connect http://127.0.0.1:9222`,
+        `  libretto connect http://remote-host:9222`,
+        `  libretto connect http://remote-host:9222/devtools/browser/<id>`
+      ].join("\n")
+    );
+  }
+  const endpoint = parsedUrl.href;
+  const port = parsedUrl.port ? Number(parsedUrl.port) : parsedUrl.protocol === "https:" ? 443 : 80;
+  console.log(
+    `Connecting to CDP endpoint at ${endpoint} (session: ${session})...`
+  );
+  const versionUrl = `${parsedUrl.protocol}//${parsedUrl.host}/json/version`;
+  try {
+    const resp = await fetch(versionUrl);
+    const versionInfo = await resp.json();
+    logger.info("connect-version-ok", { versionUrl, versionInfo });
+  } catch (err) {
+    logger.error("connect-version-failed", { versionUrl, error: err });
+    throw new Error(
+      `Cannot reach CDP endpoint at ${versionUrl}. Make sure the target is running and accessible at ${parsedUrl.host}.`
+    );
+  }
+  const browser = await tryConnectToCDP(endpoint, logger, 1e4);
+  if (!browser) {
+    throw new Error(
+      `CDP endpoint at ${endpoint} is reachable but Playwright could not connect. Check that the URL is a Chrome DevTools Protocol endpoint.`
+    );
+  }
+  const pages = resolveOperationalPages(browser);
+  logger.info("connect-pages", {
+    session,
+    pageCount: pages.length,
+    urls: pages.map((p) => p.url())
+  });
+  disconnectBrowser(browser, logger, session);
+  writeSessionState(
+    {
+      port,
+      cdpEndpoint: endpoint,
+      session,
+      startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      status: "active"
+    },
+    logger
+  );
+  logger.info("connect-success", { cdpUrl: endpoint, session, port });
+  console.log(`Connected to ${endpoint} (session: ${session})`);
+  console.log(`  Pages found: ${pages.length}`);
+  if (pages.length > 0) {
+    for (const p of pages.slice(0, 5)) {
+      console.log(`    ${p.url()}`);
+    }
+    if (pages.length > 5) {
+      console.log(`    ... and ${pages.length - 5} more`);
+    }
+  }
+}
 function resolvePath(filePath) {
   return join(process.cwd(), filePath);
 }
@@ -666,8 +834,10 @@ export {
   normalizeDomain,
   normalizeUrl,
   resolvePath,
+  resolveViewport,
   runClose,
   runCloseAll,
+  runConnect,
   runOpen,
   runPages,
   runSave

package/dist/cli/core/context.js

@@ -49,7 +49,10 @@ function createLoggerForSession(session) {
   const sessionDir = getSessionDir(session);
   mkdirSync(sessionDir, { recursive: true });
   const logFilePath = getSessionLogsPath(session);
-  return new Logger(["libretto"], [createFileLogSink({ filePath: logFilePath })]);
+  return new Logger(
+    ["libretto"],
+    [createFileLogSink({ filePath: logFilePath })]
+  );
 }
 async function closeLogger(logger) {
   if (!logger) return;