libretto 0.3.1 → 0.3.2

package/README.md

@@ -6,21 +6,18 @@ It is designed for engineering teams that automate workflows in web apps and wan
 
 ## Installation
 
-Install Libretto in your project with your favorite package manager:
-
 ```bash
-npm install libretto playwright zod
-yarn add libretto playwright zod
-bun add libretto playwright zod
-pnpm add libretto playwright zod
+npm install --save-dev libretto
 ```
 
-Then initialize Libretto:
+Chromium is downloaded automatically via a `postinstall` script. If postinstall scripts are disabled (e.g. `--ignore-scripts`, common in monorepos), run init manually:
 
 ```bash
 npx libretto init
 ```
 
+This installs the Chromium browser binary and optionally configures an AI subagent (Gemini, Claude, or Codex) that can analyze page snapshots without consuming the coding agent's context window.
+
 ## Usage
 
 Libretto is usually used through prompts with the Libretto skill.
@@ -56,6 +53,19 @@ npx libretto help
 npx libretto run ./integration.ts main
 ```
 
+## The `.libretto/` directory
+
+Libretto stores local runtime state in a `.libretto/` directory at your project root. Sensitive directories (`sessions/` and `profiles/`) are automatically git-ignored via `.libretto/.gitignore`.
+
+- **`profiles/<domain>.json`** — Saved browser sessions (cookies, localStorage) for authenticated sites. Created via `npx libretto save <domain>`. Machine-local and never committed.
+- **`sessions/<name>/`** — Per-session runtime state:
+  - `state.json` — Session metadata (debug port, PID, status)
+  - `logs.jsonl` — Structured session logs
+  - `network.jsonl` — Captured network requests (URLs, methods, headers, response status)
+  - `actions.jsonl` — Recorded user actions (clicks, fills, navigations)
+  - `snapshots/` — Screenshot PNGs and HTML snapshots captured via `npx libretto snapshot`
+- **`ai.json`** — AI runtime configuration set via `npx libretto ai configure`.
+
 ## Authors
 
 Maintained by the team at [Saffron Health](https://saffron.health).

package/dist/cli/commands/browser.js

@@ -16,6 +16,9 @@ function registerBrowserCommands(yargs, logger) {
     }).option("headless", {
       type: "boolean",
       default: false
+    }).option("viewport", {
+      type: "string",
+      describe: "Viewport size as WIDTHxHEIGHT (e.g. 1920x1080)"
     }),
     async (argv) => {
       const hasHeadedFlag = Boolean(argv.headed);
@@ -27,10 +30,28 @@ function registerBrowserCommands(yargs, logger) {
       const url = argv.url;
       if (!url) {
         throw new Error(
-          "Usage: libretto-cli open <url> [--headless] [--session <name>]"
+          "Usage: libretto-cli open <url> [--headless] [--viewport WxH] [--session <name>]"
         );
       }
-      await runOpen(url, headed, String(argv.session), logger);
+      const viewportArg = argv.viewport;
+      let viewport;
+      if (viewportArg) {
+        const match = viewportArg.match(/^(\d+)x(\d+)$/i);
+        if (!match) {
+          throw new Error(
+            "Invalid --viewport format. Expected WIDTHxHEIGHT (e.g. 1920x1080)."
+          );
+        }
+        const w = Number(match[1]);
+        const h = Number(match[2]);
+        if (w < 1 || h < 1) {
+          throw new Error(
+            "Invalid --viewport dimensions. Width and height must be at least 1."
+          );
+        }
+        viewport = { width: w, height: h };
+      }
+      await runOpen(url, headed, String(argv.session), logger, { viewport });
     }
   ).command(
     "save [urlOrDomain]",

package/dist/cli/commands/snapshot.js

@@ -1,14 +1,70 @@
 import { mkdirSync } from "node:fs";
 import { connect, disconnectBrowser } from "../core/browser.js";
 import { getSessionSnapshotRunDir } from "../core/context.js";
+import { readSessionState } from "../core/session.js";
 import {
   canAnalyzeSnapshots,
   runInterpret
 } from "../core/snapshot-analyzer.js";
 const DEFAULT_SNAPSHOT_CONTEXT = "No additional user context provided.";
+const FALLBACK_SNAPSHOT_VIEWPORT = { width: 1280, height: 800 };
 function generateSnapshotRunId() {
   return `snapshot-${Date.now()}`;
 }
+function isZeroViewport(value) {
+  return typeof value === "number" && value <= 0;
+}
+function shouldForceSnapshotViewport(metrics) {
+  return isZeroViewport(metrics.configuredWidth) || isZeroViewport(metrics.configuredHeight) || isZeroViewport(metrics.innerWidth) || isZeroViewport(metrics.innerHeight);
+}
+function isZeroWidthScreenshotError(error) {
+  return error instanceof Error && error.message.includes("Cannot take screenshot with 0 width");
+}
+async function readSnapshotViewportMetrics(page) {
+  const configuredViewport = page.viewportSize();
+  let innerWidth = null;
+  let innerHeight = null;
+  try {
+    const innerViewport = await page.evaluate(() => ({
+      width: window.innerWidth,
+      height: window.innerHeight
+    }));
+    innerWidth = innerViewport.width;
+    innerHeight = innerViewport.height;
+  } catch {
+  }
+  return {
+    configuredWidth: configuredViewport?.width ?? null,
+    configuredHeight: configuredViewport?.height ?? null,
+    innerWidth,
+    innerHeight
+  };
+}
+function resolveSnapshotViewport(session, logger) {
+  const state = readSessionState(session, logger);
+  if (state?.viewport) {
+    logger.info("screenshot-viewport-from-session-state", {
+      session,
+      viewport: state.viewport
+    });
+    return state.viewport;
+  }
+  logger.info("screenshot-viewport-fallback", {
+    session,
+    reason: "no viewport in session state",
+    viewport: FALLBACK_SNAPSHOT_VIEWPORT
+  });
+  return FALLBACK_SNAPSHOT_VIEWPORT;
+}
+async function forceSnapshotViewport(page, viewport, logger, session, pageId, reason) {
+  await page.setViewportSize(viewport);
+  logger.warn("screenshot-viewport-forced", {
+    session,
+    pageId,
+    reason,
+    viewport
+  });
+}
 async function captureScreenshot(session, logger, pageId) {
   logger.info("screenshot-start", { session, pageId });
   const snapshotRunId = generateSnapshotRunId();
@@ -19,11 +75,60 @@ async function captureScreenshot(session, logger, pageId) {
     requireSinglePage: true
   });
   try {
-    const title = await page.title();
-    const pageUrl = page.url();
+    let title = null;
+    try {
+      title = await page.title();
+    } catch (error) {
+      logger.warn("screenshot-title-read-failed", {
+        session,
+        pageId,
+        error
+      });
+    }
+    let pageUrl = null;
+    try {
+      pageUrl = page.url();
+    } catch (error) {
+      logger.warn("screenshot-url-read-failed", {
+        session,
+        pageId,
+        error
+      });
+    }
     const pngPath = `${snapshotRunDir}/page.png`;
     const htmlPath = `${snapshotRunDir}/page.html`;
-    await page.screenshot({ path: pngPath });
+    const restoreViewport = resolveSnapshotViewport(session, logger);
+    const viewportMetrics = await readSnapshotViewportMetrics(page);
+    logger.info("screenshot-viewport-metrics", {
+      session,
+      pageId,
+      restoreViewport,
+      ...viewportMetrics
+    });
+    await forceSnapshotViewport(
+      page,
+      restoreViewport,
+      logger,
+      session,
+      pageId,
+      shouldForceSnapshotViewport(viewportMetrics) ? "preflight-invalid-viewport" : "preflight-normalize-viewport"
+    );
+    try {
+      await page.screenshot({ path: pngPath });
+    } catch (error) {
+      if (!isZeroWidthScreenshotError(error)) {
+        throw error;
+      }
+      await forceSnapshotViewport(
+        page,
+        restoreViewport,
+        logger,
+        session,
+        pageId,
+        "retry-after-zero-width-screenshot-error"
+      );
+      await page.screenshot({ path: pngPath });
+    }
     const htmlContent = await page.content();
     const fs = await import("node:fs/promises");
     await fs.writeFile(htmlPath, htmlContent);
@@ -49,7 +154,13 @@ async function captureScreenshot(session, logger, pageId) {
       session,
       pageAlive,
       browserConnected,
-      pageUrl: page.url()
+      pageUrl: (() => {
+        try {
+          return page.url();
+        } catch {
+          return null;
+        }
+      })()
     });
     throw err;
   } finally {

package/dist/cli/core/ai-config.js

@@ -10,9 +10,14 @@ const AiConfigSchema = z.object({
   commandPrefix: z.array(z.string()).min(1),
   updatedAt: z.string()
 }).strict();
+const ViewportConfigSchema = z.object({
+  width: z.number().int().min(1),
+  height: z.number().int().min(1)
+});
 const LibrettoConfigSchema = z.object({
   version: z.literal(CURRENT_CONFIG_VERSION),
-  ai: AiConfigSchema.optional()
+  ai: AiConfigSchema.optional(),
+  viewport: ViewportConfigSchema.optional()
 }).passthrough();
 const AI_CONFIG_PRESETS = {
   codex: ["codex", "exec", "--skip-git-repo-check", "--sandbox", "read-only"],
@@ -73,9 +78,10 @@ function writeAiConfig(preset, commandPrefix, configPath = LIBRETTO_CONFIG_PATH)
 function clearAiConfig(configPath = LIBRETTO_CONFIG_PATH) {
   const librettoConfig = readLibrettoConfig(configPath);
   if (!librettoConfig.ai) return false;
+  const { ai: _ai, ...rest } = librettoConfig;
   writeLibrettoConfig(
     {
-      version: librettoConfig.version
+      ...rest
     },
     configPath
   );
@@ -139,6 +145,7 @@ export {
   AiPresetSchema,
   CURRENT_CONFIG_VERSION,
   LibrettoConfigSchema,
+  ViewportConfigSchema,
   clearAiConfig,
   formatCommandPrefix,
   readAiConfig,

package/dist/cli/core/browser.js

@@ -9,6 +9,7 @@ import {
   getSessionNetworkLogPath,
   PROFILES_DIR
 } from "./context.js";
+import { readLibrettoConfig } from "./ai-config.js";
 import {
   assertSessionAvailableForStart,
   clearSessionState,
@@ -216,9 +217,24 @@ async function runPages(session, logger) {
     console.log(`  id=${pageSummary.id} url=${pageSummary.url}${activeSuffix}`);
   });
 }
-async function runOpen(rawUrl, headed, session, logger) {
+const DEFAULT_VIEWPORT = { width: 1366, height: 768 };
+function resolveViewport(cliViewport, logger) {
+  if (cliViewport) {
+    logger.info("viewport-source", { source: "cli", viewport: cliViewport });
+    return cliViewport;
+  }
+  const config = readLibrettoConfig();
+  if (config.viewport) {
+    logger.info("viewport-source", { source: "config", viewport: config.viewport });
+    return config.viewport;
+  }
+  logger.info("viewport-source", { source: "default", viewport: DEFAULT_VIEWPORT });
+  return DEFAULT_VIEWPORT;
+}
+async function runOpen(rawUrl, headed, session, logger, options) {
   const url = normalizeUrl(rawUrl);
-  logger.info("open-start", { url, headed, session });
+  const viewport = resolveViewport(options?.viewport, logger);
+  logger.info("open-start", { url, headed, session, viewport });
   assertSessionAvailableForStart(session, logger);
   const port = await pickFreePort();
   const runLogPath = logFileForSession(session);
@@ -296,7 +312,7 @@ browser.on('disconnected', () => {
 
 const context = await browser.newContext({
 	${storageStateCode}
-	viewport: { width: 1366, height: 768 },
+	viewport: { width: ${viewport.width}, height: ${viewport.height} },
 	userAgent: 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Safari/537.36',
 });
 
@@ -398,7 +414,8 @@ await new Promise(() => {});
         pid: child.pid,
         session,
         startedAt: (/* @__PURE__ */ new Date()).toISOString(),
-        status: "active"
+        status: "active",
+        viewport
       }, logger);
       logger.info("open-success", {
         url,

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

@@ -66,8 +66,8 @@ class UserCodingAgent {
 Screenshot file path: ${pngPath}
 Use the screenshot alongside the HTML snapshot context above.`;
   }
-  async runAnalyzer(args, stdinText) {
-    const result = await runExternalCommand(this.command, args, stdinText);
+  async runAnalyzer(args, logger, stdinText) {
+    const result = await runExternalCommand(this.command, args, logger, stdinText);
     if (result.exitCode !== 0) {
       throw new Error(
         `Analyzer command failed (${formatCommandPrefix([this.command, ...args])}).
@@ -76,13 +76,13 @@ ${stripAnsi(result.stderr).trim() || stripAnsi(result.stdout).trim() || "No erro
     }
     return result;
   }
-  async runAndParse(args, stdinText) {
-    const result = await this.runAnalyzer(args, stdinText);
+  async runAndParse(args, logger, stdinText) {
+    const result = await this.runAnalyzer(args, logger, stdinText);
     return parseInterpretResultFromText(result.stdout);
   }
 }
 class CodexUserCodingAgent extends UserCodingAgent {
-  async analyzeSnapshot(prompt, pngPath) {
+  async analyzeSnapshot(prompt, pngPath, logger) {
     const tempDir = mkdtempSync(join(tmpdir(), "libretto-cli-analyzer-"));
     const outputPath = join(
       tempDir,
@@ -96,9 +96,21 @@ class CodexUserCodingAgent extends UserCodingAgent {
       pngPath,
       "-"
     ];
-    const result = await this.runAnalyzer(args, prompt);
+    logger.info("interpret-analyzer-codex-start", {
+      outputPath,
+      pngPath,
+      promptChars: prompt.length,
+      args
+    });
+    const result = await this.runAnalyzer(args, logger, prompt);
     let outputText = result.stdout;
     try {
+      logger.info("interpret-analyzer-codex-finish", {
+        outputPath,
+        outputFileExists: existsSync(outputPath),
+        stdoutChars: result.stdout.length,
+        stderrChars: result.stderr.length
+      });
       if (existsSync(outputPath)) {
         outputText = readFileSync(outputPath, "utf-8");
       }
@@ -109,31 +121,59 @@ class CodexUserCodingAgent extends UserCodingAgent {
   }
 }
 class ClaudeUserCodingAgent extends UserCodingAgent {
-  async analyzeSnapshot(prompt, pngPath) {
-    const args = [...this.baseArgs, `${prompt}${this.screenshotHint(pngPath)}`];
-    return await this.runAndParse(args);
+  async analyzeSnapshot(prompt, pngPath, logger) {
+    return await this.runAndParse(
+      [...this.baseArgs],
+      logger,
+      `${prompt}${this.screenshotHint(pngPath)}`
+    );
   }
 }
 class GeminiUserCodingAgent extends UserCodingAgent {
-  async analyzeSnapshot(prompt, pngPath) {
-    const args = [...this.baseArgs, `${prompt}${this.screenshotHint(pngPath)}`];
-    return await this.runAndParse(args);
+  async analyzeSnapshot(prompt, pngPath, logger) {
+    return await this.runAndParse(
+      [...this.baseArgs],
+      logger,
+      `${prompt}${this.screenshotHint(pngPath)}`
+    );
   }
 }
-async function runExternalCommand(command, args, stdinText) {
+async function runExternalCommand(command, args, logger, stdinText) {
   return await new Promise((resolve2, reject) => {
+    const startedAt = Date.now();
+    logger.info("interpret-analyzer-spawn-start", {
+      command,
+      args,
+      stdinChars: stdinText?.length ?? 0
+    });
     const child = spawn(command, args, {
       stdio: ["pipe", "pipe", "pipe"]
     });
     let stdout = "";
     let stderr = "";
+    let stdinError = null;
     child.stdout.on("data", (chunk) => {
       stdout += chunk.toString();
     });
     child.stderr.on("data", (chunk) => {
       stderr += chunk.toString();
     });
+    child.stdin.on("error", (err) => {
+      stdinError = err;
+      logger.warn("interpret-analyzer-stdin-pipe-error", {
+        command,
+        args,
+        code: stdinError.code ?? null,
+        message: stdinError.message,
+        hint: stdinError.code === "EPIPE" ? "Child process exited before consuming all stdin data" : "Unexpected stdin write error"
+      });
+    });
     child.on("error", (err) => {
+      logger.error("interpret-analyzer-spawn-error", {
+        command,
+        args,
+        error: err
+      });
       const error = err;
       if (error.code === "ENOENT") {
         reject(
@@ -146,16 +186,41 @@ async function runExternalCommand(command, args, stdinText) {
       reject(err);
     });
     child.on("close", (code) => {
+      const stdinNote = formatStdinError(stderr, stdinError);
+      const combinedStderr = `${stderr}${stdinNote}`;
+      logger.info("interpret-analyzer-spawn-close", {
+        command,
+        args,
+        exitCode: code ?? 1,
+        durationMs: Date.now() - startedAt,
+        stdoutChars: stdout.length,
+        stderrChars: combinedStderr.length,
+        stdinErrorCode: stdinError?.code ?? null,
+        stdoutPreview: summarizeForLog(stdout),
+        stderrPreview: summarizeForLog(combinedStderr)
+      });
       resolve2({
         exitCode: code ?? 1,
         stdout,
-        stderr
+        stderr: combinedStderr
       });
     });
-    if (stdinText !== void 0) {
-      child.stdin.write(stdinText);
+    try {
+      if (stdinText !== void 0) {
+        child.stdin.end(stdinText);
+      } else {
+        child.stdin.end();
+      }
+    } catch (err) {
+      stdinError = err;
+      logger.warn("interpret-analyzer-stdin-write-error", {
+        command,
+        args,
+        code: stdinError.code ?? null,
+        message: stdinError.message,
+        hint: stdinError.code === "EPIPE" ? "Child process exited before consuming all stdin data" : "Unexpected stdin write error"
+      });
     }
-    child.stdin.end();
   });
 }
 function stripAnsi(value) {
@@ -164,6 +229,19 @@ function stripAnsi(value) {
     ""
   );
 }
+function summarizeForLog(value, maxChars = 800) {
+  const cleaned = stripAnsi(value).trim();
+  if (!cleaned) return "";
+  if (cleaned.length <= maxChars) return cleaned;
+  return `${cleaned.slice(0, maxChars)}\u2026 [truncated ${cleaned.length - maxChars} chars]`;
+}
+function formatStdinError(stderr, error) {
+  if (!error) return "";
+  const detail = error.code === "EPIPE" ? "Analyzer closed stdin before Libretto finished sending the snapshot prompt." : `Analyzer stdin error: ${error.message}`;
+  if (stderr.includes(detail)) return "";
+  return `${stderr.endsWith("\n") || stderr.length === 0 ? "" : "\n"}${detail}
+`;
+}
 function extractJsonObjectCandidates(text) {
   const candidates = [];
   const seen = /* @__PURE__ */ new Set();
@@ -430,7 +508,7 @@ ${trimmedHtml}`;
       preset: configuredAnalyzer.preset,
       commandPrefix: configuredAnalyzer.commandPrefix
     });
-    parsed = await configuredAgent.analyzeSnapshot(prompt, pngPath);
+    parsed = await configuredAgent.analyzeSnapshot(prompt, pngPath, logger);
   } else {
     const llmClientFactory = getLLMClientFactory();
     if (!llmClientFactory) {

package/dist/cli/index.js

@@ -1,3 +1,4 @@
+#!/usr/bin/env node
 import { runLibrettoCLI } from "./cli.js";
 import {
   maybeConfigureLLMClientFactoryFromEnv,

package/dist/shared/llm/types.d.cts

@@ -42,7 +42,7 @@ interface LLMClient {
         prompt: string;
         schema: T;
         temperature?: number;
-    }): Promise<z.infer<T>>;
+    }): Promise<z.output<T>>;
     /**
      * Generate a structured object from a conversation-style message array.
      *
@@ -60,7 +60,7 @@ interface LLMClient {
         messages: Message[];
         schema: T;
         temperature?: number;
-    }): Promise<z.infer<T>>;
+    }): Promise<z.output<T>>;
 }
 
 export type { LLMClient, Message, MessageContentPart };

package/dist/shared/llm/types.d.ts

@@ -42,7 +42,7 @@ interface LLMClient {
         prompt: string;
         schema: T;
         temperature?: number;
-    }): Promise<z.infer<T>>;
+    }): Promise<z.output<T>>;
     /**
      * Generate a structured object from a conversation-style message array.
      *
@@ -60,7 +60,7 @@ interface LLMClient {
         messages: Message[];
         schema: T;
         temperature?: number;
-    }): Promise<z.infer<T>>;
+    }): Promise<z.output<T>>;
 }
 
 export type { LLMClient, Message, MessageContentPart };

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

@@ -21,6 +21,7 @@ __export(session_state_exports, {
   SESSION_STATE_VERSION: () => SESSION_STATE_VERSION,
   SessionStateFileSchema: () => SessionStateFileSchema,
   SessionStatusSchema: () => SessionStatusSchema,
+  SessionViewportSchema: () => SessionViewportSchema,
   parseSessionStateContent: () => parseSessionStateContent,
   parseSessionStateData: () => parseSessionStateData,
   serializeSessionState: () => serializeSessionState
@@ -35,13 +36,18 @@ const SessionStatusSchema = import_zod.z.enum([
   "failed",
   "exited"
 ]);
+const SessionViewportSchema = import_zod.z.object({
+  width: import_zod.z.number().int().min(1),
+  height: import_zod.z.number().int().min(1)
+});
 const SessionStateFileSchema = import_zod.z.object({
   version: import_zod.z.literal(SESSION_STATE_VERSION),
   port: import_zod.z.number().int().min(0).max(65535),
   pid: import_zod.z.number().int(),
   session: import_zod.z.string().min(1),
   startedAt: import_zod.z.string().datetime({ offset: true }),
-  status: SessionStatusSchema.optional()
+  status: SessionStatusSchema.optional(),
+  viewport: SessionViewportSchema.optional()
 });
 function formatIssues(error) {
   return error.issues.map((issue) => {
@@ -79,6 +85,7 @@ function serializeSessionState(state) {
   SESSION_STATE_VERSION,
   SessionStateFileSchema,
   SessionStatusSchema,
+  SessionViewportSchema,
   parseSessionStateContent,
   parseSessionStateData,
   serializeSessionState

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

@@ -1,29 +1,35 @@
 import { z } from 'zod';
 
 declare const SESSION_STATE_VERSION = 1;
-declare const SessionStatusSchema: z.ZodEnum<["active", "paused", "completed", "failed", "exited"]>;
+declare const SessionStatusSchema: z.ZodEnum<{
+    active: "active";
+    paused: "paused";
+    completed: "completed";
+    failed: "failed";
+    exited: "exited";
+}>;
+declare const SessionViewportSchema: z.ZodObject<{
+    width: z.ZodNumber;
+    height: z.ZodNumber;
+}, z.core.$strip>;
 declare const SessionStateFileSchema: z.ZodObject<{
     version: z.ZodLiteral<1>;
     port: z.ZodNumber;
     pid: z.ZodNumber;
     session: z.ZodString;
     startedAt: z.ZodString;
-    status: z.ZodOptional<z.ZodEnum<["active", "paused", "completed", "failed", "exited"]>>;
-}, "strip", z.ZodTypeAny, {
-    version: 1;
-    port: number;
-    pid: number;
-    session: string;
-    startedAt: string;
-    status?: "active" | "paused" | "completed" | "failed" | "exited" | undefined;
-}, {
-    version: 1;
-    port: number;
-    pid: number;
-    session: string;
-    startedAt: string;
-    status?: "active" | "paused" | "completed" | "failed" | "exited" | undefined;
-}>;
+    status: z.ZodOptional<z.ZodEnum<{
+        active: "active";
+        paused: "paused";
+        completed: "completed";
+        failed: "failed";
+        exited: "exited";
+    }>>;
+    viewport: z.ZodOptional<z.ZodObject<{
+        width: z.ZodNumber;
+        height: z.ZodNumber;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
 type SessionStatus = z.infer<typeof SessionStatusSchema>;
 type SessionStateFile = z.infer<typeof SessionStateFileSchema>;
 type SessionState = Omit<SessionStateFile, "version">;
@@ -31,4 +37,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 SessionState, type SessionStateFile, SessionStateFileSchema, type SessionStatus, SessionStatusSchema, parseSessionStateContent, parseSessionStateData, serializeSessionState };
+export { SESSION_STATE_VERSION, type SessionState, type SessionStateFile, SessionStateFileSchema, type SessionStatus, SessionStatusSchema, SessionViewportSchema, parseSessionStateContent, parseSessionStateData, serializeSessionState };

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

@@ -1,29 +1,35 @@
 import { z } from 'zod';
 
 declare const SESSION_STATE_VERSION = 1;
-declare const SessionStatusSchema: z.ZodEnum<["active", "paused", "completed", "failed", "exited"]>;
+declare const SessionStatusSchema: z.ZodEnum<{
+    active: "active";
+    paused: "paused";
+    completed: "completed";
+    failed: "failed";
+    exited: "exited";
+}>;
+declare const SessionViewportSchema: z.ZodObject<{
+    width: z.ZodNumber;
+    height: z.ZodNumber;
+}, z.core.$strip>;
 declare const SessionStateFileSchema: z.ZodObject<{
     version: z.ZodLiteral<1>;
     port: z.ZodNumber;
     pid: z.ZodNumber;
     session: z.ZodString;
     startedAt: z.ZodString;
-    status: z.ZodOptional<z.ZodEnum<["active", "paused", "completed", "failed", "exited"]>>;
-}, "strip", z.ZodTypeAny, {
-    version: 1;
-    port: number;
-    pid: number;
-    session: string;
-    startedAt: string;
-    status?: "active" | "paused" | "completed" | "failed" | "exited" | undefined;
-}, {
-    version: 1;
-    port: number;
-    pid: number;
-    session: string;
-    startedAt: string;
-    status?: "active" | "paused" | "completed" | "failed" | "exited" | undefined;
-}>;
+    status: z.ZodOptional<z.ZodEnum<{
+        active: "active";
+        paused: "paused";
+        completed: "completed";
+        failed: "failed";
+        exited: "exited";
+    }>>;
+    viewport: z.ZodOptional<z.ZodObject<{
+        width: z.ZodNumber;
+        height: z.ZodNumber;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
 type SessionStatus = z.infer<typeof SessionStatusSchema>;
 type SessionStateFile = z.infer<typeof SessionStateFileSchema>;
 type SessionState = Omit<SessionStateFile, "version">;
@@ -31,4 +37,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 SessionState, type SessionStateFile, SessionStateFileSchema, type SessionStatus, SessionStatusSchema, parseSessionStateContent, parseSessionStateData, serializeSessionState };
+export { SESSION_STATE_VERSION, type SessionState, type SessionStateFile, SessionStateFileSchema, type SessionStatus, SessionStatusSchema, SessionViewportSchema, parseSessionStateContent, parseSessionStateData, serializeSessionState };

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

@@ -7,13 +7,18 @@ const SessionStatusSchema = z.enum([
   "failed",
   "exited"
 ]);
+const SessionViewportSchema = z.object({
+  width: z.number().int().min(1),
+  height: z.number().int().min(1)
+});
 const SessionStateFileSchema = z.object({
   version: z.literal(SESSION_STATE_VERSION),
   port: z.number().int().min(0).max(65535),
   pid: z.number().int(),
   session: z.string().min(1),
   startedAt: z.string().datetime({ offset: true }),
-  status: SessionStatusSchema.optional()
+  status: SessionStatusSchema.optional(),
+  viewport: SessionViewportSchema.optional()
 });
 function formatIssues(error) {
   return error.issues.map((issue) => {
@@ -50,6 +55,7 @@ export {
   SESSION_STATE_VERSION,
   SessionStateFileSchema,
   SessionStatusSchema,
+  SessionViewportSchema,
   parseSessionStateContent,
   parseSessionStateData,
   serializeSessionState

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "libretto",
-  "version": "0.3.1",
+  "version": "0.3.2",
   "description": "AI-powered browser automation library and CLI built on Playwright",
   "license": "MIT",
   "repository": {
@@ -8,6 +8,7 @@
     "url": "https://github.com/saffron-health/libretto"
   },
   "type": "module",
+  "packageManager": "pnpm@9.15.4",
   "publishConfig": {
     "access": "public"
   },
@@ -26,11 +27,23 @@
       "require": "./dist/index.cjs"
     }
   },
+  "scripts": {
+    "postinstall": "playwright install chromium",
+    "build": "pnpm run build:runtime && pnpm run build:cli",
+    "build:runtime": "tsup --config tsup.config.ts",
+    "build:cli": "tsup --config tsup.cli.config.ts",
+    "type-check": "tsc --noEmit",
+    "test": "pnpm run build && vitest run",
+    "eval": "pnpm run build && vitest run --config vitest.evals.config.ts",
+    "benchmark": "pnpm run build && tsx benchmarks/run.ts",
+    "test:watch": "vitest",
+    "cli": "node dist/index.js",
+    "prepack": "pnpm run build"
+  },
   "peerDependencies": {
-    "@ai-sdk/anthropic": "^3.0.0",
-    "@ai-sdk/google-vertex": "^4.0.0",
-    "@ai-sdk/openai": "^3.0.0",
-    "zod": ">=3.0.0"
+    "@ai-sdk/anthropic": "^3.0.58",
+    "@ai-sdk/google-vertex": "^4.0.80",
+    "@ai-sdk/openai": "^3.0.41"
   },
   "peerDependenciesMeta": {
     "@ai-sdk/anthropic": {
@@ -44,34 +57,22 @@
     }
   },
   "devDependencies": {
-    "@anthropic-ai/claude-agent-sdk": "^0.2.73",
-    "@ai-sdk/anthropic": "^3.0.53",
-    "@ai-sdk/google-vertex": "^4.0.72",
-    "@ai-sdk/openai": "^3.0.39",
-    "@types/node": "^25.3.3",
-    "@types/yargs": "^17.0.33",
-    "openai": "^6.27.0",
-    "tsup": "^8.0.0",
-    "typescript": "^5.7.0",
-    "vitest": "^4.0.18",
-    "zod": "^3.25.0"
+    "@anthropic-ai/claude-agent-sdk": "^0.2.75",
+    "@ai-sdk/anthropic": "^3.0.58",
+    "@ai-sdk/google-vertex": "^4.0.80",
+    "@ai-sdk/openai": "^3.0.41",
+    "@types/node": "^25.5.0",
+    "@types/yargs": "^17.0.35",
+    "openai": "^6.29.0",
+    "tsup": "^8.5.1",
+    "typescript": "^5.9.3",
+    "vitest": "^4.1.0"
   },
   "dependencies": {
-    "ai": "^6.0.110",
-    "playwright": "^1.52.0",
-    "tsx": "^4.19.2",
-    "yargs": "^17.7.2"
-  },
-  "scripts": {
-    "postinstall": "npx playwright install chromium",
-    "build": "pnpm run build:runtime && pnpm run build:cli",
-    "build:runtime": "tsup --config tsup.config.ts",
-    "build:cli": "tsup --config tsup.cli.config.ts",
-    "type-check": "tsc --noEmit",
-    "test": "pnpm run build && vitest run",
-    "eval": "pnpm run build && vitest run --config vitest.evals.config.ts",
-    "benchmark": "pnpm run build && tsx benchmarks/run.ts",
-    "test:watch": "vitest",
-    "cli": "node dist/index.js"
+    "ai": "^6.0.116",
+    "playwright": "^1.58.2",
+    "tsx": "^4.21.0",
+    "yargs": "^18.0.0",
+    "zod": "^4.3.6"
   }
-}
+}