libretto 0.6.24 → 0.6.26

package/dist/cli/core/profiles.js

@@ -0,0 +1,47 @@
+import { existsSync, readFileSync } from "node:fs";
+import { mkdir, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { PROFILES_DIR } from "./context.js";
+import { normalizeProfileName } from "../../shared/workflow/auth-profile-name.js";
+import { normalizeProfileName as normalizeProfileName2 } from "../../shared/workflow/auth-profile-name.js";
+function getProfilePath(profileName) {
+  return join(PROFILES_DIR, `${normalizeProfileName(profileName)}.json`);
+}
+function hasProfile(profileName) {
+  return existsSync(getProfilePath(profileName));
+}
+function readProfile(profileName) {
+  const profilePath = getProfilePath(profileName);
+  const parsed = JSON.parse(readFileSync(profilePath, "utf8"));
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new Error(`Saved auth profile "${profileName}" is not a JSON object.`);
+  }
+  return parsed;
+}
+async function writeProfile(profileName, profile) {
+  const profilePath = getProfilePath(profileName);
+  await mkdir(dirname(profilePath), { recursive: true });
+  await writeFile(profilePath, JSON.stringify(profile, null, 2), "utf8");
+  return profilePath;
+}
+function formatMissingLocalAuthProfileMessage(args) {
+  return [
+    `Local auth profile not found: "${args.profileName}".`,
+    `Expected profile file: ${args.profilePath}`,
+    "To create it locally:",
+    `  1. libretto open <site-url> --headed --session ${args.session}`,
+    "  2. Log in manually in the browser window.",
+    `  3. libretto save ${args.profileName} --session ${args.session} --sites <site>`,
+    "Or import site-scoped state from Chrome with:",
+    `  libretto import-chrome-profiles ${args.profileName} --cdp-url <url> --sites <site>`,
+    "Local profile files are not uploaded to cloud profiles."
+  ].join("\n");
+}
+export {
+  formatMissingLocalAuthProfileMessage,
+  getProfilePath,
+  hasProfile,
+  normalizeProfileName2 as normalizeProfileName,
+  readProfile,
+  writeProfile
+};

package/dist/cli/core/prompt.js

@@ -13,6 +13,14 @@ async function prompt(question, opts = {}) {
     rl.close();
   }
 }
+async function promptConfirm(question, opts = {}) {
+  const defaultValue = opts.defaultValue ?? false;
+  if (!stdin.isTTY) return defaultValue;
+  const suffix = defaultValue ? "[Y/n]" : "[y/N]";
+  const answer = (await prompt(`${question} ${suffix}`)).trim().toLowerCase();
+  if (answer.length === 0) return defaultValue;
+  return answer === "y" || answer === "yes";
+}
 const CTRL_C = "";
 const CR = "\r";
 const LF = "\n";
@@ -67,6 +75,7 @@ function slugify(name) {
 }
 export {
   prompt,
+  promptConfirm,
   promptPassword,
   slugify
 };

package/dist/cli/core/providers/libretto-cloud.js

@@ -10,7 +10,7 @@ function createLibrettoCloudProvider() {
     );
   const endpoint = resolveHostedApiUrl();
   return {
-    async createSession() {
+    async createSession(options) {
       const browserSessionTimeoutSeconds = readPositiveNumberEnv(
         "LIBRETTO_TIMEOUT_SECONDS",
         DEFAULT_BROWSER_SESSION_TIMEOUT_SECONDS
@@ -22,7 +22,11 @@ function createLibrettoCloudProvider() {
           "Content-Type": "application/json"
         },
         body: JSON.stringify({
-          json: { timeout_seconds: browserSessionTimeoutSeconds }
+          json: {
+            timeout_seconds: browserSessionTimeoutSeconds,
+            profile_name: options?.authProfileName,
+            profile_persist: options?.authProfilePersist
+          }
         })
       });
       if (!resp.ok) {

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

@@ -0,0 +1,325 @@
+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;
+}
+function parentLogAction(session, entry) {
+  try {
+    const record = { ts: (/* @__PURE__ */ new Date()).toISOString(), ...entry };
+    appendFileSync(
+      getSessionActionsLogPath(session),
+      JSON.stringify(record) + "\n"
+    );
+  } catch {
+  }
+}
+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)
+  );
+  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})`;
+}
+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;
+}
+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);
+    };
+  }
+}
+export {
+  parentLogAction,
+  readActionLog,
+  readNetworkLog,
+  wrapPageForActionLogging
+};