libretto 0.5.4 → 0.5.6

package/dist/cli/commands/status.js

@@ -0,0 +1,62 @@
+import { LIBRETTO_CONFIG_PATH } from "../core/context.js";
+import { resolveAiSetupStatus } from "../core/ai-model.js";
+import { listRunningSessions } from "../core/session.js";
+import { SimpleCLI } from "../framework/simple-cli.js";
+function printAiStatus(status) {
+  console.log("AI configuration:");
+  switch (status.kind) {
+    case "ready":
+      console.log(`  \u2713 Model: ${status.model}`);
+      if (status.source === "config") {
+        console.log(`  Config: ${LIBRETTO_CONFIG_PATH}`);
+      } else {
+        console.log(`  Source: ${status.source}`);
+      }
+      console.log(
+        "  To change: npx libretto ai configure openai | anthropic | gemini | vertex"
+      );
+      break;
+    case "configured-missing-credentials":
+      console.log(
+        `  \u2717 ${status.provider} is configured (model: ${status.model}), but credentials are missing.`
+      );
+      console.log("  Run `npx libretto setup` to repair.");
+      break;
+    case "invalid-config":
+      console.log("  \u2717 Config is invalid:");
+      for (const line of status.message.split("\n")) {
+        console.log(`    ${line}`);
+      }
+      console.log("  Run `npx libretto setup` to reconfigure.");
+      break;
+    case "unconfigured":
+      console.log("  \u2717 No AI model configured.");
+      console.log(
+        "  Run `npx libretto setup` or `npx libretto ai configure` to set up."
+      );
+      break;
+  }
+}
+function printOpenSessions(sessions) {
+  console.log("\nOpen sessions:");
+  if (sessions.length === 0) {
+    console.log("  No open sessions.");
+    return;
+  }
+  for (const session of sessions) {
+    const statusLabel = session.status ? ` [${session.status}]` : "";
+    const endpoint = `http://127.0.0.1:${session.port}`;
+    console.log(`  ${session.session}${statusLabel} \u2014 ${endpoint}`);
+  }
+}
+const statusCommand = SimpleCLI.command({
+  description: "Show workspace status: AI configuration and open sessions"
+}).input(SimpleCLI.input({ positionals: [], named: {} })).handle(async () => {
+  const aiStatus = resolveAiSetupStatus();
+  printAiStatus(aiStatus);
+  const sessions = listRunningSessions();
+  printOpenSessions(sessions);
+});
+export {
+  statusCommand
+};

package/dist/cli/core/{snapshot-api-config.js → ai-model.js}

@@ -1,17 +1,34 @@
 import { existsSync, readFileSync } from "node:fs";
 import { dirname, join, resolve } from "node:path";
-import { readAiConfig } from "./ai-config.js";
+import { readAiConfig } from "./config.js";
 import { LIBRETTO_CONFIG_PATH, REPO_ROOT } from "./context.js";
 import {
   hasProviderCredentials,
   parseModel
-} from "../../shared/llm/client.js";
+} from "./resolve-model.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-pro"
+  vertex: "vertex/gemini-2.5-flash"
 };
+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;
+  }
+}
 class SnapshotApiUnavailableError extends Error {
   constructor(message) {
     super(message);
@@ -49,7 +66,7 @@ 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, or GOOGLE_CLOUD_PROJECT to .env or as a shell environment variable, or choose a default model with \`${defaultModelCommandLine()}\`.`,
-    "For more info, run `npx libretto init`."
+    "For more info, run `npx libretto setup`."
   ].join(" ");
 }
 function missingProviderSnapshotMessage(selection) {
@@ -57,7 +74,7 @@ function missingProviderSnapshotMessage(selection) {
   return [
     `Failed to analyze snapshot because ${selection.provider} is configured${configuredSource}, but ${providerMissingCredentialSummary(selection.provider)}.`,
     providerSetupSentence(selection.provider),
-    "For more info, run `npx libretto init`."
+    "For more info, run `npx libretto setup`."
   ].join(" ");
 }
 function readWorktreeEnvPath() {
@@ -128,11 +145,12 @@ function inferAutoSnapshotModel() {
     "vertex"
   ];
   for (const provider of providersInPriorityOrder) {
-    if (!hasProviderCredentials(provider)) continue;
+    const envVar = detectProviderEnvVar(provider);
+    if (!envVar) continue;
     return {
       model: DEFAULT_SNAPSHOT_MODELS[provider],
       provider,
-      source: `env:auto-${provider}`
+      source: `env:${envVar}`
     };
   }
   return null;
@@ -164,11 +182,67 @@ function resolveSnapshotApiModelOrThrow(config = readAiConfig()) {
 function isSnapshotApiUnavailableError(error) {
   return error instanceof SnapshotApiUnavailableError;
 }
+function readAiConfigSafely(configPath) {
+  try {
+    return { ok: true, config: readAiConfig(configPath) };
+  } catch (err) {
+    return {
+      ok: false,
+      message: err instanceof Error ? err.message : String(err)
+    };
+  }
+}
+function resolveAiSetupStatus(configPath = LIBRETTO_CONFIG_PATH) {
+  loadSnapshotEnv();
+  const configResult = readAiConfigSafely(configPath);
+  if (!configResult.ok) {
+    return { kind: "invalid-config", message: configResult.message };
+  }
+  if (configResult.config) {
+    let selection;
+    try {
+      selection = resolveSnapshotApiModel(configResult.config);
+    } 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,
   loadSnapshotEnv,
   parseDotEnvAssignment,
+  resolveAiSetupStatus,
   resolveSnapshotApiModel,
   resolveSnapshotApiModelOrThrow
 };

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

@@ -1,13 +1,14 @@
 import { readFileSync } from "node:fs";
-import { createLLMClient } from "../../shared/llm/client.js";
+import { generateObject } from "ai";
+import { resolveModel } from "./resolve-model.js";
 import {
   InterpretResultSchema,
   buildInlinePromptSelection,
   getMimeType,
   readFileAsBase64
 } from "./snapshot-analyzer.js";
-import { readAiConfig } from "./ai-config.js";
-import { resolveSnapshotApiModelOrThrow } from "./snapshot-api-config.js";
+import { readAiConfig } from "./config.js";
+import { resolveSnapshotApiModelOrThrow } from "./ai-model.js";
 async function runApiInterpret(args, logger, configuredAi = readAiConfig()) {
   const selection = resolveSnapshotApiModelOrThrow(configuredAi);
   logger.info("api-interpret-start", {
@@ -41,8 +42,9 @@ async function runApiInterpret(args, logger, configuredAi = readAiConfig()) {
   const imageBase64 = readFileAsBase64(args.pngPath);
   const imageMimeType = getMimeType(args.pngPath);
   const imageBytes = Buffer.from(imageBase64, "base64");
-  const client = createLLMClient(selection.model);
-  const result = await client.generateObjectFromMessages({
+  const model = await resolveModel(selection.model);
+  const { object: result } = await generateObject({
+    model,
     schema: InterpretResultSchema,
     messages: [
       {

package/dist/cli/core/browser.js

@@ -19,10 +19,11 @@ import {
   getSessionNetworkLogPath,
   PROFILES_DIR
 } from "./context.js";
-import { readLibrettoConfig } from "./ai-config.js";
+import { readLibrettoConfig } from "./config.js";
 import {
   assertSessionAvailableForStart,
   clearSessionState,
+  isPidRunning,
   listSessionsWithStateFile,
   readSessionStateOrThrow,
   logFileForSession,
@@ -47,19 +48,44 @@ async function pickFreePort() {
     server.on("error", reject);
   });
 }
+function tryParseAbsoluteUrl(url) {
+  try {
+    return new URL(url);
+  } catch {
+    return null;
+  }
+}
+function isLikelyHostWithPort(parsedUrl, rawUrl) {
+  const remainder = rawUrl.slice(parsedUrl.protocol.length);
+  if (remainder.length === 0) return false;
+  let index = 0;
+  while (index < remainder.length) {
+    const charCode = remainder.charCodeAt(index);
+    if (charCode < 48 || charCode > 57) break;
+    index += 1;
+  }
+  if (index === 0) return false;
+  if (index === remainder.length) return true;
+  const nextChar = remainder[index];
+  return nextChar === "/" || nextChar === "?" || nextChar === "#";
+}
 function normalizeUrl(url) {
-  if (!/^https?:\/\//i.test(url)) {
-    return `https://${url}`;
+  const parsedUrl = tryParseAbsoluteUrl(url);
+  if (!parsedUrl) {
+    return new URL(`https://${url}`);
+  }
+  if (parsedUrl.protocol === "http:" || parsedUrl.protocol === "https:" || parsedUrl.protocol === "file:") {
+    return parsedUrl;
   }
-  return url;
+  if (isLikelyHostWithPort(parsedUrl, url)) {
+    return new URL(`https://${url}`);
+  }
+  throw new Error(
+    `Unsupported URL protocol: ${parsedUrl.protocol}. Use http://, https://, or file://.`
+  );
 }
 function normalizeDomain(url) {
-  try {
-    const u = new URL(normalizeUrl(url));
-    return u.hostname.replace(/^www\./, "");
-  } catch {
-    return url.replace(/^www\./, "");
-  }
+  return url.hostname.replace(/^www\./, "");
 }
 function getProfilePath(domain) {
   return join(PROFILES_DIR, `${domain}.json`);
@@ -265,19 +291,29 @@ function resolveWindowPosition(logger) {
   return void 0;
 }
 async function runOpen(rawUrl, headed, session, logger, options) {
-  const url = normalizeUrl(rawUrl);
+  const parsedUrl = normalizeUrl(rawUrl);
+  const url = parsedUrl.href;
   const viewport = resolveViewport(options?.viewport, logger);
+  const accessMode = options?.accessMode ?? "write-access";
   const windowPosition = headed ? resolveWindowPosition(logger) : void 0;
-  logger.info("open-start", { url, headed, session, viewport, windowPosition });
+  logger.info("open-start", {
+    url,
+    headed,
+    session,
+    viewport,
+    windowPosition,
+    accessMode
+  });
   assertSessionAvailableForStart(session, logger);
   const port = await pickFreePort();
   const runLogPath = logFileForSession(session);
   const networkLogPath = getSessionNetworkLogPath(session);
   const actionsLogPath = getSessionActionsLogPath(session);
   const browserMode = headed ? "headed" : "headless";
-  const domain = normalizeDomain(url);
-  const profilePath = getProfilePath(domain);
-  const useProfile = hasProfile(domain);
+  const supportsSavedProfile = parsedUrl.protocol === "http:" || parsedUrl.protocol === "https:";
+  const domain = supportsSavedProfile ? normalizeDomain(parsedUrl) : void 0;
+  const profilePath = domain ? getProfilePath(domain) : void 0;
+  const useProfile = domain ? hasProfile(domain) : false;
   logger.info("open-launching", {
     url,
     mode: browserMode,
@@ -291,9 +327,8 @@ async function runOpen(rawUrl, headed, session, logger, options) {
     console.log(`Loading saved profile for ${domain}`);
   }
   console.log(`Launching ${browserMode} browser (session: ${session})...`);
-  const escapedProfilePath = profilePath.replace(/\\/g, "\\\\").replace(/'/g, "\\'");
   const escapedUrl = url.replace(/\\/g, "\\\\").replace(/'/g, "\\'");
-  const storageStateCode = useProfile ? `storageState: '${escapedProfilePath}',` : "";
+  const storageStateCode = useProfile ? `storageState: '${profilePath.replace(/\\/g, "\\\\").replace(/'/g, "\\'")}',` : "";
   const escapedLogPath = runLogPath.replace(/\\/g, "\\\\").replace(/'/g, "\\'");
   const escapedNetworkLogPath = networkLogPath.replace(/\\/g, "\\\\").replace(/'/g, "\\'");
   const escapedActionsLogPath = actionsLogPath.replace(/\\/g, "\\\\").replace(/'/g, "\\'");
@@ -497,6 +532,7 @@ await new Promise(() => {});
           session,
           startedAt: (/* @__PURE__ */ new Date()).toISOString(),
           status: "active",
+          mode: accessMode,
           viewport
         },
         logger
@@ -528,7 +564,7 @@ async function runSave(urlOrDomain, session, logger) {
   const { browser, context, page } = await connect(session, logger);
   try {
     await new Promise((r) => setTimeout(r, 500));
-    const domain = normalizeDomain(urlOrDomain);
+    const domain = normalizeDomain(normalizeUrl(urlOrDomain));
     const profilePath = getProfilePath(domain);
     const cdpSession = await context.newCDPSession(page);
     const { cookies: rawCookies } = await cdpSession.send(
@@ -607,14 +643,6 @@ async function runClose(session, logger) {
 function waitForCloseSignalWindow(ms) {
   return new Promise((r) => setTimeout(r, ms));
 }
-function isPidRunning(pid) {
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch {
-    return false;
-  }
-}
 function sendSignalToProcessGroupOrPid(pid, signal, logger, session) {
   try {
     process.kill(pid, signal);
@@ -747,8 +775,8 @@ async function runCloseAll(logger, options) {
     console.log(`Force-killed ${forceKilled} session(s).`);
   }
 }
-async function runConnect(cdpUrl, session, logger) {
-  logger.info("connect-start", { cdpUrl, session });
+async function runConnect(cdpUrl, session, logger, accessMode = "write-access") {
+  logger.info("connect-start", { cdpUrl, session, accessMode });
   assertSessionAvailableForStart(session, logger);
   let parsedUrl;
   try {
@@ -758,28 +786,38 @@ async function runConnect(cdpUrl, session, logger) {
       [
         `Invalid CDP URL: ${cdpUrl}`,
         ``,
-        `Expected an HTTP URL pointing to a Chrome DevTools Protocol endpoint, for example:`,
+        `Expected an HTTP or WebSocket URL pointing to a Chrome DevTools Protocol endpoint, for example:`,
         `  libretto connect http://127.0.0.1:9222`,
         `  libretto connect http://remote-host:9222`,
-        `  libretto connect http://remote-host:9222/devtools/browser/<id>`
+        `  libretto connect http://remote-host:9222/devtools/browser/<id>`,
+        `  libretto connect ws://remote-host:9222/devtools/browser/<id>`,
+        `  libretto connect wss://remote-host/cdp-endpoint`
       ].join("\n")
     );
   }
   const endpoint = parsedUrl.href;
-  const port = parsedUrl.port ? Number(parsedUrl.port) : parsedUrl.protocol === "https:" ? 443 : 80;
+  const isWebSocket = parsedUrl.protocol === "ws:" || parsedUrl.protocol === "wss:";
+  const port = parsedUrl.port ? Number(parsedUrl.port) : parsedUrl.protocol === "https:" || parsedUrl.protocol === "wss:" ? 443 : 80;
   console.log(
     `Connecting to CDP endpoint at ${endpoint} (session: ${session})...`
   );
-  const versionUrl = `${parsedUrl.protocol}//${parsedUrl.host}/json/version`;
-  try {
-    const resp = await fetch(versionUrl);
-    const versionInfo = await resp.json();
-    logger.info("connect-version-ok", { versionUrl, versionInfo });
-  } catch (err) {
-    logger.error("connect-version-failed", { versionUrl, error: err });
-    throw new Error(
-      `Cannot reach CDP endpoint at ${versionUrl}. Make sure the target is running and accessible at ${parsedUrl.host}.`
-    );
+  if (!isWebSocket) {
+    const versionUrl = `${parsedUrl.protocol}//${parsedUrl.host}/json/version`;
+    try {
+      const resp = await fetch(versionUrl);
+      const versionInfo = await resp.json();
+      logger.info("connect-version-ok", { versionUrl, versionInfo });
+    } catch (err) {
+      logger.error("connect-version-failed", { versionUrl, error: err });
+      throw new Error(
+        `Cannot reach CDP endpoint at ${versionUrl}. Make sure the target is running and accessible at ${parsedUrl.host}.`
+      );
+    }
+  } else {
+    logger.info("connect-skip-version-check", {
+      reason: "WebSocket-only endpoint, skipping HTTP version check",
+      endpoint
+    });
   }
   const browser = await tryConnectToCDP(endpoint, logger, 1e4);
   if (!browser) {
@@ -800,7 +838,8 @@ async function runConnect(cdpUrl, session, logger) {
       cdpEndpoint: endpoint,
       session,
       startedAt: (/* @__PURE__ */ new Date()).toISOString(),
-      status: "active"
+      status: "active",
+      mode: accessMode
     },
     logger
   );

package/dist/cli/core/{ai-config.js → config.js}

@@ -1,6 +1,7 @@
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { dirname } from "node:path";
 import { z } from "zod";
+import { SessionAccessModeSchema } from "../../shared/state/index.js";
 import { LIBRETTO_CONFIG_PATH } from "./context.js";
 const CURRENT_CONFIG_VERSION = 1;
 const AiConfigSchema = z.object({
@@ -19,27 +20,9 @@ const LibrettoConfigSchema = z.object({
   version: z.literal(CURRENT_CONFIG_VERSION),
   ai: AiConfigSchema.optional(),
   viewport: ViewportConfigSchema.optional(),
-  windowPosition: WindowPositionConfigSchema.optional()
+  windowPosition: WindowPositionConfigSchema.optional(),
+  sessionMode: SessionAccessModeSchema.optional()
 }).passthrough();
-const DEFAULT_MODELS = {
-  openai: "openai/gpt-5.4",
-  anthropic: "anthropic/claude-sonnet-4-6",
-  gemini: "google/gemini-3-flash-preview",
-  vertex: "vertex/gemini-2.5-pro"
-};
-const PROVIDER_ALIASES = {
-  claude: DEFAULT_MODELS.anthropic,
-  google: DEFAULT_MODELS.gemini
-};
-const CONFIGURE_PROVIDERS = [
-  "openai",
-  "anthropic",
-  "gemini",
-  "vertex"
-];
-function formatConfigureProviders(separator = " | ") {
-  return CONFIGURE_PROVIDERS.join(separator);
-}
 function formatConfigIssues(error) {
   return error.issues.map((issue) => `  - ${issue.path.join(".") || "root"}: ${issue.message}`).join("\n");
 }
@@ -58,7 +41,8 @@ function formatExpectedConfigExample() {
       windowPosition: {
         x: 1600,
         y: 120
-      }
+      },
+      sessionMode: "write-access"
     },
     null,
     2
@@ -73,10 +57,10 @@ ${detail}` : null,
       "Expected config example:",
       formatExpectedConfigExample(),
       "Notes:",
-      '  - "ai", "viewport", and "windowPosition" are optional.',
+      '  - "ai", "viewport", "windowPosition", and "sessionMode" are optional.',
       '  - "ai.model" must be a provider/model string like "openai/gpt-5.4" or "anthropic/claude-sonnet-4-6".',
       "Fix the file to match this shape, or delete it and rerun:",
-      `  npx libretto ai configure ${formatConfigureProviders()}`
+      `  npx libretto ai configure openai | anthropic | gemini | vertex`
     ].filter(Boolean).join("\n")
   );
 }
@@ -112,7 +96,12 @@ function readAiConfig(configPath = LIBRETTO_CONFIG_PATH) {
   return readLibrettoConfig(configPath).ai ?? null;
 }
 function writeAiConfig(model, configPath = LIBRETTO_CONFIG_PATH) {
-  const librettoConfig = readLibrettoConfig(configPath);
+  let librettoConfig;
+  try {
+    librettoConfig = readLibrettoConfig(configPath);
+  } catch {
+    librettoConfig = { version: CURRENT_CONFIG_VERSION };
+  }
   const ai = AiConfigSchema.parse({
     model,
     updatedAt: (/* @__PURE__ */ new Date()).toISOString()
@@ -139,60 +128,6 @@ function clearAiConfig(configPath = LIBRETTO_CONFIG_PATH) {
   );
   return true;
 }
-function printAiConfig(config, configPath) {
-  console.log(`Model: ${config.model}`);
-  console.log(`Config file: ${configPath}`);
-  console.log(`Updated at: ${config.updatedAt}`);
-}
-function resolveModelFromInput(input) {
-  const trimmed = input.trim();
-  if (!trimmed) return null;
-  if (trimmed.includes("/")) return trimmed;
-  const normalized = trimmed.toLowerCase();
-  return DEFAULT_MODELS[normalized] ?? PROVIDER_ALIASES[normalized] ?? null;
-}
-function runAiConfigure(input, options = {}) {
-  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 config2 = readAiConfig(configPath);
-    if (!config2) {
-      console.log(
-        `No AI config set. Choose a default model: ${configureCommandName} ${formatConfigureProviders()}`
-      );
-      console.log(
-        "Provider credentials still come from your shell or .env file."
-      );
-      return;
-    }
-    printAiConfig(config2, configPath);
-    return;
-  }
-  if (input.clear) {
-    const removed = clearAiConfig(configPath);
-    if (removed) {
-      console.log(`Cleared AI config: ${configPath}`);
-    } else {
-      console.log("No AI config 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".`
-    );
-  }
-  const config = writeAiConfig(model, configPath);
-  console.log("AI config saved.");
-  printAiConfig(config, configPath);
-}
 export {
   AiConfigSchema,
   CURRENT_CONFIG_VERSION,
@@ -202,7 +137,6 @@ export {
   clearAiConfig,
   readAiConfig,
   readLibrettoConfig,
-  runAiConfigure,
   writeAiConfig,
   writeLibrettoConfig
 };

package/dist/cli/core/context.js

@@ -54,34 +54,14 @@ function createLoggerForSession(session) {
     [createFileLogSink({ filePath: logFilePath })]
   );
 }
-async function closeLogger(logger) {
-  if (!logger) return;
-  await logger.close();
-}
 async function withSessionLogger(session, run) {
   const logger = createLoggerForSession(session);
   try {
     return await run(logger);
   } finally {
-    await closeLogger(logger);
+    await logger.close();
   }
 }
-let llmClientFactory = null;
-function setLLMClientFactory(factory) {
-  llmClientFactory = factory;
-}
-function getLLMClientFactory() {
-  return llmClientFactory;
-}
-function maybeConfigureLLMClientFactoryFromEnv() {
-  if (llmClientFactory) return;
-  const hasAnyCreds = process.env.GOOGLE_CLOUD_PROJECT || process.env.GCLOUD_PROJECT || process.env.ANTHROPIC_API_KEY || process.env.OPENAI_API_KEY || process.env.GEMINI_API_KEY || process.env.GOOGLE_GENERATIVE_AI_API_KEY;
-  if (!hasAnyCreds) return;
-  setLLMClientFactory(async (_logger, model) => {
-    const { createLLMClient } = await import("../../shared/llm/index.js");
-    return createLLMClient(model);
-  });
-}
 export {
   LIBRETTO_CONFIG_DIR,
   LIBRETTO_CONFIG_PATH,
@@ -89,10 +69,8 @@ export {
   LIBRETTO_SESSIONS_DIR,
   PROFILES_DIR,
   REPO_ROOT,
-  closeLogger,
   createLoggerForSession,
   ensureLibrettoSetup,
-  getLLMClientFactory,
   getSessionActionsLogPath,
   getSessionDir,
   getSessionLogsPath,
@@ -100,7 +78,5 @@ export {
   getSessionSnapshotRunDir,
   getSessionSnapshotsDir,
   getSessionStatePath,
-  maybeConfigureLLMClientFactoryFromEnv,
-  setLLMClientFactory,
   withSessionLogger
 };