@donotdev/cli 0.0.20 → 0.0.21

package/dist/bin/commands/bump.js

@@ -255,7 +255,7 @@ function m(e2, u2) {
   const t = e2;
   t.isTTY && t.setRawMode(u2);
 }
-var import_sisteransi, uD, W, tD, eD, FD, sD, w, N, I, R, r, iD, CD, ED, d, oD, y, V, nD, G, _, z, K, aD, k, hD, lD, xD, B, AD, S, gD, vD, h, x, dD, A, OD, PD, J, LD;
+var import_sisteransi, uD, W, tD, eD, FD, sD, w, N, I, R, r, iD, CD, ED, d, oD, y, V, nD, G, _, z, K, aD, k, hD, lD, xD, B, AD, S, gD, vD, h, x, dD, A, kD, $D, H, SD;
 var init_dist = __esm({
   "node_modules/.bun/@clack+prompts@0.11.0/node_modules/@clack/prompts/node_modules/@clack/core/dist/index.mjs"() {
     init_utils();
@@ -492,12 +492,14 @@ var init_dist = __esm({
       }
     };
     A = /* @__PURE__ */ new WeakMap();
-    OD = Object.defineProperty;
-    PD = (e2, u2, t) => u2 in e2 ? OD(e2, u2, { enumerable: true, configurable: true, writable: true, value: t }) : e2[u2] = t;
-    J = (e2, u2, t) => (PD(e2, typeof u2 != "symbol" ? u2 + "" : u2, t), t);
-    LD = class extends x {
+    kD = Object.defineProperty;
+    $D = (e2, u2, t) => u2 in e2 ? kD(e2, u2, { enumerable: true, configurable: true, writable: true, value: t }) : e2[u2] = t;
+    H = (e2, u2, t) => ($D(e2, typeof u2 != "symbol" ? u2 + "" : u2, t), t);
+    SD = class extends x {
       constructor(u2) {
-        super(u2, false), J(this, "options"), J(this, "cursor", 0), this.options = u2.options, this.cursor = this.options.findIndex(({ value: t }) => t === u2.initialValue), this.cursor === -1 && (this.cursor = 0), this.changeValue(), this.on("cursor", (t) => {
+        super(u2, false), H(this, "options"), H(this, "cursor", 0), this.options = u2.options, this.value = [...u2.initialValues ?? []], this.cursor = Math.max(this.options.findIndex(({ value: t }) => t === u2.cursorAt), 0), this.on("key", (t) => {
+          t === "a" && this.toggleAll();
+        }), this.on("cursor", (t) => {
           switch (t) {
             case "left":
             case "up":
@@ -507,15 +509,22 @@ var init_dist = __esm({
             case "right":
               this.cursor = this.cursor === this.options.length - 1 ? 0 : this.cursor + 1;
               break;
+            case "space":
+              this.toggleValue();
+              break;
           }
-          this.changeValue();
         });
       }
       get _value() {
-        return this.options[this.cursor];
+        return this.options[this.cursor].value;
+      }
+      toggleAll() {
+        const u2 = this.value.length === this.options.length;
+        this.value = u2 ? [] : this.options.map((t) => t.value);
       }
-      changeValue() {
-        this.value = this._value.value;
+      toggleValue() {
+        const u2 = this.value.includes(this._value);
+        this.value = u2 ? this.value.filter((t) => t !== this._value) : [...this.value, this._value];
       }
     };
   }
@@ -527,7 +536,7 @@ import y2 from "node:process";
 function ce() {
   return y2.platform !== "win32" ? y2.env.TERM !== "linux" : !!y2.env.CI || !!y2.env.WT_SESSION || !!y2.env.TERMINUS_SUBLIME || y2.env.ConEmuTask === "{cmd::Cmder}" || y2.env.TERM_PROGRAM === "Terminus-Sublime" || y2.env.TERM_PROGRAM === "vscode" || y2.env.TERM === "xterm-256color" || y2.env.TERM === "alacritty" || y2.env.TERMINAL_EMULATOR === "JetBrains-JediTerm";
 }
-var import_picocolors, import_sisteransi2, V2, u, le, L2, W2, C, ue, o, d2, k2, P2, A2, T, F, $e, _2, me, de, pe, q, D, U, K2, b2, G2, ye, ve, xe, Ie, Se, M2, J2;
+var import_picocolors, import_sisteransi2, V2, u, le, L2, W2, C, ue, o, d2, k2, P2, A2, T, F, $e, _2, me, de, pe, q, D, U, K2, b2, G2, ye, fe, xe, Ie, Se, M2, J;
 var init_dist2 = __esm({
   "node_modules/.bun/@clack+prompts@0.11.0/node_modules/@clack/prompts/dist/index.mjs"() {
     init_utils();
@@ -600,32 +609,40 @@ ${import_picocolors.default.cyan(d2)}
         }
       } }).prompt();
     };
-    ve = (t) => {
+    fe = (t) => {
       const n = (r2, i) => {
         const s = r2.label ?? String(r2.value);
-        switch (i) {
-          case "selected":
-            return `${import_picocolors.default.dim(s)}`;
-          case "active":
-            return `${import_picocolors.default.green(k2)} ${s} ${r2.hint ? import_picocolors.default.dim(`(${r2.hint})`) : ""}`;
-          case "cancelled":
-            return `${import_picocolors.default.strikethrough(import_picocolors.default.dim(s))}`;
-          default:
-            return `${import_picocolors.default.dim(P2)} ${import_picocolors.default.dim(s)}`;
-        }
+        return i === "active" ? `${import_picocolors.default.cyan(A2)} ${s} ${r2.hint ? import_picocolors.default.dim(`(${r2.hint})`) : ""}` : i === "selected" ? `${import_picocolors.default.green(T)} ${import_picocolors.default.dim(s)} ${r2.hint ? import_picocolors.default.dim(`(${r2.hint})`) : ""}` : i === "cancelled" ? `${import_picocolors.default.strikethrough(import_picocolors.default.dim(s))}` : i === "active-selected" ? `${import_picocolors.default.green(T)} ${s} ${r2.hint ? import_picocolors.default.dim(`(${r2.hint})`) : ""}` : i === "submitted" ? `${import_picocolors.default.dim(s)}` : `${import_picocolors.default.dim(F)} ${import_picocolors.default.dim(s)}`;
       };
-      return new LD({ options: t.options, initialValue: t.initialValue, render() {
+      return new SD({ options: t.options, initialValues: t.initialValues, required: t.required ?? true, cursorAt: t.cursorAt, validate(r2) {
+        if (this.required && r2.length === 0) return `Please select at least one option.
+${import_picocolors.default.reset(import_picocolors.default.dim(`Press ${import_picocolors.default.gray(import_picocolors.default.bgWhite(import_picocolors.default.inverse(" space ")))} to select, ${import_picocolors.default.gray(import_picocolors.default.bgWhite(import_picocolors.default.inverse(" enter ")))} to submit`))}`;
+      }, render() {
         const r2 = `${import_picocolors.default.gray(o)}
 ${b2(this.state)}  ${t.message}
-`;
+`, i = (s, c) => {
+          const a = this.value.includes(s.value);
+          return c && a ? n(s, "active-selected") : a ? n(s, "selected") : n(s, c ? "active" : "inactive");
+        };
         switch (this.state) {
           case "submit":
-            return `${r2}${import_picocolors.default.gray(o)}  ${n(this.options[this.cursor], "selected")}`;
-          case "cancel":
-            return `${r2}${import_picocolors.default.gray(o)}  ${n(this.options[this.cursor], "cancelled")}
-${import_picocolors.default.gray(o)}`;
+            return `${r2}${import_picocolors.default.gray(o)}  ${this.options.filter(({ value: s }) => this.value.includes(s)).map((s) => n(s, "submitted")).join(import_picocolors.default.dim(", ")) || import_picocolors.default.dim("none")}`;
+          case "cancel": {
+            const s = this.options.filter(({ value: c }) => this.value.includes(c)).map((c) => n(c, "cancelled")).join(import_picocolors.default.dim(", "));
+            return `${r2}${import_picocolors.default.gray(o)}  ${s.trim() ? `${s}
+${import_picocolors.default.gray(o)}` : ""}`;
+          }
+          case "error": {
+            const s = this.error.split(`
+`).map((c, a) => a === 0 ? `${import_picocolors.default.yellow(d2)}  ${import_picocolors.default.yellow(c)}` : `   ${c}`).join(`
+`);
+            return `${r2 + import_picocolors.default.yellow(o)}  ${G2({ options: this.options, cursor: this.cursor, maxItems: t.maxItems, style: i }).join(`
+${import_picocolors.default.yellow(o)}  `)}
+${s}
+`;
+          }
           default:
-            return `${r2}${import_picocolors.default.cyan(o)}  ${G2({ cursor: this.cursor, options: this.options, maxItems: t.maxItems, style: (i, s) => n(i, s ? "active" : "inactive") }).join(`
+            return `${r2}${import_picocolors.default.cyan(o)}  ${G2({ options: this.options, cursor: this.cursor, maxItems: t.maxItems, style: i }).join(`
 ${import_picocolors.default.cyan(o)}  `)}
 ${import_picocolors.default.cyan(d2)}
 `;
@@ -670,7 +687,7 @@ ${import_picocolors.default.gray(d2)}  ${t}
     }, error: (t) => {
       M2.message(t, { symbol: import_picocolors.default.red(K2) });
     } };
-    J2 = `${import_picocolors.default.gray(o)}  `;
+    J = `${import_picocolors.default.gray(o)}  `;
   }
 });
 
@@ -6951,7 +6968,7 @@ var init_PathResolver = __esm({
         }
         const detectedFormat = this._detectFormat(filePath, format);
         let writeContent;
-        if (Buffer2.isBuffer(content)) {
+        if (Buffer.isBuffer(content)) {
           writeContent = content;
         } else if (detectedFormat === "json" && typeof content === "object") {
           writeContent = JSON.stringify(content, null, 2);
@@ -6960,7 +6977,7 @@ var init_PathResolver = __esm({
         }
         try {
           return await safeExecuteAsync(async () => {
-            if (Buffer2.isBuffer(writeContent)) {
+            if (Buffer.isBuffer(writeContent)) {
               await fs.promises.writeFile(normalizedPath, writeContent);
             } else {
               await fs.promises.writeFile(normalizedPath, writeContent, "utf8");
@@ -7012,7 +7029,7 @@ var init_PathResolver = __esm({
         }
         const detectedFormat = this._detectFormat(filePath, format);
         let writeContent;
-        if (Buffer2.isBuffer(content)) {
+        if (Buffer.isBuffer(content)) {
           writeContent = content;
         } else if (detectedFormat === "json" && typeof content === "object") {
           writeContent = JSON.stringify(content, null, 2);
@@ -7020,7 +7037,7 @@ var init_PathResolver = __esm({
           writeContent = String(content);
         }
         try {
-          if (Buffer2.isBuffer(writeContent)) {
+          if (Buffer.isBuffer(writeContent)) {
             fs.writeFileSync(normalizedPath, writeContent);
           } else {
             fs.writeFileSync(normalizedPath, writeContent, "utf8");
@@ -7888,7 +7905,7 @@ var init_pathResolver = __esm({
 });
 
 // packages/tooling/src/bundler/utils.ts
-import { Buffer as Buffer2 } from "node:buffer";
+import { Buffer } from "node:buffer";
 import { readFileSync as readFileSync2, writeFileSync as writeFileSync2, mkdirSync as mkdirSync2 } from "node:fs";
 import { createRequire as createRequire3 } from "node:module";
 import { dirname as dirname3, resolve as resolve3 } from "node:path";
@@ -7905,7 +7922,7 @@ var init_utils = __esm({
       globalThis.require = require2;
       globalThis.__filename = __filename;
       globalThis.__dirname = __dirname;
-      globalThis.Buffer = Buffer2;
+      globalThis.Buffer = Buffer;
       globalThis.process = process;
       if (typeof global === "undefined") {
         globalThis.global = globalThis;
@@ -7926,16 +7943,17 @@ async function askForConfirmation(message, defaultValue = false) {
   }
   return result;
 }
-async function askForSelection(message, choices, defaultValue = 0) {
+async function askForMultiSelection(message, choices, defaultIndices = []) {
   const options = choices.map((choice) => ({
     value: choice.value,
     label: choice.title,
     hint: choice.hint
   }));
-  const result = await ve({
+  const initialValues = defaultIndices.map((i) => choices[i]?.value).filter(Boolean);
+  const result = await fe({
     message,
     options,
-    initialValue: choices[defaultValue]?.value
+    initialValues: initialValues.length > 0 ? initialValues : void 0
   });
   if (pD(result)) {
     xe("Operation cancelled.");
@@ -8032,6 +8050,16 @@ function flattenGroups(groups) {
   }
   return flat;
 }
+function resolveGroup(groupName, matrix) {
+  return matrix.groups[groupName]?.packages || {};
+}
+function resolveGroups(groupNames, matrix) {
+  const result = {};
+  for (const groupName of groupNames) {
+    Object.assign(result, resolveGroup(groupName, matrix));
+  }
+  return result;
+}
 function getMigrationGuide(currentMajor, targetMajor, mode) {
   const matrixResult = loadMatrix(mode);
   if (!matrixResult) return void 0;
@@ -8102,12 +8130,376 @@ function compareVersions(current, expected) {
   return { behind: false, ahead: false, equal: true, isMajor: false };
 }
 
+// packages/tooling/src/utils/dependency-resolver.ts
+init_utils();
+function applyConditionals(template, options) {
+  if (!template.conditional) return [];
+  const groups = [];
+  for (const [groupName, condition] of Object.entries(template.conditional)) {
+    if (condition.includes("===")) {
+      const [key, value] = condition.split("===").map((s) => s.trim());
+      if (key && options[key] === value?.replace(/['"]/g, "")) {
+        groups.push(groupName);
+      }
+    } else if (options[condition]) {
+      groups.push(groupName);
+    }
+  }
+  return groups;
+}
+function generateScripts(templateName, options) {
+  const scripts = {};
+  if (templateName.includes("vite")) {
+    scripts.dev = "vite";
+    scripts.build = "vite build";
+    scripts.preview = "vite preview";
+    scripts.lint = "eslint src/";
+    scripts["type-check"] = "tsc --noEmit";
+  } else if (templateName.includes("nextjs")) {
+    scripts.dev = "next dev";
+    scripts.build = "next build";
+    scripts.preview = "next start";
+    scripts.lint = "eslint src/";
+    scripts["type-check"] = "tsc --noEmit";
+  } else if (templateName.includes("expo")) {
+    scripts.dev = "expo start";
+    scripts.start = "expo start";
+    scripts.android = "expo start --android";
+    scripts.ios = "expo start --ios";
+    scripts.web = "expo start --web";
+    scripts.build = "expo export";
+    scripts.lint = "eslint .";
+    scripts["type-check"] = "tsc --noEmit";
+  } else if (templateName === "consumer-root") {
+    scripts.dev = "dndev dev";
+    scripts.build = "turbo run build";
+    scripts.lint = "turbo run lint";
+    scripts["type-check"] = "dndev tc";
+  } else if (templateName.includes("functions")) {
+    scripts.build = "node build.mjs";
+    scripts["build:tsc"] = "tsc";
+    if (templateName.includes("firebase") || options.platform === "firebase") {
+      scripts.serve = "firebase emulators:start --only functions";
+      scripts.dev = "firebase emulators:start --only functions --inspect-functions";
+    } else {
+      scripts.dev = "vercel dev";
+    }
+  } else if (templateName === "demo") {
+    scripts.dev = "vite";
+    scripts.build = "tsc --noEmit && vite build --mode production";
+    scripts.preview = "vite preview";
+    scripts["type-check"] = "tsc --noEmit";
+  } else if (templateName === "dndev") {
+    scripts.dev = "vite";
+    scripts.build = "tsc --noEmit && vite build --mode production";
+    scripts.preview = "vite preview";
+    scripts["type-check"] = "tsc --noEmit";
+  } else if (templateName === "entities") {
+  }
+  return scripts;
+}
+function generatePackageJson(templateName, mode, options = {}) {
+  const matrixResult = loadMatrix(mode);
+  if (!matrixResult) {
+    throw new Error(
+      "dependencies-matrix.json not found. This command requires the matrix file."
+    );
+  }
+  const { matrix } = matrixResult;
+  const template = matrix.templateMapping?.[templateName];
+  if (!template) {
+    throw new Error(`Template "${templateName}" not found in matrix`);
+  }
+  const dependencies = {};
+  const devDependencies = {};
+  const peerDependencies = {};
+  const addDeps = (target, groupNames) => {
+    if (!groupNames) return;
+    const resolved = resolveGroups(groupNames, matrix);
+    for (const [name, version] of Object.entries(resolved)) {
+      target[name] = version.startsWith("^") ? version : `^${version}`;
+    }
+  };
+  addDeps(dependencies, template.dependencies);
+  addDeps(devDependencies, template.devDependencies);
+  addDeps(peerDependencies, template.peerDependencies);
+  const conditionalGroups = applyConditionals(template, options);
+  for (const groupName of conditionalGroups) {
+    let target = dependencies;
+    if (template.devDependencies?.includes(groupName)) target = devDependencies;
+    if (template.peerDependencies?.includes(groupName))
+      target = peerDependencies;
+    addDeps(target, [groupName]);
+  }
+  const scripts = generateScripts(templateName, options);
+  let packageName = "unknown";
+  if (templateName === "consumer-root" && options.projectName) {
+    packageName = options.projectName;
+  } else if (templateName.includes("functions") && options.appName) {
+    packageName = `${options.appName}-functions`;
+  } else if (options.appName) {
+    packageName = `${options.appName}-app`;
+  } else if (templateName === "entities") {
+    packageName = "entities";
+  }
+  const result = {
+    name: packageName,
+    version: matrix.version,
+    private: true,
+    type: "module",
+    scripts,
+    dependencies,
+    devDependencies
+  };
+  if (Object.keys(peerDependencies).length > 0) {
+    result.peerDependencies = peerDependencies;
+  }
+  if (templateName === "consumer-root") {
+    result.packageManager = "bun@1.3.5";
+    result.engines = { node: ">=24.0.0", bun: ">=1.3.0" };
+    result.workspaces = ["apps/*", "entities"];
+  }
+  if (templateName === "entities") {
+    result.main = "./index.ts";
+    result.types = "./index.ts";
+  }
+  if (templateName.includes("vite") || templateName.includes("nextjs") || templateName.includes("expo") || templateName.includes("functions")) {
+    if (!dependencies.entities) {
+      dependencies.entities = "workspace:*";
+    }
+  }
+  if (templateName.includes("functions")) {
+    result.main = "lib/index.js";
+    result.engines = { node: "22" };
+    if (options.appName) {
+      const platform = templateName.includes("vercel") ? "Vercel" : "Firebase";
+      result.description = `${options.appName} ${platform} Functions`;
+    }
+    if (mode === "development") {
+      const workspacePkgs = [
+        "@donotdev/functions",
+        "@donotdev/types",
+        "@donotdev/utils",
+        "@donotdev/core"
+      ];
+      for (const pkg of workspacePkgs) {
+        if (dependencies[pkg]) dependencies[pkg] = "workspace:*";
+        if (devDependencies[pkg]) devDependencies[pkg] = "workspace:*";
+      }
+    }
+  }
+  if (mode === "published") {
+    const overrides = {};
+    for (const [groupName, group] of Object.entries(matrix.groups || {})) {
+      if (groupName.startsWith("@donotdev/")) {
+        const version = group.packages?.[groupName];
+        if (version) {
+          overrides[groupName] = version.replace(/^\^/, "");
+        }
+      }
+    }
+    if (matrix.overrides) {
+      Object.assign(overrides, matrix.overrides);
+    }
+    if (Object.keys(overrides).length > 0) {
+      result.overrides = overrides;
+    }
+  }
+  return result;
+}
+
 // packages/tooling/src/maintenance/bump.ts
 init_utils();
 init_cli_input();
 init_cli_output();
 init_pathResolver();
 
+// packages/tooling/src/maintenance/sync-apps.ts
+init_utils();
+init_cli_output();
+init_errors();
+init_pathResolver();
+var PRESERVE_MAP = {
+  demo: [],
+  dndev: ["commands.ts"]
+};
+var SKIP_PATTERNS = ["package.json.example", ".generated.log"];
+function getAppTemplateSource(appName) {
+  try {
+    const templatesRoot = getTemplatesRoot();
+    const templateDir = joinPath(templatesRoot, `app-${appName}`);
+    if (pathExists(templateDir)) {
+      return normalizePath(templateDir);
+    }
+  } catch {
+  }
+  const appRoot = getAppRoot();
+  if (appRoot) {
+    const directPath = joinPath(
+      appRoot,
+      "node_modules",
+      "@donotdev",
+      "cli",
+      "templates",
+      `app-${appName}`
+    );
+    if (pathExists(directPath)) {
+      return normalizePath(directPath);
+    }
+  }
+  return null;
+}
+function syncPackageJson(appName, destRoot, dryRun) {
+  const executionMode = detectExecutionMode();
+  const packageJsonPath = joinPath(destRoot, "package.json");
+  const newPkg = generatePackageJson(appName, executionMode, {
+    appName,
+    template: "vite",
+    includeFunctions: false
+  });
+  if (pathExists(packageJsonPath)) {
+    const existing = parsePackageJson(packageJsonPath);
+    if (!existing) {
+      if (dryRun) {
+        log.info(`[DRY RUN] Would regenerate: apps/${appName}/package.json`);
+        return true;
+      }
+      writePackageJson(packageJsonPath, newPkg);
+      log.info(`Regenerated: apps/${appName}/package.json`);
+      return true;
+    }
+    let changed = false;
+    for (const field of ["dependencies", "devDependencies"]) {
+      const newDeps = newPkg[field];
+      if (!newDeps) continue;
+      const existingDeps = existing[field] ?? {};
+      for (const [pkg, version] of Object.entries(newDeps)) {
+        if (existingDeps[pkg] === "workspace:*") continue;
+        if (existingDeps[pkg] !== version) {
+          existingDeps[pkg] = version;
+          changed = true;
+        }
+      }
+      existing[field] = existingDeps;
+    }
+    if (changed) {
+      if (dryRun) {
+        log.info(
+          `[DRY RUN] Would update deps in: apps/${appName}/package.json`
+        );
+      } else {
+        writePackageJson(packageJsonPath, existing);
+        log.info(`Updated deps: apps/${appName}/package.json`);
+      }
+    }
+    return changed;
+  }
+  if (dryRun) {
+    log.info(`[DRY RUN] Would create: apps/${appName}/package.json`);
+    return true;
+  }
+  writePackageJson(packageJsonPath, newPkg);
+  log.info(`Created: apps/${appName}/package.json`);
+  return true;
+}
+async function syncApp(appName, options = {}) {
+  const { dryRun } = options;
+  let synced = 0;
+  let preserved = 0;
+  let errors = 0;
+  const appRoot = getAppRoot();
+  if (!appRoot) {
+    log.error("Could not determine project root");
+    return { synced, preserved, errors: 1 };
+  }
+  const sourceRoot = getAppTemplateSource(appName);
+  if (!sourceRoot) {
+    log.warn(
+      `Template for app-${appName} not found. Is @donotdev/cli installed?`
+    );
+    return { synced, preserved, errors: 1 };
+  }
+  const destRoot = normalizePath(joinPath(appRoot, "apps", appName));
+  if (!pathExists(destRoot)) {
+    log.info(`apps/${appName}/ does not exist \u2014 creating from template`);
+    if (!dryRun) {
+      await ensureDir(destRoot);
+    }
+  }
+  try {
+    if (syncPackageJson(appName, destRoot, dryRun ?? false)) {
+      synced++;
+    }
+  } catch (error2) {
+    errors++;
+    log.error(
+      `Error generating package.json for apps/${appName}:`,
+      DoNotDevError.from(
+        error2,
+        "package.json generation failed",
+        "file-operation-error"
+      )
+    );
+  }
+  const preserveFiles = PRESERVE_MAP[appName];
+  try {
+    const sourceFiles = await glob("**/*.example", {
+      cwd: sourceRoot,
+      absolute: true,
+      onlyFiles: true
+    });
+    for (const sourceFile of sourceFiles) {
+      const relativePath = normalizePath(sourceFile).replace(
+        sourceRoot + "/",
+        ""
+      );
+      if (SKIP_PATTERNS.some((p2) => relativePath.includes(p2))) {
+        continue;
+      }
+      const destRelative = relativePath.endsWith(".example") ? relativePath.slice(0, -8) : relativePath;
+      const destFile = joinPath(destRoot, destRelative);
+      const shouldPreserve = preserveFiles.some(
+        (f) => destRelative.endsWith(f)
+      );
+      if (shouldPreserve && pathExists(destFile)) {
+        if (dryRun) {
+          log.info(`[DRY RUN] Would preserve: apps/${appName}/${destRelative}`);
+        } else {
+          log.info(`Preserving: apps/${appName}/${destRelative}`);
+        }
+        preserved++;
+        continue;
+      }
+      if (!pathExists(sourceFile)) continue;
+      const content = await read(sourceFile, { format: "text" });
+      if (!content) continue;
+      if (pathExists(destFile)) {
+        const existing = await read(destFile, { format: "text" });
+        if (existing === content) continue;
+      }
+      if (dryRun) {
+        log.info(`[DRY RUN] Would sync: apps/${appName}/${destRelative}`);
+      } else {
+        await ensureDir(getDirname(destFile));
+        await write(destFile, content, { format: "text", overwrite: true });
+        log.info(`Synced: apps/${appName}/${destRelative}`);
+      }
+      synced++;
+    }
+  } catch (error2) {
+    errors++;
+    log.error(
+      `Error syncing app-${appName}:`,
+      DoNotDevError.from(
+        error2,
+        `Failed to sync app-${appName}`,
+        "file-operation-error"
+      )
+    );
+  }
+  return { synced, preserved, errors };
+}
+
 // packages/tooling/src/maintenance/sync-docs.ts
 init_utils();
 init_cli_output();
@@ -8384,41 +8776,45 @@ async function main(options = {}) {
   }
   let updatePackages = false;
   let updateDocs = false;
+  let updateDemoApp = false;
+  let updateCockpitApp = false;
   if (dryRun) {
     updatePackages = true;
     updateDocs = true;
+    updateDemoApp = true;
+    updateCockpitApp = true;
   } else {
-    const choices = [
-      {
-        title: "Update packages",
-        value: "packages",
-        hint: "Update @donotdev/* packages and dependencies"
-      },
-      {
-        title: "Sync documentation",
-        value: "docs",
-        hint: "Sync guides, commands, and agents from framework"
-      },
-      {
-        title: "Both",
-        value: "both",
-        hint: "Update packages and sync documentation"
-      }
-    ];
-    const selection = await askForSelection(
+    const selections = await askForMultiSelection(
       "What would you like to update?",
-      choices,
-      2
-      // Default to "Both"
+      [
+        {
+          title: "Packages",
+          value: "packages",
+          hint: "Update @donotdev/* packages and dependencies"
+        },
+        {
+          title: "Documentation",
+          value: "docs",
+          hint: "Sync guides, commands, and agents from framework"
+        },
+        {
+          title: "Demo app",
+          value: "demo",
+          hint: "Sync demo showcase app from latest template"
+        },
+        {
+          title: "Cockpit app",
+          value: "cockpit",
+          hint: "Sync dndev cockpit app from latest template"
+        }
+      ],
+      [0, 1]
+      // Default: packages + docs
     );
-    if (selection === "packages") {
-      updatePackages = true;
-    } else if (selection === "docs") {
-      updateDocs = true;
-    } else if (selection === "both") {
-      updatePackages = true;
-      updateDocs = true;
-    }
+    updatePackages = selections.includes("packages");
+    updateDocs = selections.includes("docs");
+    updateDemoApp = selections.includes("demo");
+    updateCockpitApp = selections.includes("cockpit");
   }
   if (updatePackages) {
     const files = globSync("**/package.json", {
@@ -8502,6 +8898,30 @@ async function main(options = {}) {
       log.warn("Some documentation files could not be synced");
     }
   }
+  if (updateDemoApp) {
+    log.info("\n\u{1F3A8} Syncing demo app...");
+    const result = await syncApp("demo", { dryRun });
+    if (result.synced > 0) {
+      log.success(`Synced ${result.synced} file(s) in apps/demo`);
+    } else if (result.errors === 0) {
+      log.info("Demo app up to date");
+    }
+    if (result.preserved > 0) {
+      log.info(`Preserved ${result.preserved} customized file(s)`);
+    }
+  }
+  if (updateCockpitApp) {
+    log.info("\n\u{1F6F8} Syncing cockpit app...");
+    const result = await syncApp("dndev", { dryRun });
+    if (result.synced > 0) {
+      log.success(`Synced ${result.synced} file(s) in apps/dndev`);
+    } else if (result.errors === 0) {
+      log.info("Cockpit app up to date");
+    }
+    if (result.preserved > 0) {
+      log.info(`Preserved ${result.preserved} customized file(s)`);
+    }
+  }
   Se("");
   return 0;
 }
@@ -8560,7 +8980,9 @@ ${majorUpdates.length} major update(s) available (manual review required):`
         for (const [file, packageKeys] of updatedFiles) {
           const pkg = parsePackageJson(file);
           if (!pkg) {
-            log.warn(`Could not parse ${file} \u2014 skipping updates for this file`);
+            log.warn(
+              `Could not parse ${file} \u2014 skipping updates for this file`
+            );
             continue;
           }
           let changed = false;