@stvor/sdk 2.0.0 → 2.0.2

package/dist/facade/types.d.ts

@@ -0,0 +1,52 @@
+/**
+ * STVOR DX Facade - Type Definitions
+ */
+/**
+ * AppToken from developer dashboard
+ * Replaces "API key" terminology for better DX
+ */
+export type AppToken = string;
+/**
+ * Configuration for SDK initialization
+ */
+export interface StvorAppConfig {
+    /** AppToken from STVOR developer dashboard */
+    appToken: string;
+    /** Relay server URL (optional, defaults to stvor.io) */
+    relayUrl?: string;
+    /** Connection timeout in ms (optional, default 10000) */
+    timeout?: number;
+}
+/**
+ * User identifier in your application
+ * Can be email, username, or UUID
+ */
+export type UserId = string;
+/**
+ * Message content - text or binary data
+ */
+export type MessageContent = string | Uint8Array;
+/**
+ * Result of receiving a decrypted message
+ */
+export interface DecryptedMessage {
+    /** Unique message identifier */
+    id: string;
+    /** Sender's user ID */
+    senderId: UserId;
+    /** Decrypted content */
+    content: MessageContent;
+    /** Timestamp when message was sent */
+    timestamp: Date;
+}
+/**
+ * Sealed payload for encrypting files/binary data
+ */
+export interface SealedPayload {
+    /** Encrypted ciphertext */
+    ciphertext: Uint8Array;
+    /** Nonce used for encryption */
+    nonce: Uint8Array;
+    /** Recipient user ID this was sealed for */
+    recipientId: UserId;
+}

package/dist/facade/types.js

@@ -0,0 +1,4 @@
+/**
+ * STVOR DX Facade - Type Definitions
+ */
+export {};

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * STVOR SDK - Main exports
+ */
+export * from './legacy';
+export * from './facade';

package/{index.ts → dist/index.js}

@@ -1,9 +1,7 @@
 /**
  * STVOR SDK - Main exports
  */
-
 // Legacy core API (for migration)
 export * from './legacy';
-
 // New DX Facade API
 export * from './facade';

package/dist/legacy.d.ts

@@ -0,0 +1,31 @@
+/**
+ * STVOR SDK - Legacy Core API
+ * Kept for backwards compatibility
+ */
+export interface StvorConfig {
+    apiKey: string;
+    serverUrl?: string;
+}
+export interface Peer {
+    id: string;
+    publicKey: any;
+}
+export interface EncryptedMessage {
+    ciphertext: string;
+    nonce: string;
+    from: string;
+}
+export declare class StvorClient {
+    private config;
+    private myKeyPair;
+    private myId;
+    private peers;
+    constructor(config: StvorConfig);
+    ready(): Promise<void>;
+    createPeer(name: string): Promise<Peer>;
+    send({ to, message }: {
+        to: string;
+        message: string;
+    }): Promise<EncryptedMessage>;
+    receive(encrypted: EncryptedMessage): Promise<string>;
+}

package/dist/legacy.js

@@ -0,0 +1,90 @@
+/**
+ * STVOR SDK - Legacy Core API
+ * Kept for backwards compatibility
+ */
+export class StvorClient {
+    constructor(config) {
+        this.myKeyPair = null;
+        this.myId = '';
+        this.peers = new Map();
+        this.config = {
+            serverUrl: 'http://localhost:3001',
+            ...config,
+        };
+    }
+    async ready() {
+        if (!this.config.apiKey) {
+            throw new Error('API key is required');
+        }
+        this.myKeyPair = await crypto.subtle.generateKey({ name: 'ECDH', namedCurve: 'P-256' }, true, ['deriveKey', 'deriveBits']);
+        this.myId = this.config.apiKey.substring(0, 8);
+    }
+    async createPeer(name) {
+        if (!this.myKeyPair)
+            throw new Error('Call ready() first');
+        const publicKey = await crypto.subtle.exportKey('jwk', this.myKeyPair.publicKey);
+        const res = await fetch(`${this.config.serverUrl}/register`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ user_id: name, publicKey }),
+        });
+        if (!res.ok) {
+            const err = await res.json();
+            throw new Error(`Registration failed: ${JSON.stringify(err)}`);
+        }
+        return { id: name, publicKey };
+    }
+    async send({ to, message }) {
+        if (!this.myKeyPair)
+            throw new Error('Call ready() first');
+        let recipientKey = this.peers.get(to);
+        if (!recipientKey) {
+            const res = await fetch(`${this.config.serverUrl}/public-key/${to}`);
+            if (!res.ok)
+                throw new Error(`Peer ${to} not found`);
+            const { publicKey } = await res.json();
+            recipientKey = await crypto.subtle.importKey('jwk', publicKey, { name: 'ECDH', namedCurve: 'P-256' }, false, []);
+            this.peers.set(to, recipientKey);
+        }
+        const sharedKey = await crypto.subtle.deriveKey({ name: 'ECDH', public: recipientKey }, this.myKeyPair.privateKey, { name: 'AES-GCM', length: 256 }, false, ['encrypt', 'decrypt']);
+        const iv = crypto.getRandomValues(new Uint8Array(12));
+        const encoder = new TextEncoder();
+        const encrypted = await crypto.subtle.encrypt({ name: 'AES-GCM', iv }, sharedKey, encoder.encode(message));
+        const sendRes = await fetch(`${this.config.serverUrl}/message`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                from: this.myId,
+                to,
+                ciphertext: Buffer.from(encrypted).toString('base64'),
+                nonce: Buffer.from(iv).toString('base64'),
+            }),
+        });
+        if (!sendRes.ok) {
+            throw new Error('Failed to send message');
+        }
+        return {
+            ciphertext: Buffer.from(encrypted).toString('base64'),
+            nonce: Buffer.from(iv).toString('base64'),
+            from: this.myId
+        };
+    }
+    async receive(encrypted) {
+        if (!this.myKeyPair)
+            throw new Error('Call ready() first');
+        let senderKey = this.peers.get(encrypted.from);
+        if (!senderKey) {
+            const res = await fetch(`${this.config.serverUrl}/public-key/${encrypted.from}`);
+            if (!res.ok)
+                throw new Error(`Sender ${encrypted.from} not found`);
+            const { publicKey } = await res.json();
+            senderKey = await crypto.subtle.importKey('jwk', publicKey, { name: 'ECDH', namedCurve: 'P-256' }, false, []);
+            this.peers.set(encrypted.from, senderKey);
+        }
+        const sharedKey = await crypto.subtle.deriveKey({ name: 'ECDH', public: senderKey }, this.myKeyPair.privateKey, { name: 'AES-GCM', length: 256 }, false, ['encrypt', 'decrypt']);
+        const iv = Buffer.from(encrypted.nonce, 'base64');
+        const ciphertext = Buffer.from(encrypted.ciphertext, 'base64');
+        const decrypted = await crypto.subtle.decrypt({ name: 'AES-GCM', iv }, sharedKey, ciphertext);
+        return new TextDecoder().decode(decrypted);
+    }
+}

package/package.json

@@ -1,20 +1,13 @@
 {
   "name": "@stvor/sdk",
-  "version": "2.0.0",
-  "description": "Stvor - is a security infrastructure for the quantum era.",
+  "version": "2.0.2",
+  "description": "STVOR DX Facade - Simple E2EE SDK for client-side encryption",
   "type": "module",
-  "main": "index.ts",
-  "types": "index.ts",
+  "main": "./dist/index.js",
   "exports": {
-    ".": {
-      "types": "./index.ts",
-      "import": "./index.ts"
-    },
-    "./facade": {
-      "types": "./facade/index.ts",
-      "import": "./facade/index.ts"
-    }
+    ".": "./dist/index.js"
   },
+  "files": ["dist"],
   "keywords": [
     "e2ee",
     "encryption",
@@ -30,5 +23,8 @@
   "bugs": {
     "url": "https://github.com/stvor/sdk/issues"
   },
-  "homepage": "https://stvor.xyz"
+  "homepage": "https://stvor.xyz",
+  "scripts": {
+    "build": "tsc"
+  }
 }