@jetstart/core 1.1.1

package/src/server/index.ts

@@ -0,0 +1,272 @@
+/**
+ * Main Server Entry Point
+ * Starts HTTP and WebSocket servers
+ */
+
+import * as path from 'path';
+import * as os from 'os';
+import { createHttpServer } from './http';
+import { createWebSocketServer } from '../websocket';
+import { WebSocketHandler } from '../websocket/handler';
+import { log, success, error } from '../utils/logger';
+import { DEFAULT_CORE_PORT, DEFAULT_WS_PORT } from '@jetstart/shared';
+import { SessionManager } from '../utils/session';
+import { BuildService } from '../build';
+import { ServerSession } from '../types';
+import { DSLParser } from '../build/dsl-parser';
+import { injectBuildConfigFields } from '../build/gradle-injector';
+
+export interface ServerConfig {
+  httpPort?: number;
+  wsPort?: number;
+  host?: string;
+  displayHost?: string; // IP address to display in logs/QR codes (for client connections)
+  projectPath?: string;
+  projectName?: string;
+}
+
+export class JetStartServer {
+  private httpServer: any;
+  private wsServer: any;
+  private wsHandler: WebSocketHandler | null = null;
+  private config: Required<ServerConfig> & { displayHost: string };
+  private sessionManager: SessionManager;
+  private buildService: BuildService;
+  private currentSession: ServerSession | null = null;
+  private buildMutex: boolean = false;  // Prevent concurrent builds
+  private latestApkPath: string | null = null;  // Store latest built APK path
+
+  constructor(config: ServerConfig = {}) {
+    const bindHost = config.host || '0.0.0.0';
+    const displayHost = config.displayHost || bindHost;
+    
+    this.config = {
+      httpPort: config.httpPort || DEFAULT_CORE_PORT,
+      wsPort: config.wsPort || DEFAULT_WS_PORT,
+      host: bindHost,
+      displayHost: displayHost,
+      projectPath: config.projectPath || process.cwd(),
+      projectName: config.projectName || path.basename(config.projectPath || process.cwd()),
+    };
+
+    this.sessionManager = new SessionManager();
+    this.buildService = new BuildService({
+      cacheEnabled: true,
+      cachePath: path.join(os.tmpdir(), 'jetstart-cache'),
+      watchEnabled: true,
+    });
+  }
+
+  async start(): Promise<ServerSession> {
+    try {
+      log('Starting JetStart Core server...');
+
+      // Create development session
+      this.currentSession = await this.sessionManager.createSession({
+        projectName: this.config.projectName,
+        projectPath: this.config.projectPath,
+      });
+
+      // Inject server URL into build.gradle for hot reload
+      const serverUrl = `ws://${this.config.displayHost}:${this.config.wsPort}`;
+      await injectBuildConfigFields(this.config.projectPath, [
+        { type: 'String', name: 'JETSTART_SERVER_URL', value: serverUrl },
+        { type: 'String', name: 'JETSTART_SESSION_ID', value: this.currentSession.id }
+      ]);
+      log(`Injected server URL: ${serverUrl}`);
+
+      // Start HTTP server
+      this.httpServer = await createHttpServer({
+        port: this.config.httpPort,
+        host: this.config.host,
+        getLatestApk: () => this.latestApkPath,
+      });
+
+      // Start WebSocket server
+      const wsResult = await createWebSocketServer({
+        port: this.config.wsPort,
+        onClientConnected: async (sessionId: string) => {
+          // Trigger initial build when client connects
+          log(`Triggering initial build for connected client (session: ${sessionId})`);
+          await this.handleRebuild();
+        },
+      });
+      this.wsServer = wsResult.server;
+      this.wsHandler = wsResult.handler;
+
+      // Setup build service event listeners
+      this.setupBuildListeners();
+
+      // Start watching for file changes
+      this.buildService.startWatching(this.config.projectPath, async (files) => {
+        log(`Files changed: ${files.map(f => path.basename(f)).join(', ')}`);
+
+        // Check if only UI files changed (MainActivity.kt, screens/, components/)
+        const uiFiles = files.filter(f =>
+          f.includes('MainActivity.kt') ||
+          f.includes('/screens/') ||
+          f.includes('\\screens\\') ||
+          f.includes('/components/') ||
+          f.includes('\\components\\')
+        );
+
+        // If ALL changed files are UI files, use DSL hot reload (FAST)
+        if (uiFiles.length > 0 && uiFiles.length === files.length) {
+          log('🚀 UI-only changes detected, using DSL hot reload');
+          this.handleUIUpdate(uiFiles[0]);
+        } else {
+          // Otherwise, full Gradle build
+          log('📦 Non-UI changes detected, triggering full Gradle build');
+          this.buildService.clearCache();
+          await this.handleRebuild();
+        }
+      });
+
+      console.log();
+      success('JetStart Core is running!');
+      log(`HTTP Server: http://${this.config.displayHost}:${this.config.httpPort}`);
+      log(`WebSocket Server: ws://${this.config.displayHost}:${this.config.wsPort}`);
+      log(`Session ID: ${this.currentSession.id}`);
+      log(`Session Token: ${this.currentSession.token}`);
+      console.log();
+
+      return this.currentSession;
+
+    } catch (err: any) {
+      error(`Failed to start server: ${err.message}`);
+      throw err;
+    }
+  }
+
+  async stop(): Promise<void> {
+    log('Stopping JetStart Core server...');
+
+    // Stop file watching
+    this.buildService.stopWatching();
+
+    if (this.wsServer) {
+      await this.wsServer.close();
+    }
+
+    if (this.httpServer) {
+      await new Promise<void>((resolve) => {
+        this.httpServer.close(() => resolve());
+      });
+    }
+
+    success('Server stopped');
+  }
+
+  getSession(): ServerSession | null {
+    return this.currentSession;
+  }
+
+  private setupBuildListeners(): void {
+    this.buildService.on('build:start', () => {
+      log('Build started');
+      if (this.wsHandler && this.currentSession) {
+        this.wsHandler.sendBuildStart(this.currentSession.id);
+      }
+    });
+
+    this.buildService.on('build:complete', (result) => {
+      success(`Build completed in ${result.buildTime}ms`);
+      if (this.wsHandler && this.currentSession) {
+        // Store the APK path
+        this.latestApkPath = result.apkPath || null;
+
+        // Send full download URL to client (not just relative path)
+        const downloadUrl = `http://${this.config.displayHost}:${this.config.httpPort}/download/app.apk`;
+        this.wsHandler.sendBuildComplete(this.currentSession.id, downloadUrl);
+        log(`APK download URL: ${downloadUrl}`);
+      }
+    });
+
+    this.buildService.on('build:error', (errorMsg, details) => {
+      error(`Build failed: ${errorMsg}`);
+      // TODO: Send build-error message via WebSocket
+    });
+
+    this.buildService.on('watch:change', (files) => {
+      // This event is just for logging/monitoring
+      // Actual build logic is handled in startWatching callback
+    });
+  }
+
+  private async handleRebuild(): Promise<void> {
+    if (!this.currentSession) {
+      return;
+    }
+
+    // Atomic mutex check - prevents race condition
+    if (this.buildMutex) {
+      log('Build already in progress, skipping duplicate build request');
+      return;
+    }
+
+    // Set mutex immediately before any async operations
+    this.buildMutex = true;
+
+    try {
+      // Trigger actual build using BuildService
+      const result = await this.buildService.build({
+        projectPath: this.config.projectPath,
+        outputPath: path.join(this.config.projectPath, 'build/outputs/apk'),
+        buildType: 'debug' as any, // BuildType.DEBUG
+        minifyEnabled: false,
+        debuggable: true,
+        versionCode: 1,
+        versionName: '1.0.0',
+        applicationId: 'com.example.app',
+      });
+
+      if (result.success) {
+        success(`Build completed successfully: ${result.apkPath || 'APK path not found'}`);
+      } else {
+        error(`Build failed: ${result.errors?.[0]?.message || 'Unknown error'}`);
+      }
+    } catch (err: any) {
+      error(`Build failed: ${err.message}`);
+    } finally {
+      // Always release mutex
+      this.buildMutex = false;
+    }
+  }
+
+  /**
+   * Handle UI file updates using DSL hot reload (FAST)
+   */
+  private handleUIUpdate(filePath: string): void {
+    if (!this.currentSession || !this.wsHandler) {
+      return;
+    }
+
+    try {
+      log(`Parsing UI file: ${path.basename(filePath)}`);
+      const parseResult = DSLParser.parseFile(filePath);
+
+      if (parseResult.success && parseResult.dsl) {
+        const dslContent = JSON.stringify(parseResult.dsl);
+        log(`DSL generated: ${dslContent.length} bytes`);
+
+        // Send DSL update via WebSocket (instant hot reload!)
+        this.wsHandler.sendUIUpdate(
+          this.currentSession.id,
+          dslContent,
+          [path.basename(filePath)]
+        );
+
+        success(`UI hot reload sent in <100ms ⚡`);
+      } else {
+        error(`Failed to parse UI file: ${parseResult.errors?.join(', ')}`);
+        // Fallback to full build
+        log('Falling back to full Gradle build...');
+        this.handleRebuild();
+      }
+    } catch (err: any) {
+      error(`UI update failed: ${err.message}`);
+      // Fallback to full build
+      this.handleRebuild();
+    }
+  }
+}

package/src/server/middleware.ts

@@ -0,0 +1,43 @@
+/**
+ * Express Middleware
+ * CORS, body parsing, error handling
+ */
+
+import { Express, Request, Response, NextFunction } from 'express';
+import express from 'express';
+import cors from 'cors';
+import { error as logError } from '../utils/logger';
+
+export function setupMiddleware(app: Express): void {
+  // CORS
+  app.use(cors({
+    origin: '*',
+    methods: ['GET', 'POST', 'PUT', 'DELETE'],
+    allowedHeaders: ['Content-Type', 'Authorization'],
+  }));
+
+  // Body parsing
+  app.use(express.json());
+  app.use(express.urlencoded({ extended: true }));
+
+  // Request logging
+  app.use((req: Request, res: Response, next: NextFunction) => {
+    const start = Date.now();
+    
+    res.on('finish', () => {
+      const duration = Date.now() - start;
+      console.log(`${req.method} ${req.path} - ${res.statusCode} (${duration}ms)`);
+    });
+
+    next();
+  });
+
+  // Error handling
+  app.use((err: Error, req: Request, res: Response, _next: NextFunction) => {
+    logError(`Server error: ${err.message}`);
+    res.status(500).json({
+      error: 'Internal server error',
+      message: err.message,
+    });
+  });
+}

package/src/server/routes.ts

@@ -0,0 +1,116 @@
+/**
+ * HTTP Routes
+ * REST API endpoints
+ */
+
+import { Express, Request, Response } from 'express';
+import path from 'path';
+import fs from 'fs';
+import { SessionManager } from '../utils/session';
+import { generateQRCode } from '../utils/qr';
+import { JETSTART_VERSION } from '@jetstart/shared';
+
+const sessionManager = new SessionManager();
+
+export function setupRoutes(app: Express, getLatestApk?: () => string | null): void {
+  // Health check
+  app.get('/health', (req: Request, res: Response) => {
+    res.json({
+      status: 'ok',
+      version: JETSTART_VERSION,
+      uptime: process.uptime(),
+    });
+  });
+
+  // Get version
+  app.get('/version', (req: Request, res: Response) => {
+    res.json({
+      version: JETSTART_VERSION,
+    });
+  });
+
+  // Create new session
+  app.post('/session/create', async (req: Request, res: Response) => {
+    try {
+      const { projectName, projectPath } = req.body;
+
+      if (!projectName || !projectPath) {
+        return res.status(400).json({
+          error: 'Missing required fields: projectName, projectPath',
+        });
+      }
+
+      const session = await sessionManager.createSession({
+        projectName,
+        projectPath,
+      });
+
+      // Generate QR code
+      const qrCode = await generateQRCode({
+        sessionId: session.id,
+        serverUrl: `http://${req.hostname}:${req.socket.localPort}`,
+        wsUrl: `ws://${req.hostname}:${req.socket.localPort}`,
+        token: session.token,
+        projectName,
+        version: JETSTART_VERSION,
+      });
+
+      res.json({
+        session,
+        qrCode,
+      });
+
+    } catch (err: any) {
+      res.status(500).json({
+        error: 'Failed to create session',
+        message: err.message,
+      });
+    }
+  });
+
+  // Get session
+  app.get('/session/:sessionId', (req: Request, res: Response) => {
+    const session = sessionManager.getSession(req.params.sessionId);
+
+    if (!session) {
+      return res.status(404).json({
+        error: 'Session not found',
+      });
+    }
+
+    res.json(session);
+  });
+
+  // Download APK
+  app.get('/download/:filename', async (req: Request, res: Response) => {
+    // Get latest built APK path
+    const apkPath = getLatestApk?.();
+
+    if (!apkPath) {
+      return res.status(404).json({ error: 'No APK available. Build the app first.' });
+    }
+
+    // Check if file exists
+    if (!fs.existsSync(apkPath)) {
+      return res.status(404).json({ error: 'APK file not found at expected location' });
+    }
+
+    // Send the APK file
+    res.download(apkPath, req.params.filename || 'app-debug.apk', (err) => {
+      if (err) {
+        console.error(`Failed to send APK: ${err.message}`);
+        if (!res.headersSent) {
+          res.status(500).json({ error: 'Failed to send APK file' });
+        }
+      }
+    });
+  });
+
+  // 404 handler
+  app.use((req: Request, res: Response) => {
+    res.status(404).json({
+      error: 'Not found',
+      path: req.path,
+    });
+  });
+}

package/src/types/index.ts

@@ -0,0 +1,21 @@
+/**
+ * Core-specific types
+ */
+
+export interface ServerSession {
+  id: string;
+  token: string;
+  projectName: string;
+  projectPath: string;
+  createdAt: number;
+  lastActivity: number;
+}
+
+export interface QRCodeOptions {
+  sessionId: string;
+  serverUrl: string;
+  wsUrl: string;
+  token: string;
+  projectName: string;
+  version: string;
+}

package/src/utils/index.ts

@@ -0,0 +1,7 @@
+/**
+ * Export all utilities
+ */
+
+export * from './logger';
+export * from './qr';
+export * from './session';

package/src/utils/logger.ts

@@ -0,0 +1,28 @@
+/**
+ * Logger Utility
+ * Colored logging for Core
+ */
+
+import chalk from 'chalk';
+
+export function log(message: string) {
+  console.log(chalk.cyan('[Core]'), message);
+}
+
+export function success(message: string) {
+  console.log(chalk.green('✔'), chalk.cyan('[Core]'), message);
+}
+
+export function error(message: string) {
+  console.error(chalk.red('✖'), chalk.cyan('[Core]'), message);
+}
+
+export function warn(message: string) {
+  console.log(chalk.yellow('⚠'), chalk.cyan('[Core]'), message);
+}
+
+export function debug(message: string) {
+  if (process.env.DEBUG) {
+    console.log(chalk.gray('[DEBUG]'), chalk.cyan('[Core]'), message);
+  }
+}

package/src/utils/qr.ts

@@ -0,0 +1,46 @@
+/**
+ * QR Code Generator
+ * Generates QR codes for device pairing
+ */
+
+import QRCode from 'qrcode';
+import { QRCodeData } from '@jetstart/shared';
+import { QRCodeOptions } from '../types';
+
+export async function generateQRCode(options: QRCodeOptions): Promise<string> {
+  const data: QRCodeData = {
+    sessionId: options.sessionId,
+    serverUrl: options.serverUrl,
+    wsUrl: options.wsUrl,
+    token: options.token,
+    projectName: options.projectName,
+    version: options.version,
+  };
+
+  // Generate QR code as data URL
+  return QRCode.toDataURL(JSON.stringify(data), {
+    errorCorrectionLevel: 'M',
+    type: 'image/png',
+    width: 300,
+  });
+}
+
+export async function generateQRCodeTerminal(options: QRCodeOptions): Promise<void> {
+  const data: QRCodeData = {
+    sessionId: options.sessionId,
+    serverUrl: options.serverUrl,
+    wsUrl: options.wsUrl,
+    token: options.token,
+    projectName: options.projectName,
+    version: options.version,
+  };
+
+  // Generate QR code for terminal
+  return QRCode.toString(JSON.stringify(data), {
+    type: 'terminal',
+    small: true,
+  }, (err, url) => {
+    if (err) throw err;
+    console.log(url);
+  });
+}

package/src/utils/session.ts

@@ -0,0 +1,58 @@
+/**
+ * Session Manager
+ * Manages development sessions
+ */
+
+import { v4 as uuidv4 } from 'uuid';
+import { ServerSession } from '../types';
+import { SESSION_TOKEN_EXPIRY } from '@jetstart/shared';
+
+export class SessionManager {
+  private sessions: Map<string, ServerSession> = new Map();
+
+  async createSession(data: {
+    projectName: string;
+    projectPath: string;
+  }): Promise<ServerSession> {
+    const session: ServerSession = {
+      id: uuidv4(),
+      token: this.generateToken(),
+      projectName: data.projectName,
+      projectPath: data.projectPath,
+      createdAt: Date.now(),
+      lastActivity: Date.now(),
+    };
+
+    this.sessions.set(session.id, session);
+    return session;
+  }
+
+  getSession(sessionId: string): ServerSession | undefined {
+    return this.sessions.get(sessionId);
+  }
+
+  updateActivity(sessionId: string): void {
+    const session = this.sessions.get(sessionId);
+    if (session) {
+      session.lastActivity = Date.now();
+    }
+  }
+
+  deleteSession(sessionId: string): void {
+    this.sessions.delete(sessionId);
+  }
+
+  cleanupExpiredSessions(): void {
+    const now = Date.now();
+    
+    for (const [id, session] of this.sessions.entries()) {
+      if (now - session.lastActivity > SESSION_TOKEN_EXPIRY) {
+        this.sessions.delete(id);
+      }
+    }
+  }
+
+  private generateToken(): string {
+    return uuidv4().replace(/-/g, '');
+  }
+}