@protontech/drive-sdk 0.9.1 → 0.9.3

package/src/crypto/openPGPCrypto.ts

@@ -1,4 +1,5 @@
 import { c } from 'ttag';
+
 import { OpenPGPCrypto, PrivateKey, PublicKey, SessionKey, VERIFICATION_STATUS } from './interface';
 import { uint8ArrayToBase64String } from './utils';
 
@@ -10,29 +11,39 @@ export interface OpenPGPCryptoProxy {
     generateKey: (options: { userIDs: { name: string }[]; type: 'ecc'; curve: 'ed25519Legacy' }) => Promise<PrivateKey>;
     exportPrivateKey: (options: { privateKey: PrivateKey; passphrase: string | null }) => Promise<string>;
     importPrivateKey: (options: { armoredKey: string; passphrase: string | null }) => Promise<PrivateKey>;
-    generateSessionKey: (options: { recipientKeys: PrivateKey[] }) => Promise<SessionKey>;
+    generateSessionKey: (options: { recipientKeys: PublicKey[] }) => Promise<SessionKey>;
     encryptSessionKey: (
-        options: SessionKey & { format: 'binary'; encryptionKeys?: PublicKey | PublicKey[]; passwords?: string[] },
+        options: SessionKey & {
+            format: 'binary';
+            encryptionKeys?: PublicKey | PublicKey[];
+            passwords?: string[];
+        },
     ) => Promise<Uint8Array>;
     decryptSessionKey: (options: {
         armoredMessage?: string;
         binaryMessage?: Uint8Array;
         decryptionKeys: PrivateKey | PrivateKey[];
     }) => Promise<SessionKey | undefined>;
-    encryptMessage: (options: {
-        format?: 'armored' | 'binary';
+    encryptMessage: <Format extends 'armored' | 'binary' = 'armored', Detached extends boolean = false>(options: {
+        format?: Format;
         binaryData: Uint8Array;
         sessionKey?: SessionKey;
-        encryptionKeys: PrivateKey[];
+        encryptionKeys: PublicKey[];
         signingKeys?: PrivateKey;
-        detached?: boolean;
+        detached?: Detached;
         compress?: boolean;
-    }) => Promise<{
-        message: string | Uint8Array;
-        signature?: string | Uint8Array;
-    }>;
-    decryptMessage: (options: {
-        format: 'utf8' | 'binary';
+    }) => Promise<
+        Detached extends true
+            ? {
+                  message: Format extends 'binary' ? Uint8Array : string;
+                  signature: Format extends 'binary' ? Uint8Array : string;
+              }
+            : {
+                  message: Format extends 'binary' ? Uint8Array : string;
+              }
+    >;
+    decryptMessage: <Format extends 'utf8' | 'binary' = 'utf8'>(options: {
+        format: Format;
         armoredMessage?: string;
         binaryMessage?: Uint8Array;
         armoredSignature?: string;
@@ -42,20 +53,17 @@ export interface OpenPGPCryptoProxy {
         decryptionKeys?: PrivateKey | PrivateKey[];
         verificationKeys?: PublicKey | PublicKey[];
     }) => Promise<{
-        data: Uint8Array | string;
-        // pmcrypto 8.3.0 changes `verified` to `verificationStatus`.
-        // Web clients are using newer pmcrypto, but CLI is using older version due to build issues with Bun.
-        verified?: VERIFICATION_STATUS;
-        verificationStatus?: VERIFICATION_STATUS;
+        data: Format extends 'binary' ? Uint8Array : string;
+        verificationStatus: VERIFICATION_STATUS;
         verificationErrors?: Error[];
     }>;
-    signMessage: (options: {
-        format: 'binary' | 'armored';
+    signMessage: <Format extends 'binary' | 'armored' = 'armored'>(options: {
+        format: Format;
         binaryData: Uint8Array;
         signingKeys: PrivateKey | PrivateKey[];
         detached: boolean;
         signatureContext?: { critical: boolean; value: string };
-    }) => Promise<Uint8Array | string>;
+    }) => Promise<Format extends 'binary' ? Uint8Array : string>;
     verifyMessage: (options: {
         binaryData: Uint8Array;
         armoredSignature?: string;
@@ -63,10 +71,7 @@ export interface OpenPGPCryptoProxy {
         verificationKeys: PublicKey | PublicKey[];
         signatureContext?: { critical: boolean; value: string };
     }) => Promise<{
-        // pmcrypto 8.3.0 changes `verified` to `verificationStatus`.
-        // Web clients are using newer pmcrypto, but CLI is using older version due to build issues with Bun.
-        verified?: VERIFICATION_STATUS;
-        verificationStatus?: VERIFICATION_STATUS;
+        verificationStatus: VERIFICATION_STATUS;
         errors?: Error[];
     }>;
 }
@@ -88,7 +93,7 @@ export class OpenPGPCryptoWithCryptoProxy implements OpenPGPCrypto {
         return uint8ArrayToBase64String(value);
     }
 
-    async generateSessionKey(encryptionKeys: PrivateKey[]) {
+    async generateSessionKey(encryptionKeys: PublicKey[]) {
         return this.cryptoProxy.generateSessionKey({ recipientKeys: encryptionKeys });
     }
 
@@ -132,21 +137,21 @@ export class OpenPGPCryptoWithCryptoProxy implements OpenPGPCrypto {
         };
     }
 
-    async encryptArmored(data: Uint8Array, encryptionKeys: PrivateKey[], sessionKey?: SessionKey) {
+    async encryptArmored(data: Uint8Array, encryptionKeys: PublicKey[], sessionKey?: SessionKey) {
         const { message: armoredData } = await this.cryptoProxy.encryptMessage({
             binaryData: data,
             sessionKey,
             encryptionKeys,
         });
         return {
-            armoredData: armoredData as string,
+            armoredData: armoredData,
         };
     }
 
     async encryptAndSign(
         data: Uint8Array,
         sessionKey: SessionKey,
-        encryptionKeys: PrivateKey[],
+        encryptionKeys: PublicKey[],
         signingKey: PrivateKey,
     ) {
         const { message: encryptedData } = await this.cryptoProxy.encryptMessage({
@@ -158,14 +163,14 @@ export class OpenPGPCryptoWithCryptoProxy implements OpenPGPCrypto {
             detached: false,
         });
         return {
-            encryptedData: encryptedData as Uint8Array,
+            encryptedData: encryptedData,
         };
     }
 
     async encryptAndSignArmored(
         data: Uint8Array,
         sessionKey: SessionKey | undefined,
-        encryptionKeys: PrivateKey[],
+        encryptionKeys: PublicKey[],
         signingKey: PrivateKey,
         options: { compress?: boolean } = {},
     ) {
@@ -178,14 +183,14 @@ export class OpenPGPCryptoWithCryptoProxy implements OpenPGPCrypto {
             compress: options.compress || false,
         });
         return {
-            armoredData: armoredData as string,
+            armoredData: armoredData,
         };
     }
 
     async encryptAndSignDetached(
         data: Uint8Array,
         sessionKey: SessionKey,
-        encryptionKeys: PrivateKey[],
+        encryptionKeys: PublicKey[],
         signingKey: PrivateKey,
     ) {
         const { message: encryptedData, signature } = await this.cryptoProxy.encryptMessage({
@@ -197,15 +202,15 @@ export class OpenPGPCryptoWithCryptoProxy implements OpenPGPCrypto {
             detached: true,
         });
         return {
-            encryptedData: encryptedData as Uint8Array,
-            signature: signature as Uint8Array,
+            encryptedData: encryptedData,
+            signature: signature,
         };
     }
 
     async encryptAndSignDetachedArmored(
         data: Uint8Array,
         sessionKey: SessionKey,
-        encryptionKeys: PrivateKey[],
+        encryptionKeys: PublicKey[],
         signingKey: PrivateKey,
     ) {
         const { message: armoredData, signature: armoredSignature } = await this.cryptoProxy.encryptMessage({
@@ -216,8 +221,8 @@ export class OpenPGPCryptoWithCryptoProxy implements OpenPGPCrypto {
             detached: true,
         });
         return {
-            armoredData: armoredData as string,
-            armoredSignature: armoredSignature as string,
+            armoredData: armoredData,
+            armoredSignature: armoredSignature,
         };
     }
 
@@ -230,7 +235,7 @@ export class OpenPGPCryptoWithCryptoProxy implements OpenPGPCrypto {
             signatureContext: { critical: true, value: signatureContext },
         });
         return {
-            signature: signature as Uint8Array,
+            signature: signature,
         };
     }
 
@@ -242,20 +247,18 @@ export class OpenPGPCryptoWithCryptoProxy implements OpenPGPCrypto {
             format: 'armored',
         });
         return {
-            signature: signature as string,
+            signature: signature,
         };
     }
 
     async verify(data: Uint8Array, signature: Uint8Array, verificationKeys: PublicKey | PublicKey[]) {
-        const { verified, verificationStatus, errors } = await this.cryptoProxy.verifyMessage({
+        const { verificationStatus, errors } = await this.cryptoProxy.verifyMessage({
             binaryData: data,
             binarySignature: signature,
             verificationKeys,
         });
         return {
-            // pmcrypto 8.3.0 changes `verified` to `verificationStatus`.
-            // Proper typing is too complex, it will be removed to support only newer pmcrypto.
-            verified: verified || verificationStatus!,
+            verified: verificationStatus,
             verificationErrors: errors,
         };
     }
@@ -266,7 +269,7 @@ export class OpenPGPCryptoWithCryptoProxy implements OpenPGPCrypto {
         verificationKeys: PublicKey | PublicKey[],
         signatureContext?: string,
     ) {
-        const { verified, verificationStatus, errors } = await this.cryptoProxy.verifyMessage({
+        const { verificationStatus, errors } = await this.cryptoProxy.verifyMessage({
             binaryData: data,
             armoredSignature,
             verificationKeys,
@@ -274,9 +277,7 @@ export class OpenPGPCryptoWithCryptoProxy implements OpenPGPCrypto {
         });
 
         return {
-            // pmcrypto 8.3.0 changes `verified` to `verificationStatus`.
-            // Proper typing is too complex, it will be removed to support only newer pmcrypto.
-            verified: verified || verificationStatus!,
+            verified: verificationStatus,
             verificationErrors: errors,
         };
     }
@@ -318,7 +319,6 @@ export class OpenPGPCryptoWithCryptoProxy implements OpenPGPCrypto {
     async decryptAndVerify(data: Uint8Array, sessionKey: SessionKey, verificationKeys: PublicKey[]) {
         const {
             data: decryptedData,
-            verified,
             verificationStatus,
             verificationErrors,
         } = await this.cryptoProxy.decryptMessage({
@@ -329,10 +329,8 @@ export class OpenPGPCryptoWithCryptoProxy implements OpenPGPCrypto {
         });
 
         return {
-            data: decryptedData as Uint8Array,
-            // pmcrypto 8.3.0 changes `verified` to `verificationStatus`.
-            // Proper typing is too complex, it will be removed to support only newer pmcrypto.
-            verified: verified || verificationStatus!,
+            data: decryptedData,
+            verified: verificationStatus,
             verificationErrors,
         };
     }
@@ -345,7 +343,6 @@ export class OpenPGPCryptoWithCryptoProxy implements OpenPGPCrypto {
     ) {
         const {
             data: decryptedData,
-            verified,
             verificationStatus,
             verificationErrors,
         } = await this.cryptoProxy.decryptMessage({
@@ -357,10 +354,8 @@ export class OpenPGPCryptoWithCryptoProxy implements OpenPGPCrypto {
         });
 
         return {
-            data: decryptedData as Uint8Array,
-            // pmcrypto 8.3.0 changes `verified` to `verificationStatus`.
-            // Proper typing is too complex, it will be removed to support only newer pmcrypto.
-            verified: verified || verificationStatus!,
+            data: decryptedData,
+            verified: verificationStatus,
             verificationErrors,
         };
     }
@@ -371,7 +366,7 @@ export class OpenPGPCryptoWithCryptoProxy implements OpenPGPCrypto {
             decryptionKeys,
             format: 'binary',
         });
-        return data as Uint8Array;
+        return data;
     }
 
     async decryptArmoredAndVerify(
@@ -379,7 +374,7 @@ export class OpenPGPCryptoWithCryptoProxy implements OpenPGPCrypto {
         decryptionKeys: PrivateKey | PrivateKey[],
         verificationKeys: PublicKey | PublicKey[],
     ) {
-        const { data, verified, verificationStatus, verificationErrors } = await this.cryptoProxy.decryptMessage({
+        const { data, verificationStatus, verificationErrors } = await this.cryptoProxy.decryptMessage({
             armoredMessage: armoredData,
             decryptionKeys,
             verificationKeys,
@@ -387,10 +382,8 @@ export class OpenPGPCryptoWithCryptoProxy implements OpenPGPCrypto {
         });
 
         return {
-            data: data as Uint8Array,
-            // pmcrypto 8.3.0 changes `verified` to `verificationStatus`.
-            // Proper typing is too complex, it will be removed to support only newer pmcrypto.
-            verified: verified || verificationStatus!,
+            data: data,
+            verified: verificationStatus,
             verificationErrors,
         };
     }
@@ -401,7 +394,7 @@ export class OpenPGPCryptoWithCryptoProxy implements OpenPGPCrypto {
         sessionKey: SessionKey,
         verificationKeys: PublicKey | PublicKey[],
     ) {
-        const { data, verified, verificationStatus, verificationErrors } = await this.cryptoProxy.decryptMessage({
+        const { data, verificationStatus, verificationErrors } = await this.cryptoProxy.decryptMessage({
             armoredMessage: armoredData,
             armoredSignature,
             sessionKeys: sessionKey,
@@ -410,10 +403,8 @@ export class OpenPGPCryptoWithCryptoProxy implements OpenPGPCrypto {
         });
 
         return {
-            data: data as Uint8Array,
-            // pmcrypto 8.3.0 changes `verified` to `verificationStatus`.
-            // Proper typing is too complex, it will be removed to support only newer pmcrypto.
-            verified: verified || verificationStatus!,
+            data: data,
+            verified: verificationStatus,
             verificationErrors: !armoredSignature
                 ? [new Error(c('Error').t`Signature is missing`)]
                 : verificationErrors,
@@ -426,6 +417,6 @@ export class OpenPGPCryptoWithCryptoProxy implements OpenPGPCrypto {
             passwords: [password],
             format: 'binary',
         });
-        return data as Uint8Array;
+        return data;
     }
 }

package/src/diagnostic/diagnostic.ts

@@ -2,7 +2,7 @@ import { MaybeNode } from '../interface';
 import { ProtonDriveClient } from '../protonDriveClient';
 import { ProtonDrivePhotosClient } from '../protonDrivePhotosClient';
 import { DiagnosticHTTPClient } from './httpClient';
-import { DiagnosticOptions, DiagnosticProgressCallback, DiagnosticResult } from './interface';
+import { DiagnosticOptions, DiagnosticProgressCallback, DiagnosticResult, TreeNode } from './interface';
 import { SDKDiagnosticMain } from './sdkDiagnosticMain';
 import { SDKDiagnosticPhotos } from './sdkDiagnosticPhotos';
 import { DiagnosticTelemetry } from './telemetry';
@@ -57,4 +57,14 @@ export class Diagnostic {
     private async *internalGenerator(): AsyncGenerator<DiagnosticResult> {
         yield* zipGenerators(this.telemetry.iterateEvents(), this.httpClient.iterateEvents());
     }
+
+    async getNodeTreeStructure(node: MaybeNode): Promise<TreeNode> {
+        const diagnostic = new SDKDiagnosticMain(this.protonDriveClient);
+        return diagnostic.getStructure(node);
+    }
+
+    async getPhotosTimelineStructure(): Promise<TreeNode> {
+        const diagnostic = new SDKDiagnosticPhotos(this.protonDrivePhotosClient);
+        return diagnostic.getStructure();
+    }
 }

package/src/diagnostic/interface.ts

@@ -15,6 +15,8 @@ export interface Diagnostic {
         options?: DiagnosticOptions,
         onProgress?: DiagnosticProgressCallback,
     ): AsyncGenerator<DiagnosticResult>;
+    getNodeTreeStructure(node: MaybeNode): Promise<TreeNode>;
+    getPhotosTimelineStructure(): Promise<TreeNode>;
 }
 
 export type DiagnosticOptions = {
@@ -36,6 +38,17 @@ export type ExpectedTreeNode = {
     children?: ExpectedTreeNode[];
 };
 
+export type TreeNode = {
+    uid: string;
+    type: NodeType;
+    // If node is degraded, error will be set.
+    error?: unknown;
+    name: string;
+    claimedSha1?: string;
+    claimedSizeInBytes?: number;
+    children?: TreeNode[];
+};
+
 export type ExpectedAuthor = string | 'anonymous';
 
 export type DiagnosticProgressCallback = (progress: {

package/src/diagnostic/sdkDiagnosticMain.ts

@@ -1,8 +1,14 @@
 import { MaybeNode, NodeType } from '../interface';
 import { ProtonDriveClient } from '../protonDriveClient';
-import { DiagnosticOptions, DiagnosticProgressCallback, DiagnosticResult, ExpectedTreeNode } from './interface';
+import {
+    DiagnosticOptions,
+    DiagnosticProgressCallback,
+    DiagnosticResult,
+    ExpectedTreeNode,
+    TreeNode,
+} from './interface';
 import { zipGenerators } from './zipGenerators';
-import { getNodeType, getNodeName, getTreeNodeChildByNodeName } from './nodeUtils';
+import { getNodeType, getNodeName, getTreeNodeChildByNodeName, getActiveRevision } from './nodeUtils';
 import { SDKDiagnosticBase } from './sdkDiagnosticBase';
 
 /**
@@ -92,4 +98,37 @@ export class SDKDiagnosticMain extends SDKDiagnosticBase {
             }
         }
     }
+
+    async getStructure(node: MaybeNode): Promise<TreeNode> {
+        const nodeType = getNodeType(node);
+        const treeNode: TreeNode = {
+            uid: node.ok ? node.value.uid : node.error.uid,
+            type: nodeType,
+            name: getNodeName(node),
+        };
+
+        if (!node.ok) {
+            treeNode.error = node.error || 'degraded node';
+        }
+
+        if (nodeType === NodeType.Folder) {
+            const children = [];
+
+            for await (const child of this.protonDriveClient.iterateFolderChildren(node)) {
+                children.push(child);
+            }
+
+            treeNode.children = [];
+            for (const child of children) {
+                const childStructure = await this.getStructure(child);
+                treeNode.children.push(childStructure);
+            }
+        } else if (nodeType === NodeType.File) {
+            const activeRevision = getActiveRevision(node);
+            treeNode.claimedSha1 = activeRevision?.claimedDigests?.sha1;
+            treeNode.claimedSizeInBytes = activeRevision?.claimedSize;
+        }
+
+        return treeNode;
+    }
 }

package/src/diagnostic/sdkDiagnosticPhotos.ts

@@ -1,8 +1,14 @@
 import { MaybeNode } from '../interface';
 import { ProtonDrivePhotosClient } from '../protonDrivePhotosClient';
-import { DiagnosticOptions, DiagnosticProgressCallback, DiagnosticResult, ExpectedTreeNode } from './interface';
+import {
+    DiagnosticOptions,
+    DiagnosticProgressCallback,
+    DiagnosticResult,
+    ExpectedTreeNode,
+    TreeNode,
+} from './interface';
 import { zipGenerators } from './zipGenerators';
-import { getNodeName, getTreeNodeChildByNodeName } from './nodeUtils';
+import { getNodeName, getTreeNodeChildByNodeName, getActiveRevision, getNodeType } from './nodeUtils';
 import { SDKDiagnosticBase } from './sdkDiagnosticBase';
 
 /**
@@ -67,4 +73,43 @@ export class SDKDiagnosticPhotos extends SDKDiagnosticBase {
 
         this.allNodesLoaded = true;
     }
+
+    async getStructure(): Promise<TreeNode> {
+        const myPhotosRootFolder = await this.protonDrivePhotosClient.getMyPhotosRootFolder();
+
+        const treeNode: TreeNode = {
+            uid: myPhotosRootFolder.ok ? myPhotosRootFolder.value.uid : myPhotosRootFolder.error.uid,
+            type: getNodeType(myPhotosRootFolder),
+            name: getNodeName(myPhotosRootFolder),
+        };
+        const children = [];
+
+        const results = await Array.fromAsync(this.protonDrivePhotosClient.iterateTimeline());
+        const nodeUids = results.map((result) => result.nodeUid);
+
+        for await (const maybeMissingNode of this.protonDrivePhotosClient.iterateNodes(nodeUids)) {
+            if (!maybeMissingNode.ok && 'missingUid' in maybeMissingNode.error) {
+                continue;
+            }
+            const node = maybeMissingNode as MaybeNode;
+
+            const activeRevision = getActiveRevision(node);
+            const childNode: TreeNode = {
+                uid: node.ok ? node.value.uid : node.error.uid,
+                name: getNodeName(node),
+                type: getNodeType(node),
+                claimedSha1: activeRevision?.claimedDigests?.sha1,
+                claimedSizeInBytes: activeRevision?.claimedSize,
+            };
+
+            if (!node.ok) {
+                childNode.error = node.error || 'degraded node';
+            }
+
+            children.push(childNode);
+        }
+
+        treeNode.children = children;
+        return treeNode;
+    }
 }