libretto 0.5.3-experimental.5 → 0.5.3

package/dist/cli/commands/execution.js

@@ -6,8 +6,10 @@ import { z } from "zod";
 import { installInstrumentation } from "../../shared/instrumentation/index.js";
 import {
   connect,
-  disconnectBrowser
+  disconnectBrowser,
+  resolveViewport
 } from "../core/browser.js";
+import { parseViewportArg } from "./browser.js";
 import { getPauseSignalPaths } from "../core/pause-signals.js";
 import {
   assertSessionAvailableForStart,
@@ -22,10 +24,10 @@ import {
 } from "../core/telemetry.js";
 import { SimpleCLI } from "../framework/simple-cli.js";
 import {
-  loadSessionStateMiddleware,
   pageOption,
-  resolveSessionMiddleware,
-  sessionOption
+  sessionOption,
+  withAutoSession,
+  withRequiredSession
 } from "./shared.js";
 const stripTypeScriptTypes = moduleBuiltin.stripTypeScriptTypes;
 const require2 = moduleBuiltin.createRequire(import.meta.url);
@@ -69,23 +71,91 @@ function compileExecFunction(code, helperNames) {
   }).constructor;
   return new AsyncFunction(...helperNames, code);
 }
+function stripEmptyCatchHandlers(code) {
+  const catchRe = /\??\s*\.catch\(\s*\(\)\s*=>\s*\{\s*\}\s*\)/g;
+  let strippedCount = 0;
+  let result = "";
+  let i = 0;
+  while (i < code.length) {
+    if (code[i] === "/" && code[i + 1] === "/") {
+      const end = code.indexOf("\n", i);
+      const slice = end === -1 ? code.slice(i) : code.slice(i, end + 1);
+      result += slice;
+      i += slice.length;
+      continue;
+    }
+    if (code[i] === "/" && code[i + 1] === "*") {
+      const end = code.indexOf("*/", i + 2);
+      const slice = end === -1 ? code.slice(i) : code.slice(i, end + 2);
+      result += slice;
+      i += slice.length;
+      continue;
+    }
+    if (code[i] === '"' || code[i] === "'" || code[i] === "`") {
+      const quote = code[i];
+      let j = i + 1;
+      while (j < code.length) {
+        if (code[j] === "\\" && quote !== "`") {
+          j += 2;
+          continue;
+        }
+        if (code[j] === "\\" && quote === "`") {
+          j += 2;
+          continue;
+        }
+        if (code[j] === quote) {
+          j++;
+          break;
+        }
+        if (quote === "`" && code[j] === "$" && code[j + 1] === "{") {
+          let depth = 1;
+          j += 2;
+          while (j < code.length && depth > 0) {
+            if (code[j] === "{") depth++;
+            else if (code[j] === "}") depth--;
+            j++;
+          }
+          continue;
+        }
+        j++;
+      }
+      result += code.slice(i, j);
+      i = j;
+      continue;
+    }
+    catchRe.lastIndex = i;
+    const match = catchRe.exec(code);
+    if (match && match.index === i) {
+      strippedCount++;
+      i += match[0].length;
+      continue;
+    }
+    result += code[i];
+    i++;
+  }
+  return { cleaned: result, strippedCount };
+}
 async function runExec(code, session, logger, visualize = false, pageId) {
+  const { cleaned: cleanedCode, strippedCount } = stripEmptyCatchHandlers(code);
+  if (strippedCount > 0) {
+    console.log("(Stripped `.catch(() => {})` \u2014 letting errors bubble up)");
+  }
   logger.info("exec-start", {
     session,
-    codeLength: code.length,
-    codePreview: code.slice(0, 200),
+    codeLength: cleanedCode.length,
+    codePreview: cleanedCode.slice(0, 200),
     visualize,
     pageId
   });
-  const { browser, context, page, pageId: resolvedPageId } = await connect(
-    session,
-    logger,
-    1e4,
-    {
-      pageId,
-      requireSinglePage: true
-    }
-  );
+  const {
+    browser,
+    context,
+    page,
+    pageId: resolvedPageId
+  } = await connect(session, logger, 1e4, {
+    pageId,
+    requireSinglePage: true
+  });
   const STALL_THRESHOLD_MS = 6e4;
   let lastActivityTs = Date.now();
   const onActivity = () => {
@@ -97,10 +167,10 @@ async function runExec(code, session, logger, visualize = false, pageId) {
       logger.warn("exec-stall-warning", {
         session,
         silenceMs,
-        codePreview: code.slice(0, 200)
+        codePreview: cleanedCode.slice(0, 200)
       });
       console.warn(
-        `[stall-warning] No Playwright activity for ${Math.round(silenceMs / 1e3)}s \u2014 exec may be hung (code: ${code.slice(0, 100)}...)`
+        `[stall-warning] No Playwright activity for ${Math.round(silenceMs / 1e3)}s \u2014 exec may be hung (code: ${cleanedCode.slice(0, 100)}...)`
       );
     }
   }, STALL_THRESHOLD_MS);
@@ -109,7 +179,7 @@ async function runExec(code, session, logger, visualize = false, pageId) {
     logger.info("exec-interrupted", {
       session,
       duration: Date.now() - execStartTs,
-      codePreview: code.slice(0, 200)
+      codePreview: cleanedCode.slice(0, 200)
     });
   };
   process.on("SIGINT", sigintHandler);
@@ -142,19 +212,21 @@ async function runExec(code, session, logger, visualize = false, pageId) {
       Buffer
     };
     const helperNames = Object.keys(helpers);
-    const fn = compileExecFunction(code, helperNames);
+    const fn = compileExecFunction(cleanedCode, helperNames);
     const result = await fn(...Object.values(helpers));
     logger.info("exec-success", { session, hasResult: result !== void 0 });
     if (result !== void 0) {
       console.log(
         typeof result === "string" ? result : JSON.stringify(result, null, 2)
       );
+    } else {
+      console.log("Executed successfully");
     }
   } catch (err) {
     logger.error("exec-error", {
       error: err,
       session,
-      codePreview: code.slice(0, 200)
+      codePreview: cleanedCode.slice(0, 200)
     });
     throw err;
   } finally {
@@ -191,6 +263,7 @@ async function stopExistingFailedRunSession(session, logger) {
     port: existingState.port
   });
   clearSessionState(session, logger);
+  if (existingState.pid == null) return;
   const stopDeadline = Date.now() + 3e3;
   while (isProcessRunning(existingState.pid) && Date.now() < stopDeadline) {
     await new Promise((resolveWait) => setTimeout(resolveWait, 100));
@@ -257,10 +330,18 @@ async function waitForWorkflowOutcome(args) {
   }
   let outputOffset = 0;
   while (true) {
-    outputOffset = streamOutputSince(signalPaths.outputSignalPath, outputOffset);
+    outputOffset = streamOutputSince(
+      signalPaths.outputSignalPath,
+      outputOffset
+    );
     if (existsSync(signalPaths.failedSignalPath)) {
-      outputOffset = streamOutputSince(signalPaths.outputSignalPath, outputOffset);
-      const failureDetails = await waitForFailureDetails(signalPaths.failedSignalPath);
+      outputOffset = streamOutputSince(
+        signalPaths.outputSignalPath,
+        outputOffset
+      );
+      const failureDetails = await waitForFailureDetails(
+        signalPaths.failedSignalPath
+      );
       return {
         status: "failed",
         message: failureDetails?.message,
@@ -268,15 +349,24 @@ async function waitForWorkflowOutcome(args) {
       };
     }
     if (existsSync(signalPaths.completedSignalPath)) {
-      outputOffset = streamOutputSince(signalPaths.outputSignalPath, outputOffset);
+      outputOffset = streamOutputSince(
+        signalPaths.outputSignalPath,
+        outputOffset
+      );
       return { status: "completed" };
     }
     if (existsSync(signalPaths.pausedSignalPath)) {
-      outputOffset = streamOutputSince(signalPaths.outputSignalPath, outputOffset);
+      outputOffset = streamOutputSince(
+        signalPaths.outputSignalPath,
+        outputOffset
+      );
       return { status: "paused" };
     }
     if (!isProcessRunning(args.pid)) {
-      outputOffset = streamOutputSince(signalPaths.outputSignalPath, outputOffset);
+      outputOffset = streamOutputSince(
+        signalPaths.outputSignalPath,
+        outputOffset
+      );
       return { status: "exited" };
     }
     await new Promise((resolveWait) => setTimeout(resolveWait, 250));
@@ -295,9 +385,9 @@ async function runResume(session, logger, sessionState) {
       `Session "${session}" is not paused. Run "libretto run ... --session ${session}" and call pause("${session}") first.`
     );
   }
-  if (!isProcessRunning(sessionState.pid)) {
+  if (sessionState.pid == null || !isProcessRunning(sessionState.pid)) {
     throw new Error(
-      `No active paused workflow found for session "${session}" (worker pid ${sessionState.pid} is not running).`
+      `No active paused workflow found for session "${session}" (worker pid ${sessionState.pid ?? "unknown"} is not running).`
     );
   }
   clearSignalIfExists(pausedSignalPath);
@@ -355,23 +445,28 @@ async function runIntegrationFromFile(args, logger) {
   );
   const payload = JSON.stringify({
     integrationPath: args.integrationPath,
-    exportName: args.exportName,
+    workflowName: args.workflowName,
     session: args.session,
     params: args.params,
     headless: args.headless,
     visualize: args.visualize,
-    authProfileDomain: args.authProfileDomain
-  });
-  const worker = spawn(process.execPath, [
-    tsxCliPath,
-    ...args.tsconfigPath ? ["--tsconfig", args.tsconfigPath] : [],
-    workerEntryPath,
-    payload
-  ], {
-    detached: true,
-    stdio: "ignore",
-    env: process.env
+    authProfileDomain: args.authProfileDomain,
+    viewport: args.viewport
   });
+  const worker = spawn(
+    process.execPath,
+    [
+      tsxCliPath,
+      ...args.tsconfigPath ? ["--tsconfig", args.tsconfigPath] : [],
+      workerEntryPath,
+      payload
+    ],
+    {
+      detached: true,
+      stdio: "ignore",
+      env: process.env
+    }
+  );
   worker.unref();
   const outcome = await waitForWorkflowOutcome({
     session: args.session,
@@ -401,43 +496,59 @@ Browser is still open. You can use \`exec\` to inspect it. Call \`run\` to re-ru
   setSessionStatus(args.session, "completed", logger);
   console.log("Integration completed.");
 }
+function readStdinSync() {
+  if (process.stdin.isTTY === true) return null;
+  try {
+    const content = readFileSync(0, "utf8");
+    return content.trim().length > 0 ? content : null;
+  } catch {
+    return null;
+  }
+}
 const execInput = SimpleCLI.input({
   positionals: [
-    SimpleCLI.positional("codeParts", z.array(z.string()).default([]), {
-      help: "Playwright TypeScript code to execute",
-      variadic: true
+    SimpleCLI.positional("code", z.string().optional(), {
+      help: "Playwright TypeScript code to execute"
     })
   ],
   named: {
     session: sessionOption(),
-    visualize: SimpleCLI.flag({ help: "Enable ghost cursor + highlight visualization" }),
+    visualize: SimpleCLI.flag({
+      help: "Enable ghost cursor + highlight visualization"
+    }),
     page: pageOption()
   }
 }).refine(
-  (input) => input.codeParts.length > 0,
-  `Usage: libretto exec <code> [--session <name>] [--visualize]`
+  (input) => input.code !== void 0,
+  `Usage: libretto exec <code|-> [--session <name>] [--visualize]
+       echo '<code>' | libretto exec - [--session <name>] [--visualize]`
 );
-function createExecCommand(logger) {
-  return SimpleCLI.command({
-    description: "Execute Playwright TypeScript code"
-  }).input(execInput).use(resolveSessionMiddleware).use(loadSessionStateMiddleware).handle(async ({ input, ctx }) => {
-    await runExec(
-      input.codeParts.join(" "),
-      ctx.session,
-      logger,
-      input.visualize,
-      input.page
+const execCommand = SimpleCLI.command({
+  description: "Execute Playwright TypeScript code"
+}).input(execInput).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 `exec -`. Pipe Playwright code into stdin."
     );
-  });
-}
-const runUsage = `Usage: libretto run <integrationFile> <integrationExport> [--params <json> | --params-file <path>] [--tsconfig <path>] [--headed|--headless] [--no-visualize]`;
+  }
+  await runExec(
+    codeFromArgsOrStdin,
+    ctx.session,
+    ctx.logger,
+    input.visualize,
+    input.page
+  );
+});
+const runUsage = `Usage: libretto run <integrationFile> <workflowName> [--params <json> | --params-file <path>] [--tsconfig <path>] [--headed|--headless] [--no-visualize] [--viewport WxH]`;
 const runInput = SimpleCLI.input({
   positionals: [
     SimpleCLI.positional("integrationFile", z.string().optional(), {
       help: "Path to the integration file"
     }),
-    SimpleCLI.positional("integrationExport", z.string().optional(), {
-      help: "Named workflow export to run"
+    SimpleCLI.positional("workflowName", z.string().optional(), {
+      help: "Workflow name to run (from workflow(name, handler))"
     })
   ],
   named: {
@@ -461,12 +572,21 @@ const runInput = SimpleCLI.input({
     authProfile: SimpleCLI.option(z.string().optional(), {
       name: "auth-profile",
       help: "Domain for local auth profile (e.g. apps.example.com)"
+    }),
+    viewport: SimpleCLI.option(z.string().optional(), {
+      help: "Viewport size as WIDTHxHEIGHT (e.g. 1920x1080)"
     })
   }
 }).refine(
-  (input) => Boolean(input.integrationFile && input.integrationExport),
+  (input) => Boolean(input.integrationFile && input.workflowName),
   runUsage
-).refine((input) => !(input.params && input.paramsFile), "Pass either --params or --params-file, not both.").refine((input) => !(input.headed && input.headless), "Cannot pass both --headed and --headless.");
+).refine(
+  (input) => !(input.params && input.paramsFile),
+  "Pass either --params or --params-file, not both."
+).refine(
+  (input) => !(input.headed && input.headless),
+  "Cannot pass both --headed and --headless."
+);
 function resolveRunParams(rawInlineParams, paramsFile) {
   if (paramsFile) {
     let content;
@@ -484,53 +604,55 @@ function resolveRunParams(rawInlineParams, paramsFile) {
   }
   return {};
 }
-function createRunCommand(logger) {
-  return SimpleCLI.command({
-    description: "Run an exported Libretto workflow from a file"
-  }).input(runInput).use(resolveSessionMiddleware).handle(async ({ input, ctx }) => {
-    await stopExistingFailedRunSession(ctx.session, logger);
-    assertSessionAvailableForStart(ctx.session, logger);
-    const params = resolveRunParams(input.params, input.paramsFile);
-    const headlessMode = input.headed ? false : input.headless ? true : void 0;
-    const visualize = !input.noVisualize;
-    await runIntegrationFromFile({
+const runCommand = SimpleCLI.command({
+  description: "Run an exported Libretto workflow from a file"
+}).input(runInput).use(withAutoSession()).handle(async ({ input, ctx }) => {
+  await stopExistingFailedRunSession(ctx.session, ctx.logger);
+  assertSessionAvailableForStart(ctx.session, ctx.logger);
+  const params = resolveRunParams(input.params, input.paramsFile);
+  const headlessMode = input.headed ? false : input.headless ? true : void 0;
+  const visualize = !input.noVisualize;
+  const viewport = resolveViewport(
+    parseViewportArg(input.viewport),
+    ctx.logger
+  );
+  await runIntegrationFromFile(
+    {
       integrationPath: input.integrationFile,
-      exportName: input.integrationExport,
+      workflowName: input.workflowName,
       session: ctx.session,
       params,
       tsconfigPath: input.tsconfig,
       headless: headlessMode ?? false,
       visualize,
-      authProfileDomain: input.authProfile
-    }, logger);
-  });
-}
+      authProfileDomain: input.authProfile,
+      viewport
+    },
+    ctx.logger
+  );
+});
 const resumeInput = SimpleCLI.input({
   positionals: [],
   named: {
     session: sessionOption()
   }
 });
-function createResumeCommand(logger) {
-  return SimpleCLI.command({
-    description: "Resume a paused workflow for the current session"
-  }).input(resumeInput).use(resolveSessionMiddleware).use(loadSessionStateMiddleware).handle(async ({ ctx }) => {
-    await runResume(ctx.session, logger, ctx.sessionState);
-  });
-}
-function createExecutionCommands(logger) {
-  return {
-    exec: createExecCommand(logger),
-    run: createRunCommand(logger),
-    resume: createResumeCommand(logger)
-  };
-}
+const resumeCommand = SimpleCLI.command({
+  description: "Resume a paused workflow for the current session"
+}).input(resumeInput).use(withRequiredSession()).handle(async ({ ctx }) => {
+  await runResume(ctx.session, ctx.logger, ctx.sessionState);
+});
+const executionCommands = {
+  exec: execCommand,
+  run: runCommand,
+  resume: resumeCommand
+};
 export {
-  createExecCommand,
-  createExecutionCommands,
-  createResumeCommand,
-  createRunCommand,
+  execCommand,
   execInput,
+  executionCommands,
+  resumeCommand,
   resumeInput,
+  runCommand,
   runInput
 };

package/dist/cli/commands/init.js

@@ -1,5 +1,13 @@
 import { createInterface } from "node:readline";
-import { appendFileSync, cpSync, existsSync, readdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import {
+  appendFileSync,
+  cpSync,
+  existsSync,
+  readdirSync,
+  readFileSync,
+  rmSync,
+  writeFileSync
+} from "node:fs";
 import { spawnSync } from "node:child_process";
 import { basename, dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
@@ -9,8 +17,8 @@ import {
   loadSnapshotEnv,
   resolveSnapshotApiModel
 } from "../core/snapshot-api-config.js";
-import { SimpleCLI } from "../framework/simple-cli.js";
 import { hasProviderCredentials } from "../../shared/llm/client.js";
+import { SimpleCLI } from "../framework/simple-cli.js";
 const PROVIDER_CHOICES = [
   {
     key: "1",
@@ -44,15 +52,6 @@ function promptUser(rl, question) {
     });
   });
 }
-function askYesNo(question) {
-  const rl = createInterface({ input: process.stdin, output: process.stdout });
-  return new Promise((resolve) => {
-    rl.question(`${question} (y/N) `, (answer) => {
-      rl.close();
-      resolve(answer.trim().toLowerCase() === "y");
-    });
-  });
-}
 function safeReadAiConfig() {
   try {
     return readAiConfig();
@@ -83,7 +82,9 @@ function printSnapshotApiStatus() {
   printInvalidAiConfigWarning();
   if (selection && hasProviderCredentials(selection.provider)) {
     console.log(`  \u2713 Ready: ${selection.model} (${selection.source})`);
-    console.log("    Snapshot objectives will use the API analyzer by default.");
+    console.log(
+      "    Snapshot objectives will use the API analyzer by default."
+    );
     console.log("    No further action required.");
     return;
   }
@@ -98,7 +99,9 @@ function printSnapshotApiStatus() {
   console.log(
     "    Or run `npx libretto ai configure openai | anthropic | gemini | vertex` to set a specific model."
   );
-  console.log("    Run `npx libretto init` interactively to set up credentials.");
+  console.log(
+    "    Run `npx libretto init` interactively to set up credentials."
+  );
 }
 async function runInteractiveApiSetup() {
   const config = safeReadAiConfig();
@@ -110,7 +113,9 @@ async function runInteractiveApiSetup() {
   printInvalidAiConfigWarning();
   if (selection && hasProviderCredentials(selection.provider)) {
     console.log(`  \u2713 Ready: ${selection.model} (${selection.source})`);
-    console.log("    Snapshot objectives will use the API analyzer by default.");
+    console.log(
+      "    Snapshot objectives will use the API analyzer by default."
+    );
     return;
   }
   console.log("  \u2717 No snapshot API credentials detected.\n");
@@ -119,14 +124,18 @@ async function runInteractiveApiSetup() {
     output: process.stdout
   });
   try {
-    console.log("  Which API provider would you like to use for snapshot analysis?\n");
+    console.log(
+      "  Which API provider would you like to use for snapshot analysis?\n"
+    );
     for (const choice of PROVIDER_CHOICES) {
       console.log(`    ${choice.key}) ${choice.label}`);
     }
     console.log("    s) Skip for now\n");
     const answer = await promptUser(rl, "  Choice: ");
     if (answer.toLowerCase() === "s" || !answer) {
-      console.log("\n  Skipped. You can set up API credentials later by rerunning `npx libretto init`.");
+      console.log(
+        "\n  Skipped. You can set up API credentials later by rerunning `npx libretto init`."
+      );
       console.log("  Or add credentials directly to your .env file:");
       console.log("    OPENAI_API_KEY=...");
       console.log("    ANTHROPIC_API_KEY=...");
@@ -215,22 +224,15 @@ function detectAgentDirs(root) {
   if (existsSync(join(root, ".claude"))) dirs.push(join(root, ".claude"));
   return dirs;
 }
-async function copySkills() {
+function copySkills() {
   const agentDirs = detectAgentDirs(REPO_ROOT);
   if (agentDirs.length === 0) {
-    console.log("\nSkills: No .agents/ or .claude/ directory found in repo root \u2014 skipping.");
+    console.log(
+      "\nSkills: No .agents/ or .claude/ directory found in repo root \u2014 skipping."
+    );
     return;
   }
   const destinations = agentDirs.map((d) => join(d, "skills", "libretto"));
-  const dirNames = agentDirs.map((d) => basename(d)).join(" and ");
-  const existing = destinations.filter((d) => existsSync(d));
-  const verb = existing.length > 0 ? "Overwrite" : "Install";
-  const proceed = await askYesNo(`
-${verb} libretto skills in ${dirNames}?`);
-  if (!proceed) {
-    console.log("  Skipping skill copy.");
-    return;
-  }
   let sourceDir;
   try {
     sourceDir = getPackageSkillsDir();
@@ -246,7 +248,9 @@ ${verb} libretto skills in ${dirNames}?`);
     }
     cpSync(sourceDir, skillDest, { recursive: true });
     const fileCount = readdirSync(skillDest).length;
-    console.log(`  \u2713 Copied ${fileCount} skill files to ${name}/skills/libretto/`);
+    console.log(
+      `  \u2713 Copied ${fileCount} skill files to ${name}/skills/libretto/`
+    );
   }
 }
 const initInput = SimpleCLI.input({
@@ -267,10 +271,11 @@ const initCommand = SimpleCLI.command({
   } else {
     console.log("\nSkipping browser installation (--skip-browsers)");
   }
+  copySkills();
   if (process.stdin.isTTY) {
-    await copySkills();
     await runInteractiveApiSetup();
   } else {
+    loadSnapshotEnv();
     printSnapshotApiStatus();
   }
   console.log("\n\u2713 libretto init complete");

package/dist/cli/commands/logs.js

@@ -12,10 +12,9 @@ import {
 import { SimpleCLI } from "../framework/simple-cli.js";
 import {
   integerOption,
-  loadSessionStateMiddleware,
   pageOption,
-  resolveSessionMiddleware,
-  sessionOption
+  sessionOption,
+  withRequiredSession
 } from "./shared.js";
 async function resolvePageId(session, pageId) {
   if (!pageId) return void 0;
@@ -44,7 +43,7 @@ const networkInput = SimpleCLI.input({
 });
 const networkCommand = SimpleCLI.command({
   description: "View captured network requests"
-}).input(networkInput).use(resolveSessionMiddleware).use(loadSessionStateMiddleware).handle(async ({ input, ctx }) => {
+}).input(networkInput).use(withRequiredSession()).handle(async ({ input, ctx }) => {
   if (input.clear) {
     clearNetworkLog(ctx.session);
     console.log("Network log cleared.");
@@ -81,7 +80,7 @@ const actionsInput = SimpleCLI.input({
 });
 const actionsCommand = SimpleCLI.command({
   description: "View captured actions"
-}).input(actionsInput).use(resolveSessionMiddleware).use(loadSessionStateMiddleware).handle(async ({ input, ctx }) => {
+}).input(actionsInput).use(withRequiredSession()).handle(async ({ input, ctx }) => {
   if (input.clear) {
     clearActionLog(ctx.session);
     console.log("Action log cleared.");