@thelacanians/vue-native-cli 0.1.0

package/dist/cli.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/cli.js

@@ -0,0 +1,754 @@
+#!/usr/bin/env node
+#!/usr/bin/env node
+
+// src/cli.ts
+import { program } from "commander";
+
+// src/commands/create.ts
+import { Command } from "commander";
+import { mkdir, writeFile } from "fs/promises";
+import { join } from "path";
+import pc from "picocolors";
+var createCommand = new Command("create").description("Create a new Vue Native project").argument("<name>", "project name").action(async (name) => {
+  const dir = join(process.cwd(), name);
+  console.log(pc.cyan(`
+Creating Vue Native project: ${pc.bold(name)}
+`));
+  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({
+      name,
+      version: "0.0.1",
+      private: true,
+      type: "module",
+      scripts: {
+        dev: "vue-native dev",
+        build: "vite build",
+        typecheck: "tsc --noEmit"
+      },
+      dependencies: {
+        "@thelacanians/vue-native-runtime": "^0.1.0",
+        "@thelacanians/vue-native-navigation": "^0.1.0",
+        "vue": "^3.5.0"
+      },
+      devDependencies: {
+        "@thelacanians/vue-native-vite-plugin": "^0.1.0",
+        "@vitejs/plugin-vue": "^5.0.0",
+        "vite": "^6.1.0",
+        "typescript": "^5.7.0"
+      }
+    }, null, 2));
+    await writeFile(join(dir, "vite.config.ts"), `import { defineConfig } from 'vite'
+import vue from '@vitejs/plugin-vue'
+import vueNative from '@thelacanians/vue-native-vite-plugin'
+
+export default defineConfig({
+  plugins: [vue(), vueNative()],
+})
+`);
+    await writeFile(join(dir, "tsconfig.json"), JSON.stringify({
+      compilerOptions: {
+        target: "ES2020",
+        module: "ESNext",
+        moduleResolution: "bundler",
+        strict: true,
+        jsx: "preserve",
+        lib: ["ES2020"],
+        types: []
+      },
+      include: ["app/**/*"]
+    }, null, 2));
+    await writeFile(join(dir, "app", "main.ts"), `import { createApp } from 'vue'
+import { createRouter } from '@thelacanians/vue-native-navigation'
+import App from './App.vue'
+import Home from './pages/Home.vue'
+
+const router = createRouter([
+  { name: 'Home', component: Home },
+])
+
+const app = createApp(App)
+app.use(router)
+app.start()
+`);
+    await writeFile(join(dir, "app", "App.vue"), `<template>
+  <VSafeArea :style="{ flex: 1, backgroundColor: '#ffffff' }">
+    <RouterView />
+  </VSafeArea>
+</template>
+
+<script setup lang="ts">
+import { RouterView } from '@thelacanians/vue-native-navigation'
+</script>
+`);
+    await writeFile(join(dir, "app", "pages", "Home.vue"), `<template>
+  <VView :style="styles.container">
+    <VText :style="styles.title">Hello, Vue Native! \u{1F389}</VText>
+    <VText :style="styles.subtitle">Edit app/pages/Home.vue to get started.</VText>
+    <VButton :style="styles.button" @press="count++">
+      <VText :style="styles.buttonText">Count: {{ count }}</VText>
+    </VButton>
+  </VView>
+</template>
+
+<script setup lang="ts">
+import { ref } from 'vue'
+import { createStyleSheet } from 'vue'
+
+const count = ref(0)
+
+const styles = createStyleSheet({
+  container: {
+    flex: 1,
+    justifyContent: 'center',
+    alignItems: 'center',
+    padding: 24,
+  },
+  title: {
+    fontSize: 28,
+    fontWeight: 'bold',
+    color: '#1a1a1a',
+    marginBottom: 8,
+    textAlign: 'center',
+  },
+  subtitle: {
+    fontSize: 16,
+    color: '#666',
+    textAlign: 'center',
+    marginBottom: 32,
+  },
+  button: {
+    backgroundColor: '#4f46e5',
+    paddingHorizontal: 32,
+    paddingVertical: 14,
+    borderRadius: 12,
+  },
+  buttonText: {
+    color: '#ffffff',
+    fontSize: 18,
+    fontWeight: '600',
+  },
+})
+</script>
+`);
+    const iosDir = join(dir, "ios");
+    const iosSrcDir = join(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}
+options:
+  bundleIdPrefix: com.vuenative
+  deploymentTarget:
+    iOS: "16.0"
+  xcodeVersion: "15.0"
+
+packages:
+  VueNativeCore:
+    path: ../native/ios
+
+targets:
+  ${xcodeProjectName}:
+    type: application
+    platform: iOS
+    sources:
+      - Sources
+    dependencies:
+      - package: VueNativeCore
+    settings:
+      base:
+        PRODUCT_BUNDLE_IDENTIFIER: ${bundleId}
+        INFOPLIST_FILE: Sources/Info.plist
+        SWIFT_VERSION: "5.9"
+        GENERATE_INFOPLIST_FILE: false
+    resources:
+      - path: ../dist/vue-native-bundle.js
+        optional: true
+`);
+    await writeFile(join(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>
+  <key>CFBundleDevelopmentRegion</key>
+  <string>en</string>
+  <key>CFBundleDisplayName</key>
+  <string>${name}</string>
+  <key>CFBundleExecutable</key>
+  <string>$(EXECUTABLE_NAME)</string>
+  <key>CFBundleIdentifier</key>
+  <string>${bundleId}</string>
+  <key>CFBundleInfoDictionaryVersion</key>
+  <string>6.0</string>
+  <key>CFBundleName</key>
+  <string>$(PRODUCT_NAME)</string>
+  <key>CFBundlePackageType</key>
+  <string>APPL</string>
+  <key>CFBundleShortVersionString</key>
+  <string>1.0</string>
+  <key>CFBundleVersion</key>
+  <string>1</string>
+  <key>LSRequiresIPhoneOS</key>
+  <true/>
+  <key>UIApplicationSceneManifest</key>
+  <dict>
+    <key>UIApplicationSupportsMultipleScenes</key>
+    <false/>
+    <key>UISceneConfigurations</key>
+    <dict>
+      <key>UIWindowSceneSessionRoleApplication</key>
+      <array>
+        <dict>
+          <key>UISceneConfigurationName</key>
+          <string>Default Configuration</string>
+          <key>UISceneDelegateClassName</key>
+          <string>$(PRODUCT_MODULE_NAME).SceneDelegate</string>
+        </dict>
+      </array>
+    </dict>
+  </dict>
+  <key>UILaunchScreen</key>
+  <dict/>
+  <key>UISupportedInterfaceOrientations</key>
+  <array>
+    <string>UIInterfaceOrientationPortrait</string>
+    <string>UIInterfaceOrientationLandscapeLeft</string>
+    <string>UIInterfaceOrientationLandscapeRight</string>
+  </array>
+</dict>
+</plist>
+`);
+    await writeFile(join(iosSrcDir, "AppDelegate.swift"), `import UIKit
+
+@main
+class AppDelegate: UIResponder, UIApplicationDelegate {
+    func application(
+        _ application: UIApplication,
+        didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?
+    ) -> Bool {
+        return true
+    }
+
+    // MARK: UISceneSession Lifecycle
+    func application(
+        _ application: UIApplication,
+        configurationForConnecting connectingSceneSession: UISceneSession,
+        options: UIScene.ConnectionOptions
+    ) -> UISceneConfiguration {
+        return UISceneConfiguration(
+            name: "Default Configuration",
+            sessionRole: connectingSceneSession.role
+        )
+    }
+}
+`);
+    await writeFile(join(iosSrcDir, "SceneDelegate.swift"), `import UIKit
+import VueNativeCore
+
+class SceneDelegate: UIResponder, UIWindowSceneDelegate {
+    var window: UIWindow?
+
+    func scene(
+        _ scene: UIScene,
+        willConnectTo session: UISceneSession,
+        options connectionOptions: UIScene.ConnectionOptions
+    ) {
+        guard let windowScene = scene as? UIWindowScene else { return }
+
+        let window = UIWindow(windowScene: windowScene)
+        window.rootViewController = AppViewController()
+        window.makeKeyAndVisible()
+        self.window = window
+    }
+}
+
+class AppViewController: VueNativeViewController {
+    override var bundleName: String { "vue-native-bundle" }
+
+    #if DEBUG
+    override var devServerURL: URL? { URL(string: "ws://localhost:8174") }
+    #endif
+}
+`);
+    const androidDir = join(dir, "android");
+    const androidAppDir = join(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);
+    await mkdir(androidKotlinDir, { recursive: true });
+    await writeFile(join(androidDir, "build.gradle.kts"), `// Top-level build file
+plugins {
+    id("com.android.application") version "8.2.2" apply false
+    id("com.android.library") version "8.2.2" apply false
+    id("org.jetbrains.kotlin.android") version "1.9.22" apply false
+}
+`);
+    await writeFile(join(androidDir, "settings.gradle.kts"), `pluginManagement {
+    repositories {
+        google()
+        mavenCentral()
+        gradlePluginPortal()
+    }
+}
+dependencyResolutionManagement {
+    repositoriesMode.set(RepositoriesMode.FAIL_ON_PROJECT_REPOS)
+    repositories {
+        google()
+        mavenCentral()
+        maven { url = uri("https://jitpack.io") }
+    }
+}
+
+rootProject.name = "${name}"
+include(":app")
+include(":VueNativeCore")
+project(":VueNativeCore").projectDir = file("../native/android/VueNativeCore")
+`);
+    await writeFile(join(androidAppDir, "build.gradle.kts"), `plugins {
+    id("com.android.application")
+    id("org.jetbrains.kotlin.android")
+}
+
+android {
+    namespace = "${androidPkg}"
+    compileSdk = 34
+
+    defaultConfig {
+        applicationId = "${androidPkg}"
+        minSdk = 21
+        targetSdk = 34
+        versionCode = 1
+        versionName = "1.0"
+    }
+
+    buildTypes {
+        release {
+            isMinifyEnabled = false
+            proguardFiles(
+                getDefaultProguardFile("proguard-android-optimize.txt"),
+                "proguard-rules.pro"
+            )
+        }
+    }
+
+    compileOptions {
+        sourceCompatibility = JavaVersion.VERSION_17
+        targetCompatibility = JavaVersion.VERSION_17
+    }
+
+    kotlinOptions {
+        jvmTarget = "17"
+    }
+}
+
+dependencies {
+    implementation(project(":VueNativeCore"))
+}
+`);
+    await writeFile(join(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" />
+
+    <application
+        android:allowBackup="true"
+        android:label="${name}"
+        android:supportsRtl="true"
+        android:theme="@style/Theme.AppCompat.Light.NoActionBar"
+        android:usesCleartextTraffic="true">
+        <activity
+            android:name=".MainActivity"
+            android:exported="true">
+            <intent-filter>
+                <action android:name="android.intent.action.MAIN" />
+                <category android:name="android.intent.category.LAUNCHER" />
+            </intent-filter>
+        </activity>
+    </application>
+</manifest>
+`);
+    await writeFile(join(androidKotlinDir, "MainActivity.kt"), `package ${androidPkg}
+
+import com.vuenative.core.VueNativeActivity
+
+class MainActivity : VueNativeActivity() {
+    override fun getBundleAssetPath(): String {
+        return "vue-native-bundle.js"
+    }
+
+    override fun getDevServerUrl(): String? {
+        return "ws://10.0.2.2:8174"
+    }
+}
+`);
+    await writeFile(join(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
+`);
+    console.log(pc.green("\u2713 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.white("  vue-native run android\n"));
+  } catch (err) {
+    console.error(pc.red(`Error creating project: ${err.message}`));
+    process.exit(1);
+  }
+});
+
+// src/commands/dev.ts
+import { Command as Command2 } from "commander";
+import { spawn } from "child_process";
+import { readFile } from "fs/promises";
+import { join as join2 } from "path";
+import { watch } from "chokidar";
+import { WebSocketServer, WebSocket } from "ws";
+import pc2 from "picocolors";
+var DEFAULT_PORT = 8174;
+var BUNDLE_FILE = "dist/vue-native-bundle.js";
+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)).action(async (options) => {
+  const port = parseInt(options.port, 10);
+  const cwd = process.cwd();
+  const bundlePath = join2(cwd, BUNDLE_FILE);
+  console.log(pc2.cyan("\n\u26A1 Vue Native Dev Server\n"));
+  const wss = new WebSocketServer({ port });
+  const clients = /* @__PURE__ */ new Set();
+  wss.on("connection", (ws) => {
+    clients.add(ws);
+    ws.send(JSON.stringify({ type: "connected" }));
+    console.log(pc2.green(`  iOS 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)`));
+      }
+    }).catch(() => {
+    });
+    ws.on("close", () => {
+      clients.delete(ws);
+      console.log(pc2.dim(`  iOS client disconnected (${clients.size} remaining)`));
+    });
+    ws.on("message", (data) => {
+      try {
+        const msg = JSON.parse(data.toString());
+        if (msg.type === "pong") return;
+      } catch {
+      }
+    });
+  });
+  wss.on("error", (err) => {
+    console.error(pc2.red(`WebSocket server error: ${err.message}`));
+  });
+  console.log(pc2.white(`  Hot reload server: ${pc2.bold(`ws://localhost:${port}`)}`));
+  console.log(pc2.dim("  Waiting for iOS app to connect...\n"));
+  console.log(pc2.white("  Starting Vite build watcher...\n"));
+  const vite = spawn(
+    "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}`));
+  });
+  vite.stderr?.on("data", (data) => {
+    const text = data.toString().trim();
+    if (text) console.log(pc2.yellow(`  [vite] ${text}`));
+  });
+  vite.on("error", (err) => {
+    console.error(pc2.red(`Vite error: ${err.message}`));
+  });
+  const watcher = watch(bundlePath, {
+    persistent: true,
+    ignoreInitial: false,
+    awaitWriteFinish: { stabilityThreshold: 100, pollInterval: 50 }
+  });
+  watcher.on("add", broadcastBundle);
+  watcher.on("change", broadcastBundle);
+  async function broadcastBundle() {
+    try {
+      const bundle = await readFile(bundlePath, "utf8");
+      const payload = JSON.stringify({ type: "bundle", bundle });
+      let sent = 0;
+      for (const client of clients) {
+        if (client.readyState === WebSocket.OPEN) {
+          client.send(payload);
+          sent++;
+        }
+      }
+      console.log(pc2.green(`  \u2713 Bundle updated (${Math.round(bundle.length / 1024)}KB) \u2192 sent to ${sent} client(s)`));
+    } catch (err) {
+    }
+  }
+  setInterval(() => {
+    for (const client of clients) {
+      if (client.readyState === WebSocket.OPEN) {
+        client.send(JSON.stringify({ type: "ping" }));
+      }
+    }
+  }, 3e4);
+  process.on("SIGINT", () => {
+    console.log(pc2.yellow("\n  Shutting down dev server..."));
+    vite.kill();
+    wss.close();
+    process.exit(0);
+  });
+});
+
+// src/commands/run.ts
+import { Command as Command3 } from "commander";
+import { spawn as spawn2, execSync } from "child_process";
+import { existsSync, readdirSync, readFileSync } from "fs";
+import { join as join3 } from "path";
+import pc3 from "picocolors";
+function findAppPath(buildDir) {
+  const derivedDataBase = join3(
+    process.env.HOME || "~",
+    "Library/Developer/Xcode/DerivedData"
+  );
+  if (existsSync(derivedDataBase)) {
+    try {
+      const projects = readdirSync(derivedDataBase);
+      for (const project of projects.reverse()) {
+        const productsDir = join3(
+          derivedDataBase,
+          project,
+          "Build/Products/Debug-iphonesimulator"
+        );
+        if (existsSync(productsDir)) {
+          const entries = readdirSync(productsDir);
+          const app = entries.find((e) => e.endsWith(".app"));
+          if (app) {
+            return join3(productsDir, app);
+          }
+        }
+      }
+    } catch {
+    }
+  }
+  return null;
+}
+function readBundleId(iosDir) {
+  const plistPath = join3(iosDir, "Sources", "Info.plist");
+  if (existsSync(plistPath)) {
+    try {
+      const content = readFileSync(plistPath, "utf8");
+      const match = content.match(
+        /<key>CFBundleIdentifier<\/key>\s*<string>([^<]+)<\/string>/
+      );
+      if (match) {
+        return match[1];
+      }
+    } catch {
+    }
+  }
+  return "com.vuenative.app";
+}
+function findApkPath(androidDir) {
+  const apkDir = join3(androidDir, "app", "build", "outputs", "apk", "debug");
+  if (existsSync(apkDir)) {
+    try {
+      const entries = readdirSync(apkDir);
+      const apk = entries.find((e) => e.endsWith(".apk") && !e.includes("androidTest"));
+      if (apk) {
+        return join3(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"'));
+    process.exit(1);
+  }
+  const cwd = process.cwd();
+  console.log(pc3.cyan(`
+\u{1F4F1} Vue Native \u2014 Run ${platform === "ios" ? "iOS" : "Android"}
+`));
+  console.log(pc3.white("  Building JS bundle..."));
+  try {
+    execSync("bun run vite build", { cwd, stdio: "inherit" });
+    console.log(pc3.green("  \u2713 Bundle built\n"));
+  } catch {
+    console.error(pc3.red("  \u2717 Bundle build failed"));
+    process.exit(1);
+  }
+  if (platform === "ios") {
+    runIOS(cwd, options);
+  } else {
+    runAndroid(cwd, options);
+  }
+});
+function runIOS(cwd, options) {
+  let xcodeProject = null;
+  const iosDir = join3(cwd, "ios");
+  if (existsSync(iosDir)) {
+    for (const ext of [".xcworkspace", ".xcodeproj"]) {
+      try {
+        const entries = readdirSync(iosDir);
+        const match = entries.find((e) => e.endsWith(ext));
+        if (match) {
+          xcodeProject = join3(iosDir, match);
+          break;
+        }
+      } catch {
+      }
+    }
+  }
+  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"));
+    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(
+    "xcodebuild",
+    [projectFlag, xcodeProject, "-scheme", scheme, "-destination", destination, "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(pc3.dim(`  ${text}`));
+    }
+  });
+  xcodebuild.on("close", (code) => {
+    if (code !== 0) {
+      console.error(pc3.red(`  \u2717 Build failed (exit code ${code})`));
+      process.exit(1);
+    }
+    console.log(pc3.green("  \u2713 Build successful\n"));
+    if (options.device) {
+      console.log(pc3.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}"...`));
+    try {
+      execSync(`xcrun simctl boot "${simulatorName}"`, { stdio: "pipe" });
+    } catch {
+    }
+    try {
+      execSync("open -a Simulator", { stdio: "pipe" });
+    } catch {
+    }
+    const appPath = findAppPath(join3(cwd, "ios"));
+    if (appPath) {
+      console.log(pc3.white(`  Installing app on simulator...`));
+      try {
+        execSync(`xcrun simctl install booted "${appPath}"`, { stdio: "pipe" });
+        console.log(pc3.green("  \u2713 App installed"));
+      } catch (err) {
+        console.error(pc3.red(`  \u2717 Failed to install app: ${err.message}`));
+        process.exit(1);
+      }
+      console.log(pc3.white(`  Launching ${bundleId}...`));
+      try {
+        execSync(`xcrun simctl launch booted "${bundleId}"`, { stdio: "pipe" });
+        console.log(pc3.green(`  \u2713 App launched on ${simulatorName}
+`));
+      } catch (err) {
+        console.error(pc3.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"));
+    }
+  });
+}
+function runAndroid(cwd, options) {
+  const androidDir = join3(cwd, "android");
+  if (!existsSync(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"));
+    return;
+  }
+  const gradlew = join3(androidDir, "gradlew");
+  if (!existsSync(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"));
+    process.exit(1);
+  }
+  console.log(pc3.white("  Building Android app with Gradle..."));
+  const gradle = spawn2(
+    "./gradlew",
+    ["assembleDebug"],
+    {
+      cwd: androidDir,
+      stdio: "pipe",
+      env: { ...process.env }
+    }
+  );
+  gradle.stdout?.on("data", (data) => {
+    const text = data.toString().trim();
+    if (text) {
+      console.log(pc3.dim(`  ${text}`));
+    }
+  });
+  gradle.stderr?.on("data", (data) => {
+    const text = data.toString().trim();
+    if (text.includes("ERROR") || text.includes("FAILURE")) {
+      console.log(pc3.red(`  ${text}`));
+    }
+  });
+  gradle.on("close", (code) => {
+    if (code !== 0) {
+      console.error(pc3.red(`  \u2717 Gradle build failed (exit code ${code})`));
+      process.exit(1);
+    }
+    console.log(pc3.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"));
+      return;
+    }
+    console.log(pc3.white("  Installing APK on device/emulator..."));
+    try {
+      execSync(`adb install -r "${apkPath}"`, { stdio: "pipe" });
+      console.log(pc3.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"));
+      process.exit(1);
+    }
+    const componentName = `${options.package}/${options.activity}`;
+    console.log(pc3.white(`  Launching ${componentName}...`));
+    try {
+      execSync(`adb shell am start -n "${componentName}"`, { stdio: "pipe" });
+      console.log(pc3.green(`  \u2713 App launched
+`));
+    } catch (err) {
+      console.error(pc3.red(`  \u2717 Failed to launch app: ${err.message}`));
+      process.exit(1);
+    }
+  });
+}
+
+// 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(createCommand);
+program.addCommand(devCommand);
+program.addCommand(runCommand);
+program.parse(process.argv);

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@thelacanians/vue-native-cli",
+  "version": "0.1.0",
+  "description": "CLI for creating and running Vue Native apps",
+  "license": "MIT",
+  "author": "Vue Native Contributors",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/abdul-hamid-achik/vue-native",
+    "directory": "packages/cli"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "type": "module",
+  "bin": {
+    "vue-native": "./dist/cli.js"
+  },
+  "exports": {
+    ".": "./dist/cli.js"
+  },
+  "files": ["dist"],
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "typecheck": "tsc --noEmit",
+    "clean": "rm -rf dist"
+  },
+  "dependencies": {
+    "commander": "^12.1.0",
+    "ws": "^8.18.0",
+    "chokidar": "^3.6.0",
+    "picocolors": "^1.1.0"
+  },
+  "devDependencies": {
+    "@types/ws": "^8.5.13",
+    "@types/node": "^22.0.0",
+    "tsup": "^8.4.0",
+    "typescript": "^5.7.0"
+  }
+}