@msssystems/mss-link-sdk 0.1.6 → 0.1.8

package/dist/client/drive-file-runtime.contracts.d.ts

@@ -0,0 +1,39 @@
+import type { DecryptedMediaBlobResult } from './media-crypto.contracts';
+import type { MediaMessageAttachmentMetadata } from './media-message.contracts';
+export type DriveFilePreviewKind = 'image' | 'pdf' | 'text' | 'unsupported' | 'video';
+export interface DriveFileContentEnvelope {
+    algorithm?: 'AES-256-GCM' | string | null;
+    keyId?: string | null;
+    nonce?: string | null;
+    wrappedKey?: string | null;
+}
+export interface DriveFileRuntimeMetadataInput {
+    fileName: string;
+    mimeType: string;
+    size: number | string;
+    storageKey: string;
+    encryption: DriveFileContentEnvelope;
+}
+export interface DriveFileAttachmentInput {
+    decrypted: DecryptedMediaBlobResult;
+    fallbackFileName?: string;
+    fallbackMimeType?: string;
+}
+export interface DriveFilePreviewInput {
+    decrypted: DecryptedMediaBlobResult;
+    fallbackFileName?: string;
+    fallbackMimeType?: string;
+}
+export interface PreparedDriveFileAttachment {
+    file: File;
+    fileName: string;
+    mimeType: string;
+}
+export interface PreparedDriveFilePreview {
+    blob: Blob;
+    fileName: string;
+    kind: DriveFilePreviewKind;
+    mimeType: string;
+    text?: string;
+}
+export type DriveFileMediaMetadata = MediaMessageAttachmentMetadata;

package/dist/client/drive-file-runtime.contracts.js

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

package/dist/client/drive-file-runtime.d.ts

@@ -0,0 +1,8 @@
+import type { DecryptedMediaBlobResult } from './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;
+export declare function prepareDriveFileAttachment({ decrypted, fallbackFileName, fallbackMimeType, }: DriveFileAttachmentInput): PreparedDriveFileAttachment;
+export declare function prepareDriveFilePreview({ decrypted, fallbackFileName, fallbackMimeType, }: DriveFilePreviewInput): Promise<PreparedDriveFilePreview>;
+export declare function getDecryptedFileName(decrypted: DecryptedMediaBlobResult, fallbackFileName?: string): string;
+export declare function getDecryptedMimeType(decrypted: DecryptedMediaBlobResult, fallbackMimeType?: string): string;

package/dist/client/drive-file-runtime.js

@@ -0,0 +1,94 @@
+const DEFAULT_FILE_NAME = 'attachment';
+const DEFAULT_MIME_TYPE = 'application/octet-stream';
+export function buildDriveFileMediaMetadata(input) {
+    const fileName = normalizeOptionalText(input.fileName) ?? DEFAULT_FILE_NAME;
+    const mimeType = normalizeOptionalText(input.mimeType) ?? DEFAULT_MIME_TYPE;
+    const nonce = normalizeRequiredText(input.encryption.nonce, 'Drive file encryption nonce is required.');
+    const wrappedKey = normalizeRequiredText(input.encryption.wrappedKey, 'Drive file wrapped content key is required.');
+    return {
+        assetId: normalizeRequiredText(input.storageKey, 'Drive file storage key is required.'),
+        mimeType,
+        originalName: fileName,
+        size: String(input.size),
+        encryption: {
+            schema: 'mss.link.media-encryption.v1',
+            algorithm: normalizeDriveFileContentAlgorithm(input.encryption.algorithm),
+            ...(input.encryption.keyId ? { keyId: input.encryption.keyId } : {}),
+            nonce,
+            wrappedKey,
+        },
+    };
+}
+export function getDriveFilePreviewKind(mimeType) {
+    const normalizedMimeType = normalizeOptionalText(mimeType) ?? DEFAULT_MIME_TYPE;
+    if (normalizedMimeType.startsWith('image/')) {
+        return 'image';
+    }
+    if (normalizedMimeType.startsWith('video/')) {
+        return 'video';
+    }
+    if (normalizedMimeType === 'application/pdf') {
+        return 'pdf';
+    }
+    if (normalizedMimeType.startsWith('text/') ||
+        normalizedMimeType.includes('json')) {
+        return 'text';
+    }
+    return 'unsupported';
+}
+export function prepareDriveFileAttachment({ decrypted, fallbackFileName, fallbackMimeType, }) {
+    const fileName = getDecryptedFileName(decrypted, fallbackFileName);
+    const mimeType = getDecryptedMimeType(decrypted, fallbackMimeType);
+    return {
+        file: new File([decrypted.blob], fileName, { type: mimeType }),
+        fileName,
+        mimeType,
+    };
+}
+export async function prepareDriveFilePreview({ decrypted, fallbackFileName, fallbackMimeType, }) {
+    const fileName = getDecryptedFileName(decrypted, fallbackFileName);
+    const mimeType = getDecryptedMimeType(decrypted, fallbackMimeType);
+    const kind = getDriveFilePreviewKind(mimeType);
+    if (kind === 'text') {
+        return {
+            blob: decrypted.blob,
+            fileName,
+            kind,
+            mimeType,
+            text: await decrypted.blob.text(),
+        };
+    }
+    return {
+        blob: decrypted.blob,
+        fileName,
+        kind,
+        mimeType,
+    };
+}
+export function getDecryptedFileName(decrypted, fallbackFileName) {
+    return (normalizeOptionalText(decrypted.fileName) ??
+        normalizeOptionalText(fallbackFileName) ??
+        DEFAULT_FILE_NAME);
+}
+export function getDecryptedMimeType(decrypted, fallbackMimeType) {
+    return (normalizeOptionalText(decrypted.mimeType) ??
+        normalizeOptionalText(fallbackMimeType) ??
+        DEFAULT_MIME_TYPE);
+}
+function normalizeDriveFileContentAlgorithm(algorithm) {
+    if (!algorithm || algorithm === 'AES-256-GCM') {
+        return 'AES-256-GCM';
+    }
+    throw new Error(`Unsupported Drive file encryption algorithm: ${algorithm}`);
+}
+function normalizeRequiredText(value, message) {
+    const normalized = normalizeOptionalText(value);
+    if (!normalized) {
+        throw new Error(message);
+    }
+    return normalized;
+}
+function normalizeOptionalText(value) {
+    const normalized = value?.trim();
+    return normalized ? normalized : undefined;
+}

package/dist/client/index.d.ts

@@ -1,6 +1,8 @@
 export * from './api-base-url';
 export * from './client-options';
 export * from './decryption-errors';
+export * from './drive-file-runtime';
+export * from './drive-file-runtime.contracts';
 export * from './local-crypto-health';
 export * from './local-crypto-health.contracts';
 export * from './media-crypto.contracts';
@@ -11,3 +13,5 @@ export * from './message-decryption.contracts';
 export * from './message-decryption-state';
 export * from './message.mapper';
 export * from './mss-link-browser-client';
+export * from './storage-metadata-crypto';
+export * from './storage-metadata-crypto.contracts';

package/dist/client/index.js

@@ -1,6 +1,8 @@
 export * from './api-base-url';
 export * from './client-options';
 export * from './decryption-errors';
+export * from './drive-file-runtime';
+export * from './drive-file-runtime.contracts';
 export * from './local-crypto-health';
 export * from './local-crypto-health.contracts';
 export * from './media-crypto.contracts';
@@ -11,3 +13,5 @@ export * from './message-decryption.contracts';
 export * from './message-decryption-state';
 export * from './message.mapper';
 export * from './mss-link-browser-client';
+export * from './storage-metadata-crypto';
+export * from './storage-metadata-crypto.contracts';

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

@@ -3,6 +3,7 @@ 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';
 export declare class MssLinkBrowserClient {
     private readonly userId;
     private readonly apiBaseUrl;
@@ -29,6 +30,10 @@ export declare class MssLinkBrowserClient {
     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>;
     syncMessages(): Promise<void>;
     getLocalMessages(chatId: string): Promise<DecryptedMessage[]>;
     reset(): void;

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

@@ -3,6 +3,7 @@ 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 { buildDecryptedDriveFileMetadata, buildDecryptedDriveFolderMetadata, buildEncryptedDriveFileMetadata, buildEncryptedDriveFolderMetadata, normalizeDriveFileMetadataInput, normalizeDriveFolderMetadataInput, normalizeEncryptedDriveFileMetadataInput, normalizeEncryptedDriveFolderMetadataInput, } from './storage-metadata-crypto';
 import { WasmCallQueue } from './wasm-call-queue';
 const DEFAULT_DEVICE_ID = 1;
 const DEFAULT_REGISTRATION_ID = 1;
@@ -150,6 +151,64 @@ export class MssLinkBrowserClient {
             throw normalizeLocalCryptoError(error);
         }
     }
+    async encryptDriveFolderMetadata(input) {
+        try {
+            const metadata = normalizeDriveFolderMetadataInput(input);
+            const encryptedName = await this.queue.run(async () => {
+                const module = await this.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.queue.run(async () => {
+                const module = await this.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.queue.run(async () => {
+                const module = await this.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.queue.run(async () => {
+                const module = await this.loadWasmModule();
+                return [
+                    module.decryptStorageMetadata(metadata.encryptedName),
+                    module.decryptStorageMetadata(metadata.encryptedMimeType),
+                ];
+            });
+            return buildDecryptedDriveFileMetadata(name, mimeType);
+        }
+        catch (error) {
+            throw normalizeLocalCryptoError(error);
+        }
+    }
     async syncMessages() {
         try {
             await this.runWithClient((client) => client.syncMessages());

package/dist/client/storage-metadata-crypto.contracts.d.ts

@@ -0,0 +1,30 @@
+export interface EncryptDriveFolderMetadataInput {
+    name: string;
+}
+export interface EncryptedDriveFolderMetadata {
+    schema: 'mss.link.drive-folder-metadata.v1';
+    encryptedName: string;
+}
+export interface DecryptDriveFolderMetadataInput {
+    encryptedName: string;
+}
+export interface DecryptedDriveFolderMetadata {
+    name: string;
+}
+export interface EncryptDriveFileMetadataInput {
+    name: string;
+    mimeType: string;
+}
+export interface EncryptedDriveFileMetadata {
+    schema: 'mss.link.drive-file-metadata.v1';
+    encryptedName: string;
+    encryptedMimeType: string;
+}
+export interface DecryptDriveFileMetadataInput {
+    encryptedName: string;
+    encryptedMimeType: string;
+}
+export interface DecryptedDriveFileMetadata {
+    mimeType: string;
+    name: string;
+}

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

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

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

@@ -0,0 +1,9 @@
+import type { DecryptDriveFileMetadataInput, DecryptDriveFolderMetadataInput, DecryptedDriveFileMetadata, DecryptedDriveFolderMetadata, EncryptedDriveFileMetadata, EncryptedDriveFolderMetadata, EncryptDriveFileMetadataInput, EncryptDriveFolderMetadataInput } from './storage-metadata-crypto.contracts';
+export declare function normalizeDriveFolderMetadataInput(input: EncryptDriveFolderMetadataInput): EncryptDriveFolderMetadataInput;
+export declare function normalizeDriveFileMetadataInput(input: EncryptDriveFileMetadataInput): EncryptDriveFileMetadataInput;
+export declare function buildEncryptedDriveFolderMetadata(encryptedName: string): EncryptedDriveFolderMetadata;
+export declare function buildEncryptedDriveFileMetadata(encryptedName: string, encryptedMimeType: string): EncryptedDriveFileMetadata;
+export declare function normalizeEncryptedDriveFolderMetadataInput(input: DecryptDriveFolderMetadataInput): DecryptDriveFolderMetadataInput;
+export declare function normalizeEncryptedDriveFileMetadataInput(input: DecryptDriveFileMetadataInput): DecryptDriveFileMetadataInput;
+export declare function buildDecryptedDriveFolderMetadata(name: string): DecryptedDriveFolderMetadata;
+export declare function buildDecryptedDriveFileMetadata(name: string, mimeType: string): DecryptedDriveFileMetadata;

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

@@ -0,0 +1,76 @@
+export function normalizeDriveFolderMetadataInput(input) {
+    const name = input.name.trim();
+    if (!name) {
+        throw new Error('Drive folder name is required.');
+    }
+    return { name };
+}
+export function normalizeDriveFileMetadataInput(input) {
+    const name = input.name.trim();
+    const mimeType = input.mimeType.trim();
+    if (!name) {
+        throw new Error('Drive file name is required.');
+    }
+    if (!mimeType) {
+        throw new Error('Drive file mimeType is required.');
+    }
+    return { mimeType, name };
+}
+export function buildEncryptedDriveFolderMetadata(encryptedName) {
+    const normalizedName = normalizeEncryptedField(encryptedName, 'encryptedName');
+    return {
+        schema: 'mss.link.drive-folder-metadata.v1',
+        encryptedName: normalizedName,
+    };
+}
+export function buildEncryptedDriveFileMetadata(encryptedName, encryptedMimeType) {
+    const normalizedName = normalizeEncryptedField(encryptedName, 'encryptedName');
+    const normalizedMimeType = normalizeEncryptedField(encryptedMimeType, 'encryptedMimeType');
+    return {
+        schema: 'mss.link.drive-file-metadata.v1',
+        encryptedName: normalizedName,
+        encryptedMimeType: normalizedMimeType,
+    };
+}
+export function normalizeEncryptedDriveFolderMetadataInput(input) {
+    return {
+        encryptedName: normalizeEncryptedField(input.encryptedName, 'encryptedName'),
+    };
+}
+export function normalizeEncryptedDriveFileMetadataInput(input) {
+    return {
+        encryptedName: normalizeEncryptedField(input.encryptedName, 'encryptedName'),
+        encryptedMimeType: normalizeEncryptedField(input.encryptedMimeType, 'encryptedMimeType'),
+    };
+}
+export function buildDecryptedDriveFolderMetadata(name) {
+    const normalizedName = name.trim();
+    if (!normalizedName) {
+        throw new Error('Decrypted drive folder name is empty.');
+    }
+    return { name: normalizedName };
+}
+export function buildDecryptedDriveFileMetadata(name, mimeType) {
+    const normalizedName = name.trim();
+    const normalizedMimeType = mimeType.trim();
+    if (!normalizedName) {
+        throw new Error('Decrypted drive file name is empty.');
+    }
+    if (!normalizedMimeType) {
+        throw new Error('Decrypted drive file mimeType is empty.');
+    }
+    return {
+        mimeType: normalizedMimeType,
+        name: normalizedName,
+    };
+}
+function normalizeEncryptedField(value, fieldName) {
+    const normalized = value.trim();
+    if (!normalized) {
+        throw new Error(`Drive metadata ${fieldName} is required.`);
+    }
+    if (!/^[0-9a-f]+$/i.test(normalized)) {
+        throw new Error(`Drive metadata ${fieldName} must be hexadecimal.`);
+    }
+    return normalized;
+}

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

@@ -6,7 +6,9 @@ export interface MssLinkWasmClient extends WasmMssClient {
 export type WasmMssClientConstructor = new (userId: string, deviceId: number, apiBaseUrl: string) => MssLinkWasmClient;
 export interface MssCryptoWasmModule {
     WasmMssClient: WasmMssClientConstructor;
+    decryptStorageMetadata(encryptedHex: string): string;
     encryptMediaBytes(plaintext: Uint8Array): WasmEncryptedMediaBytes;
+    encryptStorageMetadata(plaintext: string): string;
     decryptMediaBytes(ciphertext: Uint8Array, key: string, nonce: string): Uint8Array;
 }
 export type WasmMssClientInstance = MssLinkWasmClient;

package/package.json

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