libretto 0.1.5 → 0.2.0

package/dist/cli/core/telemetry.js

@@ -0,0 +1,350 @@
+import { appendFileSync, existsSync, readFileSync, writeFileSync } 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));
+  }
+  const last = opts.last ?? 20;
+  if (entries.length > last) {
+    entries = entries.slice(-last);
+  }
+  return entries;
+}
+function formatNetworkEntry(e) {
+  const time = e.ts.replace(/.*T/, "").replace(/\.\d+Z$/, "");
+  const duration = e.durationMs != null ? `${e.durationMs}ms` : "?ms";
+  const size = e.size != null ? `${e.size}B` : "";
+  const parts = [
+    `[${time}]`,
+    `${e.status}`,
+    `${e.method.padEnd(6)}`,
+    e.url,
+    duration,
+    size
+  ].filter(Boolean);
+  let line = parts.join(" ");
+  if (e.postData) {
+    line += `
+         body: ${e.postData.substring(0, 120)}${e.postData.length > 120 ? "..." : ""}`;
+  }
+  return line;
+}
+function clearNetworkLog(session) {
+  assertSessionStateExistsOrThrow(session);
+  const logPath = getSessionNetworkLogPath(session);
+  writeFileSync(logPath, "");
+}
+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.value || "") || re.test(e.url || "")
+    );
+  }
+  const last = opts.last ?? 20;
+  if (entries.length > last) {
+    entries = entries.slice(-last);
+  }
+  return entries;
+}
+function formatActionEntry(e) {
+  const time = e.ts.replace(/.*T/, "").replace(/\.\d+Z$/, "");
+  const src = e.source.toUpperCase().padEnd(5);
+  const parts = [`[${time}]`, `[${src}]`, e.action];
+  if (e.selector) parts.push(e.selector);
+  if (e.value) parts.push(`"${e.value}"`);
+  if (e.url) parts.push(e.url);
+  if (e.duration != null) parts.push(`${e.duration}ms`);
+  if (!e.success) parts.push(`ERROR: ${e.error || "unknown"}`);
+  return parts.join(" ");
+}
+function clearActionLog(session) {
+  assertSessionStateExistsOrThrow(session);
+  const logPath = getSessionActionsLogPath(session);
+  writeFileSync(logPath, "");
+}
+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, 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, {
+          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, {
+          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, 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, 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, onActivity);
+      });
+    };
+  }
+  return locator;
+}
+function wrapPageForActionLogging(page, session, 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, {
+          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, {
+          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, {
+          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, {
+          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, onActivity);
+    };
+  }
+}
+export {
+  clearActionLog,
+  clearNetworkLog,
+  formatActionEntry,
+  formatNetworkEntry,
+  parentLogAction,
+  readActionLog,
+  readNetworkLog,
+  wrapPageForActionLogging
+};

package/dist/cli/index.js

@@ -0,0 +1,13 @@
+import { runLibrettoCLI } from "./cli.js";
+import {
+  maybeConfigureLLMClientFactoryFromEnv,
+  setLLMClientFactory
+} from "./core/context.js";
+import { runClose } from "./commands/browser.js";
+maybeConfigureLLMClientFactoryFromEnv();
+void runLibrettoCLI();
+export {
+  runClose,
+  runLibrettoCLI,
+  setLLMClientFactory
+};

package/dist/cli/workers/run-integration-runtime.js

@@ -0,0 +1,204 @@
+import { appendFileSync, existsSync } from "node:fs";
+import { mkdir, writeFile } from "node:fs/promises";
+import { cwd } from "node:process";
+import { isAbsolute, resolve } from "node:path";
+import { pathToFileURL } from "node:url";
+import {
+  launchBrowser
+} from "../../index.js";
+import { getProfilePath, normalizeDomain } from "../core/browser.js";
+import { getSessionDir } from "../core/context.js";
+import { getPauseSignalPaths, removeSignalIfExists } from "../core/pause-signals.js";
+const LIBRETTO_WORKFLOW_BRAND = /* @__PURE__ */ Symbol.for("libretto.workflow");
+const RESUME_POLL_INTERVAL_MS = 250;
+function mirrorStdoutToFile(filePath) {
+  const stdout = process.stdout;
+  const originalWrite = stdout.write.bind(stdout);
+  stdout.write = ((chunk, ...args) => {
+    try {
+      const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(String(chunk), "utf8");
+      appendFileSync(filePath, buffer);
+    } catch {
+    }
+    return originalWrite(chunk, ...args);
+  });
+  return () => {
+    stdout.write = originalWrite;
+  };
+}
+async function waitForResumeSignal(args) {
+  const { pausedSignalPath, resumeSignalPath } = args.signalPaths;
+  await mkdir(getSessionDir(args.session), { recursive: true });
+  await removeSignalIfExists(resumeSignalPath);
+  await writeFile(
+    pausedSignalPath,
+    JSON.stringify(args.details, null, 2),
+    "utf8"
+  );
+  await args.onPaused?.(args.details);
+  while (!existsSync(resumeSignalPath)) {
+    await new Promise(
+      (resolveWait) => setTimeout(resolveWait, RESUME_POLL_INTERVAL_MS)
+    );
+  }
+  await removeSignalIfExists(resumeSignalPath);
+  await removeSignalIfExists(pausedSignalPath);
+}
+function isLoadedLibrettoWorkflow(value) {
+  if (!value || typeof value !== "object") return false;
+  const candidate = value;
+  return candidate[LIBRETTO_WORKFLOW_BRAND] === true && typeof candidate.run === "function" && !!candidate.metadata && typeof candidate.metadata === "object";
+}
+function resolveLocalAuthProfilePath(domain) {
+  return getProfilePath(normalizeDomain(domain));
+}
+function resolveWorkflowStorageStatePath(workflow) {
+  const authProfile = workflow.metadata.authProfile;
+  if (authProfile?.type !== "local") {
+    return void 0;
+  }
+  return resolveLocalAuthProfilePath(authProfile.domain);
+}
+function getMissingLocalAuthProfileError(args) {
+  const normalizedDomain = normalizeDomain(args.domain);
+  return [
+    `Local auth profile not found for domain "${normalizedDomain}".`,
+    `Expected profile file: ${args.profilePath}`,
+    "To create it:",
+    `  1. libretto-cli open https://${normalizedDomain} --headed --session ${args.session}`,
+    "  2. Log in manually in the browser window.",
+    `  3. libretto-cli save ${normalizedDomain} --session ${args.session}`
+  ].join("\n");
+}
+function getAbsoluteIntegrationPath(integrationPath) {
+  const absolutePath = isAbsolute(integrationPath) ? integrationPath : resolve(cwd(), integrationPath);
+  if (!existsSync(absolutePath)) {
+    throw new Error(`Integration file does not exist: ${absolutePath}`);
+  }
+  return absolutePath;
+}
+async function loadWorkflowExport(absolutePath, exportName) {
+  let loadedModule;
+  try {
+    loadedModule = await import(pathToFileURL(absolutePath).href);
+  } catch (error) {
+    throw new Error(
+      `Failed to import integration module at ${absolutePath}: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+  const targetExport = loadedModule[exportName];
+  if (!targetExport) {
+    const availableExports = Object.keys(loadedModule);
+    const detail = availableExports.length > 0 ? ` Available exports: ${availableExports.join(", ")}` : " The module has no exports.";
+    throw new Error(
+      `Export "${exportName}" was not found in ${absolutePath}.${detail}`
+    );
+  }
+  if (!isLoadedLibrettoWorkflow(targetExport)) {
+    throw new Error(
+      `Export "${exportName}" in ${absolutePath} must be a Libretto workflow instance. Use workflow(...) from "libretto".`
+    );
+  }
+  return targetExport;
+}
+async function runIntegrationInternal(args, options) {
+  const { logger } = options;
+  const absolutePath = getAbsoluteIntegrationPath(args.integrationPath);
+  const workflow = await loadWorkflowExport(absolutePath, args.exportName);
+  const signalPaths = getPauseSignalPaths(args.session);
+  await removeSignalIfExists(signalPaths.pausedSignalPath);
+  await removeSignalIfExists(signalPaths.resumeSignalPath);
+  await removeSignalIfExists(signalPaths.completedSignalPath);
+  await removeSignalIfExists(signalPaths.failedSignalPath);
+  await removeSignalIfExists(signalPaths.outputSignalPath);
+  const restoreStdout = mirrorStdoutToFile(signalPaths.outputSignalPath);
+  console.log(
+    `Running integration "${args.exportName}" from ${absolutePath} (${args.headless ? "headless" : "headed"})...`
+  );
+  const integrationLogger = logger.withScope("integration-run", {
+    integrationPath: absolutePath,
+    integrationExport: args.exportName,
+    session: args.session
+  });
+  const authProfile = workflow.metadata.authProfile;
+  const storageStatePath = resolveWorkflowStorageStatePath(workflow);
+  if (authProfile?.type === "local" && storageStatePath && !existsSync(storageStatePath)) {
+    throw new Error(
+      getMissingLocalAuthProfileError({
+        domain: authProfile.domain,
+        profilePath: storageStatePath,
+        session: args.session
+      })
+    );
+  }
+  const browserSession = await launchBrowser({
+    sessionName: args.session,
+    headless: args.headless,
+    storageStatePath
+  });
+  const workflowContext = {
+    logger: integrationLogger,
+    page: browserSession.page,
+    context: browserSession.context,
+    browser: browserSession.browser,
+    session: args.session,
+    integrationPath: absolutePath,
+    exportName: args.exportName,
+    headless: args.headless,
+    debug: args.debug,
+    pause: async () => {
+      const details = {
+        sessionName: args.session,
+        pausedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        url: browserSession.page.url()
+      };
+      console.log(`[pause] Paused at ${details.url}`);
+      console.log("[pause] Waiting for resume signal...");
+      await waitForResumeSignal({
+        signalPaths,
+        session: args.session,
+        details,
+        onPaused: options.onPaused
+      });
+      console.log("[pause] Resume signal received. Continuing workflow...");
+    }
+  };
+  try {
+    try {
+      await workflow.run(workflowContext, args.params ?? {});
+    } catch (error) {
+      await writeFile(
+        signalPaths.failedSignalPath,
+        JSON.stringify(
+          {
+            failedAt: (/* @__PURE__ */ new Date()).toISOString(),
+            message: error instanceof Error ? error.message : String(error)
+          },
+          null,
+          2
+        ),
+        "utf8"
+      );
+      throw error;
+    }
+    await writeFile(
+      signalPaths.completedSignalPath,
+      JSON.stringify({ completedAt: (/* @__PURE__ */ new Date()).toISOString() }, null, 2),
+      "utf8"
+    );
+    console.log("Integration completed.");
+    return { status: "completed" };
+  } finally {
+    restoreStdout();
+    await browserSession.close();
+  }
+}
+async function runIntegrationFromFileInWorker(args, logger, onPaused) {
+  return await runIntegrationInternal(args, {
+    logger,
+    onPaused
+  });
+}
+export {
+  runIntegrationFromFileInWorker
+};

package/dist/cli/workers/run-integration-worker.js

@@ -0,0 +1,83 @@
+import { writeFile } from "node:fs/promises";
+import { runIntegrationFromFileInWorker } from "./run-integration-runtime.js";
+import {
+  ensureLibrettoSetup,
+  withSessionLogger
+} from "../core/context.js";
+import { getPauseSignalPaths } from "../core/pause-signals.js";
+function sendMessage(message) {
+  if (typeof process.send !== "function" || !process.connected) return;
+  try {
+    process.send(message);
+  } catch {
+  }
+}
+function parseWorkerRequest(argv) {
+  const rawPayload = argv[2];
+  if (!rawPayload) {
+    throw new Error("Missing worker payload argument.");
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(rawPayload);
+  } catch (error) {
+    throw new Error(
+      `Invalid worker payload JSON: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+  if (!parsed || typeof parsed !== "object") {
+    throw new Error("Worker payload must be an object.");
+  }
+  const candidate = parsed;
+  if (typeof candidate.integrationPath !== "string" || typeof candidate.exportName !== "string" || typeof candidate.session !== "string" || typeof candidate.headless !== "boolean" || typeof candidate.debug !== "boolean" || !("params" in candidate)) {
+    throw new Error("Worker payload is missing required fields.");
+  }
+  return {
+    integrationPath: candidate.integrationPath,
+    exportName: candidate.exportName,
+    session: candidate.session,
+    headless: candidate.headless,
+    debug: candidate.debug,
+    params: candidate.params
+  };
+}
+async function main() {
+  let request = null;
+  let exitCode = 0;
+  try {
+    request = parseWorkerRequest(process.argv);
+    const workerRequest = request;
+    ensureLibrettoSetup();
+    await withSessionLogger(workerRequest.session, async (logger) => {
+      await runIntegrationFromFileInWorker(
+        workerRequest,
+        logger,
+        async (details) => {
+          sendMessage({ type: "paused", details });
+        }
+      );
+    });
+    sendMessage({ type: "completed" });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    if (request) {
+      const { failedSignalPath } = getPauseSignalPaths(request.session);
+      await writeFile(
+        failedSignalPath,
+        JSON.stringify(
+          {
+            failedAt: (/* @__PURE__ */ new Date()).toISOString(),
+            message
+          },
+          null,
+          2
+        ),
+        "utf8"
+      );
+    }
+    sendMessage({ type: "failed", message });
+    exitCode = 1;
+  }
+  process.exit(exitCode);
+}
+void main();