@jetstart/cli 1.2.0 → 1.5.0

package/dist/cli.js

@@ -14,12 +14,15 @@ const create_1 = require("./commands/create");
 const dev_1 = require("./commands/dev");
 const build_1 = require("./commands/build");
 const logs_1 = require("./commands/logs");
+const install_audit_1 = require("./commands/install-audit");
+const android_emulator_1 = require("./commands/android-emulator");
 const shared_1 = require("@jetstart/shared");
+const package_json_1 = require("../package.json");
 const program = new commander_1.Command();
 program
     .name('jetstart')
     .description('Fast, wireless Android development with Kotlin and Jetpack Compose')
-    .version(shared_1.JETSTART_VERSION);
+    .version(package_json_1.version || shared_1.JETSTART_VERSION);
 // Create command
 program
     .command('create <name>')
@@ -27,6 +30,7 @@ program
     .option('-p, --package <name>', 'Package name (e.g., com.example.app)')
     .option('-t, --template <name>', 'Template to use', 'default')
     .option('--skip-install', 'Skip npm install')
+    .option('--full-install', 'Automatically install all required Android dependencies')
     .action(create_1.createCommand);
 // Dev command
 program
@@ -36,6 +40,8 @@ program
     .option('-H, --host <host>', 'Host address (defaults to auto-detected network IP)')
     .option('--no-qr', 'Do not show QR code')
     .option('--no-open', 'Do not open browser')
+    .option('--emulator', 'Deploy to running Android emulator')
+    .option('--avd <name>', 'Target specific emulator by name')
     .action(dev_1.devCommand);
 // Build command
 program
@@ -54,6 +60,17 @@ program
     .option('-s, --source <source>', 'Filter by log source')
     .option('-n, --lines <number>', 'Number of lines to show', '100')
     .action(logs_1.logsCommand);
+// Install audit command
+program
+    .command('install-audit')
+    .description('Audit installation of required tools and dependencies')
+    .option('--json', 'Output results in JSON format')
+    .action(install_audit_1.installAuditCommand);
+// Android emulator command
+program
+    .command('android-emulator')
+    .description('Manage Android emulators (AVDs)')
+    .action(android_emulator_1.androidEmulatorCommand);
 // Error handling
 program.on('command:*', (operands) => {
     console.error(chalk_1.default.red(`Error: Unknown command '${operands[0]}'`));

package/dist/commands/android-emulator.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Android emulator management command
+ */
+/**
+ * Android emulator command handler
+ */
+export declare function androidEmulatorCommand(): Promise<void>;
+//# sourceMappingURL=android-emulator.d.ts.map

package/dist/commands/android-emulator.js

@@ -0,0 +1,280 @@
+"use strict";
+/**
+ * Android emulator management command
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.androidEmulatorCommand = androidEmulatorCommand;
+const inquirer_1 = __importDefault(require("inquirer"));
+const chalk_1 = __importDefault(require("chalk"));
+const emulator_1 = require("../utils/emulator");
+const logger_1 = require("../utils/logger");
+/**
+ * Display list of AVDs
+ */
+async function handleListAVDs() {
+    const avdManager = (0, emulator_1.createAVDManager)();
+    const avds = await avdManager.listAVDs();
+    if (avds.length === 0) {
+        console.log();
+        (0, logger_1.warning)('No Android emulators found.');
+        console.log();
+        const { shouldCreate } = await inquirer_1.default.prompt([
+            {
+                type: 'confirm',
+                name: 'shouldCreate',
+                message: 'Would you like to create a JetStart-optimized emulator?',
+                default: true,
+            },
+        ]);
+        if (shouldCreate) {
+            await handleCreateJetStartAVD();
+        }
+        return;
+    }
+    console.log();
+    console.log(chalk_1.default.bold('Available Android Virtual Devices:'));
+    console.log('━'.repeat(70));
+    console.log();
+    for (const avd of avds) {
+        const statusIcon = avd.running ? chalk_1.default.green('✓') : chalk_1.default.gray('○');
+        const statusText = avd.running ? chalk_1.default.green('(Running)') : '';
+        console.log(`  ${statusIcon} ${chalk_1.default.bold(avd.name)} ${statusText}`);
+        console.log(`    - Device: ${avd.device || 'Unknown'}`);
+        console.log(`    - Target: ${avd.target || 'Unknown'}`);
+        if (avd.basedOn) {
+            console.log(`    - Based on: ${avd.basedOn}`);
+        }
+        console.log();
+    }
+}
+/**
+ * Start an emulator
+ */
+async function handleStartEmulator() {
+    const avdManager = (0, emulator_1.createAVDManager)();
+    const avds = await avdManager.listAVDs();
+    if (avds.length === 0) {
+        (0, logger_1.warning)('No emulators available. Create one first.');
+        return;
+    }
+    // Filter out running emulators
+    const availableAVDs = avds.filter((avd) => !avd.running);
+    if (availableAVDs.length === 0) {
+        (0, logger_1.info)('All emulators are already running.');
+        return;
+    }
+    const { avdName } = await inquirer_1.default.prompt([
+        {
+            type: 'list',
+            name: 'avdName',
+            message: 'Select emulator to start:',
+            choices: availableAVDs.map((avd) => ({ name: `${avd.name} (${avd.target})`, value: avd.name })),
+        },
+    ]);
+    await avdManager.startEmulator({ avdName });
+}
+/**
+ * Stop an emulator
+ */
+async function handleStopEmulator() {
+    const avdManager = (0, emulator_1.createAVDManager)();
+    const avds = await avdManager.listAVDs();
+    // Filter running emulators
+    const runningAVDs = avds.filter((avd) => avd.running);
+    if (runningAVDs.length === 0) {
+        (0, logger_1.warning)('No emulators are currently running.');
+        return;
+    }
+    const { avdName } = await inquirer_1.default.prompt([
+        {
+            type: 'list',
+            name: 'avdName',
+            message: 'Select emulator to stop:',
+            choices: runningAVDs.map((avd) => ({ name: `${avd.name} (${avd.target})`, value: avd.name })),
+        },
+    ]);
+    await avdManager.stopEmulator(avdName);
+}
+/**
+ * Create JetStart-optimized AVD
+ */
+async function handleCreateJetStartAVD() {
+    const avdManager = (0, emulator_1.createAVDManager)();
+    try {
+        await avdManager.createJetStartAVD();
+    }
+    catch (err) {
+        (0, logger_1.error)(`Failed to create AVD: ${err.message}`);
+    }
+}
+/**
+ * Create custom AVD
+ */
+async function handleCreateCustomAVD() {
+    const avdManager = (0, emulator_1.createAVDManager)();
+    const answers = await inquirer_1.default.prompt([
+        {
+            type: 'input',
+            name: 'name',
+            message: 'Enter AVD name:',
+            default: 'my-android-emulator',
+            validate: (input) => {
+                if (!input || input.trim().length === 0) {
+                    return 'Name cannot be empty';
+                }
+                if (!/^[a-zA-Z0-9_-]+$/.test(input)) {
+                    return 'Name can only contain letters, numbers, hyphens, and underscores';
+                }
+                return true;
+            },
+        },
+        {
+            type: 'list',
+            name: 'device',
+            message: 'Select device profile:',
+            choices: [
+                { name: 'Pixel 5', value: 'pixel_5' },
+                { name: 'Pixel 6', value: 'pixel_6' },
+                { name: 'Pixel 8', value: 'pixel_8' },
+                { name: 'Nexus 5', value: 'Nexus 5' },
+            ],
+            default: 'pixel_5',
+        },
+        {
+            type: 'list',
+            name: 'apiLevel',
+            message: 'Select API level:',
+            choices: [
+                { name: 'API 34 (Android 14) - Recommended', value: 34 },
+                { name: 'API 33 (Android 13)', value: 33 },
+                { name: 'API 31 (Android 12)', value: 31 },
+                { name: 'API 29 (Android 10)', value: 29 },
+                { name: 'API 24 (Android 7.0) - Minimum', value: 24 },
+            ],
+            default: 34,
+        },
+        {
+            type: 'list',
+            name: 'abi',
+            message: 'Select ABI (architecture):',
+            choices: [
+                { name: 'x86_64 (Intel/AMD 64-bit)', value: 'x86_64' },
+                { name: 'arm64-v8a (ARM 64-bit)', value: 'arm64-v8a' },
+            ],
+            default: process.arch === 'arm64' ? 'arm64-v8a' : 'x86_64',
+        },
+    ]);
+    try {
+        await avdManager.createAVD({
+            name: answers.name,
+            device: answers.device,
+            apiLevel: answers.apiLevel,
+            abi: answers.abi,
+        });
+    }
+    catch (err) {
+        (0, logger_1.error)(`Failed to create AVD: ${err.message}`);
+    }
+}
+/**
+ * Delete an AVD
+ */
+async function handleDeleteAVD() {
+    const avdManager = (0, emulator_1.createAVDManager)();
+    const avds = await avdManager.listAVDs();
+    if (avds.length === 0) {
+        (0, logger_1.warning)('No emulators available to delete.');
+        return;
+    }
+    const { avdName } = await inquirer_1.default.prompt([
+        {
+            type: 'list',
+            name: 'avdName',
+            message: 'Select emulator to delete:',
+            choices: avds.map((avd) => ({ name: `${avd.name} (${avd.target})`, value: avd.name })),
+        },
+    ]);
+    const { confirm } = await inquirer_1.default.prompt([
+        {
+            type: 'confirm',
+            name: 'confirm',
+            message: `Are you sure you want to delete "${avdName}"?`,
+            default: false,
+        },
+    ]);
+    if (confirm) {
+        await avdManager.deleteAVD(avdName);
+    }
+    else {
+        (0, logger_1.info)('Deletion cancelled');
+    }
+}
+/**
+ * Android emulator command handler
+ */
+async function androidEmulatorCommand() {
+    try {
+        console.log();
+        console.log(chalk_1.default.cyan.bold('  JetStart Android Emulator Manager'));
+        console.log();
+        let running = true;
+        while (running) {
+            const { action } = await inquirer_1.default.prompt([
+                {
+                    type: 'list',
+                    name: 'action',
+                    message: 'What would you like to do?',
+                    choices: [
+                        { name: 'List existing emulators', value: 'list' },
+                        { name: 'Start emulator', value: 'start' },
+                        { name: 'Stop emulator', value: 'stop' },
+                        new inquirer_1.default.Separator(),
+                        { name: 'Create JetStart-optimized emulator', value: 'create-jetstart' },
+                        { name: 'Create custom emulator', value: 'create-custom' },
+                        { name: 'Delete emulator', value: 'delete' },
+                        new inquirer_1.default.Separator(),
+                        { name: 'Exit', value: 'exit' },
+                    ],
+                },
+            ]);
+            switch (action) {
+                case 'list':
+                    await handleListAVDs();
+                    break;
+                case 'start':
+                    await handleStartEmulator();
+                    break;
+                case 'stop':
+                    await handleStopEmulator();
+                    break;
+                case 'create-jetstart':
+                    await handleCreateJetStartAVD();
+                    break;
+                case 'create-custom':
+                    await handleCreateCustomAVD();
+                    break;
+                case 'delete':
+                    await handleDeleteAVD();
+                    break;
+                case 'exit':
+                    running = false;
+                    console.log();
+                    (0, logger_1.success)('Goodbye!');
+                    console.log();
+                    break;
+            }
+            if (running && action !== 'list') {
+                console.log();
+            }
+        }
+    }
+    catch (err) {
+        console.log();
+        (0, logger_1.error)(`Emulator management failed: ${err.message}`);
+        process.exit(1);
+    }
+}
+//# sourceMappingURL=android-emulator.js.map

package/dist/commands/create.d.ts

@@ -2,11 +2,6 @@
  * Create Command
  * Scaffolds a new JetStart project
  */
-interface CreateOptions {
-    package?: string;
-    template?: string;
-    skipInstall?: boolean;
-}
+import { CreateOptions } from '../types';
 export declare function createCommand(name: string, options: CreateOptions): Promise<void>;
-export {};
 //# sourceMappingURL=create.d.ts.map

package/dist/commands/create.js

@@ -11,11 +11,112 @@ exports.createCommand = createCommand;
 const path_1 = __importDefault(require("path"));
 const fs_extra_1 = __importDefault(require("fs-extra"));
 const chalk_1 = __importDefault(require("chalk"));
+const inquirer_1 = __importDefault(require("inquirer"));
 const logger_1 = require("../utils/logger");
 const spinner_1 = require("../utils/spinner");
 const prompt_1 = require("../utils/prompt");
 const template_1 = require("../utils/template");
 const shared_1 = require("@jetstart/shared");
+const java_1 = require("../utils/java");
+const android_sdk_1 = require("../utils/android-sdk");
+const system_tools_1 = require("../utils/system-tools");
+/**
+ * Run full installation (automated mode)
+ */
+async function runFullInstallation() {
+    (0, logger_1.info)('Starting full automated installation...');
+    console.log();
+    // 1. Check and install Java
+    const java = await (0, java_1.detectJava)();
+    if (!java || !(await (0, java_1.isJavaCompatible)(java.version))) {
+        await (0, java_1.installJava)();
+    }
+    else {
+        (0, logger_1.success)(`Java ${java.version} already installed`);
+    }
+    // 2. Check and install Android SDK
+    const sdkManager = (0, android_sdk_1.createSDKManager)();
+    const sdkRoot = await (0, system_tools_1.findAndroidSDK)();
+    if (!sdkRoot) {
+        (0, logger_1.info)('Installing Android SDK components...');
+        await sdkManager.installCmdlineTools();
+    }
+    else {
+        (0, logger_1.success)(`Android SDK found at ${sdkRoot}`);
+    }
+    // 3. Install required SDK components
+    for (const component of android_sdk_1.REQUIRED_SDK_COMPONENTS) {
+        await sdkManager.installComponent(component);
+    }
+    console.log();
+    (0, logger_1.success)('All dependencies installed successfully!');
+    console.log();
+}
+/**
+ * Run interactive installation
+ */
+async function runInteractiveInstallation() {
+    (0, logger_1.info)('Checking dependencies...');
+    console.log();
+    // Check Java
+    const java = await (0, java_1.detectJava)();
+    if (!java || !(await (0, java_1.isJavaCompatible)(java.version))) {
+        const { shouldInstall } = await inquirer_1.default.prompt([
+            {
+                type: 'confirm',
+                name: 'shouldInstall',
+                message: 'Java 17+ not found. Would you like to install it?',
+                default: true,
+            },
+        ]);
+        if (shouldInstall) {
+            await (0, java_1.installJava)();
+        }
+        else {
+            (0, logger_1.warning)('Java installation skipped. You may need to install it manually.');
+        }
+    }
+    else {
+        (0, logger_1.success)(`Java ${java.version} detected`);
+    }
+    // Check Android SDK
+    const sdkRoot = await (0, system_tools_1.findAndroidSDK)();
+    if (!sdkRoot) {
+        const { shouldInstall } = await inquirer_1.default.prompt([
+            {
+                type: 'confirm',
+                name: 'shouldInstall',
+                message: 'Android SDK not found. Would you like to install it?',
+                default: true,
+            },
+        ]);
+        if (shouldInstall) {
+            const sdkManager = (0, android_sdk_1.createSDKManager)();
+            await sdkManager.installCmdlineTools();
+            // Ask about components
+            const { installComponents } = await inquirer_1.default.prompt([
+                {
+                    type: 'confirm',
+                    name: 'installComponents',
+                    message: 'Install required SDK components?',
+                    default: true,
+                },
+            ]);
+            if (installComponents) {
+                for (const component of android_sdk_1.REQUIRED_SDK_COMPONENTS) {
+                    await sdkManager.installComponent(component);
+                }
+            }
+        }
+        else {
+            (0, logger_1.warning)('Android SDK installation skipped. Project creation may fail without SDK.');
+        }
+    }
+    else {
+        (0, logger_1.success)(`Android SDK found at ${sdkRoot}`);
+    }
+    console.log();
+}
 async function createCommand(name, options) {
     try {
         // Validate project name
@@ -32,6 +133,24 @@ async function createCommand(name, options) {
         }
         (0, logger_1.log)(`Creating JetStart project: ${chalk_1.default.cyan(name)}`);
         console.log();
+        // Run installation if requested
+        if (options.fullInstall) {
+            await runFullInstallation();
+        }
+        else {
+            // Interactive mode: ask user
+            const { shouldCheckDeps } = await inquirer_1.default.prompt([
+                {
+                    type: 'confirm',
+                    name: 'shouldCheckDeps',
+                    message: 'Check and install dependencies?',
+                    default: true,
+                },
+            ]);
+            if (shouldCheckDeps) {
+                await runInteractiveInstallation();
+            }
+        }
         // Get package name
         let packageName = options.package;
         if (!packageName) {

package/dist/commands/dev.d.ts

@@ -2,12 +2,6 @@
  * Dev Command
  * Starts the development server
  */
-interface DevOptions {
-    port?: string;
-    host?: string;
-    qr?: boolean;
-    open?: boolean;
-}
+import { DevOptions } from '../types';
 export declare function devCommand(options: DevOptions): Promise<void>;
-export {};
 //# sourceMappingURL=dev.d.ts.map

package/dist/commands/dev.js

@@ -43,11 +43,13 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.devCommand = devCommand;
 const path = __importStar(require("path"));
 const os = __importStar(require("os"));
+const fs = __importStar(require("fs-extra"));
 const chalk_1 = __importDefault(require("chalk"));
 const qrcode_terminal_1 = __importDefault(require("qrcode-terminal"));
 const logger_1 = require("../utils/logger");
 const core_1 = require("@jetstart/core");
 const shared_1 = require("@jetstart/shared");
+const emulator_deployer_1 = require("../utils/emulator-deployer");
 async function devCommand(options) {
     try {
         const port = parseInt(options.port || String(shared_1.DEFAULT_CORE_PORT));
@@ -59,6 +61,39 @@ async function devCommand(options) {
         // Get project path and name
         const projectPath = process.cwd();
         const projectName = path.basename(projectPath);
+        // Setup emulator deployment if requested
+        let deployer = null;
+        let packageName = null;
+        if (options.emulator) {
+            try {
+                deployer = await emulator_deployer_1.EmulatorDeployer.findOrSelectEmulator(options.avd);
+                // Try to read package name from build.gradle (modern Android)
+                const buildGradlePath = path.join(projectPath, 'app/build.gradle');
+                (0, logger_1.info)(`Looking for build.gradle at: ${buildGradlePath}`);
+                if (await fs.pathExists(buildGradlePath)) {
+                    const buildGradleContent = await fs.readFile(buildGradlePath, 'utf8');
+                    // Match both applicationId "..." and applicationId '...'
+                    const packageMatch = buildGradleContent.match(/applicationId\s+["']([^"']+)["']/);
+                    packageName = packageMatch ? packageMatch[1] : null;
+                    (0, logger_1.info)(`Package name: ${packageName || 'NOT FOUND'}`);
+                }
+                else {
+                    (0, logger_1.warning)('build.gradle not found - emulator deployment requires package name');
+                }
+                if (packageName) {
+                    (0, logger_1.success)('Emulator deployment enabled');
+                }
+                else {
+                    (0, logger_1.warning)('Emulator deployment disabled: package name not found');
+                }
+                console.log();
+            }
+            catch (err) {
+                (0, logger_1.error)(`Emulator setup failed: ${err.message}`);
+                (0, logger_1.info)('Continuing without emulator deployment...');
+                console.log();
+            }
+        }
         // Create and start Core server
         // Bind to 0.0.0.0 to accept connections on all interfaces,
         // but pass the detected IP for display and client connections
@@ -71,9 +106,38 @@ async function devCommand(options) {
             projectName,
         });
         const session = await server.start();
+        // Listen for build completion and deploy to emulator
+        if (deployer && packageName) {
+            (0, logger_1.info)(`Setting up build:complete listener for package: ${packageName}`);
+            let hasDeployed = false; // Track if we've already deployed to prevent reinstall loops
+            server.on('build:complete', async (result) => {
+                (0, logger_1.info)(`Build complete event received! APK: ${result.apkPath || 'NO APK PATH'}`);
+                // Only deploy if this is the first time OR if it's a file-change build (not initial client connection)
+                if (!hasDeployed && result.apkPath && deployer) {
+                    try {
+                        (0, logger_1.info)('Deploying to emulator (initial deployment)...');
+                        await deployer.installAPK(result.apkPath, packageName);
+                        await deployer.launchApp(packageName);
+                        hasDeployed = true; // Mark as deployed to prevent reinstall loop
+                        (0, logger_1.success)('Initial deployment complete. Future builds will be sent via hot reload.');
+                    }
+                    catch (err) {
+                        (0, logger_1.warning)(`Emulator deployment failed: ${err.message}`);
+                    }
+                }
+                else if (hasDeployed) {
+                    (0, logger_1.info)('Skipping deployment (app already installed, using hot reload)');
+                }
+                else {
+                    (0, logger_1.warning)(`Skipping deployment: apkPath=${result.apkPath}, deployer=${!!deployer}`);
+                }
+            });
+        }
+        else {
+            (0, logger_1.info)(`Emulator deployment not configured: deployer=${!!deployer}, packageName=${packageName}`);
+        }
         // Get URLs
         const serverUrl = `http://${host}:${port}`;
-        const wsUrl = `ws://${host}:${wsPort}`;
         const localUrl = `http://localhost:${port}`;
         console.log();
         (0, logger_1.success)('JetStart dev server is running!');
@@ -84,16 +148,11 @@ async function devCommand(options) {
         console.log();
         // Generate QR code for mobile connection
         if (showQR) {
-            const qrData = {
-                serverUrl,
-                wsUrl,
-                sessionId: session.id,
-                token: session.token,
-                projectName,
-                version: '0.1.0',
-            };
+            // Ultra-compact format: host|port|wsPort|sessionId|token|projectName
+            // Using short alphanumeric IDs for minimal QR code size
+            const qrData = `${host}|${port}|${wsPort}|${session.id}|${session.token}|${projectName}`;
             console.log(chalk_1.default.bold('Scan QR or connect manually:'));
-            qrcode_terminal_1.default.generate(JSON.stringify(qrData), { small: true });
+            qrcode_terminal_1.default.generate(qrData, { small: true });
             console.log();
             (0, logger_1.info)(`IP: ${chalk_1.default.cyan(host)}`);
             (0, logger_1.info)(`Session: ${chalk_1.default.dim(session.id)}`);

package/dist/commands/index.d.ts

@@ -5,4 +5,6 @@ export { createCommand } from './create';
 export { devCommand } from './dev';
 export { buildCommand } from './build';
 export { logsCommand } from './logs';
+export { installAuditCommand } from './install-audit';
+export { androidEmulatorCommand } from './android-emulator';
 //# sourceMappingURL=index.d.ts.map

package/dist/commands/index.js

@@ -3,7 +3,7 @@
  * Export all commands
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.logsCommand = exports.buildCommand = exports.devCommand = exports.createCommand = void 0;
+exports.androidEmulatorCommand = exports.installAuditCommand = exports.logsCommand = exports.buildCommand = exports.devCommand = exports.createCommand = void 0;
 var create_1 = require("./create");
 Object.defineProperty(exports, "createCommand", { enumerable: true, get: function () { return create_1.createCommand; } });
 var dev_1 = require("./dev");
@@ -12,4 +12,8 @@ var build_1 = require("./build");
 Object.defineProperty(exports, "buildCommand", { enumerable: true, get: function () { return build_1.buildCommand; } });
 var logs_1 = require("./logs");
 Object.defineProperty(exports, "logsCommand", { enumerable: true, get: function () { return logs_1.logsCommand; } });
+var install_audit_1 = require("./install-audit");
+Object.defineProperty(exports, "installAuditCommand", { enumerable: true, get: function () { return install_audit_1.installAuditCommand; } });
+var android_emulator_1 = require("./android-emulator");
+Object.defineProperty(exports, "androidEmulatorCommand", { enumerable: true, get: function () { return android_emulator_1.androidEmulatorCommand; } });
 //# sourceMappingURL=index.js.map

package/dist/commands/install-audit.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Installation audit command - checks all required tools and dependencies
+ */
+import { AuditOptions } from '../types';
+/**
+ * Install audit command handler
+ */
+export declare function installAuditCommand(options: AuditOptions): Promise<void>;
+//# sourceMappingURL=install-audit.d.ts.map