@astermind/cybernetic-chatbot-client 2.2.59 → 2.2.62

package/dist/cybernetic-chatbot-client.esm.js

@@ -1375,6 +1375,230 @@ class WebSocketTransport {
     }
 }
 
+// src/CyberneticSessionStorage.ts
+// Session storage manager for persisting chatbot session across page navigations
+const DEFAULT_CONFIG = {
+    enabled: true,
+    storageKey: 'astermind_session',
+    sessionTtl: 30 * 60 * 1000, // 30 minutes
+    persistMessages: true,
+    maxMessages: 50
+};
+/**
+ * Session storage manager for persisting chatbot sessions
+ *
+ * Uses sessionStorage to maintain conversation continuity across
+ * page navigations within the same browser session.
+ */
+class CyberneticSessionStorage {
+    constructor(config) {
+        this.cachedSession = null;
+        this.config = { ...DEFAULT_CONFIG, ...config };
+        // Load cached session on initialization
+        if (this.config.enabled && this.isAvailable()) {
+            this.cachedSession = this.loadFromStorage();
+        }
+    }
+    /**
+     * Check if sessionStorage is available
+     */
+    isAvailable() {
+        if (typeof window === 'undefined')
+            return false;
+        try {
+            const testKey = '__astermind_test__';
+            window.sessionStorage.setItem(testKey, 'test');
+            window.sessionStorage.removeItem(testKey);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Get the current session ID (if valid)
+     */
+    getSessionId() {
+        if (!this.config.enabled)
+            return null;
+        const session = this.getSession();
+        return session?.sessionId ?? null;
+    }
+    /**
+     * Get the full stored session (if valid)
+     */
+    getSession() {
+        if (!this.config.enabled)
+            return null;
+        // Use cached session if available
+        if (this.cachedSession) {
+            if (this.isSessionValid(this.cachedSession)) {
+                return this.cachedSession;
+            }
+            // Session expired, clear it
+            this.clear();
+            return null;
+        }
+        // Try loading from storage
+        const session = this.loadFromStorage();
+        if (session && this.isSessionValid(session)) {
+            this.cachedSession = session;
+            return session;
+        }
+        return null;
+    }
+    /**
+     * Save/update session ID
+     */
+    saveSessionId(sessionId) {
+        if (!this.config.enabled || !sessionId)
+            return;
+        const existingSession = this.getSession();
+        const session = {
+            sessionId,
+            updatedAt: Date.now(),
+            messages: existingSession?.messages ?? []
+        };
+        this.saveToStorage(session);
+        this.cachedSession = session;
+    }
+    /**
+     * Add a message to the conversation history
+     */
+    addMessage(message) {
+        if (!this.config.enabled || !this.config.persistMessages)
+            return;
+        const session = this.getSession();
+        if (!session)
+            return;
+        const newMessage = {
+            ...message,
+            id: this.generateMessageId(),
+            timestamp: Date.now()
+        };
+        // Add new message and trim if necessary
+        session.messages = session.messages ?? [];
+        session.messages.push(newMessage);
+        // Keep only the most recent messages
+        if (session.messages.length > this.config.maxMessages) {
+            session.messages = session.messages.slice(-this.config.maxMessages);
+        }
+        session.updatedAt = Date.now();
+        this.saveToStorage(session);
+        this.cachedSession = session;
+    }
+    /**
+     * Get conversation messages
+     */
+    getMessages() {
+        if (!this.config.enabled || !this.config.persistMessages)
+            return [];
+        const session = this.getSession();
+        return session?.messages ?? [];
+    }
+    /**
+     * Clear the stored session
+     */
+    clear() {
+        this.cachedSession = null;
+        if (!this.isAvailable())
+            return;
+        try {
+            window.sessionStorage.removeItem(this.config.storageKey);
+        }
+        catch (error) {
+            console.warn('[CyberneticSessionStorage] Failed to clear session:', error);
+        }
+    }
+    /**
+     * Start a new session (clears existing and optionally sets new ID)
+     */
+    startNewSession(sessionId) {
+        this.clear();
+        if (sessionId) {
+            this.saveSessionId(sessionId);
+        }
+    }
+    /**
+     * Check if we have a valid stored session
+     */
+    hasValidSession() {
+        return this.getSession() !== null;
+    }
+    /**
+     * Get session info for debugging/status
+     */
+    getSessionInfo() {
+        const session = this.getSession();
+        if (!session) {
+            return {
+                hasSession: false,
+                sessionId: null,
+                messageCount: 0,
+                lastUpdated: null,
+                ttlRemaining: null
+            };
+        }
+        const ttlRemaining = Math.max(0, this.config.sessionTtl - (Date.now() - session.updatedAt));
+        return {
+            hasSession: true,
+            sessionId: session.sessionId,
+            messageCount: session.messages?.length ?? 0,
+            lastUpdated: new Date(session.updatedAt),
+            ttlRemaining
+        };
+    }
+    // ==================== PRIVATE METHODS ====================
+    /**
+     * Check if a session is still valid (not expired)
+     */
+    isSessionValid(session) {
+        const age = Date.now() - session.updatedAt;
+        return age < this.config.sessionTtl;
+    }
+    /**
+     * Load session from sessionStorage
+     */
+    loadFromStorage() {
+        if (!this.isAvailable())
+            return null;
+        try {
+            const stored = window.sessionStorage.getItem(this.config.storageKey);
+            if (!stored)
+                return null;
+            const session = JSON.parse(stored);
+            // Validate structure
+            if (!session.sessionId || typeof session.updatedAt !== 'number') {
+                return null;
+            }
+            return session;
+        }
+        catch (error) {
+            console.warn('[CyberneticSessionStorage] Failed to load session:', error);
+            return null;
+        }
+    }
+    /**
+     * Save session to sessionStorage
+     */
+    saveToStorage(session) {
+        if (!this.isAvailable())
+            return;
+        try {
+            window.sessionStorage.setItem(this.config.storageKey, JSON.stringify(session));
+        }
+        catch (error) {
+            console.warn('[CyberneticSessionStorage] Failed to save session:', error);
+        }
+    }
+    /**
+     * Generate a unique message ID
+     */
+    generateMessageId() {
+        return `msg_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+    }
+}
+
 // src/config.ts
 // Configuration loading and validation
 /** Default API URL when not specified */
@@ -2348,6 +2572,8 @@ class CyberneticClient {
             licenseKey: config.licenseKey,
             environment: config.environment,
         });
+        // Initialize session storage (auto-loads existing session from browser sessionStorage)
+        this.sessionStorage = new CyberneticSessionStorage(config.session);
         // Verify license asynchronously (non-blocking)
         this.licenseManager.verify().then(() => {
             // Check client feature after verification
@@ -2648,6 +2874,40 @@ class CyberneticClient {
     getOfflineStorage() {
         return this.offlineStorage;
     }
+    // ==================== SESSION PERSISTENCE METHODS (ADR-028) ====================
+    /**
+     * Get stored messages from a previous session for UI restoration.
+     * Call after construction to check for resumable conversations.
+     */
+    getStoredMessages() {
+        return this.sessionStorage.getMessages();
+    }
+    /**
+     * Check if a valid stored session exists that can be resumed.
+     */
+    hasStoredSession() {
+        return this.sessionStorage.hasValidSession();
+    }
+    /**
+     * Get session info for debugging/status display.
+     */
+    getSessionInfo() {
+        return this.sessionStorage.getSessionInfo();
+    }
+    /**
+     * Clear the stored session and start fresh.
+     * Use for "New Conversation" actions.
+     */
+    clearSession() {
+        this.sessionStorage.clear();
+    }
+    /**
+     * Start a new session, clearing any stored data.
+     * Optionally sets a new sessionId immediately.
+     */
+    startNewSession(sessionId) {
+        this.sessionStorage.startNewSession(sessionId);
+    }
     // ==================== CORE METHODS ====================
     /**
      * Send a message to the chatbot
@@ -2661,6 +2921,11 @@ class CyberneticClient {
         if (!message || typeof message !== 'string') {
             return this.createErrorResponse('Message is required', 'none');
         }
+        // Auto-resolve sessionId: explicit option > stored session > none (ADR-028)
+        const resolvedSessionId = options?.sessionId ?? this.sessionStorage.getSessionId() ?? undefined;
+        const resolvedOptions = resolvedSessionId
+            ? { ...options, sessionId: resolvedSessionId }
+            : options;
         // Check maintenance mode before API call (ADR-200)
         const settings = await this.checkSystemStatus();
         if (settings.maintenanceMode || settings.forceOfflineClients) {
@@ -2681,10 +2946,16 @@ class CyberneticClient {
         }
         // Try API first
         try {
-            const response = await this.apiWithRetry(message, options);
+            const response = await this.apiWithRetry(message, resolvedOptions);
             this.setStatus('online');
             // Process response through license manager (may add warning in production)
             const processedReply = this.licenseManager.processResponse(response.reply);
+            // Persist session state (ADR-028)
+            if (response.sessionId) {
+                this.sessionStorage.saveSessionId(response.sessionId);
+            }
+            this.sessionStorage.addMessage({ role: 'user', content: message });
+            this.sessionStorage.addMessage({ role: 'assistant', content: processedReply, confidence: 'high' });
             return {
                 reply: processedReply,
                 confidence: 'high',
@@ -2730,6 +3001,13 @@ class CyberneticClient {
             });
             return;
         }
+        // Auto-resolve sessionId: explicit option > stored session > none (ADR-028)
+        const resolvedSessionId = options?.sessionId ?? this.sessionStorage.getSessionId() ?? undefined;
+        const resolvedOptions = resolvedSessionId
+            ? { ...options, sessionId: resolvedSessionId }
+            : options;
+        // Save user message immediately (ADR-028)
+        this.sessionStorage.addMessage({ role: 'user', content: message });
         // Check maintenance mode before API call (ADR-200)
         const settings = await this.checkSystemStatus();
         if (settings.maintenanceMode || settings.forceOfflineClients) {
@@ -2742,14 +3020,19 @@ class CyberneticClient {
         if (this.wsTransport && this.config.transport !== 'rest') {
             try {
                 await this.wsTransport.chatStream(message, {
-                    sessionId: options?.sessionId,
-                    context: options?.context,
+                    sessionId: resolvedOptions?.sessionId,
+                    context: resolvedOptions?.context,
                     onToken: callbacks.onToken,
                     onSources: callbacks.onSources,
                     onComplete: (response) => {
                         this.setStatus('online');
                         // Process through license manager
                         const processedReply = this.licenseManager.processResponse(response.reply);
+                        // Persist session state (ADR-028)
+                        if (response.sessionId) {
+                            this.sessionStorage.saveSessionId(response.sessionId);
+                        }
+                        this.sessionStorage.addMessage({ role: 'assistant', content: processedReply, confidence: 'high' });
                         callbacks.onComplete?.({
                             ...response,
                             reply: processedReply
@@ -2759,7 +3042,7 @@ class CyberneticClient {
                         // In 'auto' mode, fall back to SSE on WS error
                         if (this.config.transport === 'auto') {
                             console.warn('[Cybernetic] WebSocket error, falling back to SSE:', error.message);
-                            this.streamViaSSE(message, callbacks, options);
+                            this.streamViaSSE(message, callbacks, resolvedOptions);
                         }
                         else {
                             // 'websocket' mode — no fallback
@@ -2785,7 +3068,7 @@ class CyberneticClient {
             }
         }
         // REST+SSE path (on-prem, or fallback from WebSocket)
-        await this.streamViaSSE(message, callbacks, options);
+        await this.streamViaSSE(message, callbacks, resolvedOptions);
     }
     /**
      * Stream chat via REST+SSE (original transport).
@@ -2802,6 +3085,11 @@ class CyberneticClient {
                     this.setStatus('online');
                     // Process response through license manager (may add warning in production)
                     const processedReply = this.licenseManager.processResponse(data.fullText);
+                    // Persist session state (ADR-028)
+                    if (data.sessionId) {
+                        this.sessionStorage.saveSessionId(data.sessionId);
+                    }
+                    this.sessionStorage.addMessage({ role: 'assistant', content: processedReply, confidence: 'high' });
                     callbacks.onComplete?.({
                         reply: processedReply,
                         confidence: 'high',
@@ -7179,5 +7467,5 @@ function createClient(config) {
     return new CyberneticClient(config);
 }
 
-export { ApiClient, CyberneticAgent, CyberneticCache, CyberneticClient, CyberneticIntentClassifier, CyberneticLocalRAG, CyberneticOfflineStorage, LicenseManager, OmegaOfflineRAG, REQUIRED_FEATURES, SiteMapDiscovery, WebSocketTransport, configLoaders, createClient, createDiscoveryConfig, createLicenseManager, deriveWsUrl, detectEnvironment, getEnforcementMode, getTokenExpiration, isValidJWTFormat, loadConfig, registerAgenticCapabilities, resolveWsUrl, useSiteMapDiscovery, validateConfig, verifyLicenseToken };
+export { ApiClient, CyberneticAgent, CyberneticCache, CyberneticClient, CyberneticIntentClassifier, CyberneticLocalRAG, CyberneticOfflineStorage, CyberneticSessionStorage, LicenseManager, OmegaOfflineRAG, REQUIRED_FEATURES, SiteMapDiscovery, WebSocketTransport, configLoaders, createClient, createDiscoveryConfig, createLicenseManager, deriveWsUrl, detectEnvironment, getEnforcementMode, getTokenExpiration, isValidJWTFormat, loadConfig, registerAgenticCapabilities, resolveWsUrl, useSiteMapDiscovery, validateConfig, verifyLicenseToken };
 //# sourceMappingURL=cybernetic-chatbot-client.esm.js.map