@msssystems/mss-link-sdk 0.1.3 → 0.1.6

package/dist/client/index.d.ts

@@ -3,6 +3,9 @@ export * from './client-options';
 export * from './decryption-errors';
 export * from './local-crypto-health';
 export * from './local-crypto-health.contracts';
+export * from './media-crypto.contracts';
+export * from './media-message.contracts';
+export * from './media-message-metadata';
 export * from './message.contracts';
 export * from './message-decryption.contracts';
 export * from './message-decryption-state';

package/dist/client/index.js

@@ -3,6 +3,9 @@ export * from './client-options';
 export * from './decryption-errors';
 export * from './local-crypto-health';
 export * from './local-crypto-health.contracts';
+export * from './media-crypto.contracts';
+export * from './media-message.contracts';
+export * from './media-message-metadata';
 export * from './message.contracts';
 export * from './message-decryption.contracts';
 export * from './message-decryption-state';

package/dist/client/media-crypto.contracts.d.ts

@@ -0,0 +1,28 @@
+import type { MediaMessageAttachmentEncryptionInput, MediaMessageAttachmentInput, MediaMessageAttachmentMetadata } from './media-message.contracts';
+export interface EncryptMediaBlobInput {
+    assetId: string;
+    blob: Blob;
+    mimeType: string;
+    size: string | number;
+    originalName?: string;
+    uploadedAt?: string;
+}
+export interface EncryptedMediaBlobResult {
+    encryptedBlob: Blob;
+    attachment: MediaMessageAttachmentInput;
+    encryption: MediaMessageAttachmentEncryptionInput;
+}
+export interface DecryptMediaBlobInput {
+    encryptedBlob: Blob;
+    metadata: MediaMessageAttachmentMetadata;
+}
+export interface DecryptedMediaBlobResult {
+    blob: Blob;
+    fileName?: string;
+    mimeType: string;
+}
+export interface WasmEncryptedMediaBytes {
+    ciphertext: Uint8Array;
+    key: string;
+    nonce: string;
+}

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

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

package/dist/client/media-message-metadata.d.ts

@@ -0,0 +1,4 @@
+import type { MediaMessageAttachmentInput, MediaMessageMetadataPayload } from './media-message.contracts';
+export declare function buildMediaMessageMetadataPayload(attachments: MediaMessageAttachmentInput[], caption?: string): MediaMessageMetadataPayload;
+export declare function serializeMediaMessageMetadata(payload: MediaMessageMetadataPayload): string;
+export declare function extractMediaAssetIds(attachments: MediaMessageAttachmentInput[]): string[];

package/dist/client/media-message-metadata.js

@@ -0,0 +1,93 @@
+export function buildMediaMessageMetadataPayload(attachments, caption) {
+    if (attachments.length === 0) {
+        throw new Error('Media message must contain at least one attachment.');
+    }
+    const payload = {
+        schema: 'mss.link.media-message.v1',
+        attachments: attachments.map(normalizeAttachment),
+    };
+    if (caption && caption.trim().length > 0) {
+        payload.caption = caption.trim();
+    }
+    return payload;
+}
+export function serializeMediaMessageMetadata(payload) {
+    return JSON.stringify({
+        schema: payload.schema,
+        attachments: payload.attachments.map((attachment) => ({
+            assetId: attachment.assetId,
+            mimeType: attachment.mimeType,
+            size: attachment.size,
+            ...(attachment.originalName
+                ? { originalName: attachment.originalName }
+                : {}),
+            ...(attachment.uploadedAt ? { uploadedAt: attachment.uploadedAt } : {}),
+            ...(attachment.encryption
+                ? { encryption: serializeAttachmentEncryption(attachment.encryption) }
+                : {}),
+        })),
+        ...(payload.caption ? { caption: payload.caption } : {}),
+    });
+}
+export function extractMediaAssetIds(attachments) {
+    return attachments.map((attachment) => attachment.assetId);
+}
+function normalizeAttachment(attachment) {
+    const assetId = attachment.assetId.trim();
+    const mimeType = attachment.mimeType.trim();
+    const size = String(attachment.size);
+    if (!assetId) {
+        throw new Error('Media attachment assetId is required.');
+    }
+    if (!mimeType) {
+        throw new Error('Media attachment mimeType is required.');
+    }
+    if (!size || size === 'NaN') {
+        throw new Error('Media attachment size is required.');
+    }
+    return {
+        assetId,
+        mimeType,
+        size,
+        ...(attachment.originalName?.trim()
+            ? { originalName: attachment.originalName.trim() }
+            : {}),
+        ...(attachment.uploadedAt?.trim()
+            ? { uploadedAt: attachment.uploadedAt.trim() }
+            : {}),
+        ...(attachment.encryption
+            ? { encryption: normalizeAttachmentEncryption(attachment.encryption) }
+            : {}),
+    };
+}
+function normalizeAttachmentEncryption(encryption) {
+    const keyId = encryption.keyId?.trim();
+    const nonce = encryption.nonce?.trim();
+    const wrappedKey = encryption.wrappedKey?.trim();
+    const algorithm = encryption.algorithm ?? 'AES-256-GCM';
+    if (algorithm !== 'AES-256-GCM') {
+        throw new Error('Unsupported media encryption algorithm.');
+    }
+    if (!nonce) {
+        throw new Error('Media encryption nonce is required.');
+    }
+    if (!wrappedKey) {
+        throw new Error('Media encryption wrappedKey is required.');
+    }
+    return {
+        schema: 'mss.link.media-encryption.v1',
+        algorithm,
+        ...(keyId ? { keyId } : {}),
+        nonce,
+        wrappedKey,
+    };
+}
+function serializeAttachmentEncryption(encryption) {
+    return {
+        schema: 'mss.link.media-encryption.v1',
+        algorithm: encryption.algorithm,
+        ...(encryption.keyId ? { keyId: encryption.keyId } : {}),
+        nonce: encryption.nonce,
+        wrappedKey: encryption.wrappedKey,
+    };
+}

package/dist/client/media-message.contracts.d.ts

@@ -0,0 +1,41 @@
+export interface MediaMessageAttachmentInput {
+    assetId: string;
+    mimeType: string;
+    size: string | number;
+    originalName?: string;
+    uploadedAt?: string;
+    encryption?: MediaMessageAttachmentEncryptionInput;
+}
+export interface MediaMessageAttachmentEncryptionInput {
+    schema?: 'mss.link.media-encryption.v1';
+    keyId?: string;
+    nonce?: string;
+    wrappedKey?: string;
+    algorithm?: 'AES-256-GCM';
+}
+export interface SendMediaMessageParams {
+    chatId: string;
+    targetUserId: string;
+    attachments: MediaMessageAttachmentInput[];
+    caption?: string;
+}
+export interface MediaMessageAttachmentMetadata {
+    assetId: string;
+    mimeType: string;
+    size: string;
+    originalName?: string;
+    uploadedAt?: string;
+    encryption?: MediaMessageAttachmentEncryptionMetadata;
+}
+export interface MediaMessageAttachmentEncryptionMetadata {
+    schema: 'mss.link.media-encryption.v1';
+    algorithm: 'AES-256-GCM';
+    keyId?: string;
+    nonce: string;
+    wrappedKey: string;
+}
+export interface MediaMessageMetadataPayload {
+    schema: 'mss.link.media-message.v1';
+    attachments: MediaMessageAttachmentMetadata[];
+    caption?: string;
+}

package/dist/client/media-message.contracts.js

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

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

@@ -1,5 +1,7 @@
 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';
 export declare class MssLinkBrowserClient {
     private readonly userId;
@@ -24,6 +26,9 @@ export declare class MssLinkBrowserClient {
         text: string;
         kind?: string;
     }): Promise<string>;
+    sendMediaMessage(params: SendMediaMessageParams): Promise<string>;
+    encryptMediaBlob(input: EncryptMediaBlobInput): Promise<EncryptedMediaBlobResult>;
+    decryptMediaBlob(input: DecryptMediaBlobInput): Promise<DecryptedMediaBlobResult>;
     syncMessages(): Promise<void>;
     getLocalMessages(chatId: string): Promise<DecryptedMessage[]>;
     reset(): void;

package/dist/client/mss-link-browser-client.js

@@ -1,6 +1,7 @@
 import { normalizeProductApiBaseUrl } from './api-base-url';
 import { normalizeLocalCryptoError } from './decryption-errors';
 import { checkLocalCryptoHealth } from './local-crypto-health';
+import { buildMediaMessageMetadataPayload, extractMediaAssetIds, serializeMediaMessageMetadata, } from './media-message-metadata';
 import { mapLocalSdkMessage } from './message.mapper';
 import { WasmCallQueue } from './wasm-call-queue';
 const DEFAULT_DEVICE_ID = 1;
@@ -67,6 +68,88 @@ export class MssLinkBrowserClient {
             throw normalizeLocalCryptoError(error);
         }
     }
+    async sendMediaMessage(params) {
+        try {
+            await this.ensureReady();
+            const payload = buildMediaMessageMetadataPayload(params.attachments, params.caption);
+            const metadataJson = serializeMediaMessageMetadata(payload);
+            const mediaAssetIds = extractMediaAssetIds(params.attachments);
+            return this.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.queue.run(async () => {
+                const module = await this.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.queue.run(async () => {
+                const module = await this.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);
+        }
+    }
     async syncMessages() {
         try {
             await this.runWithClient((client) => client.syncMessages());
@@ -104,7 +187,7 @@ export class MssLinkBrowserClient {
         return this.wasmClient;
     }
     loadWasmModule() {
-        this.wasmModulePromise ??= import('@msssystems/mss-crypto-wasm');
+        this.wasmModulePromise ??= import('@msssystems/mss-crypto-wasm').then((module) => module);
         return this.wasmModulePromise;
     }
 }

package/dist/client/wasm-client.types.d.ts

@@ -1,6 +1,12 @@
 import type { WasmMssClient } from '@msssystems/mss-crypto-wasm';
-export type WasmMssClientConstructor = new (userId: string, deviceId: number, apiBaseUrl: string) => WasmMssClient;
+import type { WasmEncryptedMediaBytes } from './media-crypto.contracts';
+export interface MssLinkWasmClient extends WasmMssClient {
+    sendMediaMessage(chatId: string, targetUserId: string, metadataJson: string, mediaAssetIds: string[]): Promise<string>;
+}
+export type WasmMssClientConstructor = new (userId: string, deviceId: number, apiBaseUrl: string) => MssLinkWasmClient;
 export interface MssCryptoWasmModule {
     WasmMssClient: WasmMssClientConstructor;
+    encryptMediaBytes(plaintext: Uint8Array): WasmEncryptedMediaBytes;
+    decryptMediaBytes(ciphertext: Uint8Array, key: string, nonce: string): Uint8Array;
 }
-export type WasmMssClientInstance = WasmMssClient;
+export type WasmMssClientInstance = MssLinkWasmClient;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@msssystems/mss-link-sdk",
-  "version": "0.1.3",
+  "version": "0.1.6",
   "description": "Official managed application SDK for MSS ecosystem",
   "type": "module",
   "main": "./dist/index.js",
@@ -53,7 +53,7 @@
     "registry": "https://registry.npmjs.org/"
   },
   "peerDependencies": {
-    "@msssystems/mss-crypto-wasm": "^0.1.16",
+    "@msssystems/mss-crypto-wasm": "^0.1.17",
     "@nestjs/common": "^10.0.0 || ^11.0.0",
     "@nestjs/core": "^10.0.0 || ^11.0.0",
     "express": "^4.0.0 || ^5.0.0",
@@ -77,7 +77,7 @@
     }
   },
   "devDependencies": {
-    "@msssystems/mss-crypto-wasm": "^0.1.16",
+    "@msssystems/mss-crypto-wasm": "^0.1.17",
     "@nestjs/common": "^11.0.1",
     "@nestjs/core": "^11.0.1",
     "@types/express": "^5.0.0",