rivet-design 0.10.7 → 0.10.8

package/dist/mcp/agent-variants/WorktreeOrchestrator.js

@@ -13,6 +13,7 @@ const path_1 = __importDefault(require("path"));
 const child_process_1 = require("child_process");
 const simple_git_1 = require("simple-git");
 const logger_1 = require("../../utils/logger");
+const devServerError_1 = require("../../utils/devServerError");
 const errors_1 = require("./errors");
 const createProjectArtifacts_1 = require("./createProjectArtifacts");
 const contracts_1 = require("./contracts");
@@ -24,6 +25,9 @@ const previewQa_1 = require("./previewQa");
 const VariantHistoryService_1 = require("../../services/VariantHistoryService");
 const log = (0, logger_1.createLogger)('AgentVariantsOrchestrator');
 const FRESH_DEV_SERVER_HOST = '127.0.0.1';
+// Fresh worktrees run the Vite React template, whose dev server defaults to
+// 5173. Used as the scan start when allocating a fresh variant's preview port.
+const FRESH_DEV_SERVER_DEFAULT_PORT = 5173;
 const DESIGN_CONTEXT_ROUTE_SEGMENT = 'design-md';
 const DESIGN_CONTEXT_VIEW_SEGMENT = 'view';
 // Hard ceiling on worktree provisioning so a slow/large host project can never
@@ -324,8 +328,7 @@ class AgentVariantsOrchestrator {
         this.variantHistory = deps.variantHistory ?? new VariantHistoryService_1.VariantHistoryService();
         this.startStaticPreviewServerImpl =
             deps.startStaticPreviewServer ?? StaticPreviewServer_1.startStaticPreviewServer;
-        this.provisionTimeoutMs =
-            deps.provisionTimeoutMs ?? PROVISION_TIMEOUT_MS;
+        this.provisionTimeoutMs = deps.provisionTimeoutMs ?? PROVISION_TIMEOUT_MS;
     }
     // --- Pure delegations (no side effects) ---------------------------------
     propose(args) {
@@ -634,6 +637,16 @@ class AgentVariantsOrchestrator {
             const isSucceeded = variant.status === 'succeeded';
             const qaFailed = qa?.status === 'failed';
             const canView = Boolean(preview) || (isSucceeded && Boolean(port));
+            // A succeeded variant with no live preview whose dev server we tried and
+            // failed to start: surface the cause so the UI can show an accurate
+            // per-direction message instead of the generic disconnected overlay.
+            const previewFailure = resources?.previewFailures.get(variant.workItemId);
+            const previewUnavailable = !canView && isSucceeded && previewFailure
+                ? {
+                    reason: previewFailure.reason,
+                    ...(previewFailure.portInUse ? { portInUse: true } : {}),
+                }
+                : undefined;
             const canCommit = isSucceeded && !qaFailed;
             const commitDisabledReason = qaFailed
                 ? (qa?.summary ?? 'Variant failed QA')
@@ -644,6 +657,7 @@ class AgentVariantsOrchestrator {
                 ...(preview ? { preview } : {}),
                 port,
                 ...(qa ? { qa } : {}),
+                ...(previewUnavailable ? { previewUnavailable } : {}),
                 actions: {
                     view: canView
                         ? { enabled: true }
@@ -2267,40 +2281,84 @@ class AgentVariantsOrchestrator {
         // Bring up a dev server in the variant's worktree so the user can cycle
         // through live variants in the iframe via the chip. Failures here are
         // logged but non-fatal — the user can still pick by reading the diff.
-        try {
-            const port = await this.worktrees.getFreePort();
-            const dev = await this.resolveDevServer(sessionId, record.worktreePath, port, isFresh);
-            const proc = await this.worktrees.startDevServer(dev.cwd, port, dev.cmd, dev.args, dev.env);
-            record.port = port;
-            record.devServerProcess = proc;
-            // If the dev server dies on its own (crash, OOM, Vite hard-fail),
-            // clear the port so the iframe stops routing the chip onto a dead
-            // socket. Without this the proxy retargets onto an unreachable port
-            // and the chip shows "upstream_unreachable" instead of the accurate
-            // "Preview is unavailable for this variant".
-            proc.once('exit', (code, signal) => {
-                if (record.devServerProcess !== proc)
-                    return;
-                record.port = undefined;
-                record.devServerProcess = undefined;
-                log.warn(`Variant ${workItemId} dev server exited unexpectedly (code=${code ?? 'null'}, signal=${signal ?? 'null'}); preview disabled`);
+        //
+        // Pick a sensible port near the framework's default (3000 for Next, 5173
+        // for Vite) and inject it via PORT + the CLI flag (see buildDevServerCommand)
+        // so the server actually binds it — that's what moves a preview off a port
+        // the user's own dev server already holds instead of colliding on it. On a
+        // retry we scan past the port we just tried, so a transient race or a
+        // briefly-held port resolves onto the next free one.
+        const startPort = await this.resolveDevServerStartPort(sessionId, isFresh);
+        let scanFrom = startPort;
+        const maxAttempts = 2;
+        for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+            let port;
+            try {
+                port = await this.worktrees.findFreePortFrom(scanFrom);
+                const dev = await this.resolveDevServer(sessionId, record.worktreePath, port, isFresh);
+                const proc = await this.worktrees.startDevServer(dev.cwd, port, dev.cmd, dev.args, dev.env);
+                record.port = port;
+                record.devServerProcess = proc;
+                // If the dev server dies on its own (crash, OOM, Vite hard-fail),
+                // clear the port so the iframe stops routing the chip onto a dead
+                // socket. Without this the proxy retargets onto an unreachable port
+                // and the chip shows "upstream_unreachable" instead of the accurate
+                // "Preview is unavailable for this variant".
+                proc.once('exit', (code, signal) => {
+                    if (record.devServerProcess !== proc)
+                        return;
+                    record.port = undefined;
+                    record.devServerProcess = undefined;
+                    log.warn(`Variant ${workItemId} dev server exited unexpectedly (code=${code ?? 'null'}, signal=${signal ?? 'null'}); preview disabled`);
+                    this.emitChange();
+                });
                 this.emitChange();
-            });
-            this.emitChange();
-            trackFreshDevServerStarted(this.telemetry, {
-                sessionId,
-                variantId: workItemId,
-                port,
-            });
-            log.info(`Variant ${workItemId} dev server up on port ${port} (worktree ${record.worktreePath}; cmd: ${dev.cmd} ${dev.args.join(' ')})`);
-        }
-        catch (err) {
-            trackFreshDevServerFailed(this.telemetry, {
-                sessionId,
-                variantId: workItemId,
-                errorCode: 'DEV_SERVER_START_FAILED',
-            });
-            log.warn(`Failed to start dev server for variant ${workItemId}; live preview disabled for this variant`, err);
+                trackFreshDevServerStarted(this.telemetry, {
+                    sessionId,
+                    variantId: workItemId,
+                    port,
+                });
+                log.info(`Variant ${workItemId} dev server up on port ${port} (worktree ${record.worktreePath}; cmd: ${dev.cmd} ${dev.args.join(' ')})`);
+                return;
+            }
+            catch (err) {
+                const portInUse = (0, devServerError_1.isDevServerStartError)(err) && err.portInUse;
+                const reason = (0, devServerError_1.isDevServerStartError)(err) ? err.reason : 'unknown';
+                const willRetry = portInUse && attempt < maxAttempts;
+                // Next attempt scans past the port we just tried so we don't re-pick a
+                // port that's persistently held (vs. a transient race that freed it).
+                scanFrom = (port ?? scanFrom) + 1;
+                log.warn(`Failed to start dev server for variant ${workItemId} on port ${port ?? 'unallocated'} ` +
+                    `(attempt ${attempt}/${maxAttempts}, reason=${reason}, portInUse=${portInUse})` +
+                    (willRetry
+                        ? '; retrying on a fresh port'
+                        : '; live preview disabled for this variant'), err);
+                if (willRetry)
+                    continue;
+                // Record the failure so getVariants can tell the UI this direction's
+                // preview couldn't start (and why), then push a snapshot so the chip
+                // updates from "loading" to the accurate per-direction message.
+                this.resources.get(sessionId)?.previewFailures.set(workItemId, {
+                    reason,
+                    portInUse,
+                });
+                trackFreshDevServerFailed(this.telemetry, {
+                    sessionId,
+                    variantId: workItemId,
+                    errorCode: 'DEV_SERVER_START_FAILED',
+                    reason,
+                    portInUse,
+                });
+                this.emitChange();
+                return;
+            }
+            finally {
+                // Hand the reservation back whether the dev server bound the port
+                // (now visible to the listener check, so the reservation is redundant),
+                // it failed (port free again), or we're about to retry on the next port.
+                if (port !== undefined)
+                    this.worktrees.releasePort?.(port);
+            }
         }
     }
     async handleStaticPreviewRefinement(args) {
@@ -2730,6 +2788,24 @@ class AgentVariantsOrchestrator {
             return undefined;
         }
     }
+    /**
+     * The port to start scanning from when allocating a variant's preview dev
+     * server. Fresh worktrees run the Vite template (5173); existing projects use
+     * their detected framework's default (3000 for Next, etc.), falling back to
+     * 3000 if detection fails. Scanning upward from here lands the preview on a
+     * sensible, predictable port near the project's normal one.
+     */
+    async resolveDevServerStartPort(sessionId, isFresh) {
+        if (isFresh)
+            return FRESH_DEV_SERVER_DEFAULT_PORT;
+        try {
+            const env = await this.resolveEnv(sessionId);
+            return env.defaultPort ?? 3000;
+        }
+        catch {
+            return 3000;
+        }
+    }
     /**
      * Resolve dev server invocation for a worktree. Fresh-project worktrees
      * always use the Vite template's npm command at the worktree root; existing
@@ -3190,6 +3266,7 @@ class AgentVariantsOrchestrator {
                 startedAt: Date.now(),
                 leasedAt: new Map(),
                 qaResults: new Map(),
+                previewFailures: new Map(),
                 vitePreservedSiblings: false,
             };
             this.resources.set(sessionId, r);
@@ -3945,6 +4022,8 @@ const trackFreshDevServerFailed = (telemetry, data) => {
         session_id: data.sessionId,
         variant_id: data.variantId,
         error_code: data.errorCode,
+        failure_reason: data.reason,
+        port_in_use: data.portInUse,
     });
 };
 const trackStaticPreviewCompleted = (telemetry, data) => {