libretto 0.2.6 → 0.3.0

package/dist/cli/core/context.js

@@ -1,118 +0,0 @@
-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 } from "node:path";
-import { validateSessionName } from "./session.js";
-function getRepoRoot() {
-  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");
-  }
-  const agentsSkillsDir = join(REPO_ROOT, ".agents", "skills", "libretto");
-  const claudeSkillsDir = join(REPO_ROOT, ".claude", "skills", "libretto");
-  if (!existsSync(agentsSkillsDir) && !existsSync(claudeSkillsDir)) {
-    console.log("[libretto] Skills not installed. Run 'npx libretto init' to complete setup.");
-  }
-}
-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

@@ -1,29 +0,0 @@
-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

@@ -1,491 +0,0 @@
-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
-};