libretto 0.2.7 → 0.3.0

package/dist/cli/core/browser.js

@@ -1,648 +0,0 @@
-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 {
-  getSessionActionsLogPath,
-  getSessionNetworkLogPath,
-  PROFILES_DIR
-} from "./context.js";
-import {
-  assertSessionAvailableForStart,
-  clearSessionState,
-  listSessionsWithStateFile,
-  readSessionStateOrThrow,
-  logFileForSession,
-  readSessionState,
-  writeSessionState
-} from "./session.js";
-import { installSessionTelemetry } from "./session-telemetry.js";
-const CLOSE_WAIT_MS = 1500;
-const FORCE_CLOSE_WAIT_MS = 300;
-async function pickFreePort() {
-  return await new Promise((resolve2, reject) => {
-    const server = createServer();
-    server.listen(0, "127.0.0.1", () => {
-      const address = server.address();
-      if (!address || typeof address === "string") {
-        reject(new Error("Failed to pick free port"));
-        return;
-      }
-      const port = address.port;
-      server.close(() => resolve2(port));
-    });
-    server.on("error", reject);
-  });
-}
-function normalizeUrl(url) {
-  if (!/^https?:\/\//i.test(url)) {
-    return `https://${url}`;
-  }
-  return url;
-}
-function normalizeDomain(url) {
-  try {
-    const u = new URL(normalizeUrl(url));
-    return u.hostname.replace(/^www\./, "");
-  } catch {
-    return url.replace(/^www\./, "");
-  }
-}
-function getProfilePath(domain) {
-  return join(PROFILES_DIR, `${domain}.json`);
-}
-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 });
-  try {
-    const connectPromise = chromium.connectOverCDP(endpoint);
-    const timeoutPromise = new Promise(
-      (resolve2) => setTimeout(() => resolve2(null), timeoutMs)
-    );
-    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 });
-    }
-    return browser;
-  } catch (err) {
-    logger.error("cdp-connect-error", { error: err, port, endpoint });
-    return null;
-  }
-}
-function isOperationalPage(page) {
-  const url = page.url();
-  return !url.startsWith("devtools://") && !url.startsWith("chrome-error://");
-}
-function disconnectBrowser(browser, logger, session) {
-  logger.info("cdp-disconnect", { session });
-  try {
-    browser._connection?.close();
-  } catch (err) {
-    logger.warn("cdp-disconnect-already-closed", { error: err });
-  }
-}
-function resolveOperationalPages(browser) {
-  return browser.contexts().flatMap((context) => context.pages()).filter(isOperationalPage);
-}
-async function resolvePageId(page) {
-  const cdpSession = await page.context().newCDPSession(page);
-  try {
-    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()}".`);
-    }
-    return targetId;
-  } finally {
-    await cdpSession.detach();
-  }
-}
-async function resolvePageReferences(pages) {
-  const refs = await Promise.all(
-    pages.map(async (page) => {
-      const id = await resolvePageId(page);
-      return { id, page };
-    })
-  );
-  return refs;
-}
-async function listOpenPages(session, logger) {
-  const { browser, page: activePage } = await connect(session, logger);
-  try {
-    const pages = browser.contexts().flatMap((ctx) => ctx.pages()).filter(isOperationalPage);
-    const pageRefs = await resolvePageReferences(pages);
-    return pageRefs.map(({ id, page }) => ({
-      id,
-      url: page.url(),
-      active: page === activePage
-    }));
-  } finally {
-    disconnectBrowser(browser, logger, session);
-  }
-}
-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);
-  if (!browser) {
-    logger.error("connect-no-browser", {
-      session,
-      port: state.port,
-      pid: state.pid
-    });
-    clearSessionState(session, logger);
-    throw new Error(
-      `No browser running for session "${session}". Run 'libretto-cli open <url> --session ${session}' first.`
-    );
-  }
-  const contexts = browser.contexts();
-  logger.info("connect-contexts", { session, contextCount: contexts.length });
-  if (contexts.length === 0) {
-    logger.error("connect-no-contexts", { session });
-    throw new Error("No browser context found.");
-  }
-  const allPages = contexts.flatMap((c) => c.pages());
-  const pages = resolveOperationalPages(browser);
-  logger.info("connect-pages", {
-    session,
-    totalPages: allPages.length,
-    filteredPages: pages.length,
-    urls: allPages.map((p) => p.url())
-  });
-  if (pages.length === 0) {
-    logger.error("connect-no-pages", {
-      session,
-      allPageUrls: allPages.map((p) => p.url())
-    });
-    throw new Error("No pages found.");
-  }
-  if (options?.requireSinglePage && !options.pageId && pages.length > 1) {
-    throw new Error(
-      `Multiple pages are open in session "${session}". Pass --page <id> to target a page (run "libretto-cli pages --session ${session}" to list ids).`
-    );
-  }
-  const pageRefs = await resolvePageReferences(pages);
-  const pageRef = options?.pageId ? pageRefs.find((ref) => ref.id === options.pageId) ?? null : pageRefs[pageRefs.length - 1];
-  if (!pageRef) {
-    throw new Error(
-      `Page "${options?.pageId}" was not found in session "${session}". Run "libretto-cli pages --session ${session}" to list ids.`
-    );
-  }
-  const page = pageRef.page;
-  const context = page.context();
-  page.on("close", () => {
-    logger.error("page-closed-during-command", {
-      session,
-      url: page.url(),
-      trace: new Error("page-closed-trace").stack
-    });
-  });
-  page.on("crash", () => {
-    logger.error("page-crashed-during-command", {
-      session,
-      url: page.url()
-    });
-  });
-  browser.on("disconnected", () => {
-    logger.error("browser-disconnected-during-command", {
-      session,
-      trace: new Error("browser-disconnected-trace").stack
-    });
-  });
-  logger.info("connect-success", { session, pageUrl: page.url() });
-  return { browser, context, page, pageId: pageRef.id };
-}
-async function runPages(session, logger) {
-  logger.info("pages-start", { session });
-  const pageSummaries = await listOpenPages(session, logger);
-  if (pageSummaries.length === 0) {
-    console.log("No pages found.");
-    return;
-  }
-  console.log("Open pages:");
-  pageSummaries.forEach((pageSummary) => {
-    const activeSuffix = pageSummary.active ? " active=true" : "";
-    console.log(`  id=${pageSummary.id} url=${pageSummary.url}${activeSuffix}`);
-  });
-}
-async function runOpen(rawUrl, headed, session, logger) {
-  const url = normalizeUrl(rawUrl);
-  logger.info("open-start", { url, headed, session });
-  assertSessionAvailableForStart(session, logger);
-  const port = await pickFreePort();
-  const runLogPath = logFileForSession(session);
-  const networkLogPath = getSessionNetworkLogPath(session);
-  const actionsLogPath = getSessionActionsLogPath(session);
-  const browserMode = headed ? "headed" : "headless";
-  const domain = normalizeDomain(url);
-  const profilePath = getProfilePath(domain);
-  const useProfile = hasProfile(domain);
-  logger.info("open-launching", {
-    url,
-    mode: browserMode,
-    session,
-    port,
-    domain,
-    useProfile,
-    profilePath: useProfile ? profilePath : void 0
-  });
-  if (useProfile) {
-    console.log(`Loading saved profile for ${domain}`);
-  }
-  console.log(`Launching ${browserMode} browser (session: ${session})...`);
-  const escapedProfilePath = profilePath.replace(/\\/g, "\\\\").replace(/'/g, "\\'");
-  const escapedUrl = url.replace(/\\/g, "\\\\").replace(/'/g, "\\'");
-  const storageStateCode = useProfile ? `storageState: '${escapedProfilePath}',` : "";
-  const escapedLogPath = runLogPath.replace(/\\/g, "\\\\").replace(/'/g, "\\'");
-  const escapedNetworkLogPath = networkLogPath.replace(/\\/g, "\\\\").replace(/'/g, "\\'");
-  const escapedActionsLogPath = actionsLogPath.replace(/\\/g, "\\\\").replace(/'/g, "\\'");
-  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 });
-
-${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-cli.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'],
-});
-
-browser.on('disconnected', () => {
-	childLog('warn', 'browser-disconnected', { port: ${port} });
-});
-
-const context = await browser.newContext({
-	${storageStateCode}
-	viewport: { width: 1366, height: 768 },
-	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.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 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)), "../../..")
-  });
-  child.unref();
-  logger.info("open-child-spawned", { pid: child.pid, port, session });
-  let childSpawnError = null;
-  let childEarlyExit = null;
-  child.on("error", (err) => {
-    childSpawnError = err;
-    logger.error("open-child-spawn-error", { error: err, session, port });
-  });
-  child.on("exit", (code, signal) => {
-    childEarlyExit = { code, signal };
-    logger.warn("open-child-exited", {
-      code,
-      signal,
-      session,
-      port,
-      pid: child.pid
-    });
-  });
-  const cdpPollIntervalMs = 500;
-  const cdpMaxAttempts = 30;
-  const cdpStartupTimeoutMs = cdpPollIntervalMs * cdpMaxAttempts;
-  for (let i = 0; i < cdpMaxAttempts; i++) {
-    const spawnError = childSpawnError;
-    if (spawnError !== null) {
-      const errWithCode = spawnError;
-      const hint = errWithCode.code === "ENOENT" ? " Ensure Node.js is available in PATH for child processes." : "";
-      throw new Error(
-        `Failed to launch browser child process: ${spawnError.message}.${hint} Check logs: ${runLogPath}`
-      );
-    }
-    const earlyExit = childEarlyExit;
-    if (earlyExit !== null) {
-      const status = earlyExit.code ?? earlyExit.signal ?? "unknown";
-      throw new Error(
-        `Browser child process exited before startup (status: ${status}). Check logs: ${runLogPath}`
-      );
-    }
-    await new Promise((r) => setTimeout(r, cdpPollIntervalMs));
-    const ready = await fetch(`http://127.0.0.1:${port}/json/version`).then(() => true).catch(() => false);
-    if (i > 0 && i % 5 === 0) {
-      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"
-      }, logger);
-      logger.info("open-success", {
-        url,
-        mode: browserMode,
-        session,
-        port,
-        pid: child.pid
-      });
-      console.log(`Browser open (${browserMode}): ${url}`);
-      await new Promise((r) => setTimeout(r, 2e3));
-      return;
-    }
-  }
-  logger.error("open-timeout", {
-    session,
-    port,
-    pid: child.pid,
-    attempts: cdpMaxAttempts
-  });
-  throw new Error(
-    `Failed to connect to browser after ${Math.ceil(cdpStartupTimeoutMs / 1e3)}s. Check startup logs: ${runLogPath}`
-  );
-}
-async function runSave(urlOrDomain, session, logger) {
-  logger.info("save-start", { urlOrDomain, session });
-  const { browser, context, page } = await connect(session, logger);
-  try {
-    await new Promise((r) => setTimeout(r, 500));
-    const domain = normalizeDomain(urlOrDomain);
-    const profilePath = getProfilePath(domain);
-    const cdpSession = await context.newCDPSession(page);
-    const { cookies: rawCookies } = await cdpSession.send(
-      "Network.getAllCookies"
-    );
-    const cookies = rawCookies.map((c) => {
-      const cookie = { ...c };
-      if (cookie.partitionKey && typeof cookie.partitionKey === "object") {
-        delete cookie.partitionKey;
-      }
-      return cookie;
-    });
-    await cdpSession.detach();
-    const origins = [];
-    for (const ctx of browser.contexts()) {
-      for (const pg of ctx.pages()) {
-        try {
-          const origin = new URL(pg.url()).origin;
-          const localStorage = await pg.evaluate(() => {
-            const items = [];
-            for (let i = 0; i < window.localStorage.length; i++) {
-              const key = window.localStorage.key(i);
-              if (key) {
-                items.push({
-                  name: key,
-                  value: window.localStorage.getItem(key) || ""
-                });
-              }
-            }
-            return items;
-          });
-          if (localStorage.length > 0) {
-            origins.push({ origin, localStorage });
-          }
-        } catch {
-        }
-      }
-    }
-    const state = { cookies, origins };
-    const fs = await import("node:fs/promises");
-    await fs.mkdir(dirname(profilePath), { recursive: true });
-    await fs.writeFile(profilePath, JSON.stringify(state, null, 2));
-    logger.info("save-success", {
-      domain,
-      profilePath,
-      cookieCount: cookies.length,
-      originCount: origins.length
-    });
-    console.log(`Profile saved for ${domain}`);
-    console.log(`   Location: ${profilePath}`);
-    console.log(`   Cookies: ${cookies.length}, Origins: ${origins.length}`);
-  } catch (err) {
-    logger.error("save-error", { error: err, urlOrDomain, session });
-    throw err;
-  } finally {
-    disconnectBrowser(browser, logger, session);
-  }
-}
-async function runClose(session, logger) {
-  logger.info("close-start", { session });
-  const state = readSessionState(session, logger);
-  if (!state) {
-    logger.info("close-no-session", { session });
-    console.log(`No browser running for session "${session}".`);
-    return;
-  }
-  logger.info("close-killing", { session, pid: state.pid, port: state.port });
-  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}).`);
-}
-function waitForCloseSignalWindow(ms) {
-  return new Promise((r) => setTimeout(r, ms));
-}
-function isPidRunning(pid) {
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch {
-    return false;
-  }
-}
-function sendSignalToProcessGroupOrPid(pid, signal, logger, session) {
-  try {
-    process.kill(pid, signal);
-    logger.info("close-signal-pid", { session, pid, signal });
-  } catch (pidErr) {
-    const pidCode = pidErr.code;
-    if (pidCode !== "ESRCH") {
-      logger.warn("close-signal-pid-failed", {
-        session,
-        pid,
-        signal,
-        error: pidErr
-      });
-    }
-  }
-}
-function formatSessionList(targets) {
-  return targets.map((target) => `"${target.session}"`).join(", ");
-}
-function resolveClosableSessions(logger) {
-  const sessions = listSessionsWithStateFile();
-  const closable = [];
-  let clearedUnreadableStates = 0;
-  for (const session of sessions) {
-    const state = readSessionState(session, logger);
-    if (!state) {
-      clearSessionState(session, logger);
-      clearedUnreadableStates += 1;
-      continue;
-    }
-    closable.push({
-      session,
-      pid: state.pid,
-      port: state.port
-    });
-  }
-  return { closable, clearedUnreadableStates };
-}
-function clearStoppedSessionStates(sessions, logger) {
-  let cleared = 0;
-  for (const session of sessions) {
-    if (!isPidRunning(session.pid)) {
-      clearSessionState(session.session, logger);
-      cleared += 1;
-    }
-  }
-  return cleared;
-}
-async function runCloseAll(logger, options) {
-  const force = Boolean(options?.force);
-  logger.info("close-all-start", { force });
-  const { closable, clearedUnreadableStates } = resolveClosableSessions(logger);
-  if (closable.length === 0) {
-    if (clearedUnreadableStates > 0) {
-      console.log(
-        `Cleared ${clearedUnreadableStates} unreadable session state file(s).`
-      );
-    }
-    console.log("No browser sessions found.");
-    return;
-  }
-  for (const target of closable) {
-    logger.info("close-all-sigterm", {
-      session: target.session,
-      pid: target.pid,
-      port: target.port
-    });
-    sendSignalToProcessGroupOrPid(target.pid, "SIGTERM", logger, target.session);
-  }
-  await waitForCloseSignalWindow(CLOSE_WAIT_MS);
-  let survivors = closable.filter((target) => isPidRunning(target.pid));
-  if (survivors.length > 0 && !force) {
-    const closed = clearStoppedSessionStates(closable, logger);
-    throw new Error(
-      [
-        `Failed to close ${survivors.length} session(s) gracefully: ${formatSessionList(survivors)}.`,
-        `Closed ${closed} session(s).`,
-        "Retry with: libretto-cli close --all --force"
-      ].join("\n")
-    );
-  }
-  let forceKilled = 0;
-  if (survivors.length > 0) {
-    for (const survivor of survivors) {
-      logger.warn("close-all-sigkill", {
-        session: survivor.session,
-        pid: survivor.pid
-      });
-      sendSignalToProcessGroupOrPid(survivor.pid, "SIGKILL", logger, survivor.session);
-      forceKilled += 1;
-    }
-    await waitForCloseSignalWindow(FORCE_CLOSE_WAIT_MS);
-    survivors = survivors.filter((target) => isPidRunning(target.pid));
-    if (survivors.length > 0) {
-      const closed = clearStoppedSessionStates(closable, logger);
-      throw new Error(
-        [
-          `Failed to force-close ${survivors.length} session(s): ${formatSessionList(survivors)}.`,
-          `Closed ${closed} session(s).`
-        ].join("\n")
-      );
-    }
-  }
-  clearStoppedSessionStates(closable, logger);
-  if (clearedUnreadableStates > 0) {
-    console.log(
-      `Cleared ${clearedUnreadableStates} unreadable session state file(s).`
-    );
-  }
-  console.log(`Closed ${closable.length} session(s).`);
-  if (forceKilled > 0) {
-    console.log(`Force-killed ${forceKilled} session(s).`);
-  }
-}
-function resolvePath(filePath) {
-  return join(process.cwd(), filePath);
-}
-function getScreenshotBaseName(title) {
-  const sanitizedTitle = title.replace(/[^a-zA-Z0-9\s-]/g, "").replace(/\s+/g, "-").toLowerCase().slice(0, 50);
-  const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
-  return `${sanitizedTitle}-${timestamp}`;
-}
-export {
-  connect,
-  disconnectBrowser,
-  getProfilePath,
-  getScreenshotBaseName,
-  hasProfile,
-  listOpenPages,
-  normalizeDomain,
-  normalizeUrl,
-  resolvePath,
-  runClose,
-  runCloseAll,
-  runOpen,
-  runPages,
-  runSave
-};