centaurus-cli 3.0.1 → 3.1.0

package/dist/services/local-chat-storage.js

@@ -1,392 +1,369 @@
-/**
- * Local Chat Storage Service
- *
- * Provides persistent local storage for CLI conversations.
- * Stores chats in ~/.centaurus/chats/ directory as JSON files.
- */
-import * as fs from 'fs';
-import * as path from 'path';
-import * as os from 'os';
-import { logError } from '../utils/logger.js';
-/**
- * LocalChatStorage class for managing local conversation persistence
- */
-export class LocalChatStorage {
-    chatsDir;
-    indexPath;
-    chatIndex = new Map();
-    indexLoaded = false;
-    constructor() {
-        const homeDir = os.homedir();
-        this.chatsDir = path.join(homeDir, '.centaurus', 'chats');
-        this.indexPath = path.join(this.chatsDir, 'index.json');
-        // Ensure chats directory exists
-        if (!fs.existsSync(this.chatsDir)) {
-            fs.mkdirSync(this.chatsDir, { recursive: true });
-        }
-        // Load or build the index
-        this.loadIndex();
-    }
-    /**
-     * Load the metadata index from disk, or rebuild it from chat files if missing
-     */
-    loadIndex() {
-        if (this.indexLoaded)
-            return;
-        try {
-            if (fs.existsSync(this.indexPath)) {
-                const data = fs.readFileSync(this.indexPath, 'utf-8');
-                const indexArray = JSON.parse(data);
-                this.chatIndex.clear();
-                for (const meta of indexArray) {
-                    this.chatIndex.set(meta.id, meta);
-                }
-                this.indexLoaded = true;
-                return;
-            }
-        }
-        catch (error) {
-            // Index file corrupted, rebuild it
-        }
-        // Rebuild index from chat files (one-time migration)
-        this.rebuildIndex();
+import * as fs from "fs";
+import * as path from "path";
+import * as os from "os";
+import { logError } from "../utils/logger.js";
+class LocalChatStorage {
+  chatsDir;
+  indexPath;
+  chatIndex = /* @__PURE__ */ new Map();
+  indexLoaded = false;
+  constructor() {
+    const homeDir = os.homedir();
+    this.chatsDir = path.join(homeDir, ".centaurus", "chats");
+    this.indexPath = path.join(this.chatsDir, "index.json");
+    if (!fs.existsSync(this.chatsDir)) {
+      fs.mkdirSync(this.chatsDir, { recursive: true });
     }
-    /**
-     * Rebuild the index by reading metadata from all chat files
-     * This is a one-time migration that reads full files, but only happens once
-     */
-    rebuildIndex() {
+    this.loadIndex();
+  }
+  /**
+   * Load the metadata index from disk, or rebuild it from chat files if missing
+   */
+  loadIndex() {
+    if (this.indexLoaded) return;
+    try {
+      if (fs.existsSync(this.indexPath)) {
+        const data = fs.readFileSync(this.indexPath, "utf-8");
+        const indexArray = JSON.parse(data);
         this.chatIndex.clear();
-        if (!fs.existsSync(this.chatsDir)) {
-            this.indexLoaded = true;
-            return;
-        }
-        const files = fs.readdirSync(this.chatsDir)
-            .filter(f => f.endsWith('.json') && f !== 'index.json');
-        for (const file of files) {
-            try {
-                const filePath = path.join(this.chatsDir, file);
-                const data = fs.readFileSync(filePath, 'utf-8');
-                const chat = JSON.parse(data);
-                // Determine environment string from remoteContext
-                let environment = 'local';
-                if (chat.remoteContext) {
-                    const rc = chat.remoteContext;
-                    if (rc.type === 'ssh' && rc.metadata?.hostname) {
-                        environment = `ssh:${rc.metadata.username || 'user'}@${rc.metadata.hostname}`;
-                    }
-                    else if (rc.type === 'wsl') {
-                        environment = `wsl:${rc.metadata?.distroName || 'Ubuntu'}`;
-                    }
-                    else if (rc.type === 'docker' && rc.metadata?.containerId) {
-                        environment = `docker:${rc.metadata.containerId.substring(0, 12)}`;
-                    }
-                    else {
-                        environment = rc.type;
-                    }
-                }
-                // Store metadata only
-                this.chatIndex.set(chat.id, {
-                    id: chat.id,
-                    title: chat.title,
-                    createdAt: chat.createdAt,
-                    updatedAt: chat.updatedAt,
-                    messageCount: chat.messageCount,
-                    environment,
-                });
-            }
-            catch (error) {
-                // Skip invalid files
-                continue;
-            }
+        for (const meta of indexArray) {
+          this.chatIndex.set(meta.id, meta);
         }
         this.indexLoaded = true;
-        this.saveIndex();
+        return;
+      }
+    } catch (error) {
     }
-    /**
-     * Save the metadata index to disk
-     */
-    saveIndex() {
-        try {
-            const indexArray = Array.from(this.chatIndex.values());
-            fs.writeFileSync(this.indexPath, JSON.stringify(indexArray, null, 2), 'utf-8');
-        }
-        catch (error) {
-            logError('Failed to save chat index', error);
-        }
+    this.rebuildIndex();
+  }
+  /**
+   * Rebuild the index by reading metadata from all chat files
+   * This is a one-time migration that reads full files, but only happens once
+   */
+  rebuildIndex() {
+    this.chatIndex.clear();
+    if (!fs.existsSync(this.chatsDir)) {
+      this.indexLoaded = true;
+      return;
     }
-    /**
-     * Update the index entry for a chat
-     */
-    updateIndexEntry(chat) {
-        let environment = 'local';
+    const files = fs.readdirSync(this.chatsDir).filter((f) => f.endsWith(".json") && f !== "index.json");
+    for (const file of files) {
+      try {
+        const filePath = path.join(this.chatsDir, file);
+        const data = fs.readFileSync(filePath, "utf-8");
+        const chat = JSON.parse(data);
+        let environment = "local";
         if (chat.remoteContext) {
-            const rc = chat.remoteContext;
-            if (rc.type === 'ssh' && rc.metadata?.hostname) {
-                environment = `ssh:${rc.metadata.username || 'user'}@${rc.metadata.hostname}`;
-            }
-            else if (rc.type === 'wsl') {
-                environment = `wsl:${rc.metadata?.distroName || 'Ubuntu'}`;
-            }
-            else if (rc.type === 'docker' && rc.metadata?.containerId) {
-                environment = `docker:${rc.metadata.containerId.substring(0, 12)}`;
-            }
-            else {
-                environment = rc.type;
-            }
+          const rc = chat.remoteContext;
+          if (rc.type === "ssh" && rc.metadata?.hostname) {
+            environment = `ssh:${rc.metadata.username || "user"}@${rc.metadata.hostname}`;
+          } else if (rc.type === "wsl") {
+            environment = `wsl:${rc.metadata?.distroName || "Ubuntu"}`;
+          } else if (rc.type === "docker" && rc.metadata?.containerId) {
+            environment = `docker:${rc.metadata.containerId.substring(0, 12)}`;
+          } else {
+            environment = rc.type;
+          }
         }
         this.chatIndex.set(chat.id, {
-            id: chat.id,
-            title: chat.title,
-            createdAt: chat.createdAt,
-            updatedAt: chat.updatedAt,
-            messageCount: chat.messageCount,
-            environment,
+          id: chat.id,
+          title: chat.title,
+          createdAt: chat.createdAt,
+          updatedAt: chat.updatedAt,
+          messageCount: chat.messageCount,
+          environment
         });
-        this.saveIndex();
+      } catch (error) {
+        continue;
+      }
     }
-    /**
-     * Generate a unique chat ID based on timestamp
-     */
-    generateChatId() {
-        const now = new Date();
-        const timestamp = now.toISOString().replace(/[:.]/g, '-').slice(0, 19);
-        const random = Math.random().toString(36).substring(2, 6);
-        return `chat-${timestamp}-${random}`;
+    this.indexLoaded = true;
+    this.saveIndex();
+  }
+  /**
+   * Save the metadata index to disk
+   */
+  saveIndex() {
+    try {
+      const indexArray = Array.from(this.chatIndex.values());
+      fs.writeFileSync(this.indexPath, JSON.stringify(indexArray, null, 2), "utf-8");
+    } catch (error) {
+      logError("Failed to save chat index", error);
     }
-    /**
-     * Generate a title from the first user message
-     */
-    generateTitle(messages) {
-        const firstUserMessage = messages.find(m => m.role === 'user');
-        if (!firstUserMessage || !firstUserMessage.content) {
-            return 'New Chat';
-        }
-        // Take first 60 chars, trim to last word boundary
-        let title = firstUserMessage.content.substring(0, 60);
-        if (firstUserMessage.content.length > 60) {
-            const lastSpace = title.lastIndexOf(' ');
-            if (lastSpace > 30) {
-                title = title.substring(0, lastSpace);
-            }
-            title += '...';
-        }
-        // Clean up whitespace and newlines
-        title = title.replace(/\s+/g, ' ').trim();
-        return title || 'New Chat';
+  }
+  /**
+   * Update the index entry for a chat
+   */
+  updateIndexEntry(chat) {
+    let environment = "local";
+    if (chat.remoteContext) {
+      const rc = chat.remoteContext;
+      if (rc.type === "ssh" && rc.metadata?.hostname) {
+        environment = `ssh:${rc.metadata.username || "user"}@${rc.metadata.hostname}`;
+      } else if (rc.type === "wsl") {
+        environment = `wsl:${rc.metadata?.distroName || "Ubuntu"}`;
+      } else if (rc.type === "docker" && rc.metadata?.containerId) {
+        environment = `docker:${rc.metadata.containerId.substring(0, 12)}`;
+      } else {
+        environment = rc.type;
+      }
     }
-    /**
-     * Get the file path for a chat
-     */
-    getChatPath(chatId) {
-        return path.join(this.chatsDir, `${chatId}.json`);
+    this.chatIndex.set(chat.id, {
+      id: chat.id,
+      title: chat.title,
+      createdAt: chat.createdAt,
+      updatedAt: chat.updatedAt,
+      messageCount: chat.messageCount,
+      environment
+    });
+    this.saveIndex();
+  }
+  /**
+   * Generate a unique chat ID based on timestamp
+   */
+  generateChatId() {
+    const now = /* @__PURE__ */ new Date();
+    const timestamp = now.toISOString().replace(/[:.]/g, "-").slice(0, 19);
+    const random = Math.random().toString(36).substring(2, 6);
+    return `chat-${timestamp}-${random}`;
+  }
+  /**
+   * Generate a title from the first user message
+   */
+  generateTitle(messages) {
+    const firstUserMessage = messages.find((m) => m.role === "user");
+    if (!firstUserMessage || !firstUserMessage.content) {
+      return "New Chat";
     }
-    /**
-     * Save a chat to disk
-     * @param remoteContext - undefined = preserve existing, null = clear, StoredRemoteContext = set new value
-     * @param remoteContextStack - Stack of nested contexts for SSH>SSH, SSH>Docker etc.
-     */
-    saveChat(chatId, messages, uiMessages, cwd, remoteContext, remoteContextStack) {
-        const chatPath = this.getChatPath(chatId);
-        const now = new Date().toISOString();
-        let chat;
-        if (fs.existsSync(chatPath)) {
-            // Update existing chat
-            const existing = this.loadChat(chatId);
-            if (existing) {
-                chat = {
-                    ...existing,
-                    messages,
-                    uiMessages: uiMessages || existing.uiMessages,
-                    cwd: cwd || existing.cwd, // Preserve CWD if not provided
-                    // remoteContext: null = clear it, undefined = preserve existing
-                    remoteContext: remoteContext === null ? undefined : (remoteContext !== undefined ? remoteContext : existing.remoteContext),
-                    // remoteContextStack: null = clear it, undefined = preserve existing
-                    remoteContextStack: remoteContextStack === null ? undefined : (remoteContextStack !== undefined ? remoteContextStack : existing.remoteContextStack),
-                    // Preserve backendConversationId if it exists
-                    backendConversationId: existing.backendConversationId,
-                    messageCount: messages.length,
-                    updatedAt: now,
-                };
-            }
-            else {
-                // File exists but couldn't be parsed, create new
-                chat = {
-                    id: chatId,
-                    title: this.generateTitle(messages),
-                    createdAt: now,
-                    updatedAt: now,
-                    messageCount: messages.length,
-                    messages,
-                    uiMessages,
-                    cwd,
-                    remoteContext: remoteContext ?? undefined,
-                    remoteContextStack: remoteContextStack ?? undefined,
-                };
-            }
-        }
-        else {
-            // Create new chat
-            chat = {
-                id: chatId,
-                title: this.generateTitle(messages),
-                createdAt: now,
-                updatedAt: now,
-                messageCount: messages.length,
-                messages,
-                uiMessages,
-                cwd,
-                remoteContext: remoteContext ?? undefined,
-                remoteContextStack: remoteContextStack ?? undefined,
-            };
-        }
-        fs.writeFileSync(chatPath, JSON.stringify(chat, null, 2), 'utf-8');
-        // Update the metadata index
-        this.updateIndexEntry(chat);
-        return chat;
+    let title = firstUserMessage.content.substring(0, 60);
+    if (firstUserMessage.content.length > 60) {
+      const lastSpace = title.lastIndexOf(" ");
+      if (lastSpace > 30) {
+        title = title.substring(0, lastSpace);
+      }
+      title += "...";
     }
-    /**
-     * Set the backend conversation ID for a chat
-     * This is used to associate local chats with backend file storage
-     */
-    setBackendConversationId(chatId, backendConversationId) {
-        const chat = this.loadChat(chatId);
-        if (!chat) {
-            return false;
-        }
-        try {
-            chat.backendConversationId = backendConversationId;
-            chat.updatedAt = new Date().toISOString();
-            const chatPath = this.getChatPath(chatId);
-            fs.writeFileSync(chatPath, JSON.stringify(chat, null, 2), 'utf-8');
-            return true;
-        }
-        catch (error) {
-            logError(`Failed to set backend conversation ID for chat ${chatId}`, error);
-            return false;
-        }
+    title = title.replace(/\s+/g, " ").trim();
+    return title || "New Chat";
+  }
+  /**
+   * Get the file path for a chat
+   */
+  getChatPath(chatId) {
+    return path.join(this.chatsDir, `${chatId}.json`);
+  }
+  /**
+   * Save a chat to disk
+   * @param remoteContext - undefined = preserve existing, null = clear, StoredRemoteContext = set new value
+   * @param remoteContextStack - Stack of nested contexts for SSH>SSH, SSH>Docker etc.
+   * @param checkpointIndex - undefined = preserve existing, null = clear, array = set latest checkpoint metadata
+   */
+  saveChat(chatId, messages, uiMessages, cwd, remoteContext, remoteContextStack, checkpointIndex) {
+    const chatPath = this.getChatPath(chatId);
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    let chat;
+    if (fs.existsSync(chatPath)) {
+      const existing = this.loadChat(chatId);
+      if (existing) {
+        chat = {
+          ...existing,
+          messages,
+          uiMessages: uiMessages || existing.uiMessages,
+          cwd: cwd || existing.cwd,
+          // Preserve CWD if not provided
+          // remoteContext: null = clear it, undefined = preserve existing
+          remoteContext: remoteContext === null ? void 0 : remoteContext !== void 0 ? remoteContext : existing.remoteContext,
+          // remoteContextStack: null = clear it, undefined = preserve existing
+          remoteContextStack: remoteContextStack === null ? void 0 : remoteContextStack !== void 0 ? remoteContextStack : existing.remoteContextStack,
+          // checkpointIndex: null = clear it, undefined = preserve existing
+          checkpointIndex: checkpointIndex === null ? void 0 : checkpointIndex !== void 0 ? checkpointIndex : existing.checkpointIndex,
+          // Preserve backendConversationId if it exists
+          backendConversationId: existing.backendConversationId,
+          messageCount: messages.length,
+          updatedAt: now
+        };
+      } else {
+        chat = {
+          id: chatId,
+          title: this.generateTitle(messages),
+          createdAt: now,
+          updatedAt: now,
+          messageCount: messages.length,
+          messages,
+          uiMessages,
+          cwd,
+          remoteContext: remoteContext ?? void 0,
+          remoteContextStack: remoteContextStack ?? void 0,
+          checkpointIndex: checkpointIndex ?? void 0
+        };
+      }
+    } else {
+      chat = {
+        id: chatId,
+        title: this.generateTitle(messages),
+        createdAt: now,
+        updatedAt: now,
+        messageCount: messages.length,
+        messages,
+        uiMessages,
+        cwd,
+        remoteContext: remoteContext ?? void 0,
+        remoteContextStack: remoteContextStack ?? void 0,
+        checkpointIndex: checkpointIndex ?? void 0
+      };
     }
-    /**
-     * Get the backend conversation ID for a chat (if any)
-     */
-    getBackendConversationId(chatId) {
-        const chat = this.loadChat(chatId);
-        return chat?.backendConversationId;
+    fs.writeFileSync(chatPath, JSON.stringify(chat, null, 2), "utf-8");
+    this.updateIndexEntry(chat);
+    return chat;
+  }
+  /**
+   * Set the backend conversation ID for a chat
+   * This is used to associate local chats with backend file storage
+   */
+  setBackendConversationId(chatId, backendConversationId) {
+    const chat = this.loadChat(chatId);
+    if (!chat) {
+      return false;
     }
-    /**
-     * Load a chat by ID
-     */
-    loadChat(chatId) {
-        const chatPath = this.getChatPath(chatId);
-        if (!fs.existsSync(chatPath)) {
-            return null;
-        }
-        try {
-            const data = fs.readFileSync(chatPath, 'utf-8');
-            return JSON.parse(data);
-        }
-        catch (error) {
-            logError(`Failed to load chat ${chatId}`, error);
-            return null;
-        }
+    try {
+      chat.backendConversationId = backendConversationId;
+      chat.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+      const chatPath = this.getChatPath(chatId);
+      fs.writeFileSync(chatPath, JSON.stringify(chat, null, 2), "utf-8");
+      return true;
+    } catch (error) {
+      logError(`Failed to set backend conversation ID for chat ${chatId}`, error);
+      return false;
     }
-    /**
-     * List all chats (metadata only, sorted by updatedAt descending)
-     * Uses the in-memory index to avoid loading full chat files
-     */
-    listChats() {
-        // Ensure index is loaded
-        this.loadIndex();
-        // Return sorted metadata from the cache
-        const chats = Array.from(this.chatIndex.values());
-        // Sort by updatedAt descending (most recent first)
-        chats.sort((a, b) => new Date(b.updatedAt).getTime() - new Date(a.updatedAt).getTime());
-        return chats;
+  }
+  /**
+   * Get the backend conversation ID for a chat (if any)
+   */
+  getBackendConversationId(chatId) {
+    const chat = this.loadChat(chatId);
+    return chat?.backendConversationId;
+  }
+  /**
+   * Load a chat by ID
+   */
+  loadChat(chatId) {
+    const chatPath = this.getChatPath(chatId);
+    if (!fs.existsSync(chatPath)) {
+      return null;
     }
-    /**
-     * Delete a chat by ID
-     */
-    deleteChat(chatId) {
-        const chatPath = this.getChatPath(chatId);
-        if (!fs.existsSync(chatPath)) {
-            return false;
-        }
-        try {
-            fs.unlinkSync(chatPath);
-            // Remove from index
-            this.chatIndex.delete(chatId);
-            this.saveIndex();
-            return true;
-        }
-        catch (error) {
-            logError(`Failed to delete chat ${chatId}`, error);
-            return false;
-        }
+    try {
+      const data = fs.readFileSync(chatPath, "utf-8");
+      return JSON.parse(data);
+    } catch (error) {
+      logError(`Failed to load chat ${chatId}`, error);
+      return null;
     }
-    /**
-     * Import a full chat object (used for restoring from cloud sync)
-     * Overwrites existing chat with same ID if present
-     */
-    importChat(chat) {
-        if (!chat || !chat.id) {
-            return false;
-        }
+  }
+  /**
+   * List all chats (metadata only, sorted by updatedAt descending)
+   * Uses the in-memory index to avoid loading full chat files
+   */
+  listChats() {
+    this.loadIndex();
+    const chats = Array.from(this.chatIndex.values());
+    chats.sort(
+      (a, b) => new Date(b.updatedAt).getTime() - new Date(a.updatedAt).getTime()
+    );
+    return chats;
+  }
+  /**
+   * Delete a chat by ID
+   */
+  deleteChat(chatId) {
+    const chatPath = this.getChatPath(chatId);
+    const checkpointsPath = path.join(os.homedir(), ".centaurus", "checkpoints", chatId);
+    if (!fs.existsSync(chatPath)) {
+      if (fs.existsSync(checkpointsPath)) {
         try {
-            const chatPath = this.getChatPath(chat.id);
-            // Ensure the chat has required fields
-            const now = new Date().toISOString();
-            const importedChat = {
-                id: chat.id,
-                title: chat.title || 'Imported Chat',
-                createdAt: chat.createdAt || now,
-                updatedAt: now, // Always update the timestamp on import
-                messageCount: chat.messages?.length || chat.messageCount || 0,
-                messages: chat.messages || [],
-                uiMessages: chat.uiMessages,
-                cwd: chat.cwd,
-                remoteContext: chat.remoteContext,
-                backendConversationId: chat.backendConversationId,
-                environment: chat.environment,
-            };
-            fs.writeFileSync(chatPath, JSON.stringify(importedChat, null, 2), 'utf-8');
-            // Update the index
-            this.updateIndexEntry(importedChat);
-            return true;
-        }
-        catch (error) {
-            logError(`Failed to import chat ${chat.id}`, error);
-            return false;
+          fs.rmSync(checkpointsPath, { recursive: true, force: true });
+        } catch {
         }
+      }
+      return false;
     }
-    /**
-     * Rename a chat by ID
-     */
-    renameChat(chatId, newTitle) {
-        const chat = this.loadChat(chatId);
-        if (!chat) {
-            return false;
-        }
-        try {
-            chat.title = newTitle;
-            chat.updatedAt = new Date().toISOString();
-            const chatPath = this.getChatPath(chatId);
-            fs.writeFileSync(chatPath, JSON.stringify(chat, null, 2), 'utf-8');
-            // Update the index
-            this.updateIndexEntry(chat);
-            return true;
-        }
-        catch (error) {
-            logError(`Failed to rename chat ${chatId}`, error);
-            return false;
-        }
+    try {
+      fs.unlinkSync(chatPath);
+      if (fs.existsSync(checkpointsPath)) {
+        fs.rmSync(checkpointsPath, { recursive: true, force: true });
+      }
+      this.chatIndex.delete(chatId);
+      this.saveIndex();
+      return true;
+    } catch (error) {
+      logError(`Failed to delete chat ${chatId}`, error);
+      return false;
+    }
+  }
+  /**
+   * Import a full chat object (used for restoring from cloud sync)
+   * Overwrites existing chat with same ID if present
+   */
+  importChat(chat) {
+    if (!chat || !chat.id) {
+      return false;
+    }
+    try {
+      const chatPath = this.getChatPath(chat.id);
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      const importedChat = {
+        id: chat.id,
+        title: chat.title || "Imported Chat",
+        createdAt: chat.createdAt || now,
+        updatedAt: now,
+        // Always update the timestamp on import
+        messageCount: chat.messages?.length || chat.messageCount || 0,
+        messages: chat.messages || [],
+        uiMessages: chat.uiMessages,
+        cwd: chat.cwd,
+        remoteContext: chat.remoteContext,
+        remoteContextStack: chat.remoteContextStack,
+        checkpointIndex: chat.checkpointIndex,
+        backendConversationId: chat.backendConversationId,
+        environment: chat.environment
+      };
+      fs.writeFileSync(chatPath, JSON.stringify(importedChat, null, 2), "utf-8");
+      this.updateIndexEntry(importedChat);
+      return true;
+    } catch (error) {
+      logError(`Failed to import chat ${chat.id}`, error);
+      return false;
+    }
+  }
+  /**
+   * Rename a chat by ID
+   */
+  renameChat(chatId, newTitle) {
+    const chat = this.loadChat(chatId);
+    if (!chat) {
+      return false;
     }
-    /**
-     * Get the chats directory path
-     */
-    getChatsDir() {
-        return this.chatsDir;
+    try {
+      chat.title = newTitle;
+      chat.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+      const chatPath = this.getChatPath(chatId);
+      fs.writeFileSync(chatPath, JSON.stringify(chat, null, 2), "utf-8");
+      this.updateIndexEntry(chat);
+      return true;
+    } catch (error) {
+      logError(`Failed to rename chat ${chatId}`, error);
+      return false;
     }
+  }
+  /**
+   * Get the chats directory path
+   */
+  getChatsDir() {
+    return this.chatsDir;
+  }
 }
-// Export singleton instance
-export const localChatStorage = new LocalChatStorage();
+const localChatStorage = new LocalChatStorage();
+export {
+  LocalChatStorage,
+  localChatStorage
+};
 //# sourceMappingURL=local-chat-storage.js.map