@react-native-native/cli 0.1.0

package/scripts/setup-kotlin.js

@@ -0,0 +1,314 @@
+#!/usr/bin/env node
+
+/**
+ * setup-kotlin.js — Sets up basic Kotlin dev hot-reload toolchain.
+ *
+ * Downloads the embeddable Kotlin compiler + stdlib from Maven into
+ * the Gradle cache (or a local dir) so the Kotlin daemon can start
+ * without needing a full Android build first.
+ *
+ * Run: npx @react-native-native/cli setup-kotlin
+ */
+
+const fs = require('fs');
+const path = require('path');
+const https = require('https');
+const readline = require('readline');
+
+const gradleCache = path.join(process.env.HOME || '', '.gradle/caches/modules-2/files-2.1');
+
+// ── Kotlin version detection ──────────────────────────────────────────
+
+function detectKotlinVersion(projectRoot) {
+  // 1. app.json → expo-build-properties override
+  try {
+    const appJson = JSON.parse(fs.readFileSync(path.join(projectRoot, 'app.json'), 'utf8'));
+    const plugins = appJson?.expo?.plugins || [];
+    for (const p of plugins) {
+      if (Array.isArray(p) && p[0] === 'expo-build-properties') {
+        const v = p[1]?.android?.kotlinVersion;
+        if (v) return { version: v, source: 'expo-build-properties' };
+      }
+    }
+  } catch {}
+
+  // 2. nativ-fabric build.gradle → the version the package actually uses
+  const nativFabricPaths = [
+    path.join(projectRoot, 'node_modules/@react-native-native/nativ-fabric/android/build.gradle'),
+    // Hoisted in monorepo
+    ...(() => {
+      const results = [];
+      let dir = projectRoot;
+      for (let i = 0; i < 5; i++) {
+        dir = path.dirname(dir);
+        results.push(path.join(dir, 'node_modules/@react-native-native/nativ-fabric/android/build.gradle'));
+      }
+      return results;
+    })(),
+  ];
+  for (const p of nativFabricPaths) {
+    try {
+      const content = fs.readFileSync(p, 'utf8');
+      const m = content.match(/kotlinVersion\s*:\s*"([^"]+)"/);
+      if (m) return { version: m[1], source: 'nativ-fabric' };
+    } catch {}
+  }
+
+  // 3. expo-modules-core → default Kotlin version for this SDK
+  const expoCorePaths = [
+    path.join(projectRoot, 'node_modules/expo-modules-core/android/ExpoModulesCorePlugin.gradle'),
+    // Hoisted in monorepo
+    ...(() => {
+      const results = [];
+      let dir = projectRoot;
+      for (let i = 0; i < 5; i++) {
+        dir = path.dirname(dir);
+        results.push(path.join(dir, 'node_modules/expo-modules-core/android/ExpoModulesCorePlugin.gradle'));
+      }
+      return results;
+    })(),
+  ];
+  for (const p of expoCorePaths) {
+    try {
+      const content = fs.readFileSync(p, 'utf8');
+      // Parse: ? project.rootProject.ext.get("kotlinVersion") : "2.0.21"
+      const m = content.match(/project\.rootProject\.ext\.get\("kotlinVersion"\)\s*:\s*"([^"]+)"/);
+      if (m) return { version: m[1], source: 'expo-modules-core' };
+    } catch {}
+  }
+
+  // 3. Existing android/build.gradle
+  try {
+    const bg = fs.readFileSync(path.join(projectRoot, 'android/build.gradle'), 'utf8');
+    const m = bg.match(/kotlinVersion\s*=\s*["']([^"']+)["']/);
+    if (m) return { version: m[1], source: 'android/build.gradle' };
+  } catch {}
+
+  return null;
+}
+
+function readConfig(projectRoot) {
+  const configPath = path.join(projectRoot, '.nativ/nativ.config.json');
+  try { return JSON.parse(fs.readFileSync(configPath, 'utf8')); } catch {}
+  return {};
+}
+
+function writeConfig(projectRoot, config) {
+  const configPath = path.join(projectRoot, '.nativ/nativ.config.json');
+  fs.mkdirSync(path.dirname(configPath), { recursive: true });
+  fs.writeFileSync(configPath, JSON.stringify(config, null, 2) + '\n');
+}
+
+function ask(question) {
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  return new Promise(resolve => rl.question(question, answer => { rl.close(); resolve(answer.trim()); }));
+}
+
+function download(url, dest) {
+  return new Promise((resolve, reject) => {
+    console.log(`  Downloading ${path.basename(dest)}...`);
+    fs.mkdirSync(path.dirname(dest), { recursive: true });
+    const file = fs.createWriteStream(dest);
+    const request = https.get(url, (response) => {
+      if (response.statusCode === 301 || response.statusCode === 302) {
+        file.close();
+        fs.unlinkSync(dest);
+        return download(response.headers.location, dest).then(resolve, reject);
+      }
+      if (response.statusCode !== 200) {
+        file.close();
+        fs.unlinkSync(dest);
+        return reject(new Error(`HTTP ${response.statusCode}`));
+      }
+      response.pipe(file);
+      file.on('finish', () => { file.close(); resolve(); });
+    });
+    request.on('error', (err) => {
+      try { fs.unlinkSync(dest); } catch {}
+      reject(err);
+    });
+  });
+}
+
+function findJar(group, artifact) {
+  const dir = path.join(gradleCache, group, artifact);
+  if (!fs.existsSync(dir)) return null;
+  try {
+    const { execSync } = require('child_process');
+    return execSync(
+      `find "${dir}" -name "*.jar" -not -name "*sources*" -not -name "*javadoc*" 2>/dev/null | sort -V | tail -1`,
+      { encoding: 'utf8' }
+    ).trim() || null;
+  } catch { return null; }
+}
+
+const MAVEN = 'https://repo1.maven.org/maven2';
+
+const jars = [
+  ['org.jetbrains.kotlin', 'kotlin-compiler-embeddable'],
+  ['org.jetbrains.kotlin', 'kotlin-stdlib'],
+  ['org.jetbrains.kotlin', 'kotlin-script-runtime'],
+  ['org.jetbrains.kotlinx', 'kotlinx-coroutines-core-jvm'],
+  ['org.jetbrains.intellij.deps', 'trove4j'],
+  ['org.jetbrains', 'annotations'],
+];
+
+async function main() {
+  console.log('React Native Native — Kotlin dev toolchain setup\n');
+
+  const projectRoot = process.cwd();
+  const config = readConfig(projectRoot);
+
+  // ── Detect or ask for Kotlin version ────────────────────────────────
+  let kotlinVersion = config.kotlin?.version;
+  if (!kotlinVersion) {
+    const detected = detectKotlinVersion(projectRoot);
+    if (detected) {
+      console.log(`  Detected Kotlin ${detected.version} (from ${detected.source})`);
+      const answer = await ask(`  Use this version? [Y/n] `);
+      kotlinVersion = (answer.toLowerCase() === 'n') ? null : detected.version;
+    }
+    if (!kotlinVersion) {
+      const answer = await ask(`  Enter Kotlin version [2.0.21]: `);
+      kotlinVersion = answer || '2.0.21';
+    }
+    config.kotlin = { ...config.kotlin, version: kotlinVersion };
+    writeConfig(projectRoot, config);
+    console.log(`✓ Kotlin version: ${kotlinVersion} (saved to .nativ/nativ.config.json)\n`);
+  } else {
+    console.log(`✓ Kotlin version: ${kotlinVersion} (from .nativ/nativ.config.json)\n`);
+  }
+
+  const KOTLIN_VERSION = kotlinVersion;
+  let allFound = true;
+
+  for (const [group, artifact] of jars) {
+    const existing = findJar(group, artifact);
+    if (existing) {
+      console.log(`✓ ${artifact} (in Gradle cache)`);
+      continue;
+    }
+
+    allFound = false;
+
+    // Download to a local cache dir
+    const localDir = path.join(process.cwd(), '.nativ/kotlin-cache');
+    fs.mkdirSync(localDir, { recursive: true });
+
+    // Determine version — most are Kotlin version, some differ
+    let version = KOTLIN_VERSION;
+    if (artifact === 'trove4j') version = '1.0.20200330';
+    if (artifact === 'annotations') version = '13.0';
+    if (artifact === 'kotlinx-coroutines-core-jvm') version = '1.9.0';
+
+    const groupPath = group.replace(/\./g, '/');
+    const url = `${MAVEN}/${groupPath}/${artifact}/${version}/${artifact}-${version}.jar`;
+    const dest = path.join(localDir, `${artifact}-${version}.jar`);
+
+    if (fs.existsSync(dest)) {
+      console.log(`✓ ${artifact} (in local cache)`);
+      continue;
+    }
+
+    try {
+      await download(url, dest);
+      const size = fs.statSync(dest).size;
+      console.log(`✓ ${artifact}-${version}.jar (${(size / 1024 / 1024).toFixed(1)}MB)`);
+    } catch (e) {
+      console.error(`✗ Failed to download ${artifact}: ${e.message}`);
+    }
+  }
+
+  // ── android.jar (API stubs for type resolution) ──────────────────────
+  const androidHome = process.env.ANDROID_HOME || process.env.ANDROID_SDK_ROOT
+    || path.join(process.env.HOME || '', 'Library/Android/sdk');
+  const platformsDir = path.join(androidHome, 'platforms');
+  let hasAndroidJar = false;
+
+  if (fs.existsSync(platformsDir)) {
+    const platforms = fs.readdirSync(platformsDir).sort();
+    if (platforms.length > 0) {
+      const jar = path.join(platformsDir, platforms[platforms.length - 1], 'android.jar');
+      if (fs.existsSync(jar)) {
+        console.log(`✓ android.jar (${platforms[platforms.length - 1]})`);
+        hasAndroidJar = true;
+      }
+    }
+  }
+
+  if (!hasAndroidJar) {
+    // Download a minimal android.jar from Google's Maven
+    const localDir = path.join(process.cwd(), '.nativ/kotlin-cache');
+    const androidJarDest = path.join(localDir, 'android.jar');
+    if (fs.existsSync(androidJarDest)) {
+      console.log(`✓ android.jar (in local cache)`);
+    } else {
+      console.log('  Android SDK not found — downloading android.jar...');
+      // android.jar from the SDK's platforms dir. Google hosts them at dl.google.com.
+      // We use the android-34 platform as a stable baseline.
+      const androidJarUrl = 'https://dl.google.com/android/repository/platform-34_r03.zip';
+      const zipDest = path.join(localDir, 'platform-34.zip');
+      try {
+        await download(androidJarUrl, zipDest);
+        // Extract just android.jar from the zip
+        const { execSync } = require('child_process');
+        execSync(`unzip -o -q "${zipDest}" "android-34/android.jar" -d "${localDir}" 2>/dev/null`, { stdio: 'pipe' });
+        const extracted = path.join(localDir, 'android-34/android.jar');
+        if (fs.existsSync(extracted)) {
+          fs.renameSync(extracted, androidJarDest);
+          try { fs.rmdirSync(path.join(localDir, 'android-34')); } catch {}
+        }
+        try { fs.unlinkSync(zipDest); } catch {}
+        if (fs.existsSync(androidJarDest)) {
+          const size = fs.statSync(androidJarDest).size;
+          console.log(`✓ android.jar (${(size / 1024 / 1024).toFixed(1)}MB, downloaded)`);
+        }
+      } catch (e) {
+        console.warn(`⚠ Failed to download android.jar: ${e.message}`);
+        console.warn('  Install Android Studio or set $ANDROID_HOME');
+      }
+    }
+  }
+
+  // ── d8 (.class → .dex conversion) ───────────────────────────────────
+  const btDir = path.join(androidHome, 'build-tools');
+  let hasD8 = false;
+
+  if (fs.existsSync(btDir)) {
+    const versions = fs.readdirSync(btDir).sort();
+    if (versions.length > 0) {
+      console.log(`✓ d8 (Android build-tools ${versions[versions.length - 1]})`);
+      hasD8 = true;
+    }
+  }
+
+  if (!hasD8) {
+    // Download d8 (R8) from Maven — it's a standalone JAR
+    const localDir = path.join(process.cwd(), '.nativ/kotlin-cache');
+    const d8Dest = path.join(localDir, 'd8.jar');
+    if (fs.existsSync(d8Dest)) {
+      console.log(`✓ d8 (in local cache)`);
+    } else {
+      const R8_VERSION = '8.5.35';
+      const d8Url = `${MAVEN}/com/android/tools/r8/${R8_VERSION}/r8-${R8_VERSION}.jar`;
+      try {
+        await download(d8Url, d8Dest);
+        const size = fs.statSync(d8Dest).size;
+        console.log(`✓ d8/r8 (${(size / 1024 / 1024).toFixed(1)}MB, downloaded)`);
+      } catch (e) {
+        console.warn(`⚠ Failed to download d8: ${e.message}`);
+        console.warn('  Install Android Studio or set $ANDROID_HOME');
+      }
+    }
+  }
+
+  console.log('\nDone. Kotlin hot-reload is ready.');
+  if (!allFound || !hasAndroidJar || !hasD8) {
+    console.log('Note: Missing tools were cached in .nativ/kotlin-cache/');
+  }
+}
+
+main().catch(e => {
+  console.error('Setup failed:', e.message);
+  process.exit(1);
+});

package/scripts/setup-rust.js

@@ -0,0 +1,123 @@
+#!/usr/bin/env node
+
+/**
+ * setup-rust.js — Sets up Rust toolchain for native hot-reload.
+ *
+ * - Verifies Rust is installed (rustc + cargo)
+ * - Adds iOS and Android cross-compilation targets
+ * - Creates Cargo.toml with nativ-core dependency from crates.io
+ *
+ * Run: npx @react-native-native/cli setup-rust
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+
+function run(cmd) {
+  try {
+    return execSync(cmd, { encoding: 'utf8', stdio: 'pipe' }).trim();
+  } catch { return null; }
+}
+
+async function main() {
+  console.log('React Native Native — Rust dev toolchain setup\n');
+
+  const projectRoot = process.cwd();
+
+  // ── 1. Check Rust toolchain ─────────────────────────────────────────
+  const rustcVersion = run('rustc --version');
+  if (!rustcVersion) {
+    console.error('✗ Rust not found.');
+    console.error('  Install: curl --proto \'=https\' --tlsv1.2 -sSf https://sh.rustup.rs | sh');
+    process.exit(1);
+  }
+  console.log(`✓ ${rustcVersion}`);
+
+  const cargoVersion = run('cargo --version');
+  if (cargoVersion) console.log(`✓ ${cargoVersion}`);
+
+  // ── 2. Check/install cross-compilation targets ──────────────────────
+  const installed = run('rustup target list --installed') || '';
+
+  const platformArg = process.argv.find((a, i) => i > 0 && process.argv[i - 1] === '--platform') || 'all';
+  const wantIOS = platformArg === 'all' || platformArg === 'ios';
+  const wantAndroid = platformArg === 'all' || platformArg === 'android';
+
+  const targets = [
+    ...(wantIOS ? [
+      'aarch64-apple-ios',           // iOS device + App Store
+      'aarch64-apple-ios-sim',       // iOS simulator (Apple Silicon)
+    ] : []),
+    ...(wantAndroid ? [
+      'aarch64-linux-android',       // Android device
+      'armv7-linux-androideabi',     // Android device (older 32-bit)
+      'x86_64-linux-android',        // Android emulator
+    ] : []),
+  ];
+
+  for (const target of targets) {
+    if (installed.includes(target)) {
+      console.log(`✓ Target ${target}`);
+    } else {
+      console.log(`  Adding target ${target}...`);
+      try {
+        execSync(`rustup target add ${target}`, { stdio: 'inherit' });
+        console.log(`✓ Target ${target}`);
+      } catch {
+        console.warn(`⚠ Failed to add ${target}. Run manually: rustup target add ${target}`);
+      }
+    }
+  }
+
+  // ── 3. Create Cargo.toml ────────────────────────────────────────────
+  const cargoTomlPath = path.join(projectRoot, 'Cargo.toml');
+  if (fs.existsSync(cargoTomlPath)) {
+    console.log('✓ Cargo.toml already exists');
+    // Verify nativ-core dependency is present
+    const content = fs.readFileSync(cargoTomlPath, 'utf8');
+    if (!content.includes('nativ-core')) {
+      console.warn('⚠ Cargo.toml is missing nativ-core dependency. Add:');
+      console.warn('  nativ-core = "0.1"');
+    }
+  } else {
+    const cargoToml = `[package]
+name = "native"
+version = "0.1.0"
+edition = "2024"
+
+[lib]
+path = ".nativ/lib.rs"
+
+[workspace]
+
+[dependencies]
+nativ-core = "0.1"
+
+# iOS-only dependencies — e.g. objc2
+# [target.'cfg(target_os = "ios")'.dependencies]
+
+# Android-only dependencies — e.g. jni
+# [target.'cfg(target_os = "android")'.dependencies]
+`;
+    fs.writeFileSync(cargoTomlPath, cargoToml);
+    console.log('✓ Created Cargo.toml (nativ-core = "0.1")');
+  }
+
+  // Always ensure .nativ/lib.rs exists (Cargo requires a lib target)
+  const libRsPath = path.join(projectRoot, '.nativ/lib.rs');
+  if (!fs.existsSync(libRsPath)) {
+    fs.mkdirSync(path.join(projectRoot, '.nativ'), { recursive: true });
+    fs.writeFileSync(libRsPath,
+      '// Stub for rust-analyzer and `cargo add`. Do not edit.\n');
+    console.log('✓ Created .nativ/lib.rs');
+  }
+
+  console.log('\nDone. Rust hot-reload is ready.');
+  console.log('Add .rs files to src/ and they\'ll compile on save.');
+}
+
+main().catch(e => {
+  console.error('Setup failed:', e.message);
+  process.exit(1);
+});

package/scripts/setup.js

@@ -0,0 +1,107 @@
+#!/usr/bin/env node
+
+const consola = require('consola');
+const { execSync } = require('child_process');
+const path = require('path');
+const { configureProject } = require('./project-config');
+
+async function main() {
+  consola.box('React Native Native setup');
+
+  // Configure project files (.gitignore, tsconfig)
+  configureProject(process.cwd());
+
+  const platforms = await consola.prompt('Which platforms?', {
+    type: 'multiselect',
+    options: ['ios', 'android'],
+    initial: ['ios', 'android'],
+    required: true,
+  });
+  if (typeof platforms === 'symbol') process.exit(0);
+
+  const languages = await consola.prompt('Which languages?', {
+    type: 'multiselect',
+    options: [
+      { value: 'cpp', label: 'C++ / ObjC++', hint: 'no setup needed' },
+      { value: 'swift', label: 'Swift', hint: 'iOS only, no setup needed' },
+      { value: 'rust', label: 'Rust', hint: 'installs targets + Cargo.toml' },
+      { value: 'kotlin', label: 'Kotlin', hint: 'downloads compiler' },
+      { value: 'compose', label: 'Jetpack Compose', hint: 'includes Kotlin' },
+    ],
+    required: true,
+  });
+  if (typeof languages === 'symbol') process.exit(0);
+
+  const platformFlag = platforms.length === 1 ? `--platform ${platforms[0]}` : '';
+  const scriptsDir = __dirname;
+
+  if (languages.includes('rust')) {
+    consola.start('Setting up Rust...');
+    try {
+      execSync(`node ${path.join(scriptsDir, 'setup-rust.js')} ${platformFlag}`, {
+        stdio: 'inherit',
+        cwd: process.cwd(),
+      });
+      consola.success('Rust ready');
+    } catch {
+      consola.error('Rust setup failed');
+    }
+  }
+
+  if (languages.includes('compose')) {
+    // Kotlin version detection must run first — compose reads from nativ.config.json
+    consola.start('Setting up Kotlin...');
+    try {
+      execSync(`node ${path.join(scriptsDir, 'setup-kotlin.js')}`, {
+        stdio: 'inherit',
+        cwd: process.cwd(),
+      });
+    } catch {}
+    consola.start('Setting up Compose...');
+    try {
+      execSync(`node ${path.join(scriptsDir, 'setup-compose.js')}`, {
+        stdio: 'inherit',
+        cwd: process.cwd(),
+      });
+      consola.success('Kotlin + Compose ready');
+    } catch {
+      consola.error('Kotlin + Compose setup failed');
+    }
+  } else if (languages.includes('kotlin')) {
+    consola.start('Setting up Kotlin...');
+    try {
+      execSync(`node ${path.join(scriptsDir, 'setup-kotlin.js')}`, {
+        stdio: 'inherit',
+        cwd: process.cwd(),
+      });
+      consola.success('Kotlin ready');
+    } catch {
+      consola.error('Kotlin setup failed');
+    }
+  }
+
+  const noSetup = [];
+  if (languages.includes('cpp')) noSetup.push('C++/ObjC++');
+  if (languages.includes('swift')) noSetup.push('Swift');
+  if (noSetup.length > 0) {
+    consola.info(`${noSetup.join(' and ')} — no additional setup needed`);
+  }
+
+  const runDoctor = await consola.prompt('Run doctor to verify?', {
+    type: 'confirm',
+    initial: true,
+  });
+  if (runDoctor === true) {
+    execSync(`node ${path.join(scriptsDir, 'doctor.js')} ${platformFlag}`, {
+      stdio: 'inherit',
+      cwd: process.cwd(),
+    });
+  }
+
+  consola.success('Setup complete!');
+}
+
+main().catch(e => {
+  consola.error('Setup failed:', e.message);
+  process.exit(1);
+});