libretto 0.5.5 → 0.6.0

package/dist/cli/core/browser.js

@@ -19,16 +19,18 @@ 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,
   readSessionState,
   writeSessionState
 } from "./session.js";
+import { getCloudProviderApi } from "./providers/index.js";
 import { installSessionTelemetry } from "./session-telemetry.js";
 const CLOSE_WAIT_MS = 1500;
 const FORCE_CLOSE_WAIT_MS = 300;
@@ -178,6 +180,11 @@ async function connect(session, logger, timeoutMs = 1e4, options) {
       endpoint,
       pid: state.pid
     });
+    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}`
+      );
+    }
     if (state.pid == null || !isPidRunning(state.pid)) {
       clearSessionState(session, logger);
       throw new Error(
@@ -293,8 +300,16 @@ async function runOpen(rawUrl, headed, session, logger, options) {
   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);
@@ -523,6 +538,7 @@ await new Promise(() => {});
           session,
           startedAt: (/* @__PURE__ */ new Date()).toISOString(),
           status: "active",
+          mode: accessMode,
           viewport
         },
         logger
@@ -549,6 +565,86 @@ await new Promise(() => {});
     `Failed to connect to browser after ${Math.ceil(cdpStartupTimeoutMs / 1e3)}s. Check startup logs: ${runLogPath}`
   );
 }
+async function runOpenWithProvider(rawUrl, providerName, provider, session, logger, accessMode = "write-access") {
+  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
+  });
+  console.log(`Connecting to ${providerName} browser...`);
+  let browser = null;
+  try {
+    browser = await tryConnectToCDP(
+      providerSession.cdpEndpoint,
+      logger,
+      3e4
+    );
+    if (!browser) {
+      throw new Error(
+        `Could not connect to ${providerName} browser at ${providerSession.cdpEndpoint}. The remote session was created but CDP connection failed.`
+      );
+    }
+    const contexts = browser.contexts();
+    let page;
+    if (contexts.length > 0 && contexts[0].pages().length > 0) {
+      page = contexts[0].pages()[0];
+    } else {
+      const context = contexts.length > 0 ? contexts[0] : await browser.newContext();
+      page = await context.newPage();
+    }
+    await page.goto(url);
+    logger.info("open-provider-navigated", { url, session });
+    writeSessionState(
+      {
+        port: 0,
+        cdpEndpoint: providerSession.cdpEndpoint,
+        session,
+        startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        status: "active",
+        mode: accessMode,
+        provider: {
+          name: providerName,
+          sessionId: providerSession.sessionId
+        }
+      },
+      logger
+    );
+    disconnectBrowser(browser, logger, session);
+  } catch (err) {
+    if (browser) {
+      disconnectBrowser(browser, logger, session);
+    }
+    logger.warn("open-provider-cleanup-after-error", {
+      provider: providerName,
+      sessionId: providerSession.sessionId,
+      error: err
+    });
+    try {
+      await provider.closeSession(providerSession.sessionId);
+    } catch (cleanupErr) {
+      logger.warn("open-provider-cleanup-failed", {
+        provider: providerName,
+        sessionId: providerSession.sessionId,
+        error: cleanupErr
+      });
+    }
+    throw err;
+  }
+  logger.info("open-provider-success", {
+    url,
+    provider: providerName,
+    session,
+    sessionId: providerSession.sessionId
+  });
+  console.log(`Browser open (${providerName}): ${url}`);
+}
 async function runSave(urlOrDomain, session, logger) {
   logger.info("save-start", { urlOrDomain, session });
   const { browser, context, page } = await connect(session, logger);
@@ -621,10 +717,33 @@ async function runClose(session, logger) {
     console.log(`No browser running for session "${session}".`);
     return;
   }
-  logger.info("close-killing", { session, pid: state.pid, port: state.port });
-  if (state.pid != null) {
-    sendSignalToProcessGroupOrPid(state.pid, "SIGTERM", logger, session);
-    await waitForCloseSignalWindow(CLOSE_WAIT_MS);
+  if (state.provider) {
+    logger.info("close-provider", {
+      session,
+      provider: state.provider.name,
+      sessionId: state.provider.sessionId
+    });
+    try {
+      const provider = getCloudProviderApi(state.provider.name);
+      await provider.closeSession(state.provider.sessionId);
+    } 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}`
+      );
+    }
+  } else {
+    logger.info("close-killing", { session, pid: state.pid, port: state.port });
+    if (state.pid != null) {
+      sendSignalToProcessGroupOrPid(state.pid, "SIGTERM", logger, session);
+      await waitForCloseSignalWindow(CLOSE_WAIT_MS);
+    }
   }
   clearSessionState(session, logger);
   logger.info("close-success", { session });
@@ -633,14 +752,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);
@@ -674,14 +785,16 @@ function resolveClosableSessions(logger) {
     closable.push({
       session,
       pid: state.pid,
-      port: state.port
+      port: state.port,
+      provider: state.provider
     });
   }
   return { closable, clearedUnreadableStates };
 }
-function clearStoppedSessionStates(sessions, logger) {
+function clearStoppedSessionStates(sessions, logger, skip) {
   let cleared = 0;
   for (const session of sessions) {
+    if (skip?.has(session.session)) continue;
     if (session.pid == null || !isPidRunning(session.pid)) {
       clearSessionState(session.session, logger);
       cleared += 1;
@@ -702,7 +815,34 @@ async function runCloseAll(logger, options) {
     console.log("No browser sessions found.");
     return;
   }
+  const failedProviderSessions = /* @__PURE__ */ new Set();
   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);
+        await provider.closeSession(target.provider.sessionId);
+      } 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);
+        }
+      }
+    }
+  }
+  for (const target of closable) {
+    if (target.provider) continue;
     logger.info("close-all-sigterm", {
       session: target.session,
       pid: target.pid,
@@ -722,7 +862,11 @@ async function runCloseAll(logger, options) {
     (target) => target.pid != null && isPidRunning(target.pid)
   );
   if (survivors.length > 0 && !force) {
-    const closed = clearStoppedSessionStates(closable, logger);
+    const closed = clearStoppedSessionStates(
+      closable,
+      logger,
+      failedProviderSessions
+    );
     throw new Error(
       [
         `Failed to close ${survivors.length} session(s) gracefully: ${formatSessionList(survivors)}.`,
@@ -753,7 +897,11 @@ async function runCloseAll(logger, options) {
       (target) => target.pid != null && isPidRunning(target.pid)
     );
     if (survivors.length > 0) {
-      const closed = clearStoppedSessionStates(closable, logger);
+      const closed = clearStoppedSessionStates(
+        closable,
+        logger,
+        failedProviderSessions
+      );
       throw new Error(
         [
           `Failed to force-close ${survivors.length} session(s): ${formatSessionList(survivors)}.`,
@@ -762,19 +910,25 @@ async function runCloseAll(logger, options) {
       );
     }
   }
-  clearStoppedSessionStates(closable, logger);
+  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).`
     );
   }
-  console.log(`Closed ${closable.length} session(s).`);
+  const closedCount = closable.length - failedProviderSessions.size;
+  console.log(`Closed ${closedCount} session(s).`);
   if (forceKilled > 0) {
     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 {
@@ -784,28 +938,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) {
@@ -826,7 +990,8 @@ async function runConnect(cdpUrl, session, logger) {
       cdpEndpoint: endpoint,
       session,
       startedAt: (/* @__PURE__ */ new Date()).toISOString(),
-      status: "active"
+      status: "active",
+      mode: accessMode
     },
     logger
   );
@@ -865,6 +1030,7 @@ export {
   runCloseAll,
   runConnect,
   runOpen,
+  runOpenWithProvider,
   runPages,
   runSave
 };

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,10 @@ const LibrettoConfigSchema = z.object({
   version: z.literal(CURRENT_CONFIG_VERSION),
   ai: AiConfigSchema.optional(),
   viewport: ViewportConfigSchema.optional(),
-  windowPosition: WindowPositionConfigSchema.optional()
+  windowPosition: WindowPositionConfigSchema.optional(),
+  provider: z.string().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 +42,8 @@ function formatExpectedConfigExample() {
       windowPosition: {
         x: 1600,
         y: 120
-      }
+      },
+      sessionMode: "write-access"
     },
     null,
     2
@@ -73,10 +58,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 +97,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 +129,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 +138,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
 };