create-vidra-app 0.1.0

package/dist/cli.js

@@ -0,0 +1,777 @@
+// src/cli.ts
+import chalk5 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";
+
+// src/utils.ts
+var parseArgs = (argv) => {
+  const args = { _: [] };
+  for (let i = 2; i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg.startsWith("--")) {
+      const [key, val] = arg.slice(2).split("=");
+      args[key] = val ?? argv[++i] ?? true;
+    } else {
+      args._.push(arg);
+    }
+  }
+  return args;
+};
+
+// src/project.ts
+import path from "path";
+import fs from "fs-extra";
+import chalk from "chalk";
+var detectPlatform = () => {
+  switch (process.platform) {
+    case "darwin":
+      return "macos";
+    case "win32":
+      return "windows";
+    case "linux":
+      return "linux";
+    default:
+      return "macos";
+  }
+};
+var detectProject = (cwd) => {
+  let dir = cwd;
+  while (true) {
+    const uiDir = path.join(dir, "ui");
+    const srcDir = path.join(dir, "src");
+    const pkgJson = path.join(dir, "package.json");
+    if (fs.existsSync(pkgJson) && fs.existsSync(uiDir) && fs.existsSync(srcDir)) {
+      const csproj = findHostCsproj(srcDir);
+      if (csproj) {
+        const projectName = path.basename(csproj.dir).replace(/\.Host$/, "");
+        const displayVersion = readCsprojVersion(csproj.path);
+        return {
+          root: dir,
+          hostDir: csproj.dir,
+          csprojPath: csproj.path,
+          projectName,
+          displayVersion,
+          uiDir
+        };
+      }
+    }
+    const parent = path.dirname(dir);
+    if (parent === dir) break;
+    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"
+    )
+  );
+  process.exit(1);
+};
+var findHostCsproj = (srcDir) => {
+  if (!fs.existsSync(srcDir)) return null;
+  for (const entry of fs.readdirSync(srcDir, { withFileTypes: true })) {
+    if (entry.isDirectory() && entry.name.endsWith(".Host")) {
+      const csprojPath = path.join(
+        srcDir,
+        entry.name,
+        `${entry.name}.csproj`
+      );
+      if (fs.existsSync(csprojPath)) {
+        return { dir: path.join(srcDir, entry.name), path: csprojPath };
+      }
+    }
+  }
+  return null;
+};
+var readCsprojVersion = (csprojPath) => {
+  const content = fs.readFileSync(csprojPath, "utf-8");
+  const match = content.match(
+    /<ApplicationDisplayVersion>(.*?)<\/ApplicationDisplayVersion>/
+  );
+  return match?.[1] ?? "0.1.0";
+};
+
+// src/targets/macos.ts
+import path2 from "path";
+import fs2 from "fs-extra";
+import { execSync } from "child_process";
+import os from "os";
+var macosTarget = {
+  name: "macos",
+  framework: "net10.0-maccatalyst",
+  extraPublishArgs: "-p:CreatePackage=false",
+  findBundle(publishDir, _projectName) {
+    if (!fs2.existsSync(publishDir)) return null;
+    for (const entry of fs2.readdirSync(publishDir, { withFileTypes: true })) {
+      if (entry.name.endsWith(".app") && entry.isDirectory()) {
+        return path2.join(publishDir, entry.name);
+      }
+    }
+    return null;
+  },
+  async package(appPath, outputDir, meta) {
+    const dmgName = `${meta.projectName}-${meta.displayVersion}-macos.dmg`;
+    const dmgPath = path2.join(outputDir, dmgName);
+    const volName = meta.projectName;
+    const staging = fs2.mkdtempSync(path2.join(os.tmpdir(), "vidra-dmg-"));
+    try {
+      fs2.copySync(appPath, path2.join(staging, path2.basename(appPath)));
+      fs2.symlinkSync("/Applications", path2.join(staging, "Applications"));
+      if (fs2.existsSync(dmgPath)) {
+        fs2.removeSync(dmgPath);
+      }
+      execSync(
+        `hdiutil create -volname "${volName}" -srcfolder "${staging}" -ov -format UDZO "${dmgPath}"`,
+        { stdio: "pipe" }
+      );
+    } finally {
+      fs2.removeSync(staging);
+    }
+    return dmgPath;
+  }
+};
+
+// 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;
+  }
+  try {
+    execFileSync(
+      "codesign",
+      ["--force", "--deep", "--sign", codesignIdentity, appBundle],
+      {
+        stdio: options.verbose ? "inherit" : "pipe"
+      }
+    );
+    options.log(
+      `  ${chalk2.dim("Signing:")}  ${chalk2.cyan(path3.basename(appBundle))} ${chalk2.dim(`with ${codesignIdentity}`)}`
+    );
+  } catch (error) {
+    options.warn(
+      chalk2.yellow(
+        "  Failed to re-sign the macOS app bundle. It may remain ad-hoc signed."
+      )
+    );
+    options.warn(chalk2.dim(formatExecError(error)));
+  }
+};
+var resolveMacCodeSigningIdentity = () => {
+  const override = process.env.VIDRA_MACOS_CODESIGN_KEY?.trim();
+  if (override) {
+    return override;
+  }
+  try {
+    const output = execFileSync(
+      "security",
+      ["find-identity", "-v", "-p", "codesigning"],
+      {
+        stdio: ["ignore", "pipe", "pipe"],
+        encoding: "utf8"
+      }
+    );
+    const identities = output.split(/\r?\n/).map((line) => line.match(/"([^"]+)"/)?.[1] ?? null).filter((value) => value !== null);
+    return identities.find((identity) => identity.startsWith("Apple Development:")) ?? identities.find((identity) => identity.startsWith("Developer ID Application:")) ?? null;
+  } catch {
+    return null;
+  }
+};
+var formatExecError = (error) => {
+  const err = error;
+  if (Buffer.isBuffer(err.stderr)) {
+    return err.stderr.toString();
+  }
+  if (typeof err.stderr === "string") {
+    return err.stderr;
+  }
+  return err.message ?? String(error);
+};
+
+// src/targets/windows.ts
+import path4 from "path";
+import fs3 from "fs-extra";
+var windowsTarget = {
+  name: "windows",
+  framework: "net10.0-windows10.0.19041.0",
+  extraPublishArgs: "-p:RuntimeIdentifierOverride=win-x64 -p:WindowsPackageType=MSIX",
+  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;
+  },
+  async package(msixPath, outputDir, meta) {
+    const outName = `${meta.projectName}-${meta.displayVersion}-windows.msix`;
+    const outPath = path4.join(outputDir, outName);
+    fs3.copySync(msixPath, outPath, { overwrite: true });
+    return outPath;
+  }
+};
+
+// src/commands/build.ts
+var VERSION = "0.1.0";
+var TARGETS = {
+  macos: macosTarget,
+  windows: windowsTarget
+};
+var buildCommand = async (argv) => {
+  const args = parseArgs(["_", "_", ...argv]);
+  const verbose = !!args["verbose"];
+  const targetName = args["target"] || detectPlatform();
+  console.log();
+  console.log(
+    `  ${chalk3.bold.cyan("vidra build")} ${chalk3.dim(`v${VERSION}`)}`
+  );
+  console.log();
+  const target = TARGETS[targetName];
+  if (!target) {
+    const supported = Object.keys(TARGETS).join(", ");
+    console.error(
+      chalk3.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();
+  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}`)
+    );
+    process.exit(1);
+  }
+  console.log(
+    `  ${chalk3.dim("Bundle:")}   ${chalk3.cyan(path5.basename(bundlePath))}`
+  );
+  if (target.name === "macos") {
+    signMacAppBundleIfPossible(bundlePath, {
+      verbose,
+      log: console.log,
+      warn: console.warn
+    });
+  }
+  const outputDir = path5.join(project.root, "dist");
+  fs4.ensureDirSync(outputDir);
+  console.log();
+  console.log(`  ${chalk3.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(chalk3.red(`  Packaging failed.`));
+    console.error(chalk3.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)`)}`
+  );
+  console.log();
+  console.log(
+    `  ${chalk3.green("Done!")} Output: ${chalk3.cyan(path5.relative(project.root, outputPath))}`
+  );
+  console.log();
+};
+var stepBuildUi = (project, verbose) => {
+  console.log(`  ${chalk3.dim("Building UI...")}`);
+  const start = Date.now();
+  try {
+    execSync2("npm run build", {
+      cwd: project.uiDir,
+      stdio: verbose ? "inherit" : "pipe"
+    });
+  } catch (e) {
+    const err = e;
+    console.error(chalk3.red("  Vite build failed."));
+    console.error(chalk3.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();
+};
+var stepCopyAssets = (project) => {
+  console.log(`  ${chalk3.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.`));
+    process.exit(1);
+  }
+  const wwwroot = path5.join(project.hostDir, "Resources", "Raw", "wwwroot");
+  fs4.removeSync(wwwroot);
+  fs4.copySync(viteDist, wwwroot);
+  const fileCount = countFiles(wwwroot);
+  console.log(
+    `  ${chalk3.green(">")} ${fileCount} files -> ${chalk3.dim("Resources/Raw/wwwroot/")}`
+  );
+  console.log();
+};
+var countFiles = (dir) => {
+  let count = 0;
+  for (const entry of fs4.readdirSync(dir, { withFileTypes: true })) {
+    if (entry.isDirectory()) {
+      count += countFiles(path5.join(dir, entry.name));
+    } else {
+      count++;
+    }
+  }
+  return count;
+};
+var stepDotnetPublish = (project, target, verbose) => {
+  console.log(
+    `  ${chalk3.dim(`Publishing .NET host (${target.framework})...`)}`
+  );
+  const start = Date.now();
+  const extraArgs = target.extraPublishArgs ?? "-p:CreatePackage=false";
+  try {
+    execSync2(
+      `dotnet publish "${project.csprojPath}" -c Release -f ${target.framework} ${extraArgs}`,
+      {
+        cwd: project.root,
+        stdio: verbose ? "inherit" : "pipe"
+      }
+    );
+  } catch (e) {
+    const err = e;
+    console.error(chalk3.red("  dotnet publish failed."));
+    console.error(chalk3.dim(err.stderr?.toString() || err.message));
+    process.exit(1);
+  }
+  const elapsed = ((Date.now() - start) / 1e3).toFixed(1);
+  console.log(
+    `  ${chalk3.green(">")} dotnet publish complete ${chalk3.dim(`(${elapsed}s)`)}`
+  );
+  const publishDir = path5.join(
+    project.hostDir,
+    "bin",
+    "Release",
+    target.framework
+  );
+  return publishDir;
+};
+
+// src/commands/dev.ts
+import path6 from "path";
+import fs5 from "fs-extra";
+import { execFileSync as execFileSync2, spawn } from "child_process";
+import { request } from "http";
+import chalk4 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";
+var DOTNET_COMMAND = process.platform === "win32" ? "dotnet.exe" : "dotnet";
+var TARGETS2 = {
+  macos: {
+    name: "macos",
+    framework: "net10.0-maccatalyst"
+  },
+  windows: {
+    name: "windows",
+    framework: "net10.0-windows10.0.19041.0"
+  }
+};
+var devCommand = async (argv) => {
+  const args = parseArgs(["_", "_", ...argv]);
+  const targetName = args["target"] || detectPlatform();
+  const verbose = !!args["verbose"];
+  const viteUrl = process.env.VIDRA_DEV_URL || "http://localhost:5173";
+  const target = TARGETS2[targetName];
+  if (!target) {
+    const supported = Object.keys(TARGETS2).join(", ");
+    console.error(
+      chalk4.red(
+        `  Unsupported target: ${targetName}. Supported: ${supported}`
+      )
+    );
+    process.exit(1);
+  }
+  ensureTargetMatchesHostOs(target.name);
+  const project = detectProject(process.cwd());
+  const session = new DevSession(project, target, viteUrl, verbose);
+  await session.run();
+};
+var DevSession = class {
+  constructor(project, target, viteUrl, verbose) {
+    this.project = project;
+    this.target = target;
+    this.viteUrl = viteUrl;
+    this.verbose = verbose;
+  }
+  project;
+  target;
+  viteUrl;
+  verbose;
+  children = [];
+  buildConfig = process.env.VIDRA_BUILD_CONFIG || "Debug";
+  shuttingDown = false;
+  async run() {
+    this.installSignalHandlers();
+    console.log();
+    console.log(`  ${chalk4.bold.cyan("vidra dev")} ${chalk4.dim(`v${VERSION2}`)}`);
+    console.log();
+    console.log(`  ${chalk4.dim("Project:")}  ${chalk4.cyan(this.project.projectName)}`);
+    console.log(
+      `  ${chalk4.dim("Target:")}   ${chalk4.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(
+        chalk4.red(
+          `  ${error.message}`
+        )
+      );
+      this.shutdown(1);
+    }
+    console.log(`  ${chalk4.dim("Vite:")}     ${chalk4.cyan(this.viteUrl)}`);
+    console.log();
+    const host = this.target.name === "macos" ? this.launchMacosHost() : this.launchWindowsHost();
+    await waitForExit(vite, host);
+  }
+  installSignalHandlers() {
+    process.on("SIGINT", () => {
+      console.log("\n\x1B[90m[vidra]\x1B[0m Shutting down...");
+      this.shutdown(0);
+    });
+    process.on("SIGTERM", () => {
+      this.shutdown(0);
+    });
+  }
+  startVite() {
+    console.log(`  ${chalk4.dim("Starting Vite dev server...")}`);
+    const vite = spawn(NPM_COMMAND, ["run", "dev"], {
+      cwd: this.project.uiDir,
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    return this.registerChild(vite, "ui", "Vite dev server");
+  }
+  launchMacosHost() {
+    console.log(
+      `  ${chalk4.dim(`Building MAUI host (${this.target.framework})...`)}`
+    );
+    try {
+      execFileSync2(
+        DOTNET_COMMAND,
+        [
+          "build",
+          "-c",
+          this.buildConfig,
+          "-f",
+          this.target.framework,
+          this.project.csprojPath
+        ],
+        {
+          cwd: this.project.root,
+          stdio: this.verbose ? "inherit" : "pipe"
+        }
+      );
+    } catch (error) {
+      console.error(chalk4.red("  MAUI build failed."));
+      console.error(chalk4.dim(formatExecError2(error)));
+      process.exit(1);
+    }
+    const appBundle = findMacAppBundle(
+      this.project.hostDir,
+      this.target.framework,
+      this.buildConfig
+    );
+    if (!appBundle) {
+      console.error(
+        chalk4.red(
+          `  Could not find .app bundle in ${path6.join(this.project.hostDir, "bin", this.buildConfig, this.target.framework)}`
+        )
+      );
+      process.exit(1);
+    }
+    signMacAppBundleIfPossible(appBundle, {
+      verbose: this.verbose,
+      log: console.log,
+      warn: console.warn
+    });
+    const binary = findMacExecutable(appBundle);
+    if (!binary) {
+      console.error(
+        chalk4.red(`  Could not find the app executable in ${appBundle}.`)
+      );
+      process.exit(1);
+    }
+    console.log(`  ${chalk4.dim("Launching host...")}`);
+    const host = spawn(binary, [], {
+      cwd: this.project.root,
+      stdio: ["ignore", "pipe", "pipe"],
+      env: { ...process.env, VIDRA_DEV_URL: this.viteUrl }
+    });
+    return this.registerChild(host, "host", path6.basename(binary));
+  }
+  launchWindowsHost() {
+    console.log(`  ${chalk4.dim("Launching host...")}`);
+    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 }
+      }
+    );
+    return this.registerChild(host, "host", "MAUI host");
+  }
+  registerChild(child, tag, label) {
+    this.children.push(child);
+    prefixStream(child.stdout, tag);
+    prefixStream(child.stderr, tag);
+    child.on("exit", (code) => {
+      if (this.shuttingDown) return;
+      if (tag === "ui") {
+        const exitCode = code ?? 1;
+        console.error(
+          chalk4.red(`
+  ${label} exited with code ${exitCode}.`)
+        );
+        this.shutdown(exitCode);
+        return;
+      }
+      if (code !== null && code !== 0) {
+        console.error(chalk4.red(`
+  ${label} exited with code ${code}.`));
+      }
+      this.shutdown(code ?? 0);
+    });
+    child.on("error", (error) => {
+      if (this.shuttingDown) return;
+      console.error(chalk4.red(`
+  Failed to start ${label}: ${error.message}`));
+      this.shutdown(1);
+    });
+    return child;
+  }
+  shutdown(exitCode) {
+    if (this.shuttingDown) return;
+    this.shuttingDown = true;
+    for (const child of this.children) {
+      killChild(child);
+    }
+    process.exit(exitCode);
+  }
+};
+var ensureTargetMatchesHostOs = (targetName) => {
+  if (targetName === "macos" && process.platform !== "darwin") {
+    console.error(chalk4.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.")
+    );
+    process.exit(1);
+  }
+};
+var prefixStream = (stream, tag) => {
+  if (!stream) return;
+  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}
+`);
+      }
+    }
+  });
+};
+var waitForServer = (url, timeoutMs) => {
+  const { hostname, port, pathname } = new URL(url);
+  const start = Date.now();
+  return new Promise((resolve, reject) => {
+    const poll = () => {
+      if (Date.now() - start > timeoutMs) {
+        reject(
+          new Error(`Timed out waiting for ${url} after ${timeoutMs}ms`)
+        );
+        return;
+      }
+      const req = request(
+        {
+          hostname,
+          port,
+          path: pathname,
+          method: "HEAD",
+          timeout: 1e3
+        },
+        () => resolve()
+      );
+      req.on("error", () => setTimeout(poll, POLL_INTERVAL_MS));
+      req.on("timeout", () => {
+        req.destroy();
+        setTimeout(poll, POLL_INTERVAL_MS);
+      });
+      req.end();
+    };
+    poll();
+  });
+};
+var waitForExit = (vite, host) => {
+  return new Promise((resolve) => {
+    const resolveOnce = () => resolve();
+    vite.once("exit", resolveOnce);
+    host.once("exit", resolveOnce);
+  });
+};
+var findMacAppBundle = (hostDir, framework, buildConfig) => {
+  const outputDir = path6.join(hostDir, "bin", buildConfig, framework);
+  return findAppBundleRecursive(outputDir);
+};
+var findAppBundleRecursive = (dir) => {
+  if (!fs5.existsSync(dir)) return null;
+  for (const entry of fs5.readdirSync(dir, { withFileTypes: true })) {
+    const fullPath = path6.join(dir, entry.name);
+    if (entry.isDirectory() && entry.name.endsWith(".app")) {
+      return fullPath;
+    }
+    if (entry.isDirectory()) {
+      const nested = findAppBundleRecursive(fullPath);
+      if (nested) return nested;
+    }
+  }
+  return null;
+};
+var findMacExecutable = (appBundle) => {
+  const macOsDir = path6.join(appBundle, "Contents", "MacOS");
+  if (!fs5.existsSync(macOsDir)) return null;
+  for (const entry of fs5.readdirSync(macOsDir, { withFileTypes: true })) {
+    if (entry.isFile()) {
+      return path6.join(macOsDir, entry.name);
+    }
+  }
+  return null;
+};
+var killChild = (child) => {
+  if (!child.pid || child.exitCode !== null) return;
+  if (process.platform === "win32") {
+    try {
+      execFileSync2("taskkill", ["/PID", String(child.pid), "/T", "/F"], {
+        stdio: "ignore"
+      });
+    } catch {
+      child.kill();
+    }
+    return;
+  }
+  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;
+};
+
+// src/cli.ts
+var VERSION3 = "0.1.0";
+var printHelp = () => {
+  console.log(`
+  ${chalk5.bold("vidra")} ${chalk5.dim(`v${VERSION3}`)}
+
+  ${chalk5.dim("Usage:")}
+    vidra <command> [options]
+
+  ${chalk5.dim("Commands:")}
+    dev     Start the development environment
+    build   Build and package the application for distribution
+    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")}
+`);
+};
+var main = async () => {
+  const args = process.argv.slice(2);
+  const command = args[0];
+  switch (command) {
+    case "dev":
+      await devCommand(args.slice(1));
+      break;
+    case "build":
+      await buildCommand(args.slice(1));
+      break;
+    case "help":
+    case "--help":
+    case "-h":
+    case void 0:
+      printHelp();
+      break;
+    case "--version":
+    case "-v":
+      console.log(VERSION3);
+      break;
+    default:
+      console.error(chalk5.red(`  Unknown command: ${command}
+`));
+      printHelp();
+      process.exit(1);
+  }
+};
+main().catch((e) => {
+  console.error(chalk5.red(e.message));
+  process.exit(1);
+});