libretto 0.5.0 → 0.5.1

package/src/shared/logger/sinks.ts

@@ -3,142 +3,146 @@ import * as path from "node:path";
 import type { LoggerSink } from "./logger.js";
 
 export function createFileLogSink({
-	filePath,
+  filePath,
 }: {
-	filePath: string;
+  filePath: string;
 }): LoggerSink {
-	fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
 
-	const writeStream = fs.createWriteStream(filePath, { flags: "a" });
+  const writeStream = fs.createWriteStream(filePath, { flags: "a" });
 
-	return {
-		write: ({ id, scope, level, event, data, options }) => {
-			if (writeStream.destroyed || writeStream.writableEnded) {
-				return;
-			}
-			const timestamp = options?.timestamp || new Date();
+  return {
+    write: ({ id, scope, level, event, data, options }) => {
+      if (writeStream.destroyed || writeStream.writableEnded) {
+        return;
+      }
+      const timestamp = options?.timestamp || new Date();
 
-			const logEntry = {
-				timestamp: timestamp.toISOString(),
-				id,
-				level,
-				scope,
-				event,
-				data,
-			};
+      const logEntry = {
+        timestamp: timestamp.toISOString(),
+        id,
+        level,
+        scope,
+        event,
+        data,
+      };
 
-			const jsonLine = JSON.stringify(logEntry) + "\n";
+      const jsonLine = JSON.stringify(logEntry) + "\n";
 
-			try {
-				writeStream.write(jsonLine, (error) => {
-					if (error) {
-						console.error("Failed to write to log file:", error);
-						console[level]({ id, scope, event, data, timestamp });
-					}
-				});
-			} catch (error) {
-				console.error("Failed to write to log file:", error);
-				console[level]({ id, scope, event, data, timestamp });
-			}
-		},
-		flush: () =>
-			new Promise<void>((resolve, reject) => {
-				if (!writeStream.writable || writeStream.writableEnded || writeStream.destroyed) {
-					resolve();
-					return;
-				}
-				writeStream.write("", (error) => {
-					if (error) {
-						reject(error);
-					} else {
-						resolve();
-					}
-				});
-			}),
-		close: () =>
-			new Promise<void>((resolve) => {
-				if (writeStream.destroyed || writeStream.closed) {
-					resolve();
-					return;
-				}
-				let settled = false;
-				const done = () => {
-					if (settled) return;
-					settled = true;
-					resolve();
-				};
-				writeStream.once("finish", done);
-				writeStream.once("close", done);
-				writeStream.once("error", done);
-				try {
-					writeStream.end();
-				} catch {
-					done();
-				}
-			}),
-	};
+      try {
+        writeStream.write(jsonLine, (error) => {
+          if (error) {
+            console.error("Failed to write to log file:", error);
+            console[level]({ id, scope, event, data, timestamp });
+          }
+        });
+      } catch (error) {
+        console.error("Failed to write to log file:", error);
+        console[level]({ id, scope, event, data, timestamp });
+      }
+    },
+    flush: () =>
+      new Promise<void>((resolve, reject) => {
+        if (
+          !writeStream.writable ||
+          writeStream.writableEnded ||
+          writeStream.destroyed
+        ) {
+          resolve();
+          return;
+        }
+        writeStream.write("", (error) => {
+          if (error) {
+            reject(error);
+          } else {
+            resolve();
+          }
+        });
+      }),
+    close: () =>
+      new Promise<void>((resolve) => {
+        if (writeStream.destroyed || writeStream.closed) {
+          resolve();
+          return;
+        }
+        let settled = false;
+        const done = () => {
+          if (settled) return;
+          settled = true;
+          resolve();
+        };
+        writeStream.once("finish", done);
+        writeStream.once("close", done);
+        writeStream.once("error", done);
+        try {
+          writeStream.end();
+        } catch {
+          done();
+        }
+      }),
+  };
 }
 
 // ANSI color codes
 const colors = {
-	reset: "\x1b[0m",
-	gray: "\x1b[90m",
-	red: "\x1b[31m",
-	yellow: "\x1b[33m",
-	blue: "\x1b[34m",
-	cyan: "\x1b[36m",
+  reset: "\x1b[0m",
+  gray: "\x1b[90m",
+  red: "\x1b[31m",
+  yellow: "\x1b[33m",
+  blue: "\x1b[34m",
+  cyan: "\x1b[36m",
 };
 
 function formatTimestamp(date: Date): string {
-	return date.toISOString().replace("T", " ").replace("Z", "");
+  return date.toISOString().replace("T", " ").replace("Z", "");
 }
 
 export const prettyConsoleSink: LoggerSink = {
-	write: ({ scope, level, event, data, options }) => {
-		const timestamp = `${colors.gray}${formatTimestamp(options?.timestamp || new Date())}${colors.reset}`;
-		const levelColor =
-			level === "error"
-				? colors.red
-				: level === "warn"
-					? colors.yellow
-					: colors.blue;
-		const coloredScope = scope ? `${colors.cyan}[${scope}]${colors.reset}` : "";
+  write: ({ scope, level, event, data, options }) => {
+    const timestamp = `${colors.gray}${formatTimestamp(options?.timestamp || new Date())}${colors.reset}`;
+    const levelColor =
+      level === "error"
+        ? colors.red
+        : level === "warn"
+          ? colors.yellow
+          : colors.blue;
+    const coloredScope = scope ? `${colors.cyan}[${scope}]${colors.reset}` : "";
 
-		const logPrefix = `${timestamp} ${levelColor}${level.toUpperCase()}${colors.reset} ${coloredScope} ${event}`;
+    const logPrefix = `${timestamp} ${levelColor}${level.toUpperCase()}${colors.reset} ${coloredScope} ${event}`;
 
-		if (level === "error" && data.error) {
-			const { error, ...otherData } = data;
-			console.error(logPrefix);
-			if (error.stack) {
-				console.error(`  ${error.stack}`);
-			} else if (error.type && error.message) {
-				console.error(`  ${error.type}: ${error.message}`);
-			}
-			if (Object.keys(otherData).length > 0) {
-				console.error(JSON.stringify(otherData, null, 2));
-			}
-		} else {
-			console[level](logPrefix);
-			if (Object.keys(data).length > 0) {
-				console[level](JSON.stringify(data, null, 2));
-			}
-		}
-	},
+    if (level === "error" && data.error) {
+      const { error, ...otherData } = data;
+      console.error(logPrefix);
+      if (error.stack) {
+        console.error(`  ${error.stack}`);
+      } else if (error.type && error.message) {
+        console.error(`  ${error.type}: ${error.message}`);
+      }
+      if (Object.keys(otherData).length > 0) {
+        console.error(JSON.stringify(otherData, null, 2));
+      }
+    } else {
+      console[level](logPrefix);
+      if (Object.keys(data).length > 0) {
+        console[level](JSON.stringify(data, null, 2));
+      }
+    }
+  },
 };
 
 export const jsonlConsoleSink: LoggerSink = {
-	write: ({ id, scope, level, event, data, options }) => {
-		const timestamp = options?.timestamp || new Date();
+  write: ({ id, scope, level, event, data, options }) => {
+    const timestamp = options?.timestamp || new Date();
 
-		const logEntry = {
-			timestamp: timestamp.toISOString(),
-			id,
-			level,
-			scope: scope || undefined,
-			event,
-			data,
-		};
+    const logEntry = {
+      timestamp: timestamp.toISOString(),
+      id,
+      level,
+      scope: scope || undefined,
+      event,
+      data,
+    };
 
-		console.log(JSON.stringify(logEntry));
-	},
+    console.log(JSON.stringify(logEntry));
+  },
 };

package/src/shared/paths/paths.ts

@@ -11,99 +11,100 @@ const PAUSED_SIGNAL_SUFFIX = "paused";
 const RESUME_SIGNAL_SUFFIX = "resume";
 
 function getLibrettoRoot(cwd: string = process.cwd()): string {
-	return join(resolveLibrettoRepoRoot(cwd), LIBRETTO_DIRNAME);
+  return join(resolveLibrettoRepoRoot(cwd), LIBRETTO_DIRNAME);
 }
 
 function getLibrettoSessionsDir(cwd: string = process.cwd()): string {
-	return join(getLibrettoRoot(cwd), LIBRETTO_SESSIONS_DIRNAME);
+  return join(getLibrettoRoot(cwd), LIBRETTO_SESSIONS_DIRNAME);
 }
 
 function getLibrettoSessionDir(
-	sessionName: string,
-	cwd: string = process.cwd(),
+  sessionName: string,
+  cwd: string = process.cwd(),
 ): string {
-	return join(getLibrettoSessionsDir(cwd), sessionName);
+  return join(getLibrettoSessionsDir(cwd), sessionName);
 }
 
 function getLibrettoSessionStatePath(
-	sessionName: string,
-	cwd: string = process.cwd(),
+  sessionName: string,
+  cwd: string = process.cwd(),
 ): string {
-	return join(getLibrettoSessionDir(sessionName, cwd), SESSION_STATE_FILENAME);
+  return join(getLibrettoSessionDir(sessionName, cwd), SESSION_STATE_FILENAME);
 }
 
 export function getLibrettoPauseSignalDir(
-	sessionName: string,
-	cwd: string = process.cwd(),
+  sessionName: string,
+  cwd: string = process.cwd(),
 ): string {
-	return getLibrettoSessionDir(sessionName, cwd);
+  return getLibrettoSessionDir(sessionName, cwd);
 }
 
 function getLibrettoRunnerLogDir(
-	sessionName: string,
-	cwd: string = process.cwd(),
+  sessionName: string,
+  cwd: string = process.cwd(),
 ): string {
-	return join(getLibrettoSessionDir(sessionName, cwd), RUNNER_LOG_DIRNAME);
+  return join(getLibrettoSessionDir(sessionName, cwd), RUNNER_LOG_DIRNAME);
 }
 
 export function getRunnerLogPathForDir(logDir: string): string {
-	return join(logDir, RUNNER_LOG_FILENAME);
+  return join(logDir, RUNNER_LOG_FILENAME);
 }
 
 export function getPauseSignalPathForDir(
-	signalDir: string,
-	sessionName: string,
-	signal: "paused" | "resume",
+  signalDir: string,
+  sessionName: string,
+  signal: "paused" | "resume",
 ): string {
-	const suffix = signal === "paused" ? PAUSED_SIGNAL_SUFFIX : RESUME_SIGNAL_SUFFIX;
-	return join(signalDir, `${sessionName}.${suffix}`);
+  const suffix =
+    signal === "paused" ? PAUSED_SIGNAL_SUFFIX : RESUME_SIGNAL_SUFFIX;
+  return join(signalDir, `${sessionName}.${suffix}`);
 }
 
 export function getLibrettoPausedSignalPath(
-	sessionName: string,
-	cwd: string = process.cwd(),
+  sessionName: string,
+  cwd: string = process.cwd(),
 ): string {
-	return getPauseSignalPathForDir(
-		getLibrettoPauseSignalDir(sessionName, cwd),
-		sessionName,
-		"paused",
-	);
+  return getPauseSignalPathForDir(
+    getLibrettoPauseSignalDir(sessionName, cwd),
+    sessionName,
+    "paused",
+  );
 }
 
 export function getLibrettoResumeSignalPath(
-	sessionName: string,
-	cwd: string = process.cwd(),
+  sessionName: string,
+  cwd: string = process.cwd(),
 ): string {
-	return getPauseSignalPathForDir(
-		getLibrettoPauseSignalDir(sessionName, cwd),
-		sessionName,
-		"resume",
-	);
+  return getPauseSignalPathForDir(
+    getLibrettoPauseSignalDir(sessionName, cwd),
+    sessionName,
+    "resume",
+  );
 }
 
 export function ensureLibrettoSessionStatePath(
-	sessionName: string,
-	cwd: string = process.cwd(),
+  sessionName: string,
+  cwd: string = process.cwd(),
 ): string {
-	const filePath = getLibrettoSessionStatePath(sessionName, cwd);
-	mkdirSync(dirname(filePath), { recursive: true });
-	return filePath;
+  const filePath = getLibrettoSessionStatePath(sessionName, cwd);
+  mkdirSync(dirname(filePath), { recursive: true });
+  return filePath;
 }
 
 export function ensureLibrettoPauseSignalDir(
-	sessionName: string,
-	cwd: string = process.cwd(),
+  sessionName: string,
+  cwd: string = process.cwd(),
 ): string {
-	const dir = getLibrettoPauseSignalDir(sessionName, cwd);
-	mkdirSync(dir, { recursive: true });
-	return dir;
+  const dir = getLibrettoPauseSignalDir(sessionName, cwd);
+  mkdirSync(dir, { recursive: true });
+  return dir;
 }
 
 export function ensureLibrettoRunnerLogDir(
-	sessionName: string,
-	cwd: string = process.cwd(),
+  sessionName: string,
+  cwd: string = process.cwd(),
 ): string {
-	const dir = getLibrettoRunnerLogDir(sessionName, cwd);
-	mkdirSync(dir, { recursive: true });
-	return dir;
+  const dir = getLibrettoRunnerLogDir(sessionName, cwd);
+  mkdirSync(dir, { recursive: true });
+  return dir;
 }

package/src/shared/paths/repo-root.ts

@@ -4,24 +4,24 @@ import { resolve } from "node:path";
 const repoRootCache = new Map<string, string>();
 
 export function resolveLibrettoRepoRoot(cwd: string = process.cwd()): string {
-	const override = process.env.LIBRETTO_REPO_ROOT?.trim();
-	if (override) {
-		return resolve(override);
-	}
+  const override = process.env.LIBRETTO_REPO_ROOT?.trim();
+  if (override) {
+    return resolve(override);
+  }
 
-	const normalizedCwd = resolve(cwd);
-	const cached = repoRootCache.get(normalizedCwd);
-	if (cached) {
-		return cached;
-	}
+  const normalizedCwd = resolve(cwd);
+  const cached = repoRootCache.get(normalizedCwd);
+  if (cached) {
+    return cached;
+  }
 
-	const result = spawnSync("git", ["rev-parse", "--show-toplevel"], {
-		cwd: normalizedCwd,
-		encoding: "utf-8",
-	});
+  const result = spawnSync("git", ["rev-parse", "--show-toplevel"], {
+    cwd: normalizedCwd,
+    encoding: "utf-8",
+  });
 
-	const repoRoot =
-		result.status === 0 && result.stdout ? result.stdout.trim() : normalizedCwd;
-	repoRootCache.set(normalizedCwd, repoRoot);
-	return repoRoot;
+  const repoRoot =
+    result.status === 0 && result.stdout ? result.stdout.trim() : normalizedCwd;
+  repoRootCache.set(normalizedCwd, repoRoot);
+  return repoRoot;
 }

package/src/shared/run/api.ts

@@ -1,2 +1,6 @@
 // --- Browser ---
-export { launchBrowser, type LaunchBrowserArgs, type BrowserSession } from "./browser.js";
+export {
+  launchBrowser,
+  type LaunchBrowserArgs,
+  type BrowserSession,
+} from "./browser.js";

package/src/shared/run/browser.ts

@@ -1,8 +1,16 @@
-import { chromium, type Browser, type BrowserContext, type Page } from "playwright";
+import {
+  chromium,
+  type Browser,
+  type BrowserContext,
+  type Page,
+} from "playwright";
 import { createServer } from "node:net";
 import { existsSync, readFileSync, writeFileSync } from "node:fs";
 import { ensureLibrettoSessionStatePath } from "../paths/paths.js";
-import { SESSION_STATE_VERSION, SessionStateFileSchema } from "../state/session-state.js";
+import {
+  SESSION_STATE_VERSION,
+  SessionStateFileSchema,
+} from "../state/session-state.js";
 
 async function pickFreePort(): Promise<number> {
   return await new Promise((resolve, reject) => {
@@ -65,7 +73,8 @@ export async function launchBrowser({
     ? (JSON.parse(readFileSync(metadataPath, "utf-8")) as unknown)
     : undefined;
 
-  const parsedExistingState = SessionStateFileSchema.safeParse(existingStateRaw);
+  const parsedExistingState =
+    SessionStateFileSchema.safeParse(existingStateRaw);
 
   writeFileSync(
     metadataPath,

package/src/shared/state/index.ts

@@ -1,11 +1,11 @@
 export {
-	SESSION_STATE_VERSION,
-	SessionStatusSchema,
-	SessionStateFileSchema,
-	parseSessionStateData,
-	parseSessionStateContent,
-	serializeSessionState,
-	type SessionStatus,
-	type SessionState,
-	type SessionStateFile,
+  SESSION_STATE_VERSION,
+  SessionStatusSchema,
+  SessionStateFileSchema,
+  parseSessionStateData,
+  parseSessionStateContent,
+  serializeSessionState,
+  type SessionStatus,
+  type SessionState,
+  type SessionStateFile,
 } from "./session-state.js";

package/src/shared/state/session-state.ts

@@ -3,25 +3,26 @@ import { z } from "zod";
 export const SESSION_STATE_VERSION = 1;
 
 export const SessionStatusSchema = z.enum([
-	"active",
-	"paused",
-	"completed",
-	"failed",
-	"exited",
+  "active",
+  "paused",
+  "completed",
+  "failed",
+  "exited",
 ]);
 export const SessionViewportSchema = z.object({
-	width: z.number().int().min(1),
-	height: z.number().int().min(1),
+  width: z.number().int().min(1),
+  height: z.number().int().min(1),
 });
 
 export 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(),
-	viewport: SessionViewportSchema.optional(),
+  version: z.literal(SESSION_STATE_VERSION),
+  port: z.number().int().min(0).max(65535),
+  pid: z.number().int().optional(),
+  cdpEndpoint: z.string().url().optional(),
+  session: z.string().min(1),
+  startedAt: z.string().datetime({ offset: true }),
+  status: SessionStatusSchema.optional(),
+  viewport: SessionViewportSchema.optional(),
 });
 
 export type SessionStatus = z.infer<typeof SessionStatusSchema>;
@@ -29,46 +30,48 @@ export type SessionStateFile = z.infer<typeof SessionStateFileSchema>;
 export type SessionState = Omit<SessionStateFile, "version">;
 
 function formatIssues(error: z.ZodError): string {
-	return error.issues
-		.map((issue) => {
-			const path = issue.path.join(".") || "root";
-			return `${path}: ${issue.message}`;
-		})
-		.join("; ");
+  return error.issues
+    .map((issue) => {
+      const path = issue.path.join(".") || "root";
+      return `${path}: ${issue.message}`;
+    })
+    .join("; ");
 }
 
 export function parseSessionStateData(
-	rawState: unknown,
-	source: string,
+  rawState: unknown,
+  source: string,
 ): SessionState {
-	const parsed = SessionStateFileSchema.safeParse(rawState);
-	if (!parsed.success) {
-		throw new Error(`Session state at ${source} is invalid: ${formatIssues(parsed.error)}`);
-	}
+  const parsed = SessionStateFileSchema.safeParse(rawState);
+  if (!parsed.success) {
+    throw new Error(
+      `Session state at ${source} is invalid: ${formatIssues(parsed.error)}`,
+    );
+  }
 
-	const { version: _version, ...state } = parsed.data;
-	return state;
+  const { version: _version, ...state } = parsed.data;
+  return state;
 }
 
 export function parseSessionStateContent(
-	content: string,
-	source: string,
+  content: string,
+  source: string,
 ): SessionState {
-	let rawState: unknown;
-	try {
-		rawState = JSON.parse(content);
-	} catch (error) {
-		throw new Error(
-			`Session state at ${source} is not valid JSON: ${error instanceof Error ? error.message : String(error)}`,
-		);
-	}
+  let rawState: unknown;
+  try {
+    rawState = JSON.parse(content);
+  } catch (error) {
+    throw new Error(
+      `Session state at ${source} is not valid JSON: ${error instanceof Error ? error.message : String(error)}`,
+    );
+  }
 
-	return parseSessionStateData(rawState, source);
+  return parseSessionStateData(rawState, source);
 }
 
 export function serializeSessionState(state: SessionState): SessionStateFile {
-	return SessionStateFileSchema.parse({
-		version: SESSION_STATE_VERSION,
-		...state,
-	});
+  return SessionStateFileSchema.parse({
+    version: SESSION_STATE_VERSION,
+    ...state,
+  });
 }