libretto 0.6.11 → 0.6.13

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

@@ -1,235 +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 {
-  getDefaultWorkflowFromModuleExports,
-  getWorkflowsFromModuleExports,
-  instrumentContext,
-  launchBrowser
-} from "../../index.js";
-import { parseSessionStateContent } from "../../shared/state/index.js";
-import {
-  getProfilePath,
-  normalizeDomain,
-  normalizeUrl
-} 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 FAILURE_HOLD_POLL_INTERVAL_MS = 250;
-const TSCONFIG_HINT = "TypeScript compilation failed. Pass --tsconfig <path> to run against a specific tsconfig.";
-function isTsxCompileError(error) {
-  return error instanceof Error && (error.name === "TransformError" || error.message.startsWith("Cannot resolve tsconfig at path:"));
-}
-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 ?? null;
-  } 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 getMissingLocalAuthProfileError(args) {
-  return [
-    `Local auth profile not found for domain "${args.normalizedDomain}".`,
-    `Expected profile file: ${args.profilePath}`,
-    "To create it:",
-    `  1. libretto open https://${args.normalizedDomain} --headed --session ${args.session}`,
-    "  2. Log in manually in the browser window.",
-    `  3. libretto save ${args.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 loadDefaultWorkflow(absolutePath) {
-  let loadedModule;
-  try {
-    loadedModule = await import(pathToFileURL(absolutePath).href);
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    const compileHint = isTsxCompileError(error) ? `
-${TSCONFIG_HINT}` : "";
-    throw new Error(
-      `Failed to import integration module at ${absolutePath}: ${message}${compileHint}`
-    );
-  }
-  const defaultWorkflow = getDefaultWorkflowFromModuleExports(loadedModule);
-  if (defaultWorkflow) {
-    return defaultWorkflow;
-  }
-  const availableWorkflowNames = getWorkflowsFromModuleExports(loadedModule).map(
-    (candidate) => candidate.name
-  );
-  if (availableWorkflowNames.length === 0) {
-    throw new Error(
-      `No default-exported workflow found in ${absolutePath}. Export the workflow with \`export default workflow("name", handler)\`.`
-    );
-  }
-  throw new Error(
-    `No default-exported workflow found in ${absolutePath}. libretto run only uses the file's default export. Available named workflows: ${availableWorkflowNames.join(", ")}`
-  );
-}
-async function installHeadedWorkflowVisualization(args) {
-  await (args.instrument ?? instrumentContext)(args.context, {
-    visualize: true,
-    logger: args.logger
-  });
-}
-async function runIntegrationInternal(args, options) {
-  const { logger } = options;
-  const absolutePath = getAbsoluteIntegrationPath(args.integrationPath);
-  const workflow = await loadDefaultWorkflow(absolutePath);
-  const signalPaths = getPauseSignalPaths(args.session);
-  await removeSignalIfExists(signalPaths.pausedSignalPath);
-  await removeSignalIfExists(signalPaths.resumeSignalPath);
-  await removeSignalIfExists(signalPaths.completedSignalPath);
-  await removeSignalIfExists(signalPaths.failedSignalPath);
-  const restoreStdout = mirrorStdoutToFile(signalPaths.outputSignalPath);
-  console.log(
-    `Running workflow "${workflow.name}" from ${absolutePath} (${args.headless ? "headless" : "headed"})...`
-  );
-  const integrationLogger = logger.withScope("integration-run", {
-    integrationPath: absolutePath,
-    workflowName: workflow.name,
-    session: args.session
-  });
-  const authProfileDomain = args.authProfileDomain;
-  const normalizedAuthProfileDomain = authProfileDomain ? normalizeDomain(normalizeUrl(authProfileDomain)) : void 0;
-  const storageStatePath = normalizedAuthProfileDomain ? getProfilePath(normalizedAuthProfileDomain) : void 0;
-  if (normalizedAuthProfileDomain && storageStatePath && !existsSync(storageStatePath)) {
-    throw new Error(
-      getMissingLocalAuthProfileError({
-        normalizedDomain: normalizedAuthProfileDomain,
-        profilePath: storageStatePath,
-        session: args.session
-      })
-    );
-  }
-  const browserSession = await launchBrowser({
-    sessionName: args.session,
-    headless: args.headless,
-    storageStatePath,
-    viewport: args.viewport,
-    accessMode: args.accessMode,
-    cdpEndpoint: args.cdpEndpoint,
-    provider: args.provider
-  });
-  if (!args.headless && args.visualize !== false) {
-    await installHeadedWorkflowVisualization({
-      context: browserSession.context,
-      logger: integrationLogger
-    });
-  }
-  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");
-    }
-  });
-  await browserSession.context.addInitScript(() => {
-    globalThis.__name = (target, value) => Object.defineProperty(target, "name", { value, configurable: true });
-  });
-  const workflowContext = {
-    session: args.session,
-    page: browserSession.page
-  };
-  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,
-            phase: "workflow"
-          },
-          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"
-    );
-    return { status: "completed" };
-  } finally {
-    restoreStdout();
-    await browserSession.close();
-  }
-}
-async function runIntegrationFromFileInWorker(args, logger) {
-  return await runIntegrationInternal(args, {
-    logger
-  });
-}
-export {
-  installHeadedWorkflowVisualization,
-  runIntegrationFromFileInWorker
-};

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

@@ -1,17 +0,0 @@
-import { z } from "zod";
-import { SessionAccessModeSchema } from "../../shared/state/index.js";
-const RunIntegrationWorkerRequestSchema = z.object({
-  integrationPath: z.string().min(1),
-  session: z.string().min(1),
-  params: z.unknown(),
-  headless: z.boolean(),
-  visualize: z.boolean().default(true),
-  authProfileDomain: z.string().optional(),
-  viewport: z.object({ width: z.number(), height: z.number() }).optional(),
-  accessMode: SessionAccessModeSchema.default("write-access"),
-  cdpEndpoint: z.string().optional(),
-  provider: z.object({ name: z.string(), sessionId: z.string() }).optional()
-});
-export {
-  RunIntegrationWorkerRequestSchema
-};

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

@@ -1,64 +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,
-            phase: "setup"
-          },
-          null,
-          2
-        ),
-        "utf8"
-      );
-    }
-    exitCode = 1;
-  }
-  process.exit(exitCode);
-}
-void main();

package/scripts/summarize-evals.mjs

@@ -1,135 +0,0 @@
-#!/usr/bin/env node
-
-import { readdirSync, readFileSync, writeFileSync } from "node:fs";
-import { basename, join, resolve } from "node:path";
-import { fileURLToPath } from "node:url";
-
-function usage() {
-  console.error(
-    "Usage: node scripts/summarize-evals.mjs <score-dir> <summary-json-path>",
-  );
-}
-
-function normalizeFailureRecord(failure) {
-  return {
-    criterion: String(failure?.criterion ?? "").trim(),
-    reason: String(failure?.reason ?? "").trim(),
-  };
-}
-
-function normalizeRecord(record) {
-  const failures = Array.isArray(record?.failures)
-    ? record.failures
-        .map(normalizeFailureRecord)
-        .filter(
-          (failure) =>
-            failure.criterion.length > 0 && failure.reason.length > 0,
-        )
-    : [];
-
-  return {
-    name: String(record?.name ?? "").trim(),
-    passed: Number(record?.passed ?? 0),
-    total: Number(record?.total ?? 0),
-    percent: Number(record?.percent ?? 0),
-    failures,
-  };
-}
-
-export function loadScoreRecords(scoreDirArg) {
-  const scoreDir = resolve(scoreDirArg);
-  return readdirSync(scoreDir, { withFileTypes: true })
-    .filter((entry) => entry.isFile() && entry.name.endsWith(".json"))
-    .map((entry) =>
-      JSON.parse(readFileSync(join(scoreDir, entry.name), "utf8")),
-    )
-    .map(normalizeRecord)
-    .sort((a, b) => String(a.name).localeCompare(String(b.name)));
-}
-
-export function buildSummary(records) {
-  const passed = records.reduce(
-    (sum, record) => sum + Number(record.passed || 0),
-    0,
-  );
-  const total = records.reduce(
-    (sum, record) => sum + Number(record.total || 0),
-    0,
-  );
-  const percent = total > 0 ? Number(((passed / total) * 100).toFixed(2)) : 0;
-  const failingRecords = records.filter((record) => record.failures.length > 0);
-
-  return {
-    generatedAt: new Date().toISOString(),
-    recordCount: records.length,
-    passed,
-    total,
-    percent,
-    failingRecordCount: failingRecords.length,
-    records,
-  };
-}
-
-export function buildMarkdown(summary, summaryPathArg) {
-  const lines = [
-    "# Eval Summary",
-    "",
-    `- Overall score: \`${summary.percent}%\``,
-    `- Passed criteria: \`${summary.passed}/${summary.total}\``,
-    `- Recorded score entries: \`${summary.recordCount}\``,
-    `- Failed evals: \`${summary.failingRecordCount}\``,
-    `- Summary file: \`${basename(summaryPathArg)}\``,
-  ];
-
-  if (summary.records.length > 0) {
-    lines.push("", "## Breakdown", "");
-    for (const record of summary.records) {
-      const status = record.failures.length > 0 ? "fail" : "pass";
-      lines.push(
-        `- ${status} \`${record.name}\`: \`${record.percent}%\` (${record.passed}/${record.total})`,
-      );
-    }
-  }
-
-  if (summary.failingRecordCount > 0) {
-    lines.push("", "## Failed Evals", "");
-    for (const record of summary.records.filter(
-      (candidate) => candidate.failures.length > 0,
-    )) {
-      lines.push(`### \`${record.name}\``);
-      lines.push("");
-      lines.push(
-        `- Score: \`${record.percent}%\` (${record.passed}/${record.total})`,
-      );
-      for (const failure of record.failures) {
-        lines.push(`- ${failure.criterion}: ${failure.reason}`);
-      }
-      lines.push("");
-    }
-  }
-
-  return `${lines.join("\n").trimEnd()}\n`;
-}
-
-function main(argv) {
-  const [, , scoreDirArg, summaryPathArg] = argv;
-
-  if (!scoreDirArg || !summaryPathArg) {
-    usage();
-    process.exit(1);
-  }
-
-  const summaryPath = resolve(summaryPathArg);
-  const records = loadScoreRecords(scoreDirArg);
-  const summary = buildSummary(records);
-
-  writeFileSync(summaryPath, `${JSON.stringify(summary, null, 2)}\n`, "utf8");
-  process.stdout.write(buildMarkdown(summary, summaryPath));
-}
-
-if (
-  process.argv[1] &&
-  resolve(process.argv[1]) === fileURLToPath(import.meta.url)
-) {
-  main(process.argv);
-}

package/src/cli/commands/ai.ts

@@ -1,143 +0,0 @@
-import { z } from "zod";
-import {
-  CURRENT_CONFIG_VERSION,
-  readSnapshotModel,
-  writeSnapshotModel,
-  clearSnapshotModel,
-} from "../core/config.js";
-import { LIBRETTO_CONFIG_PATH } from "../core/context.js";
-import { DEFAULT_SNAPSHOT_MODELS } from "../core/ai-model.js";
-import { SimpleCLI } from "../framework/simple-cli.js";
-
-const PROVIDER_ALIASES: Record<string, string> = {
-  claude: DEFAULT_SNAPSHOT_MODELS.anthropic,
-  gemini: DEFAULT_SNAPSHOT_MODELS.google,
-  google: DEFAULT_SNAPSHOT_MODELS.google,
-};
-
-const CONFIGURE_PROVIDERS = [
-  "openai",
-  "anthropic",
-  "gemini",
-  "vertex",
-] as const;
-
-function formatConfigureProviders(separator = " | "): string {
-  return CONFIGURE_PROVIDERS.join(separator);
-}
-
-function printSnapshotModelConfig(model: string, configPath: string): void {
-  console.log(`Snapshot model: ${model}`);
-  console.log(`Config file: ${configPath}`);
-}
-
-/**
- * Resolve the model string from a `ai configure` argument.
- * Accepts a provider shorthand ("openai", "anthropic", "gemini", "vertex")
- * or a full provider/model-id string ("openai/gpt-4o", "anthropic/claude-sonnet-4-6").
- */
-function resolveModelFromInput(input: string): string | null {
-  const trimmed = input.trim();
-  if (!trimmed) return null;
-
-  // Full model string (contains a slash)
-  if (trimmed.includes("/")) return trimmed;
-
-  // Provider shorthand
-  const normalized = trimmed.toLowerCase();
-  return (
-    (DEFAULT_SNAPSHOT_MODELS as Record<string, string>)[normalized] ??
-    PROVIDER_ALIASES[normalized] ??
-    null
-  );
-}
-
-export function runAiConfigure(
-  input: {
-    preset?: string;
-    clear?: boolean;
-  },
-  options: {
-    configureCommandName?: string;
-    configPath?: string;
-  } = {},
-): void {
-  const configureCommandName =
-    options.configureCommandName ?? "npx libretto ai configure";
-  const configPath = options.configPath ?? LIBRETTO_CONFIG_PATH;
-
-  const presetArg = input.preset?.trim();
-
-  if (!presetArg && !input.clear) {
-    const model = readSnapshotModel(configPath);
-    if (!model) {
-      console.log(
-        `No snapshot model set. Choose a default model: ${configureCommandName} ${formatConfigureProviders()}`,
-      );
-      console.log(
-        "Provider credentials still come from your shell or .env file.",
-      );
-      return;
-    }
-    printSnapshotModelConfig(model, configPath);
-    return;
-  }
-
-  if (input.clear) {
-    const removed = clearSnapshotModel(configPath);
-    if (removed) {
-      console.log(`Cleared snapshot model config: ${configPath}`);
-    } else {
-      console.log("No snapshot model was set.");
-    }
-    return;
-  }
-
-  const model = resolveModelFromInput(presetArg!);
-  if (!model) {
-    console.log(
-      `Usage: ${configureCommandName} <${CONFIGURE_PROVIDERS.join("|")}|provider/model-id>\n` +
-        `       ${configureCommandName}\n` +
-        `       ${configureCommandName} --clear`,
-    );
-    throw new Error(
-      `Invalid provider or model. Use one of: ${formatConfigureProviders()}, or a full model string like "openai/gpt-4o".`,
-    );
-  }
-
-  writeSnapshotModel(model, configPath);
-  console.log("Snapshot model saved.");
-  printSnapshotModelConfig(model, configPath);
-}
-
-export const aiConfigureInput = SimpleCLI.input({
-  positionals: [
-    SimpleCLI.positional("preset", z.string().optional(), {
-      help: "Provider shorthand or provider/model-id",
-    }),
-  ],
-  named: {
-    clear: SimpleCLI.flag({ help: "Clear existing AI config" }),
-  },
-});
-
-export const aiCommands = SimpleCLI.group({
-  description: "AI commands",
-  routes: {
-    configure: SimpleCLI.command({
-      description: "Configure AI runtime",
-    })
-      .input(aiConfigureInput)
-      .handle(async ({ input }) => {
-        runAiConfigure(
-          {
-            clear: input.clear,
-            preset: input.preset,
-          },
-          {
-            configureCommandName: `libretto ai configure`,
-          },
-        );
-      }),
-  },
-});