specrails-desktop 2.64.2 → 2.65.0

package/server/dist/modules/specs/runtime/ticket-trash.js

@@ -0,0 +1,193 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TRASH_RETENTION_MS = exports.TRASH_RETENTION_DAYS = void 0;
+exports.trashPathFor = trashPathFor;
+exports.softDeleteTicket = softDeleteTicket;
+exports.restoreTicket = restoreTicket;
+exports.listTrashedTickets = listTrashedTickets;
+exports.purgeTrashedTicket = purgeTrashedTicket;
+exports.purgeExpiredTickets = purgeExpiredTickets;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const ticket_store_1 = require("./ticket-store");
+/**
+ * Soft-delete ("Recently deleted") for specs.
+ *
+ * The ticket store is a JSON file shared with specrails-core, so a `deleted_at`
+ * flag inside it would leave deleted specs visible to Core and to every direct
+ * reader. Instead a deleted spec MOVES to a sibling `<store>.trash.json`: every
+ * list/search/API/Core read sees it gone, restore moves it back under the same
+ * id (ids are never reused: `next_id` is monotonic), and a purge drops entries
+ * older than the retention window.
+ *
+ * Crash safety: delete writes the trash entry BEFORE removing the live ticket
+ * and restore removes the trash entry AFTER re-inserting, so a crash can only
+ * leave the spec in both places — never in neither. Every operation is
+ * idempotent; a spec found live is never overwritten by its trash copy.
+ */
+exports.TRASH_RETENTION_DAYS = 30;
+exports.TRASH_RETENTION_MS = exports.TRASH_RETENTION_DAYS * 24 * 60 * 60 * 1000;
+function trashPathFor(storePath) {
+    const dir = path_1.default.dirname(storePath);
+    const base = path_1.default.basename(storePath).replace(/\.json$/i, '');
+    return path_1.default.join(dir, `${base}.trash.json`);
+}
+function readTrash(trashPath) {
+    let raw;
+    try {
+        raw = fs_1.default.readFileSync(trashPath, 'utf-8');
+    }
+    catch (err) {
+        if (err.code === 'ENOENT')
+            return { version: 1, items: {} };
+        throw err;
+    }
+    // A present-but-corrupt trash must never be blanked by the next write.
+    const data = JSON.parse(raw);
+    if (!data || typeof data !== 'object' || !data.items || typeof data.items !== 'object') {
+        throw new Error(`ticket trash at ${trashPath} has an unexpected shape`);
+    }
+    return data;
+}
+function writeTrash(trashPath, data) {
+    if (Object.keys(data.items).length === 0) {
+        try {
+            fs_1.default.unlinkSync(trashPath);
+        }
+        catch { /* already gone */ }
+        return;
+    }
+    fs_1.default.mkdirSync(path_1.default.dirname(trashPath), { recursive: true });
+    const tmp = trashPath + '.tmp';
+    fs_1.default.writeFileSync(tmp, JSON.stringify(data, null, 2), 'utf-8');
+    fs_1.default.renameSync(tmp, trashPath);
+}
+function withTrash(storePath, fn) {
+    const trashPath = trashPathFor(storePath);
+    (0, ticket_store_1.acquireFileLock)(trashPath);
+    try {
+        const trash = readTrash(trashPath);
+        const result = fn(trash);
+        writeTrash(trashPath, trash);
+        return result;
+    }
+    finally {
+        (0, ticket_store_1.releaseFileLock)(trashPath);
+    }
+}
+/** Move a spec to the trash. Returns null when the spec is neither live nor trashed. */
+function softDeleteTicket(storePath, ticketId, now = new Date()) {
+    const key = String(ticketId);
+    const live = (0, ticket_store_1.readStore)(storePath).tickets[key];
+    if (!live) {
+        const trashed = withTrash(storePath, (t) => t.items[key]);
+        if (!trashed)
+            return null;
+        return { ticket: trashed.ticket, orphanedChildren: [], revision: (0, ticket_store_1.readStore)(storePath).revision, alreadyTrashed: true };
+    }
+    const orphanedChildIds = Object.values((0, ticket_store_1.readStore)(storePath).tickets)
+        .filter((c) => live.is_epic && c.parent_epic_id === ticketId)
+        .map((c) => c.id);
+    withTrash(storePath, (t) => {
+        t.items[key] = { ticket: live, deleted_at: now.toISOString(), orphaned_child_ids: orphanedChildIds };
+    });
+    const orphanedChildren = [];
+    const store = (0, ticket_store_1.mutateStore)(storePath, (s) => {
+        if (!s.tickets[key])
+            return;
+        // SMASH: deleting an epic orphans its children rather than cascading.
+        if (s.tickets[key].is_epic) {
+            const stamp = now.toISOString();
+            for (const childId of Object.keys(s.tickets)) {
+                const child = s.tickets[childId];
+                if (child.parent_epic_id === ticketId) {
+                    child.parent_epic_id = null;
+                    child.execution_order = null;
+                    child.updated_at = stamp;
+                    orphanedChildren.push(child);
+                }
+            }
+        }
+        delete s.tickets[key];
+    });
+    return { ticket: live, orphanedChildren, revision: store.revision, alreadyTrashed: false };
+}
+/** Move a spec back from the trash. Returns null when it is in neither place. */
+function restoreTicket(storePath, ticketId, now = new Date()) {
+    const key = String(ticketId);
+    const entry = withTrash(storePath, (t) => t.items[key]);
+    const current = (0, ticket_store_1.readStore)(storePath);
+    if (!entry) {
+        const live = current.tickets[key];
+        return live ? { ticket: live, readoptedChildren: [], revision: current.revision, alreadyLive: true } : null;
+    }
+    const readoptedChildren = [];
+    let alreadyLive = false;
+    let restored = entry.ticket;
+    const store = (0, ticket_store_1.mutateStore)(storePath, (s) => {
+        if (s.tickets[key]) {
+            alreadyLive = true;
+            restored = s.tickets[key];
+            return;
+        }
+        restored = { ...entry.ticket, updated_at: now.toISOString() };
+        s.tickets[key] = restored;
+        if (ticketId >= s.next_id)
+            s.next_id = ticketId + 1;
+        if (restored.is_epic) {
+            for (const childId of entry.orphaned_child_ids) {
+                const child = s.tickets[String(childId)];
+                if (child && child.parent_epic_id === null) {
+                    child.parent_epic_id = ticketId;
+                    child.updated_at = now.toISOString();
+                    readoptedChildren.push(child);
+                }
+            }
+        }
+        // A parent epic that is no longer there cannot be re-adopted: stand alone.
+        if (restored.parent_epic_id !== null && !s.tickets[String(restored.parent_epic_id)]?.is_epic) {
+            restored.parent_epic_id = null;
+            restored.execution_order = null;
+        }
+    });
+    withTrash(storePath, (t) => { delete t.items[key]; });
+    return { ticket: restored, readoptedChildren, revision: store.revision, alreadyLive };
+}
+/** The trash, newest deletion first. Entries whose id is live again are crash leftovers and hidden. */
+function listTrashedTickets(storePath) {
+    const live = (0, ticket_store_1.readStore)(storePath).tickets;
+    const trash = withTrash(storePath, (t) => Object.values(t.items));
+    return trash
+        .filter((e) => !live[String(e.ticket.id)])
+        .sort((a, b) => b.deleted_at.localeCompare(a.deleted_at));
+}
+/** Remove one entry for good. Returns the removed spec so the caller can run its cascade. */
+function purgeTrashedTicket(storePath, ticketId) {
+    return withTrash(storePath, (t) => {
+        const entry = t.items[String(ticketId)];
+        if (!entry)
+            return null;
+        delete t.items[String(ticketId)];
+        return entry;
+    });
+}
+/** Remove every entry older than the retention window. Idempotent. */
+function purgeExpiredTickets(storePath, now = new Date(), retentionMs = exports.TRASH_RETENTION_MS) {
+    const cutoff = now.getTime() - retentionMs;
+    if (!fs_1.default.existsSync(trashPathFor(storePath)))
+        return [];
+    return withTrash(storePath, (t) => {
+        const expired = [];
+        for (const [key, entry] of Object.entries(t.items)) {
+            const at = Date.parse(entry.deleted_at);
+            if (Number.isNaN(at) || at <= cutoff) {
+                expired.push(entry);
+                delete t.items[key];
+            }
+        }
+        return expired;
+    });
+}

package/server/dist/modules/specs/runtime/triage-runner.js

@@ -0,0 +1,171 @@
+"use strict";
+// Spec triage — the one provider call (launch-triage).
+//
+// A single pure-output turn on the triage engine: no tools, no repository
+// access, one JSON answer. Usage is finalised from the provider's own events so
+// the caller records the REAL cost (or null) on the `triage` accounting surface;
+// a failure after the provider billed tokens carries that partial usage too.
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runTriageModel = exports.TriageModelError = exports.TRIAGE_TIMEOUT_MS = void 0;
+const readline_1 = require("readline");
+const tree_kill_1 = __importDefault(require("tree-kill"));
+const providers_1 = require("../../../providers");
+const runtime_1 = require("../../../providers/runtime");
+const cli_prompt_1 = require("../../../util/cli-prompt");
+const transient_children_1 = require("../../../transient-children");
+const workspace_resolution_1 = require("../../../workspace-resolution");
+const result_event_1 = require("../../accounting/runtime/result-event");
+exports.TRIAGE_TIMEOUT_MS = 90_000;
+const MAX_OUTPUT_CHARS = 32_000;
+/** Error raised by the runner; `partial` carries usage billed before failing. */
+class TriageModelError extends Error {
+    partial;
+    constructor(message, partial) {
+        super(message);
+        this.partial = partial;
+        this.name = 'TriageModelError';
+    }
+}
+exports.TriageModelError = TriageModelError;
+const runTriageModel = (request) => {
+    const adapter = (0, providers_1.getAdapter)(request.provider);
+    const toolPolicy = (0, runtime_1.pureOutputToolPolicy)(adapter);
+    if (!toolPolicy)
+        return Promise.reject(new TriageModelError(`provider_tool_policy_unsupported:${adapter.id}:pure-output`));
+    const startedAt = Date.now();
+    const options = {
+        prompt: adapter.capabilities.systemPromptArg ? request.userPrompt : `${request.systemPrompt}\n\n${request.userPrompt}`,
+        systemPrompt: adapter.capabilities.systemPromptArg ? request.systemPrompt : undefined,
+        model: request.model,
+        maxTurns: 1,
+        toolPolicy,
+    };
+    const args = adapter.buildArgs('spec-gen', options);
+    // Same cwd/env contract as spec generation (relocated ⇒ workspace).
+    const exec = (0, workspace_resolution_1.resolveProjectExecution)({ slug: request.project.slug, path: request.project.path });
+    let env = process.env;
+    if (exec.relocated) {
+        env = { ...process.env, ...exec.env };
+        if (adapter.id === 'gemini')
+            env = { ...env, GEMINI_CLI_TRUST_WORKSPACE: 'true' };
+    }
+    const child = (0, cli_prompt_1.spawnAiCli)(adapter.binary, args, {
+        env: (0, runtime_1.buildProviderEnv)(adapter, options, env),
+        stdio: ['ignore', 'pipe', 'pipe'],
+        cwd: exec.cwd,
+    });
+    (0, transient_children_1.trackTransientChild)(request.projectId, child);
+    return new Promise((resolve, reject) => {
+        const events = [];
+        let text = '';
+        let stderr = '';
+        let providerError = null;
+        let settled = false;
+        const usage = () => {
+            if (events.length === 0)
+                return undefined;
+            try {
+                const { result, estimated } = (0, result_event_1.finaliseInvocationResult)(adapter, events, { fallbackModel: request.model });
+                return {
+                    model: result.model ?? request.model,
+                    provider: adapter.id,
+                    costUsd: result.total_cost_usd ?? null,
+                    costEstimated: estimated,
+                    tokensIn: result.tokens_in ?? null,
+                    tokensOut: result.tokens_out ?? null,
+                    tokensCacheRead: result.tokens_cache_read,
+                    tokensCacheCreate: result.tokens_cache_create,
+                    durationMs: result.duration_ms ?? (Date.now() - startedAt),
+                };
+            }
+            catch {
+                return undefined;
+            }
+        };
+        const kill = () => {
+            if (child.pid) {
+                try {
+                    (0, tree_kill_1.default)(child.pid, 'SIGTERM');
+                }
+                catch { /* best effort */ }
+            }
+            else {
+                try {
+                    child.kill('SIGTERM');
+                }
+                catch { /* best effort */ }
+            }
+        };
+        const fail = (message, killChild = false) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            request.signal?.removeEventListener('abort', onAbort);
+            if (killChild)
+                kill();
+            reject(new TriageModelError(message, usage()));
+        };
+        const onAbort = () => fail('triage aborted', true);
+        const timer = setTimeout(() => fail(`triage timeout after ${exports.TRIAGE_TIMEOUT_MS}ms`, true), exports.TRIAGE_TIMEOUT_MS);
+        if (typeof timer.unref === 'function')
+            timer.unref();
+        request.signal?.addEventListener('abort', onAbort, { once: true });
+        child.stderr?.on('data', (chunk) => {
+            stderr = (stderr + chunk.toString()).slice(-4096);
+        });
+        if (!child.stdout) {
+            fail('triage: child has no stdout', true);
+            return;
+        }
+        const reader = (0, readline_1.createInterface)({ input: child.stdout, crlfDelay: Infinity });
+        reader.on('line', (line) => {
+            if (settled)
+                return;
+            for (const ev of (0, runtime_1.parseStreamEvents)(adapter, line)) {
+                events.push(ev);
+                if (events.length > 1000)
+                    events.shift();
+                if (ev.kind === 'error')
+                    providerError = ev.message;
+                if (ev.kind === 'result' && ev.isError)
+                    providerError = String(ev.payload.result ?? 'Provider returned an error result');
+                if (ev.kind === 'text-delta')
+                    text += ev.text;
+            }
+            if (text.length > MAX_OUTPUT_CHARS)
+                fail('triage output exceeded the limit', true);
+        });
+        child.on('error', (err) => fail(err.message));
+        child.on('close', (code) => {
+            if (settled)
+                return;
+            if (code !== 0) {
+                fail(`${adapter.binary} exit code=${code}${stderr ? `; stderr=${stderr.slice(-300)}` : ''}`);
+                return;
+            }
+            if (providerError) {
+                fail(providerError.slice(0, 500));
+                return;
+            }
+            if (!text.trim()) {
+                fail('triage returned no text');
+                return;
+            }
+            settled = true;
+            clearTimeout(timer);
+            request.signal?.removeEventListener('abort', onAbort);
+            const final = usage() ?? {
+                model: request.model, provider: adapter.id, costUsd: null, costEstimated: false,
+                tokensIn: null, tokensOut: null, durationMs: Date.now() - startedAt,
+            };
+            resolve({ ...final, text });
+        });
+        if (request.signal?.aborted)
+            onAbort();
+    });
+};
+exports.runTriageModel = runTriageModel;