theus-cli-linux-arm64 0.2.84

package/vendor/theus-arsenal/scripts/lib/session-manager.d.ts

@@ -0,0 +1,137 @@
+/**
+ * Biblioteca de gestión de sesiones para Theus.
+ * Provee operaciones CRUD para archivos de sesión guardados como markdown en
+ * `<data home>/session-data/` (por defecto ~/.theus/arsenal/session-data/) con
+ * compatibilidad de lectura para el directorio heredado `<data home>/sessions/`.
+ */
+
+/** Metadatos parseados del nombre de archivo de una sesión */
+export interface SessionFilenameMeta {
+  /** Nombre de archivo original */
+  filename: string;
+  /** ID corto extraído del nombre de archivo, o "no-id" para el formato antiguo */
+  shortId: string;
+  /** Cadena de fecha en formato YYYY-MM-DD */
+  date: string;
+  /** Objeto Date parseado a partir de la cadena de fecha */
+  datetime: Date;
+}
+
+/** Metadatos parseados del contenido markdown de la sesión */
+export interface SessionMetadata {
+  title: string | null;
+  date: string | null;
+  started: string | null;
+  lastUpdated: string | null;
+  project: string | null;
+  branch: string | null;
+  worktree: string | null;
+  completed: string[];
+  inProgress: string[];
+  notes: string;
+  context: string;
+}
+
+/** Estadísticas calculadas a partir del contenido de la sesión */
+export interface SessionStats {
+  totalItems: number;
+  completedItems: number;
+  inProgressItems: number;
+  lineCount: number;
+  hasNotes: boolean;
+  hasContext: boolean;
+}
+
+/** Objeto de sesión devuelto por getAllSessions y getSessionById */
+export interface Session extends SessionFilenameMeta {
+  /** Ruta completa en el sistema de archivos del archivo de sesión */
+  sessionPath: string;
+  /** Si el archivo tiene algún contenido */
+  hasContent?: boolean;
+  /** Tamaño del archivo en bytes */
+  size: number;
+  /** Fecha de última modificación */
+  modifiedTime: Date;
+  /** Fecha de creación del archivo (cae a ctime en Linux) */
+  createdTime: Date;
+  /** Contenido markdown de la sesión (solo cuando includeContent=true) */
+  content?: string | null;
+  /** Metadatos parseados (solo cuando includeContent=true) */
+  metadata?: SessionMetadata;
+  /** Estadísticas de la sesión (solo cuando includeContent=true) */
+  stats?: SessionStats;
+}
+
+/** Resultado paginado de getAllSessions */
+export interface SessionListResult {
+  sessions: Session[];
+  total: number;
+  offset: number;
+  limit: number;
+  hasMore: boolean;
+}
+
+export interface GetAllSessionsOptions {
+  /** Número máximo de sesiones a devolver (por defecto: 50) */
+  limit?: number;
+  /** Número de sesiones a saltar (por defecto: 0) */
+  offset?: number;
+  /** Filtrar por fecha en formato YYYY-MM-DD */
+  date?: string | null;
+  /** Buscar en el ID corto */
+  search?: string | null;
+}
+
+/**
+ * Parsea el nombre de archivo de una sesión para extraer la fecha y el ID corto.
+ * @returns Metadatos parseados, o null si el nombre no coincide con el patrón esperado
+ */
+export function parseSessionFilename(filename: string): SessionFilenameMeta | null;
+
+/** Obtiene la ruta completa en el sistema de archivos para un nombre de archivo de sesión */
+export function getSessionPath(filename: string): string;
+
+/**
+ * Lee el contenido markdown de la sesión desde disco.
+ * @returns Cadena de contenido, o null si el archivo no existe
+ */
+export function getSessionContent(sessionPath: string): string | null;
+
+/** Parsea los metadatos de la sesión a partir del contenido markdown */
+export function parseSessionMetadata(content: string | null): SessionMetadata;
+
+/**
+ * Calcula estadísticas de una sesión.
+ * Acepta una ruta de archivo (absoluta, terminada en .tmp) o una cadena de
+ * contenido pre-leída. Admite rutas Unix (/ruta/a/session.tmp) y Windows
+ * (C:\ruta\a\session.tmp).
+ */
+export function getSessionStats(sessionPathOrContent: string): SessionStats;
+
+/** Obtiene el título de un archivo de sesión, o "Sesión sin título" si no tiene */
+export function getSessionTitle(sessionPath: string): string;
+
+/** Obtiene el tamaño del archivo en formato legible (p. ej. "1.2 KB") */
+export function getSessionSize(sessionPath: string): string;
+
+/** Obtiene todas las sesiones con filtrado y paginación opcionales */
+export function getAllSessions(options?: GetAllSessionsOptions): SessionListResult;
+
+/**
+ * Busca una sesión por ID corto o nombre de archivo.
+ * @param sessionId - Prefijo del ID corto, nombre de archivo completo o nombre sin .tmp
+ * @param includeContent - Si se debe leer y parsear el contenido de la sesión
+ */
+export function getSessionById(sessionId: string, includeContent?: boolean): Session | null;
+
+/** Escribe contenido markdown en un archivo de sesión */
+export function writeSessionContent(sessionPath: string, content: string): boolean;
+
+/** Anexa contenido a un archivo de sesión existente */
+export function appendSessionContent(sessionPath: string, content: string): boolean;
+
+/** Elimina un archivo de sesión */
+export function deleteSession(sessionPath: string): boolean;
+
+/** Verifica si un archivo de sesión existe y es un archivo regular */
+export function sessionExists(sessionPath: string): boolean;

package/vendor/theus-arsenal/scripts/lib/session-manager.js

@@ -0,0 +1,555 @@
+/**
+ * Biblioteca de gestión de sesiones para Theus
+ * Provee las operaciones CRUD centrales para listar, cargar y administrar sesiones.
+ *
+ * Las sesiones se guardan como archivos markdown en `<data home>/session-data/`
+ * (por defecto `~/.theus/arsenal/session-data/`; THEUS_AGENT_DATA_HOME la
+ * el motor lo define), con compatibilidad de lectura para el directorio
+ * heredado `<data home>/sessions/`:
+ * - YYYY-MM-DD-session.tmp (formato antiguo)
+ * - YYYY-MM-DD-<id-corto>-session.tmp (formato nuevo)
+ *
+ * Nota: estas sesiones son los resúmenes markdown del arsenal (guardar/reanudar
+ * sesión), no las transcripciones nativas de Theus, que viven en
+ * `~/.theus/projects/<dir-escapado>/<session_id>.jsonl`.
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const {
+  getSessionsDir,
+  getSessionSearchDirs,
+  readFile,
+  log
+} = require('./utils');
+
+// Patrón del nombre de archivo de sesión: YYYY-MM-DD-[id-de-sesion]-session.tmp
+// El id de sesión es opcional (formato antiguo) y puede incluir letras, dígitos,
+// guiones bajos y guiones, pero no puede empezar con guion.
+// Coincide con: "2026-02-01-session.tmp", "2026-02-01-a1b2c3d4-session.tmp",
+// "2026-02-01-frontend-worktree-1-session.tmp" y
+// "2026-02-01-ChezMoi_2-session.tmp"
+const SESSION_FILENAME_REGEX = /^(\d{4}-\d{2}-\d{2})(?:-([a-zA-Z0-9_][a-zA-Z0-9_-]*))?-session\.tmp$/;
+
+/**
+ * Resuelve la fecha de creación de un archivo, prefiriendo birthtime pero
+ * cayendo a ctime cuando birthtime no está disponible. Algunos sistemas de
+ * archivos (p. ej. overlayfs en contenedores) reportan birthtime como epoch 0;
+ * un objeto Date siempre es truthy, así que `birthtime || ctime` nunca haría
+ * el fallback. Se compara en milisegundos en su lugar.
+ * @param {import('fs').Stats} stats
+ * @returns {Date}
+ */
+function resolveCreatedTime(stats) {
+  return stats.birthtimeMs > 0 ? stats.birthtime : stats.ctime;
+}
+
+/**
+ * Parsea el nombre de archivo de una sesión para extraer sus metadatos
+ * @param {string} filename - Nombre de archivo de sesión (p. ej. "2026-01-17-abc123-session.tmp" o "2026-01-17-session.tmp")
+ * @returns {object|null} Metadatos parseados o null si es inválido
+ */
+function parseSessionFilename(filename) {
+  if (!filename || typeof filename !== 'string') return null;
+  const match = filename.match(SESSION_FILENAME_REGEX);
+  if (!match) return null;
+
+  const dateStr = match[1];
+
+  // Validar que los componentes de la fecha sean válidos en el calendario (no solo el formato)
+  const [year, month, day] = dateStr.split('-').map(Number);
+  if (month < 1 || month > 12 || day < 1 || day > 31) return null;
+  // Rechazar fechas imposibles como 31 de febrero o 31 de abril — el constructor
+  // de Date desborda los días inválidos (p. ej. 31 feb → 3 mar), así que se
+  // verifica que el mes haga el viaje de ida y vuelta
+  const d = new Date(year, month - 1, day);
+  if (d.getMonth() !== month - 1 || d.getDate() !== day) return null;
+
+  // match[2] es undefined para el formato antiguo (sin ID)
+  const shortId = match[2] || 'no-id';
+
+  return {
+    filename,
+    shortId,
+    date: dateStr,
+    // Usar el constructor en hora local (consistente con la validación anterior)
+    // new Date(dateStr) interpreta YYYY-MM-DD como medianoche UTC, que se
+    // muestra como el día anterior en zonas horarias con desfase UTC negativo
+    datetime: new Date(year, month - 1, day)
+  };
+}
+
+/**
+ * Obtiene la ruta completa a un archivo de sesión
+ * @param {string} filename - Nombre de archivo de sesión
+ * @returns {string} Ruta completa al archivo de sesión
+ */
+function getSessionPath(filename) {
+  return path.join(getSessionsDir(), filename);
+}
+
+function getSessionCandidates(options = {}) {
+  const {
+    date = null,
+    search = null
+  } = options;
+
+  const candidates = [];
+
+  for (const sessionsDir of getSessionSearchDirs()) {
+    if (!fs.existsSync(sessionsDir)) {
+      continue;
+    }
+
+    let entries;
+    try {
+      entries = fs.readdirSync(sessionsDir, { withFileTypes: true });
+    } catch (error) {
+      log(`[SessionManager] Error al leer el directorio de sesiones ${sessionsDir}: ${error.message}`);
+      continue;
+    }
+
+    for (const entry of entries) {
+      if (!entry.isFile() || !entry.name.endsWith('.tmp')) continue;
+
+      const filename = entry.name;
+      const metadata = parseSessionFilename(filename);
+
+      if (!metadata) continue;
+      if (date && metadata.date !== date) continue;
+      if (search && !metadata.shortId.includes(search)) continue;
+
+      const sessionPath = path.join(sessionsDir, filename);
+
+      let stats;
+      try {
+        stats = fs.statSync(sessionPath);
+      } catch (error) {
+        log(`[SessionManager] Error al consultar la sesión ${sessionPath}: ${error.message}`);
+        continue;
+      }
+
+      candidates.push({
+        ...metadata,
+        sessionPath,
+        hasContent: stats.size > 0,
+        size: stats.size,
+        modifiedTime: stats.mtime,
+        createdTime: resolveCreatedTime(stats)
+      });
+    }
+  }
+
+  const deduped = [];
+  const seenFilenames = new Set();
+
+  for (const session of candidates) {
+    if (seenFilenames.has(session.filename)) {
+      continue;
+    }
+    seenFilenames.add(session.filename);
+    deduped.push(session);
+  }
+
+  deduped.sort((a, b) => b.modifiedTime - a.modifiedTime);
+  return deduped;
+}
+
+function buildSessionRecord(sessionPath, metadata) {
+  let stats;
+  try {
+    stats = fs.statSync(sessionPath);
+  } catch (error) {
+    log(`[SessionManager] Error al consultar la sesión ${sessionPath}: ${error.message}`);
+    return null;
+  }
+
+  return {
+    ...metadata,
+    sessionPath,
+    hasContent: stats.size > 0,
+    size: stats.size,
+    modifiedTime: stats.mtime,
+    createdTime: resolveCreatedTime(stats)
+  };
+}
+
+function sessionMatchesId(metadata, normalizedSessionId) {
+  const filename = metadata.filename;
+  const shortIdMatch = metadata.shortId !== 'no-id' && metadata.shortId.startsWith(normalizedSessionId);
+  const filenameMatch = filename === normalizedSessionId || filename === `${normalizedSessionId}.tmp`;
+  const noIdMatch = metadata.shortId === 'no-id' && filename === `${normalizedSessionId}-session.tmp`;
+
+  return shortIdMatch || filenameMatch || noIdMatch;
+}
+
+function getMatchingSessionCandidates(normalizedSessionId) {
+  const matches = [];
+  const seenFilenames = new Set();
+
+  for (const sessionsDir of getSessionSearchDirs()) {
+    if (!fs.existsSync(sessionsDir)) {
+      continue;
+    }
+
+    let entries;
+    try {
+      entries = fs.readdirSync(sessionsDir, { withFileTypes: true });
+    } catch (error) {
+      log(`[SessionManager] Error al leer el directorio de sesiones ${sessionsDir}: ${error.message}`);
+      continue;
+    }
+
+    for (const entry of entries) {
+      if (!entry.isFile() || !entry.name.endsWith('.tmp')) continue;
+
+      const metadata = parseSessionFilename(entry.name);
+      if (!metadata || !sessionMatchesId(metadata, normalizedSessionId)) {
+        continue;
+      }
+
+      if (seenFilenames.has(metadata.filename)) {
+        continue;
+      }
+
+      const sessionPath = path.join(sessionsDir, metadata.filename);
+      const sessionRecord = buildSessionRecord(sessionPath, metadata);
+      if (!sessionRecord) {
+        continue;
+      }
+
+      seenFilenames.add(metadata.filename);
+      matches.push(sessionRecord);
+    }
+  }
+
+  matches.sort((a, b) => b.modifiedTime - a.modifiedTime);
+  return matches;
+}
+
+/**
+ * Lee y parsea el contenido markdown de una sesión
+ * @param {string} sessionPath - Ruta completa al archivo de sesión
+ * @returns {string|null} Contenido de la sesión o null si no se encuentra
+ */
+function getSessionContent(sessionPath) {
+  return readFile(sessionPath);
+}
+
+/**
+ * Parsea los metadatos de una sesión a partir de su contenido markdown.
+ * Los marcadores se aceptan tanto en español como en inglés para mantener
+ * compatibilidad con sesiones guardadas en cualquiera de los dos idiomas.
+ * @param {string} content - Contenido markdown de la sesión
+ * @returns {object} Metadatos parseados
+ */
+function parseSessionMetadata(content) {
+  const metadata = {
+    title: null,
+    date: null,
+    started: null,
+    lastUpdated: null,
+    project: null,
+    branch: null,
+    worktree: null,
+    completed: [],
+    inProgress: [],
+    notes: '',
+    context: ''
+  };
+
+  if (!content) return metadata;
+
+  // Extraer el título del primer encabezado
+  const titleMatch = content.match(/^#\s+(.+)$/m);
+  if (titleMatch) {
+    metadata.title = titleMatch[1].trim();
+  }
+
+  // Extraer la fecha
+  const dateMatch = content.match(/\*\*(?:Fecha|Date):\*\*\s*(\d{4}-\d{2}-\d{2})/);
+  if (dateMatch) {
+    metadata.date = dateMatch[1];
+  }
+
+  // Extraer la hora de inicio
+  const startedMatch = content.match(/\*\*(?:Inicio|Started):\*\*\s*([\d:]+)/);
+  if (startedMatch) {
+    metadata.started = startedMatch[1];
+  }
+
+  // Extraer la última actualización
+  const updatedMatch = content.match(/\*\*(?:Última actualización|Last Updated):\*\*\s*([\d:]+)/);
+  if (updatedMatch) {
+    metadata.lastUpdated = updatedMatch[1];
+  }
+
+  // Extraer metadatos del panel de control
+  const projectMatch = content.match(/\*\*(?:Proyecto|Project):\*\*\s*(.+)$/m);
+  if (projectMatch) {
+    metadata.project = projectMatch[1].trim();
+  }
+
+  const branchMatch = content.match(/\*\*(?:Rama|Branch):\*\*\s*(.+)$/m);
+  if (branchMatch) {
+    metadata.branch = branchMatch[1].trim();
+  }
+
+  const worktreeMatch = content.match(/\*\*Worktree:\*\*\s*(.+)$/m);
+  if (worktreeMatch) {
+    metadata.worktree = worktreeMatch[1].trim();
+  }
+
+  // Extraer los ítems completados
+  const completedSection = content.match(/### (?:Completado|Completed)\s*\n([\s\S]*?)(?=###|\n\n|$)/);
+  if (completedSection) {
+    const items = completedSection[1].match(/- \[x\]\s*(.+)/g);
+    if (items) {
+      metadata.completed = items.map(item => item.replace(/- \[x\]\s*/, '').trim());
+    }
+  }
+
+  // Extraer los ítems en progreso
+  const progressSection = content.match(/### (?:En progreso|In Progress)\s*\n([\s\S]*?)(?=###|\n\n|$)/);
+  if (progressSection) {
+    const items = progressSection[1].match(/- \[ \]\s*(.+)/g);
+    if (items) {
+      metadata.inProgress = items.map(item => item.replace(/- \[ \]\s*/, '').trim());
+    }
+  }
+
+  // Extraer las notas
+  const notesSection = content.match(/### (?:Notas para la próxima sesión|Notes for Next Session)\s*\n([\s\S]*?)(?=###|\n\n|$)/);
+  if (notesSection) {
+    metadata.notes = notesSection[1].trim();
+  }
+
+  // Extraer el contexto a cargar
+  const contextSection = content.match(/### (?:Contexto a cargar|Context to Load)\s*\n```\n([\s\S]*?)```/);
+  if (contextSection) {
+    metadata.context = contextSection[1].trim();
+  }
+
+  return metadata;
+}
+
+/**
+ * Calcula estadísticas de una sesión
+ * @param {string} sessionPathOrContent - Ruta completa al archivo de sesión, O
+ *   la cadena de contenido ya leída (para evitar lecturas de disco redundantes
+ *   cuando el llamador ya tiene el contenido cargado).
+ * @returns {object} Objeto de estadísticas
+ */
+function getSessionStats(sessionPathOrContent) {
+  // Acepta una cadena de contenido pre-leída para evitar lecturas redundantes.
+  // Si el argumento parece una ruta de archivo (sin saltos de línea, termina
+  // en .tmp, empieza con / en Unix o con letra de unidad en Windows), se lee
+  // del disco. En caso contrario se trata como contenido.
+  const looksLikePath = typeof sessionPathOrContent === 'string' &&
+    !sessionPathOrContent.includes('\n') &&
+    sessionPathOrContent.endsWith('.tmp') &&
+    (sessionPathOrContent.startsWith('/') || /^[A-Za-z]:[/\\]/.test(sessionPathOrContent));
+  const content = looksLikePath
+    ? getSessionContent(sessionPathOrContent)
+    : sessionPathOrContent;
+
+  const metadata = parseSessionMetadata(content);
+
+  return {
+    totalItems: metadata.completed.length + metadata.inProgress.length,
+    completedItems: metadata.completed.length,
+    inProgressItems: metadata.inProgress.length,
+    lineCount: content ? content.split('\n').length : 0,
+    hasNotes: !!metadata.notes,
+    hasContext: !!metadata.context
+  };
+}
+
+/**
+ * Obtiene todas las sesiones con filtrado y paginación opcionales
+ * @param {object} options - Objeto de opciones
+ * @param {number} options.limit - Número máximo de sesiones a devolver
+ * @param {number} options.offset - Número de sesiones a saltar
+ * @param {string} options.date - Filtrar por fecha (formato YYYY-MM-DD)
+ * @param {string} options.search - Buscar en el ID corto
+ * @returns {object} Objeto con el arreglo de sesiones e información de paginación
+ */
+function getAllSessions(options = {}) {
+  const {
+    limit: rawLimit = 50,
+    offset: rawOffset = 0,
+    date = null,
+    search = null
+  } = options;
+
+  // Acotar offset y limit a enteros no negativos seguros.
+  // Sin esto, un offset negativo hace que slice() cuente desde el final,
+  // y los valores NaN hacen que slice() devuelva vacío o resultados inesperados.
+  // Nota: no se puede usar `|| valorPorDefecto` porque 0 es falsy — usar isNaN.
+  const offsetNum = Number(rawOffset);
+  const offset = Number.isNaN(offsetNum) ? 0 : Math.max(0, Math.floor(offsetNum));
+  const limitNum = Number(rawLimit);
+  const limit = Number.isNaN(limitNum) ? 50 : Math.max(1, Math.floor(limitNum));
+
+  const sessions = getSessionCandidates({ date, search });
+
+  if (sessions.length === 0) {
+    return { sessions: [], total: 0, offset, limit, hasMore: false };
+  }
+
+  // Aplicar paginación
+  const paginatedSessions = sessions.slice(offset, offset + limit);
+
+  return {
+    sessions: paginatedSessions,
+    total: sessions.length,
+    offset,
+    limit,
+    hasMore: offset + limit < sessions.length
+  };
+}
+
+/**
+ * Obtiene una sesión individual por ID (ID corto o ruta completa)
+ * @param {string} sessionId - ID corto o nombre de archivo de la sesión
+ * @param {boolean} includeContent - Incluir el contenido de la sesión
+ * @returns {object|null} Objeto de sesión o null si no se encuentra
+ */
+function getSessionById(sessionId, includeContent = false) {
+  if (typeof sessionId !== 'string') {
+    return null;
+  }
+
+  const normalizedSessionId = sessionId.trim();
+  if (!normalizedSessionId) {
+    return null;
+  }
+
+  const sessions = getMatchingSessionCandidates(normalizedSessionId);
+
+  for (const session of sessions) {
+    const sessionRecord = { ...session };
+
+    if (includeContent) {
+      sessionRecord.content = getSessionContent(sessionRecord.sessionPath);
+      sessionRecord.metadata = parseSessionMetadata(sessionRecord.content);
+      // Pasar el contenido pre-leído para evitar una lectura de disco redundante
+      sessionRecord.stats = getSessionStats(sessionRecord.content || '');
+    }
+
+    return sessionRecord;
+  }
+
+  return null;
+}
+
+/**
+ * Obtiene el título de la sesión a partir de su contenido
+ * @param {string} sessionPath - Ruta completa al archivo de sesión
+ * @returns {string} Título o texto por defecto
+ */
+function getSessionTitle(sessionPath) {
+  const content = getSessionContent(sessionPath);
+  const metadata = parseSessionMetadata(content);
+
+  return metadata.title || 'Sesión sin título';
+}
+
+/**
+ * Formatea el tamaño de la sesión en un formato legible
+ * @param {string} sessionPath - Ruta completa al archivo de sesión
+ * @returns {string} Tamaño formateado (p. ej. "1.2 KB")
+ */
+function getSessionSize(sessionPath) {
+  let stats;
+  try {
+    stats = fs.statSync(sessionPath);
+  } catch {
+    return '0 B';
+  }
+  const size = stats.size;
+
+  if (size < 1024) return `${size} B`;
+  if (size < 1024 * 1024) return `${(size / 1024).toFixed(1)} KB`;
+  return `${(size / (1024 * 1024)).toFixed(1)} MB`;
+}
+
+/**
+ * Escribe el contenido de una sesión en un archivo
+ * @param {string} sessionPath - Ruta completa al archivo de sesión
+ * @param {string} content - Contenido markdown a escribir
+ * @returns {boolean} Estado de éxito
+ */
+function writeSessionContent(sessionPath, content) {
+  try {
+    fs.writeFileSync(sessionPath, content, 'utf8');
+    return true;
+  } catch (err) {
+    log(`[SessionManager] Error al escribir la sesión: ${err.message}`);
+    return false;
+  }
+}
+
+/**
+ * Anexa contenido a una sesión
+ * @param {string} sessionPath - Ruta completa al archivo de sesión
+ * @param {string} content - Contenido a anexar
+ * @returns {boolean} Estado de éxito
+ */
+function appendSessionContent(sessionPath, content) {
+  try {
+    fs.appendFileSync(sessionPath, content, 'utf8');
+    return true;
+  } catch (err) {
+    log(`[SessionManager] Error al anexar a la sesión: ${err.message}`);
+    return false;
+  }
+}
+
+/**
+ * Elimina un archivo de sesión
+ * @param {string} sessionPath - Ruta completa al archivo de sesión
+ * @returns {boolean} Estado de éxito
+ */
+function deleteSession(sessionPath) {
+  try {
+    if (fs.existsSync(sessionPath)) {
+      fs.unlinkSync(sessionPath);
+      return true;
+    }
+    return false;
+  } catch (err) {
+    log(`[SessionManager] Error al eliminar la sesión: ${err.message}`);
+    return false;
+  }
+}
+
+/**
+ * Verifica si una sesión existe
+ * @param {string} sessionPath - Ruta completa al archivo de sesión
+ * @returns {boolean} true si la sesión existe
+ */
+function sessionExists(sessionPath) {
+  try {
+    return fs.statSync(sessionPath).isFile();
+  } catch {
+    return false;
+  }
+}
+
+module.exports = {
+  parseSessionFilename,
+  getSessionPath,
+  getSessionContent,
+  parseSessionMetadata,
+  getSessionStats,
+  getSessionTitle,
+  getSessionSize,
+  getAllSessions,
+  getSessionById,
+  writeSessionContent,
+  appendSessionContent,
+  deleteSession,
+  sessionExists
+};