@jetstart/core 1.1.1

package/src/build/dsl-types.ts

@@ -0,0 +1,50 @@
+/**
+ * DSL Type Definitions for Server-Side
+ * Represents UI elements that can be sent to Android app as JSON
+ */
+
+export interface UIDefinition {
+  version: string;
+  screen: DSLElement;
+}
+
+export interface DSLElement {
+  type: string;
+  text?: string;
+  style?: string;
+  color?: string;
+  modifier?: DSLModifier;
+  horizontalAlignment?: string;
+  verticalArrangement?: string;
+  contentAlignment?: string;
+  height?: number;
+  width?: number;
+  onClick?: string;
+  enabled?: boolean;
+  imageVector?: string;
+  tint?: string;
+  contentDescription?: string;
+  children?: DSLElement[];
+}
+
+export interface DSLModifier {
+  fillMaxSize?: boolean;
+  fillMaxWidth?: boolean;
+  fillMaxHeight?: boolean;
+  padding?: number;
+  paddingHorizontal?: number;
+  paddingVertical?: number;
+  size?: number;
+  height?: number;
+  width?: number;
+  weight?: number;
+}
+
+/**
+ * Parse result from Kotlin file
+ */
+export interface ParseResult {
+  success: boolean;
+  dsl?: UIDefinition;
+  errors?: string[];
+}

package/src/build/gradle-injector.ts

@@ -0,0 +1,64 @@
+/**
+ * Gradle BuildConfig Injector
+ * Injects buildConfigField values into build.gradle
+ */
+
+import * as fs from 'fs-extra';
+import * as path from 'path';
+import { log } from '../utils/logger';
+
+export interface BuildConfigField {
+  type: string;
+  name: string;
+  value: string;
+}
+
+/**
+ * Inject buildConfigFields into app/build.gradle
+ */
+export async function injectBuildConfigFields(
+  projectPath: string,
+  fields: BuildConfigField[]
+): Promise<void> {
+  const buildGradlePath = path.join(projectPath, 'app', 'build.gradle');
+  
+  if (!fs.existsSync(buildGradlePath)) {
+    log('Warning: build.gradle not found, skipping injection');
+    return;
+  }
+
+  let content = await fs.readFile(buildGradlePath, 'utf-8');
+
+  // Find the defaultConfig block
+  const defaultConfigRegex = /defaultConfig\s*\{([^}]*(?:\{[^}]*\}[^}]*)*)\}/;
+  const match = content.match(defaultConfigRegex);
+
+  if (!match) {
+    log('Warning: defaultConfig not found in build.gradle');
+    return;
+  }
+
+  const defaultConfigBlock = match[1];
+  
+  // Remove existing JetStart buildConfigFields
+  let updatedBlock = defaultConfigBlock.replace(
+    /\/\/ JetStart injected fields[\s\S]*?\/\/ End JetStart fields\n/g,
+    ''
+  );
+
+  // Add new buildConfigFields
+  const fieldLines = fields.map(f => {
+    // For String type, escape the value with quotes
+    const escapedValue = f.type === 'String' ? `\\"${f.value}\\"` : f.value;
+    return `        buildConfigField "${f.type}", "${f.name}", "${escapedValue}"`;
+  }).join('\n');
+
+  updatedBlock = updatedBlock.trimEnd() + '\n\n        // JetStart injected fields\n' + 
+    fieldLines + '\n        // End JetStart fields\n    ';
+
+  // Replace the defaultConfig block
+  content = content.replace(defaultConfigRegex, `defaultConfig {${updatedBlock}}`);
+
+  await fs.writeFile(buildGradlePath, content, 'utf-8');
+  log('Injected buildConfigFields into build.gradle');
+}

package/src/build/gradle.ts

@@ -0,0 +1,305 @@
+/**
+ * Gradle Executor
+ * Spawns and manages Gradle build processes
+ */
+
+import { spawn, ChildProcess } from 'child_process';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+import { BuildConfig, BuildResult } from '@jetstart/shared';
+import { BuildOutputParser } from './parser';
+
+export interface GradleExecutorOptions {
+  javaHome?: string;
+  androidHome?: string;
+}
+
+export class GradleExecutor {
+  private javaHome: string | undefined;
+  private androidHome: string | undefined;
+
+  constructor(options: GradleExecutorOptions = {}) {
+    this.javaHome = options.javaHome || process.env.JAVA_HOME;
+    this.androidHome = options.androidHome || process.env.ANDROID_HOME || process.env.ANDROID_SDK_ROOT;
+  }
+
+  /**
+   * Execute Gradle build
+   */
+  async execute(config: BuildConfig): Promise<BuildResult> {
+    const startTime = Date.now();
+    const gradlePath = this.findGradle(config.projectPath);
+
+    // If Gradle not found, return mock build for testing
+    if (!gradlePath) {
+      console.log('[Gradle] No Gradle found, returning mock successful build for testing');
+
+      // Simulate build delay
+      await new Promise(resolve => setTimeout(resolve, 2000));
+
+      return {
+        success: true,
+        buildTime: Date.now() - startTime,
+        apkPath: path.join(config.projectPath, 'build/outputs/apk/debug/app-debug.apk'),
+        apkSize: 5242880, // Mock size: 5MB
+      };
+    }
+
+    // Ensure Android SDK is configured
+    await this.ensureAndroidSdk(config.projectPath);
+
+    const args = this.buildGradleArgs(config);
+    const env = this.buildEnv();
+
+    return this.runGradle(gradlePath, args, config.projectPath, env, startTime);
+  }
+
+  /**
+   * Ensure Android SDK is configured (auto-detect and create local.properties)
+   */
+  private async ensureAndroidSdk(projectPath: string): Promise<void> {
+    const localPropsPath = path.join(projectPath, 'local.properties');
+
+    // Check if local.properties already exists
+    if (fs.existsSync(localPropsPath)) {
+      return; // Already configured
+    }
+
+    // Try to find Android SDK
+    let androidSdkPath = this.androidHome;
+
+    // If not in environment, check common Windows locations
+    if (!androidSdkPath && os.platform() === 'win32') {
+      const commonPaths = [
+        'C:\\Android',  // Check C:\Android first (command-line tools location)
+        path.join(os.homedir(), 'AppData', 'Local', 'Android', 'Sdk'),
+        'C:\\Android\\Sdk',
+        'C:\\Program Files (x86)\\Android\\android-sdk',
+      ];
+
+      for (const p of commonPaths) {
+        if (fs.existsSync(p)) {
+          androidSdkPath = p;
+          console.log(`[Gradle] Auto-detected Android SDK at: ${androidSdkPath}`);
+          break;
+        }
+      }
+    }
+
+    // If not found on macOS/Linux, check common paths
+    if (!androidSdkPath && os.platform() !== 'win32') {
+      const commonPaths = [
+        path.join(os.homedir(), 'Android', 'Sdk'),
+        path.join(os.homedir(), 'Library', 'Android', 'sdk'),
+        '/opt/android-sdk',
+      ];
+
+      for (const p of commonPaths) {
+        if (fs.existsSync(p)) {
+          androidSdkPath = p;
+          console.log(`[Gradle] Auto-detected Android SDK at: ${androidSdkPath}`);
+          break;
+        }
+      }
+    }
+
+    if (!androidSdkPath) {
+      console.warn('[Gradle] Android SDK not found! Set ANDROID_HOME environment variable.');
+      console.warn('[Gradle] Download Android SDK from: https://developer.android.com/studio');
+      return;
+    }
+
+    // Create local.properties with SDK path
+    const localProps = `# Auto-generated by JetStart
+sdk.dir=${androidSdkPath.replace(/\\/g, '\\\\')}
+`;
+
+    fs.writeFileSync(localPropsPath, localProps);
+    console.log(`[Gradle] Created local.properties with SDK path: ${androidSdkPath}`);
+  }
+
+  /**
+   * Find Gradle executable (prioritize system gradle for speed)
+   */
+  private findGradle(projectPath: string): string | null {
+    const isWindows = os.platform() === 'win32';
+
+    // CHECK SYSTEM GRADLE FIRST (instant, no download needed)
+    const gradleName = isWindows ? 'gradle.bat' : 'gradle';
+    const systemGradle = this.findInPath(gradleName);
+
+    if (systemGradle) {
+      console.log('[Gradle] Using system Gradle (faster than wrapper)');
+      return systemGradle;
+    }
+
+    // Fallback to gradlew wrapper in project (slower, downloads Gradle)
+    const gradlewName = isWindows ? 'gradlew.bat' : 'gradlew';
+    const gradlewPath = path.join(projectPath, gradlewName);
+
+    if (fs.existsSync(gradlewPath)) {
+      console.log('[Gradle] Using project wrapper (may download Gradle on first run)');
+      return gradlewPath;
+    }
+
+    return null;
+  }
+
+  /**
+   * Find executable in PATH
+   */
+  private findInPath(executableName: string): string | null {
+    const pathEnv = process.env.PATH || '';
+    const pathSeparator = os.platform() === 'win32' ? ';' : ':';
+    const paths = pathEnv.split(pathSeparator);
+
+    for (const dir of paths) {
+      const fullPath = path.join(dir, executableName);
+      if (fs.existsSync(fullPath)) {
+        return fullPath;
+      }
+    }
+
+    return null;
+  }
+
+  /**
+   * Build Gradle arguments
+   */
+  private buildGradleArgs(config: BuildConfig): string[] {
+    const args: string[] = [];
+
+    // Task based on build type
+    if (config.buildType === 'debug') {
+      args.push('assembleDebug');
+    } else {
+      args.push('assembleRelease');
+    }
+
+    // Performance optimizations
+    args.push('--parallel');
+    args.push('--build-cache');
+    args.push('--configure-on-demand');
+
+    // Build universal APK for all architectures (removed single-ABI restriction)
+    // This ensures the APK works on all device architectures
+    // Note: This makes the APK larger but ensures compatibility
+
+    // Daemon for faster subsequent builds
+    args.push('--daemon');
+
+    // Console output
+    args.push('--console=plain');
+
+    return args;
+  }
+
+  /**
+   * Build environment variables
+   */
+  private buildEnv(): NodeJS.ProcessEnv {
+    const env = { ...process.env };
+
+    if (this.javaHome) {
+      env.JAVA_HOME = this.javaHome;
+    }
+
+    if (this.androidHome) {
+      env.ANDROID_HOME = this.androidHome;
+      env.ANDROID_SDK_ROOT = this.androidHome;
+    }
+
+    return env;
+  }
+
+  /**
+   * Run Gradle process and collect output
+   */
+  private runGradle(
+    gradlePath: string,
+    args: string[],
+    cwd: string,
+    env: NodeJS.ProcessEnv,
+    startTime: number
+  ): Promise<BuildResult> {
+    return new Promise((resolve) => {
+      let output = '';
+
+      console.log(`[Gradle] Running: ${gradlePath} ${args.join(' ')}`);
+      console.log(`[Gradle] Working directory: ${cwd}`);
+
+      const process = spawn(gradlePath, args, {
+        cwd,
+        env,
+        shell: true,
+      });
+
+      process.stdout.on('data', (data: Buffer) => {
+        const text = data.toString();
+        output += text;
+        // Stream output to console in real-time
+        console.log(text.trim());
+      });
+
+      process.stderr.on('data', (data: Buffer) => {
+        const text = data.toString();
+        output += text;
+        // Stream errors to console in real-time
+        console.error(text.trim());
+      });
+
+      process.on('close', (code: number) => {
+        console.log(`[Gradle] Process exited with code: ${code}`);
+        const result = BuildOutputParser.parse(output, startTime);
+
+        // If process exited with error but no errors were parsed, add generic error
+        if (code !== 0 && (!result.errors || result.errors.length === 0)) {
+          result.errors = [{
+            file: '',
+            line: 0,
+            column: 0,
+            message: `Gradle process exited with code ${code}`,
+            severity: 'error' as any,
+          }];
+          result.success = false;
+        }
+
+        // If build succeeded but APK path not found, manually search for it
+        if (result.success && !result.apkPath) {
+          const possiblePaths = [
+            path.join(cwd, 'app/build/outputs/apk/debug/app-debug.apk'),
+            path.join(cwd, 'app/build/intermediates/apk/debug/app-debug.apk'),
+            path.join(cwd, 'build/outputs/apk/debug/app-debug.apk'),
+          ];
+
+          for (const apkPath of possiblePaths) {
+            if (fs.existsSync(apkPath)) {
+              result.apkPath = apkPath;
+              result.apkSize = fs.statSync(apkPath).size;
+              console.log(`[Gradle] Found APK at: ${apkPath} (${(result.apkSize / 1024 / 1024).toFixed(2)} MB)`);
+              break;
+            }
+          }
+        }
+
+        resolve(result);
+      });
+
+      process.on('error', (err: Error) => {
+        console.error(`[Gradle] Failed to spawn process: ${err.message}`);
+        resolve({
+          success: false,
+          buildTime: Date.now() - startTime,
+          errors: [{
+            file: '',
+            line: 0,
+            column: 0,
+            message: `Failed to spawn Gradle process: ${err.message}`,
+            severity: 'error' as any,
+          }],
+        });
+      });
+    });
+  }
+}

package/src/build/index.ts

@@ -0,0 +1,10 @@
+/**
+ * Build Module
+ * Handles Kotlin/Gradle compilation, file watching, and build caching
+ */
+
+export * from './builder';
+export * from './gradle';
+export * from './parser';
+export * from './cache';
+export * from './watcher';

package/src/build/parser.ts

@@ -0,0 +1,75 @@
+/**
+ * Build Output Parser
+ * Parses Gradle build output to extract errors, warnings, and build info
+ */
+
+import { BuildResult, BuildError, BuildWarning, ErrorSeverity } from '@jetstart/shared';
+
+export class BuildOutputParser {
+  /**
+   * Parse Gradle build output
+   */
+  static parse(output: string, startTime: number): BuildResult {
+    const lines = output.split('\n');
+    const errors: BuildError[] = [];
+    const warnings: BuildWarning[] = [];
+    let apkPath: string | undefined;
+    let apkSize: number | undefined;
+
+    for (const line of lines) {
+      // Parse Kotlin compiler errors: e: /path/file.kt:10:5: Error message
+      const errorMatch = line.match(/^e: (.+):(\d+):(\d+): (.+)$/);
+      if (errorMatch) {
+        errors.push({
+          file: errorMatch[1],
+          line: parseInt(errorMatch[2], 10),
+          column: parseInt(errorMatch[3], 10),
+          message: errorMatch[4],
+          severity: ErrorSeverity.ERROR,
+        });
+        continue;
+      }
+
+      // Parse Kotlin compiler warnings: w: /path/file.kt:10:5: Warning message
+      const warningMatch = line.match(/^w: (.+):(\d+):(\d+): (.+)$/);
+      if (warningMatch) {
+        warnings.push({
+          file: warningMatch[1],
+          line: parseInt(warningMatch[2], 10),
+          message: warningMatch[4],
+        });
+        continue;
+      }
+
+      // Parse APK location (check both outputs and intermediates directories)
+      if (line.includes('.apk') && (line.includes('app/build/outputs') || line.includes('app\\build\\outputs') || line.includes('app/build/intermediates') || line.includes('app\\build\\intermediates'))) {
+        const apkMatch = line.match(/([^\s]+\.apk)/);
+        if (apkMatch) {
+          apkPath = apkMatch[1];
+        }
+      }
+
+      // Parse build success
+      if (line.includes('BUILD SUCCESSFUL')) {
+        // Success is determined later
+      }
+
+      // Parse build failure
+      if (line.includes('BUILD FAILED')) {
+        // Failure is determined by errors array
+      }
+    }
+
+    const buildTime = Date.now() - startTime;
+    const success = errors.length === 0 && output.includes('BUILD SUCCESSFUL');
+
+    return {
+      success,
+      apkPath,
+      apkSize,
+      buildTime,
+      errors: errors.length > 0 ? errors : undefined,
+      warnings: warnings.length > 0 ? warnings : undefined,
+    };
+  }
+}

package/src/build/watcher.ts

@@ -0,0 +1,103 @@
+/**
+ * File Watcher
+ * Watches for file changes using chokidar
+ */
+
+import * as chokidar from 'chokidar';
+import * as path from 'path';
+
+export interface FileWatcherOptions {
+  projectPath: string;
+  callback: (files: string[]) => void;
+  debounceMs?: number;
+}
+
+export class FileWatcher {
+  private watcher: chokidar.FSWatcher | null = null;
+  private callback: (files: string[]) => void;
+  private debounceTimer: NodeJS.Timeout | null = null;
+  private debounceMs: number;
+  private changedFiles: Set<string> = new Set();
+
+  constructor(options: FileWatcherOptions) {
+    this.callback = options.callback;
+    this.debounceMs = options.debounceMs || 300; // 300ms default
+  }
+
+  /**
+   * Start watching for file changes
+   */
+  watch(projectPath: string): void {
+    if (this.watcher) {
+      this.stop();
+    }
+
+    // Watch .kt, .xml, .gradle files
+    const patterns = [
+      path.join(projectPath, '**/*.kt'),
+      path.join(projectPath, '**/*.xml'),
+      path.join(projectPath, '**/*.gradle'),
+      path.join(projectPath, '**/*.gradle.kts'),
+    ];
+
+    this.watcher = chokidar.watch(patterns, {
+      ignored: [
+        '**/node_modules/**',
+        '**/build/**',
+        '**/.gradle/**',
+        '**/.git/**',
+        '**/dist/**',
+      ],
+      persistent: true,
+      ignoreInitial: true,
+    });
+
+    this.watcher.on('change', (filePath: string) => {
+      this.onFileChange(filePath);
+    });
+
+    this.watcher.on('add', (filePath: string) => {
+      this.onFileChange(filePath);
+    });
+
+    this.watcher.on('unlink', (filePath: string) => {
+      this.onFileChange(filePath);
+    });
+  }
+
+  /**
+   * Stop watching
+   */
+  stop(): void {
+    if (this.watcher) {
+      this.watcher.close();
+      this.watcher = null;
+    }
+
+    if (this.debounceTimer) {
+      clearTimeout(this.debounceTimer);
+      this.debounceTimer = null;
+    }
+
+    this.changedFiles.clear();
+  }
+
+  /**
+   * Handle file change with debouncing
+   */
+  private onFileChange(filePath: string): void {
+    this.changedFiles.add(filePath);
+
+    // Clear existing timer
+    if (this.debounceTimer) {
+      clearTimeout(this.debounceTimer);
+    }
+
+    // Set new timer
+    this.debounceTimer = setTimeout(() => {
+      const files = Array.from(this.changedFiles);
+      this.changedFiles.clear();
+      this.callback(files);
+    }, this.debounceMs);
+  }
+}

package/src/index.ts

@@ -0,0 +1,20 @@
+/**
+ * Core Package Entry Point
+ * Central build server and WebSocket orchestration
+ */
+
+export * from './server';
+export * from './websocket';
+export * from './build';
+export * from './types';
+export * from './utils';
+
+// Re-export shared types
+export type {
+  Session,
+  SessionStatus,
+  BuildConfig,
+  BuildResult,
+  DeviceInfo,
+  WSMessage,
+} from '@jetstart/shared';

package/src/server/http.ts

@@ -0,0 +1,38 @@
+/**
+ * HTTP Server
+ * Serves APKs, handles REST endpoints
+ */
+
+import express, { Express } from 'express';
+import { Server } from 'http';
+import { setupMiddleware } from './middleware';
+import { setupRoutes } from './routes';
+import { log } from '../utils/logger';
+
+export interface HttpServerConfig {
+  port: number;
+  host: string;
+  getLatestApk?: () => string | null;
+}
+
+export async function createHttpServer(config: HttpServerConfig): Promise<Server> {
+  const app: Express = express();
+
+  // Setup middleware
+  setupMiddleware(app);
+
+  // Setup routes
+  setupRoutes(app, config.getLatestApk);
+
+  // Start server
+  return new Promise((resolve, reject) => {
+    const server = app.listen(config.port, config.host, () => {
+      log(`HTTP server listening on ${config.host}:${config.port}`);
+      resolve(server);
+    });
+
+    server.on('error', (err: Error) => {
+      reject(err);
+    });
+  });
+}