libretto 0.6.12 → 0.6.14

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

@@ -31,7 +31,8 @@ import {
 } from "../browser.js";
 import { handlePages } from "./pages.js";
 import { handleExec, handleReadonlyExec } from "./exec.js";
-import { handleCompactSnapshot, handleSnapshot } from "./snapshot.js";
+import { DaemonExecRepl } from "./exec-repl.js";
+import { handleCompactSnapshot } from "./snapshot.js";
 import { librettoCommand } from "../../../shared/package-manager.js";
 import { snapshot } from "../../../shared/snapshot/capture-snapshot.js";
 import { diffSnapshots } from "../../../shared/snapshot/diff-snapshots.js";
@@ -105,9 +106,13 @@ class BrowserDaemon {
     this.page = page;
     this.providerSession = providerSession;
     this.logger = logger.withScope("child");
+    this.execRepl = new DaemonExecRepl({
+      browser: this.browser,
+      context: this.context
+    });
   }
   logger;
-  execState = {};
+  execRepl;
   pageById = /* @__PURE__ */ new Map();
   shutdownHandlers = [];
   connectedClis = /* @__PURE__ */ new Set();
@@ -146,7 +151,8 @@ class BrowserDaemon {
       initialPages,
       navigateUrl,
       readyProvider,
-      providerSession
+      providerSession,
+      beforeReady
     } = args;
     await mkdir(getSessionDir(session), { recursive: true });
     const networkLogFile = getSessionNetworkLogPath(session);
@@ -170,9 +176,7 @@ class BrowserDaemon {
         error: err instanceof Error ? err.message : String(err)
       });
     }
-    if (experiments["compact-snapshot-format"]) {
-      await context.addInitScript(installPageStabilityWaiter);
-    }
+    await context.addInitScript(installPageStabilityWaiter);
     const socketPath = getDaemonSocketPath(session);
     const daemon = new BrowserDaemon(
       session,
@@ -188,19 +192,15 @@ class BrowserDaemon {
       wrapPageForActionLogging(p, session);
       daemon.trackPage(p);
     }
-    if (experiments["compact-snapshot-format"]) {
-      await Promise.all(
-        initialPages.map(
-          (initialPage) => daemon.installCompactSnapshotWaiter(initialPage)
-        )
-      );
-    }
+    await Promise.all(
+      initialPages.map(
+        (initialPage) => daemon.installCompactSnapshotWaiter(initialPage)
+      )
+    );
     context.on("page", (newPage) => {
       wrapPageForActionLogging(newPage, session);
       daemon.trackPage(newPage);
-      if (experiments["compact-snapshot-format"]) {
-        void daemon.installCompactSnapshotWaiter(newPage);
-      }
+      void daemon.installCompactSnapshotWaiter(newPage);
     });
     if (navigateUrl) {
       await page.goto(navigateUrl);
@@ -239,6 +239,7 @@ class BrowserDaemon {
       });
     });
     await listenOnIpcSocket(ipcServer, socketPath);
+    beforeReady?.();
     process.send?.({ type: "ready", socketPath, provider: readyProvider });
     daemon.logger.info("ipc-server-listening", { socketPath });
     browser.on("disconnected", () => {
@@ -321,8 +322,13 @@ class BrowserDaemon {
   static async connectToProvider(args) {
     const { session, browser: config } = args;
     const provider = getCloudProviderApi(config.providerName);
-    const providerSession = await provider.createSession();
+    let providerSession;
+    const startupCleanup = createProviderStartupCleanup({
+      provider,
+      getProviderSession: () => providerSession
+    });
     try {
+      providerSession = await provider.createSession();
       const browser = await chromium.connectOverCDP(
         providerSession.cdpEndpoint
       );
@@ -349,7 +355,8 @@ class BrowserDaemon {
           provider,
           name: config.providerName,
           sessionId: providerSession.sessionId
-        }
+        },
+        beforeReady: startupCleanup.dispose
       });
       daemon.logger.info("child-provider-connected", {
         provider: config.providerName,
@@ -360,7 +367,10 @@ class BrowserDaemon {
       });
       return daemon;
     } catch (error) {
-      await provider.closeSession(providerSession.sessionId);
+      startupCleanup.dispose();
+      if (providerSession) {
+        await provider.closeSession(providerSession.sessionId);
+      }
       throw error;
     }
   }
@@ -465,38 +475,23 @@ class BrowserDaemon {
     };
   }
   async runSnapshot(args) {
-    if (args.mode === "compact") {
-      if (!this.experiments["compact-snapshot-format"]) {
-        throw new Error(
-          `The compact-snapshot-format experiment is not enabled for session "${this.session}". Close and reopen the session after running ${librettoCommand("experiments enable compact-snapshot-format")}.`
-        );
-      }
-      const targetPage = this.resolveTargetPage(args.pageId);
-      const result = await this.withRequestTimeout(
-        () => handleCompactSnapshot(
-          targetPage,
-          this.session,
-          this.logger,
-          {
-            pageId: args.pageId,
-            cachedSnapshot: this.latestCompactSnapshotByPage.get(targetPage),
-            useCachedSnapshot: args.useCachedSnapshot
-          }
-        )
-      );
-      if (!args.useCachedSnapshot) {
-        this.latestCompactSnapshotByPage.set(targetPage, result.snapshot);
-      }
-      return result;
-    }
-    return this.withRequestTimeout(
-      () => handleSnapshot(
-        this.resolveTargetPage(args.pageId),
+    const targetPage = this.resolveTargetPage(args.pageId);
+    const result = await this.withRequestTimeout(
+      () => handleCompactSnapshot(
+        targetPage,
         this.session,
         this.logger,
-        args.pageId
+        {
+          pageId: args.pageId,
+          cachedSnapshot: this.latestCompactSnapshotByPage.get(targetPage),
+          useCachedSnapshot: args.useCachedSnapshot
+        }
       )
     );
+    if (!args.useCachedSnapshot) {
+      this.latestCompactSnapshotByPage.set(targetPage, result.snapshot);
+    }
+    return result;
   }
   async withRequestTimeout(operation) {
     let timerId;
@@ -513,25 +508,7 @@ class BrowserDaemon {
     }
   }
   async runExec(args) {
-    if (this.experiments["compact-snapshot-format"]) {
-      return this.runCompactExec(args);
-    }
-    try {
-      const data = await this.withRequestTimeout(
-        () => handleExec(
-          this.resolveTargetPage(args.pageId),
-          args.code,
-          this.context,
-          this.browser,
-          this.execState,
-          this.session,
-          args.visualize
-        )
-      );
-      return { ok: true, data };
-    } catch (error) {
-      return this.createExecErrorResult(error);
-    }
+    return this.runCompactExec(args);
   }
   async runCompactExec(args) {
     let targetPage;
@@ -543,10 +520,7 @@ class BrowserDaemon {
         const result = await handleExec(
           page,
           args.code,
-          this.context,
-          this.browser,
-          this.execState,
-          this.session,
+          this.execRepl,
           args.visualize
         );
         try {
@@ -606,17 +580,17 @@ class BrowserDaemon {
       context: this.context,
       logger: this.logger,
       onLog: (event) => {
-        this.broadcast("workflowOutput", event);
+        void this.broadcast("workflowOutput", event);
       },
       onOutcome: (outcome) => {
         if (outcome.state === "paused") {
-          this.broadcast("workflowPaused", {
+          void this.broadcast("workflowPaused", {
             pausedAt: outcome.pausedAt,
             url: outcome.url
           });
           return;
         }
-        this.broadcast(
+        void this.broadcast(
           "workflowFinished",
           outcome.result === "completed" ? { result: "completed", completedAt: outcome.completedAt } : {
             result: "failed",
@@ -659,6 +633,44 @@ class BrowserDaemon {
     }
   }
 }
+function createProviderStartupCleanup(args) {
+  let disposed = false;
+  let fallbackExit;
+  const requestClose = (reason) => {
+    if (disposed) return;
+    disposed = true;
+    process.exitCode = reason === "received SIGINT" ? 130 : 1;
+    const providerSession = args.getProviderSession();
+    if (!providerSession) {
+      fallbackExit = setTimeout(() => {
+        process.exit(process.exitCode);
+      }, 5e3);
+      fallbackExit.unref();
+      return;
+    }
+    void args.provider.closeSession(providerSession.sessionId).catch(() => {
+    }).finally(() => {
+      process.exit(reason === "received SIGINT" ? 130 : 1);
+    });
+  };
+  const onDisconnect = () => requestClose("parent command disconnected");
+  const onSigint = () => requestClose("received SIGINT");
+  const onSigterm = () => requestClose("received SIGTERM");
+  if (typeof process.send === "function") {
+    process.once("disconnect", onDisconnect);
+  }
+  process.once("SIGINT", onSigint);
+  process.once("SIGTERM", onSigterm);
+  return {
+    dispose: () => {
+      disposed = true;
+      if (fallbackExit) clearTimeout(fallbackExit);
+      process.off("disconnect", onDisconnect);
+      process.off("SIGINT", onSigint);
+      process.off("SIGTERM", onSigterm);
+    }
+  };
+}
 async function main() {
   const config = JSON.parse(process.argv[2]);
   const headed = config.browser.kind === "launch" ? config.browser.headed : false;
@@ -735,7 +747,9 @@ function reportStartupError(error) {
       message: error.message
     });
   }
-  process.exit(1);
+  process.exit(
+    process.exitCode && process.exitCode !== 0 ? process.exitCode : 1
+  );
 }
 try {
   await main();

package/dist/cli/core/daemon/exec-repl.js

@@ -0,0 +1,133 @@
+import * as repl from "node:repl";
+import { PassThrough } from "node:stream";
+import { format, formatWithOptions } from "node:util";
+import { stripTypeScriptExecCode } from "../exec-compiler.js";
+const PROMPT = "__LIBRETTO_EXEC_REPL_READY__";
+const TOP_LEVEL_RETURN_HINT = "Hint: top-level return isn't supported because exec is a REPL-style environment. Use the expression value instead, for example: await page.title()";
+const NO_RESULT = /* @__PURE__ */ Symbol("NO_RESULT");
+function getErrorMessage(error) {
+  if (error instanceof Error) return error.message;
+  if (typeof error === "object" && error !== null && "message" in error && typeof error.message === "string") {
+    return error.message;
+  }
+  return String(error);
+}
+function isTopLevelReturnError(error) {
+  const message = getErrorMessage(error);
+  return message.includes("Illegal return statement") || message.includes("Return statement is not allowed here");
+}
+function isErrorLike(value) {
+  return value instanceof Error || typeof value === "object" && value !== null && "name" in value && "message" in value && typeof value.name === "string" && typeof value.message === "string";
+}
+function toError(value) {
+  return value instanceof Error ? value : new Error(getErrorMessage(value));
+}
+function appendTopLevelReturnHint(error) {
+  const message = getErrorMessage(error);
+  if (message.includes(TOP_LEVEL_RETURN_HINT)) {
+    return error instanceof Error ? error : new Error(message);
+  }
+  return new SyntaxError(`${message}
+
+${TOP_LEVEL_RETURN_HINT}`);
+}
+function createBufferedConsole() {
+  const output = { stdout: "", stderr: "" };
+  const writeStdout = (...args) => {
+    output.stdout += `${format(...args)}
+`;
+  };
+  const writeStderr = (...args) => {
+    output.stderr += `${format(...args)}
+`;
+  };
+  const bufferedConsole = {
+    ...globalThis.console,
+    log: writeStdout,
+    info: writeStdout,
+    debug: writeStdout,
+    dir: (value, options) => {
+      output.stdout += `${formatWithOptions(options ?? {}, value)}
+`;
+    },
+    warn: writeStderr,
+    error: writeStderr
+  };
+  return { console: bufferedConsole, output };
+}
+class DaemonExecRepl {
+  replServer;
+  input = new PassThrough();
+  output = new PassThrough();
+  readyResolve;
+  ready;
+  activeEval;
+  lastResult = NO_RESULT;
+  constructor(globals) {
+    this.ready = new Promise((resolve) => {
+      this.readyResolve = resolve;
+    });
+    this.output.on("data", (chunk) => {
+      this.handleOutput(String(chunk));
+    });
+    this.replServer = repl.start({
+      prompt: PROMPT,
+      input: this.input,
+      output: this.output,
+      terminal: true,
+      useGlobal: false,
+      writer: (value) => {
+        this.lastResult = value;
+        return "";
+      }
+    });
+    Object.assign(this.replServer.context, globals);
+  }
+  async run(code, globals) {
+    Object.assign(this.replServer.context, globals);
+    let jsCode;
+    try {
+      jsCode = stripTypeScriptExecCode(code);
+    } catch (error) {
+      return {
+        ok: false,
+        error: isTopLevelReturnError(error) ? appendTopLevelReturnHint(error) : toError(error),
+        output: { stdout: "", stderr: "" }
+      };
+    }
+    await this.ready;
+    const buffered = createBufferedConsole();
+    Object.assign(this.replServer.context, { console: buffered.console });
+    return await new Promise((resolve) => {
+      this.activeEval = { output: "", consoleOutput: buffered.output, resolve };
+      this.lastResult = NO_RESULT;
+      this.input.write(`.editor
+${jsCode}
+`);
+    });
+  }
+  handleOutput(chunk) {
+    const active = this.activeEval;
+    if (!active) {
+      if (chunk.includes(PROMPT)) {
+        this.readyResolve?.();
+        this.readyResolve = void 0;
+      }
+      return;
+    }
+    active.output += chunk;
+    if (!active.output.includes(PROMPT)) return;
+    this.activeEval = void 0;
+    const result = this.lastResult === NO_RESULT ? void 0 : this.lastResult;
+    const output = active.consoleOutput;
+    if (isErrorLike(result)) {
+      const error = isTopLevelReturnError(result) ? appendTopLevelReturnHint(result) : toError(result);
+      active.resolve({ ok: false, error, output });
+      return;
+    }
+    active.resolve({ ok: true, result, output });
+  }
+}
+export {
+  DaemonExecRepl
+};

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

@@ -2,7 +2,6 @@ import { format, formatWithOptions } from "node:util";
 import { installInstrumentation } from "../../../shared/instrumentation/index.js";
 import { compileExecFunction } from "../exec-compiler.js";
 import { createReadonlyExecHelpers } from "../readonly-exec.js";
-import { readNetworkLog, readActionLog } from "../telemetry.js";
 class DaemonExecError extends Error {
   constructor(message, output) {
     super(message);
@@ -34,33 +33,19 @@ function createBufferedConsole() {
   };
   return { console: bufferedConsole, output };
 }
-async function handleExec(targetPage, code, context, browser, execState, session, visualize) {
-  const buffered = createBufferedConsole();
+async function handleExec(targetPage, code, execRepl, visualize) {
   if (visualize) {
     await installInstrumentation(targetPage, { visualize: true });
   }
-  const networkLog = (opts = {}) => readNetworkLog(session, opts);
-  const actionLog = (opts = {}) => readActionLog(session, opts);
   const helpers = {
     page: targetPage,
-    context,
-    browser,
-    state: execState,
-    console: buffered.console,
-    networkLog,
-    actionLog
+    frame: targetPage.mainFrame()
   };
-  const helperNames = Object.keys(helpers);
-  const fn = compileExecFunction(code, helperNames);
-  try {
-    const result = await fn(...Object.values(helpers));
-    return { result, output: buffered.output };
-  } catch (error) {
-    throw new DaemonExecError(
-      error instanceof Error ? error.message : String(error),
-      buffered.output
-    );
+  const result = await execRepl.run(code, helpers);
+  if (!result.ok) {
+    throw new DaemonExecError(result.error.message, result.output);
   }
+  return { result: result.result, output: result.output };
 }
 async function handleReadonlyExec(targetPage, code) {
   const buffered = createBufferedConsole();

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

@@ -2,6 +2,7 @@ import { createHash } from "node:crypto";
 import { spawn } from "node:child_process";
 import { openSync, closeSync } from "node:fs";
 import { createRequire } from "node:module";
+import { homedir, userInfo } from "node:os";
 import { fileURLToPath } from "node:url";
 import { createIpcPeer } from "../../../shared/ipc/ipc.js";
 import { connectToIpcSocket } from "../../../shared/ipc/socket-transport.js";
@@ -33,9 +34,27 @@ function isDaemonStartupErrorMessage(message) {
   const candidate = message;
   return candidate.type === "startup-error" && typeof candidate.message === "string";
 }
-function getDaemonSocketPath(session) {
-  const hash = createHash("sha256").update(`${REPO_ROOT}:${session}`).digest("hex").slice(0, 12);
-  return `/tmp/libretto-${process.getuid()}-${hash}.sock`;
+function isDaemonStartupStatusMessage(message) {
+  if (typeof message !== "object" || message === null) return false;
+  const candidate = message;
+  return candidate.type === "startup-status" && typeof candidate.message === "string";
+}
+function getDaemonSocketPath(session, platform = process.platform) {
+  const userKey = getDaemonUserKey();
+  const hash = createHash("sha256").update(`${REPO_ROOT}:${session}:${userKey}`).digest("hex").slice(0, 12);
+  if (platform === "win32") {
+    return `\\\\.\\pipe\\libretto-${hash}`;
+  }
+  return `/tmp/libretto-${userKey}-${hash}.sock`;
+}
+function getDaemonUserKey() {
+  if (typeof process.getuid === "function") return String(process.getuid());
+  try {
+    const info = userInfo();
+    if (info.username) return info.username;
+  } catch {
+  }
+  return createHash("sha256").update(homedir()).digest("hex").slice(0, 12);
 }
 class DaemonClient {
   constructor(ipc) {
@@ -105,6 +124,13 @@ class DaemonClient {
       },
       onExit: (code, signal, ready) => {
         logger.warn("daemon-exit", { code, signal, session, pid, ready });
+      },
+      onStatus: (message) => {
+        logger.info("daemon-startup-status", {
+          session,
+          message: message.message
+        });
+        console.log(message.message);
       }
     }).catch(async (error) => {
       try {
@@ -131,7 +157,8 @@ class DaemonClient {
       formatExitError,
       onReady,
       onSpawnError,
-      onExit
+      onExit,
+      onStatus
     } = args;
     return new Promise((resolve, reject) => {
       let ready = false;
@@ -141,6 +168,8 @@ class DaemonClient {
         child.off("message", onMessage);
         child.off("error", onError);
         child.off("exit", onChildExit);
+        process.off("SIGINT", onParentSigint);
+        process.off("SIGTERM", onParentSigterm);
       };
       const fail = (error) => {
         cleanup();
@@ -152,6 +181,10 @@ class DaemonClient {
           fail(new Error(message.message));
           return;
         }
+        if (isDaemonStartupStatusMessage(message)) {
+          onStatus?.(message);
+          return;
+        }
         if (!isDaemonReadyMessage(message)) return;
         ready = true;
         cleanup();
@@ -167,9 +200,19 @@ class DaemonClient {
         if (ready) return;
         fail(formatExitError(code, signal));
       };
+      const forwardSignalToChild = (signal) => {
+        try {
+          child.kill(signal);
+        } catch {
+        }
+      };
+      const onParentSigint = () => forwardSignalToChild("SIGINT");
+      const onParentSigterm = () => forwardSignalToChild("SIGTERM");
       child.on("message", onMessage);
       child.on("error", onError);
       child.on("exit", onChildExit);
+      process.once("SIGINT", onParentSigint);
+      process.once("SIGTERM", onParentSigterm);
     });
   }
   async ping() {

package/dist/cli/core/daemon/ipc.spec.js

@@ -0,0 +1,21 @@
+import { describe, expect, test } from "vitest";
+import { getDaemonSocketPath } from "./ipc.js";
+describe("daemon IPC endpoint paths", () => {
+  test("uses a Windows named pipe path on Windows", () => {
+    const socketPath = getDaemonSocketPath("windows-session", "win32");
+    expect(socketPath).toMatch(/^\\\\\.\\pipe\\libretto-[a-f0-9]{12}$/);
+    expect(socketPath).not.toContain("/tmp/");
+    expect(socketPath).not.toContain(".sock");
+  });
+  test("uses a short Unix socket path on Unix-like platforms", () => {
+    const socketPath = getDaemonSocketPath("unix-session", "linux");
+    expect(socketPath).toMatch(/^\/tmp\/libretto-.+-[a-f0-9]{12}\.sock$/);
+  });
+  test("keeps daemon IPC endpoints deterministic per session", () => {
+    const firstPath = getDaemonSocketPath("stable-session", "linux");
+    const secondPath = getDaemonSocketPath("stable-session", "linux");
+    const otherPath = getDaemonSocketPath("other-session", "linux");
+    expect(secondPath).toBe(firstPath);
+    expect(otherPath).not.toBe(firstPath);
+  });
+});

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

@@ -1,4 +1,4 @@
-import { mkdirSync, writeFileSync } from "node:fs";
+import { mkdirSync } from "node:fs";
 import { getSessionSnapshotRunDir } from "../context.js";
 import {
   snapshot
@@ -13,32 +13,6 @@ import {
   forceSnapshotViewport
 } from "../../commands/snapshot.js";
 const RENDER_SETTLE_TIMEOUT_MS = 1e4;
-async function handleSnapshot(targetPage, session, logger, pageId) {
-  const screenshot = await captureSnapshotScreenshot(
-    targetPage,
-    session,
-    logger,
-    pageId
-  );
-  const htmlPath = `${getSessionSnapshotRunDir(
-    session,
-    screenshot.snapshotRunId
-  )}/page.html`;
-  const htmlContent = await targetPage.content();
-  writeFileSync(htmlPath, htmlContent);
-  logger.info("screenshot-success", {
-    session,
-    pageUrl: screenshot.pageUrl,
-    title: screenshot.title,
-    pngPath: screenshot.pngPath,
-    htmlPath,
-    snapshotRunId: screenshot.snapshotRunId
-  });
-  return {
-    ...screenshot,
-    htmlPath
-  };
-}
 async function handleCompactSnapshot(targetPage, session, logger, options = {}) {
   if (options.useCachedSnapshot) {
     if (!options.cachedSnapshot) {
@@ -147,6 +121,5 @@ async function captureSnapshotScreenshot(targetPage, session, logger, pageId) {
   };
 }
 export {
-  handleCompactSnapshot,
-  handleSnapshot
+  handleCompactSnapshot
 };

package/dist/cli/core/exec-compiler.js

@@ -1,5 +1,11 @@
 import * as moduleBuiltin from "node:module";
 const stripTypeScriptTypes = moduleBuiltin.stripTypeScriptTypes;
+function stripTypeScriptExecCode(code) {
+  if (!stripTypeScriptTypes) return code;
+  return withSuppressedStripTypeScriptWarning(
+    () => stripTypeScriptTypes(code, { mode: "strip" })
+  );
+}
 function withSuppressedStripTypeScriptWarning(action) {
   const mutableProcess = process;
   const originalEmitWarning = mutableProcess.emitWarning;
@@ -24,9 +30,7 @@ function compileTypeScriptExecFunction(code, helperNames) {
   const wrappedSource = `(async function __librettoExec(${helperNames.join(", ")}) {
 ${code}
 })`;
-  const jsSource = withSuppressedStripTypeScriptWarning(
-    () => stripTypeScriptTypes(wrappedSource, { mode: "strip" })
-  );
+  const jsSource = stripTypeScriptExecCode(wrappedSource);
   const createFunction = new Function(
     `return ${jsSource}`
   );
@@ -107,5 +111,6 @@ export {
   compileExecFunction,
   compileTypeScriptExecFunction,
   stripEmptyCatchHandlers,
+  stripTypeScriptExecCode,
   withSuppressedStripTypeScriptWarning
 };