libretto 0.5.4 → 0.5.6

package/dist/cli/commands/execution.js

@@ -13,15 +13,19 @@ import { parseViewportArg } from "./browser.js";
 import { getPauseSignalPaths } from "../core/pause-signals.js";
 import {
   assertSessionAvailableForStart,
+  assertSessionAllowsCommand,
   clearSessionState,
   readSessionState,
   setSessionStatus
 } from "../core/session.js";
+import { warnIfInstalledSkillOutOfDate } from "../core/skill-version.js";
 import {
   readActionLog,
   readNetworkLog,
   wrapPageForActionLogging
 } from "../core/telemetry.js";
+import { readLibrettoConfig } from "../core/config.js";
+import { createReadonlyExecHelpers } from "../core/readonly-exec.js";
 import { SimpleCLI } from "../framework/simple-cli.js";
 import {
   pageOption,
@@ -135,12 +139,15 @@ function stripEmptyCatchHandlers(code) {
   }
   return { cleaned: result, strippedCount };
 }
-async function runExec(code, session, logger, visualize = false, pageId) {
+async function runExec(code, session, logger, options = {}) {
+  const visualize = options.visualize ?? false;
+  const pageId = options.pageId;
+  const mode = options.mode ?? "exec";
   const { cleaned: cleanedCode, strippedCount } = stripEmptyCatchHandlers(code);
   if (strippedCount > 0) {
     console.log("(Stripped `.catch(() => {})` \u2014 letting errors bubble up)");
   }
-  logger.info("exec-start", {
+  logger.info(`${mode}-start`, {
     session,
     codeLength: cleanedCode.length,
     codePreview: cleanedCode.slice(0, 200),
@@ -164,57 +171,61 @@ async function runExec(code, session, logger, visualize = false, pageId) {
   const stallInterval = setInterval(() => {
     const silenceMs = Date.now() - lastActivityTs;
     if (silenceMs >= STALL_THRESHOLD_MS) {
-      logger.warn("exec-stall-warning", {
+      logger.warn(`${mode}-stall-warning`, {
         session,
         silenceMs,
         codePreview: cleanedCode.slice(0, 200)
       });
       console.warn(
-        `[stall-warning] No Playwright activity for ${Math.round(silenceMs / 1e3)}s \u2014 exec may be hung (code: ${cleanedCode.slice(0, 100)}...)`
+        `[stall-warning] No Playwright activity for ${Math.round(silenceMs / 1e3)}s \u2014 ${mode} may be hung (code: ${cleanedCode.slice(0, 100)}...)`
       );
     }
   }, STALL_THRESHOLD_MS);
   const execStartTs = Date.now();
   const sigintHandler = () => {
-    logger.info("exec-interrupted", {
+    logger.info(`${mode}-interrupted`, {
       session,
       duration: Date.now() - execStartTs,
       codePreview: cleanedCode.slice(0, 200)
     });
   };
   process.on("SIGINT", sigintHandler);
-  wrapPageForActionLogging(page, session, resolvedPageId, onActivity);
-  if (visualize) {
+  if (mode === "exec") {
+    wrapPageForActionLogging(page, session, resolvedPageId, onActivity);
+  }
+  if (visualize && mode === "exec") {
     await installInstrumentation(page, { visualize: true, logger });
   }
   try {
-    const execState = {};
-    const networkLog = (opts = {}) => {
-      return readNetworkLog(session, opts);
-    };
-    const actionLog = (opts = {}) => {
-      return readActionLog(session, opts);
-    };
-    const helpers = {
-      page,
-      context,
-      state: execState,
-      browser,
-      networkLog,
-      actionLog,
-      console,
-      setTimeout,
-      setInterval,
-      clearTimeout,
-      clearInterval,
-      fetch,
-      URL,
-      Buffer
-    };
+    const helpers = mode === "readonly-exec" ? createReadonlyExecHelpers(page, { onActivity }) : (() => {
+      const execState = {};
+      const networkLog = (opts = {}) => {
+        return readNetworkLog(session, opts);
+      };
+      const actionLog = (opts = {}) => {
+        return readActionLog(session, opts);
+      };
+      return {
+        page,
+        context,
+        state: execState,
+        browser,
+        networkLog,
+        actionLog,
+        console,
+        setTimeout,
+        setInterval,
+        clearTimeout,
+        clearInterval,
+        fetch,
+        URL,
+        Buffer
+      };
+    })();
     const helperNames = Object.keys(helpers);
     const fn = compileExecFunction(cleanedCode, helperNames);
     const result = await fn(...Object.values(helpers));
-    logger.info("exec-success", { session, hasResult: result !== void 0 });
+    logger.info(`${mode}-success`, { session, hasResult: result !== void 0 });
     if (result !== void 0) {
       console.log(
         typeof result === "string" ? result : JSON.stringify(result, null, 2)
@@ -223,7 +234,7 @@ async function runExec(code, session, logger, visualize = false, pageId) {
       console.log("Executed successfully");
     }
   } catch (err) {
-    logger.error("exec-error", {
+    logger.error(`${mode}-error`, {
       error: err,
       session,
       codePreview: cleanedCode.slice(0, 200)
@@ -445,13 +456,13 @@ async function runIntegrationFromFile(args, logger) {
   );
   const payload = JSON.stringify({
     integrationPath: args.integrationPath,
-    workflowName: args.workflowName,
     session: args.session,
     params: args.params,
     headless: args.headless,
     visualize: args.visualize,
     authProfileDomain: args.authProfileDomain,
-    viewport: args.viewport
+    viewport: args.viewport,
+    accessMode: args.accessMode
   });
   const worker = spawn(
     process.execPath,
@@ -526,6 +537,7 @@ const execInput = SimpleCLI.input({
 const execCommand = SimpleCLI.command({
   description: "Execute Playwright TypeScript code"
 }).input(execInput).use(withRequiredSession()).handle(async ({ input, ctx }) => {
+  assertSessionAllowsCommand(ctx.sessionState, "exec", ["write-access"]);
   const code = input.code;
   const codeFromArgsOrStdin = code === "-" ? readStdinSync() : code;
   if (codeFromArgsOrStdin === null) {
@@ -537,18 +549,48 @@ const execCommand = SimpleCLI.command({
     codeFromArgsOrStdin,
     ctx.session,
     ctx.logger,
-    input.visualize,
-    input.page
+    {
+      visualize: input.visualize,
+      pageId: input.page,
+      mode: "exec"
+    }
   );
 });
-const runUsage = `Usage: libretto run <integrationFile> <workflowName> [--params <json> | --params-file <path>] [--tsconfig <path>] [--headed|--headless] [--no-visualize] [--viewport WxH]`;
+const readonlyExecInput = SimpleCLI.input({
+  positionals: [
+    SimpleCLI.positional("code", z.string().optional(), {
+      help: "Read-only Playwright TypeScript code to execute"
+    })
+  ],
+  named: {
+    session: sessionOption(),
+    page: pageOption()
+  }
+}).refine(
+  (input) => input.code !== void 0,
+  `Usage: libretto readonly-exec <code|-> [--session <name>] [--page <id>]
+       echo '<code>' | libretto readonly-exec - [--session <name>] [--page <id>]`
+);
+const readonlyExecCommand = SimpleCLI.command({
+  description: "Execute read-only Playwright inspection code"
+}).input(readonlyExecInput).use(withRequiredSession()).handle(async ({ input, ctx }) => {
+  const code = input.code;
+  const codeFromArgsOrStdin = code === "-" ? readStdinSync() : code;
+  if (codeFromArgsOrStdin === null) {
+    throw new Error(
+      "Missing stdin input for `readonly-exec -`. Pipe inspection code into stdin."
+    );
+  }
+  await runExec(codeFromArgsOrStdin, ctx.session, ctx.logger, {
+    pageId: input.page,
+    mode: "readonly-exec"
+  });
+});
+const runUsage = `Usage: libretto run <integrationFile> [--params <json> | --params-file <path>] [--tsconfig <path>] [--headed|--headless] [--read-only|--write-access] [--no-visualize] [--viewport WxH]`;
 const runInput = SimpleCLI.input({
   positionals: [
     SimpleCLI.positional("integrationFile", z.string().optional(), {
       help: "Path to the integration file"
-    }),
-    SimpleCLI.positional("workflowName", z.string().optional(), {
-      help: "Workflow name to run (from workflow(name, handler))"
     })
   ],
   named: {
@@ -565,6 +607,14 @@ const runInput = SimpleCLI.input({
     }),
     headed: SimpleCLI.flag({ help: "Run in headed mode" }),
     headless: SimpleCLI.flag({ help: "Run in headless mode" }),
+    readOnly: SimpleCLI.flag({
+      name: "read-only",
+      help: "Create the session in read-only mode"
+    }),
+    writeAccess: SimpleCLI.flag({
+      name: "write-access",
+      help: "Create the session in write-access mode (overrides config default)"
+    }),
     noVisualize: SimpleCLI.flag({
       name: "no-visualize",
       help: "Disable ghost cursor + highlight visualization in headed mode"
@@ -578,7 +628,7 @@ const runInput = SimpleCLI.input({
     })
   }
 }).refine(
-  (input) => Boolean(input.integrationFile && input.workflowName),
+  (input) => Boolean(input.integrationFile),
   runUsage
 ).refine(
   (input) => !(input.params && input.paramsFile),
@@ -586,6 +636,9 @@ const runInput = SimpleCLI.input({
 ).refine(
   (input) => !(input.headed && input.headless),
   "Cannot pass both --headed and --headless."
+).refine(
+  (input) => !(input.readOnly && input.writeAccess),
+  "Cannot pass both --read-only and --write-access."
 );
 function resolveRunParams(rawInlineParams, paramsFile) {
   if (paramsFile) {
@@ -605,8 +658,9 @@ function resolveRunParams(rawInlineParams, paramsFile) {
   return {};
 }
 const runCommand = SimpleCLI.command({
-  description: "Run an exported Libretto workflow from a file"
+  description: "Run the default-exported Libretto workflow from a file"
 }).input(runInput).use(withAutoSession()).handle(async ({ input, ctx }) => {
+  warnIfInstalledSkillOutOfDate();
   await stopExistingFailedRunSession(ctx.session, ctx.logger);
   assertSessionAvailableForStart(ctx.session, ctx.logger);
   const params = resolveRunParams(input.params, input.paramsFile);
@@ -619,14 +673,14 @@ const runCommand = SimpleCLI.command({
   await runIntegrationFromFile(
     {
       integrationPath: input.integrationFile,
-      workflowName: input.workflowName,
       session: ctx.session,
       params,
       tsconfigPath: input.tsconfig,
       headless: headlessMode ?? false,
       visualize,
       authProfileDomain: input.authProfile,
-      viewport
+      viewport,
+      accessMode: input.readOnly ? "read-only" : input.writeAccess ? "write-access" : readLibrettoConfig().sessionMode ?? "write-access"
     },
     ctx.logger
   );
@@ -644,6 +698,7 @@ const resumeCommand = SimpleCLI.command({
 });
 const executionCommands = {
   exec: execCommand,
+  "readonly-exec": readonlyExecCommand,
   run: runCommand,
   resume: resumeCommand
 };
@@ -651,6 +706,8 @@ export {
   execCommand,
   execInput,
   executionCommands,
+  readonlyExecCommand,
+  readonlyExecInput,
   resumeCommand,
   resumeInput,
   runCommand,

package/dist/cli/commands/setup.js

@@ -0,0 +1,376 @@
+import { createInterface } from "node:readline";
+import {
+  appendFileSync,
+  cpSync,
+  existsSync,
+  readdirSync,
+  readFileSync,
+  rmSync,
+  writeFileSync
+} from "node:fs";
+import { spawnSync } from "node:child_process";
+import { basename, dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { writeAiConfig } from "../core/config.js";
+import {
+  ensureLibrettoSetup,
+  LIBRETTO_CONFIG_PATH,
+  REPO_ROOT
+} from "../core/context.js";
+import {
+  DEFAULT_SNAPSHOT_MODELS,
+  loadSnapshotEnv,
+  resolveAiSetupStatus
+} from "../core/ai-model.js";
+import { SimpleCLI } from "../framework/simple-cli.js";
+const PROVIDER_CHOICES = [
+  {
+    key: "1",
+    label: "OpenAI",
+    provider: "openai",
+    envVar: "OPENAI_API_KEY",
+    envHint: "Get your key at https://platform.openai.com/api-keys"
+  },
+  {
+    key: "2",
+    label: "Anthropic",
+    provider: "anthropic",
+    envVar: "ANTHROPIC_API_KEY",
+    envHint: "Get your key at https://console.anthropic.com/settings/keys"
+  },
+  {
+    key: "3",
+    label: "Google Gemini",
+    provider: "google",
+    envVar: "GEMINI_API_KEY",
+    envHint: "Get your key at https://aistudio.google.com/apikey"
+  },
+  {
+    key: "4",
+    label: "Google Vertex AI",
+    provider: "vertex",
+    envVar: "GOOGLE_CLOUD_PROJECT",
+    envHint: "Requires `gcloud auth application-default login` and a GCP project ID"
+  }
+];
+function promptUser(rl, question) {
+  return new Promise((resolve) => {
+    rl.question(question, (answer) => {
+      resolve(answer.trim());
+    });
+  });
+}
+function ensurePinnedDefaultModel(status) {
+  if (status.source !== "config") {
+    writeAiConfig(status.model);
+    return { ...status, source: "config" };
+  }
+  return status;
+}
+function printHealthySummary(status) {
+  console.log(`  \u2713 Model: ${status.model}`);
+  console.log(`  Config: ${LIBRETTO_CONFIG_PATH}`);
+  console.log(
+    "  To change: npx libretto ai configure openai | anthropic | gemini | vertex"
+  );
+}
+function printInvalidAiConfigWarning(status) {
+  if (status.kind !== "invalid-config") return;
+  console.log("  ! Existing AI config is invalid:");
+  for (const line of status.message.split("\n")) {
+    console.log(`    ${line}`);
+  }
+}
+function buildRepairPlan(status) {
+  if (status.kind === "configured-missing-credentials") {
+    const choice = PROVIDER_CHOICES.find((c) => c.provider === status.provider);
+    return {
+      kind: "repair-missing-credentials",
+      provider: status.provider,
+      model: status.model,
+      envVar: choice?.envVar ?? `${status.provider.toUpperCase()}_API_KEY`,
+      choices: ["enter-matching-credential", "switch-provider", "skip"]
+    };
+  }
+  if (status.kind === "invalid-config") {
+    return { kind: "repair-invalid-config", message: status.message };
+  }
+  return { kind: "no-repair-needed" };
+}
+function formatMissingCredentialsMessage(plan) {
+  return [
+    `  \u2717 ${plan.provider} is configured (model: ${plan.model}), but ${plan.envVar} is not set.`
+  ].join("\n");
+}
+function printSnapshotApiStatus() {
+  const status = resolveAiSetupStatus();
+  const envPath = join(REPO_ROOT, ".env");
+  console.log("\nSnapshot analysis:");
+  console.log(
+    "  Libretto uses direct API calls for snapshot analysis when supported credentials are available."
+  );
+  console.log(`  Credentials are loaded from process env and ${envPath}.`);
+  if (status.kind === "ready") {
+    const pinned = ensurePinnedDefaultModel(status);
+    printHealthySummary(pinned);
+    return true;
+  }
+  const plan = buildRepairPlan(status);
+  if (plan.kind === "repair-missing-credentials") {
+    console.log(formatMissingCredentialsMessage(plan));
+    console.log(
+      `    To fix: add ${plan.envVar} to .env, or run \`npx libretto setup\` interactively to repair.`
+    );
+    return false;
+  }
+  if (plan.kind === "repair-invalid-config") {
+    printInvalidAiConfigWarning(status);
+    console.log("    Run `npx libretto setup` interactively to reconfigure.");
+    return false;
+  }
+  console.log("  \u2717 No snapshot API credentials detected.");
+  console.log("    Add one provider to .env:");
+  console.log("      OPENAI_API_KEY=...");
+  console.log("      ANTHROPIC_API_KEY=...");
+  console.log("      GEMINI_API_KEY=...  # or GOOGLE_GENERATIVE_AI_API_KEY");
+  console.log(
+    "      GOOGLE_CLOUD_PROJECT=...  # plus application default credentials for Vertex"
+  );
+  console.log(
+    "    Or run `npx libretto ai configure openai | anthropic | gemini | vertex` to set a specific model."
+  );
+  console.log(
+    "    Run `npx libretto setup` interactively to set up credentials."
+  );
+  return false;
+}
+function writeEnvVar(envVar, value, envPath) {
+  let envContent = "";
+  if (existsSync(envPath)) {
+    envContent = readFileSync(envPath, "utf-8");
+  }
+  const envLine = `${envVar}=${value}`;
+  if (envContent.includes(`${envVar}=`)) {
+    const updated = envContent.replace(
+      new RegExp(`^${envVar}=.*$`, "m"),
+      () => envLine
+    );
+    writeFileSync(envPath, updated);
+    console.log(`
+  \u2713 Updated ${envVar} in ${envPath}`);
+  } else {
+    const separator = envContent && !envContent.endsWith("\n") ? "\n" : "";
+    appendFileSync(envPath, `${separator}${envLine}
+`);
+    console.log(`
+  \u2713 Added ${envVar} to ${envPath}`);
+  }
+  process.env[envVar] = value;
+}
+async function promptForCredential(rl, choice, envPath, modelOverride) {
+  console.log(`
+  ${choice.label} selected.`);
+  console.log(`  ${choice.envHint}
+`);
+  const apiKeyValue = await promptUser(rl, `  Enter your ${choice.envVar}: `);
+  if (!apiKeyValue) {
+    console.log("\n  No value entered. Skipping API key setup.");
+    return false;
+  }
+  writeEnvVar(choice.envVar, apiKeyValue, envPath);
+  loadSnapshotEnv();
+  const model = modelOverride ?? DEFAULT_SNAPSHOT_MODELS[choice.provider];
+  writeAiConfig(model);
+  console.log(`  \u2713 Snapshot API ready: ${model}`);
+  return true;
+}
+async function promptProviderSelection(rl, envPath) {
+  console.log(
+    "  Which API provider would you like to use for snapshot analysis?\n"
+  );
+  for (const choice of PROVIDER_CHOICES) {
+    console.log(`    ${choice.key}) ${choice.label}`);
+  }
+  console.log("    s) Skip for now\n");
+  const answer = await promptUser(rl, "  Choice: ");
+  if (answer.toLowerCase() === "s" || !answer) {
+    printSkipMessage();
+    return false;
+  }
+  const selected = PROVIDER_CHOICES.find((choice) => choice.key === answer);
+  if (!selected) {
+    console.log(`
+  Unknown choice "${answer}". Skipping API setup.`);
+    return false;
+  }
+  return promptForCredential(rl, selected, envPath);
+}
+function printSkipMessage() {
+  console.log(
+    "\n  Skipped. You can set up API credentials later by rerunning `npx libretto setup`."
+  );
+  console.log("  Or add credentials directly to your .env file:");
+  console.log("    OPENAI_API_KEY=...");
+  console.log("    ANTHROPIC_API_KEY=...");
+  console.log("    GEMINI_API_KEY=...");
+  console.log(
+    "    Or run `npx libretto ai configure openai | anthropic | gemini | vertex` to set a specific model."
+  );
+}
+async function runInteractiveApiSetup() {
+  const status = resolveAiSetupStatus();
+  const envPath = join(REPO_ROOT, ".env");
+  console.log("\nSnapshot analysis setup:");
+  console.log("  Libretto uses direct API calls for snapshot analysis.");
+  console.log(`  Credentials are loaded from process env and ${envPath}.`);
+  if (status.kind === "ready") {
+    const pinned = ensurePinnedDefaultModel(status);
+    printHealthySummary(pinned);
+    return;
+  }
+  const plan = buildRepairPlan(status);
+  const rl = createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  try {
+    if (plan.kind === "repair-missing-credentials") {
+      console.log(formatMissingCredentialsMessage(plan));
+      console.log("");
+      console.log("  How would you like to fix this?\n");
+      console.log(`    1) Enter ${plan.envVar}`);
+      console.log("    2) Switch to a different provider");
+      console.log("    s) Skip for now\n");
+      const answer = await promptUser(rl, "  Choice: ");
+      if (answer === "1") {
+        const matchingChoice = PROVIDER_CHOICES.find(
+          (c) => c.provider === plan.provider
+        );
+        if (matchingChoice) {
+          await promptForCredential(rl, matchingChoice, envPath, plan.model);
+        }
+        return;
+      }
+      if (answer === "2") {
+        await promptProviderSelection(rl, envPath);
+        return;
+      }
+      printSkipMessage();
+      return;
+    }
+    if (plan.kind === "repair-invalid-config") {
+      printInvalidAiConfigWarning(status);
+      console.log(
+        "\n  Would you like to reconfigure with a fresh provider selection?\n"
+      );
+      await promptProviderSelection(rl, envPath);
+      return;
+    }
+    console.log("  \u2717 No snapshot API credentials detected.\n");
+    await promptProviderSelection(rl, envPath);
+  } finally {
+    rl.close();
+  }
+}
+function installBrowsers() {
+  console.log("\nInstalling Playwright Chromium...");
+  const result = spawnSync("npx", ["playwright", "install", "chromium"], {
+    stdio: "inherit",
+    shell: true
+  });
+  if (result.status === 0) {
+    console.log("  \u2713 Playwright Chromium installed");
+  } else {
+    console.error(
+      "  \u2717 Failed to install Playwright Chromium. Run manually: npx playwright install chromium"
+    );
+  }
+}
+function getPackageSkillsRoot() {
+  const thisFile = fileURLToPath(import.meta.url);
+  let dir = dirname(thisFile);
+  while (dir !== dirname(dir)) {
+    if (existsSync(join(dir, "skills", "libretto"))) {
+      return join(dir, "skills");
+    }
+    dir = dirname(dir);
+  }
+  throw new Error("Could not locate libretto skill files in package");
+}
+function detectAgentDirs(root) {
+  const dirs = [];
+  if (existsSync(join(root, ".agents"))) dirs.push(join(root, ".agents"));
+  if (existsSync(join(root, ".claude"))) dirs.push(join(root, ".claude"));
+  return dirs;
+}
+function copySkills() {
+  const agentDirs = detectAgentDirs(REPO_ROOT);
+  if (agentDirs.length === 0) {
+    console.log(
+      "\nSkills: No .agents/ or .claude/ directory found in repo root \u2014 skipping."
+    );
+    return;
+  }
+  let skillsRoot;
+  try {
+    skillsRoot = getPackageSkillsRoot();
+  } catch (e) {
+    console.error(`  \u2717 ${e instanceof Error ? e.message : String(e)}`);
+    return;
+  }
+  const skillNames = readdirSync(skillsRoot, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name).sort();
+  for (const agentDir of agentDirs) {
+    const agentName = basename(agentDir);
+    for (const skillName of skillNames) {
+      const sourceDir = join(skillsRoot, skillName);
+      const skillDest = join(agentDir, "skills", skillName);
+      if (existsSync(skillDest)) {
+        rmSync(skillDest, { recursive: true });
+      }
+      cpSync(sourceDir, skillDest, { recursive: true });
+      const fileCount = readdirSync(skillDest).length;
+      console.log(
+        `  \u2713 Copied ${fileCount} skill files to ${agentName}/skills/${skillName}/`
+      );
+    }
+  }
+}
+const setupInput = SimpleCLI.input({
+  positionals: [],
+  named: {
+    skipBrowsers: SimpleCLI.flag({
+      name: "skip-browsers",
+      help: "Skip Playwright Chromium installation"
+    })
+  }
+});
+const setupCommand = SimpleCLI.command({
+  description: "Set up libretto in the current project"
+}).input(setupInput).handle(async ({ input }) => {
+  console.log("Setting up libretto...\n");
+  ensureLibrettoSetup();
+  if (!input.skipBrowsers) {
+    installBrowsers();
+  } else {
+    console.log("\nSkipping browser installation (--skip-browsers)");
+  }
+  copySkills();
+  if (process.stdin.isTTY) {
+    await runInteractiveApiSetup();
+  } else {
+    const ready = printSnapshotApiStatus();
+    if (!ready) {
+      console.log(
+        "\nIf you're an agent, request the user to run `npx libretto setup`."
+      );
+    }
+  }
+  console.log("\n\u2713 libretto setup complete");
+});
+export {
+  PROVIDER_CHOICES,
+  buildRepairPlan,
+  formatMissingCredentialsMessage,
+  setupCommand,
+  setupInput
+};

package/dist/cli/commands/snapshot.js

@@ -7,8 +7,8 @@ import { readSessionState } from "../core/session.js";
 import { SimpleCLI } from "../framework/simple-cli.js";
 import { pageOption, sessionOption, withRequiredSession } from "./shared.js";
 import { runApiInterpret } from "../core/api-snapshot-analyzer.js";
-import { readAiConfig } from "../core/ai-config.js";
-import { resolveSnapshotApiModelOrThrow } from "../core/snapshot-api-config.js";
+import { readAiConfig } from "../core/config.js";
+import { resolveSnapshotApiModelOrThrow } from "../core/ai-model.js";
 const FALLBACK_SNAPSHOT_VIEWPORT = { width: 1280, height: 800 };
 function generateSnapshotRunId() {
   return `snapshot-${Date.now()}`;