rivet-design 0.17.2 → 0.17.4

package/dist/agent-variants/WorktreeOrchestrator.js

@@ -10,7 +10,9 @@ const events_1 = require("events");
 const fs_1 = __importDefault(require("fs"));
 const os_1 = __importDefault(require("os"));
 const path_1 = __importDefault(require("path"));
-const child_process_1 = require("child_process");
+const DependencyPreparationService_1 = require("../services/DependencyPreparationService");
+const ProjectPackageManager_1 = require("../services/ProjectPackageManager");
+const devServerCommand_1 = require("../utils/devServerCommand");
 const simple_git_1 = require("simple-git");
 const logger_1 = require("../utils/logger");
 const devServerError_1 = require("../utils/devServerError");
@@ -1785,37 +1787,54 @@ class AgentVariantsOrchestrator {
         return this.resources.get(sessionId)?.worktrees.get(workItemId)?.port;
     }
     /**
-     * Restores a Rivet-owned variant preview that the active-session idle timer
-     * reclaimed. Other missing-preview causes remain terminal so this path never
-     * attempts to restart user-owned or repeatedly failing servers.
+     * Restores a Rivet-owned preview after idle reclamation or an explicit retry
+     * of a failed start. Reuses the saved worktree without leasing generation work.
      *
      * @effect Clears the idle marker and prior crash budget, starts the worktree
      *   dev server, and emits preview-state snapshots.
      * @deps Uses the live session resources, project context, and dev-server
      *   manager owned by this orchestrator.
      */
-    async restoreVariantPreview(sessionId, workItemId) {
+    async restoreVariantPreview(sessionId, workItemId, options = {}) {
         const resources = this.resources.get(sessionId);
         const record = resources?.worktrees.get(workItemId);
-        if (!resources || !record)
+        if (!resources || !record || resources.cleanupStarted)
             return undefined;
+        if (record.previewRestoration)
+            return record.previewRestoration;
         if (record.port !== undefined && record.devServerProcess) {
             this.touchSession(sessionId);
             return record.port;
         }
-        if (resources.previewFailures.get(workItemId)?.reason !== 'idle_timeout') {
+        const failure = resources.previewFailures.get(workItemId);
+        const isSucceeded = this.store
+            .getVariants(sessionId)
+            .some((variant) => variant.workItemId === workItemId && variant.status === 'succeeded');
+        const isExplicitRetry = options.retryFailed === true &&
+            failure?.reason !== 'missing_static_entry';
+        if (!failure ||
+            !isSucceeded ||
+            (failure.reason !== 'idle_timeout' && !isExplicitRetry)) {
             return undefined;
         }
         resources.previewFailures.delete(workItemId);
         record.devServerAutoRestarts = 0;
         this.emitChange();
         const projectContext = this.store.getProjectContext(sessionId);
-        return this.startVariantDevServer({
+        const restoration = this.startVariantDevServer({
             sessionId,
             workItemId,
             record,
             isFresh: projectContext.kind === 'fresh',
         });
+        record.previewRestoration = restoration;
+        try {
+            return await restoration;
+        }
+        finally {
+            if (record.previewRestoration === restoration)
+                record.previewRestoration = undefined;
+        }
     }
     /**
      * @effect Resolves the dev server port for a preview request and refreshes
@@ -1958,8 +1977,8 @@ class AgentVariantsOrchestrator {
         });
         this.emitChange();
         // Await provisioning before returning so request_work always sees a
-        // populated worktreePath on each leased item. Provisioning is fast
-        // (`git worktree add` per variant + node_modules symlink), and the
+        // populated worktreePath on each leased item. Provisioning creates a
+        // git worktree and copies dependencies for each variant, and the
         // agent has nothing useful to do between approve and request_work
         // anyway — running them serially is the contract the skill assumes.
         try {
@@ -2972,12 +2991,6 @@ class AgentVariantsOrchestrator {
                         // because teardown runs AFTER the rename — too late to prevent the
                         // stub-dir race.
                         await this.stopAllDevServersForSession(resources);
-                        // node_modules in fresh variants 1..N is a symlink into variant 0
-                        // (see runBackgroundInstall). After rename, variant 0's
-                        // node_modules vanishes during cleanup of the sibling worktrees,
-                        // leaving the chosen variant with a dangling link. Resolve the
-                        // symlink to a real directory first so the destination has real
-                        // deps and the rename is self-contained.
                         isDependencyInstallRequired = await resolveNodeModulesSymlink(record.worktreePath);
                         await this.renameWorktreeIntoDestination(record.worktreePath, destinationPath);
                         usedRename = true;
@@ -3404,8 +3417,7 @@ class AgentVariantsOrchestrator {
     }
     /**
      * Existing-project flow: clone the user's repo N times via git worktree.
-     * Runs synchronously because the operation is fast (no install needed —
-     * node_modules is symlinked from the source project).
+     * Waits for source and dependency copies before making work available.
      */
     async provisionExistingWorktrees(sessionId, approveResult) {
         const resources = this.ensureResources(sessionId);
@@ -3545,24 +3557,17 @@ class AgentVariantsOrchestrator {
     async runBackgroundInstall(sessionId, scaffoldWorkItemId, worktreePaths, scaffoldStartedAt) {
         const installStartedAt = Date.now();
         try {
-            const [firstWorktree, ...rest] = worktreePaths;
-            await this.installDependencies(firstWorktree);
-            await Promise.all(rest.map(async (p) => {
-                const target = path_1.default.join(firstWorktree, 'node_modules');
-                const link = path_1.default.join(p, 'node_modules');
-                // The fresh template has no node_modules until install runs, so
-                // the link target is guaranteed absent in `p` — no need to remove
-                // first.
-                try {
-                    fs_1.default.symlinkSync(target, link, 'dir');
-                }
-                catch (symlinkErr) {
-                    log.warn(`Symlink node_modules failed for ${p}, falling back to install`, symlinkErr);
-                    await this.installDependencies(p);
-                }
-            }));
+            await Promise.all(worktreePaths.map((worktreePath) => this.installDependencies(worktreePath, {
+                workspaceRoot: worktreePath,
+                signal: this.resources.get(sessionId)?.dependencyAbortController.signal,
+            })));
         }
         catch (err) {
+            // Teardown aborts in-flight preparation; a cancelled session is not a
+            // scaffold failure.
+            const resources = this.resources.get(sessionId);
+            if (!resources || resources.cleanupStarted)
+                return;
             const message = err instanceof Error ? err.message : String(err);
             log.warn(`npm install failed for session ${sessionId}; marking scaffold_base failed`, err);
             trackScaffoldFailed(this.telemetry, {
@@ -3845,8 +3850,10 @@ class AgentVariantsOrchestrator {
             let port;
             try {
                 port = await this.worktrees.findFreePortFrom(scanFrom);
-                const dev = await this.resolveDevServer(args.sessionId, args.workItemId, args.record.worktreePath, port, args.isFresh);
+                const dev = await this.resolveDevServer(args.sessionId, args.record.worktreePath, port, args.isFresh);
                 lastDev = dev;
+                if (!canContinueStart())
+                    return undefined;
                 const proc = await this.worktrees.startDevServer(dev.cwd, port, dev.cmd, dev.args, dev.env);
                 // The boot can outlive the session (a cancel during the readiness
                 // wait, or during an auto-restart's delay). At this point the child
@@ -3982,13 +3989,33 @@ class AgentVariantsOrchestrator {
                     if (missingDeps && lastDev) {
                         installRetried = true;
                         try {
-                            await this.installDependencies(lastDev.cwd, lastDev.packageManager);
+                            await this.installDependencies(lastDev.cwd, {
+                                workspaceRoot: args.record.worktreePath,
+                                force: true,
+                                signal: this.resources.get(args.sessionId)
+                                    ?.dependencyAbortController.signal,
+                            });
                         }
                         catch (installErr) {
-                            // Still retry: the boot error may have been transient, and the
-                            // retry's own failure telemetry is more specific than aborting
-                            // here on the install's stderr.
-                            log.warn(`Dependency install before dev-server retry failed for variant ${args.workItemId}`, installErr);
+                            log.warn(`Dependency preparation failed for variant ${args.workItemId}`, installErr);
+                            this.resources
+                                .get(args.sessionId)
+                                ?.previewFailures.set(args.workItemId, {
+                                reason: 'dependency_install_failed',
+                                portInUse: false,
+                            });
+                            trackPreviewFailed(this.telemetry, {
+                                sessionId: args.sessionId,
+                                variantId: args.workItemId,
+                                projectContextKind,
+                                previewKind: 'dev_server',
+                                errorCode: 'DEPENDENCY_INSTALL_FAILED',
+                                reason: 'dependency_install_failed',
+                                portInUse: false,
+                                durationMs: Date.now() - previewStartedAt,
+                            });
+                            this.emitChange();
+                            return undefined;
                         }
                     }
                     continue;
@@ -4002,9 +4029,11 @@ class AgentVariantsOrchestrator {
                     reason,
                     portInUse,
                 });
-                const errorCode = reason === 'missing_dev_script'
-                    ? 'DEV_SCRIPT_MISSING'
-                    : 'DEV_SERVER_START_FAILED';
+                let errorCode = 'DEV_SERVER_START_FAILED';
+                if (reason === 'dependency_install_failed')
+                    errorCode = 'DEPENDENCY_INSTALL_FAILED';
+                if (reason === 'missing_dev_script')
+                    errorCode = 'DEV_SCRIPT_MISSING';
                 // Telemetry gets structured classification only — never the raw
                 // output tail, which routinely carries absolute project paths and
                 // source frames (see AGENTS.md "What NEVER to capture"). The full
@@ -4875,16 +4904,13 @@ class AgentVariantsOrchestrator {
      * always use the Vite template's npm command at the worktree root; existing
      * projects defer to the user's framework/packageManager config.
      */
-    async resolveDevServer(sessionId, workItemId, worktreePath, port, isFresh) {
+    async resolveDevServer(sessionId, 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,
-            });
-        }
+        await this.ensureProjectDependencies({
+            signal: this.resources.get(sessionId)?.dependencyAbortController.signal,
+            cwd: resolved.cwd,
+            workspaceRoot: worktreePath,
+        });
         return resolved;
     }
     /**
@@ -4917,18 +4943,31 @@ class AgentVariantsOrchestrator {
             throw new Error('Static projects do not have a dev server command');
         }
         const cwd = await this.resolveExistingProjectCwd(sessionId, worktreePath, env);
-        const packageManager = detectPackageManagerForCwd(cwd, env.packageManager);
         // Every branch below — including the production buildDevCommand recipes
         // from utils/devServerCommand.ts — invokes the package.json script named
         // by env.devCommand, so the preflight applies to all of them.
         if (env.devCommand) {
             assertDevScriptExists(cwd, env.devCommand);
         }
+        const detected = fs_1.default.existsSync(path_1.default.join(cwd, 'package.json'))
+            ? await (0, ProjectPackageManager_1.resolveProjectPackageManager)({
+                cwd,
+                workspaceRoot: worktreePath,
+            }).catch((error) => {
+                throw new devServerError_1.DevServerStartError({
+                    message: error instanceof Error ? error.message : String(error),
+                    detail: '',
+                    reason: 'dependency_install_failed',
+                    portInUse: false,
+                });
+            })
+            : null;
+        const packageManager = detected?.name ?? env.packageManager;
         if (packageManager !== env.packageManager) {
             return {
                 cwd,
                 packageManager,
-                ...buildExistingProjectDevCommand(packageManager, env.devCommand, port),
+                ...(0, devServerCommand_1.buildDevServerCommand)(env.framework, packageManager, env.devCommand, port),
             };
         }
         if (env.buildDevCommand) {
@@ -4942,19 +4981,14 @@ class AgentVariantsOrchestrator {
             packageManager,
         };
     }
-    /**
-     * Existing-project variants usually reuse the user's installed
-     * node_modules. Nested example projects may be standalone packages with no
-     * install in the cloned worktree; install only when the package has no
-     * node_modules so normal user projects are not penalized.
-     */
-    async ensureExistingProjectDependencies(args) {
-        const packageJsonPath = path_1.default.join(args.cwd, 'package.json');
-        const nodeModulesPath = path_1.default.join(args.cwd, 'node_modules');
-        if (!fs_1.default.existsSync(packageJsonPath) || fs_1.default.existsSync(nodeModulesPath)) {
+    /** Prepares the direction's declared dependencies before each server start. */
+    async ensureProjectDependencies(args) {
+        if (!fs_1.default.existsSync(path_1.default.join(args.cwd, 'package.json')))
             return;
-        }
-        await this.installDependencies(args.cwd, args.packageManager);
+        await this.installDependencies(args.cwd, {
+            workspaceRoot: args.workspaceRoot,
+            signal: args.signal,
+        });
     }
     /**
      * Resolve the dev-server working directory for an existing-project variant.
@@ -4983,8 +5017,7 @@ class AgentVariantsOrchestrator {
     /**
      * After the chosen variant has been renamed into `destinationPath`, move
      * each unchosen sibling worktree into a `<destinationParent>/<slug>-variants/NN-<label>/`
-     * folder and repoint its `node_modules` symlink at the chosen project's
-     * real install. Writes a manifest documenting all 5 variants (the chosen
+     * folder with its own prepared dependency installation. Writes a manifest documenting all 5 variants (the chosen
      * one with `folder: null` and `chosenPath: '../<slug>'`).
      *
      * Sets `vitePreservedSiblings = true` on session resources so the
@@ -4999,7 +5032,6 @@ class AgentVariantsOrchestrator {
         const destinationParent = path_1.default.dirname(args.destinationPath);
         const projectSlug = path_1.default.basename(args.destinationPath);
         const historyDir = (0, createProjectArtifacts_1.createVariantsHistoryPath)(destinationParent, projectSlug);
-        const sharedNodeModulesAbs = path_1.default.join(args.destinationPath, 'node_modules');
         const briefs = this.store.getBriefs(args.sessionId);
         const variants = this.store.getVariants(args.sessionId);
         const briefIndexById = new Map(briefs.map((b, i) => [b.briefId, i]));
@@ -5057,26 +5089,6 @@ class AgentVariantsOrchestrator {
                         fs_1.default.renameSync(record.worktreePath, dest);
                         return dest;
                     })();
-                // Repoint node_modules at the chosen project's real install.
-                try {
-                    if (this.worktrees.repointNodeModulesSymlink) {
-                        this.worktrees.repointNodeModulesSymlink(newPath, sharedNodeModulesAbs);
-                    }
-                    else {
-                        const link = path_1.default.join(newPath, 'node_modules');
-                        try {
-                            fs_1.default.rmSync(link, { force: true, recursive: true });
-                        }
-                        catch {
-                            /* may not exist */
-                        }
-                        const target = path_1.default.relative(path_1.default.dirname(link), sharedNodeModulesAbs);
-                        fs_1.default.symlinkSync(target, link, 'dir');
-                    }
-                }
-                catch (err) {
-                    log.warn(`repointNodeModulesSymlink failed for ${newPath}; variant still runnable after npm install`, err);
-                }
                 // Update the in-memory record so teardown doesn't try to operate on
                 // the stale path.
                 record.worktreePath = newPath;
@@ -5408,6 +5420,8 @@ class AgentVariantsOrchestrator {
         resources.cleanupStarted = true;
         this.clearActivePreviewIdleTimer(resources);
         log.info(`Tearing down session ${sessionId} (reason: ${reason})`);
+        resources.dependencyAbortController.abort();
+        await Promise.all([...resources.worktrees.values()].map((record) => DependencyPreparationService_1.previewDependencies.settle(record.worktreePath)));
         // 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
@@ -5504,6 +5518,7 @@ class AgentVariantsOrchestrator {
                 workspaceManager: new VariantWorkspaceManager_1.VariantWorkspaceManager(),
                 contextAssets: new Map(),
                 cleanupStarted: false,
+                dependencyAbortController: new AbortController(),
                 committedVariantIds: new Set(),
                 startedAt: Date.now(),
                 nextRoundIndex: 0,
@@ -6447,54 +6462,15 @@ function copyStaticPreviewDirectory(src, dest) {
         }
     }
 }
-const buildInstallCommand = (packageManager) => {
-    if (packageManager === 'npm') {
-        return {
-            cmd: 'npm',
-            args: ['install', '--no-audit', '--no-fund', '--ignore-scripts'],
-        };
-    }
-    return {
-        cmd: packageManager,
-        args: ['install', '--ignore-scripts'],
-    };
-};
-const defaultInstallDependencies = (worktreePath, packageManager = 'npm') => {
-    const install = buildInstallCommand(packageManager);
-    return new Promise((resolve, reject) => {
-        const proc = (0, child_process_1.spawn)(install.cmd, install.args, {
-            cwd: worktreePath,
-            stdio: ['ignore', 'ignore', 'pipe'],
-        });
-        let stderr = '';
-        proc.stderr.on('data', (chunk) => {
-            stderr += chunk.toString();
-        });
-        proc.on('error', reject);
-        proc.on('exit', (code) => {
-            if (code === 0) {
-                resolve();
-                return;
-            }
-            reject(new Error(`${install.cmd} install in ${worktreePath} failed (code ${code}): ${stderr.slice(-512)}`));
-        });
+/** Prepares an isolated project through its selected package manager. */
+const defaultInstallDependencies = async (worktreePath, options) => {
+    await DependencyPreparationService_1.previewDependencies.prepare({
+        cwd: worktreePath,
+        workspaceRoot: options?.workspaceRoot ?? worktreePath,
+        force: options?.force,
+        signal: options?.signal,
     });
 };
-const detectPackageManagerForCwd = (cwd, fallback) => {
-    if (fs_1.default.existsSync(path_1.default.join(cwd, 'yarn.lock')))
-        return 'yarn';
-    if (fs_1.default.existsSync(path_1.default.join(cwd, 'pnpm-lock.yaml')))
-        return 'pnpm';
-    if (fs_1.default.existsSync(path_1.default.join(cwd, 'package-lock.json')))
-        return 'npm';
-    if (fallback === 'pnpm' || fallback === 'yarn' || fallback === 'npm') {
-        // A nested package without a lockfile should not inherit a root Yarn Berry
-        // workspace when it is not declared as a workspace member; npm treats it as
-        // an independent package and is the safest default for old examples.
-        return fs_1.default.existsSync(path_1.default.join(cwd, 'package.json')) ? 'npm' : 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
@@ -6516,12 +6492,16 @@ const buildServeRecipeFromResolved = (snapshotRoot, dev, port) => {
 };
 /**
  * Whether an install at `cwd` stays inside the Rivet-owned worktree.
- * Existing-project worktrees SYMLINK `node_modules` to the user's real
- * install (WorktreeManager.symlinkNodeModulesIfAvailable) — running a
- * package manager through that link would mutate the user's project
- * dependencies, which the variants flow must never do. Install is safe only
+ * A linked `node_modules` can point at another project's install; running a
+ * package manager through it would mutate dependencies outside this worktree.
+ * Install is safe only
  * when `node_modules` is absent (a nested standalone package — the install
  * creates a worktree-local dir) or a real directory owned by the worktree.
+ *
+ * Complements DependencyPreparationService.assertOwnedInstall rather than
+ * duplicating it: this stricter check (any symlink, even one resolving
+ * inside the worktree) decides whether an install RETRY is worth attempting,
+ * while the service enforces containment on every install it runs.
  */
 const canInstallWithoutTouchingHost = (cwd) => {
     try {
@@ -6568,29 +6548,6 @@ const assertDevScriptExists = (cwd, scriptName) => {
             : '',
     });
 };
-const buildExistingProjectDevCommand = (packageManager, devCommand, port) => {
-    const env = { PORT: String(port) };
-    if (packageManager === 'npm') {
-        return {
-            cmd: 'npm',
-            args: [
-                'run',
-                devCommand,
-                '--',
-                '--port',
-                String(port),
-                '--host',
-                FRESH_DEV_SERVER_HOST,
-            ],
-            env,
-        };
-    }
-    return {
-        cmd: packageManager,
-        args: [devCommand, '--port', String(port), '--host', FRESH_DEV_SERVER_HOST],
-        env,
-    };
-};
 /**
  * True when `a` and `b` (or the closest existing ancestor of each) live on
  * the same filesystem volume. Used by commitVariant to decide between an
@@ -6612,65 +6569,20 @@ function areSameVolume(a, b) {
         return false;
     }
 }
-/**
- * Materialize node_modules from symlink → real directory at the given path,
- * so a subsequent rename of that path leaves a self-contained tree.
- *
- * Fresh worktrees 1..N share variant 0's node_modules via a symlink (see
- * runBackgroundInstall). When the user picks variant K and we rename it
- * into the destination, the sibling worktrees get torn down — which would
- * otherwise leave a dangling symlink in the destination if variant K was
- * the one with the symlink (K > 0).
- *
- * Returns true when the destination must run a dependency install after the
- * rename because node_modules is missing or points nowhere.
- */
+/** Clears a borrowed install so a moved generated project prepares its own dependencies. */
 async function resolveNodeModulesSymlink(worktreePath) {
     const nodeModulesPath = path_1.default.join(worktreePath, 'node_modules');
-    let lstat;
     try {
-        lstat = await fs_1.default.promises.lstat(nodeModulesPath);
-    }
-    catch {
-        return true;
-    }
-    if (!lstat.isSymbolicLink())
-        return false;
-    let target;
-    try {
-        target = await fs_1.default.promises.realpath(nodeModulesPath);
-    }
-    catch {
+        if (!(await fs_1.default.promises.lstat(nodeModulesPath)).isSymbolicLink())
+            return false;
         await fs_1.default.promises.rm(nodeModulesPath, { force: true });
         return true;
     }
-    // Stage the copy under a sibling temp name so a mid-copy failure (disk
-    // full, EACCES, etc.) leaves the original symlink intact rather than
-    // wiping it and leaving the worktree with no node_modules at all.
-    // The final swap is then atomic on the same filesystem (rename + unlink).
-    const stagingPath = `${nodeModulesPath}.materializing-${(0, crypto_1.randomBytes)(4).toString('hex')}`;
-    try {
-        await fs_1.default.promises.cp(target, stagingPath, {
-            recursive: true,
-            dereference: false,
-        });
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return true;
+        throw error;
     }
-    catch (err) {
-        // Best-effort cleanup of the partial staging dir; leave the symlink
-        // intact so the caller can re-run materialization.
-        await fs_1.default.promises
-            .rm(stagingPath, { recursive: true, force: true })
-            .catch(() => { });
-        throw err;
-    }
-    // Swap: remove the symlink, then rename the staging dir into place.
-    // Both operations are local fs ops on the same parent — fast and
-    // unlikely to fail independently, but if the rename fails the symlink
-    // is already gone, so prefer to leave the staging dir on disk over a
-    // half-broken worktree (the caller will surface the throw).
-    await fs_1.default.promises.rm(nodeModulesPath, { force: true });
-    await fs_1.default.promises.rename(stagingPath, nodeModulesPath);
-    return false;
 }
 const defaultMaterializeProject = async (sourceWorktreePath, destinationPath) => {
     await fs_1.default.promises.mkdir(destinationPath, { recursive: true });