create-windy 0.3.9 → 0.3.11

package/dist/cli.js

@@ -835,7 +835,7 @@ var helpText = `create-windy <\u9879\u76EE\u540D> [\u9009\u9879]
 
 \u9009\u9879\uFF1A
   --profile private-enterprise  \u5355\u7EC4\u7EC7\u3001\u5355\u79DF\u6237\u3001\u79C1\u6709\u90E8\u7F72 profile
-  --skip-install                \u53EA\u751F\u6210\u6587\u4EF6\uFF0C\u4E0D\u6267\u884C bun install
+  --skip-install                \u751F\u6210\u6216\u66F4\u65B0\u65F6\u4E0D\u6267\u884C bun install
   --verify                      \u5B89\u88C5\u540E\u6267\u884C lint\uFF08\u82E5\u6709\uFF09\u3001typecheck\u3001test \u548C build
   --keep-on-error               \u5931\u8D25\u65F6\u4FDD\u7559\u65B0\u751F\u6210\u76EE\u5F55\u7528\u4E8E\u8BCA\u65AD
   --module <key>                \u589E\u52A0\u6A21\u5757\uFF0C\u53EF\u91CD\u590D\u4F7F\u7528
@@ -866,7 +866,7 @@ async function runCommand(command, args, cwd) {
   await new Promise((resolve2, reject) => {
     const child = spawn(command, args, { cwd, stdio: "inherit" });
     child.once("error", reject);
-    child.once("exit", (code, signal) => {
+    child.once("close", (code, signal) => {
       if (code === 0)
         resolve2();
       else
@@ -2851,8 +2851,22 @@ function isMissing(error) {
 // src/docker-copy-sync.ts
 var webDockerfilePath = "apps/web/Dockerfile";
 var webEntryDirectory = "apps/web";
+var serverDockerfilePath = "apps/server/Dockerfile";
+var serverEntryDirectory = "apps/server";
 var depsCopyAnchor = "windy-copy:deps";
 var buildCopyAnchor = "windy-copy:build";
+var dockerfileCopyTargets = [
+  {
+    dockerfilePath: serverDockerfilePath,
+    entryDirectory: serverEntryDirectory,
+    includeBuildClosure: false
+  },
+  {
+    dockerfilePath: webDockerfilePath,
+    entryDirectory: webEntryDirectory,
+    includeBuildClosure: true
+  }
+];
 async function snapshotWorkspacePackages(root, options = {}) {
   const rootContent = await readSafeOptional(root, "package.json");
   if (!rootContent) {
@@ -2885,10 +2899,8 @@ async function snapshotWorkspacePackages(root, options = {}) {
       packages.push({
         name: value.name,
         directory: path.slice(0, -"/package.json".length),
-        dependencies: [
-          ...Object.keys(value.dependencies ?? {}),
-          ...Object.keys(value.devDependencies ?? {})
-        ]
+        dependencies: dependencyNames(value),
+        workspaceDependencies: workspaceDependencyNames(value)
       });
     }
   }
@@ -2911,6 +2923,9 @@ function workspaceDependencyClosure(packages, entryDirectory) {
       directoryByName.set(pkg.name, pkg.directory);
     packageByDirectory.set(pkg.directory, pkg);
   }
+  if (!packageByDirectory.has(entryDirectory)) {
+    throw new Error(`Docker \u5165\u53E3\u4E0D\u662F root workspace: ${entryDirectory}`);
+  }
   const visited = new Set([entryDirectory]);
   const queue = [entryDirectory];
   while (queue.length) {
@@ -2924,6 +2939,11 @@ function workspaceDependencyClosure(packages, entryDirectory) {
         queue.push(directory);
       }
     }
+    for (const dependency of current.workspaceDependencies ?? []) {
+      if (!directoryByName.has(dependency)) {
+        throw new Error(`${current.directory} \u5F15\u7528\u672A\u77E5\u6216\u8D8A\u754C workspace dependency: ${dependency}`);
+      }
+    }
   }
   return [...visited].sort((a, b) => a.localeCompare(b));
 }
@@ -2940,15 +2960,16 @@ function rewriteAnchoredSection(source, anchor, lines) {
   return [...all.slice(0, begin + 1), ...lines, ...all.slice(end)].join(`
 `);
 }
-function hasCopyAnchors(source) {
-  return source.includes(`# ${depsCopyAnchor} begin`) && source.includes(`# ${buildCopyAnchor} begin`);
+function hasDockerfileCopyAnchors(source, target) {
+  return source.includes(`# ${depsCopyAnchor} begin`) && source.includes(`# ${depsCopyAnchor} end`) && (!target.includeBuildClosure || source.includes(`# ${buildCopyAnchor} begin`) && source.includes(`# ${buildCopyAnchor} end`));
 }
-function syncWebDockerfileSource(source, workspaceDirectories, buildDirectories) {
-  const withDeps = rewriteAnchoredSection(source, depsCopyAnchor, dockerManifestCopyLines(workspaceDirectories));
-  return rewriteAnchoredSection(withDeps, buildCopyAnchor, dockerCopyLines(buildDirectories));
+function syncDockerfileSource(source, target, packages) {
+  const closure = workspaceDependencyClosure(packages, target.entryDirectory);
+  const withDeps = rewriteAnchoredSection(source, depsCopyAnchor, dockerManifestCopyLines(packages.map(({ directory }) => directory)));
+  return target.includeBuildClosure ? rewriteAnchoredSection(withDeps, buildCopyAnchor, dockerCopyLines(closure)) : withDeps;
 }
-async function planWebDockerfileInProject(root, options = {}) {
-  const dockerfile = await readSafeOptional(root, webDockerfilePath);
+async function planDockerfileInProject(root, target, options = {}) {
+  const dockerfile = await readSafeOptional(root, target.dockerfilePath);
   if (!dockerfile) {
     return {
       synced: false,
@@ -2958,27 +2979,27 @@ async function planWebDockerfileInProject(root, options = {}) {
     };
   }
   const source = new TextDecoder().decode(dockerfile);
-  if (!hasCopyAnchors(source)) {
+  if (!hasDockerfileCopyAnchors(source, target)) {
     if (!options.requireAnchors) {
       return {
         synced: false,
         changed: false,
-        expectations: [expectation(webDockerfilePath, dockerfile)],
+        expectations: [expectation(target.dockerfilePath, dockerfile)],
         membershipExpectations: []
       };
     }
-    throw new Error(`${webDockerfilePath} \u7F3A\u5C11 # ${depsCopyAnchor} / # ${buildCopyAnchor} \u951A\u70B9\u6BB5\uFF0C` + `\u8BF7\u5148\u6309\u6700\u65B0\u6A21\u677F\u4E3A deps \u4E0E build \u9636\u6BB5\u7684 COPY \u6BB5\u6DFB\u52A0\u951A\u70B9\u540E\u518D\u540C\u6B65`);
+    throw new Error(`${target.dockerfilePath} \u7F3A\u5C11\u5FC5\u9700\u7684 Docker COPY \u951A\u70B9\u6BB5\uFF0C` + `\u8BF7\u5148\u6309\u6700\u65B0\u6A21\u677F\u8FC1\u79FB\u540E\u518D\u540C\u6B65`);
   }
   const snapshot = await snapshotWorkspacePackages(root);
   await options.afterWorkspaceSnapshot?.();
   const packages = snapshot.packages;
-  const next = syncWebDockerfileSource(source, packages.map(({ directory }) => directory), workspaceDependencyClosure(packages, webEntryDirectory));
+  const next = syncDockerfileSource(source, target, packages);
   return {
     synced: true,
     changed: next !== source,
     content: next,
     expectations: [
-      expectation(webDockerfilePath, dockerfile),
+      expectation(target.dockerfilePath, dockerfile),
       ...snapshot.expectations
     ],
     membershipExpectations: snapshot.membershipExpectations
@@ -3002,6 +3023,18 @@ function locateAnchoredSection(source, anchor) {
 function parseManifest(content) {
   return JSON.parse(new TextDecoder().decode(content));
 }
+function dependencyNames(manifest) {
+  return Object.keys({
+    ...manifest.dependencies,
+    ...manifest.devDependencies
+  });
+}
+function workspaceDependencyNames(manifest) {
+  return Object.entries({
+    ...manifest.dependencies,
+    ...manifest.devDependencies
+  }).filter(([, range]) => range.startsWith("workspace:")).map(([name]) => name);
+}
 function expectation(path, content) {
   return content ? { path, hash: hashContent(content) } : { path, hash: undefined };
 }
@@ -3019,11 +3052,13 @@ async function prepareCustomerDockerfiles(root) {
     const source = await readFile5(absolutePath, "utf8");
     await writeFile2(absolutePath, rewriteCustomerDockerfile(source));
   }));
-  const webPlan = await planWebDockerfileInProject(root, {
-    requireAnchors: true
-  });
-  if (webPlan.changed && webPlan.content !== undefined) {
-    await writeFile2(join6(root, webDockerfilePath), webPlan.content);
+  for (const target of dockerfileCopyTargets) {
+    const plan = await planDockerfileInProject(root, target, {
+      requireAnchors: true
+    });
+    if (plan.changed && plan.content !== undefined) {
+      await writeFile2(join6(root, target.dockerfilePath), plan.content);
+    }
   }
 }
 function rewriteCustomerDockerfile(source) {
@@ -7325,6 +7360,31 @@ async function assertRestoredEntries(root, state, backups) {
   }
 }
 
+// src/update/transaction-recovery-preserves.ts
+async function unresolvedPreservePaths(root, backupPath, state) {
+  const unresolved = [];
+  for (const path2 of state.preservePaths ?? []) {
+    const entry = state.entries.find((candidate) => candidate.path === path2);
+    if (!entry) {
+      unresolved.push(path2);
+      continue;
+    }
+    const expected = entry.existed ? await backupExpectation(root, backupPath, entry.path, entry.mode) : { kind: "missing" };
+    if (!matchesExpected(await hashSafePath(root, path2), await safeFileMode(root, path2), expected, entry.mode)) {
+      unresolved.push(path2);
+    }
+  }
+  return unresolved;
+}
+async function backupExpectation(root, backupPath, path2, mode) {
+  const backupFile = `${backupPath}/files/${path2}`;
+  const content = await readSafeOptional(root, backupFile);
+  if (!content || mode !== undefined && await safeFileMode(root, backupFile) !== mode) {
+    throw new Error(`\u4E8B\u52A1\u5907\u4EFD\u4E0D\u5B8C\u6574\uFF0C\u65E0\u6CD5\u89E3\u9664\u4FDD\u62A4\uFF1A${path2}`);
+  }
+  return { kind: "hash", value: hashContent(content) };
+}
+
 // src/update/transaction-recovery.ts
 async function restoreUpdateState(projectDirectory, state, options) {
   const root = await resolveProjectRoot(projectDirectory);
@@ -7351,8 +7411,17 @@ async function restoreUpdateState(projectDirectory, state, options) {
       current = await retainTransactionConflicts(root, conflicts);
     }
   }
+  const retainedPreservePaths = await unresolvedPreservePaths(root, backupPath, current);
+  if (retainedPreservePaths.length !== (current.preservePaths?.length ?? 0)) {
+    const next = {
+      ...current,
+      preservePaths: retainedPreservePaths.length ? retainedPreservePaths : undefined
+    };
+    await publishTransactionState(root, current, next);
+    current = next;
+  }
   const preserved = new Set([
-    ...current.preservePaths ?? [],
+    ...retainedPreservePaths,
     ...options?.preservePaths ?? []
   ]);
   const recoveryExpectations = new Map;
@@ -7867,23 +7936,21 @@ import { readFile as readFile17 } from "fs/promises";
 import { dirname as dirname6, join as join22 } from "path";
 
 // src/update/docker-copy-update-plan.ts
-function deriveWebDockerfilePlan(files, snapshots, paths) {
-  const dockerPlan = files.find(({ path: path2 }) => path2 === webDockerfilePath);
-  if (!dockerPlan || dockerPlan.conflict)
-    return;
-  const dockerSource = virtualContent(dockerPlan, snapshots);
-  const rootPackage = virtualPathContent("package.json", files, snapshots);
-  if (!dockerSource || !rootPackage)
+function deriveDockerfilePlans(files, snapshots, paths, targetWorkspaceManifests) {
+  const rootPackage = virtualPathContent("package.json", files, snapshots, targetWorkspaceManifests);
+  if (!rootPackage)
     return;
   const rootManifest = parsePackage(rootPackage, "package.json");
   const workspacePatterns = rootManifest.workspaces ?? [];
   const packages = [];
-  for (const path2 of [...paths].filter((path3) => path3.endsWith("package.json"))) {
+  for (const path2 of [
+    ...new Set([...paths, ...targetWorkspaceManifests.keys()])
+  ].filter((path3) => path3.endsWith("package.json"))) {
     const directory = path2 === "package.json" ? "." : path2.slice(0, -13);
     if (directory !== "." && !workspacePatterns.some((pattern) => matchesWorkspace(pattern, directory))) {
       continue;
     }
-    const content = virtualPathContent(path2, files, snapshots);
+    const content = virtualPathContent(path2, files, snapshots, targetWorkspaceManifests);
     if (!content)
       continue;
     const manifest = parsePackage(content, path2);
@@ -7893,20 +7960,32 @@ function deriveWebDockerfilePlan(files, snapshots, paths) {
       dependencies: [
         ...Object.keys(manifest.dependencies ?? {}),
         ...Object.keys(manifest.devDependencies ?? {})
-      ]
+      ],
+      workspaceDependencies: Object.entries({
+        ...manifest.dependencies,
+        ...manifest.devDependencies
+      }).filter(([, range]) => range.startsWith("workspace:")).map(([name]) => name)
     });
   }
-  const source = new TextDecoder().decode(dockerSource);
-  const next = syncWebDockerfileSource(source, packages.filter(({ directory }) => directory !== ".").map(({ directory }) => directory).sort(), workspaceDependencyClosure(packages, webEntryDirectory));
-  if (next === source)
-    return;
-  dockerPlan.action = "update";
-  dockerPlan.reason = "\u6309\u4E8B\u52A1\u5B89\u5168 workspace \u89C6\u56FE\u540C\u6B65 Docker COPY \u6E05\u5355";
-  dockerPlan.content = new TextEncoder().encode(next);
+  for (const target of dockerfileCopyTargets) {
+    const dockerPlan = files.find(({ path: path2 }) => path2 === target.dockerfilePath);
+    if (!dockerPlan || dockerPlan.conflict)
+      continue;
+    const dockerSource = virtualContent(dockerPlan, snapshots);
+    if (!dockerSource)
+      continue;
+    const source = new TextDecoder().decode(dockerSource);
+    const next = syncDockerfileSource(source, target, packages);
+    if (next === source)
+      continue;
+    dockerPlan.action = "update";
+    dockerPlan.reason = "\u6309\u4E8B\u52A1\u5B89\u5168 workspace \u89C6\u56FE\u540C\u6B65 Docker COPY \u6E05\u5355";
+    dockerPlan.content = new TextEncoder().encode(next);
+  }
 }
-function virtualPathContent(path2, files, snapshots) {
+function virtualPathContent(path2, files, snapshots, targetWorkspaceManifests) {
   const plan = files.find((item) => item.path === path2);
-  return plan ? virtualContent(plan, snapshots) : snapshots.get(path2);
+  return plan ? virtualContent(plan, snapshots) : snapshots.get(path2) ?? targetWorkspaceManifests.get(path2);
 }
 function virtualContent(plan, snapshots) {
   if (plan.action === "delete")
@@ -9014,7 +9093,9 @@ var recipes = [
   { id: "starter-0.3.5-to-0.3.6", from: "0.3.5", to: "0.3.6" },
   { id: "starter-0.3.6-to-0.3.7", from: "0.3.6", to: "0.3.7" },
   { id: "starter-0.3.7-to-0.3.8", from: "0.3.7", to: "0.3.8" },
-  { id: "starter-0.3.8-to-0.3.9", from: "0.3.8", to: "0.3.9" }
+  { id: "starter-0.3.8-to-0.3.9", from: "0.3.8", to: "0.3.9" },
+  { id: "starter-0.3.9-to-0.3.10", from: "0.3.9", to: "0.3.10" },
+  { id: "starter-0.3.10-to-0.3.11", from: "0.3.10", to: "0.3.11" }
 ];
 function resolveRecipeChain(sourceVersion, targetVersion) {
   if (sourceVersion === targetVersion)
@@ -9112,7 +9193,11 @@ async function createUpdatePlan(request, artifacts) {
     manageGeneratedProjectOwned: request.targetModules !== undefined,
     forcePlatformBaseline: request.forcePlatformBaseline === true
   });
-  deriveWebDockerfilePlan(files, projectSnapshots, new Set([...paths, ...workspaceSnapshot.manifests.keys()]));
+  deriveDockerfilePlans(files, projectSnapshots, new Set([
+    ...paths,
+    ...workspaceSnapshot.manifests.keys(),
+    ...targetWorkspaceSnapshot.manifests.keys()
+  ]), targetWorkspaceSnapshot.manifests);
   for (const file of files) {
     file.expectedProjectMode = projectModes.get(file.path);
     if (file.action === "create" || file.action === "update") {
@@ -10217,11 +10302,13 @@ class DefaultStarterUpdater {
   #execute;
   #beforeTransactionFinalize;
   #finalizeTransaction;
+  #skipInstall;
   constructor(dependencies = {}) {
     this.#artifacts = dependencies.artifacts ?? new PublishedArtifactProvider;
     this.#execute = dependencies.execute ?? runCommand;
     this.#beforeTransactionFinalize = dependencies.beforeTransactionFinalize;
     this.#finalizeTransaction = dependencies.finalizeTransaction ?? finalizeOwnedTransaction;
+    this.#skipInstall = dependencies.skipInstall ?? false;
   }
   async plan(input) {
     return createUpdatePlan(input, this.#artifacts);
@@ -10241,16 +10328,34 @@ class DefaultStarterUpdater {
     const steps = [];
     let verificationExpectationsFrozen = false;
     try {
-      const dockerSync = await planWebDockerfileInProject(result2.plan.projectDirectory, { requireAnchors: true });
-      if (dockerSync.changed) {
-        throw new TransactionCasError("Web Dockerfile COPY \u6E05\u5355\u672A\u5728\u66F4\u65B0\u8BA1\u5212\u4E2D\u540C\u6B65", "apps/web/Dockerfile");
+      const dockerSync = await Promise.all(dockerfileCopyTargets.map((target) => planDockerfileInProject(result2.plan.projectDirectory, target, {
+        requireAnchors: true
+      }).then((sync) => ({ target, sync }))));
+      const staleDockerfile = dockerSync.find(({ sync }) => sync.changed);
+      if (staleDockerfile) {
+        const plannedDockerfile = result2.plan.files.find(({ path: path2 }) => path2 === staleDockerfile.target.dockerfilePath);
+        if (plannedDockerfile && plannedDockerfile.action !== "preserve" && staleDockerfile.sync.content !== undefined) {
+          const content = new TextEncoder().encode(staleDockerfile.sync.content);
+          await writeOwnedTransactionFile(result2.plan.projectDirectory, plannedDockerfile.path, content, expectedForPath(result2, plannedDockerfile.path));
+          plannedDockerfile.action = "update";
+          plannedDockerfile.content = content;
+          replaceExpectations(result2, [
+            expectationForContent(plannedDockerfile.path, content)
+          ]);
+        } else {
+          throw new TransactionCasError("Dockerfile COPY \u6E05\u5355\u672A\u5728\u66F4\u65B0\u8BA1\u5212\u4E2D\u540C\u6B65", staleDockerfile.target.dockerfilePath);
+        }
       }
       steps.push({
-        name: "\u540C\u6B65 Web Dockerfile workspace COPY \u6E05\u5355",
-        status: dockerSync.synced ? "passed" : "skipped"
+        name: "\u540C\u6B65 Server \u4E0E Web Dockerfile workspace COPY \u6E05\u5355",
+        status: dockerSync.every(({ sync }) => sync.synced) ? "passed" : "skipped"
       });
-      await this.#execute("bun", ["install", "--force"], result2.plan.projectDirectory);
-      steps.push({ name: "bun install --force", status: "passed" });
+      if (this.#skipInstall) {
+        steps.push({ name: "bun install --force", status: "skipped" });
+      } else {
+        await this.#execute("bun", ["install", "--force"], result2.plan.projectDirectory);
+        steps.push({ name: "bun install --force", status: "passed" });
+      }
       const stabilized = await stabilizeManagedContent(result2, this.#execute, async (path2, content) => {
         await writeOwnedTransactionFile(result2.plan.projectDirectory, path2, content, expectedForPath(result2, path2));
         replaceExpectations(result2, [expectationForContent(path2, content)]);
@@ -10650,36 +10755,43 @@ async function runLifecycleCommand(args) {
     return true;
   }
   if (command === "sync-docker") {
-    const result2 = await planWebDockerfileInProject(projectDirectory, {
-      requireAnchors: true
-    });
-    if (!result2.synced) {
-      throw new Error("\u9879\u76EE\u7F3A\u5C11 apps/web/Dockerfile\uFF0C\u65E0\u6CD5\u540C\u6B65 COPY \u6E05\u5355");
+    if (args.includes("--help") || args.includes("-h")) {
+      console.log("\u7528\u6CD5\uFF1Acreate-windy sync-docker [--cwd <project-directory>]");
+      return true;
     }
-    if (result2.changed && result2.content !== undefined) {
-      await assertWorkspaceMembership(projectDirectory, result2.membershipExpectations);
+    const plans = await Promise.all(dockerfileCopyTargets.map((target) => planDockerfileInProject(projectDirectory, target, {
+      requireAnchors: true
+    }).then((result2) => ({ target, result: result2 }))));
+    if (plans.some(({ result: result2 }) => !result2.synced)) {
+      throw new Error("\u9879\u76EE\u7F3A\u5C11\u53D7\u652F\u6301\u7684 Dockerfile\uFF0C\u65E0\u6CD5\u540C\u6B65 COPY \u6E05\u5355");
+    }
+    const changed = plans.filter(({ result: result2 }) => result2.changed && result2.content !== undefined);
+    if (changed.length) {
+      const membershipExpectations = plans.flatMap(({ result: result2 }) => result2.membershipExpectations);
+      await assertWorkspaceMembership(projectDirectory, membershipExpectations);
       const state = await applyMetadataTransaction({
         id: `sync-docker-${Date.now()}`,
         projectDirectory,
-        guards: result2.expectations,
-        writes: [{ path: "apps/web/Dockerfile", content: result2.content }]
+        guards: plans.flatMap(({ result: result2 }) => result2.expectations),
+        writes: changed.map(({ target, result: result2 }) => ({
+          path: target.dockerfilePath,
+          content: result2.content
+        }))
       });
       await finalizeOwnedTransaction({
         projectDirectory,
         ownerToken: state.ownerToken,
-        expectations: [
-          {
-            path: "apps/web/Dockerfile",
-            expected: {
-              kind: "hash",
-              value: hashContent(result2.content)
-            }
+        expectations: changed.map(({ target, result: result2 }) => ({
+          path: target.dockerfilePath,
+          expected: {
+            kind: "hash",
+            value: hashContent(result2.content)
           }
-        ],
-        workspaceMembershipExpectations: result2.membershipExpectations
+        })),
+        workspaceMembershipExpectations: membershipExpectations
       });
     }
-    console.log(result2.changed ? "\u5DF2\u540C\u6B65 apps/web/Dockerfile workspace COPY \u6E05\u5355" : "apps/web/Dockerfile workspace COPY \u6E05\u5355\u5DF2\u662F\u6700\u65B0");
+    console.log(changed.length ? "\u5DF2\u540C\u6B65 Server \u4E0E Web Dockerfile workspace COPY \u6E05\u5355" : "Server \u4E0E Web Dockerfile workspace COPY \u6E05\u5355\u5DF2\u662F\u6700\u65B0");
     return true;
   }
   if (command === "doctor") {
@@ -10757,7 +10869,9 @@ async function runUpdate(args, projectDirectory) {
     console.log(`\u9879\u76EE\u5DF2\u7ECF\u662F ${target}\uFF0C\u65E0\u9700\u66F4\u65B0`);
     return;
   }
-  const updater = new DefaultStarterUpdater;
+  const updater = new DefaultStarterUpdater({
+    skipInstall: args.includes("--skip-install")
+  });
   const plan = await updater.plan({
     projectDirectory,
     targetVersion: target,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-windy",
-  "version": "0.3.9",
+  "version": "0.3.11",
   "description": "创建单组织、单租户、私有部署优先的 Windy 企业 Dashboard Starter",
   "type": "module",
   "bin": {

package/template/.windy-template.json

@@ -1,7 +1,7 @@
 {
   "schemaVersion": 1,
-  "templateCommit": "fe9c5197b083b0d4ff03f9550043d96a392992a1",
-  "generatorVersion": "0.3.9",
+  "templateCommit": "3adb3c8663d8b57b769e4abfef0f598c70241cde",
+  "generatorVersion": "0.3.11",
   "modules": [
     {
       "name": "system",

package/template/apps/server/Dockerfile

@@ -4,10 +4,11 @@ FROM oven/bun:1.3.14-alpine AS deps
 WORKDIR /app
 
 COPY package.json bun.lock ./
-COPY apps/server/package.json apps/server/package.json
-COPY apps/web/package.json apps/web/package.json
+# windy-copy:deps begin
 COPY apps/license/package.json apps/license/package.json
+COPY apps/server/package.json apps/server/package.json
 COPY apps/signing-service/package.json apps/signing-service/package.json
+COPY apps/web/package.json apps/web/package.json
 COPY packages/ai-client/package.json packages/ai-client/package.json
 COPY packages/config/package.json packages/config/package.json
 COPY packages/create-windy/package.json packages/create-windy/package.json
@@ -20,6 +21,7 @@ COPY packages/modules/package.json packages/modules/package.json
 COPY packages/server-sdk/package.json packages/server-sdk/package.json
 COPY packages/shared/package.json packages/shared/package.json
 COPY packages/storage/package.json packages/storage/package.json
+# windy-copy:deps end
 RUN bun install --frozen-lockfile
 
 FROM deps AS runner

package/template/package.json

@@ -51,6 +51,8 @@
     "ops:release": "bun run scripts/production-release.ts",
     "test:merge": "bun run scripts/merge-gate.ts",
     "release:verify": "bun run scripts/release-verify.ts",
+    "release:candidate": "bun run scripts/release-candidate.ts",
+    "release:verify:full": "bun run scripts/release-verify.ts --full",
     "test:packages:pack": "bun run scripts/platform-package-release.ts",
     "test:agent": "uv run --directory apps/agent-server pytest",
     "test:document": "uv run --directory apps/document-server pytest",