create-vidra-app 0.1.6 → 0.1.8

package/README.md

@@ -20,13 +20,16 @@ cd my-app
 npm run dev   # starts Vite + the native host together
 ```
 
-This package also installs the `vidra` CLI used by scaffolded apps:
+Scaffolded apps get the `vidra` CLI as a local dev dependency — there's no
+global `vidra` to install. Run it from inside your project via the npm scripts
+or `npx`:
 
 ```bash
-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
+npm run dev                     # start Vite + native host
+npm run build                   # build + package for distribution
+npm run doctor                  # check your .NET / MAUI / Xcode setup
+npx vidra dev --target windows  # run a specific desktop target
+npx vidra build --target macos  # build + package a macOS .dmg
 ```
 
 ## Prerequisites
@@ -38,7 +41,7 @@ vidra doctor                # check your .NET / MAUI / Xcode setup
 
 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`.
+`npm run doctor`.
 
 ## License
 

package/dist/cli.js

@@ -304,44 +304,74 @@ var formatExecError = (error) => {
 
 // src/targets/windows.ts
 import path4 from "path";
+import os2 from "os";
 import fs3 from "fs-extra";
+import { execFileSync as execFileSync2 } from "child_process";
 var windowsTarget = {
   name: "windows",
   framework: "net10.0-windows10.0.19041.0",
-  extraPublishArgs: "-p:RuntimeIdentifierOverride=win-x64 -p:WindowsPackageType=MSIX",
+  // `RuntimeIdentifierOverride` (rather than `-r`/`RuntimeIdentifier`) is the
+  // MAUI-recommended way to set the Windows RID — it sidesteps WindowsAppSDK
+  // issue #3337, which otherwise pulls in the wrong packaging assets.
+  extraPublishArgs: "-p:WindowsPackageType=None -p:SelfContained=true -p:WindowsAppSDKSelfContained=true -p:RuntimeIdentifierOverride=win-x64",
   findBundle(publishDir, _projectName) {
-    const appPackagesDir = path4.join(publishDir, "win-x64", "AppPackages");
-    if (!fs3.existsSync(appPackagesDir)) return null;
-    for (const entry of fs3.readdirSync(appPackagesDir, {
-      withFileTypes: true
-    })) {
-      if (!entry.isDirectory()) continue;
-      const subDir = path4.join(appPackagesDir, entry.name);
-      for (const file of fs3.readdirSync(subDir)) {
-        if (file.endsWith(".msix")) {
-          return path4.join(subDir, file);
-        }
-      }
-    }
-    return null;
+    const preferred = path4.join(publishDir, "win-x64", "publish");
+    if (dirContainsExe(preferred)) return preferred;
+    return findDirWithExe(publishDir);
   },
-  async package(msixPath, outputDir, meta) {
-    const outName = `${meta.projectName}-${meta.displayVersion}-windows.msix`;
+  async package(publishOutputDir, outputDir, meta) {
+    const outName = `${meta.projectName}-${meta.displayVersion}-windows.zip`;
     const outPath = path4.join(outputDir, outName);
-    fs3.copySync(msixPath, outPath, { overwrite: true });
+    if (fs3.existsSync(outPath)) fs3.removeSync(outPath);
+    const staging = fs3.mkdtempSync(path4.join(os2.tmpdir(), "vidra-zip-"));
+    const stagedApp = path4.join(staging, meta.projectName);
+    try {
+      fs3.copySync(publishOutputDir, stagedApp);
+      execFileSync2(
+        "powershell",
+        [
+          "-NoProfile",
+          "-NonInteractive",
+          "-Command",
+          `Compress-Archive -Path "${stagedApp}" -DestinationPath "${outPath}" -Force`
+        ],
+        { stdio: "pipe" }
+      );
+    } finally {
+      fs3.removeSync(staging);
+    }
     return outPath;
   }
 };
+var dirContainsExe = (dir) => fs3.existsSync(dir) && fs3.readdirSync(dir, { withFileTypes: true }).some((e) => e.isFile() && e.name.toLowerCase().endsWith(".exe"));
+var findDirWithExe = (root) => {
+  if (!fs3.existsSync(root)) return null;
+  let fallback = null;
+  const walk = (dir) => {
+    if (dirContainsExe(dir)) {
+      if (path4.basename(dir) === "publish") return dir;
+      fallback ??= dir;
+    }
+    for (const e of fs3.readdirSync(dir, { withFileTypes: true })) {
+      if (e.isDirectory()) {
+        const found = walk(path4.join(dir, e.name));
+        if (found) return found;
+      }
+    }
+    return null;
+  };
+  return walk(root) ?? fallback;
+};
 
 // src/doctor.ts
-import { execFileSync as execFileSync2 } from "child_process";
+import { execFileSync as execFileSync3 } from "child_process";
 import prompts from "prompts";
 var DOTNET = process.platform === "win32" ? "dotnet.exe" : "dotnet";
 var MAUI_DOCS = "https://learn.microsoft.com/dotnet/maui/get-started/installation";
 var bufToStr = (v) => v == null ? "" : Buffer.isBuffer(v) ? v.toString() : v;
 var run = (cmd, args) => {
   try {
-    const stdout = execFileSync2(cmd, args, {
+    const stdout = execFileSync3(cmd, args, {
       encoding: "utf-8",
       stdio: ["ignore", "pipe", "pipe"]
     });
@@ -497,7 +527,7 @@ var runDoctor = async () => {
     console.log(
       footer(
         `${dim("all checks passed \u2014 you're ready to run")} ${lime(
-          "vidra dev"
+          "npm run dev"
         )}${dim(".")}`
       )
     );
@@ -509,7 +539,7 @@ var runDoctor = async () => {
     footer(
       `${dim(
         `${n} issue${n === 1 ? "" : "s"} found. apply the ${n === 1 ? "fix" : "fixes"} above, then re-run`
-      )} ${lime("vidra doctor")}${dim(".")}`
+      )} ${lime("npm run doctor")}${dim(".")}`
     )
   );
   console.log();
@@ -531,7 +561,7 @@ var installWorkload = (csprojPath) => {
   );
   console.log();
   try {
-    execFileSync2(DOTNET, args, { stdio: "inherit" });
+    execFileSync3(DOTNET, args, { stdio: "inherit" });
     return true;
   } catch {
     console.error();
@@ -639,8 +669,8 @@ 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 packageLabel = (target) => target.name === "macos" ? "package DMG" : "package ZIP";
+var artifactName = (project, target) => `${project.projectName}-${project.displayVersion}-${target.name}.${target.name === "macos" ? "dmg" : "zip"}`;
 var buildCommand = async (argv) => {
   const args = parseArgs(["_", "_", ...argv]);
   const verbose = !!args["verbose"];
@@ -761,9 +791,9 @@ var printBuildPlan = (project, target) => {
     console.log(
       row({
         glyph: "active",
-        label: "package MSIX",
+        label: "package ZIP",
         labelWidth: STEP_LABEL_WIDTH,
-        detail: `${dim("\u2192")} ${value(artifactName(project, target))}`
+        detail: `${dim("self-contained \u2192")} ${value(artifactName(project, target))}`
       })
     );
   }
@@ -912,7 +942,7 @@ var stepPackage = async (project, target, bundlePath) => {
 // src/commands/dev.ts
 import path6 from "path";
 import fs5 from "fs-extra";
-import { execFileSync as execFileSync3, spawn } from "child_process";
+import { execFileSync as execFileSync4, spawn } from "child_process";
 import { request } from "http";
 var POLL_INTERVAL_MS = 500;
 var POLL_TIMEOUT_MS = 3e4;
@@ -1037,11 +1067,16 @@ var DevSession = class {
     console.log(taggedRow("active", "ui", dim("starting dev server\u2026")));
     const vite = spawn(NPM_COMMAND, ["run", "dev"], {
       cwd: this.project.uiDir,
-      stdio: ["ignore", "pipe", "pipe"]
+      stdio: ["ignore", "pipe", "pipe"],
+      shell: process.platform === "win32"
     });
     return this.registerChild(vite, "ui", "Vite dev server");
   }
-  launchMacosHost() {
+  // Builds the MAUI host as a discrete step (a plain `dotnet build`, never
+  // MSBuild's `-t:Run`) so the per-OS launch paths can spawn the produced
+  // binary directly. `-t:Run` shells out in ways that break for both locally
+  // signed mac apps and unpackaged Windows apps (see the call sites).
+  buildHostSync() {
     console.log(
       taggedRow(
         "active",
@@ -1050,7 +1085,7 @@ var DevSession = class {
       )
     );
     try {
-      execFileSync3(
+      execFileSync4(
         DOTNET_COMMAND,
         [
           "build",
@@ -1076,6 +1111,9 @@ var DevSession = class {
       }
       process.exit(1);
     }
+  }
+  launchMacosHost() {
+    this.buildHostSync();
     const appBundle = findMacAppBundle(
       this.project.hostDir,
       this.target.framework,
@@ -1117,26 +1155,42 @@ var DevSession = class {
     });
     return this.registerChild(host, "host", path6.basename(binary));
   }
+  // Build first, then spawn the produced .exe directly. A single
+  // `dotnet build -t:Run` on an unpackaged MAUI Windows app
+  // (`WindowsPackageType=None`) execs the binary before the WindowsAppSDK
+  // native assets are laid out beside it, so the app can't resolve its deps and
+  // dies with a bare `MSB3073 ... exited with code 3` (ERROR_PATH_NOT_FOUND —
+  // "The system cannot find the path specified"). Building as a discrete step
+  // and then launching the binary is the documented workaround.
+  // See dotnet/maui#13942 and dotnet/maui#5975.
   launchWindowsHost() {
-    console.log(taggedRow("active", "host", dim("launching\u2026")));
-    const host = spawn(
-      DOTNET_COMMAND,
-      [
-        "build",
-        "-t:Run",
-        "-c",
-        this.buildConfig,
-        "-f",
-        this.target.framework,
-        this.project.csprojPath
-      ],
-      {
-        cwd: this.project.root,
-        stdio: ["ignore", "pipe", "pipe"],
-        env: { ...process.env, VIDRA_DEV_URL: this.viteUrl }
-      }
+    this.buildHostSync();
+    const exe = findWindowsExecutable(
+      this.project.hostDir,
+      this.project.csprojPath,
+      this.target.framework,
+      this.buildConfig
+    );
+    if (!exe) {
+      console.error(
+        row({
+          glyph: "error",
+          detail: dim(
+            `could not find the host .exe under ${path6.join(this.project.hostDir, "bin", this.buildConfig, this.target.framework)}`
+          )
+        })
+      );
+      process.exit(1);
+    }
+    console.log(
+      taggedRow("done", "host", `${dim("launched")} ${value(path6.basename(exe))}`)
     );
-    return this.registerChild(host, "host", "MAUI host");
+    const host = spawn(exe, [], {
+      cwd: path6.dirname(exe),
+      stdio: ["ignore", "pipe", "pipe"],
+      env: { ...process.env, VIDRA_DEV_URL: this.viteUrl }
+    });
+    return this.registerChild(host, "host", path6.basename(exe));
   }
   registerChild(child, tag2, label) {
     this.children.push(child);
@@ -1283,11 +1337,36 @@ var findMacExecutable = (appBundle) => {
   }
   return null;
 };
+var findWindowsExecutable = (hostDir, csprojPath, framework, buildConfig) => {
+  const outputDir = path6.join(hostDir, "bin", buildConfig, framework);
+  if (!fs5.existsSync(outputDir)) return null;
+  const exeName = `${path6.basename(csprojPath, ".csproj")}.exe`.toLowerCase();
+  return findFileRecursive(outputDir, (name) => name.toLowerCase() === exeName) ?? findFileRecursive(
+    outputDir,
+    (name) => name.toLowerCase().endsWith(".host.exe")
+  ) ?? findFileRecursive(outputDir, (name) => name.toLowerCase().endsWith(".exe"));
+};
+var findFileRecursive = (dir, match) => {
+  if (!fs5.existsSync(dir)) return null;
+  const entries = fs5.readdirSync(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (entry.isFile() && match(entry.name)) {
+      return path6.join(dir, entry.name);
+    }
+  }
+  for (const entry of entries) {
+    if (entry.isDirectory()) {
+      const found = findFileRecursive(path6.join(dir, entry.name), match);
+      if (found) return found;
+    }
+  }
+  return null;
+};
 var killChild = (child) => {
   if (!child.pid || child.exitCode !== null) return;
   if (process.platform === "win32") {
     try {
-      execFileSync3("taskkill", ["/PID", String(child.pid), "/T", "/F"], {
+      execFileSync4("taskkill", ["/PID", String(child.pid), "/T", "/F"], {
         stdio: "ignore"
       });
     } catch {

package/dist/index.js

@@ -468,7 +468,7 @@ var main = async () => {
   );
   if (!prereqsReady) {
     console.log(
-      `    ${dim("tip: run")} ${lime("vidra doctor")} ${dim("to verify your setup first")}`
+      `    ${dim("tip: run")} ${lime("npm run doctor")} ${dim("to verify your setup first")}`
     );
   }
   console.log();

package/package.json

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

package/templates/react-vite/README.md

@@ -14,12 +14,16 @@ A cross-platform application built with [Vidra](https://github.com/user/vidra)
 Not sure if you're set up? Run:
 
 ```bash
-vidra doctor
+npm run doctor
 ```
 
 It checks your .NET SDK, the MAUI workload, and (on macOS) Xcode, and prints the
 exact command to fix anything that's missing.
 
+> The `vidra` CLI ships as a local dev dependency of this project, so run it
+> through npm (`npm run dev`, `npm run doctor`) or with `npx vidra <command>` —
+> there is no global `vidra` command to install.
+
 ### Development
 
 ```bash
@@ -31,8 +35,8 @@ This starts the Vite dev server and launches the native host for the current OS.
 To target a specific desktop platform explicitly:
 
 ```bash
-vidra dev --target macos
-vidra dev --target windows
+npx vidra dev --target macos
+npx vidra dev --target windows
 ```
 
 If you want to run the pieces separately:

package/templates/react-vite/package.json

@@ -6,7 +6,8 @@
     "dev": "vidra dev",
     "dev:ui": "npm run dev --prefix ui",
     "dev:host:macos": "vidra run --target macos",
-    "dev:host:windows": "vidra run --target windows"
+    "dev:host:windows": "vidra run --target windows",
+    "doctor": "vidra doctor"
   },
   "devDependencies": {
     "create-vidra-app": "{{cliVersion}}"