@jetstart/core 1.1.1

package/src/websocket/handler.ts

@@ -0,0 +1,150 @@
+/**
+ * WebSocket Message Handler
+ * Processes incoming WebSocket messages
+ */
+
+import {
+  WSMessage,
+  ClientMessage,
+  CoreConnectedMessage,
+  CoreBuildStartMessage,
+  CoreBuildCompleteMessage,
+  CoreUIUpdateMessage,
+} from '@jetstart/shared';
+import { ConnectionManager } from './manager';
+import { log, error as logError } from '../utils/logger';
+
+export class WebSocketHandler {
+  private onClientConnected?: (sessionId: string) => void;
+
+  constructor(
+    private connectionManager: ConnectionManager,
+    options?: { onClientConnected?: (sessionId: string) => void }
+  ) {
+    this.onClientConnected = options?.onClientConnected;
+  }
+
+  handleMessage(clientId: string, data: Buffer): void {
+    try {
+      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}`);
+    }
+  }
+
+  private isClientMessage(message: WSMessage): message is ClientMessage {
+    return message.type.startsWith('client:');
+  }
+
+  private handleClientMessage(clientId: string, message: ClientMessage): void {
+    switch (message.type) {
+      case 'client:connect':
+        this.handleConnect(clientId, message);
+        break;
+      case 'client:status':
+        log(`Client ${clientId} status: ${message.status}`);
+        break;
+      case 'client:log':
+        // Forward to logs service
+        break;
+      case 'client:heartbeat':
+        // Update last activity
+        break;
+      case 'client:disconnect':
+        this.handleDisconnect(clientId, message);
+        break;
+    }
+  }
+
+  private handleConnect(clientId: string, message: ClientMessage & { type: 'client:connect' }): void {
+    log(`Client connecting with session: ${message.sessionId}`);
+
+    // Send connected confirmation
+    const response: CoreConnectedMessage = {
+      type: 'core:connected',
+      timestamp: Date.now(),
+      sessionId: message.sessionId,
+      projectName: 'DemoProject', // In real implementation, get from session
+    };
+
+    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);
+    }
+  }
+
+  private handleDisconnect(clientId: string, message: ClientMessage & { type: 'client:disconnect' }): void {
+    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.broadcast(message);
+  }
+
+  sendBuildComplete(sessionId: string, apkUrl: string): void {
+    const message: CoreBuildCompleteMessage = {
+      type: 'core:build-complete',
+      timestamp: Date.now(),
+      sessionId,
+      apkInfo: {
+        path: '/path/to/app.apk',
+        size: 5242880,
+        hash: 'abc123',
+        versionCode: 1,
+        versionName: '1.0.0',
+        minSdkVersion: 24,
+        targetSdkVersion: 34,
+        applicationId: 'com.example.app',
+      },
+      downloadUrl: apkUrl,
+    };
+
+    this.connectionManager.broadcast(message);
+  }
+
+  /**
+   * Send UI update (DSL-based hot reload)
+   */
+  sendUIUpdate(sessionId: string, dslContent: string, screens?: string[]): void {
+    const message: CoreUIUpdateMessage = {
+      type: 'core:ui-update',
+      timestamp: Date.now(),
+      sessionId,
+      dslContent,
+      screens,
+      hash: this.generateHash(dslContent),
+    };
+
+    log(`Sending UI update: ${dslContent.length} bytes`);
+    log(`DSL Content: ${dslContent}`);
+    this.connectionManager.broadcast(message);
+  }
+
+  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);
+  }
+}

package/src/websocket/index.ts

@@ -0,0 +1,56 @@
+/**
+ * WebSocket Server
+ * Real-time communication with clients
+ */
+
+import { WebSocketServer, WebSocket } from 'ws';
+import { Server } from 'http';
+import { WebSocketHandler } from './handler';
+import { ConnectionManager } from './manager';
+import { log } from '../utils/logger';
+
+export interface WebSocketConfig {
+  port: number;
+  server?: Server;
+  onClientConnected?: (sessionId: string) => void;
+}
+
+export interface WebSocketServerResult {
+  server: WebSocketServer;
+  handler: WebSocketHandler;
+}
+
+export async function createWebSocketServer(config: WebSocketConfig): Promise<WebSocketServerResult> {
+  const wss = new WebSocketServer({
+    port: config.port,
+  });
+
+  const connectionManager = new ConnectionManager();
+  const handler = new WebSocketHandler(connectionManager, {
+    onClientConnected: config.onClientConnected,
+  });
+
+  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);
+    });
+
+    // 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);
+    });
+  });
+
+  log(`WebSocket server listening on port ${config.port}`);
+  return { server: wss, handler };
+}

package/src/websocket/manager.ts

@@ -0,0 +1,63 @@
+/**
+ * Connection Manager
+ * Manages WebSocket connections
+ */
+
+import { WebSocket } from 'ws';
+import { v4 as uuidv4 } from 'uuid';
+import { CoreMessage } from '@jetstart/shared';
+
+export class ConnectionManager {
+  private connections: Map<string, WebSocket> = new Map();
+
+  addConnection(ws: WebSocket): string {
+    const id = uuidv4();
+    this.connections.set(id, ws);
+    return id;
+  }
+
+  removeConnection(id: string): void {
+    this.connections.delete(id);
+  }
+
+  getConnection(id: string): WebSocket | undefined {
+    return this.connections.get(id);
+  }
+
+  sendToClient(clientId: string, message: CoreMessage): boolean {
+    const ws = this.connections.get(clientId);
+    
+    if (!ws || ws.readyState !== WebSocket.OPEN) {
+      return false;
+    }
+
+    try {
+      ws.send(JSON.stringify(message));
+      return true;
+    } catch (err) {
+      console.error(`Failed to send message to ${clientId}:`, err);
+      return false;
+    }
+  }
+
+  broadcast(message: CoreMessage): void {
+    const data = JSON.stringify(message);
+    const connectionCount = Array.from(this.connections.values()).filter(ws => ws.readyState === WebSocket.OPEN).length;
+    console.log(`[ConnectionManager] Broadcasting ${message.type} to ${connectionCount} connected clients`);
+
+    this.connections.forEach((ws, clientId) => {
+      if (ws.readyState === WebSocket.OPEN) {
+        try {
+          ws.send(data);
+          console.log(`[ConnectionManager] Sent ${message.type} to client ${clientId}`);
+        } catch (err) {
+          console.error(`Failed to broadcast to ${clientId}:`, err);
+        }
+      }
+    });
+  }
+
+  getConnectionCount(): number {
+    return this.connections.size;
+  }
+}

package/tests/build.test.ts

@@ -0,0 +1,13 @@
+/**
+ * Tests for build system
+ */
+
+describe('Build System', () => {
+  it('should compile Kotlin project', () => {
+    expect(true).toBe(true);
+  });
+
+  it('should cache build results', () => {
+    expect(true).toBe(true);
+  });
+});

package/tests/server.test.ts

@@ -0,0 +1,13 @@
+/**
+ * Tests for HTTP server
+ */
+
+describe('HTTP Server', () => {
+  it('should start server on specified port', () => {
+    expect(true).toBe(true);
+  });
+
+  it('should handle health check endpoint', () => {
+    expect(true).toBe(true);
+  });
+});

package/tsconfig.json

@@ -0,0 +1,25 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "commonjs",
+    "lib": ["ES2022"],
+    "moduleResolution": "node",
+    "esModuleInterop": true,
+    "allowSyntheticDefaultImports": true,
+    "strict": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "composite": true,
+    "outDir": "./dist",
+    "rootDir": "./src"
+  },
+  "references": [
+    { "path": "../shared" }
+  ],
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist", "tests"]
+}