libretto 0.3.0 → 0.3.2

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,
+  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 listSessionsWithStateFile() {
+  if (!existsSync(LIBRETTO_SESSIONS_DIR)) return [];
+  return readdirSync(LIBRETTO_SESSIONS_DIR).filter((session) => {
+    try {
+      validateSessionName(session);
+    } catch {
+      return false;
+    }
+    return existsSync(getSessionStatePath(session));
+  }).sort();
+}
+function listActiveSessions() {
+  return listSessionsWithStateFile();
+}
+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 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 (!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,
+  listSessionsWithStateFile,
+  logFileForSession,
+  readSessionState,
+  readSessionStateOrThrow,
+  setSessionStatus,
+  validateSessionName,
+  writeSessionState
+};