libretto 0.6.13 → 0.6.14

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

@@ -31,6 +31,7 @@ import {
 } from "../browser.js";
 import { handlePages } from "./pages.js";
 import { handleExec, handleReadonlyExec } from "./exec.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";
@@ -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);
@@ -233,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", () => {
@@ -315,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
       );
@@ -343,7 +355,8 @@ class BrowserDaemon {
           provider,
           name: config.providerName,
           sessionId: providerSession.sessionId
-        }
+        },
+        beforeReady: startupCleanup.dispose
       });
       daemon.logger.info("child-provider-connected", {
         provider: config.providerName,
@@ -354,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;
     }
   }
@@ -504,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 {
@@ -620,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;
@@ -696,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/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
 };

package/dist/cli/core/providers/index.js

@@ -2,7 +2,14 @@ import { readLibrettoConfig } from "../config.js";
 import { createBrowserbaseProvider } from "./browserbase.js";
 import { createKernelProvider } from "./kernel.js";
 import { createLibrettoCloudProvider } from "./libretto-cloud.js";
-const VALID_PROVIDERS = /* @__PURE__ */ new Set(["local", "kernel", "browserbase", "libretto-cloud"]);
+const VALID_PROVIDERS = /* @__PURE__ */ new Set([
+  "local",
+  "kernel",
+  "browserbase",
+  "libretto-cloud"
+]);
+const DEFAULT_PROVIDER_STARTUP_TIMEOUT_MS = 6e4;
+const LIBRETTO_CLOUD_STARTUP_TIMEOUT_MS = 10 * 6e4;
 function assertValidProviderName(value, source) {
   if (!VALID_PROVIDERS.has(value)) {
     throw new Error(
@@ -32,9 +39,7 @@ function getCloudProviderApi(name) {
     case "browserbase":
       return createBrowserbaseProvider();
     case "libretto-cloud":
-      console.warn(
-        "Note: The libretto-cloud provider is in alpha."
-      );
+      console.warn("Note: The libretto-cloud provider is in alpha.");
       return createLibrettoCloudProvider();
     default:
       throw new Error(
@@ -42,7 +47,11 @@ function getCloudProviderApi(name) {
       );
   }
 }
+function getProviderStartupTimeoutMs(providerName) {
+  return providerName === "libretto-cloud" ? LIBRETTO_CLOUD_STARTUP_TIMEOUT_MS : DEFAULT_PROVIDER_STARTUP_TIMEOUT_MS;
+}
 export {
   getCloudProviderApi,
+  getProviderStartupTimeoutMs,
   resolveProviderName
 };