create-vidra-app 0.1.4 → 0.1.6

package/dist/cli.js

@@ -1,11 +1,7 @@
-// src/cli.ts
-import chalk6 from "chalk";
-
 // src/commands/build.ts
 import path5 from "path";
 import fs4 from "fs-extra";
-import { execSync as execSync2 } from "child_process";
-import chalk4 from "chalk";
+import { execSync as execSync3 } from "child_process";
 
 // 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);
     }
@@ -22,10 +28,92 @@ var parseArgs = (argv) => {
   return args;
 };
 
+// src/exec.ts
+import { execSync } from "child_process";
+
+// src/theme.ts
+import chalk from "chalk";
+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;
+  const combined = [toText(err.stderr), toText(err.stdout)].map((s) => s.trim()).filter((s) => s.length > 0).join("\n").trim();
+  return combined.length > 0 ? combined : err.message ?? String(error);
+};
+var formatBuildError = (error) => {
+  const raw = formatProcessError(error);
+  const lines = raw.split(/\r?\n/);
+  const errorLines = lines.filter(
+    (line) => /(:\s*error\b|\berror\s+[A-Z]{2,}\d+|Build FAILED|MSB\d{4}|NETSDK\d{4})/i.test(
+      line
+    )
+  );
+  const picked = errorLines.length > 0 ? errorLines : lines.filter((line) => line.trim().length > 0).slice(-30);
+  return picked.join("\n").trim();
+};
+
 // src/project.ts
 import path from "path";
 import fs from "fs-extra";
-import chalk from "chalk";
 var detectPlatform = () => {
   switch (process.platform) {
     case "darwin":
@@ -64,9 +152,15 @@ var detectProject = (cwd) => {
     dir = parent;
   }
   console.error(
-    chalk.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);
 };
@@ -97,7 +191,7 @@ var readCsprojVersion = (csprojPath) => {
 // src/targets/macos.ts
 import path2 from "path";
 import fs2 from "fs-extra";
-import { execSync } from "child_process";
+import { execSync as execSync2 } from "child_process";
 import os from "os";
 var macosTarget = {
   name: "macos",
@@ -123,7 +217,7 @@ var macosTarget = {
       if (fs2.existsSync(dmgPath)) {
         fs2.removeSync(dmgPath);
       }
-      execSync(
+      execSync2(
         `hdiutil create -volname "${volName}" -srcfolder "${staging}" -ov -format UDZO "${dmgPath}"`,
         { stdio: "pipe" }
       );
@@ -137,41 +231,44 @@ var macosTarget = {
 // src/signing.ts
 import path3 from "path";
 import { execFileSync } from "child_process";
-import chalk2 from "chalk";
 var signMacAppBundleIfPossible = (appBundle, options) => {
   if (process.platform !== "darwin") return;
-  const codesignIdentity = resolveMacCodeSigningIdentity();
-  if (!codesignIdentity) {
-    options.warn(
-      chalk2.yellow(
-        "  No usable macOS signing identity found. The app will remain ad-hoc signed."
-      )
-    );
-    options.warn(
-      chalk2.yellow(
-        "  Set VIDRA_MACOS_CODESIGN_KEY to override identity selection if needed."
-      )
-    );
-    return;
-  }
+  const identity = resolveMacCodeSigningIdentity();
+  const signWith = identity ?? "-";
+  const label = path3.basename(appBundle);
   try {
     execFileSync(
       "codesign",
-      ["--force", "--deep", "--sign", codesignIdentity, appBundle],
+      ["--force", "--deep", "--sign", signWith, appBundle],
       {
         stdio: options.verbose ? "inherit" : "pipe"
       }
     );
     options.log(
-      `  ${chalk2.dim("Signing:")}  ${chalk2.cyan(path3.basename(appBundle))} ${chalk2.dim(`with ${codesignIdentity}`)}`
+      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(
-      chalk2.yellow(
-        "  Failed to re-sign the macOS app bundle. It may remain ad-hoc signed."
+      row({
+        glyph: "manual",
+        label: "codesign",
+        labelWidth: STEP_LABEL_WIDTH,
+        detail: dim("could not sign the app bundle; it may fail to launch")
+      })
+    );
+    options.warn(
+      footer(
+        dim(
+          "install Xcode or the Command Line Tools (provides `codesign`), or set VIDRA_MACOS_CODESIGN_KEY."
+        )
       )
     );
-    options.warn(chalk2.dim(formatExecError(error)));
+    options.warn(dim(formatExecError(error)));
   }
 };
 var resolveMacCodeSigningIdentity = () => {
@@ -188,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;
@@ -239,7 +336,6 @@ var windowsTarget = {
 // src/doctor.ts
 import { execFileSync as execFileSync2 } from "child_process";
 import prompts from "prompts";
-import chalk3 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;
@@ -272,6 +368,11 @@ var looksLikeMissingWorkload = (output) => [
   /maui-windows/i,
   /to\s+install\s+the\s+.*workload/i
 ].some((re) => re.test(output));
+var looksLikeMissingXcode = (output) => [
+  /valid\s+Xcode\s+installation\s+was\s+not\s+found/i,
+  /could\s+not\s+find\s+a\s+valid\s+Xcode\s+app\s+bundle/i,
+  /macios-missing-xcode/i
+].some((re) => re.test(output));
 var checkDotnetSdk = () => {
   const res = run(DOTNET, ["--list-sdks"]);
   if (!res.found) {
@@ -361,19 +462,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" ? chalk3.green("\u2713") : r.status === "missing" ? chalk3.red("\u2717") : chalk3.yellow("?");
-    const detail = r.detail ? ` ${chalk3.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(`      ${chalk3.dim("fix:")} ${chalk3.cyan(r.fix)}`);
+      console.log(fixLine(r.fix));
     }
   }
 };
 var runDoctor = async () => {
   console.log();
-  console.log(`  ${chalk3.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);
@@ -381,17 +495,22 @@ var runDoctor = async () => {
   const missing = reqs.filter((r) => r.status === "missing");
   if (missing.length === 0) {
     console.log(
-      `  ${chalk3.green("All checks passed.")} You're ready to run ${chalk3.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(
-    `  ${chalk3.yellow(
-      `${missing.length} issue(s) found.`
-    )} Apply the fixes above, then re-run ${chalk3.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;
@@ -399,11 +518,16 @@ var runDoctor = async () => {
 var installWorkload = (csprojPath) => {
   const args = csprojPath ? ["workload", "restore", csprojPath] : ["workload", "install", "maui"];
   console.log();
-  console.log(`  ${chalk3.dim(`Running: ${DOTNET} ${args.join(" ")}`)}`);
   console.log(
-    `  ${chalk3.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 {
@@ -411,13 +535,15 @@ var installWorkload = (csprojPath) => {
     return true;
   } catch {
     console.error();
-    console.error(`  ${chalk3.red("Workload install failed.")}`);
+    console.error(row({ glyph: "error", label: "workload install failed" }));
     console.error(
-      `  ${chalk3.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(`      ${chalk3.cyan("sudo dotnet workload install maui")}`);
+    console.error(fixLine("sudo dotnet workload install maui"));
     console.error();
     return false;
   }
@@ -426,9 +552,15 @@ var ensureMauiWorkload = async (opts = {}) => {
   const dotnet = checkDotnetSdk();
   if (dotnet.status === "missing") {
     console.log();
-    console.log(`  ${chalk3.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(`      ${chalk3.dim("fix:")} ${chalk3.cyan(dotnet.fix)}`);
+      console.log(fixLine(dotnet.fix));
     }
     return false;
   }
@@ -436,7 +568,11 @@ var ensureMauiWorkload = async (opts = {}) => {
   if (isMauiWorkloadInstalled()) return true;
   console.log();
   console.log(
-    `  ${chalk3.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) {
@@ -454,61 +590,91 @@ var ensureMauiWorkload = async (opts = {}) => {
     }
     if (install) {
       if (installWorkload(opts.csprojPath) && isMauiWorkloadInstalled()) {
-        console.log(`  ${chalk3.green("\u2713")} MAUI workload installed.`);
+        console.log(
+          row({
+            glyph: "done",
+            label: ".NET MAUI workload",
+            detail: dim("installed")
+          })
+        );
         return true;
       }
       return false;
     }
   }
-  console.log(
-    `      ${chalk3.dim("run:")} ${chalk3.cyan("dotnet workload install maui")}`
-  );
-  console.log(`      ${chalk3.dim("docs:")} ${chalk3.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(
-    `  ${chalk3.yellow("This looks like a missing .NET MAUI workload.")}`
+    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(
-    `      ${chalk3.dim("fix: ")} ${chalk3.cyan("dotnet workload install maui")}`
+    row({
+      glyph: "manual",
+      label: "Mac Catalyst needs the full Xcode app, not just the Command Line Tools."
+    })
   );
+  console.error(`      ${dim("1.")} ${value("install Xcode from the App Store")}`);
   console.error(
-    `      ${chalk3.dim("check:")} ${chalk3.cyan("vidra doctor")}`
+    `      ${dim("2.")} ${lime(
+      "sudo xcode-select -s /Applications/Xcode.app/Contents/Developer"
+    )}`
   );
+  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 MSIX";
+var artifactName = (project, target) => `${project.projectName}-${project.displayVersion}-${target.name}.${target.name === "macos" ? "dmg" : "msix"}`;
 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(
-    `  ${chalk4.bold.cyan("vidra build")} ${chalk4.dim(`v${VERSION}`)}`
-  );
-  console.log();
   const target = TARGETS[targetName];
   if (!target) {
     const supported = Object.keys(TARGETS).join(", ");
+    console.error();
     console.error(
-      chalk4.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(`  ${chalk4.dim("Project:")}  ${chalk4.cyan(project.projectName)}`);
-  console.log(`  ${chalk4.dim("Target:")}   ${chalk4.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);
   }
@@ -518,13 +684,13 @@ var buildCommand = async (argv) => {
   const bundlePath = target.findBundle(publishDir, project.projectName);
   if (!bundlePath) {
     console.error(
-      chalk4.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(
-    `  ${chalk4.dim("Bundle:")}   ${chalk4.cyan(path5.basename(bundlePath))}`
-  );
   if (target.name === "macos") {
     signMacAppBundleIfPossible(bundlePath, {
       verbose,
@@ -532,58 +698,116 @@ 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(`  ${chalk4.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) {
-    const err = e;
-    console.error(chalk4.red(`  Packaging failed.`));
-    console.error(chalk4.dim(err.stderr?.toString() || err.message));
-    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(
-    `  ${chalk4.green(">")} ${path5.basename(outputPath)} ${chalk4.dim(`(${sizeMB} MB, ${pkgTime}s)`)}`
+    footer(
+      `${dim("done \u2014")} ${value(path5.relative(project.root, outputPath))}`
+    )
   );
   console.log();
+};
+var printBuildPlan = (project, target) => {
   console.log(
-    `  ${chalk4.green("Done!")} Output: ${chalk4.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 MSIX",
+        labelWidth: STEP_LABEL_WIDTH,
+        detail: `${dim("\u2192")} ${value(artifactName(project, target))}`
+      })
+    );
+  }
 };
 var stepBuildUi = (project, verbose) => {
-  console.log(`  ${chalk4.dim("Building UI...")}`);
   const start = Date.now();
   try {
-    execSync2("npm run build", {
+    execSync3("npm run build", {
       cwd: project.uiDir,
       stdio: verbose ? "inherit" : "pipe"
     });
   } catch (e) {
-    const err = e;
-    console.error(chalk4.red("  Vite build failed."));
-    console.error(chalk4.dim(err.stderr?.toString() || err.message));
+    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(`  ${chalk4.green(">")} Vite build complete ${chalk4.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(`  ${chalk4.dim("Copying assets to host project...")}`);
   const viteDist = path5.join(project.uiDir, "dist");
   if (!fs4.existsSync(viteDist)) {
-    console.error(chalk4.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");
@@ -591,9 +815,13 @@ var stepCopyAssets = (project) => {
   fs4.copySync(viteDist, wwwroot);
   const fileCount = countFiles(wwwroot);
   console.log(
-    `  ${chalk4.green(">")} ${fileCount} files -> ${chalk4.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;
@@ -607,13 +835,10 @@ var countFiles = (dir) => {
   return count;
 };
 var stepDotnetPublish = (project, target, verbose) => {
-  console.log(
-    `  ${chalk4.dim(`Publishing .NET host (${target.framework})...`)}`
-  );
   const start = Date.now();
   const extraArgs = target.extraPublishArgs ?? "-p:CreatePackage=false";
   try {
-    execSync2(
+    execSync3(
       `dotnet publish "${project.csprojPath}" -c Release -f ${target.framework} ${extraArgs}`,
       {
         cwd: project.root,
@@ -621,24 +846,67 @@ var stepDotnetPublish = (project, target, verbose) => {
       }
     );
   } catch (e) {
-    const err = e;
-    const output = err.stderr?.toString() || err.message;
-    console.error(chalk4.red("  dotnet publish failed."));
-    console.error(chalk4.dim(output));
+    const output = formatBuildError(e);
+    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(footer(dim("re-run with --verbose for the full build log.")));
+    }
     process.exit(1);
   }
   const elapsed = ((Date.now() - start) / 1e3).toFixed(1);
   console.log(
-    `  ${chalk4.green(">")} dotnet publish complete ${chalk4.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
@@ -646,8 +914,6 @@ import path6 from "path";
 import fs5 from "fs-extra";
 import { execFileSync as execFileSync3, spawn } from "child_process";
 import { request } from "http";
-import chalk5 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";
@@ -662,7 +928,9 @@ var TARGETS2 = {
     framework: "net10.0-windows10.0.19041.0"
   }
 };
-var devCommand = async (argv) => {
+var devCommand = (argv) => startSession(argv, { vite: true });
+var runCommand = (argv) => startSession(argv, { vite: false });
+var startSession = async (argv, opts) => {
   const args = parseArgs(["_", "_", ...argv]);
   const targetName = args["target"] || detectPlatform();
   const verbose = !!args["verbose"];
@@ -671,9 +939,10 @@ var devCommand = async (argv) => {
   if (!target) {
     const supported = Object.keys(TARGETS2).join(", ");
     console.error(
-      chalk5.red(
-        `  Unsupported target: ${targetName}. Supported: ${supported}`
-      )
+      row({
+        glyph: "error",
+        detail: dim(`unsupported target: ${targetName} \u2014 supported: ${supported}`)
+      })
     );
     process.exit(1);
   }
@@ -682,15 +951,16 @@ var devCommand = async (argv) => {
   if (!await ensureMauiWorkload({ csprojPath: project.csprojPath })) {
     process.exit(1);
   }
-  const session = new DevSession(project, target, viteUrl, verbose);
+  const session = new DevSession(project, target, viteUrl, verbose, opts);
   await session.run();
 };
 var DevSession = class {
-  constructor(project, target, viteUrl, verbose) {
+  constructor(project, target, viteUrl, verbose, options = {}) {
     this.project = project;
     this.target = target;
     this.viteUrl = viteUrl;
     this.verbose = verbose;
+    this.vite = options.vite ?? true;
   }
   project;
   target;
@@ -698,36 +968,65 @@ var DevSession = class {
   verbose;
   children = [];
   buildConfig = process.env.VIDRA_BUILD_CONFIG || "Debug";
+  vite;
   shuttingDown = false;
   async run() {
     this.installSignalHandlers();
     console.log();
-    console.log(`  ${chalk5.bold.cyan("vidra dev")} ${chalk5.dim(`v${VERSION2}`)}`);
-    console.log();
-    console.log(`  ${chalk5.dim("Project:")}  ${chalk5.cyan(this.project.projectName)}`);
-    console.log(
-      `  ${chalk5.dim("Target:")}   ${chalk5.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();
-    const vite = this.startVite();
-    try {
-      await waitForServer(this.viteUrl, POLL_TIMEOUT_MS);
-    } catch (error) {
-      console.error(
-        chalk5.red(
-          `  ${error.message}`
+    let vite;
+    if (this.vite) {
+      vite = this.startVite();
+      try {
+        await waitForServer(this.viteUrl, POLL_TIMEOUT_MS);
+      } catch (error) {
+        console.error(row({ glyph: "error", detail: dim(error.message) }));
+        this.shutdown(1);
+      }
+      console.log(
+        taggedRow("active", "ui", `${dim("vite ready \u2014")} ${value(this.viteUrl)}`)
+      );
+    } else {
+      console.log(
+        taggedRow(
+          "skip",
+          "ui",
+          `${dim("vite not started \u2014")} ${value("npm run dev:ui")}`
         )
       );
-      this.shutdown(1);
     }
-    console.log(`  ${chalk5.dim("Vite:")}     ${chalk5.cyan(this.viteUrl)}`);
-    console.log();
     const host = this.target.name === "macos" ? this.launchMacosHost() : this.launchWindowsHost();
-    await waitForExit(vite, host);
+    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", () => {
@@ -735,7 +1034,7 @@ var DevSession = class {
     });
   }
   startVite() {
-    console.log(`  ${chalk5.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"]
@@ -744,7 +1043,11 @@ var DevSession = class {
   }
   launchMacosHost() {
     console.log(
-      `  ${chalk5.dim(`Building MAUI host (${this.target.framework})...`)}`
+      taggedRow(
+        "active",
+        "host",
+        `${dim("building")} ${value(this.target.framework)} ${dim("\u2026")}`
+      )
     );
     try {
       execFileSync3(
@@ -763,10 +1066,14 @@ var DevSession = class {
         }
       );
     } catch (error) {
-      const output = formatExecError2(error);
-      console.error(chalk5.red("  MAUI build failed."));
-      console.error(chalk5.dim(output));
+      const output = formatBuildError(error);
+      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(footer(dim("re-run with --verbose for the full build log.")));
+      }
       process.exit(1);
     }
     const appBundle = findMacAppBundle(
@@ -776,9 +1083,12 @@ var DevSession = class {
     );
     if (!appBundle) {
       console.error(
-        chalk5.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);
     }
@@ -790,11 +1100,16 @@ var DevSession = class {
     const binary = findMacExecutable(appBundle);
     if (!binary) {
       console.error(
-        chalk5.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(`  ${chalk5.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"],
@@ -803,7 +1118,7 @@ var DevSession = class {
     return this.registerChild(host, "host", path6.basename(binary));
   }
   launchWindowsHost() {
-    console.log(`  ${chalk5.dim("Launching host...")}`);
+    console.log(taggedRow("active", "host", dim("launching\u2026")));
     const host = spawn(
       DOTNET_COMMAND,
       [
@@ -823,31 +1138,44 @@ 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);
-    child.on("exit", (code) => {
+    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(
-          chalk5.red(`
-  ${label} exited with code ${exitCode}.`)
+          "\n" + row({ glyph: "error", detail: dim(`${label} exited with code ${exitCode}`) })
         );
         this.shutdown(exitCode);
         return;
       }
-      if (code !== null && code !== 0) {
-        console.error(chalk5.red(`
-  ${label} exited with code ${code}.`));
+      const failed = code !== null && code !== 0 || signal !== null;
+      if (failed) {
+        console.error(
+          "\n" + row({
+            glyph: "error",
+            detail: dim(
+              `${label} exited with ${signal ? `signal ${signal}` : `code ${code}`}`
+            )
+          })
+        );
+        if (tag2 === "host" && this.target.name === "macos") {
+          printMacLaunchHint();
+        }
       }
-      this.shutdown(code ?? 0);
+      this.shutdown(code ?? (signal ? 1 : 0));
     });
     child.on("error", (error) => {
       if (this.shuttingDown) return;
-      console.error(chalk5.red(`
-  Failed to start ${label}: ${error.message}`));
+      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);
     });
     return child;
@@ -863,23 +1191,26 @@ var DevSession = class {
 };
 var ensureTargetMatchesHostOs = (targetName) => {
   if (targetName === "macos" && process.platform !== "darwin") {
-    console.error(chalk5.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(
-      chalk5.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}
 `);
       }
     }
@@ -916,11 +1247,12 @@ var waitForServer = (url, timeoutMs) => {
     poll();
   });
 };
-var waitForExit = (vite, host) => {
+var waitForExit = (...children) => {
   return new Promise((resolve) => {
     const resolveOnce = () => resolve();
-    vite.once("exit", resolveOnce);
-    host.once("exit", resolveOnce);
+    for (const child of children) {
+      child.once("exit", resolveOnce);
+    }
   });
 };
 var findMacAppBundle = (hostDir, framework, buildConfig) => {
@@ -965,39 +1297,52 @@ var killChild = (child) => {
   }
   child.kill("SIGTERM");
 };
-var formatExecError2 = (error) => {
-  const err = error;
-  if (Buffer.isBuffer(err.stderr)) {
-    return err.stderr.toString();
-  }
-  if (typeof err.stderr === "string") {
-    return err.stderr;
-  }
-  return err.message;
+var printMacLaunchHint = () => {
+  console.error();
+  console.error(
+    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(
+    `      ${dim("\u2022")} ${dim("install full Xcode, then run")} ${lime("vidra doctor")} ${dim("to verify")}`
+  );
+  console.error(
+    `      ${dim("\u2022")} ${dim("approve it once in Finder: right-click the")} ${value(".app")} ${dim("and choose")} ${value("Open")}`
+  );
+  console.error(
+    `      ${dim("\u2022")} ${dim("or provide a signing identity via")} ${value("VIDRA_MACOS_CODESIGN_KEY")}`
+  );
+  console.error();
 };
 
 // src/cli.ts
-var VERSION3 = "0.1.3";
 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(`
-  ${chalk6.bold("vidra")} ${chalk6.dim(`v${VERSION3}`)}
+  ${wordmark()} ${dim(`v${CLI_VERSION}`)}
 
-  ${chalk6.dim("Usage:")}
-    vidra <command> [options]
+  ${dim("usage")}
+    ${lime("vidra")} ${dim("<command> [options]")}
 
-  ${chalk6.dim("Commands:")}
-    dev     Start the development environment
-    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")}
 
-  ${chalk6.dim("Examples:")}
-    vidra dev                   ${chalk6.dim("# start Vite + native host")}
-    vidra dev --target windows  ${chalk6.dim("# run the Windows host")}
-    vidra build                 ${chalk6.dim("# auto-detect platform")}
-    vidra build --target macos  ${chalk6.dim("# macOS DMG")}
-    vidra build --verbose       ${chalk6.dim("# show full build output")}
-    vidra doctor                ${chalk6.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 () => {
@@ -1007,6 +1352,9 @@ var main = async () => {
     case "dev":
       await devCommand(args.slice(1));
       break;
+    case "run":
+      await runCommand(args.slice(1));
+      break;
     case "build":
       await buildCommand(args.slice(1));
       break;
@@ -1021,16 +1369,15 @@ var main = async () => {
       break;
     case "--version":
     case "-v":
-      console.log(VERSION3);
+      console.log(CLI_VERSION);
       break;
     default:
-      console.error(chalk6.red(`  Unknown command: ${command}
-`));
+      console.error(row({ glyph: "error", detail: dim(`unknown command: ${command}`) }));
       printHelp();
       process.exit(1);
   }
 };
 main().catch((e) => {
-  console.error(chalk6.red(e.message));
+  console.error(row({ glyph: "error", detail: dim(e.message) }));
   process.exit(1);
 });