libretto 0.6.24 → 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/shared/workflow/auth-profile-name.d.ts

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

package/dist/shared/workflow/auth-profile-name.js

@@ -0,0 +1,29 @@
+function normalizeProfileName(name) {
+  const trimmed = name.trim();
+  if (!trimmed) {
+    throw new Error("Profile name is required.");
+  }
+  if (!isValidProfileName(trimmed)) {
+    throw new Error(
+      `Invalid profile name "${name}". Use letters, numbers, dots, underscores, and dashes only.`
+    );
+  }
+  return trimmed;
+}
+function isValidProfileName(name) {
+  if (name === "." || name === "..") return false;
+  for (let index = 0; index < name.length; index += 1) {
+    const code = name.charCodeAt(index);
+    const isUppercase = code >= 65 && code <= 90;
+    const isLowercase = code >= 97 && code <= 122;
+    const isDigit = code >= 48 && code <= 57;
+    const isAllowedPunctuation = code === 45 || code === 46 || code === 95;
+    if (!isUppercase && !isLowercase && !isDigit && !isAllowedPunctuation) {
+      return false;
+    }
+  }
+  return true;
+}
+export {
+  normalizeProfileName
+};

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

@@ -0,0 +1,20 @@
+import { BrowserContext } from 'playwright';
+
+type AuthProfileStorageState = {
+    sites?: string[];
+    cookies?: unknown[];
+    origins?: Array<{
+        origin: string;
+        localStorage: Array<{
+            name: string;
+            value: string;
+        }>;
+        indexedDB?: unknown;
+    }>;
+};
+declare function parseAuthProfileSites(value: string): string[];
+declare function normalizeAuthProfileSite(value: string): string | null;
+declare function captureAuthProfileStorageState(context: BrowserContext, sites: readonly string[]): Promise<AuthProfileStorageState>;
+declare function mergeAuthProfileStorageState(existing: AuthProfileStorageState, latest: AuthProfileStorageState, sites: readonly string[]): AuthProfileStorageState;
+
+export { type AuthProfileStorageState, captureAuthProfileStorageState, mergeAuthProfileStorageState, normalizeAuthProfileSite, parseAuthProfileSites };