@jetstart/core 1.7.0 → 2.0.1

package/src/server/index.ts

@@ -4,6 +4,7 @@
  */
 
 import * as path from 'path';
+import * as fs from 'fs';
 import * as os from 'os';
 import { EventEmitter } from 'events';
 import { createHttpServer } from './http';
@@ -14,14 +15,20 @@ 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';
+import { HotReloadService } from '../build/hot-reload-service';
+import { JsCompilerService } from '../build/js-compiler-service';
+import { AdbHelper } from '../build/gradle';
 
 export interface ServerConfig {
   httpPort?: number;
   wsPort?: number;
   host?: string;
   displayHost?: string; // IP address to display in logs/QR codes (for client connections)
+  /** Override the URL injected into BuildConfig for emulator builds. Emulators reach the host at 10.0.2.2, not the local network IP. */
+  emulatorHost?: string;
+  /** Enable web emulator support (initializes kotlinc-js compiler). */
+  webEnabled?: boolean;
   projectPath?: string;
   projectName?: string;
 }
@@ -33,12 +40,18 @@ export class JetStartServer extends EventEmitter {
   private wsServer: any;
   private logsServer: LogsServer;
   private wsHandler: WebSocketHandler | null = null;
-  private config: Required<ServerConfig> & { displayHost: string };
+  private config: Required<Omit<ServerConfig, 'emulatorHost' | 'webEnabled'>> & { displayHost: string; emulatorHost?: string; webEnabled: boolean };
   private sessionManager: SessionManager;
   private buildService: BuildService;
+  private hotReloadService: HotReloadService | null = null;
+  private jsCompiler: JsCompilerService | null = null;
   private currentSession: ServerSession | null = null;
   private buildMutex: boolean = false;  // Prevent concurrent builds
   private latestApkPath: string | null = null;  // Store latest built APK path
+  private useTrueHotReload: boolean = false;  // Use DEX-based hot reload (DISABLED - use APK builds instead)
+  private adbHelper: AdbHelper;  // Auto-install APKs via ADB
+  private autoInstall: boolean = true;  // Auto-install APK after build
+  private isFileChangeBuild: boolean = false;  // Track if build is from file change
 
   constructor(config: ServerConfig = {}) {
     super();
@@ -52,6 +65,8 @@ export class JetStartServer extends EventEmitter {
       displayHost: displayHost,
       projectPath: config.projectPath || process.cwd(),
       projectName: config.projectName || path.basename(config.projectPath || process.cwd()),
+      emulatorHost: config.emulatorHost,
+      webEnabled: config.webEnabled ?? false,
     };
 
     this.sessionManager = new SessionManager();
@@ -61,11 +76,7 @@ export class JetStartServer extends EventEmitter {
       cachePath: path.join(os.tmpdir(), 'jetstart-cache'),
       watchEnabled: true,
     });
-
-    // Hook into logger events
-    // This creates a circular import if we import logger here, but we imported 'log' etc.
-    // We need to import loggerEvents.
-    // The previous tool replacement added loggerEvents export.
+    this.adbHelper = new AdbHelper();
   }
 
   async start(): Promise<ServerSession> {
@@ -93,13 +104,30 @@ export class JetStartServer extends EventEmitter {
       });
 
       // Inject server URL into build.gradle for hot reload
-      const serverUrl = `ws://${this.config.displayHost}:${this.config.wsPort}`;
+      // For Android emulators, use 10.0.2.2 (host gateway) in BuildConfig; physical phones use the network IP
+      const buildConfigHost = this.config.emulatorHost || this.config.displayHost;
+      const serverUrl = `ws://${buildConfigHost}:${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}`);
 
+      // Initialize Hot Reload Service
+      this.hotReloadService = new HotReloadService(this.config.projectPath);
+      if (this.config.webEnabled) {
+        this.jsCompiler = new JsCompilerService();
+      }
+      const envCheck = await this.hotReloadService.checkEnvironment();
+      if (envCheck.ready) {
+        log('🔥 True hot reload enabled (DEX-based)');
+        this.useTrueHotReload = true;
+      } else {
+        log('True hot reload unavailable - file changes will trigger full Gradle builds');
+        log(`Issues: ${envCheck.issues.join(', ')}`);
+        this.useTrueHotReload = false;
+      }
+
       // Start HTTP server
       this.httpServer = await createHttpServer({
         port: this.config.httpPort,
@@ -112,10 +140,21 @@ export class JetStartServer extends EventEmitter {
       const wsResult = await createWebSocketServer({
         port: this.config.wsPort,
         logsServer: this.logsServer,
+        adbHelper: this.adbHelper,  // Enable wireless ADB auto-connect
+        expectedSessionId: this.currentSession?.id,   // Reject old-session devices
+        expectedToken:     this.currentSession?.token, // Validate token too
+        projectName:       this.config.projectName,
         onClientConnected: async (sessionId: string) => {
-          // Trigger initial build when client connects
-          log(`Triggering initial build for connected client (session: ${sessionId})`);
-          await this.handleRebuild();
+          log(`Client connected (session: ${sessionId}). Triggering initial build...`);
+          // If APK already built, just notify this new client - no rebuild needed
+          if (this.latestApkPath && fs.existsSync(this.latestApkPath)) {
+            log(`APK already built, re-sending build complete to new client`);
+            const downloadUrl = `http://${this.config.displayHost}:${this.config.httpPort}/download/app.apk`;
+            this.wsHandler?.sendBuildComplete(sessionId, downloadUrl);
+          } else {
+            this.isFileChangeBuild = false; // Don't auto-install for initial build
+            await this.handleRebuild();
+          }
         },
       });
       this.wsServer = wsResult.server;
@@ -126,25 +165,28 @@ export class JetStartServer extends EventEmitter {
 
       // 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]);
+        log(`Files changed: ${files.map(f => f.split(/[/\\]/).pop()).join(', ')}`);
+
+        // Check if all changed files support hot reload (.kt files that aren't in build directory)
+        const hotReloadFiles = files.filter(f => {
+          const normalized = f.replace(/\\/g, '/');
+          // Support hot reload for all .kt files EXCEPT those in /build/ directory
+          return normalized.endsWith('.kt') &&
+                 !normalized.includes('/build/') &&
+                 !normalized.includes('build.gradle');
+        });
+
+        // Use TRUE hot reload for Kotlin files (sends DEX via WebSocket - no USB needed!)
+        if (hotReloadFiles.length > 0 && hotReloadFiles.length === files.length && this.useTrueHotReload) {
+          log('🔥 Kotlin files changed, using TRUE hot reload (DEX via WebSocket)');
+          for (const file of hotReloadFiles) {
+            await this.handleUIUpdate(file);
+          }
         } else {
-          // Otherwise, full Gradle build
-          log('📦 Non-UI changes detected, triggering full Gradle build');
+          // Build files or mixed changes - use full Gradle build
+          log('📦 Build files changed, triggering Gradle build + ADB install');
           this.buildService.clearCache();
+          this.isFileChangeBuild = true;  // Mark as file change build for auto-install
           await this.handleRebuild();
         }
       });
@@ -202,7 +244,7 @@ export class JetStartServer extends EventEmitter {
       this.emit('build:start');
     });
 
-    this.buildService.on('build:complete', (result) => {
+    this.buildService.on('build:complete', async (result) => {
       success(`Build completed in ${result.buildTime}ms`);
       if (this.wsHandler && this.currentSession) {
         // Store the APK path
@@ -212,6 +254,45 @@ export class JetStartServer extends EventEmitter {
         const downloadUrl = `http://${this.config.displayHost}:${this.config.httpPort}/download/app.apk`;
         this.wsHandler.sendBuildComplete(this.currentSession.id, downloadUrl);
         log(`APK download URL: ${downloadUrl}`);
+
+        // Auto-install APK via ADB only for file change builds (not initial builds)
+        if (this.autoInstall && this.latestApkPath && this.isFileChangeBuild) {
+          const readyDevices = this.adbHelper.getDevices();
+
+          if (readyDevices.length > 0) {
+            log(`📱 Auto-installing APK on ${readyDevices.length} device(s)...`);
+            const installResult = await this.adbHelper.installApk(this.latestApkPath);
+            if (installResult.success) {
+              success('📱 APK auto-installed! App will restart with new code.');
+              // Launch the app
+              // Read actual package name from jetstart.config.json
+              let appPackageName = 'com.example.app';
+              try {
+                const configPath = path.join(this.config.projectPath, 'jetstart.config.json');
+                if (fs.existsSync(configPath)) {
+                  const cfg = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+                  appPackageName = cfg.packageName || appPackageName;
+                }
+              } catch (_) { /* empty */ }
+              await this.adbHelper.launchApp(appPackageName, '.MainActivity');
+            } else {
+              error(`Auto-install failed: ${installResult.error}`);
+            }
+          } else {
+            // Check if devices are connecting
+            const allDevices = this.adbHelper.getAllDeviceStates();
+            if (allDevices.length > 0) {
+              const states = allDevices.map(d => `${d.id} (${d.state})`).join(', ');
+              log(`⏳ Devices found but not ready: ${states}`);
+              log('ℹ️  Device may need user authorization on the phone.');
+              log('ℹ️  Auto-install will retry on the next file change.');
+            } else {
+              log('ℹ️  No devices connected for auto-install. Scan QR or download APK manually.');
+            }
+          }
+          // Reset flag after handling
+          this.isFileChangeBuild = false;
+        }
       }
       // Re-emit for external listeners (e.g., dev command) with result
       this.emit('build:complete', result);
@@ -272,39 +353,66 @@ export class JetStartServer extends EventEmitter {
   }
 
   /**
-   * Handle UI file updates using DSL hot reload (FAST)
+   * Handle UI file updates - uses TRUE hot reload (DEX-based) when available
    */
-  private handleUIUpdate(filePath: string): void {
-    if (!this.currentSession || !this.wsHandler) {
-      return;
-    }
 
+  /**
+   * Compile a .kt file to a browser ES module and broadcast to web clients.
+   * Physical devices use DEX (already sent above). This targets browsers only.
+   */
+  private async sendJsPreview(filePath: string): Promise<void> {
+    if (!this.jsCompiler?.isAvailable() || !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(
+      const result = await this.jsCompiler.compile(filePath);
+      if (result.success && result.jsBase64) {
+        this.wsHandler.sendJsUpdate(
           this.currentSession.id,
-          dslContent,
-          [path.basename(filePath)]
+          result.jsBase64,
+          path.basename(filePath),
+          result.byteSize ?? 0,
+          result.screenFunctionName ?? 'Screen',
         );
-
-        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();
+        log(`[JsCompiler] Web preview skipped: ${result.error?.slice(0, 100)}`);
       }
     } catch (err: any) {
-      error(`UI update failed: ${err.message}`);
-      // Fallback to full build
-      this.handleRebuild();
+      log(`[JsCompiler] Web preview error: ${err.message}`);
+    }
+  }
+
+  private async handleUIUpdate(filePath: string): Promise<void> {
+    if (!this.currentSession || !this.wsHandler) return;
+
+    // TRUE hot reload: compile to DEX and push to device via WebSocket
+    if (this.useTrueHotReload && this.hotReloadService) {
+      try {
+        log(`Hot reloading: ${path.basename(filePath)}...`);
+        const result = await this.hotReloadService.hotReload(filePath);
+
+        if (result.success && result.dexBase64) {
+          this.wsHandler.sendDexReload(
+            this.currentSession.id,
+            result.dexBase64,
+            result.classNames
+          );
+          success(`Hot reload complete! (${result.compileTime + result.dexTime}ms)`);
+          // Run JS compilation in parallel — does not block DEX delivery
+          this.sendJsPreview(filePath).catch(() => {});
+          return;
+        }
+
+        // DEX compilation failed — fall through to full Gradle rebuild
+        error(`Hot reload compile failed: ${result.errors[0] ?? 'unknown'}`);
+        log('Triggering full Gradle rebuild...');
+      } catch (err: any) {
+        error(`Hot reload error: ${err.message}`);
+        log('Triggering full Gradle rebuild...');
+      }
     }
+
+    // Fall back to full Gradle build (catches build-file changes, new dependencies, etc.)
+    this.buildService.clearCache();
+    this.isFileChangeBuild = true;
+    await this.handleRebuild();
   }
 }

package/src/websocket/handler.ts

@@ -1,6 +1,12 @@
 /**
  * WebSocket Message Handler
- * Processes incoming WebSocket messages
+ * Processes incoming WebSocket messages with session + token validation.
+ *
+ * Security model:
+ * - Every connecting client must supply the correct sessionId AND token.
+ * - Both are embedded in the QR code shown by `jetstart dev`.
+ * - A device that was built against a previous session (different token)
+ *   is rejected immediately — it cannot hijack the current dev session.
  */
 
 import {
@@ -9,26 +15,38 @@ import {
   CoreConnectedMessage,
   CoreBuildStartMessage,
   CoreBuildCompleteMessage,
-  CoreUIUpdateMessage,
+  CoreDexReloadMessage,
+  CoreJsUpdateMessage,
 } from '@jetstart/shared';
 import { ConnectionManager } from './manager';
 import { log, error as logError } from '../utils/logger';
-
 import { LogsServer } from '@jetstart/logs';
 
 export class WebSocketHandler {
   private onClientConnected?: (sessionId: string) => void;
   private logsServer?: LogsServer;
+  /** The session ID this server owns — clients must match this exactly. */
+  private expectedSessionId: string;
+  /** The token this server owns — clients must match this exactly. */
+  private expectedToken: string;
+  /** Human-readable project name for the `core:connected` response. */
+  private projectName: string;
 
   constructor(
     private connectionManager: ConnectionManager,
-    options?: { 
+    options?: {
       onClientConnected?: (sessionId: string) => void;
       logsServer?: LogsServer;
+      expectedSessionId?: string;
+      expectedToken?: string;
+      projectName?: string;
     }
   ) {
-    this.onClientConnected = options?.onClientConnected;
-    this.logsServer = options?.logsServer;
+    this.onClientConnected   = options?.onClientConnected;
+    this.logsServer          = options?.logsServer;
+    this.expectedSessionId   = options?.expectedSessionId ?? '';
+    this.expectedToken       = options?.expectedToken ?? '';
+    this.projectName         = options?.projectName ?? 'JetStart Project';
   }
 
   handleMessage(clientId: string, data: Buffer): void {
@@ -36,11 +54,9 @@ export class WebSocketHandler {
       const message: WSMessage = JSON.parse(data.toString());
       log(`Received message from ${clientId}: ${message.type}`);
 
-      // Route message based on type
       if (this.isClientMessage(message)) {
         this.handleClientMessage(clientId, message);
       }
-
     } catch (err: any) {
       logError(`Failed to parse message from ${clientId}: ${err.message}`);
     }
@@ -59,23 +75,19 @@ export class WebSocketHandler {
         log(`Client ${clientId} status: ${message.status}`);
         break;
       case 'client:log':
-        // Add to Logs Server (for CLI/Web Dashboard)
         if (this.logsServer) {
           this.logsServer.addLog(message.log);
         }
-        
-        // Broadcast log to all clients in the session (e.g. Logs Viewer in App)
         if (message.sessionId) {
           this.connectionManager.broadcastToSession(message.sessionId, {
             type: 'core:log',
             timestamp: Date.now(),
             sessionId: message.sessionId,
-            log: message.log
+            log: message.log,
           });
         }
         break;
       case 'client:heartbeat':
-        // Update last activity
         break;
       case 'client:disconnect':
         this.handleDisconnect(clientId, message);
@@ -84,25 +96,54 @@ export class WebSocketHandler {
   }
 
   private handleConnect(clientId: string, message: ClientMessage & { type: 'client:connect' }): void {
-    log(`Client connecting with session: ${message.sessionId}`);
+    const incomingSession = message.sessionId;
+    const incomingToken   = (message as any).token as string | undefined;
+
+    // ── Session + token validation ──────────────────────────────────────────
+    // Only validate when the server has an expected session configured.
+    if (this.expectedSessionId) {
+      if (incomingSession !== this.expectedSessionId) {
+        logError(
+          `Rejected client ${clientId}: wrong session "${incomingSession}" (expected "${this.expectedSessionId}")`
+        );
+        logError('This device was built against a different jetstart dev session. Rescan the QR code.');
+        // Close the WebSocket immediately — do not accept this client.
+        const ws = this.connectionManager.getConnection(clientId);
+        if (ws) {
+          ws.close(4001, 'Session mismatch — rescan QR code');
+        }
+        this.connectionManager.removeConnection(clientId);
+        return;
+      }
+
+      if (this.expectedToken && incomingToken && incomingToken !== this.expectedToken) {
+        logError(
+          `Rejected client ${clientId}: wrong token (session ${incomingSession})`
+        );
+        const ws = this.connectionManager.getConnection(clientId);
+        if (ws) {
+          ws.close(4002, 'Token mismatch — rescan QR code');
+        }
+        this.connectionManager.removeConnection(clientId);
+        return;
+      }
+    }
 
-    // Associate this client with the session for isolation
-    this.connectionManager.setClientSession(clientId, message.sessionId);
+    // ── Accepted ─────────────────────────────────────────────────────────────
+    log(`Client accepted (session: ${incomingSession})`);
+    this.connectionManager.setClientSession(clientId, incomingSession);
 
-    // Send connected confirmation
     const response: CoreConnectedMessage = {
       type: 'core:connected',
       timestamp: Date.now(),
-      sessionId: message.sessionId,
-      projectName: 'DemoProject', // In real implementation, get from session
+      sessionId: incomingSession,
+      projectName: this.projectName,
     };
-
     this.connectionManager.sendToClient(clientId, response);
 
-    // Trigger initial build for the client
     if (this.onClientConnected) {
-      log(`Triggering initial build for session: ${message.sessionId}`);
-      this.onClientConnected(message.sessionId);
+      log(`Triggering initial build for session: ${incomingSession}`);
+      this.onClientConnected(incomingSession);
     }
   }
 
@@ -110,14 +151,12 @@ export class WebSocketHandler {
     log(`Client disconnecting: ${message.reason || 'No reason provided'}`);
   }
 
-  // Send build notifications
   sendBuildStart(sessionId: string): void {
     const message: CoreBuildStartMessage = {
       type: 'core:build-start',
       timestamp: Date.now(),
       sessionId,
     };
-
     this.connectionManager.broadcastToSession(sessionId, message);
   }
 
@@ -138,46 +177,45 @@ export class WebSocketHandler {
       },
       downloadUrl: apkUrl,
     };
-
     this.connectionManager.broadcastToSession(sessionId, message);
   }
 
-  /**
-   * Send UI update (DSL-based hot reload) - SECURE, session-isolated
-   */
-  sendUIUpdate(sessionId: string, dslContent: string, screens?: string[]): void {
-    const message: CoreUIUpdateMessage = {
-      type: 'core:ui-update',
+  sendDexReload(sessionId: string, dexBase64: string, classNames: string[]): void {
+    const message: CoreDexReloadMessage = {
+      type: 'core:dex-reload',
       timestamp: Date.now(),
       sessionId,
-      dslContent,
-      screens,
-      hash: this.generateHash(dslContent),
+      dexBase64,
+      classNames,
     };
-
-    log(`Sending UI update to session ${sessionId}: ${dslContent.length} bytes`);
-    log(`DSL Content: ${dslContent}`);
-    this.connectionManager.broadcastToSession(sessionId, message);
+    log(`Sending DEX reload: ${dexBase64.length} base64 chars, ${classNames.length} classes`);
+    this.connectionManager.broadcastToAll(message as any);
   }
 
-  private generateHash(content: string): string {
-    // Simple hash for caching (in production, use crypto.createHash)
-    let hash = 0;
-    for (let i = 0; i < content.length; i++) {
-      const char = content.charCodeAt(i);
-      hash = ((hash << 5) - hash) + char;
-      hash = hash & hash; // Convert to 32bit integer
-    }
-    return hash.toString(16);
+  /**
+   * Send compiled Kotlin→JS ES module to web emulator clients.
+   * The browser imports it dynamically and renders the Compose UI as HTML.
+   */
+  sendJsUpdate(sessionId: string, jsBase64: string, sourceFile: string, byteSize: number, screenFunctionName: string): void {
+    const message: CoreJsUpdateMessage = {
+      type: 'core:js-update',
+      timestamp: Date.now(),
+      sessionId,
+      jsBase64,
+      sourceFile,
+      byteSize,
+    };
+    log(`Sending JS update: ${sourceFile} (${byteSize} bytes) to web clients`);
+    // Broadcast to all — web clients use it, Android clients ignore unknown types
+    this.connectionManager.broadcastToAll(message as any);
   }
 
-  // Broadcast any log entry to the session
   sendLogBroadcast(sessionId: string, logEntry: any): void {
-      this.connectionManager.broadcastToSession(sessionId, {
-          type: 'core:log',
-          timestamp: Date.now(),
-          sessionId: sessionId,
-          log: logEntry
-      });
+    this.connectionManager.broadcastToSession(sessionId, {
+      type: 'core:log',
+      timestamp: Date.now(),
+      sessionId,
+      log: logEntry,
+    });
   }
-}
+}

package/src/websocket/index.ts

@@ -8,7 +8,7 @@ import { Server } from 'http';
 import { WebSocketHandler } from './handler';
 import { ConnectionManager } from './manager';
 import { log } from '../utils/logger';
-
+import { AdbHelper } from '../build/gradle';
 import { LogsServer } from '@jetstart/logs';
 
 export interface WebSocketConfig {
@@ -16,6 +16,13 @@ export interface WebSocketConfig {
   server?: Server;
   logsServer?: LogsServer;
   onClientConnected?: (sessionId: string) => void;
+  adbHelper?: AdbHelper;
+  /** Session ID this server owns — clients presenting a different ID are rejected. */
+  expectedSessionId?: string;
+  /** Token this server owns — clients presenting a different token are rejected. */
+  expectedToken?: string;
+  /** Project name shown in the core:connected response. */
+  projectName?: string;
 }
 
 export interface WebSocketServerResult {
@@ -24,32 +31,38 @@ export interface WebSocketServerResult {
 }
 
 export async function createWebSocketServer(config: WebSocketConfig): Promise<WebSocketServerResult> {
-  const wss = new WebSocketServer({
-    port: config.port,
-  });
+  const wss = new WebSocketServer({ port: config.port });
 
   const connectionManager = new ConnectionManager();
   const handler = new WebSocketHandler(connectionManager, {
-    logsServer: config.logsServer,
-    onClientConnected: config.onClientConnected,
+    logsServer:         config.logsServer,
+    onClientConnected:  config.onClientConnected,
+    expectedSessionId:  config.expectedSessionId,
+    expectedToken:      config.expectedToken,
+    projectName:        config.projectName,
   });
 
-  wss.on('connection', (ws: WebSocket, _request) => {
+  wss.on('connection', (ws: WebSocket, request) => {
     const clientId = connectionManager.addConnection(ws);
-    log(`WebSocket client connected: ${clientId}`);
 
-    // Handle messages
-    ws.on('message', (data: Buffer) => {
-      handler.handleMessage(clientId, data);
-    });
+    const clientIp = request.socket.remoteAddress || 'unknown';
+    log(`WebSocket client connected: ${clientId} (IP: ${clientIp})`);
+
+    // Auto-connect wireless ADB for real devices
+    if (clientIp && clientIp !== 'localhost' && clientIp !== '127.0.0.1' && clientIp !== '::1') {
+      const cleanIp = clientIp.replace(/^::ffff:/, '');
+      if (config.adbHelper) {
+        process.nextTick(() => config.adbHelper!.connectWireless(cleanIp));
+      }
+    }
+
+    ws.on('message', (data: Buffer) => handler.handleMessage(clientId, data));
 
-    // Handle disconnection
     ws.on('close', () => {
       log(`WebSocket client disconnected: ${clientId}`);
       connectionManager.removeConnection(clientId);
     });
 
-    // Handle errors
     ws.on('error', (err: Error) => {
       console.error(`WebSocket error for ${clientId}:`, err.message);
     });

package/src/websocket/manager.ts

@@ -95,9 +95,9 @@ export class ConnectionManager {
   }
 
   /**
-   * Broadcast to ALL clients regardless of session (use with caution)
+   * Broadcast to ALL clients regardless of session (for dev mode hot reload)
    */
-  private broadcastToAll(message: CoreMessage): void {
+  broadcastToAll(message: CoreMessage): void {
     const data = JSON.stringify(message);
     const connectionCount = Array.from(this.connections.values()).filter(c => c.ws.readyState === WebSocket.OPEN).length;
     console.log(`[ConnectionManager] Broadcasting ${message.type} to ${connectionCount} connected clients`);