libretto 0.1.5 → 0.2.1

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

@@ -0,0 +1,149 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { homedir } from "node:os";
+import { z } from "zod";
+import { LIBRETTO_CONFIG_PATH } from "./context.js";
+const CURRENT_CONFIG_VERSION = 1;
+const AiPresetSchema = z.enum(["codex", "claude", "gemini"]);
+const AiConfigSchema = z.object({
+  preset: AiPresetSchema,
+  commandPrefix: z.array(z.string()).min(1),
+  updatedAt: z.string()
+}).strict();
+const LibrettoConfigSchema = z.object({
+  version: z.literal(CURRENT_CONFIG_VERSION),
+  ai: AiConfigSchema.optional()
+}).passthrough();
+const AI_CONFIG_PRESETS = {
+  codex: ["codex", "exec", "--skip-git-repo-check", "--sandbox", "read-only"],
+  claude: [join(homedir(), ".claude", "local", "claude"), "-p"],
+  gemini: ["gemini", "--output-format", "json"]
+};
+function invalidConfigError(configPath) {
+  return new Error(
+    `AI config is invalid at ${configPath}. Fix the file to match the expected schema or delete it.`
+  );
+}
+function parseConfig(raw, configPath) {
+  try {
+    return LibrettoConfigSchema.parse(JSON.parse(raw));
+  } catch {
+    throw invalidConfigError(configPath);
+  }
+}
+function readLibrettoConfig(configPath = LIBRETTO_CONFIG_PATH) {
+  if (!existsSync(configPath)) {
+    return { version: CURRENT_CONFIG_VERSION };
+  }
+  return parseConfig(readFileSync(configPath, "utf-8"), configPath);
+}
+function writeLibrettoConfig(config, configPath = LIBRETTO_CONFIG_PATH) {
+  const parsed = LibrettoConfigSchema.parse(config);
+  mkdirSync(dirname(configPath), { recursive: true });
+  writeFileSync(configPath, JSON.stringify(parsed, null, 2), "utf-8");
+  return parsed;
+}
+function readAiConfig(configPath = LIBRETTO_CONFIG_PATH) {
+  return readLibrettoConfig(configPath).ai ?? null;
+}
+function quoteShellArg(value) {
+  if (/^[a-zA-Z0-9_./:@=-]+$/.test(value)) return value;
+  return JSON.stringify(value);
+}
+function formatCommandPrefix(prefix) {
+  return prefix.map((arg) => quoteShellArg(arg)).join(" ");
+}
+function writeAiConfig(preset, commandPrefix, configPath = LIBRETTO_CONFIG_PATH) {
+  const librettoConfig = readLibrettoConfig(configPath);
+  const ai = AiConfigSchema.parse({
+    preset,
+    commandPrefix,
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  });
+  writeLibrettoConfig(
+    {
+      ...librettoConfig,
+      version: CURRENT_CONFIG_VERSION,
+      ai
+    },
+    configPath
+  );
+  return ai;
+}
+function clearAiConfig(configPath = LIBRETTO_CONFIG_PATH) {
+  const librettoConfig = readLibrettoConfig(configPath);
+  if (!librettoConfig.ai) return false;
+  writeLibrettoConfig(
+    {
+      version: librettoConfig.version
+    },
+    configPath
+  );
+  return true;
+}
+function printAiConfig(config, configPath) {
+  console.log(`AI preset: ${config.preset}`);
+  console.log(`Command prefix: ${formatCommandPrefix(config.commandPrefix)}`);
+  console.log(`Config file: ${configPath}`);
+  console.log(`Updated at: ${config.updatedAt}`);
+}
+function printConfigureUsage(commandName) {
+  console.log(
+    `Usage: ${commandName} <codex|claude|gemini> [-- <command prefix...>]
+       ${commandName}
+       ${commandName} --clear`
+  );
+}
+function runAiConfigure(input, options = {}) {
+  const configureCommandName = options.configureCommandName ?? "libretto-cli ai configure";
+  const configPath = options.configPath ?? LIBRETTO_CONFIG_PATH;
+  const presetArg = input.preset?.trim();
+  const customPrefix = (input.customPrefix ?? []).filter(Boolean);
+  if (!presetArg && customPrefix.length === 0 && !input.clear) {
+    const config2 = readAiConfig(configPath);
+    if (!config2) {
+      console.log(`No AI config set. Run '${configureCommandName} codex' to set one.`);
+      return;
+    }
+    printAiConfig(config2, configPath);
+    return;
+  }
+  if (input.clear) {
+    const removed = clearAiConfig(configPath);
+    if (removed) {
+      console.log(`Cleared AI config: ${configPath}`);
+    } else {
+      console.log("No AI config was set.");
+    }
+    return;
+  }
+  const parsedPreset = AiPresetSchema.safeParse(presetArg);
+  if (!parsedPreset.success) {
+    printConfigureUsage(configureCommandName);
+    throw new Error(
+      "Missing or invalid preset. Use one of: codex, claude, gemini."
+    );
+  }
+  if (input.customPrefix && input.customPrefix.length > 0 && customPrefix.length === 0) {
+    throw new Error("Custom command prefix cannot be empty.");
+  }
+  const preset = parsedPreset.data;
+  const commandPrefix = customPrefix.length > 0 ? customPrefix : AI_CONFIG_PRESETS[preset];
+  const config = writeAiConfig(preset, commandPrefix, configPath);
+  console.log("AI config saved.");
+  printAiConfig(config, configPath);
+}
+export {
+  AI_CONFIG_PRESETS,
+  AiConfigSchema,
+  AiPresetSchema,
+  CURRENT_CONFIG_VERSION,
+  LibrettoConfigSchema,
+  clearAiConfig,
+  formatCommandPrefix,
+  readAiConfig,
+  readLibrettoConfig,
+  runAiConfigure,
+  writeAiConfig,
+  writeLibrettoConfig
+};

package/dist/cli/core/browser.js

@@ -0,0 +1,523 @@
+import { chromium } from "playwright";
+import { openSync, existsSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { createServer } from "node:net";
+import { spawn } from "node:child_process";
+import {
+  getSessionActionsLogPath,
+  getSessionNetworkLogPath,
+  PROFILES_DIR
+} from "./context.js";
+import {
+  assertSessionAvailableForStart,
+  clearSessionState,
+  readSessionStateOrThrow,
+  logFileForSession,
+  readSessionState,
+  writeSessionState
+} from "./session.js";
+import { installSessionTelemetry } from "./session-telemetry.js";
+async function pickFreePort() {
+  return await new Promise((resolve2, reject) => {
+    const server = createServer();
+    server.listen(0, "127.0.0.1", () => {
+      const address = server.address();
+      if (!address || typeof address === "string") {
+        reject(new Error("Failed to pick free port"));
+        return;
+      }
+      const port = address.port;
+      server.close(() => resolve2(port));
+    });
+    server.on("error", reject);
+  });
+}
+function normalizeUrl(url) {
+  if (!/^https?:\/\//i.test(url)) {
+    return `https://${url}`;
+  }
+  return url;
+}
+function normalizeDomain(url) {
+  try {
+    const u = new URL(normalizeUrl(url));
+    return u.hostname.replace(/^www\./, "");
+  } catch {
+    return url.replace(/^www\./, "");
+  }
+}
+function getProfilePath(domain) {
+  return join(PROFILES_DIR, `${domain}.json`);
+}
+function hasProfile(domain) {
+  return existsSync(getProfilePath(domain));
+}
+async function tryConnectToPort(port, logger, timeoutMs = 5e3) {
+  const endpoint = `http://localhost:${port}`;
+  logger.info("cdp-connect-attempt", { port, endpoint, timeoutMs });
+  try {
+    const connectPromise = chromium.connectOverCDP(endpoint);
+    const timeoutPromise = new Promise(
+      (resolve2) => setTimeout(() => resolve2(null), timeoutMs)
+    );
+    const browser = await Promise.race([connectPromise, timeoutPromise]);
+    if (browser) {
+      logger.info("cdp-connect-success", {
+        port,
+        endpoint,
+        contexts: browser.contexts().length
+      });
+    } else {
+      logger.warn("cdp-connect-timeout", { port, endpoint, timeoutMs });
+    }
+    return browser;
+  } catch (err) {
+    logger.error("cdp-connect-error", { error: err, port, endpoint });
+    return null;
+  }
+}
+function isOperationalPage(page) {
+  const url = page.url();
+  return !url.startsWith("devtools://") && !url.startsWith("chrome-error://");
+}
+function disconnectBrowser(browser, logger, session) {
+  logger.info("cdp-disconnect", { session });
+  try {
+    browser._connection?.close();
+  } catch (err) {
+    logger.warn("cdp-disconnect-already-closed", { error: err });
+  }
+}
+function resolveOperationalPages(browser) {
+  return browser.contexts().flatMap((context) => context.pages()).filter(isOperationalPage);
+}
+async function resolvePageId(page) {
+  const cdpSession = await page.context().newCDPSession(page);
+  try {
+    const targetInfo = await cdpSession.send("Target.getTargetInfo");
+    const targetId = targetInfo?.targetInfo?.targetId;
+    if (typeof targetId !== "string" || targetId.length === 0) {
+      throw new Error(`Could not resolve target id for page at URL "${page.url()}".`);
+    }
+    return targetId;
+  } finally {
+    await cdpSession.detach();
+  }
+}
+async function resolvePageReferences(pages) {
+  const refs = await Promise.all(
+    pages.map(async (page) => {
+      const id = await resolvePageId(page);
+      return { id, page };
+    })
+  );
+  return refs;
+}
+async function listOpenPages(session, logger) {
+  const { browser, page: activePage } = await connect(session, logger);
+  try {
+    const pages = browser.contexts().flatMap((ctx) => ctx.pages()).filter(isOperationalPage);
+    const pageRefs = await resolvePageReferences(pages);
+    return pageRefs.map(({ id, page }) => ({
+      id,
+      url: page.url(),
+      active: page === activePage
+    }));
+  } finally {
+    disconnectBrowser(browser, logger, session);
+  }
+}
+async function connect(session, logger, timeoutMs = 1e4, options) {
+  logger.info("connect", { session, timeoutMs });
+  const state = readSessionStateOrThrow(session);
+  const browser = await tryConnectToPort(state.port, logger, timeoutMs);
+  if (!browser) {
+    logger.error("connect-no-browser", {
+      session,
+      port: state.port,
+      pid: state.pid
+    });
+    clearSessionState(session, logger);
+    throw new Error(
+      `No browser running for session "${session}". Run 'libretto-cli open <url> --session ${session}' first.`
+    );
+  }
+  const contexts = browser.contexts();
+  logger.info("connect-contexts", { session, contextCount: contexts.length });
+  if (contexts.length === 0) {
+    logger.error("connect-no-contexts", { session });
+    throw new Error("No browser context found.");
+  }
+  const allPages = contexts.flatMap((c) => c.pages());
+  const pages = resolveOperationalPages(browser);
+  logger.info("connect-pages", {
+    session,
+    totalPages: allPages.length,
+    filteredPages: pages.length,
+    urls: allPages.map((p) => p.url())
+  });
+  if (pages.length === 0) {
+    logger.error("connect-no-pages", {
+      session,
+      allPageUrls: allPages.map((p) => p.url())
+    });
+    throw new Error("No pages found.");
+  }
+  if (options?.requireSinglePage && !options.pageId && pages.length > 1) {
+    throw new Error(
+      `Multiple pages are open in session "${session}". Pass --page <id> to target a page (run "libretto-cli pages --session ${session}" to list ids).`
+    );
+  }
+  const pageRefs = await resolvePageReferences(pages);
+  const pageRef = options?.pageId ? pageRefs.find((ref) => ref.id === options.pageId) ?? null : pageRefs[pageRefs.length - 1];
+  if (!pageRef) {
+    throw new Error(
+      `Page "${options?.pageId}" was not found in session "${session}". Run "libretto-cli pages --session ${session}" to list ids.`
+    );
+  }
+  const page = pageRef.page;
+  const context = page.context();
+  page.on("close", () => {
+    logger.error("page-closed-during-command", {
+      session,
+      url: page.url(),
+      trace: new Error("page-closed-trace").stack
+    });
+  });
+  page.on("crash", () => {
+    logger.error("page-crashed-during-command", {
+      session,
+      url: page.url()
+    });
+  });
+  browser.on("disconnected", () => {
+    logger.error("browser-disconnected-during-command", {
+      session,
+      trace: new Error("browser-disconnected-trace").stack
+    });
+  });
+  logger.info("connect-success", { session, pageUrl: page.url() });
+  return { browser, context, page, pageId: pageRef.id };
+}
+async function runPages(session, logger) {
+  logger.info("pages-start", { session });
+  const pageSummaries = await listOpenPages(session, logger);
+  if (pageSummaries.length === 0) {
+    console.log("No pages found.");
+    return;
+  }
+  console.log("Open pages:");
+  pageSummaries.forEach((pageSummary) => {
+    const activeSuffix = pageSummary.active ? " active=true" : "";
+    console.log(`  id=${pageSummary.id} url=${pageSummary.url}${activeSuffix}`);
+  });
+}
+async function runOpen(rawUrl, headed, session, logger) {
+  const url = normalizeUrl(rawUrl);
+  logger.info("open-start", { url, headed, session });
+  assertSessionAvailableForStart(session, logger);
+  const port = await pickFreePort();
+  const runLogPath = logFileForSession(session);
+  const networkLogPath = getSessionNetworkLogPath(session);
+  const actionsLogPath = getSessionActionsLogPath(session);
+  const browserMode = headed ? "headed" : "headless";
+  const domain = normalizeDomain(url);
+  const profilePath = getProfilePath(domain);
+  const useProfile = hasProfile(domain);
+  logger.info("open-launching", {
+    url,
+    mode: browserMode,
+    session,
+    port,
+    domain,
+    useProfile,
+    profilePath: useProfile ? profilePath : void 0
+  });
+  if (useProfile) {
+    console.log(`Loading saved profile for ${domain}`);
+  }
+  console.log(`Launching ${browserMode} browser (session: ${session})...`);
+  const escapedProfilePath = profilePath.replace(/\\/g, "\\\\").replace(/'/g, "\\'");
+  const escapedUrl = url.replace(/\\/g, "\\\\").replace(/'/g, "\\'");
+  const storageStateCode = useProfile ? `storageState: '${escapedProfilePath}',` : "";
+  const escapedLogPath = runLogPath.replace(/\\/g, "\\\\").replace(/'/g, "\\'");
+  const escapedNetworkLogPath = networkLogPath.replace(/\\/g, "\\\\").replace(/'/g, "\\'");
+  const escapedActionsLogPath = actionsLogPath.replace(/\\/g, "\\\\").replace(/'/g, "\\'");
+  const launcherCode = `
+import { chromium } from 'playwright';
+import { appendFileSync, mkdirSync } from 'node:fs';
+import { dirname } from 'node:path';
+
+const LOG_FILE = '${escapedLogPath}';
+const NETWORK_LOG = '${escapedNetworkLogPath}';
+const ACTIONS_LOG = '${escapedActionsLogPath}';
+mkdirSync(dirname(NETWORK_LOG), { recursive: true });
+
+${installSessionTelemetry.toString()}
+
+function logAction(entry) {
+	appendFileSync(ACTIONS_LOG, JSON.stringify(entry) + '\\n');
+}
+
+function logNetwork(entry) {
+	appendFileSync(NETWORK_LOG, JSON.stringify(entry) + '\\n');
+}
+
+function childLog(level, event, data = {}) {
+	try {
+		const entry = JSON.stringify({
+			timestamp: new Date().toISOString(),
+			id: Math.random().toString(36).slice(2, 10),
+			level,
+			scope: 'libretto-cli.child',
+			event,
+			data,
+		});
+		appendFileSync(LOG_FILE, entry + '\\n');
+	} catch {}
+}
+
+const browser = await chromium.launch({
+	headless: ${!headed},
+	args: ['--disable-blink-features=AutomationControlled', '--remote-debugging-port=${port}', '--remote-debugging-address=127.0.0.1', '--no-focus-on-check'],
+});
+
+browser.on('disconnected', () => {
+	childLog('warn', 'browser-disconnected', { port: ${port} });
+});
+
+const context = await browser.newContext({
+	${storageStateCode}
+	viewport: { width: 1366, height: 768 },
+	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',
+});
+
+const page = await context.newPage();
+page.setDefaultTimeout(30000);
+page.setDefaultNavigationTimeout(45000);
+
+await installSessionTelemetry({
+	context,
+	initialPage: page,
+	includeUserDomActions: true,
+	logAction,
+	logNetwork,
+});
+
+
+await page.goto('${escapedUrl}');
+
+process.on('SIGTERM', async () => {
+	childLog('info', 'child-sigterm');
+	await browser.close();
+	process.exit(0);
+});
+
+process.on('SIGINT', async () => {
+	childLog('info', 'child-sigint');
+	await browser.close();
+	process.exit(0);
+});
+
+process.on('uncaughtException', (err) => {
+	childLog('error', 'uncaught-exception', { message: err.message, stack: err.stack });
+	process.exit(1);
+});
+
+process.on('unhandledRejection', (reason) => {
+	childLog('warn', 'unhandled-rejection', { reason: String(reason) });
+});
+
+process.on('exit', (code) => {
+	childLog('info', 'child-exit', { code, pid: process.pid, port: ${port} });
+});
+
+childLog('info', 'child-launched', { port: ${port}, pid: process.pid, session: '${session}' });
+
+await new Promise(() => {});
+`;
+  const childStderrFd = openSync(runLogPath, "a");
+  const child = spawn("node", ["--input-type=module", "-e", launcherCode], {
+    detached: true,
+    stdio: ["ignore", "ignore", childStderrFd],
+    cwd: resolve(dirname(fileURLToPath(import.meta.url)), "../../..")
+  });
+  child.unref();
+  logger.info("open-child-spawned", { pid: child.pid, port, session });
+  let childSpawnError = null;
+  let childEarlyExit = null;
+  child.on("error", (err) => {
+    childSpawnError = err;
+    logger.error("open-child-spawn-error", { error: err, session, port });
+  });
+  child.on("exit", (code, signal) => {
+    childEarlyExit = { code, signal };
+    logger.warn("open-child-exited", {
+      code,
+      signal,
+      session,
+      port,
+      pid: child.pid
+    });
+  });
+  const cdpPollIntervalMs = 500;
+  const cdpMaxAttempts = 30;
+  const cdpStartupTimeoutMs = cdpPollIntervalMs * cdpMaxAttempts;
+  for (let i = 0; i < cdpMaxAttempts; i++) {
+    const spawnError = childSpawnError;
+    if (spawnError !== null) {
+      const errWithCode = spawnError;
+      const hint = errWithCode.code === "ENOENT" ? " Ensure Node.js is available in PATH for child processes." : "";
+      throw new Error(
+        `Failed to launch browser child process: ${spawnError.message}.${hint} Check logs: ${runLogPath}`
+      );
+    }
+    const earlyExit = childEarlyExit;
+    if (earlyExit !== null) {
+      const status = earlyExit.code ?? earlyExit.signal ?? "unknown";
+      throw new Error(
+        `Browser child process exited before startup (status: ${status}). Check logs: ${runLogPath}`
+      );
+    }
+    await new Promise((r) => setTimeout(r, cdpPollIntervalMs));
+    const ready = await fetch(`http://127.0.0.1:${port}/json/version`).then(() => true).catch(() => false);
+    if (i > 0 && i % 5 === 0) {
+      logger.info("open-waiting-for-cdp", { attempt: i, port, session });
+    }
+    if (ready) {
+      writeSessionState({
+        port,
+        pid: child.pid,
+        session,
+        startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        status: "active"
+      }, logger);
+      logger.info("open-success", {
+        url,
+        mode: browserMode,
+        session,
+        port,
+        pid: child.pid
+      });
+      console.log(`Browser open (${browserMode}): ${url}`);
+      await new Promise((r) => setTimeout(r, 2e3));
+      return;
+    }
+  }
+  logger.error("open-timeout", {
+    session,
+    port,
+    pid: child.pid,
+    attempts: cdpMaxAttempts
+  });
+  throw new Error(
+    `Failed to connect to browser after ${Math.ceil(cdpStartupTimeoutMs / 1e3)}s. Check startup logs: ${runLogPath}`
+  );
+}
+async function runSave(urlOrDomain, session, logger) {
+  logger.info("save-start", { urlOrDomain, session });
+  const { browser, context, page } = await connect(session, logger);
+  try {
+    await new Promise((r) => setTimeout(r, 500));
+    const domain = normalizeDomain(urlOrDomain);
+    const profilePath = getProfilePath(domain);
+    const cdpSession = await context.newCDPSession(page);
+    const { cookies: rawCookies } = await cdpSession.send(
+      "Network.getAllCookies"
+    );
+    const cookies = rawCookies.map((c) => {
+      const cookie = { ...c };
+      if (cookie.partitionKey && typeof cookie.partitionKey === "object") {
+        delete cookie.partitionKey;
+      }
+      return cookie;
+    });
+    await cdpSession.detach();
+    const origins = [];
+    for (const ctx of browser.contexts()) {
+      for (const pg of ctx.pages()) {
+        try {
+          const origin = new URL(pg.url()).origin;
+          const localStorage = await pg.evaluate(() => {
+            const items = [];
+            for (let i = 0; i < window.localStorage.length; i++) {
+              const key = window.localStorage.key(i);
+              if (key) {
+                items.push({
+                  name: key,
+                  value: window.localStorage.getItem(key) || ""
+                });
+              }
+            }
+            return items;
+          });
+          if (localStorage.length > 0) {
+            origins.push({ origin, localStorage });
+          }
+        } catch {
+        }
+      }
+    }
+    const state = { cookies, origins };
+    const fs = await import("node:fs/promises");
+    await fs.mkdir(dirname(profilePath), { recursive: true });
+    await fs.writeFile(profilePath, JSON.stringify(state, null, 2));
+    logger.info("save-success", {
+      domain,
+      profilePath,
+      cookieCount: cookies.length,
+      originCount: origins.length
+    });
+    console.log(`Profile saved for ${domain}`);
+    console.log(`   Location: ${profilePath}`);
+    console.log(`   Cookies: ${cookies.length}, Origins: ${origins.length}`);
+  } catch (err) {
+    logger.error("save-error", { error: err, urlOrDomain, session });
+    throw err;
+  } finally {
+    disconnectBrowser(browser, logger, session);
+  }
+}
+async function runClose(session, logger) {
+  logger.info("close-start", { session });
+  const state = readSessionState(session, logger);
+  if (!state) {
+    logger.info("close-no-session", { session });
+    console.log(`No browser running for session "${session}".`);
+    return;
+  }
+  logger.info("close-killing", { session, pid: state.pid, port: state.port });
+  try {
+    process.kill(state.pid, "SIGTERM");
+  } catch (err) {
+    logger.warn("close-kill-failed", { error: err, session, pid: state.pid });
+  }
+  await new Promise((r) => setTimeout(r, 1500));
+  clearSessionState(session, logger);
+  logger.info("close-success", { session });
+  console.log(`Browser closed (session: ${session}).`);
+}
+function resolvePath(filePath) {
+  return join(process.cwd(), filePath);
+}
+function getScreenshotBaseName(title) {
+  const sanitizedTitle = title.replace(/[^a-zA-Z0-9\s-]/g, "").replace(/\s+/g, "-").toLowerCase().slice(0, 50);
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+  return `${sanitizedTitle}-${timestamp}`;
+}
+export {
+  connect,
+  disconnectBrowser,
+  getProfilePath,
+  getScreenshotBaseName,
+  hasProfile,
+  listOpenPages,
+  normalizeDomain,
+  normalizeUrl,
+  resolvePath,
+  runClose,
+  runOpen,
+  runPages,
+  runSave
+};