feat(installer): run ydeploy:diff around the dev server when ydeploy is installed

When ydeploy is installed, rewrite the project package.json dev script from
"vite" to "<console> ydeploy:diff && cross-env NODE_ENV=development vite &&
<console> ydeploy:diff" so schema changes made during development surface as
migrations both before Vite starts and after it exits.

- New pure helper src/utils/patch-dev-script.ts (only the exact stub/preset
  "dev": "vite" value is rewritten — idempotent, won't clobber a custom script).
- New pipeline task src/tasks/patch-dev-script.ts, run after "Apply preset
  files" (the default preset overwrites the stub package.json verbatim) and
  before the initial commit. ydeploy presence is read from disk so it covers
  both fresh (baseline ydeploy) and augmented installs.
- Console path is layout-aware (bin/console modern, redaxo/bin/console classic).
- cross-env already ships as a devDependency in viterex_addon's stub.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: ynamite

CHANGELOG.md

@@ -8,6 +8,10 @@ lives under `[Unreleased]`.
 
 ## [Unreleased]
 
+### Added (2026-06-02)
+
+- **`pnpm dev` now diffs ydeploy migrations around the Vite dev server when ydeploy is installed.** A new pipeline task (`src/tasks/patch-dev-script.ts`, "Patch dev script for ydeploy") rewrites the project `package.json` `dev` script from `"vite"` to `"<console> ydeploy:diff && cross-env NODE_ENV=development vite && <console> ydeploy:diff"`, so schema changes made during development surface as migrations both before Vite starts and after it exits. `<console>` is layout-aware (`bin/console` in modern, `redaxo/bin/console` in classic / classic+theme); `cross-env` already ships as a devDependency in `viterex_addon`'s stub `package.json`. "ydeploy installed" is read from disk (the addon's `package.yml`), covering both a fresh install (ydeploy is part of the always-included baseline) and an augmented existing install. The task runs **after** *Apply preset files* (the default preset overwrites the stub `package.json` verbatim, so the patch must land on the final file) and **before** the initial commit. Idempotent and surgical: only the exact stub/preset `"dev": "vite"` value is rewritten, so a re-run or a customised dev script is left untouched. New pure helper `src/utils/patch-dev-script.ts` (unit-tested); ordering locked in `src/__tests__/pipeline-order.test.ts` (task count 18 → 19).
+
 ## [3.0.0-alpha.2] - 2026-06-02
 
 ### Added (2026-06-02)

src/__tests__/pipeline-order.test.ts

@@ -36,7 +36,15 @@ describe("pipeline task order", () => {
     );
   });
 
-  it("still has 18 tasks", () => {
-    expect(tasks).toHaveLength(18);
+  it("patches the dev script AFTER applying preset files (so it lands on the final package.json)", () => {
+    expect(idx("Apply preset files")).toBeLessThan(idx("Patch dev script for ydeploy"));
+  });
+
+  it("patches the dev script BEFORE the initial commit (so the change is committed)", () => {
+    expect(idx("Patch dev script for ydeploy")).toBeLessThan(idx("Git initial commit"));
+  });
+
+  it("still has 19 tasks", () => {
+    expect(tasks).toHaveLength(19);
   });
 });

src/pipeline.ts

@@ -10,6 +10,7 @@ import { installRedaxo } from "./tasks/install-redaxo.js";
 import { installAddons } from "./tasks/install-addons.js";
 import { scaffoldFrontend } from "./tasks/scaffold-frontend.js";
 import { applyPresetFiles } from "./tasks/apply-preset-files.js";
+import { patchDevScript } from "./tasks/patch-dev-script.js";
 import { buildFrontend } from "./tasks/build-frontend.js";
 import { clearCache } from "./tasks/clear-cache.js";
 import { importSql } from "./tasks/import-sql.js";
@@ -77,6 +78,13 @@ export const tasks: Task[] = [
     skip: (c) => !c.presetFilesDir,
     run: applyPresetFiles,
   },
+  // Must come AFTER "Apply preset files" — the default preset overwrites the
+  // stub package.json verbatim, so the dev-script patch has to land on the
+  // final file. No-ops unless ydeploy is installed (checked on disk).
+  {
+    name: "Patch dev script for ydeploy",
+    run: patchDevScript,
+  },
   {
     name: "Seed database",
     skip: (c) => isAugment(c) || c.skipDb || !c.seedFile,

src/tasks/patch-dev-script.ts

@@ -0,0 +1,50 @@
+import path from "node:path";
+import fs from "fs-extra";
+import * as p from "@clack/prompts";
+import { consolePathFor, srcAddonsDirFor } from "../utils/detect.js";
+import { patchDevScriptForYdeploy } from "../utils/patch-dev-script.js";
+import type { ViterexConfig } from "../types.js";
+
+/**
+ * When ydeploy is installed, rewrite the project's `dev` npm script so that
+ * `pnpm dev` brackets the Vite dev server with `ydeploy:diff` calls:
+ *
+ *   <console> ydeploy:diff && cross-env NODE_ENV=development vite && <console> ydeploy:diff
+ *
+ * "ydeploy installed" is read from the filesystem (the addon directory holds a
+ * package.yml) so it covers both a fresh install — where ydeploy is part of the
+ * always-included baseline — and an augmented existing install where ydeploy
+ * was already present.
+ *
+ * Runs AFTER "Apply preset files" so it patches the final package.json (the
+ * default preset overwrites the stub package.json verbatim), and BEFORE the
+ * initial commit so the change is committed on a clean tree.
+ *
+ * Idempotent: only the exact stub/preset `"dev": "vite"` value is rewritten;
+ * an already-patched or customised script is left untouched.
+ */
+export async function patchDevScript(config: ViterexConfig): Promise<void> {
+  const { projectDir, layout, verbose } = config;
+
+  const ydeployManifest = path.join(
+    projectDir,
+    srcAddonsDirFor(layout),
+    "ydeploy",
+    "package.yml",
+  );
+  if (!(await fs.pathExists(ydeployManifest))) {
+    if (verbose) p.log.info("ydeploy not installed — leaving dev script unchanged.");
+    return;
+  }
+
+  const pkgPath = path.join(projectDir, "package.json");
+  if (!(await fs.pathExists(pkgPath))) return;
+
+  const pkg = (await fs.readJSON(pkgPath)) as Record<string, unknown>;
+  const { pkg: patched, changed } = patchDevScriptForYdeploy(pkg, consolePathFor(layout));
+
+  if (changed) {
+    await fs.writeFile(pkgPath, `${JSON.stringify(patched, null, 2)}\n`);
+    p.log.info("Patched dev script to run ydeploy:diff around the Vite dev server.");
+  }
+}

src/utils/__tests__/patch-dev-script.test.ts

@@ -0,0 +1,67 @@
+import { describe, expect, it } from "vitest";
+import { patchDevScriptForYdeploy } from "../patch-dev-script.js";
+
+const MODERN = "bin/console";
+const CLASSIC = "redaxo/bin/console";
+
+describe("patchDevScriptForYdeploy", () => {
+  it("rewrites a plain `vite` dev script to the ydeploy variant (modern console path)", () => {
+    const { pkg, changed } = patchDevScriptForYdeploy(
+      { scripts: { dev: "vite", build: "vite build" } },
+      MODERN,
+    );
+    expect(changed).toBe(true);
+    expect((pkg.scripts as Record<string, string>).dev).toBe(
+      "bin/console ydeploy:diff && cross-env NODE_ENV=development vite && bin/console ydeploy:diff",
+    );
+    // leaves sibling scripts untouched
+    expect((pkg.scripts as Record<string, string>).build).toBe("vite build");
+  });
+
+  it("uses the classic console path when given one", () => {
+    const { pkg, changed } = patchDevScriptForYdeploy(
+      { scripts: { dev: "vite" } },
+      CLASSIC,
+    );
+    expect(changed).toBe(true);
+    expect((pkg.scripts as Record<string, string>).dev).toBe(
+      "redaxo/bin/console ydeploy:diff && cross-env NODE_ENV=development vite && redaxo/bin/console ydeploy:diff",
+    );
+  });
+
+  it("is idempotent — re-patching an already-patched dev script is a no-op", () => {
+    const first = patchDevScriptForYdeploy({ scripts: { dev: "vite" } }, MODERN);
+    const second = patchDevScriptForYdeploy(first.pkg, MODERN);
+    expect(second.changed).toBe(false);
+    expect(second.pkg).toEqual(first.pkg);
+  });
+
+  it("leaves a customised dev script alone (only the exact `vite` value is patched)", () => {
+    const { pkg, changed } = patchDevScriptForYdeploy(
+      { scripts: { dev: "vite --host" } },
+      MODERN,
+    );
+    expect(changed).toBe(false);
+    expect((pkg.scripts as Record<string, string>).dev).toBe("vite --host");
+  });
+
+  it("does nothing when there is no scripts.dev entry", () => {
+    const { changed } = patchDevScriptForYdeploy(
+      { scripts: { build: "vite build" } },
+      MODERN,
+    );
+    expect(changed).toBe(false);
+  });
+
+  it("does nothing when there is no scripts section at all", () => {
+    const { pkg, changed } = patchDevScriptForYdeploy({ name: "x" }, MODERN);
+    expect(changed).toBe(false);
+    expect(pkg).toEqual({ name: "x" });
+  });
+
+  it("does not mutate the input package object", () => {
+    const input = { scripts: { dev: "vite" } };
+    patchDevScriptForYdeploy(input, MODERN);
+    expect(input.scripts.dev).toBe("vite");
+  });
+});

src/utils/patch-dev-script.ts

@@ -0,0 +1,44 @@
+/**
+ * Rewrite the `dev` npm script so that running it diffs ydeploy migrations
+ * before and after the Vite dev server.
+ *
+ * When ydeploy is installed, `pnpm dev` should bracket the dev server with
+ * `ydeploy:diff` so schema changes made during development are surfaced as
+ * migrations (once before starting Vite, once after it exits):
+ *
+ *   <console> ydeploy:diff && cross-env NODE_ENV=development vite && <console> ydeploy:diff
+ *
+ * `<console>` is the layout-aware console binary (`bin/console` in modern,
+ * `redaxo/bin/console` in classic / classic+theme). `cross-env` already ships
+ * as a devDependency in viterex_addon's stub package.json.
+ *
+ * Only the exact stub/preset value `"vite"` is rewritten — a customised dev
+ * script is left untouched, which also makes the patch idempotent (the
+ * rewritten value is no longer `"vite"`, so a second run is a no-op).
+ *
+ * Pure — does no I/O. The caller reads and writes package.json.
+ */
+export function patchDevScriptForYdeploy(
+  pkg: Record<string, unknown>,
+  consolePath: string,
+): { pkg: Record<string, unknown>; changed: boolean } {
+  const scripts = pkg.scripts;
+  if (typeof scripts !== "object" || scripts === null) {
+    return { pkg, changed: false };
+  }
+
+  const current = (scripts as Record<string, unknown>).dev;
+  if (current !== "vite") {
+    return { pkg, changed: false };
+  }
+
+  const dev = `${consolePath} ydeploy:diff && cross-env NODE_ENV=development vite && ${consolePath} ydeploy:diff`;
+
+  return {
+    pkg: {
+      ...pkg,
+      scripts: { ...(scripts as Record<string, string>), dev },
+    },
+    changed: true,
+  };
+}