@droponair/sdk-js 0.3.0

package/dist/core/bytes.d.ts

@@ -0,0 +1,8 @@
+export declare function utf8Encode(value: string): Uint8Array;
+export declare function utf8Decode(value: Uint8Array): string;
+export declare function toBase64(value: Uint8Array): string;
+export declare function fromBase64(value: string): Uint8Array;
+export declare function randomBytes(length: number): Uint8Array;
+export declare function concatBytes(...parts: Uint8Array[]): Uint8Array;
+export declare function isJwtExpired(jwt: string): boolean;
+export declare function parseJwtPayload(jwt: string): Record<string, unknown>;

package/dist/core/bytes.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.utf8Encode = utf8Encode;
+exports.utf8Decode = utf8Decode;
+exports.toBase64 = toBase64;
+exports.fromBase64 = fromBase64;
+exports.randomBytes = randomBytes;
+exports.concatBytes = concatBytes;
+exports.isJwtExpired = isJwtExpired;
+exports.parseJwtPayload = parseJwtPayload;
+function utf8Encode(value) {
+    return new TextEncoder().encode(value);
+}
+function utf8Decode(value) {
+    return new TextDecoder().decode(value);
+}
+function toBase64(value) {
+    if (typeof Buffer !== 'undefined') {
+        return Buffer.from(value).toString('base64');
+    }
+    let binary = '';
+    for (let i = 0; i < value.length; i += 1) {
+        binary += String.fromCharCode(value[i]);
+    }
+    return btoa(binary);
+}
+function fromBase64(value) {
+    if (typeof Buffer !== 'undefined') {
+        return new Uint8Array(Buffer.from(value, 'base64'));
+    }
+    const binary = atob(value);
+    const out = new Uint8Array(binary.length);
+    for (let i = 0; i < binary.length; i += 1) {
+        out[i] = binary.charCodeAt(i);
+    }
+    return out;
+}
+function randomBytes(length) {
+    const arr = new Uint8Array(length);
+    crypto.getRandomValues(arr);
+    return arr;
+}
+function concatBytes(...parts) {
+    const totalLength = parts.reduce((sum, p) => sum + p.length, 0);
+    const out = new Uint8Array(totalLength);
+    let offset = 0;
+    for (const part of parts) {
+        out.set(part, offset);
+        offset += part.length;
+    }
+    return out;
+}
+function isJwtExpired(jwt) {
+    const payload = parseJwtPayload(jwt);
+    if (typeof payload.exp !== 'number') {
+        return true;
+    }
+    const nowSeconds = Math.floor(Date.now() / 1000);
+    return payload.exp <= nowSeconds;
+}
+function parseJwtPayload(jwt) {
+    const parts = jwt.split('.');
+    if (parts.length < 2) {
+        throw new Error('Invalid JWT format');
+    }
+    const payloadPart = parts[1]
+        .replace(/-/g, '+')
+        .replace(/_/g, '/');
+    let padded = payloadPart;
+    while (padded.length % 4 !== 0) {
+        padded += '=';
+    }
+    const payloadBytes = fromBase64(padded);
+    return JSON.parse(utf8Decode(payloadBytes));
+}

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

@@ -0,0 +1,159 @@
+import { CryptoService } from '../crypto/crypto-service';
+import { SessionManager } from './session-manager';
+import { BroadcastCallback, CallEventCallback, DropOnAirClient, EventCallback, GroupCallEventCallback, GroupInfo, GroupMessageCallback, InitializeOptions, MessageCallback, TurnCredentials } from './types';
+export declare class MessagingClient implements DropOnAirClient {
+    private readonly options;
+    private readonly cryptoService;
+    private readonly sessionManager;
+    private readonly storage;
+    private readonly wsUrl;
+    private readonly httpUrl;
+    private readonly tokenExchangeEndpoint;
+    private readonly keyDirectoryEndpoint;
+    private readonly fetchFn;
+    private readonly codec;
+    private ws;
+    private shouldReconnect;
+    private reconnectTimer;
+    private dropOnAirJwt;
+    private currentUserId;
+    private deviceId;
+    private rateLimited;
+    private reconnectAttempt;
+    private handlingJwtExpiry;
+    private proactiveRefreshTimer;
+    private visibilityChangeHandler;
+    private readonly autoAckIncomingMessages;
+    private static readonly DEVICE_KEYS_CACHE_TTL_MS;
+    private readonly deviceKeysCache;
+    private readonly callListeners;
+    /** Pending startCall resolver, only one outgoing call can be in-flight at a time. */
+    private pendingInviteResolve;
+    private pendingInviteReject;
+    private readonly groupMessageListeners;
+    private readonly groupCallListeners;
+    /** Pending startGroupCall resolver. */
+    private pendingGroupInviteResolve;
+    private pendingGroupInviteReject;
+    private reconnectDelayMs;
+    /**
+     * Register a document visibilitychange listener so that when the iOS app
+     * returns from background we can immediately assess the JWT state.
+     *
+     * Background problem: iOS WebView suspends JavaScript (including all
+     * setTimeout timers) while the app is backgrounded.  A proactive-refresh
+     * timer scheduled for t+810 s effectively stops ticking, so if the user
+     * leaves the app open for 15+ minutes the JWT expires before the timer
+     * fires. This listener re-examines the JWT as soon as the user brings the
+     * app back to the foreground and either:
+     *   a) reschedules the timer with the corrected remaining time, or
+     *   b) triggers an immediate reconnect if the token has already expired or
+     *      will expire within the next 90 seconds.
+     */
+    private registerVisibilityChangeHandler;
+    private unregisterVisibilityChangeHandler;
+    /**
+     * Called every time the app returns to the foreground.
+     * Decides whether to reconnect immediately or just reschedule the proactive
+     * refresh timer with the time remaining from the current JWT's expiry.
+     */
+    private onAppForeground;
+    /**
+     * Schedule a proactive token rotation 90 seconds before the JWT expires.
+     * When it fires, a fresh token is pre-fetched and the current WebSocket is
+     * closed cleanly so the reconnect loop picks up the new token immediately.
+     * This prevents the server from ever rejecting a message due to an expired JWT.
+     */
+    private scheduleProactiveTokenRefresh;
+    private readonly messageListeners;
+    private readonly eventListeners;
+    private readonly broadcastListeners;
+    /** ------------------------------------------------------------------
+     * Lightweight structured logger. Only active when options.debug === true.
+     * Fields are safe to log: no plaintext, no private keys, no full JWTs.
+     * ------------------------------------------------------------------ */
+    private log;
+    private logError;
+    /**
+     * Build the common headers required on every backend API call.
+     * X-Platform and X-API-Version are forwarded when supplied in InitializeOptions.
+     */
+    private backendHeaders;
+    /** Redact a JWT to keep subject + expiry visible while hiding the signature. */
+    private jwtSummary;
+    constructor(options: InitializeOptions, cryptoService: CryptoService, sessionManager: SessionManager, storage: import('./types').KeyStorageAdapter);
+    connect(): Promise<void>;
+    disconnect(): void;
+    sendMessage(toUserId: string, plaintextMessage: string): Promise<{
+        messageId: string;
+    }>;
+    ack(messageId: string): Promise<void>;
+    onMessage(callback: MessageCallback): () => void;
+    onEvent(callback: EventCallback): () => void;
+    sendCleartextMessage(toUserId: string, plaintext: string): Promise<{
+        messageId: string;
+    }>;
+    subscribeBroadcast(channelId: string): Promise<void>;
+    unsubscribeBroadcast(channelId: string): Promise<void>;
+    publishBroadcast(channelId: string, plaintext: string): Promise<{
+        broadcastId: string;
+    }>;
+    onBroadcast(callback: BroadcastCallback): () => void;
+    onCallEvent(callback: CallEventCallback): () => void;
+    createGroup(name: string, memberUserIds?: string[]): Promise<GroupInfo>;
+    listGroups(): Promise<GroupInfo[]>;
+    getGroup(groupId: string): Promise<GroupInfo>;
+    addGroupMembers(groupId: string, userIds: string[]): Promise<GroupInfo>;
+    removeGroupMember(groupId: string, userId: string): Promise<GroupInfo>;
+    deleteGroup(groupId: string): Promise<void>;
+    sendGroupMessage(groupId: string, plaintext: string): Promise<{
+        messageId: string;
+    }>;
+    onGroupMessage(callback: GroupMessageCallback): () => void;
+    startGroupCall(groupId: string): Promise<string>;
+    joinGroupCall(callId: string, groupId: string): Promise<void>;
+    leaveGroupCall(callId: string): Promise<void>;
+    endGroupCall(callId: string): Promise<void>;
+    sendGroupCallSignal(type: 'GROUP_CALL_SDP_OFFER' | 'GROUP_CALL_SDP_ANSWER' | 'GROUP_CALL_ICE_CANDIDATE', callId: string, groupId: string, targetUserId: string, payload: string): void;
+    onGroupCallEvent(callback: GroupCallEventCallback): () => void;
+    private sendGroupCallFrame;
+    /**
+     * Initiate an outgoing call.
+     * Sends CALL_INVITE to the server; resolves with the server-assigned callId
+     * once the server echoes back CALL_RINGING (which contains the real callId).
+     */
+    startCall(targetUserId: string): Promise<string>;
+    acceptCall(callId: string): Promise<void>;
+    rejectCall(callId: string): Promise<void>;
+    endCall(callId: string): Promise<void>;
+    toggleVideo(callId: string, enabled: boolean): void;
+    sendCallSignal(type: 'CALL_SDP_OFFER' | 'CALL_SDP_ANSWER' | 'CALL_ICE_CANDIDATE', callId: string, payload: string): void;
+    fetchTurnCredentials(): Promise<TurnCredentials>;
+    private sendCallFrame;
+    private emitCallEvent;
+    private emitEvent;
+    private emitMessage;
+    private emitBroadcast;
+    private handleIncomingGroupMessage;
+    private emitGroupCallEvent;
+    private connectWebSocket;
+    private handleIncomingEnvelope;
+    private getPeerSharedKey;
+    /** Get or create a persistent device UUID for this SDK instance. */
+    private getOrCreateDeviceId;
+    /**
+     * Fetch all device keys for a given user (cached with short TTL).
+     * Falls back to wrapping the legacy single key into a device key entry.
+     */
+    private fetchDeviceKeys;
+    /**
+     * Fetch my own device keys and filter out the current device.
+     * Used for self-sync: encrypt sent messages for my other devices.
+     */
+    private fetchMyOtherDeviceKeys;
+    private ensureIdentityPublished;
+    private fetchAndProcessOfflineMessages;
+    private getValidDropOnAirJwt;
+    private extractSubject;
+    private isJwtExpiringSoon;
+}