@awiki/dsh-plugin 0.3.7 → 0.3.11-rc.1

package/lib/types/sdk-adapter.js

@@ -1,4 +1,5 @@
 /** Rust IM Core adapter that copies native values into Host-owned public DTOs. */
+import { mailRecoveryFailureFields } from "./mail-recovery-observability.js";
 const GROUP_LOOKUP_LIMIT = 100;
 const MAX_GROUP_LOOKUP_PAGES = 20;
 const RUST_FAILURE_CODES = {
@@ -16,14 +17,16 @@ const RUST_FAILURE_CODES = {
     permission_denied: 'forbidden',
     group_not_member: 'group-membership-required',
     group_identity_stale: 'group-identity-stale',
-    auth_revoked: 'identity-recovery-required',
+    auth_revoked: 'device-rejoin-required',
+    local_identity_recovery_required: 'identity-recovery-required',
     conflict: 'conflict',
     join_required: 'handle-unavailable',
-    state_in_use: 'state-in-use',
+    state_in_use: 'conflict',
     rate_limited: 'rate-limited',
     timeout: 'network',
     transport_unavailable: 'network',
     sync_failed: 'network',
+    sync_blocked: 'conflict',
     session_expired: 'network',
     attachment_transfer_network: 'network',
     recovery_reconciliation_unavailable: 'network',
@@ -32,15 +35,72 @@ const RUST_FAILURE_CODES = {
 /** Closed provider error consumed by the Host's fixed public failure mapping. */
 export class AwikiSdkError extends Error {
     code;
+    realtimeFailureCode;
     name = 'AwikiSdkError';
-    constructor(code) {
+    mail_ingress_classification;
+    auth_status_class;
+    auth_stable_machine_code;
+    retryable;
+    mail_closed_classification;
+    constructor(code, realtimeFailureCode, mailRecoveryFailure) {
         super(`AWiki SDK operation failed: ${code}`);
         this.code = code;
+        this.realtimeFailureCode = realtimeFailureCode;
+        if (mailRecoveryFailure !== undefined)
+            Object.assign(this, mailRecoveryFailure);
     }
 }
 function fail(code = 'remote') {
     throw new AwikiSdkError(code);
 }
+const REALTIME_RETRY_WARNING_PRIORITY = [
+    'sync.retry.local_state.actor_closed',
+    'sync.retry.local_state.database_busy',
+    'sync.retry.local_state.constraint_failed',
+    'sync.retry.local_state.schema_unavailable',
+    'sync.retry.local_state.storage_unavailable',
+    'sync.retry.local_state.codec_unavailable',
+    'sync.retry.local_state.other',
+    'sync.retry.transport_unavailable',
+    'sync.retry.service_unavailable',
+    'sync.retry.local_state_unavailable',
+];
+function realtimeSyncFailureCode(status, warnings, errorCode) {
+    if (status === 'retryable_failure') {
+        return REALTIME_RETRY_WARNING_PRIORITY.find(code => warnings.includes(code))
+            ?? 'sync.retryable_failure';
+    }
+    if (status === 'recovery_required')
+        return 'sync.recovery_required';
+    if (status === 'auth_revoked')
+        return 'sync.auth_revoked';
+    if (status === 'blocked') {
+        if (errorCode === 'sync.client_upgrade_required') {
+            return 'sync.blocked.client_upgrade_required';
+        }
+        if (errorCode === 'device_reprovision_required') {
+            return 'sync.blocked.device_reprovision_required';
+        }
+        if (errorCode === 'server_repair_required') {
+            return 'sync.blocked.server_repair_required';
+        }
+        if (errorCode === 'sync.snapshot_item_too_large'
+            || errorCode === 'sync.snapshot_required_state_too_large') {
+            return 'sync.blocked.snapshot_capacity';
+        }
+        if (errorCode === 'sync.invalid_request')
+            return 'sync.blocked.invalid_request';
+        if (errorCode === 'sync.invalid_cursor')
+            return 'sync.blocked.invalid_cursor';
+        return errorCode === undefined ? 'sync.blocked' : 'sync.blocked.other';
+    }
+    return 'sync.unexpected_status';
+}
+function syncResultErrorCode(result) {
+    if (!('errorCode' in result))
+        return undefined;
+    return typeof result.errorCode === 'string' ? result.errorCode : undefined;
+}
 function mapError(error, ambiguousSend = false) {
     if (error instanceof AwikiSdkError)
         throw error;
@@ -56,7 +116,7 @@ function mapError(error, ambiguousSend = false) {
         }
     }
     catch { }
-    fail(code);
+    throw new AwikiSdkError(code, undefined, mailRecoveryFailureFields(error));
 }
 function safeInteger(value, minimum = 0) {
     if (!/^(?:0|[1-9]\d*)$/u.test(value))
@@ -111,24 +171,6 @@ function mailAddress(value) {
         fail();
     return value;
 }
-function mailFileName(value) {
-    if (typeof value !== 'string'
-        || value.length === 0
-        || value.trim() !== value
-        || value.replace(/[. ]+$/u, '') !== value
-        || value === '.'
-        || value === '..'
-        || Buffer.byteLength(value, 'utf8') > 255
-        || /[\\/\p{C}]/u.test(value))
-        fail();
-    return value;
-}
-function mailContentType(value) {
-    if (typeof value !== 'string'
-        || !/^[A-Za-z0-9!#$&^_.+-]+\/[A-Za-z0-9!#$&^_.+-]+$/u.test(value))
-        fail();
-    return value;
-}
 function mailAddresses(value) {
     if (!Array.isArray(value) || value.length > 100)
         fail();
@@ -148,14 +190,6 @@ function uint32(value) {
         fail();
     return value;
 }
-function recoveryE2eeGroupCount(impact) {
-    if (typeof impact !== 'object' || impact === null)
-        fail();
-    const value = impact;
-    return uint32(value.unsupportedE2eeGroupCount !== undefined
-        ? value.unsupportedE2eeGroupCount
-        : value.unsupportedE2EeGroupCount);
-}
 function boolean(value) {
     if (typeof value !== 'boolean')
         fail();
@@ -254,6 +288,26 @@ function identity(value) {
         registeredAt: safeInteger(value.registeredAtMs),
     };
 }
+function joinProgress(value) {
+    return {
+        joinSessionId: required(value.joinSessionId),
+        localPhase: value.localPhase,
+        remoteState: value.remoteState,
+        expiresAt: required(value.expiresAt),
+        ...value.sas === undefined ? {} : { sas: required(value.sas) },
+        completed: boolean(value.completed),
+        ...value.identity === undefined ? {} : { identity: identity(value.identity) },
+    };
+}
+function adminJoinProgress(value) {
+    return {
+        joinSessionId: required(value.joinSessionId),
+        localPhase: value.localPhase,
+        remoteState: value.remoteState,
+        expiresAt: required(value.expiresAt),
+        ...value.sas === undefined ? {} : { sas: required(value.sas) },
+    };
+}
 function profile(value) {
     return {
         did: required(value.did),
@@ -377,20 +431,51 @@ function externalHttpAttempt(value) {
 }
 /** Adapt the Rust Node bridge to the frozen Host provider interface. */
 export class RustSdkAdapter {
+    trustedUserPresenceSupported = process.platform === 'darwin' && process.arch === 'x64';
     client;
+    refreshingDisplayPeers = new Set();
+    scheduleDisplayRefresh(client, peers) {
+        if (this.disposal !== undefined)
+            return;
+        const pending = [...new Set(peers)].filter(peer => peer.startsWith('did:') && !this.refreshingDisplayPeers.has(peer)).slice(0, 100);
+        if (pending.length === 0)
+            return;
+        for (const peer of pending)
+            this.refreshingDisplayPeers.add(peer);
+        void client.refreshDisplayProfiles({ peers: pending }).catch(() => undefined).finally(() => {
+            for (const peer of pending)
+                this.refreshingDisplayPeers.delete(peer);
+        });
+    }
+    getDisplayProfiles(peers) {
+        return this.run(async (client) => {
+            const profiles = await client.hydrateDisplayProfiles({ peers });
+            this.scheduleDisplayRefresh(client, peers);
+            return profiles.flatMap(profile => profile.did === undefined ? [] : [{
+                    did: profile.did, cacheHit: profile.cacheHit,
+                    ...profile.handle === undefined ? {} : { handle: profile.handle },
+                    ...profile.displayName === undefined ? {} : { displayName: profile.displayName },
+                }]);
+        });
+    }
     attachmentConversations = new Map();
     disposal;
+    realtime;
+    agentInbox;
     listener;
     constructor(client) {
         this.client = Promise.resolve(client);
-        this.listener = {
+        this.realtime = {
             syncNow: reason => this.listenerSyncNow(reason),
             startRealtime: () => this.listenerStartRealtime(),
+        };
+        this.agentInbox = {
             listConversations: request => this.listenerConversations(request),
             getHistory: request => this.listenerHistory(request),
             markConversationRead: conversationId => this.markConversationRead(conversationId),
             sendText: request => this.sendText(request),
         };
+        this.listener = { ...this.realtime, ...this.agentInbox };
     }
     async run(operation, ambiguousSend = false) {
         try {
@@ -404,13 +489,12 @@ export class RustSdkAdapter {
         const messages = values.filter(displayableMessage);
         const peers = [...new Set(messages
                 .filter(message => (message.conversationKind === 'group'
-                && !message.outgoing
-                && message.senderHandle === undefined
-                && message.senderDisplayName === undefined))
+                && !message.outgoing))
                 .map(message => message.senderDid))];
         if (peers.length === 0)
             return [...messages];
         const profiles = await client.hydrateDisplayProfiles({ peers });
+        this.scheduleDisplayRefresh(client, peers);
         const byDid = new Map();
         for (const profile of profiles) {
             if (profile.did !== undefined)
@@ -418,10 +502,11 @@ export class RustSdkAdapter {
         }
         return messages.map((message) => {
             const profile = byDid.get(message.senderDid);
-            if (profile === undefined)
+            if (profile === undefined || !profile.cacheHit)
                 return message;
+            const { senderDisplayName: _snapshot, ...rest } = message;
             return {
-                ...message,
+                ...rest,
                 ...profile.handle === undefined ? {} : { senderHandle: profile.handle },
                 ...profile.displayName === undefined ? {} : { senderDisplayName: profile.displayName },
             };
@@ -567,7 +652,7 @@ export class RustSdkAdapter {
             ...value.peerPersonaId === undefined ? {} : { peerPersonaId: value.peerPersonaId },
             ...value.did === undefined ? {} : { did: value.did },
             ...value.credentialDid === undefined ? {} : { credentialDid: value.credentialDid },
-            ...value.handle === undefined ? {} : { handle: value.handle },
+            ...(profile?.handle ?? value.handle) === undefined ? {} : { handle: (profile?.handle ?? value.handle) },
             ...profile?.displayName === undefined ? {} : { displayName: profile.displayName },
             ...value.role === undefined ? {} : { role: value.role },
             ...value.status === undefined ? {} : { status: value.status },
@@ -608,11 +693,14 @@ export class RustSdkAdapter {
     listenerSyncNow(reason) {
         return this.run(async (client) => {
             const result = await client.syncNow({ reason });
-            if (result.status === 'idle' || result.status === 'changed')
-                return;
-            if (result.status === 'auth_revoked')
-                fail('identity-recovery-required');
-            fail('network');
+            if (result.status === 'idle' || result.status === 'changed') {
+                return {
+                    pagesFetched: uint32(result.pagesFetched),
+                    messagesHydrated: uint32(result.messagesHydrated),
+                    olderHistoryExcluded: boolean(result.olderHistoryExcluded),
+                };
+            }
+            throw new AwikiSdkError(result.status === 'auth_revoked' ? 'device-rejoin-required' : 'network', realtimeSyncFailureCode(result.status, result.warnings, syncResultErrorCode(result)));
         });
     }
     listenerStartRealtime() {
@@ -620,6 +708,10 @@ export class RustSdkAdapter {
             const session = await client.startRealtime();
             return {
                 nextEvent: () => this.run(() => session.nextEvent()),
+                getStatus: () => this.run(async () => {
+                    const status = await session.getStatus();
+                    return { connected: status.connected };
+                }),
                 stop: () => this.run(() => session.stop()),
             };
         });
@@ -676,7 +768,137 @@ export class RustSdkAdapter {
         });
     }
     registerIdentity(request) {
-        return this.run(async (client) => identity(await client.completeRegistration(request)));
+        return this.run(async (client) => {
+            const value = await client.completeRegistrationWithOutcome(request);
+            if (value.status === 'registered') {
+                return { status: 'registered', identity: identity(value.identity) };
+            }
+            return {
+                status: 'join-required',
+                continuationId: required(value.existingHandle.continuationId),
+                fullHandle: required(value.existingHandle.fullHandle),
+                mode: value.existingHandle.mode === 'handle_recovery_rebind'
+                    ? 'handle-recovery-rebind'
+                    : 'ordinary',
+                requiresUserPresence: boolean(value.existingHandle.requiresUserPresence),
+            };
+        });
+    }
+    beginDeviceJoin(request) {
+        return this.run(async (client) => joinProgress(await client.beginPreparedRegistrationJoin(request)));
+    }
+    getDeviceJoinStatus(joinSessionId) {
+        return this.run(async (client) => joinProgress(await client.resumePreparedRegistrationJoin({ joinSessionId })));
+    }
+    listLocalDeviceJoinSessions() {
+        return this.run(async (client) => (await client.listLocalDeviceJoinSessions()).map(value => ({
+            joinSessionId: required(value.joinSessionId),
+            side: value.side,
+            localPhase: value.localPhase,
+            expiresAt: required(value.expiresAt),
+        })));
+    }
+    cancelDeviceJoin(joinSessionId) {
+        return this.run(async (client) => {
+            const value = await client.cancelPreparedRegistrationJoin({ joinSessionId });
+            return {
+                joinSessionId: required(value.joinSessionId),
+                side: value.side,
+                localPhase: value.localPhase,
+                expiresAt: required(value.expiresAt),
+            };
+        });
+    }
+    getCurrentDeviceSummary() {
+        return this.run(async (client) => {
+            const value = await client.getCurrentDeviceSummary();
+            return {
+                ...value.role === undefined ? {} : { role: value.role },
+                readiness: value.readiness,
+                canManage: boolean(value.canManage),
+            };
+        });
+    }
+    syncDeviceManagement() {
+        return this.run(async (client) => {
+            await client.syncNow({ reason: 'foreground_reconcile' });
+        });
+    }
+    getDeviceRegistry() {
+        return this.run(async (client) => (await client.getDeviceRegistry()).devices.map(value => ({
+            deviceId: required(value.protocolDeviceId),
+            status: value.status,
+            role: value.role,
+            managementReady: boolean(value.managementReady),
+            isCurrent: boolean(value.isCurrent),
+        })));
+    }
+    listLocalDeviceJoinRequests() {
+        return this.run(async (client) => (await client.listLocalDeviceJoinRequests()).map(value => ({
+            joinSessionId: required(value.joinSessionId),
+            protocolDeviceId: required(value.protocolDeviceId),
+            candidateKeyFingerprint: required(value.candidateKeyFingerprint),
+            issuedAt: required(value.issuedAt),
+            expiresAt: required(value.expiresAt),
+            state: value.state,
+            claimedByCurrentDevice: boolean(value.claimedByCurrentDevice),
+            canStartVerification: boolean(value.canStartVerification),
+        })));
+    }
+    startDeviceJoinVerification(request) {
+        return this.run(async (client) => adminJoinProgress(await client.startDeviceJoinVerification(request)));
+    }
+    getLocalDeviceJoinVerificationProgress(joinSessionId) {
+        return this.run(async (client) => adminJoinProgress(await client.getLocalDeviceJoinVerificationProgress({ joinSessionId })));
+    }
+    prepareDeviceJoinApproval(joinSessionId) {
+        return this.run(async (client) => {
+            const value = await client.prepareDeviceJoinApproval({ joinSessionId, sasConfirmed: true });
+            return { approvalHandle: required(value.approvalHandle) };
+        });
+    }
+    confirmDeviceJoinApproval(approvalHandle) {
+        return this.run(async (client) => adminJoinProgress(await client.confirmDeviceJoinApproval({
+            approvalHandle,
+            userPresenceConfirmed: true,
+        })));
+    }
+    rejectDeviceJoin(joinSessionId, reason) {
+        return this.run(async (client) => adminJoinProgress(await client.rejectDeviceJoin({ joinSessionId, reason })));
+    }
+    revokeDevice(deviceId) {
+        return this.run(async (client) => {
+            await client.revokeDevice({ targetDeviceId: deviceId, userPresenceConfirmed: true });
+        });
+    }
+    confirmUserPresence(reason) {
+        return this.run(client => client.confirmUserPresence({ reason }));
+    }
+    prepareRootKeyTransfer(deviceId) {
+        return this.run(async (client) => {
+            const value = await client.prepareRootKeyTransfer({ recipientDeviceId: deviceId });
+            return {
+                authorizationHandle: required(value.authorizationHandle),
+                recipient: {
+                    did: required(value.recipient.did),
+                    deviceId: required(value.recipient.deviceId),
+                    registryVersion: required(value.recipient.registryVersion),
+                },
+                expiresAt: required(value.expiresAt),
+            };
+        });
+    }
+    confirmAndSendRootKeyTransfer(authorizationHandle) {
+        return this.run(async (client) => {
+            const value = await client.confirmAndSendRootKeyTransfer({
+                authorizationHandle,
+                userPresenceConfirmed: true,
+            });
+            return {
+                recipientDeviceId: required(value.recipientDeviceId),
+                acceptedAt: required(value.acceptedAt),
+            };
+        });
     }
     updateDisplayName(request) {
         return this.run(async (client) => identity(await client.updateDisplayName(request.displayName)));
@@ -698,12 +920,11 @@ export class RustSdkAdapter {
             ...value.previousDid === undefined ? {} : { previousDid: value.previousDid },
             currentDid: required(value.currentDid),
             phase: value.phase,
+            allowedActions: [...(value.allowedActions ?? [])],
             ...value.failureCode === undefined ? {} : { failureCode: value.failureCode },
             retryable: boolean(value.retryable),
             localOrdinaryDataWillMigrate: boolean(value.impact.localOrdinaryDataWillMigrate),
             otherDevicesMustRejoin: boolean(value.impact.otherDevicesMustRejoin),
-            unsupportedE2eeGroupCount: recoveryE2eeGroupCount(value.impact),
-            unsupportedDidOnlyGroupCount: uint32(value.impact.unsupportedDidOnlyGroupCount),
         };
     }
     sendRecoveryOtp(request) {
@@ -723,21 +944,17 @@ export class RustSdkAdapter {
     activateRecovery(request) {
         return this.run(async (client) => this.recoveryProgress(await client.activateHandleRecovery(request)));
     }
+    listPendingRecoveries() {
+        return this.run(async (client) => (await client.listPendingHandleRecoveryOperations()).map(value => ({
+            operationId: required(value.operationId), fullHandle: required(value.fullHandle),
+        })));
+    }
     getRecoveryStatus(request) {
         return this.run(async (client) => this.recoveryProgress(await client.getHandleRecoveryStatus(request)));
     }
     resumeRecovery(request) {
         return this.run(async (client) => this.recoveryProgress(await client.resumeHandleRecovery(request)));
     }
-    issueRecoveryAttestation(request) {
-        return this.run(async (client) => {
-            const value = await client.issueHandleRecoveryAttestation(request);
-            return {
-                attestation: required(value.attestation),
-                expiresAt: required(value.expiresAt),
-            };
-        });
-    }
     discardRecovery(request) {
         return this.run(async (client) => {
             await client.discardHandleRecovery(request);
@@ -781,6 +998,7 @@ export class RustSdkAdapter {
             });
             const peers = [...new Set(value.items.flatMap(member => member.did ?? member.handle ?? []))];
             const profiles = peers.length === 0 ? [] : await client.hydrateDisplayProfiles({ peers });
+            this.scheduleDisplayRefresh(client, peers);
             const byPeer = new Map();
             for (const [index, profile] of profiles.entries()) {
                 const requested = peers[index];
@@ -808,48 +1026,6 @@ export class RustSdkAdapter {
             member,
         })));
     }
-    resumeGroupRebindRecovery() {
-        return this.run(async (client) => {
-            const value = await client.resumeGroupRebindRecovery(100);
-            const journal = value;
-            const statuses = new Map();
-            for (const item of journal.items ?? []) {
-                const { groupDid: rawGroupDid, layer: rawLayer, phase: rawPhase } = item;
-                if (typeof rawGroupDid !== 'string'
-                    || typeof rawLayer !== 'string'
-                    || typeof rawPhase !== 'string'
-                    || typeof item.blocked !== 'boolean') {
-                    throw new TypeError('invalid group recovery item');
-                }
-                const groupDid = required(rawGroupDid);
-                const layer = required(rawLayer);
-                const phase = required(rawPhase);
-                if (layer !== 'p4' && layer !== 'p6')
-                    throw new TypeError('invalid group recovery item');
-                if (phase === 'complete')
-                    continue;
-                const status = item.blocked || phase === 'blocked' ? 'blocked' : 'pending';
-                if (statuses.get(groupDid) !== 'blocked')
-                    statuses.set(groupDid, status);
-            }
-            for (const group of journal.sendPausedGroups ?? []) {
-                if (typeof group !== 'string')
-                    throw new TypeError('invalid paused recovery group');
-                const groupDid = required(group);
-                if (!statuses.has(groupDid))
-                    statuses.set(groupDid, 'pending');
-            }
-            const items = [...statuses].map(([groupDid, status]) => ({ groupDid, status }));
-            const hasJournal = journal.items !== undefined || journal.sendPausedGroups !== undefined;
-            return {
-                processed: uint32(value.processed),
-                completed: uint32(value.completed),
-                pending: hasJournal ? items.filter(item => item.status === 'pending').length : uint32(value.pending),
-                blocked: hasJournal ? items.filter(item => item.status === 'blocked').length : uint32(value.blocked),
-                items,
-            };
-        });
-    }
     listConversations(request) {
         return this.run(async (client) => {
             const conversations = await client.listConversations(request);
@@ -968,21 +1144,12 @@ export class RustSdkAdapter {
         });
     }
     sendMail(request) {
-        const attachments = request.attachments?.map(attachment => ({
-            fileName: attachment.fileName,
-            contentType: attachment.contentType,
-            bytes: Uint8Array.from(attachment.bytes),
-        }));
         return this.run(async (client) => {
-            const input = {
+            const value = await client.sendMail({
                 to: [...request.to],
                 ...request.cc === undefined ? {} : { cc: [...request.cc] },
                 subject: request.subject,
                 bodyText: request.bodyText,
-            };
-            const value = await client.sendMail({
-                ...input,
-                ...attachments === undefined || attachments.length === 0 ? {} : { attachments },
             });
             if (!Array.isArray(value.warnings) || value.warnings.length > 100)
                 fail();
@@ -996,26 +1163,21 @@ export class RustSdkAdapter {
             };
         }, true);
     }
-    downloadMailAttachment(request) {
-        return this.run(async (client) => {
-            const value = await client.downloadMailAttachment({
-                messageId: mailToken(request.messageId, 2_048),
-                attachmentIndex: uint32(request.attachmentIndex),
-            });
-            const sizeBytes = safeInteger(remoteString(value.sizeBytes, 20));
-            if (!(value.bytes instanceof Uint8Array) || value.bytes.byteLength !== sizeBytes)
-                fail();
-            return {
-                fileName: mailFileName(value.fileName),
-                contentType: mailContentType(value.contentType),
-                sizeBytes,
-                bytes: Uint8Array.from(value.bytes),
-            };
-        });
-    }
     clearLocalData() {
         return this.run(client => client.clearLocalData());
     }
+    retireDefaultIdentityForRejoin() {
+        return this.run((client) => {
+            const retire = client.retireDefaultIdentityForRejoin;
+            if (typeof retire !== 'function') {
+                throw Object.assign(new Error('device rejoin is unavailable in this IM Core build'), {
+                    name: 'AwikiSdkError',
+                    code: 'remote',
+                });
+            }
+            return retire.call(client);
+        });
+    }
     dispose() {
         this.disposal ??= this.client.then(async (client) => {
             try {