@compilr-dev/cli 0.5.0 → 0.5.1

package/dist/multi-agent/session-registry.js

@@ -0,0 +1,514 @@
+/**
+ * SessionRegistry - Multi-terminal session awareness
+ *
+ * Manages this terminal's session lifecycle in a shared SQLite table.
+ * Each CLI instance registers on startup, heartbeats periodically,
+ * and unregisters on shutdown. Other instances can query active sessions.
+ *
+ * Uses the shared projects.db with WAL mode for concurrent access.
+ */
+import * as crypto from 'node:crypto';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { getDb } from '../db/index.js';
+import { getFileLockManager } from './file-locks.js';
+import { getNotificationManager } from './notification-manager.js';
+import { cleanupSessionDiffs } from '../ui/vscode-diff-ipc.js';
+// =============================================================================
+// Module-level accessors
+// =============================================================================
+let _registry = null;
+/**
+ * Get the current SessionRegistry instance (null if not initialized)
+ */
+export function getSessionRegistry() {
+    return _registry;
+}
+/**
+ * Initialize and return the SessionRegistry singleton.
+ * @param sessionsBasePath - Optional base path for session files (e.g., ~/.compilr-dev/sessions).
+ *   Used for session file cleanup when terminals unregister.
+ */
+export function initSessionRegistry(sessionsBasePath) {
+    if (!_registry) {
+        _registry = new SessionRegistry(getDb(), sessionsBasePath);
+    }
+    return _registry;
+}
+let _activeTerminalSessionId = null;
+/**
+ * Get the active terminal session ID for this process
+ */
+export function getActiveTerminalSessionId() {
+    return _activeTerminalSessionId;
+}
+/**
+ * Set the active terminal session ID for this process
+ */
+export function setActiveTerminalSessionId(id) {
+    _activeTerminalSessionId = id;
+}
+// =============================================================================
+// Constants
+// =============================================================================
+const HEARTBEAT_INTERVAL_MS = 30_000; // 30 seconds
+const STALE_THRESHOLD_MS = 120_000; // 2 minutes
+const COUNT_CHECK_INTERVAL_MS = 5_000; // 5 seconds — lightweight DB poll for count changes
+// =============================================================================
+// SessionRegistry
+// =============================================================================
+/**
+ * Regex pattern for TRANSIENT session files that can be cleaned up on exit.
+ * Session files (current-*, team-*, agent-*, shared-context-*) all persist
+ * for resume and team restore. Only shared-context is truly transient — it's
+ * rebuilt from the team on load.
+ */
+const TRANSIENT_FILE_PATTERN = /^shared-context-([a-f0-9]{8})\.json$/;
+export class SessionRegistry {
+    sessionId = null;
+    currentProjectId = null;
+    heartbeatInterval = null;
+    countCheckInterval = null;
+    db;
+    sessionsBasePath;
+    lastKnownCount = 0;
+    onCountChangeCallback = null;
+    constructor(db, sessionsBasePath) {
+        this.db = db;
+        this.sessionsBasePath = sessionsBasePath ?? null;
+    }
+    /**
+     * Set a callback invoked when the active session count changes.
+     * Used by the footer to trigger a re-render when terminals join/leave.
+     */
+    onCountChange(callback) {
+        this.onCountChangeCallback = callback;
+    }
+    /**
+     * Register this terminal in the session registry.
+     * Cleans up stale sessions, then inserts a new row.
+     * Returns the session ID.
+     */
+    register(projectId, label) {
+        // Clean up stale/dead sessions first
+        this.cleanupStale();
+        this.sessionId = crypto.randomUUID();
+        this.currentProjectId = projectId;
+        const pid = process.pid;
+        const ttyPath = process.stdin.isTTY
+            ? (process.env.TTY || 'unknown')
+            : 'pipe';
+        // Auto-assign label based on active session count
+        const assignedLabel = label ?? this.generateLabel(projectId);
+        this.db.prepare(`
+      INSERT INTO terminal_sessions (id, project_id, pid, tty_path, label, active_agent, agents_json, status)
+      VALUES (?, ?, ?, ?, ?, 'default', '[]', 'active')
+    `).run(this.sessionId, projectId, pid, ttyPath, assignedLabel);
+        // Track initial count (after our own registration), scoped to project
+        this.lastKnownCount = this.currentProjectId !== null
+            ? this.getActiveSessionCount(this.currentProjectId)
+            : this.getActiveSessionCount();
+        // Start heartbeat (30s — updates last_heartbeat + stale cleanup)
+        this.heartbeatInterval = setInterval(() => {
+            this.heartbeat();
+        }, HEARTBEAT_INTERVAL_MS);
+        this.heartbeatInterval.unref();
+        // Start count-check interval (5s — lightweight SELECT COUNT to detect joins/leaves)
+        this.countCheckInterval = setInterval(() => {
+            this.checkCountChange();
+        }, COUNT_CHECK_INTERVAL_MS);
+        this.countCheckInterval.unref();
+        return this.sessionId;
+    }
+    /**
+     * Unregister this terminal from the session registry.
+     * Stops heartbeat and deletes the row.
+     */
+    unregister() {
+        if (this.heartbeatInterval) {
+            clearInterval(this.heartbeatInterval);
+            this.heartbeatInterval = null;
+        }
+        if (this.countCheckInterval) {
+            clearInterval(this.countCheckInterval);
+            this.countCheckInterval = null;
+        }
+        if (this.sessionId) {
+            const sessionPrefix = this.sessionId.slice(0, 8);
+            // Release file locks before deleting the session row
+            // (CASCADE handles this at DB level too, but explicit is cleaner)
+            const lockManager = getFileLockManager();
+            if (lockManager) {
+                lockManager.releaseSessionLocks(this.sessionId);
+            }
+            try {
+                this.db.prepare('DELETE FROM terminal_sessions WHERE id = ?').run(this.sessionId);
+            }
+            catch {
+                // Best effort — DB may already be closed
+            }
+            // Clean up own session files
+            if (this.sessionsBasePath) {
+                this.cleanupSessionFilesForPrefix(sessionPrefix);
+            }
+            // Clean up VS Code diff IPC files for this session
+            cleanupSessionDiffs(sessionPrefix);
+            this.sessionId = null;
+        }
+    }
+    /**
+     * Update the agent roster for this terminal session
+     */
+    updateAgents(agents) {
+        if (!this.sessionId)
+            return;
+        try {
+            this.db.prepare('UPDATE terminal_sessions SET agents_json = ? WHERE id = ?')
+                .run(JSON.stringify(agents), this.sessionId);
+        }
+        catch {
+            // Best effort
+        }
+    }
+    /**
+     * Set the currently active agent for this terminal session
+     */
+    setActiveAgent(agentId) {
+        if (!this.sessionId)
+            return;
+        try {
+            this.db.prepare('UPDATE terminal_sessions SET active_agent = ? WHERE id = ?')
+                .run(agentId, this.sessionId);
+        }
+        catch {
+            // Best effort
+        }
+    }
+    /**
+     * Get the project-scoped active session count.
+     * Returns the count scoped to this terminal's current project,
+     * or global count if no project is set.
+     * Used by footer rendering to show the correct terminal count.
+     */
+    getProjectScopedSessionCount() {
+        return this.currentProjectId !== null
+            ? this.getActiveSessionCount(this.currentProjectId)
+            : this.getActiveSessionCount();
+    }
+    /**
+     * Update the project ID for this terminal session.
+     * Called when the user switches projects.
+     * Triggers an immediate count re-check for the new project scope.
+     */
+    updateProjectId(projectId) {
+        if (!this.sessionId)
+            return;
+        try {
+            this.db.prepare('UPDATE terminal_sessions SET project_id = ? WHERE id = ?')
+                .run(projectId, this.sessionId);
+            this.currentProjectId = projectId;
+            // Trigger immediate count re-check for new project scope
+            this.checkCountChange();
+        }
+        catch {
+            // Best effort
+        }
+    }
+    /**
+     * Get all active sessions, optionally filtered by project.
+     * Pass undefined to get all sessions regardless of project.
+     */
+    getActiveSessions(projectId) {
+        try {
+            if (projectId === undefined) {
+                return this.db.prepare(`SELECT * FROM terminal_sessions WHERE status = 'active' ORDER BY started_at`).all();
+            }
+            if (projectId === null) {
+                return this.db.prepare(`SELECT * FROM terminal_sessions WHERE status = 'active' AND project_id IS NULL ORDER BY started_at`).all();
+            }
+            return this.db.prepare(`SELECT * FROM terminal_sessions WHERE status = 'active' AND project_id = ? ORDER BY started_at`).all(projectId);
+        }
+        catch {
+            return [];
+        }
+    }
+    /**
+     * Get the count of active sessions, optionally filtered by project.
+     * Pass undefined to count all sessions.
+     */
+    getActiveSessionCount(projectId) {
+        try {
+            if (projectId === undefined) {
+                const row = this.db.prepare(`SELECT COUNT(*) as count FROM terminal_sessions WHERE status = 'active'`).get();
+                return row.count;
+            }
+            if (projectId === null) {
+                const row = this.db.prepare(`SELECT COUNT(*) as count FROM terminal_sessions WHERE status = 'active' AND project_id IS NULL`).get();
+                return row.count;
+            }
+            const row = this.db.prepare(`SELECT COUNT(*) as count FROM terminal_sessions WHERE status = 'active' AND project_id = ?`).get(projectId);
+            return row.count;
+        }
+        catch {
+            return 0;
+        }
+    }
+    /**
+     * Clean up stale and dead sessions.
+     * A session is stale if its last heartbeat is older than the threshold.
+     * A session is dead if its PID no longer exists.
+     * Returns the count of sessions cleaned.
+     */
+    cleanupStale() {
+        let cleaned = 0;
+        try {
+            const sessions = this.db.prepare(`SELECT id, pid, last_heartbeat FROM terminal_sessions WHERE status = 'active'`).all();
+            for (const session of sessions) {
+                // Skip our own session
+                if (session.id === this.sessionId)
+                    continue;
+                let shouldRemove = false;
+                // Check if PID is still alive
+                try {
+                    process.kill(session.pid, 0);
+                }
+                catch {
+                    // PID doesn't exist — dead session
+                    shouldRemove = true;
+                }
+                // Check heartbeat age
+                if (!shouldRemove) {
+                    const lastHeartbeat = new Date(session.last_heartbeat).getTime();
+                    const age = Date.now() - lastHeartbeat;
+                    if (age > STALE_THRESHOLD_MS) {
+                        shouldRemove = true;
+                    }
+                }
+                if (shouldRemove) {
+                    this.db.prepare('DELETE FROM terminal_sessions WHERE id = ?').run(session.id);
+                    // Clean up orphaned session files
+                    if (this.sessionsBasePath) {
+                        this.cleanupSessionFilesForPrefix(session.id.slice(0, 8));
+                    }
+                    cleaned++;
+                }
+            }
+            // Also clean up any orphaned file locks from stale sessions
+            if (cleaned > 0) {
+                const lockManager = getFileLockManager();
+                if (lockManager) {
+                    lockManager.cleanupStaleLocks(STALE_THRESHOLD_MS);
+                }
+            }
+            // Clean up old/stale notifications
+            const notifManager = getNotificationManager();
+            if (notifManager) {
+                notifManager.cleanup();
+            }
+        }
+        catch {
+            // Best effort
+        }
+        return cleaned;
+    }
+    /**
+     * Get all agent IDs in use by other terminals (excluding self).
+     * Optionally filtered to the same project.
+     * Used for cross-terminal collision detection.
+     */
+    getGlobalAgentIds(projectId) {
+        try {
+            const sessions = this.getActiveSessions(projectId);
+            const agentIds = [];
+            for (const session of sessions) {
+                // Skip our own session
+                if (session.id === this.sessionId)
+                    continue;
+                try {
+                    const agents = JSON.parse(session.agents_json);
+                    for (const agent of agents) {
+                        agentIds.push(agent.id);
+                    }
+                }
+                catch {
+                    // Ignore parse errors for individual sessions
+                }
+            }
+            return agentIds;
+        }
+        catch {
+            return [];
+        }
+    }
+    /**
+     * Clean up orphaned session files for all stale sessions.
+     * Scans project directories under sessionsBasePath for terminal-scoped files
+     * whose session prefix is not in the active set.
+     * Returns the count of files cleaned.
+     */
+    cleanupSessionFiles() {
+        if (!this.sessionsBasePath)
+            return 0;
+        // Build set of active session prefixes (first 8 chars)
+        const activePrefixes = new Set();
+        try {
+            const sessions = this.getActiveSessions();
+            for (const session of sessions) {
+                activePrefixes.add(session.id.slice(0, 8));
+            }
+        }
+        catch {
+            return 0;
+        }
+        let cleaned = 0;
+        try {
+            if (!fs.existsSync(this.sessionsBasePath))
+                return 0;
+            const entries = fs.readdirSync(this.sessionsBasePath, { withFileTypes: true });
+            for (const entry of entries) {
+                if (!entry.isDirectory())
+                    continue;
+                const dirPath = path.join(this.sessionsBasePath, entry.name);
+                cleaned += this.cleanupOrphanFilesInDir(dirPath, activePrefixes);
+            }
+        }
+        catch {
+            // Best effort
+        }
+        return cleaned;
+    }
+    // ---------------------------------------------------------------------------
+    // Private
+    // ---------------------------------------------------------------------------
+    /**
+     * Clean up transient session files for a specific session prefix in all project directories.
+     * Preserves current-{prefix}.json files so they remain available for /resume.
+     */
+    cleanupSessionFilesForPrefix(prefix) {
+        if (!this.sessionsBasePath)
+            return;
+        try {
+            if (!fs.existsSync(this.sessionsBasePath))
+                return;
+            const entries = fs.readdirSync(this.sessionsBasePath, { withFileTypes: true });
+            for (const entry of entries) {
+                if (!entry.isDirectory())
+                    continue;
+                const dirPath = path.join(this.sessionsBasePath, entry.name);
+                try {
+                    const files = fs.readdirSync(dirPath);
+                    for (const file of files) {
+                        const match = TRANSIENT_FILE_PATTERN.exec(file);
+                        if (match) {
+                            const filePrefix = match[1] || match[2];
+                            if (filePrefix === prefix) {
+                                fs.unlinkSync(path.join(dirPath, file));
+                            }
+                        }
+                    }
+                }
+                catch {
+                    // Best effort per directory
+                }
+            }
+        }
+        catch {
+            // Best effort
+        }
+    }
+    /**
+     * Clean up orphaned transient session files in a single project directory.
+     * Preserves current-*.json files so they remain available for /resume.
+     * Returns count of files removed.
+     */
+    cleanupOrphanFilesInDir(dirPath, activePrefixes) {
+        let cleaned = 0;
+        try {
+            const files = fs.readdirSync(dirPath);
+            for (const file of files) {
+                const match = TRANSIENT_FILE_PATTERN.exec(file);
+                if (match) {
+                    const filePrefix = match[1] || match[2];
+                    if (!activePrefixes.has(filePrefix)) {
+                        fs.unlinkSync(path.join(dirPath, file));
+                        cleaned++;
+                    }
+                }
+            }
+        }
+        catch {
+            // Best effort
+        }
+        return cleaned;
+    }
+    /**
+     * Send a heartbeat (update last_heartbeat timestamp).
+     * Also opportunistically clean up stale sessions.
+     */
+    heartbeat() {
+        if (!this.sessionId)
+            return;
+        try {
+            this.db.prepare(`UPDATE terminal_sessions SET last_heartbeat = CURRENT_TIMESTAMP WHERE id = ?`).run(this.sessionId);
+            // Opportunistic cleanup
+            this.cleanupStale();
+        }
+        catch {
+            // Best effort — DB may be locked briefly
+        }
+    }
+    /**
+     * Check if the active session count changed and notify listener.
+     * Runs on a 5s interval — lightweight SELECT COUNT query.
+     * Scoped to current project for project-aware terminal count.
+     */
+    checkCountChange() {
+        try {
+            // Count sessions on the same project (or all if no project)
+            const currentCount = this.currentProjectId !== null
+                ? this.getActiveSessionCount(this.currentProjectId)
+                : this.getActiveSessionCount();
+            if (currentCount !== this.lastKnownCount) {
+                this.lastKnownCount = currentCount;
+                if (this.onCountChangeCallback) {
+                    this.onCountChangeCallback(currentCount);
+                }
+            }
+        }
+        catch {
+            // Best effort
+        }
+    }
+    /**
+     * Generate a label like "Terminal 1", "Terminal 2" using the next available number.
+     * Avoids duplicates by checking which numbers are already in use.
+     */
+    generateLabel(projectId) {
+        try {
+            const query = projectId !== null
+                ? `SELECT label FROM terminal_sessions WHERE status = 'active' AND project_id = ?`
+                : `SELECT label FROM terminal_sessions WHERE status = 'active' AND project_id IS NULL`;
+            const rows = projectId !== null
+                ? this.db.prepare(query).all(projectId)
+                : this.db.prepare(query).all();
+            // Collect numbers already in use
+            const usedNumbers = new Set();
+            for (const row of rows) {
+                const match = /^Terminal (\d+)$/.exec(row.label);
+                if (match) {
+                    usedNumbers.add(parseInt(match[1], 10));
+                }
+            }
+            // Find the first available number
+            let n = 1;
+            while (usedNumbers.has(n))
+                n++;
+            return `Terminal ${String(n)}`;
+        }
+        catch {
+            // Fallback to count-based
+            const count = this.getActiveSessionCount(projectId);
+            return `Terminal ${String(count + 1)}`;
+        }
+    }
+}