yaver-cli 1.0.0

package/bin/yaver-push

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+
+const { run } = require('../src/index');
+run(process.argv.slice(2));

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "yaver-cli",
+  "version": "1.0.0",
+  "description": "Push existing React Native projects to yaver.io for testing on real devices",
+  "bin": {
+    "yaver-push": "bin/yaver-push"
+  },
+  "main": "src/index.js",
+  "files": [
+    "bin/",
+    "src/",
+    "hermesc/",
+    "sdk-manifest.json"
+  ],
+  "keywords": [
+    "react-native",
+    "testing",
+    "mobile",
+    "yaver",
+    "expo-go-alternative"
+  ],
+  "author": "Yaver <hello@yaver.io>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/kivanccakmak/yaver.io.git"
+  },
+  "homepage": "https://yaver.io",
+  "engines": {
+    "node": ">=18"
+  },
+  "dependencies": {
+    "semver": "^7.6.0"
+  }
+}

package/sdk-manifest.json

@@ -0,0 +1,58 @@
+{
+  "sdkVersion": "1.0.0",
+  "reactNative": "0.81.5",
+  "react": "19.1.0",
+  "hermes": {
+    "version": "0.81.5",
+    "bytecodeVersion": 99
+  },
+  "arch": {
+    "newArch": true,
+    "fabric": true,
+    "bridgeless": false
+  },
+  "supportedRNRange": "0.81.x",
+  "nativeModules": {
+    "react-native-screens": "4.16.0",
+    "react-native-safe-area-context": "5.6.0",
+    "react-native-gesture-handler": "2.28.0",
+    "react-native-reanimated": "4.1.1",
+    "react-native-svg": "15.15.4",
+    "react-native-webview": "13.15.0",
+    "@react-native-async-storage/async-storage": "2.2.0",
+    "@react-native-community/netinfo": "11.4.1",
+    "react-native-maps": "1.20.1",
+    "react-native-ble-plx": "3.2.0",
+    "react-native-mmkv": "4.3.0",
+    "@shopify/react-native-skia": "2.6.2",
+    "react-native-udp": "4.1.7",
+    "react-native-markdown-display": "7.0.2",
+    "victory-native": "41.20.2",
+    "whisper.rn": "0.5.5",
+    "expo-camera": "17.0.10",
+    "expo-location": "19.0.8",
+    "expo-sensors": "15.0.8",
+    "expo-haptics": "15.0.8",
+    "expo-device": "8.0.10",
+    "expo-constants": "18.0.13",
+    "expo-notifications": "0.32.16",
+    "expo-file-system": "19.0.21",
+    "expo-asset": "12.0.12",
+    "expo-font": "14.0.11",
+    "expo-clipboard": "8.0.8",
+    "expo-linking": "8.0.11",
+    "expo-secure-store": "15.0.8",
+    "expo-av": "16.0.8",
+    "expo-image-picker": "17.0.10",
+    "expo-speech": "14.0.8",
+    "expo-web-browser": "15.0.10",
+    "expo-apple-authentication": "8.0.8",
+    "expo-battery": "10.0.8",
+    "expo-brightness": "14.0.8",
+    "expo-localization": "55.0.11",
+    "expo-share-intent": "3.2.3",
+    "expo-sharing": "14.0.8",
+    "expo-splash-screen": "31.0.13",
+    "expo-status-bar": "3.0.9"
+  }
+}

package/src/analyzer.js

@@ -0,0 +1,117 @@
+const fs = require('fs');
+const semver = require('semver');
+
+// Pure JS packages — never need native code
+const PURE_JS_PACKAGES = new Set([
+  'axios', 'lodash', 'moment', 'date-fns', 'uuid', 'dayjs',
+  'zustand', 'jotai', 'redux', '@reduxjs/toolkit', 'mobx', 'mobx-react',
+  'react-query', '@tanstack/react-query',
+  'formik', 'yup', 'zod', 'react-hook-form',
+  'i18next', 'react-i18next',
+  'nativewind', 'twrnc', 'styled-components', '@emotion/native',
+  'swr', 'immer',
+  '@react-navigation/native', '@react-navigation/stack',
+  '@react-navigation/bottom-tabs', '@react-navigation/drawer',
+  '@react-navigation/native-stack',
+  '@react-navigation/material-top-tabs',
+  'react-native-web', 'react-dom',
+  '@expo/metro-runtime', 'expo-router', 'expo-splash-screen', 'expo-status-bar',
+]);
+
+// Packages that LOOK native (react-native-*) but are pure JS
+const FALSE_POSITIVE_NATIVE = new Set([
+  'react-native-paper', 'react-native-elements',
+  'react-native-size-matters', 'react-native-responsive-screen',
+  'react-native-toast-message', 'react-native-responsive-fontsize',
+  'react-native-iphone-x-helper', 'react-native-status-bar-height',
+  'react-native-markdown-display',
+]);
+
+function analyzeProject(packageJson, sdkManifest) {
+  const errors = [];
+  const warnings = [];
+  const availableModules = [];
+  const missingModules = [];
+
+  const allDeps = { ...packageJson.dependencies, ...packageJson.peerDependencies };
+
+  // 1. React Native version
+  const projectRN = cleanVersion(allDeps['react-native'] || '');
+  const sdkRN = sdkManifest.reactNative;
+
+  if (projectRN && sdkRN) {
+    const projParsed = semver.coerce(projectRN);
+    const sdkParsed = semver.coerce(sdkRN);
+
+    if (projParsed && sdkParsed) {
+      if (semver.major(projParsed) !== semver.major(sdkParsed)) {
+        errors.push({
+          type: 'rn_major_mismatch',
+          message: `React Native major version mismatch: project ${projectRN}, yaver ${sdkRN}. Incompatible.`,
+        });
+      } else if (semver.minor(projParsed) !== semver.minor(sdkParsed)) {
+        warnings.push({
+          type: 'rn_minor_mismatch',
+          message: `React Native ${projectRN} vs yaver ${sdkRN}. Minor version differs — may work.`,
+        });
+      }
+    }
+  }
+
+  // 2. Architecture check
+  const newArchEnabled = packageJson.reactNative?.newArchEnabled === true;
+  if (newArchEnabled && !sdkManifest.arch.newArch) {
+    errors.push({
+      type: 'arch_mismatch',
+      message: 'Project uses New Architecture but yaver uses classic bridge. Incompatible.',
+    });
+  }
+
+  // 3. Native module check
+  for (const [name, version] of Object.entries(allDeps)) {
+    if (name === 'react' || name === 'react-native') continue;
+    if (PURE_JS_PACKAGES.has(name)) continue;
+    if (FALSE_POSITIVE_NATIVE.has(name)) continue;
+    if (packageJson.devDependencies?.[name] && !packageJson.dependencies?.[name]) continue;
+    if (!looksLikeNativeModule(name)) continue;
+
+    const sdkVersion = sdkManifest.nativeModules[name];
+
+    if (!sdkVersion) {
+      missingModules.push({ name, version: cleanVersion(version), reason: 'not in yaver SDK' });
+      errors.push({
+        type: 'missing_module', module: name, version,
+        message: `"${name}" requires native code but is NOT in the yaver SDK.`,
+      });
+    } else {
+      const cleanLocal = cleanVersion(version);
+      availableModules.push({ name, projectVersion: cleanLocal, sdkVersion });
+
+      const localParsed = semver.coerce(cleanLocal);
+      const sdkParsed = semver.coerce(sdkVersion);
+      if (localParsed && sdkParsed && semver.major(localParsed) !== semver.major(sdkParsed)) {
+        warnings.push({
+          type: 'version_mismatch', module: name,
+          message: `"${name}": project ${version}, yaver ${sdkVersion}. Major version differs.`,
+        });
+      }
+    }
+  }
+
+  return { reactNativeVersion: projectRN, errors, warnings, availableModules, missingModules };
+}
+
+function looksLikeNativeModule(name) {
+  return name.startsWith('react-native-') ||
+    name.startsWith('@react-native-') ||
+    name.startsWith('@react-native/') ||
+    name.startsWith('rn') ||
+    name.startsWith('expo-') ||
+    name.startsWith('@shopify/react-native-');
+}
+
+function cleanVersion(v) {
+  return (v || '').replace(/[\^~>=<\s]/g, '');
+}
+
+module.exports = { analyzeProject, PURE_JS_PACKAGES, FALSE_POSITIVE_NATIVE };

package/src/bundler.js

@@ -0,0 +1,115 @@
+const { execSync, execFileSync } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+function getHermescPath() {
+  const key = `${os.platform()}-${os.arch()}`;
+  const dir = path.join(__dirname, '..', 'hermesc');
+  const ext = os.platform() === 'win32' ? 'hermesc.exe' : 'hermesc';
+
+  const candidates = [
+    path.join(dir, key, ext),
+    path.join(dir, 'darwin-arm64', ext),
+    path.join(dir, 'linux-x64', ext),
+  ];
+
+  const found = candidates.find(p => fs.existsSync(p));
+  if (!found) {
+    // Fall back to project's hermesc (react-native ships one)
+    const rnHermesc = findRNHermesc();
+    if (rnHermesc) return rnHermesc;
+
+    throw new Error(
+      `hermesc not found for ${key}. Install @yaver/cli hermesc binaries or ensure react-native is installed.`
+    );
+  }
+
+  try { fs.chmodSync(found, 0o755); } catch {}
+  return found;
+}
+
+/** Find hermesc from the project's react-native installation */
+function findRNHermesc() {
+  const candidates = [
+    // RN 0.81+
+    path.join('node_modules', 'react-native', 'sdks', 'hermesc', getPlatformBin(), 'hermesc'),
+    // Older RN
+    path.join('node_modules', 'hermes-engine', getPlatformBin(), 'hermesc'),
+  ];
+
+  for (const c of candidates) {
+    if (fs.existsSync(c)) {
+      try { fs.chmodSync(c, 0o755); } catch {}
+      return c;
+    }
+  }
+  return null;
+}
+
+function getPlatformBin() {
+  const p = os.platform();
+  const a = os.arch();
+  if (p === 'darwin') return a === 'arm64' ? 'osx-bin' : 'osx-bin';
+  if (p === 'linux') return 'linux64-bin';
+  if (p === 'win32') return 'win64-bin';
+  return 'osx-bin';
+}
+
+async function bundle({ platform, entryFile, outputDir, dev = false, minify = true }) {
+  fs.rmSync(outputDir, { recursive: true, force: true });
+  fs.mkdirSync(outputDir, { recursive: true });
+
+  const bundlePath = path.join(outputDir, 'main.jsbundle');
+  const assetsDir = path.join(outputDir, 'assets');
+
+  const cmd = [
+    'npx react-native bundle',
+    `--platform ${platform}`,
+    `--entry-file ${entryFile}`,
+    `--bundle-output ${bundlePath}`,
+    `--assets-dest ${assetsDir}`,
+    `--dev ${dev}`,
+    `--minify ${minify}`,
+    '--reset-cache',
+  ].join(' ');
+
+  execSync(cmd, { stdio: 'inherit' });
+
+  if (!fs.existsSync(bundlePath)) {
+    throw new Error(`Bundle not found at ${bundlePath}. Check react-native bundle output.`);
+  }
+
+  return bundlePath;
+}
+
+async function compileHermes({ inputPath, outputPath }) {
+  const hermesc = getHermescPath();
+  const tmp = inputPath + '.tmp';
+  fs.renameSync(inputPath, tmp);
+
+  try {
+    execFileSync(hermesc, ['-emit-binary', '-out', outputPath, '-O', tmp], { stdio: 'pipe' });
+  } catch (err) {
+    // Restore original on failure
+    fs.renameSync(tmp, inputPath);
+    const stderr = err.stderr?.toString() || err.message;
+    throw new Error(`Hermes compile failed: ${stderr}`);
+  }
+
+  fs.unlinkSync(tmp);
+  return outputPath;
+}
+
+function readBytecodeVersion(hbcPath) {
+  const buf = fs.readFileSync(hbcPath);
+  if (buf.length < 8) return null;
+
+  // Hermes magic: 0x1F1903C1 (little-endian)
+  const magic = buf.readUInt32LE(0);
+  if (magic !== 0x1F1903C1) return null;
+
+  return buf.readUInt32LE(4);
+}
+
+module.exports = { bundle, compileHermes, readBytecodeVersion, getHermescPath };

package/src/commands/devices.js

@@ -0,0 +1,23 @@
+const { scanLAN, fetchHealth, YAVER_PORT } = require('../discovery');
+
+async function devices() {
+  console.log('📡 Scanning for yaver.io devices on your network...\n');
+
+  const found = await scanLAN();
+
+  if (found.length === 0) {
+    console.log('  No devices found.\n');
+    console.log('  Make sure the yaver.io app is open on your phone');
+    console.log('  and both devices are on the same WiFi network.\n');
+    return;
+  }
+
+  console.log(`  Found ${found.length} device(s):\n`);
+  for (const d of found) {
+    console.log(`  📱 ${d.name} (${d.platform})`);
+    console.log(`     IP: ${d.ip}:${d.port}`);
+    console.log(`     Push: yaver-push push --device ${d.ip}\n`);
+  }
+}
+
+module.exports = { devices };

package/src/commands/doctor.js

@@ -0,0 +1,88 @@
+const fs = require('fs');
+const { analyzeProject } = require('../analyzer');
+
+async function doctor() {
+  if (!fs.existsSync('package.json')) {
+    console.error('❌ No package.json found. Run this from your RN project root.');
+    process.exit(1);
+  }
+
+  const pkg = JSON.parse(fs.readFileSync('package.json', 'utf8'));
+  const sdkManifest = require('../../sdk-manifest.json');
+  const analysis = analyzeProject(pkg, sdkManifest);
+
+  console.log('\n📋 Yaver Compatibility Report\n');
+  console.log(`  Yaver SDK:     v${sdkManifest.sdkVersion}`);
+  console.log(`  SDK RN:        ${sdkManifest.reactNative}`);
+  console.log(`  SDK Hermes BC: ${sdkManifest.hermes.bytecodeVersion}`);
+  console.log(`  Your RN:       ${analysis.reactNativeVersion || 'not found'}`);
+  console.log(`  New Arch:      ${sdkManifest.arch.newArch ? 'enabled' : 'disabled'}\n`);
+
+  // Available modules
+  if (analysis.availableModules.length > 0) {
+    console.log('─── Available Native Modules ────────────────────\n');
+    console.log('  These will work in yaver.io:\n');
+    for (const m of analysis.availableModules) {
+      const warn = analysis.warnings.find(w => w.module === m.name);
+      if (warn) {
+        console.log(`  ⚠️  ${m.name}: project ${m.projectVersion}, yaver ${m.sdkVersion}`);
+      } else {
+        console.log(`  ✅ ${m.name}@${m.projectVersion}`);
+      }
+    }
+    console.log('');
+  }
+
+  // Missing modules
+  if (analysis.missingModules.length > 0) {
+    console.log('─── Missing Native Modules ─────────────────────\n');
+    console.log('  These need native code that yaver.io doesn\'t ship.');
+    console.log('  Your app WILL crash if it calls them.\n');
+
+    for (const m of analysis.missingModules) {
+      console.log(`  ❌ ${m.name}@${m.version}`);
+    }
+
+    console.log('\n  Handle gracefully in your existing code:\n');
+    console.log('  import { NativeModules } from \'react-native\';');
+    console.log('  const isYaver = !!NativeModules.YaverInfo;\n');
+    console.log('  if (isYaver) {');
+    console.log('    // skip this feature or show placeholder');
+    console.log('  } else {');
+    console.log('    // use the native module normally');
+    console.log('  }\n');
+
+    console.log('  For lazy-loaded modules (avoids import crash):\n');
+    console.log('  const MyModule = NativeModules.MyModule');
+    console.log('    ? require(\'react-native-my-module\').default');
+    console.log('    : null;\n');
+  }
+
+  // Errors
+  const hardErrors = analysis.errors.filter(e => e.type !== 'missing_module');
+  if (hardErrors.length > 0) {
+    console.log('─���─ Critical Issues ────────────────────────────\n');
+    for (const e of hardErrors) {
+      console.log(`  🚫 ${e.message}`);
+    }
+    console.log('');
+  }
+
+  // All SDK modules
+  console.log('─── All Yaver SDK Modules ──────────────────────\n');
+  for (const [name, version] of Object.entries(sdkManifest.nativeModules)) {
+    const inProject = analysis.availableModules.find(m => m.name === name);
+    console.log(`  ${name}@${version}${inProject ? ' ← used in your project' : ''}`);
+  }
+  console.log('');
+
+  // Summary
+  const total = analysis.availableModules.length + analysis.missingModules.length;
+  console.log(`─── Summary ────────────────────────────────────\n`);
+  console.log(`  ${analysis.availableModules.length}/${total} native modules available`);
+  console.log(`  ${analysis.missingModules.length} missing (push with --ignore-missing)`);
+  console.log(`  ${analysis.warnings.length} warnings`);
+  console.log(`  ${hardErrors.length} critical issues\n`);
+}
+
+module.exports = { doctor };

package/src/commands/init.js

@@ -0,0 +1,90 @@
+const fs = require('fs');
+const path = require('path');
+const { analyzeProject } = require('../analyzer');
+
+async function init() {
+  if (!fs.existsSync('package.json')) {
+    console.error('❌ No package.json found. Run this from your RN project root.');
+    process.exit(1);
+  }
+
+  const pkg = JSON.parse(fs.readFileSync('package.json', 'utf8'));
+  if (!pkg.dependencies?.['react-native']) {
+    console.error('❌ react-native not found in dependencies. Is this a React Native project?');
+    process.exit(1);
+  }
+
+  console.log('🔍 Analyzing your project...\n');
+
+  const sdkManifest = require('../../sdk-manifest.json');
+  const analysis = analyzeProject(pkg, sdkManifest);
+
+  printAnalysis(analysis, sdkManifest);
+
+  // Create yaver.json — does NOT touch the developer's code
+  const yaverJson = {
+    sdkVersion: sdkManifest.sdkVersion,
+    analyzedAt: new Date().toISOString(),
+    projectRN: analysis.reactNativeVersion,
+    compatible: analysis.errors.length === 0,
+    missingModules: analysis.missingModules.map(m => m.name),
+    availableModules: analysis.availableModules.map(m => m.name),
+    warnings: analysis.warnings.map(w => w.message),
+  };
+
+  fs.writeFileSync('yaver.json', JSON.stringify(yaverJson, null, 2));
+  console.log('\n✅ Created yaver.json');
+
+  if (analysis.errors.filter(e => e.type === 'missing_module').length > 0) {
+    console.log('\n⚠️  Your project has compatibility issues (see above).');
+    console.log('   You can still push with: yaver-push push --ignore-missing');
+    console.log('   Features using missing modules will crash.\n');
+  } else if (analysis.errors.length > 0) {
+    console.log('\n🚫 Incompatible — see errors above.\n');
+  } else {
+    console.log('\n🎉 Fully compatible! Run: yaver-push push\n');
+  }
+}
+
+function printAnalysis(analysis, sdkManifest) {
+  // RN version
+  const rnStatus = analysis.errors.find(e => e.type === 'rn_major_mismatch') ? '❌' :
+    analysis.warnings.find(w => w.type === 'rn_minor_mismatch') ? '⚠️' : '✅';
+  console.log(`  React Native:  ${analysis.reactNativeVersion || 'unknown'} ${rnStatus} (yaver supports ${sdkManifest.supportedRNRange})`);
+
+  // Hermes
+  console.log(`  Hermes:        enabled ✅`);
+
+  // Arch
+  const archStatus = analysis.errors.find(e => e.type === 'arch_mismatch') ? '❌' : '✅';
+  console.log(`  New Arch:      ${sdkManifest.arch.newArch ? 'enabled' : 'disabled'} ${archStatus}`);
+
+  // Available modules
+  if (analysis.availableModules.length > 0) {
+    console.log('\n  Native modules found in your project:');
+    for (const m of analysis.availableModules) {
+      const warn = analysis.warnings.find(w => w.module === m.name);
+      const icon = warn ? '⚠️' : '✅';
+      console.log(`    ${m.name}@${m.projectVersion}  ${icon} available in yaver`);
+    }
+  }
+
+  // Missing modules
+  if (analysis.missingModules.length > 0) {
+    console.log(`\n  ⚠️  ${analysis.missingModules.length} native module(s) NOT available in yaver.io:`);
+    for (const m of analysis.missingModules) {
+      console.log(`    • ${m.name}@${m.version} — ${m.reason}`);
+    }
+  }
+
+  // Warnings
+  const otherWarnings = analysis.warnings.filter(w => w.type !== 'rn_minor_mismatch' && w.type !== 'version_mismatch');
+  if (otherWarnings.length > 0) {
+    console.log('\n  Warnings:');
+    for (const w of otherWarnings) {
+      console.log(`    ⚠️  ${w.message}`);
+    }
+  }
+}
+
+module.exports = { init };

package/src/commands/modules.js

@@ -0,0 +1,43 @@
+async function modules() {
+  const sdkManifest = require('../../sdk-manifest.json');
+
+  console.log(`\n📦 Yaver SDK v${sdkManifest.sdkVersion} — Native Modules\n`);
+  console.log(`  React Native: ${sdkManifest.reactNative}`);
+  console.log(`  Hermes BC:    ${sdkManifest.hermes.bytecodeVersion}`);
+  console.log(`  New Arch:     ${sdkManifest.arch.newArch ? 'enabled' : 'disabled'}\n`);
+
+  const entries = Object.entries(sdkManifest.nativeModules);
+
+  // Group by prefix
+  const expo = entries.filter(([n]) => n.startsWith('expo-'));
+  const rn = entries.filter(([n]) => n.startsWith('react-native-') || n.startsWith('@react-native'));
+  const other = entries.filter(([n]) => !n.startsWith('expo-') && !n.startsWith('react-native-') && !n.startsWith('@react-native'));
+
+  if (rn.length > 0) {
+    console.log('  React Native Community:');
+    for (const [name, version] of rn) {
+      console.log(`    ${name}@${version}`);
+    }
+    console.log('');
+  }
+
+  if (expo.length > 0) {
+    console.log('  Expo Modules:');
+    for (const [name, version] of expo) {
+      console.log(`    ${name}@${version}`);
+    }
+    console.log('');
+  }
+
+  if (other.length > 0) {
+    console.log('  Other:');
+    for (const [name, version] of other) {
+      console.log(`    ${name}@${version}`);
+    }
+    console.log('');
+  }
+
+  console.log(`  Total: ${entries.length} native modules\n`);
+}
+
+module.exports = { modules };

package/src/commands/push.js

@@ -0,0 +1,150 @@
+const fs = require('fs');
+const path = require('path');
+const { analyzeProject } = require('../analyzer');
+const { bundle, compileHermes, readBytecodeVersion } = require('../bundler');
+const { discoverDevice, fetchHealth } = require('../discovery');
+const { pushBundle, pushAssets } = require('../transport');
+
+async function push(options = {}) {
+  const startTime = Date.now();
+  const quiet = options.quiet;
+  const pkg = JSON.parse(fs.readFileSync('package.json', 'utf8'));
+  const sdkManifest = require('../../sdk-manifest.json');
+
+  // Find device
+  if (!quiet) console.log('📡 Finding device...');
+  const device = await discoverDevice(options.device);
+  if (!quiet) console.log(`✅ Found: ${device.name} (${device.ip})`);
+
+  // Fetch health + verify SDK
+  const health = await fetchHealth(device);
+  const platform = health.platform || 'ios';
+
+  if (health.hermes?.bytecodeVersion !== sdkManifest.hermes.bytecodeVersion) {
+    console.error(`�� Hermes BC mismatch: device BC${health.hermes?.bytecodeVersion}, CLI BC${sdkManifest.hermes.bytecodeVersion}`);
+    console.error('   Update @yaver/cli or yaver.io app.');
+    process.exit(1);
+  }
+
+  // Analyze compatibility
+  const analysis = analyzeProject(pkg, sdkManifest);
+
+  const hardErrors = analysis.errors.filter(e =>
+    e.type === 'rn_major_mismatch' || e.type === 'arch_mismatch'
+  );
+  if (hardErrors.length > 0) {
+    console.error('\n🚫 INCOMPATIBLE:\n');
+    hardErrors.forEach(e => console.error(`  ${e.message}`));
+    process.exit(1);
+  }
+
+  if (analysis.missingModules.length > 0 && !options.ignoreMissing) {
+    console.warn(`\n⚠���  ${analysis.missingModules.length} native module(s) NOT in yaver SDK:`);
+    analysis.missingModules.forEach(m => console.warn(`    • ${m.name}@${m.version}`));
+    console.warn('\n  App will crash if it calls these modules.');
+    console.warn('  Push anyway: yaver-push push --ignore-missing\n');
+    if (!options.force) process.exit(1);
+  }
+
+  if (!quiet) console.log('✅ Compatible');
+
+  // Bundle
+  if (!quiet) console.log(`🔨 Bundling for ${platform}...`);
+  const entryFile = findEntryFile(pkg);
+  const buildDir = path.resolve('.yaver-build');
+  const bundlePath = await bundle({ platform, entryFile, outputDir: buildDir, dev: false, minify: true });
+
+  // Hermes compile
+  if (!quiet) console.log('⚡ Compiling Hermes bytecode...');
+  await compileHermes({ inputPath: bundlePath, outputPath: bundlePath });
+
+  const bcVersion = readBytecodeVersion(bundlePath);
+  if (bcVersion !== sdkManifest.hermes.bytecodeVersion) {
+    console.error(`❌ hermesc produced BC${bcVersion}, expected BC${sdkManifest.hermes.bytecodeVersion}`);
+    process.exit(1);
+  }
+
+  // Push
+  const moduleName = getModuleName(pkg);
+  const bundleData = fs.readFileSync(bundlePath);
+  if (!quiet) console.log(`📤 Pushing ${(bundleData.length / 1024).toFixed(1)} KB...`);
+
+  const result = await pushBundle(device, bundleData, {
+    moduleName,
+    appName: moduleName,
+    sdkVersion: sdkManifest.sdkVersion,
+  });
+
+  if (result.status !== 'ok') {
+    console.error(`❌ Device rejected: ${result.message}`);
+    process.exit(1);
+  }
+
+  // Assets
+  const assetsDir = path.join(buildDir, 'assets');
+  if (fs.existsSync(assetsDir)) {
+    const files = fs.readdirSync(assetsDir, { recursive: true });
+    if (files.length > 0) {
+      if (!quiet) console.log('📤 Pushing assets...');
+      await pushAssets(device, assetsDir);
+    }
+  }
+
+  const elapsed = ((Date.now() - startTime) / 1000).toFixed(1);
+  if (!quiet) console.log(`\n🚀 Done in ${elapsed}s — app loading on ${device.name}\n`);
+
+  // Watch mode
+  if (options.watch) {
+    await watchAndPush(options, device, pkg, sdkManifest);
+  }
+}
+
+async function watchAndPush(options, device, pkg, sdkManifest) {
+  console.log('👀 Watching for changes...');
+
+  const watchDirs = ['src', 'app', 'lib', 'components', 'screens', 'utils', 'hooks']
+    .filter(d => fs.existsSync(d));
+
+  if (watchDirs.length === 0) watchDirs.push('.');
+
+  const { watch } = require('fs');
+  let debounce = null;
+
+  for (const dir of watchDirs) {
+    fs.watch(dir, { recursive: true }, (event, filename) => {
+      if (!filename || !filename.match(/\.(js|jsx|ts|tsx|json)$/)) return;
+      if (filename.includes('node_modules') || filename.includes('.yaver-build')) return;
+
+      clearTimeout(debounce);
+      debounce = setTimeout(async () => {
+        console.log(`📝 ${filename} changed`);
+        try {
+          await push({ ...options, watch: false, quiet: true, device: device.ip });
+          console.log('📤 Re-pushed — done');
+        } catch (err) {
+          console.error(`❌ Re-push failed: ${err.message}`);
+        }
+      }, 300);
+    });
+  }
+}
+
+function findEntryFile(pkg) {
+  if (pkg.main && fs.existsSync(pkg.main)) return pkg.main;
+  const candidates = ['index.js', 'index.tsx', 'index.ts', 'src/index.js', 'src/index.tsx', 'App.js', 'App.tsx'];
+  return candidates.find(f => fs.existsSync(f)) || 'index.js';
+}
+
+function getModuleName(pkg) {
+  if (fs.existsSync('app.json')) {
+    try {
+      const a = JSON.parse(fs.readFileSync('app.json', 'utf8'));
+      if (a.name) return a.name;
+      if (a.displayName) return a.displayName;
+      if (a.expo?.name) return a.expo.name;
+    } catch {}
+  }
+  return pkg.name || 'App';
+}
+
+module.exports = { push };

package/src/commands/reset.js

@@ -0,0 +1,20 @@
+const { discoverDevice } = require('../discovery');
+const { resetDevice } = require('../transport');
+
+async function reset(options = {}) {
+  console.log('📡 Finding device...');
+  const device = await discoverDevice(options.device);
+  console.log(`✅ Found: ${device.name} (${device.ip})`);
+
+  console.log('🔄 Resetting device...');
+  const result = await resetDevice(device);
+
+  if (result.status === 'ok') {
+    console.log('✅ Bundle cleared — device will show default UI');
+  } else {
+    console.error(`❌ Reset failed: ${result.message}`);
+    process.exit(1);
+  }
+}
+
+module.exports = { reset };

package/src/commands/status.js

@@ -0,0 +1,42 @@
+const fs = require('fs');
+const { discoverDevice, fetchHealth } = require('../discovery');
+
+async function status(options = {}) {
+  // Project status
+  console.log('\n📋 Project Status\n');
+
+  if (fs.existsSync('yaver.json')) {
+    const yj = JSON.parse(fs.readFileSync('yaver.json', 'utf8'));
+    console.log(`  SDK Version:   ${yj.sdkVersion}`);
+    console.log(`  Project RN:    ${yj.projectRN}`);
+    console.log(`  Compatible:    ${yj.compatible ? '✅' : '❌'}`);
+    console.log(`  Available:     ${yj.availableModules?.length || 0} native modules`);
+    console.log(`  Missing:       ${yj.missingModules?.length || 0} native modules`);
+    console.log(`  Analyzed:      ${yj.analyzedAt}`);
+  } else {
+    console.log('  No yaver.json found. Run: yaver-push init');
+  }
+
+  // Device status
+  console.log('\n📱 Device Status\n');
+
+  try {
+    const device = await discoverDevice(options.device);
+    const health = await fetchHealth(device);
+
+    console.log(`  Name:          ${health.deviceName || device.name}`);
+    console.log(`  Platform:      ${health.platform}`);
+    console.log(`  IP:            ${device.ip}:${device.port}`);
+    console.log(`  SDK Version:   ${health.sdkVersion}`);
+    console.log(`  RN Version:    ${health.reactNative}`);
+    console.log(`  Hermes BC:     ${health.hermes?.bytecodeVersion}`);
+    console.log(`  Has Bundle:    ${health.hasBundle ? '✅' : '❌'}`);
+    console.log(`  App Version:   ${health.appVersion} (build ${health.build})`);
+  } catch (err) {
+    console.log(`  Not connected: ${err.message}`);
+  }
+
+  console.log('');
+}
+
+module.exports = { status };

package/src/discovery.js

@@ -0,0 +1,119 @@
+const http = require('http');
+const dgram = require('dgram');
+
+const YAVER_PORT = 8347;
+const BEACON_PORT = 19837;
+const DISCOVERY_TIMEOUT = 5000;
+
+/**
+ * Discover a yaver.io device on the network.
+ * Priority: 1) manual IP, 2) saved config, 3) UDP beacon scan, 4) mDNS
+ */
+async function discoverDevice(manualIp) {
+  if (manualIp) {
+    const health = await fetchHealth({ ip: manualIp, port: YAVER_PORT });
+    return { ip: manualIp, port: YAVER_PORT, name: health.deviceName || manualIp, platform: health.platform };
+  }
+
+  // Try UDP beacon discovery
+  const beaconDevice = await listenForBeacon(DISCOVERY_TIMEOUT);
+  if (beaconDevice) {
+    return beaconDevice;
+  }
+
+  throw new Error(
+    'No yaver.io device found on network.\n' +
+    '  Make sure the yaver.io app is open on your phone (same WiFi).\n' +
+    '  Or specify device IP: yaver-push push --device <ip>'
+  );
+}
+
+/** Listen for UDP beacon from yaver.io app */
+function listenForBeacon(timeout) {
+  return new Promise((resolve) => {
+    const socket = dgram.createSocket({ type: 'udp4', reuseAddr: true });
+    const timer = setTimeout(() => {
+      socket.close();
+      resolve(null);
+    }, timeout);
+
+    socket.on('message', (msg) => {
+      try {
+        const beacon = JSON.parse(msg.toString());
+        if (beacon.v === 1 && beacon.p) {
+          clearTimeout(timer);
+          socket.close();
+          resolve({
+            ip: beacon.ip || socket.remoteAddress,
+            port: beacon.p,
+            name: beacon.n || 'Unknown Device',
+            id: beacon.id,
+          });
+        }
+      } catch {}
+    });
+
+    socket.on('error', () => {
+      clearTimeout(timer);
+      socket.close();
+      resolve(null);
+    });
+
+    socket.bind(BEACON_PORT, () => {
+      socket.setBroadcast(true);
+    });
+  });
+}
+
+/** Fetch /health from a device */
+function fetchHealth(device) {
+  return new Promise((resolve, reject) => {
+    const url = `http://${device.ip}:${device.port || YAVER_PORT}/health`;
+    const req = http.get(url, { timeout: 5000 }, (res) => {
+      let data = '';
+      res.on('data', chunk => data += chunk);
+      res.on('end', () => {
+        try {
+          resolve(JSON.parse(data));
+        } catch {
+          reject(new Error(`Invalid JSON from ${url}`));
+        }
+      });
+    });
+    req.on('error', (err) => reject(new Error(`Cannot reach ${device.ip}:${device.port || YAVER_PORT} — ${err.message}`)));
+    req.on('timeout', () => {
+      req.destroy();
+      reject(new Error(`Timeout connecting to ${device.ip}:${device.port || YAVER_PORT}`));
+    });
+  });
+}
+
+/** Scan common LAN subnets for yaver.io devices */
+async function scanLAN() {
+  const os = require('os');
+  const interfaces = os.networkInterfaces();
+  const found = [];
+
+  for (const [, addrs] of Object.entries(interfaces)) {
+    for (const addr of addrs) {
+      if (addr.family !== 'IPv4' || addr.internal) continue;
+      // Try common IPs on this subnet
+      const subnet = addr.address.split('.').slice(0, 3).join('.');
+      const promises = [];
+      for (let i = 1; i <= 254; i++) {
+        const ip = `${subnet}.${i}`;
+        if (ip === addr.address) continue;
+        promises.push(
+          fetchHealth({ ip, port: YAVER_PORT })
+            .then(h => found.push({ ip, port: YAVER_PORT, name: h.deviceName, platform: h.platform }))
+            .catch(() => {})
+        );
+      }
+      await Promise.all(promises);
+    }
+  }
+
+  return found;
+}
+
+module.exports = { discoverDevice, fetchHealth, scanLAN, YAVER_PORT };

package/src/index.js

@@ -0,0 +1,93 @@
+const { init } = require('./commands/init');
+const { push } = require('./commands/push');
+const { doctor } = require('./commands/doctor');
+const { devices } = require('./commands/devices');
+const { modules } = require('./commands/modules');
+const { reset } = require('./commands/reset');
+const { status } = require('./commands/status');
+
+const HELP = `
+yaver-push — Push existing React Native projects to yaver.io
+
+Commands:
+  init                              Analyze project, show compatibility, create yaver.json
+  push [--device <ip>] [--watch]    Bundle + validate + push to device
+  push --ignore-missing             Push even with missing native modules
+  doctor                            Deep compatibility report with fix suggestions
+  devices                           List discovered devices
+  modules                           List all SDK native modules
+  reset [--device <ip>]             Clear pushed bundle on device
+  status [--device <ip>]            Device + project status
+
+Options:
+  --device <ip>                     Target device IP (skips discovery)
+  --watch                           Re-push on file save
+  --ignore-missing                  Push despite missing native modules
+  --force                           Skip confirmation prompts
+  --help                            Show this help
+`;
+
+async function run(args) {
+  const command = args[0];
+  const options = parseArgs(args.slice(1));
+
+  if (!command || command === '--help' || command === '-h') {
+    console.log(HELP);
+    process.exit(0);
+  }
+
+  try {
+    switch (command) {
+      case 'init':
+        await init(options);
+        break;
+      case 'push':
+        await push(options);
+        break;
+      case 'doctor':
+        await doctor(options);
+        break;
+      case 'devices':
+        await devices(options);
+        break;
+      case 'modules':
+        await modules(options);
+        break;
+      case 'reset':
+        await reset(options);
+        break;
+      case 'status':
+        await status(options);
+        break;
+      default:
+        console.error(`Unknown command: ${command}`);
+        console.log(HELP);
+        process.exit(1);
+    }
+  } catch (err) {
+    console.error(`\n❌ ${err.message}`);
+    if (process.env.YAVER_DEBUG) console.error(err.stack);
+    process.exit(1);
+  }
+}
+
+function parseArgs(args) {
+  const opts = {};
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === '--device' && args[i + 1]) {
+      opts.device = args[++i];
+    } else if (arg === '--watch') {
+      opts.watch = true;
+    } else if (arg === '--ignore-missing') {
+      opts.ignoreMissing = true;
+    } else if (arg === '--force') {
+      opts.force = true;
+    } else if (arg === '--quiet' || arg === '-q') {
+      opts.quiet = true;
+    }
+  }
+  return opts;
+}
+
+module.exports = { run };

package/src/transport.js

@@ -0,0 +1,137 @@
+const http = require('http');
+const fs = require('fs');
+const path = require('path');
+
+const { YAVER_PORT } = require('./discovery');
+
+/** Push a Hermes bytecode bundle to the device */
+function pushBundle(device, bundleData, metadata = {}) {
+  return new Promise((resolve, reject) => {
+    const options = {
+      hostname: device.ip,
+      port: device.port || YAVER_PORT,
+      path: '/bundle',
+      method: 'POST',
+      timeout: 30000,
+      headers: {
+        'Content-Type': 'application/octet-stream',
+        'Content-Length': bundleData.length,
+        'X-Module-Name': metadata.moduleName || 'main',
+        'X-App-Name': metadata.appName || '',
+        'X-SDK-Version': metadata.sdkVersion || '',
+      },
+    };
+
+    const req = http.request(options, (res) => {
+      let data = '';
+      res.on('data', chunk => data += chunk);
+      res.on('end', () => {
+        try {
+          const result = JSON.parse(data);
+          if (res.statusCode !== 200) {
+            reject(new Error(result.message || `HTTP ${res.statusCode}`));
+          } else {
+            resolve(result);
+          }
+        } catch {
+          reject(new Error(`Invalid response from device: ${data}`));
+        }
+      });
+    });
+
+    req.on('error', (err) => reject(new Error(`Push failed: ${err.message}`)));
+    req.on('timeout', () => {
+      req.destroy();
+      reject(new Error('Push timed out'));
+    });
+
+    req.write(bundleData);
+    req.end();
+  });
+}
+
+/** Push assets directory to the device */
+async function pushAssets(device, assetsDir) {
+  // For now, send individual files. A tar approach would be more efficient.
+  const files = getAllFiles(assetsDir);
+  if (files.length === 0) return;
+
+  // Concatenate all assets into a simple tar-like format
+  // The device will unpack them
+  const buffers = [];
+  for (const file of files) {
+    const relPath = path.relative(assetsDir, file);
+    const data = fs.readFileSync(file);
+    buffers.push(data);
+  }
+
+  const allData = Buffer.concat(buffers);
+
+  return new Promise((resolve, reject) => {
+    const options = {
+      hostname: device.ip,
+      port: device.port || YAVER_PORT,
+      path: '/assets',
+      method: 'POST',
+      timeout: 30000,
+      headers: {
+        'Content-Type': 'application/octet-stream',
+        'Content-Length': allData.length,
+      },
+    };
+
+    const req = http.request(options, (res) => {
+      let data = '';
+      res.on('data', chunk => data += chunk);
+      res.on('end', () => {
+        try { resolve(JSON.parse(data)); } catch { resolve({}); }
+      });
+    });
+
+    req.on('error', (err) => reject(new Error(`Asset push failed: ${err.message}`)));
+    req.write(allData);
+    req.end();
+  });
+}
+
+/** Send POST /reset to device */
+function resetDevice(device) {
+  return new Promise((resolve, reject) => {
+    const options = {
+      hostname: device.ip,
+      port: device.port || YAVER_PORT,
+      path: '/reset',
+      method: 'POST',
+      timeout: 10000,
+      headers: { 'Content-Length': 0 },
+    };
+
+    const req = http.request(options, (res) => {
+      let data = '';
+      res.on('data', chunk => data += chunk);
+      res.on('end', () => {
+        try { resolve(JSON.parse(data)); } catch { resolve({}); }
+      });
+    });
+
+    req.on('error', (err) => reject(new Error(`Reset failed: ${err.message}`)));
+    req.end();
+  });
+}
+
+function getAllFiles(dir) {
+  const results = [];
+  if (!fs.existsSync(dir)) return results;
+  const entries = fs.readdirSync(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const full = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      results.push(...getAllFiles(full));
+    } else {
+      results.push(full);
+    }
+  }
+  return results;
+}
+
+module.exports = { pushBundle, pushAssets, resetDevice };