specrails-desktop 2.64.1 → 2.65.0

package/server/dist/modules/flow/adapters/http.js

@@ -0,0 +1,147 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerFlowHttp = registerFlowHttp;
+const __1 = require("..");
+/**
+ * Inbound adapter: thin, project-scoped Flow routes. Translates HTTP into use
+ * cases and domain errors into status codes. Mounted under
+ * `/api/projects/:projectId` by the project router.
+ */
+const ID_RE = /^[A-Za-z0-9-]{1,64}$/;
+function fail(res, error) {
+    if (error instanceof __1.FlowValidationError) {
+        res.status(400).json({ error: error.code, detail: error.message });
+        return;
+    }
+    if (error instanceof __1.FlowNotFoundError) {
+        res.status(404).json({ error: error.code, detail: error.message });
+        return;
+    }
+    if (error instanceof __1.FlowUnavailableError) {
+        res.status(409).json({ error: error.code, detail: error.message, missing: error.missing });
+        return;
+    }
+    if (error instanceof __1.FlowConflictError) {
+        res.status(409).json({ error: error.code, detail: error.message, ...(error.flowId ? { flowId: error.flowId } : {}) });
+        return;
+    }
+    if (error instanceof __1.FlowTransitionError) {
+        res.status(409).json({ error: error.code, detail: error.message });
+        return;
+    }
+    if (error instanceof __1.FlowLaunchRejectedError) {
+        res.status(error.status >= 400 && error.status < 500 ? error.status : 502).json({ error: error.code, detail: error.message });
+        return;
+    }
+    console.error('[flow] request failed:', error);
+    res.status(500).json({ error: 'flow_failed', detail: error instanceof Error ? error.message : String(error) });
+}
+function optionalString(value, field) {
+    if (value === undefined || value === null)
+        return undefined;
+    if (typeof value !== 'string' || !value.trim() || value.length > 200)
+        throw new __1.FlowValidationError(`invalid_${field}`, `${field} must be a non-empty string`);
+    return value.trim();
+}
+function registerFlowHttp(router, serviceForRequest) {
+    const withService = (handler) => async (req, res) => {
+        const service = serviceForRequest(req);
+        if (!service) {
+            res.status(409).json({ error: 'feature_unavailable', detail: 'Flow is not available in this project' });
+            return;
+        }
+        try {
+            await handler(service, req, res);
+        }
+        catch (error) {
+            fail(res, error);
+        }
+    };
+    const flowId = (req) => {
+        const id = String(req.params.flowId ?? '');
+        if (!ID_RE.test(id))
+            throw new __1.FlowValidationError('invalid_flow_id', 'Invalid flow id');
+        return id;
+    };
+    // Capability gate the client uses to offer Flow (flowSessions + deriveChange).
+    router.get('/:projectId/flow/availability', withService(async (service, _req, res) => {
+        res.json(await service.availability());
+    }));
+    router.post('/:projectId/flow', withService(async (service, req, res) => {
+        const body = (req.body ?? {});
+        // `ticketId`: start from that existing spec (the idea is then optional).
+        if (body.ticketId !== undefined && body.ticketId !== null && (typeof body.ticketId !== 'number' || !Number.isSafeInteger(body.ticketId) || body.ticketId <= 0)) {
+            throw new __1.FlowValidationError('invalid_ticket_id', 'ticketId must be a positive integer');
+        }
+        const flow = await service.startFlow({
+            conversationId: typeof body.conversationId === 'string' ? body.conversationId : '',
+            idea: typeof body.idea === 'string' ? body.idea : '',
+            ...(typeof body.ticketId === 'number' ? { ticketId: body.ticketId } : {}),
+            ...(body.title !== undefined ? { title: optionalString(body.title, 'title') ?? null } : {}),
+            ...(body.flowId !== undefined ? { flowId: String(body.flowId) } : {}),
+            // The repository the Flow runs in (workspace / multi-repository projects).
+            ...(body.repositoryId !== undefined && body.repositoryId !== null ? { repositoryId: optionalString(body.repositoryId, 'repositoryId') ?? null } : {}),
+        });
+        res.status(201).json({ flow });
+    }));
+    // The project's conversations in Flow mode (the mission list marks them).
+    router.get('/:projectId/flow/open', withService((service, _req, res) => {
+        res.json({ flows: service.listOpen().map((flow) => ({ id: flow.id, conversationId: flow.conversationId, state: flow.state, branch: flow.branch })) });
+    }));
+    router.get('/:projectId/flow/by-conversation/:conversationId', withService((service, req, res) => {
+        const conversationId = String(req.params.conversationId ?? '');
+        if (!conversationId || conversationId.length > 200)
+            throw new __1.FlowValidationError('invalid_conversation_id', 'Invalid conversation id');
+        res.json({ flow: service.getByConversation(conversationId) });
+    }));
+    const deliveryId = (req) => {
+        const id = String(req.params.deliveryId ?? '');
+        if (!ID_RE.test(id))
+            throw new __1.FlowValidationError('invalid_delivery_id', 'Invalid delivery id');
+        return id;
+    };
+    // Back to Flow: a Flow -> Spec run stopped with requested changes; its
+    // worktree returns to the Flow (same mount) and the agent session reopens.
+    router.post('/:projectId/flow/by-delivery/:deliveryId/return', withService(async (service, req, res) => {
+        res.json({ flow: await service.returnToFlow({ deliveryId: deliveryId(req) }) });
+    }));
+    // Relaunch Flow -> Spec on the SAME worktree (same rail and engine choices).
+    router.post('/:projectId/flow/by-delivery/:deliveryId/relaunch', withService(async (service, req, res) => {
+        res.status(202).json(await service.relaunchFlow({ deliveryId: deliveryId(req) }));
+    }));
+    router.get('/:projectId/flow/:flowId', withService((service, req, res) => {
+        res.json({ flow: service.getFlow(flowId(req)) });
+    }));
+    router.post('/:projectId/flow/:flowId/pause', withService(async (service, req, res) => {
+        res.json({ flow: await service.pauseFlow(flowId(req)) });
+    }));
+    router.post('/:projectId/flow/:flowId/resume', withService(async (service, req, res) => {
+        res.json({ flow: await service.resumeFlow(flowId(req)) });
+    }));
+    router.post('/:projectId/flow/:flowId/discard', withService(async (service, req, res) => {
+        res.json({ flow: await service.discardFlow(flowId(req)) });
+    }));
+    router.post('/:projectId/flow/:flowId/close', withService(async (service, req, res) => {
+        res.json({ flow: await service.closeFlow(flowId(req)) });
+    }));
+    router.post('/:projectId/flow/:flowId/hand-off', withService(async (service, req, res) => {
+        const body = (req.body ?? {});
+        if (typeof body.railIndex !== 'number' || !Number.isSafeInteger(body.railIndex) || body.railIndex < 0) {
+            throw new __1.FlowValidationError('invalid_rail_index', 'railIndex must be a non-negative integer');
+        }
+        const options = {
+            loopId: optionalString(body.loopId, 'loopId'),
+            aiEngine: optionalString(body.aiEngine, 'aiEngine'),
+            model: optionalString(body.model, 'model'),
+            reasoningEffort: optionalString(body.reasoning_effort ?? body.reasoningEffort, 'reasoning_effort'),
+        };
+        const result = await service.handOffFlow({ flowId: flowId(req), railIndex: body.railIndex, options });
+        res.status(202).json(result);
+    }));
+    router.get('/:projectId/flow/:flowId/diff', withService(async (service, req, res) => {
+        res.json(await service.diffSummary(flowId(req)));
+    }));
+    router.get('/:projectId/flow/:flowId/cost', withService((service, req, res) => {
+        res.json(service.costSoFar(flowId(req)));
+    }));
+}

package/server/dist/modules/flow/adapters/sqlite.js

@@ -0,0 +1,121 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSqliteFlowRepository = createSqliteFlowRepository;
+exports.createSqliteFlowEffectsStore = createSqliteFlowEffectsStore;
+const domain_1 = require("../domain");
+function toSession(row) {
+    return {
+        id: row.id,
+        conversationId: row.conversation_id,
+        ticketId: row.ticket_id,
+        state: row.state,
+        branch: row.branch,
+        worktreePath: row.worktree_path,
+        baseSha: row.base_sha,
+        headSha: row.head_sha,
+        coreSessionId: row.core_session_id,
+        railIndex: row.rail_index,
+        deliveryId: row.delivery_id,
+        step: row.step,
+        ...(row.return_briefing ? { returnBriefing: row.return_briefing } : {}),
+        ...(parseDerivedChanges(row.derived_changes).length ? { derivedChanges: parseDerivedChanges(row.derived_changes) } : {}),
+        ...(row.repository_id ? { repositoryId: row.repository_id } : {}),
+        ...(row.spec_origin === 'existing' ? { specOrigin: 'existing' } : {}),
+        createdAt: row.created_at,
+        updatedAt: row.updated_at,
+    };
+}
+/** `derived_changes` (migration 79): a JSON array of OpenSpec change ids; anything else reads as none. */
+function parseDerivedChanges(raw) {
+    if (!raw)
+        return [];
+    try {
+        const value = JSON.parse(raw);
+        return Array.isArray(value) ? value.filter(domain_1.isOpenSpecChangeId) : [];
+    }
+    catch {
+        return [];
+    }
+}
+function params(session) {
+    return [
+        session.conversationId, session.ticketId, session.state, session.branch, session.worktreePath,
+        session.baseSha, session.headSha, session.coreSessionId, session.railIndex, session.deliveryId,
+        session.step, session.returnBriefing ?? null, session.derivedChanges?.length ? JSON.stringify(session.derivedChanges) : null, session.repositoryId ?? null,
+        session.specOrigin === 'existing' ? 'existing' : null, session.createdAt, session.updatedAt, session.id,
+    ];
+}
+function isUniqueViolation(error) {
+    const code = error?.code;
+    return code === 'SQLITE_CONSTRAINT_UNIQUE' || code === 'SQLITE_CONSTRAINT_PRIMARYKEY' || /UNIQUE constraint failed/i.test(String(error?.message));
+}
+/** Repository bound to ONE project connection (project isolation). */
+function createSqliteFlowRepository(db) {
+    const select = (where, ...args) => {
+        const row = db.prepare(`SELECT * FROM flow_sessions WHERE ${where}`).get(...args);
+        return row ? toSession(row) : null;
+    };
+    return {
+        insert(session) {
+            try {
+                db.prepare(`INSERT INTO flow_sessions (conversation_id, ticket_id, state, branch, worktree_path, base_sha, head_sha,
+          core_session_id, rail_index, delivery_id, step, return_briefing, derived_changes, repository_id, spec_origin, created_at, updated_at, id) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(...params(session));
+            }
+            catch (error) {
+                if (!isUniqueViolation(error))
+                    throw error;
+                const open = select(`conversation_id = ? AND state IN ('active','paused')`, session.conversationId);
+                throw new domain_1.FlowConflictError('flow_already_open', 'This conversation already has a Flow; resume or discard it first', open?.id ?? session.id);
+            }
+        },
+        save(session) {
+            const result = db.prepare(`UPDATE flow_sessions SET conversation_id = ?, ticket_id = ?, state = ?, branch = ?, worktree_path = ?,
+        base_sha = ?, head_sha = ?, core_session_id = ?, rail_index = ?, delivery_id = ?, step = ?, return_briefing = ?, derived_changes = ?, repository_id = ?, spec_origin = ?, created_at = ?, updated_at = ?
+        WHERE id = ?`).run(...params(session));
+            if (result.changes === 0)
+                throw new Error(`Flow ${session.id} does not exist`);
+        },
+        get: (flowId) => select('id = ?', flowId),
+        findOpenByConversation: (conversationId) => select(`conversation_id = ? AND state IN ('active','paused')`, conversationId),
+        latestByConversation: (conversationId) => select('conversation_id = ? ORDER BY created_at DESC, rowid DESC LIMIT 1', conversationId),
+        listUnsettled() {
+            const rows = db.prepare(`SELECT * FROM flow_sessions WHERE state IN ('active','paused') OR step IS NOT NULL ORDER BY created_at`).all();
+            return rows.map(toSession);
+        },
+        listHandedOff() {
+            const rows = db.prepare(`SELECT * FROM flow_sessions WHERE state = 'handed_off' ORDER BY created_at`).all();
+            return rows.map(toSession);
+        },
+        findByDelivery: (deliveryId) => select('delivery_id = ? ORDER BY created_at DESC LIMIT 1', deliveryId),
+    };
+}
+function toEffect(row) {
+    return {
+        key: row.effect_key, flowId: row.flow_id, kind: row.kind, seq: row.seq,
+        status: row.status, attempts: row.attempts, lastError: row.last_error, note: row.note,
+        nextAttemptAt: row.next_attempt_at, createdAt: row.created_at, updatedAt: row.updated_at,
+    };
+}
+/** Settlement effects bound to ONE project connection. */
+function createSqliteFlowEffectsStore(db) {
+    return {
+        enqueue(effects) {
+            const insert = db.prepare(`INSERT OR IGNORE INTO flow_effects (effect_key, flow_id, kind, seq, status, attempts, last_error, note,
+        next_attempt_at, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`);
+            db.transaction(() => {
+                for (const e of effects)
+                    insert.run(e.key, e.flowId, e.kind, e.seq, e.status, e.attempts, e.lastError, e.note, e.nextAttemptAt, e.createdAt, e.updatedAt);
+            })();
+        },
+        list(flowId) {
+            return db.prepare(`SELECT * FROM flow_effects WHERE flow_id = ? ORDER BY seq`).all(flowId).map(toEffect);
+        },
+        save(e) {
+            db.prepare(`UPDATE flow_effects SET status = ?, attempts = ?, last_error = ?, note = ?, next_attempt_at = ?, updated_at = ?
+        WHERE effect_key = ?`).run(e.status, e.attempts, e.lastError, e.note, e.nextAttemptAt, e.updatedAt, e.key);
+        },
+        pendingFlowIds() {
+            return db.prepare(`SELECT DISTINCT flow_id FROM flow_effects WHERE status = 'pending' ORDER BY flow_id`).all().map((row) => row.flow_id);
+        },
+    };
+}