@ganakailabs/cloudeval-cli 0.19.2 → 0.19.4

package/dist/chunk-RCRNSEQS.js

@@ -0,0 +1,1014 @@
+// src/frontendLinks.ts
+var trimTrailingSlash = (value) => value.replace(/\/+$/, "");
+var resolveFrontendBaseUrl = ({
+  frontendUrl,
+  apiBaseUrl,
+  env = process.env
+} = {}) => {
+  const explicit = frontendUrl?.trim() || env.CLOUDEVAL_FRONTEND_URL || env.CLOUDEVAL_WEB_URL;
+  if (explicit) {
+    return trimTrailingSlash(explicit);
+  }
+  try {
+    const api = apiBaseUrl ? new URL(apiBaseUrl) : void 0;
+    if (api && ["localhost", "127.0.0.1", "::1"].includes(api.hostname)) {
+      return "http://localhost:3000";
+    }
+  } catch {
+  }
+  return "https://cloudeval.ai";
+};
+var appUrl = (baseUrl, path3) => new URL(
+  `/app${path3.startsWith("/") ? path3 : `/${path3}`}`,
+  `${trimTrailingSlash(baseUrl)}/`
+);
+var setParam = (url, key, value) => {
+  if (value !== void 0 && value !== "" && value !== false) {
+    url.searchParams.set(key, String(value));
+  }
+};
+var setArrayParam = (url, key, value) => {
+  if (!value) {
+    return;
+  }
+  url.searchParams.set(key, Array.isArray(value) ? value.join(",") : value);
+};
+var buildFrontendUrl = (options) => {
+  let url;
+  switch (options.target) {
+    case "overview":
+      url = appUrl(options.baseUrl, "/overview");
+      break;
+    case "chat":
+      url = appUrl(options.baseUrl, "/chat");
+      setParam(url, "threadId", options.threadId);
+      break;
+    case "projects":
+      url = appUrl(options.baseUrl, "/projects");
+      if (options.quick) {
+        setParam(url, "dialog", "quick");
+        setParam(url, "template_url", options.templateUrl);
+        setParam(url, "name", options.name);
+        setParam(url, "description", options.description);
+        setParam(url, "provider", options.provider);
+        setParam(url, "auto_submit", options.autoSubmit ? "true" : void 0);
+      }
+      break;
+    case "project":
+      if (!options.projectId) {
+        throw new Error("projectId is required for project frontend links.");
+      }
+      url = appUrl(
+        options.baseUrl,
+        `/projects/${encodeURIComponent(options.projectId)}`
+      );
+      setParam(url, "view", options.view);
+      setParam(url, "layout", options.layout);
+      setArrayParam(url, "node", options.node);
+      setParam(url, "resource", options.resource);
+      setParam(url, "tab", options.tab);
+      setParam(url, "file", options.file);
+      setArrayParam(url, "files", options.files);
+      setParam(url, "cursor", options.cursor);
+      setParam(url, "selection", options.selection);
+      setParam(
+        url,
+        "workspaceFocus",
+        options.workspaceFocus ? "true" : void 0
+      );
+      setParam(url, "mode", options.presentation ? "presentation" : void 0);
+      break;
+    case "connections":
+      url = appUrl(options.baseUrl, "/connections");
+      setParam(url, "dialog", options.dialog);
+      break;
+    case "connection":
+      if (!options.connectionId) {
+        throw new Error(
+          "connectionId is required for connection frontend links."
+        );
+      }
+      url = appUrl(
+        options.baseUrl,
+        `/connections/${encodeURIComponent(options.connectionId)}`
+      );
+      break;
+    case "reports":
+      url = options.projectId ? appUrl(
+        options.baseUrl,
+        `/reports/${encodeURIComponent(options.projectId)}`
+      ) : appUrl(options.baseUrl, "/reports");
+      setParam(url, "tab", options.tab);
+      setParam(url, "reportType", options.reportType);
+      setParam(url, "timeRange", options.timeRange);
+      setParam(url, "persona", options.persona);
+      setParam(url, "cadence", options.cadence);
+      setParam(url, "issuesQuery", options.issuesQuery);
+      setParam(
+        url,
+        "issuesFullscreen",
+        options.issuesFullscreen ? "1" : void 0
+      );
+      setParam(url, "issuesView", options.issuesView);
+      setParam(url, "downloadPdf", options.downloadPdf ? "1" : void 0);
+      setParam(url, "pdfVerbosity", options.pdfVerbosity);
+      setParam(url, "downloadReport", options.downloadReport);
+      setParam(url, "reportVerbosity", options.reportVerbosity);
+      break;
+    case "billing":
+      url = appUrl(options.baseUrl, "/subscription");
+      setParam(url, "tab", options.tab);
+      break;
+    default:
+      throw new Error(
+        `Unsupported frontend target '${String(options.target)}'.`
+      );
+  }
+  return url.toString();
+};
+var openExternalUrl = async (url) => {
+  const { spawn } = await import("child_process");
+  const platform = process.platform;
+  const command = platform === "darwin" ? "open" : platform === "win32" ? "cmd" : "xdg-open";
+  const args = platform === "win32" ? ["/c", "start", "", url] : [url];
+  const child = spawn(command, args, {
+    detached: true,
+    stdio: "ignore"
+  });
+  child.unref();
+};
+
+// src/cliConfig.ts
+import fs from "fs/promises";
+import os from "os";
+import path from "path";
+var CONFIG_PROFILE_PATTERN = /^[a-zA-Z0-9][a-zA-Z0-9_-]{0,63}$/;
+var SETTINGS_FILE = "settings.json";
+var normalizeConfigProfile = (profile) => {
+  const normalized = (profile || process.env.CLOUDEVAL_PROFILE || "default").trim() || "default";
+  if (!CONFIG_PROFILE_PATTERN.test(normalized)) {
+    throw new Error(
+      `Invalid profile '${normalized}'. Use letters, numbers, dashes, or underscores.`
+    );
+  }
+  return normalized;
+};
+var getActiveConfigProfile = (command) => {
+  const opts = typeof command?.optsWithGlobals === "function" ? command.optsWithGlobals() : command?.opts();
+  return normalizeConfigProfile(opts?.profile);
+};
+var getCloudevalConfigDir = () => path.join(os.homedir(), ".config", "cloudeval");
+var getCliConfigPath = (profile) => {
+  const normalized = normalizeConfigProfile(profile);
+  if (normalized === "default") {
+    return path.join(getCloudevalConfigDir(), SETTINGS_FILE);
+  }
+  return path.join(getCloudevalConfigDir(), "profiles", normalized, SETTINGS_FILE);
+};
+var ensureConfigParent = async (filePath) => {
+  await fs.mkdir(path.dirname(filePath), { recursive: true, mode: 448 });
+};
+var loadCliConfig = async (profile) => {
+  const filePath = getCliConfigPath(profile);
+  try {
+    const raw = await fs.readFile(filePath, "utf8");
+    const parsed = JSON.parse(raw);
+    return parsed && typeof parsed === "object" ? parsed : {};
+  } catch (error) {
+    if (error?.code === "ENOENT") {
+      return {};
+    }
+    throw error;
+  }
+};
+var saveCliConfig = async (config, profile) => {
+  const filePath = getCliConfigPath(profile);
+  await ensureConfigParent(filePath);
+  const tempPath = `${filePath}.${process.pid}.tmp`;
+  await fs.writeFile(tempPath, `${JSON.stringify(config, null, 2)}
+`, {
+    encoding: "utf8",
+    mode: 384
+  });
+  await fs.rename(tempPath, filePath);
+  return filePath;
+};
+var listCliConfigProfiles = async () => {
+  const profiles = /* @__PURE__ */ new Set(["default"]);
+  const profilesDir = path.join(getCloudevalConfigDir(), "profiles");
+  try {
+    const entries = await fs.readdir(profilesDir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.isDirectory() && CONFIG_PROFILE_PATTERN.test(entry.name)) {
+        profiles.add(entry.name);
+      }
+    }
+  } catch (error) {
+    if (error?.code !== "ENOENT") {
+      throw error;
+    }
+  }
+  return [...profiles].sort();
+};
+var keyAliases = {
+  project: "defaultProjectId",
+  projectId: "defaultProjectId",
+  defaultProject: "defaultProjectId",
+  defaultProjectId: "defaultProjectId",
+  model: "model",
+  mode: "mode",
+  chatMode: "mode",
+  defaultMode: "mode",
+  baseUrl: "baseUrl",
+  frontendUrl: "frontendUrl",
+  outputFormat: "outputFormat",
+  format: "outputFormat"
+};
+var normalizeCliMode = (value) => {
+  const normalized = value?.trim().toLowerCase();
+  if (!normalized) {
+    return void 0;
+  }
+  if (normalized === "ask" || normalized === "agent") {
+    return normalized;
+  }
+  throw new Error("mode must be one of: ask, agent");
+};
+var normalizeConfigKey = (key) => {
+  const normalized = key.trim();
+  const mapped = keyAliases[normalized];
+  if (!mapped) {
+    throw new Error(
+      `Unsupported config key '${key}'. Supported keys: baseUrl, frontendUrl, defaultProjectId, model, mode, outputFormat.`
+    );
+  }
+  return mapped;
+};
+var readCliConfigValue = (config, key) => {
+  const normalized = normalizeConfigKey(key);
+  const value = config[normalized];
+  return typeof value === "string" ? value : void 0;
+};
+var writeCliConfigValue = (config, key, value) => {
+  const normalized = normalizeConfigKey(key);
+  const normalizedValue = normalized === "mode" ? normalizeCliMode(value) : value;
+  return {
+    ...config,
+    [normalized]: normalizedValue
+  };
+};
+var unsetCliConfigValue = (config, key) => {
+  const normalized = normalizeConfigKey(key);
+  const next = { ...config };
+  delete next[normalized];
+  return next;
+};
+
+// src/ui/userDisplayName.ts
+var toTitleCase = (value) => {
+  const normalized = value.trim();
+  if (!normalized) {
+    return "";
+  }
+  return normalized.charAt(0).toUpperCase() + normalized.slice(1).toLowerCase();
+};
+var firstToken = (value) => {
+  const token = value?.trim().split(/\s+/)[0]?.replace(/^[^\p{L}]+|[^\p{L}]+$/gu, "");
+  return token ? toTitleCase(token) : void 0;
+};
+var firstNameFromEmail = (email) => {
+  const localPart = email?.split("@")[0];
+  if (!localPart) {
+    return void 0;
+  }
+  const token = localPart.split(/[._-]+/).find((part) => /[a-z]/i.test(part))?.replace(/\d+/g, "");
+  return token ? toTitleCase(token) : void 0;
+};
+var getFirstNameForDisplay = (user, fallback = "You") => {
+  const fromName = firstToken(user?.full_name ?? user?.fullName ?? user?.name);
+  if (fromName) {
+    return fromName;
+  }
+  return firstNameFromEmail(user?.email) ?? fallback;
+};
+
+// src/sessionsStore.ts
+import fsSync from "fs";
+import fs2 from "fs/promises";
+import path2 from "path";
+import { fileURLToPath } from "url";
+var SQLJS_WASM_ENV_VAR = "CLOUDEVAL_SQLJS_WASM";
+var legacySessionsDir = (profile) => {
+  const normalized = normalizeConfigProfile(profile);
+  if (normalized === "default") {
+    return path2.join(getCloudevalConfigDir(), "sessions");
+  }
+  return path2.join(getCloudevalConfigDir(), "profiles", normalized, "sessions");
+};
+var sessionsDatabasePath = (profile) => {
+  const normalized = normalizeConfigProfile(profile);
+  if (normalized === "default") {
+    return path2.join(getCloudevalConfigDir(), "sessions.sqlite");
+  }
+  return path2.join(getCloudevalConfigDir(), "profiles", normalized, "sessions.sqlite");
+};
+var legacySessionPath = (threadId, profile) => path2.join(legacySessionsDir(profile), `${sanitizeThreadId(threadId)}.json`);
+var sanitizeThreadId = (threadId) => threadId.replace(/[^a-zA-Z0-9_.-]/g, "_");
+var nowIso = () => (/* @__PURE__ */ new Date()).toISOString();
+var titleFromQuestion = (question) => {
+  const singleLine = question.replace(/[^\p{L}\p{N}\s'-]/gu, " ").replace(/\s+/g, " ").trim().replace(/^(can you|could you|please|help me|show me|tell me|what is|what are|how do i)\s+/i, "").replace(/^(review|investigate|triage|summarize|explain|analyze)\s+the\s+/i, "$1 ");
+  if (!singleLine) {
+    return "Untitled CloudEval session";
+  }
+  const words = singleLine.split(/\s+/).slice(0, 7);
+  const joined = words.join(" ");
+  const title = joined.charAt(0).toUpperCase() + joined.slice(1);
+  return title.length > 80 ? `${title.slice(0, 77)}...` : title;
+};
+var sanitizeTitle = (title) => {
+  const cleaned = title.replace(/[\u0000-\u001f\u007f]/g, " ").replace(/[\u200b-\u200f\u202a-\u202e]/g, "").replace(/\s+/g, " ").trim();
+  if (!cleaned) {
+    throw new Error("Session title cannot be empty.");
+  }
+  return cleaned.length > 100 ? cleaned.slice(0, 100) : cleaned;
+};
+var hasFile = (candidate) => {
+  try {
+    return fsSync.statSync(candidate).isFile();
+  } catch {
+    return false;
+  }
+};
+var findSqlJsWasmInNodeModules = (dir) => {
+  const nodeModulesDir = path2.join(dir, "node_modules");
+  const direct = path2.join(nodeModulesDir, "sql.js", "dist", "sql-wasm.wasm");
+  if (hasFile(direct)) {
+    return direct;
+  }
+  const pnpmRoot = path2.join(nodeModulesDir, ".pnpm");
+  if (!fsSync.existsSync(pnpmRoot)) {
+    return void 0;
+  }
+  for (const entry of fsSync.readdirSync(pnpmRoot)) {
+    if (!entry.startsWith("sql.js@")) {
+      continue;
+    }
+    const candidate = path2.join(
+      pnpmRoot,
+      entry,
+      "node_modules",
+      "sql.js",
+      "dist",
+      "sql-wasm.wasm"
+    );
+    if (hasFile(candidate)) {
+      return candidate;
+    }
+  }
+  return void 0;
+};
+var searchSqlJsWasmFrom = (start) => {
+  let current = path2.resolve(start);
+  while (true) {
+    const localCandidates = [
+      path2.join(current, "sql-wasm.wasm"),
+      path2.join(current, "dist", "sql-wasm.wasm")
+    ];
+    for (const candidate of localCandidates) {
+      if (hasFile(candidate)) {
+        return candidate;
+      }
+    }
+    const nodeModulesMatch = findSqlJsWasmInNodeModules(current);
+    if (nodeModulesMatch) {
+      return nodeModulesMatch;
+    }
+    const parent = path2.dirname(current);
+    if (parent === current) {
+      return void 0;
+    }
+    current = parent;
+  }
+};
+var resolveSqlJsWasmPath = () => {
+  if (process.env[SQLJS_WASM_ENV_VAR]) {
+    return process.env[SQLJS_WASM_ENV_VAR];
+  }
+  const moduleDir = path2.dirname(fileURLToPath(import.meta.url));
+  const seen = /* @__PURE__ */ new Set();
+  const roots = [process.cwd(), moduleDir, path2.dirname(process.execPath)];
+  for (const root of roots) {
+    const resolvedRoot = path2.resolve(root);
+    if (seen.has(resolvedRoot)) {
+      continue;
+    }
+    seen.add(resolvedRoot);
+    const match = searchSqlJsWasmFrom(resolvedRoot);
+    if (match) {
+      return match;
+    }
+  }
+  return void 0;
+};
+var isBunRuntime = () => typeof process.versions.bun === "string";
+var dynamicImport = new Function("specifier", "return import(specifier)");
+var openBunDatabase = async (dbPath) => {
+  if (!isBunRuntime()) {
+    return null;
+  }
+  try {
+    const { Database } = await dynamicImport("bun:sqlite");
+    await fs2.mkdir(path2.dirname(dbPath), { recursive: true, mode: 448 });
+    const db = new Database(dbPath, { create: true });
+    db.exec("PRAGMA foreign_keys = ON");
+    return {
+      rows(sql, params = []) {
+        const statement = db.query(sql);
+        return statement.all(...params);
+      },
+      run(sql, params = []) {
+        const statement = db.query(sql);
+        statement.run(...params);
+      },
+      async persist() {
+      },
+      close() {
+        db.close();
+      }
+    };
+  } catch {
+    return null;
+  }
+};
+var sqlJsFactoryPromise = null;
+var loadSqlJsFactory = async () => {
+  if (!sqlJsFactoryPromise) {
+    sqlJsFactoryPromise = (async () => {
+      const initSqlJs = (await import("sql.js")).default;
+      const wasmPath = resolveSqlJsWasmPath();
+      return initSqlJs({
+        locateFile: (file) => {
+          if (file === "sql-wasm.wasm" && wasmPath) {
+            return wasmPath;
+          }
+          return file;
+        }
+      });
+    })();
+  }
+  return sqlJsFactoryPromise;
+};
+var openSqlJsDatabase = async (dbPath) => {
+  await fs2.mkdir(path2.dirname(dbPath), { recursive: true, mode: 448 });
+  const SQL = await loadSqlJsFactory();
+  let bytes;
+  try {
+    bytes = await fs2.readFile(dbPath);
+  } catch (error) {
+    if (error?.code !== "ENOENT") {
+      throw error;
+    }
+  }
+  const db = bytes ? new SQL.Database(bytes) : new SQL.Database();
+  db.run("PRAGMA foreign_keys = ON");
+  let dirty = false;
+  return {
+    rows(sql, params = []) {
+      const statement = db.prepare(sql, params);
+      const rows = [];
+      try {
+        while (statement.step()) {
+          rows.push(statement.getAsObject());
+        }
+      } finally {
+        statement.free();
+      }
+      return rows;
+    },
+    run(sql, params = []) {
+      db.run(sql, params);
+      dirty = true;
+    },
+    async persist() {
+      if (!dirty) {
+        return;
+      }
+      const tempPath = `${dbPath}.${process.pid}.tmp`;
+      await fs2.writeFile(tempPath, Buffer.from(db.export()), { mode: 384 });
+      await fs2.rename(tempPath, dbPath);
+      dirty = false;
+    },
+    close() {
+      db.close();
+    }
+  };
+};
+var openSessionDatabase = async (profile) => {
+  const dbPath = sessionsDatabasePath(profile);
+  return await openBunDatabase(dbPath) ?? openSqlJsDatabase(dbPath);
+};
+var ensureSchema = (db) => {
+  db.run(`
+    CREATE TABLE IF NOT EXISTS sessions (
+      thread_id TEXT PRIMARY KEY,
+      title TEXT NOT NULL,
+      project_id TEXT,
+      project_name TEXT,
+      model TEXT,
+      profile TEXT NOT NULL,
+      created_at TEXT NOT NULL,
+      updated_at TEXT NOT NULL,
+      message_count INTEGER NOT NULL DEFAULT 0
+    )
+  `);
+  db.run(`
+    CREATE TABLE IF NOT EXISTS session_messages (
+      session_thread_id TEXT NOT NULL,
+      message_index INTEGER NOT NULL,
+      role TEXT NOT NULL CHECK (role IN ('user', 'assistant')),
+      content TEXT NOT NULL,
+      created_at TEXT NOT NULL,
+      PRIMARY KEY (session_thread_id, message_index),
+      FOREIGN KEY (session_thread_id) REFERENCES sessions(thread_id) ON DELETE CASCADE
+    )
+  `);
+  db.run("CREATE INDEX IF NOT EXISTS idx_sessions_updated_at ON sessions(updated_at DESC)");
+  db.run(
+    "CREATE INDEX IF NOT EXISTS idx_session_messages_thread ON session_messages(session_thread_id, message_index)"
+  );
+  ensureFtsSchema(db);
+};
+var ensureFtsSchema = (db) => {
+  try {
+    db.run(`
+      CREATE VIRTUAL TABLE IF NOT EXISTS session_messages_fts USING fts5(
+        thread_id UNINDEXED,
+        title,
+        project,
+        content
+      )
+    `);
+    return true;
+  } catch {
+    return false;
+  }
+};
+var optionalString = (value) => typeof value === "string" && value.length > 0 ? value : void 0;
+var messageFromRow = (row) => {
+  const role = row.role;
+  const content = row.content;
+  const createdAt = row.created_at;
+  if (role !== "user" && role !== "assistant" || typeof content !== "string") {
+    return null;
+  }
+  return {
+    role,
+    content,
+    createdAt: typeof createdAt === "string" ? createdAt : nowIso()
+  };
+};
+var sessionFromRow = (db, row) => {
+  const threadId = row.thread_id;
+  const title = row.title;
+  const createdAt = row.created_at;
+  const updatedAt = row.updated_at;
+  if (typeof threadId !== "string" || typeof title !== "string" || typeof createdAt !== "string" || typeof updatedAt !== "string") {
+    return null;
+  }
+  const messages = db.rows(
+    `SELECT role, content, created_at
+       FROM session_messages
+       WHERE session_thread_id = ?
+       ORDER BY message_index ASC`,
+    [threadId]
+  ).map(messageFromRow).filter((message) => Boolean(message));
+  return {
+    threadId,
+    title,
+    projectId: optionalString(row.project_id),
+    projectName: optionalString(row.project_name),
+    model: optionalString(row.model),
+    profile: optionalString(row.profile),
+    createdAt,
+    updatedAt,
+    messageCount: Number(row.message_count) || messages.length,
+    messages
+  };
+};
+var getSessionFromDb = (db, threadId) => {
+  const row = db.rows("SELECT * FROM sessions WHERE thread_id = ?", [threadId])[0];
+  return row ? sessionFromRow(db, row) : null;
+};
+var runTransaction = (db, fn) => {
+  db.run("BEGIN IMMEDIATE");
+  try {
+    const result = fn();
+    db.run("COMMIT");
+    return result;
+  } catch (error) {
+    try {
+      db.run("ROLLBACK");
+    } catch {
+    }
+    throw error;
+  }
+};
+var upsertSession = (db, session) => {
+  runTransaction(db, () => {
+    db.run(
+      `INSERT INTO sessions (
+        thread_id,
+        title,
+        project_id,
+        project_name,
+        model,
+        profile,
+        created_at,
+        updated_at,
+        message_count
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+      ON CONFLICT(thread_id) DO UPDATE SET
+        title = excluded.title,
+        project_id = excluded.project_id,
+        project_name = excluded.project_name,
+        model = excluded.model,
+        profile = excluded.profile,
+        created_at = excluded.created_at,
+        updated_at = excluded.updated_at,
+        message_count = excluded.message_count`,
+      [
+        session.threadId,
+        session.title,
+        session.projectId ?? null,
+        session.projectName ?? null,
+        session.model ?? null,
+        session.profile ?? "default",
+        session.createdAt,
+        session.updatedAt,
+        session.messages.length
+      ]
+    );
+    db.run("DELETE FROM session_messages WHERE session_thread_id = ?", [session.threadId]);
+    session.messages.forEach((message, index) => {
+      db.run(
+        `INSERT INTO session_messages (
+          session_thread_id,
+          message_index,
+          role,
+          content,
+          created_at
+        ) VALUES (?, ?, ?, ?, ?)`,
+        [session.threadId, index, message.role, message.content, message.createdAt]
+      );
+    });
+    upsertSessionFts(db, session);
+  });
+};
+var upsertSessionFts = (db, session) => {
+  if (!ensureFtsSchema(db)) {
+    return;
+  }
+  try {
+    db.run("DELETE FROM session_messages_fts WHERE thread_id = ?", [session.threadId]);
+    db.run(
+      `INSERT INTO session_messages_fts (thread_id, title, project, content)
+       VALUES (?, ?, ?, ?)`,
+      [
+        session.threadId,
+        session.title,
+        [session.projectId, session.projectName].filter(Boolean).join(" "),
+        session.messages.map((message) => message.content).join("\n")
+      ]
+    );
+  } catch {
+  }
+};
+var deleteSessionFts = (db, threadId) => {
+  if (!ensureFtsSchema(db)) {
+    return;
+  }
+  try {
+    db.run("DELETE FROM session_messages_fts WHERE thread_id = ?", [threadId]);
+  } catch {
+  }
+};
+var readLegacySessionFile = async (filePath) => {
+  try {
+    const raw = await fs2.readFile(filePath, "utf8");
+    const parsed = JSON.parse(raw);
+    return parsed && typeof parsed === "object" ? normalizeLegacySession(parsed) : null;
+  } catch (error) {
+    if (error?.code === "ENOENT") {
+      return null;
+    }
+    throw error;
+  }
+};
+var normalizeLegacySession = (value) => {
+  if (!value || typeof value !== "object" || typeof value.threadId !== "string") {
+    return null;
+  }
+  const timestamp = nowIso();
+  const messages = Array.isArray(value.messages) ? value.messages.map((message) => {
+    if (!message || message.role !== "user" && message.role !== "assistant" || typeof message.content !== "string") {
+      return null;
+    }
+    return {
+      role: message.role,
+      content: message.content,
+      createdAt: typeof message.createdAt === "string" ? message.createdAt : timestamp
+    };
+  }).filter(
+    (message) => Boolean(message)
+  ) : [];
+  return {
+    threadId: value.threadId,
+    title: typeof value.title === "string" && value.title.trim() ? sanitizeTitle(value.title) : "Untitled CloudEval session",
+    projectId: optionalString(value.projectId),
+    projectName: optionalString(value.projectName),
+    model: optionalString(value.model),
+    profile: optionalString(value.profile),
+    createdAt: typeof value.createdAt === "string" ? value.createdAt : timestamp,
+    updatedAt: typeof value.updatedAt === "string" ? value.updatedAt : timestamp,
+    messageCount: messages.length,
+    messages
+  };
+};
+var readLegacySessions = async (profile) => {
+  try {
+    const dir = legacySessionsDir(profile);
+    const entries = await fs2.readdir(dir, { withFileTypes: true });
+    const sessions = await Promise.all(
+      entries.filter((entry) => entry.isFile() && entry.name.endsWith(".json")).map((entry) => readLegacySessionFile(path2.join(dir, entry.name)))
+    );
+    return sessions.filter((session) => Boolean(session));
+  } catch (error) {
+    if (error?.code === "ENOENT") {
+      return [];
+    }
+    throw error;
+  }
+};
+var migrateLegacyJsonSessions = async (db, profile) => {
+  const normalizedProfile = normalizeConfigProfile(profile);
+  const legacySessions = await readLegacySessions(normalizedProfile);
+  for (const session of legacySessions) {
+    if (getSessionFromDb(db, session.threadId)) {
+      continue;
+    }
+    upsertSession(db, {
+      ...session,
+      profile: session.profile ?? normalizedProfile,
+      messageCount: session.messages.length
+    });
+  }
+};
+var withSessionDatabase = async (profile, fn) => {
+  const normalizedProfile = normalizeConfigProfile(profile);
+  const db = await openSessionDatabase(normalizedProfile);
+  try {
+    ensureSchema(db);
+    await migrateLegacyJsonSessions(db, normalizedProfile);
+    const result = await fn(db, normalizedProfile);
+    await db.persist();
+    return result;
+  } finally {
+    db.close();
+  }
+};
+var recordSessionTurn = async ({
+  threadId,
+  question,
+  response,
+  project,
+  model,
+  profile
+}) => {
+  if (!threadId || !question.trim() && !response.trim()) {
+    return;
+  }
+  await withSessionDatabase(profile, (db, normalizedProfile) => {
+    const existing = getSessionFromDb(db, threadId);
+    const timestamp = nowIso();
+    const messages = [
+      ...existing?.messages ?? [],
+      ...question.trim() ? [{ role: "user", content: question.trim(), createdAt: timestamp }] : [],
+      ...response.trim() ? [{ role: "assistant", content: response.trim(), createdAt: timestamp }] : []
+    ];
+    upsertSession(db, {
+      threadId,
+      title: existing?.title ?? titleFromQuestion(question),
+      projectId: project?.id ?? existing?.projectId,
+      projectName: project?.name ?? existing?.projectName,
+      model: model ?? existing?.model,
+      profile: normalizedProfile,
+      createdAt: existing?.createdAt ?? timestamp,
+      updatedAt: timestamp,
+      messageCount: messages.length,
+      messages
+    });
+  });
+};
+var listSessions = async (limit = 20, profile) => withSessionDatabase(profile, (db) => {
+  const rows = db.rows(
+    `SELECT *
+       FROM sessions
+       ORDER BY updated_at DESC
+       LIMIT ?`,
+    [Math.max(1, limit)]
+  );
+  return rows.map((row) => sessionFromRow(db, row)).filter((session) => Boolean(session));
+});
+var listAllSessionsFromDb = (db) => {
+  const rows = db.rows(
+    `SELECT *
+     FROM sessions
+     ORDER BY updated_at DESC`
+  );
+  return rows.map((row) => sessionFromRow(db, row)).filter((session) => Boolean(session));
+};
+var getSession = async (threadId, profile) => withSessionDatabase(profile, (db) => getSessionFromDb(db, threadId));
+var renameSession = async (threadId, title, profile) => {
+  return withSessionDatabase(profile, (db) => {
+    const session = getSessionFromDb(db, threadId);
+    if (!session) {
+      return null;
+    }
+    const updated = {
+      ...session,
+      title: sanitizeTitle(title),
+      updatedAt: nowIso()
+    };
+    upsertSession(db, updated);
+    return updated;
+  });
+};
+var searchTerms = (query) => query.toLowerCase().split(/[^a-z0-9]+/i).map((term) => term.trim()).filter((term) => term.length > 1);
+var countTerm = (text, term) => {
+  if (!text || !term) return 0;
+  const escaped = term.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  return text.match(new RegExp(escaped, "gi"))?.length ?? 0;
+};
+var previewFor = (session, terms) => {
+  const matched = session.messages.map((message) => ({
+    message,
+    score: terms.reduce((total, term) => total + countTerm(message.content, term), 0)
+  })).filter((entry) => entry.score > 0).sort((a, b) => b.score - a.score)[0]?.message;
+  const value = matched?.content ?? session.messages.at(-1)?.content ?? session.title;
+  const singleLine = value.replace(/\s+/g, " ").trim();
+  return singleLine.length > 180 ? `${singleLine.slice(0, 177)}...` : singleLine;
+};
+var scoreSession = (session, terms) => {
+  const title = session.title.toLowerCase();
+  const project = `${session.projectId ?? ""} ${session.projectName ?? ""}`.toLowerCase();
+  const messages = session.messages.map((message) => message.content).join("\n").toLowerCase();
+  return terms.reduce(
+    (score, term) => score + countTerm(title, term) * 8 + countTerm(project, term) * 4 + countTerm(messages, term),
+    0
+  );
+};
+var toSearchResult = (session, score, terms) => ({
+  threadId: session.threadId,
+  title: session.title,
+  projectId: session.projectId,
+  projectName: session.projectName,
+  model: session.model,
+  profile: session.profile,
+  createdAt: session.createdAt,
+  updatedAt: session.updatedAt,
+  messageCount: session.messageCount,
+  score,
+  preview: previewFor(session, terms)
+});
+var searchSessions = async (query, options = {}) => {
+  const terms = searchTerms(query);
+  const limit = Math.max(1, options.limit ?? 20);
+  return withSessionDatabase(options.profile, (db) => {
+    const sessions = listAllSessionsFromDb(db);
+    if (!terms.length) {
+      return sessions.slice(0, limit).map((session) => toSearchResult(session, 0, []));
+    }
+    const ftsMatches = searchSessionsWithFts(db, terms, limit * 4);
+    const candidates = ftsMatches?.length ? ftsMatches : sessions;
+    return candidates.map((session) => ({
+      session,
+      score: scoreSession(session, terms)
+    })).filter((entry) => entry.score > 0).sort((a, b) => b.score - a.score || b.session.updatedAt.localeCompare(a.session.updatedAt)).slice(0, limit).map((entry) => toSearchResult(entry.session, entry.score, terms));
+  });
+};
+var ftsQueryForTerms = (terms) => terms.map((term) => term.replace(/"/g, "")).filter(Boolean).map((term) => `${term}*`).join(" OR ");
+var rebuildFtsIndex = (db) => {
+  if (!ensureFtsSchema(db)) {
+    return;
+  }
+  try {
+    const sessionCount = Number(db.rows("SELECT COUNT(*) AS count FROM sessions")[0]?.count ?? 0);
+    const ftsCount = Number(db.rows("SELECT COUNT(*) AS count FROM session_messages_fts")[0]?.count ?? 0);
+    if (ftsCount >= sessionCount) {
+      return;
+    }
+    db.run("DELETE FROM session_messages_fts");
+    for (const session of listAllSessionsFromDb(db)) {
+      upsertSessionFts(db, session);
+    }
+  } catch {
+  }
+};
+var searchSessionsWithFts = (db, terms, limit) => {
+  if (!ensureFtsSchema(db)) {
+    return null;
+  }
+  const query = ftsQueryForTerms(terms);
+  if (!query) {
+    return null;
+  }
+  try {
+    rebuildFtsIndex(db);
+    const rows = db.rows(
+      `SELECT sessions.*
+       FROM session_messages_fts
+       JOIN sessions ON sessions.thread_id = session_messages_fts.thread_id
+       WHERE session_messages_fts MATCH ?
+       ORDER BY bm25(session_messages_fts) ASC, sessions.updated_at DESC
+       LIMIT ?`,
+      [query, limit]
+    );
+    return rows.map((row) => sessionFromRow(db, row)).filter((session) => Boolean(session));
+  } catch {
+    return null;
+  }
+};
+var resolveSessionReference = async (reference, profile) => {
+  const trimmed = reference.trim();
+  if (!trimmed) {
+    return null;
+  }
+  const exact = await getSession(trimmed, profile);
+  if (exact) {
+    return exact;
+  }
+  const sessions = await exportSessions(profile);
+  const lower = trimmed.toLowerCase();
+  return sessions.find((session) => session.title.toLowerCase() === lower) ?? sessions.find((session) => session.threadId.startsWith(trimmed)) ?? sessions.find((session) => session.title.toLowerCase().includes(lower)) ?? null;
+};
+var deleteSession = async (threadId, profile) => {
+  const deleted = await withSessionDatabase(profile, (db) => {
+    const existing = getSessionFromDb(db, threadId);
+    if (!existing) {
+      return false;
+    }
+    deleteSessionFts(db, threadId);
+    db.run("DELETE FROM sessions WHERE thread_id = ?", [threadId]);
+    return true;
+  });
+  try {
+    await fs2.unlink(legacySessionPath(threadId, profile));
+  } catch (error) {
+    if (error?.code !== "ENOENT") {
+      throw error;
+    }
+  }
+  return deleted;
+};
+var exportSessions = async (profile) => listSessions(Number.MAX_SAFE_INTEGER, profile);
+var pruneSessions = async (olderThanDays, profile) => {
+  const cutoff = Date.now() - Math.max(1, olderThanDays) * 24 * 60 * 60 * 1e3;
+  const sessions = await exportSessions(profile);
+  let deleted = 0;
+  for (const session of sessions) {
+    const updatedAt = Date.parse(session.updatedAt);
+    if (Number.isFinite(updatedAt) && updatedAt < cutoff) {
+      if (await deleteSession(session.threadId, profile)) {
+        deleted++;
+      }
+    }
+  }
+  return deleted;
+};
+
+export {
+  resolveFrontendBaseUrl,
+  buildFrontendUrl,
+  openExternalUrl,
+  normalizeConfigProfile,
+  getActiveConfigProfile,
+  getCloudevalConfigDir,
+  getCliConfigPath,
+  loadCliConfig,
+  saveCliConfig,
+  listCliConfigProfiles,
+  normalizeCliMode,
+  readCliConfigValue,
+  writeCliConfigValue,
+  unsetCliConfigValue,
+  getFirstNameForDisplay,
+  recordSessionTurn,
+  listSessions,
+  getSession,
+  renameSession,
+  searchSessions,
+  resolveSessionReference,
+  deleteSession,
+  exportSessions,
+  pruneSessions
+};