specrails-desktop 2.36.0 → 2.42.2

package/server/dist/agent-input-store.js

@@ -0,0 +1,206 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AgentInputLimitError = exports.AgentInputConflictError = exports.MAX_PENDING_AGENT_INPUTS = void 0;
+exports.getAgentInput = getAgentInput;
+exports.enqueueAgentInput = enqueueAgentInput;
+exports.listPendingAgentInputs = listPendingAgentInputs;
+exports.editPendingAgentInput = editPendingAgentInput;
+exports.steerPendingAgentInput = steerPendingAgentInput;
+exports.deletePendingAgentInput = deletePendingAgentInput;
+exports.setAgentInputReceipt = setAgentInputReceipt;
+exports.deliverAgentInput = deliverAgentInput;
+exports.interruptAgentInput = interruptAgentInput;
+exports.cancelPendingAgentInputs = cancelPendingAgentInputs;
+exports.recoverPendingAgentInputs = recoverPendingAgentInputs;
+exports.decorateAgentInputMessages = decorateAgentInputMessages;
+const crypto_1 = require("crypto");
+const agent_store_1 = require("./agent-store");
+exports.MAX_PENDING_AGENT_INPUTS = 50;
+class AgentInputConflictError extends Error {
+    code = 'agent_input_conflict';
+    constructor() { super('This message ID was already used for different content.'); this.name = 'AgentInputConflictError'; }
+}
+exports.AgentInputConflictError = AgentInputConflictError;
+class AgentInputLimitError extends Error {
+    code = 'agent_input_limit';
+    constructor() { super(`A conversation can have at most ${exports.MAX_PENDING_AGENT_INPUTS} pending messages.`); this.name = 'AgentInputLimitError'; }
+}
+exports.AgentInputLimitError = AgentInputLimitError;
+function mapInput(row) {
+    return {
+        id: row.id, conversationId: row.conversation_id, queueId: row.queue_id, text: row.text,
+        options: JSON.parse(row.options_json),
+        status: row.status, receipt: row.receipt, createdAt: row.created_at, messageId: row.message_id,
+    };
+}
+/** Stable key ordering makes equivalent HTTP retries independent of JSON key order. */
+function canonicalJson(value) {
+    const sort = (entry) => Array.isArray(entry)
+        ? entry.map(sort)
+        : entry && typeof entry === 'object'
+            ? Object.fromEntries(Object.entries(entry).sort(([a], [b]) => a.localeCompare(b)).map(([key, item]) => [key, sort(item)]))
+            : entry;
+    return JSON.stringify(sort(value));
+}
+function readRaw(db, conversationId, queueId) {
+    return db.prepare('SELECT * FROM agent_inputs WHERE conversation_id = ? AND queue_id = ?').get(conversationId, queueId);
+}
+function getAgentInput(db, conversationId, queueId) {
+    const row = readRaw(db, conversationId, queueId);
+    return row ? mapInput(row) : undefined;
+}
+function enqueueAgentInput(db, input) {
+    const queueId = input.queueId ?? (0, crypto_1.randomUUID)();
+    if (typeof queueId !== 'string' || queueId.trim().length === 0)
+        throw new Error('A message ID must be a nonempty string.');
+    if (typeof input.text !== 'string')
+        throw new Error('A message must contain text.');
+    if (input.options?.deliveryMode !== undefined && input.options.deliveryMode !== 'queue' && input.options.deliveryMode !== 'steer') {
+        throw new Error('Message deliveryMode must be queue or steer.');
+    }
+    // Copy only the supported options. Persist arrays even when empty so absent
+    // and explicitly empty metadata have the same idempotency semantics.
+    const options = {
+        ...(input.options?.tierLevel !== undefined ? { tierLevel: input.options.tierLevel } : {}),
+        ...(input.options?.model !== undefined ? { model: input.options.model } : {}),
+        ...(input.options?.deliveryMode !== undefined ? { deliveryMode: input.options.deliveryMode } : {}),
+        attachmentIds: input.options?.attachmentIds ?? [], contextRefs: input.options?.contextRefs ?? [],
+    };
+    const optionsJson = canonicalJson(options);
+    const payload = canonicalJson({ text: input.text, options });
+    return db.transaction(() => {
+        const existing = readRaw(db, input.conversationId, queueId);
+        if (existing) {
+            if (existing.enqueue_payload !== payload)
+                throw new AgentInputConflictError();
+            return { input: mapInput(existing), created: false };
+        }
+        const count = db.prepare("SELECT COUNT(*) AS n FROM agent_inputs WHERE conversation_id = ? AND status = 'pending'").get(input.conversationId);
+        if (count.n >= exports.MAX_PENDING_AGENT_INPUTS)
+            throw new AgentInputLimitError();
+        db.prepare(`INSERT INTO agent_inputs (id, conversation_id, queue_id, text, options_json, enqueue_payload)
+      VALUES (?, ?, ?, ?, ?, ?)`).run((0, crypto_1.randomUUID)(), input.conversationId, queueId, input.text, optionsJson, payload);
+        return { input: mapInput(readRaw(db, input.conversationId, queueId)), created: true };
+    })();
+}
+function listPendingAgentInputs(db, conversationId) {
+    return db.prepare("SELECT * FROM agent_inputs WHERE conversation_id = ? AND status = 'pending' ORDER BY created_at, rowid").all(conversationId).map(mapInput);
+}
+/** Editing changes the pending intent, never its original HTTP dedup fingerprint. */
+function editPendingAgentInput(db, conversationId, queueId, text) {
+    if (typeof text !== 'string')
+        throw new Error('A message must contain text.');
+    return db.transaction(() => {
+        const update = db.prepare("UPDATE agent_inputs SET text = ? WHERE conversation_id = ? AND queue_id = ? AND status = 'pending'").run(text, conversationId, queueId);
+        return update.changes ? getAgentInput(db, conversationId, queueId) : undefined;
+    })();
+}
+/** Promote pending input without rewriting its original HTTP identity. The
+ * manager owns the synchronous in-flight claim and must reject a claimed row. */
+function steerPendingAgentInput(db, conversationId, queueId) {
+    return db.transaction(() => {
+        const row = readRaw(db, conversationId, queueId);
+        if (!row || row.status !== 'pending')
+            return undefined;
+        const options = { ...JSON.parse(row.options_json), deliveryMode: 'steer' };
+        db.prepare("UPDATE agent_inputs SET options_json = ? WHERE id = ? AND status = 'pending'").run(canonicalJson(options), row.id);
+        return getAgentInput(db, conversationId, queueId);
+    })();
+}
+/** Removing a queue chip is an explicit deletion of unsent input. Keep its
+ * dedup tombstone, but do not add the removed text to conversation history. */
+function deletePendingAgentInput(db, conversationId, queueId) {
+    return db.prepare("UPDATE agent_inputs SET status = 'cancelled' WHERE conversation_id = ? AND queue_id = ? AND status = 'pending'")
+        .run(conversationId, queueId).changes > 0;
+}
+const receiptOrder = { sent: 0, received: 1, read: 2 };
+function validateReceipt(receipt) {
+    if (receipt !== 'sent' && receipt !== 'received' && receipt !== 'read')
+        throw new Error('Message receipt must be sent, received or read.');
+}
+function latestReceipt(existing, incoming) {
+    return receiptOrder[incoming] > receiptOrder[existing] ? incoming : existing;
+}
+/** The caller must hold a transaction while moving a pending row and user message together. */
+function settleInput(db, row, status, receipt = row.receipt) {
+    const options = JSON.parse(row.options_json);
+    const message = (0, agent_store_1.addAgentMessage)(db, {
+        conversationId: row.conversation_id, role: 'user', content: row.text,
+        attachmentIds: options.attachmentIds, contextRefs: options.contextRefs,
+    });
+    const nextReceipt = latestReceipt(row.receipt, receipt);
+    db.prepare("UPDATE agent_inputs SET status = ?, message_id = ?, receipt = ? WHERE id = ? AND status = 'pending'").run(status, message.id, nextReceipt, row.id);
+    return {
+        input: mapInput(readRaw(db, row.conversation_id, row.queue_id)),
+        message: { ...message, delivery_status: status, delivery_receipt: nextReceipt },
+    };
+}
+/** Provider acknowledgements can arrive out of order or after a reconnect. Only
+ * advance receipt state, retaining the same transcript identity and metadata. */
+function setAgentInputReceipt(db, conversationId, queueId, receipt) {
+    validateReceipt(receipt);
+    return db.transaction(() => {
+        const row = readRaw(db, conversationId, queueId);
+        if (!row || (row.status !== 'pending' && row.status !== 'delivered'))
+            return undefined;
+        const nextReceipt = latestReceipt(row.receipt, receipt);
+        if (nextReceipt !== row.receipt)
+            db.prepare('UPDATE agent_inputs SET receipt = ? WHERE id = ?').run(nextReceipt, row.id);
+        const updated = { ...row, receipt: nextReceipt };
+        const message = row.message_id ? (0, agent_store_1.listAgentMessages)(db, conversationId).find((entry) => entry.id === row.message_id) : undefined;
+        return {
+            input: mapInput(updated),
+            ...(message ? { message: { ...message, delivery_status: row.status, delivery_receipt: nextReceipt } } : {}),
+        };
+    })();
+}
+function deliverAgentInput(db, conversationId, queueId, receipt = 'received') {
+    validateReceipt(receipt);
+    return db.transaction(() => {
+        const row = readRaw(db, conversationId, queueId);
+        if (!row)
+            return undefined;
+        if (row.status === 'delivered') {
+            return setAgentInputReceipt(db, conversationId, queueId, receipt)?.message;
+        }
+        if (row.status !== 'pending')
+            return undefined;
+        return settleInput(db, row, 'delivered', receipt).message;
+    })();
+}
+/** A native write whose acknowledgement was lost must not be replayed. */
+function interruptAgentInput(db, conversationId, queueId) {
+    return db.transaction(() => {
+        const row = readRaw(db, conversationId, queueId);
+        if (!row || row.status !== 'pending')
+            return undefined;
+        return settleInput(db, row, 'interrupted').message;
+    })();
+}
+function settlePending(db, status, conversationId) {
+    return db.transaction(() => {
+        const rows = conversationId === undefined
+            ? db.prepare("SELECT * FROM agent_inputs WHERE status = 'pending' ORDER BY created_at, rowid").all()
+            : db.prepare("SELECT * FROM agent_inputs WHERE conversation_id = ? AND status = 'pending' ORDER BY created_at, rowid").all(conversationId);
+        return rows.map((row) => settleInput(db, row, status));
+    })();
+}
+function cancelPendingAgentInputs(db, conversationId) {
+    return settlePending(db, 'cancelled', conversationId);
+}
+/** Startup preserves unsent messages for review; it never silently replays them. */
+function recoverPendingAgentInputs(db, conversationId) {
+    return settlePending(db, 'interrupted', conversationId);
+}
+function decorateAgentInputMessages(db, messages) {
+    if (messages.length === 0)
+        return [];
+    const ids = messages.map((message) => message.id);
+    const rows = db.prepare(`SELECT message_id, status, receipt FROM agent_inputs
+    WHERE message_id IN (SELECT value FROM json_each(?)) AND status <> 'pending'`).all(JSON.stringify(ids));
+    const statuses = new Map(rows.map((row) => [row.message_id, row]));
+    return messages.map((message) => {
+        const status = statuses.get(message.id);
+        return status ? { ...message, delivery_status: status.status, delivery_receipt: status.receipt } : message;
+    });
+}

package/server/dist/agent-mcp-config.js

@@ -21,6 +21,13 @@ const agent_tier_1 = require("./agent-tier");
 const providers_1 = require("./providers");
 const external_mcp_1 = require("./external-mcp");
 const AGENT_CONVERSATION_ID_RE = /^[A-Za-z0-9][A-Za-z0-9_-]{0,63}$/;
+const AGENT_INVOCATION_ID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+function invocationFileName(extension, invocationId) {
+    if (invocationId !== undefined && !AGENT_INVOCATION_ID_RE.test(invocationId)) {
+        throw new Error('Unsafe agent invocation id: expected a UUID.');
+    }
+    return invocationId === undefined ? `mcp.${extension}` : `mcp.${invocationId}.${extension}`;
+}
 // ─── Agent MCP wiring (design D8 / D1) ────────────────────────────────────────
 //
 // The in-app agent drives the app by talking to its OWN embedded MCP server. We
@@ -142,14 +149,14 @@ function buildAgentMcpArgs(opts) {
     if (!entry)
         return [];
     const dir = agentDir(opts.conversationId);
-    const file = path_1.default.join(dir, 'mcp.json');
+    const file = path_1.default.join(dir, invocationFileName('json', opts.invocationId));
     const mcpServers = { specrails: entry };
     for (const server of opts.external ?? []) {
         if (server.name === 'specrails')
             continue;
         mcpServers[server.name] = server.config;
     }
-    fs_1.default.writeFileSync(file, JSON.stringify({ mcpServers }, null, 2), { mode: 0o600 });
+    fs_1.default.writeFileSync(file, JSON.stringify({ mcpServers }, null, 2), { mode: 0o600, flag: opts.invocationId === undefined ? 'w' : 'wx' });
     try {
         fs_1.default.chmodSync(file, 0o600);
     }
@@ -170,14 +177,35 @@ function agentDir(conversationId) {
     catch { /* best-effort on platforms without chmod */ }
     return dir;
 }
-function capabilityFilePath(conversationId) {
-    return path_1.default.join(agentDir(conversationId), 'mcp.capability');
+function capabilityFilePath(conversationId, invocationId) {
+    const fileName = invocationFileName('capability', invocationId);
+    return path_1.default.join(agentDir(conversationId), fileName);
 }
 function buildAgentTurnEntry(opts) {
-    const capabilityFile = capabilityFilePath(opts.conversationId);
+    const capabilityFile = capabilityFilePath(opts.conversationId, opts.invocationId);
     const entry = buildSpecrailsMcpEntry({ port: opts.port, capabilityFile });
     if (!entry)
         return null;
+    if (opts.invocationId !== undefined) {
+        // Never replace an invocation's bearer, even if a stale process has not
+        // opened it yet. Publish the config/argv only after this synchronous write.
+        // Exclusive creation also rejects a pre-planted file or symlink.
+        const fd = fs_1.default.openSync(capabilityFile, 'wx', 0o600);
+        try {
+            fs_1.default.writeFileSync(fd, opts.capability, { encoding: 'utf8' });
+        }
+        catch (err) {
+            try {
+                fs_1.default.unlinkSync(capabilityFile);
+            }
+            catch { /* only our newly-created file */ }
+            throw err;
+        }
+        finally {
+            fs_1.default.closeSync(fd);
+        }
+        return entry;
+    }
     const tmp = `${capabilityFile}.tmp-${process.pid}-${(0, crypto_1.randomBytes)(8).toString('hex')}`;
     try {
         // `wx` prevents a pre-planted symlink from redirecting the bearer write.
@@ -208,14 +236,22 @@ function buildAgentTurnEntry(opts) {
     return entry;
 }
 /** Delete the on-disk bearer as soon as its owning agent turn settles. */
-function removeAgentCapabilityFile(conversationId) {
-    if (!AGENT_CONVERSATION_ID_RE.test(conversationId))
+function removeAgentCapabilityFile(conversationId, invocationId) {
+    if (!AGENT_CONVERSATION_ID_RE.test(conversationId) ||
+        (invocationId !== undefined && !AGENT_INVOCATION_ID_RE.test(invocationId)))
         return;
-    const file = path_1.default.join(homeDir(), '.specrails', 'agent', conversationId, 'mcp.capability');
-    try {
-        fs_1.default.unlinkSync(file);
+    const dir = path_1.default.join(homeDir(), '.specrails', 'agent', conversationId);
+    const files = [invocationFileName('capability', invocationId)];
+    // The invocation-owned Claude config is no longer needed either. Preserve
+    // the legacy shared config and every other invocation's files.
+    if (invocationId !== undefined)
+        files.push(invocationFileName('json', invocationId));
+    for (const file of files) {
+        try {
+            fs_1.default.unlinkSync(path_1.default.join(dir, file));
+        }
+        catch { /* absent/already removed */ }
     }
-    catch { /* absent/already removed */ }
 }
 /**
  * Codex registers the specrails MCP via inline `-c mcp_servers.specrails.*`
@@ -259,18 +295,21 @@ function codexExternalOverrides(server) {
 }
 /**
  * Prepares the specrails MCP for the given provider and returns the spawn
- * extraArgs + env to merge. Returns empty wiring when the bridge is unavailable
- * (agent then runs tool-less / degraded).
+ * extraArgs + env to merge. A missing bridge is an actionable failure: never
+ * launch a paid operator turn while silently omitting its primary tools.
  */
 function prepareAgentMcp(opts) {
     const adapter = (0, providers_1.getAdapter)(opts.adapterId);
     const external = (opts.external ?? []).filter((s) => s.name !== 'specrails');
     if (adapter.id === 'claude') {
-        return { extraArgs: buildAgentMcpArgs(opts), env: {} };
+        const extraArgs = buildAgentMcpArgs(opts);
+        if (!extraArgs.length)
+            throw new Error('The bundled Specrails MCP bridge is unavailable.');
+        return { extraArgs, env: {} };
     }
     const entry = buildAgentTurnEntry(opts);
     if (!entry)
-        return { extraArgs: [], env: {} };
+        throw new Error('The bundled Specrails MCP bridge is unavailable.');
     if (adapter.mcpRegistration === 'cli-add') {
         // Inline -c overrides contain only the capability FILE PATH, never its secret.
         const externalArgs = external.filter(external_mcp_1.isCodexInjectable).flatMap(codexExternalOverrides);