libretto 0.6.10 → 0.6.12

package/src/cli/commands/execution.ts

@@ -1,56 +1,80 @@
-import { existsSync, readFileSync, unlinkSync, writeFileSync } from "node:fs";
-import { spawn } from "node:child_process";
+import { readFileSync } from "node:fs";
 import * as moduleBuiltin from "node:module";
-import { fileURLToPath } from "node:url";
 import { z } from "zod";
 import { installInstrumentation } from "../../shared/instrumentation/index.js";
 import type { LoggerApi } from "../../shared/logger/index.js";
 import {
   connect,
   disconnectBrowser,
+  getProfilePath,
+  hasProfile,
+  normalizeDomain,
+  normalizeUrl,
+  runClose,
   resolveViewport,
 } from "../core/browser.js";
 import { parseViewportArg } from "./browser.js";
-import { getPauseSignalPaths } from "../core/pause-signals.js";
 import {
   assertSessionAvailableForStart,
   assertSessionAllowsCommand,
   clearSessionState,
+  logFileForSession,
   readSessionState,
   readSessionStateOrThrow,
   setSessionStatus,
+  writeSessionState,
   type SessionState,
 } from "../core/session.js";
 import { warnIfInstalledSkillOutOfDate } from "../core/skill-version.js";
 import { readLibrettoConfig } from "../core/config.js";
-import { resolveProviderName, getCloudProviderApi } from "../core/providers/index.js";
+import { librettoCommand } from "../../shared/package-manager.js";
+import { renderSnapshotDiff } from "../../shared/snapshot/diff-snapshots.js";
+import { resolveProviderName } from "../core/providers/index.js";
+import { getAbsoluteIntegrationPath } from "../core/workflow-runtime.js";
 import {
   compileExecFunction,
   stripEmptyCatchHandlers,
 } from "../core/exec-compiler.js";
-import { DaemonClient } from "../core/daemon/index.js";
+import {
+  DaemonClient,
+  type DaemonExecSuccess,
+  type DaemonExecResult,
+  type DaemonToCliApi,
+} from "../core/daemon/ipc.js";
 import { createReadonlyExecHelpers } from "../core/readonly-exec.js";
 import {
   readActionLog,
   readNetworkLog,
   wrapPageForActionLogging,
 } from "../core/telemetry.js";
-import type { RunIntegrationWorkerRequest } from "../workers/run-integration-worker-protocol.js";
+import type { SessionAccessMode } from "../../shared/state/index.js";
+import type { Experiments } from "../core/experiments.js";
 import { SimpleCLI } from "../framework/simple-cli.js";
 import {
   pageOption,
   sessionOption,
   withAutoSession,
+  withExperiments,
   withRequiredSession,
 } from "./shared.js";
 
-type RunIntegrationCommandRequest = RunIntegrationWorkerRequest & {
+type RunIntegrationCommandRequest = {
+  integrationPath: string;
+  session: string;
+  params: unknown;
+  headless: boolean;
+  visualize: boolean;
+  viewport?: { width: number; height: number };
+  accessMode: SessionAccessMode;
+  authProfileDomain?: string;
+  providerName?: string;
+  stayOpenOnSuccess: boolean;
   tsconfigPath?: string;
+  experiments: Experiments;
 };
 type ExecMode = "exec" | "readonly-exec";
 
 const require = moduleBuiltin.createRequire(import.meta.url);
-const tsxCliPath = require.resolve("tsx/cli");
 
 function writeDaemonExecOutput(output?: { stdout: string; stderr: string }) {
   if (output?.stdout) {
@@ -61,6 +85,16 @@ function writeDaemonExecOutput(output?: { stdout: string; stderr: string }) {
   }
 }
 
+function writeDaemonSnapshotDiff(
+  snapshotDiff: DaemonExecSuccess["snapshotDiff"],
+) {
+  if (!snapshotDiff) return;
+  const renderedDiff = renderSnapshotDiff(snapshotDiff);
+  if (!renderedDiff) return;
+  console.log("Page changes:");
+  console.log(renderedDiff);
+}
+
 async function execViaDaemon(
   code: string,
   session: string,
@@ -86,26 +120,30 @@ async function execViaDaemon(
     via: "daemon",
   });
 
-  const client = new DaemonClient(daemonSocketPath);
-
-  const response =
-    mode === "exec"
-      ? await client.exec({
-          code: cleanedCode,
-          pageId: options.pageId,
-          visualize: options.visualize,
-        })
-      : await client.readonlyExec({
-          code: cleanedCode,
-          pageId: options.pageId,
-        });
+  const client = await DaemonClient.connect(daemonSocketPath);
+  let response: DaemonExecResult;
+  try {
+    response =
+      mode === "exec"
+        ? await client.exec({
+            code: cleanedCode,
+            pageId: options.pageId,
+            visualize: options.visualize,
+          })
+        : await client.readonlyExec({
+            code: cleanedCode,
+            pageId: options.pageId,
+          });
+  } finally {
+    client.destroy();
+  }
 
   if (!response.ok) {
     writeDaemonExecOutput(response.output);
     throw new Error(response.message);
   }
 
-  const { result, output } = response.data;
+  const { result, output, snapshotDiff } = response.data;
   writeDaemonExecOutput(output);
 
   logger.info(`${mode}-success`, {
@@ -120,6 +158,7 @@ async function execViaDaemon(
   } else {
     console.log("Executed successfully");
   }
+  writeDaemonSnapshotDiff(snapshotDiff);
 }
 
 async function execViaCdpFallback(
@@ -276,10 +315,9 @@ async function runExec(
 ): Promise<void> {
   const state = readSessionStateOrThrow(session);
   if (!state.daemonSocketPath) {
-    // Compatibility fallback for failed runs created before `run` became
-    // daemon-backed: those session states can have a live CDP endpoint/port but
-    // no daemon socket. Keep `exec` inspection working until such sessions are
-    // gone. Context: https://www.notion.so/Make-libretto-run-daemon-backed-for-failed-workflow-inspection-352ac9fb35f181c1b7d3f08c0a735e9d
+    // Compatibility fallback for older sessions that predate daemon-backed
+    // command handling. Keep `exec` inspection working when state has a live
+    // CDP endpoint/port but no daemon socket.
     logger.warn(`${options.mode ?? "exec"}-daemon-socket-missing-cdp-fallback`, {
       session,
       hasCdpEndpoint: Boolean(state.cdpEndpoint),
@@ -322,9 +360,23 @@ async function stopExistingFailedRunSession(
     pid: existingState.pid,
     port: existingState.port,
   });
-  clearSessionState(session, logger);
+  if (existingState.pid == null) {
+    clearSessionState(session, logger);
+    return;
+  }
 
-  if (existingState.pid == null) return;
+  try {
+    process.kill(existingState.pid, "SIGTERM");
+  } catch (error) {
+    const code = (error as NodeJS.ErrnoException).code;
+    if (code !== "ESRCH") {
+      logger.warn("run-release-existing-failed-session-signal-failed", {
+        session,
+        pid: existingState.pid,
+        error,
+      });
+    }
+  }
 
   const stopDeadline = Date.now() + 3_000;
   while (isProcessRunning(existingState.pid) && Date.now() < stopDeadline) {
@@ -335,69 +387,17 @@ async function stopExistingFailedRunSession(
       session,
       pid: existingState.pid,
     });
-    console.warn(
-      `Existing failed workflow process for session "${session}" (pid ${existingState.pid}) is still shutting down; continuing.`,
+    throw new Error(
+      `Existing failed workflow process for session "${session}" (pid ${existingState.pid}) is still running. Close it with: ${librettoCommand(`close --session ${session}`)}`,
     );
-    return;
   }
+  clearSessionState(session, logger);
   console.log(
     `Closed existing failed workflow process for session "${session}" (pid ${existingState.pid}).`,
   );
 }
 
-function readJsonFileIfExists(path: string): unknown {
-  if (!existsSync(path)) return null;
-  try {
-    return JSON.parse(readFileSync(path, "utf8")) as unknown;
-  } catch {
-    return null;
-  }
-}
-
-function readFailureDetails(path: string): {
-  message?: string;
-  phase?: "setup" | "workflow";
-} | null {
-  const raw = readJsonFileIfExists(path);
-  if (!raw || typeof raw !== "object") return null;
-
-  const message = (raw as { message?: unknown }).message;
-  const phase = (raw as { phase?: unknown }).phase;
-
-  return {
-    message: typeof message === "string" ? message : undefined,
-    phase: phase === "setup" || phase === "workflow" ? phase : undefined,
-  };
-}
-
-async function waitForFailureDetails(
-  path: string,
-  timeoutMs = 1_000,
-): Promise<{
-  message?: string;
-  phase?: "setup" | "workflow";
-} | null> {
-  const deadline = Date.now() + timeoutMs;
-  while (Date.now() < deadline) {
-    const details = readFailureDetails(path);
-    if (details?.message) return details;
-    await new Promise((resolveWait) => setTimeout(resolveWait, 25));
-  }
-  return readFailureDetails(path);
-}
-
-function streamOutputSince(path: string, offset: number): number {
-  if (!existsSync(path)) return offset;
-  const output = readFileSync(path);
-  if (output.length <= offset) return output.length;
-  process.stdout.write(output.subarray(offset));
-  return output.length;
-}
-
-type WaitForWorkflowOutcomeArgs = {
-  session: string;
-  pid: number;
-};
+type RunIntegrationResult = "completed" | "paused";
 
 type WorkflowOutcome = {
   status: "completed" | "paused" | "failed" | "exited";
@@ -405,70 +405,68 @@ type WorkflowOutcome = {
   phase?: "setup" | "workflow";
 };
 
-function clearSignalIfExists(path: string): void {
-  if (!existsSync(path)) return;
-  try {
-    unlinkSync(path);
-  } catch {
-    // Ignore cleanup failures; next checks still validate actual state.
-  }
-}
-
-async function waitForWorkflowOutcome(
-  args: WaitForWorkflowOutcomeArgs,
-): Promise<WorkflowOutcome> {
-  const signalPaths = getPauseSignalPaths(args.session);
-  if (args.pid <= 0) {
-    return { status: "exited" };
-  }
-  let outputOffset = 0;
+type Deferred<T> = {
+  promise: Promise<T>;
+  resolve(value: T): void;
+};
 
-  while (true) {
-    outputOffset = streamOutputSince(
-      signalPaths.outputSignalPath,
-      outputOffset,
-    );
+function createDeferred<T>(): Deferred<T> {
+  let resolve!: (value: T) => void;
+  const promise = new Promise<T>((resolvePromise) => {
+    resolve = resolvePromise;
+  });
+  return { promise, resolve };
+}
 
-    if (existsSync(signalPaths.failedSignalPath)) {
-      outputOffset = streamOutputSince(
-        signalPaths.outputSignalPath,
-        outputOffset,
-      );
-      const failureDetails = await waitForFailureDetails(
-        signalPaths.failedSignalPath,
-      );
-      return {
+function createWorkflowHandlers(
+  settleOutcome: (outcome: WorkflowOutcome) => void,
+): DaemonToCliApi {
+  return {
+    workflowOutput: (event) => {
+      const stream =
+        event.stream === "stdout" ? process.stdout : process.stderr;
+      stream.write(event.text);
+    },
+    workflowPaused: () => {
+      settleOutcome({ status: "paused" });
+    },
+    workflowFinished: (event) => {
+      if (event.result === "completed") {
+        settleOutcome({ status: "completed" });
+        return;
+      }
+      settleOutcome({
         status: "failed",
-        message: failureDetails?.message,
-        phase: failureDetails?.phase,
-      };
-    }
+        message: event.message,
+        phase: event.phase,
+      });
+    },
+  };
+}
 
-    if (existsSync(signalPaths.completedSignalPath)) {
-      outputOffset = streamOutputSince(
-        signalPaths.outputSignalPath,
-        outputOffset,
-      );
-      return { status: "completed" };
-    }
+async function waitForWorkflowOutcome(
+  pid: number,
+  outcomePromise: Promise<WorkflowOutcome>,
+): Promise<WorkflowOutcome> {
+  let processExitInterval: ReturnType<typeof setInterval> | undefined;
 
-    if (existsSync(signalPaths.pausedSignalPath)) {
-      outputOffset = streamOutputSince(
-        signalPaths.outputSignalPath,
-        outputOffset,
-      );
-      return { status: "paused" };
+  const processExitPromise = new Promise<WorkflowOutcome>((resolve) => {
+    if (pid <= 0 || !isProcessRunning(pid)) {
+      resolve({ status: "exited" });
+      return;
     }
 
-    if (!isProcessRunning(args.pid)) {
-      outputOffset = streamOutputSince(
-        signalPaths.outputSignalPath,
-        outputOffset,
-      );
-      return { status: "exited" };
-    }
+    processExitInterval = setInterval(() => {
+      if (!isProcessRunning(pid)) {
+        resolve({ status: "exited" });
+      }
+    }, 250);
+  });
 
-    await new Promise((resolveWait) => setTimeout(resolveWait, 250));
+  try {
+    return await Promise.race([outcomePromise, processExitPromise]);
+  } finally {
+    if (processExitInterval) clearInterval(processExitInterval);
   }
 }
 
@@ -477,56 +475,63 @@ async function runResume(
   logger: LoggerApi,
   sessionState: SessionState,
 ): Promise<void> {
-  const {
-    pausedSignalPath,
-    resumeSignalPath,
-    completedSignalPath,
-    failedSignalPath,
-    outputSignalPath,
-  } = getPauseSignalPaths(session);
-
-  if (!existsSync(pausedSignalPath)) {
+  if (sessionState.pid == null || !isProcessRunning(sessionState.pid)) {
     throw new Error(
-      `Session "${session}" is not paused. Run "libretto run ... --session ${session}" and call pause("${session}") first.`,
+      `No active paused workflow found for session "${session}" (worker pid ${sessionState.pid ?? "unknown"} is not running).`,
     );
   }
 
-  if (sessionState.pid == null || !isProcessRunning(sessionState.pid)) {
+  if (!sessionState.daemonSocketPath) {
     throw new Error(
-      `No active paused workflow found for session "${session}" (worker pid ${sessionState.pid ?? "unknown"} is not running).`,
+      `No active paused workflow found for session "${session}" (daemon socket is missing).`,
     );
   }
 
-  // Clear stale pause/output markers before signaling resume so we always wait
-  // for the next pause/completion and only stream post-resume logs.
-  clearSignalIfExists(pausedSignalPath);
-  clearSignalIfExists(outputSignalPath);
-  clearSignalIfExists(completedSignalPath);
-  clearSignalIfExists(failedSignalPath);
-  setSessionStatus(session, "active", logger);
+  const workflowOutcome = createDeferred<WorkflowOutcome>();
+  const handlers = createWorkflowHandlers(workflowOutcome.resolve);
+  let client: DaemonClient;
+  try {
+    client = await DaemonClient.connect(
+      sessionState.daemonSocketPath,
+      handlers,
+    );
+  } catch {
+    throw new Error(
+      `No active paused workflow found for session "${session}" (worker pid ${sessionState.pid} is not running).`,
+    );
+  }
 
-  writeFileSync(
-    resumeSignalPath,
-    JSON.stringify(
-      {
-        resumedAt: new Date().toISOString(),
-        sourcePid: process.pid,
-      },
-      null,
-      2,
-    ),
-    "utf8",
-  );
-  console.log(`Resume signal sent for session "${session}".`);
+  let outcome: WorkflowOutcome;
+  try {
+    const status = await client.getWorkflowStatus();
+    if (status.state !== "paused") {
+      throw new Error(
+        `Session "${session}" is not paused. Run "${librettoCommand(`run ... --session ${session}`)}" and call pause("${session}") first.`,
+      );
+    }
 
-  const outcome = await waitForWorkflowOutcome({
-    session,
-    pid: sessionState.pid!,
-  });
+    await client.resumeWorkflow();
+    setSessionStatus(session, "active", logger);
+    console.log(`Resume requested for session "${session}".`);
+
+    outcome = await waitForWorkflowOutcome(
+      sessionState.pid!,
+      workflowOutcome.promise,
+    );
+  } finally {
+    client.destroy();
+  }
 
   if (outcome.status === "completed") {
     setSessionStatus(session, "completed", logger);
     console.log("Integration completed.");
+    if (sessionState.stayOpenOnSuccess) {
+      console.log(
+        `Browser is still open for session "${session}". Close it with: libretto close --session ${session}`,
+      );
+    } else {
+      await runClose(session, logger);
+    }
     return;
   }
   if (outcome.status === "failed") {
@@ -540,7 +545,8 @@ async function runResume(
   if (outcome.status === "exited") {
     setSessionStatus(session, "exited", logger);
     throw new Error(
-      `Workflow process for session "${session}" exited before reporting completion or pause.`,
+      outcome.message ??
+        `Workflow process for session "${session}" exited before reporting completion or pause.`,
     );
   }
   setSessionStatus(session, "paused", logger);
@@ -550,53 +556,95 @@ async function runResume(
 async function runIntegrationFromFile(
   args: RunIntegrationCommandRequest,
   logger: LoggerApi,
-): Promise<void> {
+): Promise<RunIntegrationResult> {
   await stopExistingFailedRunSession(args.session, logger);
-  const signalPaths = getPauseSignalPaths(args.session);
-  clearSignalIfExists(signalPaths.pausedSignalPath);
-  clearSignalIfExists(signalPaths.resumeSignalPath);
-  clearSignalIfExists(signalPaths.completedSignalPath);
-  clearSignalIfExists(signalPaths.failedSignalPath);
-  clearSignalIfExists(signalPaths.outputSignalPath);
-
-  const workerEntryPath = fileURLToPath(
-    new URL("../workers/run-integration-worker.js", import.meta.url),
+
+  const absoluteIntegrationPath = getAbsoluteIntegrationPath(
+    args.integrationPath,
   );
-  const payload = JSON.stringify({
-    integrationPath: args.integrationPath,
-    session: args.session,
-    params: args.params,
-    headless: args.headless,
-    visualize: args.visualize,
-    authProfileDomain: args.authProfileDomain,
-    viewport: args.viewport,
-    accessMode: args.accessMode,
-    cdpEndpoint: args.cdpEndpoint,
-    provider: args.provider,
-  } satisfies RunIntegrationWorkerRequest);
-  const worker = spawn(
-    process.execPath,
-    [
-      tsxCliPath,
-      ...(args.tsconfigPath ? ["--tsconfig", args.tsconfigPath] : []),
-      workerEntryPath,
-      payload,
-    ],
+  if (args.authProfileDomain) {
+    const normalizedDomain = normalizeDomain(normalizeUrl(args.authProfileDomain));
+    if (!hasProfile(normalizedDomain)) {
+      const profilePath = getProfilePath(normalizedDomain);
+      throw new Error(
+        [
+          `Local auth profile not found for domain "${normalizedDomain}".`,
+          `Expected profile file: ${profilePath}`,
+          "To create it:",
+          `  1. ${librettoCommand(`open https://${normalizedDomain} --headed --session ${args.session}`)}`,
+          "  2. Log in manually in the browser window.",
+          `  3. ${librettoCommand(`save ${normalizedDomain} --session ${args.session}`)}`,
+        ].join("\n"),
+      );
+    }
+  }
+
+  const runLogPath = logFileForSession(args.session);
+  const workflowOutcome = createDeferred<WorkflowOutcome>();
+  const handlers = createWorkflowHandlers(workflowOutcome.resolve);
+  const {
+    pid,
+    socketPath: daemonSocketPath,
+    provider,
+    client,
+  } = await DaemonClient.spawn({
+    config: {
+      session: args.session,
+      experiments: args.experiments,
+      browser: args.providerName
+        ? { kind: "provider", providerName: args.providerName }
+        : {
+            kind: "launch",
+            headed: !args.headless,
+            viewport: args.viewport ?? { width: 1366, height: 768 },
+      },
+      workflow: {
+        integrationPath: absoluteIntegrationPath,
+        params: args.params,
+        visualize: args.visualize,
+        stayOpenOnSuccess: args.stayOpenOnSuccess,
+        tsconfigPath: args.tsconfigPath,
+        authProfileDomain: args.authProfileDomain,
+      },
+    },
+    logger,
+    logPath: runLogPath,
+    startupTimeoutMs: 60_000,
+    handlers,
+  });
+
+  writeSessionState(
     {
-      detached: true,
-      stdio: "ignore",
-      env: process.env,
+      port: 0,
+      pid,
+      cdpEndpoint: provider?.cdpEndpoint,
+      session: args.session,
+      startedAt: new Date().toISOString(),
+      status: "active",
+      mode: args.accessMode,
+      viewport: args.viewport,
+      stayOpenOnSuccess: args.stayOpenOnSuccess,
+      daemonSocketPath,
+      provider: provider
+        ? { name: provider.name, sessionId: provider.sessionId }
+        : undefined,
     },
+    logger,
   );
-  worker.unref();
-  const outcome = await waitForWorkflowOutcome({
-    session: args.session,
-    pid: worker.pid ?? 0,
-  });
+  if (provider?.liveViewUrl) {
+    console.log(`View live session: ${provider.liveViewUrl}`);
+  }
+
+  let outcome: WorkflowOutcome;
+  try {
+    outcome = await waitForWorkflowOutcome(pid, workflowOutcome.promise);
+  } finally {
+    client.destroy();
+  }
   if (outcome.status === "paused") {
     setSessionStatus(args.session, "paused", logger);
     console.log("Workflow paused.");
-    return;
+    return "paused";
   }
   if (outcome.status === "failed") {
     setSessionStatus(args.session, "failed", logger);
@@ -610,11 +658,20 @@ async function runIntegrationFromFile(
   if (outcome.status === "exited") {
     setSessionStatus(args.session, "exited", logger);
     throw new Error(
-      "Workflow process exited before reporting completion or pause during run.",
+      outcome.message ??
+        "Workflow process exited before reporting completion or pause during run.",
     );
   }
   setSessionStatus(args.session, "completed", logger);
   console.log("Integration completed.");
+  if (args.stayOpenOnSuccess) {
+    console.log(
+      `Browser is still open for session "${args.session}". Close it with: libretto close --session ${args.session}`,
+    );
+  } else {
+    await runClose(args.session, logger);
+  }
+  return "completed";
 }
 
 function readStdinSync(): string | null {
@@ -642,7 +699,7 @@ export const execInput = SimpleCLI.input({
   },
 }).refine(
   (input) => input.code !== undefined,
-  `Usage: libretto exec <code|-> [--session <name>] [--visualize]\n       echo '<code>' | libretto exec - [--session <name>] [--visualize]`,
+  `Usage: ${librettoCommand("exec <code|-> [--session <name>] [--visualize]")}\n       echo '<code>' | ${librettoCommand("exec - [--session <name>] [--visualize]")}`,
 );
 
 export const execCommand = SimpleCLI.command({
@@ -683,7 +740,7 @@ export const readonlyExecInput = SimpleCLI.input({
   },
 }).refine(
   (input) => input.code !== undefined,
-  `Usage: libretto readonly-exec <code|-> [--session <name>] [--page <id>]\n       echo '<code>' | libretto readonly-exec - [--session <name>] [--page <id>]`,
+  `Usage: ${librettoCommand("readonly-exec <code|-> [--session <name>] [--page <id>]")}\n       echo '<code>' | ${librettoCommand("readonly-exec - [--session <name>] [--page <id>]")}`,
 );
 
 export const readonlyExecCommand = SimpleCLI.command({
@@ -705,7 +762,7 @@ export const readonlyExecCommand = SimpleCLI.command({
     });
   });
 
-const runUsage = `Usage: libretto run <integrationFile> [--params <json> | --params-file <path>] [--tsconfig <path>] [--headed|--headless] [--read-only|--write-access] [--no-visualize] [--viewport WxH]`;
+const runUsage = `Usage: ${librettoCommand("run <integrationFile> [--params <json> | --params-file <path>] [--tsconfig <path>] [--headed|--headless] [--read-only|--write-access] [--no-visualize] [--stay-open-on-success] [--viewport WxH]")}`;
 
 export const runInput = SimpleCLI.input({
   positionals: [
@@ -739,6 +796,10 @@ export const runInput = SimpleCLI.input({
       name: "no-visualize",
       help: "Disable ghost cursor + highlight visualization in headed mode",
     }),
+    stayOpenOnSuccess: SimpleCLI.flag({
+      name: "stay-open-on-success",
+      help: "Keep the browser session open after the workflow completes successfully",
+    }),
     authProfile: SimpleCLI.option(z.string().optional(), {
       name: "auth-profile",
       help: "Domain for local auth profile (e.g. apps.example.com)",
@@ -795,6 +856,7 @@ export const runCommand = SimpleCLI.command({
 })
   .input(runInput)
   .use(withAutoSession())
+  .use(withExperiments())
   .handle(async ({ input, ctx }) => {
     warnIfInstalledSkillOutOfDate();
     await stopExistingFailedRunSession(ctx.session, ctx.logger);
@@ -813,64 +875,34 @@ export const runCommand = SimpleCLI.command({
     );
 
     const providerName = resolveProviderName(input.provider);
-    let cdpEndpoint: string | undefined;
-    let providerInfo: { name: string; sessionId: string } | undefined;
-    let provider: ReturnType<typeof getCloudProviderApi> | undefined;
-    if (providerName !== "local") {
-      provider = getCloudProviderApi(providerName);
+    const daemonProviderName = providerName === "local" ? undefined : providerName;
+    if (daemonProviderName) {
       console.log(
         `Creating ${providerName} browser session (session: ${ctx.session})...`,
       );
-      const providerSession = await provider.createSession();
-      ctx.logger.info("run-provider-session-created", {
+      ctx.logger.info("run-provider-session-requested", {
         provider: providerName,
-        sessionId: providerSession.sessionId,
-        cdpEndpoint: providerSession.cdpEndpoint,
-        liveViewUrl: providerSession.liveViewUrl,
       });
-      if (providerSession.liveViewUrl) {
-        console.log(`View live session: ${providerSession.liveViewUrl}`);
-      }
       console.log(`Connecting to ${providerName} browser...`);
-      cdpEndpoint = providerSession.cdpEndpoint;
-      providerInfo = {
-        name: providerName,
-        sessionId: providerSession.sessionId,
-      };
     }
 
-    try {
-      await runIntegrationFromFile(
-        {
-          integrationPath: input.integrationFile!,
-          session: ctx.session,
-          params,
-          tsconfigPath: input.tsconfig,
-          headless: cdpEndpoint ? true : (headlessMode ?? false),
-          visualize,
-          authProfileDomain: input.authProfile,
-          viewport,
-          accessMode: input.readOnly ? "read-only" : input.writeAccess ? "write-access" : (readLibrettoConfig().sessionMode ?? "write-access"),
-          cdpEndpoint,
-          provider: providerInfo,
-        },
-        ctx.logger,
-      );
-    } finally {
-      if (provider && providerInfo) {
-        try {
-          const result = await provider.closeSession(providerInfo.sessionId);
-          if (result.replayUrl) {
-            console.log(`View recording: ${result.replayUrl}`);
-          }
-        } catch (cleanupErr) {
-          console.error(
-            `Failed to clean up ${providerInfo.name} session ${providerInfo.sessionId}:`,
-            cleanupErr instanceof Error ? cleanupErr.message : cleanupErr,
-          );
-        }
-      }
-    }
+    await runIntegrationFromFile(
+      {
+        integrationPath: input.integrationFile!,
+        session: ctx.session,
+        params,
+        tsconfigPath: input.tsconfig,
+        headless: daemonProviderName ? true : (headlessMode ?? false),
+        visualize,
+        authProfileDomain: input.authProfile,
+        viewport,
+        accessMode: input.readOnly ? "read-only" : input.writeAccess ? "write-access" : (readLibrettoConfig().sessionMode ?? "write-access"),
+        providerName: daemonProviderName,
+        stayOpenOnSuccess: input.stayOpenOnSuccess,
+        experiments: ctx.experiments,
+      },
+      ctx.logger,
+    );
   });
 
 export const resumeInput = SimpleCLI.input({