specrails-desktop 2.4.0 → 2.5.0

package/server/dist/queue-manager.js

@@ -14,6 +14,7 @@ const tree_kill_1 = __importDefault(require("tree-kill"));
 const types_1 = require("./types");
 const command_resolver_1 = require("./command-resolver");
 const cli_prompt_1 = require("./util/cli-prompt");
+const stream_display_1 = require("./util/stream-display");
 const hooks_1 = require("./hooks");
 const ai_invocations_1 = require("./ai-invocations");
 const feature_flags_1 = require("./feature-flags");
@@ -23,6 +24,7 @@ const crypto_1 = require("crypto");
 const providers_1 = require("./providers");
 const codex_otel_bridge_1 = require("./codex-otel-bridge");
 const db_1 = require("./db");
+const interactive_job_session_1 = require("./interactive-job-session");
 const attachment_manager_1 = require("./attachment-manager");
 const ticket_store_1 = require("./ticket-store");
 const binary_probe_1 = require("./binary-probe");
@@ -104,59 +106,6 @@ class JobAlreadyTerminalError extends Error {
 }
 exports.JobAlreadyTerminalError = JobAlreadyTerminalError;
 // ─── Helpers ──────────────────────────────────────────────────────────────────
-function extractDisplayText(event) {
-    const type = event.type;
-    // ── Claude `--output-format stream-json` ───────────────────────────────
-    if (type === 'assistant') {
-        const content = event.message;
-        const texts = (content?.content ?? [])
-            .filter((c) => c.type === 'text')
-            .map((c) => c.text ?? '');
-        return texts.join('') || null;
-    }
-    if (type === 'tool_use') {
-        const name = event.name;
-        const input = JSON.stringify(event.input ?? {});
-        return `[tool: ${name}] ${input.slice(0, 120)}`;
-    }
-    if (type === 'tool_result' || type === 'system_prompt' || type === 'user' || type === 'system' || type === 'result') {
-        return null;
-    }
-    // ── Codex `exec --json` event types ───────────────────────────────────
-    // Codex shape differs from claude: items are nested under `item` with a
-    // discriminator at `item.type`. Without explicit handling the Job Detail
-    // log shows only the spawn preamble and exit notice — exactly the
-    // "2 / 2 lines" symptom that masks 200k+ tokens of real work.
-    if (type === 'item.completed' || type === 'item.started') {
-        const item = event.item;
-        if (!item)
-            return null;
-        const itemType = item.type;
-        if (itemType === 'agent_message') {
-            const text = item.text?.trim();
-            return text && text.length > 0 ? text : null;
-        }
-        if (itemType === 'command_execution') {
-            // Only surface the completed line so the log isn't doubled with the
-            // matching `item.started` placeholder.
-            if (type !== 'item.completed')
-                return null;
-            const cmd = item.command ?? '';
-            const exitCode = item.exit_code;
-            const exitStr = typeof exitCode === 'number' ? ` → exit ${exitCode}` : '';
-            return `[exec]${exitStr} ${cmd.slice(0, 200)}`;
-        }
-        if (itemType === 'agent_reasoning') {
-            const text = item.text?.trim();
-            return text && text.length > 0 ? `[reasoning] ${text.slice(0, 200)}` : null;
-        }
-        return null;
-    }
-    if (type === 'thread.started' || type === 'turn.started' || type === 'turn.completed') {
-        return null;
-    }
-    return null;
-}
 const TERMINAL_STATUSES = new Set(['completed', 'failed', 'canceled', 'zombie_terminated', 'skipped']);
 /** Match an Ultracode rail command: `/specrails:ultracode #5 …` (or `/sr:…`). */
 exports.ULTRACODE_COMMAND_RE = /^\/(specrails|sr):ultracode\b/;
@@ -207,6 +156,12 @@ class QueueManager {
     /** Pre-spawn working-tree snapshot refs keyed by jobId — read at exit time
      *  by the Code-Explorer provenance hook. Cleared on job exit. */
     _snapshotRefs;
+    /** Pending per-job interactive flag keyed by jobId — read at spawn time.
+     *  In-memory only (mirrors _jobModelSelection). */
+    _jobInteractiveSelection;
+    /** Live interactive job sessions keyed by jobId (the resident persistent-stdin
+     *  child + per-turn accounting). Present only while an interactive job runs. */
+    _interactiveSessions;
     constructor(broadcast, db, commands, cwd, options) {
         this._queue = [];
         this._jobs = new Map();
@@ -235,6 +190,8 @@ class QueueManager {
         this._jobProviderSelection = new Map();
         this._jobModelSelection = new Map();
         this._snapshotRefs = new Map();
+        this._jobInteractiveSelection = new Map();
+        this._interactiveSessions = new Map();
         const envTimeout = process.env.WM_ZOMBIE_TIMEOUT_MS !== undefined
             ? parseInt(process.env.WM_ZOMBIE_TIMEOUT_MS, 10)
             : null;
@@ -293,6 +250,15 @@ class QueueManager {
         }
         this._activeProcess = null;
         this._activeJobId = null;
+        // Tear down any resident interactive sessions (SIGTERM their children) so
+        // teardown orphans no persistent claude process. dispose() does not settle.
+        for (const session of this._interactiveSessions.values()) {
+            try {
+                session.dispose();
+            }
+            catch { /* best-effort */ }
+        }
+        this._interactiveSessions.clear();
         // Release any per-job provenance snapshots so teardown leaves no map entries.
         this._snapshotRefs.clear();
         // Drop the DB reference last so any in-flight 'close' callback sees null
@@ -357,6 +323,11 @@ class QueueManager {
         if (resolvedOpts?.model) {
             this._jobModelSelection.set(id, resolvedOpts.model);
         }
+        // Record per-job interactive flag (ultracode + claude only — enforced at
+        // spawn time against the resolved adapter's persistent-stdin capability).
+        if (resolvedOpts?.interactive) {
+            this._jobInteractiveSelection.set(id, true);
+        }
         // Insert at the correct position based on priority (higher priority first, FIFO within same level)
         const weight = types_1.PRIORITY_WEIGHT[priority];
         let insertIdx = this._queue.length;
@@ -395,6 +366,7 @@ class QueueManager {
             this._jobProviderSelection.delete(jobId);
             this._jobModelSelection.delete(jobId);
             this._jobProfileSelection.delete(jobId);
+            this._jobInteractiveSelection.delete(jobId);
             this._skipDependents(jobId, `Parent job ${jobId} was canceled`);
             this._recomputePositions();
             this._persistJob(job);
@@ -415,6 +387,15 @@ class QueueManager {
             return 'canceled';
         }
         // job.status === 'running'
+        // Interactive jobs own a resident child via the session (not _activeProcess),
+        // so route their cancel through the session: SIGTERM → settle sees the
+        // canceling flag and stamps 'canceled'.
+        const interactiveSession = this._interactiveSessions.get(jobId);
+        if (interactiveSession) {
+            this._cancelingJobs.add(jobId);
+            interactiveSession.finalize();
+            return 'canceling';
+        }
         this._kill(jobId);
         return 'canceling';
     }
@@ -490,6 +471,29 @@ class QueueManager {
     getLogBuffer() {
         return [...this._logBuffer];
     }
+    /** True while an interactive ultracode session is resident for this job. */
+    isInteractiveJob(jobId) {
+        return this._interactiveSessions.has(jobId);
+    }
+    /** Feed one more user prompt to a running interactive job (queued behind the
+     *  active turn). Returns false when the job isn't an active interactive
+     *  session (unknown / already finalized / not interactive). */
+    sendInteractiveTurn(jobId, text) {
+        const session = this._interactiveSessions.get(jobId);
+        if (!session)
+            return false;
+        return session.send(text);
+    }
+    /** User-initiated finalize for an interactive job: SIGTERM the resident child;
+     *  the settle path stamps the summed totals + 'completed' status. Returns false
+     *  when the job isn't an active interactive session. */
+    finalizeInteractive(jobId) {
+        const session = this._interactiveSessions.get(jobId);
+        if (!session)
+            return false;
+        session.finalize();
+        return true;
+    }
     // ─── Private methods ────────────────────────────────────────────────────────
     phasesForCommand(command) {
         return this._phasesForCommand(command);
@@ -630,6 +634,143 @@ class QueueManager {
         }
         return this._adapter;
     }
+    /**
+     * Spawn an interactive ultracode session. The job row is created with the
+     * `interactive` flag set; the resident child runs the first turn (the
+     * ultracode prompt) and stays alive for follow-up turns until finalize/crash.
+     * No zombie timer is armed (the child idles between turns by design) and
+     * `_activeProcess` is left null — the session owns the child; the active SLOT
+     * (`_activeJobId`, reserved by _drainQueue) is held until settle.
+     */
+    _startInteractiveJob(jobId, job, adapter, spec, firstPrompt) {
+        if (this._db) {
+            try {
+                (0, db_1.createJob)(this._db, {
+                    id: jobId,
+                    command: job.command,
+                    started_at: job.startedAt,
+                    priority: job.priority,
+                    depends_on_job_id: job.dependsOnJobId,
+                    pipeline_id: job.pipelineId,
+                    interactive: true,
+                });
+            }
+            catch (err) {
+                console.error('[queue-manager] createJob (interactive) failed:', err);
+            }
+        }
+        const session = new interactive_job_session_1.InteractiveJobSession({
+            jobId,
+            projectId: this._projectId ?? '',
+            db: this._db,
+            adapter,
+            broadcast: this._broadcast,
+            onSettle: (info) => this._settleInteractiveJob(jobId, info),
+        });
+        this._interactiveSessions.set(jobId, session);
+        session.start(spec, firstPrompt);
+        this._broadcastQueueState();
+    }
+    /**
+     * Terminal bookkeeping for an interactive job (called once by the session's
+     * onSettle). Releases the active slot, stamps the job's terminal status +
+     * finished_at (token/cost totals were already accumulated per turn), writes a
+     * single ai_invocations row with the summed usage, fires the rail/ticket
+     * completion callback, and drains the queue.
+     */
+    _settleInteractiveJob(jobId, info) {
+        this._interactiveSessions.delete(jobId);
+        if (this._activeJobId === jobId) {
+            this._activeProcess = null;
+            this._activeJobId = null;
+        }
+        // Interactive jobs skip provenance, but a defensive delete keeps the map
+        // clean if a snapshot was ever recorded for this id.
+        this._snapshotRefs.delete(jobId);
+        if (this._disposed)
+            return;
+        const job = this._jobs.get(jobId);
+        if (!job) {
+            this._drainQueue();
+            return;
+        }
+        const wasCanceling = this._cancelingJobs.has(jobId);
+        this._cancelingJobs.delete(jobId);
+        const finalStatus = wasCanceling
+            ? 'canceled'
+            : info.reason === 'finalized'
+                ? 'completed'
+                : 'failed';
+        job.status = finalStatus;
+        job.finishedAt = new Date().toISOString();
+        job.exitCode = info.reason === 'finalized' ? 0 : 1;
+        const totals = info.totals;
+        if (this._db) {
+            try {
+                (0, db_1.finalizeInteractiveJob)(this._db, jobId, finalStatus);
+            }
+            catch (err) {
+                console.error('[queue-manager] finalizeInteractiveJob failed:', err);
+            }
+            if (this._projectId) {
+                try {
+                    const invStatus = finalStatus === 'completed'
+                        ? 'success'
+                        : finalStatus === 'canceled'
+                            ? 'aborted'
+                            : 'failed';
+                    const ticketIds = this._extractTicketIds(job.command);
+                    const durationMs = job.startedAt
+                        ? new Date(job.finishedAt).getTime() - new Date(job.startedAt).getTime()
+                        : undefined;
+                    (0, ai_invocations_1.recordInvocation)(this._db, {
+                        id: (0, crypto_1.randomUUID)(),
+                        project_id: this._projectId,
+                        provider: 'claude',
+                        surface: 'job',
+                        surface_ref_id: jobId,
+                        ticket_id: ticketIds[0] ?? null,
+                        status: invStatus,
+                        started_at: job.startedAt ?? new Date().toISOString(),
+                        finished_at: job.finishedAt,
+                        total_cost_usd_estimated: false,
+                        tokens_in: totals.tokens_in,
+                        tokens_out: totals.tokens_out,
+                        tokens_cache_read: totals.tokens_cache_read,
+                        tokens_cache_create: totals.tokens_cache_create,
+                        total_cost_usd: totals.total_cost_usd,
+                        num_turns: totals.num_turns,
+                        model: info.model ?? undefined,
+                        session_id: info.sessionId ?? undefined,
+                        duration_ms: durationMs,
+                    });
+                    this._broadcast({ type: 'spending.invalidated', projectId: this._projectId });
+                }
+                catch (err) {
+                    console.error('[queue-manager] recordInvocation (interactive) failed:', err);
+                }
+            }
+        }
+        this._persistJob(job);
+        this._broadcast({
+            type: 'job.finalized',
+            projectId: this._projectId ?? '',
+            jobId,
+            status: finalStatus,
+            totals,
+            timestamp: new Date().toISOString(),
+        });
+        this._broadcastQueueState();
+        if (this._onJobFinished) {
+            try {
+                this._onJobFinished(jobId, finalStatus, totals.total_cost_usd);
+            }
+            catch (err) {
+                console.error(`[QueueManager] onJobFinished failed for ${jobId}: ${err.message}`);
+            }
+        }
+        this._drainQueue();
+    }
     async _startJob(jobId) {
         const job = this._jobs.get(jobId);
         if (!job) {
@@ -859,6 +1000,25 @@ class QueueManager {
                 };
             }
         }
+        // ─── Interactive ultracode branch ──────────────────────────────────────
+        // When the launch requested interactive mode AND the command is ultracode
+        // AND the adapter supports persistent stdin (claude), hand off to a resident
+        // session instead of the one-shot spawn below. The session keeps the child
+        // alive across turns and settles only on finalize/crash. Code-Explorer
+        // provenance is intentionally skipped for interactive jobs (v1 — deferred).
+        const wantsInteractive = this._jobInteractiveSelection.get(jobId) === true;
+        this._jobInteractiveSelection.delete(jobId);
+        if (wantsInteractive && isUltracode && adapter.capabilities.persistentStdin) {
+            const interactiveArgs = adapter.buildArgs('chat-stream', {
+                // chat-stream feeds the prompt over stdin per-turn, so the argv `prompt`
+                // is unused — pass empty to satisfy the shared SpawnOptions shape.
+                prompt: '',
+                systemPrompt: systemAppend || undefined,
+                model: railModel,
+            });
+            this._startInteractiveJob(jobId, job, adapter, { binary, args: interactiveArgs, cwd: this._cwd, env: spawnEnv }, railPrompt);
+            return;
+        }
         // Code-Explorer pre-spawn snapshot. Captures the working-tree state via
         // `git stash create --include-untracked` so the post-exit hook can diff
         // against it. Gated by SPECRAILS_CODE_EXPLORER — when off, no-op.
@@ -996,7 +1156,7 @@ class QueueManager {
                 if (eventType === 'result') {
                     lastResultEvent = parsed;
                 }
-                const displayText = extractDisplayText(parsed);
+                const displayText = (0, stream_display_1.extractDisplayText)(parsed);
                 if (displayText !== null) {
                     if (this._db) {
                         (0, db_1.appendEvent)(this._db, jobId, eventSeq++, {

package/server/dist/rails-router.js

@@ -5,6 +5,7 @@ const express_1 = require("express");
 const rails_store_1 = require("./rails-store");
 const queue_manager_1 = require("./queue-manager");
 const provider_selection_1 = require("./provider-selection");
+const feature_flags_1 = require("./feature-flags");
 const VALID_MODES = new Set(['implement', 'batch-implement', 'ultracode']);
 // Models the ultracode picker exposes (Claude aliases). Mirrors the client
 // RailModelSelector options and the project-router orchestrator-model allow-list.
@@ -189,7 +190,7 @@ function createRailsRouter() {
             res.status(400).json({ error: 'Invalid rail index' });
             return;
         }
-        const { mode = 'implement', profileName, aiEngine, model } = req.body ?? {};
+        const { mode = 'implement', profileName, aiEngine, model, interactive } = req.body ?? {};
         if (!VALID_MODES.has(mode)) {
             res.status(400).json({ error: 'mode must be "implement", "batch-implement" or "ultracode"' });
             return;
@@ -202,6 +203,18 @@ function createRailsRouter() {
                 return;
             }
         }
+        // Interactive toggle: only valid for ultracode (Claude-only) and only when
+        // the feature is enabled. Reject loudly so the client never silently drops it.
+        if (interactive === true) {
+            if (mode !== 'ultracode') {
+                res.status(400).json({ error: 'interactive mode is only available for ultracode rails' });
+                return;
+            }
+            if (!(0, feature_flags_1.isInteractiveJobsEnabled)()) {
+                res.status(403).json({ error: 'Interactive jobs are disabled on this server' });
+                return;
+            }
+        }
         const c = ctx(req);
         const rail = (0, rails_store_1.getRail)(c.db, railIndex);
         if (rail.ticketIds.length === 0) {
@@ -267,6 +280,7 @@ function createRailsRouter() {
                         profileName: null,
                         provider: 'claude',
                         ...(ultracodeModel ? { model: ultracodeModel } : {}),
+                        ...(interactive === true ? { interactive: true } : {}),
                     });
                     jobIds.push(job.id);
                     c.railJobs.set(job.id, { railIndex, mode, ticketIds: [ticketId] });

package/server/dist/util/stream-display.js

@@ -0,0 +1,66 @@
+"use strict";
+// Shared stream-frame → human-readable display-text extraction.
+//
+// Extracted from queue-manager so the interactive-job session transport can
+// render the SAME log lines QueueManager's one-shot spawn does, without a
+// circular import between the two modules.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractDisplayText = extractDisplayText;
+/**
+ * Map a parsed provider stream-json frame to the single display line the Job
+ * Detail log shows (or null when the frame carries no user-facing text).
+ * Handles both Claude `--output-format stream-json` and Codex `exec --json`.
+ */
+function extractDisplayText(event) {
+    const type = event.type;
+    // ── Claude `--output-format stream-json` ───────────────────────────────
+    if (type === 'assistant') {
+        const content = event.message;
+        const texts = (content?.content ?? [])
+            .filter((c) => c.type === 'text')
+            .map((c) => c.text ?? '');
+        return texts.join('') || null;
+    }
+    if (type === 'tool_use') {
+        const name = event.name;
+        const input = JSON.stringify(event.input ?? {});
+        return `[tool: ${name}] ${input.slice(0, 120)}`;
+    }
+    if (type === 'tool_result' || type === 'system_prompt' || type === 'user' || type === 'system' || type === 'result') {
+        return null;
+    }
+    // ── Codex `exec --json` event types ───────────────────────────────────
+    // Codex shape differs from claude: items are nested under `item` with a
+    // discriminator at `item.type`. Without explicit handling the Job Detail
+    // log shows only the spawn preamble and exit notice — exactly the
+    // "2 / 2 lines" symptom that masks 200k+ tokens of real work.
+    if (type === 'item.completed' || type === 'item.started') {
+        const item = event.item;
+        if (!item)
+            return null;
+        const itemType = item.type;
+        if (itemType === 'agent_message') {
+            const text = item.text?.trim();
+            return text && text.length > 0 ? text : null;
+        }
+        if (itemType === 'command_execution') {
+            // Only surface the completed line so the log isn't doubled with the
+            // matching `item.started` placeholder.
+            if (type !== 'item.completed')
+                return null;
+            const cmd = item.command ?? '';
+            const exitCode = item.exit_code;
+            const exitStr = typeof exitCode === 'number' ? ` → exit ${exitCode}` : '';
+            return `[exec]${exitStr} ${cmd.slice(0, 200)}`;
+        }
+        if (itemType === 'agent_reasoning') {
+            const text = item.text?.trim();
+            return text && text.length > 0 ? `[reasoning] ${text.slice(0, 200)}` : null;
+        }
+        return null;
+    }
+    if (type === 'thread.started' || type === 'turn.started' || type === 'turn.completed') {
+        return null;
+    }
+    return null;
+}