create-vidra-app 0.1.5 → 0.1.7

package/dist/cli.js

@@ -1,11 +1,7 @@
-// src/cli.ts
-import chalk7 from "chalk";
-
 // src/commands/build.ts
 import path5 from "path";
 import fs4 from "fs-extra";
 import { execSync as execSync3 } from "child_process";
-import chalk5 from "chalk";
 
 // src/utils.ts
 var parseArgs = (argv) => {
@@ -14,7 +10,17 @@ var parseArgs = (argv) => {
     const arg = argv[i];
     if (arg.startsWith("--")) {
       const [key, val] = arg.slice(2).split("=");
-      args[key] = val ?? argv[++i] ?? true;
+      if (val !== void 0) {
+        args[key] = val;
+        continue;
+      }
+      const next = argv[i + 1];
+      if (next !== void 0 && !next.startsWith("--")) {
+        args[key] = next;
+        i++;
+      } else {
+        args[key] = true;
+      }
     } else {
       args._.push(arg);
     }
@@ -24,10 +30,69 @@ var parseArgs = (argv) => {
 
 // src/exec.ts
 import { execSync } from "child_process";
+
+// src/theme.ts
 import chalk from "chalk";
-var toText = (value) => {
-  if (value == null) return "";
-  return Buffer.isBuffer(value) ? value.toString() : value;
+var CLI_VERSION = "0.1.5";
+var STEP_LABEL_WIDTH = 16;
+var lime = chalk.hex("#c8f751");
+var value = chalk.hex("#e8e8ec");
+var dim = chalk.hex("#7a7a86");
+var amber = chalk.hex("#ffcf5c");
+var green = chalk.hex("#86d98f");
+var red = chalk.hex("#ff8585");
+var slate = chalk.hex("#a9b0bd");
+var uiColor = chalk.hex("#6fd3e0");
+var hostColor = chalk.hex("#a48ce8");
+var GLYPH_CHAR = {
+  done: "\u2713",
+  active: "\u25B8",
+  error: "\u2717",
+  manual: "?",
+  plan: "\u25C6",
+  skip: "\u2298"
+};
+var GLYPH_COLOR = {
+  done: green,
+  active: lime,
+  error: red,
+  manual: amber,
+  plan: slate,
+  skip: slate
+};
+var glyph = (name) => GLYPH_COLOR[name](GLYPH_CHAR[name]);
+var TAG_COLOR = {
+  ui: uiColor,
+  host: hostColor
+};
+var TAG_WIDTH = 6;
+var tag = (name) => TAG_COLOR[name](`[${name}]`.padEnd(TAG_WIDTH));
+var blankTag = () => " ".repeat(TAG_WIDTH);
+var wordmark = () => lime("vidra");
+var header = (sub, context) => {
+  const base = `  ${wordmark()} ${value(sub)}`;
+  return context ? `${base} ${dim(`\u2014 ${context}`)}` : base;
+};
+var kv = (label, val, width = 9) => `  ${dim(label.padEnd(width))} ${value(val)}`;
+var row = (opts) => {
+  const parts = [`  ${glyph(opts.glyph)}`];
+  if (opts.label !== void 0) {
+    const padded = opts.labelWidth ? opts.label.padEnd(opts.labelWidth) : opts.label;
+    parts.push(value(padded));
+  }
+  if (opts.detail) parts.push(opts.detail);
+  return parts.join(" ");
+};
+var taggedRow = (glyphName, tagName, text) => `  ${glyph(glyphName)} ${tagName ? tag(tagName) : blankTag()} ${text}`;
+var streamPrefix = (tagName) => `  ${dim("\xB7")} ${tag(tagName)}`;
+var footer = (content) => `  ${content}`;
+var fixLine = (cmd, label = "fix:") => `      ${amber(label)} ${lime(cmd)}`;
+var planBadge = (text = "PLAN ONLY \xB7 BEING BUILT") => amber(`[ ${text} ]`);
+
+// src/exec.ts
+var toText = (value2) => {
+  if (value2 == null) return "";
+  return Buffer.isBuffer(value2) ? value2.toString() : value2;
 };
 var formatProcessError = (error) => {
   const err = error;
@@ -49,7 +114,6 @@ var formatBuildError = (error) => {
 // src/project.ts
 import path from "path";
 import fs from "fs-extra";
-import chalk2 from "chalk";
 var detectPlatform = () => {
   switch (process.platform) {
     case "darwin":
@@ -88,9 +152,15 @@ var detectProject = (cwd) => {
     dir = parent;
   }
   console.error(
-    chalk2.red(
-      "  Could not detect Vidra project. Run this command from your project root.\n  Expected: package.json, ui/, src/<Name>.Host/<Name>.Host.csproj"
-    )
+    row({
+      glyph: "error",
+      detail: dim(
+        "Could not detect Vidra project. Run this command from your project root."
+      )
+    })
+  );
+  console.error(
+    footer(dim("expected: package.json, ui/, src/<Name>.Host/<Name>.Host.csproj"))
   );
   process.exit(1);
 };
@@ -161,7 +231,6 @@ var macosTarget = {
 // src/signing.ts
 import path3 from "path";
 import { execFileSync } from "child_process";
-import chalk3 from "chalk";
 var signMacAppBundleIfPossible = (appBundle, options) => {
   if (process.platform !== "darwin") return;
   const identity = resolveMacCodeSigningIdentity();
@@ -176,20 +245,30 @@ var signMacAppBundleIfPossible = (appBundle, options) => {
       }
     );
     options.log(
-      identity ? `  ${chalk3.dim("Signing:")}  ${chalk3.cyan(label)} ${chalk3.dim(`with ${identity}`)}` : `  ${chalk3.dim("Signing:")}  ${chalk3.cyan(label)} ${chalk3.dim("ad-hoc (no developer identity)")}`
+      row({
+        glyph: "done",
+        label: "codesign",
+        labelWidth: STEP_LABEL_WIDTH,
+        detail: identity ? `${value(label)} ${dim(`with ${identity}`)}` : `${value(label)} ${dim("ad-hoc (-)")}`
+      })
     );
   } catch (error) {
     options.warn(
-      chalk3.yellow(
-        "  Could not code-sign the macOS app bundle; it may fail to launch."
-      )
+      row({
+        glyph: "manual",
+        label: "codesign",
+        labelWidth: STEP_LABEL_WIDTH,
+        detail: dim("could not sign the app bundle; it may fail to launch")
+      })
     );
     options.warn(
-      chalk3.yellow(
-        "  Install Xcode or the Command Line Tools (provides `codesign`), or set VIDRA_MACOS_CODESIGN_KEY."
+      footer(
+        dim(
+          "install Xcode or the Command Line Tools (provides `codesign`), or set VIDRA_MACOS_CODESIGN_KEY."
+        )
       )
     );
-    options.warn(chalk3.dim(formatExecError(error)));
+    options.warn(dim(formatExecError(error)));
   }
 };
 var resolveMacCodeSigningIdentity = () => {
@@ -206,7 +285,7 @@ var resolveMacCodeSigningIdentity = () => {
         encoding: "utf8"
       }
     );
-    const identities = output.split(/\r?\n/).map((line) => line.match(/"([^"]+)"/)?.[1] ?? null).filter((value) => value !== null);
+    const identities = output.split(/\r?\n/).map((line) => line.match(/"([^"]+)"/)?.[1] ?? null).filter((value2) => value2 !== null);
     return identities.find((identity) => identity.startsWith("Apple Development:")) ?? identities.find((identity) => identity.startsWith("Developer ID Application:")) ?? null;
   } catch {
     return null;
@@ -225,45 +304,74 @@ var formatExecError = (error) => {
 
 // src/targets/windows.ts
 import path4 from "path";
+import os2 from "os";
 import fs3 from "fs-extra";
+import { execFileSync as execFileSync2 } from "child_process";
 var windowsTarget = {
   name: "windows",
   framework: "net10.0-windows10.0.19041.0",
-  extraPublishArgs: "-p:RuntimeIdentifierOverride=win-x64 -p:WindowsPackageType=MSIX",
+  // `RuntimeIdentifierOverride` (rather than `-r`/`RuntimeIdentifier`) is the
+  // MAUI-recommended way to set the Windows RID — it sidesteps WindowsAppSDK
+  // issue #3337, which otherwise pulls in the wrong packaging assets.
+  extraPublishArgs: "-p:WindowsPackageType=None -p:SelfContained=true -p:WindowsAppSDKSelfContained=true -p:RuntimeIdentifierOverride=win-x64",
   findBundle(publishDir, _projectName) {
-    const appPackagesDir = path4.join(publishDir, "win-x64", "AppPackages");
-    if (!fs3.existsSync(appPackagesDir)) return null;
-    for (const entry of fs3.readdirSync(appPackagesDir, {
-      withFileTypes: true
-    })) {
-      if (!entry.isDirectory()) continue;
-      const subDir = path4.join(appPackagesDir, entry.name);
-      for (const file of fs3.readdirSync(subDir)) {
-        if (file.endsWith(".msix")) {
-          return path4.join(subDir, file);
-        }
-      }
-    }
-    return null;
+    const preferred = path4.join(publishDir, "win-x64", "publish");
+    if (dirContainsExe(preferred)) return preferred;
+    return findDirWithExe(publishDir);
   },
-  async package(msixPath, outputDir, meta) {
-    const outName = `${meta.projectName}-${meta.displayVersion}-windows.msix`;
+  async package(publishOutputDir, outputDir, meta) {
+    const outName = `${meta.projectName}-${meta.displayVersion}-windows.zip`;
     const outPath = path4.join(outputDir, outName);
-    fs3.copySync(msixPath, outPath, { overwrite: true });
+    if (fs3.existsSync(outPath)) fs3.removeSync(outPath);
+    const staging = fs3.mkdtempSync(path4.join(os2.tmpdir(), "vidra-zip-"));
+    const stagedApp = path4.join(staging, meta.projectName);
+    try {
+      fs3.copySync(publishOutputDir, stagedApp);
+      execFileSync2(
+        "powershell",
+        [
+          "-NoProfile",
+          "-NonInteractive",
+          "-Command",
+          `Compress-Archive -Path "${stagedApp}" -DestinationPath "${outPath}" -Force`
+        ],
+        { stdio: "pipe" }
+      );
+    } finally {
+      fs3.removeSync(staging);
+    }
     return outPath;
   }
 };
+var dirContainsExe = (dir) => fs3.existsSync(dir) && fs3.readdirSync(dir, { withFileTypes: true }).some((e) => e.isFile() && e.name.toLowerCase().endsWith(".exe"));
+var findDirWithExe = (root) => {
+  if (!fs3.existsSync(root)) return null;
+  let fallback = null;
+  const walk = (dir) => {
+    if (dirContainsExe(dir)) {
+      if (path4.basename(dir) === "publish") return dir;
+      fallback ??= dir;
+    }
+    for (const e of fs3.readdirSync(dir, { withFileTypes: true })) {
+      if (e.isDirectory()) {
+        const found = walk(path4.join(dir, e.name));
+        if (found) return found;
+      }
+    }
+    return null;
+  };
+  return walk(root) ?? fallback;
+};
 
 // src/doctor.ts
-import { execFileSync as execFileSync2 } from "child_process";
+import { execFileSync as execFileSync3 } from "child_process";
 import prompts from "prompts";
-import chalk4 from "chalk";
 var DOTNET = process.platform === "win32" ? "dotnet.exe" : "dotnet";
 var MAUI_DOCS = "https://learn.microsoft.com/dotnet/maui/get-started/installation";
 var bufToStr = (v) => v == null ? "" : Buffer.isBuffer(v) ? v.toString() : v;
 var run = (cmd, args) => {
   try {
-    const stdout = execFileSync2(cmd, args, {
+    const stdout = execFileSync3(cmd, args, {
       encoding: "utf-8",
       stdio: ["ignore", "pipe", "pipe"]
     });
@@ -384,19 +492,32 @@ var collectRequirements = (opts = {}) => {
   }
   return reqs;
 };
+var STATUS_GLYPH = {
+  ok: "done",
+  missing: "error",
+  unknown: "manual"
+};
 var printRequirements = (reqs) => {
+  const labelWidth = Math.max(0, ...reqs.map((r) => r.name.length)) + 2;
   for (const r of reqs) {
-    const icon = r.status === "ok" ? chalk4.green("\u2713") : r.status === "missing" ? chalk4.red("\u2717") : chalk4.yellow("?");
-    const detail = r.detail ? ` ${chalk4.dim(`(${r.detail})`)}` : "";
-    console.log(`  ${icon} ${r.name}${detail}`);
+    console.log(
+      row({
+        glyph: STATUS_GLYPH[r.status],
+        label: r.name,
+        labelWidth,
+        detail: r.detail ? dim(r.detail) : void 0
+      })
+    );
     if (r.status === "missing" && r.fix) {
-      console.log(`      ${chalk4.dim("fix:")} ${chalk4.cyan(r.fix)}`);
+      console.log(fixLine(r.fix));
     }
   }
 };
 var runDoctor = async () => {
   console.log();
-  console.log(`  ${chalk4.bold.cyan("vidra doctor")}`);
+  console.log(`  ${lime("vidra")} ${value("doctor")}`);
+  console.log();
+  console.log(footer(dim("checking your environment\u2026")));
   console.log();
   const reqs = collectRequirements();
   printRequirements(reqs);
@@ -404,17 +525,22 @@ var runDoctor = async () => {
   const missing = reqs.filter((r) => r.status === "missing");
   if (missing.length === 0) {
     console.log(
-      `  ${chalk4.green("All checks passed.")} You're ready to run ${chalk4.cyan(
-        "vidra dev"
-      )}.`
+      footer(
+        `${dim("all checks passed \u2014 you're ready to run")} ${lime(
+          "vidra dev"
+        )}${dim(".")}`
+      )
     );
     console.log();
     return 0;
   }
+  const n = missing.length;
   console.log(
-    `  ${chalk4.yellow(
-      `${missing.length} issue(s) found.`
-    )} Apply the fixes above, then re-run ${chalk4.cyan("vidra doctor")}.`
+    footer(
+      `${dim(
+        `${n} issue${n === 1 ? "" : "s"} found. apply the ${n === 1 ? "fix" : "fixes"} above, then re-run`
+      )} ${lime("vidra doctor")}${dim(".")}`
+    )
   );
   console.log();
   return 1;
@@ -422,25 +548,32 @@ var runDoctor = async () => {
 var installWorkload = (csprojPath) => {
   const args = csprojPath ? ["workload", "restore", csprojPath] : ["workload", "install", "maui"];
   console.log();
-  console.log(`  ${chalk4.dim(`Running: ${DOTNET} ${args.join(" ")}`)}`);
   console.log(
-    `  ${chalk4.dim(
-      "This can download several hundred MB and take a few minutes."
-    )}`
+    row({
+      glyph: "active",
+      detail: `${dim("running")} ${value(`${DOTNET} ${args.join(" ")}`)}`
+    })
+  );
+  console.log(
+    footer(
+      dim("this can download several hundred MB and take a few minutes.")
+    )
   );
   console.log();
   try {
-    execFileSync2(DOTNET, args, { stdio: "inherit" });
+    execFileSync3(DOTNET, args, { stdio: "inherit" });
     return true;
   } catch {
     console.error();
-    console.error(`  ${chalk4.red("Workload install failed.")}`);
+    console.error(row({ glyph: "error", label: "workload install failed" }));
     console.error(
-      `  ${chalk4.dim(
-        "If this is a permissions error, your SDK is in a system location and needs elevation:"
-      )}`
+      footer(
+        dim(
+          "if this is a permissions error, your SDK is in a system location and needs elevation:"
+        )
+      )
     );
-    console.error(`      ${chalk4.cyan("sudo dotnet workload install maui")}`);
+    console.error(fixLine("sudo dotnet workload install maui"));
     console.error();
     return false;
   }
@@ -449,9 +582,15 @@ var ensureMauiWorkload = async (opts = {}) => {
   const dotnet = checkDotnetSdk();
   if (dotnet.status === "missing") {
     console.log();
-    console.log(`  ${chalk4.yellow("!")} ${dotnet.name} \u2014 ${dotnet.detail}`);
+    console.log(
+      row({
+        glyph: "error",
+        label: dotnet.name,
+        detail: dotnet.detail ? dim(dotnet.detail) : void 0
+      })
+    );
     if (dotnet.fix) {
-      console.log(`      ${chalk4.dim("fix:")} ${chalk4.cyan(dotnet.fix)}`);
+      console.log(fixLine(dotnet.fix));
     }
     return false;
   }
@@ -459,7 +598,11 @@ var ensureMauiWorkload = async (opts = {}) => {
   if (isMauiWorkloadInstalled()) return true;
   console.log();
   console.log(
-    `  ${chalk4.yellow("!")} The .NET MAUI workload is required but not installed.`
+    row({
+      glyph: "error",
+      label: ".NET MAUI workload",
+      detail: dim("required but not installed")
+    })
   );
   const interactive = opts.interactive ?? isInteractive();
   if (interactive) {
@@ -477,80 +620,91 @@ var ensureMauiWorkload = async (opts = {}) => {
     }
     if (install) {
       if (installWorkload(opts.csprojPath) && isMauiWorkloadInstalled()) {
-        console.log(`  ${chalk4.green("\u2713")} MAUI workload installed.`);
+        console.log(
+          row({
+            glyph: "done",
+            label: ".NET MAUI workload",
+            detail: dim("installed")
+          })
+        );
         return true;
       }
       return false;
     }
   }
-  console.log(
-    `      ${chalk4.dim("run:")} ${chalk4.cyan("dotnet workload install maui")}`
-  );
-  console.log(`      ${chalk4.dim("docs:")} ${chalk4.cyan(MAUI_DOCS)}`);
+  console.log(fixLine("dotnet workload install maui", "run:"));
+  console.log(fixLine(MAUI_DOCS, "docs:"));
   return false;
 };
 var printWorkloadHint = () => {
   console.error();
   console.error(
-    `  ${chalk4.yellow("This looks like a missing .NET MAUI workload.")}`
-  );
-  console.error(
-    `      ${chalk4.dim("fix: ")} ${chalk4.cyan("dotnet workload install maui")}`
-  );
-  console.error(
-    `      ${chalk4.dim("check:")} ${chalk4.cyan("vidra doctor")}`
+    row({ glyph: "manual", label: "this looks like a missing .NET MAUI workload." })
   );
+  console.error(fixLine("dotnet workload install maui"));
+  console.error(fixLine("vidra doctor", "check:"));
   console.error();
 };
 var printXcodeHint = () => {
   console.error();
   console.error(
-    `  ${chalk4.yellow(
-      "Mac Catalyst builds need the full Xcode app, not just the Command Line Tools."
-    )}`
+    row({
+      glyph: "manual",
+      label: "Mac Catalyst needs the full Xcode app, not just the Command Line Tools."
+    })
   );
-  console.error(`      ${chalk4.dim("1.")} Install Xcode from the App Store`);
+  console.error(`      ${dim("1.")} ${value("install Xcode from the App Store")}`);
   console.error(
-    `      ${chalk4.dim("2.")} ${chalk4.cyan(
+    `      ${dim("2.")} ${lime(
       "sudo xcode-select -s /Applications/Xcode.app/Contents/Developer"
     )}`
   );
-  console.error(
-    `      ${chalk4.dim("3.")} ${chalk4.cyan("sudo xcodebuild -runFirstLaunch")}`
-  );
-  console.error(`      ${chalk4.dim("check:")} ${chalk4.cyan("vidra doctor")}`);
+  console.error(`      ${dim("3.")} ${lime("sudo xcodebuild -runFirstLaunch")}`);
+  console.error(fixLine("vidra doctor", "check:"));
   console.error();
 };
 
 // src/commands/build.ts
-var VERSION = "0.1.0";
 var TARGETS = {
   macos: macosTarget,
   windows: windowsTarget
 };
+var packageLabel = (target) => target.name === "macos" ? "package DMG" : "package ZIP";
+var artifactName = (project, target) => `${project.projectName}-${project.displayVersion}-${target.name}.${target.name === "macos" ? "dmg" : "zip"}`;
 var buildCommand = async (argv) => {
   const args = parseArgs(["_", "_", ...argv]);
   const verbose = !!args["verbose"];
+  const plan = !!args["plan"] || !!args["dry-run"];
   const targetName = args["target"] || detectPlatform();
-  console.log();
-  console.log(
-    `  ${chalk5.bold.cyan("vidra build")} ${chalk5.dim(`v${VERSION}`)}`
-  );
-  console.log();
   const target = TARGETS[targetName];
   if (!target) {
     const supported = Object.keys(TARGETS).join(", ");
+    console.error();
     console.error(
-      chalk5.red(
-        `  Unsupported target: ${targetName}. Supported: ${supported}`
-      )
+      row({
+        glyph: "error",
+        detail: dim(`unsupported target: ${targetName} \u2014 supported: ${supported}`)
+      })
     );
     process.exit(1);
   }
   const project = detectProject(process.cwd());
-  console.log(`  ${chalk5.dim("Project:")}  ${chalk5.cyan(project.projectName)}`);
-  console.log(`  ${chalk5.dim("Target:")}   ${chalk5.cyan(target.name)} (${target.framework})`);
   console.log();
+  console.log(
+    header("build", `${target.name} \xB7 Release${plan ? " \xB7 plan" : ""}`)
+  );
+  console.log(kv("project", project.projectName));
+  console.log(kv("target", target.framework));
+  console.log();
+  if (plan) {
+    printBuildPlan(project, target);
+    console.log();
+    console.log(
+      footer(`${dim("nothing has run. re-run without")} ${lime("--plan")} ${dim("to apply.")}`)
+    );
+    console.log();
+    return;
+  }
   if (!await ensureMauiWorkload({ csprojPath: project.csprojPath })) {
     process.exit(1);
   }
@@ -560,13 +714,13 @@ var buildCommand = async (argv) => {
   const bundlePath = target.findBundle(publishDir, project.projectName);
   if (!bundlePath) {
     console.error(
-      chalk5.red(`  Could not find build artifact in ${publishDir}`)
+      row({
+        glyph: "error",
+        detail: dim(`could not find build artifact in ${publishDir}`)
+      })
     );
     process.exit(1);
   }
-  console.log(
-    `  ${chalk5.dim("Bundle:")}   ${chalk5.cyan(path5.basename(bundlePath))}`
-  );
   if (target.name === "macos") {
     signMacAppBundleIfPossible(bundlePath, {
       verbose,
@@ -574,36 +728,77 @@ var buildCommand = async (argv) => {
       warn: console.warn
     });
   }
-  const outputDir = path5.join(project.root, "dist");
-  fs4.ensureDirSync(outputDir);
+  const outputPath = await stepPackage(project, target, bundlePath);
   console.log();
-  console.log(`  ${chalk5.dim(`Packaging for ${target.name}...`)}`);
-  const startPkg = Date.now();
-  let outputPath;
-  try {
-    outputPath = await target.package(bundlePath, outputDir, {
-      projectName: project.projectName,
-      displayVersion: project.displayVersion
-    });
-  } catch (e) {
-    console.error(chalk5.red(`  Packaging failed.`));
-    console.error(chalk5.dim(formatProcessError(e)));
-    process.exit(1);
-  }
-  const pkgTime = ((Date.now() - startPkg) / 1e3).toFixed(1);
-  const sizeBytes = fs4.statSync(outputPath).size;
-  const sizeMB = (sizeBytes / (1024 * 1024)).toFixed(1);
   console.log(
-    `  ${chalk5.green(">")} ${path5.basename(outputPath)} ${chalk5.dim(`(${sizeMB} MB, ${pkgTime}s)`)}`
+    footer(
+      `${dim("done \u2014")} ${value(path5.relative(project.root, outputPath))}`
+    )
   );
   console.log();
+};
+var printBuildPlan = (project, target) => {
   console.log(
-    `  ${chalk5.green("Done!")} Output: ${chalk5.cyan(path5.relative(project.root, outputPath))}`
+    row({
+      glyph: "done",
+      label: "build UI",
+      labelWidth: STEP_LABEL_WIDTH,
+      detail: `${dim("vite \u2192")} ${value("ui/dist")}`
+    })
   );
-  console.log();
+  console.log(
+    row({
+      glyph: "done",
+      label: "copy assets",
+      labelWidth: STEP_LABEL_WIDTH,
+      detail: `${dim("\u2192")} ${value("Resources/Raw/wwwroot")}`
+    })
+  );
+  console.log(
+    row({
+      glyph: "done",
+      label: "publish .NET",
+      labelWidth: STEP_LABEL_WIDTH,
+      detail: `${dim("Release \xB7")} ${value(target.framework)}`
+    })
+  );
+  if (target.name === "macos") {
+    console.log(
+      row({
+        glyph: "done",
+        label: "codesign .app",
+        labelWidth: STEP_LABEL_WIDTH,
+        detail: dim("Apple Development, or ad-hoc (-)")
+      })
+    );
+    console.log(
+      row({
+        glyph: "plan",
+        label: "notarize",
+        labelWidth: STEP_LABEL_WIDTH,
+        detail: planBadge()
+      })
+    );
+    console.log(
+      row({
+        glyph: "active",
+        label: "package DMG",
+        labelWidth: STEP_LABEL_WIDTH,
+        detail: `${dim("hdiutil UDZO \u2192")} ${value(artifactName(project, target))}`
+      })
+    );
+  } else {
+    console.log(
+      row({
+        glyph: "active",
+        label: "package ZIP",
+        labelWidth: STEP_LABEL_WIDTH,
+        detail: `${dim("self-contained \u2192")} ${value(artifactName(project, target))}`
+      })
+    );
+  }
 };
 var stepBuildUi = (project, verbose) => {
-  console.log(`  ${chalk5.dim("Building UI...")}`);
   const start = Date.now();
   try {
     execSync3("npm run build", {
@@ -611,19 +806,38 @@ var stepBuildUi = (project, verbose) => {
       stdio: verbose ? "inherit" : "pipe"
     });
   } catch (e) {
-    console.error(chalk5.red("  Vite build failed."));
-    console.error(chalk5.dim(formatBuildError(e)));
+    console.error(
+      row({
+        glyph: "error",
+        label: "build UI",
+        labelWidth: STEP_LABEL_WIDTH,
+        detail: dim("vite build failed")
+      })
+    );
+    console.error(dim(formatBuildError(e)));
     process.exit(1);
   }
   const elapsed = ((Date.now() - start) / 1e3).toFixed(1);
-  console.log(`  ${chalk5.green(">")} Vite build complete ${chalk5.dim(`(${elapsed}s)`)}`);
-  console.log();
+  console.log(
+    row({
+      glyph: "done",
+      label: "build UI",
+      labelWidth: STEP_LABEL_WIDTH,
+      detail: `${dim("vite \u2192")} ${value("ui/dist")} ${dim(`(${elapsed}s)`)}`
+    })
+  );
 };
 var stepCopyAssets = (project) => {
-  console.log(`  ${chalk5.dim("Copying assets to host project...")}`);
   const viteDist = path5.join(project.uiDir, "dist");
   if (!fs4.existsSync(viteDist)) {
-    console.error(chalk5.red(`  ui/dist not found. Vite build may have failed.`));
+    console.error(
+      row({
+        glyph: "error",
+        label: "copy assets",
+        labelWidth: STEP_LABEL_WIDTH,
+        detail: dim("ui/dist not found \u2014 vite build may have failed")
+      })
+    );
     process.exit(1);
   }
   const wwwroot = path5.join(project.hostDir, "Resources", "Raw", "wwwroot");
@@ -631,9 +845,13 @@ var stepCopyAssets = (project) => {
   fs4.copySync(viteDist, wwwroot);
   const fileCount = countFiles(wwwroot);
   console.log(
-    `  ${chalk5.green(">")} ${fileCount} files -> ${chalk5.dim("Resources/Raw/wwwroot/")}`
+    row({
+      glyph: "done",
+      label: "copy assets",
+      labelWidth: STEP_LABEL_WIDTH,
+      detail: `${dim("\u2192")} ${value("Resources/Raw/wwwroot")} ${dim(`(${fileCount} files)`)}`
+    })
   );
-  console.log();
 };
 var countFiles = (dir) => {
   let count = 0;
@@ -647,9 +865,6 @@ var countFiles = (dir) => {
   return count;
 };
 var stepDotnetPublish = (project, target, verbose) => {
-  console.log(
-    `  ${chalk5.dim(`Publishing .NET host (${target.framework})...`)}`
-  );
   const start = Date.now();
   const extraArgs = target.extraPublishArgs ?? "-p:CreatePackage=false";
   try {
@@ -662,37 +877,73 @@ var stepDotnetPublish = (project, target, verbose) => {
     );
   } catch (e) {
     const output = formatBuildError(e);
-    console.error(chalk5.red("  dotnet publish failed."));
-    console.error(chalk5.dim(output));
+    console.error(
+      row({
+        glyph: "error",
+        label: "publish .NET",
+        labelWidth: STEP_LABEL_WIDTH,
+        detail: dim("dotnet publish failed")
+      })
+    );
+    console.error(dim(output));
     if (looksLikeMissingWorkload(output)) printWorkloadHint();
     else if (looksLikeMissingXcode(output)) printXcodeHint();
     if (!verbose) {
-      console.error(
-        chalk5.dim("  Re-run with --verbose for the full build log.")
-      );
+      console.error(footer(dim("re-run with --verbose for the full build log.")));
     }
     process.exit(1);
   }
   const elapsed = ((Date.now() - start) / 1e3).toFixed(1);
   console.log(
-    `  ${chalk5.green(">")} dotnet publish complete ${chalk5.dim(`(${elapsed}s)`)}`
+    row({
+      glyph: "done",
+      label: "publish .NET",
+      labelWidth: STEP_LABEL_WIDTH,
+      detail: `${dim("Release \xB7")} ${value(target.framework)} ${dim(`(${elapsed}s)`)}`
+    })
   );
-  const publishDir = path5.join(
-    project.hostDir,
-    "bin",
-    "Release",
-    target.framework
+  return path5.join(project.hostDir, "bin", "Release", target.framework);
+};
+var stepPackage = async (project, target, bundlePath) => {
+  const outputDir = path5.join(project.root, "dist");
+  fs4.ensureDirSync(outputDir);
+  const start = Date.now();
+  let outputPath;
+  try {
+    outputPath = await target.package(bundlePath, outputDir, {
+      projectName: project.projectName,
+      displayVersion: project.displayVersion
+    });
+  } catch (e) {
+    console.error(
+      row({
+        glyph: "error",
+        label: packageLabel(target),
+        labelWidth: STEP_LABEL_WIDTH,
+        detail: dim("packaging failed")
+      })
+    );
+    console.error(dim(formatProcessError(e)));
+    process.exit(1);
+  }
+  const pkgTime = ((Date.now() - start) / 1e3).toFixed(1);
+  const sizeMB = (fs4.statSync(outputPath).size / (1024 * 1024)).toFixed(1);
+  console.log(
+    row({
+      glyph: "done",
+      label: packageLabel(target),
+      labelWidth: STEP_LABEL_WIDTH,
+      detail: `${value(path5.basename(outputPath))} ${dim(`(${sizeMB} MB, ${pkgTime}s)`)}`
+    })
   );
-  return publishDir;
+  return outputPath;
 };
 
 // src/commands/dev.ts
 import path6 from "path";
 import fs5 from "fs-extra";
-import { execFileSync as execFileSync3, spawn } from "child_process";
+import { execFileSync as execFileSync4, spawn } from "child_process";
 import { request } from "http";
-import chalk6 from "chalk";
-var VERSION2 = "0.1.0";
 var POLL_INTERVAL_MS = 500;
 var POLL_TIMEOUT_MS = 3e4;
 var NPM_COMMAND = process.platform === "win32" ? "npm.cmd" : "npm";
@@ -718,9 +969,10 @@ var startSession = async (argv, opts) => {
   if (!target) {
     const supported = Object.keys(TARGETS2).join(", ");
     console.error(
-      chalk6.red(
-        `  Unsupported target: ${targetName}. Supported: ${supported}`
-      )
+      row({
+        glyph: "error",
+        detail: dim(`unsupported target: ${targetName} \u2014 supported: ${supported}`)
+      })
     );
     process.exit(1);
   }
@@ -751,14 +1003,9 @@ var DevSession = class {
   async run() {
     this.installSignalHandlers();
     console.log();
-    console.log(
-      `  ${chalk6.bold.cyan(this.vite ? "vidra dev" : "vidra run")} ${chalk6.dim(`v${VERSION2}`)}`
-    );
-    console.log();
-    console.log(`  ${chalk6.dim("Project:")}  ${chalk6.cyan(this.project.projectName)}`);
-    console.log(
-      `  ${chalk6.dim("Target:")}   ${chalk6.cyan(this.target.name)} (${this.target.framework})`
-    );
+    console.log(header(this.vite ? "dev" : "run", this.target.name));
+    console.log(kv("project", this.project.projectName));
+    console.log(kv("target", this.target.framework));
     console.log();
     let vite;
     if (this.vite) {
@@ -766,23 +1013,50 @@ var DevSession = class {
       try {
         await waitForServer(this.viteUrl, POLL_TIMEOUT_MS);
       } catch (error) {
-        console.error(chalk6.red(`  ${error.message}`));
+        console.error(row({ glyph: "error", detail: dim(error.message) }));
         this.shutdown(1);
       }
-      console.log(`  ${chalk6.dim("Vite:")}     ${chalk6.cyan(this.viteUrl)}`);
-      console.log();
+      console.log(
+        taggedRow("active", "ui", `${dim("vite ready \u2014")} ${value(this.viteUrl)}`)
+      );
     } else {
       console.log(
-        `  ${chalk6.dim("UI:")}       ${chalk6.cyan(this.viteUrl)} ${chalk6.dim("(start it separately, e.g. `npm run dev:ui`)")}`
+        taggedRow(
+          "skip",
+          "ui",
+          `${dim("vite not started \u2014")} ${value("npm run dev:ui")}`
+        )
       );
-      console.log();
     }
     const host = this.target.name === "macos" ? this.launchMacosHost() : this.launchWindowsHost();
+    if (this.vite) {
+      console.log(
+        taggedRow(
+          "active",
+          null,
+          `${lime("hot reload active")} ${dim("\u2014 edit ui/src and save")}`
+        )
+      );
+      console.log();
+      console.log(
+        footer(
+          `${dim("watching")} ${value("ui/")} ${dim(
+            "\xB7 hot reload on save \xB7 ctrl-c to stop"
+          )}`
+        )
+      );
+    } else {
+      console.log();
+      console.log(
+        footer(dim("host only \xB7 serve the UI separately \xB7 ctrl-c to stop"))
+      );
+    }
+    console.log();
     await waitForExit(...vite ? [vite, host] : [host]);
   }
   installSignalHandlers() {
     process.on("SIGINT", () => {
-      console.log("\n\x1B[90m[vidra]\x1B[0m Shutting down...");
+      console.log("\n" + footer(dim("shutting down\u2026")));
       this.shutdown(0);
     });
     process.on("SIGTERM", () => {
@@ -790,19 +1064,24 @@ var DevSession = class {
     });
   }
   startVite() {
-    console.log(`  ${chalk6.dim("Starting Vite dev server...")}`);
+    console.log(taggedRow("active", "ui", dim("starting dev server\u2026")));
     const vite = spawn(NPM_COMMAND, ["run", "dev"], {
       cwd: this.project.uiDir,
-      stdio: ["ignore", "pipe", "pipe"]
+      stdio: ["ignore", "pipe", "pipe"],
+      shell: process.platform === "win32"
     });
     return this.registerChild(vite, "ui", "Vite dev server");
   }
   launchMacosHost() {
     console.log(
-      `  ${chalk6.dim(`Building MAUI host (${this.target.framework})...`)}`
+      taggedRow(
+        "active",
+        "host",
+        `${dim("building")} ${value(this.target.framework)} ${dim("\u2026")}`
+      )
     );
     try {
-      execFileSync3(
+      execFileSync4(
         DOTNET_COMMAND,
         [
           "build",
@@ -819,14 +1098,12 @@ var DevSession = class {
       );
     } catch (error) {
       const output = formatBuildError(error);
-      console.error(chalk6.red("  MAUI build failed."));
-      console.error(chalk6.dim(output));
+      console.error(taggedRow("error", "host", dim("MAUI build failed")));
+      console.error(dim(output));
       if (looksLikeMissingWorkload(output)) printWorkloadHint();
       else if (looksLikeMissingXcode(output)) printXcodeHint();
       if (!this.verbose) {
-        console.error(
-          chalk6.dim("  Re-run with --verbose for the full build log.")
-        );
+        console.error(footer(dim("re-run with --verbose for the full build log.")));
       }
       process.exit(1);
     }
@@ -837,9 +1114,12 @@ var DevSession = class {
     );
     if (!appBundle) {
       console.error(
-        chalk6.red(
-          `  Could not find .app bundle in ${path6.join(this.project.hostDir, "bin", this.buildConfig, this.target.framework)}`
-        )
+        row({
+          glyph: "error",
+          detail: dim(
+            `could not find .app bundle in ${path6.join(this.project.hostDir, "bin", this.buildConfig, this.target.framework)}`
+          )
+        })
       );
       process.exit(1);
     }
@@ -851,11 +1131,16 @@ var DevSession = class {
     const binary = findMacExecutable(appBundle);
     if (!binary) {
       console.error(
-        chalk6.red(`  Could not find the app executable in ${appBundle}.`)
+        row({
+          glyph: "error",
+          detail: dim(`could not find the app executable in ${appBundle}`)
+        })
       );
       process.exit(1);
     }
-    console.log(`  ${chalk6.dim("Launching host...")}`);
+    console.log(
+      taggedRow("done", "host", `${dim("launched")} ${value(path6.basename(appBundle))}`)
+    );
     const host = spawn(binary, [], {
       cwd: this.project.root,
       stdio: ["ignore", "pipe", "pipe"],
@@ -864,7 +1149,7 @@ var DevSession = class {
     return this.registerChild(host, "host", path6.basename(binary));
   }
   launchWindowsHost() {
-    console.log(`  ${chalk6.dim("Launching host...")}`);
+    console.log(taggedRow("active", "host", dim("launching\u2026")));
     const host = spawn(
       DOTNET_COMMAND,
       [
@@ -884,17 +1169,16 @@ var DevSession = class {
     );
     return this.registerChild(host, "host", "MAUI host");
   }
-  registerChild(child, tag, label) {
+  registerChild(child, tag2, label) {
     this.children.push(child);
-    prefixStream(child.stdout, tag);
-    prefixStream(child.stderr, tag);
+    prefixStream(child.stdout, tag2);
+    prefixStream(child.stderr, tag2);
     child.on("exit", (code, signal) => {
       if (this.shuttingDown) return;
-      if (tag === "ui") {
+      if (tag2 === "ui") {
         const exitCode = code ?? 1;
         console.error(
-          chalk6.red(`
-  ${label} exited with code ${exitCode}.`)
+          "\n" + row({ glyph: "error", detail: dim(`${label} exited with code ${exitCode}`) })
         );
         this.shutdown(exitCode);
         return;
@@ -902,12 +1186,14 @@ var DevSession = class {
       const failed = code !== null && code !== 0 || signal !== null;
       if (failed) {
         console.error(
-          chalk6.red(
-            `
-  ${label} exited with ${signal ? `signal ${signal}` : `code ${code}`}.`
-          )
+          "\n" + row({
+            glyph: "error",
+            detail: dim(
+              `${label} exited with ${signal ? `signal ${signal}` : `code ${code}`}`
+            )
+          })
         );
-        if (tag === "host" && this.target.name === "macos") {
+        if (tag2 === "host" && this.target.name === "macos") {
           printMacLaunchHint();
         }
       }
@@ -915,9 +1201,10 @@ var DevSession = class {
     });
     child.on("error", (error) => {
       if (this.shuttingDown) return;
-      console.error(chalk6.red(`
-  Failed to start ${label}: ${error.message}`));
-      if (tag === "host" && this.target.name === "macos") {
+      console.error(
+        "\n" + row({ glyph: "error", detail: dim(`failed to start ${label}: ${error.message}`) })
+      );
+      if (tag2 === "host" && this.target.name === "macos") {
         printMacLaunchHint();
       }
       this.shutdown(1);
@@ -935,23 +1222,26 @@ var DevSession = class {
 };
 var ensureTargetMatchesHostOs = (targetName) => {
   if (targetName === "macos" && process.platform !== "darwin") {
-    console.error(chalk6.red("  The macOS dev target can only run on macOS."));
+    console.error(
+      row({ glyph: "error", detail: dim("the macOS target can only run on macOS") })
+    );
     process.exit(1);
   }
   if (targetName === "windows" && process.platform !== "win32") {
     console.error(
-      chalk6.red("  The Windows dev target can only run on Windows.")
+      row({ glyph: "error", detail: dim("the Windows target can only run on Windows") })
     );
     process.exit(1);
   }
 };
-var prefixStream = (stream, tag) => {
+var prefixStream = (stream, tag2) => {
   if (!stream) return;
+  const prefix = streamPrefix(tag2);
   stream.on("data", (chunk) => {
     const lines = chunk.toString().split("\n");
     for (const line of lines) {
       if (line.length > 0) {
-        process.stdout.write(`\x1B[90m[${tag}]\x1B[0m ${line}
+        process.stdout.write(`${prefix} ${line}
 `);
       }
     }
@@ -1028,7 +1318,7 @@ var killChild = (child) => {
   if (!child.pid || child.exitCode !== null) return;
   if (process.platform === "win32") {
     try {
-      execFileSync3("taskkill", ["/PID", String(child.pid), "/T", "/F"], {
+      execFileSync4("taskkill", ["/PID", String(child.pid), "/T", "/F"], {
         stdio: "ignore"
       });
     } catch {
@@ -1040,48 +1330,50 @@ var killChild = (child) => {
 };
 var printMacLaunchHint = () => {
   console.error();
-  console.error(chalk6.yellow("  The host built but the app couldn't launch."));
   console.error(
-    chalk6.dim(
-      "  On macOS this is usually code signing / Gatekeeper for a locally built app:"
+    row({ glyph: "manual", label: "the host built but the app couldn't launch." })
+  );
+  console.error(
+    footer(
+      dim(
+        "on macOS this is usually code signing / Gatekeeper for a locally built app:"
+      )
     )
   );
   console.error(
-    `    ${chalk6.dim("\u2022")} Install full Xcode, then run ${chalk6.cyan("vidra doctor")} to verify`
+    `      ${dim("\u2022")} ${dim("install full Xcode, then run")} ${lime("vidra doctor")} ${dim("to verify")}`
   );
   console.error(
-    `    ${chalk6.dim("\u2022")} Approve it once in Finder: right-click the ${chalk6.cyan(".app")} and choose ${chalk6.cyan("Open")}`
+    `      ${dim("\u2022")} ${dim("approve it once in Finder: right-click the")} ${value(".app")} ${dim("and choose")} ${value("Open")}`
   );
   console.error(
-    `    ${chalk6.dim("\u2022")} Or provide a signing identity via ${chalk6.cyan("VIDRA_MACOS_CODESIGN_KEY")}`
+    `      ${dim("\u2022")} ${dim("or provide a signing identity via")} ${value("VIDRA_MACOS_CODESIGN_KEY")}`
   );
   console.error();
 };
 
 // src/cli.ts
-var VERSION3 = "0.1.5";
 var printHelp = () => {
+  const cmd = (name, desc) => `    ${value(name.padEnd(10))} ${dim(desc)}`;
+  const ex = (args, comment) => `    ${lime("vidra")} ${value(args.padEnd(22))} ${dim(`# ${comment}`)}`;
   console.log(`
-  ${chalk7.bold("vidra")} ${chalk7.dim(`v${VERSION3}`)}
+  ${wordmark()} ${dim(`v${CLI_VERSION}`)}
 
-  ${chalk7.dim("Usage:")}
-    vidra <command> [options]
+  ${dim("usage")}
+    ${lime("vidra")} ${dim("<command> [options]")}
 
-  ${chalk7.dim("Commands:")}
-    dev     Start the development environment (Vite + native host)
-    run     Build and launch the native host only (no Vite dev server)
-    build   Build and package the application for distribution
-    doctor  Check that your environment is set up to build Vidra apps
-    help    Show this help message
+  ${dim("commands")}
+${cmd("dev", "start vite + the native host (hot reload)")}
+${cmd("run", "launch the native host only")}
+${cmd("build", "build & package for distribution")}
+${cmd("doctor", "check your environment")}
+${cmd("help", "show this message")}
 
-  ${chalk7.dim("Examples:")}
-    vidra dev                   ${chalk7.dim("# start Vite + native host")}
-    vidra dev --target windows  ${chalk7.dim("# run the Windows host")}
-    vidra run                   ${chalk7.dim("# launch the host (UI served separately)")}
-    vidra build                 ${chalk7.dim("# auto-detect platform")}
-    vidra build --target macos  ${chalk7.dim("# macOS DMG")}
-    vidra build --verbose       ${chalk7.dim("# show full build output")}
-    vidra doctor                ${chalk7.dim("# verify .NET SDK + MAUI workload")}
+  ${dim("examples")}
+${ex("dev --target windows", "run the windows host")}
+${ex("build --plan", "preview the build, run nothing")}
+${ex("build --target macos", "build & package a macOS DMG")}
+${ex("doctor", "verify .NET SDK + MAUI workload")}
 `);
 };
 var main = async () => {
@@ -1108,16 +1400,15 @@ var main = async () => {
       break;
     case "--version":
     case "-v":
-      console.log(VERSION3);
+      console.log(CLI_VERSION);
       break;
     default:
-      console.error(chalk7.red(`  Unknown command: ${command}
-`));
+      console.error(row({ glyph: "error", detail: dim(`unknown command: ${command}`) }));
       printHelp();
       process.exit(1);
   }
 };
 main().catch((e) => {
-  console.error(chalk7.red(e.message));
+  console.error(row({ glyph: "error", detail: dim(e.message) }));
   process.exit(1);
 });