libretto 0.3.0 → 0.3.1

package/dist/cli/core/context.js

@@ -0,0 +1,117 @@
+import { Logger, createFileLogSink } from "../../shared/logger/index.js";
+import { spawnSync } from "node:child_process";
+import { cwd } from "node:process";
+import { existsSync, mkdirSync, writeFileSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { validateSessionName } from "./session.js";
+function getRepoRoot() {
+  const override = process.env.LIBRETTO_REPO_ROOT?.trim();
+  if (override) {
+    return resolve(override);
+  }
+  const result = spawnSync("git", ["rev-parse", "--show-toplevel"], {
+    encoding: "utf-8"
+  });
+  if (result.status === 0 && result.stdout) {
+    return result.stdout.trim();
+  }
+  return cwd();
+}
+const REPO_ROOT = getRepoRoot();
+const LIBRETTO_CONFIG_DIR = join(REPO_ROOT, ".libretto");
+const LIBRETTO_CONFIG_PATH = join(LIBRETTO_CONFIG_DIR, "config.json");
+const PROFILES_DIR = join(LIBRETTO_CONFIG_DIR, "profiles");
+const LIBRETTO_SESSIONS_DIR = join(LIBRETTO_CONFIG_DIR, "sessions");
+const LIBRETTO_GITIGNORE_PATH = join(LIBRETTO_CONFIG_DIR, ".gitignore");
+const LIBRETTO_GITIGNORE_CONTENT = [
+  "# Local libretto runtime state",
+  "sessions/",
+  "profiles/",
+  ""
+].join("\n");
+function getSessionDir(session) {
+  return join(LIBRETTO_SESSIONS_DIR, session);
+}
+function getSessionStatePath(session) {
+  return join(getSessionDir(session), "state.json");
+}
+function getSessionLogsPath(session) {
+  return join(getSessionDir(session), "logs.jsonl");
+}
+function getSessionNetworkLogPath(session) {
+  return join(getSessionDir(session), "network.jsonl");
+}
+function getSessionActionsLogPath(session) {
+  return join(getSessionDir(session), "actions.jsonl");
+}
+function getSessionSnapshotsDir(session) {
+  return join(getSessionDir(session), "snapshots");
+}
+function getSessionSnapshotRunDir(session, snapshotRunId) {
+  return join(getSessionSnapshotsDir(session), snapshotRunId);
+}
+function ensureLibrettoSetup() {
+  mkdirSync(LIBRETTO_CONFIG_DIR, { recursive: true });
+  mkdirSync(LIBRETTO_SESSIONS_DIR, { recursive: true });
+  mkdirSync(PROFILES_DIR, { recursive: true });
+  if (!existsSync(LIBRETTO_GITIGNORE_PATH)) {
+    writeFileSync(LIBRETTO_GITIGNORE_PATH, LIBRETTO_GITIGNORE_CONTENT, "utf-8");
+  }
+}
+function createLoggerForSession(session) {
+  validateSessionName(session);
+  const sessionDir = getSessionDir(session);
+  mkdirSync(sessionDir, { recursive: true });
+  const logFilePath = getSessionLogsPath(session);
+  return new Logger(["libretto-cli"], [createFileLogSink({ filePath: logFilePath })]);
+}
+async function closeLogger(logger) {
+  if (!logger) return;
+  await logger.close();
+}
+async function withSessionLogger(session, run) {
+  const logger = createLoggerForSession(session);
+  try {
+    return await run(logger);
+  } finally {
+    await closeLogger(logger);
+  }
+}
+let llmClientFactory = null;
+function setLLMClientFactory(factory) {
+  llmClientFactory = factory;
+}
+function getLLMClientFactory() {
+  return llmClientFactory;
+}
+function maybeConfigureLLMClientFactoryFromEnv() {
+  if (llmClientFactory) return;
+  const hasAnyCreds = process.env.GOOGLE_CLOUD_PROJECT || process.env.GCLOUD_PROJECT || process.env.ANTHROPIC_API_KEY || process.env.OPENAI_API_KEY;
+  if (!hasAnyCreds) return;
+  setLLMClientFactory(async (_logger, model) => {
+    const { createLLMClient } = await import("../../shared/llm/index.js");
+    return createLLMClient(model);
+  });
+}
+export {
+  LIBRETTO_CONFIG_DIR,
+  LIBRETTO_CONFIG_PATH,
+  LIBRETTO_GITIGNORE_PATH,
+  LIBRETTO_SESSIONS_DIR,
+  PROFILES_DIR,
+  REPO_ROOT,
+  closeLogger,
+  createLoggerForSession,
+  ensureLibrettoSetup,
+  getLLMClientFactory,
+  getSessionActionsLogPath,
+  getSessionDir,
+  getSessionLogsPath,
+  getSessionNetworkLogPath,
+  getSessionSnapshotRunDir,
+  getSessionSnapshotsDir,
+  getSessionStatePath,
+  maybeConfigureLLMClientFactoryFromEnv,
+  setLLMClientFactory,
+  withSessionLogger
+};

package/dist/cli/core/pause-signals.js

@@ -0,0 +1,29 @@
+import { existsSync } from "node:fs";
+import { unlink } from "node:fs/promises";
+import { join } from "node:path";
+import { getSessionDir } from "./context.js";
+function getPauseSignalPaths(session) {
+  const sessionDir = getSessionDir(session);
+  return {
+    pausedSignalPath: join(sessionDir, `${session}.paused`),
+    resumeSignalPath: join(sessionDir, `${session}.resume`),
+    completedSignalPath: join(sessionDir, `${session}.completed`),
+    failedSignalPath: join(sessionDir, `${session}.failed`),
+    outputSignalPath: join(sessionDir, `${session}.output`)
+  };
+}
+async function removeSignalIfExists(path) {
+  if (!existsSync(path)) return;
+  try {
+    await unlink(path);
+  } catch (error) {
+    const code = error.code;
+    if (code !== "ENOENT") {
+      throw error;
+    }
+  }
+}
+export {
+  getPauseSignalPaths,
+  removeSignalIfExists
+};

package/dist/cli/core/session-telemetry.js

@@ -0,0 +1,491 @@
+async function installSessionTelemetry(options) {
+  const STATIC_EXT_RE = /\.(css|js|png|jpg|jpeg|gif|woff|woff2|ttf|ico|svg)(\?|$)/i;
+  const { context, initialPage, logAction, logNetwork } = options;
+  const includeUserDomActions = options.includeUserDomActions ?? false;
+  const pageIdCache = /* @__PURE__ */ new WeakMap();
+  const wrappedPages = /* @__PURE__ */ new WeakSet();
+  const exposedPages = /* @__PURE__ */ new WeakSet();
+  const resolvePageId = async (page) => {
+    if (pageIdCache.has(page)) return pageIdCache.get(page);
+    const cdpSession = await context.newCDPSession(page);
+    try {
+      const targetInfo = await cdpSession.send("Target.getTargetInfo");
+      const targetId = targetInfo?.targetInfo?.targetId;
+      if (typeof targetId !== "string" || targetId.length === 0) {
+        throw new Error(`Could not resolve target id for page at URL "${page.url()}".`);
+      }
+      pageIdCache.set(page, targetId);
+      return targetId;
+    } finally {
+      await cdpSession.detach();
+    }
+  };
+  const emitAction = (entry) => {
+    logAction({
+      ts: (/* @__PURE__ */ new Date()).toISOString(),
+      ...entry
+    });
+  };
+  const emitNetwork = (entry) => {
+    logNetwork({
+      ts: (/* @__PURE__ */ new Date()).toISOString(),
+      ...entry
+    });
+  };
+  const markApiActionInProgress = async (page, inProgress) => {
+    await page.evaluate((flag) => {
+      window.__btApiActionInProgress = flag;
+    }, inProgress);
+  };
+  const wrapLocator = (locator, page, pageId) => {
+    if (locator.__librettoActionLogged) return locator;
+    locator.__librettoActionLogged = true;
+    const locatorActionMethods = [
+      "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 locatorReturningMethods = [
+      "first",
+      "last",
+      "locator",
+      "getByRole",
+      "getByText",
+      "getByLabel",
+      "getByPlaceholder",
+      "getByAltText",
+      "getByTitle",
+      "getByTestId",
+      "filter",
+      "and",
+      "or"
+    ];
+    for (const actMethod of locatorActionMethods) {
+      if (typeof locator[actMethod] !== "function") continue;
+      const originalAction = locator[actMethod].bind(locator);
+      locator[actMethod] = async (...actionArgs) => {
+        const start = Date.now();
+        await markApiActionInProgress(page, true);
+        try {
+          const result = await originalAction(...actionArgs);
+          emitAction({
+            pageId,
+            action: actMethod,
+            source: "agent",
+            selector: "locator",
+            value: actionArgs[0] !== void 0 ? String(actionArgs[0]).slice(0, 100) : void 0,
+            duration: Date.now() - start,
+            success: true
+          });
+          return result;
+        } catch (error) {
+          emitAction({
+            pageId,
+            action: actMethod,
+            source: "agent",
+            selector: "locator",
+            duration: Date.now() - start,
+            success: false,
+            error: error?.message ?? String(error)
+          });
+          throw error;
+        } finally {
+          await markApiActionInProgress(page, false);
+        }
+      };
+    }
+    for (const method of locatorReturningMethods) {
+      if (typeof locator[method] !== "function") continue;
+      const originalMethod = locator[method].bind(locator);
+      locator[method] = (...args) => {
+        const child = originalMethod(...args);
+        return wrapLocator(child, page, pageId);
+      };
+    }
+    if (typeof locator.nth === "function") {
+      const originalNth = locator.nth.bind(locator);
+      locator.nth = (index) => {
+        const child = originalNth(index);
+        return wrapLocator(child, page, pageId);
+      };
+    }
+    if (typeof locator.all === "function") {
+      const originalAll = locator.all.bind(locator);
+      locator.all = async () => {
+        const items = await originalAll();
+        return items.map((item) => wrapLocator(item, page, pageId));
+      };
+    }
+    return locator;
+  };
+  const installUserDomTracking = async (page, pageId) => {
+    if (exposedPages.has(page)) return;
+    exposedPages.add(page);
+    await page.exposeFunction("__btActionLog", (jsonStr) => {
+      const parsed = JSON.parse(jsonStr);
+      emitAction({
+        pageId,
+        source: "user",
+        ...parsed
+      });
+    });
+    await page.addInitScript(() => {
+      if (window.__btDomListenersInstalled) return;
+      window.__btDomListenersInstalled = true;
+      const identify = (el) => {
+        if (!el || !el.tagName) return "";
+        const testId = el.getAttribute("data-testid");
+        if (testId) return `[data-testid="${testId}"]`;
+        const role = el.getAttribute("role") || "";
+        const id = el.id;
+        if (role && id) return `${role}#${id}`;
+        const label = el.getAttribute("aria-label") || (el.textContent || "").trim().slice(0, 30) || "";
+        if (role && label) return `${role} "${label}"`;
+        const tag = el.tagName.toLowerCase();
+        const cls = el.className && typeof el.className === "string" ? "." + el.className.trim().split(/\s+/).slice(0, 2).join(".") : "";
+        return `${tag}${cls}`;
+      };
+      let clickTimer = null;
+      let pendingClick = null;
+      document.addEventListener(
+        "click",
+        (event) => {
+          if (window.__btApiActionInProgress) return;
+          const target = event.target;
+          const selector = identify(target);
+          if (target?.type === "checkbox") {
+            window.__btActionLog(
+              JSON.stringify({
+                action: target.checked ? "check" : "uncheck",
+                selector,
+                success: true
+              })
+            );
+            return;
+          }
+          pendingClick = { selector };
+          if (clickTimer) clearTimeout(clickTimer);
+          clickTimer = setTimeout(() => {
+            if (pendingClick) {
+              window.__btActionLog(
+                JSON.stringify({
+                  action: "click",
+                  selector: pendingClick.selector,
+                  success: true
+                })
+              );
+            }
+            pendingClick = null;
+            clickTimer = null;
+          }, 200);
+        },
+        true
+      );
+      document.addEventListener(
+        "dblclick",
+        (event) => {
+          if (window.__btApiActionInProgress) return;
+          if (clickTimer) {
+            clearTimeout(clickTimer);
+            clickTimer = null;
+            pendingClick = null;
+          }
+          const selector = identify(event.target);
+          window.__btActionLog(
+            JSON.stringify({ action: "dblclick", selector, success: true })
+          );
+        },
+        true
+      );
+      const inputTimers = /* @__PURE__ */ new WeakMap();
+      document.addEventListener(
+        "input",
+        (event) => {
+          if (window.__btApiActionInProgress) return;
+          const target = event.target;
+          const selector = identify(target);
+          if (target.tagName === "SELECT") {
+            window.__btActionLog(
+              JSON.stringify({
+                action: "selectOption",
+                selector,
+                value: target.value,
+                success: true
+              })
+            );
+            return;
+          }
+          const existing = inputTimers.get(target);
+          if (existing) clearTimeout(existing);
+          inputTimers.set(
+            target,
+            setTimeout(() => {
+              inputTimers.delete(target);
+              window.__btActionLog(
+                JSON.stringify({
+                  action: "fill",
+                  selector,
+                  value: (target.value || "").slice(0, 100),
+                  success: true
+                })
+              );
+            }, 500)
+          );
+        },
+        true
+      );
+      const specialKeys = /* @__PURE__ */ new Set([
+        "Enter",
+        "Escape",
+        "Tab",
+        "Backspace",
+        "Delete",
+        "ArrowUp",
+        "ArrowDown",
+        "ArrowLeft",
+        "ArrowRight",
+        "Home",
+        "End",
+        "PageUp",
+        "PageDown",
+        "F1",
+        "F2",
+        "F3",
+        "F4",
+        "F5",
+        "F6",
+        "F7",
+        "F8",
+        "F9",
+        "F10",
+        "F11",
+        "F12"
+      ]);
+      document.addEventListener(
+        "keydown",
+        (event) => {
+          if (window.__btApiActionInProgress) return;
+          const isShortcut = event.ctrlKey || event.metaKey || event.altKey;
+          if (!isShortcut && !specialKeys.has(event.key)) return;
+          const selector = identify(event.target);
+          const keyDesc = (event.ctrlKey ? "Ctrl+" : "") + (event.metaKey ? "Meta+" : "") + (event.altKey ? "Alt+" : "") + (event.shiftKey ? "Shift+" : "") + event.key;
+          window.__btActionLog(
+            JSON.stringify({
+              action: "press",
+              selector,
+              value: keyDesc,
+              success: true
+            })
+          );
+        },
+        true
+      );
+      let scrollTimer = null;
+      document.addEventListener(
+        "scroll",
+        () => {
+          if (window.__btApiActionInProgress) return;
+          if (scrollTimer) clearTimeout(scrollTimer);
+          scrollTimer = setTimeout(() => {
+            scrollTimer = null;
+            window.__btActionLog(
+              JSON.stringify({
+                action: "scroll",
+                selector: "document",
+                value: `y=${window.scrollY}`,
+                success: true
+              })
+            );
+          }, 300);
+        },
+        true
+      );
+    });
+  };
+  const wrapPageActions = (page, pageId) => {
+    if (wrappedPages.has(page)) return;
+    wrappedPages.add(page);
+    const pageActions = [
+      "click",
+      "dblclick",
+      "fill",
+      "type",
+      "press",
+      "check",
+      "uncheck",
+      "selectOption",
+      "hover",
+      "focus"
+    ];
+    const navActions = ["goto", "reload", "goBack", "goForward"];
+    const locatorFactories = [
+      "locator",
+      "getByRole",
+      "getByText",
+      "getByLabel",
+      "getByPlaceholder",
+      "getByAltText",
+      "getByTitle",
+      "getByTestId"
+    ];
+    for (const method of pageActions) {
+      const originalMethod = page[method].bind(page);
+      page[method] = async (...args) => {
+        const start = Date.now();
+        await markApiActionInProgress(page, true);
+        try {
+          const result = await originalMethod(...args);
+          emitAction({
+            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
+          });
+          return result;
+        } catch (error) {
+          emitAction({
+            pageId,
+            action: method,
+            source: "agent",
+            selector: typeof args[0] === "string" ? args[0] : void 0,
+            duration: Date.now() - start,
+            success: false,
+            error: error?.message ?? String(error)
+          });
+          throw error;
+        } finally {
+          await markApiActionInProgress(page, false);
+        }
+      };
+    }
+    for (const method of navActions) {
+      const originalMethod = page[method].bind(page);
+      page[method] = async (...args) => {
+        const start = Date.now();
+        try {
+          const result = await originalMethod(...args);
+          emitAction({
+            pageId,
+            action: method,
+            source: "agent",
+            url: typeof args[0] === "string" ? args[0] : page.url(),
+            duration: Date.now() - start,
+            success: true
+          });
+          return result;
+        } catch (error) {
+          emitAction({
+            pageId,
+            action: method,
+            source: "agent",
+            url: typeof args[0] === "string" ? args[0] : void 0,
+            duration: Date.now() - start,
+            success: false,
+            error: error?.message ?? String(error)
+          });
+          throw error;
+        }
+      };
+    }
+    for (const factory of locatorFactories) {
+      const originalFactory = page[factory].bind(page);
+      page[factory] = (...factoryArgs) => {
+        const locator = originalFactory(...factoryArgs);
+        return wrapLocator(locator, page, pageId);
+      };
+    }
+  };
+  const installForPage = async (page) => {
+    const pageId = await resolvePageId(page);
+    wrapPageActions(page, pageId);
+    if (includeUserDomActions) {
+      await installUserDomTracking(page, pageId);
+    }
+    page.on("response", async (response) => {
+      const request = response.request();
+      const url = request.url();
+      if (STATIC_EXT_RE.test(url) || url.startsWith("chrome-extension://")) return;
+      emitNetwork({
+        pageId,
+        method: request.method(),
+        url,
+        status: response.status(),
+        contentType: response.headers()["content-type"] ?? null,
+        postData: request.method() === "POST" || request.method() === "PUT" || request.method() === "PATCH" ? (request.postData() ?? "").substring(0, 2e3) : void 0,
+        responseBody: null,
+        size: null,
+        durationMs: null
+      });
+    });
+    page.on("framenavigated", (frame) => {
+      if (frame !== page.mainFrame()) return;
+      emitAction({
+        pageId,
+        action: "navigate",
+        source: "agent",
+        url: frame.url(),
+        success: true
+      });
+    });
+    page.on("popup", (popup) => {
+      emitAction({
+        pageId,
+        action: "popup",
+        source: "agent",
+        url: popup.url(),
+        success: true
+      });
+    });
+    page.on("dialog", (dialog) => {
+      emitAction({
+        pageId,
+        action: "dialog",
+        source: "agent",
+        value: `${dialog.type()}: ${dialog.message().slice(0, 500)}`,
+        success: true
+      });
+    });
+  };
+  await installForPage(initialPage);
+  context.on("page", (newPage) => {
+    void installForPage(newPage);
+  });
+}
+export {
+  installSessionTelemetry
+};