@secrecy/lib 1.7.0 → 1.8.0

package/dist/lib/client/SecrecyDbClient.js

@@ -0,0 +1,10 @@
+export class SecrecyDbClient {
+    // #client: SecrecyClient;
+    // #keys: KeyPair;
+    #apiClient;
+    constructor(_client, _keys, apiClient) {
+        // this.#client = client;
+        // this.#keys = keys;
+        this.#apiClient = apiClient;
+    }
+}

package/dist/lib/client/SecrecyMailClient.js

@@ -0,0 +1,283 @@
+import { filesCache } from '../cache.js';
+import { encryptCryptoBox, sodium } from '../index.js';
+import { convertInternalMailToExternal } from './convert/mail.js';
+export class SecrecyMailClient {
+    #client;
+    #keys;
+    #apiClient;
+    constructor(client, keys, apiClient) {
+        this.#client = client;
+        this.#keys = keys;
+        this.#apiClient = apiClient;
+    }
+    async get({ id }) {
+        const mail = await this.#apiClient.mail.byId.query({ id });
+        return await convertInternalMailToExternal({
+            mail,
+            client: this.#client,
+            keyPair: this.#keys,
+        });
+    }
+    async recover({ mailId }) {
+        const { isRecovered } = await this.#apiClient.mail.recover.mutate({
+            id: mailId,
+        });
+        return isRecovered;
+    }
+    async deletedMails({ mailType, }) {
+        const deletedMails = await this.#apiClient.mail.deleted.query({
+            type: mailType,
+        });
+        return await Promise.all(deletedMails.map(async (mail) => await convertInternalMailToExternal({
+            mail,
+            client: this.#client,
+            keyPair: this.#keys,
+        })));
+    }
+    async create(data, customMessage) {
+        const mail = await this.createDraft(data);
+        return await this.sendDraft(mail.mailIntegrityId, customMessage);
+    }
+    async waitingReceivedMails() {
+        // TODO
+        // const waitingReceivedMails =
+        //   await this.#apiClient.mail.waitingReceived.query({})
+        // const result = waitingReceivedMails.map((m) => ({
+        //   id: Math.random().toString(36).substr(2, 9),
+        //   ...m,
+        // }))
+        // return result
+        return [];
+    }
+    async updateDraft(draftId, { body, subject, senderFiles, recipients, replyToId }) {
+        const drafts = await this.draftMails();
+        const draft = drafts.find((d) => d.mailIntegrityId === draftId);
+        if (draft === undefined) {
+            throw new Error(`Invalid draft ${draftId}`);
+        }
+        let hashKey = null;
+        let hash = null;
+        if (body !== undefined || subject !== undefined) {
+            hashKey = sodium.randombytes_buf(sodium.crypto_generichash_KEYBYTES, 'hex');
+            hash = sodium.crypto_generichash(sodium.crypto_generichash_BYTES, JSON.stringify({ body, subject }), hashKey, 'hex');
+        }
+        if (senderFiles !== undefined) {
+            for (const f of senderFiles) {
+                let file = filesCache.get(f.id);
+                if (file === undefined) {
+                    await this.#client.cloud.fileMetadata({ id: f.id });
+                    file = filesCache.get(f.id);
+                    if (file === undefined) {
+                        throw new Error(`File ${f.name} (${f.id}) does not exists`);
+                    }
+                }
+                f.name = sodium.to_hex(encryptCryptoBox(sodium.from_string(f.name), this.#keys.publicKey, this.#keys.privateKey));
+            }
+        }
+        const updateDraftMail = await this.#apiClient.mail.updateDraft.mutate({
+            id: draftId,
+            recipients: recipients ?? null,
+            replyToId: replyToId ?? null,
+            body: body !== undefined
+                ? sodium.to_hex(encryptCryptoBox(sodium.from_string(body), this.#keys.publicKey, this.#keys.privateKey))
+                : null,
+            subject: subject !== undefined
+                ? sodium.to_hex(encryptCryptoBox(sodium.from_string(subject), this.#keys.publicKey, this.#keys.privateKey))
+                : null,
+            senderFiles: senderFiles ?? null,
+            hash,
+            hashKey,
+        });
+        return (await convertInternalMailToExternal({
+            mail: updateDraftMail,
+            client: this.#client,
+            keyPair: this.#keys,
+        }));
+    }
+    async deleteDraft(draftId) {
+        const { isDeleted } = await this.#apiClient.mail.deleteDraft.mutate({
+            id: draftId,
+        });
+        return isDeleted;
+    }
+    async deleteTrash({ ids }) {
+        const { isDeleted } = await this.#apiClient.mail.deleteTrash.mutate({
+            ids,
+        });
+        return isDeleted;
+    }
+    async emptyTrash() {
+        const { isDeleted } = await this.#apiClient.mail.emptyTrash.mutate({});
+        return isDeleted;
+    }
+    async delete({ mailId }) {
+        const { isDeleted } = await this.#apiClient.mail.delete.mutate({
+            id: mailId,
+        });
+        return isDeleted;
+    }
+    async sendDraft(draftId, customMessage) {
+        const drafts = await this.draftMails();
+        const draft = drafts.find((d) => d.mailIntegrityId === draftId);
+        if (draft === undefined) {
+            return false;
+        }
+        const temporaryRecipients = new Array();
+        const recipients = new Array(); // TODO
+        for (const { email } of draft.temporaryRecipients) {
+            if (email === undefined) {
+                continue;
+            }
+            const input = await this._eachUser(draft.files, draft.subject, draft.body, email);
+            if (input === null) {
+                temporaryRecipients.push(email);
+            }
+            else {
+                recipients.push(input);
+            }
+        }
+        for (const { id } of draft.recipients) {
+            const input = await this._eachUser(draft.files, draft.subject, draft.body, id);
+            if (input === null) {
+                temporaryRecipients.push(id);
+            }
+            else {
+                recipients.push(input);
+            }
+        }
+        const { isSent } = await this.#apiClient.mail.sendDraft.mutate({
+            temporaryRecipients,
+            recipients,
+            id: draft.mailIntegrityId,
+            customMessage: customMessage ?? null,
+        });
+        return isSent;
+    }
+    async sendWaitingEmails() {
+        // TODO opti this
+        const mails = await this.sentMails();
+        const filtered = mails.filter((m) => m.temporaryRecipients.length > 0);
+        for (const mail of filtered) {
+            for (const { email } of mail.temporaryRecipients) {
+                if (email === undefined) {
+                    continue;
+                }
+                try {
+                    const input = await this._eachUser(mail.files, mail.subject, mail.body, email);
+                    if (input === null) {
+                        continue;
+                    }
+                    await this.#apiClient.mail.sendOne.mutate({
+                        id: mail.mailIntegrityId,
+                        recipient: input,
+                    });
+                }
+                catch {
+                    continue;
+                }
+            }
+        }
+    }
+    async createDraft({ body, subject, senderFiles, recipients, replyToId, }) {
+        const hashKey = sodium.randombytes_buf(sodium.crypto_generichash_KEYBYTES, 'hex');
+        const hash = sodium.crypto_generichash(sodium.crypto_generichash_BYTES, JSON.stringify({ body, subject }), hashKey, 'hex');
+        for (const f of senderFiles) {
+            let file = filesCache.get(f.id);
+            if (file === undefined) {
+                await this.#client.cloud.fileMetadata({ id: f.id });
+                file = filesCache.get(f.id);
+                if (file === undefined) {
+                    throw new Error(`File ${f.name} (${f.id}) does not exists`);
+                }
+            }
+            senderFiles.push({
+                id: file.id,
+                name: sodium.to_hex(encryptCryptoBox(sodium.from_string(f.name), this.#keys.publicKey, this.#keys.privateKey)),
+            });
+        }
+        const createDraftMail = await this.#apiClient.mail.createDraft.mutate({
+            // recipients: recipientsIds,
+            recipients, // TODO
+            replyToId,
+            body: sodium.to_hex(encryptCryptoBox(sodium.from_string(body), this.#keys.publicKey, this.#keys.privateKey)),
+            subject: sodium.to_hex(encryptCryptoBox(sodium.from_string(subject), this.#keys.publicKey, this.#keys.privateKey)),
+            senderFiles,
+            hash,
+            hashKey,
+        });
+        return (await convertInternalMailToExternal({
+            mail: createDraftMail,
+            client: this.#client,
+            keyPair: this.#keys,
+        }));
+    }
+    async read({ mailId }) {
+        const { isRead } = await this.#apiClient.mail.read.mutate({
+            id: mailId,
+        });
+        return isRead;
+    }
+    async unread({ mailId }) {
+        const { isUnread } = await this.#apiClient.mail.unread.mutate({
+            id: mailId,
+        });
+        return isUnread;
+    }
+    async receivedMails() {
+        const receivedMails = await this.#apiClient.mail.received.query({});
+        return await Promise.all(receivedMails.map(async (mail) => (await convertInternalMailToExternal({
+            mail,
+            client: this.#client,
+            keyPair: this.#keys,
+        }))));
+    }
+    async sentMails() {
+        const sentMails = await this.#apiClient.mail.sent.query({});
+        return await Promise.all(sentMails.map(async (mail) => (await convertInternalMailToExternal({
+            mail,
+            client: this.#client,
+            keyPair: this.#keys,
+        }))));
+    }
+    async draftMails() {
+        const draftMails = await this.#apiClient.mail.draft.query({});
+        return await Promise.all(draftMails.map(async (mail) => (await convertInternalMailToExternal({
+            mail,
+            client: this.#client,
+            keyPair: this.#keys,
+        }))));
+    }
+    async unreadReceivedMailsCount() {
+        const unreadReceivedMailsCount = await this.#apiClient.mail.unreadReceivedCount.query({});
+        return unreadReceivedMailsCount;
+    }
+    _eachUser = async (files, subject, body, idOrMail) => {
+        // const pubKey = await this.#client.app.userPublicKey(userId)
+        const pubKey = await this.#client.app.userPublicKey(idOrMail);
+        // const recipientsFiles = new Array<MailFileInput>()
+        const recipientsFiles = new Array();
+        for (const f of files) {
+            let fileInHistory = filesCache.get(f.id);
+            if (fileInHistory === undefined) {
+                await this.#client.cloud.fileMetadata({ id: f.id });
+                fileInHistory = filesCache.get(f.id);
+                if (fileInHistory === undefined) {
+                    throw new Error(`File ${f.name} (${f.id}) does not exists`);
+                }
+            }
+            const key = fileInHistory.key;
+            recipientsFiles.push({
+                id: f.id,
+                name: sodium.to_hex(encryptCryptoBox(sodium.from_string(f.name), pubKey, this.#keys.privateKey)),
+                fileKey: sodium.to_hex(encryptCryptoBox(sodium.from_hex(key), pubKey, this.#keys.privateKey)),
+            });
+        }
+        return {
+            // recipientId: userId,
+            recipientId: idOrMail,
+            body: sodium.to_hex(encryptCryptoBox(sodium.from_string(body), pubKey, this.#keys.privateKey)),
+            subject: sodium.to_hex(encryptCryptoBox(sodium.from_string(subject), pubKey, this.#keys.privateKey)),
+            files: recipientsFiles,
+        };
+    };
+}

package/dist/lib/client/SecrecyPayClient.js

@@ -0,0 +1,34 @@
+import { getUrl } from '../index.js';
+import { popup } from '../utils/popup-tools.js';
+export class SecrecyPayClient {
+    #client;
+    // #keys: KeyPair
+    // #apiClient: ApiClient
+    constructor(client, _keys, _apiClient) {
+        this.#client = client;
+        // this.#keys = keys
+        // this.#apiClient = apiClient
+    }
+    async confirmPaymentIntent({ paymentIntentId, secrecyIdWhoCreatedPaymentIntent, secrecyIdWhoNeedToConfirmPaymentIntent, amount, currency, }) {
+        const url = getUrl({
+            hash: Buffer.from(JSON.stringify({
+                appSession: this.#client.sessionId,
+                paymentIntentId,
+                secrecyIdWhoCreatedPaymentIntent,
+                secrecyIdWhoNeedToConfirmPaymentIntent,
+                amount,
+                currency,
+            })).toString('base64'),
+            path: '/account/iframe/pay-confirm',
+        });
+        return await new Promise((resolve, reject) => popup(url, 'Secrecy Pay - Confirm Payment Intent', {
+            width: 500,
+        }, (err, data) => {
+            if (err !== undefined) {
+                reject(err);
+                return;
+            }
+            resolve(data);
+        }));
+    }
+}

package/dist/lib/client/SecrecyUserClient.js

@@ -0,0 +1,27 @@
+export class SecrecyUserClient {
+    #apiClient;
+    constructor(_client, _keys, apiClient) {
+        this.#apiClient = apiClient;
+    }
+    async answerInvitation(input) {
+        return await this.#apiClient.contacts.answerInvitation.mutate(input);
+    }
+    async cancelInvitation(input) {
+        return await this.#apiClient.contacts.cancelInvitation.mutate(input);
+    }
+    async createInvitation(input) {
+        return await this.#apiClient.contacts.createInvitation.mutate(input);
+    }
+    async getContacts(input) {
+        return await this.#apiClient.contacts.getContacts.query(input);
+    }
+    async getReceivedInvitations(input) {
+        return await this.#apiClient.contacts.getReceivedInvitations.query(input);
+    }
+    async getSentInvitations(input) {
+        return await this.#apiClient.contacts.getSentInvitations.query(input);
+    }
+    async removeContact(input) {
+        return await this.#apiClient.contacts.removeContact.mutate(input);
+    }
+}

package/dist/lib/client/SecrecyWalletClient.js

@@ -0,0 +1,50 @@
+import { getUrl } from '../index.js';
+import { popup } from '../utils/popup-tools.js';
+export class SecrecyWalletClient {
+    #client;
+    // #keys: KeyPair;
+    // #thunder: ReturnType<typeof Thunder>;
+    constructor(client) {
+        this.#client = client;
+        // this.#keys = keys;
+        // this.#thunder = thunder;
+    }
+    async createTransaction({ network = 'mainnet', tx, }) {
+        const url = getUrl({
+            hash: Buffer.from(JSON.stringify({
+                appSession: this.#client.sessionId,
+                network,
+                tx,
+            })).toString('base64'),
+            path: '/account/iframe/wallet-transaction',
+        });
+        return await new Promise((resolve, reject) => popup(url, 'Secrecy Wallet - Transaction', {
+            width: 500,
+        }, (err, data) => {
+            if (err !== undefined) {
+                reject(err);
+                return;
+            }
+            resolve(data);
+        }));
+    }
+    async createSignature({ network = 'mainnet', message, }) {
+        const url = getUrl({
+            hash: Buffer.from(JSON.stringify({
+                appSession: this.#client.sessionId,
+                network,
+                message,
+            })).toString('base64'),
+            path: '/account/iframe/wallet-signature',
+        });
+        return await new Promise((resolve, reject) => popup(url, 'Secrecy Wallet - Signature', {
+            width: 500,
+        }, (err, data) => {
+            if (err !== undefined) {
+                reject(err);
+                return;
+            }
+            resolve(data);
+        }));
+    }
+}

package/dist/lib/client/convert/file.js

@@ -0,0 +1,29 @@
+import { filesCache } from '../../cache.js';
+import { decryptCryptoBox } from '../../crypto/index.js';
+import { sodium } from '../../sodium.js';
+export function apiFileToInternal(apiFile, keyPair) {
+    const file = {
+        id: apiFile.id,
+        md5: apiFile.md5,
+        md5Encrypted: apiFile.md5Encrypted,
+        createdAt: apiFile.createdAt,
+        size: apiFile.size,
+        sizeBefore: apiFile.sizeBefore,
+        key: sodium.to_hex(decryptCryptoBox(sodium.from_hex(apiFile.access.key), apiFile.access.sharedByPubKey, keyPair.privateKey)),
+    };
+    filesCache.set(file.id, file);
+    return file;
+}
+export function internalFileToFile(internal) {
+    return {
+        id: internal.id,
+        md5: internal.md5,
+        md5Encrypted: internal.md5Encrypted,
+        createdAt: internal.createdAt,
+        size: internal.size,
+        sizeBefore: internal.sizeBefore,
+    };
+}
+export function apiFileToExternal(apiFile, keyPair) {
+    return internalFileToFile(apiFileToInternal(apiFile, keyPair));
+}

package/dist/lib/client/convert/mail.js

@@ -0,0 +1,42 @@
+import { sodium, decryptCryptoBox, } from '../../index.js';
+export async function convertInternalMailToExternal({ client, mail, keyPair, }) {
+    let type = mail.type;
+    if (mail.mailIntegrityDraft !== null) {
+        type = 'draft';
+    }
+    const mI = type === 'draft' ? mail.mailIntegrityDraft : mail.mailIntegrity;
+    if (mI === null) {
+        throw new Error('Mail integrity is null');
+    }
+    const pubKey = mail.type === 'received'
+        ? await client.app.userPublicKey(mail.sender.id)
+        : keyPair.publicKey;
+    const privateKey = keyPair.privateKey;
+    const body = sodium.to_string(decryptCryptoBox(sodium.from_hex(mail.body), pubKey, privateKey));
+    const subject = sodium.to_string(decryptCryptoBox(sodium.from_hex(mail.subject), pubKey, privateKey));
+    const hash = sodium.crypto_generichash(sodium.crypto_generichash_BYTES, JSON.stringify({ body, subject }), mI.hashKey, 'hex');
+    return {
+        type,
+        id: mail.id,
+        mailIntegrityId: mI.id,
+        replyTo: mI.replyTo?.id,
+        body,
+        subject,
+        createdAt: mail.createdAt,
+        deletedAt: mail.deletedAt,
+        openedAt: mail.openedAt,
+        isAltered: hash !== mI.hash,
+        // temporaryRecipients: mI.temporaryRecipients,
+        temporaryRecipients: [], // TODO
+        recipients: mI.recipients,
+        sender: mail.sender,
+        files: mail.files.map((f) => {
+            const name = sodium.to_string(decryptCryptoBox(sodium.from_hex(f.filename), pubKey, privateKey));
+            return {
+                id: f.fileId,
+                name,
+                key: f.fileKey,
+            };
+        }),
+    };
+}

package/dist/lib/client/convert/node.js

@@ -0,0 +1,100 @@
+import { sodium } from '../../sodium.js';
+import { decryptCryptoBox } from '../../crypto/index.js';
+import { nodesCache } from '../../cache.js';
+import { decryptSecretstream } from '../../crypto/file.js';
+import { apiFileToInternal, internalFileToFile } from './file.js';
+export async function apiNodeToInternal(apiNode, keyPair) {
+    const internal = {
+        id: apiNode.id,
+        type: apiNode.type,
+        access: apiNode.access,
+        name: apiNode.name,
+        isFavorite: apiNode.isFavorite,
+        // TODO
+        // breadcrumb: apiNode.breadcrumb,
+        // createdBy: apiNode.createdBy.user,
+        breadcrumb: [],
+        createdBy: {
+            firstname: apiNode.createdBy.userId,
+            lastname: apiNode.createdBy.userId,
+            avatar: apiNode.createdBy.userId,
+            id: apiNode.createdBy.userId,
+            isSearchable: true,
+        },
+        currentFileId: null,
+        // currentFileId: apiNode.currentFileId ?? null,
+        sizes: {
+            // size: apiNode.sizes.size,
+            // sizeBefore: apiNode.sizes.sizeBefore,
+            size: 0n,
+            sizeBefore: 0n,
+        },
+        createdAt: apiNode.createdAt,
+        updatedAt: apiNode.updatedAt,
+        deletedAt: apiNode.deletedAt,
+        users: apiNode.users,
+        parentId: apiNode.parentId ?? null,
+    };
+    internal.access = { ...apiNode.access };
+    if (apiNode.access.nameKey !== null) {
+        const key = decryptCryptoBox(sodium.from_hex(apiNode.access.nameKey), apiNode.access.sharedByPubKey, keyPair.privateKey);
+        internal.name = sodium.to_string(await decryptSecretstream(key, sodium.from_hex(internal.name)));
+        internal.access.nameKey = sodium.to_hex(key);
+    }
+    for (const b of internal.breadcrumb) {
+        if (b.nameKey === null) {
+            continue;
+        }
+        const key = decryptCryptoBox(sodium.from_hex(b.nameKey), b.pubKey, keyPair.privateKey);
+        b.nameKey = sodium.to_hex(key);
+        b.name = sodium.to_string(await decryptSecretstream(key, sodium.from_hex(b.name)));
+    }
+    nodesCache.set(internal.id, internal);
+    return internal;
+}
+export async function apiNodeFullToInternalFull(apiNodeFull, keyPair) {
+    const f = await apiNodeToInternal(apiNodeFull, keyPair);
+    return {
+        ...f,
+        current: apiNodeFull.current !== null
+            ? apiFileToInternal(apiNodeFull.current, keyPair)
+            : undefined,
+        parent: apiNodeFull.parent !== null
+            ? await apiNodeToInternal(apiNodeFull.parent, keyPair)
+            : null,
+        children: await Promise.all(apiNodeFull.children.map(async (s) => await apiNodeToInternal(s, keyPair))),
+        history: apiNodeFull.history.map((f) => apiFileToInternal(f, keyPair)),
+    };
+}
+export function internalNodeToNode(internal) {
+    const node = {
+        ...internal,
+        breadcrumb: internal.breadcrumb.map((b) => ({
+            id: b.id,
+            name: b.name,
+        })),
+        access: {
+            isRoot: internal.access.isRoot,
+            rights: internal.access.rights,
+            sharedByPubKey: internal.access.sharedByPubKey,
+        },
+    };
+    return node;
+}
+export function internalNodeFullToNodeFull(internal) {
+    return {
+        ...internalNodeToNode(internal),
+        parent: internal.parent !== null ? internalNodeToNode(internal.parent) : null,
+        children: internal.children.map(internalNodeToNode),
+        history: internal.history.map((f) => internalFileToFile(f)),
+        current: internal.current !== null && internal.current !== undefined
+            ? internalFileToFile(internal.current)
+            : undefined,
+    };
+}
+export async function apiNodeToExternalNodeFull(apiNodeFull, keyPair) {
+    return internalNodeFullToNodeFull(await apiNodeFullToInternalFull(apiNodeFull, keyPair));
+}
+export async function apiNodeToExternal(apiNode, keyPair) {
+    return internalNodeToNode(await apiNodeToInternal(apiNode, keyPair));
+}

package/dist/lib/client/helpers.js

@@ -0,0 +1,103 @@
+import { SecrecyClient } from './index.js';
+import { popup } from '../utils/popup-tools.js';
+import { secrecyUserApp } from './types/index.js';
+import { getStorage } from './storage.js';
+export function parseInfos() {
+    if (window.location.hash === '') {
+        return null;
+    }
+    const hash = window.location.hash.substr(1);
+    try {
+        const res = JSON.parse(atob(hash));
+        window.location.hash = '';
+        const data = secrecyUserApp.safeParse(res);
+        return data.success ? data.data : null;
+    }
+    catch {
+        return null;
+    }
+}
+export const getUrl = ({ hash, path, }) => {
+    const lang = document.documentElement.lang;
+    const rawAuthUrl = process.env.NEXT_PUBLIC_SECRECY_AUTH_URL ?? 'https://auth.secrecy.me/';
+    const authUrl = rawAuthUrl.endsWith('/') ? rawAuthUrl : `${rawAuthUrl}/`;
+    path = path.startsWith('/') ? path : `/${path}`;
+    return `${authUrl}${lang}${path}#${hash}`;
+};
+export function getSecrecyClient(session) {
+    const storage = getStorage(session);
+    const uaSession = storage.userAppSession.load();
+    const uaKeys = storage.userAppKeys.load();
+    const uaJwt = storage.jwt.load();
+    if (uaSession === null || uaKeys === null || uaJwt === null) {
+        const infos = parseInfos();
+        if (infos !== null) {
+            storage.userAppKeys.save(infos.keys);
+            storage.userAppSession.save(infos.uaSession);
+            storage.jwt.save(infos.jwt);
+            return new SecrecyClient(infos.uaSession, infos.keys, infos.jwt);
+        }
+        return null;
+    }
+    return new SecrecyClient(uaSession, uaKeys, uaJwt);
+}
+export async function login({ appId, path, redirect, scopes, backPath, session, }) {
+    return await new Promise((resolve, reject) => {
+        const appUrl = window.location.origin;
+        const client = getSecrecyClient();
+        if (client === null) {
+            const infos = {
+                appUrl,
+                appId,
+                redirect,
+                path,
+                scopes,
+                backPath,
+            };
+            const data = btoa(JSON.stringify(infos)).replaceAll('=', '');
+            const url = getUrl({
+                hash: data,
+                path: 'login',
+            });
+            const validate = (infos) => {
+                const storage = getStorage(session);
+                storage.userAppSession.save(infos.uaSession);
+                storage.userAppKeys.save(infos.keys);
+                storage.jwt.save(infos.jwt);
+                resolve(new SecrecyClient(infos.uaSession, infos.keys, infos.jwt));
+            };
+            if (redirect === true) {
+                const infos = parseInfos();
+                if (infos !== null) {
+                    validate(infos);
+                }
+                else {
+                    window.location.href = url;
+                    resolve(null);
+                }
+            }
+            else {
+                popup(url, 'Secrecy Login', {
+                    width: 500,
+                    height: 750,
+                    resizable: 'no',
+                    menubar: 'no',
+                    location: 'no',
+                    centered: true,
+                    scrollbars: 'no',
+                }, (err, data) => {
+                    if (err !== undefined) {
+                        reject(err);
+                    }
+                    else {
+                        const res = secrecyUserApp.safeParse(data);
+                        res.success ? validate(res.data) : reject(res.error.message);
+                    }
+                });
+            }
+        }
+        else {
+            resolve(client);
+        }
+    });
+}