rivet-design 0.10.0 → 0.10.2

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

@@ -416,6 +416,106 @@ class AgentVariantsOrchestrator {
         this.emitChange();
         return decorated;
     }
+    beginStaticPreviewRefinements(args) {
+        const seenVariantIds = new Set();
+        for (const target of args.targets) {
+            if (seenVariantIds.has(target.variantId))
+                continue;
+            seenVariantIds.add(target.variantId);
+            const currentHtml = this.resources
+                .get(args.sessionId)
+                ?.staticPreviews.get(target.variantId)?.html ??
+                (() => {
+                    try {
+                        const output = this.store.getWorkItemOutput(args.sessionId, target.variantId);
+                        return output?.html;
+                    }
+                    catch {
+                        return undefined;
+                    }
+                })();
+            try {
+                this.store.createRefineVariantWorkItem({
+                    sessionId: args.sessionId,
+                    variantId: target.variantId,
+                    instruction: target.instruction,
+                    currentHtml,
+                });
+            }
+            catch (error) {
+                if (error instanceof errors_1.AgentVariantsError &&
+                    error.code === 'PENDING_CHANGE_CONFLICT') {
+                    // A refinement is already queued for this variant and the newer
+                    // comment was already consumed from the bridge. Fold it into the
+                    // still-pending item so it isn't silently dropped.
+                    const folded = this.store.appendPendingRefineVariantInstruction({
+                        sessionId: args.sessionId,
+                        variantId: target.variantId,
+                        instruction: target.instruction,
+                    });
+                    if (!folded) {
+                        this.store.createRefineVariantWorkItem({
+                            sessionId: args.sessionId,
+                            variantId: target.variantId,
+                            instruction: target.instruction,
+                            currentHtml,
+                        });
+                    }
+                    continue;
+                }
+                throw error;
+            }
+        }
+        this.emitChange();
+    }
+    getVariantPick(sessionId) {
+        return this.store.getVariantPick(sessionId);
+    }
+    refineVariant(args) {
+        try {
+            const lease = this.store.leaseRefineItemForVariant({
+                sessionId: args.sessionId,
+                variantId: args.variantId,
+                leaseOwner: args.leaseOwner,
+            });
+            this.emitChange();
+            return lease;
+        }
+        catch (error) {
+            if (!(error instanceof errors_1.AgentVariantsError) ||
+                error.code !== 'INVALID_STAGE_ACTION' ||
+                !error.message.includes('No pending refinement exists')) {
+                throw error;
+            }
+        }
+        const currentHtml = this.resources
+            .get(args.sessionId)
+            ?.staticPreviews.get(args.variantId)?.html ??
+            (() => {
+                try {
+                    const output = this.store.getWorkItemOutput(args.sessionId, args.variantId);
+                    return output?.html;
+                }
+                catch {
+                    return undefined;
+                }
+            })();
+        const refineItem = this.store.createRefineVariantWorkItem({
+            sessionId: args.sessionId,
+            variantId: args.variantId,
+            instruction: args.instruction,
+            currentHtml,
+        });
+        // Lease the just-created refine item by id. A generic
+        // requestWork({ requestedLeaseCount: 1 }) takes the first leasable item in
+        // work-item order, which could be an unrelated still-pending static_preview
+        // rather than this refinement.
+        return this.requestWork({
+            sessionId: args.sessionId,
+            leaseOwner: args.leaseOwner,
+            workItemId: refineItem.id,
+        });
+    }
     getStage(sessionId) {
         return this.store.getStage(sessionId);
     }
@@ -512,6 +612,13 @@ class AgentVariantsOrchestrator {
         return this.resources.get(sessionId)?.worktrees.get(workItemId)
             ?.worktreePath;
     }
+    /**
+     * Resolve the project cwd inside a worktree so subdirectory projects run
+     * from the same repo-relative location.
+     */
+    getProjectCwdInWorktree(worktreePath) {
+        return this.worktrees.getProjectCwdInWorktree(worktreePath);
+    }
     /** Resolve the dev server port for a code-gen work item, if running. */
     getDevServerPort(sessionId, workItemId) {
         return this.resources.get(sessionId)?.worktrees.get(workItemId)?.port;
@@ -586,7 +693,8 @@ class AgentVariantsOrchestrator {
         // plant a symlink under the base (e.g. via a follow-up Write tool call)
         // could pivot outside the sandbox.
         const target = path_1.default.resolve(record.assetBase, '.' + path_1.default.sep + requestedPath);
-        if (target !== record.assetBase && !target.startsWith(record.assetBase + path_1.default.sep)) {
+        if (target !== record.assetBase &&
+            !target.startsWith(record.assetBase + path_1.default.sep)) {
             return undefined;
         }
         let realTarget;
@@ -769,6 +877,9 @@ class AgentVariantsOrchestrator {
         };
     }
     async reportComplete(args) {
+        const workItemKind = this.store.hasSession(args.sessionId)
+            ? this.store.getWorkItemKind(args.sessionId, args.workItemId)
+            : undefined;
         // Contract validation: a `succeeded` static_preview report MUST carry the
         // deliverable inline as `output.html` (with optional `css` / `js`). Agents
         // sometimes default to writing files to disk and reporting back a file
@@ -778,10 +889,10 @@ class AgentVariantsOrchestrator {
         // of silently producing an empty-preview run.
         if (args.status === 'succeeded' &&
             this.store.hasSession(args.sessionId) &&
-            this.store.getWorkItemKind(args.sessionId, args.workItemId) ===
-                'static_preview' &&
+            (workItemKind === 'static_preview' ||
+                workItemKind === 'refine_variant') &&
             !parseStaticPreviewOutput(normalizeOutput(args.output))) {
-            throw new errors_1.AgentVariantsError('SCHEMA_VALIDATION_FAILED', 'static_preview report_variant_complete requires output.html (string, non-empty). ' +
+            throw new errors_1.AgentVariantsError('SCHEMA_VALIDATION_FAILED', `${workItemKind} report_variant_complete requires output.html (string, non-empty). ` +
                 'Pass the full HTML inline as output: { html: "<!doctype html>...", css?: "...", js?: "..." }. ' +
                 'Do NOT write the HTML to a file and report a file list — Rivet renders the HTML inline; on-disk files are not read.');
         }
@@ -790,8 +901,45 @@ class AgentVariantsOrchestrator {
         // verdict converts the report to `failed` with code `VARIANT_QA_FAILED`
         // so the variant never reaches `ready` and `getVariants` can disable
         // its commit action.
-        const qaOverride = await this.evaluateQaForReport(args);
-        const effectiveArgs = qaOverride?.overrideArgs ?? args;
+        const qaOverride = workItemKind === 'refine_variant'
+            ? null
+            : await this.evaluateQaForReport(args);
+        let effectiveArgs = qaOverride?.overrideArgs ?? args;
+        // For a successful refine_variant, swap the refined static preview into
+        // place and persist history BEFORE recording success in the store. This
+        // keeps the user-visible `refinement.status: succeeded` (and the snapshot
+        // emitted below) from ever being observable while the variant still serves
+        // stale HTML. If post-processing throws, convert the report to `failed` so
+        // the agent/UI surface the failure instead of a success pointing at
+        // unrefreshed output.
+        if (workItemKind === 'refine_variant' &&
+            effectiveArgs.status === 'succeeded') {
+            try {
+                this.store.validateReportLease({
+                    sessionId: args.sessionId,
+                    workItemId: args.workItemId,
+                    leaseId: args.leaseId,
+                    attempt: args.attempt,
+                });
+                await this.handleStaticPreviewRefinement({
+                    sessionId: args.sessionId,
+                    workItemId: args.workItemId,
+                    output: args.output,
+                });
+            }
+            catch (err) {
+                log.error(`handleStaticPreviewRefinement failed for ${args.sessionId}/${args.workItemId}`, err);
+                const code = err instanceof errors_1.AgentVariantsError ? err.code : 'INTERNAL_ERROR';
+                const message = err instanceof Error
+                    ? err.message
+                    : 'Static preview refinement post-processing failed';
+                effectiveArgs = {
+                    ...effectiveArgs,
+                    status: 'failed',
+                    error: { code, message },
+                };
+            }
+        }
         const result = this.store.reportComplete(effectiveArgs);
         this.emitChange();
         // Per-variant telemetry on terminal item statuses (skip 'running'
@@ -848,7 +996,8 @@ class AgentVariantsOrchestrator {
                 });
             }
         }
-        if (effectiveArgs.status === 'succeeded') {
+        if (effectiveArgs.status === 'succeeded' &&
+            workItemKind !== 'refine_variant') {
             void this.handleSucceededReport({
                 sessionId: args.sessionId,
                 workItemId: args.workItemId,
@@ -1075,8 +1224,7 @@ class AgentVariantsOrchestrator {
                 if (!anyAssetBaseIsDestination) {
                     const allowed = new Set();
                     for (const sp of resources.staticPreviews.values()) {
-                        if (sp.assetBase &&
-                            isStrictlyInside(sp.assetBase, compareBase)) {
+                        if (sp.assetBase && isStrictlyInside(sp.assetBase, compareBase)) {
                             allowed.add(path_1.default.basename(sp.assetBase));
                         }
                     }
@@ -1426,7 +1574,9 @@ class AgentVariantsOrchestrator {
             payloadKind: payload.kind,
             destinationPath: envelopeDestination,
             ...(committedPreviewPort
-                ? { previewUrl: `http://${FRESH_DEV_SERVER_HOST}:${committedPreviewPort}` }
+                ? {
+                    previewUrl: `http://${FRESH_DEV_SERVER_HOST}:${committedPreviewPort}`,
+                }
                 : {}),
         };
     }
@@ -1697,6 +1847,10 @@ class AgentVariantsOrchestrator {
             return null;
         if (!this.store.hasSession(args.sessionId))
             return null;
+        if (this.store.getWorkItemKind(args.sessionId, args.workItemId) !==
+            'static_preview') {
+            return null;
+        }
         const projectContext = this.store.getProjectContext(args.sessionId);
         if (projectContext.kind !== 'fresh')
             return null;
@@ -1868,6 +2022,64 @@ class AgentVariantsOrchestrator {
             log.warn(`Failed to start dev server for variant ${workItemId}; live preview disabled for this variant`, err);
         }
     }
+    async handleStaticPreviewRefinement(args) {
+        const resources = this.resources.get(args.sessionId);
+        if (!resources) {
+            throw new errors_1.AgentVariantsError('SESSION_NOT_FOUND', `No live resources for session ${args.sessionId}`);
+        }
+        const input = this.store.getWorkItemInput(args.sessionId, args.workItemId);
+        if (!input.variantId) {
+            throw new errors_1.AgentVariantsError('MISSING_REQUIRED_INPUT', 'refine_variant work item is missing variantId');
+        }
+        const parsed = parseStaticPreviewOutput(normalizeOutput(args.output));
+        if (!parsed) {
+            throw new errors_1.AgentVariantsError('SCHEMA_VALIDATION_FAILED', 'refine_variant report_variant_complete requires output.html');
+        }
+        const targetInput = this.store.getWorkItemInput(args.sessionId, input.variantId);
+        if (!targetInput.briefId) {
+            throw new errors_1.AgentVariantsError('VARIANT_NOT_EDITABLE', 'Target static_preview variant is missing briefId');
+        }
+        const resolvedAssetBase = resolveStaticPreviewAssetBase({
+            assetBase: parsed.assetBase,
+            projectContext: this.store.getProjectContext(args.sessionId),
+        });
+        // A refinement that only rewrites HTML won't re-declare an assetBase, but
+        // the refined markup can still reference the original sibling assets
+        // (images, GLB, fonts). Fall back to the variant's existing asset base so
+        // those relative URLs keep resolving instead of 404ing after the swap.
+        const previousAssetBase = resources.staticPreviews.get(input.variantId)?.assetBase;
+        const assetBase = resolvedAssetBase ?? previousAssetBase;
+        // Swap the served preview to the refined HTML. This is the critical step:
+        // once this is in place the success the caller records (and the snapshot it
+        // emits) never serves stale HTML. It runs before store.reportComplete so a
+        // validation failure above converts to a `failed` report rather than a
+        // success pointing at unrefreshed output.
+        this.store.replaceWorkItemOutput(args.sessionId, input.variantId, {
+            ...parsed,
+            ...(assetBase ? { assetBase } : {}),
+        });
+        resources.staticPreviews.set(input.variantId, {
+            workItemId: input.variantId,
+            briefId: targetInput.briefId,
+            html: parsed.html,
+            ...(assetBase ? { assetBase } : {}),
+        });
+        // History persistence is best-effort, mirroring handleSucceededReport's
+        // fire-and-forget persistence for freshly completed variants. A failure
+        // here (e.g. a transient filesystem race) must not fail the refinement or
+        // discard the already-serving refined HTML.
+        try {
+            await this.persistCompletedFreshVariant({
+                sessionId: args.sessionId,
+                workItemId: input.variantId,
+            });
+        }
+        catch (err) {
+            log.warn(`persistCompletedFreshVariant failed for refined variant ${input.variantId} (session ${args.sessionId}); preview already swapped`, err);
+        }
+        // The caller (reportComplete) emits the change after recording success so
+        // the snapshot reflects both the swapped HTML and refinement.status.
+    }
     /**
      * Persist a completed existing-project code_gen variant into
      * `<env.projectPath>/.rivet/variants/<sessionId>/<variantId>/`. Called from
@@ -1887,7 +2099,9 @@ class AgentVariantsOrchestrator {
             log.warn(`persistCompletedExistingVariant: resolveEnv failed for ${args.sessionId}`, err);
             return;
         }
-        const record = this.resources.get(args.sessionId)?.worktrees.get(args.workItemId);
+        const record = this.resources
+            .get(args.sessionId)
+            ?.worktrees.get(args.workItemId);
         let sourceDir;
         if (env.framework === 'static' && record) {
             try {