libretto 0.6.11 → 0.6.13

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

@@ -1,298 +0,0 @@
-import { readSnapshotModel } from "./config.js";
-import { LIBRETTO_CONFIG_PATH } from "./context.js";
-import {
-  hasProviderCredentials,
-  parseModel,
-  type Provider,
-} from "./resolve-model.js";
-
-// Re-export so existing consumers (e.g. tests) don't break.
-export { parseDotEnvAssignment } from "../../shared/env/load-env.js";
-
-// ── Default models ──────────────────────────────────────────────────────────
-
-export 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",
-} as const satisfies Record<Provider, string>;
-
-// ── Source detection ────────────────────────────────────────────────────────
-
-/**
- * Detect which specific env var provides credentials for a provider.
- * Returns the env var name (e.g. "OPENAI_API_KEY", "GEMINI_API_KEY"),
- * or null if no credential is found.
- */
-function detectProviderEnvVar(
-  provider: Provider,
-  env: NodeJS.ProcessEnv = process.env,
-): string | null {
-  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;
-  }
-}
-
-// ── Snapshot model resolution ───────────────────────────────────────────────
-
-export type SnapshotApiModelSelection = {
-  model: string;
-  provider: Provider;
-  source: "config" | `env:${string}`;
-};
-
-export class SnapshotApiUnavailableError extends Error {
-  constructor(message: string) {
-    super(message);
-    this.name = "SnapshotApiUnavailableError";
-  }
-}
-
-function providerSetupSentence(provider: Provider): string {
-  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(): string {
-  return "npx libretto ai configure openai | anthropic | gemini | vertex | openrouter";
-}
-
-function providerMissingCredentialSummary(provider: Provider): string {
-  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(): string {
-  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 `npx libretto setup`.",
-  ].join(" ");
-}
-
-function missingProviderSnapshotMessage(
-  selection: SnapshotApiModelSelection,
-): string {
-  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 `npx libretto setup`.",
-  ].join(" ");
-}
-
-// ── Model resolution ────────────────────────────────────────────────────────
-
-function inferAutoSnapshotModel(): SnapshotApiModelSelection | null {
-  const providersInPriorityOrder: Provider[] = [
-    "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;
-}
-
-/**
- * Resolve which API model to use for snapshot analysis.
- *
- * Environment variables are loaded by the CLI entrypoint (`runLibrettoCLI` in
- * `cli.ts`) before this resolver runs. Keep dotenv loading centralized there so
- * model resolution and browser provider resolution share the same env setup.
- *
- * Priority:
- * 1. snapshotModel from .libretto/config.json (set via `ai configure`)
- * 2. Auto-detect from available API credentials in env
- */
-export function resolveSnapshotApiModel(
-  snapshotModel: string | null = readSnapshotModel(),
-): SnapshotApiModelSelection | null {
-  if (snapshotModel) {
-    const { provider } = parseModel(snapshotModel);
-    return {
-      model: snapshotModel,
-      provider,
-      source: "config",
-    };
-  }
-
-  return inferAutoSnapshotModel();
-}
-
-export function resolveSnapshotApiModelOrThrow(
-  snapshotModel: string | null = readSnapshotModel(),
-): SnapshotApiModelSelection {
-  const selection = resolveSnapshotApiModel(snapshotModel);
-  if (!selection) {
-    throw new SnapshotApiUnavailableError(noSnapshotApiConfiguredMessage());
-  }
-
-  if (!hasProviderCredentials(selection.provider)) {
-    throw new SnapshotApiUnavailableError(
-      missingProviderSnapshotMessage(selection),
-    );
-  }
-
-  return selection;
-}
-
-export function isSnapshotApiUnavailableError(error: unknown): boolean {
-  return error instanceof SnapshotApiUnavailableError;
-}
-
-// ── AI setup status ─────────────────────────────────────────────────────────
-
-/**
- * Workspace AI setup health states.
- *
- * - `ready`: a usable model was resolved and the matching provider has credentials.
- * - `configured-missing-credentials`: config pins a provider whose credentials are absent.
- * - `invalid-config`: `.libretto/config.json` exists but fails schema validation.
- * - `unconfigured`: no config and no env credentials detected.
- */
-export type AiSetupStatus =
-  | {
-      kind: "ready";
-      model: string;
-      provider: Provider;
-      source: "config" | `env:${string}`;
-    }
-  | {
-      kind: "configured-missing-credentials";
-      model: string;
-      provider: Provider;
-    }
-  | { kind: "invalid-config"; message: string }
-  | { kind: "unconfigured" };
-
-/**
- * Read snapshot model without throwing on invalid files.
- * Returns the model string or an error message.
- */
-function readSnapshotModelSafely(
-  configPath: string,
-): { ok: true; model: string | null } | { ok: false; message: string } {
-  try {
-    return { ok: true, model: readSnapshotModel(configPath) };
-  } catch (err) {
-    return {
-      ok: false,
-      message: err instanceof Error ? err.message : String(err),
-    };
-  }
-}
-
-/**
- * Resolve the workspace's current AI setup health.
- *
- * Uses the existing config reader and snapshot model resolver, but wraps
- * them to distinguish broken states (invalid config, missing credentials)
- * that the throwing APIs collapse into errors.
- *
- * 1. If config read throws → `invalid-config`.
- * 2. If config has a `snapshotModel` → check credentials for that provider.
- * 3. If no `snapshotModel` → auto-detect from env via existing resolver.
- */
-export function resolveAiSetupStatus(
-  configPath: string = LIBRETTO_CONFIG_PATH,
-): AiSetupStatus {
-  const result = readSnapshotModelSafely(configPath);
-
-  if (!result.ok) {
-    return { kind: "invalid-config", message: result.message };
-  }
-
-  // Config has a snapshotModel — use it directly to check credentials
-  if (result.model) {
-    let selection: SnapshotApiModelSelection | null;
-    try {
-      selection = resolveSnapshotApiModel(result.model);
-    } catch (err) {
-      return {
-        kind: "invalid-config",
-        message: err instanceof Error ? err.message : String(err),
-      };
-    }
-    if (!selection) {
-      // Should not happen when config has a model, but handle gracefully
-      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,
-    };
-  }
-
-  // No snapshotModel — fall back to env auto-detect via existing resolver
-  const envSelection = resolveSnapshotApiModel(null);
-  if (envSelection && hasProviderCredentials(envSelection.provider)) {
-    return {
-      kind: "ready",
-      model: envSelection.model,
-      provider: envSelection.provider,
-      source: envSelection.source,
-    };
-  }
-
-  return { kind: "unconfigured" };
-}

package/src/cli/core/api-snapshot-analyzer.ts

@@ -1,110 +0,0 @@
-/**
- * API-based snapshot analyzer.
- *
- * Sends the DOM snapshot (condensed or full depending on sizing) and screenshot
- * directly to a supported API provider via the Vercel AI SDK, without spawning
- * a CLI process.
- */
-
-import { readFileSync } from "node:fs";
-import type { LoggerApi } from "../../shared/logger/index.js";
-import { generateObject } from "ai";
-import { resolveModel } from "./resolve-model.js";
-import {
-  InterpretResultSchema,
-  buildInlinePromptSelection,
-  getMimeType,
-  readFileAsBase64,
-  type InterpretResult,
-  type InterpretArgs,
-} from "./snapshot-analyzer.js";
-import { readSnapshotModel } from "./config.js";
-import { resolveSnapshotApiModelOrThrow } from "./ai-model.js";
-
-export async function runApiInterpret(
-  args: InterpretArgs,
-  logger: LoggerApi,
-  snapshotModel: string | null = readSnapshotModel(),
-): Promise<void> {
-  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: InterpretResult = 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()}`);
-  }
-}

package/src/cli/core/daemon/index.ts

@@ -1,24 +0,0 @@
-export {
-  DaemonServer,
-  DaemonClient,
-  DaemonClientError,
-  getDaemonSocketPath,
-  type DaemonCommandResult,
-  type DaemonExecOutput,
-  type DaemonRequest,
-  type DaemonResponse,
-  type DaemonResultMap,
-  type RequestHandler,
-} from "./ipc.js";
-
-export {
-  type DaemonLaunchConfig,
-  type DaemonConnectConfig,
-  type DaemonConfig,
-} from "./config.js";
-
-export {
-  spawnSessionDaemon,
-  type SpawnSessionDaemonOptions,
-  type SpawnSessionDaemonResult,
-} from "./spawn.js";

package/src/cli/core/daemon/spawn.ts

@@ -1,171 +0,0 @@
-/**
- * Spawn and wait for a browser daemon process.
- *
- * Shared by `runOpen`, `runConnect`, and `runOpenWithProvider` in
- * `browser.ts`. Encapsulates the child-process lifecycle and IPC
- * readiness polling so callers only need to provide config and
- * handle session-state persistence.
- */
-
-import { openSync, closeSync } from "node:fs";
-import { fileURLToPath, pathToFileURL } from "node:url";
-import { createRequire } from "node:module";
-import { spawn } from "node:child_process";
-import type { LoggerApi } from "../../../shared/logger/index.js";
-import { getDaemonSocketPath } from "./ipc.js";
-import { DaemonClient } from "./ipc.js";
-import type { DaemonConfig } from "./config.js";
-
-// ── Public types ─────────────────────────────────────────────────────
-
-export type SpawnSessionDaemonOptions = {
-  /** Daemon config — serialized as JSON and passed to the child process. */
-  config: DaemonConfig;
-  session: string;
-  logger: LoggerApi;
-  /** Path for the child's stderr log file. */
-  logPath: string;
-  /** How long to wait for the daemon's IPC server (default: 10 000 ms). */
-  ipcTimeoutMs?: number;
-  /**
-   * Called before throwing when the daemon fails to start (spawn error,
-   * early exit, or IPC timeout). Use for cleanup — e.g. closing a cloud
-   * provider session. Return value is ignored.
-   */
-  onFailure?: () => Promise<unknown>;
-};
-
-export type SpawnSessionDaemonResult = {
-  /** PID of the detached daemon child process. */
-  pid: number;
-  /** Unix domain socket path for daemon IPC. */
-  socketPath: string;
-  /** Ready-to-use IPC client (already confirmed reachable via ping). */
-  client: DaemonClient;
-};
-
-// ── Implementation ───────────────────────────────────────────────────
-
-const DEFAULT_IPC_TIMEOUT_MS = 10_000;
-const IPC_POLL_INTERVAL_MS = 250;
-
-/**
- * Spawn a daemon child process with the given config and wait for its
- * IPC server to become reachable.
- *
- * The daemon entry point is resolved relative to this module so the
- * caller doesn't need to know where the daemon script lives.
- */
-export async function spawnSessionDaemon(
-  options: SpawnSessionDaemonOptions,
-): Promise<SpawnSessionDaemonResult> {
-  const {
-    config,
-    session,
-    logger,
-    logPath,
-    ipcTimeoutMs = DEFAULT_IPC_TIMEOUT_MS,
-    onFailure,
-  } = options;
-
-  // Resolve paths for the daemon entry point and tsx loader.
-  const daemonEntryPath = fileURLToPath(
-    new URL("./daemon.js", import.meta.url),
-  );
-  const require = createRequire(import.meta.url);
-  const tsxImportPath = pathToFileURL(require.resolve("tsx/esm")).href;
-
-  // Spawn detached child process with stderr going to the log file.
-  const childStderrFd = openSync(logPath, "a");
-  const child = spawn(
-    process.execPath,
-    ["--import", tsxImportPath, daemonEntryPath, JSON.stringify(config)],
-    {
-      detached: true,
-      stdio: ["ignore", "ignore", childStderrFd],
-    },
-  );
-  child.unref();
-  closeSync(childStderrFd);
-
-  const pid = child.pid!;
-  logger.info("daemon-spawned", { pid, session });
-
-  // Track spawn errors and early exits so the polling loop can fail fast.
-  let childSpawnError: Error | null = null;
-  let childEarlyExit: {
-    code: number | null;
-    signal: NodeJS.Signals | null;
-  } | null = null;
-
-  child.on("error", (err) => {
-    childSpawnError = err;
-    logger.error("daemon-spawn-error", { error: err, session });
-  });
-
-  child.on("exit", (code, signal) => {
-    childEarlyExit = { code, signal };
-    logger.warn("daemon-early-exit", { code, signal, session, pid });
-  });
-
-  // Poll the daemon's IPC server until it responds to a ping.
-  const socketPath = getDaemonSocketPath(session);
-  const client = new DaemonClient(socketPath);
-  const maxAttempts = Math.ceil(ipcTimeoutMs / IPC_POLL_INTERVAL_MS);
-  let ipcReady = false;
-
-  for (let i = 0; i < maxAttempts; i++) {
-    // Fail fast on spawn errors. The cast is needed because TypeScript
-    // doesn't track that the variable is mutated asynchronously by the
-    // child's "error" event handler.
-    const spawnError = childSpawnError as Error | null;
-    if (spawnError !== null) {
-      await onFailure?.();
-      const errWithCode = spawnError as Error & { code?: string };
-      const hint =
-        errWithCode.code === "ENOENT"
-          ? " Ensure Node.js is available in PATH for child processes."
-          : "";
-      throw new Error(
-        `Failed to spawn daemon: ${spawnError.message}.${hint} Check logs: ${logPath}`,
-      );
-    }
-
-    // Fail fast on early exit.
-    const earlyExit = childEarlyExit as {
-      code: number | null;
-      signal: NodeJS.Signals | null;
-    } | null;
-    if (earlyExit !== null) {
-      await onFailure?.();
-      const status = earlyExit.code ?? earlyExit.signal ?? "unknown";
-      throw new Error(
-        `Daemon exited before startup (status: ${status}). Check logs: ${logPath}`,
-      );
-    }
-
-    await new Promise((r) => setTimeout(r, IPC_POLL_INTERVAL_MS));
-    ipcReady = await client.ping();
-    if (ipcReady) break;
-
-    if (i > 0 && i % 10 === 0) {
-      logger.info("daemon-waiting-for-ipc", { attempt: i, session });
-    }
-  }
-
-  if (!ipcReady) {
-    // Kill the orphaned daemon process before reporting failure.
-    try {
-      process.kill(pid, "SIGTERM");
-    } catch {
-      // Process may have already exited.
-    }
-    await onFailure?.();
-    throw new Error(
-      `Daemon failed to start within ${Math.ceil(ipcTimeoutMs / 1000)}s. Check logs: ${logPath}`,
-    );
-  }
-
-  logger.info("daemon-ipc-ready", { session, socketPath });
-  return { pid, socketPath, client };
-}

package/src/cli/core/pause-signals.ts

@@ -1,35 +0,0 @@
-import { existsSync } from "node:fs";
-import { unlink } from "node:fs/promises";
-import { join } from "node:path";
-import { getSessionDir } from "./context.js";
-
-export type PauseSignalPaths = {
-  pausedSignalPath: string;
-  resumeSignalPath: string;
-  completedSignalPath: string;
-  failedSignalPath: string;
-  outputSignalPath: string;
-};
-
-export function getPauseSignalPaths(session: string): PauseSignalPaths {
-  const sessionDir = getSessionDir(session);
-  return {
-    pausedSignalPath: join(sessionDir, `${session}.paused`),
-    resumeSignalPath: join(sessionDir, `${session}.resume`),
-    completedSignalPath: join(sessionDir, `${session}.completed`),
-    failedSignalPath: join(sessionDir, `${session}.failed`),
-    outputSignalPath: join(sessionDir, `${session}.output`),
-  };
-}
-
-export async function removeSignalIfExists(path: string): Promise<void> {
-  if (!existsSync(path)) return;
-  try {
-    await unlink(path);
-  } catch (error) {
-    const code = (error as NodeJS.ErrnoException).code;
-    if (code !== "ENOENT") {
-      throw error;
-    }
-  }
-}