bedrock-ts-sdk 0.0.2 → 0.0.4

package/dist/index.js

@@ -188,24 +188,27 @@ var FileMetaEncryptedSchema = import_zod.z.object({
   // Encrypted filename
   path: import_zod.z.string(),
   // Encrypted path
-  key: HexString64Schema,
-  // Encrypted AES key
-  iv: HexString32Schema,
-  // Encrypted IV
-  store_hash: HexString64Schema,
-  // Aleph STORE hash
+  key: import_zod.z.string(),
+  // Encrypted AES key (ECIES encrypted)
+  iv: import_zod.z.string(),
+  // Encrypted IV (ECIES encrypted)
+  store_hash: import_zod.z.string(),
+  // Encrypted Aleph STORE hash
   size: import_zod.z.string(),
   // Encrypted size
   created_at: import_zod.z.string(),
   // Encrypted datetime
   deleted_at: import_zod.z.string().nullable(),
   // Encrypted datetime or null
-  shared_keys: import_zod.z.record(import_zod.z.string(), import_zod.z.object({
-    key: import_zod.z.string(),
-    // Encrypted key for recipient
-    iv: import_zod.z.string()
-    // Encrypted IV for recipient
-  })).default({})
+  shared_keys: import_zod.z.record(
+    import_zod.z.string(),
+    import_zod.z.object({
+      key: import_zod.z.string(),
+      // Encrypted key for recipient
+      iv: import_zod.z.string()
+      // Encrypted IV for recipient
+    })
+  ).default({})
 });
 var FileMetaSchema = import_zod.z.object({
   name: import_zod.z.string(),
@@ -216,10 +219,13 @@ var FileMetaSchema = import_zod.z.object({
   size: import_zod.z.number(),
   created_at: DatetimeSchema,
   deleted_at: DatetimeSchema.nullable(),
-  shared_keys: import_zod.z.record(import_zod.z.string(), import_zod.z.object({
-    key: HexString64Schema,
-    iv: HexString32Schema
-  })).default({})
+  shared_keys: import_zod.z.record(
+    import_zod.z.string(),
+    import_zod.z.object({
+      key: HexString64Schema,
+      iv: HexString32Schema
+    })
+  ).default({})
 });
 var PublicFileMetaSchema = import_zod.z.object({
   name: import_zod.z.string(),
@@ -264,13 +270,15 @@ var FileEntriesAggregateSchema = import_zod.z.object({
   files: import_zod.z.array(FileEntrySchema).default([])
 });
 var SecurityAggregateSchema = import_zod.z.object({
-  authorizations: import_zod.z.array(import_zod.z.object({
-    address: AddressSchema,
-    chain: import_zod.z.string(),
-    channels: import_zod.z.array(import_zod.z.string()).optional(),
-    post_types: import_zod.z.array(import_zod.z.string()).optional(),
-    aggregate_keys: import_zod.z.array(import_zod.z.string()).optional()
-  }))
+  authorizations: import_zod.z.array(
+    import_zod.z.object({
+      address: AddressSchema,
+      chain: import_zod.z.string(),
+      channels: import_zod.z.array(import_zod.z.string()).optional(),
+      post_types: import_zod.z.array(import_zod.z.string()).optional(),
+      aggregate_keys: import_zod.z.array(import_zod.z.string()).optional()
+    })
+  )
 });
 
 // src/client/aleph-service.ts
@@ -594,7 +602,7 @@ var BedrockCore = class _BedrockCore {
    * Get the main account's public key
    */
   getPublicKey() {
-    return this.encryptionPrivateKey.publicKey.toHex();
+    return this.encryptionPrivateKey.publicKey.compressed.toString("hex");
   }
   /**
    * Get the sub-account's private key (as hex string)
@@ -654,6 +662,9 @@ var BedrockCore = class _BedrockCore {
   }
 };
 
+// src/services/file-service.ts
+var import_client3 = require("@aleph-sdk/client");
+
 // src/crypto/encryption.ts
 var import_eciesjs2 = require("eciesjs");
 var CryptoUtils = class {
@@ -880,74 +891,33 @@ var EncryptionService = class {
   // ============================================================================
   static async encryptBrowser(data, key, iv) {
     const crypto = CryptoUtils.getCrypto();
-    const cryptoKey = await crypto.subtle.importKey(
-      "raw",
-      key,
-      { name: "AES-CBC" },
-      false,
-      ["encrypt"]
-    );
+    const cryptoKey = await crypto.subtle.importKey("raw", key, { name: "AES-CBC" }, false, ["encrypt"]);
     const dataBuffer = Buffer.from(data, "utf-8");
-    const encrypted = await crypto.subtle.encrypt(
-      { name: "AES-CBC", iv },
-      cryptoKey,
-      dataBuffer
-    );
+    const encrypted = await crypto.subtle.encrypt({ name: "AES-CBC", iv }, cryptoKey, dataBuffer);
     return CryptoUtils.bufferToHex(Buffer.from(encrypted));
   }
   static async decryptBrowser(encryptedData, key, iv) {
     const crypto = CryptoUtils.getCrypto();
-    const cryptoKey = await crypto.subtle.importKey(
-      "raw",
-      key,
-      { name: "AES-CBC" },
-      false,
-      ["decrypt"]
-    );
+    const cryptoKey = await crypto.subtle.importKey("raw", key, { name: "AES-CBC" }, false, ["decrypt"]);
     const encryptedBuffer = CryptoUtils.hexToBuffer(encryptedData);
-    const decrypted = await crypto.subtle.decrypt(
-      { name: "AES-CBC", iv },
-      cryptoKey,
-      encryptedBuffer
-    );
+    const decrypted = await crypto.subtle.decrypt({ name: "AES-CBC", iv }, cryptoKey, encryptedBuffer);
     return Buffer.from(decrypted).toString("utf-8");
   }
   static async encryptFileBrowser(buffer, key, iv) {
     const crypto = CryptoUtils.getCrypto();
-    const cryptoKey = await crypto.subtle.importKey(
-      "raw",
-      key,
-      { name: "AES-CBC" },
-      false,
-      ["encrypt"]
-    );
-    const encrypted = await crypto.subtle.encrypt(
-      { name: "AES-CBC", iv },
-      cryptoKey,
-      buffer
-    );
+    const cryptoKey = await crypto.subtle.importKey("raw", key, { name: "AES-CBC" }, false, ["encrypt"]);
+    const encrypted = await crypto.subtle.encrypt({ name: "AES-CBC", iv }, cryptoKey, buffer);
     return Buffer.from(encrypted);
   }
   static async decryptFileBrowser(buffer, key, iv) {
     const crypto = CryptoUtils.getCrypto();
-    const cryptoKey = await crypto.subtle.importKey(
-      "raw",
-      key,
-      { name: "AES-CBC" },
-      false,
-      ["decrypt"]
-    );
-    const decrypted = await crypto.subtle.decrypt(
-      { name: "AES-CBC", iv },
-      cryptoKey,
-      buffer
-    );
+    const cryptoKey = await crypto.subtle.importKey("raw", key, { name: "AES-CBC" }, false, ["decrypt"]);
+    const decrypted = await crypto.subtle.decrypt({ name: "AES-CBC", iv }, cryptoKey, buffer);
     return Buffer.from(decrypted);
   }
 };
 
 // src/services/file-service.ts
-var import_client3 = require("@aleph-sdk/client");
 var FileService = class {
   constructor(core) {
     this.core = core;
@@ -958,10 +928,7 @@ var FileService = class {
   async setup() {
     const aleph = this.core.getAlephService();
     try {
-      await aleph.fetchAggregate(
-        AGGREGATE_KEYS.FILE_ENTRIES,
-        FileEntriesAggregateSchema
-      );
+      await aleph.fetchAggregate(AGGREGATE_KEYS.FILE_ENTRIES, FileEntriesAggregateSchema);
     } catch {
       await aleph.createAggregate(AGGREGATE_KEYS.FILE_ENTRIES, { files: [] });
     }
@@ -989,7 +956,7 @@ var FileService = class {
         }
         const encryptedContent = await EncryptionService.encryptFile(fileBuffer, key, iv);
         const storeResult = await aleph.uploadFile(encryptedContent);
-        const fullPath = directoryPath ? `${directoryPath}/${file.path}` : file.path;
+        const fullPath = directoryPath ? `${directoryPath}${file.path}` : file.path;
         const createdAt = (/* @__PURE__ */ new Date()).toISOString();
         const fileMeta = {
           name: file.name,
@@ -1040,12 +1007,14 @@ var FileService = class {
    */
   async fetchFileEntries() {
     const aleph = this.core.getAlephService();
+    const privateKey = this.core.getSubAccountPrivateKey();
     try {
-      const aggregate = await aleph.fetchAggregate(
-        AGGREGATE_KEYS.FILE_ENTRIES,
-        FileEntriesAggregateSchema
-      );
-      return aggregate.files;
+      const aggregate = await aleph.fetchAggregate(AGGREGATE_KEYS.FILE_ENTRIES, FileEntriesAggregateSchema);
+      return aggregate.files.map(({ post_hash, path, shared_with }) => ({
+        post_hash,
+        path: EncryptionService.decryptEcies(path, privateKey),
+        shared_with
+      }));
     } catch (error) {
       throw new FileError(`Failed to fetch file entries: ${error.message}`);
     }
@@ -1167,15 +1136,9 @@ var FileService = class {
     const aleph = this.core.getAlephService();
     try {
       const files = await Promise.all(filePaths.map((path) => this.getFile(path)));
-      await aleph.updateAggregate(
-        AGGREGATE_KEYS.FILE_ENTRIES,
-        FileEntriesAggregateSchema,
-        async (aggregate) => ({
-          files: aggregate.files.filter(
-            (entry) => !files.some((f) => f.post_hash === entry.post_hash)
-          )
-        })
-      );
+      await aleph.updateAggregate(AGGREGATE_KEYS.FILE_ENTRIES, FileEntriesAggregateSchema, async (aggregate) => ({
+        files: aggregate.files.filter((entry) => !files.some((f) => f.post_hash === entry.post_hash))
+      }));
       const hashesToForget = files.flatMap((f) => [f.store_hash, f.post_hash]);
       await aleph.deleteFiles(hashesToForget);
     } catch (error) {
@@ -1205,15 +1168,11 @@ var FileService = class {
           }
         );
         const newEncryptedPath = EncryptionService.encryptEcies(newPath, publicKey);
-        await aleph.updateAggregate(
-          AGGREGATE_KEYS.FILE_ENTRIES,
-          FileEntriesAggregateSchema,
-          async (aggregate) => ({
-            files: aggregate.files.map(
-              (entry) => entry.post_hash === file.post_hash ? { ...entry, path: newEncryptedPath } : entry
-            )
-          })
-        );
+        await aleph.updateAggregate(AGGREGATE_KEYS.FILE_ENTRIES, FileEntriesAggregateSchema, async (aggregate) => ({
+          files: aggregate.files.map(
+            (entry) => entry.post_hash === file.post_hash ? { ...entry, path: newEncryptedPath } : entry
+          )
+        }));
       }
     } catch (error) {
       throw new FileError(`Failed to move files: ${error.message}`);
@@ -1228,11 +1187,13 @@ var FileService = class {
     try {
       const sourceFile = await this.getFile(sourcePath);
       const content = await this.downloadFile(sourceFile);
-      const [newFile] = await this.uploadFiles([{
-        name: newPath.split("/").pop() || newPath,
-        path: newPath,
-        content
-      }]);
+      const [newFile] = await this.uploadFiles([
+        {
+          name: newPath.split("/").pop() || newPath,
+          path: newPath,
+          content
+        }
+      ]);
       return newFile;
     } catch (error) {
       throw new FileError(`Failed to duplicate file: ${error.message}`);
@@ -1263,15 +1224,11 @@ var FileService = class {
           return await this.encryptFileMeta(decryptedMeta);
         }
       );
-      await aleph.updateAggregate(
-        AGGREGATE_KEYS.FILE_ENTRIES,
-        FileEntriesAggregateSchema,
-        async (aggregate) => ({
-          files: aggregate.files.map(
-            (entry) => entry.post_hash === file.post_hash ? { ...entry, shared_with: [.../* @__PURE__ */ new Set([...entry.shared_with, contactPublicKey])] } : entry
-          )
-        })
-      );
+      await aleph.updateAggregate(AGGREGATE_KEYS.FILE_ENTRIES, FileEntriesAggregateSchema, async (aggregate) => ({
+        files: aggregate.files.map(
+          (entry) => entry.post_hash === file.post_hash ? { ...entry, shared_with: [.../* @__PURE__ */ new Set([...entry.shared_with, contactPublicKey])] } : entry
+        )
+      }));
     } catch (error) {
       throw new FileError(`Failed to share file: ${error.message}`);
     }
@@ -1296,15 +1253,11 @@ var FileService = class {
           return await this.encryptFileMeta(decryptedMeta);
         }
       );
-      await aleph.updateAggregate(
-        AGGREGATE_KEYS.FILE_ENTRIES,
-        FileEntriesAggregateSchema,
-        async (aggregate) => ({
-          files: aggregate.files.map(
-            (entry) => entry.post_hash === file.post_hash ? { ...entry, shared_with: entry.shared_with.filter((pk) => pk !== contactPublicKey) } : entry
-          )
-        })
-      );
+      await aleph.updateAggregate(AGGREGATE_KEYS.FILE_ENTRIES, FileEntriesAggregateSchema, async (aggregate) => ({
+        files: aggregate.files.map(
+          (entry) => entry.post_hash === file.post_hash ? { ...entry, shared_with: entry.shared_with.filter((pk) => pk !== contactPublicKey) } : entry
+        )
+      }));
     } catch (error) {
       throw new FileError(`Failed to unshare file: ${error.message}`);
     }
@@ -1369,51 +1322,51 @@ var FileService = class {
   // ============================================================================
   async saveFileEntries(files) {
     const aleph = this.core.getAlephService();
-    await aleph.updateAggregate(
-      AGGREGATE_KEYS.FILE_ENTRIES,
-      FileEntriesAggregateSchema,
-      async (aggregate) => {
-        const newEntries = files.map((f) => ({
-          path: f.path,
-          post_hash: f.post_hash,
-          shared_with: f.shared_with || []
-        }));
-        return { files: [...aggregate.files, ...newEntries] };
-      }
-    );
+    const publicKey = this.core.getPublicKey();
+    await aleph.updateAggregate(AGGREGATE_KEYS.FILE_ENTRIES, FileEntriesAggregateSchema, async (aggregate) => {
+      const newEntries = files.map((f) => ({
+        path: EncryptionService.encryptEcies(f.path, publicKey),
+        post_hash: f.post_hash,
+        shared_with: f.shared_with || []
+      }));
+      return { files: [...aggregate.files, ...newEntries] };
+    });
   }
   async encryptFileMeta(meta) {
-    const key = this.core.getEncryptionKey();
-    const iv = EncryptionService.generateIv();
     const publicKey = this.core.getPublicKey();
+    const fileKey = Buffer.from(meta.key, "hex");
+    const fileIv = Buffer.from(meta.iv, "hex");
     return {
-      name: await EncryptionService.encrypt(meta.name, key, iv),
-      path: EncryptionService.encryptEcies(meta.path, publicKey),
+      name: await EncryptionService.encrypt(meta.name, fileKey, fileIv),
+      path: await EncryptionService.encrypt(meta.path, fileKey, fileIv),
       key: EncryptionService.encryptEcies(meta.key, publicKey),
       iv: EncryptionService.encryptEcies(meta.iv, publicKey),
-      store_hash: meta.store_hash,
-      size: await EncryptionService.encrypt(meta.size.toString(), key, iv),
-      created_at: await EncryptionService.encrypt(meta.created_at, key, iv),
-      deleted_at: meta.deleted_at ? await EncryptionService.encrypt(meta.deleted_at, key, iv) : null,
+      store_hash: await EncryptionService.encrypt(meta.store_hash, fileKey, fileIv),
+      size: await EncryptionService.encrypt(meta.size.toString(), fileKey, fileIv),
+      created_at: await EncryptionService.encrypt(meta.created_at, fileKey, fileIv),
+      deleted_at: await EncryptionService.encrypt(meta.deleted_at ?? "null", fileKey, fileIv),
       shared_keys: meta.shared_keys
     };
   }
   async decryptFileMeta(encryptedMeta, privateKey) {
-    const key = this.core.getEncryptionKey();
-    const iv = EncryptionService.generateIv();
     const privKey = privateKey || this.core.getSubAccountPrivateKey();
     if (!privKey) {
       throw new EncryptionError("Private key not available");
     }
+    const decryptedKey = EncryptionService.decryptEcies(encryptedMeta.key, privKey);
+    const decryptedIv = EncryptionService.decryptEcies(encryptedMeta.iv, privKey);
+    const fileKey = Buffer.from(decryptedKey, "hex");
+    const fileIv = Buffer.from(decryptedIv, "hex");
+    const decryptedDeletedAt = await EncryptionService.decrypt(encryptedMeta.deleted_at, fileKey, fileIv);
     return {
-      name: await EncryptionService.decrypt(encryptedMeta.name, key, iv),
-      path: EncryptionService.decryptEcies(encryptedMeta.path, privKey),
-      key: EncryptionService.decryptEcies(encryptedMeta.key, privKey),
-      iv: EncryptionService.decryptEcies(encryptedMeta.iv, privKey),
-      store_hash: encryptedMeta.store_hash,
-      size: parseInt(await EncryptionService.decrypt(encryptedMeta.size, key, iv)),
-      created_at: await EncryptionService.decrypt(encryptedMeta.created_at, key, iv),
-      deleted_at: encryptedMeta.deleted_at ? await EncryptionService.decrypt(encryptedMeta.deleted_at, key, iv) : null,
+      name: await EncryptionService.decrypt(encryptedMeta.name, fileKey, fileIv),
+      path: await EncryptionService.decrypt(encryptedMeta.path, fileKey, fileIv),
+      key: decryptedKey,
+      iv: decryptedIv,
+      store_hash: await EncryptionService.decrypt(encryptedMeta.store_hash, fileKey, fileIv),
+      size: Number.parseInt(await EncryptionService.decrypt(encryptedMeta.size, fileKey, fileIv)),
+      created_at: await EncryptionService.decrypt(encryptedMeta.created_at, fileKey, fileIv),
+      deleted_at: decryptedDeletedAt === "null" ? null : decryptedDeletedAt,
       shared_keys: encryptedMeta.shared_keys || {}
     };
   }
@@ -1431,10 +1384,7 @@ var ContactService = class {
   async setup() {
     const aleph = this.core.getAlephService();
     try {
-      await aleph.fetchAggregate(
-        AGGREGATE_KEYS.CONTACTS,
-        ContactsAggregateSchema
-      );
+      await aleph.fetchAggregate(AGGREGATE_KEYS.CONTACTS, ContactsAggregateSchema);
     } catch {
       await aleph.createAggregate(AGGREGATE_KEYS.CONTACTS, { contacts: [] });
     }
@@ -1445,10 +1395,7 @@ var ContactService = class {
   async listContacts() {
     const aleph = this.core.getAlephService();
     try {
-      const aggregate = await aleph.fetchAggregate(
-        AGGREGATE_KEYS.CONTACTS,
-        ContactsAggregateSchema
-      );
+      const aggregate = await aleph.fetchAggregate(AGGREGATE_KEYS.CONTACTS, ContactsAggregateSchema);
       return aggregate.contacts;
     } catch (error) {
       throw new ContactError(`Failed to fetch contacts: ${error.message}`);
@@ -1499,13 +1446,9 @@ var ContactService = class {
         address,
         public_key: publicKey
       };
-      await aleph.updateAggregate(
-        AGGREGATE_KEYS.CONTACTS,
-        ContactsAggregateSchema,
-        async (aggregate) => ({
-          contacts: [...aggregate.contacts, newContact]
-        })
-      );
+      await aleph.updateAggregate(AGGREGATE_KEYS.CONTACTS, ContactsAggregateSchema, async (aggregate) => ({
+        contacts: [...aggregate.contacts, newContact]
+      }));
       return newContact;
     } catch (error) {
       if (error instanceof ContactError) {
@@ -1522,13 +1465,9 @@ var ContactService = class {
     const aleph = this.core.getAlephService();
     try {
       await this.getContact(publicKey);
-      await aleph.updateAggregate(
-        AGGREGATE_KEYS.CONTACTS,
-        ContactsAggregateSchema,
-        async (aggregate) => ({
-          contacts: aggregate.contacts.filter((c) => c.public_key !== publicKey)
-        })
-      );
+      await aleph.updateAggregate(AGGREGATE_KEYS.CONTACTS, ContactsAggregateSchema, async (aggregate) => ({
+        contacts: aggregate.contacts.filter((c) => c.public_key !== publicKey)
+      }));
     } catch (error) {
       if (error instanceof ContactError) {
         throw error;
@@ -1549,15 +1488,9 @@ var ContactService = class {
         ...existingContact,
         name: newName
       };
-      await aleph.updateAggregate(
-        AGGREGATE_KEYS.CONTACTS,
-        ContactsAggregateSchema,
-        async (aggregate) => ({
-          contacts: aggregate.contacts.map(
-            (c) => c.public_key === publicKey ? updatedContact : c
-          )
-        })
-      );
+      await aleph.updateAggregate(AGGREGATE_KEYS.CONTACTS, ContactsAggregateSchema, async (aggregate) => ({
+        contacts: aggregate.contacts.map((c) => c.public_key === publicKey ? updatedContact : c)
+      }));
       return updatedContact;
     } catch (error) {
       if (error instanceof ContactError) {
@@ -1574,9 +1507,7 @@ var ContactService = class {
     try {
       await this.getContact(publicKey);
       const entries = await this.fileService.fetchFileEntries();
-      const sharedEntries = entries.filter(
-        (entry) => entry.shared_with.includes(publicKey)
-      );
+      const sharedEntries = entries.filter((entry) => entry.shared_with.includes(publicKey));
       const files = await this.fileService.fetchFilesMetaFromEntries(sharedEntries);
       return files;
     } catch (error) {
@@ -1599,9 +1530,7 @@ var ContactService = class {
         contact.address
         // Important: contact's address, not current user's
       );
-      const sharedEntries = contactEntries.files.filter(
-        (entry) => entry.shared_with.includes(currentUserPublicKey)
-      );
+      const sharedEntries = contactEntries.files.filter((entry) => entry.shared_with.includes(currentUserPublicKey));
       const files = await this.fileService.fetchFilesMetaFromEntries(
         sharedEntries,
         contact.address
@@ -1651,10 +1580,7 @@ var KnowledgeBaseService = class {
   async setup() {
     const aleph = this.core.getAlephService();
     try {
-      await aleph.fetchAggregate(
-        AGGREGATE_KEYS.KNOWLEDGE_BASES,
-        KnowledgeBasesAggregateSchema
-      );
+      await aleph.fetchAggregate(AGGREGATE_KEYS.KNOWLEDGE_BASES, KnowledgeBasesAggregateSchema);
     } catch {
       await aleph.createAggregate(AGGREGATE_KEYS.KNOWLEDGE_BASES, { knowledge_bases: [] });
     }
@@ -1665,10 +1591,7 @@ var KnowledgeBaseService = class {
   async listKnowledgeBases() {
     const aleph = this.core.getAlephService();
     try {
-      const aggregate = await aleph.fetchAggregate(
-        AGGREGATE_KEYS.KNOWLEDGE_BASES,
-        KnowledgeBasesAggregateSchema
-      );
+      const aggregate = await aleph.fetchAggregate(AGGREGATE_KEYS.KNOWLEDGE_BASES, KnowledgeBasesAggregateSchema);
       return aggregate.knowledge_bases;
     } catch (error) {
       throw new KnowledgeBaseError(`Failed to fetch knowledge bases: ${error.message}`);
@@ -1706,13 +1629,9 @@ var KnowledgeBaseService = class {
         created_at: now,
         updated_at: now
       };
-      await aleph.updateAggregate(
-        AGGREGATE_KEYS.KNOWLEDGE_BASES,
-        KnowledgeBasesAggregateSchema,
-        async (aggregate) => ({
-          knowledge_bases: [...aggregate.knowledge_bases, newKb]
-        })
-      );
+      await aleph.updateAggregate(AGGREGATE_KEYS.KNOWLEDGE_BASES, KnowledgeBasesAggregateSchema, async (aggregate) => ({
+        knowledge_bases: [...aggregate.knowledge_bases, newKb]
+      }));
       return newKb;
     } catch (error) {
       if (error instanceof KnowledgeBaseError) {
@@ -1729,13 +1648,9 @@ var KnowledgeBaseService = class {
     const aleph = this.core.getAlephService();
     try {
       await this.getKnowledgeBase(name);
-      await aleph.updateAggregate(
-        AGGREGATE_KEYS.KNOWLEDGE_BASES,
-        KnowledgeBasesAggregateSchema,
-        async (aggregate) => ({
-          knowledge_bases: aggregate.knowledge_bases.filter((k) => k.name !== name)
-        })
-      );
+      await aleph.updateAggregate(AGGREGATE_KEYS.KNOWLEDGE_BASES, KnowledgeBasesAggregateSchema, async (aggregate) => ({
+        knowledge_bases: aggregate.knowledge_bases.filter((k) => k.name !== name)
+      }));
     } catch (error) {
       if (error instanceof KnowledgeBaseError) {
         throw error;
@@ -1761,15 +1676,9 @@ var KnowledgeBaseService = class {
         name: newName,
         updated_at: (/* @__PURE__ */ new Date()).toISOString()
       };
-      await aleph.updateAggregate(
-        AGGREGATE_KEYS.KNOWLEDGE_BASES,
-        KnowledgeBasesAggregateSchema,
-        async (aggregate) => ({
-          knowledge_bases: aggregate.knowledge_bases.map(
-            (k) => k.name === oldName ? updatedKb : k
-          )
-        })
-      );
+      await aleph.updateAggregate(AGGREGATE_KEYS.KNOWLEDGE_BASES, KnowledgeBasesAggregateSchema, async (aggregate) => ({
+        knowledge_bases: aggregate.knowledge_bases.map((k) => k.name === oldName ? updatedKb : k)
+      }));
       return updatedKb;
     } catch (error) {
       if (error instanceof KnowledgeBaseError) {
@@ -1792,15 +1701,9 @@ var KnowledgeBaseService = class {
         file_paths: filePaths,
         updated_at: (/* @__PURE__ */ new Date()).toISOString()
       };
-      await aleph.updateAggregate(
-        AGGREGATE_KEYS.KNOWLEDGE_BASES,
-        KnowledgeBasesAggregateSchema,
-        async (aggregate) => ({
-          knowledge_bases: aggregate.knowledge_bases.map(
-            (k) => k.name === name ? updatedKb : k
-          )
-        })
-      );
+      await aleph.updateAggregate(AGGREGATE_KEYS.KNOWLEDGE_BASES, KnowledgeBasesAggregateSchema, async (aggregate) => ({
+        knowledge_bases: aggregate.knowledge_bases.map((k) => k.name === name ? updatedKb : k)
+      }));
       return updatedKb;
     } catch (error) {
       if (error instanceof KnowledgeBaseError) {
@@ -1824,15 +1727,9 @@ var KnowledgeBaseService = class {
         file_paths: updatedFilePaths,
         updated_at: (/* @__PURE__ */ new Date()).toISOString()
       };
-      await aleph.updateAggregate(
-        AGGREGATE_KEYS.KNOWLEDGE_BASES,
-        KnowledgeBasesAggregateSchema,
-        async (aggregate) => ({
-          knowledge_bases: aggregate.knowledge_bases.map(
-            (k) => k.name === name ? updatedKb : k
-          )
-        })
-      );
+      await aleph.updateAggregate(AGGREGATE_KEYS.KNOWLEDGE_BASES, KnowledgeBasesAggregateSchema, async (aggregate) => ({
+        knowledge_bases: aggregate.knowledge_bases.map((k) => k.name === name ? updatedKb : k)
+      }));
       return updatedKb;
     } catch (error) {
       if (error instanceof KnowledgeBaseError) {
@@ -1850,23 +1747,15 @@ var KnowledgeBaseService = class {
     const aleph = this.core.getAlephService();
     try {
       const existingKb = await this.getKnowledgeBase(name);
-      const updatedFilePaths = existingKb.file_paths.filter(
-        (path) => !filePaths.includes(path)
-      );
+      const updatedFilePaths = existingKb.file_paths.filter((path) => !filePaths.includes(path));
       const updatedKb = {
         ...existingKb,
         file_paths: updatedFilePaths,
         updated_at: (/* @__PURE__ */ new Date()).toISOString()
       };
-      await aleph.updateAggregate(
-        AGGREGATE_KEYS.KNOWLEDGE_BASES,
-        KnowledgeBasesAggregateSchema,
-        async (aggregate) => ({
-          knowledge_bases: aggregate.knowledge_bases.map(
-            (k) => k.name === name ? updatedKb : k
-          )
-        })
-      );
+      await aleph.updateAggregate(AGGREGATE_KEYS.KNOWLEDGE_BASES, KnowledgeBasesAggregateSchema, async (aggregate) => ({
+        knowledge_bases: aggregate.knowledge_bases.map((k) => k.name === name ? updatedKb : k)
+      }));
       return updatedKb;
     } catch (error) {
       if (error instanceof KnowledgeBaseError) {
@@ -2005,11 +1894,7 @@ var BedrockClient = class _BedrockClient {
    * WARNING: This will delete all user data from Aleph
    */
   async resetAllData() {
-    await Promise.all([
-      this.resetFiles(),
-      this.resetContacts(),
-      this.resetKnowledgeBases()
-    ]);
+    await Promise.all([this.resetFiles(), this.resetContacts(), this.resetKnowledgeBases()]);
   }
   /**
    * Reset all files
@@ -2042,11 +1927,7 @@ var BedrockClient = class _BedrockClient {
    * Setup all services (create aggregates if they don't exist)
    */
   async setup() {
-    await Promise.all([
-      this.files.setup(),
-      this.contacts.setup(),
-      this.knowledgeBases.setup()
-    ]);
+    await Promise.all([this.files.setup(), this.contacts.setup(), this.knowledgeBases.setup()]);
   }
 };