libretto 0.5.6 → 0.6.1

package/dist/cli/core/browser.js

@@ -30,6 +30,7 @@ import {
   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;
@@ -179,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(
@@ -559,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);
@@ -631,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 });
@@ -676,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;
@@ -704,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,
@@ -724,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)}.`,
@@ -755,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)}.`,
@@ -764,13 +910,19 @@ 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).`);
   }
@@ -878,6 +1030,7 @@ export {
   runCloseAll,
   runConnect,
   runOpen,
+  runOpenWithProvider,
   runPages,
   runSave
 };

package/dist/cli/core/config.js

@@ -21,6 +21,7 @@ const LibrettoConfigSchema = z.object({
   ai: AiConfigSchema.optional(),
   viewport: ViewportConfigSchema.optional(),
   windowPosition: WindowPositionConfigSchema.optional(),
+  provider: z.string().optional(),
   sessionMode: SessionAccessModeSchema.optional()
 }).passthrough();
 function formatConfigIssues(error) {

package/dist/cli/core/providers/browserbase.js

@@ -0,0 +1,53 @@
+function createBrowserbaseProvider() {
+  const apiKey = process.env.BROWSERBASE_API_KEY;
+  if (!apiKey)
+    throw new Error(
+      "BROWSERBASE_API_KEY is required for Browserbase provider."
+    );
+  const projectId = process.env.BROWSERBASE_PROJECT_ID;
+  if (!projectId)
+    throw new Error(
+      "BROWSERBASE_PROJECT_ID is required for Browserbase provider."
+    );
+  const endpoint = process.env.BROWSERBASE_ENDPOINT ?? "https://api.browserbase.com";
+  return {
+    async createSession() {
+      const resp = await fetch(`${endpoint}/v1/sessions`, {
+        method: "POST",
+        headers: {
+          "X-BB-API-Key": apiKey,
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({ projectId })
+      });
+      if (!resp.ok) {
+        const body = await resp.text();
+        throw new Error(`Browserbase API error (${resp.status}): ${body}`);
+      }
+      const json = await resp.json();
+      return {
+        sessionId: json.id,
+        cdpEndpoint: json.connectUrl
+      };
+    },
+    async closeSession(sessionId) {
+      const resp = await fetch(`${endpoint}/v1/sessions/${sessionId}`, {
+        method: "POST",
+        headers: {
+          "X-BB-API-Key": apiKey,
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({ status: "REQUEST_RELEASE" })
+      });
+      if (!resp.ok) {
+        const body = await resp.text();
+        throw new Error(
+          `Browserbase API error closing session ${sessionId} (${resp.status}): ${body}`
+        );
+      }
+    }
+  };
+}
+export {
+  createBrowserbaseProvider
+};

package/dist/cli/core/providers/index.js

@@ -0,0 +1,48 @@
+import { readLibrettoConfig } from "../config.js";
+import { createBrowserbaseProvider } from "./browserbase.js";
+import { createKernelProvider } from "./kernel.js";
+import { createLibrettoCloudProvider } from "./libretto-cloud.js";
+const VALID_PROVIDERS = /* @__PURE__ */ new Set(["local", "kernel", "browserbase", "libretto-cloud"]);
+function assertValidProviderName(value, source) {
+  if (!VALID_PROVIDERS.has(value)) {
+    throw new Error(
+      `Invalid provider "${value}" from ${source}. Valid providers: ${[...VALID_PROVIDERS].join(", ")}`
+    );
+  }
+  return value;
+}
+function resolveProviderName(cliFlag) {
+  if (cliFlag) {
+    return assertValidProviderName(cliFlag, "--provider flag");
+  }
+  const envVar = process.env.LIBRETTO_PROVIDER;
+  if (envVar) {
+    return assertValidProviderName(envVar, "LIBRETTO_PROVIDER env var");
+  }
+  const config = readLibrettoConfig();
+  if (config.provider) {
+    return assertValidProviderName(config.provider, "config file");
+  }
+  return "local";
+}
+function getCloudProviderApi(name) {
+  switch (name) {
+    case "kernel":
+      return createKernelProvider();
+    case "browserbase":
+      return createBrowserbaseProvider();
+    case "libretto-cloud":
+      console.warn(
+        "Note: The libretto-cloud provider is in alpha."
+      );
+      return createLibrettoCloudProvider();
+    default:
+      throw new Error(
+        `Unknown provider "${name}". Valid cloud providers: kernel, browserbase`
+      );
+  }
+}
+export {
+  getCloudProviderApi,
+  resolveProviderName
+};

package/dist/cli/core/providers/kernel.js

@@ -0,0 +1,46 @@
+function createKernelProvider() {
+  const apiKey = process.env.KERNEL_API_KEY;
+  if (!apiKey)
+    throw new Error("KERNEL_API_KEY is required for Kernel provider.");
+  const endpoint = process.env.KERNEL_ENDPOINT ?? "https://api.onkernel.com";
+  return {
+    async createSession() {
+      const resp = await fetch(`${endpoint}/browsers`, {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${apiKey}`,
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({
+          headless: process.env.KERNEL_HEADLESS !== "false",
+          stealth: process.env.KERNEL_STEALTH === "true",
+          timeout_seconds: Number(process.env.KERNEL_TIMEOUT_SECONDS ?? 300)
+        })
+      });
+      if (!resp.ok) {
+        const body = await resp.text();
+        throw new Error(`Kernel API error (${resp.status}): ${body}`);
+      }
+      const json = await resp.json();
+      return {
+        sessionId: json.session_id,
+        cdpEndpoint: json.cdp_ws_url
+      };
+    },
+    async closeSession(sessionId) {
+      const resp = await fetch(`${endpoint}/browsers/${sessionId}`, {
+        method: "DELETE",
+        headers: { Authorization: `Bearer ${apiKey}` }
+      });
+      if (!resp.ok) {
+        const body = await resp.text();
+        throw new Error(
+          `Kernel API error closing session ${sessionId} (${resp.status}): ${body}`
+        );
+      }
+    }
+  };
+}
+export {
+  createKernelProvider
+};

package/dist/cli/core/providers/libretto-cloud.js

@@ -0,0 +1,58 @@
+function createLibrettoCloudProvider() {
+  const apiKey = process.env.LIBRETTO_API_KEY;
+  if (!apiKey)
+    throw new Error(
+      "LIBRETTO_API_KEY is required for the Libretto Cloud provider."
+    );
+  const apiUrl = process.env.LIBRETTO_API_URL;
+  if (!apiUrl)
+    throw new Error(
+      "LIBRETTO_API_URL is required for the Libretto Cloud provider."
+    );
+  const endpoint = apiUrl.replace(/\/$/, "");
+  return {
+    async createSession() {
+      const timeoutSeconds = Number(
+        process.env.LIBRETTO_TIMEOUT_SECONDS ?? 7200
+      );
+      const resp = await fetch(`${endpoint}/v1/sessions/create`, {
+        method: "POST",
+        headers: {
+          "x-api-key": apiKey,
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({ timeout_seconds: timeoutSeconds })
+      });
+      if (!resp.ok) {
+        const body = await resp.text();
+        throw new Error(
+          `Libretto Cloud API error (${resp.status}): ${body}`
+        );
+      }
+      const json = await resp.json();
+      return {
+        sessionId: json.session_id,
+        cdpEndpoint: json.cdp_url
+      };
+    },
+    async closeSession(sessionId) {
+      const resp = await fetch(`${endpoint}/v1/sessions/close`, {
+        method: "POST",
+        headers: {
+          "x-api-key": apiKey,
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({ session_id: sessionId })
+      });
+      if (!resp.ok) {
+        const body = await resp.text();
+        throw new Error(
+          `Libretto Cloud API error closing session ${sessionId} (${resp.status}): ${body}`
+        );
+      }
+    }
+  };
+}
+export {
+  createLibrettoCloudProvider
+};

package/dist/cli/core/session.js

@@ -95,6 +95,10 @@ function listRunningSessions() {
   for (const name of sessions) {
     const state = readSessionState(name);
     if (!state) continue;
+    if (state.provider) {
+      running.push(state);
+      continue;
+    }
     if (state.pid == null || !isPidRunning(state.pid)) continue;
     running.push(state);
   }
@@ -207,6 +211,11 @@ function setSessionStatus(session, status, logger) {
 function assertSessionAvailableForStart(session, logger) {
   const existingState = readSessionState(session, logger);
   if (!existingState) return;
+  if (existingState.provider && existingState.cdpEndpoint) {
+    throw new Error(
+      `Session "${session}" is already open via ${existingState.provider.name} provider. Close it first with: libretto close --session ${session}`
+    );
+  }
   if (existingState.pid == null || !isPidRunning(existingState.pid)) {
     setSessionStatus(session, "exited", logger);
     return;

package/dist/cli/workers/run-integration-runtime.js

@@ -158,7 +158,9 @@ async function runIntegrationInternal(args, options) {
     headless: args.headless,
     storageStatePath,
     viewport: args.viewport,
-    accessMode: args.accessMode
+    accessMode: args.accessMode,
+    cdpEndpoint: args.cdpEndpoint,
+    provider: args.provider
   });
   if (!args.headless && args.visualize !== false) {
     await installHeadedWorkflowVisualization({

package/dist/cli/workers/run-integration-worker-protocol.js

@@ -8,7 +8,9 @@ const RunIntegrationWorkerRequestSchema = z.object({
   visualize: z.boolean().default(true),
   authProfileDomain: z.string().optional(),
   viewport: z.object({ width: z.number(), height: z.number() }).optional(),
-  accessMode: SessionAccessModeSchema.default("write-access")
+  accessMode: SessionAccessModeSchema.default("write-access"),
+  cdpEndpoint: z.string().optional(),
+  provider: z.object({ name: z.string(), sessionId: z.string() }).optional()
 });
 export {
   RunIntegrationWorkerRequestSchema

package/dist/shared/run/browser.d.ts

@@ -11,6 +11,11 @@ type LaunchBrowserArgs = {
     };
     storageStatePath?: string;
     accessMode?: SessionAccessMode;
+    cdpEndpoint?: string;
+    provider?: {
+        name: string;
+        sessionId: string;
+    };
 };
 type BrowserSession = {
     browser: Browser;
@@ -20,6 +25,6 @@ type BrowserSession = {
     metadataPath: string;
     close: () => Promise<void>;
 };
-declare function launchBrowser({ sessionName, headless, viewport, storageStatePath, accessMode, }: LaunchBrowserArgs): Promise<BrowserSession>;
+declare function launchBrowser({ sessionName, headless, viewport, storageStatePath, accessMode, cdpEndpoint, provider, }: LaunchBrowserArgs): Promise<BrowserSession>;
 
 export { type BrowserSession, type LaunchBrowserArgs, launchBrowser };

package/dist/shared/run/browser.js

@@ -64,8 +64,46 @@ async function launchBrowser({
   headless = false,
   viewport = { width: 1366, height: 768 },
   storageStatePath,
-  accessMode = "write-access"
+  accessMode = "write-access",
+  cdpEndpoint,
+  provider
 }) {
+  if (cdpEndpoint) {
+    const browser2 = await chromium.connectOverCDP(cdpEndpoint);
+    const context2 = browser2.contexts()[0] ?? await browser2.newContext({ viewport });
+    const page2 = context2.pages()[0] ?? await context2.newPage();
+    page2.setDefaultTimeout(3e4);
+    page2.setDefaultNavigationTimeout(45e3);
+    const metadataPath2 = ensureLibrettoSessionStatePath(sessionName);
+    writeFileSync(
+      metadataPath2,
+      JSON.stringify(
+        {
+          version: SESSION_STATE_VERSION,
+          session: sessionName,
+          port: 0,
+          cdpEndpoint,
+          pid: process.pid,
+          startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+          status: "active",
+          mode: accessMode,
+          ...provider ? { provider } : {}
+        },
+        null,
+        2
+      )
+    );
+    return {
+      browser: browser2,
+      context: context2,
+      page: page2,
+      debugPort: 0,
+      metadataPath: metadataPath2,
+      close: async () => {
+        await browser2.close();
+      }
+    };
+  }
   const debugPort = await pickFreePort();
   const windowPosition = headless ? void 0 : resolveWindowPosition();
   const browser = await chromium.launch({

package/dist/shared/state/session-state.d.ts

@@ -7,6 +7,7 @@ declare const SessionStatusSchema: z.ZodEnum<{
     completed: "completed";
     failed: "failed";
     exited: "exited";
+    "cleanup-failed": "cleanup-failed";
 }>;
 declare const SessionAccessModeSchema: z.ZodEnum<{
     "read-only": "read-only";
@@ -16,6 +17,10 @@ declare const SessionViewportSchema: z.ZodObject<{
     width: z.ZodNumber;
     height: z.ZodNumber;
 }, z.core.$strip>;
+declare const ProviderStateSchema: z.ZodObject<{
+    name: z.ZodString;
+    sessionId: z.ZodString;
+}, z.core.$strip>;
 declare const SessionStateFileSchema: z.ZodObject<{
     version: z.ZodLiteral<1>;
     port: z.ZodNumber;
@@ -29,6 +34,7 @@ declare const SessionStateFileSchema: z.ZodObject<{
         completed: "completed";
         failed: "failed";
         exited: "exited";
+        "cleanup-failed": "cleanup-failed";
     }>>;
     mode: z.ZodDefault<z.ZodEnum<{
         "read-only": "read-only";
@@ -38,6 +44,10 @@ declare const SessionStateFileSchema: z.ZodObject<{
         width: z.ZodNumber;
         height: z.ZodNumber;
     }, z.core.$strip>>;
+    provider: z.ZodOptional<z.ZodObject<{
+        name: z.ZodString;
+        sessionId: z.ZodString;
+    }, z.core.$strip>>;
 }, z.core.$strip>;
 type SessionStatus = z.infer<typeof SessionStatusSchema>;
 type SessionAccessMode = z.infer<typeof SessionAccessModeSchema>;
@@ -47,4 +57,4 @@ declare function parseSessionStateData(rawState: unknown, source: string): Sessi
 declare function parseSessionStateContent(content: string, source: string): SessionState;
 declare function serializeSessionState(state: SessionState): SessionStateFile;
 
-export { SESSION_STATE_VERSION, type SessionAccessMode, SessionAccessModeSchema, type SessionState, type SessionStateFile, SessionStateFileSchema, type SessionStatus, SessionStatusSchema, SessionViewportSchema, parseSessionStateContent, parseSessionStateData, serializeSessionState };
+export { ProviderStateSchema, SESSION_STATE_VERSION, type SessionAccessMode, SessionAccessModeSchema, type SessionState, type SessionStateFile, SessionStateFileSchema, type SessionStatus, SessionStatusSchema, SessionViewportSchema, parseSessionStateContent, parseSessionStateData, serializeSessionState };

package/dist/shared/state/session-state.js

@@ -5,13 +5,18 @@ const SessionStatusSchema = z.enum([
   "paused",
   "completed",
   "failed",
-  "exited"
+  "exited",
+  "cleanup-failed"
 ]);
 const SessionAccessModeSchema = z.enum(["read-only", "write-access"]);
 const SessionViewportSchema = z.object({
   width: z.number().int().min(1),
   height: z.number().int().min(1)
 });
+const ProviderStateSchema = z.object({
+  name: z.string(),
+  sessionId: z.string()
+});
 const SessionStateFileSchema = z.object({
   version: z.literal(SESSION_STATE_VERSION),
   port: z.number().int().min(0).max(65535),
@@ -21,7 +26,8 @@ const SessionStateFileSchema = z.object({
   startedAt: z.string().datetime({ offset: true }),
   status: SessionStatusSchema.optional(),
   mode: SessionAccessModeSchema.default("write-access"),
-  viewport: SessionViewportSchema.optional()
+  viewport: SessionViewportSchema.optional(),
+  provider: ProviderStateSchema.optional()
 });
 function formatIssues(error) {
   return error.issues.map((issue) => {
@@ -57,6 +63,7 @@ function serializeSessionState(state) {
   });
 }
 export {
+  ProviderStateSchema,
   SESSION_STATE_VERSION,
   SessionAccessModeSchema,
   SessionStateFileSchema,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "libretto",
-  "version": "0.5.6",
+  "version": "0.6.1",
   "description": "AI-powered browser automation library and CLI built on Playwright",
   "license": "MIT",
   "repository": {

package/skills/AGENTS.md

@@ -9,3 +9,4 @@
 
 - Run `pnpm sync:mirrors` after changing anything under `skills/`.
 - Run `pnpm check:mirrors` to verify that generated READMEs, skill mirrors, and skill version metadata are in sync.
+