libretto 0.2.6 → 0.3.0

package/dist/cli/core/telemetry.js

@@ -1,362 +0,0 @@
-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));
-  }
-  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 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 || "")
-    );
-  }
-  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 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, 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 {
-  clearActionLog,
-  clearNetworkLog,
-  formatActionEntry,
-  formatNetworkEntry,
-  parentLogAction,
-  readActionLog,
-  readNetworkLog,
-  wrapPageForActionLogging
-};

package/dist/cli/index.js

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

@@ -1,227 +0,0 @@
-import { appendFileSync, existsSync, readFileSync } from "node:fs";
-import { 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 { setSessionForPause } from "../../shared/debug/pause.js";
-import { parseSessionStateContent } from "../../shared/state/index.js";
-import { getProfilePath, normalizeDomain } from "../core/browser.js";
-import {
-  getSessionActionsLogPath,
-  getSessionNetworkLogPath,
-  getSessionStatePath
-} from "../core/context.js";
-import { getPauseSignalPaths, removeSignalIfExists } from "../core/pause-signals.js";
-import { installSessionTelemetry } from "../core/session-telemetry.js";
-const LIBRETTO_WORKFLOW_BRAND = /* @__PURE__ */ Symbol.for("libretto.workflow");
-const FAILURE_HOLD_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;
-  };
-}
-function readSessionStatePid(session) {
-  const statePath = getSessionStatePath(session);
-  if (!existsSync(statePath)) return null;
-  try {
-    return parseSessionStateContent(readFileSync(statePath, "utf8"), statePath).pid;
-  } catch {
-    return null;
-  }
-}
-async function waitForFailureSessionRelease(args) {
-  const { session, expectedPid, logger } = args;
-  logger.info("run-failure-session-hold", { session, expectedPid });
-  while (true) {
-    const currentPid = readSessionStatePid(session);
-    if (currentPid !== expectedPid) {
-      logger.info("run-failure-session-released", {
-        session,
-        expectedPid,
-        currentPid
-      });
-      return;
-    }
-    await new Promise(
-      (resolveWait) => setTimeout(resolveWait, FAILURE_HOLD_POLL_INTERVAL_MS)
-    );
-  }
-}
-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 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} is not a valid Libretto workflow.`,
-        "",
-        'A workflow must be created using the workflow() function from "libretto":',
-        "",
-        '  import { workflow } from "libretto";',
-        "",
-        `  export const ${exportName} = workflow<InputType, OutputType>(`,
-        "    {},",
-        "    async (ctx, input) => {",
-        "      // ctx.page     \u2014 Playwright Page instance",
-        "      // ctx.logger   \u2014 MinimalLogger",
-        "      // ctx.services \u2014 injected dependencies (generic, default {})",
-        "      // input        \u2014 JSON-serializable input matching InputType",
-        "      return output; // must match OutputType",
-        "    },",
-        "  );"
-      ].join("\n")
-    );
-  }
-  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 authProfileDomain = args.authProfileDomain;
-  const storageStatePath = authProfileDomain ? resolveLocalAuthProfilePath(authProfileDomain) : void 0;
-  if (authProfileDomain && storageStatePath && !existsSync(storageStatePath)) {
-    throw new Error(
-      getMissingLocalAuthProfileError({
-        domain: authProfileDomain,
-        profilePath: storageStatePath,
-        session: args.session
-      })
-    );
-  }
-  const browserSession = await launchBrowser({
-    sessionName: args.session,
-    headless: args.headless,
-    storageStatePath
-  });
-  const actionsLogPath = getSessionActionsLogPath(args.session);
-  const networkLogPath = getSessionNetworkLogPath(args.session);
-  await installSessionTelemetry({
-    context: browserSession.context,
-    initialPage: browserSession.page,
-    includeUserDomActions: true,
-    logAction: (entry) => {
-      appendFileSync(actionsLogPath, JSON.stringify(entry) + "\n");
-    },
-    logNetwork: (entry) => {
-      appendFileSync(networkLogPath, JSON.stringify(entry) + "\n");
-    }
-  });
-  setSessionForPause(args.session);
-  const workflowContext = {
-    logger: integrationLogger,
-    page: browserSession.page,
-    services: {}
-  };
-  try {
-    try {
-      await workflow.run(workflowContext, args.params ?? {});
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : String(error);
-      await writeFile(
-        signalPaths.failedSignalPath,
-        JSON.stringify(
-          {
-            failedAt: (/* @__PURE__ */ new Date()).toISOString(),
-            message: errorMessage
-          },
-          null,
-          2
-        ),
-        "utf8"
-      );
-      await waitForFailureSessionRelease({
-        session: args.session,
-        expectedPid: process.pid,
-        logger
-      });
-      return { status: "failed-held" };
-    }
-    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) {
-  return await runIntegrationInternal(args, {
-    logger
-  });
-}
-export {
-  runIntegrationFromFileInWorker
-};

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

@@ -1,12 +0,0 @@
-import { z } from "zod";
-const RunIntegrationWorkerRequestSchema = z.object({
-  integrationPath: z.string().min(1),
-  exportName: z.string().min(1),
-  session: z.string().min(1),
-  params: z.unknown(),
-  headless: z.boolean(),
-  authProfileDomain: z.string().optional()
-});
-export {
-  RunIntegrationWorkerRequestSchema
-};

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

@@ -1,66 +0,0 @@
-import { writeFile } from "node:fs/promises";
-import { ZodError } from "zod";
-import {
-  RunIntegrationWorkerRequestSchema
-} from "./run-integration-worker-protocol.js";
-import { runIntegrationFromFileInWorker } from "./run-integration-runtime.js";
-import {
-  ensureLibrettoSetup,
-  withSessionLogger
-} from "../core/context.js";
-import { getPauseSignalPaths } from "../core/pause-signals.js";
-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)}`
-    );
-  }
-  try {
-    return RunIntegrationWorkerRequestSchema.parse(parsed);
-  } catch (error) {
-    if (error instanceof ZodError) {
-      const details = error.issues.map((issue) => `${issue.path.join(".") || "root"}: ${issue.message}`).join("; ");
-      throw new Error(`Worker payload is invalid: ${details}`);
-    }
-    throw error;
-  }
-}
-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);
-    });
-  } 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"
-      );
-    }
-    exitCode = 1;
-  }
-  process.exit(exitCode);
-}
-void main();