@jetstart/core 1.7.0 → 2.0.0

package/src/build/gradle.ts

@@ -3,13 +3,271 @@
  * Spawns and manages Gradle build processes
  */
 
-import { spawn, ChildProcess } from 'child_process';
+import { spawn, ChildProcess, execSync } from 'child_process';
 import * as fs from 'fs';
 import * as path from 'path';
 import * as os from 'os';
 import { BuildConfig, BuildResult } from '@jetstart/shared';
 import { BuildOutputParser } from './parser';
 
+/**
+ * ADB Helper for auto-installing APKs
+ */
+export class AdbHelper {
+  private adbPath: string | null = null;
+  private connectedDevices = new Map<string, { lastConnected: number; retryCount: number }>();
+
+  constructor() {
+    this.adbPath = this.findAdb();
+  }
+
+  /**
+   * Find adb executable
+   */
+  private findAdb(): string | null {
+    const isWindows = os.platform() === 'win32';
+
+    // Check common locations
+    const commonPaths = isWindows ? [
+      'C:\\Android\\platform-tools\\adb.exe',
+      path.join(os.homedir(), 'AppData', 'Local', 'Android', 'Sdk', 'platform-tools', 'adb.exe'),
+    ] : [
+      path.join(os.homedir(), 'Android', 'Sdk', 'platform-tools', 'adb'),
+      path.join(os.homedir(), 'Library', 'Android', 'sdk', 'platform-tools', 'adb'),
+      '/opt/android-sdk/platform-tools/adb',
+    ];
+
+    for (const p of commonPaths) {
+      if (fs.existsSync(p)) {
+        console.log(`[ADB] Found at: ${p}`);
+        return p;
+      }
+    }
+
+    // Try PATH
+    try {
+      const result = execSync(isWindows ? 'where adb' : 'which adb', { encoding: 'utf8' });
+      const adbPath = result.trim().split('\n')[0];
+      if (fs.existsSync(adbPath)) {
+        console.log(`[ADB] Found in PATH: ${adbPath}`);
+        return adbPath;
+      }
+    } catch {
+      // Not in PATH
+    }
+
+    console.warn('[ADB] Not found. Auto-install disabled.');
+    return null;
+  }
+
+  /**
+   * Get list of connected devices (FULLY READY devices only)
+   * Returns only devices in "device" state (connected and authorized)
+   */
+  getDevices(): string[] {
+    if (!this.adbPath) return [];
+
+    try {
+      const output = execSync(`"${this.adbPath}" devices`, { encoding: 'utf8' });
+      const lines = output.trim().split('\n').slice(1); // Skip header
+      return lines
+        .filter(line => line.includes('\tdevice'))
+        .map(line => line.split('\t')[0]);
+    } catch (err) {
+      console.error('[ADB] Failed to get devices:', err);
+      return [];
+    }
+  }
+
+  /**
+   * Get ALL devices including those in "connecting" or "offline" state
+   * Useful for debugging and understanding device availability
+   */
+  getAllDeviceStates(): { id: string; state: string }[] {
+    if (!this.adbPath) return [];
+
+    try {
+      const output = execSync(`"${this.adbPath}" devices`, { encoding: 'utf8' });
+      const lines = output.trim().split('\n').slice(1); // Skip header
+      return lines
+        .filter(line => line.trim().length > 0)
+        .map(line => {
+          const parts = line.split(/\s+/);
+          return { id: parts[0], state: parts[1] || 'unknown' };
+        });
+    } catch (err) {
+      console.error('[ADB] Failed to get device states:', err);
+      return [];
+    }
+  }
+
+  /**
+   * Install APK on a device
+   */
+  async installApk(apkPath: string, deviceId?: string): Promise<{ success: boolean; error?: string }> {
+    if (!this.adbPath) {
+      return { success: false, error: 'ADB not found' };
+    }
+
+    if (!fs.existsSync(apkPath)) {
+      return { success: false, error: `APK not found: ${apkPath}` };
+    }
+
+    const devices = this.getDevices();
+    if (devices.length === 0) {
+      return { success: false, error: 'No devices connected' };
+    }
+
+    const target = deviceId || devices[0];
+    console.log(`[ADB] Installing APK on device: ${target}`);
+
+    return new Promise((resolve) => {
+      const args = ['-s', target, 'install', '-r', apkPath];
+      const proc = spawn(this.adbPath!, args, { shell: true });
+
+      let output = '';
+      let errorOutput = '';
+
+      proc.stdout.on('data', (data) => {
+        output += data.toString();
+        console.log(`[ADB] ${data.toString().trim()}`);
+      });
+
+      proc.stderr.on('data', (data) => {
+        errorOutput += data.toString();
+        console.error(`[ADB] ${data.toString().trim()}`);
+      });
+
+      proc.on('close', (code) => {
+        if (code === 0 && output.includes('Success')) {
+          console.log('[ADB] ✅ APK installed successfully!');
+          resolve({ success: true });
+        } else {
+          resolve({ success: false, error: errorOutput || output || `Exit code: ${code}` });
+        }
+      });
+
+      proc.on('error', (err) => {
+        resolve({ success: false, error: err.message });
+      });
+    });
+  }
+
+  /**
+   * Launch app on device
+   */
+  async launchApp(packageName: string, activityName: string, deviceId?: string): Promise<boolean> {
+    if (!this.adbPath) return false;
+
+    const devices = this.getDevices();
+    if (devices.length === 0) return false;
+
+    const target = deviceId || devices[0];
+
+    try {
+      execSync(`"${this.adbPath}" -s ${target} shell am start -n ${packageName}/${activityName}`, { encoding: 'utf8' });
+      console.log(`[ADB] ✅ Launched ${packageName}`);
+      return true;
+    } catch (err) {
+      console.error('[ADB] Failed to launch app:', err);
+      return false;
+    }
+  }
+
+  /**
+   * Connect to a device via wireless ADB with retry logic
+   * Called when the JetStart app connects via WebSocket
+   *
+   * Handles timing issues with wireless ADB:
+   * - Devices may need time for user approval
+   * - Network handshake can be slow
+   * - Retries automatically if device not ready
+   */
+  connectWireless(ipAddress: string, retryCount: number = 0): void {
+    if (!this.adbPath) {
+      console.warn('[ADB] ADB not found, cannot connect wireless device');
+      return;
+    }
+
+    const target = `${ipAddress}:5555`;
+    const maxRetries = 5;
+    const retryDelays = [0, 1000, 2000, 3000, 5000]; // Escalating delays
+
+    try {
+      // console.log(`[ADB] Attempting wireless connection to ${target}...${retryCount > 0 ? ` (retry ${retryCount}/${maxRetries})` : ''}`);
+
+      // Use longer timeout: 15 seconds for wireless ADB handshake
+      // This allows time for:
+      // - User approval on device
+      // - Network handshake
+      // - ADB daemon initialization
+      execSync(`"${this.adbPath}" connect ${target}`, {
+        encoding: 'utf8',
+        timeout: 15000,
+        stdio: ['pipe', 'pipe', 'pipe']
+      });
+
+      // CRITICAL: After connect, device needs time to reach "device" state
+      // Poll for device state readiness
+      this.waitForDeviceReady(target, retryCount, maxRetries, retryDelays);
+    } catch (err: any) {
+      // Handle timeout or connection errors with retry
+      if (retryCount < maxRetries) {
+        const delay = retryDelays[retryCount + 1] || 5000;
+        console.warn(`[ADB] Connection failed: ${err.message}`);
+        console.log(`[ADB] Retrying in ${delay}ms... (attempt ${retryCount + 1}/${maxRetries})`);
+        setTimeout(() => this.connectWireless(ipAddress, retryCount + 1), delay);
+      } else {
+        console.error(`[ADB] Failed to connect ${target} after ${maxRetries} retries: ${err.message}`);
+        console.warn(`[ADB] Device may need user authorization on the phone. Check your device!`);
+      }
+    }
+  }
+
+  /**
+   * Wait for a device to reach "device" state after adb connect
+   * The device may be "connecting" or "offline" initially
+   */
+  private waitForDeviceReady(
+    target: string,
+    connectRetryCount: number,
+    maxConnectRetries: number,
+    connectRetryDelays: number[]
+  ): void {
+    const maxWaitAttempts = 10;
+    const waitInterval = 500; // Check every 500ms
+
+    const checkDeviceState = (attemptNum: number = 0) => {
+      if (attemptNum > maxWaitAttempts) {
+        console.warn(`[ADB] Device ${target} not ready after ${maxWaitAttempts * waitInterval}ms, will retry on next build`);
+        return;
+      }
+
+      const allDevices = this.getAllDeviceStates();
+      const device = allDevices.find(d => d.id === target);
+
+      if (device?.state === 'device') {
+        // ✅ Device is ready!
+        console.log(`[ADB] ✅ Wireless ADB connected and ready: ${target}`);
+        this.connectedDevices.set(target, { lastConnected: Date.now(), retryCount: 0 });
+      } else if (device?.state === 'connecting' || device?.state === 'offline' || device?.state === 'unknown') {
+        // Device is still connecting, check again later
+        console.log(`[ADB] Device state: ${device?.state || 'not found'}, waiting...`);
+        setTimeout(() => checkDeviceState(attemptNum + 1), waitInterval);
+      } else if (!device) {
+        // Device not found yet, retry connection
+        if (connectRetryCount < maxConnectRetries) {
+          const delay = connectRetryDelays[connectRetryCount + 1] || 5000;
+          setTimeout(() => this.connectWireless(target.split(':')[0], connectRetryCount + 1), delay);
+        }
+      }
+    };
+
+    // Start polling for device readiness
+    setTimeout(() => checkDeviceState(), 100);
+  }
+}
+
 export interface GradleExecutorOptions {
   javaHome?: string;
   androidHome?: string;

package/src/build/hot-reload-service.ts

@@ -0,0 +1,178 @@
+/**
+ * Hot Reload Service
+ * Orchestrates Kotlin compilation, DEX generation, and sending to app
+ */
+
+import * as path from 'path';
+import * as fs from 'fs';
+import * as os from 'os';
+import { KotlinCompiler } from './kotlin-compiler';
+import { DexGenerator } from './dex-generator';
+import { OverrideGenerator } from './override-generator';
+import { log, error as logError, success } from '../utils/logger';
+
+export interface HotReloadResult {
+  success: boolean;
+  dexBase64: string | null;
+  classNames: string[];
+  errors: string[];
+  compileTime: number;
+  dexTime: number;
+}
+
+export class HotReloadService {
+  private kotlinCompiler: KotlinCompiler;
+  private dexGenerator: DexGenerator;
+  private overrideGenerator: OverrideGenerator;
+  private projectPath: string;
+
+  constructor(projectPath: string) {
+    this.projectPath = projectPath;
+    this.kotlinCompiler = new KotlinCompiler(projectPath);
+    this.dexGenerator = new DexGenerator();
+    this.overrideGenerator = new OverrideGenerator();
+  }
+
+  /**
+   * Perform hot reload for a changed Kotlin file
+   * Returns DEX bytes ready to be sent to the app
+   */
+  async hotReload(filePath: string): Promise<HotReloadResult> {
+    const startTime = Date.now();
+
+    log(`🔥 Hot reload starting for: ${path.basename(filePath)}`);
+
+    // Step 1: Compile Kotlin to .class
+    const compileStart = Date.now();
+    const compileResult = await this.kotlinCompiler.compileFile(filePath);
+    const compileTime = Date.now() - compileStart;
+
+    if (!compileResult.success) {
+      logError(`Compilation failed: ${compileResult.errors.join(', ')}`);
+      return {
+        success: false,
+        dexBase64: null,
+        classNames: [],
+        errors: compileResult.errors,
+        compileTime,
+        dexTime: 0
+      };
+    }
+
+    log(`Compilation completed in ${compileTime}ms (${compileResult.classFiles.length} classes)`);
+
+    // Step 2: Generate $Override classes (Phase 2)
+    const overrideDir = path.join(os.tmpdir(), 'jetstart-overrides', Date.now().toString());
+    fs.mkdirSync(overrideDir, { recursive: true });
+
+    const overrideResult = await this.overrideGenerator.generateOverrides(
+      compileResult.classFiles,
+      filePath,
+      overrideDir
+    );
+
+    if (!overrideResult.success) {
+      log(`⚠️ Override generation failed: ${overrideResult.errors.join(', ')}`);
+      log(`📝 Falling back to direct class hot reload (less efficient)`);
+    } else {
+      log(`Generated ${overrideResult.overrideClassFiles.length} override classes`);
+
+      // Compile override source files to .class
+      const allOverrideClassFiles: string[] = [];
+      for (const overrideFile of overrideResult.overrideClassFiles) {
+        const compRes = await this.kotlinCompiler.compileFile(overrideFile);
+        if (compRes.success) {
+          allOverrideClassFiles.push(...compRes.classFiles);
+        } else {
+          log(`⚠️ Failed to compile override ${path.basename(overrideFile)}: ${compRes.errors.join(', ')}`);
+        }
+      }
+
+      if (allOverrideClassFiles.length > 0) {
+        log(`Compiled ${allOverrideClassFiles.length} override classes`);
+        // Add override classes to DEX generation
+        compileResult.classFiles.push(...allOverrideClassFiles);
+      }
+    }
+
+    // Step 3: Convert .class to .dex
+    const dexStart = Date.now();
+    const dexResult = await this.dexGenerator.generateDex(compileResult.classFiles);
+    const dexTime = Date.now() - dexStart;
+
+    if (!dexResult.success || !dexResult.dexBytes) {
+      logError(`DEX generation failed: ${dexResult.errors.join(', ')}`);
+      return {
+        success: false,
+        dexBase64: null,
+        classNames: [],
+        errors: dexResult.errors,
+        compileTime,
+        dexTime
+      };
+    }
+
+    log(`DEX generated in ${dexTime}ms (${dexResult.dexBytes.length} bytes)`);
+
+    // Extract class names from file paths
+    const classNames = this.extractClassNames(compileResult.classFiles, compileResult.outputDir);
+
+    const totalTime = Date.now() - startTime;
+    success(`🔥 Hot reload complete in ${totalTime}ms (compile: ${compileTime}ms, dex: ${dexTime}ms)`);
+
+    return {
+      success: true,
+      dexBase64: dexResult.dexBytes.toString('base64'),
+      classNames,
+      errors: [],
+      compileTime,
+      dexTime
+    };
+  }
+
+  /**
+   * Extract fully qualified class names from class file paths
+   */
+  private extractClassNames(classFiles: string[], outputDir: string): string[] {
+    return classFiles.map(classFile => {
+      // Remove output dir prefix and .class suffix
+      let relativePath = classFile
+        .replace(outputDir, '')
+        .replace(/^[\/\\]/, '')
+        .replace('.class', '');
+
+      // Convert path separators to dots
+      return relativePath.replace(/[\/\\]/g, '.');
+    });
+  }
+
+  /**
+   * Check if the environment is properly set up for hot reload
+   */
+  async checkEnvironment(): Promise<{ ready: boolean; issues: string[] }> {
+    const issues: string[] = [];
+
+    // Check kotlinc
+    const kotlinc = await this.kotlinCompiler.findKotlinc();
+    if (!kotlinc) {
+      issues.push('kotlinc not found - install Kotlin or set KOTLIN_HOME');
+    }
+
+    // Check d8
+    const d8 = await this.dexGenerator.findD8();
+    if (!d8) {
+      issues.push('d8 not found - set ANDROID_HOME and install build-tools');
+    }
+
+    // Check classpath
+    const classpath = await this.kotlinCompiler.buildClasspath();
+    if (classpath.length === 0) {
+      issues.push('Cannot build classpath - ANDROID_HOME not set or SDK not installed');
+    }
+
+    return {
+      ready: issues.length === 0,
+      issues
+    };
+  }
+}