libretto 0.5.5 → 0.6.0

package/dist/cli/commands/execution.js

@@ -13,15 +13,20 @@ import { parseViewportArg } from "./browser.js";
 import { getPauseSignalPaths } from "../core/pause-signals.js";
 import {
   assertSessionAvailableForStart,
+  assertSessionAllowsCommand,
   clearSessionState,
   readSessionState,
   setSessionStatus
 } from "../core/session.js";
+import { warnIfInstalledSkillOutOfDate } from "../core/skill-version.js";
 import {
   readActionLog,
   readNetworkLog,
   wrapPageForActionLogging
 } from "../core/telemetry.js";
+import { readLibrettoConfig } from "../core/config.js";
+import { resolveProviderName, getCloudProviderApi } from "../core/providers/index.js";
+import { createReadonlyExecHelpers } from "../core/readonly-exec.js";
 import { SimpleCLI } from "../framework/simple-cli.js";
 import {
   pageOption,
@@ -135,12 +140,15 @@ function stripEmptyCatchHandlers(code) {
   }
   return { cleaned: result, strippedCount };
 }
-async function runExec(code, session, logger, visualize = false, pageId) {
+async function runExec(code, session, logger, options = {}) {
+  const visualize = options.visualize ?? false;
+  const pageId = options.pageId;
+  const mode = options.mode ?? "exec";
   const { cleaned: cleanedCode, strippedCount } = stripEmptyCatchHandlers(code);
   if (strippedCount > 0) {
     console.log("(Stripped `.catch(() => {})` \u2014 letting errors bubble up)");
   }
-  logger.info("exec-start", {
+  logger.info(`${mode}-start`, {
     session,
     codeLength: cleanedCode.length,
     codePreview: cleanedCode.slice(0, 200),
@@ -164,57 +172,61 @@ async function runExec(code, session, logger, visualize = false, pageId) {
   const stallInterval = setInterval(() => {
     const silenceMs = Date.now() - lastActivityTs;
     if (silenceMs >= STALL_THRESHOLD_MS) {
-      logger.warn("exec-stall-warning", {
+      logger.warn(`${mode}-stall-warning`, {
         session,
         silenceMs,
         codePreview: cleanedCode.slice(0, 200)
       });
       console.warn(
-        `[stall-warning] No Playwright activity for ${Math.round(silenceMs / 1e3)}s \u2014 exec may be hung (code: ${cleanedCode.slice(0, 100)}...)`
+        `[stall-warning] No Playwright activity for ${Math.round(silenceMs / 1e3)}s \u2014 ${mode} may be hung (code: ${cleanedCode.slice(0, 100)}...)`
       );
     }
   }, STALL_THRESHOLD_MS);
   const execStartTs = Date.now();
   const sigintHandler = () => {
-    logger.info("exec-interrupted", {
+    logger.info(`${mode}-interrupted`, {
       session,
       duration: Date.now() - execStartTs,
       codePreview: cleanedCode.slice(0, 200)
     });
   };
   process.on("SIGINT", sigintHandler);
-  wrapPageForActionLogging(page, session, resolvedPageId, onActivity);
-  if (visualize) {
+  if (mode === "exec") {
+    wrapPageForActionLogging(page, session, resolvedPageId, onActivity);
+  }
+  if (visualize && mode === "exec") {
     await installInstrumentation(page, { visualize: true, logger });
   }
   try {
-    const execState = {};
-    const networkLog = (opts = {}) => {
-      return readNetworkLog(session, opts);
-    };
-    const actionLog = (opts = {}) => {
-      return readActionLog(session, opts);
-    };
-    const helpers = {
-      page,
-      context,
-      state: execState,
-      browser,
-      networkLog,
-      actionLog,
-      console,
-      setTimeout,
-      setInterval,
-      clearTimeout,
-      clearInterval,
-      fetch,
-      URL,
-      Buffer
-    };
+    const helpers = mode === "readonly-exec" ? createReadonlyExecHelpers(page, { onActivity }) : (() => {
+      const execState = {};
+      const networkLog = (opts = {}) => {
+        return readNetworkLog(session, opts);
+      };
+      const actionLog = (opts = {}) => {
+        return readActionLog(session, opts);
+      };
+      return {
+        page,
+        context,
+        state: execState,
+        browser,
+        networkLog,
+        actionLog,
+        console,
+        setTimeout,
+        setInterval,
+        clearTimeout,
+        clearInterval,
+        fetch,
+        URL,
+        Buffer
+      };
+    })();
     const helperNames = Object.keys(helpers);
     const fn = compileExecFunction(cleanedCode, helperNames);
     const result = await fn(...Object.values(helpers));
-    logger.info("exec-success", { session, hasResult: result !== void 0 });
+    logger.info(`${mode}-success`, { session, hasResult: result !== void 0 });
     if (result !== void 0) {
       console.log(
         typeof result === "string" ? result : JSON.stringify(result, null, 2)
@@ -223,7 +235,7 @@ async function runExec(code, session, logger, visualize = false, pageId) {
       console.log("Executed successfully");
     }
   } catch (err) {
-    logger.error("exec-error", {
+    logger.error(`${mode}-error`, {
       error: err,
       session,
       codePreview: cleanedCode.slice(0, 200)
@@ -445,13 +457,15 @@ async function runIntegrationFromFile(args, logger) {
   );
   const payload = JSON.stringify({
     integrationPath: args.integrationPath,
-    workflowName: args.workflowName,
     session: args.session,
     params: args.params,
     headless: args.headless,
     visualize: args.visualize,
     authProfileDomain: args.authProfileDomain,
-    viewport: args.viewport
+    viewport: args.viewport,
+    accessMode: args.accessMode,
+    cdpEndpoint: args.cdpEndpoint,
+    provider: args.provider
   });
   const worker = spawn(
     process.execPath,
@@ -526,6 +540,7 @@ const execInput = SimpleCLI.input({
 const execCommand = SimpleCLI.command({
   description: "Execute Playwright TypeScript code"
 }).input(execInput).use(withRequiredSession()).handle(async ({ input, ctx }) => {
+  assertSessionAllowsCommand(ctx.sessionState, "exec", ["write-access"]);
   const code = input.code;
   const codeFromArgsOrStdin = code === "-" ? readStdinSync() : code;
   if (codeFromArgsOrStdin === null) {
@@ -537,18 +552,48 @@ const execCommand = SimpleCLI.command({
     codeFromArgsOrStdin,
     ctx.session,
     ctx.logger,
-    input.visualize,
-    input.page
+    {
+      visualize: input.visualize,
+      pageId: input.page,
+      mode: "exec"
+    }
   );
 });
-const runUsage = `Usage: libretto run <integrationFile> <workflowName> [--params <json> | --params-file <path>] [--tsconfig <path>] [--headed|--headless] [--no-visualize] [--viewport WxH]`;
+const readonlyExecInput = SimpleCLI.input({
+  positionals: [
+    SimpleCLI.positional("code", z.string().optional(), {
+      help: "Read-only Playwright TypeScript code to execute"
+    })
+  ],
+  named: {
+    session: sessionOption(),
+    page: pageOption()
+  }
+}).refine(
+  (input) => input.code !== void 0,
+  `Usage: libretto readonly-exec <code|-> [--session <name>] [--page <id>]
+       echo '<code>' | libretto readonly-exec - [--session <name>] [--page <id>]`
+);
+const readonlyExecCommand = SimpleCLI.command({
+  description: "Execute read-only Playwright inspection code"
+}).input(readonlyExecInput).use(withRequiredSession()).handle(async ({ input, ctx }) => {
+  const code = input.code;
+  const codeFromArgsOrStdin = code === "-" ? readStdinSync() : code;
+  if (codeFromArgsOrStdin === null) {
+    throw new Error(
+      "Missing stdin input for `readonly-exec -`. Pipe inspection code into stdin."
+    );
+  }
+  await runExec(codeFromArgsOrStdin, ctx.session, ctx.logger, {
+    pageId: input.page,
+    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 runInput = SimpleCLI.input({
   positionals: [
     SimpleCLI.positional("integrationFile", z.string().optional(), {
       help: "Path to the integration file"
-    }),
-    SimpleCLI.positional("workflowName", z.string().optional(), {
-      help: "Workflow name to run (from workflow(name, handler))"
     })
   ],
   named: {
@@ -565,6 +610,14 @@ const runInput = SimpleCLI.input({
     }),
     headed: SimpleCLI.flag({ help: "Run in headed mode" }),
     headless: SimpleCLI.flag({ help: "Run in headless mode" }),
+    readOnly: SimpleCLI.flag({
+      name: "read-only",
+      help: "Create the session in read-only mode"
+    }),
+    writeAccess: SimpleCLI.flag({
+      name: "write-access",
+      help: "Create the session in write-access mode (overrides config default)"
+    }),
     noVisualize: SimpleCLI.flag({
       name: "no-visualize",
       help: "Disable ghost cursor + highlight visualization in headed mode"
@@ -575,10 +628,14 @@ const runInput = SimpleCLI.input({
     }),
     viewport: SimpleCLI.option(z.string().optional(), {
       help: "Viewport size as WIDTHxHEIGHT (e.g. 1920x1080)"
+    }),
+    provider: SimpleCLI.option(z.string().optional(), {
+      help: "Browser provider (local, kernel, browserbase)",
+      aliases: ["-p"]
     })
   }
 }).refine(
-  (input) => Boolean(input.integrationFile && input.workflowName),
+  (input) => Boolean(input.integrationFile),
   runUsage
 ).refine(
   (input) => !(input.params && input.paramsFile),
@@ -586,6 +643,9 @@ const runInput = SimpleCLI.input({
 ).refine(
   (input) => !(input.headed && input.headless),
   "Cannot pass both --headed and --headless."
+).refine(
+  (input) => !(input.readOnly && input.writeAccess),
+  "Cannot pass both --read-only and --write-access."
 );
 function resolveRunParams(rawInlineParams, paramsFile) {
   if (paramsFile) {
@@ -605,8 +665,9 @@ function resolveRunParams(rawInlineParams, paramsFile) {
   return {};
 }
 const runCommand = SimpleCLI.command({
-  description: "Run an exported Libretto workflow from a file"
+  description: "Run the default-exported Libretto workflow from a file"
 }).input(runInput).use(withAutoSession()).handle(async ({ input, ctx }) => {
+  warnIfInstalledSkillOutOfDate();
   await stopExistingFailedRunSession(ctx.session, ctx.logger);
   assertSessionAvailableForStart(ctx.session, ctx.logger);
   const params = resolveRunParams(input.params, input.paramsFile);
@@ -616,20 +677,52 @@ const runCommand = SimpleCLI.command({
     parseViewportArg(input.viewport),
     ctx.logger
   );
-  await runIntegrationFromFile(
-    {
-      integrationPath: input.integrationFile,
-      workflowName: input.workflowName,
-      session: ctx.session,
-      params,
-      tsconfigPath: input.tsconfig,
-      headless: headlessMode ?? false,
-      visualize,
-      authProfileDomain: input.authProfile,
-      viewport
-    },
-    ctx.logger
-  );
+  const providerName = resolveProviderName(input.provider);
+  let cdpEndpoint;
+  let providerInfo;
+  let provider;
+  if (providerName !== "local") {
+    provider = getCloudProviderApi(providerName);
+    console.log(
+      `Creating ${providerName} browser session (session: ${ctx.session})...`
+    );
+    const providerSession = await provider.createSession();
+    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 {
+        await provider.closeSession(providerInfo.sessionId);
+      } catch (cleanupErr) {
+        console.error(
+          `Failed to clean up ${providerInfo.name} session ${providerInfo.sessionId}:`,
+          cleanupErr instanceof Error ? cleanupErr.message : cleanupErr
+        );
+      }
+    }
+  }
 });
 const resumeInput = SimpleCLI.input({
   positionals: [],
@@ -644,6 +737,7 @@ const resumeCommand = SimpleCLI.command({
 });
 const executionCommands = {
   exec: execCommand,
+  "readonly-exec": readonlyExecCommand,
   run: runCommand,
   resume: resumeCommand
 };
@@ -651,6 +745,8 @@ export {
   execCommand,
   execInput,
   executionCommands,
+  readonlyExecCommand,
+  readonlyExecInput,
   resumeCommand,
   resumeInput,
   runCommand,