@stvor/sdk 2.3.2 → 2.4.1

package/dist/facade/app.cjs

@@ -0,0 +1,29 @@
+'use strict';
+
+// Auto-generated CommonJS wrapper for facade/app.js
+// This allows `require('@stvor/sdk')` to work alongside ESM `import`.
+
+const mod = require('module');
+const url = require('url');
+
+// Use dynamic import to load the ESM module
+let _cached;
+async function _load() {
+  if (!_cached) {
+    _cached = await import(url.pathToFileURL(__filename.replace(/\.cjs$/, '.js')).href);
+  }
+  return _cached;
+}
+
+// For simple CJS usage, expose a promise-based loader
+module.exports = new Proxy({ load: _load }, {
+  get(target, prop) {
+    if (prop === '__esModule') return true;
+    if (prop === 'then') return undefined; // prevent treating as thenable
+    if (prop === 'load') return _load;
+    if (prop === 'default') {
+      return _load().then(m => m.default);
+    }
+    return _load().then(m => m[prop]);
+  }
+});

package/dist/facade/crypto.cjs

@@ -0,0 +1,29 @@
+'use strict';
+
+// Auto-generated CommonJS wrapper for facade/crypto.js
+// This allows `require('@stvor/sdk')` to work alongside ESM `import`.
+
+const mod = require('module');
+const url = require('url');
+
+// Use dynamic import to load the ESM module
+let _cached;
+async function _load() {
+  if (!_cached) {
+    _cached = await import(url.pathToFileURL(__filename.replace(/\.cjs$/, '.js')).href);
+  }
+  return _cached;
+}
+
+// For simple CJS usage, expose a promise-based loader
+module.exports = new Proxy({ load: _load }, {
+  get(target, prop) {
+    if (prop === '__esModule') return true;
+    if (prop === 'then') return undefined; // prevent treating as thenable
+    if (prop === 'load') return _load;
+    if (prop === 'default') {
+      return _load().then(m => m.default);
+    }
+    return _load().then(m => m[prop]);
+  }
+});

package/dist/facade/errors.cjs

@@ -0,0 +1,29 @@
+'use strict';
+
+// Auto-generated CommonJS wrapper for facade/errors.js
+// This allows `require('@stvor/sdk')` to work alongside ESM `import`.
+
+const mod = require('module');
+const url = require('url');
+
+// Use dynamic import to load the ESM module
+let _cached;
+async function _load() {
+  if (!_cached) {
+    _cached = await import(url.pathToFileURL(__filename.replace(/\.cjs$/, '.js')).href);
+  }
+  return _cached;
+}
+
+// For simple CJS usage, expose a promise-based loader
+module.exports = new Proxy({ load: _load }, {
+  get(target, prop) {
+    if (prop === '__esModule') return true;
+    if (prop === 'then') return undefined; // prevent treating as thenable
+    if (prop === 'load') return _load;
+    if (prop === 'default') {
+      return _load().then(m => m.default);
+    }
+    return _load().then(m => m[prop]);
+  }
+});

package/dist/facade/index.cjs

@@ -0,0 +1,29 @@
+'use strict';
+
+// Auto-generated CommonJS wrapper for facade/index.js
+// This allows `require('@stvor/sdk')` to work alongside ESM `import`.
+
+const mod = require('module');
+const url = require('url');
+
+// Use dynamic import to load the ESM module
+let _cached;
+async function _load() {
+  if (!_cached) {
+    _cached = await import(url.pathToFileURL(__filename.replace(/\.cjs$/, '.js')).href);
+  }
+  return _cached;
+}
+
+// For simple CJS usage, expose a promise-based loader
+module.exports = new Proxy({ load: _load }, {
+  get(target, prop) {
+    if (prop === '__esModule') return true;
+    if (prop === 'then') return undefined; // prevent treating as thenable
+    if (prop === 'load') return _load;
+    if (prop === 'default') {
+      return _load().then(m => m.default);
+    }
+    return _load().then(m => m[prop]);
+  }
+});

package/dist/facade/relay-client.cjs

@@ -0,0 +1,29 @@
+'use strict';
+
+// Auto-generated CommonJS wrapper for facade/relay-client.js
+// This allows `require('@stvor/sdk')` to work alongside ESM `import`.
+
+const mod = require('module');
+const url = require('url');
+
+// Use dynamic import to load the ESM module
+let _cached;
+async function _load() {
+  if (!_cached) {
+    _cached = await import(url.pathToFileURL(__filename.replace(/\.cjs$/, '.js')).href);
+  }
+  return _cached;
+}
+
+// For simple CJS usage, expose a promise-based loader
+module.exports = new Proxy({ load: _load }, {
+  get(target, prop) {
+    if (prop === '__esModule') return true;
+    if (prop === 'then') return undefined; // prevent treating as thenable
+    if (prop === 'load') return _load;
+    if (prop === 'default') {
+      return _load().then(m => m.default);
+    }
+    return _load().then(m => m[prop]);
+  }
+});

package/dist/facade/types.cjs

@@ -0,0 +1,29 @@
+'use strict';
+
+// Auto-generated CommonJS wrapper for facade/types.js
+// This allows `require('@stvor/sdk')` to work alongside ESM `import`.
+
+const mod = require('module');
+const url = require('url');
+
+// Use dynamic import to load the ESM module
+let _cached;
+async function _load() {
+  if (!_cached) {
+    _cached = await import(url.pathToFileURL(__filename.replace(/\.cjs$/, '.js')).href);
+  }
+  return _cached;
+}
+
+// For simple CJS usage, expose a promise-based loader
+module.exports = new Proxy({ load: _load }, {
+  get(target, prop) {
+    if (prop === '__esModule') return true;
+    if (prop === 'then') return undefined; // prevent treating as thenable
+    if (prop === 'load') return _load;
+    if (prop === 'default') {
+      return _load().then(m => m.default);
+    }
+    return _load().then(m => m[prop]);
+  }
+});

package/dist/index.cjs

@@ -0,0 +1,29 @@
+'use strict';
+
+// Auto-generated CommonJS wrapper for index.js
+// This allows `require('@stvor/sdk')` to work alongside ESM `import`.
+
+const mod = require('module');
+const url = require('url');
+
+// Use dynamic import to load the ESM module
+let _cached;
+async function _load() {
+  if (!_cached) {
+    _cached = await import(url.pathToFileURL(__filename.replace(/\.cjs$/, '.js')).href);
+  }
+  return _cached;
+}
+
+// For simple CJS usage, expose a promise-based loader
+module.exports = new Proxy({ load: _load }, {
+  get(target, prop) {
+    if (prop === '__esModule') return true;
+    if (prop === 'then') return undefined; // prevent treating as thenable
+    if (prop === 'load') return _load;
+    if (prop === 'default') {
+      return _load().then(m => m.default);
+    }
+    return _load().then(m => m[prop]);
+  }
+});

package/dist/index.d.cts

@@ -0,0 +1,2 @@
+export * from './legacy.js';
+export * from './facade/index.js';

package/dist/legacy.cjs

@@ -0,0 +1,29 @@
+'use strict';
+
+// Auto-generated CommonJS wrapper for legacy.js
+// This allows `require('@stvor/sdk')` to work alongside ESM `import`.
+
+const mod = require('module');
+const url = require('url');
+
+// Use dynamic import to load the ESM module
+let _cached;
+async function _load() {
+  if (!_cached) {
+    _cached = await import(url.pathToFileURL(__filename.replace(/\.cjs$/, '.js')).href);
+  }
+  return _cached;
+}
+
+// For simple CJS usage, expose a promise-based loader
+module.exports = new Proxy({ load: _load }, {
+  get(target, prop) {
+    if (prop === '__esModule') return true;
+    if (prop === 'then') return undefined; // prevent treating as thenable
+    if (prop === 'load') return _load;
+    if (prop === 'default') {
+      return _load().then(m => m.default);
+    }
+    return _load().then(m => m[prop]);
+  }
+});

package/dist/mock-relay-server.cjs

@@ -0,0 +1,29 @@
+'use strict';
+
+// Auto-generated CommonJS wrapper for mock-relay-server.js
+// This allows `require('@stvor/sdk')` to work alongside ESM `import`.
+
+const mod = require('module');
+const url = require('url');
+
+// Use dynamic import to load the ESM module
+let _cached;
+async function _load() {
+  if (!_cached) {
+    _cached = await import(url.pathToFileURL(__filename.replace(/\.cjs$/, '.js')).href);
+  }
+  return _cached;
+}
+
+// For simple CJS usage, expose a promise-based loader
+module.exports = new Proxy({ load: _load }, {
+  get(target, prop) {
+    if (prop === '__esModule') return true;
+    if (prop === 'then') return undefined; // prevent treating as thenable
+    if (prop === 'load') return _load;
+    if (prop === 'default') {
+      return _load().then(m => m.default);
+    }
+    return _load().then(m => m[prop]);
+  }
+});

package/dist/mock-relay-server.d.ts

@@ -0,0 +1,30 @@
+#!/usr/bin/env node
+/**
+ * STVOR Mock Relay Server
+ *
+ * A lightweight local development server that emulates the production
+ * STVOR relay over WebSocket. Run it locally to develop and test
+ * without internet access or a production relay.
+ *
+ * Usage:
+ *   npx @stvor/sdk mock-relay                   # via npx
+ *   npm run mock-relay                           # from SDK root
+ *   node dist/mock-relay-server.js               # direct
+ *   PORT=9000 node dist/mock-relay-server.js     # custom port
+ *   STVOR_MOCK_VERBOSE=1 node dist/mock-relay-server.js  # verbose
+ *
+ * Accepts any AppToken starting with "stvor_" for easy local testing.
+ *
+ * Protocol:
+ *   Connection: ws://localhost:PORT with Authorization header
+ *   Handshake:  Server sends { type: 'handshake', status: 'ok' }
+ *   Announce:   { type: 'announce', user: string, pub: string }
+ *   Message:    { type: 'message', to: string, from: string, payload: any }
+ *   Ack:        { type: 'ack', id: string }
+ *   Error:      { type: 'error', code: string, message: string }
+ */
+import http from 'node:http';
+declare const PORT: number;
+declare const httpServer: http.Server<typeof http.IncomingMessage, typeof http.ServerResponse>;
+declare const wss: any;
+export { PORT, wss, httpServer };

package/dist/mock-relay-server.js

@@ -0,0 +1,236 @@
+#!/usr/bin/env node
+/**
+ * STVOR Mock Relay Server
+ *
+ * A lightweight local development server that emulates the production
+ * STVOR relay over WebSocket. Run it locally to develop and test
+ * without internet access or a production relay.
+ *
+ * Usage:
+ *   npx @stvor/sdk mock-relay                   # via npx
+ *   npm run mock-relay                           # from SDK root
+ *   node dist/mock-relay-server.js               # direct
+ *   PORT=9000 node dist/mock-relay-server.js     # custom port
+ *   STVOR_MOCK_VERBOSE=1 node dist/mock-relay-server.js  # verbose
+ *
+ * Accepts any AppToken starting with "stvor_" for easy local testing.
+ *
+ * Protocol:
+ *   Connection: ws://localhost:PORT with Authorization header
+ *   Handshake:  Server sends { type: 'handshake', status: 'ok' }
+ *   Announce:   { type: 'announce', user: string, pub: string }
+ *   Message:    { type: 'message', to: string, from: string, payload: any }
+ *   Ack:        { type: 'ack', id: string }
+ *   Error:      { type: 'error', code: string, message: string }
+ */
+import * as WS from 'ws';
+import http from 'node:http';
+const { WebSocketServer } = WS;
+// ── Configuration ────────────────────────────────────────────────────
+const PORT = parseInt(process.env.STVOR_MOCK_PORT || process.env.PORT || '4444', 10);
+const VERBOSE = process.env.STVOR_MOCK_VERBOSE === '1';
+// ── In-memory state ──────────────────────────────────────────────────
+/** userId → WebSocket */
+const clients = new Map();
+/** userId → public key (base64) */
+const pubkeys = new Map();
+/** userId → pending messages (for offline delivery) */
+const mailboxes = new Map();
+let totalConnections = 0;
+let totalMessages = 0;
+// ── Helpers ──────────────────────────────────────────────────────────
+function log(...args) {
+    if (VERBOSE)
+        console.log('[mock-relay]', new Date().toISOString(), ...args);
+}
+function validateAuth(req) {
+    const auth = req.headers.authorization;
+    if (!auth)
+        return false;
+    const token = auth.replace(/^Bearer\s+/i, '');
+    return token.startsWith('stvor_');
+}
+function broadcast(obj, exceptWs) {
+    const data = JSON.stringify(obj);
+    for (const ws of clients.values()) {
+        if (ws !== exceptWs && ws.readyState === 1 /* OPEN */) {
+            ws.send(data);
+        }
+    }
+}
+// ── HTTP server for health check (and future REST endpoints) ─────────
+const httpServer = http.createServer((req, res) => {
+    const url = new URL(req.url || '/', `http://localhost:${PORT}`);
+    // CORS
+    res.setHeader('Access-Control-Allow-Origin', '*');
+    res.setHeader('Access-Control-Allow-Headers', 'Content-Type, Authorization');
+    res.setHeader('Access-Control-Allow-Methods', 'GET, POST, OPTIONS');
+    if (req.method === 'OPTIONS') {
+        res.writeHead(204);
+        return res.end();
+    }
+    if (url.pathname === '/health') {
+        res.writeHead(200, { 'Content-Type': 'application/json' });
+        return res.end(JSON.stringify({
+            status: 'ok',
+            server: 'stvor-mock-relay',
+            version: '1.0.0',
+            uptime: process.uptime(),
+            connectedUsers: clients.size,
+            totalConnections,
+            totalMessages,
+        }));
+    }
+    // GET /status/:userId - check if user is online
+    const statusMatch = url.pathname.match(/^\/status\/(.+)$/);
+    if (statusMatch) {
+        const userId = decodeURIComponent(statusMatch[1]);
+        res.writeHead(200, { 'Content-Type': 'application/json' });
+        return res.end(JSON.stringify({
+            userId,
+            online: clients.has(userId),
+            hasPublicKey: pubkeys.has(userId),
+        }));
+    }
+    // GET /usage - mock unlimited usage
+    if (url.pathname === '/usage') {
+        res.writeHead(200, { 'Content-Type': 'application/json' });
+        return res.end(JSON.stringify({ used: 0, limit: -1 }));
+    }
+    res.writeHead(404, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify({ error: 'Not Found' }));
+});
+// ── WebSocket server ─────────────────────────────────────────────────
+const wss = new WebSocketServer({ server: httpServer });
+wss.on('connection', (ws, req) => {
+    totalConnections++;
+    // ── Auth check ───────────────────────────────────────────────────
+    if (!validateAuth(req)) {
+        log('Auth failed for connection');
+        ws.send(JSON.stringify({
+            type: 'handshake',
+            status: 'error',
+            reason: 'Invalid AppToken. Token must start with "stvor_".',
+        }));
+        ws.close(4001, 'Unauthorized');
+        return;
+    }
+    // ── Successful handshake ─────────────────────────────────────────
+    ws.send(JSON.stringify({ type: 'handshake', status: 'ok' }));
+    log('Client connected (auth OK)');
+    // Send all known user announcements to the new client
+    for (const [user, pub] of pubkeys.entries()) {
+        try {
+            ws.send(JSON.stringify({ type: 'announce', user, pub }));
+        }
+        catch {
+            // ignore
+        }
+    }
+    // ── Message handler ──────────────────────────────────────────────
+    ws.on('message', (data) => {
+        let msg;
+        try {
+            msg = JSON.parse(data.toString());
+        }
+        catch {
+            return;
+        }
+        // ── Announce: register user + broadcast public key ────────────
+        if (msg.type === 'announce' && msg.user) {
+            const oldWs = clients.get(msg.user);
+            clients.set(msg.user, ws);
+            if (msg.pub) {
+                pubkeys.set(msg.user, msg.pub);
+            }
+            log(`User announced: ${msg.user}`);
+            // Broadcast announce to all other clients
+            broadcast({ type: 'announce', user: msg.user, pub: msg.pub }, ws);
+            // Deliver any pending messages
+            const pending = mailboxes.get(msg.user) || [];
+            if (pending.length > 0) {
+                log(`Delivering ${pending.length} pending messages to ${msg.user}`);
+                for (const m of pending) {
+                    try {
+                        ws.send(JSON.stringify(m));
+                    }
+                    catch {
+                        // ignore
+                    }
+                }
+                mailboxes.set(msg.user, []);
+            }
+            return;
+        }
+        // ── Message: route to recipient ──────────────────────────────
+        if (msg.type === 'message' && msg.to) {
+            totalMessages++;
+            const target = clients.get(msg.to);
+            if (target && target.readyState === 1 /* OPEN */) {
+                // Deliver immediately
+                target.send(JSON.stringify(msg));
+                log(`Message delivered: ${msg.from} → ${msg.to}`);
+                // ACK back to sender
+                if (msg.from && ws.readyState === 1 /* OPEN */) {
+                    ws.send(JSON.stringify({ type: 'ack', id: msg.id ?? null }));
+                }
+            }
+            else {
+                // Store for later delivery
+                if (!mailboxes.has(msg.to)) {
+                    mailboxes.set(msg.to, []);
+                }
+                mailboxes.get(msg.to).push(msg);
+                log(`Message queued: ${msg.from} → ${msg.to} (recipient offline)`);
+                // Notify sender that message is queued
+                if (ws.readyState === 1 /* OPEN */) {
+                    ws.send(JSON.stringify({
+                        type: 'queued',
+                        id: msg.id ?? null,
+                        to: msg.to,
+                        message: 'Recipient is offline. Message queued for delivery.',
+                    }));
+                }
+            }
+            return;
+        }
+        log('Unknown message type:', msg.type);
+    });
+    // ── Disconnect ───────────────────────────────────────────────────
+    ws.on('close', () => {
+        for (const [user, sock] of clients.entries()) {
+            if (sock === ws) {
+                log(`User disconnected: ${user}`);
+                clients.delete(user);
+                // Keep public key so reconnecting users can still be found
+                // pubkeys.delete(user);  // intentionally NOT deleted
+            }
+        }
+    });
+    ws.on('error', (err) => {
+        log('WebSocket error:', err.message);
+    });
+});
+// ── Start server ─────────────────────────────────────────────────────
+httpServer.listen(PORT, () => {
+    console.log('');
+    console.log('  ╔══════════════════════════════════════════════════════╗');
+    console.log('  ║          STVOR Mock Relay Server v1.0.0             ║');
+    console.log('  ╠══════════════════════════════════════════════════════╣');
+    console.log(`  ║  WebSocket: ws://localhost:${String(PORT).padEnd(27)}║`);
+    console.log(`  ║  Health:    http://localhost:${String(PORT).padEnd(22)}║`);
+    console.log('  ║  Auth:      Any token starting with "stvor_"        ║');
+    console.log('  ║  Data:      In-memory (resets on restart)           ║');
+    console.log('  ╚══════════════════════════════════════════════════════╝');
+    console.log('');
+    console.log('  Usage in your app:');
+    console.log('');
+    console.log("    const app = await Stvor.init({");
+    console.log("      appToken: 'stvor_dev_test123',");
+    console.log(`      relayUrl: 'ws://localhost:${PORT}'`);
+    console.log("    });");
+    console.log('');
+    console.log('  Set STVOR_MOCK_VERBOSE=1 for detailed logging.');
+    console.log('');
+});
+export { PORT, wss, httpServer };

package/package.json

@@ -1,14 +1,25 @@
 {
   "name": "@stvor/sdk",
-  "version": "2.3.2",
+  "version": "2.4.1",
   "description": "Stvor DX Facade - Simple E2EE SDK for client-side encryption",
   "type": "module",
-  "main": "./dist/index.js",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "exports": {
     ".": {
-      "import": "./dist/index.js",
-      "types": "./dist/index.d.ts"
+      "import": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      },
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.cjs"
+      }
+    },
+    "./mock-relay": {
+      "import": "./dist/mock-relay-server.js",
+      "require": "./dist/mock-relay-server.cjs"
     }
   },
   "files": [
@@ -28,19 +39,23 @@
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/izahii/stvor-api.git"
+    "url": "git+https://github.com/sapogeth/stvor_sdk.git"
   },
   "engines": {
     "node": ">=18.0.0"
   },
   "bugs": {
-    "url": "https://github.com/izahii/stvor-api/issues"
+    "url": "https://github.com/sapogeth/stvor_sdk/issues"
   },
   "homepage": "https://stvor.xyz",
   "scripts": {
-    "build": "tsc",
+    "build": "tsc && node postbuild-fix-extensions.cjs && node build-cjs.cjs",
     "prepublishOnly": "npm run build",
-    "test": "echo \"No tests yet\" && exit 0"
+    "test": "echo \"No tests yet\" && exit 0",
+    "mock-relay": "node dist/mock-relay-server.js"
+  },
+  "bin": {
+    "stvor-mock-relay": "./dist/mock-relay-server.js"
   },
   "dependencies": {
     "ws": "^8.13.0",

package/dist/facade/crypto-session.d.ts

@@ -1,76 +0,0 @@
-/**
- * STVOR Crypto Session Manager
- * Integrates X3DH + Double Ratchet from ratchet module
- *
- * CRITICAL: Identity keys generated ONCE per userId
- * Currently in-memory only - keys lost on restart
- *
- * TODO: Add persistent storage (IndexedDB/Keychain)
- */
-export interface IdentityKeys {
-    identityKeyPair: {
-        publicKey: Uint8Array;
-        privateKey: Uint8Array;
-    };
-    signedPreKeyPair: {
-        publicKey: Uint8Array;
-        privateKey: Uint8Array;
-    };
-    oneTimePreKeys: Uint8Array[];
-}
-export interface SerializedPublicKeys {
-    identityKey: string;
-    signedPreKey: string;
-    signedPreKeySignature: string;
-    oneTimePreKey: string;
-}
-/**
- * Manages cryptographic sessions for all peers
- */
-export declare class CryptoSessionManager {
-    private userId;
-    private identityKeys;
-    private sessions;
-    private initialized;
-    private initPromise;
-    constructor(userId: string);
-    /**
-     * Initialize libsodium and generate identity keys
-     * RACE CONDITION SAFE: Returns same promise if called concurrently
-     */
-    initialize(): Promise<void>;
-    private _doInitialize;
-    /**
-     * Get serialized public keys for relay registration
-     */
-    getPublicKeys(): SerializedPublicKeys;
-    /**
-     * Establish session with peer (X3DH handshake)
-     */
-    establishSessionWithPeer(peerId: string, peerPublicKeys: SerializedPublicKeys): Promise<void>;
-    /**
-     * Encrypt message for peer using Double Ratchet
-     */
-    encryptForPeer(peerId: string, plaintext: string): Promise<{
-        ciphertext: Uint8Array;
-        header: {
-            publicKey: Uint8Array;
-            nonce: Uint8Array;
-        };
-    }>;
-    /**
-     * Decrypt message from peer using Double Ratchet
-     */
-    decryptFromPeer(peerId: string, ciphertext: Uint8Array, header: {
-        publicKey: Uint8Array;
-        nonce: Uint8Array;
-    }): Promise<string>;
-    /**
-     * Check if session exists with peer
-     */
-    hasSession(peerId: string): boolean;
-    /**
-     * Destroy all sessions (cleanup)
-     */
-    destroy(): void;
-}