libretto 0.5.0 → 0.5.2

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,17 @@
-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";
+import { readLibrettoConfig } from "../../cli/core/ai-config.js";
 
 async function pickFreePort(): Promise<number> {
   return await new Promise((resolve, reject) => {
@@ -36,6 +45,53 @@ export type BrowserSession = {
   close: () => Promise<void>;
 };
 
+function resolveWindowPosition(): { x: number; y: number } | undefined {
+  return readLibrettoConfig().windowPosition;
+}
+
+async function applyWindowPosition(
+  browser: Browser,
+  context: BrowserContext,
+  page: Page,
+  windowPosition: { x: number; y: number } | undefined,
+): Promise<void> {
+  if (!windowPosition) {
+    return;
+  }
+
+  const requestedBounds = {
+    left: windowPosition.x,
+    top: windowPosition.y,
+    windowState: "normal" as const,
+  };
+
+  const pageCdp = await context.newCDPSession(page);
+  let browserCdp:
+    | Awaited<ReturnType<Browser["newBrowserCDPSession"]>>
+    | undefined;
+  try {
+    const targetInfo = await pageCdp.send("Target.getTargetInfo");
+    const targetId = (
+      targetInfo as { targetInfo?: { targetId?: string } }
+    ).targetInfo?.targetId;
+    browserCdp = await browser.newBrowserCDPSession();
+    const windowResult = await browserCdp.send(
+      "Browser.getWindowForTarget",
+      targetId ? { targetId } : {},
+    );
+    await browserCdp.send("Browser.setWindowBounds", {
+      windowId: windowResult.windowId,
+      bounds: requestedBounds,
+    });
+    await new Promise((resolve) => setTimeout(resolve, 250));
+  } catch {
+    // Best-effort: window positioning should not prevent browser launch.
+  } finally {
+    await pageCdp.detach().catch(() => {});
+    await browserCdp?.detach().catch(() => {});
+  }
+}
+
 export async function launchBrowser({
   sessionName,
   headless = false,
@@ -43,12 +99,16 @@ export async function launchBrowser({
   storageStatePath,
 }: LaunchBrowserArgs): Promise<BrowserSession> {
   const debugPort = await pickFreePort();
+  const windowPosition = headless ? undefined : resolveWindowPosition();
   const browser = await chromium.launch({
     headless,
     args: [
       "--disable-blink-features=AutomationControlled",
       `--remote-debugging-port=${debugPort}`,
       "--no-focus-on-check",
+      ...(windowPosition
+        ? [`--window-position=${windowPosition.x},${windowPosition.y}`]
+        : []),
     ],
   });
 
@@ -57,6 +117,7 @@ export async function launchBrowser({
     ...(storageStatePath ? { storageState: storageStatePath } : {}),
   });
   const page = await context.newPage();
+  await applyWindowPosition(browser, context, page, windowPosition);
   page.setDefaultTimeout(30_000);
   page.setDefaultNavigationTimeout(45_000);
 
@@ -65,7 +126,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";