libretto 0.6.8 → 0.6.10

package/dist/cli/core/browser.js

@@ -1,12 +1,9 @@
 import {
   chromium
 } from "playwright";
-import { openSync, closeSync, existsSync } from "node:fs";
+import { existsSync, unlinkSync } 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 { PROFILES_DIR } from "./context.js";
 import { readLibrettoConfig } from "./config.js";
 import {
@@ -20,6 +17,7 @@ import {
   writeSessionState
 } from "./session.js";
 import { getCloudProviderApi } from "./providers/index.js";
+import { DaemonClient, spawnSessionDaemon } from "./daemon/index.js";
 const CLOSE_WAIT_MS = 1500;
 const FORCE_CLOSE_WAIT_MS = 300;
 async function pickFreePort() {
@@ -143,20 +141,6 @@ async function resolvePageReferences(pages) {
   );
   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);
@@ -242,7 +226,15 @@ async function connect(session, logger, timeoutMs = 1e4, options) {
 }
 async function runPages(session, logger) {
   logger.info("pages-start", { session });
-  const pageSummaries = await listOpenPages(session, logger);
+  const state = readSessionStateOrThrow(session);
+  let pageSummaries;
+  if (!state.daemonSocketPath) {
+    throw new Error(
+      `Session "${session}" has no daemon socket. The browser daemon may have crashed. Close and reopen the session: libretto close --session ${session}`
+    );
+  }
+  const client = new DaemonClient(state.daemonSocketPath);
+  pageSummaries = await client.pages();
   if (pageSummaries.length === 0) {
     console.log("No pages found.");
     return;
@@ -302,8 +294,17 @@ async function runOpen(rawUrl, headed, session, logger, options) {
   const port = await pickFreePort();
   const runLogPath = logFileForSession(session);
   const browserMode = headed ? "headed" : "headless";
+  const authDomain = options?.authProfileDomain ? normalizeDomain(normalizeUrl(options.authProfileDomain)) : void 0;
+  if (authDomain) {
+    const authProfilePath = getProfilePath(authDomain);
+    if (!existsSync(authProfilePath)) {
+      throw new Error(
+        `No saved auth profile for "${authDomain}". Save one first: libretto open https://${authDomain} --headed --session <name>, log in, then run: libretto save ${authDomain} --session <name>`
+      );
+    }
+  }
   const supportsSavedProfile = parsedUrl.protocol === "http:" || parsedUrl.protocol === "https:";
-  const domain = supportsSavedProfile ? normalizeDomain(parsedUrl) : void 0;
+  const domain = authDomain ?? (supportsSavedProfile ? normalizeDomain(parsedUrl) : void 0);
   const profilePath = domain ? getProfilePath(domain) : void 0;
   const useProfile = domain ? hasProfile(domain) : false;
   logger.info("open-launching", {
@@ -319,106 +320,46 @@ async function runOpen(rawUrl, headed, session, logger, options) {
     console.log(`Loading saved profile for ${domain}`);
   }
   console.log(`Launching ${browserMode} browser (session: ${session})...`);
-  const daemonEntryPath = fileURLToPath(
-    new URL("./browser-daemon.js", import.meta.url)
-  );
-  const require2 = createRequire(import.meta.url);
-  const tsxImportPath = pathToFileURL(require2.resolve("tsx/esm")).href;
-  const daemonConfig = {
-    port,
-    url,
+  const { pid, socketPath: daemonSocketPath } = await spawnSessionDaemon({
+    config: {
+      port,
+      url,
+      session,
+      headed,
+      viewport,
+      storageStatePath: useProfile ? profilePath : void 0,
+      windowPosition
+    },
     session,
-    headed,
-    viewport,
-    storageStatePath: useProfile ? profilePath : void 0,
-    windowPosition
-  };
-  const childStderrFd = openSync(runLogPath, "a");
-  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 });
-  let childSpawnError = null;
-  let childEarlyExit = null;
-  child.on("error", (err) => {
-    childSpawnError = err;
-    logger.error("open-child-spawn-error", { error: err, session, port });
+    logger,
+    logPath: runLogPath,
+    // The daemon launches Chromium, installs telemetry, navigates to
+    // the URL, and only then starts IPC. Navigation alone can take up
+    // to 45s (page.setDefaultNavigationTimeout), so the IPC timeout
+    // must cover launch + navigation.
+    ipcTimeoutMs: 6e4
   });
-  child.on("exit", (code, signal) => {
-    childEarlyExit = { code, signal };
-    logger.warn("open-child-exited", {
-      code,
-      signal,
-      session,
+  writeSessionState(
+    {
       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",
-          mode: accessMode,
-          viewport
-        },
-        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", {
+      pid,
+      session,
+      startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      status: "active",
+      mode: accessMode,
+      viewport,
+      daemonSocketPath
+    },
+    logger
+  );
+  logger.info("open-success", {
+    url,
+    mode: browserMode,
     session,
     port,
-    pid: child.pid,
-    attempts: cdpMaxAttempts
+    pid
   });
-  throw new Error(
-    `Failed to connect to browser after ${Math.ceil(cdpStartupTimeoutMs / 1e3)}s. Check startup logs: ${runLogPath}`
-  );
+  console.log(`Browser open (${browserMode}): ${url}`);
 }
 async function runOpenWithProvider(rawUrl, providerName, provider, session, logger, accessMode = "write-access") {
   const parsedUrl = normalizeUrl(rawUrl);
@@ -431,67 +372,45 @@ async function runOpenWithProvider(rawUrl, providerName, provider, session, logg
   logger.info("open-provider-session-created", {
     provider: providerName,
     sessionId: providerSession.sessionId,
-    cdpEndpoint: providerSession.cdpEndpoint
+    cdpEndpoint: providerSession.cdpEndpoint,
+    liveViewUrl: providerSession.liveViewUrl
   });
-  console.log(`Connecting to ${providerName} browser...`);
-  let browser = null;
-  try {
-    browser = await tryConnectToCDP(
-      providerSession.cdpEndpoint,
-      logger,
-      3e4
-    );
-    if (!browser) {
-      throw new Error(
-        `Could not connect to ${providerName} browser at ${providerSession.cdpEndpoint}. The remote session was created but CDP connection failed.`
-      );
-    }
-    const contexts = browser.contexts();
-    let page;
-    if (contexts.length > 0 && contexts[0].pages().length > 0) {
-      page = contexts[0].pages()[0];
-    } else {
-      const context = contexts.length > 0 ? contexts[0] : await browser.newContext();
-      page = await context.newPage();
-    }
-    await page.goto(url);
-    logger.info("open-provider-navigated", { url, session });
-    writeSessionState(
-      {
-        port: 0,
-        cdpEndpoint: providerSession.cdpEndpoint,
-        session,
-        startedAt: (/* @__PURE__ */ new Date()).toISOString(),
-        status: "active",
-        mode: accessMode,
-        provider: {
-          name: providerName,
-          sessionId: providerSession.sessionId
-        }
-      },
-      logger
-    );
-    disconnectBrowser(browser, logger, session);
-  } catch (err) {
-    if (browser) {
-      disconnectBrowser(browser, logger, session);
-    }
-    logger.warn("open-provider-cleanup-after-error", {
-      provider: providerName,
-      sessionId: providerSession.sessionId,
-      error: err
-    });
-    try {
-      await provider.closeSession(providerSession.sessionId);
-    } catch (cleanupErr) {
-      logger.warn("open-provider-cleanup-failed", {
-        provider: providerName,
-        sessionId: providerSession.sessionId,
-        error: cleanupErr
-      });
-    }
-    throw err;
+  if (providerSession.liveViewUrl) {
+    console.log(`View live session: ${providerSession.liveViewUrl}`);
   }
+  console.log(`Connecting to ${providerName} browser...`);
+  const runLogPath = logFileForSession(session);
+  const { pid, socketPath: daemonSocketPath } = await spawnSessionDaemon({
+    config: {
+      mode: "connect",
+      session,
+      cdpEndpoint: providerSession.cdpEndpoint,
+      url
+    },
+    session,
+    logger,
+    logPath: runLogPath,
+    // Remote CDP connection + navigation; must cover both.
+    ipcTimeoutMs: 6e4,
+    onFailure: () => provider.closeSession(providerSession.sessionId)
+  });
+  writeSessionState(
+    {
+      port: 0,
+      pid,
+      cdpEndpoint: providerSession.cdpEndpoint,
+      session,
+      startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      status: "active",
+      mode: accessMode,
+      daemonSocketPath,
+      provider: {
+        name: providerName,
+        sessionId: providerSession.sessionId
+      }
+    },
+    logger
+  );
   logger.info("open-provider-success", {
     url,
     provider: providerName,
@@ -572,6 +491,12 @@ async function runClose(session, logger) {
     console.log(`No browser running for session "${session}".`);
     return;
   }
+  if (state.pid != null) {
+    logger.info("close-killing", { session, pid: state.pid, port: state.port });
+    sendSignalToProcessGroupOrPid(state.pid, "SIGTERM", logger, session);
+    await waitForCloseSignalWindow(CLOSE_WAIT_MS);
+  }
+  let replayUrl;
   if (state.provider) {
     logger.info("close-provider", {
       session,
@@ -580,7 +505,8 @@ async function runClose(session, logger) {
     });
     try {
       const provider = getCloudProviderApi(state.provider.name);
-      await provider.closeSession(state.provider.sessionId);
+      const result = await provider.closeSession(state.provider.sessionId);
+      replayUrl = result.replayUrl;
     } catch (err) {
       logger.warn("close-provider-error", {
         session,
@@ -593,16 +519,14 @@ async function runClose(session, logger) {
         `Failed to close remote ${state.provider.name} session "${state.provider.sessionId}" for session "${session}". State preserved with status "cleanup-failed". Retry with: libretto close --session ${session}`
       );
     }
-  } else {
-    logger.info("close-killing", { session, pid: state.pid, port: state.port });
-    if (state.pid != null) {
-      sendSignalToProcessGroupOrPid(state.pid, "SIGTERM", logger, session);
-      await waitForCloseSignalWindow(CLOSE_WAIT_MS);
-    }
   }
+  unlinkDaemonSocket(state.daemonSocketPath, logger, session);
   clearSessionState(session, logger);
-  logger.info("close-success", { session });
+  logger.info("close-success", { session, replayUrl });
   console.log(`Browser closed (session: ${session}).`);
+  if (replayUrl) {
+    console.log(`View recording: ${replayUrl}`);
+  }
 }
 function waitForCloseSignalWindow(ms) {
   return new Promise((r) => setTimeout(r, ms));
@@ -641,16 +565,32 @@ function resolveClosableSessions(logger) {
       session,
       pid: state.pid,
       port: state.port,
-      provider: state.provider
+      provider: state.provider,
+      daemonSocketPath: state.daemonSocketPath
     });
   }
   return { closable, clearedUnreadableStates };
 }
+function unlinkDaemonSocket(socketPath, logger, session) {
+  if (!socketPath) return;
+  try {
+    unlinkSync(socketPath);
+  } catch (err) {
+    if (err.code !== "ENOENT") {
+      logger.warn("close-socket-unlink-failed", {
+        session,
+        socketPath,
+        error: err
+      });
+    }
+  }
+}
 function clearStoppedSessionStates(sessions, logger, skip) {
   let cleared = 0;
   for (const session of sessions) {
     if (skip?.has(session.session)) continue;
     if (session.pid == null || !isPidRunning(session.pid)) {
+      unlinkDaemonSocket(session.daemonSocketPath, logger, session.session);
       clearSessionState(session.session, logger);
       cleared += 1;
     }
@@ -671,6 +611,7 @@ async function runCloseAll(logger, options) {
     return;
   }
   const failedProviderSessions = /* @__PURE__ */ new Set();
+  const replayUrls = [];
   for (const target of closable) {
     if (target.provider) {
       logger.info("close-all-provider", {
@@ -680,7 +621,13 @@ async function runCloseAll(logger, options) {
       });
       try {
         const provider = getCloudProviderApi(target.provider.name);
-        await provider.closeSession(target.provider.sessionId);
+        const result = await provider.closeSession(target.provider.sessionId);
+        if (result.replayUrl) {
+          replayUrls.push({
+            session: target.session,
+            replayUrl: result.replayUrl
+          });
+        }
       } catch (err) {
         logger.warn("close-all-provider-error", {
           session: target.session,
@@ -697,20 +644,18 @@ async function runCloseAll(logger, options) {
     }
   }
   for (const target of closable) {
-    if (target.provider) continue;
+    if (target.pid == null) continue;
     logger.info("close-all-sigterm", {
       session: target.session,
       pid: target.pid,
       port: target.port
     });
-    if (target.pid != null) {
-      sendSignalToProcessGroupOrPid(
-        target.pid,
-        "SIGTERM",
-        logger,
-        target.session
-      );
-    }
+    sendSignalToProcessGroupOrPid(
+      target.pid,
+      "SIGTERM",
+      logger,
+      target.session
+    );
   }
   await waitForCloseSignalWindow(CLOSE_WAIT_MS);
   let survivors = closable.filter(
@@ -781,6 +726,9 @@ async function runCloseAll(logger, options) {
   if (forceKilled > 0) {
     console.log(`Force-killed ${forceKilled} session(s).`);
   }
+  for (const { session, replayUrl } of replayUrls) {
+    console.log(`View recording (${session}): ${replayUrl}`);
+  }
 }
 async function runConnect(cdpUrl, session, logger, accessMode = "write-access") {
   logger.info("connect-start", { cdpUrl, session, accessMode });
@@ -826,36 +774,34 @@ async function runConnect(cdpUrl, session, logger, accessMode = "write-access")
       endpoint
     });
   }
-  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", {
+  const runLogPath = logFileForSession(session);
+  const { pid, socketPath: daemonSocketPath, client } = await spawnSessionDaemon({
+    config: { mode: "connect", session, cdpEndpoint: endpoint },
     session,
-    pageCount: pages.length,
-    urls: pages.map((p) => p.url())
+    logger,
+    logPath: runLogPath,
+    ipcTimeoutMs: 1e4
   });
-  disconnectBrowser(browser, logger, session);
   writeSessionState(
     {
       port,
+      pid,
       cdpEndpoint: endpoint,
       session,
       startedAt: (/* @__PURE__ */ new Date()).toISOString(),
       status: "active",
-      mode: accessMode
+      mode: accessMode,
+      daemonSocketPath
     },
     logger
   );
+  const pages = await client.pages();
   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()}`);
+      console.log(`    ${p.url}`);
     }
     if (pages.length > 5) {
       console.log(`    ... and ${pages.length - 5} more`);
@@ -876,7 +822,6 @@ export {
   getProfilePath,
   getScreenshotBaseName,
   hasProfile,
-  listOpenPages,
   normalizeDomain,
   normalizeUrl,
   resolvePath,

package/dist/cli/core/daemon/config.js

@@ -0,0 +1,6 @@
+function isConnectConfig(config) {
+  return "mode" in config && config.mode === "connect";
+}
+export {
+  isConnectConfig
+};