@msssystems/mss-link-sdk 0.2.3 → 0.2.5

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

@@ -2,6 +2,7 @@ import type { WasmMssClient } from '@msssystems/mss-crypto-wasm';
 import type { WasmEncryptedMediaBytes } from '../modules/media/media-crypto.contracts';
 export interface MssLinkWasmClient extends WasmMssClient {
     sendMediaMessage(chatId: string, targetUserId: string, metadataJson: string, mediaAssetIds: string[]): Promise<string>;
+    healSession(chatId: string, targetUserId: string): Promise<string>;
 }
 export type WasmMssClientConstructor = new (userId: string, deviceId: number, apiBaseUrl: string) => MssLinkWasmClient;
 export interface MssCryptoWasmModule {

package/dist/core/http-client.d.ts

@@ -2,7 +2,7 @@ export interface HttpClientOptions {
     baseUrl: string;
     token?: string | (() => string | Promise<string>) | undefined;
     fetch?: typeof fetch;
-    onUnauthorized?: (() => Promise<void>) | undefined;
+    onUnauthorized?: (() => Promise<string | null | void>) | undefined;
 }
 export declare class HttpClient {
     private baseUrl;
@@ -12,6 +12,12 @@ export declare class HttpClient {
     constructor(options: HttpClientOptions);
     setToken(token: string): Promise<void>;
     private getHeaders;
+    requestRaw(method: string, path: string, options?: {
+        body?: any;
+        params?: Record<string, any>;
+        headers?: Record<string, string>;
+        responseType?: 'json' | 'blob';
+    }): Promise<Response>;
     request<T>(method: string, path: string, options?: {
         body?: any;
         params?: Record<string, any>;

package/dist/core/http-client.js

@@ -27,7 +27,7 @@ export class HttpClient {
         }
         return headers;
     }
-    async request(method, path, options = {}) {
+    async requestRaw(method, path, options = {}) {
         const url = new URL(`${this.baseUrl}${path}`);
         if (options.params) {
             for (const [key, value] of Object.entries(options.params)) {
@@ -47,7 +47,10 @@ export class HttpClient {
         let response = await this.customFetch(url.toString(), fetchOptions);
         if (response.status === 401 && this.onUnauthorized) {
             try {
-                await this.onUnauthorized();
+                const newToken = await this.onUnauthorized();
+                if (typeof newToken === 'string') {
+                    this.setToken(newToken);
+                }
                 // Update headers with new token
                 fetchOptions.headers = await this.getHeaders(options.headers);
                 response = await this.customFetch(url.toString(), fetchOptions);
@@ -56,6 +59,10 @@ export class HttpClient {
                 // If refresh fails, let the original 401 error throw below
             }
         }
+        return response;
+    }
+    async request(method, path, options = {}) {
+        const response = await this.requestRaw(method, path, options);
         if (!response.ok) {
             let errorPayload;
             try {

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

@@ -10,5 +10,6 @@ export declare class MessagesCryptoClient {
         kind?: string;
     }): Promise<string>;
     syncMessages(): Promise<void>;
+    private handleSessionHealing;
     getLocalMessages(chatId: string): Promise<DecryptedMessage[]>;
 }

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

@@ -16,16 +16,38 @@ export class MessagesCryptoClient {
     }
     async syncMessages() {
         try {
-            await this.engine.runWithClient((client) => client.syncMessages());
+            await this.engine.runWithClient(async (client) => {
+                const rawMessages = await client.syncMessages();
+                await this.handleSessionHealing(client, rawMessages);
+            });
         }
         catch (error) {
             throw normalizeLocalCryptoError(error);
         }
     }
+    async handleSessionHealing(client, messages) {
+        for (const message of messages) {
+            if (message.deliveryState === 'FAILED' &&
+                (message.plaintext === '[Ошибка дешифровки]' ||
+                    message.plaintext === '[Ошибка дешифровки]')) {
+                if (message.kind === 'SYSTEM')
+                    continue;
+                console.warn(`[E2EE] Decryption failed for message ${message.messageId} from ${message.senderId}. Triggering auto-heal...`);
+                try {
+                    await client.healSession(message.chatId, message.senderId);
+                }
+                catch (e) {
+                    console.error('[E2EE] Failed to heal session:', e);
+                }
+            }
+        }
+    }
     async getLocalMessages(chatId) {
         try {
             const rawMessages = await this.engine.runWithClient((client) => client.getLocalMessages(chatId));
-            return rawMessages.map((message) => mapLocalSdkMessage(message));
+            return rawMessages
+                .filter((message) => message.kind !== 'SYSTEM')
+                .map((message) => mapLocalSdkMessage(message));
         }
         catch (error) {
             throw normalizeLocalCryptoError(error);

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

@@ -31,8 +31,8 @@ export class MessagesClient {
         return this.http.get(`/link/v1/media/assets/${assetId}/url`);
     }
     async downloadMediaAsset(assetId) {
-        const res = await fetch(`${this.http['baseUrl']}/link/v1/media/assets/${assetId}/download`, {
-            headers: await this.http['getHeaders']()
+        const res = await this.http.requestRaw('GET', `/link/v1/media/assets/${assetId}/download`, {
+            responseType: 'blob'
         });
         if (!res.ok)
             throw new Error('Download failed');

package/package.json

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