cc-control-agent 2.0.0

package/dist/session/claude-monitor.js

@@ -0,0 +1,770 @@
+// ============================================================================
+// Claude Code Session Monitor - Monitors Real Claude Code Sessions
+// ============================================================================
+import { watch } from "chokidar";
+import { promises as fs } from "fs";
+import { join } from "path";
+import { logger } from "../utils/logger.js";
+export class ClaudeSessionMonitor {
+    wsClient;
+    watcher = null;
+    sessionCache = new Map();
+    debounceTimer = new Map();
+    periodicSyncTimer = null;
+    claudePath;
+    projectsPath;
+    deviceId;
+    constructor(wsClient, deviceId, claudePath = `${process.env.HOME}/.claude`) {
+        this.wsClient = wsClient;
+        this.deviceId = deviceId;
+        this.claudePath = claudePath;
+        this.projectsPath = join(claudePath, "projects");
+    }
+    async start() {
+        try {
+            logger.info(`Starting Claude Code session monitor for: ${this.projectsPath}`);
+            // Ensure projects directory exists
+            await fs.mkdir(this.projectsPath, { recursive: true });
+            // Initialize session cache from existing projects
+            await this.initializeSessionCache();
+            // Watch all project directories
+            this.watcher = watch(this.projectsPath, {
+                ignored: /(^|[\/\\])\../,
+                persistent: true,
+                ignoreInitial: true, // Don't fire for existing files (we already loaded them)
+                depth: 2,
+                // Use polling on macOS for reliability with frequently-written files
+                usePolling: true,
+                interval: 2000, // Check every 2 seconds
+            });
+            // Watch for changes
+            this.watcher
+                .on("add", (path) => {
+                logger.info(`[Watcher] File added: ${path.split("/").pop()}`);
+                this.handleFileChange("add", path);
+            })
+                .on("change", (path) => {
+                logger.info(`[Watcher] File changed: ${path.split("/").pop()}`);
+                this.handleFileChange("change", path);
+            })
+                .on("unlink", (path) => this.handleFileChange("unlink", path))
+                .on("error", (error) => logger.error("Watcher error", error))
+                .on("ready", () => {
+                logger.info("Claude Code session watcher ready");
+                logger.info(`Monitoring ${this.sessionCache.size} sessions`);
+            });
+            // Periodic re-sync: scan for recently modified sessions every 30 seconds
+            this.periodicSyncTimer = setInterval(() => this.periodicSync(), 30000);
+            logger.info("Claude Code session monitor started");
+        }
+        catch (error) {
+            logger.error("Failed to start Claude Code session monitor", error);
+            throw error;
+        }
+    }
+    async initializeSessionCache() {
+        try {
+            // List all project directories
+            const projects = await fs.readdir(this.projectsPath);
+            for (const project of projects) {
+                const projectDir = join(this.projectsPath, project);
+                // Check if it's a directory
+                try {
+                    const stat = await fs.stat(projectDir);
+                    if (!stat.isDirectory())
+                        continue;
+                }
+                catch {
+                    continue;
+                }
+                // First, try to read sessions-index.json
+                const indexPath = join(projectDir, "sessions-index.json");
+                try {
+                    await fs.access(indexPath);
+                    await this.processSessionIndex(indexPath, false);
+                }
+                catch {
+                    // No index, that's OK - we'll find JSONL files directly
+                }
+                // Then scan for .jsonl files NOT already in cache
+                await this.scanForJsonlFiles(projectDir, false);
+            }
+            logger.info(`Initialized session cache with ${this.sessionCache.size} sessions`);
+        }
+        catch (error) {
+            logger.error("Failed to initialize session cache", error);
+        }
+    }
+    /**
+     * Scan a project directory for .jsonl session files not in cache
+     */
+    async scanForJsonlFiles(projectDir, sendUpdates = true) {
+        try {
+            const files = await fs.readdir(projectDir);
+            // Derive projectPath from the directory name
+            // Directory name is the encoded path like "-Users-Krunal-Desktop-Projects-..."
+            const dirName = projectDir.split("/").pop() || "";
+            const projectPath = dirName.startsWith("-")
+                ? "/" + dirName.slice(1).replace(/-/g, "/")
+                : dirName;
+            for (const file of files) {
+                if (!file.endsWith(".jsonl"))
+                    continue;
+                const sessionId = file.replace(".jsonl", "");
+                // Only process UUID-format session IDs
+                if (!/^[a-f0-9-]{36}$/.test(sessionId))
+                    continue;
+                // Skip if already cached
+                if (this.sessionCache.has(sessionId))
+                    continue;
+                const filePath = join(projectDir, file);
+                try {
+                    const session = await this.parseSessionFromFile(sessionId, filePath, projectPath);
+                    if (session) {
+                        this.sessionCache.set(sessionId, session);
+                        logger.debug(`Discovered session from JSONL: ${sessionId}`, {
+                            messageCount: session.messages.length,
+                            project: projectPath,
+                        });
+                        if (sendUpdates) {
+                            this.sendSessionUpdate(sessionId, session);
+                        }
+                    }
+                }
+                catch (error) {
+                    logger.error(`Failed to parse JSONL session ${sessionId}`, error);
+                }
+            }
+        }
+        catch (error) {
+            logger.error(`Failed to scan for JSONL files in ${projectDir}`, error);
+        }
+    }
+    /**
+     * Look up customTitle from JSONL lines and sessions-index.json.
+     * JSONL has {"type":"custom-title","customTitle":"..."} entries written by /rename.
+     */
+    lookupCustomTitleFromLines(lines) {
+        // Scan backwards (most recent rename wins)
+        for (let i = lines.length - 1; i >= 0; i--) {
+            try {
+                const parsed = JSON.parse(lines[i]);
+                if (parsed.type === "custom-title" && parsed.customTitle) {
+                    // Clean up: take first line only, trim whitespace
+                    return parsed.customTitle.split("\n")[0].trim();
+                }
+            }
+            catch { /* ignore */ }
+        }
+        return undefined;
+    }
+    async lookupCustomTitleFromIndex(sessionId, filePath) {
+        try {
+            const dir = filePath.substring(0, filePath.lastIndexOf("/"));
+            const indexPath = join(dir, "sessions-index.json");
+            const content = await fs.readFile(indexPath, "utf-8");
+            const index = JSON.parse(content);
+            const entry = index.entries.find(e => e.sessionId === sessionId);
+            return entry?.customTitle;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    /**
+     * Parse a session directly from a JSONL file (no index entry needed)
+     */
+    async parseSessionFromFile(sessionId, filePath, projectPath) {
+        try {
+            const content = await fs.readFile(filePath, "utf-8");
+            const lines = content.split("\n").filter(line => line.trim().length > 0);
+            if (lines.length === 0)
+                return null;
+            const messages = await this.parseMessages(lines, sessionId);
+            // Get file stat for timestamps
+            const fileStat = await fs.stat(filePath);
+            // Extract first prompt and summary from messages
+            const firstUserMsg = messages.find(m => m.role === "user");
+            const firstPrompt = firstUserMsg?.content?.slice(0, 200) || "";
+            // Parse first few messages for cwd info
+            let cwd = projectPath;
+            for (let i = 0; i < Math.min(5, lines.length); i++) {
+                try {
+                    const parsed = JSON.parse(lines[i]);
+                    if (parsed.cwd) {
+                        cwd = parsed.cwd;
+                        break;
+                    }
+                }
+                catch { /* ignore */ }
+            }
+            // Look up customTitle: first from JSONL (type: "custom-title"), then from index
+            const customTitle = this.lookupCustomTitleFromLines(lines)
+                || await this.lookupCustomTitleFromIndex(sessionId, filePath);
+            // Determine status based on file modification time and message history
+            const status = this.calculateStatusFromMessages(messages, fileStat.mtime);
+            const session = {
+                id: sessionId,
+                deviceId: this.deviceId,
+                status,
+                messages,
+                filesAccessed: [],
+                lastActivity: fileStat.mtime,
+                createdAt: fileStat.birthtime || fileStat.mtime,
+                metadata: {
+                    workingDirectory: cwd,
+                    claudeVersion: "unknown",
+                    summary: firstPrompt.slice(0, 100),
+                    firstPrompt,
+                    customTitle,
+                    messageCount: messages.length,
+                },
+            };
+            return session;
+        }
+        catch (error) {
+            logger.error(`Failed to parse session from file ${filePath}`, error);
+            return null;
+        }
+    }
+    async sendAllSessionsToRelay() {
+        if (!this.wsClient.isConnected()) {
+            logger.warn("WebSocket not connected, cannot send sessions");
+            return;
+        }
+        // Sort sessions by lastActivity descending (latest first)
+        const sortedSessions = Array.from(this.sessionCache.entries())
+            .sort(([, a], [, b]) => b.lastActivity.getTime() - a.lastActivity.getTime());
+        const totalSessions = sortedSessions.length;
+        logger.info(`Syncing ${totalSessions} sessions to relay server in batches...`);
+        // Send in batches of 10 with delay between batches
+        const BATCH_SIZE = 10;
+        const BATCH_DELAY_MS = 500;
+        let successCount = 0;
+        for (let i = 0; i < sortedSessions.length; i += BATCH_SIZE) {
+            if (!this.wsClient.isConnected()) {
+                logger.warn("WebSocket disconnected during sync, stopping");
+                break;
+            }
+            const batch = sortedSessions.slice(i, i + BATCH_SIZE);
+            const lightweightSessions = batch.map(([, session]) => {
+                const msgs = session.messages || [];
+                const lastMsg = msgs[msgs.length - 1];
+                const lastMessage = lastMsg
+                    ? {
+                        role: lastMsg.role,
+                        content: lastMsg.content?.slice(0, 200) || "",
+                        timestamp: lastMsg.timestamp,
+                    }
+                    : undefined;
+                // Last 30 messages with content truncated for DB storage
+                const recentMessages = msgs.slice(-30).map(m => ({
+                    id: m.id,
+                    sessionId: m.sessionId,
+                    role: m.role,
+                    content: m.content?.slice(0, 2000) || "",
+                    timestamp: m.timestamp,
+                    metadata: m.metadata,
+                    toolCalls: m.toolCalls?.map(tc => ({
+                        ...tc,
+                        result: typeof tc.result === "string" ? tc.result.slice(0, 1500) : tc.result,
+                    })),
+                }));
+                return {
+                    id: session.id,
+                    sessionId: session.id,
+                    deviceId: this.deviceId,
+                    status: this.calculateStatusFromMessages(msgs, session.lastActivity),
+                    metadata: session.metadata,
+                    lastActivity: session.lastActivity,
+                    createdAt: session.createdAt,
+                    messageCount: msgs.length || session.metadata?.messageCount || 0,
+                    workingDirectory: session.metadata?.workingDirectory,
+                    projectName: session.metadata?.customTitle || session.metadata?.project,
+                    summary: session.metadata?.summary,
+                    firstPrompt: session.metadata?.firstPrompt,
+                    lastMessage,
+                    recentMessages,
+                };
+            });
+            try {
+                this.wsClient.send({
+                    type: "sessions:sync",
+                    payload: { sessions: lightweightSessions },
+                });
+                successCount += batch.length;
+                logger.info(`Batch ${Math.floor(i / BATCH_SIZE) + 1}: sent ${batch.length} sessions (${successCount}/${totalSessions})`);
+            }
+            catch (error) {
+                logger.error(`Batch sync failed at offset ${i}`, error);
+            }
+            // Wait between batches to avoid overwhelming the socket
+            if (i + BATCH_SIZE < sortedSessions.length) {
+                await new Promise(resolve => setTimeout(resolve, BATCH_DELAY_MS));
+            }
+        }
+        logger.info(`Session sync complete: ${successCount}/${totalSessions} sent`);
+    }
+    async sendInitialSessions(limit = 10) {
+        if (!this.wsClient.isConnected()) {
+            logger.warn("WebSocket not connected, cannot send sessions");
+            return;
+        }
+        const sessions = Array.from(this.sessionCache.entries()).slice(0, limit);
+        logger.info(`Sending initial ${sessions.length} sessions to relay server...`);
+        let sentCount = 0;
+        for (const [sessionId, session] of sessions) {
+            this.sendSessionUpdate(sessionId, session);
+            sentCount++;
+            // Longer delay to avoid overwhelming the socket
+            await new Promise(resolve => setTimeout(resolve, 200));
+        }
+        logger.info(`Sent ${sentCount} initial sessions to relay server`);
+    }
+    handleFileChange(event, path) {
+        // Process sessions-index.json files
+        if (path.endsWith("sessions-index.json")) {
+            this.debounce("index", path, async () => {
+                await this.processSessionIndex(path);
+            });
+            return;
+        }
+        // Process .jsonl session files
+        if (path.endsWith(".jsonl")) {
+            this.debounce("session", path, async () => {
+                await this.processSessionFile(path);
+            });
+            return;
+        }
+    }
+    debounce(type, key, fn) {
+        const debounceKey = `${type}:${key}`;
+        const existingTimer = this.debounceTimer.get(debounceKey);
+        if (existingTimer) {
+            clearTimeout(existingTimer);
+        }
+        const timer = setTimeout(async () => {
+            try {
+                await fn();
+            }
+            catch (error) {
+                logger.error(`Debounced function failed for ${debounceKey}`, error);
+            }
+            finally {
+                this.debounceTimer.delete(debounceKey);
+            }
+        }, 500); // 500ms debounce
+        this.debounceTimer.set(debounceKey, timer);
+    }
+    async processSessionIndex(indexPath, sendUpdates = true) {
+        try {
+            const content = await fs.readFile(indexPath, "utf-8");
+            const index = JSON.parse(content);
+            logger.debug(`Processing session index: ${indexPath}`, {
+                entries: index.entries.length,
+            });
+            // Process each session in the index
+            for (const entry of index.entries) {
+                try {
+                    // Read the session JSONL file
+                    const sessionContent = await fs.readFile(entry.fullPath, "utf-8");
+                    const session = await this.parseSession(entry, sessionContent);
+                    if (session) {
+                        // Check if session changed
+                        const cached = this.sessionCache.get(session.id);
+                        const hasChanged = !cached ||
+                            JSON.stringify(cached.messages) !== JSON.stringify(session.messages);
+                        if (hasChanged) {
+                            this.sessionCache.set(session.id, session);
+                            logger.debug(`Session updated: ${session.id}`, {
+                                messageCount: session.messages.length,
+                                summary: session.metadata?.summary,
+                            });
+                            // Send update to relay server only if requested
+                            if (sendUpdates) {
+                                this.sendSessionUpdate(session.id, session);
+                            }
+                        }
+                    }
+                }
+                catch (error) {
+                    logger.error(`Failed to process session ${entry.sessionId}`, error);
+                }
+            }
+        }
+        catch (error) {
+            logger.error(`Failed to process session index: ${indexPath}`, error);
+        }
+    }
+    async processSessionFile(sessionPath) {
+        try {
+            const content = await fs.readFile(sessionPath, "utf-8");
+            const lines = content.split("\n").filter(line => line.trim().length > 0);
+            // Extract session ID from path
+            const sessionId = this.extractSessionId(sessionPath);
+            if (!sessionId)
+                return;
+            // Get cached session - if not cached, create from file
+            let cached = this.sessionCache.get(sessionId);
+            if (!cached) {
+                // Derive project path from the parent directory name
+                const dirName = sessionPath.split("/").slice(-2, -1)[0] || "";
+                const projectPath = dirName.startsWith("-")
+                    ? "/" + dirName.slice(1).replace(/-/g, "/")
+                    : dirName;
+                const parsed = await this.parseSessionFromFile(sessionId, sessionPath, projectPath);
+                if (!parsed)
+                    return;
+                cached = parsed;
+                this.sessionCache.set(sessionId, cached);
+                logger.info(`New session discovered: ${sessionId}`);
+                this.sendSessionUpdate(sessionId, cached);
+                return;
+            }
+            // Parse messages from JSONL
+            const messages = await this.parseMessages(lines, sessionId);
+            // Check if messages changed (compare count for performance)
+            const hasChanged = cached.messages.length !== messages.length ||
+                (messages.length > 0 && cached.messages.length > 0 &&
+                    messages[messages.length - 1]?.id !== cached.messages[cached.messages.length - 1]?.id);
+            // Also refresh customTitle from JSONL lines or index (user may have renamed)
+            const customTitle = this.lookupCustomTitleFromLines(lines)
+                || await this.lookupCustomTitleFromIndex(sessionId, sessionPath);
+            const titleChanged = !!customTitle && cached.metadata?.customTitle !== customTitle;
+            if (titleChanged && cached.metadata) {
+                cached.metadata.customTitle = customTitle;
+            }
+            if (hasChanged || titleChanged) {
+                cached.messages = messages;
+                cached.lastActivity = new Date();
+                cached.status = this.calculateStatusFromMessages(messages, new Date());
+                cached.deviceId = this.deviceId;
+                if (cached.metadata) {
+                    cached.metadata.messageCount = messages.length;
+                }
+                this.sessionCache.set(sessionId, cached);
+                this.sendSessionUpdate(sessionId, cached);
+                logger.debug(`Session file updated: ${sessionId}`, {
+                    messageCount: messages.length,
+                    status: cached.status,
+                });
+            }
+        }
+        catch (error) {
+            logger.error(`Failed to process session file: ${sessionPath}`, error);
+        }
+    }
+    async parseSession(entry, content) {
+        try {
+            const lines = content.split("\n").filter(line => line.trim().length > 0);
+            const messages = await this.parseMessages(lines, entry.sessionId);
+            // Use actual file modification time for accurate status (index timestamps can be stale)
+            let lastModified;
+            try {
+                const fileStat = await fs.stat(entry.fullPath);
+                lastModified = fileStat.mtime;
+            }
+            catch {
+                lastModified = new Date(entry.modified);
+            }
+            const status = this.calculateStatusFromMessages(messages, lastModified);
+            const session = {
+                id: entry.sessionId,
+                deviceId: this.deviceId,
+                status,
+                messages,
+                filesAccessed: [],
+                lastActivity: lastModified,
+                createdAt: new Date(entry.created),
+                metadata: {
+                    workingDirectory: entry.projectPath,
+                    claudeVersion: "unknown",
+                    summary: entry.summary,
+                    firstPrompt: entry.firstPrompt,
+                    customTitle: entry.customTitle,
+                    messageCount: entry.messageCount || messages.length,
+                },
+            };
+            return session;
+        }
+        catch (error) {
+            logger.error(`Failed to parse session ${entry.sessionId}`, error);
+            return null;
+        }
+    }
+    /**
+     * Calculate session status based on last modification time and message history.
+     * - If file not modified in >5 minutes -> "idle"
+     * - If last message role is "assistant" -> "waiting_input" (Claude finished, waiting for user)
+     * - If last message role is "user" -> "processing" (Claude is working)
+     * - Default -> "processing"
+     */
+    calculateStatusFromMessages(messages, lastModified) {
+        const IDLE_THRESHOLD = 5 * 60 * 1000;
+        const timeSinceModified = Date.now() - lastModified.getTime();
+        if (timeSinceModified > IDLE_THRESHOLD)
+            return "idle";
+        const lastMsg = messages[messages.length - 1];
+        if (!lastMsg)
+            return "processing";
+        // Assistant spoke last = waiting for user input
+        if (lastMsg.role === "assistant")
+            return "waiting_input";
+        // User spoke last = Claude is processing
+        return "processing";
+    }
+    /**
+     * Backward-compatible status calculation when messages are not available.
+     */
+    calculateStatus(lastModified) {
+        return this.calculateStatusFromMessages([], lastModified);
+    }
+    async parseMessages(lines, sessionId) {
+        const messages = [];
+        // Pass 1: Collect tool_result content keyed by tool_use_id
+        const toolResultMap = new Map();
+        for (const line of lines) {
+            try {
+                const parsed = JSON.parse(line);
+                if (!parsed.message || parsed.type === "file-history-snapshot")
+                    continue;
+                if (!Array.isArray(parsed.message.content))
+                    continue;
+                for (const block of parsed.message.content) {
+                    if (block.type === "tool_result" && block.tool_use_id) {
+                        let resultText = "";
+                        if (typeof block.content === "string") {
+                            resultText = block.content;
+                        }
+                        else if (Array.isArray(block.content)) {
+                            resultText = block.content
+                                .filter((c) => c.type === "text")
+                                .map((c) => c.text)
+                                .join("\n");
+                        }
+                        toolResultMap.set(block.tool_use_id, resultText);
+                    }
+                }
+            }
+            catch {
+                continue;
+            }
+        }
+        // Pass 2: Build messages with structured toolCalls
+        for (const line of lines) {
+            try {
+                const parsed = JSON.parse(line);
+                if (!parsed.message || parsed.type === "file-history-snapshot") {
+                    continue;
+                }
+                const role = parsed.message.role;
+                let textContent = "";
+                let toolCalls = [];
+                let isToolResult = false;
+                if (typeof parsed.message.content === "string") {
+                    textContent = parsed.message.content;
+                }
+                else if (Array.isArray(parsed.message.content)) {
+                    textContent = parsed.message.content
+                        .filter(c => c.type === "text")
+                        .map(c => c.text)
+                        .join("\n");
+                    for (const block of parsed.message.content) {
+                        if (block.type === "tool_use") {
+                            const toolId = block.id || block.tool_use_id || "";
+                            const result = toolResultMap.get(toolId) || "";
+                            toolCalls.push({
+                                id: toolId,
+                                name: block.name || "",
+                                arguments: block.input || {},
+                                result: result.slice(0, 1500),
+                                status: "completed",
+                            });
+                        }
+                        if (block.type === "tool_result") {
+                            isToolResult = true;
+                        }
+                    }
+                }
+                // Skip tool_result "user" messages - they're system-generated responses
+                if (isToolResult)
+                    continue;
+                // Skip if nothing to show
+                if (!textContent.trim() && toolCalls.length === 0)
+                    continue;
+                const message = {
+                    id: parsed.message.id || parsed.uuid,
+                    sessionId,
+                    role,
+                    content: textContent.trim(),
+                    timestamp: new Date(parsed.timestamp),
+                    toolCalls: toolCalls.length > 0 ? toolCalls : undefined,
+                    metadata: {
+                        model: parsed.message.model,
+                        gitBranch: parsed.gitBranch,
+                        cwd: parsed.cwd,
+                        usage: parsed.message.usage,
+                    },
+                };
+                messages.push(message);
+            }
+            catch (error) {
+                continue;
+            }
+        }
+        return messages;
+    }
+    extractSessionId(path) {
+        // Extract session ID from path
+        // Format: /path/to/session-{id}.jsonl
+        const match = path.match(/([a-f0-9-]{36})\.jsonl$/);
+        return match ? match[1] : null;
+    }
+    /**
+     * Send a lightweight session update (no messages array - just metadata)
+     */
+    sendSessionUpdate(sessionId, session) {
+        if (!this.wsClient.isConnected()) {
+            logger.warn("WebSocket not connected, skipping session update");
+            return;
+        }
+        try {
+            // Recalculate status dynamically based on current time and messages
+            const msgs = session.messages || [];
+            const currentStatus = this.calculateStatusFromMessages(msgs, session.lastActivity);
+            // Extract last message info for the lightweight payload
+            const lastMsg = msgs[msgs.length - 1];
+            const lastMessage = lastMsg
+                ? {
+                    role: lastMsg.role,
+                    content: lastMsg.content?.slice(0, 200) || "",
+                    timestamp: lastMsg.timestamp,
+                }
+                : undefined;
+            // Include recent messages so the relay can update session_messages table
+            const recentMessages = msgs.slice(-30).map(m => ({
+                id: m.id,
+                sessionId: m.sessionId,
+                role: m.role,
+                content: m.content?.slice(0, 2000) || "",
+                timestamp: m.timestamp,
+                metadata: m.metadata,
+                toolCalls: m.toolCalls?.map(tc => ({
+                    ...tc,
+                    result: typeof tc.result === "string" ? tc.result.slice(0, 1500) : tc.result,
+                })),
+            }));
+            const payload = {
+                session: {
+                    id: session.id,
+                    sessionId: session.id,
+                    deviceId: this.deviceId,
+                    status: currentStatus,
+                    metadata: session.metadata,
+                    lastActivity: session.lastActivity,
+                    createdAt: session.createdAt,
+                    messageCount: msgs.length || session.metadata?.messageCount || 0,
+                    lastMessage,
+                    recentMessages,
+                },
+            };
+            this.wsClient.send({
+                type: "state:session_update",
+                payload,
+            });
+            logger.info(`Session update sent: ${sessionId}`, {
+                messageCount: msgs.length,
+                recentMessages: recentMessages.length,
+                status: currentStatus,
+            });
+        }
+        catch (error) {
+            logger.error(`Error sending session update for ${sessionId}`, error);
+            throw error;
+        }
+    }
+    /**
+     * Periodic sync: scan for recently modified JSONL files and push updates.
+     * Safety net in case the file watcher misses changes.
+     */
+    async periodicSync() {
+        if (!this.wsClient.isConnected())
+            return;
+        try {
+            const projects = await fs.readdir(this.projectsPath);
+            const now = Date.now();
+            const RECENT_THRESHOLD = 60000; // Files modified in last 60 seconds
+            for (const project of projects) {
+                const projectDir = join(this.projectsPath, project);
+                try {
+                    const stat = await fs.stat(projectDir);
+                    if (!stat.isDirectory())
+                        continue;
+                }
+                catch {
+                    continue;
+                }
+                const files = await fs.readdir(projectDir);
+                for (const file of files) {
+                    if (!file.endsWith(".jsonl"))
+                        continue;
+                    const sessionId = file.replace(".jsonl", "");
+                    if (!/^[a-f0-9-]{36}$/.test(sessionId))
+                        continue;
+                    const filePath = join(projectDir, file);
+                    try {
+                        const fileStat = await fs.stat(filePath);
+                        if (now - fileStat.mtime.getTime() > RECENT_THRESHOLD)
+                            continue;
+                        // File was recently modified - process it
+                        await this.processSessionFile(filePath);
+                    }
+                    catch {
+                        continue;
+                    }
+                }
+            }
+        }
+        catch (error) {
+            logger.error("Periodic sync failed", error);
+        }
+    }
+    async stop() {
+        logger.info("Stopping Claude Code session monitor...");
+        // Clear periodic sync timer
+        if (this.periodicSyncTimer) {
+            clearInterval(this.periodicSyncTimer);
+            this.periodicSyncTimer = null;
+        }
+        // Clear debounce timers
+        for (const timer of this.debounceTimer.values()) {
+            clearTimeout(timer);
+        }
+        this.debounceTimer.clear();
+        // Close file watcher
+        if (this.watcher) {
+            await this.watcher.close();
+            this.watcher = null;
+        }
+        // Clear session cache
+        this.sessionCache.clear();
+        logger.info("Claude Code session monitor stopped");
+    }
+    getSessionCache() {
+        return new Map(this.sessionCache);
+    }
+    getSession(sessionId) {
+        return this.sessionCache.get(sessionId);
+    }
+    getAllSessions() {
+        return Array.from(this.sessionCache.values());
+    }
+    getSessionsByProject(projectPath) {
+        return this.getAllSessions().filter(session => session.metadata?.workingDirectory === projectPath);
+    }
+    getActiveSessions(minutes = 5) {
+        const cutoff = new Date(Date.now() - minutes * 60 * 1000);
+        return this.getAllSessions().filter(session => session.lastActivity > cutoff);
+    }
+}
+//# sourceMappingURL=claude-monitor.js.map