specrails-desktop 2.0.0

package/server/dist/project-registry.js

@@ -0,0 +1,443 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProjectRegistry = void 0;
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const db_1 = require("./db");
+const queue_manager_1 = require("./queue-manager");
+const chat_manager_1 = require("./chat-manager");
+const setup_manager_1 = require("./setup-manager");
+const proposal_manager_1 = require("./proposal-manager");
+const agent_refine_manager_1 = require("./agent-refine-manager");
+const file_summary_manager_1 = require("./file-summary-manager");
+const file_summary_generator_1 = require("./file-summary-generator");
+const providers_1 = require("./providers");
+const agent_refine_db_1 = require("./agent-refine-db");
+const spec_launcher_manager_1 = require("./spec-launcher-manager");
+const webhook_manager_1 = require("./webhook-manager");
+const ticket_watcher_1 = require("./ticket-watcher");
+const terminal_manager_1 = require("./terminal-manager");
+const browser_capture_manager_1 = require("./browser-capture-manager");
+const explore_cwd_manager_1 = require("./explore-cwd-manager");
+const ticket_store_1 = require("./ticket-store");
+const rails_store_1 = require("./rails-store");
+const desktop_db_1 = require("./desktop-db");
+const config_1 = require("./config");
+// ─── ProjectRegistry ──────────────────────────────────────────────────────────
+class ProjectRegistry {
+    _desktopDb;
+    _contexts;
+    _broadcast;
+    _webhookManager;
+    _desktopPort;
+    // M9: projects whose per-project DB failed to load at startup (corrupt, locked,
+    // or migration-stuck). They stay registered but have no live context.
+    _failedProjects;
+    constructor(broadcast, desktopDbPath, desktopPort) {
+        this._broadcast = broadcast;
+        this._desktopDb = (0, desktop_db_1.initDesktopDb)(desktopDbPath ?? (0, desktop_db_1.getDesktopDbPath)());
+        this._contexts = new Map();
+        this._webhookManager = new webhook_manager_1.WebhookManager(this._desktopDb);
+        this._desktopPort = desktopPort ?? 4200;
+        this._failedProjects = new Map();
+    }
+    get desktopDb() {
+        return this._desktopDb;
+    }
+    loadAll() {
+        const projects = (0, desktop_db_1.listProjects)(this._desktopDb);
+        for (const project of projects) {
+            try {
+                this._loadProjectContext(project);
+                this._failedProjects.delete(project.id);
+            }
+            catch (err) {
+                // M9: a single corrupt / locked / migration-stuck per-project jobs.sqlite
+                // must NOT crash the whole app at startup (previously it did, killing
+                // every other project + the UI in a restart loop). Log it, record it as
+                // failed-to-load, and keep loading the rest.
+                const msg = err instanceof Error ? err.message : String(err);
+                console.error(`[project-registry] failed to load project ${project.id} (${project.slug}): ${msg}`);
+                this._failedProjects.set(project.id, { project, error: msg });
+            }
+        }
+    }
+    /** Projects whose per-project DB failed to load at startup (M9). */
+    listFailedProjects() {
+        return Array.from(this._failedProjects.values());
+    }
+    addProject(opts) {
+        const row = (0, desktop_db_1.addProject)(this._desktopDb, opts);
+        return this._loadProjectContext(row);
+    }
+    removeProject(id) {
+        const ctx = this._contexts.get(id);
+        if (ctx) {
+            // Tear down spawners BEFORE closing the DB. QueueManager.shutdown() drops
+            // its DB handle so a late child 'close' can't run prepared statements on
+            // the closed connection (which would crash the app) and terminates any
+            // orphaned rail child + dangling zombie timer. ChatManager.shutdown()
+            // kills in-flight chat/Explore children and clears their idle timers.
+            // SetupManager.abort() stops the 3s install poll and kills install/enrich
+            // children. All are idempotent no-ops when nothing is running.
+            try {
+                ctx.queueManager.shutdown();
+            }
+            catch { /* ignore */ }
+            try {
+                ctx.chatManager.shutdown();
+            }
+            catch { /* ignore */ }
+            try {
+                ctx.setupManager.abort(id);
+            }
+            catch { /* ignore */ }
+            // M12: these three also spawn children that outlive removeProject. Proposal
+            // and AgentRefine write to the per-project DB in their close handlers — if
+            // not disposed before db.close() they throw on the closed connection and
+            // (no uncaughtException handler) crash the entire app. SpecLauncher has no
+            // DB but its --dangerously-skip-permissions child keeps burning spend.
+            try {
+                ctx.proposalManager.shutdown();
+            }
+            catch { /* ignore */ }
+            try {
+                ctx.agentRefineManager.shutdown();
+            }
+            catch { /* ignore */ }
+            try {
+                ctx.specLauncherManager.shutdown();
+            }
+            catch { /* ignore */ }
+            // Tear down the embedded browser (closes pages + persistent context).
+            void ctx.browserCaptureManager.shutdown().catch(() => { });
+            // Kill any terminal sessions belonging to this project
+            try {
+                (0, terminal_manager_1.getTerminalManager)().killAllForProject(id);
+            }
+            catch { /* ignore */ }
+            // Close the ticket file watcher
+            ctx.ticketWatcher.close().catch(() => { });
+            // Tear down the code-explorer summary manager: aborts any in-flight
+            // provider child, rejects queued work, and detaches the watcher — BEFORE
+            // db.close() so a completing generation can't write to the closed handle.
+            try {
+                ctx.fileSummaryManager.dispose();
+            }
+            catch { /* ignore */ }
+            // Drop the app-managed Explore Spec cwd (CLAUDE.md + symlink to project)
+            try {
+                (0, explore_cwd_manager_1.removeExploreCwd)(ctx.project.slug);
+            }
+            catch { /* ignore — non-fatal */ }
+            // Close the DB connection BEFORE removing the project's data dir below.
+            try {
+                ctx.db.close();
+            }
+            catch { /* ignore */ }
+            // B54: remove the ENTIRE app-managed data dir for this project, not just
+            // the telemetry subdir. It also holds user-mcp.json (a copy of the user's
+            // MCP config that can contain API keys), profile snapshots, codex-home, and
+            // terminal shim dirs — all secret-bearing residue that previously survived
+            // project removal. Guard on a non-empty slug so we never rm the projects/
+            // root itself.
+            try {
+                const slug = ctx.project.slug;
+                if (slug && slug.trim() && !slug.includes('/') && !slug.includes('..')) {
+                    const projectDir = path_1.default.join(os_1.default.homedir(), '.specrails', 'projects', slug);
+                    if (fs_1.default.existsSync(projectDir)) {
+                        fs_1.default.rmSync(projectDir, { recursive: true, force: true });
+                    }
+                }
+            }
+            catch { /* ignore — non-fatal */ }
+            this._contexts.delete(id);
+        }
+        (0, desktop_db_1.removeProject)(this._desktopDb, id);
+    }
+    getContext(id) {
+        return this._contexts.get(id);
+    }
+    getContextByPath(projectPath) {
+        const row = (0, desktop_db_1.getProjectByPath)(this._desktopDb, projectPath);
+        if (!row)
+            return undefined;
+        return this._contexts.get(row.id);
+    }
+    listContexts() {
+        return Array.from(this._contexts.values());
+    }
+    /**
+     * Graceful process-level teardown: terminate every project's active rail and
+     * chat children so SIGTERM/SIGINT (or desktop parent-death) does not leave
+     * orphaned claude/codex processes reparented to init. Best-effort per project
+     * — one failure never blocks the rest. Does NOT close DBs (the process is
+     * exiting anyway).
+     */
+    shutdown() {
+        for (const ctx of this._contexts.values()) {
+            try {
+                ctx.queueManager.shutdown();
+            }
+            catch { /* ignore */ }
+            try {
+                ctx.chatManager.shutdown();
+            }
+            catch { /* ignore */ }
+            try {
+                ctx.proposalManager.shutdown();
+            }
+            catch { /* ignore */ }
+            try {
+                ctx.agentRefineManager.shutdown();
+            }
+            catch { /* ignore */ }
+            try {
+                ctx.specLauncherManager.shutdown();
+            }
+            catch { /* ignore */ }
+            void ctx.browserCaptureManager.shutdown().catch(() => { });
+            // Release chokidar watchers + abort in-flight generations so a restart
+            // does not leak handles/children — mirror removeProject()'s per-project teardown.
+            try {
+                ctx.fileSummaryManager.dispose();
+            }
+            catch { /* ignore */ }
+            ctx.ticketWatcher.close().catch(() => { });
+        }
+    }
+    touchProject(id) {
+        (0, desktop_db_1.touchProject)(this._desktopDb, id);
+    }
+    getProjectRow(id) {
+        return (0, desktop_db_1.getProject)(this._desktopDb, id);
+    }
+    _loadProjectContext(project) {
+        // Avoid double-loading
+        const existing = this._contexts.get(project.id);
+        if (existing)
+            return existing;
+        const db = (0, db_1.initDb)(project.db_path);
+        // Bind broadcast with projectId so all WS messages carry context.
+        // Also wire agent status: when a queued job reaches a terminal state,
+        // clear current_job_id on any agent that was assigned to it.
+        const TERMINAL_JOB_STATUSES = new Set(['completed', 'failed', 'canceled']);
+        const boundBroadcast = (msg) => {
+            const enriched = { ...msg, projectId: project.id };
+            this._broadcast(enriched);
+            if (msg.type === 'queue') {
+                for (const job of msg.jobs) {
+                    if (TERMINAL_JOB_STATUSES.has(job.status)) {
+                        (0, desktop_db_1.clearAgentJob)(this._desktopDb, job.id);
+                    }
+                }
+            }
+        };
+        // Per-project zombie timeout (stored in queue_state)
+        let projectZombieTimeout;
+        try {
+            const row = db.prepare(`SELECT value FROM queue_state WHERE key = 'config.zombie_timeout_ms'`).get();
+            if (row) {
+                const parsed = parseInt(row.value, 10);
+                if (!isNaN(parsed) && parsed > 0)
+                    projectZombieTimeout = parsed;
+            }
+        }
+        catch { /* queue_state table may not exist yet */ }
+        const webhookManager = this._webhookManager;
+        const railJobs = new Map();
+        const queueManager = new queue_manager_1.QueueManager(boundBroadcast, db, undefined, project.path, {
+            zombieTimeoutMs: projectZombieTimeout,
+            provider: project.provider ?? 'claude',
+            projectId: project.id,
+            projectSlug: project.slug,
+            desktopPort: this._desktopPort,
+            getCostAlertThreshold: () => {
+                const val = (0, desktop_db_1.getDesktopSetting)(this._desktopDb, 'cost_alert_threshold_usd');
+                return val != null ? parseFloat(val) : null;
+            },
+            getDesktopDailyBudget: () => {
+                const val = (0, desktop_db_1.getDesktopSetting)(this._desktopDb, 'desktop_daily_budget_usd');
+                const budget = val != null ? parseFloat(val) : null;
+                let totalSpend = 0;
+                for (const c of this.listContexts()) {
+                    const row = c.db.prepare(`SELECT COALESCE(SUM(total_cost_usd), 0) as total FROM jobs WHERE status = 'completed' AND total_cost_usd IS NOT NULL AND started_at >= date('now')`).get();
+                    totalSpend += row.total;
+                }
+                return { budget, totalSpend };
+            },
+            onJobFinished: (jobId, status, costUsd) => {
+                const jobRow = db.prepare('SELECT command, duration_ms FROM jobs WHERE id = ?').get(jobId);
+                const event = status === 'completed' ? 'job.completed' : status === 'canceled' ? 'job.canceled' : 'job.failed';
+                webhookManager.deliver(project.id, event, {
+                    jobId,
+                    command: jobRow?.command ?? '',
+                    status,
+                    costUsd: costUsd ?? null,
+                    durationMs: jobRow?.duration_ms ?? null,
+                });
+                // Broadcast rail.job_completed if this job was launched by a rail
+                const railMeta = railJobs.get(jobId);
+                if (railMeta) {
+                    railJobs.delete(jobId);
+                }
+                // Determine ticket IDs: from rail metadata, or parse from command as fallback
+                // (railJobs Map is in-memory and lost on server restart)
+                let completedTicketIds = railMeta?.ticketIds ?? [];
+                if (completedTicketIds.length === 0 && jobRow?.command) {
+                    const matches = jobRow.command.match(/#(\d+)/g);
+                    if (matches)
+                        completedTicketIds = matches.map((m) => parseInt(m.slice(1), 10));
+                }
+                // Apply the job outcome to its tickets. Success promotes todo/in_progress
+                // → done (→ Specs Done); failure/cancel/zombie reverts in_progress → todo
+                // (→ Specs) or flags an already-done spec for review. zombie_terminated is
+                // treated as a failure here (and is included in the _onJobExit callback
+                // guard) so a timed-out rail releases its specs instead of stranding them.
+                if (completedTicketIds.length > 0 &&
+                    (status === 'completed' || status === 'failed' || status === 'canceled' || status === 'zombie_terminated')) {
+                    try {
+                        const ticketFile = (0, ticket_store_1.resolveTicketStoragePath)(project.path);
+                        const now = new Date().toISOString();
+                        let changedIds = [];
+                        const store = (0, ticket_store_1.mutateStore)(ticketFile, (s) => {
+                            changedIds = (0, ticket_store_1.applyJobOutcomeToTickets)(s, completedTicketIds, status, now);
+                        });
+                        for (const tid of changedIds) {
+                            const ticket = store.tickets[String(tid)];
+                            if (!ticket)
+                                continue;
+                            boundBroadcast({
+                                type: 'ticket_updated',
+                                ticket: ticket,
+                                projectId: project.id,
+                                timestamp: ticket.updated_at,
+                            });
+                        }
+                    }
+                    catch (err) {
+                        console.error('[project-registry] failed to apply job outcome to tickets:', err);
+                    }
+                }
+                // Release the job's tickets from any rail that still holds them. The
+                // server `rails` table is the source of truth for mobile clients (the
+                // desktop strips its localStorage copy on rail.job_completed) — without
+                // this, a finished spec stays stranded on the rail forever. Runs on
+                // every terminal outcome, mirroring the desktop: success → spec is
+                // done; failure/cancel/zombie → spec returns to the board. Scans ALL
+                // rails (not just railMeta.railIndex) so it also heals after a server
+                // restart, when the in-memory railJobs map is lost.
+                if (completedTicketIds.length > 0 &&
+                    (status === 'completed' || status === 'failed' || status === 'canceled' || status === 'zombie_terminated')) {
+                    try {
+                        for (const rail of (0, rails_store_1.getRails)(db)) {
+                            const remaining = rail.ticketIds.filter((id) => !completedTicketIds.includes(id));
+                            if (remaining.length === rail.ticketIds.length)
+                                continue;
+                            (0, rails_store_1.setRailTickets)(db, rail.railIndex, remaining, rail.mode, rail.profileName, rail.aiEngine);
+                            boundBroadcast({
+                                type: 'rail.updated',
+                                projectId: project.id,
+                                railIndex: rail.railIndex,
+                                changed: 'tickets',
+                                ticketIds: remaining,
+                                name: rail.name ?? null,
+                                mode: rail.mode,
+                                profileName: rail.profileName ?? null,
+                                aiEngine: rail.aiEngine ?? null,
+                            });
+                        }
+                    }
+                    catch (err) {
+                        console.error('[project-registry] failed to release rail tickets after job exit:', err);
+                    }
+                }
+                // Broadcast rail.job_completed if we know the rail index
+                if (railMeta) {
+                    boundBroadcast({
+                        type: 'rail.job_completed',
+                        projectId: project.id,
+                        railIndex: railMeta.railIndex,
+                        jobId,
+                        status,
+                        ticketIds: completedTicketIds,
+                    });
+                }
+            },
+        });
+        const chatManager = new chat_manager_1.ChatManager(boundBroadcast, db, project.path, project.name, project.provider ?? 'claude', project.id, project.slug);
+        const setupManager = new setup_manager_1.SetupManager(boundBroadcast, (pid, sid) => (0, desktop_db_1.setProjectSetupSession)(this._desktopDb, pid, sid), (pid) => (0, desktop_db_1.clearProjectSetupSession)(this._desktopDb, pid));
+        const proposalManager = new proposal_manager_1.ProposalManager(boundBroadcast, db, project.path);
+        const agentRefineManager = new agent_refine_manager_1.AgentRefineManager(boundBroadcast, db, project.path, project.id, project.provider ?? 'claude');
+        // Retention prune: drop stale/abandoned refine sessions on project load.
+        try {
+            (0, agent_refine_db_1.pruneStaleRefineSessions)(db);
+        }
+        catch (err) {
+            console.error('[project-registry] prune refine sessions failed:', err);
+        }
+        const specLauncherManager = new spec_launcher_manager_1.SpecLauncherManager(boundBroadcast, project.path);
+        // FileSummaryManager — code-explorer. The class is constructed for every
+        // project regardless of the feature flag; the router 404s when the flag
+        // is off, so no spawn can occur. Budget reader queries `ai_invocations`
+        // for the current calendar month.
+        const fileSummaryAdapter = (0, providers_1.getAdapter)(project.provider ?? 'claude');
+        const fileSummaryGenerate = (0, file_summary_generator_1.createFileSummaryGenerator)({ adapter: fileSummaryAdapter, cwd: project.path });
+        const fileSummaryManager = new file_summary_manager_1.FileSummaryManager({
+            db,
+            broadcast: boundBroadcast,
+            generate: fileSummaryGenerate,
+            monthToDateSpend: (projectId) => {
+                const row = db.prepare(`SELECT COALESCE(SUM(total_cost_usd), 0) AS total FROM ai_invocations
+           WHERE project_id = ? AND surface = 'file-summary'
+             AND started_at >= strftime('%Y-%m-01', 'now')`).get(projectId);
+                return row?.total ?? 0;
+            },
+            monthlyBudgetUsd: () => {
+                const raw = (0, desktop_db_1.getDesktopSetting)(this._desktopDb, 'summary_monthly_budget_usd');
+                const n = parseFloat(raw ?? '5.00');
+                return isNaN(n) ? 5.0 : n;
+            },
+            language: () => {
+                const raw = (0, desktop_db_1.getDesktopSetting)(this._desktopDb, 'summary_language');
+                return raw === 'es' ? 'es' : 'en';
+            },
+            providerId: () => fileSummaryAdapter.id,
+        });
+        // NOTE: the chokidar watcher is NOT attached here. It is only needed to mark
+        // already-generated summaries stale, which is irrelevant until the user opens
+        // the Code section. Attaching at startup for every project — even ones that
+        // never use Code Explorer (the client flag is OFF by default) — added a
+        // persistent recursive watcher per project, the source of the fd leak that
+        // broke terminals. The watcher is now attached lazily on the first
+        // code-explorer request (see code-explorer-router.ts).
+        // Load commands for this project
+        try {
+            const config = (0, config_1.getConfig)(project.path, db, project.name);
+            queueManager.setCommands(config.commands);
+        }
+        catch {
+            // Non-fatal: project may not have commands yet
+        }
+        const ticketWatcher = new ticket_watcher_1.TicketWatcher(project.path, project.id, boundBroadcast);
+        ticketWatcher.start();
+        // BrowserCaptureManager — "Add Spec from browser". Constructed for every
+        // project regardless of the feature flag; the routes + WS endpoint 404 when
+        // the flag is off, and the persistent Chromium context is launched lazily on
+        // first session create, so a project that never uses it pays nothing.
+        const browserCaptureManager = new browser_capture_manager_1.BrowserCaptureManager({
+            projectId: project.id,
+            projectSlug: project.slug,
+            db,
+            broadcast: boundBroadcast,
+        });
+        const ctx = { project, db, queueManager, chatManager, setupManager, proposalManager, agentRefineManager, fileSummaryManager, specLauncherManager, ticketWatcher, browserCaptureManager, broadcast: boundBroadcast, railJobs };
+        this._contexts.set(project.id, ctx);
+        return ctx;
+    }
+}
+exports.ProjectRegistry = ProjectRegistry;