rivet-design 0.11.17 → 0.12.1

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

@@ -17,6 +17,7 @@ const devServerError_1 = require("../../utils/devServerError");
 const errors_1 = require("./errors");
 const createProjectArtifacts_1 = require("./createProjectArtifacts");
 const contracts_1 = require("./contracts");
+const briefContent_1 = require("./briefContent");
 const runLabel_1 = require("./runLabel");
 const runPlan_1 = require("./runPlan");
 const viteReactTs_1 = require("../../services/templates/viteReactTs");
@@ -28,6 +29,17 @@ const VariantHistoryService_1 = require("../../services/VariantHistoryService");
 const variantContext_1 = require("./variantContext");
 const log = (0, logger_1.createLogger)('AgentVariantsOrchestrator');
 const FRESH_DEV_SERVER_HOST = '127.0.0.1';
+// Upper bound on waiting for in-flight history persists during session
+// teardown. Generous enough for a full-repo snapshot on a large project;
+// small enough that a wedged git subprocess (which has its own 120s block
+// timeout) can't make commit/cancel appear hung.
+const SETTLE_PERSISTS_TEARDOWN_TIMEOUT_MS = 20_000;
+// Sentinel port for deriving a persist-time serve recipe when the dev server
+// hasn't booted yet: resolved into the command, then reverse-substituted to
+// the ${PORT} placeholder. Digit-boundary-guarded substitution means only an
+// exact standalone occurrence is replaced, and 65535 never appears in any
+// framework's default invocation.
+const RECIPE_PORT_SENTINEL = 65535;
 // 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;
@@ -1663,7 +1675,7 @@ class AgentVariantsOrchestrator {
     buildUnifiedBriefs(args) {
         const briefId = (i) => args.uniqueBriefIds ? `v-${(0, crypto_1.randomUUID)().slice(0, 8)}` : `v${i + 1}`;
         if (args.briefs) {
-            return args.briefs.map((b, i) => ({
+            return args.briefs.map((b, i) => (0, briefContent_1.normalizeBriefContent)({
                 briefId: briefId(i),
                 label: b.label,
                 body: b.body,
@@ -3207,6 +3219,7 @@ class AgentVariantsOrchestrator {
                 const proc = await this.worktrees.startDevServer(dev.cwd, port, dev.cmd, dev.args, dev.env);
                 args.record.port = port;
                 args.record.devServerProcess = proc;
+                args.record.devCommand = dev;
                 // 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
@@ -3366,12 +3379,12 @@ class AgentVariantsOrchestrator {
                     if (this.store.getProjectContext(sessionId).kind === 'fresh') {
                         // History at `<workspacePath>/.rivet/variants/<sessionId>/<variantId>/`
                         // is the on-disk record for this generated project.
-                        this.persistCompletedFreshVariant({
+                        this.trackHistoryPersist(this.persistCompletedFreshVariant({
                             sessionId,
                             workItemId,
                         }).catch((err) => {
                             log.warn(`persistCompletedFreshVariant failed for ${sessionId}/${workItemId}`, err);
-                        });
+                        }));
                     }
                     const leasedAt = resources.leasedAt.get(workItemId);
                     trackStaticPreviewCompleted(this.telemetry, {
@@ -3422,21 +3435,21 @@ class AgentVariantsOrchestrator {
         // failure here must never block dev-server startup or the user's pick
         // flow.
         if (!isFresh) {
-            this.persistCompletedExistingVariant({
+            this.trackHistoryPersist(this.persistCompletedExistingVariant({
                 sessionId,
                 workItemId,
                 diff: record.diff ?? '',
             }).catch((err) => {
                 log.warn(`persistCompletedExistingVariant failed for ${sessionId}/${workItemId}`, err);
-            });
+            }));
         }
         else {
-            this.persistCompletedFreshVariant({
+            this.trackHistoryPersist(this.persistCompletedFreshVariant({
                 sessionId,
                 workItemId,
             }).catch((err) => {
                 log.warn(`persistCompletedFreshVariant failed for ${sessionId}/${workItemId}`, err);
-            });
+            }));
         }
         // Static existing-mode projects (framework='static', no dev command) have
         // no per-variant dev server to proxy the iframe at. Serve the variant's
@@ -3535,6 +3548,35 @@ class AgentVariantsOrchestrator {
         // The caller (reportComplete) emits the change after recording success so
         // the snapshot reflects both the swapped HTML and refinement.status.
     }
+    /** The worktree/dev-server manager this orchestrator boots previews with.
+     *  Exposed so HistoryReplayService shares the SAME instance: the
+     *  reserved-but-not-yet-bound port set is per-instance, and a second
+     *  manager scanning the same range can hand a live variant's pending port
+     *  to a replay (EADDRINUSE for the loser). */
+    get devServerManager() {
+        return this.worktrees;
+    }
+    /** In-flight fire-and-forget history persists. Tree-store snapshots spawn
+     *  git subprocesses, so these can outlive the microtask flushes that used
+     *  to be enough to drain them — {@link teardownSession} (and the test
+     *  helpers' settleBackgroundWork) await {@link settleHistoryPersists}
+     *  instead of racing the writes. */
+    pendingHistoryPersists = new Set();
+    trackHistoryPersist(persist) {
+        this.pendingHistoryPersists.add(persist);
+        void persist
+            .catch(() => undefined)
+            .finally(() => {
+            this.pendingHistoryPersists.delete(persist);
+        });
+    }
+    /** Await every in-flight history persist, including ones that start while
+     *  draining (a refine can persist mid-settle). */
+    async settleHistoryPersists() {
+        while (this.pendingHistoryPersists.size > 0) {
+            await Promise.allSettled([...this.pendingHistoryPersists]);
+        }
+    }
     /**
      * Persist a completed existing-project code_gen variant into
      * `<env.projectPath>/.rivet/variants/<sessionId>/<variantId>/`. Called from
@@ -3568,10 +3610,57 @@ class AgentVariantsOrchestrator {
         }
         const input = this.store.getWorkItemInput(args.sessionId, args.workItemId);
         const sessionPrompt = this.store.getPrompt(args.sessionId);
+        // Tree-store snapshot inputs (dual-write). The snapshot root is the
+        // worktree root — the git root, per the tree-root contract — for EVERY
+        // framework, not just static: this is what makes dev-server (Vite /
+        // fullstack) variants replayable from history instead of diff-only.
+        const snapshotDir = record?.worktreePath;
+        // Lazy per-session base snapshot from the host repo root. Best-effort:
+        // resolution failure just means no base ref (variant commits still land).
+        let baseDir;
+        try {
+            baseDir = await this.worktrees.getGitRoot?.();
+        }
+        catch (err) {
+            log.warn(`persistCompletedExistingVariant: git root resolution failed for ${args.sessionId}`, err);
+        }
+        let serve;
+        if (sourceDir && record) {
+            // Static framework: entryPath is relative to the snapshot root (the
+            // worktree root), pointing into the nested project dir when the
+            // project lives below the git root.
+            const entryPath = path_1.default.relative(record.worktreePath, path_1.default.join(sourceDir, 'index.html'));
+            serve = { kind: 'static', entryPath };
+        }
+        else if (record?.devCommand && record.port !== undefined) {
+            serve = {
+                kind: 'dev-server',
+                recipe: buildServeRecipeFromResolved(record.worktreePath, record.devCommand, record.port),
+            };
+        }
+        else if (record) {
+            // Persist fires at code-gen success, BEFORE the dev server boots (the
+            // boot is what stashes record.devCommand/port) — so for the common
+            // path the live invocation isn't available yet. Run the same
+            // deterministic resolution the boot will use, against a sentinel port
+            // that becomes the ${PORT} placeholder. No dependency install here —
+            // resolveDevServerCommand is the side-effect-free half of the split.
+            try {
+                const dev = await this.resolveDevServerCommand(args.sessionId, record.worktreePath, RECIPE_PORT_SENTINEL, false);
+                serve = {
+                    kind: 'dev-server',
+                    recipe: buildServeRecipeFromResolved(record.worktreePath, dev, RECIPE_PORT_SENTINEL),
+                };
+            }
+            catch (err) {
+                log.warn(`persistCompletedExistingVariant: dev command resolution failed for ${args.sessionId}/${args.workItemId} — persisting without a serve recipe`, err);
+            }
+        }
         await this.variantHistory.persistVariant({
             projectPath: env.projectPath,
             sessionId: args.sessionId,
             variantId: args.workItemId,
+            ...(input.requestId ? { requestId: input.requestId } : {}),
             label: input.briefLabel,
             brief: input.briefBody,
             sessionPrompt,
@@ -3584,6 +3673,9 @@ class AgentVariantsOrchestrator {
                 : { kind: 'none', reason: 'diff_only' },
             changedFilesCount: countDiffFiles(args.diff),
             projectKind: 'existing',
+            snapshotDir,
+            baseDir,
+            serve,
         });
     }
     /**
@@ -3772,11 +3864,42 @@ class AgentVariantsOrchestrator {
                     script: 'dev',
                 },
             };
+        // Tree-store serve contract. Fresh worktrees prefer the live record's
+        // resolved invocation (stashed at dev-server start); the fallback recipe
+        // mirrors resolveDevServer's fresh branch, which is fully deterministic
+        // for the Vite template. Static previews serve their staged index.html.
+        // Fresh sessions have no host project, so there is no base snapshot —
+        // variant commits are root commits.
+        const serve = staticPreview
+            ? { kind: 'static', entryPath: 'index.html' }
+            : worktreeRecord?.devCommand && worktreeRecord.port !== undefined
+                ? {
+                    kind: 'dev-server',
+                    recipe: buildServeRecipeFromResolved(worktreeRecord.worktreePath, worktreeRecord.devCommand, worktreeRecord.port),
+                }
+                : {
+                    kind: 'dev-server',
+                    recipe: {
+                        cwd: '.',
+                        cmd: 'npm',
+                        argsTemplate: [
+                            'run',
+                            'dev',
+                            '--',
+                            '--port',
+                            '${PORT}',
+                            '--host',
+                            FRESH_DEV_SERVER_HOST,
+                        ],
+                        envTemplate: { PORT: '${PORT}' },
+                    },
+                };
         try {
             await this.variantHistory.persistVariant({
                 projectPath: historyProjectPath,
                 sessionId: args.sessionId,
                 variantId: args.workItemId,
+                ...(input.requestId ? { requestId: input.requestId } : {}),
                 label: input.briefLabel,
                 brief: input.briefBody,
                 sessionPrompt,
@@ -3788,6 +3911,8 @@ class AgentVariantsOrchestrator {
                 projectKind: 'fresh',
                 designMarkdown: designArtifact?.markdown,
                 designSource: designArtifact?.source,
+                snapshotDir: sourceDir,
+                serve,
             });
         }
         finally {
@@ -3975,6 +4100,25 @@ class AgentVariantsOrchestrator {
      * projects defer to the user's framework/packageManager config.
      */
     async resolveDevServer(sessionId, workItemId, worktreePath, port, isFresh) {
+        const resolved = await this.resolveDevServerCommand(sessionId, worktreePath, port, isFresh);
+        if (!isFresh) {
+            await this.ensureExistingProjectDependencies({
+                sessionId,
+                workItemId,
+                cwd: resolved.cwd,
+                packageManager: resolved.packageManager,
+            });
+        }
+        return resolved;
+    }
+    /**
+     * Pure invocation resolution — no dependency installs, no side effects.
+     * Split from {@link resolveDevServer} so history persistence can capture
+     * the SAME deterministic resolution the boot path uses without booting:
+     * persist fires at code-gen success, before the dev server starts, so the
+     * live record's stashed command usually isn't available yet.
+     */
+    async resolveDevServerCommand(sessionId, worktreePath, port, isFresh) {
         if (isFresh) {
             return {
                 cwd: worktreePath,
@@ -3989,31 +4133,28 @@ class AgentVariantsOrchestrator {
                     FRESH_DEV_SERVER_HOST,
                 ],
                 env: { PORT: String(port) },
+                packageManager: 'npm',
             };
         }
         const env = await this.resolveEnv(sessionId);
         const cwd = await this.resolveExistingProjectCwd(sessionId, worktreePath, env);
         const packageManager = detectPackageManagerForCwd(cwd, env.packageManager);
-        await this.ensureExistingProjectDependencies({
-            sessionId,
-            workItemId,
-            cwd,
-            packageManager,
-        });
         if (packageManager !== env.packageManager) {
             return {
                 cwd,
+                packageManager,
                 ...buildExistingProjectDevCommand(packageManager, env.devCommand, port),
             };
         }
         if (env.buildDevCommand) {
-            return { cwd, ...env.buildDevCommand(port) };
+            return { cwd, packageManager, ...env.buildDevCommand(port) };
         }
         return {
             cwd,
             cmd: env.packageManager,
             args: [env.devCommand, '--port', String(port)],
             env: { PORT: String(port) },
+            packageManager,
         };
     }
     /**
@@ -4411,6 +4552,17 @@ class AgentVariantsOrchestrator {
             return;
         resources.cleanupStarted = true;
         log.info(`Tearing down session ${sessionId} (reason: ${reason})`);
+        // Drain in-flight history persists BEFORE deleting worktrees: a tree
+        // snapshot's `git add -A --work-tree <worktree>` racing the deletion
+        // below doesn't fail — it stages whatever files remain, publishing a
+        // silently truncated snapshot. The design doc's ordering constraint
+        // ("tree committed before worktree teardown") is enforced here, not
+        // just in tests. Best-effort with a bound: never let a wedged git call
+        // stall teardown forever.
+        await Promise.race([
+            this.settleHistoryPersists(),
+            new Promise((resolve) => setTimeout(resolve, SETTLE_PERSISTS_TEARDOWN_TIMEOUT_MS)),
+        ]);
         // Stop dev servers in parallel; ignore individual failures.
         // NOTE: For the fresh vite_app rename path, commitVariant already stopped
         // these dev servers BEFORE the rename (so Vite couldn't recreate `.vite/`
@@ -5472,6 +5624,25 @@ const detectPackageManagerForCwd = (cwd, fallback) => {
     }
     return 'npm';
 };
+/**
+ * Turn the invocation a live dev server actually booted with into a
+ * port-parameterized replay recipe. The resolution bakes the allocated port
+ * into args/env (`--port <n>`, `PORT=<n>`) — storing that verbatim would
+ * bake in a dead port, so occurrences of the port (digit-boundary-guarded so
+ * incidental digit runs survive) become `${PORT}` for replay to substitute.
+ * `cwd` is stored relative to the snapshot root per the tree-root contract.
+ */
+const buildServeRecipeFromResolved = (snapshotRoot, dev, port) => {
+    const portPattern = new RegExp(`(?<![0-9])${port}(?![0-9])`, 'g');
+    const sub = (value) => value.replace(portPattern, '${PORT}');
+    const relativeCwd = path_1.default.relative(snapshotRoot, dev.cwd);
+    return {
+        cwd: relativeCwd === '' ? '.' : relativeCwd,
+        cmd: dev.cmd,
+        argsTemplate: dev.args.map(sub),
+        envTemplate: Object.fromEntries(Object.entries(dev.env).map(([key, value]) => [key, sub(value)])),
+    };
+};
 const buildExistingProjectDevCommand = (packageManager, devCommand, port) => {
     const env = { PORT: String(port) };
     if (packageManager === 'npm') {