create-vidra-app 0.1.4 → 0.1.5

package/dist/cli.js

@@ -1,11 +1,11 @@
 // src/cli.ts
-import chalk6 from "chalk";
+import chalk7 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";
+import chalk5 from "chalk";
 
 // src/utils.ts
 var parseArgs = (argv) => {
@@ -22,10 +22,34 @@ var parseArgs = (argv) => {
   return args;
 };
 
+// src/exec.ts
+import { execSync } from "child_process";
+import chalk from "chalk";
+var toText = (value) => {
+  if (value == null) return "";
+  return Buffer.isBuffer(value) ? value.toString() : value;
+};
+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";
+import chalk2 from "chalk";
 var detectPlatform = () => {
   switch (process.platform) {
     case "darwin":
@@ -64,7 +88,7 @@ var detectProject = (cwd) => {
     dir = parent;
   }
   console.error(
-    chalk.red(
+    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"
     )
   );
@@ -97,7 +121,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 +147,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 +161,35 @@ var macosTarget = {
 // src/signing.ts
 import path3 from "path";
 import { execFileSync } from "child_process";
-import chalk2 from "chalk";
+import chalk3 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}`)}`
+      identity ? `  ${chalk3.dim("Signing:")}  ${chalk3.cyan(label)} ${chalk3.dim(`with ${identity}`)}` : `  ${chalk3.dim("Signing:")}  ${chalk3.cyan(label)} ${chalk3.dim("ad-hoc (no developer identity)")}`
     );
   } catch (error) {
     options.warn(
-      chalk2.yellow(
-        "  Failed to re-sign the macOS app bundle. It may remain ad-hoc signed."
+      chalk3.yellow(
+        "  Could not code-sign the macOS 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."
       )
     );
-    options.warn(chalk2.dim(formatExecError(error)));
+    options.warn(chalk3.dim(formatExecError(error)));
   }
 };
 var resolveMacCodeSigningIdentity = () => {
@@ -239,7 +257,7 @@ var windowsTarget = {
 // src/doctor.ts
 import { execFileSync as execFileSync2 } from "child_process";
 import prompts from "prompts";
-import chalk3 from "chalk";
+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;
@@ -272,6 +290,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) {
@@ -363,17 +386,17 @@ var collectRequirements = (opts = {}) => {
 };
 var printRequirements = (reqs) => {
   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})`)}` : "";
+    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}`);
     if (r.status === "missing" && r.fix) {
-      console.log(`      ${chalk3.dim("fix:")} ${chalk3.cyan(r.fix)}`);
+      console.log(`      ${chalk4.dim("fix:")} ${chalk4.cyan(r.fix)}`);
     }
   }
 };
 var runDoctor = async () => {
   console.log();
-  console.log(`  ${chalk3.bold.cyan("vidra doctor")}`);
+  console.log(`  ${chalk4.bold.cyan("vidra doctor")}`);
   console.log();
   const reqs = collectRequirements();
   printRequirements(reqs);
@@ -381,7 +404,7 @@ 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(
+      `  ${chalk4.green("All checks passed.")} You're ready to run ${chalk4.cyan(
         "vidra dev"
       )}.`
     );
@@ -389,9 +412,9 @@ var runDoctor = async () => {
     return 0;
   }
   console.log(
-    `  ${chalk3.yellow(
+    `  ${chalk4.yellow(
       `${missing.length} issue(s) found.`
-    )} Apply the fixes above, then re-run ${chalk3.cyan("vidra doctor")}.`
+    )} Apply the fixes above, then re-run ${chalk4.cyan("vidra doctor")}.`
   );
   console.log();
   return 1;
@@ -399,9 +422,9 @@ 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(`  ${chalk4.dim(`Running: ${DOTNET} ${args.join(" ")}`)}`);
   console.log(
-    `  ${chalk3.dim(
+    `  ${chalk4.dim(
       "This can download several hundred MB and take a few minutes."
     )}`
   );
@@ -411,13 +434,13 @@ var installWorkload = (csprojPath) => {
     return true;
   } catch {
     console.error();
-    console.error(`  ${chalk3.red("Workload install failed.")}`);
+    console.error(`  ${chalk4.red("Workload install failed.")}`);
     console.error(
-      `  ${chalk3.dim(
+      `  ${chalk4.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(`      ${chalk4.cyan("sudo dotnet workload install maui")}`);
     console.error();
     return false;
   }
@@ -426,9 +449,9 @@ var ensureMauiWorkload = async (opts = {}) => {
   const dotnet = checkDotnetSdk();
   if (dotnet.status === "missing") {
     console.log();
-    console.log(`  ${chalk3.yellow("!")} ${dotnet.name} \u2014 ${dotnet.detail}`);
+    console.log(`  ${chalk4.yellow("!")} ${dotnet.name} \u2014 ${dotnet.detail}`);
     if (dotnet.fix) {
-      console.log(`      ${chalk3.dim("fix:")} ${chalk3.cyan(dotnet.fix)}`);
+      console.log(`      ${chalk4.dim("fix:")} ${chalk4.cyan(dotnet.fix)}`);
     }
     return false;
   }
@@ -436,7 +459,7 @@ var ensureMauiWorkload = async (opts = {}) => {
   if (isMauiWorkloadInstalled()) return true;
   console.log();
   console.log(
-    `  ${chalk3.yellow("!")} The .NET MAUI workload is required but not installed.`
+    `  ${chalk4.yellow("!")} The .NET MAUI workload is required but not installed.`
   );
   const interactive = opts.interactive ?? isInteractive();
   if (interactive) {
@@ -454,31 +477,50 @@ var ensureMauiWorkload = async (opts = {}) => {
     }
     if (install) {
       if (installWorkload(opts.csprojPath) && isMauiWorkloadInstalled()) {
-        console.log(`  ${chalk3.green("\u2713")} MAUI workload installed.`);
+        console.log(`  ${chalk4.green("\u2713")} MAUI workload installed.`);
         return true;
       }
       return false;
     }
   }
   console.log(
-    `      ${chalk3.dim("run:")} ${chalk3.cyan("dotnet workload install maui")}`
+    `      ${chalk4.dim("run:")} ${chalk4.cyan("dotnet workload install maui")}`
   );
-  console.log(`      ${chalk3.dim("docs:")} ${chalk3.cyan(MAUI_DOCS)}`);
+  console.log(`      ${chalk4.dim("docs:")} ${chalk4.cyan(MAUI_DOCS)}`);
   return false;
 };
 var printWorkloadHint = () => {
   console.error();
   console.error(
-    `  ${chalk3.yellow("This looks like a missing .NET MAUI workload.")}`
+    `  ${chalk4.yellow("This looks like a missing .NET MAUI workload.")}`
   );
   console.error(
-    `      ${chalk3.dim("fix: ")} ${chalk3.cyan("dotnet workload install maui")}`
+    `      ${chalk4.dim("fix: ")} ${chalk4.cyan("dotnet workload install maui")}`
   );
   console.error(
-    `      ${chalk3.dim("check:")} ${chalk3.cyan("vidra doctor")}`
+    `      ${chalk4.dim("check:")} ${chalk4.cyan("vidra doctor")}`
   );
   console.error();
 };
+var printXcodeHint = () => {
+  console.error();
+  console.error(
+    `  ${chalk4.yellow(
+      "Mac Catalyst builds need the full Xcode app, not just the Command Line Tools."
+    )}`
+  );
+  console.error(`      ${chalk4.dim("1.")} Install Xcode from the App Store`);
+  console.error(
+    `      ${chalk4.dim("2.")} ${chalk4.cyan(
+      "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();
+};
 
 // src/commands/build.ts
 var VERSION = "0.1.0";
@@ -492,22 +534,22 @@ var buildCommand = async (argv) => {
   const targetName = args["target"] || detectPlatform();
   console.log();
   console.log(
-    `  ${chalk4.bold.cyan("vidra build")} ${chalk4.dim(`v${VERSION}`)}`
+    `  ${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(
-      chalk4.red(
+      chalk5.red(
         `  Unsupported target: ${targetName}. 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(`  ${chalk5.dim("Project:")}  ${chalk5.cyan(project.projectName)}`);
+  console.log(`  ${chalk5.dim("Target:")}   ${chalk5.cyan(target.name)} (${target.framework})`);
   console.log();
   if (!await ensureMauiWorkload({ csprojPath: project.csprojPath })) {
     process.exit(1);
@@ -518,12 +560,12 @@ var buildCommand = async (argv) => {
   const bundlePath = target.findBundle(publishDir, project.projectName);
   if (!bundlePath) {
     console.error(
-      chalk4.red(`  Could not find build artifact in ${publishDir}`)
+      chalk5.red(`  Could not find build artifact in ${publishDir}`)
     );
     process.exit(1);
   }
   console.log(
-    `  ${chalk4.dim("Bundle:")}   ${chalk4.cyan(path5.basename(bundlePath))}`
+    `  ${chalk5.dim("Bundle:")}   ${chalk5.cyan(path5.basename(bundlePath))}`
   );
   if (target.name === "macos") {
     signMacAppBundleIfPossible(bundlePath, {
@@ -535,7 +577,7 @@ var buildCommand = async (argv) => {
   const outputDir = path5.join(project.root, "dist");
   fs4.ensureDirSync(outputDir);
   console.log();
-  console.log(`  ${chalk4.dim(`Packaging for ${target.name}...`)}`);
+  console.log(`  ${chalk5.dim(`Packaging for ${target.name}...`)}`);
   const startPkg = Date.now();
   let outputPath;
   try {
@@ -544,46 +586,44 @@ var buildCommand = async (argv) => {
       displayVersion: project.displayVersion
     });
   } catch (e) {
-    const err = e;
-    console.error(chalk4.red(`  Packaging failed.`));
-    console.error(chalk4.dim(err.stderr?.toString() || err.message));
+    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(
-    `  ${chalk4.green(">")} ${path5.basename(outputPath)} ${chalk4.dim(`(${sizeMB} MB, ${pkgTime}s)`)}`
+    `  ${chalk5.green(">")} ${path5.basename(outputPath)} ${chalk5.dim(`(${sizeMB} MB, ${pkgTime}s)`)}`
   );
   console.log();
   console.log(
-    `  ${chalk4.green("Done!")} Output: ${chalk4.cyan(path5.relative(project.root, outputPath))}`
+    `  ${chalk5.green("Done!")} Output: ${chalk5.cyan(path5.relative(project.root, outputPath))}`
   );
   console.log();
 };
 var stepBuildUi = (project, verbose) => {
-  console.log(`  ${chalk4.dim("Building UI...")}`);
+  console.log(`  ${chalk5.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(chalk5.red("  Vite build failed."));
+    console.error(chalk5.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(`  ${chalk5.green(">")} Vite build complete ${chalk5.dim(`(${elapsed}s)`)}`);
   console.log();
 };
 var stepCopyAssets = (project) => {
-  console.log(`  ${chalk4.dim("Copying assets to host project...")}`);
+  console.log(`  ${chalk5.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(chalk5.red(`  ui/dist not found. Vite build may have failed.`));
     process.exit(1);
   }
   const wwwroot = path5.join(project.hostDir, "Resources", "Raw", "wwwroot");
@@ -591,7 +631,7 @@ var stepCopyAssets = (project) => {
   fs4.copySync(viteDist, wwwroot);
   const fileCount = countFiles(wwwroot);
   console.log(
-    `  ${chalk4.green(">")} ${fileCount} files -> ${chalk4.dim("Resources/Raw/wwwroot/")}`
+    `  ${chalk5.green(">")} ${fileCount} files -> ${chalk5.dim("Resources/Raw/wwwroot/")}`
   );
   console.log();
 };
@@ -608,12 +648,12 @@ var countFiles = (dir) => {
 };
 var stepDotnetPublish = (project, target, verbose) => {
   console.log(
-    `  ${chalk4.dim(`Publishing .NET host (${target.framework})...`)}`
+    `  ${chalk5.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,16 +661,21 @@ 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(chalk5.red("  dotnet publish failed."));
+    console.error(chalk5.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.")
+      );
+    }
     process.exit(1);
   }
   const elapsed = ((Date.now() - start) / 1e3).toFixed(1);
   console.log(
-    `  ${chalk4.green(">")} dotnet publish complete ${chalk4.dim(`(${elapsed}s)`)}`
+    `  ${chalk5.green(">")} dotnet publish complete ${chalk5.dim(`(${elapsed}s)`)}`
   );
   const publishDir = path5.join(
     project.hostDir,
@@ -646,7 +691,7 @@ 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";
+import chalk6 from "chalk";
 var VERSION2 = "0.1.0";
 var POLL_INTERVAL_MS = 500;
 var POLL_TIMEOUT_MS = 3e4;
@@ -662,7 +707,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,7 +718,7 @@ var devCommand = async (argv) => {
   if (!target) {
     const supported = Object.keys(TARGETS2).join(", ");
     console.error(
-      chalk5.red(
+      chalk6.red(
         `  Unsupported target: ${targetName}. Supported: ${supported}`
       )
     );
@@ -682,15 +729,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,32 +746,39 @@ 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(
+      `  ${chalk6.bold.cyan(this.vite ? "vidra dev" : "vidra run")} ${chalk6.dim(`v${VERSION2}`)}`
+    );
     console.log();
-    console.log(`  ${chalk5.dim("Project:")}  ${chalk5.cyan(this.project.projectName)}`);
+    console.log(`  ${chalk6.dim("Project:")}  ${chalk6.cyan(this.project.projectName)}`);
     console.log(
-      `  ${chalk5.dim("Target:")}   ${chalk5.cyan(this.target.name)} (${this.target.framework})`
+      `  ${chalk6.dim("Target:")}   ${chalk6.cyan(this.target.name)} (${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(chalk6.red(`  ${error.message}`));
+        this.shutdown(1);
+      }
+      console.log(`  ${chalk6.dim("Vite:")}     ${chalk6.cyan(this.viteUrl)}`);
+      console.log();
+    } else {
+      console.log(
+        `  ${chalk6.dim("UI:")}       ${chalk6.cyan(this.viteUrl)} ${chalk6.dim("(start it separately, e.g. `npm run dev:ui`)")}`
       );
-      this.shutdown(1);
+      console.log();
     }
-    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);
+    await waitForExit(...vite ? [vite, host] : [host]);
   }
   installSignalHandlers() {
     process.on("SIGINT", () => {
@@ -735,7 +790,7 @@ var DevSession = class {
     });
   }
   startVite() {
-    console.log(`  ${chalk5.dim("Starting Vite dev server...")}`);
+    console.log(`  ${chalk6.dim("Starting Vite dev server...")}`);
     const vite = spawn(NPM_COMMAND, ["run", "dev"], {
       cwd: this.project.uiDir,
       stdio: ["ignore", "pipe", "pipe"]
@@ -744,7 +799,7 @@ var DevSession = class {
   }
   launchMacosHost() {
     console.log(
-      `  ${chalk5.dim(`Building MAUI host (${this.target.framework})...`)}`
+      `  ${chalk6.dim(`Building MAUI host (${this.target.framework})...`)}`
     );
     try {
       execFileSync3(
@@ -763,10 +818,16 @@ 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(chalk6.red("  MAUI build failed."));
+      console.error(chalk6.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.")
+        );
+      }
       process.exit(1);
     }
     const appBundle = findMacAppBundle(
@@ -776,7 +837,7 @@ var DevSession = class {
     );
     if (!appBundle) {
       console.error(
-        chalk5.red(
+        chalk6.red(
           `  Could not find .app bundle in ${path6.join(this.project.hostDir, "bin", this.buildConfig, this.target.framework)}`
         )
       );
@@ -790,11 +851,11 @@ var DevSession = class {
     const binary = findMacExecutable(appBundle);
     if (!binary) {
       console.error(
-        chalk5.red(`  Could not find the app executable in ${appBundle}.`)
+        chalk6.red(`  Could not find the app executable in ${appBundle}.`)
       );
       process.exit(1);
     }
-    console.log(`  ${chalk5.dim("Launching host...")}`);
+    console.log(`  ${chalk6.dim("Launching host...")}`);
     const host = spawn(binary, [], {
       cwd: this.project.root,
       stdio: ["ignore", "pipe", "pipe"],
@@ -803,7 +864,7 @@ var DevSession = class {
     return this.registerChild(host, "host", path6.basename(binary));
   }
   launchWindowsHost() {
-    console.log(`  ${chalk5.dim("Launching host...")}`);
+    console.log(`  ${chalk6.dim("Launching host...")}`);
     const host = spawn(
       DOTNET_COMMAND,
       [
@@ -827,27 +888,38 @@ var DevSession = class {
     this.children.push(child);
     prefixStream(child.stdout, tag);
     prefixStream(child.stderr, tag);
-    child.on("exit", (code) => {
+    child.on("exit", (code, signal) => {
       if (this.shuttingDown) return;
       if (tag === "ui") {
         const exitCode = code ?? 1;
         console.error(
-          chalk5.red(`
+          chalk6.red(`
   ${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(
+          chalk6.red(
+            `
+  ${label} exited with ${signal ? `signal ${signal}` : `code ${code}`}.`
+          )
+        );
+        if (tag === "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(`
+      console.error(chalk6.red(`
   Failed to start ${label}: ${error.message}`));
+      if (tag === "host" && this.target.name === "macos") {
+        printMacLaunchHint();
+      }
       this.shutdown(1);
     });
     return child;
@@ -863,12 +935,12 @@ 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(chalk6.red("  The macOS dev 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.")
+      chalk6.red("  The Windows dev target can only run on Windows.")
     );
     process.exit(1);
   }
@@ -916,11 +988,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 +1038,50 @@ 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(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:"
+    )
+  );
+  console.error(
+    `    ${chalk6.dim("\u2022")} Install full Xcode, then run ${chalk6.cyan("vidra doctor")} to verify`
+  );
+  console.error(
+    `    ${chalk6.dim("\u2022")} Approve it once in Finder: right-click the ${chalk6.cyan(".app")} and choose ${chalk6.cyan("Open")}`
+  );
+  console.error(
+    `    ${chalk6.dim("\u2022")} Or provide a signing identity via ${chalk6.cyan("VIDRA_MACOS_CODESIGN_KEY")}`
+  );
+  console.error();
 };
 
 // src/cli.ts
-var VERSION3 = "0.1.3";
+var VERSION3 = "0.1.5";
 var printHelp = () => {
   console.log(`
-  ${chalk6.bold("vidra")} ${chalk6.dim(`v${VERSION3}`)}
+  ${chalk7.bold("vidra")} ${chalk7.dim(`v${VERSION3}`)}
 
-  ${chalk6.dim("Usage:")}
+  ${chalk7.dim("Usage:")}
     vidra <command> [options]
 
-  ${chalk6.dim("Commands:")}
-    dev     Start the development environment
+  ${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
 
-  ${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")}
+  ${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")}
 `);
 };
 var main = async () => {
@@ -1007,6 +1091,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;
@@ -1024,13 +1111,13 @@ var main = async () => {
       console.log(VERSION3);
       break;
     default:
-      console.error(chalk6.red(`  Unknown command: ${command}
+      console.error(chalk7.red(`  Unknown command: ${command}
 `));
       printHelp();
       process.exit(1);
   }
 };
 main().catch((e) => {
-  console.error(chalk6.red(e.message));
+  console.error(chalk7.red(e.message));
   process.exit(1);
 });

package/dist/index.js

@@ -37,13 +37,21 @@ var parseArgs = (argv) => {
 // src/exec.ts
 import { execSync } from "child_process";
 import chalk from "chalk";
+var toText = (value) => {
+  if (value == null) return "";
+  return Buffer.isBuffer(value) ? value.toString() : value;
+};
+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 exec = (cmd, cwd) => {
   try {
     execSync(cmd, { cwd, stdio: "pipe" });
   } catch (e) {
-    const err = e;
     console.error(chalk.red(`  Command failed: ${cmd}`));
-    console.error(chalk.dim(err.stderr?.toString() || err.message));
+    console.error(chalk.dim(formatProcessError(e)));
     process.exit(1);
   }
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-vidra-app",
-  "version": "0.1.4",
+  "version": "0.1.5",
   "description": "Scaffold a new Vidra application (React + .NET MAUI)",
   "type": "module",
   "bin": {

package/templates/react-vite/package.json

@@ -5,8 +5,8 @@
     "build": "vidra build",
     "dev": "vidra dev",
     "dev:ui": "npm run dev --prefix ui",
-    "dev:host:macos": "dotnet build -t:Run -f net10.0-maccatalyst src/{{projectName}}.Host/{{projectName}}.Host.csproj",
-    "dev:host:windows": "dotnet build -t:Run -f net10.0-windows10.0.19041.0 src/{{projectName}}.Host/{{projectName}}.Host.csproj"
+    "dev:host:macos": "vidra run --target macos",
+    "dev:host:windows": "vidra run --target windows"
   },
   "devDependencies": {
     "create-vidra-app": "{{cliVersion}}"