libretto 0.6.23 → 0.6.25

package/dist/cli/core/telemetry.js

@@ -1,325 +1,95 @@
-import {
-  appendFileSync,
-  existsSync,
-  readFileSync
-} from "node:fs";
-import {
-  getSessionActionsLogPath,
-  getSessionNetworkLogPath
-} from "./context.js";
-import { assertSessionStateExistsOrThrow } from "./session.js";
-function readNetworkLog(session, opts = {}) {
-  assertSessionStateExistsOrThrow(session);
-  const logPath = getSessionNetworkLogPath(session);
-  if (!existsSync(logPath)) return [];
-  const lines = readFileSync(logPath, "utf-8").trim().split("\n").filter(Boolean);
-  let entries = lines.map(
-    (line) => JSON.parse(line)
-  );
-  if (opts.method) {
-    const m = opts.method.toUpperCase();
-    entries = entries.filter((e) => e.method === m);
-  }
-  if (opts.filter) {
-    const re = new RegExp(opts.filter, "i");
-    entries = entries.filter((e) => re.test(e.url));
-  }
-  if (opts.pageId) {
-    entries = entries.filter((e) => e.pageId === opts.pageId);
-  }
-  const last = opts.last ?? 20;
-  if (entries.length > last) {
-    entries = entries.slice(-last);
-  }
-  return entries;
+import { randomUUID } from "node:crypto";
+import { promises as fs } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { resolveHostedApiUrl } from "./auth-fetch.js";
+const TELEMETRY_FILE_NAME = "telemetry.json";
+const TELEMETRY_ENDPOINT_PATH = "/v1/telemetry/recordCliEvent";
+const TELEMETRY_TIMEOUT_MS = 250;
+function telemetryDir() {
+  return join(homedir(), ".libretto");
+}
+function telemetryPath() {
+  return join(telemetryDir(), TELEMETRY_FILE_NAME);
 }
-function parentLogAction(session, entry) {
+function isTelemetryDisabled() {
+  return process.env.LIBRETTO_TELEMETRY_DISABLED === "1" || process.env.DO_NOT_TRACK === "1" || process.env.CI === "1";
+}
+async function readTelemetryState() {
   try {
-    const record = { ts: (/* @__PURE__ */ new Date()).toISOString(), ...entry };
-    appendFileSync(
-      getSessionActionsLogPath(session),
-      JSON.stringify(record) + "\n"
-    );
-  } catch {
+    const raw = await fs.readFile(telemetryPath(), "utf8");
+    return JSON.parse(raw);
+  } catch (error) {
+    if (error.code !== "ENOENT") throw error;
+    return null;
   }
 }
-function readActionLog(session, opts = {}) {
-  assertSessionStateExistsOrThrow(session);
-  const logPath = getSessionActionsLogPath(session);
-  if (!existsSync(logPath)) return [];
-  const lines = readFileSync(logPath, "utf-8").trim().split("\n").filter(Boolean);
-  let entries = lines.map(
-    (line) => JSON.parse(line)
+async function readOrCreateInstallId() {
+  const state = await readTelemetryState();
+  if (state?.enabled === false) return null;
+  if (typeof state?.installId === "string" && state.installId.length > 0) {
+    return state.installId;
+  }
+  const installId = randomUUID();
+  writeTelemetryNotice();
+  await writeTelemetryState({ installId, enabled: true });
+  return installId;
+}
+function writeTelemetryNotice() {
+  if (!process.stderr.isTTY) return;
+  process.stderr.write(
+    [
+      "Libretto collects anonymous CLI telemetry: install id, timestamp, command event, and error status only.",
+      "Set LIBRETTO_TELEMETRY_DISABLED=1 or DO_NOT_TRACK=1 to disable it, or set enabled:false in ~/.libretto/telemetry.json."
+    ].join(" ") + "\n"
   );
-  if (opts.action) {
-    const a = opts.action.toLowerCase();
-    entries = entries.filter((e) => e.action === a);
-  }
-  if (opts.source) {
-    const s = opts.source.toLowerCase();
-    entries = entries.filter((e) => e.source === s);
-  }
-  if (opts.filter) {
-    const re = new RegExp(opts.filter, "i");
-    entries = entries.filter(
-      (e) => re.test(e.action) || re.test(e.selector || "") || re.test(e.bestSemanticSelector || "") || re.test(e.targetSelector || "") || re.test((e.ancestorSelectors || []).join(" ")) || re.test(e.nearbyText || "") || re.test((e.composedPath || []).join(" ")) || re.test(e.value || "") || re.test(e.url || "")
-    );
-  }
-  if (opts.pageId) {
-    entries = entries.filter((e) => e.pageId === opts.pageId);
-  }
-  const last = opts.last ?? 20;
-  if (entries.length > last) {
-    entries = entries.slice(-last);
-  }
-  return entries;
 }
-const LOCATOR_ACTION_METHODS = [
-  "click",
-  "dblclick",
-  "fill",
-  "type",
-  "press",
-  "check",
-  "uncheck",
-  "selectOption",
-  "hover",
-  "focus",
-  "scrollIntoViewIfNeeded",
-  "waitFor",
-  "innerHTML",
-  "innerText",
-  "textContent",
-  "inputValue",
-  "isChecked",
-  "isDisabled",
-  "isEditable",
-  "isEnabled",
-  "isHidden",
-  "isVisible",
-  "count",
-  "boundingBox",
-  "screenshot",
-  "evaluate",
-  "evaluateAll",
-  "evaluateHandle",
-  "getAttribute",
-  "dispatchEvent",
-  "setInputFiles",
-  "selectText",
-  "dragTo",
-  "highlight",
-  "tap"
-];
-const LOCATOR_RETURNING_METHODS = [
-  "first",
-  "last",
-  "locator",
-  "getByRole",
-  "getByText",
-  "getByLabel",
-  "getByPlaceholder",
-  "getByAltText",
-  "getByTitle",
-  "getByTestId",
-  "filter",
-  "and",
-  "or"
-];
-function formatHint(method, args) {
-  const formatted = args.map((a) => JSON.stringify(a)).join(", ");
-  return `${method}(${formatted})`;
+async function writeTelemetryState(state) {
+  await fs.mkdir(telemetryDir(), { recursive: true, mode: 448 });
+  const target = telemetryPath();
+  const tmp = `${target}.${process.pid}.${randomUUID()}.tmp`;
+  await fs.writeFile(tmp, JSON.stringify(state, null, 2), { mode: 384 });
+  await fs.rename(tmp, target);
 }
-function wrapLocator(locator, hint, session, page, pageId, onActivity) {
-  if (locator.__librettoActionLogged) return locator;
-  locator.__librettoActionLogged = true;
-  for (const actMethod of LOCATOR_ACTION_METHODS) {
-    if (typeof locator[actMethod] !== "function") continue;
-    const origAct = locator[actMethod].bind(locator);
-    locator[actMethod] = async (...actArgs) => {
-      const start = Date.now();
-      try {
-        await page.evaluate(() => {
-          window.__btApiActionInProgress = true;
-        });
-      } catch {
-      }
-      try {
-        const result = await origAct(...actArgs);
-        parentLogAction(session, {
-          pageId,
-          action: actMethod,
-          source: "agent",
-          selector: hint,
-          value: actArgs[0] !== void 0 ? String(actArgs[0]).slice(0, 100) : void 0,
-          duration: Date.now() - start,
-          success: true
-        });
-        onActivity?.();
-        return result;
-      } catch (err) {
-        parentLogAction(session, {
-          pageId,
-          action: actMethod,
-          source: "agent",
-          selector: hint,
-          duration: Date.now() - start,
-          success: false,
-          error: err.message
-        });
-        onActivity?.();
-        throw err;
-      } finally {
-        try {
-          await page.evaluate(() => {
-            window.__btApiActionInProgress = false;
-          });
-        } catch {
-        }
-      }
-    };
-  }
-  for (const method of LOCATOR_RETURNING_METHODS) {
-    if (typeof locator[method] !== "function") continue;
-    const origMethod = locator[method].bind(locator);
-    locator[method] = (...args) => {
-      const child = origMethod(...args);
-      const childHint = args.length > 0 ? `${hint}.${formatHint(method, args)}` : `${hint}.${method}()`;
-      return wrapLocator(child, childHint, session, page, pageId, onActivity);
-    };
-  }
-  if (typeof locator.nth === "function") {
-    const origNth = locator.nth.bind(locator);
-    locator.nth = (index) => {
-      const child = origNth(index);
-      const childHint = `${hint}.nth(${index})`;
-      return wrapLocator(child, childHint, session, page, pageId, onActivity);
-    };
-  }
-  if (typeof locator.all === "function") {
-    const origAll = locator.all.bind(locator);
-    locator.all = async () => {
-      const items = await origAll();
-      return items.map((item, i) => {
-        const childHint = `${hint}.all()[${i}]`;
-        return wrapLocator(item, childHint, session, page, pageId, onActivity);
-      });
-    };
-  }
-  return locator;
+async function recordCliTelemetryEvent(command, error) {
+  if (isTelemetryDisabled()) return;
+  const installId = await readOrCreateInstallId();
+  if (!installId) return;
+  await sendWithTimeout({
+    installId,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    event: `libretto ${command.path.join(" ")}`,
+    error
+  });
 }
-function wrapPageForActionLogging(page, session, pageId, onActivity) {
-  const PAGE_ACTIONS = [
-    "click",
-    "dblclick",
-    "fill",
-    "type",
-    "press",
-    "check",
-    "uncheck",
-    "selectOption",
-    "hover",
-    "focus"
-  ];
-  const NAV_ACTIONS = ["goto", "reload", "goBack", "goForward"];
-  for (const method of PAGE_ACTIONS) {
-    const orig = page[method].bind(page);
-    page[method] = async (...args) => {
-      const start = Date.now();
-      try {
-        await page.evaluate(() => {
-          window.__btApiActionInProgress = true;
-        });
-      } catch {
-      }
-      try {
-        const result = await orig(...args);
-        parentLogAction(session, {
-          pageId,
-          action: method,
-          source: "agent",
-          selector: typeof args[0] === "string" ? args[0] : void 0,
-          value: args[1] !== void 0 ? String(args[1]).slice(0, 100) : void 0,
-          duration: Date.now() - start,
-          success: true
-        });
-        onActivity?.();
-        return result;
-      } catch (err) {
-        parentLogAction(session, {
-          pageId,
-          action: method,
-          source: "agent",
-          selector: typeof args[0] === "string" ? args[0] : void 0,
-          duration: Date.now() - start,
-          success: false,
-          error: err.message
-        });
-        onActivity?.();
-        throw err;
-      } finally {
-        try {
-          await page.evaluate(() => {
-            window.__btApiActionInProgress = false;
-          });
-        } catch {
-        }
-      }
-    };
-  }
-  for (const method of NAV_ACTIONS) {
-    const orig = page[method].bind(page);
-    page[method] = async (...args) => {
-      const start = Date.now();
-      try {
-        const result = await orig(...args);
-        parentLogAction(session, {
-          pageId,
-          action: method,
-          source: "agent",
-          url: typeof args[0] === "string" ? args[0] : page.url(),
-          duration: Date.now() - start,
-          success: true
-        });
-        onActivity?.();
-        return result;
-      } catch (err) {
-        parentLogAction(session, {
-          pageId,
-          action: method,
-          source: "agent",
-          url: typeof args[0] === "string" ? args[0] : void 0,
-          duration: Date.now() - start,
-          success: false,
-          error: err.message
-        });
-        onActivity?.();
-        throw err;
-      }
-    };
-  }
-  const LOCATOR_FACTORIES = [
-    "locator",
-    "getByRole",
-    "getByText",
-    "getByLabel",
-    "getByPlaceholder",
-    "getByAltText",
-    "getByTitle",
-    "getByTestId"
-  ];
-  for (const factory of LOCATOR_FACTORIES) {
-    const orig = page[factory].bind(page);
-    page[factory] = (...factoryArgs) => {
-      const locator = orig(...factoryArgs);
-      const hint = formatHint(factory, factoryArgs);
-      return wrapLocator(locator, hint, session, page, pageId, onActivity);
-    };
+async function sendWithTimeout(payload) {
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), TELEMETRY_TIMEOUT_MS);
+  try {
+    await fetch(`${resolveHostedApiUrl()}${TELEMETRY_ENDPOINT_PATH}`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({ json: payload }),
+      signal: controller.signal
+    });
+  } finally {
+    clearTimeout(timeout);
   }
 }
+const telemetryMiddleware = async ({ command, next }) => {
+  try {
+    const result = await next();
+    await recordCliTelemetryEvent(command, false).catch(() => {
+    });
+    return result;
+  } catch (error) {
+    await recordCliTelemetryEvent(command, true).catch(() => {
+    });
+    throw error;
+  }
+};
 export {
-  parentLogAction,
-  readActionLog,
-  readNetworkLog,
-  wrapPageForActionLogging
+  telemetryMiddleware
 };

package/dist/cli/core/workflow-runner/runner.js

@@ -1,4 +1,9 @@
 import { installPauseHandler } from "../../../shared/debug/pause-handler.js";
+import {
+  mergeAuthProfileStorageState,
+  normalizeAuthProfileSite
+} from "../../../shared/workflow/auth-profile-state.js";
+import { readProfile, writeProfile } from "../profiles.js";
 import {
   getAbsoluteIntegrationPath,
   installHeadedWorkflowVisualization,
@@ -72,6 +77,7 @@ class WorkflowController {
         session: this.config.session,
         page: this.config.page
       };
+      const visitedSites = createVisitedSiteTracker(this.config.context);
       const uninstallPauseHandler = installPauseHandler(
         (pauseArgs) => this.pause({
           ...pauseArgs,
@@ -80,6 +86,12 @@ class WorkflowController {
       );
       try {
         await workflow.run(workflowContext, workflowConfig.params ?? {});
+        await refreshLocalAuthProfileIfEnabled({
+          context: this.config.context,
+          enabled: this.config.refreshLocalAuthProfiles === true,
+          sites: visitedSites.sites(),
+          workflow
+        });
       } catch (error) {
         this.emitOutcome({
           state: "finished",
@@ -90,6 +102,7 @@ class WorkflowController {
         return;
       } finally {
         uninstallPauseHandler();
+        visitedSites.dispose();
       }
       this.emitOutcome({
         state: "finished",
@@ -139,6 +152,58 @@ class WorkflowController {
     };
   }
 }
+async function refreshLocalAuthProfileIfEnabled(args) {
+  const { context, enabled, sites, workflow } = args;
+  if (!workflow.authProfileName || workflow.authProfileRefresh !== true) {
+    return;
+  }
+  if (!enabled) return;
+  if (sites.length === 0) {
+    console.warn(
+      `Auth profile refresh skipped for "${workflow.authProfileName}": workflow did not visit any http(s) sites.`
+    );
+    return;
+  }
+  const existing = readProfile(workflow.authProfileName);
+  const latest = await context.storageState({ indexedDB: true });
+  const state = mergeAuthProfileStorageState(existing, latest, sites);
+  await writeProfile(workflow.authProfileName, state);
+  console.warn(`Auth profile refreshed: ${workflow.authProfileName}`);
+}
+function createVisitedSiteTracker(context) {
+  const sites = /* @__PURE__ */ new Set();
+  const pageListeners = /* @__PURE__ */ new Map();
+  const recordUrl = (url) => {
+    if (!url.startsWith("http://") && !url.startsWith("https://")) return;
+    const site = normalizeAuthProfileSite(url);
+    if (site) sites.add(site);
+  };
+  const trackPage = (page) => {
+    if (pageListeners.has(page)) return;
+    recordUrl(page.url());
+    const onFrameNavigated = (frame) => {
+      if (frame === page.mainFrame()) {
+        recordUrl(frame.url());
+      }
+    };
+    pageListeners.set(page, onFrameNavigated);
+    page.on("framenavigated", onFrameNavigated);
+  };
+  for (const page of context.pages()) {
+    trackPage(page);
+  }
+  context.on("page", trackPage);
+  return {
+    sites: () => [...sites],
+    dispose: () => {
+      context.off("page", trackPage);
+      for (const [page, listener] of pageListeners) {
+        page.off("framenavigated", listener);
+      }
+      pageListeners.clear();
+    }
+  };
+}
 function chunkToString(chunk) {
   return Buffer.isBuffer(chunk) ? chunk.toString("utf8") : String(chunk);
 }

package/dist/cli/router.js

@@ -1,13 +1,17 @@
 import { authCommands } from "./commands/auth.js";
 import { billingCommands } from "./commands/billing.js";
 import { browserCommands } from "./commands/browser.js";
+import { cloudCredentialCommands } from "./commands/cloud-credentials.js";
 import { deployCommand } from "./commands/deploy.js";
 import { executionCommands } from "./commands/execution.js";
 import { experimentsCommand } from "./commands/experiments.js";
+import { importChromeProfilesCommand } from "./commands/import-chrome-profiles.js";
+import { profileCommands } from "./commands/profiles.js";
 import { setupCommand } from "./commands/setup.js";
 import { statusCommand } from "./commands/status.js";
 import { snapshotCommand } from "./commands/snapshot.js";
 import { searchCommand } from "./commands/search.js";
+import { telemetryMiddleware } from "./core/telemetry.js";
 import { updateCommand } from "./commands/update.js";
 import { SimpleCLI } from "affordance";
 const cliRoutes = {
@@ -17,10 +21,13 @@ const cliRoutes = {
     routes: {
       deploy: deployCommand,
       auth: authCommands,
-      billing: billingCommands
+      billing: billingCommands,
+      credentials: cloudCredentialCommands,
+      profiles: profileCommands
     }
   }),
   experiments: experimentsCommand,
+  "import-chrome-profiles": importChromeProfilesCommand,
   ...executionCommands,
   search: searchCommand,
   setup: setupCommand,
@@ -30,6 +37,7 @@ const cliRoutes = {
 };
 function createCLIApp() {
   return SimpleCLI.define("libretto", cliRoutes, {
+    middlewares: [telemetryMiddleware],
     appendHelpText: [
       "Options:",
       "  --session <name>  Required for session-scoped commands",

package/dist/index.d.ts

@@ -13,7 +13,9 @@ export { InstrumentationOptions, InstrumentedPage, installInstrumentation, instr
 export { GhostCursorOptions, ensureGhostCursor, ghostClick, hideGhostCursor, moveGhostCursor } from './shared/visualization/ghost-cursor.js';
 export { HighlightOptions, clearHighlights, ensureHighlightLayer, showHighlight } from './shared/visualization/highlight.js';
 export { BrowserSession, LaunchBrowserArgs, launchBrowser } from './shared/run/browser.js';
+export { LibrettoAuthenticateOptions, librettoAuthenticate } from './shared/workflow/authenticate.js';
 export { ExportedLibrettoWorkflow, LIBRETTO_WORKFLOW_BRAND, LibrettoWorkflow, LibrettoWorkflowContext, LibrettoWorkflowHandler, LibrettoWorkflowInputError, LibrettoWorkflowOptions, WorkflowInputValidator, getDefaultWorkflowFromModuleExports, getWorkflowFromModuleExports, getWorkflowsFromModuleExports, isLibrettoWorkflow, validateWorkflowInput, workflow } from './shared/workflow/workflow.js';
+export { AuthProfileStorageState, captureAuthProfileStorageState, normalizeAuthProfileSite, parseAuthProfileSites } from './shared/workflow/auth-profile-state.js';
 import 'zod';
 import 'playwright';
 import 'ai';

package/dist/index.js

@@ -60,6 +60,9 @@ import {
 import {
   launchBrowser
 } from "./shared/run/api.js";
+import {
+  librettoAuthenticate
+} from "./shared/workflow/authenticate.js";
 import {
   getDefaultWorkflowFromModuleExports,
   getWorkflowFromModuleExports,
@@ -71,6 +74,11 @@ import {
   validateWorkflowInput,
   workflow
 } from "./shared/workflow/workflow.js";
+import {
+  captureAuthProfileStorageState,
+  normalizeAuthProfileSite,
+  parseAuthProfileSites
+} from "./shared/workflow/auth-profile-state.js";
 const isDirectExecution = () => {
   const entryArg = process.argv[1];
   if (!entryArg) {
@@ -97,6 +105,7 @@ export {
   SessionStateFileSchema,
   SessionStatusSchema,
   attemptWithRecovery,
+  captureAuthProfileStorageState,
   clearHighlights,
   computerUseRecoveryAction,
   createFileLogSink,
@@ -119,8 +128,11 @@ export {
   isLibrettoWorkflow,
   jsonlConsoleSink,
   launchBrowser,
+  librettoAuthenticate,
   moveGhostCursor,
+  normalizeAuthProfileSite,
   pageRequest,
+  parseAuthProfileSites,
   parseSessionStateContent,
   parseSessionStateData,
   pause,

package/dist/runtime/recovery/agent.js

@@ -88,16 +88,23 @@ function readPngDimensions(buffer) {
     height: buffer.readUInt32BE(20)
   };
 }
-async function takeViewportScreenshot(page) {
-  const viewport = page.viewportSize();
-  if (!viewport) {
-    throw new Error("Viewport size not found");
-  }
-  const screenshot = await page.screenshot({
-    fullPage: false,
-    scale: "css",
-    timeout: 1e4
-  });
+function toPositiveNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : void 0;
+}
+async function getViewportFromPage(page) {
+  const metrics = await page.evaluate(() => ({
+    visualViewportWidth: window.visualViewport?.width,
+    visualViewportHeight: window.visualViewport?.height,
+    innerWidth: window.innerWidth,
+    innerHeight: window.innerHeight,
+    documentElementClientWidth: document.documentElement?.clientWidth,
+    documentElementClientHeight: document.documentElement?.clientHeight
+  }));
+  const width = toPositiveNumber(metrics.visualViewportWidth) ?? toPositiveNumber(metrics.innerWidth) ?? toPositiveNumber(metrics.documentElementClientWidth);
+  const height = toPositiveNumber(metrics.visualViewportHeight) ?? toPositiveNumber(metrics.innerHeight) ?? toPositiveNumber(metrics.documentElementClientHeight);
+  return width && height ? { width, height } : null;
+}
+function screenshotState(screenshot, viewport) {
   const dimensions = readPngDimensions(screenshot);
   return {
     screenshot,
@@ -110,6 +117,18 @@ async function takeViewportScreenshot(page) {
     }
   };
 }
+async function takeViewportScreenshot(page) {
+  const viewport = page.viewportSize() ?? await getViewportFromPage(page).catch(() => null);
+  if (!viewport) {
+    throw new Error("Viewport size not found");
+  }
+  const screenshot = await page.screenshot({
+    fullPage: false,
+    scale: "css",
+    timeout: 1e4
+  });
+  return screenshotState(screenshot, viewport);
+}
 async function executeBrowserAction(page, action, logger = defaultLogger) {
   switch (action.type) {
     case "click": {
@@ -247,9 +266,9 @@ async function executeRecoveryAgent(page, instruction, logger, model, maxSteps =
   }
   const log = logger ?? defaultLogger;
   log.info("Executing vision-based recovery agent", { instruction });
-  let screenshotState;
+  let screenshotState2;
   try {
-    screenshotState = await takeViewportScreenshot(page);
+    screenshotState2 = await takeViewportScreenshot(page);
   } catch (screenshotError) {
     log.warn("Failed to take screenshot for recovery agent, skipping", {
       screenshotError: screenshotError instanceof Error ? screenshotError.message : String(screenshotError)
@@ -258,7 +277,7 @@ async function executeRecoveryAgent(page, instruction, logger, model, maxSteps =
   }
   const steps = [];
   for (let step = 1; step <= maxSteps; step++) {
-    const { screenshot, dimensions, scale } = screenshotState;
+    const { screenshot, dimensions, scale } = screenshotState2;
     const { object: result } = await generateObject({
       model,
       schema: recoveryActionSchema,
@@ -305,7 +324,7 @@ Analyze the screenshot and decide what action to take. If the task is complete o
     await executeBrowserAction(page, action, log);
     await delay(2e3);
     if (step < maxSteps) {
-      screenshotState = await takeViewportScreenshot(page);
+      screenshotState2 = await takeViewportScreenshot(page);
     }
   }
   log.info("Recovery agent execution completed");

package/dist/shared/workflow/auth-profile-name.d.ts

@@ -0,0 +1,3 @@
+declare function normalizeProfileName(name: string): string;
+
+export { normalizeProfileName };