@protontech/drive-sdk 0.2.1 → 0.3.1

package/src/internal/sharingPublic/session/session.ts

@@ -0,0 +1,78 @@
+import { SRPModule } from "../../../crypto";
+import { SharingPublicSessionAPIService } from "./apiService";
+import { PublicLinkInfo, PublicLinkSrpInfo } from "./interface";
+
+/**
+ * Session for a public link.
+ *
+ * It is responsible for initializing and authenticating the public link session
+ * with the SRP handshake. It also can re-authenticate the session if it is expired.
+ */
+export class SharingPublicLinkSession {
+    private sessionUid?: string;
+    private sessionAccessToken?: string;
+
+    constructor(
+        private apiService: SharingPublicSessionAPIService,
+        private srpModule: SRPModule,
+        private token: string,
+        private password: string,
+    ) {
+        this.apiService = apiService;
+        this.srpModule = srpModule;
+        this.token = token;
+        this.password = password;
+    }
+
+    async reauth(): Promise<void> {
+        const info = await this.init();
+        await this.auth(info.srp);
+    }
+
+    async init(): Promise<PublicLinkInfo> {
+        return this.apiService.initPublicLinkSession(this.token);
+    }
+
+    async auth(srp: PublicLinkSrpInfo): Promise<void> {
+        const { expectedServerProof, clientProof, clientEphemeral } = await this.srpModule.getSrp(
+            srp.version,
+            srp.modulus,
+            srp.serverEphemeral,
+            srp.salt,
+            this.password,
+        );
+
+        const auth = await this.apiService.authPublicLinkSession(this.token, {
+            clientProof,
+            clientEphemeral,
+            srpSession: srp.srpSession,
+        });
+
+        if (auth.serverProof !== expectedServerProof) {
+            throw new Error('Invalid server proof');
+        }
+
+        this.sessionUid = auth.sessionUid;
+        this.sessionAccessToken = auth.sessionAccessToken;
+    }
+
+    /**
+     * Get the session uid and access token.
+     *
+     * The access token is only returned if the session is newly created.
+     * If the access token is not available, it means the existing session
+     * can be used to access the public link.
+     *
+     * @throws If the session is not initialized.
+     */
+    get session() {
+        if (!this.sessionUid) {
+            throw new Error('Session not initialized');
+        }
+
+        return {
+            uid: this.sessionUid,
+            accessToken: this.sessionAccessToken,
+        };
+    }
+}

package/src/internal/sharingPublic/session/url.test.ts

@@ -0,0 +1,72 @@
+import { ValidationError } from '../../../errors';
+import { getTokenAndPasswordFromUrl } from './url';
+
+describe('getTokenAndPasswordFromUrl', () => {
+    describe('valid URLs', () => {
+        it('should extract token and password from a valid URL', () => {
+            const url = 'https://drive.proton.me/urls/abc123#def456';
+            const result = getTokenAndPasswordFromUrl(url);
+
+            expect(result).toEqual({
+                token: 'abc123',
+                password: 'def456'
+            });
+        });
+
+        it('should handle URLs with different domains', () => {
+            const url = 'https://example.com/urls/mytoken#mypassword';
+            const result = getTokenAndPasswordFromUrl(url);
+
+            expect(result).toEqual({
+                token: 'mytoken',
+                password: 'mypassword'
+            });
+        });
+
+        it('should handle URLs with query parameters', () => {
+            const url = 'https://drive.proton.me/urls/token123?param=value#password456';
+            const result = getTokenAndPasswordFromUrl(url);
+
+            expect(result).toEqual({
+                token: 'token123',
+                password: 'password456'
+            });
+        });
+    });
+
+    describe('should throw ValidationError', () => {
+        it('when token is missing (no path)', () => {
+            const url = 'https://drive.proton.me/#password123';
+
+            expect(() => getTokenAndPasswordFromUrl(url)).toThrow(ValidationError);
+        });
+
+        it('when token is missing (empty path segment)', () => {
+            const url = 'https://drive.proton.me/urls/#password123';
+
+            expect(() => getTokenAndPasswordFromUrl(url)).toThrow(ValidationError);
+        });
+
+        it('when password is missing (no hash)', () => {
+            const url = 'https://drive.proton.me/urls/token123';
+
+            expect(() => getTokenAndPasswordFromUrl(url)).toThrow(ValidationError);
+            expect(() => getTokenAndPasswordFromUrl(url)).toThrow('Invalid URL');
+        });
+
+        it('when password is empty (empty hash)', () => {
+            const url = 'https://drive.proton.me/urls/token123#';
+
+            expect(() => getTokenAndPasswordFromUrl(url)).toThrow(ValidationError);
+            expect(() => getTokenAndPasswordFromUrl(url)).toThrow('Invalid URL');
+        });
+
+        it('for empty string', () => {
+            expect(() => getTokenAndPasswordFromUrl('')).toThrow();
+        });
+
+        it('for invalid URL format', () => {
+            expect(() => getTokenAndPasswordFromUrl('not-a-url')).toThrow();
+        });
+    });
+});

package/src/internal/sharingPublic/session/url.ts

@@ -0,0 +1,23 @@
+import { c } from 'ttag';
+
+import { ValidationError } from '../../../errors';
+
+/**
+ * Parse the token and password from the URL.
+ *
+ * The URL format is: https://drive.proton.me/urls/token#password
+ *
+ * @param url - The URL of the public link.
+ * @returns The token and password.
+ */
+export function getTokenAndPasswordFromUrl(url: string): { token: string; password: string } {
+    const urlObj = new URL(url);
+    const token = urlObj.pathname.split('/').pop();
+    const password = urlObj.hash.slice(1);
+
+    if (!token || !password) {
+        throw new ValidationError(c('Error').t`Invalid URL`);
+    }
+
+    return { token, password };
+}

package/src/internal/upload/manager.test.ts

@@ -206,7 +206,7 @@ describe('UploadManager', () => {
                 await promise;
             } catch (error: any) {
                 expect(error.message).toBe('Draft already exists');
-                expect(error.ongoingUploadByOtherClient).toBe(true);
+                expect(error.isUnfinishedUpload).toBe(true);
             }
             expect(apiService.deleteDraft).not.toHaveBeenCalled();
         });
@@ -237,7 +237,7 @@ describe('UploadManager', () => {
                 await promise;
             } catch (error: any) {
                 expect(error.message).toBe('Draft already exists');
-                expect(error.ongoingUploadByOtherClient).toBe(true);
+                expect(error.isUnfinishedUpload).toBe(true);
             }
             expect(apiService.deleteDraft).not.toHaveBeenCalled();
         });

package/src/internal/upload/manager.ts

@@ -1,7 +1,7 @@
 import { c } from 'ttag';
 
 import { Logger, ProtonDriveTelemetry, UploadMetadata } from '../../interface';
-import { ValidationError, NodeAlreadyExistsValidationError } from '../../errors';
+import { ValidationError, NodeWithSameNameExistsValidationError } from '../../errors';
 import { ErrorCode } from '../apiService';
 import { generateFileExtendedAttributes } from '../nodes';
 import { UploadAPIService } from './apiService';
@@ -158,9 +158,7 @@ export class UploadManager {
                         ? makeNodeUid(splitNodeUid(parentFolderUid).volumeId, typedDetails.ConflictLinkID)
                         : undefined;
 
-                    // If there is existing node, return special error
-                    // that includes the available name the client can use.
-                    throw new NodeAlreadyExistsValidationError(
+                    throw new NodeWithSameNameExistsValidationError(
                         error.message,
                         error.code,
                         existingNodeUid,

package/src/protonDriveClient.ts

@@ -1,3 +1,5 @@
+import { getConfig } from './config';
+import { DriveCrypto, SessionKey } from './crypto';
 import {
     Logger,
     ProtonDriveClientContructorParameters,
@@ -6,6 +8,7 @@ import {
     MaybeMissingNode,
     NodeResult,
     Revision,
+    RevisionOrUid,
     ShareNodeSettings,
     UnshareNodeSettings,
     ProtonInvitationOrUid,
@@ -25,16 +28,6 @@ import {
     ThumbnailResult,
     SDKEvent,
 } from './interface';
-import { DriveCrypto, SessionKey } from './crypto';
-import { DriveAPIService } from './internal/apiService';
-import { initSharesModule } from './internal/shares';
-import { initNodesModule } from './internal/nodes';
-import { initSharingModule } from './internal/sharing';
-import { initDownloadModule } from './internal/download';
-import { initUploadModule } from './internal/upload';
-import { DriveEventsService, DriveListener } from './internal/events';
-import { SDKEvents } from './internal/sdkEvents';
-import { getConfig } from './config';
 import {
     getUid,
     getUids,
@@ -44,9 +37,18 @@ import {
     convertInternalNode,
 } from './transformers';
 import { Telemetry } from './telemetry';
+import { DriveAPIService } from './internal/apiService';
 import { initDevicesModule } from './internal/devices';
+import { initDownloadModule } from './internal/download';
+import { DriveEventsService, DriveListener, EventSubscription } from './internal/events';
+import { initNodesModule } from './internal/nodes';
+import { SDKEvents } from './internal/sdkEvents';
+import { initSharesModule } from './internal/shares';
+import { initSharingModule } from './internal/sharing';
+import { SharingPublicSessionManager } from './internal/sharingPublic';
+import { initUploadModule } from './internal/upload';
 import { makeNodeUid } from './internal/uids';
-import { EventSubscription } from './internal/events/interface';
+import { ProtonDrivePublicLinkClient } from './protonDrivePublicLinkClient';
 
 /**
  * ProtonDriveClient is the main interface for the ProtonDrive SDK.
@@ -65,6 +67,7 @@ export class ProtonDriveClient {
     private download: ReturnType<typeof initDownloadModule>;
     private upload: ReturnType<typeof initUploadModule>;
     private devices: ReturnType<typeof initDevicesModule>;
+    private sessionManager: SharingPublicSessionManager;
 
     public experimental: {
         /**
@@ -81,6 +84,20 @@ export class ProtonDriveClient {
          * This is used by Docs app to encrypt and decrypt document updates.
          */
         getDocsKey: (nodeUid: NodeOrUid) => Promise<SessionKey>;
+        /**
+         * Experimental feature to get the info for a public link
+         * required to authenticate the public link.
+         */
+        getPublicLinkInfo: (url: string) => Promise<{
+            isCustomPasswordProtected: boolean;
+            isLegacy: boolean;
+            vendorType: number;
+        }>;
+        /**
+         * Experimental feature to authenticate a public link and
+         * return the client for the public link to access it.
+         */
+        authPublicLink: (url: string, customPassword?: string) => Promise<ProtonDrivePublicLinkClient>;
     };
 
     constructor({
@@ -166,6 +183,8 @@ export class ProtonDriveClient {
             latestEventIdProvider,
         );
 
+        this.sessionManager = new SharingPublicSessionManager(httpClient, apiService, srpModule);
+
         this.experimental = {
             getNodeUrl: async (nodeUid: NodeOrUid) => {
                 this.logger.debug(`Getting node URL for ${getUid(nodeUid)}`);
@@ -179,6 +198,24 @@ export class ProtonDriveClient {
                 }
                 return keys.contentKeyPacketSessionKey;
             },
+            getPublicLinkInfo: async (url: string) => {
+                this.logger.info(`Getting info for public link ${url}`);
+                return this.sessionManager.getInfo(url);
+            },
+            authPublicLink: async (url: string, customPassword?: string) => {
+                this.logger.info(`Authenticating public link ${url}`);
+                const { httpClient, token, password } = await this.sessionManager.auth(url, customPassword);
+                return new ProtonDrivePublicLinkClient({
+                    httpClient,
+                    cryptoCache,
+                    openPGPCryptoModule,
+                    srpModule,
+                    config,
+                    telemetry,
+                    token,
+                    password,
+                });
+            },
         };
     }
 
@@ -311,7 +348,7 @@ export class ProtonDriveClient {
      * @param nodeUid - Node entity or its UID string.
      * @returns The updated node entity.
      * @throws {@link ValidationError} If the name is empty, too long, or contains a slash.
-     * @throws {@link Error} If another node with the same name already exists.
+     * @throws {@link ValidationError} If another node with the same name already exists.
      */
     async renameNode(nodeUid: NodeOrUid, newName: string): Promise<MaybeNode> {
         this.logger.info(`Renaming node ${getUid(nodeUid)}`);
@@ -342,7 +379,7 @@ export class ProtonDriveClient {
         newParentNodeUid: NodeOrUid,
         signal?: AbortSignal,
     ): AsyncGenerator<NodeResult> {
-        this.logger.info(`Moving ${nodeUids.length} nodes to ${newParentNodeUid}`);
+        this.logger.info(`Moving ${nodeUids.length} nodes to ${getUid(newParentNodeUid)}`);
         yield* this.nodes.management.moveNodes(getUids(nodeUids), getUid(newParentNodeUid), signal);
     }
 
@@ -453,9 +490,9 @@ export class ProtonDriveClient {
      *
      * @param revisionUid - UID of the revision to restore.
      */
-    async restoreRevision(revisionUid: string): Promise<void> {
-        this.logger.info(`Restoring revision ${revisionUid}`);
-        await this.nodes.revisions.restoreRevision(revisionUid);
+    async restoreRevision(revisionUid: RevisionOrUid): Promise<void> {
+        this.logger.info(`Restoring revision ${getUid(revisionUid)}`);
+        await this.nodes.revisions.restoreRevision(getUid(revisionUid));
     }
 
     /**
@@ -463,9 +500,9 @@ export class ProtonDriveClient {
      *
      * @param revisionUid - UID of the revision to delete.
      */
-    async deleteRevision(revisionUid: string): Promise<void> {
-        this.logger.info(`Deleting revision ${revisionUid}`);
-        await this.nodes.revisions.deleteRevision(revisionUid);
+    async deleteRevision(revisionUid: RevisionOrUid): Promise<void> {
+        this.logger.info(`Deleting revision ${getUid(revisionUid)}`);
+        await this.nodes.revisions.deleteRevision(getUid(revisionUid));
     }
 
     /**
@@ -527,21 +564,21 @@ export class ProtonDriveClient {
     /**
      * Accept the invitation to the shared node.
      *
-     * @param invitationId - Invitation entity or its UID string.
+     * @param invitationUid - Invitation entity or its UID string.
      */
-    async acceptInvitation(invitationId: string): Promise<void> {
-        this.logger.info(`Accepting invitation ${invitationId}`);
-        await this.sharing.access.acceptInvitation(invitationId);
+    async acceptInvitation(invitationUid: ProtonInvitationOrUid): Promise<void> {
+        this.logger.info(`Accepting invitation ${getUid(invitationUid)}`);
+        await this.sharing.access.acceptInvitation(getUid(invitationUid));
     }
 
     /**
      * Reject the invitation to the shared node.
      *
-     * @param invitationId - Invitation entity or its UID string.
+     * @param invitationOrUid - Invitation entity or its UID string.
      */
-    async rejectInvitation(invitationId: string): Promise<void> {
-        this.logger.info(`Rejecting invitation ${invitationId}`);
-        await this.sharing.access.rejectInvitation(invitationId);
+    async rejectInvitation(invitationUid: ProtonInvitationOrUid): Promise<void> {
+        this.logger.info(`Rejecting invitation ${getUid(invitationUid)}`);
+        await this.sharing.access.rejectInvitation(getUid(invitationUid));
     }
 
     /**

package/src/protonDrivePublicLinkClient.ts

@@ -0,0 +1,121 @@
+import { getConfig } from './config';
+import { DriveCrypto, OpenPGPCrypto, SRPModule, SessionKey } from './crypto';
+import {
+    ProtonDriveHTTPClient,
+    ProtonDriveTelemetry,
+    ProtonDriveConfig,
+    Logger,
+    ProtonDriveCryptoCache,
+    NodeOrUid,
+} from './interface';
+import { Telemetry } from './telemetry';
+import { getUid } from './transformers';
+import { DriveAPIService } from './internal/apiService';
+import { SDKEvents } from './internal/sdkEvents';
+import { initSharingPublicModule } from './internal/sharingPublic';
+
+/**
+ * ProtonDrivePublicLinkClient is the interface for the public link client.
+ *
+ * The client provides high-level operations for managing nodes, and
+ * downloading/uploading files.
+ *
+ * Do not use this client direclty, use ProtonDriveClient instead.
+ * The main client handles public link sessions and provides access to
+ * public links.
+ *
+ * See `experimental.getPublicLinkInfo` and `experimental.authPublicLink`
+ * for more information.
+ */
+export class ProtonDrivePublicLinkClient {
+    private logger: Logger;
+    private sdkEvents: SDKEvents;
+    private sharingPublic: ReturnType<typeof initSharingPublicModule>;
+
+    public experimental: {
+        /**
+         * Experimental feature to return the URL of the node.
+         *
+         * Use it when you want to open the node in the ProtonDrive web app.
+         *
+         * It has hardcoded URLs to open in production client only.
+         */
+        getNodeUrl: (nodeUid: NodeOrUid) => Promise<string>;
+        /**
+         * Experimental feature to get the docs key for a node.
+         *
+         * This is used by Docs app to encrypt and decrypt document updates.
+         */
+        getDocsKey: (nodeUid: NodeOrUid) => Promise<SessionKey>;
+    };
+
+    constructor({
+        httpClient,
+        cryptoCache,
+        openPGPCryptoModule,
+        srpModule,
+        config,
+        telemetry,
+        token,
+        password,
+    }: {
+        httpClient: ProtonDriveHTTPClient;
+        cryptoCache: ProtonDriveCryptoCache;
+        openPGPCryptoModule: OpenPGPCrypto;
+        srpModule: SRPModule;
+        config?: ProtonDriveConfig;
+        telemetry?: ProtonDriveTelemetry;
+        token: string;
+        password: string;
+    }) {
+        if (!telemetry) {
+            telemetry = new Telemetry();
+        }
+        this.logger = telemetry.getLogger('interface');
+
+        const fullConfig = getConfig(config);
+        this.sdkEvents = new SDKEvents(telemetry);
+
+        const apiService = new DriveAPIService(
+            telemetry,
+            this.sdkEvents,
+            httpClient,
+            fullConfig.baseUrl,
+            fullConfig.language,
+        );
+        const driveCrypto = new DriveCrypto(openPGPCryptoModule, srpModule);
+        this.sharingPublic = initSharingPublicModule(telemetry, apiService, cryptoCache, driveCrypto, token, password);
+
+        this.experimental = {
+            getNodeUrl: async (nodeUid: NodeOrUid) => {
+                this.logger.debug(`Getting node URL for ${getUid(nodeUid)}`);
+                // TODO: public node has different URL
+                return '';
+            },
+            getDocsKey: async (nodeUid: NodeOrUid) => {
+                this.logger.debug(`Getting docs keys for ${getUid(nodeUid)}`);
+                const keys = await this.sharingPublic.getNodeKeys(getUid(nodeUid));
+                if (!keys.contentKeyPacketSessionKey) {
+                    throw new Error('Node does not have a content key packet session key');
+                }
+                return keys.contentKeyPacketSessionKey;
+            },
+        };
+    }
+
+    // TODO: comment
+    // TODO: add public node interface
+    async getRootNode() {
+        this.logger.info(`Getting root node`);
+        // TODO: conversion to public node
+        return this.sharingPublic.getRootNode();
+    }
+
+    // TODO: comment
+    // TODO: add public node interface
+    async *iterateChildren(parentUid: NodeOrUid) {
+        this.logger.info(`Iterating children of ${getUid(parentUid)}`);
+        // TODO: conversion to public node
+        yield * this.sharingPublic.iterateChildren(getUid(parentUid));
+    }
+}