specrails-desktop 2.2.0 → 2.3.0

package/server/dist/project-router-jobs.js

@@ -0,0 +1,389 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerJobsRoutes = registerJobsRoutes;
+const db_1 = require("./db");
+const queue_manager_1 = require("./queue-manager");
+const types_1 = require("./types");
+const hooks_1 = require("./hooks");
+const explore_smash_1 = require("./explore-smash");
+const spec_models_1 = require("./spec-models");
+const provider_selection_1 = require("./provider-selection");
+const metrics_1 = require("./metrics");
+const ticket_store_1 = require("./ticket-store");
+const project_router_helpers_1 = require("./project-router-helpers");
+function registerJobsRoutes(deps) {
+    const { router, registry, ctx, ticketPath } = deps;
+    // ─── Queue / Spawn routes ────────────────────────────────────────────────────
+    router.post('/:projectId/spawn', (req, res) => {
+        const { command, priority, dependsOnJobId, pipelineId, profileName, aiEngine } = req.body ?? {};
+        if (!command || typeof command !== 'string' || !command.trim()) {
+            res.status(400).json({ error: 'command is required' });
+            return;
+        }
+        if (priority !== undefined && !types_1.VALID_PRIORITIES.has(priority)) {
+            res.status(400).json({ error: 'priority must be one of: low, normal, high, critical' });
+            return;
+        }
+        // profileName accepts: undefined (default resolution), null (force legacy), string (explicit)
+        const normalizedProfileName = profileName === null ? null
+            : typeof profileName === 'string' && profileName.trim() ? profileName.trim()
+                : undefined;
+        // aiEngine: optional per-job provider override; must be installed on the
+        // project. Omitting it runs on the project's primary provider.
+        const engineCheck = (0, provider_selection_1.validateRequestedProvider)(ctx(req).project, aiEngine);
+        if (!engineCheck.ok) {
+            res.status(400).json({ error: engineCheck.error });
+            return;
+        }
+        try {
+            const job = ctx(req).queueManager.enqueue(command, priority ?? 'normal', {
+                dependsOnJobId: dependsOnJobId || undefined,
+                pipelineId: pipelineId || undefined,
+                profileName: normalizedProfileName,
+                provider: aiEngine ? engineCheck.provider : undefined,
+            });
+            const position = job.queuePosition ?? 0;
+            res.status(202).json({ jobId: job.id, position });
+        }
+        catch (err) {
+            if (err instanceof queue_manager_1.ClaudeNotFoundError) {
+                res.status(400).json({ error: err.message });
+            }
+            else {
+                console.error('[project-router] spawn error:', err);
+                res.status(500).json({ error: 'Internal server error' });
+            }
+        }
+    });
+    // ─── Pipeline routes ──────────────────────────────────────────────────────────
+    // NOTE: Ad-hoc pipeline creation removed — use rails (templates) instead.
+    // The GET route remains for viewing existing pipeline status.
+    router.get('/:projectId/pipelines/:pipelineId', (req, res) => {
+        const { db } = ctx(req);
+        const pipelineId = req.params.pipelineId;
+        const jobs = (0, db_1.getPipelineJobs)(db, pipelineId);
+        if (jobs.length === 0) {
+            res.status(404).json({ error: 'Pipeline not found' });
+            return;
+        }
+        const allCompleted = jobs.every(j => j.status === 'completed');
+        const anyFailed = jobs.some(j => ['failed', 'skipped', 'canceled', 'zombie_terminated'].includes(j.status));
+        const status = allCompleted ? 'completed' : anyFailed ? 'failed' : 'running';
+        res.json({ pipelineId, status, jobs });
+    });
+    router.get('/:projectId/state', (req, res) => {
+        const { queueManager, project } = ctx(req);
+        res.json({
+            projectName: project.name,
+            projectId: project.id,
+            phases: (0, hooks_1.getPhaseStates)(),
+            busy: queueManager.getActiveJobId() !== null,
+            currentJobId: queueManager.getActiveJobId(),
+            featureFlags: {
+                smash: !(0, explore_smash_1.isSpecsSmashKillSwitchActive)(),
+            },
+        });
+    });
+    // Returns the resolved default model for Add Spec + the full provider
+    // allow-list so the modal can render its picker without maintaining its
+    // own copy of the model lists. Source of truth is `server/spec-models.ts`.
+    router.get('/:projectId/default-spec-model', (req, res) => {
+        const { project } = ctx(req);
+        // Multi-provider: an optional ?provider= query selects which engine's models
+        // to return. It must be one the project actually has installed; an invalid
+        // or omitted value falls back to the project's primary provider. The
+        // response also lists every installed provider so the Add Spec modal can
+        // render its AI Engine selector without a second round-trip.
+        const provider = (0, provider_selection_1.resolveProvider)(project, typeof req.query.provider === 'string' ? req.query.provider : undefined);
+        const model = (0, project_router_helpers_1.resolveDefaultSpecModel)({ projectPath: project.path, provider });
+        const allowed = (0, spec_models_1.getModelsForProvider)(provider);
+        res.json({ model, provider, allowed, providers: project.providers });
+    });
+    router.delete('/:projectId/jobs/:id', (req, res) => {
+        try {
+            const result = ctx(req).queueManager.cancel(req.params.id);
+            res.json({ ok: true, status: result });
+        }
+        catch (err) {
+            if (err instanceof queue_manager_1.JobNotFoundError) {
+                res.status(404).json({ error: 'Job not found' });
+            }
+            else if (err instanceof queue_manager_1.JobAlreadyTerminalError) {
+                // Job already finished — delete it from the DB
+                (0, db_1.deleteJob)(ctx(req).db, req.params.id);
+                res.json({ ok: true, status: 'deleted' });
+            }
+            else {
+                res.status(500).json({ error: 'Internal server error' });
+            }
+        }
+    });
+    router.patch('/:projectId/jobs/:id/priority', (req, res) => {
+        const { priority } = req.body ?? {};
+        if (!priority || !types_1.VALID_PRIORITIES.has(priority)) {
+            res.status(400).json({ error: 'priority must be one of: low, normal, high, critical' });
+            return;
+        }
+        try {
+            ctx(req).queueManager.updatePriority(req.params.id, priority);
+            res.json({ ok: true });
+        }
+        catch (err) {
+            if (err instanceof queue_manager_1.JobNotFoundError) {
+                res.status(404).json({ error: 'Job not found' });
+            }
+            else {
+                res.status(400).json({ error: err.message });
+            }
+        }
+    });
+    router.post('/:projectId/queue/pause', (req, res) => {
+        ctx(req).queueManager.pause();
+        res.json({ ok: true, paused: true });
+    });
+    router.post('/:projectId/queue/resume', (req, res) => {
+        ctx(req).queueManager.resume();
+        res.json({ ok: true, paused: false });
+    });
+    router.put('/:projectId/queue/reorder', (req, res) => {
+        const { jobIds } = req.body ?? {};
+        if (!Array.isArray(jobIds)) {
+            res.status(400).json({ error: 'jobIds must be an array' });
+            return;
+        }
+        try {
+            ctx(req).queueManager.reorder(jobIds);
+            res.json({ ok: true, queue: jobIds });
+        }
+        catch (err) {
+            res.status(400).json({ error: err.message });
+        }
+    });
+    router.get('/:projectId/queue', (req, res) => {
+        const { queueManager } = ctx(req);
+        res.json({
+            jobs: queueManager.getJobs(),
+            paused: queueManager.isPaused(),
+            activeJobId: queueManager.getActiveJobId(),
+        });
+    });
+    router.get('/:projectId/jobs', (req, res) => {
+        // Clamp to [1, 200] (H-11): a negative limit is LIMIT -1 in SQLite, which
+        // means UNLIMITED — without the lower bound `?limit=-1` dumps the whole table.
+        const limit = Math.max(1, Math.min(parseInt(String(req.query.limit ?? '50'), 10) || 50, 200));
+        const offset = parseInt(String(req.query.offset ?? '0'), 10) || 0;
+        const status = req.query.status;
+        const from = req.query.from;
+        const to = req.query.to;
+        const { db } = ctx(req);
+        const result = (0, db_1.listJobs)(db, { limit, offset, status, from, to });
+        // Merge in-memory queued jobs that haven't been persisted to DB yet
+        const { queueManager } = ctx(req);
+        const dbIds = new Set(result.jobs.map((j) => j.id));
+        const queuedRows = queueManager
+            .getJobs()
+            .filter((j) => j.status === 'queued' && !dbIds.has(j.id))
+            .filter((j) => !status || j.status === status)
+            .map((j) => ({
+            id: j.id,
+            command: j.command,
+            started_at: j.startedAt ?? new Date().toISOString(),
+            finished_at: j.finishedAt,
+            status: j.status,
+            exit_code: j.exitCode,
+            queue_position: j.queuePosition,
+            priority: j.priority,
+            tokens_in: null,
+            tokens_out: null,
+            tokens_cache_read: null,
+            tokens_cache_create: null,
+            total_cost_usd: null,
+            num_turns: null,
+            model: null,
+            duration_ms: null,
+            duration_api_ms: null,
+            session_id: null,
+            depends_on_job_id: j.dependsOnJobId,
+            pipeline_id: j.pipelineId,
+            skip_reason: j.skipReason,
+        }));
+        if (queuedRows.length > 0) {
+            result.jobs = [...queuedRows, ...result.jobs];
+            result.total += queuedRows.length;
+        }
+        // Annotate each job with hasTelemetry so the client can show the
+        // Export diagnostic button without an extra round trip.
+        const jobsWithTelemetry = (0, db_1.getJobsWithTelemetry)(db);
+        const annotatedJobs = result.jobs.map((j) => ({
+            ...j,
+            hasTelemetry: jobsWithTelemetry.has(j.id),
+        }));
+        res.json({ jobs: annotatedJobs, total: result.total });
+    });
+    // ─── CSV helper ──────────────────────────────────────────────────────────────
+    const toCsv = (headers, rows) => {
+        const escape = (v) => {
+            const s = v == null ? '' : String(v);
+            return s.includes(',') || s.includes('"') || s.includes('\n') ? `"${s.replace(/"/g, '""')}"` : s;
+        };
+        const lines = [headers.join(',')];
+        for (const row of rows) {
+            lines.push(headers.map(h => escape(row[h])).join(','));
+        }
+        return lines.join('\n');
+    };
+    // ─── Jobs export (must be before /:projectId/jobs/:id) ─────────────────────
+    router.get('/:projectId/jobs/export', (req, res) => {
+        const format = req.query.format || 'json';
+        if (format !== 'json' && format !== 'csv') {
+            res.status(400).json({ error: 'Invalid format. Must be json or csv' });
+            return;
+        }
+        const from = req.query.from;
+        const to = req.query.to;
+        const { db } = ctx(req);
+        const conditions = [];
+        const params = [];
+        if (from) {
+            conditions.push('started_at >= ?');
+            params.push(from);
+        }
+        if (to) {
+            conditions.push('started_at <= ?');
+            params.push(to);
+        }
+        const where = conditions.length > 0 ? `WHERE ${conditions.join(' AND ')}` : '';
+        const jobs = db
+            .prepare(`SELECT * FROM jobs ${where} ORDER BY started_at DESC LIMIT 10000`)
+            .all(...params);
+        if (format === 'csv') {
+            const headers = ['id', 'command', 'status', 'started_at', 'finished_at', 'duration_ms', 'tokens_in', 'tokens_out', 'tokens_cache_read', 'total_cost_usd', 'model'];
+            const csv = toCsv(headers, jobs);
+            res.setHeader('Content-Type', 'text/csv');
+            res.setHeader('Content-Disposition', 'attachment; filename="jobs-export.csv"');
+            res.send(csv);
+        }
+        else {
+            res.json({ jobs });
+        }
+    });
+    // Must be registered BEFORE /:projectId/jobs/:id, otherwise Express matches
+    // the parameterized route first with id='compare' and this never runs (the
+    // Job Comparison feature would always 404).
+    router.get('/:projectId/jobs/compare', (req, res) => {
+        const raw = req.query.jobIds;
+        if (!raw) {
+            res.status(400).json({ error: 'jobIds query param required (comma-separated, exactly 2)' });
+            return;
+        }
+        const ids = raw.split(',').map((s) => s.trim()).filter(Boolean);
+        if (ids.length !== 2) {
+            res.status(400).json({ error: 'Exactly 2 jobIds are required' });
+            return;
+        }
+        const { db } = ctx(req);
+        const rows = ids.map((id) => {
+            const job = db.prepare('SELECT * FROM jobs WHERE id = ?').get(id);
+            if (!job)
+                return null;
+            const phases = db.prepare("SELECT phase FROM job_phases WHERE job_id = ? AND state = 'done' ORDER BY updated_at ASC").all(id);
+            return {
+                id: job.id,
+                command: job.command,
+                status: job.status,
+                startedAt: job.started_at,
+                finishedAt: job.finished_at,
+                durationMs: job.duration_ms,
+                tokensIn: job.tokens_in,
+                tokensOut: job.tokens_out,
+                tokensCacheRead: job.tokens_cache_read,
+                totalCostUsd: job.total_cost_usd,
+                model: job.model,
+                phasesCompleted: phases.map((p) => p.phase),
+            };
+        });
+        const missing = ids.filter((_, i) => rows[i] === null);
+        if (missing.length > 0) {
+            res.status(404).json({ error: `Jobs not found: ${missing.join(', ')}` });
+            return;
+        }
+        res.json({ jobs: rows });
+    });
+    router.get('/:projectId/jobs/:id', (req, res) => {
+        const { db, queueManager, project } = ctx(req);
+        const jobId = req.params.id;
+        const job = (0, db_1.getJob)(db, jobId);
+        if (!job) {
+            // Queued jobs live only in memory until spawn time (createJob runs on spawn,
+            // not enqueue). Fall back to the in-memory queue so /jobs/:id returns a
+            // usable payload instead of 404 — the detail page then renders a "queued"
+            // state and flips to live logs via WS once the job starts.
+            const inMemory = queueManager.getJobs().find((j) => j.id === jobId);
+            if (!inMemory) {
+                res.status(404).json({ error: 'Job not found' });
+                return;
+            }
+            const synthetic = {
+                id: inMemory.id,
+                command: inMemory.command,
+                started_at: inMemory.startedAt ?? '',
+                finished_at: inMemory.finishedAt,
+                status: inMemory.status,
+                exit_code: inMemory.exitCode,
+                queue_position: inMemory.queuePosition,
+                priority: inMemory.priority,
+                tokens_in: null,
+                tokens_out: null,
+                tokens_cache_read: null,
+                tokens_cache_create: null,
+                total_cost_usd: null,
+                num_turns: null,
+                model: null,
+                duration_ms: null,
+                duration_api_ms: null,
+                session_id: null,
+                depends_on_job_id: inMemory.dependsOnJobId,
+                pipeline_id: inMemory.pipelineId,
+                skip_reason: inMemory.skipReason,
+            };
+            const phaseDefinitions = queueManager.phasesForCommand(synthetic.command);
+            const tickets = (0, ticket_store_1.resolveTicketsFromCommand)(project.path, synthetic.command);
+            res.json({ job: { ...synthetic, hasTelemetry: false, tickets }, events: [], phaseDefinitions });
+            return;
+        }
+        const events = (0, db_1.getJobEvents)(db, jobId);
+        const phaseDefinitions = queueManager.phasesForCommand(job.command);
+        const tickets = (0, ticket_store_1.resolveTicketsFromCommand)(project.path, job.command);
+        const annotated = { ...job, hasTelemetry: (0, db_1.hasJobTelemetry)(db, jobId), tickets };
+        res.json({ job: annotated, events, phaseDefinitions });
+    });
+    router.delete('/:projectId/jobs', (req, res) => {
+        try {
+            const { from, to } = req.body ?? {};
+            const deleted = (0, db_1.purgeJobs)(ctx(req).db, { from, to });
+            res.json({ ok: true, deleted });
+        }
+        catch (err) {
+            console.error('[project-router] purge error:', err);
+            res.status(500).json({ error: 'Failed to purge jobs' });
+        }
+    });
+    router.get('/:projectId/activity', (req, res) => {
+        const limit = Math.min(Math.max(1, parseInt(String(req.query.limit ?? '50'), 10) || 50), 100);
+        const before = req.query.before;
+        res.json((0, db_1.getProjectActivity)(ctx(req).db, { limit, before }));
+    });
+    router.get('/:projectId/stats', (req, res) => {
+        res.json((0, db_1.getStats)(ctx(req).db));
+    });
+    router.get('/:projectId/metrics', (req, res) => {
+        const { project, db } = ctx(req);
+        try {
+            res.json((0, metrics_1.getProjectMetrics)(project.path, db));
+        }
+        catch (err) {
+            console.error('[project-router] metrics error:', err);
+            res.status(500).json({ error: 'Failed to compute metrics' });
+        }
+    });
+}