@freesignal/socketio 0.1.0 → 0.1.2

package/dist/base.d.ts

@@ -0,0 +1,19 @@
+import { Database, LocalStorage, Crypto, KeyExchangeDataBundle } from "@freesignal/interfaces";
+import { Datagram, PrivateIdentityKey, UserId } from "@freesignal/protocol";
+import { ExportedKeySession } from "@freesignal/protocol/double-ratchet";
+import { BootstrapRequest, FreeSignalNode } from "@freesignal/protocol/node";
+export declare class FreeSignalSocketio extends FreeSignalNode {
+    protected readonly outbox: LocalStorage<string, Uint8Array[]>;
+    constructor(storage: Database<{
+        sessions: LocalStorage<string, ExportedKeySession>;
+        keyExchange: LocalStorage<string, Crypto.KeyPair>;
+        users: LocalStorage<string, string>;
+        bundles: LocalStorage<string, KeyExchangeDataBundle>;
+        bootstraps: LocalStorage<string, BootstrapRequest>;
+        outbox: LocalStorage<string, Uint8Array[]>;
+    }>, privateIdentityKey?: PrivateIdentityKey);
+    protected addToOutbox(userId: string | UserId, datagram: Datagram | Uint8Array): Promise<void>;
+    protected flushOutbox(): Promise<void>;
+    onClose: () => void;
+    onError: (err: Event | Error) => void;
+}

package/dist/base.js

@@ -0,0 +1,36 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { Datagram, UserId } from "@freesignal/protocol";
+import { FreeSignalNode } from "@freesignal/protocol/node";
+export class FreeSignalSocketio extends FreeSignalNode {
+    constructor(storage, privateIdentityKey) {
+        super(storage, privateIdentityKey);
+        this.onClose = () => { };
+        this.onError = () => { };
+        this.outbox = storage.outbox;
+    }
+    addToOutbox(userId, datagram) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const array = yield this.outbox.get(userId.toString());
+            this.outbox.set(userId.toString(), [...(array !== null && array !== void 0 ? array : []), Datagram.from(datagram).toBytes()]);
+        });
+    }
+    flushOutbox() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            for (const [userId, array] of Array.from((_a = yield this.outbox.entries()) !== null && _a !== void 0 ? _a : [])) {
+                yield this.outbox.delete(userId);
+                for (const data of array) {
+                    this.emitter.emit('send', { userId: UserId.from(userId), datagram: Datagram.from(data) });
+                }
+            }
+        });
+    }
+}

package/dist/client.d.ts

@@ -0,0 +1,29 @@
+import { Database, LocalStorage, Crypto, KeyExchangeDataBundle } from "@freesignal/interfaces";
+import { Datagram, PrivateIdentityKey, UserId } from "@freesignal/protocol";
+import { ExportedKeySession, KeySession } from "@freesignal/protocol/double-ratchet";
+import { BootstrapRequest } from "@freesignal/protocol/node";
+import { EventCallback } from "easyemitter.ts";
+import { FreeSignalSocketio } from "./base.js";
+export declare class FreeSignalClient extends FreeSignalSocketio {
+    private _serverId?;
+    private socket?;
+    constructor(storage: Database<{
+        sessions: LocalStorage<string, ExportedKeySession>;
+        keyExchange: LocalStorage<string, Crypto.KeyPair>;
+        users: LocalStorage<string, string>;
+        bundles: LocalStorage<string, KeyExchangeDataBundle>;
+        bootstraps: LocalStorage<string, BootstrapRequest>;
+        outbox: LocalStorage<string, Uint8Array[]>;
+    }>, privateIdentityKey?: PrivateIdentityKey);
+    get connected(): boolean;
+    get serverId(): UserId | undefined;
+    protected sendHandler: EventCallback<{
+        session?: KeySession;
+        payload?: Uint8Array;
+        datagram?: Datagram;
+        request?: BootstrapRequest;
+        userId?: UserId;
+    }, typeof this.emitter>;
+    connect(url: string | URL): Promise<void>;
+    close(): void;
+}

package/dist/client.js

@@ -0,0 +1,70 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { UserId } from "@freesignal/protocol";
+import { io } from "socket.io-client";
+import { FreeSignalSocketio } from "./base.js";
+export class FreeSignalClient extends FreeSignalSocketio {
+    constructor(storage, privateIdentityKey) {
+        super(storage, privateIdentityKey);
+        this.sendHandler = (eventData) => {
+            const { session, datagram, userId } = eventData;
+            if (!userId && !session)
+                throw new Error("UserId missing");
+            const receiverId = (userId === null || userId === void 0 ? void 0 : userId.toString()) || (session === null || session === void 0 ? void 0 : session.userId.toString());
+            if (!datagram)
+                throw new Error("Datagram missing");
+            if (!!this._serverId && receiverId !== this._serverId)
+                this.sendRelay(this._serverId, receiverId, datagram);
+            else if (!this.socket || !this.socket.connected)
+                this.addToOutbox(receiverId, datagram);
+            else
+                this.socket.send(datagram.toBytes());
+        };
+        this.emitter.on('send', this.sendHandler);
+    }
+    get connected() {
+        var _a, _b;
+        return (_b = (_a = this.socket) === null || _a === void 0 ? void 0 : _a.connected) !== null && _b !== void 0 ? _b : false;
+    }
+    get serverId() {
+        return this._serverId ? UserId.from(this._serverId) : undefined;
+    }
+    connect(url) {
+        return new Promise((resolve, reject) => {
+            try {
+                this.socket = io(url.toString(), {
+                    auth: {
+                        userId: this.userId.toString()
+                    }
+                });
+                this.socket.on('handshake', (userId) => __awaiter(this, void 0, void 0, function* () {
+                    this._serverId = userId;
+                    yield this.waitHandshaked(userId);
+                    yield this.flushOutbox();
+                    resolve();
+                }));
+                this.socket.on('message', (data) => __awaiter(this, void 0, void 0, function* () { this.open(data); }));
+                this.socket.on('disconnect', () => {
+                    this.onClose();
+                    this.socket = undefined;
+                });
+            }
+            catch (error) {
+                reject(error);
+            }
+        });
+    }
+    close() {
+        if (!this.socket)
+            throw new Error("Socket not connected");
+        this.socket.close();
+        this.onClose();
+    }
+}

package/dist/server.d.ts

@@ -0,0 +1,46 @@
+/**
+ * FreeSignal Protocol
+ *
+ * Copyright (C) 2025  Christian Braghette
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>
+ */
+import { Database, LocalStorage, Crypto, KeyExchangeDataBundle } from "@freesignal/interfaces";
+import { Datagram, PrivateIdentityKey, UserId } from "@freesignal/protocol";
+import { ExportedKeySession, KeySession } from "@freesignal/protocol/double-ratchet";
+import { BootstrapRequest } from "@freesignal/protocol/node";
+import { EventCallback } from "easyemitter.ts";
+import { type Server as HttpServer } from "http";
+import { FreeSignalSocketio } from "./base.js";
+export declare class FreeSignalServer extends FreeSignalSocketio {
+    private wss?;
+    private readonly connections;
+    constructor(storage: Database<{
+        sessions: LocalStorage<string, ExportedKeySession>;
+        keyExchange: LocalStorage<string, Crypto.KeyPair>;
+        users: LocalStorage<string, string>;
+        bundles: LocalStorage<string, KeyExchangeDataBundle>;
+        bootstraps: LocalStorage<string, BootstrapRequest>;
+        outbox: LocalStorage<string, Uint8Array[]>;
+    }>, privateIdentityKey?: PrivateIdentityKey);
+    protected sendHandler: EventCallback<{
+        session?: KeySession;
+        datagram?: Datagram;
+        userId?: UserId;
+    }, typeof this.emitter>;
+    listen(): this;
+    listen(port: number): this;
+    listen(server: HttpServer): this;
+    close(): void;
+}

package/dist/server.js

@@ -0,0 +1,86 @@
+/**
+ * FreeSignal Protocol
+ *
+ * Copyright (C) 2025  Christian Braghette
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>
+ */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { Server } from 'socket.io';
+import { FreeSignalSocketio } from "./base.js";
+export class FreeSignalServer extends FreeSignalSocketio {
+    constructor(storage, privateIdentityKey) {
+        super(storage, privateIdentityKey);
+        this.connections = new Map();
+        this.sendHandler = (eventData) => {
+            const { session, datagram, userId } = eventData;
+            if (!userId && !session)
+                throw new Error("UserId missing");
+            const receiverId = (userId === null || userId === void 0 ? void 0 : userId.toString()) || (session === null || session === void 0 ? void 0 : session.userId.toString());
+            const socket = this.connections.get(receiverId);
+            if (!socket)
+                throw new Error("Socket not found for user: " + userId);
+            if (!datagram)
+                throw new Error("Datagram missing");
+            if (!socket.connected)
+                this.addToOutbox(receiverId, datagram);
+            else
+                socket.send(datagram.toBytes());
+        };
+        this.emitter.on('send', this.sendHandler);
+        this.emitter.on('bootstrap', ({ request }) => request === null || request === void 0 ? void 0 : request.accept());
+    }
+    listen(server) {
+        server !== null && server !== void 0 ? server : (server = 12437);
+        this.wss = new Server(server, {
+            cors: {
+                origin: (origin, callback) => {
+                    // origin può essere undefined (curl, mobile app, server)
+                    callback(null, true);
+                },
+                methods: ["GET", "POST"]
+            }
+        });
+        this.wss.on('connection', (socket) => __awaiter(this, void 0, void 0, function* () {
+            const userId = socket.handshake.auth.userId;
+            if (!userId) {
+                socket.disconnect();
+                return;
+            }
+            console.debug("Client connected: ", userId);
+            this.connections.set(userId, socket);
+            socket.on('message', (data) => this.open(data));
+            socket.on('disconnect', () => this.connections.delete(userId));
+            socket.emit('handshake', this.userId.toString());
+            if (!(yield this.sessions.has(userId)))
+                this.sendBootstrap(userId);
+            else
+                this.sendHandshake(userId);
+        }));
+        return this;
+    }
+    close() {
+        var _a;
+        if ((_a = this.wss) === null || _a === void 0 ? void 0 : _a.close((err) => err ? this.onError(err) : undefined))
+            this.onClose();
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@freesignal/socketio",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "Socket.io trasnport package for FreeSignal protocol",
   "homepage": "https://github.com/christianbraghette/freesignal-socketio#readme",
   "bugs": {
@@ -14,13 +14,17 @@
   "author": "Christian Braghette",
   "type": "module",
   "exports": {
-    ".": {
-      "import": "./dist/index.js",
-      "require": "./dist/index.js",
-      "types": "./dist/index.d.ts"
+    "./server": {
+      "import": "./dist/server.js",
+      "require": "./dist/server.js",
+      "types": "./dist/server.d.ts"
+    },
+    "./client": {
+      "import": "./dist/client.js",
+      "require": "./dist/client.js",
+      "types": "./dist/client.d.ts"
     }
   },
-  "main": "./dist/index.js",
   "scripts": {
     "pretest": "tsc",
     "test": "node ./dist/test.js",