@jetstart/core 1.7.0 → 2.0.0

package/dist/server/index.js

@@ -39,6 +39,7 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.JetStartServer = void 0;
 const path = __importStar(require("path"));
+const fs = __importStar(require("fs"));
 const os = __importStar(require("os"));
 const events_1 = require("events");
 const http_1 = require("./http");
@@ -47,8 +48,10 @@ const logger_1 = require("../utils/logger");
 const shared_1 = require("@jetstart/shared");
 const session_1 = require("../utils/session");
 const build_1 = require("../build");
-const dsl_parser_1 = require("../build/dsl-parser");
 const gradle_injector_1 = require("../build/gradle-injector");
+const hot_reload_service_1 = require("../build/hot-reload-service");
+const js_compiler_service_1 = require("../build/js-compiler-service");
+const gradle_1 = require("../build/gradle");
 const logs_1 = require("@jetstart/logs");
 class JetStartServer extends events_1.EventEmitter {
     httpServer;
@@ -58,9 +61,15 @@ class JetStartServer extends events_1.EventEmitter {
     config;
     sessionManager;
     buildService;
+    hotReloadService = null;
+    jsCompiler = null;
     currentSession = null;
     buildMutex = false; // Prevent concurrent builds
     latestApkPath = null; // Store latest built APK path
+    useTrueHotReload = false; // Use DEX-based hot reload (DISABLED - use APK builds instead)
+    adbHelper; // Auto-install APKs via ADB
+    autoInstall = true; // Auto-install APK after build
+    isFileChangeBuild = false; // Track if build is from file change
     constructor(config = {}) {
         super();
         const bindHost = config.host || '0.0.0.0';
@@ -72,6 +81,8 @@ class JetStartServer extends events_1.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 session_1.SessionManager();
         this.logsServer = new logs_1.LogsServer();
@@ -80,10 +91,7 @@ class JetStartServer extends events_1.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 gradle_1.AdbHelper();
     }
     async start() {
         try {
@@ -105,12 +113,29 @@ class JetStartServer extends events_1.EventEmitter {
                 projectPath: this.config.projectPath,
             });
             // 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 (0, gradle_injector_1.injectBuildConfigFields)(this.config.projectPath, [
                 { type: 'String', name: 'JETSTART_SERVER_URL', value: serverUrl },
                 { type: 'String', name: 'JETSTART_SESSION_ID', value: this.currentSession.id }
             ]);
             (0, logger_1.log)(`Injected server URL: ${serverUrl}`);
+            // Initialize Hot Reload Service
+            this.hotReloadService = new hot_reload_service_1.HotReloadService(this.config.projectPath);
+            if (this.config.webEnabled) {
+                this.jsCompiler = new js_compiler_service_1.JsCompilerService();
+            }
+            const envCheck = await this.hotReloadService.checkEnvironment();
+            if (envCheck.ready) {
+                (0, logger_1.log)('🔥 True hot reload enabled (DEX-based)');
+                this.useTrueHotReload = true;
+            }
+            else {
+                (0, logger_1.log)('True hot reload unavailable - file changes will trigger full Gradle builds');
+                (0, logger_1.log)(`Issues: ${envCheck.issues.join(', ')}`);
+                this.useTrueHotReload = false;
+            }
             // Start HTTP server
             this.httpServer = await (0, http_1.createHttpServer)({
                 port: this.config.httpPort,
@@ -122,10 +147,22 @@ class JetStartServer extends events_1.EventEmitter {
             const wsResult = await (0, websocket_1.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) => {
-                    // Trigger initial build when client connects
-                    (0, logger_1.log)(`Triggering initial build for connected client (session: ${sessionId})`);
-                    await this.handleRebuild();
+                    (0, logger_1.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)) {
+                        (0, logger_1.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;
@@ -134,22 +171,27 @@ class JetStartServer extends events_1.EventEmitter {
             this.setupBuildListeners();
             // Start watching for file changes
             this.buildService.startWatching(this.config.projectPath, async (files) => {
-                (0, logger_1.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) {
-                    (0, logger_1.log)('🚀 UI-only changes detected, using DSL hot reload');
-                    this.handleUIUpdate(uiFiles[0]);
+                (0, logger_1.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) {
+                    (0, logger_1.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
-                    (0, logger_1.log)('📦 Non-UI changes detected, triggering full Gradle build');
+                    // Build files or mixed changes - use full Gradle build
+                    (0, logger_1.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();
                 }
             });
@@ -196,7 +238,7 @@ class JetStartServer extends events_1.EventEmitter {
             // Re-emit for external listeners (e.g., dev command)
             this.emit('build:start');
         });
-        this.buildService.on('build:complete', (result) => {
+        this.buildService.on('build:complete', async (result) => {
             (0, logger_1.success)(`Build completed in ${result.buildTime}ms`);
             if (this.wsHandler && this.currentSession) {
                 // Store the APK path
@@ -205,6 +247,47 @@ class JetStartServer extends events_1.EventEmitter {
                 const downloadUrl = `http://${this.config.displayHost}:${this.config.httpPort}/download/app.apk`;
                 this.wsHandler.sendBuildComplete(this.currentSession.id, downloadUrl);
                 (0, logger_1.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) {
+                        (0, logger_1.log)(`📱 Auto-installing APK on ${readyDevices.length} device(s)...`);
+                        const installResult = await this.adbHelper.installApk(this.latestApkPath);
+                        if (installResult.success) {
+                            (0, logger_1.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 {
+                            (0, logger_1.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(', ');
+                            (0, logger_1.log)(`⏳ Devices found but not ready: ${states}`);
+                            (0, logger_1.log)('ℹ️  Device may need user authorization on the phone.');
+                            (0, logger_1.log)('ℹ️  Auto-install will retry on the next file change.');
+                        }
+                        else {
+                            (0, logger_1.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);
@@ -260,34 +343,56 @@ class JetStartServer extends events_1.EventEmitter {
         }
     }
     /**
-     * Handle UI file updates using DSL hot reload (FAST)
+     * Handle UI file updates - uses TRUE hot reload (DEX-based) when available
+     */
+    /**
+     * 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.
      */
-    handleUIUpdate(filePath) {
-        if (!this.currentSession || !this.wsHandler) {
+    async sendJsPreview(filePath) {
+        if (!this.jsCompiler?.isAvailable() || !this.currentSession || !this.wsHandler)
             return;
-        }
         try {
-            (0, logger_1.log)(`Parsing UI file: ${path.basename(filePath)}`);
-            const parseResult = dsl_parser_1.DSLParser.parseFile(filePath);
-            if (parseResult.success && parseResult.dsl) {
-                const dslContent = JSON.stringify(parseResult.dsl);
-                (0, logger_1.log)(`DSL generated: ${dslContent.length} bytes`);
-                // Send DSL update via WebSocket (instant hot reload!)
-                this.wsHandler.sendUIUpdate(this.currentSession.id, dslContent, [path.basename(filePath)]);
-                (0, logger_1.success)(`UI hot reload sent in <100ms ⚡`);
+            const result = await this.jsCompiler.compile(filePath);
+            if (result.success && result.jsBase64) {
+                this.wsHandler.sendJsUpdate(this.currentSession.id, result.jsBase64, path.basename(filePath), result.byteSize ?? 0, result.screenFunctionName ?? 'Screen');
             }
             else {
-                (0, logger_1.error)(`Failed to parse UI file: ${parseResult.errors?.join(', ')}`);
-                // Fallback to full build
-                (0, logger_1.log)('Falling back to full Gradle build...');
-                this.handleRebuild();
+                (0, logger_1.log)(`[JsCompiler] Web preview skipped: ${result.error?.slice(0, 100)}`);
             }
         }
         catch (err) {
-            (0, logger_1.error)(`UI update failed: ${err.message}`);
-            // Fallback to full build
-            this.handleRebuild();
+            (0, logger_1.log)(`[JsCompiler] Web preview error: ${err.message}`);
+        }
+    }
+    async handleUIUpdate(filePath) {
+        if (!this.currentSession || !this.wsHandler)
+            return;
+        // TRUE hot reload: compile to DEX and push to device via WebSocket
+        if (this.useTrueHotReload && this.hotReloadService) {
+            try {
+                (0, logger_1.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);
+                    (0, logger_1.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
+                (0, logger_1.error)(`Hot reload compile failed: ${result.errors[0] ?? 'unknown'}`);
+                (0, logger_1.log)('Triggering full Gradle rebuild...');
+            }
+            catch (err) {
+                (0, logger_1.error)(`Hot reload error: ${err.message}`);
+                (0, logger_1.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();
     }
 }
 exports.JetStartServer = JetStartServer;

package/dist/websocket/handler.d.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 { ConnectionManager } from './manager';
 import { LogsServer } from '@jetstart/logs';
@@ -8,9 +14,18 @@ export declare class WebSocketHandler {
     private connectionManager;
     private onClientConnected?;
     private logsServer?;
+    /** The session ID this server owns — clients must match this exactly. */
+    private expectedSessionId;
+    /** The token this server owns — clients must match this exactly. */
+    private expectedToken;
+    /** Human-readable project name for the `core:connected` response. */
+    private projectName;
     constructor(connectionManager: ConnectionManager, options?: {
         onClientConnected?: (sessionId: string) => void;
         logsServer?: LogsServer;
+        expectedSessionId?: string;
+        expectedToken?: string;
+        projectName?: string;
     });
     handleMessage(clientId: string, data: Buffer): void;
     private isClientMessage;
@@ -19,11 +34,12 @@ export declare class WebSocketHandler {
     private handleDisconnect;
     sendBuildStart(sessionId: string): void;
     sendBuildComplete(sessionId: string, apkUrl: string): void;
+    sendDexReload(sessionId: string, dexBase64: string, classNames: string[]): void;
     /**
-     * Send UI update (DSL-based hot reload) - SECURE, session-isolated
+     * Send compiled Kotlin→JS ES module to web emulator clients.
+     * The browser imports it dynamically and renders the Compose UI as HTML.
      */
-    sendUIUpdate(sessionId: string, dslContent: string, screens?: string[]): void;
-    private generateHash;
+    sendJsUpdate(sessionId: string, jsBase64: string, sourceFile: string, byteSize: number, screenFunctionName: string): void;
     sendLogBroadcast(sessionId: string, logEntry: any): void;
 }
 //# sourceMappingURL=handler.d.ts.map

package/dist/websocket/handler.js

@@ -1,7 +1,13 @@
 "use strict";
 /**
  * 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.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.WebSocketHandler = void 0;
@@ -10,16 +16,24 @@ class WebSocketHandler {
     connectionManager;
     onClientConnected;
     logsServer;
+    /** The session ID this server owns — clients must match this exactly. */
+    expectedSessionId;
+    /** The token this server owns — clients must match this exactly. */
+    expectedToken;
+    /** Human-readable project name for the `core:connected` response. */
+    projectName;
     constructor(connectionManager, options) {
         this.connectionManager = connectionManager;
         this.onClientConnected = options?.onClientConnected;
         this.logsServer = options?.logsServer;
+        this.expectedSessionId = options?.expectedSessionId ?? '';
+        this.expectedToken = options?.expectedToken ?? '';
+        this.projectName = options?.projectName ?? 'JetStart Project';
     }
     handleMessage(clientId, data) {
         try {
             const message = JSON.parse(data.toString());
             (0, logger_1.log)(`Received message from ${clientId}: ${message.type}`);
-            // Route message based on type
             if (this.isClientMessage(message)) {
                 this.handleClientMessage(clientId, message);
             }
@@ -40,22 +54,19 @@ class WebSocketHandler {
                 (0, logger_1.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);
@@ -63,27 +74,50 @@ class WebSocketHandler {
         }
     }
     handleConnect(clientId, message) {
-        (0, logger_1.log)(`Client connecting with session: ${message.sessionId}`);
-        // Associate this client with the session for isolation
-        this.connectionManager.setClientSession(clientId, message.sessionId);
-        // Send connected confirmation
+        const incomingSession = message.sessionId;
+        const incomingToken = message.token;
+        // ── Session + token validation ──────────────────────────────────────────
+        // Only validate when the server has an expected session configured.
+        if (this.expectedSessionId) {
+            if (incomingSession !== this.expectedSessionId) {
+                (0, logger_1.error)(`Rejected client ${clientId}: wrong session "${incomingSession}" (expected "${this.expectedSessionId}")`);
+                (0, logger_1.error)('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) {
+                (0, logger_1.error)(`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;
+            }
+        }
+        // ── Accepted ─────────────────────────────────────────────────────────────
+        (0, logger_1.log)(`Client accepted (session: ${incomingSession})`);
+        this.connectionManager.setClientSession(clientId, incomingSession);
         const response = {
             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) {
-            (0, logger_1.log)(`Triggering initial build for session: ${message.sessionId}`);
-            this.onClientConnected(message.sessionId);
+            (0, logger_1.log)(`Triggering initial build for session: ${incomingSession}`);
+            this.onClientConnected(incomingSession);
         }
     }
     handleDisconnect(clientId, message) {
         (0, logger_1.log)(`Client disconnecting: ${message.reason || 'No reason provided'}`);
     }
-    // Send build notifications
     sendBuildStart(sessionId) {
         const message = {
             type: 'core:build-start',
@@ -111,39 +145,40 @@ class WebSocketHandler {
         };
         this.connectionManager.broadcastToSession(sessionId, message);
     }
+    sendDexReload(sessionId, dexBase64, classNames) {
+        const message = {
+            type: 'core:dex-reload',
+            timestamp: Date.now(),
+            sessionId,
+            dexBase64,
+            classNames,
+        };
+        (0, logger_1.log)(`Sending DEX reload: ${dexBase64.length} base64 chars, ${classNames.length} classes`);
+        this.connectionManager.broadcastToAll(message);
+    }
     /**
-     * Send UI update (DSL-based hot reload) - SECURE, session-isolated
+     * Send compiled Kotlin→JS ES module to web emulator clients.
+     * The browser imports it dynamically and renders the Compose UI as HTML.
      */
-    sendUIUpdate(sessionId, dslContent, screens) {
+    sendJsUpdate(sessionId, jsBase64, sourceFile, byteSize, screenFunctionName) {
         const message = {
-            type: 'core:ui-update',
+            type: 'core:js-update',
             timestamp: Date.now(),
             sessionId,
-            dslContent,
-            screens,
-            hash: this.generateHash(dslContent),
+            jsBase64,
+            sourceFile,
+            byteSize,
         };
-        (0, logger_1.log)(`Sending UI update to session ${sessionId}: ${dslContent.length} bytes`);
-        (0, logger_1.log)(`DSL Content: ${dslContent}`);
-        this.connectionManager.broadcastToSession(sessionId, message);
+        (0, logger_1.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);
     }
-    generateHash(content) {
-        // 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);
-    }
-    // Broadcast any log entry to the session
     sendLogBroadcast(sessionId, logEntry) {
         this.connectionManager.broadcastToSession(sessionId, {
             type: 'core:log',
             timestamp: Date.now(),
-            sessionId: sessionId,
-            log: logEntry
+            sessionId,
+            log: logEntry,
         });
     }
 }

package/dist/websocket/index.d.ts

@@ -5,12 +5,20 @@
 import { WebSocketServer } from 'ws';
 import { Server } from 'http';
 import { WebSocketHandler } from './handler';
+import { AdbHelper } from '../build/gradle';
 import { LogsServer } from '@jetstart/logs';
 export interface WebSocketConfig {
     port: number;
     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 {
     server: WebSocketServer;

package/dist/websocket/index.js

@@ -10,27 +10,31 @@ const handler_1 = require("./handler");
 const manager_1 = require("./manager");
 const logger_1 = require("../utils/logger");
 async function createWebSocketServer(config) {
-    const wss = new ws_1.WebSocketServer({
-        port: config.port,
-    });
+    const wss = new ws_1.WebSocketServer({ port: config.port });
     const connectionManager = new manager_1.ConnectionManager();
     const handler = new handler_1.WebSocketHandler(connectionManager, {
         logsServer: config.logsServer,
         onClientConnected: config.onClientConnected,
+        expectedSessionId: config.expectedSessionId,
+        expectedToken: config.expectedToken,
+        projectName: config.projectName,
     });
-    wss.on('connection', (ws, _request) => {
+    wss.on('connection', (ws, request) => {
         const clientId = connectionManager.addConnection(ws);
-        (0, logger_1.log)(`WebSocket client connected: ${clientId}`);
-        // Handle messages
-        ws.on('message', (data) => {
-            handler.handleMessage(clientId, data);
-        });
-        // Handle disconnection
+        const clientIp = request.socket.remoteAddress || 'unknown';
+        (0, logger_1.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) => handler.handleMessage(clientId, data));
         ws.on('close', () => {
             (0, logger_1.log)(`WebSocket client disconnected: ${clientId}`);
             connectionManager.removeConnection(clientId);
         });
-        // Handle errors
         ws.on('error', (err) => {
             console.error(`WebSocket error for ${clientId}:`, err.message);
         });

package/dist/websocket/manager.d.ts

@@ -24,9 +24,9 @@ export declare class ConnectionManager {
      */
     broadcastToSession(sessionId: string, message: CoreMessage): void;
     /**
-     * Broadcast to ALL clients regardless of session (use with caution)
+     * Broadcast to ALL clients regardless of session (for dev mode hot reload)
      */
-    private broadcastToAll;
+    broadcastToAll(message: CoreMessage): void;
     getConnectionCount(): number;
 }
 //# sourceMappingURL=manager.d.ts.map

package/dist/websocket/manager.js

@@ -80,7 +80,7 @@ class ConnectionManager {
         }
     }
     /**
-     * Broadcast to ALL clients regardless of session (use with caution)
+     * Broadcast to ALL clients regardless of session (for dev mode hot reload)
      */
     broadcastToAll(message) {
         const data = JSON.stringify(message);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jetstart/core",
-  "version": "1.7.0",
+  "version": "2.0.0",
   "description": "Build server and orchestration for JetStart",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -33,8 +33,8 @@
   },
   "homepage": "https://github.com/dev-phantom/jetstart#readme",
   "dependencies": {
-    "@jetstart/shared": "^1.7.0",
-    "@jetstart/logs": "^1.7.0",
+    "@jetstart/shared": "^2.0.0",
+    "@jetstart/logs": "^2.0.0",
     "express": "^4.18.2",
     "ws": "^8.14.2",
     "chokidar": "^3.5.3",