@jetstart/cli 1.2.0 → 1.4.0

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';

package/src/commands/install-audit.ts

@@ -0,0 +1,227 @@
+/**
+ * Installation audit command - checks all required tools and dependencies
+ */
+
+import chalk from 'chalk';
+import { AuditOptions } from '../types';
+import {
+  detectNode,
+  detectNpm,
+  detectJava,
+  detectGradle,
+  detectAndroidSDK,
+  detectAndroidCmdlineTools,
+  detectAndroidBuildTools,
+  detectAndroidPlatformTools,
+  detectAndroidEmulator,
+  detectAndroidPlatform,
+  checkJavaHome,
+  checkAndroidHome,
+  ToolInfo,
+} from '../utils/system-tools';
+import { warning } from '../utils/logger';
+
+/**
+ * Print tool status in table format
+ */
+function printToolStatus(tool: ToolInfo): void {
+  const icon =
+    tool.status === 'ok'
+      ? chalk.green('✓')
+      : tool.status === 'warning'
+      ? chalk.yellow('⚠')
+      : chalk.red('✗');
+
+  const name = tool.name.padEnd(25);
+  const version = (tool.version || (tool.installed ? 'Unknown' : 'Not installed')).padEnd(15);
+
+  let statusText = '';
+  if (tool.status === 'ok') {
+    statusText = chalk.green('OK');
+  } else if (tool.status === 'warning') {
+    statusText = chalk.yellow(tool.message || 'Warning');
+  } else {
+    statusText = chalk.red(tool.message || 'ERROR');
+  }
+
+  console.log(`  ${icon} ${name} ${version} ${statusText}`);
+}
+
+/**
+ * Print section header
+ */
+function printSection(title: string): void {
+  console.log();
+  console.log(chalk.bold(title + ':'));
+  console.log('━'.repeat(70));
+}
+
+/**
+ * Run audit in table format
+ */
+async function runAuditTable(): Promise<void> {
+  console.log();
+  console.log(chalk.cyan.bold('  JetStart Installation Audit'));
+  console.log();
+
+  const allTools: ToolInfo[] = [];
+
+  // Development Tools
+  printSection('Development Tools');
+
+  const node = await detectNode();
+  printToolStatus(node);
+  allTools.push(node);
+
+  const npm = await detectNpm();
+  printToolStatus(npm);
+  allTools.push(npm);
+
+  const java = await detectJava();
+  printToolStatus(java);
+  allTools.push(java);
+
+  const gradle = await detectGradle();
+  printToolStatus(gradle);
+  allTools.push(gradle);
+
+  // Android SDK
+  printSection('Android SDK');
+
+  const sdk = await detectAndroidSDK();
+  printToolStatus(sdk);
+  allTools.push(sdk);
+
+  const cmdlineTools = await detectAndroidCmdlineTools();
+  printToolStatus(cmdlineTools);
+  allTools.push(cmdlineTools);
+
+  const buildTools = await detectAndroidBuildTools();
+  printToolStatus(buildTools);
+  allTools.push(buildTools);
+
+  const platformTools = await detectAndroidPlatformTools();
+  printToolStatus(platformTools);
+  allTools.push(platformTools);
+
+  const emulator = await detectAndroidEmulator();
+  printToolStatus(emulator);
+  allTools.push(emulator);
+
+  // Android Platforms
+  printSection('Android Platforms');
+
+  const api34 = await detectAndroidPlatform(34);
+  printToolStatus({ ...api34, name: 'API 34 (Target)' });
+  allTools.push(api34);
+
+  const api24 = await detectAndroidPlatform(24);
+  printToolStatus({ ...api24, name: 'API 24 (Minimum)' });
+  allTools.push(api24);
+
+  // Environment Variables
+  printSection('Environment Variables');
+
+  const javaHome = await checkJavaHome();
+  printToolStatus(javaHome);
+  allTools.push(javaHome);
+
+  const androidHome = await checkAndroidHome();
+  printToolStatus(androidHome);
+  allTools.push(androidHome);
+
+  // Summary
+  const summary = {
+    ok: allTools.filter((t) => t.status === 'ok').length,
+    warning: allTools.filter((t) => t.status === 'warning').length,
+    error: allTools.filter((t) => t.status === 'error').length,
+  };
+
+  printSection('Summary');
+  console.log(`  ${chalk.green('✓')} ${summary.ok} components OK`);
+  if (summary.warning > 0) {
+    console.log(`  ${chalk.yellow('⚠')} ${summary.warning} warning${summary.warning > 1 ? 's' : ''}`);
+  }
+  if (summary.error > 0) {
+    console.log(`  ${chalk.red('✗')} ${summary.error} error${summary.error > 1 ? 's' : ''}`);
+  }
+
+  // Recommendations
+  if (summary.error > 0) {
+    console.log();
+    warning('Recommendation:');
+    console.log('  Run "jetstart create <project-name> --full-install" to install missing dependencies');
+  }
+
+  console.log();
+}
+
+/**
+ * Run audit in JSON format
+ */
+async function runAuditJSON(): Promise<void> {
+  const tools = {
+    node: await detectNode(),
+    npm: await detectNpm(),
+    java: await detectJava(),
+    gradle: await detectGradle(),
+  };
+
+  const androidComponents = {
+    sdk: await detectAndroidSDK(),
+    cmdlineTools: await detectAndroidCmdlineTools(),
+    buildTools: await detectAndroidBuildTools(),
+    platformTools: await detectAndroidPlatformTools(),
+    emulator: await detectAndroidEmulator(),
+    platforms: {
+      api34: await detectAndroidPlatform(34),
+      api24: await detectAndroidPlatform(24),
+    },
+  };
+
+  const environment = {
+    javaHome: await checkJavaHome(),
+    androidHome: await checkAndroidHome(),
+  };
+
+  const allTools = [
+    ...Object.values(tools),
+    ...Object.values(androidComponents).filter((v) => typeof v === 'object' && 'status' in v),
+    androidComponents.platforms.api34,
+    androidComponents.platforms.api24,
+    ...Object.values(environment),
+  ] as ToolInfo[];
+
+  const summary = {
+    ok: allTools.filter((t) => t.status === 'ok').length,
+    warning: allTools.filter((t) => t.status === 'warning').length,
+    error: allTools.filter((t) => t.status === 'error').length,
+  };
+
+  const result = {
+    timestamp: new Date().toISOString(),
+    platform: process.platform,
+    tools,
+    androidComponents,
+    environment,
+    summary,
+  };
+
+  console.log(JSON.stringify(result, null, 2));
+}
+
+/**
+ * Install audit command handler
+ */
+export async function installAuditCommand(options: AuditOptions): Promise<void> {
+  try {
+    if (options.json) {
+      await runAuditJSON();
+    } else {
+      await runAuditTable();
+    }
+  } catch (err: any) {
+    console.error(chalk.red(`\nAudit failed: ${err.message}`));
+    process.exit(1);
+  }
+}

package/src/types/index.ts

@@ -19,4 +19,34 @@ export interface TemplateOptions {
 export interface CommandContext {
   cwd: string;
   config?: ProjectConfig;
+}
+
+// Create command options
+export interface CreateOptions {
+  package?: string;
+  template?: string;
+  skipInstall?: boolean;
+  fullInstall?: boolean;
+}
+
+// Install audit command options
+export interface AuditOptions {
+  json?: boolean;
+}
+
+// Dev command options
+export interface DevOptions {
+  port?: string;
+  host?: string;
+  qr?: boolean;
+  open?: boolean;
+  emulator?: boolean;
+  avd?: string;
+}
+
+// Install action enum
+export enum InstallAction {
+  SKIP = 'skip',
+  UPDATE = 'update',
+  REPLACE = 'replace',
 }