@stvor/sdk 2.0.8 → 2.0.9

package/dist/facade/app.d.ts

@@ -1,12 +1,17 @@
-import type { StvorAppConfig, UserId, MessageContent, DecryptedMessage } from './types.js';
+import type { StvorAppConfig, UserId, MessageContent } from './types.js';
 import { RelayClient } from './relay-client.js';
+type MessageHandler = (from: UserId, msg: string | Uint8Array) => void;
 export declare class StvorFacadeClient {
     readonly userId: UserId;
     private readonly relay;
+    private crypto;
+    private handlers;
+    private knownPubKeys;
     constructor(userId: UserId, relay: RelayClient);
+    private handleRelayMessage;
     internalInitialize(): Promise<void>;
     send(recipientId: UserId, content: MessageContent): Promise<void>;
-    onMessage(handler: (msg: DecryptedMessage) => void): () => void;
+    onMessage(handler: MessageHandler): () => void;
 }
 export declare class StvorApp {
     private readonly config;
@@ -19,3 +24,4 @@ export declare function init(config: StvorAppConfig): Promise<StvorApp>;
 export declare const Stvor: {
     init: typeof init;
 };
+export {};

package/dist/facade/app.js

@@ -1,19 +1,59 @@
 import { Errors, StvorError } from './errors.js';
 import { RelayClient } from './relay-client.js';
+import { CryptoSession } from './crypto.js';
 export class StvorFacadeClient {
     constructor(userId, relay) {
         this.userId = userId;
         this.relay = relay;
+        this.handlers = [];
+        this.knownPubKeys = new Map();
+        this.crypto = new CryptoSession();
+        // listen relay messages
+        this.relay.onMessage((m) => this.handleRelayMessage(m));
+        // announce our public key
+        this.relay.send({ type: 'announce', user: this.userId, pub: this.crypto.exportPublic() });
+    }
+    async handleRelayMessage(m) {
+        if (!m || typeof m !== 'object')
+            return;
+        if (m.type === 'announce' && m.user && m.pub) {
+            this.knownPubKeys.set(m.user, m.pub);
+            return;
+        }
+        if (m.type === 'message' && m.to === this.userId && m.payload) {
+            const payload = m.payload;
+            const sender = m.from;
+            try {
+                const plain = this.crypto.decrypt(payload, payload.senderPub);
+                const text = new TextDecoder().decode(plain);
+                for (const h of this.handlers)
+                    h(sender, text);
+            }
+            catch (e) {
+                // ignore decryption errors
+            }
+        }
     }
     async internalInitialize() {
-        // TODO: init logic
+        // nothing for now; announce already sent in constructor
     }
     async send(recipientId, content) {
-        // TODO: send logic
+        const recipientPub = this.knownPubKeys.get(recipientId);
+        if (!recipientPub) {
+            throw new StvorError(Errors.RECIPIENT_NOT_FOUND, 'Recipient public key unknown');
+        }
+        const plain = typeof content === 'string' ? new TextEncoder().encode(content) : content;
+        const payload = this.crypto.encrypt(plain, recipientPub);
+        const msg = { type: 'message', to: recipientId, from: this.userId, payload };
+        this.relay.send(msg);
     }
     onMessage(handler) {
-        // TODO: subscription logic
-        return () => { };
+        this.handlers.push(handler);
+        return () => {
+            const i = this.handlers.indexOf(handler);
+            if (i >= 0)
+                this.handlers.splice(i, 1);
+        };
     }
 }
 export class StvorApp {

package/dist/facade/crypto.d.ts

@@ -0,0 +1,19 @@
+import crypto from 'crypto';
+export type EncryptedMessage = {
+    version: number;
+    senderPub: string;
+    nonce: string;
+    ciphertext: string;
+    tag: string;
+};
+export declare class CryptoSession {
+    privateKey: crypto.KeyObject;
+    publicKey: crypto.KeyObject;
+    readonly publicKeyBase64: string;
+    constructor();
+    exportPublic(): string;
+    private deriveShared;
+    encrypt(plaintext: Uint8Array, remotePubBase64: string): EncryptedMessage;
+    decrypt(msg: EncryptedMessage, remotePubBase64: string): Uint8Array;
+}
+export default CryptoSession;

package/dist/facade/crypto.js

@@ -0,0 +1,46 @@
+import crypto from 'crypto';
+export class CryptoSession {
+    constructor() {
+        const { publicKey, privateKey } = crypto.generateKeyPairSync('x25519');
+        this.privateKey = privateKey;
+        this.publicKey = publicKey;
+        const spki = publicKey.export({ type: 'spki', format: 'der' });
+        this.publicKeyBase64 = spki.toString('base64');
+    }
+    exportPublic() {
+        return this.publicKeyBase64;
+    }
+    deriveShared(remotePubBase64) {
+        const remoteDer = Buffer.from(remotePubBase64, 'base64');
+        const remoteKey = crypto.createPublicKey({ key: remoteDer, type: 'spki', format: 'der' });
+        const shared = crypto.diffieHellman({ privateKey: this.privateKey, publicKey: remoteKey });
+        // HKDF-SHA256 to 32 bytes
+        const key = crypto.hkdfSync('sha256', shared, Buffer.alloc(0), Buffer.from('stvor v0.1'), 32);
+        return Buffer.from(key);
+    }
+    encrypt(plaintext, remotePubBase64) {
+        const key = this.deriveShared(remotePubBase64);
+        const nonce = crypto.randomBytes(12);
+        const cipher = crypto.createCipheriv('aes-256-gcm', key, nonce);
+        const ct = Buffer.concat([cipher.update(Buffer.from(plaintext)), cipher.final()]);
+        const tag = cipher.getAuthTag();
+        return {
+            version: 1,
+            senderPub: this.publicKeyBase64,
+            nonce: nonce.toString('base64'),
+            ciphertext: ct.toString('base64'),
+            tag: tag.toString('base64'),
+        };
+    }
+    decrypt(msg, remotePubBase64) {
+        const key = this.deriveShared(remotePubBase64);
+        const nonce = Buffer.from(msg.nonce, 'base64');
+        const ct = Buffer.from(msg.ciphertext, 'base64');
+        const tag = Buffer.from(msg.tag, 'base64');
+        const decipher = crypto.createDecipheriv('aes-256-gcm', key, nonce);
+        decipher.setAuthTag(tag);
+        const pt = Buffer.concat([decipher.update(ct), decipher.final()]);
+        return new Uint8Array(pt);
+    }
+}
+export default CryptoSession;

package/dist/facade/errors.d.ts

@@ -2,6 +2,10 @@ export declare const Errors: {
     readonly INVALID_APP_TOKEN: "INVALID_APP_TOKEN";
     readonly RELAY_UNAVAILABLE: "RELAY_UNAVAILABLE";
     readonly DELIVERY_FAILED: "DELIVERY_FAILED";
+    readonly RECIPIENT_NOT_FOUND: "RECIPIENT_NOT_FOUND";
+    readonly MESSAGE_INTEGRITY_FAILED: "MESSAGE_INTEGRITY_FAILED";
+    readonly RECEIVE_TIMEOUT: "RECEIVE_TIMEOUT";
+    readonly RECEIVE_IN_PROGRESS: "RECEIVE_IN_PROGRESS";
 };
 export type ErrorCode = (typeof Errors)[keyof typeof Errors];
 export declare class StvorError extends Error {

package/dist/facade/errors.js

@@ -2,6 +2,10 @@ export const Errors = {
     INVALID_APP_TOKEN: 'INVALID_APP_TOKEN',
     RELAY_UNAVAILABLE: 'RELAY_UNAVAILABLE',
     DELIVERY_FAILED: 'DELIVERY_FAILED',
+    RECIPIENT_NOT_FOUND: 'RECIPIENT_NOT_FOUND',
+    MESSAGE_INTEGRITY_FAILED: 'MESSAGE_INTEGRITY_FAILED',
+    RECEIVE_TIMEOUT: 'RECEIVE_TIMEOUT',
+    RECEIVE_IN_PROGRESS: 'RECEIVE_IN_PROGRESS',
 };
 export class StvorError extends Error {
     constructor(code, message, action, retryable) {

package/dist/facade/relay-client.d.ts

@@ -1,13 +1,24 @@
 /**
  * STVOR DX Facade - Relay Client
  */
+type JSONable = Record<string, any>;
+export type RelayHandler = (msg: JSONable) => void;
 export declare class RelayClient {
     private relayUrl;
     private timeout;
     private appToken;
+    private ws?;
     private connected;
+    private backoff;
+    private queue;
+    private handlers;
+    private reconnecting;
     constructor(relayUrl: string, appToken: string, timeout?: number);
     private getAuthHeaders;
-    healthCheck(): Promise<void>;
+    private connect;
+    private scheduleReconnect;
+    send(obj: JSONable): void;
+    onMessage(h: RelayHandler): void;
     isConnected(): boolean;
 }
+export {};

package/dist/facade/relay-client.js

@@ -1,36 +1,81 @@
 /**
  * STVOR DX Facade - Relay Client
  */
-import { Errors, StvorError } from './errors.js';
+import * as WS from 'ws';
 export class RelayClient {
     constructor(relayUrl, appToken, timeout = 10000) {
         this.connected = false;
-        this.relayUrl = relayUrl;
+        this.backoff = 1000;
+        this.queue = [];
+        this.handlers = [];
+        this.reconnecting = false;
+        this.relayUrl = relayUrl.replace(/^http/, 'ws');
         this.appToken = appToken;
         this.timeout = timeout;
+        this.connect();
     }
     getAuthHeaders() {
         return {
-            'Authorization': `Bearer ${this.appToken}`,
-            'Content-Type': 'application/json',
+            Authorization: `Bearer ${this.appToken}`,
         };
     }
-    async healthCheck() {
-        const controller = new AbortController();
-        const timeoutId = setTimeout(() => controller.abort(), this.timeout);
-        try {
-            const res = await fetch(`${this.relayUrl}/health`, {
-                method: 'GET',
-                signal: controller.signal,
-            });
-            if (!res.ok) {
-                throw new StvorError(Errors.RELAY_UNAVAILABLE, 'Relay unavailable', 'Check network', true);
+    connect() {
+        if (this.ws)
+            return;
+        const WSClass = WS.default ?? WS;
+        this.ws = new WSClass(this.relayUrl, { headers: this.getAuthHeaders() });
+        this.ws.on('open', () => {
+            this.connected = true;
+            this.backoff = 1000;
+            // flush queue
+            while (this.queue.length) {
+                const m = this.queue.shift();
+                this.send(m);
             }
+        });
+        this.ws.on('message', (data) => {
+            try {
+                const json = JSON.parse(data.toString());
+                for (const h of this.handlers)
+                    h(json);
+            }
+            catch (e) {
+                // ignore
+            }
+        });
+        this.ws.on('close', () => {
+            this.connected = false;
+            this.ws = undefined;
+            this.scheduleReconnect();
+        });
+        this.ws.on('error', () => {
+            this.connected = false;
+            this.ws = undefined;
+            this.scheduleReconnect();
+        });
+    }
+    scheduleReconnect() {
+        if (this.reconnecting)
+            return;
+        this.reconnecting = true;
+        setTimeout(() => {
+            this.reconnecting = false;
+            this.connect();
+            this.backoff = Math.min(this.backoff * 2, 30000);
+        }, this.backoff);
+    }
+    send(obj) {
+        const data = JSON.stringify(obj);
+        if (this.connected && this.ws) {
+            this.ws.send(data);
         }
-        finally {
-            clearTimeout(timeoutId);
+        else {
+            this.queue.push(obj);
         }
     }
+    onMessage(h) {
+        this.handlers.push(h);
+    }
     isConnected() {
         return this.connected;
     }

package/package.json

@@ -1,11 +1,15 @@
 {
   "name": "@stvor/sdk",
-  "version": "2.0.8",
+  "version": "2.0.9",
   "description": "STVOR DX Facade - Simple E2EE SDK for client-side encryption",
   "type": "module",
   "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
   "exports": {
-    ".": "./dist/index.js"
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
   },
   "files": [
     "dist"
@@ -15,18 +19,33 @@
     "encryption",
     "security",
     "cryptography",
-    "end-to-end"
+    "end-to-end",
+    "x3dh",
+    "double-ratchet",
+    "libsodium"
   ],
   "author": "Stvor",
   "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/izahii/stvor-api.git"
+  },
   "engines": {
     "node": ">=18.0.0"
   },
   "bugs": {
-    "url": "https://github.com/stvor/sdk/issues"
+    "url": "https://github.com/izahii/stvor-api/issues"
   },
   "homepage": "https://stvor.xyz",
   "scripts": {
-    "build": "tsc"
+    "build": "tsc",
+    "prepublishOnly": "npm run build",
+    "test": "echo \"No tests yet\" && exit 0"
+  },
+  "dependencies": {
+    "ws": "^8.13.0"
+  },
+  "peerDependencies": {
+    "libsodium-wrappers": "^0.7.13"
   }
 }