@jetstart/cli 1.7.0 → 2.0.2

package/src/utils/android-sdk.ts

@@ -1,512 +0,0 @@
-/**
- * Android SDK Manager wrapper
- */
-
-import { spawn, ChildProcess } from 'child_process';
-import * as fs from 'fs-extra';
-import * as path from 'path';
-import * as os from 'os';
-import { downloadAndExtract } from './downloader';
-import { findAndroidSDK, getDefaultSDKPath } from './system-tools';
-import { startSpinner, stopSpinner, updateSpinner } from './spinner';
-import { success, error as logError, warning, info } from './logger';
-
-export interface SDKComponent {
-  name: string;
-  path: string;
-  version?: string;
-  installed: boolean;
-}
-
-/**
- * Required SDK components for JetStart
- */
-export const REQUIRED_SDK_COMPONENTS = [
-  'platform-tools',                              // adb, fastboot
-  'platforms;android-34',                        // Target API
-  'platforms;android-24',                        // Minimum API
-  'build-tools;34.0.0',                         // Latest build tools
-  'emulator',                                    // Android Emulator
-  'system-images;android-34;google_apis;x86_64', // For AVD
-];
-
-/**
- * Android cmdline-tools download URLs
- */
-const CMDLINE_TOOLS_URLS = {
-  win32: 'https://dl.google.com/android/repository/commandlinetools-win-11076708_latest.zip',
-  darwin: 'https://dl.google.com/android/repository/commandlinetools-mac-11076708_latest.zip',
-  linux: 'https://dl.google.com/android/repository/commandlinetools-linux-11076708_latest.zip',
-};
-
-/**
- * Android SDK Manager class
- */
-export class AndroidSDKManager {
-  private sdkRoot: string;
-
-  constructor(sdkRoot?: string) {
-    this.sdkRoot = sdkRoot || '';
-  }
-
-  /**
-   * Initialize SDK root, detecting or creating as needed
-   */
-  async ensureSDKRoot(): Promise<string> {
-    if (this.sdkRoot && await fs.pathExists(this.sdkRoot)) {
-      return this.sdkRoot;
-    }
-
-    // Try to find existing SDK
-    const existingSDK = await findAndroidSDK();
-    if (existingSDK) {
-      this.sdkRoot = existingSDK;
-      return this.sdkRoot;
-    }
-
-    // Create new SDK at default location
-    this.sdkRoot = getDefaultSDKPath();
-    await fs.ensureDir(this.sdkRoot);
-
-    info(`Creating Android SDK at: ${this.sdkRoot}`);
-
-    return this.sdkRoot;
-  }
-
-  /**
-   * Install Android cmdline-tools
-   */
-  async installCmdlineTools(): Promise<void> {
-    const sdkRoot = await this.ensureSDKRoot();
-    const platform = os.platform() as 'win32' | 'darwin' | 'linux';
-
-    const url = CMDLINE_TOOLS_URLS[platform];
-    if (!url) {
-      throw new Error(`Unsupported platform: ${platform}`);
-    }
-
-    const extractPath = path.join(sdkRoot, 'cmdline-tools');
-    const latestPath = path.join(extractPath, 'latest');
-
-    // Check if already installed
-    if (await fs.pathExists(latestPath)) {
-      success('Android cmdline-tools already installed');
-      return;
-    }
-
-    // Download and extract
-    await downloadAndExtract(url, extractPath, 'Downloading Android cmdline-tools');
-
-    // The extracted folder is named 'cmdline-tools', need to move it to 'latest'
-    const extractedPath = path.join(extractPath, 'cmdline-tools');
-    if (await fs.pathExists(extractedPath)) {
-      await fs.move(extractedPath, latestPath);
-    }
-
-    // Set environment variables for this process
-    process.env.ANDROID_HOME = sdkRoot;
-    process.env.ANDROID_SDK_ROOT = sdkRoot;
-
-    success('Android cmdline-tools installed');
-  }
-
-  /**
-   * Resolve sdkmanager path and tools root
-   * Checks multiple standard paths:
-   * 1. cmdline-tools/latest/bin (Standard)
-   * 2. cmdline-tools/bin (Alternative)
-   * 3. tools/bin (Legacy)
-   */
-  private async resolveSDKToolsPath(): Promise<{ binPath: string | null; toolsRoot: string }> {
-    const sdkmanagerName = os.platform() === 'win32' ? 'sdkmanager.bat' : 'sdkmanager';
-    
-    // Potential paths to check (in order of preference)
-    const candidates = [
-      {
-        bin: path.join(this.sdkRoot, 'cmdline-tools', 'latest', 'bin', sdkmanagerName),
-        root: path.join(this.sdkRoot, 'cmdline-tools', 'latest')
-      },
-      {
-        bin: path.join(this.sdkRoot, 'cmdline-tools', 'bin', sdkmanagerName),
-        root: path.join(this.sdkRoot, 'cmdline-tools')
-      },
-      {
-        bin: path.join(this.sdkRoot, 'tools', 'bin', sdkmanagerName),
-        root: path.join(this.sdkRoot, 'tools')
-      }
-    ];
-
-    for (const candidate of candidates) {
-      if (await fs.pathExists(candidate.bin)) {
-        return { binPath: candidate.bin, toolsRoot: candidate.root };
-      }
-    }
-
-    return { binPath: null, toolsRoot: '' };
-  }
-
-  /**
-   * Get path to sdkmanager executable (Legacy method, kept for reference but unused internally now)
-   */
-  private getSDKManagerPath(): string {
-    const sdkmanagerName = os.platform() === 'win32' ? 'sdkmanager.bat' : 'sdkmanager';
-    return path.join(this.sdkRoot, 'cmdline-tools', 'latest', 'bin', sdkmanagerName);
-  }
-
-  /**
-   * Get path to avdmanager executable
-   */
-  private getAVDManagerPath(): string {
-    const avdmanagerName = os.platform() === 'win32' ? 'avdmanager.bat' : 'avdmanager';
-    return path.join(this.sdkRoot, 'cmdline-tools', 'latest', 'bin', avdmanagerName);
-  }
-
-  /**
-   * Run sdkmanager command
-   */
-  private async runSDKManager(
-    args: string[],
-    onProgress?: (progress: number, message: string) => void
-  ): Promise<string> {
-    // Resolve proper sdkmanager path and tools root
-    const { binPath, toolsRoot } = await this.resolveSDKToolsPath();
-
-    if (!binPath) {
-      throw new Error('sdkmanager not found. Install cmdline-tools first.');
-    }
-
-    return new Promise((resolve, reject) => {
-      const proc = spawn(binPath, args, {
-        env: {
-          ...process.env,
-          ANDROID_HOME: this.sdkRoot,
-          ANDROID_SDK_ROOT: this.sdkRoot,
-          // Accept licenses automatically
-          JAVA_OPTS:
-            '-Dcom.android.sdkmanager.toolsdir=' + toolsRoot,
-        },
-        shell: true,
-      });
-
-      let output = '';
-      let errorOutput = '';
-
-      proc.stdout?.on('data', (data) => {
-        output += data.toString();
-      });
-
-      // Parse stderr for progress updates
-      proc.stderr?.on('data', (data) => {
-        const text = data.toString();
-        errorOutput += text;
-
-        if (onProgress) {
-          // Parse progress percentage: "10% ▋...................."
-          const progressMatch = text.match(/(\d+)%/);
-          if (progressMatch) {
-            const percent = parseInt(progressMatch[1], 10);
-
-            // Extract current operation
-            const lines = text.split('\n');
-            const currentOp =
-              lines.find(
-                (l: string) =>
-                  l.includes('Downloading') ||
-                  l.includes('Installing') ||
-                  l.includes('Extracting') ||
-                  l.includes('Unzipping')
-              ) || 'Processing...';
-
-            onProgress(percent, currentOp.trim());
-          }
-        }
-      });
-
-      proc.on('close', (code) => {
-        if (code === 0) {
-          resolve(output);
-        } else {
-          reject(new Error(`sdkmanager exited with code ${code}: ${errorOutput}`));
-        }
-      });
-
-      proc.on('error', (err) => {
-        reject(err);
-      });
-    });
-  }
-
-  /**
-   * Accept all SDK licenses
-   */
-  async acceptLicenses(): Promise<void> {
-    const spinner = startSpinner('Accepting SDK licenses...');
-
-    try {
-      // Resolve tools path
-      const { binPath, toolsRoot } = await this.resolveSDKToolsPath();
-
-      if (!binPath) {
-        throw new Error('sdkmanager not found. Install cmdline-tools first.');
-      }
-
-      await new Promise<void>((resolve, reject) => {
-        const proc = spawn(binPath, ['--licenses'], {
-          env: {
-            ...process.env,
-            ANDROID_HOME: this.sdkRoot,
-            ANDROID_SDK_ROOT: this.sdkRoot,
-            // ADD MISSING JAVA_OPTS (critical fix)
-            JAVA_OPTS:
-              '-Dcom.android.sdkmanager.toolsdir=' + toolsRoot,
-          },
-          // ADD explicit stdio configuration
-          stdio: ['pipe', 'pipe', 'pipe'],
-          shell: true,
-        });
-
-        // Check if stdin is writable before writing
-        if (proc.stdin) {
-          const success = proc.stdin.write('y\n'.repeat(100));
-          if (!success) {
-            // Handle backpressure - wait for drain
-            proc.stdin.once('drain', () => {
-              proc.stdin?.end();
-            });
-          } else {
-            proc.stdin.end();
-          }
-        } else {
-          reject(new Error('stdin not available'));
-          return;
-        }
-
-        // Collect stderr for debugging
-        let errorOutput = '';
-        proc.stderr?.on('data', (data) => {
-          errorOutput += data.toString();
-        });
-
-        proc.on('close', (code) => {
-          if (code === 0 || code === null) {
-            resolve();
-          } else {
-            reject(
-              new Error(`Failed to accept licenses: exit code ${code}\n${errorOutput}`)
-            );
-          }
-        });
-
-        proc.on('error', (err) => {
-          reject(err);
-        });
-      });
-
-      stopSpinner(spinner, true, 'SDK licenses accepted');
-    } catch (error) {
-      stopSpinner(spinner, false, 'Failed to accept licenses');
-      throw error;
-    }
-  }
-
-  /**
-   * Install an SDK component
-   */
-  async installComponent(component: string, progressLabel?: string): Promise<void> {
-    const label = progressLabel || `Installing ${component}`;
-    const spinner = startSpinner(label);
-
-    try {
-      // Accept licenses first
-      await this.acceptLicenses();
-
-      // Install component with progress updates
-      await this.runSDKManager(['--install', component], (percent, message) => {
-        // Update spinner text with progress
-        spinner.text = `${label} (${percent}%) - ${message}`;
-      });
-
-      stopSpinner(spinner, true, `${component} installed`);
-    } catch (error) {
-      stopSpinner(spinner, false, `Failed to install ${component}`);
-      throw error;
-    }
-  }
-
-  /**
-   * List installed SDK components
-   */
-  async listInstalled(): Promise<SDKComponent[]> {
-    try {
-      const output = await this.runSDKManager(['--list_installed']);
-      return this.parseSDKList(output);
-    } catch (error) {
-      return [];
-    }
-  }
-
-  /**
-   * Parse sdkmanager list output
-   */
-  private parseSDKList(output: string): SDKComponent[] {
-    const components: SDKComponent[] = [];
-    const lines = output.split('\n');
-
-    for (const line of lines) {
-      // Example: "build-tools;34.0.0 | 34.0.0 | Android SDK Build-Tools 34"
-      const match = line.match(/^([^|]+)\|([^|]+)\|(.+)$/);
-      if (match) {
-        const name = match[1].trim();
-        const version = match[2].trim();
-
-        components.push({
-          name,
-          version,
-          path: path.join(this.sdkRoot, name.replace(/;/g, path.sep)),
-          installed: true,
-        });
-      }
-    }
-
-    return components;
-  }
-
-  /**
-   * Update all installed components
-   */
-  async updateAll(): Promise<void> {
-    const spinner = startSpinner('Updating SDK components...');
-
-    try {
-      await this.runSDKManager(['--update']);
-      stopSpinner(spinner, true, 'SDK components updated');
-    } catch (error) {
-      stopSpinner(spinner, false, 'Failed to update components');
-      throw error;
-    }
-  }
-
-  /**
-   * Check if a component is installed
-   */
-  async isComponentInstalled(component: string): Promise<boolean> {
-    const installed = await this.listInstalled();
-    return installed.some((c) => c.name === component);
-  }
-
-  /**
-   * Install all required components for JetStart
-   */
-  async installRequiredComponents(): Promise<void> {
-    info('Installing required Android SDK components...');
-    console.log();
-
-    for (let i = 0; i < REQUIRED_SDK_COMPONENTS.length; i++) {
-      const component = REQUIRED_SDK_COMPONENTS[i];
-      const overallProgress = `[${i + 1}/${REQUIRED_SDK_COMPONENTS.length}]`;
-
-      try {
-        await this.installComponent(component, `${overallProgress} Installing ${component}`);
-      } catch (error) {
-        warning(`Failed to install ${component}: ${(error as Error).message}`);
-      }
-    }
-
-    console.log();
-    success('All required SDK components installed');
-  }
-
-  /**
-   * Detect missing required components
-   */
-  async detectMissingComponents(): Promise<string[]> {
-    const installed = await this.listInstalled();
-    const installedNames = installed.map((c) => c.name);
-
-    return REQUIRED_SDK_COMPONENTS.filter((c) => !installedNames.includes(c));
-  }
-
-  /**
-   * Create local.properties file with SDK path
-   */
-  async createLocalProperties(projectPath: string): Promise<void> {
-    const localPropertiesPath = path.join(projectPath, 'local.properties');
-
-    // Check if already exists
-    if (await fs.pathExists(localPropertiesPath)) {
-      return;
-    }
-
-    const sdkRoot = await this.ensureSDKRoot();
-
-    // Escape backslashes for Windows paths
-    const sdkPathEscaped = sdkRoot.replace(/\\/g, '\\\\');
-
-    const content = `# Automatically generated by JetStart
-sdk.dir=${sdkPathEscaped}
-`;
-
-    await fs.writeFile(localPropertiesPath, content, 'utf8');
-    info(`Created local.properties with SDK path`);
-  }
-}
-
-/**
- * Create an SDK manager instance
- */
-export function createSDKManager(sdkRoot?: string): AndroidSDKManager {
-  // Check for mock mode (for testing)
-  if (process.env.JETSTART_MOCK_SDK === 'true') {
-    return new MockAndroidSDKManager() as any;
-  }
-
-  return new AndroidSDKManager(sdkRoot);
-}
-
-/**
- * Mock SDK manager for testing
- */
-class MockAndroidSDKManager {
-  async ensureSDKRoot(): Promise<string> {
-    return '/mock/android/sdk';
-  }
-
-  async installCmdlineTools(): Promise<void> {
-    info('[MOCK] Installing cmdline-tools');
-  }
-
-  async acceptLicenses(): Promise<void> {
-    info('[MOCK] Accepting licenses');
-  }
-
-  async installComponent(component: string): Promise<void> {
-    info(`[MOCK] Installing ${component}`);
-  }
-
-  async listInstalled(): Promise<SDKComponent[]> {
-    return [
-      { name: 'platforms;android-34', version: '1', path: '/mock/platforms/android-34', installed: true },
-      { name: 'build-tools;34.0.0', version: '34.0.0', path: '/mock/build-tools/34.0.0', installed: true },
-    ];
-  }
-
-  async updateAll(): Promise<void> {
-    info('[MOCK] Updating all components');
-  }
-
-  async isComponentInstalled(component: string): Promise<boolean> {
-    return true;
-  }
-
-  async installRequiredComponents(): Promise<void> {
-    info('[MOCK] Installing required components');
-  }
-
-  async detectMissingComponents(): Promise<string[]> {
-    return [];
-  }
-
-  async createLocalProperties(projectPath: string): Promise<void> {
-    info(`[MOCK] Creating local.properties at ${projectPath}`);
-  }
-}

package/src/utils/downloader.ts

@@ -1,201 +0,0 @@
-/**
- * Download utilities with progress tracking
- */
-
-import axios from 'axios';
-import * as fs from 'fs-extra';
-import * as path from 'path';
-import { startSpinner, stopSpinner } from './spinner';
-import { error as logError } from './logger';
-
-export interface DownloadOptions {
-  url: string;
-  destination: string;
-  progressLabel?: string;
-  expectedSize?: number;
-  timeout?: number;
-}
-
-/**
- * Format bytes into human-readable format
- */
-export function formatBytes(bytes: number): string {
-  if (bytes === 0) return '0 B';
-  if (bytes < 1024) return `${bytes} B`;
-  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(2)} KB`;
-  if (bytes < 1024 * 1024 * 1024) return `${(bytes / (1024 * 1024)).toFixed(2)} MB`;
-  return `${(bytes / (1024 * 1024 * 1024)).toFixed(2)} GB`;
-}
-
-/**
- * Download a file with progress tracking
- */
-export async function downloadWithProgress(options: DownloadOptions): Promise<void> {
-  const {
-    url,
-    destination,
-    progressLabel = 'Downloading',
-    timeout = 300000, // 5 minutes default
-  } = options;
-
-  // Ensure destination directory exists
-  await fs.ensureDir(path.dirname(destination));
-
-  const response = await axios({
-    url,
-    method: 'GET',
-    responseType: 'stream',
-    timeout,
-    headers: {
-      'User-Agent': 'JetStart-CLI',
-    },
-  });
-
-  const totalSize = parseInt(response.headers['content-length'] || '0', 10);
-  let downloadedSize = 0;
-
-  const spinner = startSpinner(`${progressLabel} (0%)`);
-
-  return new Promise((resolve, reject) => {
-    const writer = fs.createWriteStream(destination);
-
-    response.data.on('data', (chunk: Buffer) => {
-      downloadedSize += chunk.length;
-
-      if (totalSize > 0) {
-        const percent = Math.round((downloadedSize / totalSize) * 100);
-        const downloaded = formatBytes(downloadedSize);
-        const total = formatBytes(totalSize);
-        spinner.text = `${progressLabel} (${percent}%) - ${downloaded} / ${total}`;
-      } else {
-        const downloaded = formatBytes(downloadedSize);
-        spinner.text = `${progressLabel} - ${downloaded}`;
-      }
-    });
-
-    response.data.pipe(writer);
-
-    writer.on('finish', () => {
-      stopSpinner(spinner, true, `${progressLabel} completed`);
-      resolve();
-    });
-
-    writer.on('error', (err) => {
-      stopSpinner(spinner, false, `${progressLabel} failed`);
-      reject(err);
-    });
-
-    response.data.on('error', (err: Error) => {
-      stopSpinner(spinner, false, `${progressLabel} failed`);
-      reject(err);
-    });
-  });
-}
-
-/**
- * Sleep for a specified number of milliseconds
- */
-function sleep(ms: number): Promise<void> {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-
-/**
- * Download a file with retry logic and exponential backoff
- */
-export async function downloadWithRetry(
-  options: DownloadOptions,
-  maxRetries: number = 3
-): Promise<void> {
-  let lastError: Error | null = null;
-
-  for (let attempt = 1; attempt <= maxRetries; attempt++) {
-    try {
-      await downloadWithProgress(options);
-      return; // Success!
-    } catch (err) {
-      lastError = err as Error;
-
-      if (attempt < maxRetries) {
-        const delay = Math.pow(2, attempt) * 1000; // 2s, 4s, 8s
-        console.log(`\nDownload failed (attempt ${attempt}/${maxRetries}). Retrying in ${delay / 1000}s...`);
-        await sleep(delay);
-      }
-    }
-  }
-
-  logError(`Download failed after ${maxRetries} attempts: ${lastError?.message}`);
-  throw lastError;
-}
-
-/**
- * Download and extract a ZIP file
- */
-export async function downloadAndExtract(
-  url: string,
-  extractPath: string,
-  progressLabel?: string
-): Promise<void> {
-  const extract = require('extract-zip');
-  const tempZip = path.join(require('os').tmpdir(), `jetstart-download-${Date.now()}.zip`);
-
-  try {
-    // Download
-    await downloadWithRetry({
-      url,
-      destination: tempZip,
-      progressLabel: progressLabel || 'Downloading archive',
-    });
-
-    // Extract
-    const spinner = startSpinner('Extracting archive...');
-    try {
-      await extract(tempZip, { dir: path.resolve(extractPath) });
-      stopSpinner(spinner, true, 'Archive extracted successfully');
-    } catch (err) {
-      stopSpinner(spinner, false, 'Failed to extract archive');
-      throw err;
-    }
-  } finally {
-    // Clean up temp file
-    try {
-      await fs.remove(tempZip);
-    } catch {
-      // Ignore cleanup errors
-    }
-  }
-}
-
-/**
- * Check if a URL is accessible
- */
-export async function checkUrlAccessible(url: string): Promise<boolean> {
-  try {
-    const response = await axios.head(url, {
-      timeout: 10000,
-      headers: {
-        'User-Agent': 'JetStart-CLI',
-      },
-    });
-    return response.status >= 200 && response.status < 400;
-  } catch {
-    return false;
-  }
-}
-
-/**
- * Get file size from URL without downloading
- */
-export async function getRemoteFileSize(url: string): Promise<number | null> {
-  try {
-    const response = await axios.head(url, {
-      timeout: 10000,
-      headers: {
-        'User-Agent': 'JetStart-CLI',
-      },
-    });
-    const size = response.headers['content-length'];
-    return size ? parseInt(size, 10) : null;
-  } catch {
-    return null;
-  }
-}