@thelacanians/vue-native-cli 0.4.14 → 0.6.0

package/dist/cli.js

@@ -3,29 +3,356 @@
 // src/cli.ts
 import { program } from "commander";
 
-// src/commands/create.ts
+// src/commands/build.ts
 import { Command } from "commander";
+import { spawn, execSync } from "child_process";
+import { existsSync, readdirSync, mkdirSync, copyFileSync } from "fs";
+import { join, basename } from "path";
+import pc from "picocolors";
+function findXcodeProject(iosDir) {
+  if (!existsSync(iosDir)) return null;
+  for (const ext of [".xcworkspace", ".xcodeproj"]) {
+    try {
+      const entries = readdirSync(iosDir);
+      const match = entries.find((e) => e.endsWith(ext));
+      if (match) {
+        return {
+          path: join(iosDir, match),
+          isWorkspace: ext === ".xcworkspace"
+        };
+      }
+    } catch {
+    }
+  }
+  return null;
+}
+function findReleaseApk(androidDir) {
+  const apkDir = join(androidDir, "app", "build", "outputs", "apk", "release");
+  if (existsSync(apkDir)) {
+    try {
+      const entries = readdirSync(apkDir);
+      const apk = entries.find((e) => e.endsWith(".apk") && !e.includes("androidTest"));
+      if (apk) {
+        return join(apkDir, apk);
+      }
+    } catch {
+    }
+  }
+  return null;
+}
+function findReleaseAab(androidDir) {
+  const aabDir = join(androidDir, "app", "build", "outputs", "bundle", "release");
+  if (existsSync(aabDir)) {
+    try {
+      const entries = readdirSync(aabDir);
+      const aab = entries.find((e) => e.endsWith(".aab"));
+      if (aab) {
+        return join(aabDir, aab);
+      }
+    } catch {
+    }
+  }
+  return null;
+}
+function ensureOutputDir(outputPath) {
+  if (!existsSync(outputPath)) {
+    mkdirSync(outputPath, { recursive: true });
+  }
+}
+var buildCommand = new Command("build").description("Create a release build of the app").argument("<platform>", "platform to build for (ios, android, macos)").option("--mode <mode>", "build mode", "release").option("--output <path>", "output directory for the build artifact", "./build").option("--scheme <scheme>", "Xcode scheme to build (iOS only)").option("--aab", "build Android App Bundle (.aab) instead of APK").action(async (platform, options) => {
+  if (platform !== "ios" && platform !== "android" && platform !== "macos") {
+    console.error(pc.red('Platform must be "ios", "android", or "macos"'));
+    process.exit(1);
+  }
+  const cwd = process.cwd();
+  const outputDir = join(cwd, options.output);
+  const platformLabel = platform === "ios" ? "iOS" : platform === "android" ? "Android" : "macOS";
+  console.log(pc.cyan(`
+  Vue Native \u2014 ${options.mode.charAt(0).toUpperCase() + options.mode.slice(1)} Build (${platformLabel})
+`));
+  console.log(pc.white("  Building JS bundle for production..."));
+  try {
+    execSync("bun run vite build --mode production", { cwd, stdio: "inherit" });
+    console.log(pc.green("  \u2713 Bundle built\n"));
+  } catch {
+    console.error(pc.red("  \u2717 Bundle build failed"));
+    process.exit(1);
+  }
+  if (platform === "ios") {
+    buildIOS(cwd, outputDir, options);
+  } else if (platform === "android") {
+    buildAndroid(cwd, outputDir, options);
+  } else {
+    buildMacOS(cwd, outputDir, options);
+  }
+});
+function buildIOS(cwd, outputDir, options) {
+  const iosDir = join(cwd, "ios");
+  const project = findXcodeProject(iosDir);
+  if (!project) {
+    console.log(pc.yellow("  No Xcode project found in ./ios/"));
+    console.log(pc.dim("  To add iOS support, create an Xcode project in the ios/ directory."));
+    console.log(pc.dim("  Bundle has been built to dist/vue-native-bundle.js\n"));
+    return;
+  }
+  const projectFlag = project.isWorkspace ? "-workspace" : "-project";
+  const scheme = options.scheme || project.path.split("/").pop()?.replace(/\.(xcworkspace|xcodeproj)$/, "") || "App";
+  const configuration = options.mode === "release" ? "Release" : "Debug";
+  const archivePath = join(outputDir, `${scheme}.xcarchive`);
+  ensureOutputDir(outputDir);
+  console.log(pc.white(`  Archiving ${scheme} (${configuration})...`));
+  console.log(pc.dim(`  Archive path: ${archivePath}`));
+  const xcodebuild = spawn(
+    "xcodebuild",
+    [
+      projectFlag,
+      project.path,
+      "-scheme",
+      scheme,
+      "-configuration",
+      configuration,
+      "-destination",
+      "generic/platform=iOS",
+      "-archivePath",
+      archivePath,
+      "archive"
+    ],
+    {
+      cwd,
+      stdio: "pipe",
+      env: { ...process.env, DEVELOPER_DIR: "/Applications/Xcode.app/Contents/Developer" }
+    }
+  );
+  const cleanup = () => {
+    if (xcodebuild && !xcodebuild.killed) {
+      xcodebuild.kill();
+    }
+  };
+  process.on("exit", cleanup);
+  process.on("SIGINT", cleanup);
+  process.on("SIGTERM", cleanup);
+  xcodebuild.stdout?.on("data", (data) => {
+    const text = data.toString().trim();
+    if (text.includes("Compiling") || text.includes("Linking") || text.includes("Signing")) {
+      console.log(pc.dim(`  ${text.split("\n").pop()}`));
+    }
+  });
+  xcodebuild.stderr?.on("data", (data) => {
+    const text = data.toString().trim();
+    if (text.includes("error:")) {
+      console.log(pc.red(`  ${text}`));
+    } else if (text.includes("warning:")) {
+      console.log(pc.yellow(`  ${text}`));
+    }
+  });
+  xcodebuild.on("error", (err) => {
+    console.error(pc.red(`  xcodebuild process error: ${err.message}`));
+    cleanup();
+  });
+  xcodebuild.on("close", (code) => {
+    if (code !== 0) {
+      console.error(pc.red(`  \u2717 Archive failed (exit code ${code})`));
+      process.exit(1);
+    }
+    console.log(pc.green("  \u2713 Archive successful\n"));
+    if (existsSync(archivePath)) {
+      console.log(pc.green(`  Archive: ${archivePath}`));
+      console.log(pc.dim("  To export an IPA, open the archive in Xcode Organizer or run:"));
+      console.log(pc.dim(`  xcodebuild -exportArchive -archivePath "${archivePath}" -exportOptionsPlist ExportOptions.plist -exportPath "${outputDir}"
+`));
+    } else {
+      console.log(pc.yellow("  Archive path not found. Check Xcode build settings.\n"));
+    }
+  });
+}
+function buildAndroid(cwd, outputDir, options) {
+  const androidDir = join(cwd, "android");
+  if (!existsSync(androidDir)) {
+    console.log(pc.yellow("  No android/ directory found."));
+    console.log(pc.dim("  To add Android support, create an Android project in the android/ directory."));
+    console.log(pc.dim("  Bundle has been built to dist/vue-native-bundle.js\n"));
+    return;
+  }
+  const gradlew = join(androidDir, "gradlew");
+  if (!existsSync(gradlew)) {
+    console.error(pc.red("  \u2717 gradlew not found in android/ directory"));
+    console.log(pc.dim("  Make sure your Android project has the Gradle wrapper.\n"));
+    process.exit(1);
+  }
+  const gradleTask = options.aab ? "bundleRelease" : "assembleRelease";
+  const artifactType = options.aab ? "AAB" : "APK";
+  ensureOutputDir(outputDir);
+  console.log(pc.white(`  Building release ${artifactType} with Gradle...`));
+  const gradle = spawn(
+    "./gradlew",
+    [gradleTask],
+    {
+      cwd: androidDir,
+      stdio: "pipe",
+      env: { ...process.env }
+    }
+  );
+  const cleanupGradle = () => {
+    if (gradle && !gradle.killed) {
+      gradle.kill();
+    }
+  };
+  process.on("exit", cleanupGradle);
+  process.on("SIGINT", cleanupGradle);
+  process.on("SIGTERM", cleanupGradle);
+  gradle.stdout?.on("data", (data) => {
+    const text = data.toString().trim();
+    if (text) {
+      console.log(pc.dim(`  ${text}`));
+    }
+  });
+  gradle.stderr?.on("data", (data) => {
+    const text = data.toString().trim();
+    if (text.includes("ERROR") || text.includes("FAILURE")) {
+      console.log(pc.red(`  ${text}`));
+    }
+  });
+  gradle.on("error", (err) => {
+    console.error(pc.red(`  Gradle process error: ${err.message}`));
+    cleanupGradle();
+  });
+  gradle.on("close", (code) => {
+    if (code !== 0) {
+      console.error(pc.red(`  \u2717 Gradle build failed (exit code ${code})`));
+      process.exit(1);
+    }
+    console.log(pc.green("  \u2713 Build successful\n"));
+    if (options.aab) {
+      const aabPath = findReleaseAab(androidDir);
+      if (aabPath) {
+        const destPath = join(outputDir, basename(aabPath));
+        copyFileSync(aabPath, destPath);
+        console.log(pc.green(`  AAB copied to: ${destPath}`));
+        console.log(pc.dim("  Upload this file to the Google Play Console.\n"));
+      } else {
+        console.log(pc.yellow("  Could not locate release AAB."));
+        console.log(pc.dim("  Expected at android/app/build/outputs/bundle/release/\n"));
+      }
+    } else {
+      const apkPath = findReleaseApk(androidDir);
+      if (apkPath) {
+        const destPath = join(outputDir, basename(apkPath));
+        copyFileSync(apkPath, destPath);
+        console.log(pc.green(`  APK copied to: ${destPath}`));
+        console.log(pc.dim('  Install with: adb install -r "' + destPath + '"\n'));
+      } else {
+        console.log(pc.yellow("  Could not locate release APK."));
+        console.log(pc.dim("  Expected at android/app/build/outputs/apk/release/\n"));
+      }
+    }
+  });
+}
+function buildMacOS(cwd, outputDir, options) {
+  const macosDir = join(cwd, "macos");
+  const project = findXcodeProject(macosDir);
+  if (!project) {
+    console.log(pc.yellow("  No Xcode project found in ./macos/"));
+    console.log(pc.dim("  To add macOS support, create an Xcode project in the macos/ directory."));
+    console.log(pc.dim("  Bundle has been built to dist/vue-native-bundle.js\n"));
+    return;
+  }
+  const projectFlag = project.isWorkspace ? "-workspace" : "-project";
+  const scheme = options.scheme || project.path.split("/").pop()?.replace(/\.(xcworkspace|xcodeproj)$/, "") || "App";
+  const configuration = options.mode === "release" ? "Release" : "Debug";
+  const archivePath = join(outputDir, `${scheme}.xcarchive`);
+  ensureOutputDir(outputDir);
+  console.log(pc.white(`  Archiving ${scheme} (${configuration}) for macOS...`));
+  console.log(pc.dim(`  Archive path: ${archivePath}`));
+  const xcodebuild = spawn(
+    "xcodebuild",
+    [
+      projectFlag,
+      project.path,
+      "-scheme",
+      scheme,
+      "-configuration",
+      configuration,
+      "-destination",
+      "generic/platform=macOS",
+      "-archivePath",
+      archivePath,
+      "archive"
+    ],
+    {
+      cwd,
+      stdio: "pipe",
+      env: { ...process.env, DEVELOPER_DIR: "/Applications/Xcode.app/Contents/Developer" }
+    }
+  );
+  const cleanup = () => {
+    if (xcodebuild && !xcodebuild.killed) {
+      xcodebuild.kill();
+    }
+  };
+  process.on("exit", cleanup);
+  process.on("SIGINT", cleanup);
+  process.on("SIGTERM", cleanup);
+  xcodebuild.stdout?.on("data", (data) => {
+    const text = data.toString().trim();
+    if (text.includes("Compiling") || text.includes("Linking") || text.includes("Signing")) {
+      console.log(pc.dim(`  ${text.split("\n").pop()}`));
+    }
+  });
+  xcodebuild.stderr?.on("data", (data) => {
+    const text = data.toString().trim();
+    if (text.includes("error:")) {
+      console.log(pc.red(`  ${text}`));
+    } else if (text.includes("warning:")) {
+      console.log(pc.yellow(`  ${text}`));
+    }
+  });
+  xcodebuild.on("error", (err) => {
+    console.error(pc.red(`  xcodebuild process error: ${err.message}`));
+    cleanup();
+  });
+  xcodebuild.on("close", (code) => {
+    if (code !== 0) {
+      console.error(pc.red(`  \u2717 Archive failed (exit code ${code})`));
+      process.exit(1);
+    }
+    console.log(pc.green("  \u2713 Archive successful\n"));
+    if (existsSync(archivePath)) {
+      console.log(pc.green(`  Archive: ${archivePath}`));
+      console.log(pc.dim("  To export a .app or .pkg, open the archive in Xcode Organizer or run:"));
+      console.log(pc.dim(`  xcodebuild -exportArchive -archivePath "${archivePath}" -exportOptionsPlist ExportOptions.plist -exportPath "${outputDir}"
+`));
+    } else {
+      console.log(pc.yellow("  Archive path not found. Check Xcode build settings.\n"));
+    }
+  });
+}
+
+// src/commands/create.ts
+import { Command as Command2 } from "commander";
 import { cp, mkdir, writeFile } from "fs/promises";
-import { join, dirname } from "path";
+import { join as join2, dirname } from "path";
 import { fileURLToPath } from "url";
-import { existsSync } from "fs";
-import pc from "picocolors";
+import { existsSync as existsSync2 } from "fs";
+import pc2 from "picocolors";
 var VERSION = "0.4.14";
-var createCommand = new Command("create").description("Create a new Vue Native project").argument("<name>", "project name").option("-t, --template <template>", "project template (blank, tabs, drawer)", "blank").action(async (name, options) => {
+var JS_PACKAGE_VERSION = "^0.5.0";
+var VITE_PLUGIN_VUE_VERSION = "^6.0.5";
+var VITE_VERSION = "^8.0.0";
+var createCommand = new Command2("create").description("Create a new Vue Native project").argument("<name>", "project name").option("-t, --template <template>", "project template (blank, tabs, drawer)", "blank").action(async (name, options) => {
   const template = options.template;
   if (!["blank", "tabs", "drawer"].includes(template)) {
-    console.error(pc.red(`Invalid template "${template}". Choose: blank, tabs, drawer`));
+    console.error(pc2.red(`Invalid template "${template}". Choose: blank, tabs, drawer`));
     process.exit(1);
   }
-  const dir = join(process.cwd(), name);
-  console.log(pc.cyan(`
-Creating Vue Native project: ${pc.bold(name)} (template: ${template})
+  const dir = join2(process.cwd(), name);
+  console.log(pc2.cyan(`
+Creating Vue Native project: ${pc2.bold(name)} (template: ${template})
 `));
   try {
     await mkdir(dir, { recursive: true });
-    await mkdir(join(dir, "app"), { recursive: true });
-    await mkdir(join(dir, "app", "pages"), { recursive: true });
-    await writeFile(join(dir, "package.json"), JSON.stringify({
+    await mkdir(join2(dir, "app"), { recursive: true });
+    await mkdir(join2(dir, "app", "pages"), { recursive: true });
+    await writeFile(join2(dir, "package.json"), JSON.stringify({
       name,
       version: "0.0.1",
       private: true,
@@ -36,18 +363,18 @@ Creating Vue Native project: ${pc.bold(name)} (template: ${template})
         typecheck: "tsc --noEmit"
       },
       dependencies: {
-        "@thelacanians/vue-native-runtime": "^0.4.0",
-        "@thelacanians/vue-native-navigation": "^0.4.0",
+        "@thelacanians/vue-native-runtime": JS_PACKAGE_VERSION,
+        "@thelacanians/vue-native-navigation": JS_PACKAGE_VERSION,
         "vue": "^3.5.0"
       },
       devDependencies: {
-        "@thelacanians/vue-native-vite-plugin": "^0.4.0",
-        "@vitejs/plugin-vue": "^5.0.0",
-        "vite": "^6.1.0",
+        "@thelacanians/vue-native-vite-plugin": JS_PACKAGE_VERSION,
+        "@vitejs/plugin-vue": VITE_PLUGIN_VUE_VERSION,
+        "vite": VITE_VERSION,
         "typescript": "^5.7.0"
       }
     }, null, 2));
-    await writeFile(join(dir, "vite.config.ts"), `import { defineConfig } from 'vite'
+    await writeFile(join2(dir, "vite.config.ts"), `import { defineConfig } from 'vite'
 import vue from '@vitejs/plugin-vue'
 import vueNative from '@thelacanians/vue-native-vite-plugin'
 
@@ -55,7 +382,7 @@ export default defineConfig({
   plugins: [vue(), vueNative()],
 })
 `);
-    await writeFile(join(dir, "tsconfig.json"), JSON.stringify({
+    await writeFile(join2(dir, "tsconfig.json"), JSON.stringify({
       compilerOptions: {
         target: "ES2020",
         module: "ESNext",
@@ -71,12 +398,12 @@ export default defineConfig({
       include: ["app/**/*", "env.d.ts"]
     }, null, 2));
     await generateTemplateFiles(dir, name, template);
-    const iosDir = join(dir, "ios");
-    const iosSrcDir = join(iosDir, "Sources");
+    const iosDir = join2(dir, "ios");
+    const iosSrcDir = join2(iosDir, "Sources");
     await mkdir(iosSrcDir, { recursive: true });
     const xcodeProjectName = name.replace(/[^a-zA-Z0-9]/g, "");
     const bundleId = `com.vuenative.${name.replace(/[^a-zA-Z0-9]/g, "").toLowerCase()}`;
-    await writeFile(join(iosDir, "project.yml"), `name: ${xcodeProjectName}
+    await writeFile(join2(iosDir, "project.yml"), `name: ${xcodeProjectName}
 options:
   bundleIdPrefix: com.vuenative
   deploymentTarget:
@@ -107,7 +434,7 @@ targets:
       - path: ../dist/vue-native-bundle.js
         optional: true
 `);
-    await writeFile(join(iosSrcDir, "Info.plist"), `<?xml version="1.0" encoding="UTF-8"?>
+    await writeFile(join2(iosSrcDir, "Info.plist"), `<?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
 <plist version="1.0">
 <dict>
@@ -173,7 +500,7 @@ targets:
 </dict>
 </plist>
 `);
-    await writeFile(join(iosSrcDir, "AppDelegate.swift"), `import UIKit
+    await writeFile(join2(iosSrcDir, "AppDelegate.swift"), `import UIKit
 
 @main
 class AppDelegate: UIResponder, UIApplicationDelegate {
@@ -197,7 +524,7 @@ class AppDelegate: UIResponder, UIApplicationDelegate {
     }
 }
 `);
-    await writeFile(join(iosSrcDir, "SceneDelegate.swift"), `import UIKit
+    await writeFile(join2(iosSrcDir, "SceneDelegate.swift"), `import UIKit
 import VueNativeCore
 
 class SceneDelegate: UIResponder, UIWindowSceneDelegate {
@@ -225,29 +552,29 @@ class AppViewController: VueNativeViewController {
     #endif
 }
 `);
-    const androidDir = join(dir, "android");
-    const androidAppDir = join(androidDir, "app");
+    const androidDir = join2(dir, "android");
+    const androidAppDir = join2(androidDir, "app");
     const androidPkg = `com.vuenative.${name.replace(/[^a-zA-Z0-9]/g, "").toLowerCase()}`;
     const androidPkgPath = androidPkg.replace(/\./g, "/");
-    const androidSrcDir = join(androidAppDir, "src", "main");
-    const androidKotlinDir = join(androidSrcDir, "kotlin", androidPkgPath);
-    const androidResValuesDir = join(androidSrcDir, "res", "values");
-    const androidResXmlDir = join(androidSrcDir, "res", "xml");
-    const androidDebugResXmlDir = join(androidAppDir, "src", "debug", "res", "xml");
-    const androidGradleWrapperDir = join(androidDir, "gradle", "wrapper");
+    const androidSrcDir = join2(androidAppDir, "src", "main");
+    const androidKotlinDir = join2(androidSrcDir, "kotlin", androidPkgPath);
+    const androidResValuesDir = join2(androidSrcDir, "res", "values");
+    const androidResXmlDir = join2(androidSrcDir, "res", "xml");
+    const androidDebugResXmlDir = join2(androidAppDir, "src", "debug", "res", "xml");
+    const androidGradleWrapperDir = join2(androidDir, "gradle", "wrapper");
     await mkdir(androidKotlinDir, { recursive: true });
     await mkdir(androidResValuesDir, { recursive: true });
     await mkdir(androidResXmlDir, { recursive: true });
     await mkdir(androidDebugResXmlDir, { recursive: true });
     await mkdir(androidGradleWrapperDir, { recursive: true });
-    await writeFile(join(androidDir, "build.gradle.kts"), `// Top-level build file
+    await writeFile(join2(androidDir, "build.gradle.kts"), `// Top-level build file
 plugins {
     id("com.android.application") version "8.7.3" apply false
     id("com.android.library") version "8.7.3" apply false
     id("org.jetbrains.kotlin.android") version "2.0.21" apply false
 }
 `);
-    await writeFile(join(androidDir, "settings.gradle.kts"), `pluginManagement {
+    await writeFile(join2(androidDir, "settings.gradle.kts"), `pluginManagement {
     repositories {
         google()
         mavenCentral()
@@ -273,7 +600,7 @@ dependencyResolutionManagement {
 rootProject.name = "${name}"
 include(":app")
 `);
-    await writeFile(join(androidAppDir, "build.gradle.kts"), `plugins {
+    await writeFile(join2(androidAppDir, "build.gradle.kts"), `plugins {
     id("com.android.application")
     id("org.jetbrains.kotlin.android")
 }
@@ -321,13 +648,13 @@ dependencies {
     implementation("androidx.core:core-ktx:1.15.0")
 }
 `);
-    await writeFile(join(androidAppDir, "proguard-rules.pro"), `# Vue Native
+    await writeFile(join2(androidAppDir, "proguard-rules.pro"), `# Vue Native
 -keep class com.vuenative.** { *; }
 
 # J2V8
 -keep class com.eclipsesource.v8.** { *; }
 `);
-    await writeFile(join(androidSrcDir, "AndroidManifest.xml"), `<?xml version="1.0" encoding="utf-8"?>
+    await writeFile(join2(androidSrcDir, "AndroidManifest.xml"), `<?xml version="1.0" encoding="utf-8"?>
 <manifest xmlns:android="http://schemas.android.com/apk/res/android">
     <uses-permission android:name="android.permission.INTERNET" />
 
@@ -350,12 +677,12 @@ dependencies {
     </application>
 </manifest>
 `);
-    await writeFile(join(androidResValuesDir, "strings.xml"), `<?xml version="1.0" encoding="utf-8"?>
+    await writeFile(join2(androidResValuesDir, "strings.xml"), `<?xml version="1.0" encoding="utf-8"?>
 <resources>
     <string name="app_name">${name}</string>
 </resources>
 `);
-    await writeFile(join(androidResValuesDir, "themes.xml"), `<?xml version="1.0" encoding="utf-8"?>
+    await writeFile(join2(androidResValuesDir, "themes.xml"), `<?xml version="1.0" encoding="utf-8"?>
 <resources>
     <style name="Theme.VueNative" parent="Theme.MaterialComponents.Light.NoActionBar">
         <item name="colorPrimary">#4F46E5</item>
@@ -368,12 +695,12 @@ dependencies {
     </style>
 </resources>
 `);
-    await writeFile(join(androidResXmlDir, "network_security_config.xml"), `<?xml version="1.0" encoding="utf-8"?>
+    await writeFile(join2(androidResXmlDir, "network_security_config.xml"), `<?xml version="1.0" encoding="utf-8"?>
 <network-security-config>
     <base-config cleartextTrafficPermitted="false" />
 </network-security-config>
 `);
-    await writeFile(join(androidDebugResXmlDir, "network_security_config.xml"), `<?xml version="1.0" encoding="utf-8"?>
+    await writeFile(join2(androidDebugResXmlDir, "network_security_config.xml"), `<?xml version="1.0" encoding="utf-8"?>
 <network-security-config>
     <domain-config cleartextTrafficPermitted="true">
         <domain includeSubdomains="true">localhost</domain>
@@ -382,7 +709,7 @@ dependencies {
     </domain-config>
 </network-security-config>
 `);
-    await writeFile(join(androidKotlinDir, "MainActivity.kt"), `package ${androidPkg}
+    await writeFile(join2(androidKotlinDir, "MainActivity.kt"), `package ${androidPkg}
 
 import com.vuenative.core.VueNativeActivity
 
@@ -396,20 +723,20 @@ class MainActivity : VueNativeActivity() {
     }
 }
 `);
-    await writeFile(join(androidDir, "gradle.properties"), `# Project-wide Gradle settings
+    await writeFile(join2(androidDir, "gradle.properties"), `# Project-wide Gradle settings
 org.gradle.jvmargs=-Xmx2048m -Dfile.encoding=UTF-8
 android.useAndroidX=true
 kotlin.code.style=official
 android.nonTransitiveRClass=true
 `);
-    await writeFile(join(androidGradleWrapperDir, "gradle-wrapper.properties"), `distributionBase=GRADLE_USER_HOME
+    await writeFile(join2(androidGradleWrapperDir, "gradle-wrapper.properties"), `distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
 distributionUrl=https\\://services.gradle.org/distributions/gradle-8.11.1-bin.zip
 networkTimeout=10000
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists
 `);
-    await writeFile(join(dir, "vue-native.config.ts"), `import { defineConfig } from '@thelacanians/vue-native-cli'
+    await writeFile(join2(dir, "vue-native.config.ts"), `import { defineConfig } from '@thelacanians/vue-native-cli'
 
 export default defineConfig({
   name: '${name}',
@@ -424,7 +751,7 @@ export default defineConfig({
   },
 })
 `);
-    await writeFile(join(dir, "env.d.ts"), `/// <reference types="vite/client" />
+    await writeFile(join2(dir, "env.d.ts"), `/// <reference types="vite/client" />
 declare module '*.vue' {
   import type { DefineComponent } from '@thelacanians/vue-native-runtime'
   const component: DefineComponent<{}, {}, any>
@@ -432,7 +759,7 @@ declare module '*.vue' {
 }
 declare const __DEV__: boolean
 `);
-    await writeFile(join(dir, ".gitignore"), `node_modules/
+    await writeFile(join2(dir, ".gitignore"), `node_modules/
 dist/
 *.xcuserstate
 *.xcuserdatad/
@@ -455,30 +782,30 @@ local.properties
 *.jks
 `);
     const cliDir = dirname(dirname(fileURLToPath(import.meta.url)));
-    const bundledNative = join(cliDir, "native");
-    if (existsSync(bundledNative)) {
-      const nativeDir = join(dir, "native");
+    const bundledNative = join2(cliDir, "native");
+    if (existsSync2(bundledNative)) {
+      const nativeDir = join2(dir, "native");
       await cp(bundledNative, nativeDir, { recursive: true });
-      console.log(pc.dim("  Bundled native/ copied as fallback.\n"));
-    }
-    console.log(pc.green("  Project created successfully!\n"));
-    console.log(pc.white("  Next steps:\n"));
-    console.log(pc.white(`    cd ${name}`));
-    console.log(pc.white("    bun install"));
-    console.log(pc.white("    vue-native dev\n"));
-    console.log(pc.white("  To run on iOS:"));
-    console.log(pc.white("    vue-native run ios\n"));
-    console.log(pc.white("  To run on Android:"));
-    console.log(pc.dim("    Open android/ in Android Studio, or run:"));
-    console.log(pc.dim("    cd android && gradle wrapper && cd .."));
-    console.log(pc.white("    vue-native run android\n"));
+      console.log(pc2.dim("  Bundled native/ copied as fallback.\n"));
+    }
+    console.log(pc2.green("  Project created successfully!\n"));
+    console.log(pc2.white("  Next steps:\n"));
+    console.log(pc2.white(`    cd ${name}`));
+    console.log(pc2.white("    bun install"));
+    console.log(pc2.white("    vue-native dev\n"));
+    console.log(pc2.white("  To run on iOS:"));
+    console.log(pc2.white("    vue-native run ios\n"));
+    console.log(pc2.white("  To run on Android:"));
+    console.log(pc2.dim("    Open android/ in Android Studio, or run:"));
+    console.log(pc2.dim("    cd android && gradle wrapper && cd .."));
+    console.log(pc2.white("    vue-native run android\n"));
   } catch (err) {
-    console.error(pc.red(`Error creating project: ${err.message}`));
+    console.error(pc2.red(`Error creating project: ${err.message}`));
     process.exit(1);
   }
 });
 async function generateTemplateFiles(dir, name, template) {
-  const pagesDir = join(dir, "app", "pages");
+  const pagesDir = join2(dir, "app", "pages");
   if (template === "blank") {
     await generateBlankTemplate(dir, pagesDir);
   } else if (template === "tabs") {
@@ -488,7 +815,7 @@ async function generateTemplateFiles(dir, name, template) {
   }
 }
 async function generateBlankTemplate(dir, pagesDir) {
-  await writeFile(join(dir, "app", "main.ts"), `import { createApp } from '@thelacanians/vue-native-runtime'
+  await writeFile(join2(dir, "app", "main.ts"), `import { createApp } from '@thelacanians/vue-native-runtime'
 import { createRouter } from '@thelacanians/vue-native-navigation'
 import App from './App.vue'
 import Home from './pages/Home.vue'
@@ -501,7 +828,7 @@ const app = createApp(App)
 app.use(router)
 app.start()
 `);
-  await writeFile(join(dir, "app", "App.vue"), `<template>
+  await writeFile(join2(dir, "app", "App.vue"), `<template>
   <VSafeArea :style="{ flex: 1, backgroundColor: '#ffffff' }">
     <RouterView />
   </VSafeArea>
@@ -511,7 +838,7 @@ app.start()
 import { RouterView } from '@thelacanians/vue-native-navigation'
 </script>
 `);
-  await writeFile(join(pagesDir, "Home.vue"), `<script setup lang="ts">
+  await writeFile(join2(pagesDir, "Home.vue"), `<script setup lang="ts">
 import { ref } from 'vue'
 import { createStyleSheet } from '@thelacanians/vue-native-runtime'
 
@@ -563,13 +890,13 @@ const styles = createStyleSheet({
 `);
 }
 async function generateTabsTemplate(dir, pagesDir) {
-  await writeFile(join(dir, "app", "main.ts"), `import { createApp } from '@thelacanians/vue-native-runtime'
+  await writeFile(join2(dir, "app", "main.ts"), `import { createApp } from '@thelacanians/vue-native-runtime'
 import App from './App.vue'
 
 const app = createApp(App)
 app.start()
 `);
-  await writeFile(join(dir, "app", "App.vue"), `<script setup lang="ts">
+  await writeFile(join2(dir, "app", "App.vue"), `<script setup lang="ts">
 import { createTabNavigator } from '@thelacanians/vue-native-navigation'
 import Home from './pages/Home.vue'
 import Settings from './pages/Settings.vue'
@@ -588,7 +915,7 @@ const { TabNavigator } = createTabNavigator()
   </VSafeArea>
 </template>
 `);
-  await writeFile(join(pagesDir, "Home.vue"), `<script setup lang="ts">
+  await writeFile(join2(pagesDir, "Home.vue"), `<script setup lang="ts">
 import { ref } from 'vue'
 import { createStyleSheet } from '@thelacanians/vue-native-runtime'
 
@@ -632,7 +959,7 @@ const styles = createStyleSheet({
   </VView>
 </template>
 `);
-  await writeFile(join(pagesDir, "Settings.vue"), `<script setup lang="ts">
+  await writeFile(join2(pagesDir, "Settings.vue"), `<script setup lang="ts">
 import { ref } from 'vue'
 import { createStyleSheet } from '@thelacanians/vue-native-runtime'
 
@@ -676,13 +1003,13 @@ const styles = createStyleSheet({
 `);
 }
 async function generateDrawerTemplate(dir, pagesDir) {
-  await writeFile(join(dir, "app", "main.ts"), `import { createApp } from '@thelacanians/vue-native-runtime'
+  await writeFile(join2(dir, "app", "main.ts"), `import { createApp } from '@thelacanians/vue-native-runtime'
 import App from './App.vue'
 
 const app = createApp(App)
 app.start()
 `);
-  await writeFile(join(dir, "app", "App.vue"), `<script setup lang="ts">
+  await writeFile(join2(dir, "app", "App.vue"), `<script setup lang="ts">
 import { createDrawerNavigator } from '@thelacanians/vue-native-navigation'
 import Home from './pages/Home.vue'
 import About from './pages/About.vue'
@@ -701,7 +1028,7 @@ const { DrawerNavigator } = createDrawerNavigator()
   </VSafeArea>
 </template>
 `);
-  await writeFile(join(pagesDir, "Home.vue"), `<script setup lang="ts">
+  await writeFile(join2(pagesDir, "Home.vue"), `<script setup lang="ts">
 import { createStyleSheet } from '@thelacanians/vue-native-runtime'
 import { useDrawer } from '@thelacanians/vue-native-navigation'
 
@@ -754,7 +1081,7 @@ const styles = createStyleSheet({
   </VView>
 </template>
 `);
-  await writeFile(join(pagesDir, "About.vue"), `<script setup lang="ts">
+  await writeFile(join2(pagesDir, "About.vue"), `<script setup lang="ts">
 import { createStyleSheet } from '@thelacanians/vue-native-runtime'
 import { useDrawer } from '@thelacanians/vue-native-navigation'
 
@@ -810,19 +1137,19 @@ const styles = createStyleSheet({
 }
 
 // src/commands/dev.ts
-import { Command as Command2 } from "commander";
-import { spawn, execSync } from "child_process";
+import { Command as Command3 } from "commander";
+import { spawn as spawn2, execSync as execSync2 } from "child_process";
 import { readFile } from "fs/promises";
-import { existsSync as existsSync2 } from "fs";
-import { join as join2 } from "path";
+import { existsSync as existsSync3 } from "fs";
+import { join as join3 } from "path";
 import { watch } from "chokidar";
 import { WebSocketServer, WebSocket } from "ws";
-import pc2 from "picocolors";
+import pc3 from "picocolors";
 var DEFAULT_PORT = 8174;
 var BUNDLE_FILE = "dist/vue-native-bundle.js";
 function detectIOSSimulators() {
   try {
-    const output = execSync("xcrun simctl list devices available -j", {
+    const output = execSync2("xcrun simctl list devices available -j", {
       stdio: "pipe",
       encoding: "utf8"
     });
@@ -847,33 +1174,33 @@ function detectIOSSimulators() {
 }
 function bootSimulator(udid) {
   try {
-    execSync(`xcrun simctl boot "${udid}"`, { stdio: "pipe" });
+    execSync2(`xcrun simctl boot "${udid}"`, { stdio: "pipe" });
   } catch {
   }
   try {
-    execSync("open -a Simulator", { stdio: "pipe" });
+    execSync2("open -a Simulator", { stdio: "pipe" });
   } catch {
   }
 }
 function detectAndroidEmulators() {
   try {
-    const output = execSync("adb devices", { stdio: "pipe", encoding: "utf8" });
+    const output = execSync2("adb devices", { stdio: "pipe", encoding: "utf8" });
     const lines = output.split("\n").filter((l) => l.includes("device") && !l.startsWith("List"));
     return lines.map((l) => l.split("	")[0]).filter(Boolean);
   } catch {
     return [];
   }
 }
-var devCommand = new Command2("dev").description("Start the Vue Native dev server with hot reload").option("-p, --port <port>", "WebSocket port for hot reload", String(DEFAULT_PORT)).option("--ios", "auto-detect and launch iOS Simulator").option("--android", "auto-detect Android emulator").option("--simulator <name>", "specify iOS Simulator name").action(async (options) => {
+var devCommand = new Command3("dev").description("Start the Vue Native dev server with hot reload").option("-p, --port <port>", "WebSocket port for hot reload", String(DEFAULT_PORT)).option("--ios", "auto-detect and launch iOS Simulator").option("--android", "auto-detect Android emulator").option("--simulator <name>", "specify iOS Simulator name").action(async (options) => {
   const port = parseInt(options.port, 10);
   const cwd = process.cwd();
-  const bundlePath = join2(cwd, BUNDLE_FILE);
-  console.log(pc2.cyan("\n  Vue Native Dev Server\n"));
+  const bundlePath = join3(cwd, BUNDLE_FILE);
+  console.log(pc3.cyan("\n  Vue Native Dev Server\n"));
   if (options.ios) {
-    console.log(pc2.white("  Detecting iOS Simulators..."));
+    console.log(pc3.white("  Detecting iOS Simulators..."));
     const simulators = detectIOSSimulators();
     if (simulators.length === 0) {
-      console.log(pc2.yellow("  No iOS Simulators found. Install Xcode and create a simulator."));
+      console.log(pc3.yellow("  No iOS Simulators found. Install Xcode and create a simulator."));
     } else {
       let target = simulators.find((s) => s.state === "Booted");
       if (!target && options.simulator) {
@@ -884,46 +1211,69 @@ var devCommand = new Command2("dev").description("Start the Vue Native dev serve
       }
       if (target) {
         if (target.state !== "Booted") {
-          console.log(pc2.white(`  Booting ${target.name}...`));
+          console.log(pc3.white(`  Booting ${target.name}...`));
           bootSimulator(target.udid);
         }
-        console.log(pc2.green(`  iOS Simulator ready: ${target.name}`));
+        console.log(pc3.green(`  iOS Simulator ready: ${target.name}`));
       }
     }
     console.log();
   }
   if (options.android) {
-    console.log(pc2.white("  Detecting Android emulators..."));
+    console.log(pc3.white("  Detecting Android emulators..."));
     const emulators = detectAndroidEmulators();
     if (emulators.length === 0) {
-      console.log(pc2.yellow("  No Android emulators detected. Start one via Android Studio or `emulator -avd <name>`."));
+      console.log(pc3.yellow("  No Android emulators detected. Start one via Android Studio or `emulator -avd <name>`."));
     } else {
-      console.log(pc2.green(`  Android emulator(s) connected: ${emulators.join(", ")}`));
+      console.log(pc3.green(`  Android emulator(s) connected: ${emulators.join(", ")}`));
     }
     console.log();
   }
+  let lanIP = "";
+  try {
+    const nets = await import("os").then((os) => os.networkInterfaces());
+    for (const ifaces of Object.values(nets)) {
+      for (const iface of ifaces ?? []) {
+        if (iface.family === "IPv4" && !iface.internal) {
+          lanIP = iface.address;
+          break;
+        }
+      }
+      if (lanIP) break;
+    }
+  } catch {
+  }
+  const isPrivateOrLocal = (addr) => {
+    if (!addr) return false;
+    const ip = addr.replace(/^::ffff:/, "");
+    if (ip === "127.0.0.1" || ip === "::1") return true;
+    if (ip === "10.0.2.2") return true;
+    if (ip.startsWith("10.")) return true;
+    if (ip.startsWith("192.168.")) return true;
+    if (/^172\.(1[6-9]|2\d|3[01])\./.test(ip)) return true;
+    return false;
+  };
   const wss = new WebSocketServer({
     port,
     verifyClient: (info) => {
-      const addr = info.req.socket.remoteAddress;
-      return addr === "127.0.0.1" || addr === "::1" || addr === "::ffff:127.0.0.1";
+      return isPrivateOrLocal(info.req.socket.remoteAddress);
     }
   });
   const clients = /* @__PURE__ */ new Set();
   wss.on("connection", (ws) => {
     clients.add(ws);
     ws.send(JSON.stringify({ type: "connected" }));
-    console.log(pc2.green(`  Client connected (${clients.size} total)`));
+    console.log(pc3.green(`  Client connected (${clients.size} total)`));
     readFile(bundlePath, "utf8").then((bundle) => {
       if (ws.readyState === WebSocket.OPEN) {
         ws.send(JSON.stringify({ type: "bundle", bundle }));
-        console.log(pc2.dim(`  Sent bundle to new client (${Math.round(bundle.length / 1024)}KB)`));
+        console.log(pc3.dim(`  Sent bundle to new client (${Math.round(bundle.length / 1024)}KB)`));
       }
     }).catch(() => {
     });
     ws.on("close", () => {
       clients.delete(ws);
-      console.log(pc2.dim(`  Client disconnected (${clients.size} remaining)`));
+      console.log(pc3.dim(`  Client disconnected (${clients.size} remaining)`));
     });
     ws.on("message", (data) => {
       try {
@@ -934,34 +1284,43 @@ var devCommand = new Command2("dev").description("Start the Vue Native dev serve
     });
   });
   wss.on("error", (err) => {
-    console.error(pc2.red(`WebSocket server error: ${err.message}`));
+    console.error(pc3.red(`WebSocket server error: ${err.message}`));
   });
-  console.log(pc2.white(`  Hot reload server: ${pc2.bold(`ws://localhost:${port}`)}`));
-  const iosDir = join2(cwd, "ios");
-  const androidDir = join2(cwd, "android");
-  if (existsSync2(iosDir)) {
-    console.log(pc2.dim(`  iOS app should connect to ws://localhost:${port}`));
+  console.log(pc3.white(`  Hot reload server: ${pc3.bold(`ws://localhost:${port}`)}`));
+  if (lanIP) {
+    console.log(pc3.white(`  LAN address:       ${pc3.bold(`ws://${lanIP}:${port}`)}`));
+  }
+  const iosDir = join3(cwd, "ios");
+  const androidDir = join3(cwd, "android");
+  if (existsSync3(iosDir)) {
+    console.log(pc3.dim(`  iOS Simulator:     ws://localhost:${port}`));
+    if (lanIP) {
+      console.log(pc3.dim(`  iOS Device (WiFi): ws://${lanIP}:${port}`));
+    }
   }
-  if (existsSync2(androidDir)) {
-    console.log(pc2.dim(`  Android emulator should connect to ws://10.0.2.2:${port}`));
+  if (existsSync3(androidDir)) {
+    console.log(pc3.dim(`  Android emulator:  ws://10.0.2.2:${port}`));
+    if (lanIP) {
+      console.log(pc3.dim(`  Android Device:    ws://${lanIP}:${port}`));
+    }
   }
-  console.log(pc2.dim("  Waiting for app to connect...\n"));
-  console.log(pc2.white("  Starting Vite build watcher...\n"));
-  const vite = spawn(
+  console.log(pc3.dim("  Waiting for app to connect...\n"));
+  console.log(pc3.white("  Starting Vite build watcher...\n"));
+  const vite = spawn2(
     "bun",
     ["run", "vite", "build", "--watch", "--mode", "development"],
     { cwd, stdio: "pipe" }
   );
   vite.stdout?.on("data", (data) => {
     const text = data.toString().trim();
-    if (text) console.log(pc2.dim(`  [vite] ${text}`));
+    if (text) console.log(pc3.dim(`  [vite] ${text}`));
   });
   vite.stderr?.on("data", (data) => {
     const text = data.toString().trim();
-    if (text) console.log(pc2.yellow(`  [vite] ${text}`));
+    if (text) console.log(pc3.yellow(`  [vite] ${text}`));
   });
   vite.on("error", (err) => {
-    console.error(pc2.red(`Vite error: ${err.message}`));
+    console.error(pc3.red(`Vite error: ${err.message}`));
   });
   const watcher = watch(bundlePath, {
     persistent: true,
@@ -981,7 +1340,7 @@ var devCommand = new Command2("dev").description("Start the Vue Native dev serve
           sent++;
         }
       }
-      console.log(pc2.green(`  Bundle updated (${Math.round(bundle.length / 1024)}KB) -> sent to ${sent} client(s)`));
+      console.log(pc3.green(`  Bundle updated (${Math.round(bundle.length / 1024)}KB) -> sent to ${sent} client(s)`));
     } catch {
     }
   }
@@ -993,7 +1352,7 @@ var devCommand = new Command2("dev").description("Start the Vue Native dev serve
     }
   }, 3e4);
   process.on("SIGINT", () => {
-    console.log(pc2.yellow("\n  Shutting down dev server..."));
+    console.log(pc3.yellow("\n  Shutting down dev server..."));
     vite.kill();
     wss.close();
     process.exit(0);
@@ -1001,30 +1360,30 @@ var devCommand = new Command2("dev").description("Start the Vue Native dev serve
 });
 
 // src/commands/run.ts
-import { Command as Command3 } from "commander";
-import { spawn as spawn2, execSync as execSync2 } from "child_process";
-import { existsSync as existsSync3, readdirSync, readFileSync } from "fs";
-import { join as join3 } from "path";
-import pc3 from "picocolors";
+import { Command as Command4 } from "commander";
+import { spawn as spawn3, execSync as execSync3 } from "child_process";
+import { existsSync as existsSync4, readdirSync as readdirSync2, readFileSync } from "fs";
+import { join as join4 } from "path";
+import pc4 from "picocolors";
 function findAppPath(_buildDir) {
-  const derivedDataBase = join3(
+  const derivedDataBase = join4(
     process.env.HOME || "~",
     "Library/Developer/Xcode/DerivedData"
   );
-  if (existsSync3(derivedDataBase)) {
+  if (existsSync4(derivedDataBase)) {
     try {
-      const projects = readdirSync(derivedDataBase);
+      const projects = readdirSync2(derivedDataBase);
       for (const project of projects.reverse()) {
-        const productsDir = join3(
+        const productsDir = join4(
           derivedDataBase,
           project,
           "Build/Products/Debug-iphonesimulator"
         );
-        if (existsSync3(productsDir)) {
-          const entries = readdirSync(productsDir);
+        if (existsSync4(productsDir)) {
+          const entries = readdirSync2(productsDir);
           const app = entries.find((e) => e.endsWith(".app"));
           if (app) {
-            return join3(productsDir, app);
+            return join4(productsDir, app);
           }
         }
       }
@@ -1034,8 +1393,8 @@ function findAppPath(_buildDir) {
   return null;
 }
 function readBundleId(iosDir) {
-  const plistPath = join3(iosDir, "Sources", "Info.plist");
-  if (existsSync3(plistPath)) {
+  const plistPath = join4(iosDir, "Sources", "Info.plist");
+  if (existsSync4(plistPath)) {
     try {
       const content = readFileSync(plistPath, "utf8");
       const match = content.match(
@@ -1050,52 +1409,55 @@ function readBundleId(iosDir) {
   return "com.vuenative.app";
 }
 function findApkPath(androidDir) {
-  const apkDir = join3(androidDir, "app", "build", "outputs", "apk", "debug");
-  if (existsSync3(apkDir)) {
+  const apkDir = join4(androidDir, "app", "build", "outputs", "apk", "debug");
+  if (existsSync4(apkDir)) {
     try {
-      const entries = readdirSync(apkDir);
+      const entries = readdirSync2(apkDir);
       const apk = entries.find((e) => e.endsWith(".apk") && !e.includes("androidTest"));
       if (apk) {
-        return join3(apkDir, apk);
+        return join4(apkDir, apk);
       }
     } catch {
     }
   }
   return null;
 }
-var runCommand = new Command3("run").description("Build and run the app").argument("<platform>", "platform to run on (ios, android)").option("--device", "run on physical device instead of simulator").option("--scheme <scheme>", "Xcode scheme to build").option("--simulator <name>", "simulator name", "iPhone 16").option("--bundle-id <id>", "app bundle identifier").option("--package <name>", "Android package name", "com.vuenative.app").option("--activity <name>", "Android activity name", ".MainActivity").action(async (platform, options) => {
-  if (platform !== "ios" && platform !== "android") {
-    console.error(pc3.red('Platform must be "ios" or "android"'));
+var runCommand = new Command4("run").description("Build and run the app").argument("<platform>", "platform to run on (ios, android, macos)").option("--device", "run on physical device instead of simulator").option("--scheme <scheme>", "Xcode scheme to build").option("--simulator <name>", "simulator name", "iPhone 16").option("--bundle-id <id>", "app bundle identifier").option("--package <name>", "Android package name", "com.vuenative.app").option("--activity <name>", "Android activity name", ".MainActivity").action(async (platform, options) => {
+  if (platform !== "ios" && platform !== "android" && platform !== "macos") {
+    console.error(pc4.red('Platform must be "ios", "android", or "macos"'));
     process.exit(1);
   }
   const cwd = process.cwd();
-  console.log(pc3.cyan(`
-\u{1F4F1} Vue Native \u2014 Run ${platform === "ios" ? "iOS" : "Android"}
+  const platformLabel = platform === "ios" ? "iOS" : platform === "android" ? "Android" : "macOS";
+  console.log(pc4.cyan(`
+\u{1F4F1} Vue Native \u2014 Run ${platformLabel}
 `));
-  console.log(pc3.white("  Building JS bundle..."));
+  console.log(pc4.white("  Building JS bundle..."));
   try {
-    execSync2("bun run vite build", { cwd, stdio: "inherit" });
-    console.log(pc3.green("  \u2713 Bundle built\n"));
+    execSync3("bun run vite build", { cwd, stdio: "inherit" });
+    console.log(pc4.green("  \u2713 Bundle built\n"));
   } catch {
-    console.error(pc3.red("  \u2717 Bundle build failed"));
+    console.error(pc4.red("  \u2717 Bundle build failed"));
     process.exit(1);
   }
   if (platform === "ios") {
     runIOS(cwd, options);
-  } else {
+  } else if (platform === "android") {
     runAndroid(cwd, options);
+  } else {
+    runMacOS(cwd, options);
   }
 });
 function runIOS(cwd, options) {
   let xcodeProject = null;
-  const iosDir = join3(cwd, "ios");
-  if (existsSync3(iosDir)) {
+  const iosDir = join4(cwd, "ios");
+  if (existsSync4(iosDir)) {
     for (const ext of [".xcworkspace", ".xcodeproj"]) {
       try {
-        const entries = readdirSync(iosDir);
+        const entries = readdirSync2(iosDir);
         const match = entries.find((e) => e.endsWith(ext));
         if (match) {
-          xcodeProject = join3(iosDir, match);
+          xcodeProject = join4(iosDir, match);
           break;
         }
       } catch {
@@ -1103,17 +1465,17 @@ function runIOS(cwd, options) {
     }
   }
   if (!xcodeProject) {
-    console.log(pc3.yellow("  No Xcode project found in ./ios/"));
-    console.log(pc3.dim("  To add iOS support, create an Xcode project in the ios/ directory."));
-    console.log(pc3.dim("  Bundle has been built to dist/vue-native-bundle.js\n"));
+    console.log(pc4.yellow("  No Xcode project found in ./ios/"));
+    console.log(pc4.dim("  To add iOS support, create an Xcode project in the ios/ directory."));
+    console.log(pc4.dim("  Bundle has been built to dist/vue-native-bundle.js\n"));
     return;
   }
   const isWorkspace = xcodeProject.endsWith(".xcworkspace");
   const scheme = options.scheme || xcodeProject.split("/").pop()?.replace(/\.(xcworkspace|xcodeproj)$/, "") || "App";
   const destination = options.device ? "generic/platform=iOS" : `platform=iOS Simulator,name=${options.simulator}`;
   const projectFlag = isWorkspace ? "-workspace" : "-project";
-  console.log(pc3.white(`  Building ${scheme} for ${options.device ? "device" : options.simulator}...`));
-  const xcodebuild = spawn2(
+  console.log(pc4.white(`  Building ${scheme} for ${options.device ? "device" : options.simulator}...`));
+  const xcodebuild = spawn3(
     "xcodebuild",
     [projectFlag, xcodeProject, "-scheme", scheme, "-destination", destination, "build"],
     {
@@ -1125,71 +1487,71 @@ function runIOS(cwd, options) {
   xcodebuild.stderr?.on("data", (data) => {
     const text = data.toString().trim();
     if (text.includes("error:") || text.includes("warning:")) {
-      console.log(pc3.dim(`  ${text}`));
+      console.log(pc4.dim(`  ${text}`));
     }
   });
   xcodebuild.on("close", (code) => {
     if (code !== 0) {
-      console.error(pc3.red(`  \u2717 Build failed (exit code ${code})`));
+      console.error(pc4.red(`  \u2717 Build failed (exit code ${code})`));
       process.exit(1);
     }
-    console.log(pc3.green("  \u2713 Build successful\n"));
+    console.log(pc4.green("  \u2713 Build successful\n"));
     if (options.device) {
-      console.log(pc3.green("  App built for device. Install via Xcode.\n"));
+      console.log(pc4.green("  App built for device. Install via Xcode.\n"));
       return;
     }
     const simulatorName = options.simulator;
-    const bundleId = options.bundleId || readBundleId(join3(cwd, "ios"));
-    console.log(pc3.white(`  Booting simulator "${simulatorName}"...`));
+    const bundleId = options.bundleId || readBundleId(join4(cwd, "ios"));
+    console.log(pc4.white(`  Booting simulator "${simulatorName}"...`));
     try {
-      execSync2(`xcrun simctl boot "${simulatorName}"`, { stdio: "pipe" });
+      execSync3(`xcrun simctl boot "${simulatorName}"`, { stdio: "pipe" });
     } catch {
     }
     try {
-      execSync2("open -a Simulator", { stdio: "pipe" });
+      execSync3("open -a Simulator", { stdio: "pipe" });
     } catch {
     }
-    const appPath = findAppPath(join3(cwd, "ios"));
+    const appPath = findAppPath(join4(cwd, "ios"));
     if (appPath) {
-      console.log(pc3.white(`  Installing app on simulator...`));
+      console.log(pc4.white(`  Installing app on simulator...`));
       try {
-        execSync2(`xcrun simctl install booted "${appPath}"`, { stdio: "pipe" });
-        console.log(pc3.green("  \u2713 App installed"));
+        execSync3(`xcrun simctl install booted "${appPath}"`, { stdio: "pipe" });
+        console.log(pc4.green("  \u2713 App installed"));
       } catch (err) {
-        console.error(pc3.red(`  \u2717 Failed to install app: ${err.message}`));
+        console.error(pc4.red(`  \u2717 Failed to install app: ${err.message}`));
         process.exit(1);
       }
-      console.log(pc3.white(`  Launching ${bundleId}...`));
+      console.log(pc4.white(`  Launching ${bundleId}...`));
       try {
-        execSync2(`xcrun simctl launch booted "${bundleId}"`, { stdio: "pipe" });
-        console.log(pc3.green(`  \u2713 App launched on ${simulatorName}
+        execSync3(`xcrun simctl launch booted "${bundleId}"`, { stdio: "pipe" });
+        console.log(pc4.green(`  \u2713 App launched on ${simulatorName}
 `));
       } catch (err) {
-        console.error(pc3.red(`  \u2717 Failed to launch app: ${err.message}`));
+        console.error(pc4.red(`  \u2717 Failed to launch app: ${err.message}`));
         process.exit(1);
       }
     } else {
-      console.log(pc3.yellow("  Could not locate .app bundle in DerivedData."));
-      console.log(pc3.dim("  Try running the app from Xcode directly.\n"));
+      console.log(pc4.yellow("  Could not locate .app bundle in DerivedData."));
+      console.log(pc4.dim("  Try running the app from Xcode directly.\n"));
     }
   });
 }
 function runAndroid(cwd, options) {
-  const androidDir = join3(cwd, "android");
-  if (!existsSync3(androidDir)) {
-    console.log(pc3.yellow("  No android/ directory found."));
-    console.log(pc3.dim("  To add Android support, create an Android project in the android/ directory."));
-    console.log(pc3.dim("  Bundle has been built to dist/vue-native-bundle.js\n"));
+  const androidDir = join4(cwd, "android");
+  if (!existsSync4(androidDir)) {
+    console.log(pc4.yellow("  No android/ directory found."));
+    console.log(pc4.dim("  To add Android support, create an Android project in the android/ directory."));
+    console.log(pc4.dim("  Bundle has been built to dist/vue-native-bundle.js\n"));
     return;
   }
-  const gradlew = join3(androidDir, "gradlew");
-  if (!existsSync3(gradlew)) {
-    console.error(pc3.red("  \u2717 gradlew not found in android/ directory"));
-    console.log(pc3.dim("  Make sure your Android project has the Gradle wrapper.\n"));
+  const gradlew = join4(androidDir, "gradlew");
+  if (!existsSync4(gradlew)) {
+    console.error(pc4.red("  \u2717 gradlew not found in android/ directory"));
+    console.log(pc4.dim("  Make sure your Android project has the Gradle wrapper.\n"));
     process.exit(1);
   }
-  console.log(pc3.white("  Building Android app with Gradle..."));
-  const gradle = spawn2(
+  console.log(pc4.white("  Building Android app with Gradle..."));
+  const gradle = spawn3(
     "./gradlew",
     ["assembleDebug"],
     {
@@ -1209,56 +1571,283 @@ function runAndroid(cwd, options) {
   gradle.stdout?.on("data", (data) => {
     const text = data.toString().trim();
     if (text) {
-      console.log(pc3.dim(`  ${text}`));
+      console.log(pc4.dim(`  ${text}`));
     }
   });
   gradle.stderr?.on("data", (data) => {
     const text = data.toString().trim();
     if (text.includes("ERROR") || text.includes("FAILURE")) {
-      console.log(pc3.red(`  ${text}`));
+      console.log(pc4.red(`  ${text}`));
     }
   });
   gradle.on("error", (err) => {
-    console.error(pc3.red(`  Gradle process error: ${err.message}`));
+    console.error(pc4.red(`  Gradle process error: ${err.message}`));
     cleanupGradle();
   });
   gradle.on("close", (code) => {
     if (code !== 0) {
-      console.error(pc3.red(`  \u2717 Gradle build failed (exit code ${code})`));
+      console.error(pc4.red(`  \u2717 Gradle build failed (exit code ${code})`));
       process.exit(1);
     }
-    console.log(pc3.green("  \u2713 Build successful\n"));
+    console.log(pc4.green("  \u2713 Build successful\n"));
     const apkPath = findApkPath(androidDir);
     if (!apkPath) {
-      console.log(pc3.yellow("  Could not locate debug APK."));
-      console.log(pc3.dim("  Expected at android/app/build/outputs/apk/debug/\n"));
+      console.log(pc4.yellow("  Could not locate debug APK."));
+      console.log(pc4.dim("  Expected at android/app/build/outputs/apk/debug/\n"));
       return;
     }
-    console.log(pc3.white("  Installing APK on device/emulator..."));
+    console.log(pc4.white("  Installing APK on device/emulator..."));
     try {
-      execSync2(`adb install -r "${apkPath}"`, { stdio: "pipe" });
-      console.log(pc3.green("  \u2713 APK installed"));
+      execSync3(`adb install -r "${apkPath}"`, { stdio: "pipe" });
+      console.log(pc4.green("  \u2713 APK installed"));
     } catch (err) {
-      console.error(pc3.red(`  \u2717 Failed to install APK: ${err.message}`));
-      console.log(pc3.dim("  Make sure an emulator is running or a device is connected (adb devices).\n"));
+      console.error(pc4.red(`  \u2717 Failed to install APK: ${err.message}`));
+      console.log(pc4.dim("  Make sure an emulator is running or a device is connected (adb devices).\n"));
       process.exit(1);
     }
     const componentName = `${options.package}/${options.activity}`;
-    console.log(pc3.white(`  Launching ${componentName}...`));
+    console.log(pc4.white(`  Launching ${componentName}...`));
     try {
-      execSync2(`adb shell am start -n "${componentName}"`, { stdio: "pipe" });
-      console.log(pc3.green(`  \u2713 App launched
+      execSync3(`adb shell am start -n "${componentName}"`, { stdio: "pipe" });
+      console.log(pc4.green(`  \u2713 App launched
 `));
     } catch (err) {
-      console.error(pc3.red(`  \u2717 Failed to launch app: ${err.message}`));
+      console.error(pc4.red(`  \u2717 Failed to launch app: ${err.message}`));
+      process.exit(1);
+    }
+  });
+}
+function runMacOS(cwd, options) {
+  const macosDir = join4(cwd, "macos");
+  if (!existsSync4(macosDir)) {
+    console.log(pc4.yellow("  No macos/ directory found."));
+    console.log(pc4.dim("  To add macOS support, create an Xcode project in the macos/ directory."));
+    console.log(pc4.dim("  Bundle has been built to dist/vue-native-bundle.js\n"));
+    return;
+  }
+  let xcodeProject = null;
+  for (const ext of [".xcworkspace", ".xcodeproj"]) {
+    try {
+      const entries = readdirSync2(macosDir);
+      const match = entries.find((e) => e.endsWith(ext));
+      if (match) {
+        xcodeProject = join4(macosDir, match);
+        break;
+      }
+    } catch {
+    }
+  }
+  if (!xcodeProject) {
+    console.log(pc4.yellow("  No Xcode project found in ./macos/"));
+    return;
+  }
+  const isWorkspace = xcodeProject.endsWith(".xcworkspace");
+  const scheme = options.scheme || xcodeProject.split("/").pop()?.replace(/\.(xcworkspace|xcodeproj)$/, "") || "App";
+  const projectFlag = isWorkspace ? "-workspace" : "-project";
+  console.log(pc4.white(`  Building ${scheme} for macOS...`));
+  const xcodebuild = spawn3(
+    "xcodebuild",
+    [projectFlag, xcodeProject, "-scheme", scheme, "-destination", "platform=macOS", "build"],
+    {
+      cwd,
+      stdio: "pipe",
+      env: { ...process.env, DEVELOPER_DIR: "/Applications/Xcode.app/Contents/Developer" }
+    }
+  );
+  xcodebuild.stderr?.on("data", (data) => {
+    const text = data.toString().trim();
+    if (text.includes("error:") || text.includes("warning:")) {
+      console.log(pc4.dim(`  ${text}`));
+    }
+  });
+  xcodebuild.on("close", (code) => {
+    if (code !== 0) {
+      console.error(pc4.red(`  \u2717 Build failed (exit code ${code})`));
       process.exit(1);
     }
+    console.log(pc4.green("  \u2713 Build successful\n"));
+    const derivedDataBase = join4(process.env.HOME || "~", "Library/Developer/Xcode/DerivedData");
+    let appPath = null;
+    if (existsSync4(derivedDataBase)) {
+      try {
+        const projects = readdirSync2(derivedDataBase);
+        for (const project of projects.reverse()) {
+          const productsDir = join4(derivedDataBase, project, "Build/Products/Debug");
+          if (existsSync4(productsDir)) {
+            const entries = readdirSync2(productsDir);
+            const app = entries.find((e) => e.endsWith(".app"));
+            if (app) {
+              appPath = join4(productsDir, app);
+              break;
+            }
+          }
+        }
+      } catch {
+      }
+    }
+    if (appPath) {
+      console.log(pc4.white(`  Launching ${appPath}...`));
+      try {
+        execSync3(`open "${appPath}"`, { stdio: "pipe" });
+        console.log(pc4.green(`  \u2713 App launched
+`));
+      } catch (err) {
+        console.error(pc4.red(`  \u2717 Failed to launch app: ${err.message}`));
+      }
+    } else {
+      console.log(pc4.yellow("  Could not locate .app bundle in DerivedData."));
+      console.log(pc4.dim("  Try running the app from Xcode directly.\n"));
+    }
   });
 }
 
+// src/commands/generate.ts
+import { Command as Command5 } from "commander";
+import { existsSync as existsSync5 } from "fs";
+import { join as join5 } from "path";
+import pc5 from "picocolors";
+import { parseDirectory } from "@thelacanians/vue-native-sfc-parser";
+import { generateCode, writeGeneratedFiles, cleanGeneratedFiles, validateNativeBlocks, formatValidationErrors } from "@thelacanians/vue-native-codegen";
+var generateCommand = new Command5("generate").description("Generate native code from <native> blocks in Vue SFC files").option("--root <path>", "project root directory", process.cwd()).option("--watch", "watch mode - regenerate on file changes").option("--clean", "clean generated files before generating").option("--ios-output <path>", "iOS Swift output directory").option("--android-output <path>", "Android Kotlin output directory").option("--macos-output <path>", "macOS Swift output directory").option("--ts-output <path>", "TypeScript output directory").option("--no-swift", "disable Swift generation").option("--no-kotlin", "disable Kotlin generation").option("--no-typescript", "disable TypeScript generation").option("--exclude <patterns>", "patterns to exclude (comma-separated)").action(async (options) => {
+  const cwd = options.root;
+  const appDir = join5(cwd, "app");
+  if (!existsSync5(appDir)) {
+    console.error(pc5.red(`Error: App directory not found at ${appDir}`));
+    console.error(pc5.yellow("Make sure you run this command from your project root."));
+    process.exit(1);
+  }
+  const codegenOptions = {
+    root: cwd,
+    includeHeader: true,
+    generateSwift: options.swift !== false,
+    generateKotlin: options.kotlin !== false,
+    generateTypeScript: options.typescript !== false
+  };
+  if (options.iosOutput) codegenOptions.iosOutputDir = options.iosOutput;
+  if (options.androidOutput) codegenOptions.androidOutputDir = options.androidOutput;
+  if (options.macosOutput) codegenOptions.macosOutputDir = options.macosOutput;
+  if (options.tsOutput) codegenOptions.typescriptOutputDir = options.tsOutput;
+  const exclude = options.exclude ? options.exclude.split(",").map((p) => p.trim()) : ["node_modules", "dist", ".git", ".turbo"];
+  async function runGeneration() {
+    console.log(pc5.cyan("\n\u{1F527} Vue Native Code Generator"));
+    console.log(pc5.dim("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n"));
+    try {
+      if (options.clean) {
+        console.log(pc5.yellow("\u{1F5D1}\uFE0F  Cleaning generated files..."));
+        cleanGeneratedFiles(codegenOptions, cwd);
+        console.log(pc5.green("\u2713 Cleaned\n"));
+      }
+      console.log(pc5.blue("\u{1F4C4} Scanning SFC files..."));
+      const parseResult = parseDirectory(".", {
+        root: cwd,
+        exclude
+      });
+      if (parseResult.errors.length > 0) {
+        console.log(pc5.yellow("\u26A0\uFE0F  Parse warnings:"));
+        parseResult.errors.forEach((err) => {
+          console.log(pc5.dim(`  - ${err.file}:${err.line || "?"} ${err.message}`));
+        });
+        console.log();
+      }
+      const blockCount = parseResult.allNativeBlocks.length;
+      console.log(pc5.green(`\u2713 Found ${blockCount} <native> block${blockCount !== 1 ? "s" : ""}`));
+      if (blockCount === 0) {
+        console.log(pc5.yellow("\n\u26A0\uFE0F  No <native> blocks found."));
+        console.log(pc5.dim('Add <native platform="ios"> or <native platform="android"> blocks to your SFC files.'));
+        return;
+      }
+      console.log(pc5.blue("\u{1F50D} Validating native code..."));
+      const validation = validateNativeBlocks(parseResult.allNativeBlocks);
+      if (!validation.isValid) {
+        console.log(pc5.red("\n\u274C Validation failed:"));
+        console.log(formatValidationErrors(validation));
+        process.exit(1);
+      }
+      if (validation.warnings.length > 0) {
+        console.log(pc5.yellow(`\u26A0\uFE0F  ${validation.warnings.length} warning${validation.warnings.length !== 1 ? "s" : ""}`));
+      } else {
+        console.log(pc5.green("\u2713 Validation passed"));
+      }
+      console.log();
+      const iosBlocks = parseResult.allNativeBlocks.filter((b) => b.platform === "ios" || b.platform === "macos");
+      const androidBlocks = parseResult.allNativeBlocks.filter((b) => b.platform === "android");
+      if (iosBlocks.length > 0) {
+        console.log(pc5.dim(`  - iOS/macOS: ${iosBlocks.length} block${iosBlocks.length !== 1 ? "s" : ""}`));
+      }
+      if (androidBlocks.length > 0) {
+        console.log(pc5.dim(`  - Android: ${androidBlocks.length} block${androidBlocks.length !== 1 ? "s" : ""}`));
+      }
+      console.log();
+      console.log(pc5.blue("\u2699\uFE0F  Generating code..."));
+      const codegenResult = generateCode(parseResult.allNativeBlocks, codegenOptions);
+      if (codegenResult.errors.length > 0) {
+        console.log(pc5.red("\n\u274C Generation errors:"));
+        codegenResult.errors.forEach((err) => {
+          console.log(pc5.red(`  - ${err.file} ${err.message}`));
+        });
+        process.exit(1);
+      }
+      console.log(pc5.blue("\u{1F4DD} Writing files..."));
+      const writeResult = writeGeneratedFiles(codegenResult, cwd);
+      if (writeResult.errors.length > 0) {
+        console.log(pc5.red("\n\u274C Write errors:"));
+        writeResult.errors.forEach((err) => {
+          console.log(pc5.red(`  - ${err.message}`));
+        });
+        process.exit(1);
+      }
+      console.log(pc5.green("\n\u2705 Generation complete!\n"));
+      console.log(pc5.dim("Generated files:"));
+      console.log(pc5.dim(`  - Swift:      ${codegenResult.stats.swiftFiles} file${codegenResult.stats.swiftFiles !== 1 ? "s" : ""}`));
+      console.log(pc5.dim(`  - Kotlin:     ${codegenResult.stats.kotlinFiles} file${codegenResult.stats.kotlinFiles !== 1 ? "s" : ""}`));
+      console.log(pc5.dim(`  - TypeScript: ${codegenResult.stats.typescriptFiles} file${codegenResult.stats.typescriptFiles !== 1 ? "s" : ""}`));
+      console.log();
+      if (codegenResult.warnings.length > 0) {
+        console.log(pc5.yellow("\u26A0\uFE0F  Warnings:"));
+        codegenResult.warnings.forEach((warn) => {
+          console.log(pc5.dim(`  - ${warn.message}`));
+        });
+        console.log();
+      }
+      console.log(pc5.green("\u{1F389} Ready to build!\n"));
+    } catch (error) {
+      console.error(pc5.red("\n\u274C Fatal error:"));
+      console.error(pc5.red(error.message));
+      console.error(pc5.dim(error.stack || ""));
+      process.exit(1);
+    }
+  }
+  await runGeneration();
+  if (options.watch) {
+    console.log(pc5.cyan("\n\u{1F441}\uFE0F  Watch mode enabled. Press Ctrl+C to stop.\n"));
+    const chokidar = await import("chokidar");
+    const watcher = chokidar.default.watch("app/**/*.vue", {
+      cwd,
+      ignored: exclude,
+      ignoreInitial: true
+    });
+    watcher.on("change", async (file) => {
+      console.log(pc5.dim(`[${(/* @__PURE__ */ new Date()).toLocaleTimeString()}]`) + pc5.blue(` Changed: ${file}`));
+      await runGeneration();
+    });
+    watcher.on("error", (error) => {
+      console.error(pc5.red("Watch error:"), error);
+    });
+    process.on("SIGINT", () => {
+      console.log(pc5.yellow("\n\u23F9\uFE0F  Stopping watch mode..."));
+      watcher.close();
+      process.exit(0);
+    });
+    await new Promise(() => {
+    });
+  }
+});
+
 // src/cli.ts
 program.name("vue-native").description("Vue Native \u2014 build native iOS and Android apps with Vue.js").version("0.1.0");
+program.addCommand(buildCommand);
 program.addCommand(createCommand);
 program.addCommand(devCommand);
 program.addCommand(runCommand);
+program.addCommand(generateCommand);
 program.parse(process.argv);