@jetstart/shared 1.1.1

package/src/utils/validation.ts

@@ -0,0 +1,115 @@
+/**
+ * Validation Utilities
+ * Common validation functions used across packages
+ */
+
+import { QRCodeData, SessionToken, DeviceInfo } from '../types';
+
+/**
+ * Validate session ID format
+ */
+export function isValidSessionId(sessionId: string): boolean {
+  return /^[a-zA-Z0-9-_]{8,64}$/.test(sessionId);
+}
+
+/**
+ * Validate token format
+ */
+export function isValidToken(token: string): boolean {
+  return /^[a-zA-Z0-9-_]{16,128}$/.test(token);
+}
+
+/**
+ * Validate project name
+ */
+export function isValidProjectName(name: string): boolean {
+  return /^[a-zA-Z][a-zA-Z0-9-_]{0,63}$/.test(name);
+}
+
+/**
+ * Validate package name (Android)
+ */
+export function isValidPackageName(packageName: string): boolean {
+  return /^[a-z][a-z0-9_]*(\.[a-z][a-z0-9_]*)+$/.test(packageName);
+}
+
+/**
+ * Validate port number
+ */
+export function isValidPort(port: number): boolean {
+  return Number.isInteger(port) && port >= 1024 && port <= 65535;
+}
+
+/**
+ * Validate URL format
+ */
+export function isValidUrl(url: string): boolean {
+  try {
+    new URL(url);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Validate QR code data structure
+ */
+export function isValidQRCodeData(data: any): data is QRCodeData {
+  return (
+    data !== null &&
+    typeof data === 'object' &&
+    isValidSessionId(data.sessionId) &&
+    isValidUrl(data.serverUrl) &&
+    isValidUrl(data.wsUrl) &&
+    isValidToken(data.token) &&
+    typeof data.projectName === 'string' &&
+    typeof data.version === 'string'
+  );
+}
+
+/**
+ * Validate session token structure
+ */
+export function isValidSessionToken(token: any): token is SessionToken {
+  return (
+    token !== null &&
+    typeof token === 'object' &&
+    isValidSessionId(token.sessionId) &&
+    isValidToken(token.token) &&
+    typeof token.expiresAt === 'number' &&
+    isValidUrl(token.serverUrl) &&
+    isValidUrl(token.wsUrl)
+  );
+}
+
+/**
+ * Validate device info structure
+ */
+export function isValidDeviceInfo(info: any): info is DeviceInfo {
+  return (
+    info !== null &&
+    typeof info === 'object' &&
+    typeof info.id === 'string' &&
+    typeof info.name === 'string' &&
+    typeof info.model === 'string' &&
+    typeof info.manufacturer === 'string' &&
+    typeof info.platform === 'string' &&
+    typeof info.osVersion === 'string' &&
+    typeof info.apiLevel === 'number'
+  );
+}
+
+/**
+ * Sanitize user input
+ */
+export function sanitizeInput(input: string): string {
+  return input.trim().replace(/[<>]/g, '');
+}
+
+/**
+ * Validate version string (semver)
+ */
+export function isValidVersion(version: string): boolean {
+  return /^\d+\.\d+\.\d+(-[a-zA-Z0-9.-]+)?$/.test(version);
+}

package/tests/protocols.test.ts

@@ -0,0 +1,121 @@
+/**
+ * Tests for protocol definitions
+ */
+
+import {
+  WSState,
+  WSErrorCode,
+  ClientConnectMessage,
+  CoreConnectedMessage,
+  CoreBuildCompleteMessage,
+} from '../src/protocols/websocket';
+import { Platform, Architecture } from '../src/types';
+
+describe('WebSocket Protocol', () => {
+  describe('WSState enum', () => {
+    it('should have correct state values', () => {
+      expect(WSState.CONNECTING).toBe('connecting');
+      expect(WSState.CONNECTED).toBe('connected');
+      expect(WSState.DISCONNECTING).toBe('disconnecting');
+      expect(WSState.DISCONNECTED).toBe('disconnected');
+      expect(WSState.ERROR).toBe('error');
+    });
+  });
+
+  describe('WSErrorCode enum', () => {
+    it('should have correct error codes', () => {
+      expect(WSErrorCode.CONNECTION_FAILED).toBe('connection_failed');
+      expect(WSErrorCode.AUTHENTICATION_FAILED).toBe('authentication_failed');
+      expect(WSErrorCode.TIMEOUT).toBe('timeout');
+      expect(WSErrorCode.INVALID_MESSAGE).toBe('invalid_message');
+      expect(WSErrorCode.SESSION_EXPIRED).toBe('session_expired');
+      expect(WSErrorCode.UNKNOWN).toBe('unknown');
+    });
+  });
+
+  describe('Message structures', () => {
+    it('should create valid ClientConnectMessage', () => {
+      const message: ClientConnectMessage = {
+        type: 'client:connect',
+        timestamp: Date.now(),
+        sessionId: 'session12345',
+        token: 'token1234567890abc',
+        deviceInfo: {
+          id: 'device123',
+          name: 'Pixel 6',
+          model: 'Pixel 6',
+          manufacturer: 'Google',
+          platform: Platform.ANDROID,
+          osVersion: '14',
+          apiLevel: 34,
+          screenResolution: { width: 1080, height: 2400 },
+          density: 3.0,
+          isEmulator: false,
+          architecture: Architecture.ARM64_V8A,
+          locale: 'en-US',
+          timezone: 'America/New_York',
+        },
+      };
+
+      expect(message.type).toBe('client:connect');
+      expect(message.sessionId).toBe('session12345');
+      expect(message.deviceInfo.platform).toBe(Platform.ANDROID);
+    });
+
+    it('should create valid CoreConnectedMessage', () => {
+      const message: CoreConnectedMessage = {
+        type: 'core:connected',
+        timestamp: Date.now(),
+        sessionId: 'session12345',
+        projectName: 'MyProject',
+      };
+
+      expect(message.type).toBe('core:connected');
+      expect(message.sessionId).toBe('session12345');
+      expect(message.projectName).toBe('MyProject');
+    });
+
+    it('should create valid CoreBuildCompleteMessage', () => {
+      const message: CoreBuildCompleteMessage = {
+        type: 'core:build-complete',
+        timestamp: Date.now(),
+        sessionId: 'session12345',
+        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: 'http://localhost:8765/download/app.apk',
+      };
+
+      expect(message.type).toBe('core:build-complete');
+      expect(message.apkInfo.size).toBe(5242880);
+      expect(message.downloadUrl).toContain('/download/');
+    });
+  });
+
+  describe('Message type guards', () => {
+    it('should identify message types by type field', () => {
+      const connectMessage = {
+        type: 'client:connect',
+        timestamp: Date.now(),
+      };
+
+      expect(connectMessage.type).toBe('client:connect');
+      expect(connectMessage.type.startsWith('client:')).toBe(true);
+
+      const coreMessage = {
+        type: 'core:build-start',
+        timestamp: Date.now(),
+      };
+
+      expect(coreMessage.type).toBe('core:build-start');
+      expect(coreMessage.type.startsWith('core:')).toBe(true);
+    });
+  });
+});

package/tests/setup.ts

@@ -0,0 +1,16 @@
+/**
+ * Test setup and global configuration
+ */
+
+// Mock console methods to reduce noise in tests
+global.console = {
+  ...console,
+  log: jest.fn(),
+  debug: jest.fn(),
+  info: jest.fn(),
+  warn: jest.fn(),
+  error: jest.fn(),
+};
+
+// Set test timeout
+jest.setTimeout(10000);

package/tests/types.test.ts

@@ -0,0 +1,103 @@
+/**
+ * Tests for type definitions and enums
+ */
+
+import {
+  SessionStatus,
+  ConnectionType,
+  Platform,
+  Architecture,
+  NetworkType,
+  BuildType,
+  ErrorSeverity,
+  BuildPhase,
+  LogLevel,
+  LogSource,
+} from '../src/types';
+
+describe('Type Definitions', () => {
+  describe('Enums', () => {
+    it('should have correct SessionStatus values', () => {
+      expect(SessionStatus.PENDING).toBe('pending');
+      expect(SessionStatus.CONNECTED).toBe('connected');
+      expect(SessionStatus.BUILDING).toBe('building');
+      expect(SessionStatus.READY).toBe('ready');
+      expect(SessionStatus.ERROR).toBe('error');
+      expect(SessionStatus.DISCONNECTED).toBe('disconnected');
+    });
+
+    it('should have correct ConnectionType values', () => {
+      expect(ConnectionType.MINIMAL).toBe('minimal');
+      expect(ConnectionType.FASTER).toBe('faster');
+    });
+
+    it('should have correct Platform values', () => {
+      expect(Platform.ANDROID).toBe('android');
+      expect(Platform.WEB).toBe('web');
+    });
+
+    it('should have correct Architecture values', () => {
+      expect(Architecture.ARM64_V8A).toBe('arm64-v8a');
+      expect(Architecture.ARMEABI_V7A).toBe('armeabi-v7a');
+      expect(Architecture.X86).toBe('x86');
+      expect(Architecture.X86_64).toBe('x86_64');
+    });
+
+    it('should have correct NetworkType values', () => {
+      expect(NetworkType.WIFI).toBe('wifi');
+      expect(NetworkType.CELLULAR).toBe('cellular');
+      expect(NetworkType.ETHERNET).toBe('ethernet');
+      expect(NetworkType.UNKNOWN).toBe('unknown');
+    });
+
+    it('should have correct BuildType values', () => {
+      expect(BuildType.DEBUG).toBe('debug');
+      expect(BuildType.RELEASE).toBe('release');
+    });
+
+    it('should have correct ErrorSeverity values', () => {
+      expect(ErrorSeverity.ERROR).toBe('error');
+      expect(ErrorSeverity.WARNING).toBe('warning');
+      expect(ErrorSeverity.INFO).toBe('info');
+    });
+
+    it('should have correct BuildPhase values', () => {
+      expect(BuildPhase.IDLE).toBe('idle');
+      expect(BuildPhase.INITIALIZING).toBe('initializing');
+      expect(BuildPhase.COMPILING).toBe('compiling');
+      expect(BuildPhase.PACKAGING).toBe('packaging');
+      expect(BuildPhase.SIGNING).toBe('signing');
+      expect(BuildPhase.OPTIMIZING).toBe('optimizing');
+      expect(BuildPhase.COMPLETE).toBe('complete');
+      expect(BuildPhase.FAILED).toBe('failed');
+    });
+
+    it('should have correct LogLevel values', () => {
+      expect(LogLevel.VERBOSE).toBe('verbose');
+      expect(LogLevel.DEBUG).toBe('debug');
+      expect(LogLevel.INFO).toBe('info');
+      expect(LogLevel.WARN).toBe('warn');
+      expect(LogLevel.ERROR).toBe('error');
+      expect(LogLevel.FATAL).toBe('fatal');
+    });
+
+    it('should have correct LogSource values', () => {
+      expect(LogSource.CLI).toBe('cli');
+      expect(LogSource.CORE).toBe('core');
+      expect(LogSource.CLIENT).toBe('client');
+      expect(LogSource.BUILD).toBe('build');
+      expect(LogSource.NETWORK).toBe('network');
+      expect(LogSource.SYSTEM).toBe('system');
+    });
+  });
+
+  describe('Type Guards', () => {
+    it('should correctly identify enum values', () => {
+      const status: SessionStatus = SessionStatus.CONNECTED;
+      expect(Object.values(SessionStatus)).toContain(status);
+
+      const invalidStatus = 'invalid' as any;
+      expect(Object.values(SessionStatus)).not.toContain(invalidStatus);
+    });
+  });
+});

package/tests/validation.test.ts

@@ -0,0 +1,226 @@
+/**
+ * Tests for validation utilities
+ */
+
+import {
+  isValidSessionId,
+  isValidToken,
+  isValidProjectName,
+  isValidPackageName,
+  isValidPort,
+  isValidUrl,
+  isValidQRCodeData,
+  isValidSessionToken,
+  isValidDeviceInfo,
+  sanitizeInput,
+  isValidVersion,
+} from '../src/utils/validation';
+import { Platform, Architecture } from '../src/types';
+
+describe('Validation Utilities', () => {
+  describe('isValidSessionId', () => {
+    it('should accept valid session IDs', () => {
+      expect(isValidSessionId('abc12345')).toBe(true);
+      expect(isValidSessionId('session-123-abc')).toBe(true);
+      expect(isValidSessionId('ABC_123_xyz')).toBe(true);
+      expect(isValidSessionId('a'.repeat(64))).toBe(true);
+    });
+
+    it('should reject invalid session IDs', () => {
+      expect(isValidSessionId('short')).toBe(false); // Too short
+      expect(isValidSessionId('a'.repeat(65))).toBe(false); // Too long
+      expect(isValidSessionId('invalid@session')).toBe(false); // Invalid char
+      expect(isValidSessionId('spaces not allowed')).toBe(false);
+      expect(isValidSessionId('')).toBe(false); // Empty
+    });
+  });
+
+  describe('isValidToken', () => {
+    it('should accept valid tokens', () => {
+      expect(isValidToken('a'.repeat(16))).toBe(true);
+      expect(isValidToken('token-123-abc-xyz')).toBe(true);
+      expect(isValidToken('a'.repeat(128))).toBe(true);
+    });
+
+    it('should reject invalid tokens', () => {
+      expect(isValidToken('short')).toBe(false); // Too short
+      expect(isValidToken('a'.repeat(129))).toBe(false); // Too long
+      expect(isValidToken('invalid@token')).toBe(false); // Invalid char
+      expect(isValidToken('')).toBe(false); // Empty
+    });
+  });
+
+  describe('isValidProjectName', () => {
+    it('should accept valid project names', () => {
+      expect(isValidProjectName('myApp')).toBe(true);
+      expect(isValidProjectName('MyProject123')).toBe(true);
+      expect(isValidProjectName('test-app')).toBe(true);
+      expect(isValidProjectName('app_name')).toBe(true);
+    });
+
+    it('should reject invalid project names', () => {
+      expect(isValidProjectName('123app')).toBe(false); // Starts with number
+      expect(isValidProjectName('-myapp')).toBe(false); // Starts with hyphen
+      expect(isValidProjectName('my app')).toBe(false); // Contains space
+      expect(isValidProjectName('app@name')).toBe(false); // Invalid char
+      expect(isValidProjectName('')).toBe(false); // Empty
+      expect(isValidProjectName('a'.repeat(65))).toBe(false); // Too long
+    });
+  });
+
+  describe('isValidPackageName', () => {
+    it('should accept valid package names', () => {
+      expect(isValidPackageName('com.example.app')).toBe(true);
+      expect(isValidPackageName('com.mycompany.myapp')).toBe(true);
+      expect(isValidPackageName('org.jetstart.client')).toBe(true);
+    });
+
+    it('should reject invalid package names', () => {
+      expect(isValidPackageName('com.Example.app')).toBe(false); // Uppercase
+      expect(isValidPackageName('singlename')).toBe(false); // No dots
+      expect(isValidPackageName('com..app')).toBe(false); // Double dot
+      expect(isValidPackageName('123.example.app')).toBe(false); // Starts with number
+      expect(isValidPackageName('')).toBe(false); // Empty
+    });
+  });
+
+  describe('isValidPort', () => {
+    it('should accept valid ports', () => {
+      expect(isValidPort(1024)).toBe(true);
+      expect(isValidPort(8080)).toBe(true);
+      expect(isValidPort(65535)).toBe(true);
+    });
+
+    it('should reject invalid ports', () => {
+      expect(isValidPort(0)).toBe(false);
+      expect(isValidPort(1023)).toBe(false); // Too low
+      expect(isValidPort(65536)).toBe(false); // Too high
+      expect(isValidPort(8080.5)).toBe(false); // Not integer
+      expect(isValidPort(-1)).toBe(false); // Negative
+    });
+  });
+
+  describe('isValidUrl', () => {
+    it('should accept valid URLs', () => {
+      expect(isValidUrl('http://localhost:8080')).toBe(true);
+      expect(isValidUrl('https://example.com')).toBe(true);
+      expect(isValidUrl('ws://192.168.1.1:8765')).toBe(true);
+      expect(isValidUrl('wss://jetstart.dev/ws')).toBe(true);
+    });
+
+    it('should reject invalid URLs', () => {
+      expect(isValidUrl('not-a-url')).toBe(false);
+      expect(isValidUrl('ftp://invalid')).toBe(true); // Actually valid URL format
+      expect(isValidUrl('')).toBe(false);
+      expect(isValidUrl('http://')).toBe(false);
+    });
+  });
+
+  describe('isValidQRCodeData', () => {
+    const validQRData = {
+      sessionId: 'session12345',
+      serverUrl: 'http://localhost:8765',
+      wsUrl: 'ws://localhost:8766',
+      token: 'token1234567890abc',
+      projectName: 'MyProject',
+      version: '0.1.0',
+    };
+
+    it('should accept valid QR code data', () => {
+      expect(isValidQRCodeData(validQRData)).toBe(true);
+    });
+
+    it('should reject invalid QR code data', () => {
+      expect(isValidQRCodeData({ ...validQRData, sessionId: 'bad' })).toBe(false);
+      expect(isValidQRCodeData({ ...validQRData, serverUrl: 'not-url' })).toBe(false);
+      expect(isValidQRCodeData({ ...validQRData, token: 'short' })).toBe(false);
+      expect(isValidQRCodeData(null)).toBe(false);
+      expect(isValidQRCodeData({})).toBe(false);
+    });
+  });
+
+  describe('isValidSessionToken', () => {
+    const validToken = {
+      sessionId: 'session12345',
+      token: 'token1234567890abc',
+      expiresAt: Date.now() + 3600000,
+      serverUrl: 'http://localhost:8765',
+      wsUrl: 'ws://localhost:8766',
+    };
+
+    it('should accept valid session tokens', () => {
+      expect(isValidSessionToken(validToken)).toBe(true);
+    });
+
+    it('should reject invalid session tokens', () => {
+      expect(isValidSessionToken({ ...validToken, sessionId: 'bad' })).toBe(false);
+      expect(isValidSessionToken({ ...validToken, token: 'short' })).toBe(false);
+      expect(isValidSessionToken({ ...validToken, expiresAt: 'not-number' })).toBe(false);
+      expect(isValidSessionToken(null)).toBe(false);
+    });
+  });
+
+  describe('isValidDeviceInfo', () => {
+    const validDevice = {
+      id: 'device123',
+      name: 'Pixel 6',
+      model: 'Pixel 6',
+      manufacturer: 'Google',
+      platform: Platform.ANDROID,
+      osVersion: '14',
+      apiLevel: 34,
+      screenResolution: { width: 1080, height: 2400 },
+      density: 3.0,
+      isEmulator: false,
+      architecture: Architecture.ARM64_V8A,
+      locale: 'en-US',
+      timezone: 'America/New_York',
+    };
+
+    it('should accept valid device info', () => {
+      expect(isValidDeviceInfo(validDevice)).toBe(true);
+    });
+
+    it('should reject invalid device info', () => {
+      expect(isValidDeviceInfo({ ...validDevice, id: 123 })).toBe(false);
+      expect(isValidDeviceInfo({ ...validDevice, apiLevel: '34' })).toBe(false);
+      expect(isValidDeviceInfo(null)).toBe(false);
+      expect(isValidDeviceInfo({})).toBe(false);
+    });
+  });
+
+  describe('sanitizeInput', () => {
+    it('should trim whitespace', () => {
+      expect(sanitizeInput('  hello  ')).toBe('hello');
+      expect(sanitizeInput('\nhello\n')).toBe('hello');
+    });
+
+    it('should remove dangerous characters', () => {
+      expect(sanitizeInput('<script>alert("xss")</script>')).toBe('scriptalert("xss")/script');
+      expect(sanitizeInput('hello<>world')).toBe('helloworld');
+    });
+
+    it('should handle empty strings', () => {
+      expect(sanitizeInput('')).toBe('');
+      expect(sanitizeInput('   ')).toBe('');
+    });
+  });
+
+  describe('isValidVersion', () => {
+    it('should accept valid semantic versions', () => {
+      expect(isValidVersion('0.1.0')).toBe(true);
+      expect(isValidVersion('1.0.0')).toBe(true);
+      expect(isValidVersion('2.3.4')).toBe(true);
+      expect(isValidVersion('1.0.0-alpha')).toBe(true);
+      expect(isValidVersion('1.0.0-beta.1')).toBe(true);
+    });
+
+    it('should reject invalid versions', () => {
+      expect(isValidVersion('1.0')).toBe(false);
+      expect(isValidVersion('v1.0.0')).toBe(false);
+      expect(isValidVersion('1.0.0.0')).toBe(false);
+      expect(isValidVersion('abc')).toBe(false);
+      expect(isValidVersion('')).toBe(false);
+    });
+  });
+});

package/tsconfig.json

@@ -0,0 +1,22 @@
+{
+  "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"
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist", "tests"]
+}