specrails-desktop 2.29.0 → 2.29.2

package/server/dist/jira/jira-sync-manager.js

@@ -6,7 +6,8 @@
 //     classification → retry / dead-letter / auth-pause),
 //   - the write-back hooks: onRailLaunch (todo→In Progress), onJobOutcome
 //     (Done / revert + completion comment), onRailReview (ask-first PR delivery
-//     settle → on_review) and onRailMerged / onRailDiscard (PR-decision outcomes),
+//     settle → on_review) and the merged/completed/refined/discarded decision
+//     outcomes (each with truthful, idempotent Jira semantics),
 // and stays completely inert until the project configures a Jira connection.
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.JiraSyncManager = void 0;
@@ -15,6 +16,8 @@ exports.formatJqlDate = formatJqlDate;
 exports.buildCompletionComment = buildCompletionComment;
 exports.buildRailReviewComment = buildRailReviewComment;
 exports.buildPrMergedComment = buildPrMergedComment;
+exports.buildRailCompletedComment = buildRailCompletedComment;
+exports.buildRailRefinedComment = buildRailRefinedComment;
 const node_crypto_1 = require("node:crypto");
 const ticket_store_1 = require("../ticket-store");
 const jira_client_1 = require("./jira-client");
@@ -49,6 +52,8 @@ class JiraSyncManager {
     notifyLocalWriteCb;
     pollTimer = null;
     drainTimer = null;
+    /** Exactly one outbox drain loop may claim work for this project at a time. */
+    drainPromise = null;
     /** When set, the outbox is paused pending re-auth (401). */
     authPaused = false;
     constructor(opts) {
@@ -722,12 +727,14 @@ class JiraSyncManager {
      * known) per Jira-linked ticket. Outbox-only: the local on_review→done cache
      * write is the caller's job (the decision endpoint mutates the ticket store
      * itself). NOT onJobOutcome — its completion comment assumes job cost/duration
-     * that a merge poll does not have. Never throws.
+     * that a merge poll does not have. Never throws. Returns false only when the
+     * durable Jira-outbox handoff itself failed; callers that do not need the
+     * acknowledgement may continue to ignore the return value.
      */
     onRailMerged(ticketIds, refId, prUrl) {
         try {
             if (!this.isActive())
-                return;
+                return true;
             const text = buildPrMergedComment(prUrl);
             const ops = [];
             for (const localId of ticketIds) {
@@ -749,13 +756,138 @@ class JiraSyncManager {
                 });
             }
             if (ops.length === 0)
-                return;
+                return true;
             (0, jira_db_1.enqueueMany)(this.db, ops);
             this.broadcastOutboxState();
             void this.drainOnce().catch(() => undefined);
+            return true;
         }
         catch (err) {
             console.error('[jira-sync] onRailMerged failed:', err);
+            return false;
+        }
+    }
+    /**
+     * Called when a fresh no-change result is explicitly accepted as complete.
+     * This is not a merge: enqueue a truthful no-PR comment plus Done transition,
+     * with action-specific keys so crash replay cannot duplicate either effect.
+     */
+    onRailCompleted(ticketIds, refId) {
+        try {
+            if (!this.isActive())
+                return true;
+            const text = buildRailCompletedComment();
+            const ops = [];
+            for (const localId of ticketIds) {
+                const link = (0, jira_db_1.getLinkByLocalId)(this.db, localId);
+                if (!link || link.tombstoned)
+                    continue;
+                ops.push({
+                    jiraIssueId: link.jiraIssueId,
+                    opType: 'comment',
+                    idempotencyKey: `${refId}:${localId}:comment:completed`,
+                    payload: {
+                        jiraIssueId: link.jiraIssueId,
+                        text,
+                        marker: (0, jira_adf_1.railCompletedCommentMarker)(refId, localId),
+                    },
+                });
+                ops.push({
+                    jiraIssueId: link.jiraIssueId,
+                    opType: 'transition',
+                    idempotencyKey: `${refId}:${localId}:transition:completed`,
+                    payload: { localId, jiraIssueId: link.jiraIssueId, logicalState: 'done' },
+                });
+            }
+            if (ops.length === 0)
+                return true;
+            (0, jira_db_1.enqueueMany)(this.db, ops);
+            this.broadcastOutboxState();
+            void this.drainOnce().catch(() => undefined);
+            return true;
+        }
+        catch (err) {
+            console.error('[jira-sync] onRailCompleted failed:', err);
+            return false;
+        }
+    }
+    /**
+     * Called when a fresh no-change result is returned for refinement. Refine is
+     * deliberately distinct from discard: it always goes to logical todo and
+     * never consults the configured discard/cancelled status.
+     */
+    onRailRefined(ticketIds, refId) {
+        try {
+            if (!this.isActive())
+                return true;
+            const text = buildRailRefinedComment();
+            const ops = [];
+            for (const localId of ticketIds) {
+                const link = (0, jira_db_1.getLinkByLocalId)(this.db, localId);
+                if (!link || link.tombstoned)
+                    continue;
+                ops.push({
+                    jiraIssueId: link.jiraIssueId,
+                    opType: 'comment',
+                    idempotencyKey: `${refId}:${localId}:comment:refine`,
+                    payload: {
+                        jiraIssueId: link.jiraIssueId,
+                        text,
+                        marker: (0, jira_adf_1.railRefinedCommentMarker)(refId, localId),
+                    },
+                });
+                ops.push({
+                    jiraIssueId: link.jiraIssueId,
+                    opType: 'transition',
+                    idempotencyKey: `${refId}:${localId}:transition:refine`,
+                    payload: { localId, jiraIssueId: link.jiraIssueId, logicalState: 'todo' },
+                });
+            }
+            if (ops.length === 0)
+                return true;
+            (0, jira_db_1.enqueueMany)(this.db, ops);
+            this.broadcastOutboxState();
+            void this.drainOnce().catch(() => undefined);
+            return true;
+        }
+        catch (err) {
+            console.error('[jira-sync] onRailRefined failed:', err);
+            return false;
+        }
+    }
+    /**
+     * Migration-only recovery for an ambiguous historical fresh discard. The
+     * only safe fact is that its local tickets must leave on_review for todo.
+     * Enqueue that transition without a causal comment and without consulting
+     * discardStatus, because v49 did not retain whether the user chose Refine or
+     * discarded a real delivery.
+     */
+    onRailBacklog(ticketIds, refId) {
+        try {
+            if (!this.isActive())
+                return true;
+            const ops = [];
+            for (const localId of ticketIds) {
+                const link = (0, jira_db_1.getLinkByLocalId)(this.db, localId);
+                if (!link || link.tombstoned)
+                    continue;
+                ops.push({
+                    jiraIssueId: link.jiraIssueId,
+                    opType: 'transition',
+                    idempotencyKey: `${refId}:${localId}:transition:backlog`,
+                    payload: { localId, jiraIssueId: link.jiraIssueId, logicalState: 'todo' },
+                });
+            }
+            if (ops.length === 0)
+                return true;
+            (0, jira_db_1.enqueueMany)(this.db, ops);
+            this.broadcastOutboxState();
+            void this.drainOnce().catch(() => undefined);
+            return true;
+        }
+        catch (err) {
+            console.error('[jira-sync] onRailBacklog failed:', err);
+            return false;
         }
     }
     /**
@@ -764,12 +896,13 @@ class JiraSyncManager {
      * (mirroring discardSpec's transition payload), else reverts it to the backlog
      * via a plain `todo` transition — a missing configuration is never an error.
      * Outbox-only like onRailMerged: local cache writes belong to the caller.
-     * Never throws.
+     * Never throws. Returns false only when the durable Jira-outbox handoff
+     * failed; existing fire-and-forget callers may ignore the acknowledgement.
      */
     onRailDiscard(ticketIds, refId) {
         try {
             if (!this.isActive())
-                return;
+                return true;
             const conn = (0, jira_db_1.getConnection)(this.db, this.projectId);
             const target = conn?.discardStatus ?? null;
             const ops = [];
@@ -789,17 +922,30 @@ class JiraSyncManager {
                 });
             }
             if (ops.length === 0)
-                return;
+                return true;
             (0, jira_db_1.enqueueMany)(this.db, ops);
             this.broadcastOutboxState();
             void this.drainOnce().catch(() => undefined);
+            return true;
         }
         catch (err) {
             console.error('[jira-sync] onRailDiscard failed:', err);
+            return false;
         }
     }
     // ─── Outbox drain ──────────────────────────────────────────────────────────
-    async drainOnce() {
+    drainOnce() {
+        if (this.drainPromise)
+            return this.drainPromise;
+        const running = this.drainUntilBlocked();
+        this.drainPromise = running;
+        void running.finally(() => {
+            if (this.drainPromise === running)
+                this.drainPromise = null;
+        }).catch(() => undefined);
+        return running;
+    }
+    async drainUntilBlocked() {
         if (this.authPaused)
             return;
         const conn = (0, jira_db_1.getConnection)(this.db, this.projectId);
@@ -808,11 +954,16 @@ class JiraSyncManager {
         const client = this.buildClient();
         if (!client)
             return;
-        const batch = (0, jira_db_1.claimDrainable)(this.db, MAX_DRAIN_BATCH);
-        if (batch.length === 0)
-            return;
-        await Promise.all(batch.map((op) => this.executeOp(client, conn, op)));
-        this.broadcastOutboxState();
+        let changed = false;
+        while (!this.authPaused) {
+            const batch = (0, jira_db_1.claimDrainable)(this.db, MAX_DRAIN_BATCH);
+            if (batch.length === 0)
+                break;
+            changed = true;
+            await Promise.all(batch.map((op) => this.executeOp(client, conn, op)));
+        }
+        if (changed)
+            this.broadcastOutboxState();
     }
     async executeOp(client, conn, op) {
         try {
@@ -1209,6 +1360,24 @@ function buildPrMergedComment(prUrl) {
         parts.push(`PR: ${prUrl}`);
     return parts.join('\n');
 }
+/** Comment posted when the user accepts a fresh no-change result as complete. */
+function buildRailCompletedComment() {
+    return [
+        'Specrails delivery accepted.',
+        'Result: no code changes were required.',
+        'No pull request was created.',
+        'Jira status: moving to Done.',
+    ].join('\n');
+}
+/** Comment posted when the user returns a fresh no-change result to refinement. */
+function buildRailRefinedComment() {
+    return [
+        'Specrails delivery returned for refinement.',
+        'Result: no code changes were accepted as complete.',
+        'No pull request was created.',
+        'Jira status: returning to the backlog.',
+    ].join('\n');
+}
 function formatDuration(ms) {
     const s = Math.round(ms / 1000);
     if (s < 60)

package/server/dist/job-listing.js

@@ -0,0 +1,140 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.listUnifiedJobs = listUnifiedJobs;
+exports.getQueuedJobForListing = getQueuedJobForListing;
+const QUEUED_SOURCE = `
+  WITH queued_source AS (
+    SELECT
+      q.id, q.command, q.queue_position, q.priority,
+      q.depends_on_job_id, q.pipeline_id, q.enqueued_at
+    FROM queued_jobs q
+    UNION ALL
+    SELECT
+      j.id, j.command, j.queue_position, j.priority,
+      j.depends_on_job_id, j.pipeline_id, j.started_at AS enqueued_at
+    FROM jobs j
+    WHERE j.status = 'queued'
+      AND NOT EXISTS (SELECT 1 FROM queued_jobs q WHERE q.id = j.id)
+  )
+`;
+function queuedConditions(opts) {
+    const conditions = [];
+    const params = [];
+    if (opts.from) {
+        conditions.push('datetime(enqueued_at) >= datetime(?)');
+        params.push(opts.from);
+    }
+    if (opts.to) {
+        conditions.push('datetime(enqueued_at) <= datetime(?)');
+        params.push(opts.to);
+    }
+    return {
+        sql: conditions.length > 0 ? `WHERE ${conditions.join(' AND ')}` : '',
+        params,
+    };
+}
+function historyConditions(opts) {
+    const conditions = ["jobs.status <> 'queued'"];
+    const params = [];
+    if (opts.status) {
+        conditions.push('jobs.status = ?');
+        params.push(opts.status);
+    }
+    if (opts.from) {
+        conditions.push('jobs.started_at >= ?');
+        params.push(opts.from);
+    }
+    if (opts.to) {
+        conditions.push('jobs.started_at <= ?');
+        params.push(opts.to);
+    }
+    return { sql: `WHERE ${conditions.join(' AND ')}`, params };
+}
+function toQueuedJobRow(row) {
+    return {
+        id: row.id,
+        command: row.command,
+        started_at: null,
+        enqueued_at: row.enqueued_at,
+        finished_at: null,
+        status: 'queued',
+        exit_code: null,
+        queue_position: row.queue_position,
+        priority: row.priority,
+        tokens_in: null,
+        tokens_out: null,
+        tokens_cache_read: null,
+        tokens_cache_create: null,
+        total_cost_usd: null,
+        total_cost_usd_estimated: null,
+        num_turns: null,
+        model: null,
+        duration_ms: null,
+        duration_api_ms: null,
+        session_id: null,
+        depends_on_job_id: row.depends_on_job_id,
+        pipeline_id: row.pipeline_id,
+        skip_reason: null,
+        profile_name: null,
+        interactive: 0,
+        provider: null,
+        owner: 'queue',
+    };
+}
+/**
+ * Page queued admissions and execution history as one stable sequence. Queued
+ * work remains first (in durable queue order), followed by history newest-first.
+ * Both total and offset apply to that combined sequence; no in-memory prepend
+ * can amplify the requested limit.
+ */
+function listUnifiedJobs(db, opts) {
+    const limit = Math.max(1, Math.min(opts.limit, 200));
+    const offset = Math.max(0, opts.offset);
+    const includeQueued = !opts.status || opts.status === 'queued';
+    const includeHistory = opts.status !== 'queued';
+    let queuedTotal = 0;
+    let queuedRows = [];
+    if (includeQueued) {
+        const queued = queuedConditions(opts);
+        queuedTotal = db.prepare(`${QUEUED_SOURCE} SELECT COUNT(*) AS count FROM queued_source ${queued.sql}`).get(...queued.params).count;
+        const queuedOffset = Math.min(offset, queuedTotal);
+        const queuedLimit = Math.min(limit, Math.max(0, queuedTotal - offset));
+        if (queuedLimit > 0) {
+            const rows = db.prepare(`
+        ${QUEUED_SOURCE}
+        SELECT * FROM queued_source
+        ${queued.sql}
+        ORDER BY queue_position ASC, id ASC
+        LIMIT ? OFFSET ?
+      `).all(...queued.params, queuedLimit, queuedOffset);
+            queuedRows = rows.map(toQueuedJobRow);
+        }
+    }
+    let historyTotal = 0;
+    let historyRows = [];
+    if (includeHistory) {
+        const history = historyConditions(opts);
+        historyTotal = db.prepare(`SELECT COUNT(*) AS count FROM jobs ${history.sql}`).get(...history.params).count;
+        const remaining = limit - queuedRows.length;
+        const historyOffset = Math.max(0, offset - queuedTotal);
+        if (remaining > 0 && historyOffset < historyTotal) {
+            historyRows = db.prepare(`
+        SELECT jobs.*, jp.profile_name AS profile_name, NULL AS enqueued_at
+        FROM jobs
+        LEFT JOIN job_profiles jp ON jp.job_id = jobs.id
+        ${history.sql}
+        ORDER BY jobs.started_at DESC, jobs.id ASC
+        LIMIT ? OFFSET ?
+      `).all(...history.params, remaining, historyOffset);
+        }
+    }
+    return { jobs: [...queuedRows, ...historyRows], total: queuedTotal + historyTotal };
+}
+/** Durable queued detail lookup used before execution creates a jobs row. */
+function getQueuedJobForListing(db, jobId) {
+    const row = db.prepare(`
+    ${QUEUED_SOURCE}
+    SELECT * FROM queued_source WHERE id = ?
+  `).get(jobId);
+    return row ? toQueuedJobRow(row) : undefined;
+}

package/server/dist/job-spawn-idempotency.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JobSpawnIdempotencyReplayError = exports.JobSpawnIdempotencyConflictError = exports.JOB_SPAWN_IDEMPOTENCY_TTL_MS = void 0;
+exports.fingerprintJobSpawn = fingerprintJobSpawn;
+exports.findIdempotentJob = findIdempotentJob;
+exports.rememberIdempotentJob = rememberIdempotentJob;
+exports.claimIdempotentJob = claimIdempotentJob;
+const crypto_1 = require("crypto");
+exports.JOB_SPAWN_IDEMPOTENCY_TTL_MS = 10 * 60 * 1000;
+class JobSpawnIdempotencyConflictError extends Error {
+    constructor() {
+        super('Idempotency-Key was already used for a different spawn request');
+        this.name = 'JobSpawnIdempotencyConflictError';
+    }
+}
+exports.JobSpawnIdempotencyConflictError = JobSpawnIdempotencyConflictError;
+/** Internal control-flow signal: another request already committed the exact
+ * same logical spawn. Throwing from QueueManager's outer admission transaction
+ * rolls the speculative queued_jobs row and in-memory job back before the route
+ * returns the original id. */
+class JobSpawnIdempotencyReplayError extends Error {
+    jobId;
+    constructor(jobId) {
+        super('Idempotent spawn already admitted');
+        this.jobId = jobId;
+        this.name = 'JobSpawnIdempotencyReplayError';
+    }
+}
+exports.JobSpawnIdempotencyReplayError = JobSpawnIdempotencyReplayError;
+/** Hash a canonical, route-owned payload so the ledger never has to duplicate
+ * the command text already stored in jobs. Callers must construct object keys
+ * in a stable order. */
+function fingerprintJobSpawn(payload) {
+    return (0, crypto_1.createHash)('sha256').update(JSON.stringify(payload)).digest('hex');
+}
+/** Return the original job for an unexpired matching request. Reusing a key
+ * with different semantics is a client error, never permission to enqueue. */
+function findIdempotentJob(db, key, fingerprint, nowMs = Date.now()) {
+    return db.transaction(() => {
+        db.prepare('DELETE FROM job_spawn_requests WHERE expires_at_ms <= ?').run(nowMs);
+        const row = db.prepare('SELECT fingerprint, job_id FROM job_spawn_requests WHERE idempotency_key = ?').get(key);
+        if (!row)
+            return null;
+        if (row.fingerprint !== fingerprint)
+            throw new JobSpawnIdempotencyConflictError();
+        return row.job_id;
+    })();
+}
+function rememberIdempotentJob(db, key, fingerprint, jobId, nowMs = Date.now()) {
+    db.prepare(`INSERT INTO job_spawn_requests
+       (idempotency_key, fingerprint, job_id, created_at_ms, expires_at_ms)
+     VALUES (?, ?, ?, ?, ?)`).run(key, fingerprint, jobId, nowMs, nowMs + exports.JOB_SPAWN_IDEMPOTENCY_TTL_MS);
+}
+/** Claim a key from INSIDE QueueManager's durable-admission transaction.
+ * Existing matching keys throw Replay so the speculative queue admission rolls
+ * back; mismatched keys throw Conflict; a new key is inserted atomically beside
+ * queued_jobs before QueueManager is allowed to drain. */
+function claimIdempotentJob(db, key, fingerprint, jobId, nowMs = Date.now()) {
+    db.prepare('DELETE FROM job_spawn_requests WHERE expires_at_ms <= ?').run(nowMs);
+    const row = db.prepare('SELECT fingerprint, job_id FROM job_spawn_requests WHERE idempotency_key = ?').get(key);
+    if (row) {
+        if (row.fingerprint !== fingerprint)
+            throw new JobSpawnIdempotencyConflictError();
+        throw new JobSpawnIdempotencyReplayError(row.job_id);
+    }
+    rememberIdempotentJob(db, key, fingerprint, jobId, nowMs);
+}