modd-network 1.0.0

package/README.md

@@ -0,0 +1,41 @@
+# MODD Network SDK
+
+The official SDK for connecting to the MODD mesh network for multiplayer applications.
+
+## Installation
+
+```bash
+npm install modd-network
+```
+
+## Usage
+
+```typescript
+import { MODD } from 'modd-network';
+
+// Initialize the client
+const client = new MODD('your-app-id', {
+  centralServiceUrl: 'ws://your-central-service.com', // Optional
+});
+
+// Create a room
+await client.createRoom('my-room-id', { level: 1, score: 0 });
+
+// Or join a room
+await client.joinRoom('my-room-id');
+
+// Listen for inputs
+client.onInput((input) => {
+  console.log('Received input:', input);
+});
+
+// Send input
+client.sendInput({ x: 10, y: 20 });
+```
+
+## Features
+
+- Room creation and joining
+- Real-time input synchronization with sequencing
+- Snapshot state management
+- Mesh network connectivity

package/dist/index.d.ts

@@ -0,0 +1,37 @@
+export interface MODDOptions {
+    centralServiceUrl?: string;
+    nodeUrl?: string;
+}
+export interface OrderedInput {
+    data: any;
+    sequenceNumber: number;
+    timestamp: number;
+    clientId: string;
+    id: string;
+}
+export type InputHandler = (input: OrderedInput) => void;
+export type SnapshotHandler = (snapshot: any) => void;
+export declare class MODD {
+    private ws;
+    private roomId;
+    private appId;
+    private centralServiceUrl;
+    private nodeUrl;
+    private snapshot;
+    private inputHandlers;
+    private snapshotHandlers;
+    constructor(appId: string, options?: MODDOptions);
+    createRoom(roomId: string, initialSnapshot: any): Promise<void>;
+    joinRoom(roomId: string): Promise<void>;
+    private setupMessageHandlers;
+    sendInput(data: any): void;
+    sendSnapshot(snapshot: any): void;
+    onInput(handler: InputHandler): void;
+    onSnapshot(handler: SnapshotHandler): void;
+    getSnapshot(): any;
+    disconnect(): void;
+    private getNodeUrl;
+    private hashSnapshot;
+}
+export declare class MeshClient extends MODD {
+}

package/dist/index.js

@@ -0,0 +1,177 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MeshClient = exports.MODD = void 0;
+const ws_1 = __importDefault(require("ws"));
+const crypto_1 = __importDefault(require("crypto"));
+// Primary SDK client: MODD
+class MODD {
+    ws = null;
+    roomId = null;
+    appId = null;
+    centralServiceUrl;
+    nodeUrl = null;
+    snapshot = null;
+    inputHandlers = [];
+    snapshotHandlers = [];
+    constructor(appId, options = {}) {
+        this.appId = appId;
+        this.centralServiceUrl = options.centralServiceUrl || 'ws://localhost:9001';
+        this.nodeUrl = options.nodeUrl || null;
+    }
+    async createRoom(roomId, initialSnapshot) {
+        if (!this.appId) {
+            throw new Error('appId is required. Initialize MODD with appId in constructor.');
+        }
+        this.roomId = roomId;
+        this.snapshot = initialSnapshot;
+        const nodeUrl = this.nodeUrl || await this.getNodeUrl(roomId);
+        return new Promise((resolve, reject) => {
+            this.ws = new ws_1.default(nodeUrl);
+            this.ws.on('open', () => {
+                this.ws.send(JSON.stringify({
+                    type: 'CREATE_ROOM',
+                    payload: { roomId, appId: this.appId, snapshot: initialSnapshot }
+                }));
+            });
+            this.ws.on('message', (data) => {
+                const message = JSON.parse(data.toString());
+                if (message.type === 'ROOM_CREATED') {
+                    console.log('Room created:', roomId);
+                    this.setupMessageHandlers();
+                    resolve();
+                }
+            });
+            this.ws.on('error', reject);
+        });
+    }
+    async joinRoom(roomId) {
+        if (!this.appId) {
+            throw new Error('appId is required. Initialize MODD with appId in constructor.');
+        }
+        this.roomId = roomId;
+        const nodeUrl = this.nodeUrl || await this.getNodeUrl(roomId);
+        return new Promise((resolve, reject) => {
+            this.ws = new ws_1.default(nodeUrl);
+            this.ws.on('open', () => {
+                this.ws.send(JSON.stringify({
+                    type: 'JOIN_ROOM',
+                    payload: { roomId, appId: this.appId }
+                }));
+            });
+            this.ws.on('message', (data) => {
+                const message = JSON.parse(data.toString());
+                if (message.type === 'INITIAL_STATE') {
+                    this.snapshot = message.payload.snapshot;
+                    const inputs = message.payload.inputs || [];
+                    // Apply any pending inputs to catch up (in sequence order)
+                    const sortedInputs = [...inputs].sort((a, b) => a.sequenceNumber - b.sequenceNumber);
+                    sortedInputs.forEach((input) => {
+                        const orderedInput = {
+                            data: input.data,
+                            sequenceNumber: input.sequenceNumber,
+                            timestamp: input.timestamp,
+                            clientId: input.clientId,
+                            id: input.id
+                        };
+                        this.inputHandlers.forEach(handler => handler(orderedInput));
+                    });
+                }
+                if (message.type === 'ROOM_JOINED') {
+                    console.log('Joined room:', roomId);
+                    this.setupMessageHandlers();
+                    resolve();
+                }
+            });
+            this.ws.on('error', reject);
+        });
+    }
+    setupMessageHandlers() {
+        if (!this.ws)
+            return;
+        this.ws.on('message', (data) => {
+            const message = JSON.parse(data.toString());
+            if (message.type === 'ORDERED_INPUTS') {
+                const inputs = message.payload.inputs || [];
+                inputs.forEach((input) => {
+                    const orderedInput = {
+                        data: input.data,
+                        sequenceNumber: input.sequenceNumber,
+                        timestamp: input.timestamp,
+                        clientId: input.clientId,
+                        id: input.id
+                    };
+                    this.inputHandlers.forEach(handler => handler(orderedInput));
+                });
+            }
+            if (message.type === 'SNAPSHOT_UPDATE') {
+                this.snapshot = message.payload.snapshot;
+                this.snapshotHandlers.forEach(handler => handler(this.snapshot));
+            }
+        });
+    }
+    sendInput(data) {
+        if (!this.ws || !this.roomId) {
+            throw new Error('Not connected to a room');
+        }
+        this.ws.send(JSON.stringify({
+            type: 'SEND_INPUT',
+            payload: { roomId: this.roomId, data }
+        }));
+    }
+    sendSnapshot(snapshot) {
+        if (!this.ws || !this.roomId) {
+            throw new Error('Not connected to a room');
+        }
+        this.snapshot = snapshot;
+        const hash = this.hashSnapshot(snapshot);
+        this.ws.send(JSON.stringify({
+            type: 'SEND_SNAPSHOT',
+            payload: { roomId: this.roomId, snapshot, hash }
+        }));
+    }
+    onInput(handler) {
+        this.inputHandlers.push(handler);
+    }
+    onSnapshot(handler) {
+        this.snapshotHandlers.push(handler);
+    }
+    getSnapshot() {
+        return this.snapshot;
+    }
+    disconnect() {
+        if (this.ws) {
+            this.ws.close();
+            this.ws = null;
+        }
+    }
+    async getNodeUrl(roomId) {
+        if (!this.appId) {
+            throw new Error('appId is required');
+        }
+        // Use REST API instead of WebSocket for better error handling
+        const httpUrl = this.centralServiceUrl.replace('ws://', 'http://').replace('wss://', 'https://');
+        const response = await fetch(`${httpUrl}/api/apps/${this.appId}/rooms/${roomId}/connect`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({})
+        });
+        if (!response.ok) {
+            const error = await response.json().catch(() => ({ error: 'Failed to connect to room' }));
+            throw new Error(error.error || `HTTP ${response.status}`);
+        }
+        const data = await response.json();
+        return data.url;
+    }
+    hashSnapshot(snapshot) {
+        const data = JSON.stringify(snapshot);
+        return crypto_1.default.createHash('sha256').update(data).digest('hex');
+    }
+}
+exports.MODD = MODD;
+// Backwards-compatible alias
+class MeshClient extends MODD {
+}
+exports.MeshClient = MeshClient;

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "modd-network",
+  "version": "1.0.0",
+  "description": "SDK for connecting to mesh network for multiplayer applications",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsx watch src/index.ts"
+  },
+  "keywords": [
+    "mesh",
+    "network",
+    "multiplayer",
+    "sdk"
+  ],
+  "author": "",
+  "license": "MIT",
+  "dependencies": {
+    "ws": "^8.16.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.10.6",
+    "@types/ws": "^8.5.10",
+    "tsx": "^4.7.0",
+    "typescript": "^5.3.3"
+  }
+}