libretto 0.4.4 → 0.5.1

package/dist/cli/commands/snapshot.js

@@ -5,16 +5,10 @@ import { getSessionSnapshotRunDir } from "../core/context.js";
 import { condenseDom } from "../../shared/condense-dom/condense-dom.js";
 import { readSessionState } from "../core/session.js";
 import { SimpleCLI } from "../framework/simple-cli.js";
-import {
-  loadSessionStateMiddleware,
-  pageOption,
-  resolveSessionMiddleware,
-  sessionOption
-} from "./shared.js";
+import { pageOption, sessionOption, withRequiredSession } from "./shared.js";
 import { runApiInterpret } from "../core/api-snapshot-analyzer.js";
 import { readAiConfig } from "../core/ai-config.js";
 import { resolveSnapshotApiModelOrThrow } from "../core/snapshot-api-config.js";
-const DEFAULT_SNAPSHOT_CONTEXT = "No additional user context provided.";
 const FALLBACK_SNAPSHOT_VIEWPORT = { width: 1280, height: 800 };
 function generateSnapshotRunId() {
   return `snapshot-${Date.now()}`;
@@ -106,6 +100,12 @@ async function captureScreenshot(session, logger, pageId) {
     const pngPath = `${snapshotRunDir}/page.png`;
     const htmlPath = `${snapshotRunDir}/page.html`;
     const condensedHtmlPath = `${snapshotRunDir}/page.condensed.html`;
+    const RENDER_SETTLE_TIMEOUT_MS = 1e4;
+    await Promise.race([
+      page.waitForLoadState("networkidle").catch(() => {
+      }),
+      new Promise((resolve) => setTimeout(resolve, RENDER_SETTLE_TIMEOUT_MS))
+    ]);
     const restoreViewport = resolveSnapshotViewport(session, logger);
     const viewportMetrics = await readSnapshotViewportMetrics(page);
     logger.info("screenshot-viewport-metrics", {
@@ -185,17 +185,10 @@ async function captureScreenshot(session, logger, pageId) {
   }
 }
 async function runSnapshot(session, logger, pageId, objective, context) {
-  const normalizedObjective = objective?.trim();
-  const normalizedContext = context?.trim();
-  if (!normalizedObjective && normalizedContext) {
-    throw new Error(
-      "Couldn't run analysis: --objective is required when providing --context."
-    );
-  }
-  const configuredAi = normalizedObjective ? readAiConfig() : null;
-  if (normalizedObjective) {
-    resolveSnapshotApiModelOrThrow(configuredAi);
-  }
+  const normalizedObjective = objective.trim();
+  const normalizedContext = context.trim();
+  const configuredAi = readAiConfig();
+  resolveSnapshotApiModelOrThrow(configuredAi);
   const { pngPath, htmlPath, condensedHtmlPath } = await captureScreenshot(
     session,
     logger,
@@ -205,14 +198,10 @@ async function runSnapshot(session, logger, pageId, objective, context) {
   console.log(`  PNG:             ${pngPath}`);
   console.log(`  HTML:            ${htmlPath}`);
   console.log(`  Condensed HTML:  ${condensedHtmlPath}`);
-  if (!normalizedObjective) {
-    console.log("Use --objective flag to analyze snapshots.");
-    return;
-  }
   const interpretArgs = {
     objective: normalizedObjective,
     session,
-    context: normalizedContext ?? DEFAULT_SNAPSHOT_CONTEXT,
+    context: normalizedContext,
     pngPath,
     htmlPath,
     condensedHtmlPath
@@ -224,24 +213,22 @@ const snapshotInput = SimpleCLI.input({
   named: {
     session: sessionOption(),
     page: pageOption(),
-    objective: SimpleCLI.option(z.string().optional()),
-    context: SimpleCLI.option(z.string().optional())
+    objective: SimpleCLI.option(z.string()),
+    context: SimpleCLI.option(z.string())
   }
 });
-function createSnapshotCommand(logger) {
-  return SimpleCLI.command({
-    description: "Capture PNG + HTML; analyze when --objective is provided (--context optional)"
-  }).input(snapshotInput).use(resolveSessionMiddleware).use(loadSessionStateMiddleware).handle(async ({ input, ctx }) => {
-    await runSnapshot(
-      ctx.session,
-      logger,
-      input.page,
-      input.objective,
-      input.context
-    );
-  });
-}
+const snapshotCommand = SimpleCLI.command({
+  description: "Capture PNG + HTML and analyze with --objective and --context"
+}).input(snapshotInput).use(withRequiredSession()).handle(async ({ input, ctx }) => {
+  await runSnapshot(
+    ctx.session,
+    ctx.logger,
+    input.page,
+    input.objective,
+    input.context
+  );
+});
 export {
-  createSnapshotCommand,
+  snapshotCommand,
   snapshotInput
 };

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

@@ -26,7 +26,12 @@ const PROVIDER_ALIASES = {
   claude: DEFAULT_MODELS.anthropic,
   google: DEFAULT_MODELS.gemini
 };
-const CONFIGURE_PROVIDERS = ["openai", "anthropic", "gemini", "vertex"];
+const CONFIGURE_PROVIDERS = [
+  "openai",
+  "anthropic",
+  "gemini",
+  "vertex"
+];
 function formatConfigureProviders(separator = " | ") {
   return CONFIGURE_PROVIDERS.join(separator);
 }
@@ -147,7 +152,9 @@ function runAiConfigure(input, options = {}) {
       console.log(
         `No AI config set. Choose a default model: ${configureCommandName} ${formatConfigureProviders()}`
       );
-      console.log("Provider credentials still come from your shell or .env file.");
+      console.log(
+        "Provider credentials still come from your shell or .env file."
+      );
       return;
     }
     printAiConfig(config2, configPath);

package/dist/cli/core/api-snapshot-analyzer.js

@@ -1,16 +1,13 @@
 import { readFileSync } from "node:fs";
 import { createLLMClient } from "../../shared/llm/client.js";
 import {
-  formatInterpretationOutput,
   InterpretResultSchema,
   buildInlinePromptSelection,
   getMimeType,
   readFileAsBase64
 } from "./snapshot-analyzer.js";
 import { readAiConfig } from "./ai-config.js";
-import {
-  resolveSnapshotApiModelOrThrow
-} from "./snapshot-api-config.js";
+import { resolveSnapshotApiModelOrThrow } from "./snapshot-api-config.js";
 async function runApiInterpret(args, logger, configuredAi = readAiConfig()) {
   const selection = resolveSnapshotApiModelOrThrow(configuredAi);
   logger.info("api-interpret-start", {
@@ -67,7 +64,20 @@ async function runApiInterpret(args, logger, configuredAi = readAiConfig()) {
     selectorCount: parsed.selectors.length,
     answer: parsed.answer.slice(0, 200)
   });
-  console.log(formatInterpretationOutput(parsed, "Interpretation (via API):"));
+  console.log("");
+  console.log("Analysis:");
+  console.log(parsed.answer);
+  if (parsed.selectors.length > 0) {
+    console.log("");
+    console.log("Selectors:");
+    parsed.selectors.forEach((selector, index) => {
+      console.log(`  ${index + 1}. ${selector.label}: ${selector.selector}`);
+    });
+  }
+  if (parsed.notes?.trim()) {
+    console.log("");
+    console.log(`Notes: ${parsed.notes.trim()}`);
+  }
 }
 export {
   runApiInterpret

package/dist/cli/core/browser.js

@@ -1,4 +1,6 @@
-import { chromium } from "playwright";
+import {
+  chromium
+} from "playwright";
 import { openSync, existsSync } from "node:fs";
 import { dirname, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
@@ -57,9 +59,8 @@ function getProfilePath(domain) {
 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 });
+async function tryConnectToCDP(endpoint, logger, timeoutMs = 5e3) {
+  logger.info("cdp-connect-attempt", { endpoint, timeoutMs });
   try {
     const connectPromise = chromium.connectOverCDP(endpoint);
     const timeoutPromise = new Promise(
@@ -68,16 +69,15 @@ async function tryConnectToPort(port, logger, timeoutMs = 5e3) {
     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 });
+      logger.warn("cdp-connect-timeout", { endpoint, timeoutMs });
     }
     return browser;
   } catch (err) {
-    logger.error("cdp-connect-error", { error: err, port, endpoint });
+    logger.error("cdp-connect-error", { error: err, endpoint });
     return null;
   }
 }
@@ -102,7 +102,9 @@ async function resolvePageId(page) {
     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()}".`);
+      throw new Error(
+        `Could not resolve target id for page at URL "${page.url()}".`
+      );
     }
     return targetId;
   } finally {
@@ -135,16 +137,22 @@ async function listOpenPages(session, logger) {
 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);
+  const endpoint = state.cdpEndpoint ?? `http://localhost:${state.port}`;
+  const browser = await tryConnectToCDP(endpoint, logger, timeoutMs);
   if (!browser) {
     logger.error("connect-no-browser", {
       session,
-      port: state.port,
+      endpoint,
       pid: state.pid
     });
-    clearSessionState(session, logger);
+    if (state.pid == null || !isPidRunning(state.pid)) {
+      clearSessionState(session, logger);
+      throw new Error(
+        `No browser running for session "${session}". Run 'libretto open <url> --session ${session}' first.`
+      );
+    }
     throw new Error(
-      `No browser running for session "${session}". Run 'libretto-cli open <url> --session ${session}' first.`
+      `Could not connect to the browser for session "${session}" at ${endpoint}, but the session process (pid ${state.pid}) is still running. Try the command again, or close and reopen the session if it stays stuck.`
     );
   }
   const contexts = browser.contexts();
@@ -170,14 +178,14 @@ async function connect(session, logger, timeoutMs = 1e4, options) {
   }
   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).`
+      `Multiple pages are open in session "${session}". Pass --page <id> to target a page (run "libretto 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.`
+      `Page "${options?.pageId}" was not found in session "${session}". Run "libretto pages --session ${session}" to list ids.`
     );
   }
   const page = pageRef.page;
@@ -225,10 +233,16 @@ function resolveViewport(cliViewport, logger) {
   }
   const config = readLibrettoConfig();
   if (config.viewport) {
-    logger.info("viewport-source", { source: "config", viewport: config.viewport });
+    logger.info("viewport-source", {
+      source: "config",
+      viewport: config.viewport
+    });
     return config.viewport;
   }
-  logger.info("viewport-source", { source: "default", viewport: DEFAULT_VIEWPORT });
+  logger.info("viewport-source", {
+    source: "default",
+    viewport: DEFAULT_VIEWPORT
+  });
   return DEFAULT_VIEWPORT;
 }
 async function runOpen(rawUrl, headed, session, logger, options) {
@@ -293,7 +307,7 @@ function childLog(level, event, data = {}) {
 			timestamp: new Date().toISOString(),
 			id: Math.random().toString(36).slice(2, 10),
 			level,
-			scope: 'libretto-cli.child',
+			scope: 'libretto.child',
 			event,
 			data,
 		});
@@ -409,14 +423,17 @@ await new Promise(() => {});
       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",
-        viewport
-      }, logger);
+      writeSessionState(
+        {
+          port,
+          pid: child.pid,
+          session,
+          startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+          status: "active",
+          viewport
+        },
+        logger
+      );
       logger.info("open-success", {
         url,
         mode: browserMode,
@@ -512,8 +529,10 @@ async function runClose(session, logger) {
     return;
   }
   logger.info("close-killing", { session, pid: state.pid, port: state.port });
-  sendSignalToProcessGroupOrPid(state.pid, "SIGTERM", logger, session);
-  await waitForCloseSignalWindow(CLOSE_WAIT_MS);
+  if (state.pid != null) {
+    sendSignalToProcessGroupOrPid(state.pid, "SIGTERM", logger, session);
+    await waitForCloseSignalWindow(CLOSE_WAIT_MS);
+  }
   clearSessionState(session, logger);
   logger.info("close-success", { session });
   console.log(`Browser closed (session: ${session}).`);
@@ -570,7 +589,7 @@ function resolveClosableSessions(logger) {
 function clearStoppedSessionStates(sessions, logger) {
   let cleared = 0;
   for (const session of sessions) {
-    if (!isPidRunning(session.pid)) {
+    if (session.pid == null || !isPidRunning(session.pid)) {
       clearSessionState(session.session, logger);
       cleared += 1;
     }
@@ -596,17 +615,26 @@ async function runCloseAll(logger, options) {
       pid: target.pid,
       port: target.port
     });
-    sendSignalToProcessGroupOrPid(target.pid, "SIGTERM", logger, target.session);
+    if (target.pid != null) {
+      sendSignalToProcessGroupOrPid(
+        target.pid,
+        "SIGTERM",
+        logger,
+        target.session
+      );
+    }
   }
   await waitForCloseSignalWindow(CLOSE_WAIT_MS);
-  let survivors = closable.filter((target) => isPidRunning(target.pid));
+  let survivors = closable.filter(
+    (target) => target.pid != null && isPidRunning(target.pid)
+  );
   if (survivors.length > 0 && !force) {
     const closed = clearStoppedSessionStates(closable, logger);
     throw new Error(
       [
         `Failed to close ${survivors.length} session(s) gracefully: ${formatSessionList(survivors)}.`,
         `Closed ${closed} session(s).`,
-        "Retry with: libretto-cli close --all --force"
+        `Retry with: libretto close --all --force`
       ].join("\n")
     );
   }
@@ -617,11 +645,20 @@ async function runCloseAll(logger, options) {
         session: survivor.session,
         pid: survivor.pid
       });
-      sendSignalToProcessGroupOrPid(survivor.pid, "SIGKILL", logger, survivor.session);
+      if (survivor.pid != null) {
+        sendSignalToProcessGroupOrPid(
+          survivor.pid,
+          "SIGKILL",
+          logger,
+          survivor.session
+        );
+      }
       forceKilled += 1;
     }
     await waitForCloseSignalWindow(FORCE_CLOSE_WAIT_MS);
-    survivors = survivors.filter((target) => isPidRunning(target.pid));
+    survivors = survivors.filter(
+      (target) => target.pid != null && isPidRunning(target.pid)
+    );
     if (survivors.length > 0) {
       const closed = clearStoppedSessionStates(closable, logger);
       throw new Error(
@@ -643,6 +680,75 @@ async function runCloseAll(logger, options) {
     console.log(`Force-killed ${forceKilled} session(s).`);
   }
 }
+async function runConnect(cdpUrl, session, logger) {
+  logger.info("connect-start", { cdpUrl, session });
+  assertSessionAvailableForStart(session, logger);
+  let parsedUrl;
+  try {
+    parsedUrl = new URL(cdpUrl);
+  } catch {
+    throw new Error(
+      [
+        `Invalid CDP URL: ${cdpUrl}`,
+        ``,
+        `Expected an HTTP URL pointing to a Chrome DevTools Protocol endpoint, for example:`,
+        `  libretto connect http://127.0.0.1:9222`,
+        `  libretto connect http://remote-host:9222`,
+        `  libretto connect http://remote-host:9222/devtools/browser/<id>`
+      ].join("\n")
+    );
+  }
+  const endpoint = parsedUrl.href;
+  const port = parsedUrl.port ? Number(parsedUrl.port) : parsedUrl.protocol === "https:" ? 443 : 80;
+  console.log(
+    `Connecting to CDP endpoint at ${endpoint} (session: ${session})...`
+  );
+  const versionUrl = `${parsedUrl.protocol}//${parsedUrl.host}/json/version`;
+  try {
+    const resp = await fetch(versionUrl);
+    const versionInfo = await resp.json();
+    logger.info("connect-version-ok", { versionUrl, versionInfo });
+  } catch (err) {
+    logger.error("connect-version-failed", { versionUrl, error: err });
+    throw new Error(
+      `Cannot reach CDP endpoint at ${versionUrl}. Make sure the target is running and accessible at ${parsedUrl.host}.`
+    );
+  }
+  const browser = await tryConnectToCDP(endpoint, logger, 1e4);
+  if (!browser) {
+    throw new Error(
+      `CDP endpoint at ${endpoint} is reachable but Playwright could not connect. Check that the URL is a Chrome DevTools Protocol endpoint.`
+    );
+  }
+  const pages = resolveOperationalPages(browser);
+  logger.info("connect-pages", {
+    session,
+    pageCount: pages.length,
+    urls: pages.map((p) => p.url())
+  });
+  disconnectBrowser(browser, logger, session);
+  writeSessionState(
+    {
+      port,
+      cdpEndpoint: endpoint,
+      session,
+      startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      status: "active"
+    },
+    logger
+  );
+  logger.info("connect-success", { cdpUrl: endpoint, session, port });
+  console.log(`Connected to ${endpoint} (session: ${session})`);
+  console.log(`  Pages found: ${pages.length}`);
+  if (pages.length > 0) {
+    for (const p of pages.slice(0, 5)) {
+      console.log(`    ${p.url()}`);
+    }
+    if (pages.length > 5) {
+      console.log(`    ... and ${pages.length - 5} more`);
+    }
+  }
+}
 function resolvePath(filePath) {
   return join(process.cwd(), filePath);
 }
@@ -661,8 +767,10 @@ export {
   normalizeDomain,
   normalizeUrl,
   resolvePath,
+  resolveViewport,
   runClose,
   runCloseAll,
+  runConnect,
   runOpen,
   runPages,
   runSave

package/dist/cli/core/context.js

@@ -1,23 +1,9 @@
 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, resolve } from "node:path";
+import { join } from "node:path";
+import { resolveLibrettoRepoRoot } from "../../shared/paths/repo-root.js";
 import { validateSessionName } from "./session.js";
-function getRepoRoot() {
-  const override = process.env.LIBRETTO_REPO_ROOT?.trim();
-  if (override) {
-    return resolve(override);
-  }
-  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 REPO_ROOT = resolveLibrettoRepoRoot();
 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");
@@ -63,7 +49,10 @@ function createLoggerForSession(session) {
   const sessionDir = getSessionDir(session);
   mkdirSync(sessionDir, { recursive: true });
   const logFilePath = getSessionLogsPath(session);
-  return new Logger(["libretto-cli"], [createFileLogSink({ filePath: logFilePath })]);
+  return new Logger(
+    ["libretto"],
+    [createFileLogSink({ filePath: logFilePath })]
+  );
 }
 async function closeLogger(logger) {
   if (!logger) return;

package/dist/cli/core/session-telemetry.js

@@ -12,7 +12,9 @@ async function installSessionTelemetry(options) {
       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()}".`);
+        throw new Error(
+          `Could not resolve target id for page at URL "${page.url()}".`
+        );
       }
       pageIdCache.set(page, targetId);
       return targetId;
@@ -439,7 +441,8 @@ async function installSessionTelemetry(options) {
     page.on("response", async (response) => {
       const request = response.request();
       const url = request.url();
-      if (STATIC_EXT_RE.test(url) || url.startsWith("chrome-extension://")) return;
+      if (STATIC_EXT_RE.test(url) || url.startsWith("chrome-extension://"))
+        return;
       emitNetwork({
         pageId,
         method: request.method(),

package/dist/cli/core/session.js

@@ -18,9 +18,16 @@ import {
   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 generateSessionName() {
+  const chars = "abcdefghijklmnopqrstuvwxyz0123456789";
+  let id = "";
+  for (let i = 0; i < 4; i++) {
+    id += chars[Math.floor(Math.random() * chars.length)];
+  }
+  return `ses-${id}`;
+}
 function logFileForSession(session) {
   validateSessionName(session);
   const dir = getSessionDir(session);
@@ -93,7 +100,7 @@ function throwSessionNotFoundError(session) {
   }
   lines.push("");
   lines.push("Start one with:");
-  lines.push(`  libretto-cli open <url> --session ${session}`);
+  lines.push(`  libretto open <url> --session ${session}`);
   throw new Error(lines.join("\n"));
 }
 function assertSessionStateExistsOrThrow(session) {
@@ -108,7 +115,10 @@ function readSessionStateOrThrow(session) {
     throwSessionNotFoundError(session);
   }
   try {
-    return parseSessionStateContent(readFileSync(stateFile, "utf-8"), stateFile);
+    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)}`
@@ -147,31 +157,34 @@ function setSessionStatus(session, status, logger) {
   const state = readSessionState(session, logger);
   if (!state) return;
   if (state.status === status) return;
-  writeSessionState({
-    ...state,
-    status
-  }, logger);
+  writeSessionState(
+    {
+      ...state,
+      status
+    },
+    logger
+  );
 }
 function assertSessionAvailableForStart(session, logger) {
   const existingState = readSessionState(session, logger);
   if (!existingState) return;
-  if (!isPidRunning(existingState.pid)) {
+  if (existingState.pid == null || !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}`
+    `Session "${session}" is already open and connected to ${endpoint} (pid ${existingState.pid}). Create a new session or close the current one with: libretto close --session ${session}`
   );
 }
 export {
   SESSION_BROWSER_AGENT,
-  SESSION_DEFAULT,
   SESSION_DEV_SERVER,
   SESSION_STATE_VERSION,
   assertSessionAvailableForStart,
   assertSessionStateExistsOrThrow,
   clearSessionState,
+  generateSessionName,
   getStateFilePath,
   listSessionsWithStateFile,
   logFileForSession,