libretto 0.6.12 → 0.6.14

package/src/cli/core/resolve-model.ts

@@ -105,6 +105,7 @@ async function getProviderModel(
       if (!apiKey) {
         throw new Error(missingProviderCredentialsMessage(provider));
       }
+      // @lintc-ignore Human-approved: we don't want to import unless the user is using that subagent.
       const { createGoogleGenerativeAI } = await import("@ai-sdk/google");
       const google = createGoogleGenerativeAI({ apiKey });
       return google(modelId);
@@ -114,6 +115,7 @@ async function getProviderModel(
       if (!project) {
         throw new Error(missingProviderCredentialsMessage(provider));
       }
+      // @lintc-ignore Human-approved: we don't want to import unless the user is using that subagent.
       const { createVertex } = await import("@ai-sdk/google-vertex");
       const vertex = createVertex({
         project,
@@ -126,6 +128,7 @@ async function getProviderModel(
       if (!apiKey) {
         throw new Error(missingProviderCredentialsMessage(provider));
       }
+      // @lintc-ignore Human-approved: we don't want to import unless the user is using that subagent.
       const { createAnthropic } = await import("@ai-sdk/anthropic");
       const anthropic = createAnthropic({ apiKey });
       return anthropic(modelId);
@@ -135,6 +138,7 @@ async function getProviderModel(
       if (!apiKey) {
         throw new Error(missingProviderCredentialsMessage(provider));
       }
+      // @lintc-ignore Human-approved: we don't want to import unless the user is using that subagent.
       const { createOpenAI } = await import("@ai-sdk/openai");
       const openai = createOpenAI({ apiKey });
       return openai(modelId);
@@ -144,6 +148,7 @@ async function getProviderModel(
       if (!apiKey) {
         throw new Error(missingProviderCredentialsMessage(provider));
       }
+      // @lintc-ignore Human-approved: we don't want to import unless the user is using that subagent.
       const { createOpenAI } = await import("@ai-sdk/openai");
       const openrouter = createOpenAI({
         apiKey,

package/src/cli/core/workflow-runtime.ts

@@ -37,6 +37,7 @@ export async function loadDefaultWorkflow(
 ): Promise<ExportedLibrettoWorkflow> {
   let loadedModule: Record<string, unknown>;
   try {
+    // @lintc-ignore Human-approved: user workflow files must be loaded dynamically from the CLI argument.
     loadedModule = (await import(pathToFileURL(absolutePath).href)) as Record<
       string,
       unknown

package/src/cli/index.ts

@@ -1,7 +1,6 @@
 #!/usr/bin/env node
 import { runLibrettoCLI } from "./cli.js";
 
-export { runClose } from "./commands/browser.js";
 export { runLibrettoCLI };
 
 void runLibrettoCLI();

package/src/cli/router.ts

@@ -1,4 +1,3 @@
-import { aiCommands } from "./commands/ai.js";
 import { authCommands } from "./commands/auth.js";
 import { billingCommands } from "./commands/billing.js";
 import { browserCommands } from "./commands/browser.js";
@@ -9,16 +8,20 @@ import { setupCommand } from "./commands/setup.js";
 import { statusCommand } from "./commands/status.js";
 import { snapshotCommand } from "./commands/snapshot.js";
 import { librettoCommand } from "../shared/package-manager.js";
-import { SimpleCLI } from "./framework/simple-cli.js";
+import { SimpleCLI } from "affordance";
 
 export const cliRoutes = {
   ...browserCommands,
-  deploy: deployCommand,
+  cloud: SimpleCLI.group({
+    description: "Libretto Cloud commands",
+    routes: {
+      deploy: deployCommand,
+      auth: authCommands,
+      billing: billingCommands,
+    },
+  }),
   experiments: experimentsCommand,
   ...executionCommands,
-  ai: aiCommands,
-  auth: authCommands,
-  billing: billingCommands,
   setup: setupCommand,
   status: statusCommand,
   snapshot: snapshotCommand,

package/src/shared/instrumentation/instrument.ts

@@ -131,12 +131,12 @@ function wrapLocatorActions(
       try {
         const result = await orig(...args);
         if (opts.visualize) {
-          enqueue(page, () => visualizeAfterAction(page));
+          void enqueue(page, () => visualizeAfterAction(page));
         }
         return result;
       } catch (err: any) {
         if (opts.visualize) {
-          enqueue(page, () => visualizeAfterAction(page));
+          void enqueue(page, () => visualizeAfterAction(page));
         }
         // Enrich timeout errors for pointer actions
         if (POINTER_ACTIONS.has(method) && isTimeoutError(err)) {
@@ -323,12 +323,12 @@ export async function installInstrumentation(
       try {
         const result = await orig(...args);
         if (visualize) {
-          enqueue(page, () => visualizeAfterAction(page));
+          void enqueue(page, () => visualizeAfterAction(page));
         }
         return result;
       } catch (err: any) {
         if (visualize) {
-          enqueue(page, () => visualizeAfterAction(page));
+          void enqueue(page, () => visualizeAfterAction(page));
         }
         if (
           POINTER_ACTIONS.has(method) &&

package/src/shared/ipc/socket-transport.spec.ts

@@ -6,6 +6,7 @@ import { expect, test as base } from "vitest";
 import { createIpcPeer, type IpcPeer } from "./ipc.js";
 import {
   connectToIpcSocket,
+  isWindowsNamedPipePath,
   listenForIpcConnections,
 } from "./socket-transport.js";
 
@@ -64,6 +65,11 @@ test("sends concurrent calls over one socket", async ({ socketPath }) => {
   await expect(stat(socketPath)).rejects.toThrow();
 });
 
+test("recognizes Windows named pipe paths", () => {
+  expect(isWindowsNamedPipePath("\\\\.\\pipe\\libretto-abc123")).toBe(true);
+  expect(isWindowsNamedPipePath("/tmp/libretto-501-abc123.sock")).toBe(false);
+});
+
 test("rejects pending calls when the socket closes", async ({ socketPath }) => {
   const serverPeers: Array<IpcPeer<ClientApi>> = [];
   const server = await listenForIpcConnections(socketPath, (transport) => {

package/src/shared/ipc/socket-transport.ts

@@ -1,4 +1,4 @@
-import { rm } from "node:fs/promises";
+import { mkdir, rm } from "node:fs/promises";
 import {
   createServer,
   createConnection,
@@ -6,7 +6,6 @@ import {
   type Socket,
 } from "node:net";
 import { dirname } from "node:path";
-import { mkdir } from "node:fs/promises";
 import type { IpcProtocolMessage, IpcTransport } from "./ipc.js";
 
 function createJsonSocketTransport(
@@ -109,13 +108,12 @@ export async function listenOnIpcSocket(
   server: Server,
   socketPath: string,
 ): Promise<void> {
-  await mkdir(dirname(socketPath), { recursive: true });
-  await rm(socketPath, { force: true });
+  await prepareIpcSocketPath(socketPath);
 
   const originalClose = server.close.bind(server);
   server.close = ((callback?: (error?: Error) => void) => {
     return originalClose((error?: Error) => {
-      void rm(socketPath, { force: true }).finally(() => callback?.(error));
+      void removeStaleSocketFile(socketPath).finally(() => callback?.(error));
     });
   }) as Server["close"];
 
@@ -135,6 +133,23 @@ export async function listenOnIpcSocket(
   });
 }
 
+export function isWindowsNamedPipePath(socketPath: string): boolean {
+  return socketPath.startsWith("\\\\.\\pipe\\");
+}
+
+async function prepareIpcSocketPath(socketPath: string): Promise<void> {
+  if (isWindowsNamedPipePath(socketPath)) return;
+
+  await mkdir(dirname(socketPath), { recursive: true });
+  await removeStaleSocketFile(socketPath);
+}
+
+async function removeStaleSocketFile(socketPath: string): Promise<void> {
+  if (isWindowsNamedPipePath(socketPath)) return;
+
+  await rm(socketPath, { force: true });
+}
+
 async function connectSocket(socketPath: string): Promise<Socket> {
   const socket = createConnection(socketPath);
 

package/dist/cli/commands/ai.js

@@ -1,110 +0,0 @@
-import { z } from "zod";
-import {
-  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 { librettoCommand } from "../../shared/package-manager.js";
-import { SimpleCLI } from "../framework/simple-cli.js";
-const PROVIDER_ALIASES = {
-  claude: DEFAULT_SNAPSHOT_MODELS.anthropic,
-  gemini: DEFAULT_SNAPSHOT_MODELS.google,
-  google: DEFAULT_SNAPSHOT_MODELS.google
-};
-const CONFIGURE_PROVIDERS = [
-  "openai",
-  "anthropic",
-  "gemini",
-  "vertex"
-];
-function formatConfigureProviders(separator = " | ") {
-  return CONFIGURE_PROVIDERS.join(separator);
-}
-function printSnapshotModelConfig(model, configPath) {
-  console.log(`Snapshot model: ${model}`);
-  console.log(`Config file: ${configPath}`);
-}
-function resolveModelFromInput(input) {
-  const trimmed = input.trim();
-  if (!trimmed) return null;
-  if (trimmed.includes("/")) return trimmed;
-  const normalized = trimmed.toLowerCase();
-  return DEFAULT_SNAPSHOT_MODELS[normalized] ?? PROVIDER_ALIASES[normalized] ?? null;
-}
-function runAiConfigure(input, options = {}) {
-  const configureCommandName = options.configureCommandName ?? librettoCommand("ai configure");
-  const configPath = options.configPath ?? LIBRETTO_CONFIG_PATH;
-  const presetArg = input.preset?.trim();
-  if (!presetArg && !input.clear) {
-    const model2 = readSnapshotModel(configPath);
-    if (!model2) {
-      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(model2, 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>
-       ${configureCommandName}
-       ${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);
-}
-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" })
-  }
-});
-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: librettoCommand("ai configure")
-        }
-      );
-    })
-  }
-});
-export {
-  aiCommands,
-  aiConfigureInput,
-  runAiConfigure
-};

package/dist/cli/core/ai-model.js

@@ -1,195 +0,0 @@
-import { readSnapshotModel } from "./config.js";
-import { LIBRETTO_CONFIG_PATH } from "./context.js";
-import { librettoCommand } from "../../shared/package-manager.js";
-import {
-  hasProviderCredentials,
-  parseModel
-} from "./resolve-model.js";
-import { parseDotEnvAssignment } from "../../shared/env/load-env.js";
-const DEFAULT_SNAPSHOT_MODELS = {
-  openai: "openai/gpt-5.4",
-  anthropic: "anthropic/claude-sonnet-4-6",
-  google: "google/gemini-3-flash-preview",
-  vertex: "vertex/gemini-2.5-flash",
-  openrouter: "openrouter/free"
-};
-function detectProviderEnvVar(provider, env = process.env) {
-  switch (provider) {
-    case "openai":
-      return env.OPENAI_API_KEY?.trim() ? "OPENAI_API_KEY" : null;
-    case "anthropic":
-      return env.ANTHROPIC_API_KEY?.trim() ? "ANTHROPIC_API_KEY" : null;
-    case "google":
-      if (env.GEMINI_API_KEY?.trim()) return "GEMINI_API_KEY";
-      if (env.GOOGLE_GENERATIVE_AI_API_KEY?.trim())
-        return "GOOGLE_GENERATIVE_AI_API_KEY";
-      return null;
-    case "vertex":
-      if (env.GOOGLE_CLOUD_PROJECT?.trim()) return "GOOGLE_CLOUD_PROJECT";
-      if (env.GCLOUD_PROJECT?.trim()) return "GCLOUD_PROJECT";
-      return null;
-    case "openrouter":
-      return env.OPENROUTER_API_KEY?.trim() ? "OPENROUTER_API_KEY" : null;
-  }
-}
-class SnapshotApiUnavailableError extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "SnapshotApiUnavailableError";
-  }
-}
-function providerSetupSentence(provider) {
-  switch (provider) {
-    case "openai":
-      return "Add OPENAI_API_KEY to .env or as a shell environment variable.";
-    case "anthropic":
-      return "Add ANTHROPIC_API_KEY to .env or as a shell environment variable.";
-    case "google":
-      return "Add GEMINI_API_KEY or GOOGLE_GENERATIVE_AI_API_KEY to .env or as a shell environment variable.";
-    case "vertex":
-      return "Add GOOGLE_CLOUD_PROJECT or GCLOUD_PROJECT to .env or as a shell environment variable, and make sure application default credentials are configured.";
-    case "openrouter":
-      return "Add OPENROUTER_API_KEY to .env or as a shell environment variable.";
-  }
-}
-function defaultModelCommandLine() {
-  return librettoCommand(
-    "ai configure openai | anthropic | gemini | vertex | openrouter"
-  );
-}
-function providerMissingCredentialSummary(provider) {
-  switch (provider) {
-    case "openai":
-      return "OPENAI_API_KEY is missing";
-    case "anthropic":
-      return "ANTHROPIC_API_KEY is missing";
-    case "google":
-      return "GEMINI_API_KEY and GOOGLE_GENERATIVE_AI_API_KEY are missing";
-    case "vertex":
-      return "GOOGLE_CLOUD_PROJECT and GCLOUD_PROJECT are missing";
-    case "openrouter":
-      return "OPENROUTER_API_KEY is missing";
-  }
-}
-function noSnapshotApiConfiguredMessage() {
-  return [
-    "Failed to analyze snapshot because no snapshot analyzer is configured.",
-    `Add OPENAI_API_KEY, ANTHROPIC_API_KEY, GEMINI_API_KEY or GOOGLE_GENERATIVE_AI_API_KEY, GOOGLE_CLOUD_PROJECT, or OPENROUTER_API_KEY to .env or as a shell environment variable, or choose a default model with \`${defaultModelCommandLine()}\`.`,
-    `For more info, run \`${librettoCommand("setup")}\`.`
-  ].join(" ");
-}
-function missingProviderSnapshotMessage(selection) {
-  const configuredSource = selection.source === "config" ? ` in ${LIBRETTO_CONFIG_PATH}` : " from process env or .env";
-  return [
-    `Failed to analyze snapshot because ${selection.provider} is configured${configuredSource}, but ${providerMissingCredentialSummary(selection.provider)}.`,
-    providerSetupSentence(selection.provider),
-    `For more info, run \`${librettoCommand("setup")}\`.`
-  ].join(" ");
-}
-function inferAutoSnapshotModel() {
-  const providersInPriorityOrder = [
-    "openai",
-    "anthropic",
-    "google",
-    "vertex",
-    "openrouter"
-  ];
-  for (const provider of providersInPriorityOrder) {
-    const envVar = detectProviderEnvVar(provider);
-    if (!envVar) continue;
-    return {
-      model: DEFAULT_SNAPSHOT_MODELS[provider],
-      provider,
-      source: `env:${envVar}`
-    };
-  }
-  return null;
-}
-function resolveSnapshotApiModel(snapshotModel = readSnapshotModel()) {
-  if (snapshotModel) {
-    const { provider } = parseModel(snapshotModel);
-    return {
-      model: snapshotModel,
-      provider,
-      source: "config"
-    };
-  }
-  return inferAutoSnapshotModel();
-}
-function resolveSnapshotApiModelOrThrow(snapshotModel = readSnapshotModel()) {
-  const selection = resolveSnapshotApiModel(snapshotModel);
-  if (!selection) {
-    throw new SnapshotApiUnavailableError(noSnapshotApiConfiguredMessage());
-  }
-  if (!hasProviderCredentials(selection.provider)) {
-    throw new SnapshotApiUnavailableError(
-      missingProviderSnapshotMessage(selection)
-    );
-  }
-  return selection;
-}
-function isSnapshotApiUnavailableError(error) {
-  return error instanceof SnapshotApiUnavailableError;
-}
-function readSnapshotModelSafely(configPath) {
-  try {
-    return { ok: true, model: readSnapshotModel(configPath) };
-  } catch (err) {
-    return {
-      ok: false,
-      message: err instanceof Error ? err.message : String(err)
-    };
-  }
-}
-function resolveAiSetupStatus(configPath = LIBRETTO_CONFIG_PATH) {
-  const result = readSnapshotModelSafely(configPath);
-  if (!result.ok) {
-    return { kind: "invalid-config", message: result.message };
-  }
-  if (result.model) {
-    let selection;
-    try {
-      selection = resolveSnapshotApiModel(result.model);
-    } catch (err) {
-      return {
-        kind: "invalid-config",
-        message: err instanceof Error ? err.message : String(err)
-      };
-    }
-    if (!selection) {
-      return { kind: "unconfigured" };
-    }
-    if (hasProviderCredentials(selection.provider)) {
-      return {
-        kind: "ready",
-        model: selection.model,
-        provider: selection.provider,
-        source: selection.source
-      };
-    }
-    return {
-      kind: "configured-missing-credentials",
-      model: selection.model,
-      provider: selection.provider
-    };
-  }
-  const envSelection = resolveSnapshotApiModel(null);
-  if (envSelection && hasProviderCredentials(envSelection.provider)) {
-    return {
-      kind: "ready",
-      model: envSelection.model,
-      provider: envSelection.provider,
-      source: envSelection.source
-    };
-  }
-  return { kind: "unconfigured" };
-}
-export {
-  DEFAULT_SNAPSHOT_MODELS,
-  SnapshotApiUnavailableError,
-  isSnapshotApiUnavailableError,
-  parseDotEnvAssignment,
-  resolveAiSetupStatus,
-  resolveSnapshotApiModel,
-  resolveSnapshotApiModelOrThrow
-};

package/dist/cli/core/api-snapshot-analyzer.js

@@ -1,86 +0,0 @@
-import { readFileSync } from "node:fs";
-import { generateObject } from "ai";
-import { resolveModel } from "./resolve-model.js";
-import {
-  InterpretResultSchema,
-  buildInlinePromptSelection,
-  getMimeType,
-  readFileAsBase64
-} from "./snapshot-analyzer.js";
-import { readSnapshotModel } from "./config.js";
-import { resolveSnapshotApiModelOrThrow } from "./ai-model.js";
-async function runApiInterpret(args, logger, snapshotModel = readSnapshotModel()) {
-  const selection = resolveSnapshotApiModelOrThrow(snapshotModel);
-  logger.info("api-interpret-start", {
-    objective: args.objective,
-    pngPath: args.pngPath,
-    htmlPath: args.htmlPath,
-    condensedHtmlPath: args.condensedHtmlPath,
-    model: selection.model,
-    modelSource: selection.source
-  });
-  const fullHtmlContent = readFileSync(args.htmlPath, "utf-8");
-  const condensedHtmlContent = readFileSync(args.condensedHtmlPath, "utf-8");
-  const promptSelection = buildInlinePromptSelection(
-    args,
-    fullHtmlContent,
-    condensedHtmlContent,
-    selection.model
-  );
-  logger.info("api-interpret-dom-selection", {
-    configuredModel: promptSelection.stats.configuredModel,
-    fullDomEstimatedTokens: promptSelection.stats.fullDomEstimatedTokens,
-    condensedDomEstimatedTokens: promptSelection.stats.condensedDomEstimatedTokens,
-    contextWindowTokens: promptSelection.budget.contextWindowTokens,
-    promptBudgetTokens: promptSelection.budget.promptBudgetTokens,
-    selectedDom: promptSelection.domSource,
-    selectedHtmlEstimatedTokens: promptSelection.htmlEstimatedTokens,
-    selectedPromptEstimatedTokens: promptSelection.promptEstimatedTokens,
-    selectionReason: promptSelection.selectionReason,
-    truncated: promptSelection.truncated
-  });
-  const imageBase64 = readFileAsBase64(args.pngPath);
-  const imageMimeType = getMimeType(args.pngPath);
-  const imageBytes = Buffer.from(imageBase64, "base64");
-  const model = await resolveModel(selection.model);
-  const { object: result } = await generateObject({
-    model,
-    schema: InterpretResultSchema,
-    messages: [
-      {
-        role: "user",
-        content: [
-          { type: "text", text: promptSelection.prompt },
-          {
-            type: "image",
-            image: imageBytes,
-            mediaType: imageMimeType
-          }
-        ]
-      }
-    ],
-    temperature: 0.1
-  });
-  const parsed = InterpretResultSchema.parse(result);
-  logger.info("api-interpret-success", {
-    selectorCount: parsed.selectors.length,
-    answer: parsed.answer.slice(0, 200)
-  });
-  console.log("");
-  console.log("Analysis:");
-  console.log(parsed.answer);
-  if (parsed.selectors.length > 0) {
-    console.log("");
-    console.log("Selectors:");
-    parsed.selectors.forEach((selector, index) => {
-      console.log(`  ${index + 1}. ${selector.label}: ${selector.selector}`);
-    });
-  }
-  if (parsed.notes?.trim()) {
-    console.log("");
-    console.log(`Notes: ${parsed.notes.trim()}`);
-  }
-}
-export {
-  runApiInterpret
-};