libretto 0.6.24 → 0.6.26

package/src/cli/core/telemetry.ts

@@ -1,445 +1,174 @@
-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 { existsSync, readFileSync } from "node:fs";
+import { promises as fs } from "node:fs";
+import { homedir } from "node:os";
+import { basename, dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+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 BuildChannel = "node_modules" | "source" | "unknown";
+
+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);
-  }
+type CliTelemetryPayload = {
+  installId: string;
+  timestamp: string;
+  event: string;
+  error: boolean;
+  packageVersion: string;
+  buildChannel: BuildChannel;
+};
 
-  const last = opts.last ?? 20;
-  if (entries.length > last) {
-    entries = entries.slice(-last);
-  }
+type PackageJson = {
+  version?: unknown;
+};
 
-  return entries;
+function packageRoot(): string {
+  return join(dirname(fileURLToPath(import.meta.url)), "../../..");
 }
 
-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;
-};
-
-export function parentLogAction(
-  session: string,
-  entry: Record<string, unknown>,
-): void {
+function readPackageVersion(): string {
   try {
-    const record = { ts: new Date().toISOString(), ...entry };
-    appendFileSync(
-      getSessionActionsLogPath(session),
-      JSON.stringify(record) + "\n",
-    );
-  } catch {}
+    const parsed = JSON.parse(
+      readFileSync(join(packageRoot(), "package.json"), "utf8"),
+    ) as PackageJson;
+    return typeof parsed.version === "string" ? parsed.version : "unknown";
+  } catch {
+    return "unknown";
+  }
 }
 
-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);
+function resolveBuildChannel(): BuildChannel {
+  const root = packageRoot();
+  const workspaceRoot = join(root, "../..");
+  if (
+    basename(dirname(root)) === "packages" &&
+    existsSync(join(workspaceRoot, "pnpm-workspace.yaml"))
+  ) {
+    return "source";
   }
 
-  const last = opts.last ?? 20;
-  if (entries.length > last) {
-    entries = entries.slice(-last);
-  }
+  const pathSegments = root.split(/[\\/]+/);
+  if (pathSegments.includes("node_modules")) return "node_modules";
 
-  return entries;
+  return "unknown";
 }
 
-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 packageVersion = readPackageVersion();
+const buildChannel = resolveBuildChannel();
 
-const LOCATOR_RETURNING_METHODS = [
-  "first",
-  "last",
-  "locator",
-  "getByRole",
-  "getByText",
-  "getByLabel",
-  "getByPlaceholder",
-  "getByAltText",
-  "getByTitle",
-  "getByTestId",
-  "filter",
-  "and",
-  "or",
-] as const;
+function telemetryDir(): string {
+  return join(homedir(), ".libretto");
+}
 
-function formatHint(method: string, args: any[]): string {
-  const formatted = args.map((a: any) => JSON.stringify(a)).join(", ");
-  return `${method}(${formatted})`;
+function telemetryPath(): string {
+  return join(telemetryDir(), TELEMETRY_FILE_NAME);
 }
 
-function wrapLocator(
-  locator: any,
-  hint: string,
-  session: string,
-  page: Page,
-  pageId?: string,
-  onActivity?: () => void,
-): any {
-  if (locator.__librettoActionLogged) return locator;
-  locator.__librettoActionLogged = true;
+function isTelemetryDisabled(): boolean {
+  return (
+    process.env.LIBRETTO_TELEMETRY_DISABLED === "1" ||
+    process.env.DO_NOT_TRACK === "1" ||
+    process.env.CI === "1"
+  );
+}
 
-  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, error status, package version, and build channel 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,
+    packageVersion,
+    buildChannel,
+  });
+}
 
-  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;
   }
-}
+};