libretto 0.6.11 → 0.6.13

package/dist/cli/core/browser.js

@@ -1,11 +1,14 @@
 import {
   chromium
 } from "playwright";
-import { existsSync, unlinkSync } from "node:fs";
+import { existsSync, readFileSync, unlinkSync } from "node:fs";
+import { mkdir, writeFile } from "node:fs/promises";
 import { dirname, join } from "node:path";
 import { createServer } from "node:net";
-import { PROFILES_DIR } from "./context.js";
+import { getSessionProviderClosePath, PROFILES_DIR } from "./context.js";
 import { readLibrettoConfig } from "./config.js";
+import { librettoCommand } from "../../shared/package-manager.js";
+import { getCloudProviderApi } from "./providers/index.js";
 import {
   assertSessionAvailableForStart,
   clearSessionState,
@@ -16,9 +19,9 @@ import {
   readSessionState,
   writeSessionState
 } from "./session.js";
-import { getCloudProviderApi } from "./providers/index.js";
-import { DaemonClient, spawnSessionDaemon } from "./daemon/index.js";
+import { DaemonClient } from "./daemon/ipc.js";
 const CLOSE_WAIT_MS = 1500;
+const PROVIDER_CLOSE_WAIT_MS = 3e4;
 const FORCE_CLOSE_WAIT_MS = 300;
 async function pickFreePort() {
   return await new Promise((resolve, reject) => {
@@ -154,13 +157,13 @@ async function connect(session, logger, timeoutMs = 1e4, options) {
     });
     if (state.provider) {
       throw new Error(
-        `Could not connect to ${state.provider.name} session for "${session}" at ${endpoint}. The remote session may still be active. Try again, or close with: libretto close --session ${session}`
+        `Could not connect to ${state.provider.name} session for "${session}" at ${endpoint}. The remote session may still be active. Try again, or close with: ${librettoCommand(`close --session ${session}`)}`
       );
     }
     if (state.pid == null || !isPidRunning(state.pid)) {
       clearSessionState(session, logger);
       throw new Error(
-        `No browser running for session "${session}". Run 'libretto open <url> --session ${session}' first.`
+        `No browser running for session "${session}". Run '${librettoCommand(`open <url> --session ${session}`)}' first.`
       );
     }
     throw new Error(
@@ -190,14 +193,14 @@ async function connect(session, logger, timeoutMs = 1e4, options) {
   }
   if (options?.requireSinglePage && !options.pageId && pages.length > 1) {
     throw new Error(
-      `Multiple pages are open in session "${session}". Pass --page <id> to target a page (run "libretto pages --session ${session}" to list ids).`
+      `Multiple pages are open in session "${session}". Pass --page <id> to target a page (run "${librettoCommand(`pages --session ${session}`)}" to list ids).`
     );
   }
   const pageRefs = await resolvePageReferences(pages);
   const pageRef = options?.pageId ? pageRefs.find((ref) => ref.id === options.pageId) ?? null : pageRefs[pageRefs.length - 1];
   if (!pageRef) {
     throw new Error(
-      `Page "${options?.pageId}" was not found in session "${session}". Run "libretto pages --session ${session}" to list ids.`
+      `Page "${options?.pageId}" was not found in session "${session}". Run "${librettoCommand(`pages --session ${session}`)}" to list ids.`
     );
   }
   const page = pageRef.page;
@@ -230,11 +233,15 @@ async function runPages(session, logger) {
   let pageSummaries;
   if (!state.daemonSocketPath) {
     throw new Error(
-      `Session "${session}" has no daemon socket. The browser daemon may have crashed. Close and reopen the session: libretto close --session ${session}`
+      `Session "${session}" has no daemon socket. The browser daemon may have crashed. Close and reopen the session: ${librettoCommand(`close --session ${session}`)}`
     );
   }
-  const client = new DaemonClient(state.daemonSocketPath);
-  pageSummaries = await client.pages();
+  const client = await DaemonClient.connect(state.daemonSocketPath);
+  try {
+    pageSummaries = await client.pages();
+  } finally {
+    client.destroy();
+  }
   if (pageSummaries.length === 0) {
     console.log("No pages found.");
     return;
@@ -299,7 +306,7 @@ async function runOpen(rawUrl, headed, session, logger, options) {
     const authProfilePath = getProfilePath(authDomain);
     if (!existsSync(authProfilePath)) {
       throw new Error(
-        `No saved auth profile for "${authDomain}". Save one first: libretto open https://${authDomain} --headed --session <name>, log in, then run: libretto save ${authDomain} --session <name>`
+        `No saved auth profile for "${authDomain}". Save one first: ${librettoCommand(`open https://${authDomain} --headed --session <name>`)}, log in, then run: ${librettoCommand(`save ${authDomain} --session <name>`)}`
       );
     }
   }
@@ -320,25 +327,29 @@ async function runOpen(rawUrl, headed, session, logger, options) {
     console.log(`Loading saved profile for ${domain}`);
   }
   console.log(`Launching ${browserMode} browser (session: ${session})...`);
-  const { pid, socketPath: daemonSocketPath } = await spawnSessionDaemon({
+  const { pid, socketPath: daemonSocketPath, client } = await DaemonClient.spawn({
     config: {
-      port,
-      url,
       session,
-      headed,
-      viewport,
-      storageStatePath: useProfile ? profilePath : void 0,
-      windowPosition
+      experiments: options.experiments,
+      browser: {
+        kind: "launch",
+        headed,
+        viewport,
+        storageStatePath: useProfile ? profilePath : void 0,
+        windowPosition,
+        remoteDebuggingPort: port,
+        initialUrl: url
+      }
     },
-    session,
     logger,
     logPath: runLogPath,
     // The daemon launches Chromium, installs telemetry, navigates to
     // the URL, and only then starts IPC. Navigation alone can take up
     // to 45s (page.setDefaultNavigationTimeout), so the IPC timeout
     // must cover launch + navigation.
-    ipcTimeoutMs: 6e4
+    startupTimeoutMs: 6e4
   });
+  client.destroy();
   writeSessionState(
     {
       port,
@@ -361,39 +372,50 @@ async function runOpen(rawUrl, headed, session, logger, options) {
   });
   console.log(`Browser open (${browserMode}): ${url}`);
 }
-async function runOpenWithProvider(rawUrl, providerName, provider, session, logger, accessMode = "write-access") {
+async function runOpenWithProvider(rawUrl, providerName, session, logger, accessMode, experiments) {
   const parsedUrl = normalizeUrl(rawUrl);
   const url = parsedUrl.href;
   logger.info("open-provider-start", { url, provider: providerName, session });
   console.log(
     `Creating ${providerName} browser session (session: ${session})...`
   );
-  const providerSession = await provider.createSession();
-  logger.info("open-provider-session-created", {
-    provider: providerName,
-    sessionId: providerSession.sessionId,
-    cdpEndpoint: providerSession.cdpEndpoint,
-    liveViewUrl: providerSession.liveViewUrl
-  });
-  if (providerSession.liveViewUrl) {
-    console.log(`View live session: ${providerSession.liveViewUrl}`);
-  }
   console.log(`Connecting to ${providerName} browser...`);
   const runLogPath = logFileForSession(session);
-  const { pid, socketPath: daemonSocketPath } = await spawnSessionDaemon({
+  const {
+    pid,
+    socketPath: daemonSocketPath,
+    provider: providerSession,
+    client
+  } = await DaemonClient.spawn({
     config: {
-      mode: "connect",
       session,
-      cdpEndpoint: providerSession.cdpEndpoint,
-      url
+      experiments,
+      browser: {
+        kind: "provider",
+        providerName,
+        initialUrl: url
+      }
     },
-    session,
     logger,
     logPath: runLogPath,
     // Remote CDP connection + navigation; must cover both.
-    ipcTimeoutMs: 6e4,
-    onFailure: () => provider.closeSession(providerSession.sessionId)
+    startupTimeoutMs: 6e4
   });
+  client.destroy();
+  if (!providerSession) {
+    throw new Error(
+      `Provider daemon did not return session metadata for ${providerName}.`
+    );
+  }
+  logger.info("open-provider-session-created", {
+    provider: providerName,
+    sessionId: providerSession.sessionId,
+    cdpEndpoint: providerSession.cdpEndpoint,
+    liveViewUrl: providerSession.liveViewUrl
+  });
+  if (providerSession.liveViewUrl) {
+    console.log(`View live session: ${providerSession.liveViewUrl}`);
+  }
   writeSessionState(
     {
       port: 0,
@@ -464,9 +486,8 @@ async function runSave(urlOrDomain, session, logger) {
       }
     }
     const state = { cookies, origins };
-    const fs = await import("node:fs/promises");
-    await fs.mkdir(dirname(profilePath), { recursive: true });
-    await fs.writeFile(profilePath, JSON.stringify(state, null, 2));
+    await mkdir(dirname(profilePath), { recursive: true });
+    await writeFile(profilePath, JSON.stringify(state, null, 2));
     logger.info("save-success", {
       domain,
       profilePath,
@@ -491,33 +512,60 @@ async function runClose(session, logger) {
     console.log(`No browser running for session "${session}".`);
     return;
   }
-  if (state.pid != null) {
+  let replayUrl;
+  if (state.daemonSocketPath && state.pid != null && isPidRunning(state.pid)) {
+    try {
+      const result = await closeDaemonSession(
+        {
+          session,
+          pid: state.pid,
+          port: state.port,
+          provider: state.provider,
+          daemonSocketPath: state.daemonSocketPath
+        },
+        logger
+      );
+      replayUrl = result.replayUrl;
+      if (!state.provider) {
+        await waitForCloseSignalWindow(CLOSE_WAIT_MS);
+      }
+    } catch (error) {
+      if (state.provider) {
+        writeSessionState({ ...state, status: "cleanup-failed" }, logger);
+      }
+      throw formatDaemonCloseFailure(session, state.provider?.name, error);
+    }
+  } else if (state.pid != null) {
     logger.info("close-killing", { session, pid: state.pid, port: state.port });
     sendSignalToProcessGroupOrPid(state.pid, "SIGTERM", logger, session);
-    await waitForCloseSignalWindow(CLOSE_WAIT_MS);
+    if (state.provider) {
+      await waitForProviderCloseResult(session, state.pid);
+    } else {
+      await waitForCloseSignalWindow(CLOSE_WAIT_MS);
+    }
   }
-  let replayUrl;
   if (state.provider) {
-    logger.info("close-provider", {
+    logger.info("close-provider-daemon-owned", {
       session,
       provider: state.provider.name,
       sessionId: state.provider.sessionId
     });
-    try {
-      const provider = getCloudProviderApi(state.provider.name);
-      const result = await provider.closeSession(state.provider.sessionId);
-      replayUrl = result.replayUrl;
-    } catch (err) {
-      logger.warn("close-provider-error", {
-        session,
-        provider: state.provider.name,
-        sessionId: state.provider.sessionId,
-        error: err
-      });
-      writeSessionState({ ...state, status: "cleanup-failed" }, logger);
-      throw new Error(
-        `Failed to close remote ${state.provider.name} session "${state.provider.sessionId}" for session "${session}". State preserved with status "cleanup-failed". Retry with: libretto close --session ${session}`
-      );
+    if (!hasProviderCloseResult(session)) {
+      if (state.pid == null || !isPidRunning(state.pid)) {
+        try {
+          replayUrl = await closeProviderSessionDirectly(session, state.provider, logger);
+        } catch (error) {
+          writeSessionState({ ...state, status: "cleanup-failed" }, logger);
+          throw error;
+        }
+      } else {
+        writeSessionState({ ...state, status: "cleanup-failed" }, logger);
+        throw new Error(
+          `Failed to confirm remote ${state.provider.name} session cleanup for session "${session}". State preserved with status "cleanup-failed". Retry with: ${librettoCommand(`close --session ${session}`)}`
+        );
+      }
+    } else {
+      replayUrl = replayUrl ?? readProviderReplayUrl(session, logger);
     }
   }
   unlinkDaemonSocket(state.daemonSocketPath, logger, session);
@@ -528,9 +576,115 @@ async function runClose(session, logger) {
     console.log(`View recording: ${replayUrl}`);
   }
 }
+async function closeDaemonSession(target, logger) {
+  if (!target.daemonSocketPath) {
+    throw new Error("session has no daemon socket path");
+  }
+  const timeoutMs = target.provider ? PROVIDER_CLOSE_WAIT_MS : CLOSE_WAIT_MS;
+  logger.info("close-daemon-ipc-start", {
+    session: target.session,
+    pid: target.pid,
+    provider: target.provider?.name,
+    timeoutMs
+  });
+  let client;
+  try {
+    client = await DaemonClient.connect(target.daemonSocketPath);
+    const result = await withTimeout(
+      client.close(),
+      timeoutMs,
+      `Daemon did not respond to close within ${timeoutMs}ms.`
+    );
+    logger.info("close-daemon-ipc-success", {
+      session: target.session,
+      replayUrl: result.replayUrl
+    });
+    return result;
+  } finally {
+    client?.destroy();
+  }
+}
+async function withTimeout(promise, timeoutMs, timeoutMessage) {
+  let timeout;
+  const timeoutPromise = new Promise((_resolve, reject) => {
+    timeout = setTimeout(() => reject(new Error(timeoutMessage)), timeoutMs);
+  });
+  try {
+    return await Promise.race([promise, timeoutPromise]);
+  } finally {
+    if (timeout) clearTimeout(timeout);
+  }
+}
+function formatDaemonCloseFailure(session, providerName, error) {
+  const message = error instanceof Error ? error.message : String(error);
+  const cleanupWarning = providerName ? ` State preserved with status "cleanup-failed" because remote ${providerName} cleanup could not be confirmed.` : " State preserved so you can retry or inspect the session.";
+  return new Error(
+    `Failed to close session "${session}" gracefully over daemon IPC: ${message}.${cleanupWarning} Retry with: ${librettoCommand(`close --session ${session}`)}`
+  );
+}
 function waitForCloseSignalWindow(ms) {
   return new Promise((r) => setTimeout(r, ms));
 }
+async function waitForProviderCloseResult(session, pid) {
+  const deadline = Date.now() + PROVIDER_CLOSE_WAIT_MS;
+  while (Date.now() < deadline) {
+    if (hasProviderCloseResult(session) || !isPidRunning(pid)) return;
+    await new Promise((resolve) => setTimeout(resolve, 100));
+  }
+}
+async function waitForCloseAllTargets(targets) {
+  const hasProviderSession = targets.some((target) => target.provider);
+  const deadline = Date.now() + (hasProviderSession ? PROVIDER_CLOSE_WAIT_MS : CLOSE_WAIT_MS);
+  while (Date.now() < deadline) {
+    const stillWaiting = targets.some((target) => {
+      if (target.pid == null || !isPidRunning(target.pid)) return false;
+      return target.provider ? !hasProviderCloseResult(target.session) : true;
+    });
+    if (!stillWaiting) return;
+    await new Promise((resolve) => setTimeout(resolve, 100));
+  }
+}
+async function closeProviderSessionDirectly(session, providerState, logger) {
+  try {
+    const provider = getCloudProviderApi(providerState.name);
+    const result = await provider.closeSession(providerState.sessionId);
+    logger.info("close-provider-direct-fallback-success", {
+      session,
+      provider: providerState.name,
+      sessionId: providerState.sessionId,
+      replayUrl: result.replayUrl
+    });
+    return result.replayUrl;
+  } catch (error) {
+    logger.warn("close-provider-direct-fallback-failed", {
+      session,
+      provider: providerState.name,
+      sessionId: providerState.sessionId,
+      error
+    });
+    throw new Error(
+      `Failed to close remote ${providerState.name} session "${providerState.sessionId}" for session "${session}". State preserved with status "cleanup-failed". Retry with: ${librettoCommand(`close --session ${session}`)}`
+    );
+  }
+}
+function readProviderReplayUrl(session, logger) {
+  const closePath = getSessionProviderClosePath(session);
+  if (!existsSync(closePath)) return void 0;
+  try {
+    const parsed = JSON.parse(readFileSync(closePath, "utf8"));
+    return typeof parsed.replayUrl === "string" && parsed.replayUrl.length > 0 ? parsed.replayUrl : void 0;
+  } catch (err) {
+    logger.warn("provider-close-result-read-failed", {
+      session,
+      path: closePath,
+      error: err
+    });
+    return void 0;
+  }
+}
+function hasProviderCloseResult(session) {
+  return existsSync(getSessionProviderClosePath(session));
+}
 function sendSignalToProcessGroupOrPid(pid, signal, logger, session) {
   try {
     process.kill(pid, signal);
@@ -597,6 +751,11 @@ function clearStoppedSessionStates(sessions, logger, skip) {
   }
   return cleared;
 }
+function markProviderCleanupFailed(session, logger) {
+  const state = readSessionState(session, logger);
+  if (!state) return;
+  writeSessionState({ ...state, status: "cleanup-failed" }, logger);
+}
 async function runCloseAll(logger, options) {
   const force = Boolean(options?.force);
   logger.info("close-all-start", { force });
@@ -611,67 +770,73 @@ async function runCloseAll(logger, options) {
     return;
   }
   const failedProviderSessions = /* @__PURE__ */ new Set();
-  const replayUrls = [];
-  for (const target of closable) {
-    if (target.provider) {
-      logger.info("close-all-provider", {
-        session: target.session,
-        provider: target.provider.name,
-        sessionId: target.provider.sessionId
-      });
-      try {
-        const provider = getCloudProviderApi(target.provider.name);
-        const result = await provider.closeSession(target.provider.sessionId);
-        if (result.replayUrl) {
-          replayUrls.push({
+  const gracefulCloseFailures = /* @__PURE__ */ new Map();
+  await Promise.all(
+    closable.map(async (target) => {
+      if (target.pid == null) return;
+      if (target.daemonSocketPath && isPidRunning(target.pid)) {
+        try {
+          await closeDaemonSession(target, logger);
+          return;
+        } catch (error) {
+          const closeError = formatDaemonCloseFailure(
+            target.session,
+            target.provider?.name,
+            error
+          );
+          gracefulCloseFailures.set(target.session, closeError);
+          logger.warn("close-all-daemon-ipc-failed", {
             session: target.session,
-            replayUrl: result.replayUrl
+            pid: target.pid,
+            error: closeError.message
           });
-        }
-      } catch (err) {
-        logger.warn("close-all-provider-error", {
-          session: target.session,
-          provider: target.provider.name,
-          sessionId: target.provider.sessionId,
-          error: err
-        });
-        failedProviderSessions.add(target.session);
-        const state = readSessionState(target.session, logger);
-        if (state) {
-          writeSessionState({ ...state, status: "cleanup-failed" }, logger);
+          if (!force) return;
         }
       }
-    }
-  }
+      logger.info("close-all-sigterm", {
+        session: target.session,
+        pid: target.pid,
+        port: target.port
+      });
+      sendSignalToProcessGroupOrPid(
+        target.pid,
+        "SIGTERM",
+        logger,
+        target.session
+      );
+    })
+  );
+  await waitForCloseAllTargets(closable);
   for (const target of closable) {
-    if (target.pid == null) continue;
-    logger.info("close-all-sigterm", {
-      session: target.session,
-      pid: target.pid,
-      port: target.port
-    });
-    sendSignalToProcessGroupOrPid(
-      target.pid,
-      "SIGTERM",
-      logger,
-      target.session
-    );
+    if (!target.provider || hasProviderCloseResult(target.session)) continue;
+    if (target.pid != null && isPidRunning(target.pid)) continue;
+    try {
+      await closeProviderSessionDirectly(target.session, target.provider, logger);
+    } catch {
+      markProviderCleanupFailed(target.session, logger);
+      failedProviderSessions.add(target.session);
+    }
   }
-  await waitForCloseSignalWindow(CLOSE_WAIT_MS);
   let survivors = closable.filter(
     (target) => target.pid != null && isPidRunning(target.pid)
   );
-  if (survivors.length > 0 && !force) {
+  if ((survivors.length > 0 || gracefulCloseFailures.size > 0) && !force) {
     const closed = clearStoppedSessionStates(
       closable,
       logger,
       failedProviderSessions
     );
+    const failedSessions = Array.from(
+      /* @__PURE__ */ new Set([
+        ...survivors.map((survivor) => survivor.session),
+        ...gracefulCloseFailures.keys()
+      ])
+    ).map((sessionName) => ({ session: sessionName }));
     throw new Error(
       [
-        `Failed to close ${survivors.length} session(s) gracefully: ${formatSessionList(survivors)}.`,
+        `Failed to close ${failedSessions.length} session(s) gracefully: ${formatSessionList(failedSessions)}.`,
         `Closed ${closed} session(s).`,
-        `Retry with: libretto close --all --force`
+        `Retry with: ${librettoCommand("close --all --force")}`
       ].join("\n")
     );
   }
@@ -710,12 +875,11 @@ async function runCloseAll(logger, options) {
       );
     }
   }
+  const replayUrls = closable.filter((target) => target.provider).flatMap((target) => {
+    const replayUrl = readProviderReplayUrl(target.session, logger);
+    return replayUrl ? [{ session: target.session, replayUrl }] : [];
+  });
   clearStoppedSessionStates(closable, logger, failedProviderSessions);
-  if (failedProviderSessions.size > 0) {
-    console.log(
-      `Warning: ${failedProviderSessions.size} provider session(s) failed remote cleanup and were preserved with status "cleanup-failed".`
-    );
-  }
   if (clearedUnreadableStates > 0) {
     console.log(
       `Cleared ${clearedUnreadableStates} unreadable session state file(s).`
@@ -723,14 +887,21 @@ async function runCloseAll(logger, options) {
   }
   const closedCount = closable.length - failedProviderSessions.size;
   console.log(`Closed ${closedCount} session(s).`);
+  if (failedProviderSessions.size > 0) {
+    console.warn(
+      `Failed to confirm remote cleanup for ${failedProviderSessions.size} provider-backed session(s). State preserved with status "cleanup-failed". Retry with: ${librettoCommand("close --all")}`
+    );
+  }
+  for (const recording of replayUrls) {
+    console.log(
+      `View recording for session "${recording.session}": ${recording.replayUrl}`
+    );
+  }
   if (forceKilled > 0) {
     console.log(`Force-killed ${forceKilled} session(s).`);
   }
-  for (const { session, replayUrl } of replayUrls) {
-    console.log(`View recording (${session}): ${replayUrl}`);
-  }
 }
-async function runConnect(cdpUrl, session, logger, accessMode = "write-access") {
+async function runConnect(cdpUrl, session, logger, accessMode, experiments) {
   logger.info("connect-start", { cdpUrl, session, accessMode });
   assertSessionAvailableForStart(session, logger);
   let parsedUrl;
@@ -742,11 +913,11 @@ async function runConnect(cdpUrl, session, logger, accessMode = "write-access")
         `Invalid CDP URL: ${cdpUrl}`,
         ``,
         `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 ws://remote-host:9222/devtools/browser/<id>`,
-        `  libretto connect wss://remote-host/cdp-endpoint`
+        `  ${librettoCommand("connect http://127.0.0.1:9222")}`,
+        `  ${librettoCommand("connect http://remote-host:9222")}`,
+        `  ${librettoCommand("connect http://remote-host:9222/devtools/browser/<id>")}`,
+        `  ${librettoCommand("connect ws://remote-host:9222/devtools/browser/<id>")}`,
+        `  ${librettoCommand("connect wss://remote-host/cdp-endpoint")}`
       ].join("\n")
     );
   }
@@ -775,12 +946,15 @@ async function runConnect(cdpUrl, session, logger, accessMode = "write-access")
     });
   }
   const runLogPath = logFileForSession(session);
-  const { pid, socketPath: daemonSocketPath, client } = await spawnSessionDaemon({
-    config: { mode: "connect", session, cdpEndpoint: endpoint },
-    session,
+  const { pid, socketPath: daemonSocketPath, client } = await DaemonClient.spawn({
+    config: {
+      session,
+      experiments,
+      browser: { kind: "connect", cdpEndpoint: endpoint }
+    },
     logger,
     logPath: runLogPath,
-    ipcTimeoutMs: 1e4
+    startupTimeoutMs: 1e4
   });
   writeSessionState(
     {
@@ -795,7 +969,12 @@ async function runConnect(cdpUrl, session, logger, accessMode = "write-access")
     },
     logger
   );
-  const pages = await client.pages();
+  let pages;
+  try {
+    pages = await client.pages();
+  } finally {
+    client.destroy();
+  }
   logger.info("connect-success", { cdpUrl: endpoint, session, port });
   console.log(`Connected to ${endpoint} (session: ${session})`);
   console.log(`  Pages found: ${pages.length}`);

package/dist/cli/core/config.js

@@ -18,7 +18,8 @@ const LibrettoConfigSchema = z.object({
   viewport: ViewportConfigSchema.optional(),
   windowPosition: WindowPositionConfigSchema.optional(),
   provider: z.string().optional(),
-  sessionMode: SessionAccessModeSchema.optional()
+  sessionMode: SessionAccessModeSchema.optional(),
+  experiments: z.record(z.string(), z.boolean()).optional()
 }).passthrough();
 function formatConfigIssues(error) {
   return error.issues.map((issue) => `  - ${issue.path.join(".") || "root"}: ${issue.message}`).join("\n");
@@ -27,7 +28,6 @@ function formatExpectedConfigExample() {
   return JSON.stringify(
     {
       version: CURRENT_CONFIG_VERSION,
-      snapshotModel: "openai/gpt-5.4",
       viewport: {
         width: 1280,
         height: 800
@@ -51,10 +51,9 @@ ${detail}` : null,
       "Expected config example:",
       formatExpectedConfigExample(),
       "Notes:",
-      '  - "snapshotModel", "viewport", "windowPosition", and "sessionMode" are optional.',
-      '  - "snapshotModel" 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 openai | anthropic | gemini | vertex | openrouter`
+      '  - "viewport", "windowPosition", and "sessionMode" are optional.',
+      '  - "snapshotModel" is deprecated and ignored by snapshot.',
+      "Fix the file to match this shape, or delete it and rerun setup."
     ].filter(Boolean).join("\n")
   );
 }

package/dist/cli/core/context.js

@@ -30,6 +30,9 @@ function getSessionNetworkLogPath(session) {
 function getSessionActionsLogPath(session) {
   return join(getSessionDir(session), "actions.jsonl");
 }
+function getSessionProviderClosePath(session) {
+  return join(getSessionDir(session), "provider-close.json");
+}
 function getSessionSnapshotsDir(session) {
   return join(getSessionDir(session), "snapshots");
 }
@@ -75,6 +78,7 @@ export {
   getSessionDir,
   getSessionLogsPath,
   getSessionNetworkLogPath,
+  getSessionProviderClosePath,
   getSessionSnapshotRunDir,
   getSessionSnapshotsDir,
   getSessionStatePath,

package/dist/cli/core/daemon/config.js

@@ -1,6 +0,0 @@
-function isConnectConfig(config) {
-  return "mode" in config && config.mode === "connect";
-}
-export {
-  isConnectConfig
-};