libretto 0.6.24 → 0.6.25

package/src/cli/core/telemetry.ts

@@ -1,445 +1,128 @@
-import {
-  appendFileSync,
-  existsSync,
-  readFileSync,
-} from "node:fs";
-import type { Page } from "playwright";
-import {
-  getSessionActionsLogPath,
-  getSessionNetworkLogPath,
-} from "./context.js";
-import { assertSessionStateExistsOrThrow } from "./session.js";
-
-export type NetworkLogEntry = {
-  id?: number;
-  ts: string;
-  pageId?: string;
-  method: string;
-  url: string;
-  resourceType?: string;
-  status: number | null;
-  statusText?: string | null;
-  contentType: string | null;
-  requestHeaders?: Record<string, string> | null;
-  responseHeaders?: Record<string, string> | null;
-  requestBodyPreview?: string | null;
-  requestBodyPath?: string | null;
-  requestBodyBytes?: number | null;
-  requestBodyTruncated?: boolean;
-  requestBodyOmittedReason?: string | null;
-  responseBodyPreview?: string | null;
-  responseBodyPath?: string | null;
-  responseBodyBytes?: number | null;
-  responseBodyTruncated?: boolean;
-  responseBodyOmittedReason?: string | null;
-  errorText?: string | null;
-  postData?: string;
-  responseBody?: string | null;
-  size?: number | null;
-  durationMs?: number | null;
+import { randomUUID } from "node:crypto";
+import { promises as fs } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import type { SimpleCLICommandMeta, SimpleCLIMiddleware } from "affordance";
+import { resolveHostedApiUrl } from "./auth-fetch.js";
+
+const TELEMETRY_FILE_NAME = "telemetry.json";
+const TELEMETRY_ENDPOINT_PATH = "/v1/telemetry/recordCliEvent";
+const TELEMETRY_TIMEOUT_MS = 250;
+
+type StoredTelemetryState = {
+  installId?: string;
+  enabled?: boolean;
 };
 
-export function readNetworkLog(
-  session: string,
-  opts: {
-    last?: number;
-    filter?: string;
-    method?: string;
-    pageId?: string;
-  } = {},
-): NetworkLogEntry[] {
-  assertSessionStateExistsOrThrow(session);
-  const logPath = getSessionNetworkLogPath(session);
-  if (!existsSync(logPath)) return [];
-
-  const lines = readFileSync(logPath, "utf-8")
-    .trim()
-    .split("\n")
-    .filter(Boolean);
-  let entries: NetworkLogEntry[] = lines.map(
-    (line) => JSON.parse(line) as NetworkLogEntry,
-  );
-
-  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;
-}
-
-export type ActionLogEntry = {
-  ts: string;
-  pageId?: string;
-  action: string;
-  source: "user" | "agent";
-  selector?: string;
-  bestSemanticSelector?: string;
-  targetSelector?: string;
-  ancestorSelectors?: string[];
-  nearbyText?: string;
-  composedPath?: string[];
-  coordinates?: {
-    x: number;
-    y: number;
-  };
-  value?: string;
-  url?: string;
-  duration?: number;
-  success: boolean;
-  error?: string;
+type CliTelemetryPayload = {
+  installId: string;
+  timestamp: string;
+  event: string;
+  error: boolean;
 };
 
-export function parentLogAction(
-  session: string,
-  entry: Record<string, unknown>,
-): void {
-  try {
-    const record = { ts: new Date().toISOString(), ...entry };
-    appendFileSync(
-      getSessionActionsLogPath(session),
-      JSON.stringify(record) + "\n",
-    );
-  } catch {}
+function telemetryDir(): string {
+  return join(homedir(), ".libretto");
 }
 
-export function readActionLog(
-  session: string,
-  opts: {
-    last?: number;
-    filter?: string;
-    action?: string;
-    source?: string;
-    pageId?: string;
-  } = {},
-): ActionLogEntry[] {
-  assertSessionStateExistsOrThrow(session);
-  const logPath = getSessionActionsLogPath(session);
-  if (!existsSync(logPath)) return [];
-
-  const lines = readFileSync(logPath, "utf-8")
-    .trim()
-    .split("\n")
-    .filter(Boolean);
-  let entries: ActionLogEntry[] = lines.map(
-    (line) => JSON.parse(line) as ActionLogEntry,
-  );
-
-  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;
+function telemetryPath(): string {
+  return join(telemetryDir(), TELEMETRY_FILE_NAME);
 }
 
-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",
-] as const;
-
-const LOCATOR_RETURNING_METHODS = [
-  "first",
-  "last",
-  "locator",
-  "getByRole",
-  "getByText",
-  "getByLabel",
-  "getByPlaceholder",
-  "getByAltText",
-  "getByTitle",
-  "getByTestId",
-  "filter",
-  "and",
-  "or",
-] as const;
-
-function formatHint(method: string, args: any[]): string {
-  const formatted = args.map((a: any) => JSON.stringify(a)).join(", ");
-  return `${method}(${formatted})`;
+function isTelemetryDisabled(): boolean {
+  return (
+    process.env.LIBRETTO_TELEMETRY_DISABLED === "1" ||
+    process.env.DO_NOT_TRACK === "1" ||
+    process.env.CI === "1"
+  );
 }
 
-function wrapLocator(
-  locator: any,
-  hint: string,
-  session: string,
-  page: Page,
-  pageId?: string,
-  onActivity?: () => void,
-): any {
-  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: any[]) => {
-      const start = Date.now();
-      try {
-        await page.evaluate(() => {
-          (window as any).__btApiActionInProgress = true;
-        });
-      } catch {}
-      try {
-        const result = await origAct(...actArgs);
-        parentLogAction(session, {
-          pageId,
-          action: actMethod,
-          source: "agent",
-          selector: hint,
-          value:
-            actArgs[0] !== undefined
-              ? String(actArgs[0]).slice(0, 100)
-              : undefined,
-          duration: Date.now() - start,
-          success: true,
-        });
-        onActivity?.();
-        return result;
-      } catch (err: any) {
-        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 as any).__btApiActionInProgress = false;
-          });
-        } catch {}
-      }
-    };
+async function readTelemetryState(): Promise<StoredTelemetryState | null> {
+  try {
+    const raw = await fs.readFile(telemetryPath(), "utf8");
+    return JSON.parse(raw) as Partial<StoredTelemetryState>;
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code !== "ENOENT") throw error;
+    return null;
   }
+}
 
-  for (const method of LOCATOR_RETURNING_METHODS) {
-    if (typeof locator[method] !== "function") continue;
-    const origMethod = locator[method].bind(locator);
-    locator[method] = (...args: any[]) => {
-      const child = origMethod(...args);
-      const childHint =
-        args.length > 0
-          ? `${hint}.${formatHint(method, args)}`
-          : `${hint}.${method}()`;
-      return wrapLocator(child, childHint, session, page, pageId, onActivity);
-    };
-  }
+async function readOrCreateInstallId(): Promise<string | null> {
+  const state = await readTelemetryState();
+  if (state?.enabled === false) return null;
 
-  if (typeof locator.nth === "function") {
-    const origNth = locator.nth.bind(locator);
-    locator.nth = (index: number) => {
-      const child = origNth(index);
-      const childHint = `${hint}.nth(${index})`;
-      return wrapLocator(child, childHint, session, page, pageId, onActivity);
-    };
+  if (typeof state?.installId === "string" && state.installId.length > 0) {
+    return state.installId;
   }
 
-  if (typeof locator.all === "function") {
-    const origAll = locator.all.bind(locator);
-    locator.all = async () => {
-      const items: any[] = await origAll();
-      return items.map((item: any, i: number) => {
-        const childHint = `${hint}.all()[${i}]`;
-        return wrapLocator(item, childHint, session, page, pageId, onActivity);
-      });
-    };
-  }
+  const installId = randomUUID();
+  writeTelemetryNotice();
+  await writeTelemetryState({ installId, enabled: true });
+  return installId;
+}
 
-  return locator;
+function writeTelemetryNotice(): void {
+  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",
+  );
 }
 
-export function wrapPageForActionLogging(
-  page: Page,
-  session: string,
-  pageId?: string,
-  onActivity?: () => void,
-): void {
-  const PAGE_ACTIONS = [
-    "click",
-    "dblclick",
-    "fill",
-    "type",
-    "press",
-    "check",
-    "uncheck",
-    "selectOption",
-    "hover",
-    "focus",
-  ] as const;
-  const NAV_ACTIONS = ["goto", "reload", "goBack", "goForward"] as const;
+async function writeTelemetryState(state: StoredTelemetryState): Promise<void> {
+  await fs.mkdir(telemetryDir(), { recursive: true, mode: 0o700 });
+  const target = telemetryPath();
+  const tmp = `${target}.${process.pid}.${randomUUID()}.tmp`;
+  await fs.writeFile(tmp, JSON.stringify(state, null, 2), { mode: 0o600 });
+  await fs.rename(tmp, target);
+}
 
-  for (const method of PAGE_ACTIONS) {
-    const orig = (page as any)[method].bind(page);
-    (page as any)[method] = async (...args: any[]) => {
-      const start = Date.now();
-      try {
-        await page.evaluate(() => {
-          (window as any).__btApiActionInProgress = true;
-        });
-      } catch {}
-      try {
-        const result = await orig(...args);
-        parentLogAction(session, {
-          pageId,
-          action: method,
-          source: "agent",
-          selector: typeof args[0] === "string" ? args[0] : undefined,
-          value:
-            args[1] !== undefined ? String(args[1]).slice(0, 100) : undefined,
-          duration: Date.now() - start,
-          success: true,
-        });
-        onActivity?.();
-        return result;
-      } catch (err: any) {
-        parentLogAction(session, {
-          pageId,
-          action: method,
-          source: "agent",
-          selector: typeof args[0] === "string" ? args[0] : undefined,
-          duration: Date.now() - start,
-          success: false,
-          error: err.message,
-        });
-        onActivity?.();
-        throw err;
-      } finally {
-        try {
-          await page.evaluate(() => {
-            (window as any).__btApiActionInProgress = false;
-          });
-        } catch {}
-      }
-    };
-  }
+async function recordCliTelemetryEvent(
+  command: SimpleCLICommandMeta,
+  error: boolean,
+): Promise<void> {
+  if (isTelemetryDisabled()) return;
+  const installId = await readOrCreateInstallId();
+  if (!installId) return;
+
+  await sendWithTimeout({
+    installId,
+    timestamp: new Date().toISOString(),
+    event: `libretto ${command.path.join(" ")}`,
+    error,
+  });
+}
 
-  for (const method of NAV_ACTIONS) {
-    const orig = (page as any)[method].bind(page);
-    (page as any)[method] = async (...args: any[]) => {
-      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: any) {
-        parentLogAction(session, {
-          pageId,
-          action: method,
-          source: "agent",
-          url: typeof args[0] === "string" ? args[0] : undefined,
-          duration: Date.now() - start,
-          success: false,
-          error: err.message,
-        });
-        onActivity?.();
-        throw err;
-      }
-    };
+async function sendWithTimeout(payload: CliTelemetryPayload): Promise<void> {
+  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 LOCATOR_FACTORIES = [
-    "locator",
-    "getByRole",
-    "getByText",
-    "getByLabel",
-    "getByPlaceholder",
-    "getByAltText",
-    "getByTitle",
-    "getByTestId",
-  ] as const;
-
-  for (const factory of LOCATOR_FACTORIES) {
-    const orig = (page as any)[factory].bind(page);
-    (page as any)[factory] = (...factoryArgs: any[]) => {
-      const locator = orig(...factoryArgs);
-      const hint = formatHint(factory, factoryArgs);
-      return wrapLocator(locator, hint, session, page, pageId, onActivity);
-    };
+export const telemetryMiddleware: SimpleCLIMiddleware<
+  unknown,
+  {},
+  {}
+> = async ({ command, next }) => {
+  try {
+    const result = await next();
+    await recordCliTelemetryEvent(command, false).catch(() => {});
+    return result;
+  } catch (error) {
+    await recordCliTelemetryEvent(command, true).catch(() => {});
+    throw error;
   }
-}
+};

package/src/cli/core/workflow-runner/runner.ts

@@ -1,10 +1,15 @@
-import type { BrowserContext, Page } from "playwright";
+import type { BrowserContext, Frame, Page } from "playwright";
 import type { LoggerApi } from "../../../shared/logger/index.js";
 import { installPauseHandler } from "../../../shared/debug/pause-handler.js";
+import {
+  mergeAuthProfileStorageState,
+  normalizeAuthProfileSite,
+} from "../../../shared/workflow/auth-profile-state.js";
 import type {
   ExportedLibrettoWorkflow,
   LibrettoWorkflowContext,
 } from "../../../shared/workflow/workflow.js";
+import { readProfile, writeProfile } from "../profiles.js";
 import {
   getAbsoluteIntegrationPath,
   installHeadedWorkflowVisualization,
@@ -44,6 +49,7 @@ export type WorkflowControllerConfig = {
   page: Page;
   context: BrowserContext;
   logger: LoggerApi;
+  refreshLocalAuthProfiles?: boolean;
   onLog?: (event: WorkflowLogEvent) => void;
   onOutcome?: (outcome: WorkflowOutcome) => void;
 };
@@ -155,6 +161,7 @@ export class WorkflowController {
         session: this.config.session,
         page: this.config.page,
       };
+      const visitedSites = createVisitedSiteTracker(this.config.context);
 
       const uninstallPauseHandler = installPauseHandler((pauseArgs) =>
         this.pause({
@@ -164,6 +171,12 @@ export 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",
@@ -174,6 +187,7 @@ export class WorkflowController {
         return;
       } finally {
         uninstallPauseHandler();
+        visitedSites.dispose();
       }
 
       this.emitOutcome({
@@ -232,6 +246,77 @@ export class WorkflowController {
   }
 }
 
+async function refreshLocalAuthProfileIfEnabled(
+  args: {
+    context: BrowserContext;
+    enabled: boolean;
+    sites: readonly string[];
+    workflow: ExportedLibrettoWorkflow;
+  },
+): Promise<void> {
+  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: BrowserContext): {
+  sites: () => string[];
+  dispose: () => void;
+} {
+  const sites = new Set<string>();
+  const pageListeners = new Map<Page, (frame: Frame) => void>();
+
+  const recordUrl = (url: string): void => {
+    if (!url.startsWith("http://") && !url.startsWith("https://")) return;
+    const site = normalizeAuthProfileSite(url);
+    if (site) sites.add(site);
+  };
+
+  const trackPage = (page: Page): void => {
+    if (pageListeners.has(page)) return;
+    recordUrl(page.url());
+
+    const onFrameNavigated = (frame: Frame): void => {
+      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: unknown): string {
   return Buffer.isBuffer(chunk) ? chunk.toString("utf8") : String(chunk);
 }