libretto 0.6.9 → 0.6.11

package/src/cli/commands/billing.ts

@@ -0,0 +1,133 @@
+/**
+ * Hosted-platform billing commands. Stripe is the source of truth
+ * for the plan catalog and is also where every tenant — including
+ * Free — has a live Subscription. The Stripe Customer Portal is the
+ * single management UI: it shows the user's current plan and lets
+ * them switch between any of the configured Subscription Update
+ * products (Free / Pro / Team).
+ *
+ *   libretto experimental billing portal   → Stripe Customer Portal
+ *   libretto experimental billing status   → plan + usage + period end
+ *
+ * `libretto init` is unchanged. New tenants start on Free automatically
+ * (with a real Stripe Customer + Free Subscription created at signup).
+ *
+ * Auth: requires a session cookie (or LIBRETTO_API_KEY).
+ */
+
+import { SimpleCLI } from "../framework/simple-cli.js";
+import {
+  NOT_AUTHENTICATED_MESSAGE,
+  orpcCall,
+  pickCredential,
+  resolveApiUrl,
+} from "../core/auth-fetch.js";
+import { readAuthState } from "../core/auth-storage.js";
+
+// Marketing-site URL — used for BAA requests and Enterprise contact.
+const CONTACT_URL = "https://libretto.sh";
+
+// ---------------------------------------------------------------------------
+// Types — mirrored from api/src/routes/billing/subscription.ts
+// ---------------------------------------------------------------------------
+
+type SubscriptionResponse = {
+  plan: string;
+  status: string;
+  currentPeriodEnd: string | null;
+  cancelAtPeriodEnd: boolean;
+  browserHoursUsedThisPeriod: number;
+  browserHoursLimit: number | null;
+};
+
+type OpenPlansPageResponse = {
+  url: string;
+};
+
+// ---------------------------------------------------------------------------
+// Shared helpers
+// ---------------------------------------------------------------------------
+
+async function requireAuth(): Promise<{ apiUrl: string; credential: ReturnType<typeof pickCredential> }> {
+  const stored = await readAuthState();
+  const apiUrl = resolveApiUrl(stored);
+  const credential = pickCredential(stored);
+  if (credential.source === "none") {
+    throw new Error(NOT_AUTHENTICATED_MESSAGE);
+  }
+  return { apiUrl, credential };
+}
+
+function formatLimit(limit: number | null): string {
+  return limit === null ? "∞" : String(limit);
+}
+
+// ---------------------------------------------------------------------------
+// portal: always opens the Stripe Customer Portal — every tenant has a
+// live Stripe Subscription (Free or paid) so the portal always has
+// something to show. It's where users see their current plan and switch
+// to another. We DON'T branch on plan / status here.
+// ---------------------------------------------------------------------------
+
+export const billingPortalCommand = SimpleCLI.command({
+  description: "Open the libretto plans page (current plan + switch options)",
+  experimental: true,
+})
+  .handle(async () => {
+    const { apiUrl, credential } = await requireAuth();
+    const { url } = await orpcCall<OpenPlansPageResponse>({
+      apiUrl,
+      path: "/v1/billing/openPlansPage",
+      credential,
+    });
+    console.log("Open this URL in your browser to choose or change your plan:");
+    console.log(`  ${url}`);
+    console.log();
+    console.log(
+      "(Shows all tiers with features, your current plan, and a Manage payment / invoices link.)",
+    );
+    console.log(
+      `For a BAA or Enterprise pricing, contact us at ${CONTACT_URL}.`,
+    );
+  });
+
+// ---------------------------------------------------------------------------
+// status
+// ---------------------------------------------------------------------------
+
+export const billingStatusCommand = SimpleCLI.command({
+  description: "Print the current plan, status, and browser-hour usage",
+  experimental: true,
+})
+  .handle(async () => {
+    const { apiUrl, credential } = await requireAuth();
+    const sub = await orpcCall<SubscriptionResponse>({
+      apiUrl,
+      path: "/v1/billing/subscription",
+      credential,
+    });
+
+    const used = sub.browserHoursUsedThisPeriod.toFixed(2);
+    const limit = formatLimit(sub.browserHoursLimit);
+
+    console.log(`Plan:    ${sub.plan} (${sub.status})`);
+    console.log(`Usage:   ${used} / ${limit} browser hours this period`);
+    if (sub.currentPeriodEnd) {
+      console.log(`Period:  ends ${sub.currentPeriodEnd.slice(0, 10)}`);
+    }
+    if (sub.cancelAtPeriodEnd) {
+      console.log("Note:    cancellation scheduled at period end.");
+    }
+  });
+
+// ---------------------------------------------------------------------------
+// Group export
+// ---------------------------------------------------------------------------
+
+export const billingCommands = SimpleCLI.group({
+  description: "Hosted-platform subscription + usage commands",
+  routes: {
+    portal: billingPortalCommand,
+    status: billingStatusCommand,
+  },
+});

package/src/cli/commands/browser.ts

@@ -80,6 +80,10 @@ export const openInput = SimpleCLI.input({
       name: "write-access",
       help: "Create the session in write-access mode (overrides config default)",
     }),
+    authProfile: SimpleCLI.option(z.string().optional(), {
+      name: "auth-profile",
+      help: "Override the domain used for auth profile lookup (e.g. use login.example.com's profile when opening app.example.com)",
+    }),
     viewport: SimpleCLI.option(z.string().optional(), {
       help: "Viewport size as WIDTHxHEIGHT (e.g. 1920x1080)",
     }),
@@ -91,7 +95,7 @@ export const openInput = SimpleCLI.input({
 })
   .refine(
     (input) => Boolean(input.url),
-    `Usage: libretto open <url> [--headless] [--read-only|--write-access] [--viewport WxH] [--session <name>]`,
+    `Usage: libretto open <url> [--headless] [--read-only|--write-access] [--auth-profile <domain>] [--viewport WxH] [--session <name>]`,
   )
   .refine(
     (input) => !(input.headed && input.headless),
@@ -103,7 +107,8 @@ export const openInput = SimpleCLI.input({
   );
 
 export const openCommand = SimpleCLI.command({
-  description: "Launch browser and open URL (headed by default)",
+  description:
+    "Launch browser and open URL (headed by default). Automatically loads a saved auth profile for the URL's domain if one exists.",
 })
   .input(openInput)
   .use(withAutoSession())
@@ -120,6 +125,7 @@ export const openCommand = SimpleCLI.command({
           input.readOnly,
           input.writeAccess,
         ),
+        authProfileDomain: input.authProfile,
       });
     } else {
       const provider = getCloudProviderApi(providerName);

package/src/cli/commands/deploy.ts

@@ -1,5 +1,6 @@
 import { randomBytes } from "node:crypto";
 import { z } from "zod";
+import { HOSTED_API_URL } from "../core/auth-fetch.js";
 import { buildHostedDeployTarball } from "../core/deploy-artifact.js";
 import { SimpleCLI } from "../framework/simple-cli.js";
 
@@ -19,21 +20,15 @@ function generateDeploymentName(): string {
 }
 
 function getConfig() {
-  const apiUrl = process.env.LIBRETTO_API_URL;
   const apiKey = process.env.LIBRETTO_API_KEY;
 
-  if (!apiUrl) {
-    throw new Error(
-      "LIBRETTO_API_URL environment variable is required.",
-    );
-  }
   if (!apiKey) {
     throw new Error(
       "LIBRETTO_API_KEY environment variable is required.",
     );
   }
 
-  return { apiUrl: apiUrl.replace(/\/$/, ""), apiKey };
+  return { apiUrl: HOSTED_API_URL, apiKey };
 }
 
 async function postJson(

package/src/cli/commands/execution.ts

@@ -17,18 +17,24 @@ import {
   assertSessionAllowsCommand,
   clearSessionState,
   readSessionState,
+  readSessionStateOrThrow,
   setSessionStatus,
   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 {
+  compileExecFunction,
+  stripEmptyCatchHandlers,
+} from "../core/exec-compiler.js";
+import { DaemonClient } from "../core/daemon/index.js";
+import { createReadonlyExecHelpers } from "../core/readonly-exec.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 type { RunIntegrationWorkerRequest } from "../workers/run-integration-worker-protocol.js";
 import { SimpleCLI } from "../framework/simple-cli.js";
 import {
@@ -38,173 +44,85 @@ import {
   withRequiredSession,
 } from "./shared.js";
 
-type ExecFunction = (...args: unknown[]) => Promise<unknown>;
 type RunIntegrationCommandRequest = RunIntegrationWorkerRequest & {
   tsconfigPath?: string;
 };
 type ExecMode = "exec" | "readonly-exec";
 
-type StripTypeScriptTypesFn = (
-  code: string,
-  options?: { mode?: "strip" | "transform" },
-) => string;
-
-const stripTypeScriptTypes = (
-  moduleBuiltin as { stripTypeScriptTypes?: StripTypeScriptTypesFn }
-).stripTypeScriptTypes;
 const require = moduleBuiltin.createRequire(import.meta.url);
 const tsxCliPath = require.resolve("tsx/cli");
 
-function withSuppressedStripTypeScriptWarning<T>(action: () => T): T {
-  type EmitWarningFn = (...args: unknown[]) => void;
-  const mutableProcess = process as unknown as { emitWarning: EmitWarningFn };
-  const originalEmitWarning = mutableProcess.emitWarning;
-
-  mutableProcess.emitWarning = (...args: unknown[]) => {
-    const warning = args[0];
-    const typeOrOptions = args[1];
-    const warningMessage =
-      typeof warning === "string"
-        ? warning
-        : warning instanceof Error
-          ? warning.message
-          : "";
-    const warningType =
-      typeof typeOrOptions === "string"
-        ? typeOrOptions
-        : typeof typeOrOptions === "object" &&
-            typeOrOptions !== null &&
-            "type" in typeOrOptions &&
-            typeof (typeOrOptions as { type?: unknown }).type === "string"
-          ? ((typeOrOptions as { type?: string }).type ?? "")
-          : "";
-
-    if (
-      warningType === "ExperimentalWarning" &&
-      warningMessage.includes("stripTypeScriptTypes")
-    ) {
-      return;
-    }
-    originalEmitWarning(...args);
-  };
-
-  try {
-    return action();
-  } finally {
-    mutableProcess.emitWarning = originalEmitWarning;
+function writeDaemonExecOutput(output?: { stdout: string; stderr: string }) {
+  if (output?.stdout) {
+    process.stdout.write(output.stdout);
+  }
+  if (output?.stderr) {
+    process.stderr.write(output.stderr);
   }
 }
 
-function compileTypeScriptExecFunction(
+async function execViaDaemon(
   code: string,
-  helperNames: string[],
-): ExecFunction | null {
-  if (!stripTypeScriptTypes) return null;
+  session: string,
+  daemonSocketPath: string,
+  logger: LoggerApi,
+  options: {
+    visualize?: boolean;
+    pageId?: string;
+    mode?: ExecMode;
+  },
+): Promise<void> {
+  const mode = options.mode ?? "exec";
+  const { cleaned: cleanedCode, strippedCount } = stripEmptyCatchHandlers(code);
+  if (strippedCount > 0) {
+    console.log("(Stripped `.catch(() => {})` — letting errors bubble up)");
+  }
+  logger.info(`${mode}-start`, {
+    session,
+    codeLength: cleanedCode.length,
+    codePreview: cleanedCode.slice(0, 200),
+    visualize: options.visualize,
+    pageId: options.pageId,
+    via: "daemon",
+  });
 
-  const wrappedSource = `(async function __librettoExec(${helperNames.join(", ")}) {\n${code}\n})`;
-  const jsSource = withSuppressedStripTypeScriptWarning(() =>
-    stripTypeScriptTypes(wrappedSource, { mode: "strip" }),
-  );
-  const createFunction = new Function(
-    `return ${jsSource}`,
-  ) as () => ExecFunction;
-  return createFunction();
-}
+  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,
+        });
+
+  if (!response.ok) {
+    writeDaemonExecOutput(response.output);
+    throw new Error(response.message);
+  }
 
-function compileExecFunction(
-  code: string,
-  helperNames: string[],
-): ExecFunction {
-  const typeStripped = compileTypeScriptExecFunction(code, helperNames);
-  if (typeStripped) return typeStripped;
-
-  const AsyncFunction = Object.getPrototypeOf(async function () {})
-    .constructor as new (...args: string[]) => ExecFunction;
-  return new AsyncFunction(...helperNames, code);
-}
+  const { result, output } = response.data;
+  writeDaemonExecOutput(output);
 
-/**
- * Strip `.catch(() => {})` / `?.catch(() => {})` from executable code,
- * skipping occurrences inside string literals (single, double, backtick)
- * and single-line / multi-line comments so we never corrupt non-code text.
- */
-function stripEmptyCatchHandlers(code: string): {
-  cleaned: string;
-  strippedCount: number;
-} {
-  const catchRe = /\??\s*\.catch\(\s*\(\)\s*=>\s*\{\s*\}\s*\)/g;
-  let strippedCount = 0;
-  let result = "";
-  let i = 0;
-
-  while (i < code.length) {
-    // Single-line comment
-    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;
-    }
-    // Multi-line comment
-    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;
-    }
-    // String literals
-    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;
-        }
-        // Template literal interpolation — skip nested braces
-        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;
-    }
-    // Try to match the catch pattern at the current position
-    catchRe.lastIndex = i;
-    const match = catchRe.exec(code);
-    if (match && match.index === i) {
-      strippedCount++;
-      i += match[0].length;
-      continue;
-    }
-    // Regular character
-    result += code[i];
-    i++;
+  logger.info(`${mode}-success`, {
+    session,
+    hasResult: result !== undefined,
+    via: "daemon",
+  });
+  if (result !== undefined) {
+    console.log(
+      typeof result === "string" ? result : JSON.stringify(result, null, 2),
+    );
+  } else {
+    console.log("Executed successfully");
   }
-
-  return { cleaned: result, strippedCount };
 }
 
-async function runExec(
+async function execViaCdpFallback(
   code: string,
   session: string,
   logger: LoggerApi,
@@ -212,7 +130,7 @@ async function runExec(
     visualize?: boolean;
     pageId?: string;
     mode?: ExecMode;
-  } = {},
+  },
 ): Promise<void> {
   const visualize = options.visualize ?? false;
   const pageId = options.pageId;
@@ -227,7 +145,9 @@ async function runExec(
     codePreview: cleanedCode.slice(0, 200),
     visualize,
     pageId,
+    via: "cdp-fallback",
   });
+
   const {
     browser,
     context,
@@ -235,7 +155,6 @@ async function runExec(
     pageId: resolvedPageId,
   } = await connect(session, logger, 10000, {
     pageId,
-    requireSinglePage: true,
   });
 
   const STALL_THRESHOLD_MS = 60_000;
@@ -251,6 +170,7 @@ async function runExec(
         session,
         silenceMs,
         codePreview: cleanedCode.slice(0, 200),
+        via: "cdp-fallback",
       });
       console.warn(
         `[stall-warning] No Playwright activity for ${Math.round(silenceMs / 1000)}s — ${mode} may be hung (code: ${cleanedCode.slice(0, 100)}...)`,
@@ -264,6 +184,7 @@ async function runExec(
       session,
       duration: Date.now() - execStartTs,
       codePreview: cleanedCode.slice(0, 200),
+      via: "cdp-fallback",
     });
   };
   process.on("SIGINT", sigintHandler);
@@ -277,24 +198,24 @@ async function runExec(
   }
 
   try {
+    const execState: Record<string, unknown> = {};
     const helpers =
       mode === "readonly-exec"
         ? createReadonlyExecHelpers(page, { onActivity })
-        : (() => {
-            const execState: Record<string, unknown> = {};
-
-            const networkLog = (
+        : {
+            page,
+            context,
+            state: execState,
+            browser,
+            networkLog: (
               opts: {
                 last?: number;
                 filter?: string;
                 method?: string;
                 pageId?: string;
               } = {},
-            ) => {
-              return readNetworkLog(session, opts);
-            };
-
-            const actionLog = (
+            ) => readNetworkLog(session, opts),
+            actionLog: (
               opts: {
                 last?: number;
                 filter?: string;
@@ -302,33 +223,25 @@ async function runExec(
                 source?: string;
                 pageId?: string;
               } = {},
-            ) => {
-              return readActionLog(session, opts);
-            };
-
-            return {
-              page,
-              context,
-              state: execState,
-              browser,
-              networkLog,
-              actionLog,
-              console,
-              setTimeout,
-              setInterval,
-              clearTimeout,
-              clearInterval,
-              fetch,
-              URL,
-              Buffer,
-            };
-          })();
+            ) => readActionLog(session, opts),
+            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(`${mode}-success`, { session, hasResult: result !== undefined });
+    logger.info(`${mode}-success`, {
+      session,
+      hasResult: result !== undefined,
+      via: "cdp-fallback",
+    });
     if (result !== undefined) {
       console.log(
         typeof result === "string" ? result : JSON.stringify(result, null, 2),
@@ -341,6 +254,7 @@ async function runExec(
       error: err,
       session,
       codePreview: cleanedCode.slice(0, 200),
+      via: "cdp-fallback",
     });
     throw err;
   } finally {
@@ -350,6 +264,32 @@ async function runExec(
   }
 }
 
+async function runExec(
+  code: string,
+  session: string,
+  logger: LoggerApi,
+  options: {
+    visualize?: boolean;
+    pageId?: string;
+    mode?: ExecMode;
+  } = {},
+): 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
+    logger.warn(`${options.mode ?? "exec"}-daemon-socket-missing-cdp-fallback`, {
+      session,
+      hasCdpEndpoint: Boolean(state.cdpEndpoint),
+      port: state.port,
+    });
+    return execViaCdpFallback(code, session, logger, options);
+  }
+  return execViaDaemon(code, session, state.daemonSocketPath, logger, options);
+}
+
 function parseJsonArg(label: string, raw: string): unknown {
   try {
     return JSON.parse(raw);