specrails-desktop 2.20.1 → 2.22.0

package/server/dist/agent-chat-manager.js

@@ -1,9 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AgentChatManager = void 0;
+exports.sanitizeAgentTitle = sanitizeAgentTitle;
 const crypto_1 = require("crypto");
+const readline_1 = require("readline");
+const os_1 = require("os");
 const providers_1 = require("./providers");
 const spawn_lifecycle_1 = require("./spawn-lifecycle");
+const cli_prompt_1 = require("./util/cli-prompt");
 const result_event_1 = require("./result-event");
 const desktop_db_1 = require("./desktop-db");
 const agent_cwd_manager_1 = require("./agent-cwd-manager");
@@ -29,6 +33,10 @@ class AgentChatManager {
      *  at settle so an abort is never mistaken for a stale session (auto-heal
      *  would resurrect the aborted prompt) nor surfaced as an error. */
     _abortedTurns = new Set();
+    /** Fire-and-forget auxiliary children (the AI title spawn) tracked so
+     *  shutdown() can tree-kill them instead of orphaning them. Self-removed on
+     *  'close'/'error'. */
+    _auxProcesses = new Set();
     constructor(broadcast, db, port) {
         this._broadcast = broadcast;
         this._db = db;
@@ -337,6 +345,10 @@ class AgentChatManager {
             persistSession(r.sessionId);
             this._broadcast({ type: 'agent_done', conversationId, fullText: r.text, timestamp: timestamp() });
             record(r, 'success');
+            // AI title after the FIRST completed turn (industry standard — ChatGPT /
+            // Claude.ai), on the conversation's own provider. The deterministic title
+            // set at send stays the instant fallback; this upgrades it a moment later.
+            this._maybeAiTitle(conversation, userText, r.text);
             return;
         }
         // Failure: reset the session so the NEXT turn starts fresh, and surface the
@@ -408,6 +420,173 @@ class AgentChatManager {
             console.error(`[agent-chat] auto-title failed (${conversationId}):`, err);
         }
     }
+    /**
+     * Gate + fire the AI title upgrade. Runs ONLY on the first completed assistant
+     * turn and ONLY while the stored title is still the deterministic turn-1
+     * auto-title (a manual rename is recomputable-detectable and never clobbered),
+     * so the cheap spawn is skipped when it would be pointless.
+     */
+    _maybeAiTitle(conversation, firstUserMsg, firstResponse) {
+        try {
+            const conversationId = conversation.id;
+            const assistantCount = (0, agent_store_1.listAgentMessages)(this._db, conversationId).filter((m) => m.role === 'assistant').length;
+            if (assistantCount !== 1)
+                return;
+            const deterministic = (0, explore_draft_title_1.generateAutoTitle)([{ role: 'user', content: firstUserMsg }]);
+            const fresh = (0, agent_store_1.getAgentConversation)(this._db, conversationId);
+            if (!fresh || fresh.title !== deterministic)
+                return;
+            this._aiTitle(fresh, firstUserMsg, firstResponse);
+        }
+        catch (err) {
+            console.error(`[agent-chat] ai-title gate failed (${conversation.id}):`, err);
+        }
+    }
+    /**
+     * Fire-and-forget AI title: a cheap one-shot on the conversation's OWN provider
+     * (default model) that summarizes the first exchange into a 3-6 word title.
+     * Spawned from an empty tmp cwd so no operator CLAUDE.md / `.mcp.json` /
+     * user-scope settings are auto-loaded (leanest possible spawn, no tool wiring).
+     * On close it records the billable turn (parity with ChatManager's LOW-1 title
+     * accounting), then overwrites the title only if it is STILL the deterministic
+     * one (never clobbers a rename made during the ~1s generation). Never throws
+     * into the turn path — title generation failing must not surface an error.
+     */
+    _aiTitle(conversation, firstUserMsg, firstResponse) {
+        try {
+            const conversationId = conversation.id;
+            const adapter = (0, providers_1.getAdapter)(conversation.provider);
+            const model = adapter.defaultModel();
+            const prompt = 'Generate a concise 3-6 word title for this conversation. ' +
+                'Output ONLY the title text — no quotes, no punctuation, no markdown, no preamble.\n\n' +
+                `User: ${firstUserMsg.slice(0, 240)}\nAssistant: ${firstResponse.slice(0, 320)}`;
+            const args = adapter.buildArgs('auto-title', { prompt, model });
+            const child = (0, cli_prompt_1.spawnAiCli)(adapter.binary, args, {
+                env: process.env,
+                stdio: ['ignore', 'pipe', 'pipe'],
+                cwd: (0, os_1.tmpdir)(),
+            });
+            this._auxProcesses.add(child);
+            let raw = '';
+            const events = [];
+            const startedAt = new Date().toISOString();
+            const reader = (0, readline_1.createInterface)({ input: child.stdout, crlfDelay: Infinity });
+            reader.on('line', (line) => {
+                const ev = adapter.parseStreamLine(line);
+                if (!ev)
+                    return;
+                events.push(ev);
+                if (ev.kind === 'text-delta')
+                    raw += ev.text;
+            });
+            child.on('error', () => {
+                this._auxProcesses.delete(child);
+            });
+            child.on('close', (code) => {
+                this._auxProcesses.delete(child);
+                const fresh = (0, agent_store_1.getAgentConversation)(this._db, conversationId);
+                if (!fresh)
+                    return; // deleted mid-generation — FK-safe: skip record + update
+                // Cost accounting parity with ChatManager LOW-1: the title spawn is a
+                // real billable invocation — record one agent_invocations row.
+                this._recordTurn(fresh, adapter, model, { events, startedAt, sessionId: null }, code === 0 ? 'success' : 'failed');
+                if (code !== 0)
+                    return;
+                const title = sanitizeAgentTitle(raw);
+                if (!title || title === fresh.title)
+                    return;
+                // Never clobber a manual rename made while the title was generating.
+                const deterministic = (0, explore_draft_title_1.generateAutoTitle)([{ role: 'user', content: firstUserMsg }]);
+                if (fresh.title !== deterministic)
+                    return;
+                (0, agent_store_1.updateAgentConversation)(this._db, conversationId, { title });
+                this._broadcast({ type: 'agent_title', conversationId, title, timestamp: new Date().toISOString() });
+            });
+        }
+        catch (err) {
+            console.error(`[agent-chat] ai-title spawn failed (${conversation.id}):`, err);
+        }
+    }
+    /**
+     * Post the inline PR-decision card into the conversation that launched the
+     * rail (safe-pr-review-flow): persist a `system`-role row whose content is
+     * the JSON envelope (so the card survives refresh/cold-load), then broadcast
+     * `agent_pr_decision` so open panels render it live. No-ops when the
+     * conversation was deleted (the ledger's origin link is a soft reference).
+     * NEVER throws — it runs inside rail settle paths.
+     */
+    postPrDecisionCard(conversationId, envelope) {
+        try {
+            if (!(0, agent_store_1.getAgentConversation)(this._db, conversationId)) {
+                console.log(`[agent-chat] pr-decision card skipped — conversation gone (${conversationId})`);
+                return;
+            }
+            (0, agent_store_1.addAgentMessage)(this._db, { conversationId, role: 'system', content: JSON.stringify(envelope) });
+            this._broadcastPrDecision(conversationId, envelope);
+        }
+        catch (err) {
+            console.error(`[agent-chat] postPrDecisionCard failed (${conversationId}):`, err);
+        }
+    }
+    /**
+     * Update the SAME persisted card in place on a later decision transition
+     * (matched by `prDeliveryId`), so a cold-load renders the current/terminal
+     * state instead of a stale ask — then re-broadcast. Falls back to posting a
+     * fresh card when none exists (resilience: e.g. the original post raced a
+     * conversation delete/restore). NEVER throws — it runs inside decision paths.
+     */
+    updatePrDecisionCard(conversationId, envelope) {
+        try {
+            const existing = (0, agent_store_1.findAgentSystemMessage)(this._db, conversationId, (content) => {
+                try {
+                    const parsed = JSON.parse(content);
+                    return parsed.kind === 'pr_decision' && parsed.prDeliveryId === envelope.prDeliveryId;
+                }
+                catch {
+                    return false;
+                }
+            });
+            if (!existing) {
+                this.postPrDecisionCard(conversationId, envelope);
+                return;
+            }
+            (0, agent_store_1.updateAgentMessageContent)(this._db, existing.id, JSON.stringify(envelope));
+            this._broadcastPrDecision(conversationId, envelope);
+        }
+        catch (err) {
+            console.error(`[agent-chat] updatePrDecisionCard failed (${conversationId}):`, err);
+        }
+    }
+    _broadcastPrDecision(conversationId, envelope) {
+        this._broadcast({
+            type: 'agent_pr_decision',
+            conversationId,
+            ...envelope,
+            timestamp: new Date().toISOString(),
+        });
+    }
+    /**
+     * Edits a still-queued message in place (composer ↑/↓ queue navigation).
+     * Returns false when the message is no longer in the queue — the drain loop
+     * `shift()`s an item synchronously before spawning its turn, so a false here
+     * means "already dispatched (or cleared)" and the router maps it to 409.
+     * Success broadcasts `agent_queue_edited` so every open window updates its chip.
+     */
+    editQueued(conversationId, queueId, text) {
+        const pending = this._queue.get(conversationId);
+        const item = pending?.find((q) => q.queueId === queueId);
+        if (!item)
+            return false;
+        item.text = text;
+        this._broadcast({
+            type: 'agent_queue_edited',
+            conversationId,
+            queueId,
+            text,
+            timestamp: new Date().toISOString(),
+        });
+        return true;
+    }
     /** Aborts the active turn for a conversation, if any. Stop means stop: any
      *  queued messages are discarded too (broadcast so the client drops chips),
      *  and the settling turn is marked aborted so the stale-session auto-heal
@@ -447,9 +626,41 @@ class AgentChatManager {
             }
         }
         this._active.clear();
+        for (const child of this._auxProcesses) {
+            try {
+                child.kill('SIGTERM');
+            }
+            catch {
+                /* ignore */
+            }
+        }
+        this._auxProcesses.clear();
     }
     _emitError(conversationId, error) {
         this._broadcast({ type: 'agent_error', conversationId, error, timestamp: new Date().toISOString() });
     }
 }
 exports.AgentChatManager = AgentChatManager;
+const MAX_AI_TITLE_LEN = 80;
+/**
+ * Coerce a model's title output into a clean single-line title: first non-empty
+ * line, surrounding quotes / markdown emphasis / leading list markers stripped,
+ * whitespace collapsed, word-aware length cap. Returns '' when nothing usable
+ * remains (the caller then keeps the deterministic title).
+ */
+function sanitizeAgentTitle(raw) {
+    const firstLine = raw.split('\n').map((s) => s.trim()).find((s) => s.length > 0) ?? '';
+    const stripped = firstLine
+        .replace(/^[\s>*_#-]+/, '') // leading markdown/list markers
+        .replace(/^["'`]+/, '')
+        .replace(/["'`*_\s]+$/, '')
+        .replace(/\s+/g, ' ')
+        .trim();
+    if (!stripped)
+        return '';
+    if (stripped.length <= MAX_AI_TITLE_LEN)
+        return stripped;
+    const head = stripped.slice(0, MAX_AI_TITLE_LEN);
+    const lastSpace = head.lastIndexOf(' ');
+    return (lastSpace > 20 ? head.slice(0, lastSpace) : head).trim() + '…';
+}

package/server/dist/agent-chat-registry.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setAgentChatManager = setAgentChatManager;
+exports.getAgentChatManager = getAgentChatManager;
+// ─── Agent-chat manager registry (safe-pr-review-flow) ────────────────────────
+//
+// The AgentChatManager instance is a non-exported local of index.ts's startup,
+// but the rails layer (rail-isolated-launch / the pr-decision endpoint) must
+// reach it to post/update the inline PR-decision card into the launching
+// conversation. This process-wide singleton is the reference path — mirroring
+// the `setActiveProject` pattern in mcp/tools/types.ts — so rails code never
+// imports index.ts (circular). It stays null in tests and when agent chat is
+// disabled; callers use `getAgentChatManager()?.…` (null-safe).
+let _manager = null;
+function setAgentChatManager(m) {
+    _manager = m;
+}
+function getAgentChatManager() {
+    return _manager;
+}

package/server/dist/agent-chat-router.js

@@ -307,6 +307,28 @@ function createAgentChatRouter(deps) {
         void manager.sendMessage(conversation.id, text, { tierLevel, model, attachmentIds, queueId }).catch((e) => console.error('[agent-chat] send failed:', e));
         res.status(202).json({ accepted: true, queued });
     });
+    // Edit a still-queued (not yet dispatched) message in place. 409 when the
+    // queue already consumed it — the client keeps the user's text as a draft so
+    // nothing is lost (never-lose-input semantics).
+    router.patch('/conversations/:id/queue/:queueId', (req, res) => {
+        const conversation = (0, agent_store_1.getAgentConversation)(desktopDb, String(req.params.id));
+        if (!conversation) {
+            res.status(404).json({ error: 'Unknown conversation' });
+            return;
+        }
+        const body = (req.body ?? {});
+        const text = typeof body.text === 'string' ? body.text.trim() : '';
+        if (!text) {
+            res.status(400).json({ error: 'text is required' });
+            return;
+        }
+        const edited = manager.editQueued(conversation.id, String(req.params.queueId), text);
+        if (!edited) {
+            res.status(409).json({ error: 'Message already dispatched' });
+            return;
+        }
+        res.json({ ok: true });
+    });
     router.post('/conversations/:id/abort', (req, res) => {
         const aborted = manager.abort(String(req.params.id));
         res.json({ aborted });

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

@@ -13,6 +13,7 @@ const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const os_1 = __importDefault(require("os"));
 const path_resolver_1 = require("./path-resolver");
+const win_spawn_1 = require("./util/win-spawn");
 const agent_tier_1 = require("./agent-tier");
 // ─── Agent MCP wiring (design D8 / D1) ────────────────────────────────────────
 //
@@ -42,9 +43,16 @@ function fileExists(p) {
  * Climbs from this module so it works whether running from server/ or server/dist/.
  */
 function resolveBridgeScript() {
+    // Tauri's resource_dir() delivers `\\?\C:\…` verbatim paths on Windows; a
+    // `\\?\`-prefixed script argument crashes node's module loader (EISDIR
+    // lstat 'C:'), leaving the MCP server perpetually "connecting". Strip here
+    // as defence-in-depth even though ensureWindowsBaseEnv() normalizes the var.
     const fromEnv = process.env.SPECRAILS_BUNDLED_MCP_BRIDGE_PATH;
-    if (fromEnv && fileExists(fromEnv))
-        return fromEnv;
+    if (fromEnv) {
+        const cleaned = (0, win_spawn_1.stripWindowsVerbatimPrefix)(fromEnv);
+        if (fileExists(cleaned))
+            return cleaned;
+    }
     const roots = [
         path_1.default.resolve(__dirname, '..'),
         path_1.default.resolve(__dirname, '..', '..'),
@@ -67,6 +75,9 @@ function resolveBridgeScript() {
 function resolveNodeCommand() {
     return (0, path_resolver_1.resolveBundledNodeExe)() ?? 'node';
 }
+/** The launch-route contract for an origin conversation id (safe-pr-review-flow):
+ *  must match rails-router's validation so a tagged launch is never 400'd. */
+const ORIGIN_CONVERSATION_ID_RE = /^[A-Za-z0-9-]{1,64}$/;
 /** Build the `mcpServers.specrails` entry the agent (or a project workspace) uses. */
 function buildSpecrailsMcpEntry(opts) {
     const bridge = resolveBridgeScript();
@@ -82,6 +93,9 @@ function buildSpecrailsMcpEntry(opts) {
         env[agent_tier_1.AGENT_TIER_ENV] = (0, agent_tier_1.tierNameForLevel)(opts.tierLevel);
     if (opts.activeProjectId)
         env[agent_tier_1.AGENT_PROJECT_ENV] = opts.activeProjectId;
+    if (opts.conversationId && ORIGIN_CONVERSATION_ID_RE.test(opts.conversationId)) {
+        env[agent_tier_1.AGENT_CONVERSATION_ENV] = opts.conversationId;
+    }
     return { command: resolveNodeCommand(), args: [bridge], env };
 }
 /**
@@ -124,7 +138,12 @@ function mergeSpecrailsIntoWorkspaceMcp(workspaceDir, port) {
  * `[]` when the bridge can't be located (agent then runs tool-less / degraded).
  */
 function buildAgentMcpArgs(opts) {
-    const entry = buildSpecrailsMcpEntry({ port: opts.port, tierLevel: opts.tierLevel, activeProjectId: opts.activeProjectId });
+    const entry = buildSpecrailsMcpEntry({
+        port: opts.port,
+        tierLevel: opts.tierLevel,
+        activeProjectId: opts.activeProjectId,
+        conversationId: opts.conversationId,
+    });
     if (!entry)
         return [];
     if (!/^[A-Za-z0-9][A-Za-z0-9_-]*$/.test(opts.conversationId)) {
@@ -179,6 +198,7 @@ function prepareAgentMcp(opts) {
         port: opts.port,
         tierLevel: opts.tierLevel,
         activeProjectId: opts.activeProjectId,
+        conversationId: opts.conversationId,
     });
     if (!entry)
         return { extraArgs: [], env: {} };
@@ -191,6 +211,28 @@ function prepareAgentMcp(opts) {
     }
     // gemini + any other project-json provider: write .mcp.json in the spawn cwd.
     const file = path_1.default.join(opts.cwd, '.mcp.json');
+    mergeServerIntoJsonFile(file, entry);
+    if (opts.adapterId === 'gemini') {
+        // gemini-cli has NEVER read .mcp.json (a Claude convention) — its only MCP
+        // surface is `mcpServers` in settings.json (user or <cwd>/.gemini project
+        // scope), and an UNTRUSTED cwd suppresses MCP entirely (headless run exits
+        // 55 with FatalUntrustedWorkspaceError on 0.49). So: register in the
+        // project-scope settings file AND trust the app-owned agent cwd per-spawn
+        // via env — the same pattern every other gemini spawn path already uses
+        // (chat-manager / queue-manager / cli-prompt). Verified empirically against
+        // gemini-cli 0.49.0 (see docs/internals note on FQN tool prefixing).
+        const geminiDir = path_1.default.join(opts.cwd, '.gemini');
+        fs_1.default.mkdirSync(geminiDir, { recursive: true });
+        mergeServerIntoJsonFile(path_1.default.join(geminiDir, 'settings.json'), entry);
+        return { extraArgs: [], env: { GEMINI_CLI_TRUST_WORKSPACE: 'true' } };
+    }
+    return { extraArgs: [], env: {} };
+}
+/** Merge `mcpServers.specrails` into a JSON config file (read-if-exists,
+ *  preserve every other key, corrupt file → start fresh, chmod 600). Shape is
+ *  shared by claude-style `.mcp.json` and gemini `.gemini/settings.json` —
+ *  both carry a top-level `mcpServers` object. */
+function mergeServerIntoJsonFile(file, entry) {
     let current = {};
     try {
         if (fs_1.default.existsSync(file)) {
@@ -204,5 +246,4 @@ function prepareAgentMcp(opts) {
     }
     const next = { ...current, mcpServers: { ...(current.mcpServers ?? {}), specrails: entry } };
     fs_1.default.writeFileSync(file, JSON.stringify(next, null, 2), { mode: 0o600 });
-    return { extraArgs: [], env: {} };
 }