create-vidra-app 0.1.1 → 0.1.3

package/README.md

@@ -26,13 +26,19 @@ This package also installs the `vidra` CLI used by scaffolded apps:
 vidra dev                   # start Vite + native host
 vidra dev --target windows  # run the Windows host
 vidra build --target macos  # build + package a macOS .dmg
+vidra doctor                # check your .NET / MAUI / Xcode setup
 ```
 
 ## Prerequisites
 
-- .NET 10 SDK with the MAUI workload
+- .NET 10 SDK
+- The .NET MAUI workload: `dotnet workload install maui`
 - Node.js 18+
-- Windows targets must be built on Windows; macOS targets on macOS
+- macOS targets require Xcode; Windows targets must be built on Windows
+
+If the MAUI workload is missing, `create-vidra-app` will detect it after
+scaffolding and offer to install it for you. You can re-check at any time with
+`vidra doctor`.
 
 ## License
 

package/dist/cli.js

@@ -1,11 +1,11 @@
 // src/cli.ts
-import chalk5 from "chalk";
+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 chalk3 from "chalk";
+import chalk4 from "chalk";
 
 // src/utils.ts
 var parseArgs = (argv) => {
@@ -236,6 +236,250 @@ 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;
+var run = (cmd, args) => {
+  try {
+    const stdout = execFileSync2(cmd, args, {
+      encoding: "utf-8",
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    return { found: true, ok: true, stdout: stdout ?? "", stderr: "" };
+  } catch (e) {
+    const err = e;
+    return {
+      found: err.code !== "ENOENT",
+      ok: false,
+      stdout: bufToStr(err.stdout),
+      stderr: bufToStr(err.stderr)
+    };
+  }
+};
+var hasNet10Sdk = (listSdksOutput) => listSdksOutput.split(/\r?\n/).some((line) => /^10\./.test(line.trim()));
+var newestNet10Sdk = (listSdksOutput) => listSdksOutput.split(/\r?\n/).map((line) => line.trim().split(/\s+/)[0]).filter((v) => /^10\./.test(v)).sort(
+  (a, b) => a.localeCompare(b, void 0, { numeric: true, sensitivity: "base" })
+).pop();
+var outputMentionsMaui = (workloadListOutput) => /\bmaui\b/i.test(workloadListOutput);
+var looksLikeMissingWorkload = (output) => [
+  /NETSDK1147/i,
+  /workloads?\s+must\s+be\s+installed/i,
+  /maui-maccatalyst/i,
+  /maui-windows/i,
+  /to\s+install\s+the\s+.*workload/i
+].some((re) => re.test(output));
+var checkDotnetSdk = () => {
+  const res = run(DOTNET, ["--list-sdks"]);
+  if (!res.found) {
+    return {
+      name: ".NET SDK",
+      status: "missing",
+      detail: "`dotnet` was not found on your PATH",
+      fix: "Install the .NET 10 SDK \u2014 https://dotnet.microsoft.com/download"
+    };
+  }
+  if (!res.ok && !res.stdout) {
+    return {
+      name: ".NET SDK",
+      status: "unknown",
+      detail: "could not run `dotnet --list-sdks`"
+    };
+  }
+  if (hasNet10Sdk(res.stdout)) {
+    const newest = newestNet10Sdk(res.stdout);
+    return {
+      name: ".NET SDK",
+      status: "ok",
+      detail: newest ? `found ${newest}` : "found 10.x"
+    };
+  }
+  return {
+    name: ".NET SDK",
+    status: "missing",
+    detail: "no 10.x SDK installed",
+    fix: "Install the .NET 10 SDK \u2014 https://dotnet.microsoft.com/download"
+  };
+};
+var checkMauiWorkload = (dotnetOk) => {
+  if (!dotnetOk) {
+    return {
+      name: ".NET MAUI workload",
+      status: "unknown",
+      detail: "requires the .NET SDK first"
+    };
+  }
+  const res = run(DOTNET, ["workload", "list"]);
+  if (!res.found) {
+    return {
+      name: ".NET MAUI workload",
+      status: "unknown",
+      detail: "could not query workloads"
+    };
+  }
+  if (outputMentionsMaui(res.stdout)) {
+    return { name: ".NET MAUI workload", status: "ok", detail: "installed" };
+  }
+  return {
+    name: ".NET MAUI workload",
+    status: "missing",
+    detail: "not installed",
+    fix: "dotnet workload install maui"
+  };
+};
+var checkXcode = () => {
+  const res = run("xcode-select", ["-p"]);
+  if (!res.found || !res.ok) {
+    return {
+      name: "Xcode",
+      status: "missing",
+      detail: "not found",
+      fix: "Install Xcode from the App Store"
+    };
+  }
+  const devDir = res.stdout.trim();
+  if (/CommandLineTools/i.test(devDir)) {
+    return {
+      name: "Xcode",
+      status: "missing",
+      detail: "only Command Line Tools detected (Mac Catalyst needs full Xcode)",
+      fix: "Install Xcode, then: sudo xcode-select -s /Applications/Xcode.app"
+    };
+  }
+  return { name: "Xcode", status: "ok", detail: devDir };
+};
+var isMauiWorkloadInstalled = () => outputMentionsMaui(run(DOTNET, ["workload", "list"]).stdout);
+var isInteractive = () => Boolean(process.stdin.isTTY && process.stdout.isTTY);
+var collectRequirements = (opts = {}) => {
+  const dotnet = checkDotnetSdk();
+  const reqs = [dotnet, checkMauiWorkload(dotnet.status === "ok")];
+  if (opts.includeXcode ?? process.platform === "darwin") {
+    reqs.push(checkXcode());
+  }
+  return reqs;
+};
+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})`)}` : "";
+    console.log(`  ${icon} ${r.name}${detail}`);
+    if (r.status === "missing" && r.fix) {
+      console.log(`      ${chalk3.dim("fix:")} ${chalk3.cyan(r.fix)}`);
+    }
+  }
+};
+var runDoctor = async () => {
+  console.log();
+  console.log(`  ${chalk3.bold.cyan("vidra doctor")}`);
+  console.log();
+  const reqs = collectRequirements();
+  printRequirements(reqs);
+  console.log();
+  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"
+      )}.`
+    );
+    console.log();
+    return 0;
+  }
+  console.log(
+    `  ${chalk3.yellow(
+      `${missing.length} issue(s) found.`
+    )} Apply the fixes above, then re-run ${chalk3.cyan("vidra doctor")}.`
+  );
+  console.log();
+  return 1;
+};
+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."
+    )}`
+  );
+  console.log();
+  try {
+    execFileSync2(DOTNET, args, { stdio: "inherit" });
+    return true;
+  } catch {
+    console.error();
+    console.error(`  ${chalk3.red("Workload install failed.")}`);
+    console.error(
+      `  ${chalk3.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();
+    return false;
+  }
+};
+var ensureMauiWorkload = async (opts = {}) => {
+  const dotnet = checkDotnetSdk();
+  if (dotnet.status === "missing") {
+    console.log();
+    console.log(`  ${chalk3.yellow("!")} ${dotnet.name} \u2014 ${dotnet.detail}`);
+    if (dotnet.fix) {
+      console.log(`      ${chalk3.dim("fix:")} ${chalk3.cyan(dotnet.fix)}`);
+    }
+    return false;
+  }
+  if (dotnet.status === "unknown") return true;
+  if (isMauiWorkloadInstalled()) return true;
+  console.log();
+  console.log(
+    `  ${chalk3.yellow("!")} The .NET MAUI workload is required but not installed.`
+  );
+  const interactive = opts.interactive ?? isInteractive();
+  if (interactive) {
+    let install = false;
+    try {
+      const res = await prompts({
+        type: "confirm",
+        name: "install",
+        message: "Install the .NET MAUI workload now?",
+        initial: true
+      });
+      install = Boolean(res.install);
+    } catch {
+      install = false;
+    }
+    if (install) {
+      if (installWorkload(opts.csprojPath) && isMauiWorkloadInstalled()) {
+        console.log(`  ${chalk3.green("\u2713")} MAUI workload 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)}`);
+  return false;
+};
+var printWorkloadHint = () => {
+  console.error();
+  console.error(
+    `  ${chalk3.yellow("This looks like a missing .NET MAUI workload.")}`
+  );
+  console.error(
+    `      ${chalk3.dim("fix: ")} ${chalk3.cyan("dotnet workload install maui")}`
+  );
+  console.error(
+    `      ${chalk3.dim("check:")} ${chalk3.cyan("vidra doctor")}`
+  );
+  console.error();
+};
+
 // src/commands/build.ts
 var VERSION = "0.1.0";
 var TARGETS = {
@@ -248,35 +492,38 @@ var buildCommand = async (argv) => {
   const targetName = args["target"] || detectPlatform();
   console.log();
   console.log(
-    `  ${chalk3.bold.cyan("vidra build")} ${chalk3.dim(`v${VERSION}`)}`
+    `  ${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(
-      chalk3.red(
+      chalk4.red(
         `  Unsupported target: ${targetName}. Supported: ${supported}`
       )
     );
     process.exit(1);
   }
   const project = detectProject(process.cwd());
-  console.log(`  ${chalk3.dim("Project:")}  ${chalk3.cyan(project.projectName)}`);
-  console.log(`  ${chalk3.dim("Target:")}   ${chalk3.cyan(target.name)} (${target.framework})`);
+  console.log(`  ${chalk4.dim("Project:")}  ${chalk4.cyan(project.projectName)}`);
+  console.log(`  ${chalk4.dim("Target:")}   ${chalk4.cyan(target.name)} (${target.framework})`);
   console.log();
+  if (!await ensureMauiWorkload({ csprojPath: project.csprojPath })) {
+    process.exit(1);
+  }
   stepBuildUi(project, verbose);
   stepCopyAssets(project);
   const publishDir = stepDotnetPublish(project, target, verbose);
   const bundlePath = target.findBundle(publishDir, project.projectName);
   if (!bundlePath) {
     console.error(
-      chalk3.red(`  Could not find build artifact in ${publishDir}`)
+      chalk4.red(`  Could not find build artifact in ${publishDir}`)
     );
     process.exit(1);
   }
   console.log(
-    `  ${chalk3.dim("Bundle:")}   ${chalk3.cyan(path5.basename(bundlePath))}`
+    `  ${chalk4.dim("Bundle:")}   ${chalk4.cyan(path5.basename(bundlePath))}`
   );
   if (target.name === "macos") {
     signMacAppBundleIfPossible(bundlePath, {
@@ -288,7 +535,7 @@ var buildCommand = async (argv) => {
   const outputDir = path5.join(project.root, "dist");
   fs4.ensureDirSync(outputDir);
   console.log();
-  console.log(`  ${chalk3.dim(`Packaging for ${target.name}...`)}`);
+  console.log(`  ${chalk4.dim(`Packaging for ${target.name}...`)}`);
   const startPkg = Date.now();
   let outputPath;
   try {
@@ -298,24 +545,24 @@ var buildCommand = async (argv) => {
     });
   } catch (e) {
     const err = e;
-    console.error(chalk3.red(`  Packaging failed.`));
-    console.error(chalk3.dim(err.stderr?.toString() || err.message));
+    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(
-    `  ${chalk3.green(">")} ${path5.basename(outputPath)} ${chalk3.dim(`(${sizeMB} MB, ${pkgTime}s)`)}`
+    `  ${chalk4.green(">")} ${path5.basename(outputPath)} ${chalk4.dim(`(${sizeMB} MB, ${pkgTime}s)`)}`
   );
   console.log();
   console.log(
-    `  ${chalk3.green("Done!")} Output: ${chalk3.cyan(path5.relative(project.root, outputPath))}`
+    `  ${chalk4.green("Done!")} Output: ${chalk4.cyan(path5.relative(project.root, outputPath))}`
   );
   console.log();
 };
 var stepBuildUi = (project, verbose) => {
-  console.log(`  ${chalk3.dim("Building UI...")}`);
+  console.log(`  ${chalk4.dim("Building UI...")}`);
   const start = Date.now();
   try {
     execSync2("npm run build", {
@@ -324,19 +571,19 @@ var stepBuildUi = (project, verbose) => {
     });
   } catch (e) {
     const err = e;
-    console.error(chalk3.red("  Vite build failed."));
-    console.error(chalk3.dim(err.stderr?.toString() || err.message));
+    console.error(chalk4.red("  Vite build failed."));
+    console.error(chalk4.dim(err.stderr?.toString() || err.message));
     process.exit(1);
   }
   const elapsed = ((Date.now() - start) / 1e3).toFixed(1);
-  console.log(`  ${chalk3.green(">")} Vite build complete ${chalk3.dim(`(${elapsed}s)`)}`);
+  console.log(`  ${chalk4.green(">")} Vite build complete ${chalk4.dim(`(${elapsed}s)`)}`);
   console.log();
 };
 var stepCopyAssets = (project) => {
-  console.log(`  ${chalk3.dim("Copying assets to host project...")}`);
+  console.log(`  ${chalk4.dim("Copying assets to host project...")}`);
   const viteDist = path5.join(project.uiDir, "dist");
   if (!fs4.existsSync(viteDist)) {
-    console.error(chalk3.red(`  ui/dist not found. Vite build may have failed.`));
+    console.error(chalk4.red(`  ui/dist not found. Vite build may have failed.`));
     process.exit(1);
   }
   const wwwroot = path5.join(project.hostDir, "Resources", "Raw", "wwwroot");
@@ -344,7 +591,7 @@ var stepCopyAssets = (project) => {
   fs4.copySync(viteDist, wwwroot);
   const fileCount = countFiles(wwwroot);
   console.log(
-    `  ${chalk3.green(">")} ${fileCount} files -> ${chalk3.dim("Resources/Raw/wwwroot/")}`
+    `  ${chalk4.green(">")} ${fileCount} files -> ${chalk4.dim("Resources/Raw/wwwroot/")}`
   );
   console.log();
 };
@@ -361,7 +608,7 @@ var countFiles = (dir) => {
 };
 var stepDotnetPublish = (project, target, verbose) => {
   console.log(
-    `  ${chalk3.dim(`Publishing .NET host (${target.framework})...`)}`
+    `  ${chalk4.dim(`Publishing .NET host (${target.framework})...`)}`
   );
   const start = Date.now();
   const extraArgs = target.extraPublishArgs ?? "-p:CreatePackage=false";
@@ -375,13 +622,15 @@ var stepDotnetPublish = (project, target, verbose) => {
     );
   } catch (e) {
     const err = e;
-    console.error(chalk3.red("  dotnet publish failed."));
-    console.error(chalk3.dim(err.stderr?.toString() || err.message));
+    const output = err.stderr?.toString() || err.message;
+    console.error(chalk4.red("  dotnet publish failed."));
+    console.error(chalk4.dim(output));
+    if (looksLikeMissingWorkload(output)) printWorkloadHint();
     process.exit(1);
   }
   const elapsed = ((Date.now() - start) / 1e3).toFixed(1);
   console.log(
-    `  ${chalk3.green(">")} dotnet publish complete ${chalk3.dim(`(${elapsed}s)`)}`
+    `  ${chalk4.green(">")} dotnet publish complete ${chalk4.dim(`(${elapsed}s)`)}`
   );
   const publishDir = path5.join(
     project.hostDir,
@@ -395,9 +644,9 @@ var stepDotnetPublish = (project, target, verbose) => {
 // src/commands/dev.ts
 import path6 from "path";
 import fs5 from "fs-extra";
-import { execFileSync as execFileSync2, spawn } from "child_process";
+import { execFileSync as execFileSync3, spawn } from "child_process";
 import { request } from "http";
-import chalk4 from "chalk";
+import chalk5 from "chalk";
 var VERSION2 = "0.1.0";
 var POLL_INTERVAL_MS = 500;
 var POLL_TIMEOUT_MS = 3e4;
@@ -422,7 +671,7 @@ var devCommand = async (argv) => {
   if (!target) {
     const supported = Object.keys(TARGETS2).join(", ");
     console.error(
-      chalk4.red(
+      chalk5.red(
         `  Unsupported target: ${targetName}. Supported: ${supported}`
       )
     );
@@ -430,6 +679,9 @@ var devCommand = async (argv) => {
   }
   ensureTargetMatchesHostOs(target.name);
   const project = detectProject(process.cwd());
+  if (!await ensureMauiWorkload({ csprojPath: project.csprojPath })) {
+    process.exit(1);
+  }
   const session = new DevSession(project, target, viteUrl, verbose);
   await session.run();
 };
@@ -450,11 +702,11 @@ var DevSession = class {
   async run() {
     this.installSignalHandlers();
     console.log();
-    console.log(`  ${chalk4.bold.cyan("vidra dev")} ${chalk4.dim(`v${VERSION2}`)}`);
+    console.log(`  ${chalk5.bold.cyan("vidra dev")} ${chalk5.dim(`v${VERSION2}`)}`);
     console.log();
-    console.log(`  ${chalk4.dim("Project:")}  ${chalk4.cyan(this.project.projectName)}`);
+    console.log(`  ${chalk5.dim("Project:")}  ${chalk5.cyan(this.project.projectName)}`);
     console.log(
-      `  ${chalk4.dim("Target:")}   ${chalk4.cyan(this.target.name)} (${this.target.framework})`
+      `  ${chalk5.dim("Target:")}   ${chalk5.cyan(this.target.name)} (${this.target.framework})`
     );
     console.log();
     const vite = this.startVite();
@@ -462,13 +714,13 @@ var DevSession = class {
       await waitForServer(this.viteUrl, POLL_TIMEOUT_MS);
     } catch (error) {
       console.error(
-        chalk4.red(
+        chalk5.red(
           `  ${error.message}`
         )
       );
       this.shutdown(1);
     }
-    console.log(`  ${chalk4.dim("Vite:")}     ${chalk4.cyan(this.viteUrl)}`);
+    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);
@@ -483,7 +735,7 @@ var DevSession = class {
     });
   }
   startVite() {
-    console.log(`  ${chalk4.dim("Starting Vite dev server...")}`);
+    console.log(`  ${chalk5.dim("Starting Vite dev server...")}`);
     const vite = spawn(NPM_COMMAND, ["run", "dev"], {
       cwd: this.project.uiDir,
       stdio: ["ignore", "pipe", "pipe"]
@@ -492,10 +744,10 @@ var DevSession = class {
   }
   launchMacosHost() {
     console.log(
-      `  ${chalk4.dim(`Building MAUI host (${this.target.framework})...`)}`
+      `  ${chalk5.dim(`Building MAUI host (${this.target.framework})...`)}`
     );
     try {
-      execFileSync2(
+      execFileSync3(
         DOTNET_COMMAND,
         [
           "build",
@@ -511,8 +763,10 @@ var DevSession = class {
         }
       );
     } catch (error) {
-      console.error(chalk4.red("  MAUI build failed."));
-      console.error(chalk4.dim(formatExecError2(error)));
+      const output = formatExecError2(error);
+      console.error(chalk5.red("  MAUI build failed."));
+      console.error(chalk5.dim(output));
+      if (looksLikeMissingWorkload(output)) printWorkloadHint();
       process.exit(1);
     }
     const appBundle = findMacAppBundle(
@@ -522,7 +776,7 @@ var DevSession = class {
     );
     if (!appBundle) {
       console.error(
-        chalk4.red(
+        chalk5.red(
           `  Could not find .app bundle in ${path6.join(this.project.hostDir, "bin", this.buildConfig, this.target.framework)}`
         )
       );
@@ -536,11 +790,11 @@ var DevSession = class {
     const binary = findMacExecutable(appBundle);
     if (!binary) {
       console.error(
-        chalk4.red(`  Could not find the app executable in ${appBundle}.`)
+        chalk5.red(`  Could not find the app executable in ${appBundle}.`)
       );
       process.exit(1);
     }
-    console.log(`  ${chalk4.dim("Launching host...")}`);
+    console.log(`  ${chalk5.dim("Launching host...")}`);
     const host = spawn(binary, [], {
       cwd: this.project.root,
       stdio: ["ignore", "pipe", "pipe"],
@@ -549,7 +803,7 @@ var DevSession = class {
     return this.registerChild(host, "host", path6.basename(binary));
   }
   launchWindowsHost() {
-    console.log(`  ${chalk4.dim("Launching host...")}`);
+    console.log(`  ${chalk5.dim("Launching host...")}`);
     const host = spawn(
       DOTNET_COMMAND,
       [
@@ -578,21 +832,21 @@ var DevSession = class {
       if (tag === "ui") {
         const exitCode = code ?? 1;
         console.error(
-          chalk4.red(`
+          chalk5.red(`
   ${label} exited with code ${exitCode}.`)
         );
         this.shutdown(exitCode);
         return;
       }
       if (code !== null && code !== 0) {
-        console.error(chalk4.red(`
+        console.error(chalk5.red(`
   ${label} exited with code ${code}.`));
       }
       this.shutdown(code ?? 0);
     });
     child.on("error", (error) => {
       if (this.shuttingDown) return;
-      console.error(chalk4.red(`
+      console.error(chalk5.red(`
   Failed to start ${label}: ${error.message}`));
       this.shutdown(1);
     });
@@ -609,12 +863,12 @@ var DevSession = class {
 };
 var ensureTargetMatchesHostOs = (targetName) => {
   if (targetName === "macos" && process.platform !== "darwin") {
-    console.error(chalk4.red("  The macOS dev target can only run on macOS."));
+    console.error(chalk5.red("  The macOS dev target can only run on macOS."));
     process.exit(1);
   }
   if (targetName === "windows" && process.platform !== "win32") {
     console.error(
-      chalk4.red("  The Windows dev target can only run on Windows.")
+      chalk5.red("  The Windows dev target can only run on Windows.")
     );
     process.exit(1);
   }
@@ -701,7 +955,7 @@ var killChild = (child) => {
   if (!child.pid || child.exitCode !== null) return;
   if (process.platform === "win32") {
     try {
-      execFileSync2("taskkill", ["/PID", String(child.pid), "/T", "/F"], {
+      execFileSync3("taskkill", ["/PID", String(child.pid), "/T", "/F"], {
         stdio: "ignore"
       });
     } catch {
@@ -723,25 +977,27 @@ var formatExecError2 = (error) => {
 };
 
 // src/cli.ts
-var VERSION3 = "0.1.1";
+var VERSION3 = "0.1.3";
 var printHelp = () => {
   console.log(`
-  ${chalk5.bold("vidra")} ${chalk5.dim(`v${VERSION3}`)}
+  ${chalk6.bold("vidra")} ${chalk6.dim(`v${VERSION3}`)}
 
-  ${chalk5.dim("Usage:")}
+  ${chalk6.dim("Usage:")}
     vidra <command> [options]
 
-  ${chalk5.dim("Commands:")}
+  ${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
 
-  ${chalk5.dim("Examples:")}
-    vidra dev                   ${chalk5.dim("# start Vite + native host")}
-    vidra dev --target windows  ${chalk5.dim("# run the Windows host")}
-    vidra build                 ${chalk5.dim("# auto-detect platform")}
-    vidra build --target macos  ${chalk5.dim("# macOS DMG")}
-    vidra build --verbose       ${chalk5.dim("# show full build output")}
+  ${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")}
 `);
 };
 var main = async () => {
@@ -754,6 +1010,9 @@ var main = async () => {
     case "build":
       await buildCommand(args.slice(1));
       break;
+    case "doctor":
+      process.exit(await runDoctor());
+      break;
     case "help":
     case "--help":
     case "-h":
@@ -765,13 +1024,13 @@ var main = async () => {
       console.log(VERSION3);
       break;
     default:
-      console.error(chalk5.red(`  Unknown command: ${command}
+      console.error(chalk6.red(`  Unknown command: ${command}
 `));
       printHelp();
       process.exit(1);
   }
 };
 main().catch((e) => {
-  console.error(chalk5.red(e.message));
+  console.error(chalk6.red(e.message));
   process.exit(1);
 });

package/dist/index.js

@@ -1,6 +1,6 @@
 // src/index.ts
-import prompts from "prompts";
-import chalk2 from "chalk";
+import prompts2 from "prompts";
+import chalk3 from "chalk";
 import fs2 from "fs-extra";
 import path2 from "path";
 import { randomUUID } from "crypto";
@@ -112,6 +112,140 @@ var applyReplacements = (str, replacements) => {
   return str;
 };
 
+// src/doctor.ts
+import { execFileSync } from "child_process";
+import prompts from "prompts";
+import chalk2 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 = execFileSync(cmd, args, {
+      encoding: "utf-8",
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    return { found: true, ok: true, stdout: stdout ?? "", stderr: "" };
+  } catch (e) {
+    const err = e;
+    return {
+      found: err.code !== "ENOENT",
+      ok: false,
+      stdout: bufToStr(err.stdout),
+      stderr: bufToStr(err.stderr)
+    };
+  }
+};
+var hasNet10Sdk = (listSdksOutput) => listSdksOutput.split(/\r?\n/).some((line) => /^10\./.test(line.trim()));
+var newestNet10Sdk = (listSdksOutput) => listSdksOutput.split(/\r?\n/).map((line) => line.trim().split(/\s+/)[0]).filter((v) => /^10\./.test(v)).sort(
+  (a, b) => a.localeCompare(b, void 0, { numeric: true, sensitivity: "base" })
+).pop();
+var outputMentionsMaui = (workloadListOutput) => /\bmaui\b/i.test(workloadListOutput);
+var checkDotnetSdk = () => {
+  const res = run(DOTNET, ["--list-sdks"]);
+  if (!res.found) {
+    return {
+      name: ".NET SDK",
+      status: "missing",
+      detail: "`dotnet` was not found on your PATH",
+      fix: "Install the .NET 10 SDK \u2014 https://dotnet.microsoft.com/download"
+    };
+  }
+  if (!res.ok && !res.stdout) {
+    return {
+      name: ".NET SDK",
+      status: "unknown",
+      detail: "could not run `dotnet --list-sdks`"
+    };
+  }
+  if (hasNet10Sdk(res.stdout)) {
+    const newest = newestNet10Sdk(res.stdout);
+    return {
+      name: ".NET SDK",
+      status: "ok",
+      detail: newest ? `found ${newest}` : "found 10.x"
+    };
+  }
+  return {
+    name: ".NET SDK",
+    status: "missing",
+    detail: "no 10.x SDK installed",
+    fix: "Install the .NET 10 SDK \u2014 https://dotnet.microsoft.com/download"
+  };
+};
+var isMauiWorkloadInstalled = () => outputMentionsMaui(run(DOTNET, ["workload", "list"]).stdout);
+var isInteractive = () => Boolean(process.stdin.isTTY && process.stdout.isTTY);
+var installWorkload = (csprojPath) => {
+  const args = csprojPath ? ["workload", "restore", csprojPath] : ["workload", "install", "maui"];
+  console.log();
+  console.log(`  ${chalk2.dim(`Running: ${DOTNET} ${args.join(" ")}`)}`);
+  console.log(
+    `  ${chalk2.dim(
+      "This can download several hundred MB and take a few minutes."
+    )}`
+  );
+  console.log();
+  try {
+    execFileSync(DOTNET, args, { stdio: "inherit" });
+    return true;
+  } catch {
+    console.error();
+    console.error(`  ${chalk2.red("Workload install failed.")}`);
+    console.error(
+      `  ${chalk2.dim(
+        "If this is a permissions error, your SDK is in a system location and needs elevation:"
+      )}`
+    );
+    console.error(`      ${chalk2.cyan("sudo dotnet workload install maui")}`);
+    console.error();
+    return false;
+  }
+};
+var ensureMauiWorkload = async (opts = {}) => {
+  const dotnet = checkDotnetSdk();
+  if (dotnet.status === "missing") {
+    console.log();
+    console.log(`  ${chalk2.yellow("!")} ${dotnet.name} \u2014 ${dotnet.detail}`);
+    if (dotnet.fix) {
+      console.log(`      ${chalk2.dim("fix:")} ${chalk2.cyan(dotnet.fix)}`);
+    }
+    return false;
+  }
+  if (dotnet.status === "unknown") return true;
+  if (isMauiWorkloadInstalled()) return true;
+  console.log();
+  console.log(
+    `  ${chalk2.yellow("!")} The .NET MAUI workload is required but not installed.`
+  );
+  const interactive = opts.interactive ?? isInteractive();
+  if (interactive) {
+    let install = false;
+    try {
+      const res = await prompts({
+        type: "confirm",
+        name: "install",
+        message: "Install the .NET MAUI workload now?",
+        initial: true
+      });
+      install = Boolean(res.install);
+    } catch {
+      install = false;
+    }
+    if (install) {
+      if (installWorkload(opts.csprojPath) && isMauiWorkloadInstalled()) {
+        console.log(`  ${chalk2.green("\u2713")} MAUI workload installed.`);
+        return true;
+      }
+      return false;
+    }
+  }
+  console.log(
+    `      ${chalk2.dim("run:")} ${chalk2.cyan("dotnet workload install maui")}`
+  );
+  console.log(`      ${chalk2.dim("docs:")} ${chalk2.cyan(MAUI_DOCS)}`);
+  return false;
+};
+
 // src/index.ts
 var __dirname = path2.dirname(fileURLToPath(import.meta.url));
 var CLI_ROOT = path2.resolve(__dirname, "..");
@@ -124,13 +258,13 @@ var VIDRA_VERSION = "0.1.0";
 var SDK_VERSION = "0.1.0";
 var main = async () => {
   console.log();
-  console.log(chalk2.bold("  create-vidra-app"));
-  console.log(chalk2.dim("  Scaffold a new Vidra application\n"));
+  console.log(chalk3.bold("  create-vidra-app"));
+  console.log(chalk3.dim("  Scaffold a new Vidra application\n"));
   const args = parseArgs(process.argv);
   let projectDir = args._[0];
   let appId = args["app-id"];
   if (!projectDir) {
-    const res = await prompts(
+    const res = await prompts2(
       {
         type: "text",
         name: "projectDir",
@@ -147,7 +281,7 @@ var main = async () => {
   const appTitle = toTitleCase(projectDir);
   const appGuid = randomUUID().toUpperCase();
   if (!appId) {
-    const res = await prompts(
+    const res = await prompts2(
       {
         type: "text",
         name: "appId",
@@ -162,7 +296,7 @@ var main = async () => {
   const root = path2.resolve(projectDir);
   if (fs2.existsSync(root) && fs2.readdirSync(root).length > 0) {
     console.error(
-      chalk2.red(
+      chalk3.red(
         `
   Directory "${projectDir}" already exists and is not empty.
 `
@@ -171,13 +305,13 @@ var main = async () => {
     process.exit(1);
   }
   console.log();
-  console.log(`  ${chalk2.dim("Project:")}    ${chalk2.cyan(projectName)}`);
-  console.log(`  ${chalk2.dim("Directory:")}  ${chalk2.cyan(root)}`);
-  console.log(`  ${chalk2.dim("App ID:")}     ${chalk2.cyan(appId)}`);
+  console.log(`  ${chalk3.dim("Project:")}    ${chalk3.cyan(projectName)}`);
+  console.log(`  ${chalk3.dim("Directory:")}  ${chalk3.cyan(root)}`);
+  console.log(`  ${chalk3.dim("App ID:")}     ${chalk3.cyan(appId)}`);
   console.log();
   const isMonorepo = fs2.existsSync(path2.join(LOCAL_SDK_DIR, "package.json"));
   const localFeedExists = isMonorepo && fs2.existsSync(LOCAL_FEED_DIR);
-  const localFeedPath = localFeedExists ? toTextPath(LOCAL_FEED_DIR) : "";
+  const localFeedSource = localFeedExists ? `    <add key="vidra-local" value="${toTextPath(LOCAL_FEED_DIR)}" />` : "";
   const cliRef = isMonorepo ? `file:${toTextPath(LOCAL_CLI_DIR)}` : `^${VIDRA_VERSION}`;
   const sdkRef = isMonorepo ? `file:${toTextPath(LOCAL_SDK_DIR)}` : `^${SDK_VERSION}`;
   const replacements = {
@@ -189,55 +323,69 @@ var main = async () => {
     "{{cliVersion}}": cliRef,
     "{{vidraVersion}}": VIDRA_VERSION,
     "{{sdkVersion}}": sdkRef,
-    "{{localFeedPath}}": localFeedPath
+    "{{localFeedSource}}": localFeedSource
   };
   const templateDir = path2.join(TEMPLATES_DIR, "react-vite");
   await scaffoldDir(templateDir, root, replacements);
-  console.log(chalk2.dim("  Creating solution..."));
+  console.log(chalk3.dim("  Creating solution..."));
   exec(`dotnet new sln -n ${projectName} --force`, root);
   const slnFile = fs2.existsSync(path2.join(root, `${projectName}.slnx`)) ? `${projectName}.slnx` : `${projectName}.sln`;
   exec(
     `dotnet sln ${slnFile} add src/${projectName}.Host/${projectName}.Host.csproj`,
     root
   );
-  console.log(chalk2.dim("  Installing npm dependencies..."));
+  console.log(chalk3.dim("  Installing npm dependencies..."));
   const uiDir = path2.join(root, "ui");
   const rootNpmOk = tryExec("npm install", root);
   const uiNpmOk = tryExec("npm install", uiDir);
   const npmOk = rootNpmOk && uiNpmOk;
   console.log();
-  console.log(chalk2.green("  Done! ") + "Your Vidra app is ready.\n");
+  console.log(chalk3.green("  Done! ") + "Your Vidra app is ready.\n");
   if (localFeedExists) {
     console.log(
-      chalk2.dim("  NuGet:") + " local feed \u2192 " + chalk2.cyan(LOCAL_FEED_DIR)
+      chalk3.dim("  NuGet:") + " local feed \u2192 " + chalk3.cyan(LOCAL_FEED_DIR)
     );
   } else if (isMonorepo) {
     console.log(
-      chalk2.yellow("  Note: ") + "Local NuGet feed not found. Run " + chalk2.cyan("./pack-local.sh") + " in the Vidra repo, then update NuGet.Config."
+      chalk3.yellow("  Note: ") + "Local NuGet feed not found. Run " + chalk3.cyan("./pack-local.sh") + " in the Vidra repo, then update NuGet.Config."
     );
   }
   if (isMonorepo) {
     console.log(
-      chalk2.dim("  npm:  ") + " @vidra-dev/sdk \u2192 " + chalk2.cyan(LOCAL_SDK_DIR)
+      chalk3.dim("  npm:  ") + " @vidra-dev/sdk \u2192 " + chalk3.cyan(LOCAL_SDK_DIR)
     );
     console.log(
-      chalk2.dim("  npm:  ") + " create-vidra-app \u2192 " + chalk2.cyan(LOCAL_CLI_DIR)
+      chalk3.dim("  npm:  ") + " create-vidra-app \u2192 " + chalk3.cyan(LOCAL_CLI_DIR)
     );
   }
   console.log();
   if (!npmOk) {
     console.log(
-      chalk2.yellow("  Note: ") + "`npm install` had errors. Re-run " + chalk2.cyan("npm install") + " in the project root and in " + chalk2.cyan("ui/") + " to retry.\n"
+      chalk3.yellow("  Note: ") + "`npm install` had errors. Re-run " + chalk3.cyan("npm install") + " in the project root and in " + chalk3.cyan("ui/") + " to retry.\n"
     );
   }
-  console.log(chalk2.bold("  Next steps:\n"));
+  const hostCsproj = path2.join(
+    root,
+    "src",
+    `${projectName}.Host`,
+    `${projectName}.Host.csproj`
+  );
+  const prereqsReady = await ensureMauiWorkload({ csprojPath: hostCsproj });
+  console.log(chalk3.bold("  Next steps:\n"));
   console.log(`    cd ${projectDir}`);
   console.log(
-    `    npm run dev  ${chalk2.dim("# starts Vite + MAUI host together")}`
+    `    npm run dev  ${chalk3.dim("# starts Vite + MAUI host together")}`
   );
+  if (!prereqsReady) {
+    console.log(
+      `    ${chalk3.dim("# tip: run")} ${chalk3.cyan(
+        "vidra doctor"
+      )} ${chalk3.dim("to verify your setup first")}`
+    );
+  }
   console.log();
 };
 main().catch((e) => {
-  console.error(chalk2.red(e.message));
+  console.error(chalk3.red(e.message));
   process.exit(1);
 });

package/package.json

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

package/templates/react-vite/NuGet.Config

@@ -3,6 +3,6 @@
   <packageSources>
     <clear />
     <add key="nuget.org" value="https://api.nuget.org/v3/index.json" />
-    <add key="vidra-local" value="{{localFeedPath}}" />
+{{localFeedSource}}
   </packageSources>
 </configuration>

package/templates/react-vite/README.md

@@ -6,9 +6,19 @@ A cross-platform application built with [Vidra](https://github.com/user/vidra)
 
 ### Prerequisites
 
-- [.NET 10 SDK](https://dotnet.microsoft.com/download) with MAUI workload
+- [.NET 10 SDK](https://dotnet.microsoft.com/download)
+- The .NET MAUI workload: `dotnet workload install maui`
 - [Node.js](https://nodejs.org/) 18+
-- Windows development must be run from a Windows machine with the MAUI Windows workload installed
+- macOS targets require Xcode; Windows targets must be built on Windows
+
+Not sure if you're set up? Run:
+
+```bash
+vidra doctor
+```
+
+It checks your .NET SDK, the MAUI workload, and (on macOS) Xcode, and prints the
+exact command to fix anything that's missing.
 
 ### Development