libretto 0.6.11 → 0.6.12

package/dist/cli/commands/execution.js

@@ -1,32 +1,41 @@
-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 {
   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
+  setSessionStatus,
+  writeSessionState
 } 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
+} from "../core/daemon/ipc.js";
 import { createReadonlyExecHelpers } from "../core/readonly-exec.js";
 import {
   readActionLog,
@@ -38,10 +47,10 @@ import {
   pageOption,
   sessionOption,
   withAutoSession,
+  withExperiments,
   withRequiredSession
 } from "./shared.js";
 const require2 = moduleBuiltin.createRequire(import.meta.url);
-const tsxCliPath = require2.resolve("tsx/cli");
 function writeDaemonExecOutput(output) {
   if (output?.stdout) {
     process.stdout.write(output.stdout);
@@ -50,6 +59,13 @@ function writeDaemonExecOutput(output) {
     process.stderr.write(output.stderr);
   }
 }
+function writeDaemonSnapshotDiff(snapshotDiff) {
+  if (!snapshotDiff) return;
+  const renderedDiff = renderSnapshotDiff(snapshotDiff);
+  if (!renderedDiff) return;
+  console.log("Page changes:");
+  console.log(renderedDiff);
+}
 async function execViaDaemon(code, session, daemonSocketPath, logger, options) {
   const mode = options.mode ?? "exec";
   const { cleaned: cleanedCode, strippedCount } = stripEmptyCatchHandlers(code);
@@ -64,20 +80,25 @@ async function execViaDaemon(code, session, daemonSocketPath, logger, options) {
     pageId: options.pageId,
     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;
+  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`, {
     session,
@@ -91,6 +112,7 @@ async function execViaDaemon(code, session, daemonSocketPath, logger, options) {
   } else {
     console.log("Executed successfully");
   }
+  writeDaemonSnapshotDiff(snapshotDiff);
 }
 async function execViaCdpFallback(code, session, logger, options) {
   const visualize = options.visualize ?? false;
@@ -237,8 +259,22 @@ async function stopExistingFailedRunSession(session, logger) {
     pid: existingState.pid,
     port: existingState.port
   });
-  clearSessionState(session, logger);
-  if (existingState.pid == null) return;
+  if (existingState.pid == null) {
+    clearSessionState(session, logger);
+    return;
+  }
+  try {
+    process.kill(existingState.pid, "SIGTERM");
+  } catch (error) {
+    const code = error.code;
+    if (code !== "ESRCH") {
+      logger.warn("run-release-existing-failed-session-signal-failed", {
+        session,
+        pid: existingState.pid,
+        error
+      });
+    }
+  }
   const stopDeadline = Date.now() + 3e3;
   while (isProcessRunning(existingState.pid) && Date.now() < stopDeadline) {
     await new Promise((resolveWait) => setTimeout(resolveWait, 100));
@@ -248,148 +284,115 @@ async function stopExistingFailedRunSession(session, logger) {
       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) {
-  if (!existsSync(path)) return null;
-  try {
-    return JSON.parse(readFileSync(path, "utf8"));
-  } catch {
-    return null;
-  }
+function createDeferred() {
+  let resolve;
+  const promise = new Promise((resolvePromise) => {
+    resolve = resolvePromise;
+  });
+  return { promise, resolve };
 }
-function readFailureDetails(path) {
-  const raw = readJsonFileIfExists(path);
-  if (!raw || typeof raw !== "object") return null;
-  const message = raw.message;
-  const phase = raw.phase;
+function createWorkflowHandlers(settleOutcome) {
   return {
-    message: typeof message === "string" ? message : void 0,
-    phase: phase === "setup" || phase === "workflow" ? phase : void 0
+    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: event.message,
+        phase: event.phase
+      });
+    }
   };
 }
-async function waitForFailureDetails(path, timeoutMs = 1e3) {
-  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, offset) {
-  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;
-}
-function clearSignalIfExists(path) {
-  if (!existsSync(path)) return;
+async function waitForWorkflowOutcome(pid, outcomePromise) {
+  let processExitInterval;
+  const processExitPromise = new Promise((resolve) => {
+    if (pid <= 0 || !isProcessRunning(pid)) {
+      resolve({ status: "exited" });
+      return;
+    }
+    processExitInterval = setInterval(() => {
+      if (!isProcessRunning(pid)) {
+        resolve({ status: "exited" });
+      }
+    }, 250);
+  });
   try {
-    unlinkSync(path);
-  } catch {
+    return await Promise.race([outcomePromise, processExitPromise]);
+  } finally {
+    if (processExitInterval) clearInterval(processExitInterval);
   }
 }
-async function waitForWorkflowOutcome(args) {
-  const signalPaths = getPauseSignalPaths(args.session);
-  if (args.pid <= 0) {
-    return { status: "exited" };
-  }
-  let outputOffset = 0;
-  while (true) {
-    outputOffset = streamOutputSince(
-      signalPaths.outputSignalPath,
-      outputOffset
+async function runResume(session, logger, sessionState) {
+  if (sessionState.pid == null || !isProcessRunning(sessionState.pid)) {
+    throw new Error(
+      `No active paused workflow found for session "${session}" (worker pid ${sessionState.pid ?? "unknown"} is not running).`
     );
-    if (existsSync(signalPaths.failedSignalPath)) {
-      outputOffset = streamOutputSince(
-        signalPaths.outputSignalPath,
-        outputOffset
-      );
-      const failureDetails = await waitForFailureDetails(
-        signalPaths.failedSignalPath
-      );
-      return {
-        status: "failed",
-        message: failureDetails?.message,
-        phase: failureDetails?.phase
-      };
-    }
-    if (existsSync(signalPaths.completedSignalPath)) {
-      outputOffset = streamOutputSince(
-        signalPaths.outputSignalPath,
-        outputOffset
-      );
-      return { status: "completed" };
-    }
-    if (existsSync(signalPaths.pausedSignalPath)) {
-      outputOffset = streamOutputSince(
-        signalPaths.outputSignalPath,
-        outputOffset
-      );
-      return { status: "paused" };
-    }
-    if (!isProcessRunning(args.pid)) {
-      outputOffset = streamOutputSince(
-        signalPaths.outputSignalPath,
-        outputOffset
-      );
-      return { status: "exited" };
-    }
-    await new Promise((resolveWait) => setTimeout(resolveWait, 250));
   }
-}
-async function runResume(session, logger, sessionState) {
-  const {
-    pausedSignalPath,
-    resumeSignalPath,
-    completedSignalPath,
-    failedSignalPath,
-    outputSignalPath
-  } = getPauseSignalPaths(session);
-  if (!existsSync(pausedSignalPath)) {
+  if (!sessionState.daemonSocketPath) {
     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}" (daemon socket is missing).`
     );
   }
-  if (sessionState.pid == null || !isProcessRunning(sessionState.pid)) {
+  const workflowOutcome = createDeferred();
+  const handlers = createWorkflowHandlers(workflowOutcome.resolve);
+  let client;
+  try {
+    client = await DaemonClient.connect(
+      sessionState.daemonSocketPath,
+      handlers
+    );
+  } catch {
     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}" (worker pid ${sessionState.pid} is not running).`
     );
   }
-  clearSignalIfExists(pausedSignalPath);
-  clearSignalIfExists(outputSignalPath);
-  clearSignalIfExists(completedSignalPath);
-  clearSignalIfExists(failedSignalPath);
-  setSessionStatus(session, "active", logger);
-  writeFileSync(
-    resumeSignalPath,
-    JSON.stringify(
-      {
-        resumedAt: (/* @__PURE__ */ new Date()).toISOString(),
-        sourcePid: process.pid
-      },
-      null,
-      2
-    ),
-    "utf8"
-  );
-  console.log(`Resume signal sent for session "${session}".`);
-  const outcome = await waitForWorkflowOutcome({
-    session,
-    pid: sessionState.pid
-  });
+  let outcome;
+  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.`
+      );
+    }
+    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") {
@@ -401,7 +404,7 @@ async function runResume(session, logger, sessionState) {
   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);
@@ -409,50 +412,85 @@ async function runResume(session, logger, sessionState) {
 }
 async function runIntegrationFromFile(args, logger) {
   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
+  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();
+  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: 6e4,
+    handlers
   });
-  const worker = spawn(
-    process.execPath,
-    [
-      tsxCliPath,
-      ...args.tsconfigPath ? ["--tsconfig", args.tsconfigPath] : [],
-      workerEntryPath,
-      payload
-    ],
+  writeSessionState(
     {
-      detached: true,
-      stdio: "ignore",
-      env: process.env
-    }
+      port: 0,
+      pid,
+      cdpEndpoint: provider?.cdpEndpoint,
+      session: args.session,
+      startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      status: "active",
+      mode: args.accessMode,
+      viewport: args.viewport,
+      stayOpenOnSuccess: args.stayOpenOnSuccess,
+      daemonSocketPath,
+      provider: provider ? { name: provider.name, sessionId: provider.sessionId } : void 0
+    },
+    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;
+  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);
@@ -467,11 +505,19 @@ Browser is still open. You can use \`exec\` to inspect it. Call \`run\` to re-ru
   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() {
   if (process.stdin.isTTY === true) return null;
@@ -497,8 +543,8 @@ const execInput = SimpleCLI.input({
   }
 }).refine(
   (input) => input.code !== void 0,
-  `Usage: libretto exec <code|-> [--session <name>] [--visualize]
-       echo '<code>' | libretto exec - [--session <name>] [--visualize]`
+  `Usage: ${librettoCommand("exec <code|-> [--session <name>] [--visualize]")}
+       echo '<code>' | ${librettoCommand("exec - [--session <name>] [--visualize]")}`
 );
 const execCommand = SimpleCLI.command({
   description: "Execute Playwright TypeScript code"
@@ -534,8 +580,8 @@ const readonlyExecInput = SimpleCLI.input({
   }
 }).refine(
   (input) => input.code !== void 0,
-  `Usage: libretto readonly-exec <code|-> [--session <name>] [--page <id>]
-       echo '<code>' | libretto readonly-exec - [--session <name>] [--page <id>]`
+  `Usage: ${librettoCommand("readonly-exec <code|-> [--session <name>] [--page <id>]")}
+       echo '<code>' | ${librettoCommand("readonly-exec - [--session <name>] [--page <id>]")}`
 );
 const readonlyExecCommand = SimpleCLI.command({
   description: "Execute read-only Playwright inspection code"
@@ -552,7 +598,7 @@ const readonlyExecCommand = SimpleCLI.command({
     mode: "readonly-exec"
   });
 });
-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]")}`;
 const runInput = SimpleCLI.input({
   positionals: [
     SimpleCLI.positional("integrationFile", z.string().optional(), {
@@ -585,6 +631,10 @@ 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)"
@@ -629,7 +679,7 @@ function resolveRunParams(rawInlineParams, paramsFile) {
 }
 const runCommand = SimpleCLI.command({
   description: "Run the default-exported Libretto workflow from a file"
-}).input(runInput).use(withAutoSession()).handle(async ({ input, ctx }) => {
+}).input(runInput).use(withAutoSession()).use(withExperiments()).handle(async ({ input, ctx }) => {
   warnIfInstalledSkillOutOfDate();
   await stopExistingFailedRunSession(ctx.session, ctx.logger);
   assertSessionAvailableForStart(ctx.session, ctx.logger);
@@ -641,63 +691,33 @@ const runCommand = SimpleCLI.command({
     ctx.logger
   );
   const providerName = resolveProviderName(input.provider);
-  let cdpEndpoint;
-  let providerInfo;
-  let provider;
-  if (providerName !== "local") {
-    provider = getCloudProviderApi(providerName);
+  const daemonProviderName = providerName === "local" ? void 0 : providerName;
+  if (daemonProviderName) {
     console.log(
       `Creating ${providerName} browser session (session: ${ctx.session})...`
     );
-    const providerSession = await provider.createSession();
-    ctx.logger.info("run-provider-session-created", {
-      provider: providerName,
-      sessionId: providerSession.sessionId,
-      cdpEndpoint: providerSession.cdpEndpoint,
-      liveViewUrl: providerSession.liveViewUrl
+    ctx.logger.info("run-provider-session-requested", {
+      provider: providerName
     });
-    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
+  );
 });
 const resumeInput = SimpleCLI.input({
   positionals: [],