hammoc 1.0.0

package/packages/server/dist/services/sessionService.js

@@ -0,0 +1,672 @@
+/**
+ * Session Service for Session Management
+ * Story 1.6: Session Management
+ *
+ * Handles session persistence, retrieval, and listing
+ * from Claude Code's ~/.claude/projects/ directory structure
+ */
+import path from 'path';
+import os from 'os';
+import fs from 'fs/promises';
+import { existsSync } from 'fs';
+import { parseJSONLFile, sortMessagesByParentUuid, transformToHistoryMessages, cleanCommandTags, } from './historyParser.js';
+/**
+ * SessionService - Manages Claude Code session data
+ */
+export class SessionService {
+    claudeProjectsDir;
+    constructor() {
+        this.claudeProjectsDir = path.join(os.homedir(), '.claude', 'projects');
+    }
+    /**
+     * Encode a project path to Claude Code's directory format
+     * /Users/username/myproject -> -Users-username-myproject
+     * C:\Users\username\myproject -> C-Users-username-myproject
+     */
+    encodeProjectPath(projectPath) {
+        return projectPath.replace(/[/\\:]/g, '-').replace(/^-/, '');
+    }
+    /**
+     * Get the sessions directory for a project
+     */
+    getSessionsDir(projectPath) {
+        const encoded = this.encodeProjectPath(projectPath);
+        return path.join(this.claudeProjectsDir, encoded);
+    }
+    /**
+     * Get the sessions-index.json path for a project
+     */
+    getSessionsIndexPath(projectPath) {
+        return path.join(this.getSessionsDir(projectPath), 'sessions-index.json');
+    }
+    /**
+     * Save the current session ID for a project
+     * Note: This creates a simple tracking file, not modifying Claude's actual index
+     */
+    async saveSessionId(projectPath, sessionId) {
+        const sessionsDir = this.getSessionsDir(projectPath);
+        // Ensure directory exists
+        if (!existsSync(sessionsDir)) {
+            await fs.mkdir(sessionsDir, { recursive: true });
+        }
+        const trackingPath = path.join(sessionsDir, '.bmad-current-session');
+        await fs.writeFile(trackingPath, sessionId, 'utf-8');
+    }
+    /**
+     * Get the last used session ID for a project
+     */
+    async getSessionId(projectPath) {
+        const trackingPath = path.join(this.getSessionsDir(projectPath), '.bmad-current-session');
+        try {
+            const sessionId = await fs.readFile(trackingPath, 'utf-8');
+            return sessionId.trim() || null;
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * List all sessions for a project from sessions-index.json
+     */
+    async listSessions(projectPath) {
+        const indexPath = this.getSessionsIndexPath(projectPath);
+        try {
+            const content = await fs.readFile(indexPath, 'utf-8');
+            const index = JSON.parse(content);
+            if (!index.entries || !Array.isArray(index.entries)) {
+                return [];
+            }
+            const projectSlug = this.encodeProjectPath(projectPath);
+            return index.entries.map((entry) => ({
+                sessionId: entry.sessionId,
+                projectSlug,
+                firstPrompt: entry.firstPrompt,
+                messageCount: entry.messageCount,
+                created: new Date(entry.created),
+                modified: new Date(entry.modified),
+            }));
+        }
+        catch {
+            // File doesn't exist or is invalid
+            return [];
+        }
+    }
+    /**
+     * Check if a session exists in the sessions-index.json
+     */
+    async sessionExists(projectPath, sessionId) {
+        const sessions = await this.listSessions(projectPath);
+        return sessions.some((s) => s.sessionId === sessionId);
+    }
+    /**
+     * Get a specific session by ID
+     */
+    async getSession(projectPath, sessionId) {
+        const sessions = await this.listSessions(projectPath);
+        return sessions.find((s) => s.sessionId === sessionId) || null;
+    }
+    /**
+     * Validate session ID format (basic validation)
+     * Session IDs from Claude Code are typically alphanumeric with hyphens
+     */
+    isValidSessionId(sessionId) {
+        if (!sessionId || typeof sessionId !== 'string') {
+            return false;
+        }
+        // Allow alphanumeric characters, hyphens, and underscores
+        return /^[a-zA-Z0-9_-]+$/.test(sessionId);
+    }
+    // Story 3.3: Session List API methods
+    /**
+     * Get original project path from projectSlug
+     * @param projectSlug The folder name in ~/.claude/projects/
+     * @returns Original project path or null if not found
+     */
+    async getProjectPathBySlug(projectSlug) {
+        const projectDir = path.join(this.claudeProjectsDir, projectSlug);
+        const indexPath = path.join(projectDir, 'sessions-index.json');
+        try {
+            const content = await fs.readFile(indexPath, 'utf-8');
+            const index = JSON.parse(content);
+            return index.originalPath || null;
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * Truncate text to specified length with ellipsis
+     */
+    truncateFirstPrompt(text, maxLength = 100) {
+        if (!text)
+            return '';
+        const cleaned = cleanCommandTags(text);
+        if (!cleaned)
+            return '';
+        // Use first non-empty line as preview
+        const firstLine = cleaned.split('\n').find(line => line.trim())?.trim() || '';
+        if (!firstLine)
+            return '';
+        if (firstLine.length <= maxLength)
+            return firstLine;
+        return firstLine.slice(0, maxLength - 3) + '...';
+    }
+    /**
+     * Safely parse ISO date string for sorting
+     * Returns 0 for invalid dates to push them to the end
+     */
+    parseDate(dateStr) {
+        const timestamp = Date.parse(dateStr);
+        return isNaN(timestamp) ? 0 : timestamp;
+    }
+    /**
+     * Check if a session matches the search query by metadata
+     * Matches against session name, session ID, and firstPrompt (case-insensitive)
+     */
+    matchesMetadata(sessionId, firstPrompt, queryLower, sessionNames) {
+        if (sessionId.toLowerCase().includes(queryLower))
+            return true;
+        if (firstPrompt && firstPrompt.toLowerCase().includes(queryLower))
+            return true;
+        const name = sessionNames?.[sessionId];
+        if (name && name.toLowerCase().includes(queryLower))
+            return true;
+        return false;
+    }
+    /**
+     * Search JSONL file content for a query string
+     * Returns true on first match (early termination)
+     */
+    async searchFileContent(filePath, queryLower) {
+        try {
+            const rawMessages = await parseJSONLFile(filePath);
+            for (const msg of rawMessages) {
+                if (msg.type !== 'user' && msg.type !== 'assistant')
+                    continue;
+                const content = msg.message?.content;
+                if (typeof content === 'string') {
+                    if (content.toLowerCase().includes(queryLower))
+                        return true;
+                }
+                else if (Array.isArray(content)) {
+                    for (const block of content) {
+                        if (block.type === 'text' && 'text' in block && typeof block.text === 'string') {
+                            if (block.text.toLowerCase().includes(queryLower))
+                                return true;
+                        }
+                    }
+                }
+            }
+        }
+        catch {
+            // Skip unparseable files
+        }
+        return false;
+    }
+    /**
+     * Execute async tasks with bounded concurrency
+     */
+    async pMapWithLimit(items, fn, concurrency) {
+        const results = new Array(items.length);
+        let nextIndex = 0;
+        const worker = async () => {
+            while (nextIndex < items.length) {
+                const i = nextIndex++;
+                results[i] = await fn(items[i]);
+            }
+        };
+        await Promise.all(Array.from({ length: Math.min(concurrency, items.length) }, () => worker()));
+        return results;
+    }
+    /**
+     * List sessions for API response (by projectSlug)
+     * - Sorted by modified descending (AC 3)
+     * - firstPrompt truncated to 100 chars (AC 4)
+     * - Also scans for .jsonl files not yet in sessions-index.json
+     * - Supports search by query and content search (Story 23.1)
+     */
+    async listSessionsBySlug(projectSlug, params = {}) {
+        const { includeEmpty = false, limit = 0, offset = 0, query, searchContent, sessionNames } = params;
+        const queryLower = query?.toLowerCase();
+        const projectDir = path.join(this.claudeProjectsDir, projectSlug);
+        const indexPath = path.join(projectDir, 'sessions-index.json');
+        // Check if project directory exists
+        if (!existsSync(projectDir)) {
+            return null;
+        }
+        // Fast path: use index as metadata cache, stat for sort, parse only missing
+        if (limit > 0) {
+            try {
+                // Load sessions-index.json as metadata cache (non-blocking)
+                const indexMap = new Map();
+                try {
+                    const indexContent = await fs.readFile(indexPath, 'utf-8');
+                    const index = JSON.parse(indexContent);
+                    if (index.entries && Array.isArray(index.entries)) {
+                        for (const entry of index.entries) {
+                            indexMap.set(entry.sessionId, entry);
+                        }
+                    }
+                }
+                catch {
+                    // Index missing or invalid — will fall back to JSONL parsing
+                }
+                const files = await fs.readdir(projectDir);
+                const jsonlFiles = files.filter(f => f.endsWith('.jsonl'));
+                // Stat all files (cheap) to get modified time
+                const fileStats = await Promise.all(jsonlFiles.map(async (file) => {
+                    const stat = await fs.stat(path.join(projectDir, file));
+                    return { file, sessionId: file.replace('.jsonl', ''), stat };
+                }));
+                // Sort by mtime descending
+                fileStats.sort((a, b) => b.stat.mtimeMs - a.stat.mtimeMs);
+                // Pre-filter known-empty sessions from index cache when !includeEmpty
+                let candidates = fileStats;
+                if (!includeEmpty) {
+                    candidates = fileStats.filter(({ sessionId }) => {
+                        const cached = indexMap.get(sessionId);
+                        // If cached and firstPrompt is empty, exclude
+                        if (cached && !cached.firstPrompt)
+                            return false;
+                        return true; // Include cache misses — will filter after resolution
+                    });
+                }
+                // Apply search filter BEFORE pagination
+                if (queryLower) {
+                    // Resolve first prompts for cache-miss sessions before metadata filtering
+                    const cacheMisses = candidates.filter(({ sessionId }) => !indexMap.has(sessionId));
+                    if (cacheMisses.length > 0) {
+                        await this.pMapWithLimit(cacheMisses, async ({ file, sessionId }) => {
+                            try {
+                                const rawMessages = await parseJSONLFile(path.join(projectDir, file));
+                                const userMessage = rawMessages.find(m => m.type === 'user');
+                                const content = userMessage?.message?.content;
+                                let rawText = '';
+                                if (typeof content === 'string') {
+                                    rawText = content;
+                                }
+                                else if (Array.isArray(content)) {
+                                    const textBlock = content
+                                        .filter((b) => b.type === 'text')
+                                        .find((b) => 'text' in b && typeof b.text === 'string' && cleanCommandTags(b.text).trim());
+                                    if (textBlock && 'text' in textBlock) {
+                                        rawText = textBlock.text;
+                                    }
+                                }
+                                indexMap.set(sessionId, {
+                                    sessionId,
+                                    firstPrompt: rawText,
+                                    messageCount: rawMessages.filter(m => m.type === 'user' || m.type === 'assistant').length,
+                                    created: '',
+                                    modified: '',
+                                });
+                            }
+                            catch {
+                                // Skip unparseable files — treated as empty firstPrompt
+                            }
+                        }, 8);
+                    }
+                    const metadataMatched = new Set();
+                    const metadataFiltered = candidates.filter(({ sessionId }) => {
+                        const cached = indexMap.get(sessionId);
+                        const firstPrompt = cached?.firstPrompt || '';
+                        if (this.matchesMetadata(sessionId, firstPrompt, queryLower, sessionNames)) {
+                            metadataMatched.add(sessionId);
+                            return true;
+                        }
+                        return false;
+                    });
+                    if (searchContent) {
+                        // Content search for sessions not already matched by metadata (cap at 100)
+                        const unmatchedCandidates = candidates
+                            .filter(({ sessionId }) => !metadataMatched.has(sessionId))
+                            .slice(0, 100);
+                        const contentMatched = await this.pMapWithLimit(unmatchedCandidates, async (entry) => {
+                            const matched = await this.searchFileContent(path.join(projectDir, entry.file), queryLower);
+                            return matched ? entry : null;
+                        }, 8);
+                        const contentHits = contentMatched.filter((e) => e !== null);
+                        candidates = [...metadataFiltered, ...contentHits];
+                        // Re-sort after merging
+                        candidates.sort((a, b) => b.stat.mtimeMs - a.stat.mtimeMs);
+                    }
+                    else {
+                        candidates = metadataFiltered;
+                    }
+                }
+                const topFiles = candidates.slice(offset, offset + limit);
+                // Resolve metadata: use index cache when available, parse JSONL only for misses (in parallel)
+                const sessions = (await Promise.all(topFiles.map(async ({ file, sessionId, stat }) => {
+                    const cached = indexMap.get(sessionId);
+                    if (cached) {
+                        return {
+                            sessionId,
+                            firstPrompt: this.truncateFirstPrompt(cached.firstPrompt),
+                            messageCount: cached.messageCount,
+                            created: stat.birthtime.toISOString(),
+                            modified: stat.mtime.toISOString(),
+                        };
+                    }
+                    // Cache miss — parse JSONL
+                    try {
+                        const rawMessages = await parseJSONLFile(path.join(projectDir, file));
+                        const userMessage = rawMessages.find(m => m.type === 'user');
+                        const content = userMessage?.message?.content;
+                        let rawText = null;
+                        if (typeof content === 'string') {
+                            rawText = content;
+                        }
+                        else if (Array.isArray(content)) {
+                            const textBlock = content
+                                .filter((b) => b.type === 'text')
+                                .find((b) => 'text' in b && cleanCommandTags(b.text).trim());
+                            if (textBlock && 'text' in textBlock) {
+                                rawText = textBlock.text;
+                            }
+                        }
+                        // Filter empty sessions for cache misses when !includeEmpty
+                        if (!includeEmpty && !rawText)
+                            return null;
+                        return {
+                            sessionId,
+                            firstPrompt: rawText ? this.truncateFirstPrompt(rawText) : '',
+                            messageCount: rawMessages.filter(m => m.type === 'user' || m.type === 'assistant').length,
+                            created: stat.birthtime.toISOString(),
+                            modified: stat.mtime.toISOString(),
+                        };
+                    }
+                    catch {
+                        return null; // Skip unparseable files
+                    }
+                }))).filter((s) => s !== null);
+                return { sessions, total: candidates.length };
+            }
+            catch {
+                return { sessions: [], total: 0 };
+            }
+        }
+        // Full path: build complete session map from index + file scan
+        const sessionMap = new Map();
+        // Keep raw firstPrompt (full text) for search matching
+        const rawFirstPromptMap = new Map();
+        try {
+            const content = await fs.readFile(indexPath, 'utf-8');
+            const index = JSON.parse(content);
+            if (index.entries && Array.isArray(index.entries)) {
+                for (const entry of index.entries) {
+                    rawFirstPromptMap.set(entry.sessionId, entry.firstPrompt);
+                    sessionMap.set(entry.sessionId, {
+                        sessionId: entry.sessionId,
+                        firstPrompt: this.truncateFirstPrompt(entry.firstPrompt),
+                        messageCount: entry.messageCount,
+                        created: entry.created,
+                        modified: entry.modified,
+                    });
+                }
+            }
+        }
+        catch {
+            // Index file doesn't exist or is invalid - continue with file scan
+        }
+        // Scan for .jsonl files not in index (SDK may not have updated index yet)
+        try {
+            const files = await fs.readdir(projectDir);
+            const jsonlFiles = files.filter(f => f.endsWith('.jsonl'));
+            for (const file of jsonlFiles) {
+                const sessionId = file.replace('.jsonl', '');
+                if (!sessionMap.has(sessionId)) {
+                    const filePath = path.join(projectDir, file);
+                    const stat = await fs.stat(filePath);
+                    try {
+                        const rawMessages = await parseJSONLFile(filePath);
+                        const userMessage = rawMessages.find(m => m.type === 'user');
+                        if (userMessage) {
+                            const content = userMessage.message?.content;
+                            let rawText = null;
+                            if (typeof content === 'string') {
+                                rawText = content;
+                            }
+                            else if (Array.isArray(content)) {
+                                const textBlock = content
+                                    .filter((b) => b.type === 'text')
+                                    .find((b) => 'text' in b && cleanCommandTags(b.text).trim());
+                                if (textBlock && 'text' in textBlock) {
+                                    rawText = textBlock.text;
+                                }
+                            }
+                            const firstPrompt = rawText ? this.truncateFirstPrompt(rawText) : null;
+                            if (rawText || includeEmpty) {
+                                if (rawText)
+                                    rawFirstPromptMap.set(sessionId, rawText);
+                                sessionMap.set(sessionId, {
+                                    sessionId,
+                                    firstPrompt: firstPrompt || '',
+                                    messageCount: rawMessages.filter(m => m.type === 'user' || m.type === 'assistant').length,
+                                    created: stat.birthtime.toISOString(),
+                                    modified: stat.mtime.toISOString(),
+                                });
+                            }
+                        }
+                        else if (includeEmpty) {
+                            sessionMap.set(sessionId, {
+                                sessionId,
+                                firstPrompt: '',
+                                messageCount: 0,
+                                created: stat.birthtime.toISOString(),
+                                modified: stat.mtime.toISOString(),
+                            });
+                        }
+                    }
+                    catch {
+                        if (includeEmpty) {
+                            sessionMap.set(sessionId, {
+                                sessionId,
+                                firstPrompt: '',
+                                messageCount: 0,
+                                created: stat.birthtime.toISOString(),
+                                modified: stat.mtime.toISOString(),
+                            });
+                        }
+                    }
+                }
+            }
+        }
+        catch {
+            // Failed to read directory - return what we have from index
+        }
+        if (sessionMap.size === 0) {
+            return { sessions: [], total: 0 };
+        }
+        // Sort by modified descending (AC 3)
+        let sorted = [...sessionMap.values()].sort((a, b) => this.parseDate(b.modified) - this.parseDate(a.modified));
+        // Apply search filter for full path
+        if (queryLower) {
+            const metadataMatched = new Set();
+            const metadataFiltered = sorted.filter((s) => {
+                const rawPrompt = rawFirstPromptMap.get(s.sessionId) || '';
+                if (this.matchesMetadata(s.sessionId, rawPrompt, queryLower, sessionNames)) {
+                    metadataMatched.add(s.sessionId);
+                    return true;
+                }
+                return false;
+            });
+            if (searchContent) {
+                // Content search for sessions not already matched (cap at 100)
+                const unmatched = sorted
+                    .filter((s) => !metadataMatched.has(s.sessionId))
+                    .slice(0, 100);
+                const contentHits = [];
+                for (const s of unmatched) {
+                    const filePath = path.join(projectDir, `${s.sessionId}.jsonl`);
+                    const matched = await this.searchFileContent(filePath, queryLower);
+                    if (matched)
+                        contentHits.push(s);
+                }
+                sorted = [...metadataFiltered, ...contentHits];
+                sorted.sort((a, b) => this.parseDate(b.modified) - this.parseDate(a.modified));
+            }
+            else {
+                sorted = metadataFiltered;
+            }
+        }
+        return { sessions: sorted, total: sorted.length };
+    }
+    // Session deletion methods
+    /**
+     * Remove a session entry from sessions-index.json
+     */
+    async removeFromSessionsIndex(projectSlug, sessionId) {
+        const indexPath = path.join(this.claudeProjectsDir, projectSlug, 'sessions-index.json');
+        try {
+            const content = await fs.readFile(indexPath, 'utf-8');
+            const index = JSON.parse(content);
+            const before = index.entries.length;
+            index.entries = index.entries.filter(e => e.sessionId !== sessionId);
+            if (index.entries.length < before) {
+                await fs.writeFile(indexPath, JSON.stringify(index, null, 2), 'utf-8');
+            }
+        }
+        catch {
+            // Index file doesn't exist or is invalid - skip
+        }
+    }
+    /**
+     * Remove multiple session entries from sessions-index.json in one write
+     */
+    async removeMultipleFromSessionsIndex(projectSlug, sessionIds) {
+        const indexPath = path.join(this.claudeProjectsDir, projectSlug, 'sessions-index.json');
+        try {
+            const content = await fs.readFile(indexPath, 'utf-8');
+            const index = JSON.parse(content);
+            const before = index.entries.length;
+            index.entries = index.entries.filter(e => !sessionIds.has(e.sessionId));
+            if (index.entries.length < before) {
+                await fs.writeFile(indexPath, JSON.stringify(index, null, 2), 'utf-8');
+            }
+        }
+        catch {
+            // Index file doesn't exist or is invalid - skip
+        }
+    }
+    /**
+     * Delete a single session (.jsonl file + index entry)
+     */
+    async deleteSession(projectSlug, sessionId) {
+        const filePath = this.getSessionFilePath(projectSlug, sessionId);
+        await fs.unlink(filePath);
+        await this.removeFromSessionsIndex(projectSlug, sessionId);
+    }
+    /**
+     * Delete multiple sessions (batch)
+     * Returns count of successfully deleted and failed sessions
+     */
+    async deleteSessions(projectSlug, sessionIds) {
+        let deleted = 0;
+        let failed = 0;
+        const deletedIds = new Set();
+        for (const sessionId of sessionIds) {
+            if (!this.isValidPathParam(sessionId)) {
+                failed++;
+                continue;
+            }
+            try {
+                const filePath = this.getSessionFilePath(projectSlug, sessionId);
+                await fs.unlink(filePath);
+                deleted++;
+                deletedIds.add(sessionId);
+            }
+            catch {
+                failed++;
+            }
+        }
+        // Remove all deleted sessions from index in one write
+        if (deletedIds.size > 0) {
+            await this.removeMultipleFromSessionsIndex(projectSlug, deletedIds);
+        }
+        return { deleted, failed };
+    }
+    // Story 3.5: Session History Loading methods
+    /**
+     * Get the JSONL file path for a session
+     * Claude Code stores session files directly in the project folder (not in a sessions subfolder)
+     * @param projectSlug The project slug
+     * @param sessionId The session ID
+     * @returns Full path to the JSONL session file
+     */
+    getSessionFilePath(projectSlug, sessionId) {
+        return path.join(this.claudeProjectsDir, projectSlug, `${sessionId}.jsonl`);
+    }
+    /**
+     * Check if a session file exists
+     * @param projectSlug The project slug
+     * @param sessionId The session ID
+     * @returns true if the session file exists
+     */
+    sessionFileExists(projectSlug, sessionId) {
+        const filePath = this.getSessionFilePath(projectSlug, sessionId);
+        return existsSync(filePath);
+    }
+    /**
+     * Validate path parameter to prevent path traversal attacks
+     * @param param The path parameter to validate
+     * @returns true if the parameter is safe
+     */
+    isValidPathParam(param) {
+        // Reject if contains path traversal sequences
+        if (param.includes('..') || param.includes('/') || param.includes('\\')) {
+            return false;
+        }
+        // Reject if contains null bytes or other dangerous characters
+        if (param.includes('\0') || param.includes('%00')) {
+            return false;
+        }
+        // Only allow alphanumeric, hyphens, and underscores
+        return /^[a-zA-Z0-9_-]+$/.test(param);
+    }
+    /**
+     * Get session messages with pagination
+     * @param projectSlug The project slug
+     * @param sessionId The session ID
+     * @param options Pagination options (limit, offset)
+     * @returns Messages with pagination info, or null if session not found
+     */
+    async getSessionMessages(projectSlug, sessionId, options = {}) {
+        const { limit = 50, offset = 0 } = options;
+        const filePath = this.getSessionFilePath(projectSlug, sessionId);
+        if (!existsSync(filePath)) {
+            return null;
+        }
+        const rawMessages = await parseJSONLFile(filePath);
+        const sorted = sortMessagesByParentUuid(rawMessages);
+        const transformed = transformToHistoryMessages(sorted);
+        const total = transformed.length;
+        // Chat UI: Load from the END (most recent messages first)
+        // offset=0 means "most recent N messages"
+        // offset=50 means "skip 50 most recent, get next N older messages"
+        const startIndex = Math.max(0, total - offset - limit);
+        const endIndex = Math.max(0, total - offset);
+        const paginated = transformed.slice(startIndex, endIndex);
+        // Scan full message list (reverse) for last slash command in user messages
+        // Used by client to detect active agent even when first message is not loaded
+        let lastAgentCommand = null;
+        for (let i = transformed.length - 1; i >= 0; i--) {
+            if (transformed[i].type === 'user' && transformed[i].content.startsWith('/')) {
+                lastAgentCommand = transformed[i].content;
+                break;
+            }
+        }
+        return {
+            messages: paginated,
+            pagination: {
+                total,
+                limit,
+                offset,
+                hasMore: startIndex > 0, // There are older messages to load
+            },
+            lastAgentCommand,
+        };
+    }
+}
+// Singleton export for controllers (Story 3.3)
+export const sessionService = new SessionService();
+//# sourceMappingURL=sessionService.js.map