@jetstart/core 1.7.0 → 2.0.1

package/dist/build/gradle.js

@@ -37,12 +37,244 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.GradleExecutor = void 0;
+exports.GradleExecutor = exports.AdbHelper = void 0;
 const child_process_1 = require("child_process");
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const os = __importStar(require("os"));
 const parser_1 = require("./parser");
+/**
+ * ADB Helper for auto-installing APKs
+ */
+class AdbHelper {
+    adbPath = null;
+    connectedDevices = new Map();
+    constructor() {
+        this.adbPath = this.findAdb();
+    }
+    /**
+     * Find adb executable
+     */
+    findAdb() {
+        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 = (0, child_process_1.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() {
+        if (!this.adbPath)
+            return [];
+        try {
+            const output = (0, child_process_1.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() {
+        if (!this.adbPath)
+            return [];
+        try {
+            const output = (0, child_process_1.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, deviceId) {
+        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 = (0, child_process_1.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, activityName, deviceId) {
+        if (!this.adbPath)
+            return false;
+        const devices = this.getDevices();
+        if (devices.length === 0)
+            return false;
+        const target = deviceId || devices[0];
+        try {
+            (0, child_process_1.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, retryCount = 0) {
+        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
+            (0, child_process_1.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) {
+            // 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
+     */
+    waitForDeviceReady(target, connectRetryCount, maxConnectRetries, connectRetryDelays) {
+        const maxWaitAttempts = 10;
+        const waitInterval = 500; // Check every 500ms
+        const checkDeviceState = (attemptNum = 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);
+    }
+}
+exports.AdbHelper = AdbHelper;
 class GradleExecutor {
     javaHome;
     androidHome;

package/dist/build/hot-reload-service.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Hot Reload Service
+ * Orchestrates Kotlin compilation, DEX generation, and sending to app
+ */
+export interface HotReloadResult {
+    success: boolean;
+    dexBase64: string | null;
+    classNames: string[];
+    errors: string[];
+    compileTime: number;
+    dexTime: number;
+}
+export declare class HotReloadService {
+    private kotlinCompiler;
+    private dexGenerator;
+    private overrideGenerator;
+    private projectPath;
+    constructor(projectPath: string);
+    /**
+     * Perform hot reload for a changed Kotlin file
+     * Returns DEX bytes ready to be sent to the app
+     */
+    hotReload(filePath: string): Promise<HotReloadResult>;
+    /**
+     * Extract fully qualified class names from class file paths
+     */
+    private extractClassNames;
+    /**
+     * Check if the environment is properly set up for hot reload
+     */
+    checkEnvironment(): Promise<{
+        ready: boolean;
+        issues: string[];
+    }>;
+}
+//# sourceMappingURL=hot-reload-service.d.ts.map

package/dist/build/hot-reload-service.js

@@ -0,0 +1,179 @@
+"use strict";
+/**
+ * Hot Reload Service
+ * Orchestrates Kotlin compilation, DEX generation, and sending to app
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HotReloadService = void 0;
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const kotlin_compiler_1 = require("./kotlin-compiler");
+const dex_generator_1 = require("./dex-generator");
+const override_generator_1 = require("./override-generator");
+const logger_1 = require("../utils/logger");
+class HotReloadService {
+    kotlinCompiler;
+    dexGenerator;
+    overrideGenerator;
+    projectPath;
+    constructor(projectPath) {
+        this.projectPath = projectPath;
+        this.kotlinCompiler = new kotlin_compiler_1.KotlinCompiler(projectPath);
+        this.dexGenerator = new dex_generator_1.DexGenerator();
+        this.overrideGenerator = new override_generator_1.OverrideGenerator();
+    }
+    /**
+     * Perform hot reload for a changed Kotlin file
+     * Returns DEX bytes ready to be sent to the app
+     */
+    async hotReload(filePath) {
+        const startTime = Date.now();
+        (0, logger_1.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) {
+            (0, logger_1.error)(`Compilation failed: ${compileResult.errors.join(', ')}`);
+            return {
+                success: false,
+                dexBase64: null,
+                classNames: [],
+                errors: compileResult.errors,
+                compileTime,
+                dexTime: 0
+            };
+        }
+        (0, logger_1.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) {
+            (0, logger_1.log)(`⚠️ Override generation failed: ${overrideResult.errors.join(', ')}`);
+            (0, logger_1.log)(`📝 Falling back to direct class hot reload (less efficient)`);
+        }
+        else {
+            (0, logger_1.log)(`Generated ${overrideResult.overrideClassFiles.length} override classes`);
+            // Compile override source files to .class
+            const allOverrideClassFiles = [];
+            for (const overrideFile of overrideResult.overrideClassFiles) {
+                const compRes = await this.kotlinCompiler.compileFile(overrideFile);
+                if (compRes.success) {
+                    allOverrideClassFiles.push(...compRes.classFiles);
+                }
+                else {
+                    (0, logger_1.log)(`⚠️ Failed to compile override ${path.basename(overrideFile)}: ${compRes.errors.join(', ')}`);
+                }
+            }
+            if (allOverrideClassFiles.length > 0) {
+                (0, logger_1.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) {
+            (0, logger_1.error)(`DEX generation failed: ${dexResult.errors.join(', ')}`);
+            return {
+                success: false,
+                dexBase64: null,
+                classNames: [],
+                errors: dexResult.errors,
+                compileTime,
+                dexTime
+            };
+        }
+        (0, logger_1.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;
+        (0, logger_1.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
+     */
+    extractClassNames(classFiles, outputDir) {
+        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() {
+        const issues = [];
+        // 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
+        };
+    }
+}
+exports.HotReloadService = HotReloadService;
+//# sourceMappingURL=hot-reload-service.js.map

package/dist/build/js-compiler-service.d.ts

@@ -0,0 +1,61 @@
+/**
+ * JsCompilerService
+ * Compiles Kotlin Compose source to browser-executable ES modules via kotlinc-js.
+ *
+ * Pipeline (two steps required by K2 compiler):
+ *   1. user.kt → screen.klib       (compile)
+ *   2. screen.klib → screen.mjs    (link, includes stdlib + stubs)
+ *
+ * The resulting .mjs exports renderScreen() which builds a plain JS object tree.
+ * The browser imports it, calls renderScreen(() => ScreenName()), renders tree as HTML.
+ */
+export interface JsCompileResult {
+    success: boolean;
+    jsBase64?: string;
+    byteSize?: number;
+    compileTimeMs?: number;
+    screenFunctionName?: string;
+    error?: string;
+}
+export declare class JsCompilerService {
+    private kotlincJsPath;
+    private stdlibKlib;
+    private stubsKlib;
+    private readonly workDir;
+    constructor();
+    private init;
+    isAvailable(): boolean;
+    private writeStubsSource;
+    /** Build the Compose shims klib once. Returns klib path or null. */
+    private ensureStubsKlib;
+    /**
+     * Compile a .kt Compose file to a browser-runnable ES module.
+     * Returns base64-encoded .mjs content.
+     */
+    /**
+     * Remove horizontalArrangement = ... lines that appear inside non-Row containers.
+     * LazyVerticalStaggeredGrid etc. don't accept this param in our stubs.
+     * Row/LazyRow DO accept it — those lines are kept.
+     */
+    private removeHorizontalArrangementOutsideRow;
+    /**
+     * Remove a brace-balanced block (including optional trailing else block).
+     * Used to surgically strip LaunchedEffect, forEach, broken if-else blocks etc.
+     */
+    private removeBalancedBlock;
+    /**
+     * Remove "} else { BLOCK }" where the else body matches a predicate.
+     */
+    private removeElseBlockIf;
+    /**
+     * Preprocess a Kotlin Compose source file for kotlinc-js compilation.
+     *
+     * The user's file uses Android/Compose/Java imports that don't exist in
+     * a browser context. This method transforms the file so that only the
+     * Compose UI structure remains — which maps directly to our jetstart.compose
+     * shims. The result compiles cleanly with kotlinc-js.
+     */
+    private preprocessFile;
+    compile(ktFilePath: string): Promise<JsCompileResult>;
+}
+//# sourceMappingURL=js-compiler-service.d.ts.map