@jetstart/cli 1.2.0 → 1.5.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jetstart/cli",
-  "version": "1.2.0",
+  "version": "1.5.0",
   "description": "Command-line interface for JetStart",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -36,24 +36,28 @@
   },
   "homepage": "https://github.com/dev-phantom/jetstart#readme",
   "dependencies": {
-    "@jetstart/core": "^1.2.0",
-    "@jetstart/shared": "^1.2.0",
+    "@jetstart/core": "^1.5.0",
+    "@jetstart/shared": "^1.5.0",
     "axios": "^1.6.2",
     "chalk": "^4.1.2",
     "commander": "^11.1.0",
     "dotenv": "^16.3.1",
+    "extract-zip": "^2.0.1",
     "fs-extra": "^11.2.0",
     "inquirer": "^8.2.6",
     "ora": "^5.4.1",
     "qrcode-terminal": "^0.12.0",
+    "which": "^4.0.0",
     "ws": "^8.14.2"
   },
   "devDependencies": {
+    "@types/extract-zip": "^2.0.1",
     "@types/fs-extra": "^11.0.4",
     "@types/inquirer": "^8.2.10",
     "@types/jest": "^29.5.0",
     "@types/node": "^20.10.0",
     "@types/qrcode-terminal": "0.12.2",
+    "@types/which": "^3.0.3",
     "@types/ws": "^8.5.10",
     "jest": "^29.5.0",
     "ts-jest": "^29.1.0",

package/src/cli.ts

@@ -11,14 +11,16 @@ import { createCommand } from './commands/create';
 import { devCommand } from './commands/dev';
 import { buildCommand } from './commands/build';
 import { logsCommand } from './commands/logs';
+import { installAuditCommand } from './commands/install-audit';
+import { androidEmulatorCommand } from './commands/android-emulator';
 import { JETSTART_VERSION } from '@jetstart/shared';
-
+import {version} from '../package.json';
 const program = new Command();
 
 program
   .name('jetstart')
   .description('Fast, wireless Android development with Kotlin and Jetpack Compose')
-  .version(JETSTART_VERSION);
+  .version(version || JETSTART_VERSION);
 
 // Create command
 program
@@ -27,6 +29,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(createCommand);
 
 // Dev command
@@ -37,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(devCommand);
 
 // Build command
@@ -58,6 +63,19 @@ program
   .option('-n, --lines <number>', 'Number of lines to show', '100')
   .action(logsCommand);
 
+// Install audit command
+program
+  .command('install-audit')
+  .description('Audit installation of required tools and dependencies')
+  .option('--json', 'Output results in JSON format')
+  .action(installAuditCommand);
+
+// Android emulator command
+program
+  .command('android-emulator')
+  .description('Manage Android emulators (AVDs)')
+  .action(androidEmulatorCommand);
+
 // Error handling
 program.on('command:*', (operands) => {
   console.error(chalk.red(`Error: Unknown command '${operands[0]}'`));

package/src/commands/android-emulator.ts

@@ -0,0 +1,304 @@
+/**
+ * Android emulator management command
+ */
+
+import inquirer from 'inquirer';
+import chalk from 'chalk';
+import { createAVDManager } from '../utils/emulator';
+import { error as logError, success, info, warning } from '../utils/logger';
+
+/**
+ * Display list of AVDs
+ */
+async function handleListAVDs(): Promise<void> {
+  const avdManager = createAVDManager();
+
+  const avds = await avdManager.listAVDs();
+
+  if (avds.length === 0) {
+    console.log();
+    warning('No Android emulators found.');
+    console.log();
+
+    const { shouldCreate } = await inquirer.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.bold('Available Android Virtual Devices:'));
+  console.log('━'.repeat(70));
+  console.log();
+
+  for (const avd of avds) {
+    const statusIcon = avd.running ? chalk.green('✓') : chalk.gray('○');
+    const statusText = avd.running ? chalk.green('(Running)') : '';
+
+    console.log(`  ${statusIcon} ${chalk.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(): Promise<void> {
+  const avdManager = createAVDManager();
+  const avds = await avdManager.listAVDs();
+
+  if (avds.length === 0) {
+    warning('No emulators available. Create one first.');
+    return;
+  }
+
+  // Filter out running emulators
+  const availableAVDs = avds.filter((avd) => !avd.running);
+
+  if (availableAVDs.length === 0) {
+    info('All emulators are already running.');
+    return;
+  }
+
+  const { avdName } = await inquirer.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(): Promise<void> {
+  const avdManager = createAVDManager();
+  const avds = await avdManager.listAVDs();
+
+  // Filter running emulators
+  const runningAVDs = avds.filter((avd) => avd.running);
+
+  if (runningAVDs.length === 0) {
+    warning('No emulators are currently running.');
+    return;
+  }
+
+  const { avdName } = await inquirer.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(): Promise<void> {
+  const avdManager = createAVDManager();
+
+  try {
+    await avdManager.createJetStartAVD();
+  } catch (err: any) {
+    logError(`Failed to create AVD: ${err.message}`);
+  }
+}
+
+/**
+ * Create custom AVD
+ */
+async function handleCreateCustomAVD(): Promise<void> {
+  const avdManager = createAVDManager();
+
+  const answers = await inquirer.prompt([
+    {
+      type: 'input',
+      name: 'name',
+      message: 'Enter AVD name:',
+      default: 'my-android-emulator',
+      validate: (input: string) => {
+        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: any) {
+    logError(`Failed to create AVD: ${err.message}`);
+  }
+}
+
+/**
+ * Delete an AVD
+ */
+async function handleDeleteAVD(): Promise<void> {
+  const avdManager = createAVDManager();
+  const avds = await avdManager.listAVDs();
+
+  if (avds.length === 0) {
+    warning('No emulators available to delete.');
+    return;
+  }
+
+  const { avdName } = await inquirer.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.prompt([
+    {
+      type: 'confirm',
+      name: 'confirm',
+      message: `Are you sure you want to delete "${avdName}"?`,
+      default: false,
+    },
+  ]);
+
+  if (confirm) {
+    await avdManager.deleteAVD(avdName);
+  } else {
+    info('Deletion cancelled');
+  }
+}
+
+/**
+ * Android emulator command handler
+ */
+export async function androidEmulatorCommand(): Promise<void> {
+  try {
+    console.log();
+    console.log(chalk.cyan.bold('  JetStart Android Emulator Manager'));
+    console.log();
+
+    let running = true;
+
+    while (running) {
+      const { action } = await inquirer.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.Separator(),
+            { name: 'Create JetStart-optimized emulator', value: 'create-jetstart' },
+            { name: 'Create custom emulator', value: 'create-custom' },
+            { name: 'Delete emulator', value: 'delete' },
+            new inquirer.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();
+          success('Goodbye!');
+          console.log();
+          break;
+      }
+
+      if (running && action !== 'list') {
+        console.log();
+      }
+    }
+  } catch (err: any) {
+    console.log();
+    logError(`Emulator management failed: ${err.message}`);
+    process.exit(1);
+  }
+}

package/src/commands/create.ts

@@ -6,16 +6,120 @@
 import path from 'path';
 import fs from 'fs-extra';
 import chalk from 'chalk';
-import { log, success, error } from '../utils/logger';
+import inquirer from 'inquirer';
+import { log, success, error, info, warning } from '../utils/logger';
 import { startSpinner, stopSpinner } from '../utils/spinner';
 import { prompt } from '../utils/prompt';
 import { generateProjectTemplate } from '../utils/template';
 import { isValidProjectName, isValidPackageName } from '@jetstart/shared';
+import { CreateOptions } from '../types';
+import { detectJava, installJava, isJavaCompatible } from '../utils/java';
+import { createSDKManager, REQUIRED_SDK_COMPONENTS } from '../utils/android-sdk';
+import { findAndroidSDK } from '../utils/system-tools';
 
-interface CreateOptions {
-  package?: string;
-  template?: string;
-  skipInstall?: boolean;
+/**
+ * Run full installation (automated mode)
+ */
+async function runFullInstallation(): Promise<void> {
+  info('Starting full automated installation...');
+  console.log();
+
+  // 1. Check and install Java
+  const java = await detectJava();
+  if (!java || !(await isJavaCompatible(java.version))) {
+    await installJava();
+  } else {
+    success(`Java ${java.version} already installed`);
+  }
+
+  // 2. Check and install Android SDK
+  const sdkManager = createSDKManager();
+  const sdkRoot = await findAndroidSDK();
+
+  if (!sdkRoot) {
+    info('Installing Android SDK components...');
+    await sdkManager.installCmdlineTools();
+  } else {
+    success(`Android SDK found at ${sdkRoot}`);
+  }
+
+  // 3. Install required SDK components
+  for (const component of REQUIRED_SDK_COMPONENTS) {
+    await sdkManager.installComponent(component);
+  }
+
+  console.log();
+  success('All dependencies installed successfully!');
+  console.log();
+}
+
+/**
+ * Run interactive installation
+ */
+async function runInteractiveInstallation(): Promise<void> {
+  info('Checking dependencies...');
+  console.log();
+
+  // Check Java
+  const java = await detectJava();
+  if (!java || !(await isJavaCompatible(java.version))) {
+    const { shouldInstall } = await inquirer.prompt([
+      {
+        type: 'confirm',
+        name: 'shouldInstall',
+        message: 'Java 17+ not found. Would you like to install it?',
+        default: true,
+      },
+    ]);
+
+    if (shouldInstall) {
+      await installJava();
+    } else {
+      warning('Java installation skipped. You may need to install it manually.');
+    }
+  } else {
+    success(`Java ${java.version} detected`);
+  }
+
+  // Check Android SDK
+  const sdkRoot = await findAndroidSDK();
+  if (!sdkRoot) {
+    const { shouldInstall } = await inquirer.prompt([
+      {
+        type: 'confirm',
+        name: 'shouldInstall',
+        message: 'Android SDK not found. Would you like to install it?',
+        default: true,
+      },
+    ]);
+
+    if (shouldInstall) {
+      const sdkManager = createSDKManager();
+      await sdkManager.installCmdlineTools();
+
+      // Ask about components
+      const { installComponents } = await inquirer.prompt([
+        {
+          type: 'confirm',
+          name: 'installComponents',
+          message: 'Install required SDK components?',
+          default: true,
+        },
+      ]);
+
+      if (installComponents) {
+        for (const component of REQUIRED_SDK_COMPONENTS) {
+          await sdkManager.installComponent(component);
+        }
+      }
+    } else {
+      warning('Android SDK installation skipped. Project creation may fail without SDK.');
+    }
+  } else {
+    success(`Android SDK found at ${sdkRoot}`);
+  }
+
+  console.log();
 }
 
 export async function createCommand(name: string, options: CreateOptions) {
@@ -38,6 +142,25 @@ export async function createCommand(name: string, options: CreateOptions) {
     log(`Creating JetStart project: ${chalk.cyan(name)}`);
     console.log();
 
+    // Run installation if requested
+    if (options.fullInstall) {
+      await runFullInstallation();
+    } else {
+      // Interactive mode: ask user
+      const { shouldCheckDeps } = await inquirer.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/src/commands/dev.ts

@@ -5,18 +5,14 @@
 
 import * as path from 'path';
 import * as os from 'os';
+import * as fs from 'fs-extra';
 import chalk from 'chalk';
 import qrcode from 'qrcode-terminal';
-import { log, success, error, info } from '../utils/logger';
+import { log, success, error, info, warning } from '../utils/logger';
 import { JetStartServer } from '@jetstart/core';
 import { DEFAULT_CORE_PORT, DEFAULT_WS_PORT } from '@jetstart/shared';
-
-interface DevOptions {
-  port?: string;
-  host?: string;
-  qr?: boolean;
-  open?: boolean;
-}
+import { DevOptions } from '../types';
+import { EmulatorDeployer } from '../utils/emulator-deployer';
 
 export async function devCommand(options: DevOptions) {
   try {
@@ -32,6 +28,40 @@ export async function devCommand(options: DevOptions) {
     const projectPath = process.cwd();
     const projectName = path.basename(projectPath);
 
+    // Setup emulator deployment if requested
+    let deployer: EmulatorDeployer | null = null;
+    let packageName: string | null = null;
+
+    if (options.emulator) {
+      try {
+        deployer = await EmulatorDeployer.findOrSelectEmulator(options.avd);
+
+        // Try to read package name from build.gradle (modern Android)
+        const buildGradlePath = path.join(projectPath, 'app/build.gradle');
+        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;
+          info(`Package name: ${packageName || 'NOT FOUND'}`);
+        } else {
+          warning('build.gradle not found - emulator deployment requires package name');
+        }
+
+        if (packageName) {
+          success('Emulator deployment enabled');
+        } else {
+          warning('Emulator deployment disabled: package name not found');
+        }
+        console.log();
+      } catch (err: any) {
+        error(`Emulator setup failed: ${err.message}`);
+        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
@@ -46,9 +76,37 @@ export async function devCommand(options: DevOptions) {
 
     const session = await server.start();
 
+    // Listen for build completion and deploy to emulator
+    if (deployer && packageName) {
+      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: any) => {
+        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 {
+            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
+            success('Initial deployment complete. Future builds will be sent via hot reload.');
+          } catch (err: any) {
+            warning(`Emulator deployment failed: ${err.message}`);
+          }
+        } else if (hasDeployed) {
+          info('Skipping deployment (app already installed, using hot reload)');
+        } else {
+          warning(`Skipping deployment: apkPath=${result.apkPath}, deployer=${!!deployer}`);
+        }
+      });
+    } else {
+      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();
@@ -61,17 +119,12 @@ export async function devCommand(options: DevOptions) {
 
     // 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.bold('Scan QR or connect manually:'));
-      qrcode.generate(JSON.stringify(qrData), { small: true });
+      qrcode.generate(qrData, { small: true });
       console.log();
       info(`IP: ${chalk.cyan(host)}`);
       info(`Session: ${chalk.dim(session.id)}`);

package/src/commands/index.ts

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