libretto 0.6.31 → 0.6.33

package/dist/cli/commands/cloud-schedules.js

@@ -0,0 +1,128 @@
+import { readFileSync } from "node:fs";
+import { z } from "zod";
+import { SimpleCLI } from "affordance";
+import { orpcCall } from "../core/auth-fetch.js";
+import { withCloudApiKey } from "./shared.js";
+const createScheduleUsage = "Usage: libretto cloud schedules create <workflow> --cron <expr> [--params <json> | --params-file <path>]";
+function parseJsonObject(label, raw) {
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (error) {
+    throw new Error(
+      `Invalid JSON in ${label}: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new Error(`${label} must be a JSON object.`);
+  }
+  return parsed;
+}
+function readJsonObjectFile(label, filePath) {
+  let content;
+  try {
+    content = readFileSync(filePath, "utf8");
+  } catch {
+    throw new Error(
+      `Could not read ${label} "${filePath}". Ensure the file exists and is readable.`
+    );
+  }
+  return parseJsonObject(label, content);
+}
+const createCloudScheduleInput = SimpleCLI.input({
+  positionals: [
+    SimpleCLI.positional("workflow", z.string().optional(), {
+      help: "Deployed workflow name to schedule"
+    })
+  ],
+  named: {
+    cron: SimpleCLI.option(z.string().optional(), {
+      help: "Standard 5-field cron expression"
+    }),
+    timezone: SimpleCLI.option(z.string().optional(), {
+      help: "IANA timezone name (default: UTC)"
+    }),
+    params: SimpleCLI.option(z.string().optional(), {
+      help: "Inline JSON params object"
+    }),
+    paramsFile: SimpleCLI.option(z.string().optional(), {
+      name: "params-file",
+      help: "Path to a JSON params file"
+    }),
+    timeoutSeconds: SimpleCLI.option(z.coerce.number().int().min(1).optional(), {
+      name: "timeout-seconds",
+      help: "Job timeout in seconds for each schedule fire"
+    }),
+    callbackUrl: SimpleCLI.option(z.string().optional(), {
+      name: "callback-url",
+      help: "Per-schedule callback URL"
+    }),
+    callbackSecret: SimpleCLI.option(z.string().optional(), {
+      name: "callback-secret",
+      help: "Secret used to sign per-schedule callbacks"
+    }),
+    skipCallbacks: SimpleCLI.flag({
+      name: "skip-callbacks",
+      help: "Skip stored webhook callbacks for jobs created by this schedule"
+    }),
+    residentialProxy: SimpleCLI.option(z.string().optional(), {
+      name: "residential-proxy",
+      help: "Residential proxy config as a JSON object"
+    }),
+    disabled: SimpleCLI.flag({
+      help: "Create the schedule disabled"
+    })
+  }
+}).refine((input) => Boolean(input.workflow && input.cron), createScheduleUsage).refine(
+  (input) => !(input.params && input.paramsFile),
+  "Pass either --params or --params-file, not both."
+).refine(
+  (input) => !input.callbackUrl && !input.callbackSecret || Boolean(input.callbackUrl && input.callbackSecret),
+  "Pass both --callback-url and --callback-secret, or omit both."
+);
+const createCloudScheduleCommand = SimpleCLI.command({
+  description: "Create a recurring schedule for a deployed workflow"
+}).input(createCloudScheduleInput).use(withCloudApiKey("create Libretto Cloud schedules")).handle(async ({ input, ctx }) => {
+  const params = input.paramsFile ? readJsonObjectFile("--params-file", input.paramsFile) : input.params ? parseJsonObject("--params", input.params) : {};
+  const residentialProxy = input.residentialProxy ? parseJsonObject("--residential-proxy", input.residentialProxy) : void 0;
+  const payload = {
+    workflow: input.workflow,
+    cron_expr: input.cron,
+    timezone: input.timezone ?? "UTC",
+    params,
+    enabled: !input.disabled
+  };
+  if (input.timeoutSeconds !== void 0) {
+    payload.timeout_seconds = input.timeoutSeconds;
+  }
+  if (input.callbackUrl) payload.callback_url = input.callbackUrl;
+  if (input.callbackSecret) payload.callback_secret = input.callbackSecret;
+  if (input.skipCallbacks) payload.skip_callbacks = true;
+  if (residentialProxy !== void 0) {
+    payload.residential_proxy = residentialProxy;
+  }
+  const response = await orpcCall({
+    apiUrl: ctx.apiUrl,
+    path: "/v1/schedules/create",
+    input: payload,
+    credential: ctx.credential
+  });
+  const { schedule } = response;
+  console.log(`Schedule created: ${schedule.id}`);
+  console.log(`Workflow: ${schedule.workflow}`);
+  console.log(`Cron: ${schedule.cron_expr} (${schedule.timezone})`);
+  console.log(`Next fire: ${schedule.next_fire_at}`);
+  console.log(`Enabled: ${schedule.enabled ? "yes" : "no"}`);
+  return schedule.id;
+});
+const cloudScheduleCommands = SimpleCLI.group({
+  description: "Create and manage hosted schedules",
+  routes: {
+    create: createCloudScheduleCommand
+  }
+});
+export {
+  cloudScheduleCommands,
+  createCloudScheduleCommand,
+  createCloudScheduleInput
+};

package/dist/cli/commands/cloud-settings.js

@@ -0,0 +1,75 @@
+import { z } from "zod";
+import { SimpleCLI } from "affordance";
+import { orpcCall } from "../core/auth-fetch.js";
+import { withCloudApiKey } from "./shared.js";
+const settingState = z.enum(["enabled", "disabled"]);
+function toBoolean(state) {
+  return state === "enabled";
+}
+function printTenantSettings(settings) {
+  const notificationsEnabled = !settings.disable_job_failure_notifications;
+  console.log(
+    `Code sharing: ${settings.code_sharing_enabled ? "enabled" : "disabled"}`
+  );
+  console.log(
+    `Job failure notifications: ${notificationsEnabled ? "enabled" : "disabled"}`
+  );
+  console.log(
+    `Notification recipient: ${settings.debug_notification_email ?? "not configured"}`
+  );
+  return settings;
+}
+async function tenantSettings(ctx, input = {}) {
+  return orpcCall({
+    apiUrl: ctx.apiUrl,
+    path: "/v1/tenant/settings",
+    input,
+    credential: ctx.credential
+  });
+}
+const settingsStatusCommand = SimpleCLI.command({
+  description: "Show Libretto Cloud tenant settings"
+}).input(SimpleCLI.input({ positionals: [], named: {} })).use(withCloudApiKey("manage Libretto Cloud settings")).handle(async ({ ctx }) => printTenantSettings(await tenantSettings(ctx)));
+const setSettingsCommand = SimpleCLI.command({
+  description: "Update one or more Libretto Cloud tenant settings"
+}).input(
+  SimpleCLI.input({
+    positionals: [],
+    named: {
+      codeSharing: SimpleCLI.option(settingState.optional(), {
+        help: "Set tenant code sharing: enabled or disabled"
+      }),
+      jobFailureNotifications: SimpleCLI.option(settingState.optional(), {
+        help: "Set hosted job failure notification emails: enabled or disabled"
+      })
+    }
+  })
+).use(withCloudApiKey("manage Libretto Cloud settings")).handle(async ({ input, ctx }) => {
+  const updates = {};
+  if (input.codeSharing !== void 0) {
+    updates.code_sharing_enabled = toBoolean(input.codeSharing);
+  }
+  if (input.jobFailureNotifications !== void 0) {
+    updates.disable_job_failure_notifications = !toBoolean(
+      input.jobFailureNotifications
+    );
+  }
+  if (Object.keys(updates).length === 0) {
+    throw new Error(
+      "No settings provided. Use one or more flags, for example `libretto cloud settings set --code-sharing enabled --job-failure-notifications disabled`."
+    );
+  }
+  return printTenantSettings(await tenantSettings(ctx, updates));
+});
+const settingsCommands = SimpleCLI.group({
+  description: "Manage Libretto Cloud tenant settings",
+  routes: {
+    status: settingsStatusCommand,
+    set: setSettingsCommand
+  }
+});
+export {
+  setSettingsCommand,
+  settingsCommands,
+  settingsStatusCommand
+};

package/dist/cli/commands/cloud-sharing.js

@@ -1,18 +1,7 @@
 import { z } from "zod";
 import { SimpleCLI } from "affordance";
-import { orpcCall, resolveApiUrl } from "../core/auth-fetch.js";
-function requireCloudApiKey() {
-  const apiKey = process.env.LIBRETTO_API_KEY?.trim();
-  if (!apiKey) {
-    throw new Error(
-      "LIBRETTO_API_KEY is required to share Libretto Cloud workflow code. Issue one with `libretto cloud auth api-key issue --label <label>`."
-    );
-  }
-  return {
-    apiUrl: resolveApiUrl(null),
-    credential: { source: "env-api-key", apiKey }
-  };
-}
+import { orpcCall } from "../core/auth-fetch.js";
+import { withCloudApiKey } from "./shared.js";
 const shareWorkflowCommand = SimpleCLI.command({
   description: "Share one hosted workflow's code publicly"
 }).input(SimpleCLI.input({
@@ -26,13 +15,12 @@ const shareWorkflowCommand = SimpleCLI.command({
       help: "Refresh an existing share from the workflow's current deployment"
     })
   }
-})).handle(async ({ input }) => {
-  const { apiUrl, credential } = requireCloudApiKey();
+})).use(withCloudApiKey("share Libretto Cloud workflow code")).handle(async ({ input, ctx }) => {
   const response = await orpcCall({
-    apiUrl,
+    apiUrl: ctx.apiUrl,
     path: "/v1/workflows/share",
     input: { workflow: input.workflow, refresh: input.refresh },
-    credential
+    credential: ctx.credential
   });
   if (response.status === "existing") {
     console.log(`Workflow is already shared: ${response.workflow}`);
@@ -48,34 +36,32 @@ const shareWorkflowCommand = SimpleCLI.command({
 });
 const codeSharingStatusCommand = SimpleCLI.command({
   description: "Show whether tenant code sharing is enabled"
-}).input(SimpleCLI.input({ positionals: [], named: {} })).handle(async () => {
-  const { apiUrl, credential } = requireCloudApiKey();
+}).input(SimpleCLI.input({ positionals: [], named: {} })).use(withCloudApiKey("manage tenant workflow code sharing")).handle(async ({ ctx }) => {
   const response = await orpcCall({
-    apiUrl,
+    apiUrl: ctx.apiUrl,
     path: "/v1/tenant/codeSharing",
     input: {},
-    credential
+    credential: ctx.credential
   });
   console.log(`Code sharing: ${response.enabled ? "enabled" : "disabled"}`);
   return response.enabled;
 });
-async function updateCodeSharing(enabled) {
-  const { apiUrl, credential } = requireCloudApiKey();
+async function updateCodeSharing(enabled, ctx) {
   const response = await orpcCall({
-    apiUrl,
+    apiUrl: ctx.apiUrl,
     path: "/v1/tenant/updateCodeSharing",
     input: { enabled },
-    credential
+    credential: ctx.credential
   });
   console.log(`Code sharing: ${response.enabled ? "enabled" : "disabled"}`);
   return response.enabled;
 }
 const enableCodeSharingCommand = SimpleCLI.command({
   description: "Enable public workflow code sharing for this tenant"
-}).input(SimpleCLI.input({ positionals: [], named: {} })).handle(async () => updateCodeSharing(true));
+}).input(SimpleCLI.input({ positionals: [], named: {} })).use(withCloudApiKey("manage tenant workflow code sharing")).handle(async ({ ctx }) => updateCodeSharing(true, ctx));
 const disableCodeSharingCommand = SimpleCLI.command({
   description: "Disable public workflow code sharing for this tenant"
-}).input(SimpleCLI.input({ positionals: [], named: {} })).handle(async () => updateCodeSharing(false));
+}).input(SimpleCLI.input({ positionals: [], named: {} })).use(withCloudApiKey("manage tenant workflow code sharing")).handle(async ({ ctx }) => updateCodeSharing(false, ctx));
 const codeSharingCommands = SimpleCLI.group({
   description: "Manage tenant workflow code sharing",
   routes: {

package/dist/cli/commands/deploy.js

@@ -1,14 +1,12 @@
 import { randomBytes } from "node:crypto";
 import { z } from "zod";
-import {
-  orpcCall,
-  resolveApiUrl
-} from "../core/auth-fetch.js";
+import { orpcCall } from "../core/auth-fetch.js";
 import {
   buildHostedDeployTarball
 } from "../core/deploy-artifact.js";
 import { readAuthState } from "../core/auth-storage.js";
 import { SimpleCLI } from "affordance";
+import { withCloudApiKey } from "./shared.js";
 function generateDeploymentName() {
   return `deploy-${Date.now().toString(36)}-${randomBytes(4).toString("hex")}`;
 }
@@ -30,16 +28,6 @@ function deployApiKeyRequiredMessage(hasStoredSession) {
     "  \u2022 Add it to your project .env file: `LIBRETTO_API_KEY=<issued-key>`."
   ].join("\n");
 }
-async function requireDeployApiKey() {
-  const apiKey = process.env.LIBRETTO_API_KEY?.trim();
-  if (!apiKey) {
-    throw new Error(deployApiKeyRequiredMessage(await hasStoredCloudSession()));
-  }
-  return {
-    apiUrl: resolveApiUrl(null),
-    credential: { source: "env-api-key", apiKey }
-  };
-}
 async function hasStoredCloudSession() {
   try {
     return Boolean((await readAuthState())?.session);
@@ -130,8 +118,11 @@ const deployInput = SimpleCLI.input({
 });
 const deployCommand = SimpleCLI.command({
   description: "Deploy workflows to the hosted platform"
-}).input(deployInput).handle(async ({ input }) => {
-  const { apiUrl, credential } = await requireDeployApiKey();
+}).input(deployInput).use(withCloudApiKey(
+  "deploy to Libretto Cloud",
+  async () => deployApiKeyRequiredMessage(await hasStoredCloudSession())
+)).handle(async ({ input, ctx }) => {
+  const { apiUrl, credential } = ctx;
   const deploymentName = generateDeploymentName();
   console.log("Bundling hosted deployment artifact...");
   const { entryPoint, source, workflows } = await buildHostedDeployTarball({

package/dist/cli/commands/execution.js

@@ -58,7 +58,8 @@ function createRunBrowserConfig(args) {
   if (args.providerName) {
     return {
       kind: "provider",
-      providerName: args.providerName
+      providerName: args.providerName,
+      headless: args.headless
     };
   }
   return {
@@ -700,7 +701,7 @@ const runCommand = SimpleCLI.command({
     });
     console.log(`Connecting to ${providerName} browser...`);
   }
-  const headless = daemonProviderName ? true : headlessMode ?? false;
+  const headless = headlessMode ?? false;
   const windowPosition = headless ? void 0 : resolveWindowPosition(ctx.logger);
   await runIntegrationFromFile(
     {

package/dist/cli/commands/profiles.js

@@ -1,28 +1,16 @@
 import { z } from "zod";
 import { SimpleCLI } from "affordance";
-import { orpcCall, resolveApiUrl } from "../core/auth-fetch.js";
+import { orpcCall } from "../core/auth-fetch.js";
 import { normalizeProfileName } from "../core/profiles.js";
-function requireApiKeyCredential() {
-  const apiKey = process.env.LIBRETTO_API_KEY?.trim();
-  if (!apiKey) {
-    throw new Error(
-      "LIBRETTO_API_KEY is required to manage Libretto Cloud profiles. Issue one with `libretto cloud auth api-key issue --label <label>`."
-    );
-  }
-  return {
-    apiUrl: resolveApiUrl(null),
-    credential: { source: "env-api-key", apiKey }
-  };
-}
+import { withCloudApiKey } from "./shared.js";
 const listProfilesCommand = SimpleCLI.command({
   description: "List Libretto Cloud auth profiles"
-}).input(SimpleCLI.input({ positionals: [], named: {} })).handle(async () => {
-  const { apiUrl, credential } = requireApiKeyCredential();
+}).input(SimpleCLI.input({ positionals: [], named: {} })).use(withCloudApiKey("manage Libretto Cloud profiles")).handle(async ({ ctx }) => {
   const response = await orpcCall({
-    apiUrl,
+    apiUrl: ctx.apiUrl,
     path: "/v1/browserProfiles/list",
     input: {},
-    credential
+    credential: ctx.credential
   });
   if (response.profiles.length === 0) {
     console.log("No cloud profiles found.");
@@ -42,14 +30,13 @@ const deleteProfileCommand = SimpleCLI.command({
     })
   ],
   named: {}
-})).handle(async ({ input }) => {
+})).use(withCloudApiKey("manage Libretto Cloud profiles")).handle(async ({ input, ctx }) => {
   const profileName = normalizeProfileName(input.profileName);
-  const { apiUrl, credential } = requireApiKeyCredential();
   const response = await orpcCall({
-    apiUrl,
+    apiUrl: ctx.apiUrl,
     path: "/v1/browserProfiles/delete",
     input: { name: profileName },
-    credential
+    credential: ctx.credential
   });
   if (!response.success || response.deleted_count === 0) {
     console.log(`No cloud profile found for ${profileName}.`);

package/dist/cli/commands/shared.js

@@ -6,6 +6,7 @@ import {
   readSessionStateOrThrow,
   validateSessionName
 } from "../core/session.js";
+import { resolveApiUrl } from "../core/auth-fetch.js";
 import {
   SimpleCLI
 } from "affordance";
@@ -24,6 +25,21 @@ function withExperiments() {
     experiments: resolveExperiments()
   });
 }
+function withCloudApiKey(action, formatMissingMessage) {
+  return async ({ ctx }) => {
+    const apiKey = process.env.LIBRETTO_API_KEY?.trim();
+    if (!apiKey) {
+      throw new Error(
+        formatMissingMessage ? await formatMissingMessage() : `LIBRETTO_API_KEY is required to ${action}. Issue one with \`libretto cloud auth api-key issue --label <label>\`.`
+      );
+    }
+    return {
+      ...ctx,
+      apiUrl: resolveApiUrl(null),
+      credential: { source: "env-api-key", apiKey }
+    };
+  };
+}
 function withRequiredSession() {
   return async ({ input, ctx }) => {
     if (!input.session) {
@@ -54,6 +70,7 @@ export {
   pageOption,
   sessionOption,
   withAutoSession,
+  withCloudApiKey,
   withExperiments,
   withRequiredSession
 };

package/dist/cli/core/browser.js

@@ -387,7 +387,7 @@ async function runOpen(rawUrl, headed, session, logger, options) {
   });
   console.log(`Browser open (${browserMode}): ${url}`);
 }
-async function runOpenWithProvider(rawUrl, providerName, session, logger, accessMode, experiments) {
+async function runOpenWithProvider(rawUrl, providerName, headless, session, logger, accessMode, experiments) {
   const parsedUrl = normalizeUrl(rawUrl);
   const url = parsedUrl.href;
   logger.info("open-provider-start", { url, provider: providerName, session });
@@ -408,6 +408,7 @@ async function runOpenWithProvider(rawUrl, providerName, session, logger, access
       browser: {
         kind: "provider",
         providerName,
+        headless,
         initialUrl: url
       }
     },

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

@@ -324,7 +324,8 @@ class BrowserDaemon {
     try {
       providerSession = await provider.createSession({
         authProfileName: config.authProfileName,
-        authProfilePersist: config.authProfilePersist
+        authProfilePersist: config.authProfilePersist,
+        headless: config.headless
       });
       const browser = await chromium.connectOverCDP(
         providerSession.cdpEndpoint

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

@@ -1,7 +1,7 @@
 import { createHash } from "node:crypto";
 import { spawn } from "node:child_process";
 import { openSync, closeSync } from "node:fs";
-import { createRequire } from "node:module";
+import * as moduleBuiltin from "node:module";
 import { homedir, userInfo } from "node:os";
 import { fileURLToPath } from "node:url";
 import { createIpcPeer } from "../../../shared/ipc/ipc.js";
@@ -72,22 +72,29 @@ class DaemonClient {
     const daemonEntryPath = fileURLToPath(
       new URL("./daemon.js", import.meta.url)
     );
-    const require2 = createRequire(import.meta.url);
-    const tsxCliPath = require2.resolve("tsx/cli");
-    const childStderrFd = openSync(logPath, "a");
-    const child = spawn(
-      process.execPath,
-      [
-        tsxCliPath,
-        ...config.workflow?.tsconfigPath ? ["--tsconfig", config.workflow.tsconfigPath] : [],
-        daemonEntryPath,
-        JSON.stringify(config)
-      ],
-      {
-        detached: true,
-        stdio: ["ignore", "ignore", childStderrFd, "ipc"]
+    const childArgs = [daemonEntryPath, JSON.stringify(config)];
+    const childEnv = { ...process.env };
+    if (config.workflow) {
+      const tsxPreflightPath = fileURLToPath(
+        import.meta.resolve("tsx/preflight")
+      );
+      const tsxLoaderFlag = typeof moduleBuiltin.register === "function" ? "--import" : "--loader";
+      childArgs.unshift(
+        "--require",
+        tsxPreflightPath,
+        tsxLoaderFlag,
+        import.meta.resolve("tsx")
+      );
+      if (config.workflow.tsconfigPath) {
+        childEnv.TSX_TSCONFIG_PATH = config.workflow.tsconfigPath;
       }
-    );
+    }
+    const childStderrFd = openSync(logPath, "a");
+    const child = spawn(process.execPath, childArgs, {
+      detached: true,
+      stdio: ["ignore", "ignore", childStderrFd, "ipc"],
+      env: childEnv
+    });
     closeSync(childStderrFd);
     const pid = child.pid;
     logger.info("daemon-spawned", { pid, session });

package/dist/cli/core/deploy-artifact.js

@@ -21,6 +21,9 @@ import {
   LIBRETTO_WORKFLOW_BRAND
 } from "../../shared/workflow/workflow.js";
 import { normalizeCredentialNames } from "../../shared/workflow/credentials.js";
+import {
+  ViewportConfigSchema
+} from "./config.js";
 const DEFAULT_RUNTIME_EXTERNALS = [
   "playwright",
   "playwright-core",
@@ -581,7 +584,8 @@ function createDiscoveryLibrettoModule(workflowsByName) {
       workflowsByName.set(name, {
         name,
         ...extractDiscoveryCredentialMetadata(definitionOrHandler),
-        ...extractDiscoveryAuthProfileMetadata(definitionOrHandler)
+        ...extractDiscoveryAuthProfileMetadata(definitionOrHandler),
+        ...extractDiscoveryLaunchMetadata(definitionOrHandler)
       });
       return {
         [LIBRETTO_WORKFLOW_BRAND]: true,
@@ -604,6 +608,26 @@ function createDiscoveryLibrettoModule(workflowsByName) {
     }
   });
 }
+function extractDiscoveryLaunchMetadata(definitionOrHandler) {
+  if (!definitionOrHandler || typeof definitionOrHandler !== "object") {
+    return {};
+  }
+  const record = definitionOrHandler;
+  const metadata = {};
+  if (typeof record.startUrl === "string") {
+    metadata.startUrl = record.startUrl;
+  }
+  if (typeof record.gpu === "boolean") {
+    metadata.gpu = record.gpu;
+  }
+  if (record.viewport && typeof record.viewport === "object" && !Array.isArray(record.viewport)) {
+    const viewport = ViewportConfigSchema.safeParse(record.viewport);
+    if (viewport.success) {
+      metadata.viewport = viewport.data;
+    }
+  }
+  return metadata;
+}
 function extractDiscoveryCredentialMetadata(definitionOrHandler) {
   if (!definitionOrHandler || typeof definitionOrHandler !== "object" || !("credentials" in definitionOrHandler)) {
     return { credentialNames: [] };
@@ -692,7 +716,10 @@ function createBootstrapSource(args) {
     (workflow, index) => `export const ${getGeneratedWorkflowExportName(index)} = createWorkflowProxy(${JSON.stringify(workflow.name)}, ${JSON.stringify({
       credentialNames: workflow.credentialNames,
       authProfileName: workflow.authProfileName,
-      authProfileRefresh: workflow.authProfileRefresh
+      authProfileRefresh: workflow.authProfileRefresh,
+      startUrl: workflow.startUrl,
+      gpu: workflow.gpu,
+      viewport: workflow.viewport
     })});`
   ).join("\n");
   return `import { createRequire, Module } from "node:module";
@@ -774,23 +801,21 @@ function createWorkflowProxy(workflowName, metadata) {
     return await target.run(ctx, input);
   };
 
-  if (!metadata?.authProfileName) {
-    return workflow(workflowName, {
-      credentials: Array.isArray(metadata?.credentialNames)
-        ? metadata.credentialNames
-        : [],
-      handler,
-    });
-  }
-
   return workflow(workflowName, {
-    credentials: Array.isArray(metadata.credentialNames)
+    credentials: Array.isArray(metadata?.credentialNames)
       ? metadata.credentialNames
       : [],
-    authProfile: {
-      name: metadata.authProfileName,
-      ...(typeof metadata.authProfileRefresh === "boolean" ? { refresh: metadata.authProfileRefresh } : {}),
-    },
+    ...(metadata?.authProfileName
+      ? {
+          authProfile: {
+            name: metadata.authProfileName,
+            ...(typeof metadata.authProfileRefresh === "boolean" ? { refresh: metadata.authProfileRefresh } : {}),
+          },
+        }
+      : {}),
+    ...(typeof metadata?.startUrl === "string" ? { startUrl: metadata.startUrl } : {}),
+    ...(typeof metadata?.gpu === "boolean" ? { gpu: metadata.gpu } : {}),
+    ...(metadata?.viewport ? { viewport: metadata.viewport } : {}),
     handler,
   });
 }

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

@@ -49,7 +49,8 @@ function createKernelProvider(options = {}) {
   const enableRecording = options.enableRecording ?? readBooleanEnv("KERNEL_ENABLE_RECORDING", false);
   const replays = /* @__PURE__ */ new Map();
   return {
-    async createSession() {
+    async createSession(sessionOptions) {
+      const sessionHeadless = sessionOptions?.headless ?? headless;
       const json = await kernelFetchJson(
         endpoint,
         apiKey,
@@ -57,7 +58,7 @@ function createKernelProvider(options = {}) {
         {
           method: "POST",
           body: JSON.stringify({
-            headless,
+            headless: sessionHeadless,
             stealth,
             timeout_seconds: timeoutSeconds
           })

package/dist/cli/core/providers/libretto-cloud.js

@@ -25,7 +25,8 @@ function createLibrettoCloudProvider() {
           json: {
             timeout_seconds: browserSessionTimeoutSeconds,
             profile_name: options?.authProfileName,
-            profile_persist: options?.authProfilePersist
+            profile_persist: options?.authProfilePersist,
+            headless: options?.headless
           }
         })
       });