@msssystems/mss-link-sdk 0.1.11 → 0.2.1

package/dist/modules/media/media-crypto.client.js

@@ -0,0 +1,90 @@
+import { normalizeLocalCryptoError } from '../../errors/decryption-errors';
+import { buildMediaMessageMetadataPayload, extractMediaAssetIds, serializeMediaMessageMetadata, } from './media-message-metadata';
+export class MediaCryptoClient {
+    engine;
+    constructor(engine) {
+        this.engine = engine;
+    }
+    async sendMediaMessage(params) {
+        try {
+            await this.engine.ensureReady();
+            const payload = buildMediaMessageMetadataPayload(params.attachments, params.caption);
+            const metadataJson = serializeMediaMessageMetadata(payload);
+            const mediaAssetIds = extractMediaAssetIds(params.attachments);
+            return this.engine.runWithClient((client) => client.sendMediaMessage(params.chatId, params.targetUserId, metadataJson, mediaAssetIds));
+        }
+        catch (error) {
+            throw normalizeLocalCryptoError(error);
+        }
+    }
+    async encryptMediaBlob(input) {
+        try {
+            const plaintext = new Uint8Array(await input.blob.arrayBuffer());
+            const encrypted = await this.engine.queue.run(async () => {
+                const module = await this.engine.loadWasmModule();
+                return module.encryptMediaBytes(plaintext);
+            });
+            const encryptedBytes = new Uint8Array(encrypted.ciphertext);
+            return {
+                encryptedBlob: new Blob([encryptedBytes], {
+                    type: 'application/octet-stream',
+                }),
+                encryption: {
+                    schema: 'mss.link.media-encryption.v1',
+                    algorithm: 'AES-256-GCM',
+                    keyId: input.assetId,
+                    nonce: encrypted.nonce,
+                    wrappedKey: encrypted.key,
+                },
+                attachment: {
+                    assetId: input.assetId,
+                    mimeType: input.mimeType,
+                    size: input.size,
+                    ...(input.originalName ? { originalName: input.originalName } : {}),
+                    ...(input.uploadedAt ? { uploadedAt: input.uploadedAt } : {}),
+                    encryption: {
+                        schema: 'mss.link.media-encryption.v1',
+                        algorithm: 'AES-256-GCM',
+                        keyId: input.assetId,
+                        nonce: encrypted.nonce,
+                        wrappedKey: encrypted.key,
+                    },
+                },
+            };
+        }
+        catch (error) {
+            throw normalizeLocalCryptoError(error);
+        }
+    }
+    async decryptMediaBlob(input) {
+        const encryption = input.metadata.encryption;
+        if (!encryption) {
+            return {
+                blob: input.encryptedBlob,
+                mimeType: input.metadata.mimeType,
+                ...(input.metadata.originalName
+                    ? { fileName: input.metadata.originalName }
+                    : {}),
+            };
+        }
+        try {
+            const ciphertext = new Uint8Array(await input.encryptedBlob.arrayBuffer());
+            const plaintext = await this.engine.queue.run(async () => {
+                const module = await this.engine.loadWasmModule();
+                return module.decryptMediaBytes(ciphertext, encryption.wrappedKey, encryption.nonce);
+            });
+            return {
+                blob: new Blob([new Uint8Array(plaintext)], {
+                    type: input.metadata.mimeType,
+                }),
+                mimeType: input.metadata.mimeType,
+                ...(input.metadata.originalName
+                    ? { fileName: input.metadata.originalName }
+                    : {}),
+            };
+        }
+        catch (error) {
+            throw normalizeLocalCryptoError(error);
+        }
+    }
+}

package/dist/{client → modules/messages}/message-decryption-state.js

@@ -1,4 +1,4 @@
-import { normalizeLocalCryptoError } from './decryption-errors';
+import { normalizeLocalCryptoError } from '../../errors/decryption-errors';
 export function createMessageDecryptionStateIndex({ messages, decryptedMessages, isDecrypting, decryptError, }) {
     const decryptedById = createDecryptedMessageIndex(decryptedMessages);
     const index = new Map();

package/dist/{client → modules/messages}/message-decryption.contracts.d.ts

@@ -1,4 +1,4 @@
-import type { LocalCryptoErrorCode } from './decryption-errors';
+import type { LocalCryptoErrorCode } from '../../errors/decryption-errors';
 import type { DecryptedMessage } from './message.contracts';
 export type MessageDecryptStatus = 'decrypted' | 'pending' | 'failed' | 'recovery_required';
 export type MessageDecryptReason = 'local_sync_in_progress' | 'local_message_missing' | 'local_crypto_error';

package/dist/modules/messages/messages-crypto.client.d.ts

@@ -0,0 +1,14 @@
+import { WasmCryptoEngine } from '../../core/wasm-crypto-engine';
+import type { DecryptedMessage } from './message.contracts';
+export declare class MessagesCryptoClient {
+    private readonly engine;
+    constructor(engine: WasmCryptoEngine);
+    sendMessage(params: {
+        chatId: string;
+        targetUserId: string;
+        text: string;
+        kind?: string;
+    }): Promise<string>;
+    syncMessages(): Promise<void>;
+    getLocalMessages(chatId: string): Promise<DecryptedMessage[]>;
+}

package/dist/modules/messages/messages-crypto.client.js

@@ -0,0 +1,34 @@
+import { normalizeLocalCryptoError } from '../../errors/decryption-errors';
+import { mapLocalSdkMessage } from './message.mapper';
+export class MessagesCryptoClient {
+    engine;
+    constructor(engine) {
+        this.engine = engine;
+    }
+    async sendMessage(params) {
+        try {
+            await this.engine.ensureReady();
+            return this.engine.runWithClient((client) => client.sendMessage(params.chatId, params.targetUserId, params.text, params.kind ?? 'TEXT'));
+        }
+        catch (error) {
+            throw normalizeLocalCryptoError(error);
+        }
+    }
+    async syncMessages() {
+        try {
+            await this.engine.runWithClient((client) => client.syncMessages());
+        }
+        catch (error) {
+            throw normalizeLocalCryptoError(error);
+        }
+    }
+    async getLocalMessages(chatId) {
+        try {
+            const rawMessages = await this.engine.runWithClient((client) => client.getLocalMessages(chatId));
+            return rawMessages.map((message) => mapLocalSdkMessage(message));
+        }
+        catch (error) {
+            throw normalizeLocalCryptoError(error);
+        }
+    }
+}

package/dist/modules/messages/messages.client.d.ts

@@ -0,0 +1,8 @@
+import { HttpClient } from '../../core/http-client';
+export declare class MessagesClient {
+    private readonly http;
+    constructor(http: HttpClient);
+    list(chatId: string, limit?: number, before?: string, after?: string): Promise<any>;
+    markDelivered(chatId: string, throughMessageId: string, limit?: number): Promise<any>;
+    markRead(chatId: string, throughMessageId: string, limit?: number): Promise<any>;
+}

package/dist/modules/messages/messages.client.js

@@ -0,0 +1,24 @@
+// TODO: Import proper types from contracts
+export class MessagesClient {
+    http;
+    constructor(http) {
+        this.http = http;
+    }
+    async list(chatId, limit = 30, before, after) {
+        return this.http.get(`/link/v1/chats/${chatId}/messages`, {
+            params: { limit, before, after }
+        });
+    }
+    async markDelivered(chatId, throughMessageId, limit) {
+        return this.http.post(`/link/v1/chats/${chatId}/messages/delivered`, {
+            throughMessageId,
+            limit
+        });
+    }
+    async markRead(chatId, throughMessageId, limit) {
+        return this.http.post(`/link/v1/chats/${chatId}/messages/read`, {
+            throughMessageId,
+            limit
+        });
+    }
+}

package/dist/{client → modules/storage}/drive-file-runtime.contracts.d.ts

@@ -1,5 +1,5 @@
-import type { DecryptedMediaBlobResult } from './media-crypto.contracts';
-import type { MediaMessageAttachmentMetadata } from './media-message.contracts';
+import type { DecryptedMediaBlobResult } from '../media/media-crypto.contracts';
+import type { MediaMessageAttachmentMetadata } from '../media/media-message.contracts';
 export type DriveFilePreviewKind = 'image' | 'pdf' | 'text' | 'unsupported' | 'video';
 export interface DriveFileContentEnvelope {
     algorithm?: 'AES-256-GCM' | string | null;

package/dist/{client → modules/storage}/drive-file-runtime.d.ts

@@ -1,4 +1,4 @@
-import type { DecryptedMediaBlobResult } from './media-crypto.contracts';
+import type { DecryptedMediaBlobResult } from '../media/media-crypto.contracts';
 import type { DriveFileAttachmentInput, DriveFileMediaMetadata, DriveFilePreviewInput, DriveFilePreviewKind, DriveFileRuntimeMetadataInput, PreparedDriveFileAttachment, PreparedDriveFilePreview } from './drive-file-runtime.contracts';
 export declare function buildDriveFileMediaMetadata(input: DriveFileRuntimeMetadataInput): DriveFileMediaMetadata;
 export declare function getDriveFilePreviewKind(mimeType: string): DriveFilePreviewKind;

package/dist/{client → modules/storage}/drive-key-wrapping.contracts.d.ts

@@ -1,6 +1,7 @@
 import type { DriveItemType, DriveWrappedItemKey } from './drive-sharing.contracts';
 export type DriveRecipientPublicKeyAlgorithm = 'X25519';
 export type DriveWrappedItemKeyAlgorithm = 'MSS-DRIVE-PUBLIC-KEY-WRAPPED-ITEM-KEY-v1';
+export type DriveItemKeyMaterialKind = 'content-key' | 'folder-metadata-envelope';
 export interface DriveRecipientPublicKey {
     algorithm: DriveRecipientPublicKeyAlgorithm;
     keyId: string;
@@ -14,6 +15,7 @@ export interface DriveRecipientKeyTarget {
 }
 export interface DriveItemContentKeyEnvelope {
     algorithm?: 'AES-256-GCM' | string | null;
+    keyMaterialKind?: DriveItemKeyMaterialKind | string | null;
     keyId?: string | null;
     nonce?: string | null;
     wrappedKey: string;
@@ -39,10 +41,20 @@ export interface CreateDriveWrappedItemKeyForRecipientInput {
     recipient: DriveRecipientKeyTarget;
     wrappingAdapter: DrivePublicKeyWrappingAdapter;
 }
+export interface CreateDriveWrappedFolderKeyForRecipientInput {
+    encryptedFolderMetadata: {
+        encryptedName: string;
+        schema?: 'mss.link.drive-folder-metadata.v1' | string;
+    };
+    folderId: string;
+    recipient: DriveRecipientKeyTarget;
+    wrappingAdapter: DrivePublicKeyWrappingAdapter;
+}
 export interface DriveWrappedItemKeyPayload {
     contentAlgorithm: string;
     contentKey: string;
     contentKeyId?: string;
+    contentKeyMaterialKind: DriveItemKeyMaterialKind;
     contentNonce?: string;
     createdAt: string;
     itemId: string;

package/dist/modules/storage/drive-key-wrapping.d.ts

@@ -0,0 +1,3 @@
+import type { CreateDriveWrappedFolderKeyForRecipientInput, CreateDriveWrappedItemKeyForRecipientInput, DriveWrappedItemKeyForRecipientResult } from './drive-key-wrapping.contracts';
+export declare function createDriveWrappedItemKeyForRecipient(input: CreateDriveWrappedItemKeyForRecipientInput): Promise<DriveWrappedItemKeyForRecipientResult>;
+export declare function createDriveWrappedFolderKeyForRecipient(input: CreateDriveWrappedFolderKeyForRecipientInput): Promise<DriveWrappedItemKeyForRecipientResult>;

package/dist/{client → modules/storage}/drive-key-wrapping.js

@@ -1,5 +1,7 @@
+import { normalizeEncryptedDriveFolderMetadataInput } from './storage-metadata-crypto';
 const CONTENT_KEY_SCHEMA = 'mss.link.drive.item-key.v1';
 const WRAPPED_ITEM_KEY_ALGORITHM = 'MSS-DRIVE-PUBLIC-KEY-WRAPPED-ITEM-KEY-v1';
+const FOLDER_METADATA_KEY_ID_PREFIX = 'drive-folder-metadata';
 export async function createDriveWrappedItemKeyForRecipient(input) {
     const itemId = normalizeRequiredText(input.itemId, 'Drive item id is required for key wrapping.');
     const itemType = input.itemType;
@@ -29,6 +31,24 @@ export async function createDriveWrappedItemKeyForRecipient(input) {
         }),
     };
 }
+export function createDriveWrappedFolderKeyForRecipient(input) {
+    const folderId = normalizeRequiredText(input.folderId, 'Drive folder id is required for key wrapping.');
+    const metadata = normalizeEncryptedDriveFolderMetadataInput({
+        encryptedName: input.encryptedFolderMetadata.encryptedName,
+    });
+    return createDriveWrappedItemKeyForRecipient({
+        contentKey: {
+            algorithm: 'AES-256-GCM',
+            keyId: `${FOLDER_METADATA_KEY_ID_PREFIX}:${folderId}`,
+            keyMaterialKind: 'folder-metadata-envelope',
+            wrappedKey: metadata.encryptedName,
+        },
+        itemId: folderId,
+        itemType: 'folder',
+        recipient: input.recipient,
+        wrappingAdapter: input.wrappingAdapter,
+    });
+}
 function buildWrappedItemKeyPayload({ contentKey, itemId, itemType, }) {
     return {
         schema: CONTENT_KEY_SCHEMA,
@@ -36,6 +56,7 @@ function buildWrappedItemKeyPayload({ contentKey, itemId, itemType, }) {
         itemType,
         contentAlgorithm: contentKey.algorithm,
         contentKey: contentKey.wrappedKey,
+        contentKeyMaterialKind: contentKey.keyMaterialKind,
         createdAt: new Date().toISOString(),
         ...(contentKey.keyId ? { contentKeyId: contentKey.keyId } : {}),
         ...(contentKey.nonce ? { contentNonce: contentKey.nonce } : {}),
@@ -74,10 +95,19 @@ function normalizeContentKey(contentKey) {
     return {
         algorithm,
         keyId: normalizeOptionalText(contentKey.keyId) ?? '',
+        keyMaterialKind: normalizeKeyMaterialKind(contentKey.keyMaterialKind),
         nonce: normalizeOptionalText(contentKey.nonce) ?? '',
         wrappedKey: normalizeRequiredText(contentKey.wrappedKey, 'Drive item content key is required.'),
     };
 }
+function normalizeKeyMaterialKind(kind) {
+    const normalized = normalizeOptionalText(kind) ?? 'content-key';
+    if (normalized !== 'content-key' &&
+        normalized !== 'folder-metadata-envelope') {
+        throw new Error(`Unsupported Drive item key material kind: ${normalized}`);
+    }
+    return normalized;
+}
 function normalizeWrappingAdapter(adapter) {
     if (!adapter || typeof adapter.wrapDriveItemKey !== 'function') {
         throw new Error('Drive public-key wrapping adapter is not configured.');

package/dist/modules/storage/drive-sharing.contracts.js

@@ -0,0 +1 @@
+export {};

package/dist/modules/storage/storage-crypto.client.d.ts

@@ -0,0 +1,13 @@
+import { WasmCryptoEngine } from '../../core/wasm-crypto-engine';
+import type { DecryptDriveFileMetadataInput, DecryptDriveFolderMetadataInput, DecryptedDriveFileMetadata, DecryptedDriveFolderMetadata, EncryptedDriveFileMetadata, EncryptedDriveFolderMetadata, EncryptDriveFileMetadataInput, EncryptDriveFolderMetadataInput } from './storage-metadata-crypto.contracts';
+import type { CreateDriveWrappedFolderKeyForRecipientInput, CreateDriveWrappedItemKeyForRecipientInput, DriveWrappedItemKeyForRecipientResult } from './drive-key-wrapping.contracts';
+export declare class StorageCryptoClient {
+    private readonly engine;
+    constructor(engine: WasmCryptoEngine);
+    encryptDriveFolderMetadata(input: EncryptDriveFolderMetadataInput): Promise<EncryptedDriveFolderMetadata>;
+    decryptDriveFolderMetadata(input: DecryptDriveFolderMetadataInput): Promise<DecryptedDriveFolderMetadata>;
+    encryptDriveFileMetadata(input: EncryptDriveFileMetadataInput): Promise<EncryptedDriveFileMetadata>;
+    decryptDriveFileMetadata(input: DecryptDriveFileMetadataInput): Promise<DecryptedDriveFileMetadata>;
+    createDriveWrappedItemKeyForRecipient(input: CreateDriveWrappedItemKeyForRecipientInput): Promise<DriveWrappedItemKeyForRecipientResult>;
+    createDriveWrappedFolderKeyForRecipient(input: CreateDriveWrappedFolderKeyForRecipientInput): Promise<DriveWrappedItemKeyForRecipientResult>;
+}

package/dist/modules/storage/storage-crypto.client.js

@@ -0,0 +1,73 @@
+import { normalizeLocalCryptoError } from '../../errors/decryption-errors';
+import { buildDecryptedDriveFileMetadata, buildDecryptedDriveFolderMetadata, buildEncryptedDriveFileMetadata, buildEncryptedDriveFolderMetadata, normalizeDriveFileMetadataInput, normalizeDriveFolderMetadataInput, normalizeEncryptedDriveFileMetadataInput, normalizeEncryptedDriveFolderMetadataInput, } from './storage-metadata-crypto';
+import { createDriveWrappedFolderKeyForRecipient, createDriveWrappedItemKeyForRecipient, } from './drive-key-wrapping';
+export class StorageCryptoClient {
+    engine;
+    constructor(engine) {
+        this.engine = engine;
+    }
+    async encryptDriveFolderMetadata(input) {
+        try {
+            const metadata = normalizeDriveFolderMetadataInput(input);
+            const encryptedName = await this.engine.queue.run(async () => {
+                const module = await this.engine.loadWasmModule();
+                return module.encryptStorageMetadata(metadata.name);
+            });
+            return buildEncryptedDriveFolderMetadata(encryptedName);
+        }
+        catch (error) {
+            throw normalizeLocalCryptoError(error);
+        }
+    }
+    async decryptDriveFolderMetadata(input) {
+        try {
+            const metadata = normalizeEncryptedDriveFolderMetadataInput(input);
+            const name = await this.engine.queue.run(async () => {
+                const module = await this.engine.loadWasmModule();
+                return module.decryptStorageMetadata(metadata.encryptedName);
+            });
+            return buildDecryptedDriveFolderMetadata(name);
+        }
+        catch (error) {
+            throw normalizeLocalCryptoError(error);
+        }
+    }
+    async encryptDriveFileMetadata(input) {
+        try {
+            const metadata = normalizeDriveFileMetadataInput(input);
+            const [encryptedName, encryptedMimeType] = await this.engine.queue.run(async () => {
+                const module = await this.engine.loadWasmModule();
+                return [
+                    module.encryptStorageMetadata(metadata.name),
+                    module.encryptStorageMetadata(metadata.mimeType),
+                ];
+            });
+            return buildEncryptedDriveFileMetadata(encryptedName, encryptedMimeType);
+        }
+        catch (error) {
+            throw normalizeLocalCryptoError(error);
+        }
+    }
+    async decryptDriveFileMetadata(input) {
+        try {
+            const metadata = normalizeEncryptedDriveFileMetadataInput(input);
+            const [name, mimeType] = await this.engine.queue.run(async () => {
+                const module = await this.engine.loadWasmModule();
+                return [
+                    module.decryptStorageMetadata(metadata.encryptedName),
+                    module.decryptStorageMetadata(metadata.encryptedMimeType),
+                ];
+            });
+            return buildDecryptedDriveFileMetadata(name, mimeType);
+        }
+        catch (error) {
+            throw normalizeLocalCryptoError(error);
+        }
+    }
+    createDriveWrappedItemKeyForRecipient(input) {
+        return createDriveWrappedItemKeyForRecipient(input);
+    }
+    createDriveWrappedFolderKeyForRecipient(input) {
+        return createDriveWrappedFolderKeyForRecipient(input);
+    }
+}

package/dist/modules/storage/storage-metadata-crypto.contracts.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@msssystems/mss-link-sdk",
-  "version": "0.1.11",
+  "version": "0.2.1",
   "description": "Official managed application SDK for MSS ecosystem",
   "type": "module",
   "main": "./dist/index.js",

package/dist/client/drive-key-wrapping.d.ts

@@ -1,2 +0,0 @@
-import type { CreateDriveWrappedItemKeyForRecipientInput, DriveWrappedItemKeyForRecipientResult } from './drive-key-wrapping.contracts';
-export declare function createDriveWrappedItemKeyForRecipient(input: CreateDriveWrappedItemKeyForRecipientInput): Promise<DriveWrappedItemKeyForRecipientResult>;

package/dist/client/mss-link-browser-client.d.ts

@@ -1,45 +0,0 @@
-import type { MssLinkBrowserClientOptions } from './client-options';
-import type { LocalCryptoHealth } from './local-crypto-health.contracts';
-import type { DecryptMediaBlobInput, DecryptedMediaBlobResult, EncryptedMediaBlobResult, EncryptMediaBlobInput } from './media-crypto.contracts';
-import type { SendMediaMessageParams } from './media-message.contracts';
-import type { DecryptedMessage } from './message.contracts';
-import type { DecryptDriveFileMetadataInput, DecryptDriveFolderMetadataInput, DecryptedDriveFileMetadata, DecryptedDriveFolderMetadata, EncryptedDriveFileMetadata, EncryptedDriveFolderMetadata, EncryptDriveFileMetadataInput, EncryptDriveFolderMetadataInput } from './storage-metadata-crypto.contracts';
-import type { CreateDriveWrappedItemKeyForRecipientInput, DriveWrappedItemKeyForRecipientResult } from './drive-key-wrapping.contracts';
-export declare class MssLinkBrowserClient {
-    private readonly userId;
-    private readonly apiBaseUrl;
-    private readonly deviceId;
-    private readonly registrationId;
-    private readonly signedPrekeyId;
-    private readonly initialOneTimePrekeyCount;
-    private readonly minOneTimePrekeys;
-    private readonly replenishOneTimePrekeys;
-    private readonly queue;
-    private wasmClient;
-    private wasmModulePromise;
-    private accessToken;
-    constructor(options: MssLinkBrowserClientOptions);
-    setAccessToken(accessToken: string | null): void;
-    ensureReady(): Promise<void>;
-    getLocalCryptoHealth(): Promise<LocalCryptoHealth>;
-    sendMessage(params: {
-        chatId: string;
-        targetUserId: string;
-        text: string;
-        kind?: string;
-    }): Promise<string>;
-    sendMediaMessage(params: SendMediaMessageParams): Promise<string>;
-    encryptMediaBlob(input: EncryptMediaBlobInput): Promise<EncryptedMediaBlobResult>;
-    decryptMediaBlob(input: DecryptMediaBlobInput): Promise<DecryptedMediaBlobResult>;
-    encryptDriveFolderMetadata(input: EncryptDriveFolderMetadataInput): Promise<EncryptedDriveFolderMetadata>;
-    decryptDriveFolderMetadata(input: DecryptDriveFolderMetadataInput): Promise<DecryptedDriveFolderMetadata>;
-    encryptDriveFileMetadata(input: EncryptDriveFileMetadataInput): Promise<EncryptedDriveFileMetadata>;
-    decryptDriveFileMetadata(input: DecryptDriveFileMetadataInput): Promise<DecryptedDriveFileMetadata>;
-    createDriveWrappedItemKeyForRecipient(input: CreateDriveWrappedItemKeyForRecipientInput): Promise<DriveWrappedItemKeyForRecipientResult>;
-    syncMessages(): Promise<void>;
-    getLocalMessages(chatId: string): Promise<DecryptedMessage[]>;
-    reset(): void;
-    private runWithClient;
-    private getClient;
-    private loadWasmModule;
-}