yaver-cli 1.0.1 → 1.95.5

package/src/agent-runtime.js

@@ -0,0 +1,329 @@
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { spawn } = require('child_process');
+const { pipeline } = require('stream/promises');
+const https = require('https');
+const semver = require('semver');
+
+const PACKAGE = require('../package.json');
+
+const DEFAULT_REPO = process.env.YAVER_AGENT_REPO || 'kivanccakmak/yaver.io';
+const WINDOWS_REPO = process.env.YAVER_WINDOWS_AGENT_REPO || 'kivanccakmak/yaver-cli';
+const CACHE_ROOT = process.env.YAVER_AGENT_CACHE_DIR || path.join(os.homedir(), '.yaver', 'bin');
+let resolvedAgentVersionPromise = null;
+const resolvedAssetPromiseByKey = new Map();
+
+async function ensureAgentBinary({ quiet = false } = {}) {
+  const asset = await resolveAsset();
+  const localAgentPath = resolveLocalAgentBinary(asset);
+  if (localAgentPath) {
+    return localAgentPath;
+  }
+  const installDir = path.join(CACHE_ROOT, asset.version, asset.cacheKey);
+  const binaryPath = path.join(installDir, asset.binaryName);
+
+  if (fs.existsSync(binaryPath)) {
+    if (process.platform !== 'win32') {
+      fs.chmodSync(binaryPath, 0o755);
+    }
+    return binaryPath;
+  }
+
+  fs.mkdirSync(installDir, { recursive: true });
+  const tmpPath = path.join(installDir, asset.downloadName);
+
+  if (!quiet) {
+    console.error(`Installing Yaver agent ${asset.version} for ${asset.cacheKey}...`);
+  }
+
+  await downloadToFile(asset.url, tmpPath);
+
+  if (asset.archiveType === 'tar.gz') {
+    await extractTarball(tmpPath, installDir);
+    fs.rmSync(tmpPath, { force: true });
+    if (!fs.existsSync(binaryPath) && asset.extractedBinaryName) {
+      const extractedPath = path.join(installDir, asset.extractedBinaryName);
+      if (fs.existsSync(extractedPath)) {
+        fs.renameSync(extractedPath, binaryPath);
+      }
+    }
+  } else {
+    fs.renameSync(tmpPath, binaryPath);
+  }
+
+  if (!fs.existsSync(binaryPath)) {
+    throw new Error(`agent binary missing after install: ${binaryPath}`);
+  }
+  if (process.platform !== 'win32') {
+    fs.chmodSync(binaryPath, 0o755);
+  }
+  return binaryPath;
+}
+
+async function runAgentCommand(args, options = {}) {
+  const localAgent = resolveLocalAgentCommand(args);
+  const spawnSpec = localAgent
+    ? localAgent
+    : { command: await ensureAgentBinary(options), args };
+  const child = spawn(spawnSpec.command, spawnSpec.args, {
+    stdio: 'inherit',
+    env: process.env,
+    cwd: spawnSpec.cwd || process.cwd(),
+  });
+
+  await new Promise((resolve, reject) => {
+    child.on('error', reject);
+    child.on('exit', (code, signal) => {
+      if (signal) {
+        reject(new Error(`agent terminated by signal ${signal}`));
+        return;
+      }
+      if (code && code !== 0) {
+        const error = new Error(`agent exited with code ${code}`);
+        error.exitCode = code;
+        reject(error);
+        return;
+      }
+      resolve();
+    });
+  });
+}
+
+function resolveAgentInfo() {
+  return {
+    version: process.env.YAVER_AGENT_VERSION || PACKAGE.version,
+    repo: DEFAULT_REPO,
+    note: 'Run a real agent command once to resolve the current published agent release.',
+  };
+}
+
+function resolveLocalAgentBinary(asset) {
+  if (process.env.YAVER_AGENT_BIN && fs.existsSync(process.env.YAVER_AGENT_BIN)) {
+    return process.env.YAVER_AGENT_BIN;
+  }
+  const repoBinary = path.join(repoRoot(), 'desktop', 'agent', asset.downloadName.replace('.tar.gz', '').replace('.exe', '.exe'));
+  if (fs.existsSync(repoBinary)) {
+    return repoBinary;
+  }
+  return null;
+}
+
+function resolveLocalAgentCommand(agentArgs) {
+  if (process.env.YAVER_AGENT_BIN && fs.existsSync(process.env.YAVER_AGENT_BIN)) {
+    return { command: process.env.YAVER_AGENT_BIN, args: agentArgs };
+  }
+
+  const asset = resolveLocalAsset();
+  const localBinary = resolveLocalAgentBinary(asset);
+  if (localBinary) {
+    return { command: localBinary, args: agentArgs };
+  }
+
+  const agentDir = path.join(repoRoot(), 'desktop', 'agent');
+  const goMod = path.join(agentDir, 'go.mod');
+  if (fs.existsSync(goMod)) {
+    return {
+      command: 'go',
+      args: ['run', '.', ...agentArgs],
+      cwd: agentDir,
+    };
+  }
+
+  return null;
+}
+
+function resolveLocalAsset() {
+  const platform = process.platform;
+  const arch = process.arch;
+  const goArch = arch === 'x64' ? 'amd64' : arch === 'arm64' ? 'arm64' : null;
+
+  if (!goArch) {
+    throw new Error(`unsupported architecture for npm bootstrap: ${arch}`);
+  }
+
+  if (platform === 'win32') {
+    return {
+      cacheKey: `${platform}-${goArch}`,
+      binaryName: 'yaver.exe',
+      downloadName: `yaver-windows-${goArch}.exe`,
+      archiveType: 'exe',
+      url: '',
+      version: process.env.YAVER_AGENT_VERSION || PACKAGE.version,
+    };
+  }
+
+  if (platform === 'darwin' || platform === 'linux') {
+    return {
+      cacheKey: `${platform}-${goArch}`,
+      binaryName: 'yaver',
+      extractedBinaryName: `yaver-${platform}-${goArch}`,
+      downloadName: `yaver-${platform}-${goArch}.tar.gz`,
+      archiveType: 'tar.gz',
+      url: '',
+      version: process.env.YAVER_AGENT_VERSION || PACKAGE.version,
+    };
+  }
+
+  throw new Error(`unsupported platform for npm bootstrap: ${platform}`);
+}
+
+async function resolveAsset() {
+  const platform = process.platform;
+  const arch = process.arch;
+  const goArch = arch === 'x64' ? 'amd64' : arch === 'arm64' ? 'arm64' : null;
+
+  if (!goArch) {
+    throw new Error(`unsupported architecture for npm bootstrap: ${arch}`);
+  }
+
+  const cacheKey = `${platform}-${goArch}`;
+  if (!resolvedAssetPromiseByKey.has(cacheKey)) {
+    resolvedAssetPromiseByKey.set(cacheKey, fetchRemoteAsset(platform, goArch));
+  }
+  return resolvedAssetPromiseByKey.get(cacheKey);
+}
+
+async function fetchRemoteAsset(platform, goArch) {
+  if (platform === 'win32') {
+    const release = await fetchLatestRelease(WINDOWS_REPO);
+    const asset = findReleaseAsset(release, [`yaver-windows-${goArch}.exe`]);
+    if (!asset) {
+      throw new Error(`could not find Windows agent asset for ${goArch} in ${WINDOWS_REPO}`);
+    }
+    return {
+      cacheKey: `${platform}-${goArch}`,
+      binaryName: 'yaver.exe',
+      downloadName: asset.name,
+      archiveType: 'exe',
+      url: asset.browser_download_url,
+      version: release.tag_name.replace(/^v/, ''),
+    };
+  }
+
+  if (platform === 'darwin' || platform === 'linux') {
+    const release = await fetchLatestRelease(DEFAULT_REPO);
+    const version = release.tag_name.replace(/^v/, '');
+    const asset = findReleaseAsset(release, [
+      `yaver-v${version}-${platform}-${goArch}.tar.gz`,
+      `yaver-${platform}-${goArch}.tar.gz`,
+    ]);
+    if (!asset) {
+      throw new Error(`could not find ${platform}/${goArch} agent tarball in ${DEFAULT_REPO}`);
+    }
+    return {
+      cacheKey: `${platform}-${goArch}`,
+      binaryName: 'yaver',
+      extractedBinaryName: `yaver-${platform}-${goArch}`,
+      downloadName: asset.name,
+      archiveType: 'tar.gz',
+      url: asset.browser_download_url,
+      version,
+    };
+  }
+
+  throw new Error(`unsupported platform for npm bootstrap: ${platform}`);
+}
+
+async function fetchLatestRelease(repo) {
+  const response = await request(`https://api.github.com/repos/${repo}/releases?per_page=20`, {
+    headers: {
+      'User-Agent': `yaver-cli/${PACKAGE.version}`,
+      Accept: 'application/vnd.github+json',
+    },
+  });
+  const body = await readResponseBody(response);
+  if (response.statusCode && response.statusCode >= 400) {
+    throw new Error(`failed to resolve latest release (${response.statusCode}) from ${repo}`);
+  }
+
+  let releases;
+  try {
+    releases = JSON.parse(body);
+  } catch (error) {
+    throw new Error(`invalid release metadata from ${repo}: ${error.message}`);
+  }
+
+  const latest = Array.isArray(releases)
+    ? releases.find((release) => !release.draft && !release.prerelease && semver.valid(String(release.tag_name || '').replace(/^v/, '')))
+    : null;
+
+  if (!latest || !latest.tag_name) {
+    throw new Error(`could not find a published semver release in ${repo}`);
+  }
+
+  return latest;
+}
+
+function findReleaseAsset(release, names) {
+  const byName = new Map((release.assets || []).map((asset) => [asset.name, asset]));
+  for (const name of names) {
+    const asset = byName.get(name);
+    if (asset) return asset;
+  }
+  return null;
+}
+
+async function downloadToFile(url, destPath) {
+  const response = await request(url);
+  if (response.statusCode && response.statusCode >= 400) {
+    throw new Error(`download failed (${response.statusCode}) from ${url}. Publish the matching CLI release assets or set YAVER_AGENT_BIN.`);
+  }
+  await pipeline(response, fs.createWriteStream(destPath));
+}
+
+function request(url, options = {}) {
+  return new Promise((resolve, reject) => {
+    https.get(url, options, (response) => {
+      if (response.statusCode && response.statusCode >= 300 && response.statusCode < 400 && response.headers.location) {
+        resolve(request(response.headers.location, options));
+        return;
+      }
+      resolve(response);
+    }).on('error', reject);
+  });
+}
+
+function readResponseBody(response) {
+  return new Promise((resolve, reject) => {
+    let body = '';
+    response.setEncoding('utf8');
+    response.on('data', (chunk) => {
+      body += chunk;
+    });
+    response.on('end', () => resolve(body));
+    response.on('error', reject);
+  });
+}
+
+async function extractTarball(archivePath, destDir) {
+  const child = spawn('tar', ['-xzf', archivePath, '-C', destDir], {
+    stdio: ['ignore', 'pipe', 'pipe'],
+  });
+
+  let stderr = '';
+  child.stderr.on('data', (chunk) => {
+    stderr += chunk.toString();
+  });
+
+  await new Promise((resolve, reject) => {
+    child.on('error', reject);
+    child.on('exit', (code) => {
+      if (code !== 0) {
+        reject(new Error(stderr.trim() || `tar exited with code ${code}`));
+        return;
+      }
+      resolve();
+    });
+  });
+}
+
+module.exports = {
+  ensureAgentBinary,
+  resolveAgentInfo,
+  runAgentCommand,
+};
+
+function repoRoot() {
+  return path.resolve(__dirname, '..', '..');
+}

package/src/analyzer.js

@@ -73,7 +73,7 @@ function analyzeProject(packageJson, sdkManifest) {
     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;
+    if (!looksLikeNativeModule(name, sdkManifest)) continue;
 
     const sdkVersion = sdkManifest.nativeModules[name];
 
@@ -89,10 +89,10 @@ function analyzeProject(packageJson, sdkManifest) {
 
       const localParsed = semver.coerce(cleanLocal);
       const sdkParsed = semver.coerce(sdkVersion);
-      if (localParsed && sdkParsed && semver.major(localParsed) !== semver.major(sdkParsed)) {
+      if (localParsed && sdkParsed && hasPotentiallyBreakingVersionDrift(localParsed, sdkParsed)) {
         warnings.push({
           type: 'version_mismatch', module: name,
-          message: `"${name}": project ${version}, yaver ${sdkVersion}. Major version differs.`,
+          message: `"${name}": project ${version}, yaver ${sdkVersion}. Version differs at a potentially breaking boundary.`,
         });
       }
     }
@@ -101,7 +101,8 @@ function analyzeProject(packageJson, sdkManifest) {
   return { reactNativeVersion: projectRN, errors, warnings, availableModules, missingModules };
 }
 
-function looksLikeNativeModule(name) {
+function looksLikeNativeModule(name, sdkManifest) {
+  if (sdkManifest?.nativeModules?.[name]) return true;
   return name.startsWith('react-native-') ||
     name.startsWith('@react-native-') ||
     name.startsWith('@react-native/') ||
@@ -114,4 +115,12 @@ function cleanVersion(v) {
   return (v || '').replace(/[\^~>=<\s]/g, '');
 }
 
+function hasPotentiallyBreakingVersionDrift(projectVersion, sdkVersion) {
+  if (semver.major(projectVersion) !== semver.major(sdkVersion)) return true;
+  if (semver.major(projectVersion) === 0 && semver.minor(projectVersion) !== semver.minor(sdkVersion)) {
+    return true;
+  }
+  return false;
+}
+
 module.exports = { analyzeProject, PURE_JS_PACKAGES, FALSE_POSITIVE_NATIVE };

package/src/bundler.js

@@ -103,13 +103,13 @@ async function compileHermes({ inputPath, outputPath }) {
 
 function readBytecodeVersion(hbcPath) {
   const buf = fs.readFileSync(hbcPath);
-  if (buf.length < 8) return null;
+  if (buf.length < 12) return null;
 
-  // Hermes magic: 0x1F1903C1 (little-endian)
-  const magic = buf.readUInt32LE(0);
+  // Hermes HBC format: magic at offset 4, BC version at offset 8
+  const magic = buf.readUInt32LE(4);
   if (magic !== 0x1F1903C1) return null;
 
-  return buf.readUInt32LE(4);
+  return buf.readUInt32LE(8);
 }
 
 module.exports = { bundle, compileHermes, readBytecodeVersion, getHermescPath };

package/src/commands/devices.js

@@ -16,7 +16,7 @@ async function devices() {
   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`);
+    console.log(`     Push: yaver push --device ${d.ip}\n`);
   }
 }
 

package/src/commands/doctor.js

@@ -1,5 +1,6 @@
 const fs = require('fs');
 const { analyzeProject } = require('../analyzer');
+const { loadSDKManifest } = require('../sdk-manifest');
 
 async function doctor() {
   if (!fs.existsSync('package.json')) {
@@ -8,7 +9,7 @@ async function doctor() {
   }
 
   const pkg = JSON.parse(fs.readFileSync('package.json', 'utf8'));
-  const sdkManifest = require('../../sdk-manifest.json');
+  const sdkManifest = loadSDKManifest();
   const analysis = analyzeProject(pkg, sdkManifest);
 
   console.log('\n📋 Yaver Compatibility Report\n');

package/src/commands/init.js

@@ -1,6 +1,6 @@
 const fs = require('fs');
-const path = require('path');
 const { analyzeProject } = require('../analyzer');
+const { loadSDKManifest } = require('../sdk-manifest');
 
 async function init() {
   if (!fs.existsSync('package.json')) {
@@ -16,7 +16,7 @@ async function init() {
 
   console.log('🔍 Analyzing your project...\n');
 
-  const sdkManifest = require('../../sdk-manifest.json');
+  const sdkManifest = loadSDKManifest();
   const analysis = analyzeProject(pkg, sdkManifest);
 
   printAnalysis(analysis, sdkManifest);
@@ -37,12 +37,12 @@ async function init() {
 
   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('   You can still push with: yaver 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');
+    console.log('\n🎉 Fully compatible! Run: yaver push\n');
   }
 }
 

package/src/commands/modules.js

@@ -1,5 +1,6 @@
 async function modules() {
-  const sdkManifest = require('../../sdk-manifest.json');
+  const { loadSDKManifest } = require('../sdk-manifest');
+  const sdkManifest = loadSDKManifest();
 
   console.log(`\n📦 Yaver SDK v${sdkManifest.sdkVersion} — Native Modules\n`);
   console.log(`  React Native: ${sdkManifest.reactNative}`);

package/src/commands/push.js

@@ -3,13 +3,14 @@ const path = require('path');
 const { analyzeProject } = require('../analyzer');
 const { bundle, compileHermes, readBytecodeVersion } = require('../bundler');
 const { discoverDevice, fetchHealth } = require('../discovery');
+const { loadSDKManifest } = require('../sdk-manifest');
 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');
+  const sdkManifest = loadSDKManifest();
 
   // Find device
   if (!quiet) console.log('📡 Finding device...');
@@ -22,7 +23,7 @@ async function push(options = {}) {
 
   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.');
+    console.error('   Update the npm package or the yaver.io app.');
     process.exit(1);
   }
 
@@ -42,7 +43,7 @@ async function push(options = {}) {
     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');
+    console.warn('  Push anyway: yaver push --ignore-missing\n');
     if (!options.force) process.exit(1);
   }
 

package/src/commands/status.js

@@ -14,7 +14,7 @@ async function status(options = {}) {
     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');
+    console.log('  No yaver.json found. Run: yaver push init');
   }
 
   // Device status

package/src/discovery.js

@@ -24,7 +24,7 @@ async function discoverDevice(manualIp) {
   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>'
+    '  Or specify device IP: yaver push --device <ip>'
   );
 }
 

package/src/index.js

@@ -1,3 +1,5 @@
+const PACKAGE = require('../package.json');
+const { resolveAgentInfo, runAgentCommand } = require('./agent-runtime');
 const { init } = require('./commands/init');
 const { push } = require('./commands/push');
 const { doctor } = require('./commands/doctor');
@@ -6,8 +8,8 @@ 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
+const PUSH_HELP = `
+yaver push — Push existing React Native projects to the Yaver mobile host
 
 Commands:
   init                              Analyze project, show compatibility, create yaver.json
@@ -27,12 +29,43 @@ Options:
   --help                            Show this help
 `;
 
-async function run(args) {
+const UNIFIED_HELP = `
+yaver — single npm install for the Go agent and the RN push CLI
+
+Agent commands:
+  yaver serve                       Start the Yaver agent (downloads platform binary if needed)
+  yaver auth                        Sign in and configure the agent
+  yaver version                     Print agent version
+  yaver <agent-command>             Forward any other command to the Go agent
+
+Push-to-device commands:
+  yaver push                        Bundle + validate + push current RN/Expo project
+  yaver push init                   Analyze current project and create yaver.json
+  yaver push doctor                 Deep compatibility report for current project
+  yaver push modules                List native modules compiled into the mobile host
+  yaver push devices                Scan LAN for Yaver mobile hosts
+  yaver push reset                  Clear pushed bundle on the selected device
+  yaver push status                 Show project + device push status
+
+Compatibility:
+  yaver-push <command>              Legacy alias for the push subcommands above
+
+Options:
+  --help                            Show this help
+`;
+
+const PUSH_SUBCOMMANDS = new Set(['init', 'push', 'doctor', 'devices', 'modules', 'reset', 'status']);
+const DIRECT_PUSH_ALIASES = new Map([
+  ['init', 'init'],
+  ['modules', 'modules'],
+]);
+
+async function runPushCli(args) {
   const command = args[0];
   const options = parseArgs(args.slice(1));
 
-  if (!command || command === '--help' || command === '-h') {
-    console.log(HELP);
+  if (!command || command === '--help' || command === '-h' || args.includes('--help') || args.includes('-h')) {
+    console.log(PUSH_HELP);
     process.exit(0);
   }
 
@@ -61,7 +94,7 @@ async function run(args) {
         break;
       default:
         console.error(`Unknown command: ${command}`);
-        console.log(HELP);
+        console.log(PUSH_HELP);
         process.exit(1);
     }
   } catch (err) {
@@ -71,6 +104,53 @@ async function run(args) {
   }
 }
 
+async function runUnified(args) {
+  const command = args[0];
+
+  if (!command || command === '--help' || command === '-h' || command === 'help') {
+    console.log(UNIFIED_HELP);
+    process.exit(0);
+  }
+
+  if (command === 'push') {
+    const next = args[1];
+    if (!next || next.startsWith('-')) {
+      await runPushCli(['push', ...args.slice(1)]);
+      return;
+    }
+    if (PUSH_SUBCOMMANDS.has(next)) {
+      const subcommand = next === 'push' ? 'push' : next;
+      await runPushCli([subcommand, ...args.slice(2)]);
+      return;
+    }
+    console.error(`Unknown push subcommand: ${next}`);
+    console.log(PUSH_HELP);
+    process.exit(1);
+  }
+
+  if (DIRECT_PUSH_ALIASES.has(command)) {
+    await runPushCli([DIRECT_PUSH_ALIASES.get(command), ...args.slice(1)]);
+    return;
+  }
+
+  if (command === 'npm-agent-info') {
+    const info = resolveAgentInfo();
+    console.log(JSON.stringify(info, null, 2));
+    return;
+  }
+
+  try {
+    await runAgentCommand(args);
+  } catch (err) {
+    if (typeof err.exitCode === 'number') {
+      process.exit(err.exitCode);
+    }
+    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++) {
@@ -90,4 +170,4 @@ function parseArgs(args) {
   return opts;
 }
 
-module.exports = { run };
+module.exports = { runPushCli, runUnified };

package/src/sdk-manifest.js

@@ -0,0 +1,9 @@
+const path = require('path');
+
+function loadSDKManifest() {
+  const manifestPath = path.resolve(__dirname, '..', 'sdk-manifest.json');
+  delete require.cache[manifestPath];
+  return require(manifestPath);
+}
+
+module.exports = { loadSDKManifest };