libretto 0.1.5 → 0.2.0

package/dist/cli/core/context.js

@@ -0,0 +1,113 @@
+import { Logger, createFileLogSink } from "../../shared/logger/index.js";
+import { spawnSync } from "node:child_process";
+import { cwd } from "node:process";
+import { existsSync, mkdirSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { validateSessionName } from "./session.js";
+function getRepoRoot() {
+  const result = spawnSync("git", ["rev-parse", "--show-toplevel"], {
+    encoding: "utf-8"
+  });
+  if (result.status === 0 && result.stdout) {
+    return result.stdout.trim();
+  }
+  return cwd();
+}
+const REPO_ROOT = getRepoRoot();
+const LIBRETTO_CONFIG_DIR = join(REPO_ROOT, ".libretto");
+const LIBRETTO_CONFIG_PATH = join(LIBRETTO_CONFIG_DIR, "config.json");
+const PROFILES_DIR = join(LIBRETTO_CONFIG_DIR, "profiles");
+const LIBRETTO_SESSIONS_DIR = join(LIBRETTO_CONFIG_DIR, "sessions");
+const LIBRETTO_GITIGNORE_PATH = join(LIBRETTO_CONFIG_DIR, ".gitignore");
+const LIBRETTO_GITIGNORE_CONTENT = [
+  "# Local libretto runtime state",
+  "sessions/",
+  "profiles/",
+  ""
+].join("\n");
+function getSessionDir(session) {
+  return join(LIBRETTO_SESSIONS_DIR, session);
+}
+function getSessionStatePath(session) {
+  return join(getSessionDir(session), "state.json");
+}
+function getSessionLogsPath(session) {
+  return join(getSessionDir(session), "logs.jsonl");
+}
+function getSessionNetworkLogPath(session) {
+  return join(getSessionDir(session), "network.jsonl");
+}
+function getSessionActionsLogPath(session) {
+  return join(getSessionDir(session), "actions.jsonl");
+}
+function getSessionSnapshotsDir(session) {
+  return join(getSessionDir(session), "snapshots");
+}
+function getSessionSnapshotRunDir(session, snapshotRunId) {
+  return join(getSessionSnapshotsDir(session), snapshotRunId);
+}
+function ensureLibrettoSetup() {
+  mkdirSync(LIBRETTO_CONFIG_DIR, { recursive: true });
+  mkdirSync(LIBRETTO_SESSIONS_DIR, { recursive: true });
+  mkdirSync(PROFILES_DIR, { recursive: true });
+  if (!existsSync(LIBRETTO_GITIGNORE_PATH)) {
+    writeFileSync(LIBRETTO_GITIGNORE_PATH, LIBRETTO_GITIGNORE_CONTENT, "utf-8");
+  }
+}
+function createLoggerForSession(session) {
+  validateSessionName(session);
+  const sessionDir = getSessionDir(session);
+  mkdirSync(sessionDir, { recursive: true });
+  const logFilePath = getSessionLogsPath(session);
+  return new Logger(["libretto-cli"], [createFileLogSink({ filePath: logFilePath })]);
+}
+async function closeLogger(logger) {
+  if (!logger) return;
+  await logger.close();
+}
+async function withSessionLogger(session, run) {
+  const logger = createLoggerForSession(session);
+  try {
+    return await run(logger);
+  } finally {
+    await closeLogger(logger);
+  }
+}
+let llmClientFactory = null;
+function setLLMClientFactory(factory) {
+  llmClientFactory = factory;
+}
+function getLLMClientFactory() {
+  return llmClientFactory;
+}
+function maybeConfigureLLMClientFactoryFromEnv() {
+  if (llmClientFactory) return;
+  const hasAnyCreds = process.env.GOOGLE_CLOUD_PROJECT || process.env.GCLOUD_PROJECT || process.env.ANTHROPIC_API_KEY || process.env.OPENAI_API_KEY;
+  if (!hasAnyCreds) return;
+  setLLMClientFactory(async (_logger, model) => {
+    const { createLLMClient } = await import("../../shared/llm/index.js");
+    return createLLMClient(model);
+  });
+}
+export {
+  LIBRETTO_CONFIG_DIR,
+  LIBRETTO_CONFIG_PATH,
+  LIBRETTO_GITIGNORE_PATH,
+  LIBRETTO_SESSIONS_DIR,
+  PROFILES_DIR,
+  REPO_ROOT,
+  closeLogger,
+  createLoggerForSession,
+  ensureLibrettoSetup,
+  getLLMClientFactory,
+  getSessionActionsLogPath,
+  getSessionDir,
+  getSessionLogsPath,
+  getSessionNetworkLogPath,
+  getSessionSnapshotRunDir,
+  getSessionSnapshotsDir,
+  getSessionStatePath,
+  maybeConfigureLLMClientFactoryFromEnv,
+  setLLMClientFactory,
+  withSessionLogger
+};

package/dist/cli/core/pause-signals.js

@@ -0,0 +1,29 @@
+import { existsSync } from "node:fs";
+import { unlink } from "node:fs/promises";
+import { join } from "node:path";
+import { getSessionDir } from "./context.js";
+function getPauseSignalPaths(session) {
+  const sessionDir = getSessionDir(session);
+  return {
+    pausedSignalPath: join(sessionDir, `${session}.paused`),
+    resumeSignalPath: join(sessionDir, `${session}.resume`),
+    completedSignalPath: join(sessionDir, `${session}.completed`),
+    failedSignalPath: join(sessionDir, `${session}.failed`),
+    outputSignalPath: join(sessionDir, `${session}.output`)
+  };
+}
+async function removeSignalIfExists(path) {
+  if (!existsSync(path)) return;
+  try {
+    await unlink(path);
+  } catch (error) {
+    const code = error.code;
+    if (code !== "ENOENT") {
+      throw error;
+    }
+  }
+}
+export {
+  getPauseSignalPaths,
+  removeSignalIfExists
+};

package/dist/cli/core/session.js

@@ -0,0 +1,183 @@
+import {
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  readdirSync,
+  unlinkSync,
+  writeFileSync
+} from "node:fs";
+import {
+  getSessionDir,
+  getSessionLogsPath,
+  getSessionStatePath,
+  LIBRETTO_SESSIONS_DIR
+} from "./context.js";
+import {
+  SESSION_STATE_VERSION,
+  SessionStatusSchema,
+  parseSessionStateContent,
+  serializeSessionState
+} from "../../shared/state/index.js";
+const SESSION_NAME_PATTERN = /^[a-zA-Z0-9._-]+$/;
+const SESSION_DEFAULT = "default";
+const SESSION_DEV_SERVER = "dev-server";
+const SESSION_BROWSER_AGENT = "browser-agent";
+function logFileForSession(session) {
+  validateSessionName(session);
+  const dir = getSessionDir(session);
+  mkdirSync(dir, { recursive: true });
+  return getSessionLogsPath(session);
+}
+function validateSessionName(session) {
+  if (!SESSION_NAME_PATTERN.test(session) || session.includes("..") || session.includes("/") || session.includes("\\")) {
+    throw new Error(
+      "Invalid session name. Use only letters, numbers, dots, underscores, and dashes."
+    );
+  }
+}
+function getStateFilePath(session) {
+  validateSessionName(session);
+  const sessionDir = getSessionDir(session);
+  mkdirSync(sessionDir, { recursive: true });
+  return getSessionStatePath(session);
+}
+function readSessionState(session, logger) {
+  const stateFile = getStateFilePath(session);
+  if (!existsSync(stateFile)) {
+    logger?.info("session-state-not-found", { session, stateFile });
+    return null;
+  }
+  try {
+    const content = readFileSync(stateFile, "utf-8");
+    const state = parseSessionStateContent(content, stateFile);
+    logger?.info("session-state-read", {
+      session,
+      port: state.port,
+      pid: state.pid
+    });
+    return state;
+  } catch (err) {
+    logger?.warn("session-state-parse-error", {
+      error: err instanceof Error ? err.message : String(err),
+      session,
+      stateFile
+    });
+    return null;
+  }
+}
+function listActiveSessions() {
+  if (!existsSync(LIBRETTO_SESSIONS_DIR)) return [];
+  return readdirSync(LIBRETTO_SESSIONS_DIR).filter(
+    (session) => existsSync(getSessionStatePath(session))
+  );
+}
+function throwSessionNotFoundError(session) {
+  const active = listActiveSessions();
+  const lines = [`No session "${session}" found.`];
+  if (active.length > 0) {
+    lines.push("");
+    lines.push("Active sessions:");
+    for (const name of active) {
+      lines.push(`  ${name}`);
+    }
+  } else {
+    lines.push("");
+    lines.push("No active sessions.");
+  }
+  lines.push("");
+  lines.push("Start one with:");
+  lines.push(`  libretto-cli open <url> --session ${session}`);
+  throw new Error(lines.join("\n"));
+}
+function assertSessionStateExistsOrThrow(session) {
+  const stateFile = getStateFilePath(session);
+  if (!existsSync(stateFile)) {
+    throwSessionNotFoundError(session);
+  }
+}
+function readSessionStateOrThrow(session) {
+  const stateFile = getStateFilePath(session);
+  if (!existsSync(stateFile)) {
+    throwSessionNotFoundError(session);
+  }
+  try {
+    return parseSessionStateContent(readFileSync(stateFile, "utf-8"), stateFile);
+  } catch (err) {
+    throw new Error(
+      `Could not read session state for "${session}": ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+}
+function writeSessionState(state, logger) {
+  const stateFile = getStateFilePath(state.session);
+  const fileState = serializeSessionState(state);
+  writeFileSync(stateFile, JSON.stringify(fileState, null, 2), "utf-8");
+  logger?.info("session-state-write", {
+    session: state.session,
+    stateFile,
+    port: state.port,
+    pid: state.pid
+  });
+}
+function clearSessionState(session, logger) {
+  const stateFile = getStateFilePath(session);
+  if (!existsSync(stateFile)) {
+    logger?.info("session-state-clear-missing", { session, stateFile });
+    return;
+  }
+  unlinkSync(stateFile);
+  logger?.info("session-state-cleared", { session, stateFile });
+}
+function isSessionStatus(value) {
+  return SessionStatusSchema.safeParse(value).success;
+}
+function isPidRunning(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function setSessionStatus(session, status, logger) {
+  const state = readSessionState(session, logger);
+  if (!state) return;
+  if (state.status === status) return;
+  writeSessionState({
+    ...state,
+    status
+  }, logger);
+}
+function assertSessionAvailableForStart(session, logger) {
+  const existingState = readSessionState(session, logger);
+  if (!existingState) return;
+  if (isSessionStatus(existingState.status)) {
+    if (existingState.status === "completed" || existingState.status === "failed" || existingState.status === "exited") {
+      return;
+    }
+  }
+  if (!isPidRunning(existingState.pid)) {
+    setSessionStatus(session, "exited", logger);
+    return;
+  }
+  const endpoint = `http://127.0.0.1:${existingState.port}`;
+  throw new Error(
+    `Session "${session}" is already open and connected to ${endpoint} (pid ${existingState.pid}). Create a new session or close the current one with: libretto-cli close --session ${session}`
+  );
+}
+export {
+  SESSION_BROWSER_AGENT,
+  SESSION_DEFAULT,
+  SESSION_DEV_SERVER,
+  SESSION_STATE_VERSION,
+  assertSessionAvailableForStart,
+  assertSessionStateExistsOrThrow,
+  clearSessionState,
+  getStateFilePath,
+  logFileForSession,
+  readSessionState,
+  readSessionStateOrThrow,
+  setSessionStatus,
+  validateSessionName,
+  writeSessionState
+};