@haex-space/vault-sdk 2.5.49 → 2.5.52

package/dist/index.js

@@ -645,6 +645,224 @@ var DatabaseAPI = class {
   }
 };
 
+// src/crypto/vaultKey.ts
+var PBKDF2_ITERATIONS = 6e5;
+var KEY_LENGTH = 256;
+var ALGORITHM = "AES-GCM";
+async function deriveKeyFromPassword(password, salt) {
+  const encoder = new TextEncoder();
+  const passwordBuffer = encoder.encode(password);
+  const saltBuffer = new Uint8Array(salt);
+  const keyMaterial = await crypto.subtle.importKey(
+    "raw",
+    passwordBuffer,
+    "PBKDF2",
+    false,
+    ["deriveKey"]
+  );
+  return await crypto.subtle.deriveKey(
+    {
+      name: "PBKDF2",
+      salt: saltBuffer,
+      iterations: PBKDF2_ITERATIONS,
+      hash: "SHA-256"
+    },
+    keyMaterial,
+    { name: ALGORITHM, length: KEY_LENGTH },
+    false,
+    // not extractable
+    ["encrypt", "decrypt"]
+  );
+}
+function generateVaultKey() {
+  return crypto.getRandomValues(new Uint8Array(32));
+}
+async function encryptString(data, derivedKey) {
+  const nonce = crypto.getRandomValues(new Uint8Array(12));
+  const encoder = new TextEncoder();
+  const dataBuffer = encoder.encode(data);
+  const encryptedBuffer = await crypto.subtle.encrypt(
+    {
+      name: ALGORITHM,
+      iv: nonce
+    },
+    derivedKey,
+    dataBuffer
+  );
+  return {
+    encryptedData: arrayBufferToBase64(encryptedBuffer),
+    nonce: arrayBufferToBase64(nonce)
+  };
+}
+async function decryptString(encryptedData, nonce, derivedKey) {
+  const encryptedBuffer = base64ToArrayBuffer(encryptedData);
+  const nonceBuffer = base64ToArrayBuffer(nonce);
+  const encryptedDataBuffer = new Uint8Array(encryptedBuffer);
+  const iv = new Uint8Array(nonceBuffer);
+  const decryptedBuffer = await crypto.subtle.decrypt(
+    {
+      name: ALGORITHM,
+      iv
+    },
+    derivedKey,
+    encryptedDataBuffer
+  );
+  const decoder = new TextDecoder();
+  return decoder.decode(decryptedBuffer);
+}
+async function encryptVaultKey(vaultKey, password) {
+  const salt = crypto.getRandomValues(new Uint8Array(32));
+  const derivedKey = await deriveKeyFromPassword(password, salt);
+  const nonce = crypto.getRandomValues(new Uint8Array(12));
+  const vaultKeyBuffer = new Uint8Array(vaultKey);
+  const encryptedBuffer = await crypto.subtle.encrypt(
+    {
+      name: ALGORITHM,
+      iv: nonce
+    },
+    derivedKey,
+    vaultKeyBuffer
+  );
+  return {
+    encryptedVaultKey: arrayBufferToBase64(encryptedBuffer),
+    salt: arrayBufferToBase64(salt),
+    vaultKeyNonce: arrayBufferToBase64(nonce)
+  };
+}
+async function decryptVaultKey(encryptedVaultKey, salt, vaultKeyNonce, password) {
+  const encryptedBuffer = base64ToArrayBuffer(encryptedVaultKey);
+  const saltBuffer = base64ToArrayBuffer(salt);
+  const nonceBuffer = base64ToArrayBuffer(vaultKeyNonce);
+  const derivedKey = await deriveKeyFromPassword(password, saltBuffer);
+  const encryptedData = new Uint8Array(encryptedBuffer);
+  const iv = new Uint8Array(nonceBuffer);
+  const decryptedBuffer = await crypto.subtle.decrypt(
+    {
+      name: ALGORITHM,
+      iv
+    },
+    derivedKey,
+    encryptedData
+  );
+  return new Uint8Array(decryptedBuffer);
+}
+async function decryptVaultName(encryptedVaultName, vaultNameNonce, vaultNameSalt, password) {
+  const saltBuffer = base64ToArrayBuffer(vaultNameSalt);
+  const derivedKey = await deriveKeyFromPassword(password, saltBuffer);
+  return decryptString(encryptedVaultName, vaultNameNonce, derivedKey);
+}
+async function encryptCrdtData(data, vaultKey) {
+  const vaultKeyBuffer = new Uint8Array(vaultKey);
+  const cryptoKey = await crypto.subtle.importKey(
+    "raw",
+    vaultKeyBuffer,
+    { name: ALGORITHM },
+    false,
+    ["encrypt"]
+  );
+  const nonce = crypto.getRandomValues(new Uint8Array(12));
+  const encoder = new TextEncoder();
+  const dataBuffer = encoder.encode(JSON.stringify(data));
+  const encryptedBuffer = await crypto.subtle.encrypt(
+    {
+      name: ALGORITHM,
+      iv: nonce
+    },
+    cryptoKey,
+    dataBuffer
+  );
+  return {
+    encryptedData: arrayBufferToBase64(encryptedBuffer),
+    nonce: arrayBufferToBase64(nonce)
+  };
+}
+async function wrapKey(keyToWrap, wrappingKey) {
+  const cryptoKey = await crypto.subtle.importKey(
+    "raw",
+    new Uint8Array(wrappingKey),
+    { name: ALGORITHM },
+    false,
+    ["encrypt"]
+  );
+  const nonce = crypto.getRandomValues(new Uint8Array(12));
+  const ciphertext = await crypto.subtle.encrypt(
+    { name: ALGORITHM, iv: nonce },
+    cryptoKey,
+    new Uint8Array(keyToWrap)
+  );
+  const result = new Uint8Array(12 + ciphertext.byteLength);
+  result.set(nonce, 0);
+  result.set(new Uint8Array(ciphertext), 12);
+  return result;
+}
+async function unwrapKey(wrappedKey, wrappingKey) {
+  const cryptoKey = await crypto.subtle.importKey(
+    "raw",
+    new Uint8Array(wrappingKey),
+    { name: ALGORITHM },
+    false,
+    ["decrypt"]
+  );
+  const nonce = wrappedKey.slice(0, 12);
+  const ciphertext = wrappedKey.slice(12);
+  const plaintext = await crypto.subtle.decrypt(
+    { name: ALGORITHM, iv: nonce },
+    cryptoKey,
+    ciphertext
+  );
+  return new Uint8Array(plaintext);
+}
+async function decryptCrdtData(encryptedData, nonce, vaultKey) {
+  const vaultKeyBuffer = new Uint8Array(vaultKey);
+  const cryptoKey = await crypto.subtle.importKey(
+    "raw",
+    vaultKeyBuffer,
+    { name: ALGORITHM },
+    false,
+    ["decrypt"]
+  );
+  const encryptedBuffer = base64ToArrayBuffer(encryptedData);
+  const nonceBuffer = base64ToArrayBuffer(nonce);
+  const encryptedDataBuffer = new Uint8Array(encryptedBuffer);
+  const iv = new Uint8Array(nonceBuffer);
+  const decryptedBuffer = await crypto.subtle.decrypt(
+    {
+      name: ALGORITHM,
+      iv
+    },
+    cryptoKey,
+    encryptedDataBuffer
+  );
+  const decoder = new TextDecoder();
+  const jsonString = decoder.decode(decryptedBuffer);
+  return JSON.parse(jsonString);
+}
+function arrayBufferToBase64(buffer) {
+  const bytes = buffer instanceof Uint8Array ? buffer : new Uint8Array(buffer);
+  if (typeof Buffer !== "undefined") {
+    return Buffer.from(bytes).toString("base64");
+  }
+  let binary = "";
+  for (let i = 0; i < bytes.length; i++) {
+    const byte = bytes[i];
+    if (byte !== void 0) {
+      binary += String.fromCharCode(byte);
+    }
+  }
+  return btoa(binary);
+}
+function base64ToArrayBuffer(base64) {
+  if (typeof Buffer !== "undefined") {
+    return new Uint8Array(Buffer.from(base64, "base64"));
+  }
+  const binary = atob(base64);
+  const bytes = new Uint8Array(binary.length);
+  for (let i = 0; i < binary.length; i++) {
+    bytes[i] = binary.charCodeAt(i);
+  }
+  return bytes;
+}
+
 // src/api/filesystem.ts
 var FilesystemAPI = class {
   constructor(client) {
@@ -716,12 +934,7 @@ var FilesystemAPI = class {
       HAEXTENSION_METHODS.filesystem.readFile,
       { path }
     );
-    const binary = atob(base64);
-    const bytes = new Uint8Array(binary.length);
-    for (let i = 0; i < binary.length; i++) {
-      bytes[i] = binary.charCodeAt(i);
-    }
-    return bytes;
+    return base64ToArrayBuffer(base64);
   }
   /**
    * Write file contents
@@ -729,7 +942,7 @@ var FilesystemAPI = class {
    * @param data File contents as Uint8Array
    */
   async writeFile(path, data) {
-    const base64 = btoa(String.fromCharCode(...data));
+    const base64 = arrayBufferToBase64(data);
     await this.client.request(
       HAEXTENSION_METHODS.filesystem.writeFile,
       { path, data: base64 }
@@ -1015,7 +1228,7 @@ var RemoteStorageAPI = class {
    * @param data - Data to upload
    */
   async upload(backendId, key, data) {
-    const base64 = btoa(String.fromCharCode(...data));
+    const base64 = arrayBufferToBase64(data);
     await this.client.request(HAEXTENSION_METHODS.remoteStorage.upload, {
       backendId,
       key,
@@ -1033,12 +1246,7 @@ var RemoteStorageAPI = class {
       HAEXTENSION_METHODS.remoteStorage.download,
       { backendId, key }
     );
-    const binary = atob(base64);
-    const bytes = new Uint8Array(binary.length);
-    for (let i = 0; i < binary.length; i++) {
-      bytes[i] = binary.charCodeAt(i);
-    }
-    return bytes;
+    return base64ToArrayBuffer(base64);
   }
   /**
    * Delete an object from a storage backend
@@ -1455,6 +1663,7 @@ var webHandlers = {
 
 // src/transport/handlers/filesystem.ts
 var filesystemHandlers = {
+  // Legacy extension-specific operations
   [HAEXTENSION_METHODS.filesystem.saveFile]: {
     command: TAURI_COMMANDS.filesystem.saveFile,
     args: (p) => ({
@@ -1476,6 +1685,58 @@ var filesystemHandlers = {
     args: (p) => ({
       dataUrl: p.dataUrl
     })
+  },
+  // Generic filesystem operations
+  [HAEXTENSION_METHODS.filesystem.readFile]: {
+    command: TAURI_COMMANDS.filesystem.readFile,
+    args: (p) => ({ path: p.path })
+  },
+  [HAEXTENSION_METHODS.filesystem.writeFile]: {
+    command: TAURI_COMMANDS.filesystem.writeFile,
+    args: (p) => ({ path: p.path, data: p.data })
+  },
+  [HAEXTENSION_METHODS.filesystem.readDir]: {
+    command: TAURI_COMMANDS.filesystem.readDir,
+    args: (p) => ({ path: p.path })
+  },
+  [HAEXTENSION_METHODS.filesystem.mkdir]: {
+    command: TAURI_COMMANDS.filesystem.mkdir,
+    args: (p) => ({ path: p.path })
+  },
+  [HAEXTENSION_METHODS.filesystem.remove]: {
+    command: TAURI_COMMANDS.filesystem.remove,
+    args: (p) => ({ path: p.path })
+  },
+  [HAEXTENSION_METHODS.filesystem.exists]: {
+    command: TAURI_COMMANDS.filesystem.exists,
+    args: (p) => ({ path: p.path })
+  },
+  [HAEXTENSION_METHODS.filesystem.stat]: {
+    command: TAURI_COMMANDS.filesystem.stat,
+    args: (p) => ({ path: p.path })
+  },
+  [HAEXTENSION_METHODS.filesystem.selectFolder]: {
+    command: TAURI_COMMANDS.filesystem.selectFolder,
+    args: (p) => ({
+      title: p.title,
+      defaultPath: p.defaultPath
+    })
+  },
+  [HAEXTENSION_METHODS.filesystem.selectFile]: {
+    command: TAURI_COMMANDS.filesystem.selectFile,
+    args: (p) => ({
+      title: p.title,
+      defaultPath: p.defaultPath,
+      filters: p.filters
+    })
+  },
+  [HAEXTENSION_METHODS.filesystem.rename]: {
+    command: TAURI_COMMANDS.filesystem.rename,
+    args: (p) => ({ from: p.from, to: p.to })
+  },
+  [HAEXTENSION_METHODS.filesystem.copy]: {
+    command: TAURI_COMMANDS.filesystem.copy,
+    args: (p) => ({ from: p.from, to: p.to })
   }
 };
 
@@ -2276,224 +2537,6 @@ async function verifyExtensionSignature(files, manifest) {
   }
 }
 
-// src/crypto/vaultKey.ts
-var PBKDF2_ITERATIONS = 6e5;
-var KEY_LENGTH = 256;
-var ALGORITHM = "AES-GCM";
-async function deriveKeyFromPassword(password, salt) {
-  const encoder = new TextEncoder();
-  const passwordBuffer = encoder.encode(password);
-  const saltBuffer = new Uint8Array(salt);
-  const keyMaterial = await crypto.subtle.importKey(
-    "raw",
-    passwordBuffer,
-    "PBKDF2",
-    false,
-    ["deriveKey"]
-  );
-  return await crypto.subtle.deriveKey(
-    {
-      name: "PBKDF2",
-      salt: saltBuffer,
-      iterations: PBKDF2_ITERATIONS,
-      hash: "SHA-256"
-    },
-    keyMaterial,
-    { name: ALGORITHM, length: KEY_LENGTH },
-    false,
-    // not extractable
-    ["encrypt", "decrypt"]
-  );
-}
-function generateVaultKey() {
-  return crypto.getRandomValues(new Uint8Array(32));
-}
-async function encryptString(data, derivedKey) {
-  const nonce = crypto.getRandomValues(new Uint8Array(12));
-  const encoder = new TextEncoder();
-  const dataBuffer = encoder.encode(data);
-  const encryptedBuffer = await crypto.subtle.encrypt(
-    {
-      name: ALGORITHM,
-      iv: nonce
-    },
-    derivedKey,
-    dataBuffer
-  );
-  return {
-    encryptedData: arrayBufferToBase64(encryptedBuffer),
-    nonce: arrayBufferToBase64(nonce)
-  };
-}
-async function decryptString(encryptedData, nonce, derivedKey) {
-  const encryptedBuffer = base64ToArrayBuffer(encryptedData);
-  const nonceBuffer = base64ToArrayBuffer(nonce);
-  const encryptedDataBuffer = new Uint8Array(encryptedBuffer);
-  const iv = new Uint8Array(nonceBuffer);
-  const decryptedBuffer = await crypto.subtle.decrypt(
-    {
-      name: ALGORITHM,
-      iv
-    },
-    derivedKey,
-    encryptedDataBuffer
-  );
-  const decoder = new TextDecoder();
-  return decoder.decode(decryptedBuffer);
-}
-async function encryptVaultKey(vaultKey, password) {
-  const salt = crypto.getRandomValues(new Uint8Array(32));
-  const derivedKey = await deriveKeyFromPassword(password, salt);
-  const nonce = crypto.getRandomValues(new Uint8Array(12));
-  const vaultKeyBuffer = new Uint8Array(vaultKey);
-  const encryptedBuffer = await crypto.subtle.encrypt(
-    {
-      name: ALGORITHM,
-      iv: nonce
-    },
-    derivedKey,
-    vaultKeyBuffer
-  );
-  return {
-    encryptedVaultKey: arrayBufferToBase64(encryptedBuffer),
-    salt: arrayBufferToBase64(salt),
-    vaultKeyNonce: arrayBufferToBase64(nonce)
-  };
-}
-async function decryptVaultKey(encryptedVaultKey, salt, vaultKeyNonce, password) {
-  const encryptedBuffer = base64ToArrayBuffer(encryptedVaultKey);
-  const saltBuffer = base64ToArrayBuffer(salt);
-  const nonceBuffer = base64ToArrayBuffer(vaultKeyNonce);
-  const derivedKey = await deriveKeyFromPassword(password, saltBuffer);
-  const encryptedData = new Uint8Array(encryptedBuffer);
-  const iv = new Uint8Array(nonceBuffer);
-  const decryptedBuffer = await crypto.subtle.decrypt(
-    {
-      name: ALGORITHM,
-      iv
-    },
-    derivedKey,
-    encryptedData
-  );
-  return new Uint8Array(decryptedBuffer);
-}
-async function decryptVaultName(encryptedVaultName, vaultNameNonce, vaultNameSalt, password) {
-  const saltBuffer = base64ToArrayBuffer(vaultNameSalt);
-  const derivedKey = await deriveKeyFromPassword(password, saltBuffer);
-  return decryptString(encryptedVaultName, vaultNameNonce, derivedKey);
-}
-async function encryptCrdtData(data, vaultKey) {
-  const vaultKeyBuffer = new Uint8Array(vaultKey);
-  const cryptoKey = await crypto.subtle.importKey(
-    "raw",
-    vaultKeyBuffer,
-    { name: ALGORITHM },
-    false,
-    ["encrypt"]
-  );
-  const nonce = crypto.getRandomValues(new Uint8Array(12));
-  const encoder = new TextEncoder();
-  const dataBuffer = encoder.encode(JSON.stringify(data));
-  const encryptedBuffer = await crypto.subtle.encrypt(
-    {
-      name: ALGORITHM,
-      iv: nonce
-    },
-    cryptoKey,
-    dataBuffer
-  );
-  return {
-    encryptedData: arrayBufferToBase64(encryptedBuffer),
-    nonce: arrayBufferToBase64(nonce)
-  };
-}
-async function wrapKey(keyToWrap, wrappingKey) {
-  const cryptoKey = await crypto.subtle.importKey(
-    "raw",
-    new Uint8Array(wrappingKey),
-    { name: ALGORITHM },
-    false,
-    ["encrypt"]
-  );
-  const nonce = crypto.getRandomValues(new Uint8Array(12));
-  const ciphertext = await crypto.subtle.encrypt(
-    { name: ALGORITHM, iv: nonce },
-    cryptoKey,
-    new Uint8Array(keyToWrap)
-  );
-  const result = new Uint8Array(12 + ciphertext.byteLength);
-  result.set(nonce, 0);
-  result.set(new Uint8Array(ciphertext), 12);
-  return result;
-}
-async function unwrapKey(wrappedKey, wrappingKey) {
-  const cryptoKey = await crypto.subtle.importKey(
-    "raw",
-    new Uint8Array(wrappingKey),
-    { name: ALGORITHM },
-    false,
-    ["decrypt"]
-  );
-  const nonce = wrappedKey.slice(0, 12);
-  const ciphertext = wrappedKey.slice(12);
-  const plaintext = await crypto.subtle.decrypt(
-    { name: ALGORITHM, iv: nonce },
-    cryptoKey,
-    ciphertext
-  );
-  return new Uint8Array(plaintext);
-}
-async function decryptCrdtData(encryptedData, nonce, vaultKey) {
-  const vaultKeyBuffer = new Uint8Array(vaultKey);
-  const cryptoKey = await crypto.subtle.importKey(
-    "raw",
-    vaultKeyBuffer,
-    { name: ALGORITHM },
-    false,
-    ["decrypt"]
-  );
-  const encryptedBuffer = base64ToArrayBuffer(encryptedData);
-  const nonceBuffer = base64ToArrayBuffer(nonce);
-  const encryptedDataBuffer = new Uint8Array(encryptedBuffer);
-  const iv = new Uint8Array(nonceBuffer);
-  const decryptedBuffer = await crypto.subtle.decrypt(
-    {
-      name: ALGORITHM,
-      iv
-    },
-    cryptoKey,
-    encryptedDataBuffer
-  );
-  const decoder = new TextDecoder();
-  const jsonString = decoder.decode(decryptedBuffer);
-  return JSON.parse(jsonString);
-}
-function arrayBufferToBase64(buffer) {
-  const bytes = buffer instanceof Uint8Array ? buffer : new Uint8Array(buffer);
-  if (typeof Buffer !== "undefined") {
-    return Buffer.from(bytes).toString("base64");
-  }
-  let binary = "";
-  for (let i = 0; i < bytes.length; i++) {
-    const byte = bytes[i];
-    if (byte !== void 0) {
-      binary += String.fromCharCode(byte);
-    }
-  }
-  return btoa(binary);
-}
-function base64ToArrayBuffer(base64) {
-  if (typeof Buffer !== "undefined") {
-    return new Uint8Array(Buffer.from(base64, "base64"));
-  }
-  const binary = atob(base64);
-  const bytes = new Uint8Array(binary.length);
-  for (let i = 0; i < binary.length; i++) {
-    bytes[i] = binary.charCodeAt(i);
-  }
-  return bytes;
-}
-
 // src/index.ts
 function createHaexVaultSdk(config = {}) {
   return new HaexVaultSdk(config);