@juspay/neurolink 9.87.4 → 9.88.0

package/dist/core/redisConversationMemoryManager.js

@@ -1271,6 +1271,86 @@ User message: "${userMessage}"`;
             return results;
         }
     }
+    /**
+     * List all sessions with metadata for CLI/API usage
+     * Implements IConversationMemoryManager.listSessions
+     * @param userId - Optional user identifier to filter sessions
+     * @returns Array of session list items with metadata
+     */
+    async listSessions(userId) {
+        await this.ensureInitialized();
+        if (!this.redisClient) {
+            return [];
+        }
+        const now = Date.now();
+        const list = [];
+        if (userId) {
+            // List sessions for a specific user
+            const sessionIds = await this.getUserSessions(userId);
+            for (const sessionId of sessionIds) {
+                const session = await this.getUserSessionObject(userId, sessionId);
+                if (!session) {
+                    continue;
+                }
+                list.push({
+                    id: session.sessionId,
+                    title: session.title || session.sessionId,
+                    createdAt: session.createdAt,
+                    updatedAt: session.updatedAt,
+                    userId: session.userId,
+                    messageCount: session.messages.length,
+                    lastActive: this.formatTimeAgo(now - new Date(session.updatedAt).getTime()),
+                });
+            }
+        }
+        else {
+            // List all sessions across all users by scanning Redis keys
+            const keys = await scanKeys(this.redisClient, `${this.redisConfig.keyPrefix}*`);
+            for (const key of keys) {
+                // Skip user session index keys (they end with :sessions)
+                if (key.endsWith(":sessions")) {
+                    continue;
+                }
+                const raw = await this.redisClient.get(key);
+                if (!raw) {
+                    continue;
+                }
+                const session = deserializeConversation(raw);
+                if (!session) {
+                    continue;
+                }
+                list.push({
+                    id: session.sessionId,
+                    title: session.title || session.sessionId,
+                    createdAt: session.createdAt,
+                    updatedAt: session.updatedAt,
+                    userId: session.userId,
+                    messageCount: session.messages.length,
+                    lastActive: this.formatTimeAgo(now - new Date(session.updatedAt).getTime()),
+                });
+            }
+        }
+        return list.sort((a, b) => new Date(b.updatedAt).getTime() - new Date(a.updatedAt).getTime());
+    }
+    /**
+     * Format milliseconds into human-readable time ago string
+     */
+    formatTimeAgo(ms) {
+        const seconds = Math.floor(ms / 1000);
+        const minutes = Math.floor(seconds / 60);
+        const hours = Math.floor(minutes / 60);
+        const days = Math.floor(hours / 24);
+        if (days > 0) {
+            return `${days} day${days > 1 ? "s" : ""} ago`;
+        }
+        if (hours > 0) {
+            return `${hours} hour${hours > 1 ? "s" : ""} ago`;
+        }
+        if (minutes > 0) {
+            return `${minutes} minute${minutes > 1 ? "s" : ""} ago`;
+        }
+        return "just now";
+    }
     /**
      * Clean up stale pending tool execution data
      * Removes data older than 5 minutes to prevent memory leaks

package/dist/lib/core/conversationMemoryManager.d.ts

@@ -2,7 +2,7 @@
  * Conversation Memory Manager for NeuroLink
  * Handles in-memory conversation storage, session management, and context injection
  */
-import type { ChatMessage, ConversationMemoryConfig, ConversationMemoryStats, SessionMemory, StoreConversationTurnOptions, IConversationMemoryManager } from "../types/index.js";
+import type { ChatMessage, ConversationMemoryConfig, ConversationMemoryStats, SessionListItem, SessionMemory, StoreConversationTurnOptions, IConversationMemoryManager } from "../types/index.js";
 export declare class ConversationMemoryManager implements IConversationMemoryManager {
     private sessions;
     config: ConversationMemoryConfig;
@@ -56,6 +56,16 @@ export declare class ConversationMemoryManager implements IConversationMemoryMan
     private createNewSession;
     private enforceSessionLimit;
     getStats(): Promise<ConversationMemoryStats>;
+    /**
+     * List all sessions with metadata
+     * @param userId - Optional user ID to filter sessions
+     * @returns Array of session list items with metadata
+     */
+    listSessions(userId?: string): Promise<SessionListItem[]>;
+    /**
+     * Format milliseconds into human-readable time ago string
+     */
+    private formatTimeAgo;
     clearSession(sessionId: string): Promise<boolean>;
     clearAllSessions(): Promise<void>;
     /**

package/dist/lib/core/conversationMemoryManager.js

@@ -292,6 +292,50 @@ export class ConversationMemoryManager {
             totalTurns,
         };
     }
+    /**
+     * List all sessions with metadata
+     * @param userId - Optional user ID to filter sessions
+     * @returns Array of session list items with metadata
+     */
+    async listSessions(userId) {
+        await this.ensureInitialized();
+        const sessions = Array.from(this.sessions.values());
+        const now = Date.now();
+        return sessions
+            .filter((session) => !userId || session.userId === userId)
+            .map((session) => {
+            const lastActive = this.formatTimeAgo(now - session.lastActivity);
+            return {
+                id: session.sessionId,
+                title: session.sessionId, // In-memory doesn't store title, use sessionId
+                createdAt: new Date(session.createdAt).toISOString(),
+                updatedAt: new Date(session.lastActivity).toISOString(),
+                userId: session.userId,
+                messageCount: session.messages.length,
+                lastActive,
+            };
+        })
+            .sort((a, b) => new Date(b.updatedAt).getTime() - new Date(a.updatedAt).getTime());
+    }
+    /**
+     * Format milliseconds into human-readable time ago string
+     */
+    formatTimeAgo(ms) {
+        const seconds = Math.floor(ms / 1000);
+        const minutes = Math.floor(seconds / 60);
+        const hours = Math.floor(minutes / 60);
+        const days = Math.floor(hours / 24);
+        if (days > 0) {
+            return `${days} day${days > 1 ? "s" : ""} ago`;
+        }
+        if (hours > 0) {
+            return `${hours} hour${hours > 1 ? "s" : ""} ago`;
+        }
+        if (minutes > 0) {
+            return `${minutes} minute${minutes > 1 ? "s" : ""} ago`;
+        }
+        return "just now";
+    }
     async clearSession(sessionId) {
         return withSpan({
             name: "neurolink.memory.clear",

package/dist/lib/core/redisConversationMemoryManager.d.ts

@@ -2,7 +2,7 @@
  * Redis Conversation Memory Manager for NeuroLink
  * Redis-based implementation of conversation storage with same interface as ConversationMemoryManager
  */
-import type { ChatMessage, ConversationMemoryConfig, ConversationMemoryStats, RedisConversationObject, RedisStorageConfig, SessionMemory, SessionMetadata, StoreConversationTurnOptions, AgenticLoopReportMetadata, IConversationMemoryManager } from "../types/index.js";
+import type { ChatMessage, ConversationMemoryConfig, ConversationMemoryStats, RedisConversationObject, RedisStorageConfig, SessionListItem, SessionMemory, SessionMetadata, StoreConversationTurnOptions, AgenticLoopReportMetadata, IConversationMemoryManager } from "../types/index.js";
 /**
  * Redis-based implementation of the ConversationMemoryManager
  * Uses the same interface but stores data in Redis
@@ -175,6 +175,17 @@ export declare class RedisConversationMemoryManager implements IConversationMemo
      * @returns Array of session metadata objects
      */
     getUserAllSessionsHistory(userId: string): Promise<SessionMetadata[]>;
+    /**
+     * List all sessions with metadata for CLI/API usage
+     * Implements IConversationMemoryManager.listSessions
+     * @param userId - Optional user identifier to filter sessions
+     * @returns Array of session list items with metadata
+     */
+    listSessions(userId?: string): Promise<SessionListItem[]>;
+    /**
+     * Format milliseconds into human-readable time ago string
+     */
+    private formatTimeAgo;
     /**
      * Clean up stale pending tool execution data
      * Removes data older than 5 minutes to prevent memory leaks

package/dist/lib/core/redisConversationMemoryManager.js

@@ -1271,6 +1271,86 @@ User message: "${userMessage}"`;
             return results;
         }
     }
+    /**
+     * List all sessions with metadata for CLI/API usage
+     * Implements IConversationMemoryManager.listSessions
+     * @param userId - Optional user identifier to filter sessions
+     * @returns Array of session list items with metadata
+     */
+    async listSessions(userId) {
+        await this.ensureInitialized();
+        if (!this.redisClient) {
+            return [];
+        }
+        const now = Date.now();
+        const list = [];
+        if (userId) {
+            // List sessions for a specific user
+            const sessionIds = await this.getUserSessions(userId);
+            for (const sessionId of sessionIds) {
+                const session = await this.getUserSessionObject(userId, sessionId);
+                if (!session) {
+                    continue;
+                }
+                list.push({
+                    id: session.sessionId,
+                    title: session.title || session.sessionId,
+                    createdAt: session.createdAt,
+                    updatedAt: session.updatedAt,
+                    userId: session.userId,
+                    messageCount: session.messages.length,
+                    lastActive: this.formatTimeAgo(now - new Date(session.updatedAt).getTime()),
+                });
+            }
+        }
+        else {
+            // List all sessions across all users by scanning Redis keys
+            const keys = await scanKeys(this.redisClient, `${this.redisConfig.keyPrefix}*`);
+            for (const key of keys) {
+                // Skip user session index keys (they end with :sessions)
+                if (key.endsWith(":sessions")) {
+                    continue;
+                }
+                const raw = await this.redisClient.get(key);
+                if (!raw) {
+                    continue;
+                }
+                const session = deserializeConversation(raw);
+                if (!session) {
+                    continue;
+                }
+                list.push({
+                    id: session.sessionId,
+                    title: session.title || session.sessionId,
+                    createdAt: session.createdAt,
+                    updatedAt: session.updatedAt,
+                    userId: session.userId,
+                    messageCount: session.messages.length,
+                    lastActive: this.formatTimeAgo(now - new Date(session.updatedAt).getTime()),
+                });
+            }
+        }
+        return list.sort((a, b) => new Date(b.updatedAt).getTime() - new Date(a.updatedAt).getTime());
+    }
+    /**
+     * Format milliseconds into human-readable time ago string
+     */
+    formatTimeAgo(ms) {
+        const seconds = Math.floor(ms / 1000);
+        const minutes = Math.floor(seconds / 60);
+        const hours = Math.floor(minutes / 60);
+        const days = Math.floor(hours / 24);
+        if (days > 0) {
+            return `${days} day${days > 1 ? "s" : ""} ago`;
+        }
+        if (hours > 0) {
+            return `${hours} hour${hours > 1 ? "s" : ""} ago`;
+        }
+        if (minutes > 0) {
+            return `${minutes} minute${minutes > 1 ? "s" : ""} ago`;
+        }
+        return "just now";
+    }
     /**
      * Clean up stale pending tool execution data
      * Removes data older than 5 minutes to prevent memory leaks

package/dist/lib/neurolink.d.ts

@@ -14,6 +14,7 @@ import { MCPToolRegistry } from "./mcp/toolRegistry.js";
 import type { DynamicOptions } from "./types/index.js";
 import { SkillsManager } from "./skills/skillsManager.js";
 import { TaskManager } from "./tasks/taskManager.js";
+import type { SessionExport, SessionListItem } from "./types/index.js";
 /**
  * Curator P2-4 dedup (concurrency-safe): native providers emit
  * `generation:end` on the shared SDK emitter. We attach a fresh
@@ -1631,6 +1632,32 @@ export declare class NeuroLink {
      * Clear all conversation history (public API)
      */
     clearAllConversations(): Promise<void>;
+    /**
+     * List all conversation sessions with metadata (public API)
+     * @param userId - Optional user ID to filter sessions (required for Redis storage)
+     * @returns Array of session list items with metadata
+     */
+    listSessions(userId?: string): Promise<SessionListItem[]>;
+    /**
+     * Export a single session with full history and metadata (public API)
+     * @param sessionId - The session ID to export
+     * @param options - Export options
+     * @returns Session export object with full history
+     */
+    exportSession(sessionId: string, options?: {
+        includeMetadata?: boolean;
+        format?: "json" | "csv";
+    }): Promise<SessionExport | null>;
+    /**
+     * Export all sessions for a user (public API)
+     * @param userId - Optional user ID (required for Redis storage)
+     * @param options - Export options
+     * @returns Array of session exports
+     */
+    exportAllSessions(userId?: string, options?: {
+        includeMetadata?: boolean;
+        format?: "json" | "csv";
+    }): Promise<SessionExport[]>;
     /**
      * Store tool executions in conversation memory if enabled and Redis is configured
      * @param sessionId - Session identifier

package/dist/lib/neurolink.js

@@ -10504,6 +10504,139 @@ Current user's request: ${currentInput}`;
         this.lastCompactionMessageCount.clear();
         await this.conversationMemory.clearAllSessions();
     }
+    /**
+     * List all conversation sessions with metadata (public API)
+     * @param userId - Optional user ID to filter sessions (required for Redis storage)
+     * @returns Array of session list items with metadata
+     */
+    async listSessions(userId) {
+        // First ensure memory is initialized
+        const initId = `list-sessions-init-${Date.now()}`;
+        await this.initializeConversationMemoryForGeneration(initId, Date.now(), process.hrtime.bigint());
+        if (!this.conversationMemory) {
+            throw new Error("Conversation memory is not enabled");
+        }
+        // Check if listSessions is available on the memory manager
+        if (!this.conversationMemory.listSessions) {
+            logger.warn("listSessions not available on current memory manager");
+            return [];
+        }
+        const MEMORY_OPERATION_TIMEOUT = 30000; // 30 seconds
+        try {
+            const sessions = await withTimeout(this.conversationMemory.listSessions(userId), MEMORY_OPERATION_TIMEOUT, new Error("listSessions operation timed out after 30s"));
+            logger.debug("Listed conversation sessions", {
+                userId,
+                sessionCount: sessions.length,
+            });
+            return sessions;
+        }
+        catch (error) {
+            logger.error("Failed to list conversation sessions", {
+                userId,
+                error: error instanceof Error ? error.message : String(error),
+            });
+            return [];
+        }
+    }
+    /**
+     * Export a single session with full history and metadata (public API)
+     * @param sessionId - The session ID to export
+     * @param options - Export options
+     * @returns Session export object with full history
+     */
+    async exportSession(sessionId, options = {}) {
+        // First ensure memory is initialized
+        const initId = `export-session-init-${Date.now()}`;
+        await this.initializeConversationMemoryForGeneration(initId, Date.now(), process.hrtime.bigint());
+        if (!this.conversationMemory) {
+            throw new Error("Conversation memory is not enabled");
+        }
+        if (!sessionId || typeof sessionId !== "string") {
+            throw new Error("Session ID must be a non-empty string");
+        }
+        const MEMORY_OPERATION_TIMEOUT = 30000; // 30 seconds
+        try {
+            const messages = await withTimeout(this.conversationMemory.buildContextMessages(sessionId), MEMORY_OPERATION_TIMEOUT, new Error("buildContextMessages operation timed out after 30s"));
+            if (messages.length === 0) {
+                logger.debug("No messages found for session export", { sessionId });
+                return null;
+            }
+            const sessionResult = this.conversationMemory.getSession(sessionId);
+            const session = await withTimeout(sessionResult instanceof Promise
+                ? sessionResult
+                : Promise.resolve(sessionResult), MEMORY_OPERATION_TIMEOUT, new Error("getSession operation timed out after 30s"));
+            const now = new Date().toISOString();
+            const exportData = {
+                sessionId,
+                title: sessionId, // Use sessionId as title if not available
+                userId: session?.userId,
+                createdAt: session?.createdAt
+                    ? new Date(session.createdAt).toISOString()
+                    : now,
+                updatedAt: session?.lastActivity
+                    ? new Date(session.lastActivity).toISOString()
+                    : now,
+                messages,
+            };
+            if (options.includeMetadata) {
+                exportData.exportMetadata = {
+                    exportedAt: now,
+                    exportFormat: options.format || "json",
+                };
+            }
+            logger.debug("Exported conversation session", {
+                sessionId,
+                messageCount: messages.length,
+            });
+            return exportData;
+        }
+        catch (error) {
+            logger.error("Failed to export conversation session", {
+                sessionId,
+                error: error instanceof Error ? error.message : String(error),
+            });
+            return null;
+        }
+    }
+    /**
+     * Export all sessions for a user (public API)
+     * @param userId - Optional user ID (required for Redis storage)
+     * @param options - Export options
+     * @returns Array of session exports
+     */
+    async exportAllSessions(userId, options = {}) {
+        // First ensure memory is initialized
+        const initId = `export-all-init-${Date.now()}`;
+        await this.initializeConversationMemoryForGeneration(initId, Date.now(), process.hrtime.bigint());
+        if (!this.conversationMemory) {
+            throw new Error("Conversation memory is not enabled");
+        }
+        const MEMORY_OPERATION_TIMEOUT = 30000; // 30 seconds
+        const EXPORT_SESSION_TIMEOUT = 60000; // 60 seconds for full export
+        try {
+            // Get all session IDs
+            const sessions = await withTimeout(this.listSessions(userId), MEMORY_OPERATION_TIMEOUT, new Error("listSessions operation timed out after 30s"));
+            const exports = [];
+            for (const session of sessions) {
+                const exportData = await withTimeout(this.exportSession(session.id, options), EXPORT_SESSION_TIMEOUT, new Error(`exportSession operation timed out after 60s for session ${session.id}`));
+                if (exportData) {
+                    exports.push(exportData);
+                }
+            }
+            logger.debug("Exported all conversation sessions", {
+                userId,
+                sessionCount: exports.length,
+            });
+            return exports;
+        }
+        catch (error) {
+            logger.error("Failed to export all conversation sessions", {
+                userId,
+                error: error instanceof Error ? error.message : String(error),
+            });
+            return [];
+        }
+    }
     /**
      * Store tool executions in conversation memory if enabled and Redis is configured
      * @param sessionId - Session identifier

package/dist/lib/types/conversation.d.ts

@@ -451,6 +451,42 @@ export type AgenticLoopReportMetadata = {
         endDate: string;
     };
 };
+/**
+ * Session list item for CLI/API listing
+ * Extends SessionMetadata with additional display information
+ */
+export type SessionListItem = SessionMetadata & {
+    /** User identifier associated with this session */
+    userId?: string;
+    /** Total number of messages in this session */
+    messageCount: number;
+    /** Human-readable time since last activity (e.g., "2 hours ago") */
+    lastActive?: string;
+};
+/**
+ * Complete session export format for backup/analytics
+ * Contains full session data including all messages
+ */
+export type SessionExport = {
+    /** Session identifier */
+    sessionId: string;
+    /** Session title/description */
+    title?: string;
+    /** User identifier */
+    userId?: string;
+    /** When session was created (ISO 8601) */
+    createdAt: string;
+    /** When session was last updated (ISO 8601) */
+    updatedAt: string;
+    /** Complete message history */
+    messages: ChatMessage[];
+    /** Export metadata */
+    exportMetadata?: {
+        exportedAt: string;
+        exportFormat: "json" | "csv";
+        neuroLinkVersion?: string;
+    };
+};
 /**
  * Base conversation metadata (shared fields across all conversation types)
  * Contains essential conversation information without heavy data arrays

package/dist/lib/types/conversationMemoryInterface.d.ts

@@ -3,7 +3,7 @@
  * Both ConversationMemoryManager and RedisConversationMemoryManager
  * should implement this type.
  */
-import type { ChatMessage, ConversationMemoryConfig, ConversationMemoryStats, SessionMemory, StoreConversationTurnOptions } from "./conversation.js";
+import type { ChatMessage, ConversationMemoryConfig, ConversationMemoryStats, SessionListItem, SessionMemory, StoreConversationTurnOptions } from "./conversation.js";
 /**
  * Common type for all conversation memory manager implementations.
  * Provides a consistent API for storing, retrieving, and managing conversation history.
@@ -24,6 +24,10 @@ export type IConversationMemoryManager = {
     clearAllSessions(): Promise<void> | void;
     /** Get memory statistics */
     getStats(): Promise<ConversationMemoryStats> | ConversationMemoryStats;
+    /** List all sessions with metadata (optional - for session management) */
+    listSessions?(userId?: string): Promise<SessionListItem[]>;
+    /** List all sessions with metadata (optional - for session management) */
+    listSessions?(userId?: string): Promise<SessionListItem[]>;
     /** Get raw messages array for a session (no context filtering or summarization) */
     getSessionMessages(sessionId: string, userId?: string): Promise<ChatMessage[]>;
     /** Replace the entire messages array for a session */

package/dist/lib/utils/fileDetector.js

@@ -1823,23 +1823,47 @@ class ExtensionStrategy {
         };
     }
     getExtension(input) {
-        if (this.isURL(input)) {
-            const url = new URL(input);
-            const match = url.pathname.match(/\.([^.]+)$/);
-            return match ? match[1] : null;
+        const normalizedInput = input.trim();
+        let extensionSource = normalizedInput;
+        if (this.isURL(normalizedInput)) {
+            try {
+                const url = new URL(normalizedInput);
+                extensionSource = url.pathname;
+                try {
+                    extensionSource = decodeURIComponent(extensionSource);
+                }
+                catch {
+                    // Keep the original pathname if the URL contains malformed escapes.
+                }
+            }
+            catch {
+                extensionSource = normalizedInput;
+            }
         }
-        const match = input.match(/\.([^.]+)$/);
-        return match ? match[1] : null;
+        const match = extensionSource.trim().match(/\.([^.]+)$/);
+        if (!match) {
+            return null;
+        }
+        const ext = match[1].split(/[?#]/)[0].toLowerCase();
+        return /^[a-z0-9]+$/.test(ext) ? ext : null;
     }
     isURL(str) {
-        return str.startsWith("http://") || str.startsWith("https://");
+        const normalized = str.trim();
+        return (normalized.startsWith("http://") || normalized.startsWith("https://"));
     }
     detectSource(input) {
-        if (input.startsWith("data:")) {
+        const normalized = input.trim();
+        if (normalized.startsWith("data:")) {
             return "datauri";
         }
-        if (this.isURL(input)) {
-            return "url";
+        if (this.isURL(normalized)) {
+            try {
+                new URL(normalized);
+                return "url";
+            }
+            catch {
+                return "path";
+            }
         }
         return "path";
     }

package/dist/neurolink.d.ts

@@ -14,6 +14,7 @@ import { MCPToolRegistry } from "./mcp/toolRegistry.js";
 import type { DynamicOptions } from "./types/index.js";
 import { SkillsManager } from "./skills/skillsManager.js";
 import { TaskManager } from "./tasks/taskManager.js";
+import type { SessionExport, SessionListItem } from "./types/index.js";
 /**
  * Curator P2-4 dedup (concurrency-safe): native providers emit
  * `generation:end` on the shared SDK emitter. We attach a fresh
@@ -1631,6 +1632,32 @@ export declare class NeuroLink {
      * Clear all conversation history (public API)
      */
     clearAllConversations(): Promise<void>;
+    /**
+     * List all conversation sessions with metadata (public API)
+     * @param userId - Optional user ID to filter sessions (required for Redis storage)
+     * @returns Array of session list items with metadata
+     */
+    listSessions(userId?: string): Promise<SessionListItem[]>;
+    /**
+     * Export a single session with full history and metadata (public API)
+     * @param sessionId - The session ID to export
+     * @param options - Export options
+     * @returns Session export object with full history
+     */
+    exportSession(sessionId: string, options?: {
+        includeMetadata?: boolean;
+        format?: "json" | "csv";
+    }): Promise<SessionExport | null>;
+    /**
+     * Export all sessions for a user (public API)
+     * @param userId - Optional user ID (required for Redis storage)
+     * @param options - Export options
+     * @returns Array of session exports
+     */
+    exportAllSessions(userId?: string, options?: {
+        includeMetadata?: boolean;
+        format?: "json" | "csv";
+    }): Promise<SessionExport[]>;
     /**
      * Store tool executions in conversation memory if enabled and Redis is configured
      * @param sessionId - Session identifier