libretto 0.5.4 → 0.5.6

package/dist/cli/core/skill-version.js

@@ -0,0 +1,73 @@
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { REPO_ROOT } from "./context.js";
+const INSTALLED_SKILL_PATHS = [
+  [".agents", "skills", "libretto", "SKILL.md"],
+  [".claude", "skills", "libretto", "SKILL.md"]
+];
+let cachedCliVersion = null;
+function readCurrentCliVersion() {
+  if (cachedCliVersion) {
+    return cachedCliVersion;
+  }
+  const packageJsonPath = fileURLToPath(
+    new URL("../../../package.json", import.meta.url)
+  );
+  const manifest = JSON.parse(
+    readFileSync(packageJsonPath, "utf8")
+  );
+  if (!manifest.version) {
+    throw new Error(
+      `Unable to determine current libretto version from ${packageJsonPath}.`
+    );
+  }
+  cachedCliVersion = manifest.version;
+  return cachedCliVersion;
+}
+function readInstalledSkillVersion(skillPath) {
+  if (!existsSync(skillPath)) {
+    return null;
+  }
+  const contents = readFileSync(skillPath, "utf8");
+  const frontmatterMatch = contents.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+  if (!frontmatterMatch) {
+    return null;
+  }
+  const metadataBlock = frontmatterMatch[1].match(
+    /^metadata:\s*\r?\n((?:[ \t]+.*(?:\r?\n|$))*)/m
+  )?.[1];
+  if (!metadataBlock) {
+    return null;
+  }
+  const versionMatch = metadataBlock.match(
+    /^[ \t]+version:\s*["']?([^"'\r\n]+)["']?\s*$/m
+  );
+  return versionMatch?.[1]?.trim() ?? null;
+}
+function findInstalledSkillVersionMismatch() {
+  const cliVersion = readCurrentCliVersion();
+  for (const relativePathParts of INSTALLED_SKILL_PATHS) {
+    const skillPath = join(REPO_ROOT, ...relativePathParts);
+    const installedVersion = readInstalledSkillVersion(skillPath);
+    if (installedVersion && installedVersion !== cliVersion) {
+      return { installedVersion, cliVersion };
+    }
+  }
+  return null;
+}
+function warnIfInstalledSkillOutOfDate() {
+  try {
+    const mismatch = findInstalledSkillVersionMismatch();
+    if (!mismatch) {
+      return;
+    }
+    console.error(
+      `Warning: Your agent skill (${mismatch.installedVersion}) is out of date with your Libretto CLI (${mismatch.cliVersion}). Please run \`npx libretto setup\` to update your skills to the correct version.`
+    );
+  } catch {
+  }
+}
+export {
+  warnIfInstalledSkillOutOfDate
+};

package/dist/cli/core/telemetry.js

@@ -1,8 +1,7 @@
 import {
   appendFileSync,
   existsSync,
-  readFileSync,
-  writeFileSync
+  readFileSync
 } from "node:fs";
 import {
   getSessionActionsLogPath,
@@ -34,30 +33,6 @@ function readNetworkLog(session, opts = {}) {
   }
   return entries;
 }
-function formatNetworkEntry(e) {
-  const time = e.ts.replace(/.*T/, "").replace(/\.\d+Z$/, "");
-  const duration = e.durationMs != null ? `${e.durationMs}ms` : "?ms";
-  const size = e.size != null ? `${e.size}B` : "";
-  const parts = [
-    `[${time}]`,
-    `${e.status}`,
-    `${e.method.padEnd(6)}`,
-    e.url,
-    duration,
-    size
-  ].filter(Boolean);
-  let line = parts.join(" ");
-  if (e.postData) {
-    line += `
-         body: ${e.postData.substring(0, 120)}${e.postData.length > 120 ? "..." : ""}`;
-  }
-  return line;
-}
-function clearNetworkLog(session) {
-  assertSessionStateExistsOrThrow(session);
-  const logPath = getSessionNetworkLogPath(session);
-  writeFileSync(logPath, "");
-}
 function parentLogAction(session, entry) {
   try {
     const record = { ts: (/* @__PURE__ */ new Date()).toISOString(), ...entry };
@@ -99,30 +74,6 @@ function readActionLog(session, opts = {}) {
   }
   return entries;
 }
-function formatActionEntry(e) {
-  const time = e.ts.replace(/.*T/, "").replace(/\.\d+Z$/, "");
-  const src = e.source.toUpperCase().padEnd(5);
-  const displaySelector = e.bestSemanticSelector || e.selector;
-  const parts = [`[${time}]`, `[${src}]`, e.action];
-  if (displaySelector) parts.push(displaySelector);
-  if (e.targetSelector && e.targetSelector !== displaySelector) {
-    parts.push(`target=${e.targetSelector}`);
-  }
-  if (e.nearbyText) parts.push(`text="${e.nearbyText}"`);
-  if (e.coordinates) {
-    parts.push(`@(${e.coordinates.x},${e.coordinates.y})`);
-  }
-  if (e.value) parts.push(`"${e.value}"`);
-  if (e.url) parts.push(e.url);
-  if (e.duration != null) parts.push(`${e.duration}ms`);
-  if (!e.success) parts.push(`ERROR: ${e.error || "unknown"}`);
-  return parts.join(" ");
-}
-function clearActionLog(session) {
-  assertSessionStateExistsOrThrow(session);
-  const logPath = getSessionActionsLogPath(session);
-  writeFileSync(logPath, "");
-}
 const LOCATOR_ACTION_METHODS = [
   "click",
   "dblclick",
@@ -367,10 +318,6 @@ function wrapPageForActionLogging(page, session, pageId, onActivity) {
   }
 }
 export {
-  clearActionLog,
-  clearNetworkLog,
-  formatActionEntry,
-  formatNetworkEntry,
   parentLogAction,
   readActionLog,
   readNetworkLog,

package/dist/cli/index.js

@@ -1,14 +1,8 @@
 #!/usr/bin/env node
 import { runLibrettoCLI } from "./cli.js";
-import {
-  maybeConfigureLLMClientFactoryFromEnv,
-  setLLMClientFactory
-} from "./core/context.js";
 import { runClose } from "./commands/browser.js";
-maybeConfigureLLMClientFactoryFromEnv();
 void runLibrettoCLI();
 export {
   runClose,
-  runLibrettoCLI,
-  setLLMClientFactory
+  runLibrettoCLI
 };

package/dist/cli/router.js

@@ -2,17 +2,17 @@ import { aiCommands } from "./commands/ai.js";
 import { browserCommands } from "./commands/browser.js";
 import { deployCommand } from "./commands/deploy.js";
 import { executionCommands } from "./commands/execution.js";
-import { initCommand } from "./commands/init.js";
-import { logCommands } from "./commands/logs.js";
+import { setupCommand } from "./commands/setup.js";
+import { statusCommand } from "./commands/status.js";
 import { snapshotCommand } from "./commands/snapshot.js";
 import { SimpleCLI } from "./framework/simple-cli.js";
 const cliRoutes = {
   ...browserCommands,
   deploy: deployCommand,
   ...executionCommands,
-  ...logCommands,
   ai: aiCommands,
-  init: initCommand,
+  setup: setupCommand,
+  status: statusCommand,
   snapshot: snapshotCommand
 };
 function createCLIApp() {

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

@@ -4,13 +4,17 @@ import { cwd } from "node:process";
 import { isAbsolute, resolve } from "node:path";
 import { pathToFileURL } from "node:url";
 import {
-  getWorkflowFromModuleExports,
+  getDefaultWorkflowFromModuleExports,
   getWorkflowsFromModuleExports,
   instrumentContext,
   launchBrowser
 } from "../../index.js";
 import { parseSessionStateContent } from "../../shared/state/index.js";
-import { getProfilePath, normalizeDomain } from "../core/browser.js";
+import {
+  getProfilePath,
+  normalizeDomain,
+  normalizeUrl
+} from "../core/browser.js";
 import {
   getSessionActionsLogPath,
   getSessionNetworkLogPath,
@@ -68,18 +72,14 @@ async function waitForFailureSessionRelease(args) {
     );
   }
 }
-function resolveLocalAuthProfilePath(domain) {
-  return getProfilePath(normalizeDomain(domain));
-}
 function getMissingLocalAuthProfileError(args) {
-  const normalizedDomain = normalizeDomain(args.domain);
   return [
-    `Local auth profile not found for domain "${normalizedDomain}".`,
+    `Local auth profile not found for domain "${args.normalizedDomain}".`,
     `Expected profile file: ${args.profilePath}`,
     "To create it:",
-    `  1. libretto open https://${normalizedDomain} --headed --session ${args.session}`,
+    `  1. libretto open https://${args.normalizedDomain} --headed --session ${args.session}`,
     "  2. Log in manually in the browser window.",
-    `  3. libretto save ${normalizedDomain} --session ${args.session}`
+    `  3. libretto save ${args.normalizedDomain} --session ${args.session}`
   ].join("\n");
 }
 function getAbsoluteIntegrationPath(integrationPath) {
@@ -89,7 +89,7 @@ function getAbsoluteIntegrationPath(integrationPath) {
   }
   return absolutePath;
 }
-async function loadWorkflowByName(absolutePath, workflowName) {
+async function loadDefaultWorkflow(absolutePath) {
   let loadedModule;
   try {
     loadedModule = await import(pathToFileURL(absolutePath).href);
@@ -101,16 +101,20 @@ ${TSCONFIG_HINT}` : "";
       `Failed to import integration module at ${absolutePath}: ${message}${compileHint}`
     );
   }
-  const workflow = getWorkflowFromModuleExports(loadedModule, workflowName);
-  if (workflow) {
-    return workflow;
+  const defaultWorkflow = getDefaultWorkflowFromModuleExports(loadedModule);
+  if (defaultWorkflow) {
+    return defaultWorkflow;
   }
-  const availableWorkflows = getWorkflowsFromModuleExports(loadedModule).map(
+  const availableWorkflowNames = getWorkflowsFromModuleExports(loadedModule).map(
     (candidate) => candidate.name
   );
-  const detail = availableWorkflows.length > 0 ? ` Available workflows: ${availableWorkflows.join(", ")}` : ' No workflows found in this file. Export a workflow() instance from "libretto" directly or via `export const workflows = { ... }`.';
+  if (availableWorkflowNames.length === 0) {
+    throw new Error(
+      `No default-exported workflow found in ${absolutePath}. Export the workflow with \`export default workflow("name", handler)\`.`
+    );
+  }
   throw new Error(
-    `Workflow "${workflowName}" not found in ${absolutePath}.${detail}`
+    `No default-exported workflow found in ${absolutePath}. libretto run only uses the file's default export. Available named workflows: ${availableWorkflowNames.join(", ")}`
   );
 }
 async function installHeadedWorkflowVisualization(args) {
@@ -122,7 +126,7 @@ async function installHeadedWorkflowVisualization(args) {
 async function runIntegrationInternal(args, options) {
   const { logger } = options;
   const absolutePath = getAbsoluteIntegrationPath(args.integrationPath);
-  const workflow = await loadWorkflowByName(absolutePath, args.workflowName);
+  const workflow = await loadDefaultWorkflow(absolutePath);
   const signalPaths = getPauseSignalPaths(args.session);
   await removeSignalIfExists(signalPaths.pausedSignalPath);
   await removeSignalIfExists(signalPaths.resumeSignalPath);
@@ -130,19 +134,20 @@ async function runIntegrationInternal(args, options) {
   await removeSignalIfExists(signalPaths.failedSignalPath);
   const restoreStdout = mirrorStdoutToFile(signalPaths.outputSignalPath);
   console.log(
-    `Running workflow "${args.workflowName}" from ${absolutePath} (${args.headless ? "headless" : "headed"})...`
+    `Running workflow "${workflow.name}" from ${absolutePath} (${args.headless ? "headless" : "headed"})...`
   );
   const integrationLogger = logger.withScope("integration-run", {
     integrationPath: absolutePath,
-    workflowName: args.workflowName,
+    workflowName: workflow.name,
     session: args.session
   });
   const authProfileDomain = args.authProfileDomain;
-  const storageStatePath = authProfileDomain ? resolveLocalAuthProfilePath(authProfileDomain) : void 0;
-  if (authProfileDomain && storageStatePath && !existsSync(storageStatePath)) {
+  const normalizedAuthProfileDomain = authProfileDomain ? normalizeDomain(normalizeUrl(authProfileDomain)) : void 0;
+  const storageStatePath = normalizedAuthProfileDomain ? getProfilePath(normalizedAuthProfileDomain) : void 0;
+  if (normalizedAuthProfileDomain && storageStatePath && !existsSync(storageStatePath)) {
     throw new Error(
       getMissingLocalAuthProfileError({
-        domain: authProfileDomain,
+        normalizedDomain: normalizedAuthProfileDomain,
         profilePath: storageStatePath,
         session: args.session
       })
@@ -152,7 +157,8 @@ async function runIntegrationInternal(args, options) {
     sessionName: args.session,
     headless: args.headless,
     storageStatePath,
-    viewport: args.viewport
+    viewport: args.viewport,
+    accessMode: args.accessMode
   });
   if (!args.headless && args.visualize !== false) {
     await installHeadedWorkflowVisualization({
@@ -175,7 +181,6 @@ async function runIntegrationInternal(args, options) {
   });
   const workflowContext = {
     session: args.session,
-    logger: integrationLogger,
     page: browserSession.page
   };
   try {
@@ -208,7 +213,6 @@ async function runIntegrationInternal(args, options) {
       JSON.stringify({ completedAt: (/* @__PURE__ */ new Date()).toISOString() }, null, 2),
       "utf8"
     );
-    console.log("Integration completed.");
     return { status: "completed" };
   } finally {
     restoreStdout();

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

@@ -1,13 +1,14 @@
 import { z } from "zod";
+import { SessionAccessModeSchema } from "../../shared/state/index.js";
 const RunIntegrationWorkerRequestSchema = z.object({
   integrationPath: z.string().min(1),
-  workflowName: z.string().min(1),
   session: z.string().min(1),
   params: z.unknown(),
   headless: z.boolean(),
   visualize: z.boolean().default(true),
   authProfileDomain: z.string().optional(),
-  viewport: z.object({ width: z.number(), height: z.number() }).optional()
+  viewport: z.object({ width: z.number(), height: z.number() }).optional(),
+  accessMode: SessionAccessModeSchema.default("write-access")
 });
 export {
   RunIntegrationWorkerRequestSchema

package/dist/index.d.ts

@@ -1,7 +1,5 @@
 export { LogOptions, Logger, LoggerApi, LoggerSink, MinimalLogger, defaultLogger } from './shared/logger/logger.js';
 export { createFileLogSink, jsonlConsoleSink, prettyConsoleSink } from './shared/logger/sinks.js';
-export { LLMClient, Message, MessageContentPart } from './shared/llm/types.js';
-export { createLLMClientFromModel } from './shared/llm/ai-sdk-adapter.js';
 export { SESSION_STATE_VERSION, SessionState, SessionStateFile, SessionStateFileSchema, SessionStatus, SessionStatusSchema, parseSessionStateContent, parseSessionStateData, serializeSessionState } from './shared/state/session-state.js';
 export { executeRecoveryAgent } from './runtime/recovery/agent.js';
 export { attemptWithRecovery } from './runtime/recovery/recovery.js';
@@ -14,7 +12,7 @@ export { InstrumentationOptions, InstrumentedPage, installInstrumentation, instr
 export { GhostCursorOptions, ensureGhostCursor, ghostClick, hideGhostCursor, moveGhostCursor } from './shared/visualization/ghost-cursor.js';
 export { HighlightOptions, clearHighlights, ensureHighlightLayer, showHighlight } from './shared/visualization/highlight.js';
 export { BrowserSession, LaunchBrowserArgs, launchBrowser } from './shared/run/browser.js';
-export { ExportedLibrettoWorkflow, LIBRETTO_WORKFLOW_BRAND, LibrettoWorkflow, LibrettoWorkflowContext, LibrettoWorkflowHandler, getWorkflowFromModuleExports, getWorkflowsFromModuleExports, isLibrettoWorkflow, workflow } from './shared/workflow/workflow.js';
+export { ExportedLibrettoWorkflow, LIBRETTO_WORKFLOW_BRAND, LibrettoWorkflow, LibrettoWorkflowContext, LibrettoWorkflowHandler, getDefaultWorkflowFromModuleExports, getWorkflowFromModuleExports, getWorkflowsFromModuleExports, isLibrettoWorkflow, workflow } from './shared/workflow/workflow.js';
 import 'zod';
-import 'ai';
 import 'playwright';
+import 'ai';

package/dist/index.js

@@ -9,7 +9,6 @@ import {
   prettyConsoleSink,
   jsonlConsoleSink
 } from "./shared/logger/sinks.js";
-import { createLLMClientFromModel } from "./shared/llm/ai-sdk-adapter.js";
 import {
   SESSION_STATE_VERSION,
   SessionStatusSchema,
@@ -54,6 +53,7 @@ import {
   launchBrowser
 } from "./shared/run/api.js";
 import {
+  getDefaultWorkflowFromModuleExports,
   getWorkflowFromModuleExports,
   getWorkflowsFromModuleExports,
   isLibrettoWorkflow,
@@ -86,7 +86,6 @@ export {
   attemptWithRecovery,
   clearHighlights,
   createFileLogSink,
-  createLLMClientFromModel,
   defaultLogger,
   detectSubmissionError,
   downloadAndSave,
@@ -95,6 +94,7 @@ export {
   ensureHighlightLayer,
   executeRecoveryAgent,
   extractFromPage,
+  getDefaultWorkflowFromModuleExports,
   getWorkflowFromModuleExports,
   getWorkflowsFromModuleExports,
   ghostClick,

package/dist/runtime/extract/extract.d.ts

@@ -1,13 +1,13 @@
 import { Page } from 'playwright';
 import z from 'zod';
 import { MinimalLogger } from '../../shared/logger/logger.js';
-import { LLMClient } from '../../shared/llm/types.js';
+import { LanguageModel } from 'ai';
 
 type ExtractOptions<T extends z.ZodType> = {
     page: Page;
     instruction: string;
     schema: T;
-    llmClient: LLMClient;
+    model: LanguageModel;
     logger?: MinimalLogger;
     /** Optional CSS selector to scope extraction to a specific element. */
     selector?: string;

package/dist/runtime/extract/extract.js

@@ -1,6 +1,7 @@
 import {
   defaultLogger
 } from "../../shared/logger/logger.js";
+import { generateObject } from "ai";
 async function extractFromPage(options) {
   const {
     page,
@@ -8,7 +9,7 @@ async function extractFromPage(options) {
     schema,
     selector,
     logger = defaultLogger,
-    llmClient
+    model
   } = options;
   let screenshot;
   let domContent;
@@ -49,7 +50,8 @@ ${domContent}
 </html>` : ""}
 
 Extract the requested information from the screenshot and return it in the specified format. Be precise and only extract what is visible.`;
-  const result = await llmClient.generateObjectFromMessages({
+  const { object: result } = await generateObject({
+    model,
     schema,
     messages: [
       {

package/dist/runtime/extract/index.d.ts

@@ -2,4 +2,4 @@ export { ExtractOptions, extractFromPage } from './extract.js';
 import 'playwright';
 import 'zod';
 import '../../shared/logger/logger.js';
-import '../../shared/llm/types.js';
+import 'ai';

package/dist/runtime/recovery/agent.d.ts

@@ -1,13 +1,12 @@
 import { Page } from 'playwright';
 import { MinimalLogger } from '../../shared/logger/logger.js';
-import { LLMClient } from '../../shared/llm/types.js';
-import 'zod';
+import { LanguageModel } from 'ai';
 
 /**
  * Executes a vision-based recovery agent to recover from browser automation failures.
  * Takes a screenshot, sends it to the LLM with the instruction, and executes
  * the LLM's suggested browser actions.
  */
-declare function executeRecoveryAgent(page: Page, instruction: string, logger?: MinimalLogger, llmClient?: LLMClient): Promise<void>;
+declare function executeRecoveryAgent(page: Page, instruction: string, logger?: MinimalLogger, model?: LanguageModel): Promise<void>;
 
 export { executeRecoveryAgent };

package/dist/runtime/recovery/agent.js

@@ -1,6 +1,7 @@
 import {
   defaultLogger
 } from "../../shared/logger/logger.js";
+import { generateObject } from "ai";
 function delay(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
@@ -137,8 +138,8 @@ const recoveryActionSchema = z.object({
     })
   ])
 });
-async function executeRecoveryAgent(page, instruction, logger, llmClient) {
-  if (!llmClient) {
+async function executeRecoveryAgent(page, instruction, logger, model) {
+  if (!model) {
     return;
   }
   const log = logger ?? defaultLogger;
@@ -158,7 +159,8 @@ async function executeRecoveryAgent(page, instruction, logger, llmClient) {
   }
   const maxSteps = 3;
   for (let step = 1; step <= maxSteps; step++) {
-    const result = await llmClient.generateObjectFromMessages({
+    const { object: result } = await generateObject({
+      model,
       schema: recoveryActionSchema,
       messages: [
         {

package/dist/runtime/recovery/errors.d.ts

@@ -1,7 +1,6 @@
 import { Page } from 'playwright';
 import { MinimalLogger } from '../../shared/logger/logger.js';
-import { LLMClient } from '../../shared/llm/types.js';
-import 'zod';
+import { LanguageModel } from 'ai';
 
 /**
  * Known error type for classifying submission errors.
@@ -26,6 +25,6 @@ type DetectedSubmissionError = {
  * @returns DetectedSubmissionError if a known error is matched
  * @throws The original error if no known error matches
  */
-declare function detectSubmissionError(page: Page, error: unknown, logContext: string, llmClient: LLMClient, knownErrors?: KnownSubmissionError[], logger?: MinimalLogger): Promise<DetectedSubmissionError>;
+declare function detectSubmissionError(page: Page, error: unknown, logContext: string, model: LanguageModel, knownErrors?: KnownSubmissionError[], logger?: MinimalLogger): Promise<DetectedSubmissionError>;
 
 export { type DetectedSubmissionError, type KnownSubmissionError, detectSubmissionError };

package/dist/runtime/recovery/errors.js

@@ -1,13 +1,14 @@
 import {
   defaultLogger
 } from "../../shared/logger/logger.js";
+import { generateObject } from "ai";
 import { z } from "zod";
 const detectSubmissionErrorSchema = z.object({
   hasError: z.boolean().describe("Whether an error is visible on the page"),
   matchedKnownErrorId: z.string().nullable().describe("The ID of the matched known error, or null if no match"),
   errorMessage: z.string().nullable().describe("The error message visible on screen, or null if no error")
 });
-async function detectSubmissionError(page, error, logContext, llmClient, knownErrors = [], logger) {
+async function detectSubmissionError(page, error, logContext, model, knownErrors = [], logger) {
   const log = logger ?? defaultLogger;
   let screenshot;
   let domSnapshot;
@@ -58,7 +59,8 @@ IMPORTANT:
 ${domSnapshot ? `<dom_snapshot>
 ${domSnapshot}
 </dom_snapshot>` : ""}`;
-  const result = await llmClient.generateObjectFromMessages({
+  const { object: result } = await generateObject({
+    model,
     schema: detectSubmissionErrorSchema,
     messages: [
       {

package/dist/runtime/recovery/index.d.ts

@@ -3,5 +3,4 @@ export { attemptWithRecovery } from './recovery.js';
 export { DetectedSubmissionError, KnownSubmissionError, detectSubmissionError } from './errors.js';
 import 'playwright';
 import '../../shared/logger/logger.js';
-import '../../shared/llm/types.js';
-import 'zod';
+import 'ai';

package/dist/runtime/recovery/recovery.d.ts

@@ -1,12 +1,11 @@
 import { Page } from 'playwright';
 import { MinimalLogger } from '../../shared/logger/logger.js';
-import { LLMClient } from '../../shared/llm/types.js';
-import 'zod';
+import { LanguageModel } from 'ai';
 
 /**
  * Attempts to execute a function, and if it fails, runs popup recovery
  * (if an LLM client is provided) and retries the function once.
  */
-declare function attemptWithRecovery<T>(page: Page, fn: () => Promise<T>, logger?: MinimalLogger, llmClient?: LLMClient): Promise<T>;
+declare function attemptWithRecovery<T>(page: Page, fn: () => Promise<T>, logger?: MinimalLogger, model?: LanguageModel): Promise<T>;
 
 export { attemptWithRecovery };

package/dist/runtime/recovery/recovery.js

@@ -2,7 +2,7 @@ import {
   defaultLogger
 } from "../../shared/logger/logger.js";
 import { executeRecoveryAgent } from "./agent.js";
-async function attemptWithRecovery(page, fn, logger, llmClient) {
+async function attemptWithRecovery(page, fn, logger, model) {
   const log = logger ?? defaultLogger;
   try {
     return await fn();
@@ -13,7 +13,7 @@ async function attemptWithRecovery(page, fn, logger, llmClient) {
       });
       throw error;
     }
-    if (!llmClient) {
+    if (!model) {
       throw error;
     }
     log.info("Action failed, attempting popup recovery", {
@@ -23,7 +23,7 @@ async function attemptWithRecovery(page, fn, logger, llmClient) {
       page,
       "Look at the page to see if there is a popup blocking the screen. If so, close the popup.",
       log,
-      llmClient
+      model
     );
     return await fn();
   }

package/dist/shared/debug/pause.js

@@ -5,31 +5,14 @@ import {
   getPauseSignalPaths,
   removeSignalIfExists
 } from "../../cli/core/pause-signals.js";
-import {
-  listSessionsWithStateFile,
-  readSessionState
-} from "../../cli/core/session.js";
-function isPidRunning(pid) {
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch {
-    return false;
-  }
-}
-function getRunningSessions() {
-  return listSessionsWithStateFile().filter((candidate) => {
-    const state = readSessionState(candidate);
-    return state !== null && state.pid != null && isPidRunning(state.pid);
-  });
-}
+import { listRunningSessions } from "../../cli/core/session.js";
 function throwMissingSessionError() {
-  const runningSessions = getRunningSessions();
+  const runningSessions = listRunningSessions();
   const lines = ["pause(session) requires a non-empty session ID."];
   if (runningSessions.length > 0) {
     lines.push("", "Running sessions:");
-    for (const runningSession of runningSessions) {
-      lines.push(`  ${runningSession}`);
+    for (const s of runningSessions) {
+      lines.push(`  ${s.session}`);
     }
   }
   throw new Error(lines.join("\n"));

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

@@ -1,2 +1,4 @@
 export { BrowserSession, LaunchBrowserArgs, launchBrowser } from './browser.js';
 import 'playwright';
+import '../state/session-state.js';
+import 'zod';

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

@@ -1,4 +1,6 @@
 import { Browser, BrowserContext, Page } from 'playwright';
+import { SessionAccessMode } from '../state/session-state.js';
+import 'zod';
 
 type LaunchBrowserArgs = {
     sessionName: string;
@@ -8,6 +10,7 @@ type LaunchBrowserArgs = {
         height: number;
     };
     storageStatePath?: string;
+    accessMode?: SessionAccessMode;
 };
 type BrowserSession = {
     browser: Browser;
@@ -17,6 +20,6 @@ type BrowserSession = {
     metadataPath: string;
     close: () => Promise<void>;
 };
-declare function launchBrowser({ sessionName, headless, viewport, storageStatePath, }: LaunchBrowserArgs): Promise<BrowserSession>;
+declare function launchBrowser({ sessionName, headless, viewport, storageStatePath, accessMode, }: LaunchBrowserArgs): Promise<BrowserSession>;
 
 export { type BrowserSession, type LaunchBrowserArgs, launchBrowser };