@happyvertical/encryption 0.74.8

package/dist/chunks/pgp-BIhtvrNo.js

@@ -0,0 +1,916 @@
+import * as openpgp from "openpgp";
+import { BaseEncryption, KeyError, EncryptError, InvalidKeyError, VerificationError, DecryptError, PassphraseError, SignatureError } from "../index.js";
+class PGPEncryption extends BaseEncryption {
+  options;
+  publicKeys;
+  privateKeys;
+  constructor(options) {
+    super("pgp", options.debug);
+    this.options = options;
+  }
+  /**
+   * Initialize keys from options
+   */
+  async initializeKeys() {
+    if (this.publicKeys || this.privateKeys) {
+      return;
+    }
+    try {
+      if (this.options.publicKey) {
+        const key = await openpgp.readKey({
+          armoredKey: this.options.publicKey
+        });
+        this.publicKeys = [key];
+      } else if (this.options.publicKeys) {
+        this.publicKeys = await Promise.all(
+          this.options.publicKeys.map(
+            (k) => openpgp.readKey({ armoredKey: k })
+          )
+        );
+      }
+      if (this.options.privateKey) {
+        const key = await openpgp.readPrivateKey({
+          armoredKey: this.options.privateKey
+        });
+        if (this.options.passphrase) {
+          const decryptedKey = await openpgp.decryptKey({
+            privateKey: key,
+            passphrase: this.options.passphrase
+          });
+          this.privateKeys = [decryptedKey];
+        } else {
+          this.privateKeys = [key];
+        }
+      } else if (this.options.privateKeys) {
+        this.privateKeys = await Promise.all(
+          this.options.privateKeys.map(async (k) => {
+            const key = await openpgp.readPrivateKey({ armoredKey: k });
+            if (this.options.passphrase) {
+              return openpgp.decryptKey({
+                privateKey: key,
+                passphrase: this.options.passphrase
+              });
+            }
+            return key;
+          })
+        );
+      }
+    } catch (error) {
+      throw new KeyError(
+        `Failed to initialize PGP keys: ${error.message}`,
+        this.adapterType,
+        error
+      );
+    }
+  }
+  /**
+   * Get public keys for encryption
+   */
+  async getPublicKeys(options) {
+    await this.initializeKeys();
+    if (options?.publicKeys) {
+      return Promise.all(
+        options.publicKeys.map((k) => openpgp.readKey({ armoredKey: k }))
+      );
+    }
+    if (!this.publicKeys || this.publicKeys.length === 0) {
+      throw new KeyError(
+        "No public keys available for encryption",
+        this.adapterType
+      );
+    }
+    return this.publicKeys;
+  }
+  /**
+   * Get private keys for decryption
+   */
+  async getPrivateKeys(options) {
+    await this.initializeKeys();
+    if (options?.privateKey) {
+      const key = await openpgp.readPrivateKey({
+        armoredKey: options.privateKey
+      });
+      if (options.passphrase) {
+        const decryptedKey = await openpgp.decryptKey({
+          privateKey: key,
+          passphrase: options.passphrase
+        });
+        return [decryptedKey];
+      }
+      return [key];
+    }
+    if (!this.privateKeys || this.privateKeys.length === 0) {
+      throw new KeyError(
+        "No private keys available for decryption",
+        this.adapterType
+      );
+    }
+    return this.privateKeys;
+  }
+  async encryptText(text, options) {
+    try {
+      this.log("Encrypting text", { length: text.length });
+      this.validateEncryptOptions(options);
+      const publicKeys = await this.getPublicKeys(options);
+      const format = options?.armor !== false ? "armored" : "binary";
+      const encryptConfig = {
+        message: await openpgp.createMessage({ text }),
+        encryptionKeys: publicKeys,
+        format
+      };
+      if (options?.sign && options?.privateKey) {
+        const signingKey = await openpgp.readPrivateKey({
+          armoredKey: options.privateKey
+        });
+        if (this.options.passphrase) {
+          encryptConfig.signingKeys = await openpgp.decryptKey({
+            privateKey: signingKey,
+            passphrase: this.options.passphrase
+          });
+        } else {
+          encryptConfig.signingKeys = signingKey;
+        }
+      } else if (options?.sign && this.privateKeys) {
+        encryptConfig.signingKeys = this.privateKeys;
+      }
+      const encrypted = await openpgp.encrypt(encryptConfig);
+      this.log("Text encrypted successfully");
+      if (format === "binary" && encrypted instanceof Uint8Array) {
+        return Buffer.from(encrypted).toString("base64");
+      }
+      return encrypted;
+    } catch (error) {
+      throw new EncryptError(
+        `Failed to encrypt text: ${error.message}`,
+        this.adapterType,
+        error
+      );
+    }
+  }
+  async decryptText(encrypted, options) {
+    try {
+      this.log("Decrypting text", { length: encrypted.length });
+      this.validateDecryptOptions(options);
+      const privateKeys = await this.getPrivateKeys(options);
+      let message;
+      try {
+        message = await openpgp.readMessage({
+          armoredMessage: encrypted
+        });
+      } catch {
+        try {
+          message = await openpgp.readMessage({
+            binaryMessage: Buffer.from(encrypted, "base64")
+          });
+        } catch {
+          message = await openpgp.readMessage({
+            binaryMessage: Buffer.from(encrypted, "binary")
+          });
+        }
+      }
+      const decryptConfig = {
+        message,
+        decryptionKeys: privateKeys,
+        format: "utf8"
+      };
+      if (options?.verify && options?.publicKey) {
+        if (typeof options.publicKey === "string") {
+          decryptConfig.verificationKeys = await openpgp.readKey({
+            armoredKey: options.publicKey
+          });
+        } else {
+          throw new InvalidKeyError(
+            "PGP verification requires armored public key string",
+            this.adapterType
+          );
+        }
+      }
+      const result = await openpgp.decrypt(decryptConfig);
+      if (options?.verify && result.signatures) {
+        try {
+          await result.signatures[0].verified;
+          this.log("Signature verified successfully");
+        } catch (error) {
+          throw new VerificationError(
+            "Signature verification failed",
+            this.adapterType,
+            error
+          );
+        }
+      }
+      this.log("Text decrypted successfully");
+      return result.data;
+    } catch (error) {
+      if (error instanceof VerificationError) {
+        throw error;
+      }
+      throw new DecryptError(
+        `Failed to decrypt text: ${error.message}`,
+        this.adapterType,
+        error
+      );
+    }
+  }
+  async encryptBuffer(buffer, options) {
+    try {
+      this.log("Encrypting buffer", { size: buffer.length });
+      this.validateEncryptOptions(options);
+      const publicKeys = await this.getPublicKeys(options);
+      const format = options?.armor === true ? "armored" : "binary";
+      const encryptConfig = {
+        message: await openpgp.createMessage({ binary: buffer }),
+        encryptionKeys: publicKeys,
+        format
+      };
+      if (options?.sign && options?.privateKey) {
+        const signingKey = await openpgp.readPrivateKey({
+          armoredKey: options.privateKey
+        });
+        if (this.options.passphrase) {
+          encryptConfig.signingKeys = await openpgp.decryptKey({
+            privateKey: signingKey,
+            passphrase: this.options.passphrase
+          });
+        } else {
+          encryptConfig.signingKeys = signingKey;
+        }
+      } else if (options?.sign && this.privateKeys) {
+        encryptConfig.signingKeys = this.privateKeys;
+      }
+      const encrypted = await openpgp.encrypt(encryptConfig);
+      this.log("Buffer encrypted successfully");
+      if (typeof encrypted === "string") {
+        return Buffer.from(encrypted);
+      }
+      if (encrypted instanceof Uint8Array) {
+        return Buffer.from(encrypted);
+      }
+      return Buffer.from(encrypted);
+    } catch (error) {
+      throw new EncryptError(
+        `Failed to encrypt buffer: ${error.message}`,
+        this.adapterType,
+        error
+      );
+    }
+  }
+  async decryptBuffer(buffer, options) {
+    try {
+      this.log("Decrypting buffer", { size: buffer.length });
+      this.validateDecryptOptions(options);
+      const privateKeys = await this.getPrivateKeys(options);
+      let message;
+      try {
+        message = await openpgp.readMessage({
+          armoredMessage: buffer.toString("utf8")
+        });
+      } catch {
+        message = await openpgp.readMessage({
+          binaryMessage: buffer
+        });
+      }
+      const decryptConfig = {
+        message,
+        decryptionKeys: privateKeys,
+        format: "binary"
+      };
+      if (options?.verify && options?.publicKey) {
+        if (typeof options.publicKey === "string") {
+          decryptConfig.verificationKeys = await openpgp.readKey({
+            armoredKey: options.publicKey
+          });
+        } else {
+          throw new InvalidKeyError(
+            "PGP verification requires armored public key string",
+            this.adapterType
+          );
+        }
+      }
+      const result = await openpgp.decrypt(decryptConfig);
+      if (options?.verify && result.signatures) {
+        try {
+          await result.signatures[0].verified;
+          this.log("Signature verified successfully");
+        } catch (error) {
+          throw new VerificationError(
+            "Signature verification failed",
+            this.adapterType,
+            error
+          );
+        }
+      }
+      this.log("Buffer decrypted successfully");
+      return Buffer.from(result.data);
+    } catch (error) {
+      if (error instanceof VerificationError) {
+        throw error;
+      }
+      throw new DecryptError(
+        `Failed to decrypt buffer: ${error.message}`,
+        this.adapterType,
+        error
+      );
+    }
+  }
+  async generateKeyPair(options) {
+    try {
+      this.log("Generating PGP key pair", options);
+      const keyType = options?.type || "rsa";
+      const keySize = options?.keySize || 4096;
+      let generateOptions;
+      if (keyType === "rsa") {
+        generateOptions = {
+          type: "rsa",
+          rsaBits: keySize,
+          userIDs: [
+            {
+              name: options?.name || "",
+              email: options?.email || ""
+            }
+          ],
+          passphrase: options?.passphrase,
+          format: "object"
+        };
+      } else if (keyType === "ecc" || keyType === "ecdh") {
+        generateOptions = {
+          type: "ecc",
+          curve: options?.curve || "curve25519",
+          userIDs: [
+            {
+              name: options?.name || "",
+              email: options?.email || ""
+            }
+          ],
+          passphrase: options?.passphrase,
+          format: "object"
+        };
+      } else {
+        throw new KeyError(
+          `Unsupported key type for PGP: ${keyType}`,
+          this.adapterType
+        );
+      }
+      const { privateKey: privKeyObj, publicKey: pubKeyObj } = await openpgp.generateKey(generateOptions);
+      const publicKey = pubKeyObj.armor();
+      const privateKey = privKeyObj.armor();
+      const fingerprint = pubKeyObj.getFingerprint();
+      const keyId = pubKeyObj.getKeyID().toHex();
+      this.log("Key pair generated successfully", { keyId, fingerprint });
+      return {
+        publicKey,
+        privateKey,
+        fingerprint,
+        keyId
+      };
+    } catch (error) {
+      throw new KeyError(
+        `Failed to generate PGP key pair: ${error.message}`,
+        this.adapterType,
+        error
+      );
+    }
+  }
+  async importKey(key, options) {
+    try {
+      this.log("Importing PGP key");
+      const armoredKey = typeof key === "string" ? key : key.toString("utf8");
+      const keyType = options?.type || "public";
+      if (keyType === "public") {
+        const pubKey = await openpgp.readKey({ armoredKey });
+        const expirationTime2 = await pubKey.getExpirationTime();
+        return {
+          type: "public",
+          format: "armored",
+          data: armoredKey,
+          fingerprint: pubKey.getFingerprint(),
+          keyId: pubKey.getKeyID().toHex(),
+          algorithm: pubKey.getAlgorithmInfo().algorithm,
+          created: pubKey.getCreationTime(),
+          expires: expirationTime2 instanceof Date ? expirationTime2 : void 0,
+          userIds: pubKey.getUserIDs().map((uid) => {
+            const match = uid.match(/^(.*?)\s*<(.+?)>$/);
+            if (match) {
+              return { name: match[1], email: match[2] };
+            }
+            return { email: uid };
+          })
+        };
+      }
+      const privKey = await openpgp.readPrivateKey({ armoredKey });
+      let decryptedKey = privKey;
+      if (options?.passphrase) {
+        try {
+          decryptedKey = await openpgp.decryptKey({
+            privateKey: privKey,
+            passphrase: options.passphrase
+          });
+        } catch (error) {
+          throw new PassphraseError(
+            "Invalid passphrase for private key",
+            this.adapterType,
+            error
+          );
+        }
+      }
+      this.log("Key imported successfully");
+      const expirationTime = await decryptedKey.getExpirationTime();
+      return {
+        type: "private",
+        format: "armored",
+        data: armoredKey,
+        fingerprint: decryptedKey.getFingerprint(),
+        keyId: decryptedKey.getKeyID().toHex(),
+        algorithm: decryptedKey.getAlgorithmInfo().algorithm,
+        created: decryptedKey.getCreationTime(),
+        expires: expirationTime instanceof Date ? expirationTime : void 0,
+        userIds: decryptedKey.getUserIDs().map((uid) => {
+          const match = uid.match(/^(.*?)\s*<(.+?)>$/);
+          if (match) {
+            return { name: match[1], email: match[2] };
+          }
+          return { email: uid };
+        })
+      };
+    } catch (error) {
+      if (error instanceof PassphraseError) {
+        throw error;
+      }
+      throw new InvalidKeyError(
+        `Failed to import PGP key: ${error.message}`,
+        this.adapterType,
+        error
+      );
+    }
+  }
+  async exportKey(key, options) {
+    try {
+      this.log("Exporting PGP key");
+      if (typeof key.data === "string") {
+        if (options?.format === "binary") {
+          return Buffer.from(key.data);
+        }
+        return key.data;
+      }
+      if (Buffer.isBuffer(key.data)) {
+        if (options?.format === "armored" || options?.armor) {
+          return key.data.toString("utf8");
+        }
+        return key.data;
+      }
+      throw new InvalidKeyError(
+        "Invalid key data format for export",
+        this.adapterType
+      );
+    } catch (error) {
+      throw new KeyError(
+        `Failed to export PGP key: ${error.message}`,
+        this.adapterType,
+        error
+      );
+    }
+  }
+  /**
+   * Sign data with private key
+   */
+  async sign(data, options) {
+    try {
+      this.log("Signing data");
+      await this.initializeKeys();
+      let signingKey;
+      if (options?.privateKey) {
+        signingKey = await openpgp.readPrivateKey({
+          armoredKey: options.privateKey
+        });
+        if (options.passphrase) {
+          signingKey = await openpgp.decryptKey({
+            privateKey: signingKey,
+            passphrase: options.passphrase
+          });
+        }
+      } else if (this.privateKeys && this.privateKeys.length > 0) {
+        signingKey = this.privateKeys[0];
+      } else {
+        throw new KeyError(
+          "No private key available for signing",
+          this.adapterType
+        );
+      }
+      const message = typeof data === "string" ? await openpgp.createMessage({ text: data }) : await openpgp.createMessage({ binary: data });
+      const format = options?.armor !== false ? "armored" : "binary";
+      const signed = await openpgp.sign({
+        message,
+        signingKeys: signingKey,
+        detached: options?.detached,
+        format
+      });
+      this.log("Data signed successfully");
+      if (format === "armored") {
+        return signed;
+      } else {
+        if (signed instanceof Uint8Array) {
+          return Buffer.from(signed);
+        }
+        return Buffer.from(signed);
+      }
+    } catch (error) {
+      throw new SignatureError(
+        `Failed to sign data: ${error.message}`,
+        this.adapterType,
+        error
+      );
+    }
+  }
+  /**
+   * Verify signature
+   */
+  async verify(data, signature, options) {
+    try {
+      this.log("Verifying signature");
+      if (!options?.publicKey) {
+        throw new KeyError(
+          "Public key required for signature verification",
+          this.adapterType
+        );
+      }
+      const verificationKey = await openpgp.readKey({
+        armoredKey: options.publicKey
+      });
+      const signatureStr = typeof signature === "string" ? signature : signature.toString("utf8");
+      const isDetached = signatureStr.includes("-----BEGIN PGP SIGNATURE-----");
+      if (isDetached) {
+        const message = typeof data === "string" ? await openpgp.createMessage({ text: data }) : await openpgp.createMessage({ binary: data });
+        const sig = await openpgp.readSignature({
+          armoredSignature: signatureStr
+        });
+        const result = await openpgp.verify({
+          message,
+          signature: sig,
+          verificationKeys: verificationKey
+        });
+        await result.signatures[0].verified;
+      } else {
+        let message;
+        if (signatureStr.includes("-----BEGIN PGP SIGNED MESSAGE-----")) {
+          message = await openpgp.readCleartextMessage({
+            cleartextMessage: signatureStr
+          });
+        } else {
+          try {
+            message = await openpgp.readMessage({
+              armoredMessage: signatureStr
+            });
+          } catch {
+            message = await openpgp.readMessage({
+              binaryMessage: typeof signature === "string" ? Buffer.from(signature, "binary") : signature
+            });
+          }
+        }
+        const result = await openpgp.verify({
+          message,
+          verificationKeys: verificationKey
+        });
+        await result.signatures[0].verified;
+      }
+      this.log("Signature verified successfully");
+      return true;
+    } catch (error) {
+      if (error instanceof KeyError) {
+        throw error;
+      }
+      this.log("Signature verification failed", error);
+      return false;
+    }
+  }
+  /**
+   * Encrypt email message in PGP/MIME format
+   */
+  async encryptEmail(message, options) {
+    try {
+      this.log("Encrypting email message");
+      const emailContent = this.serializeEmailContent(message, options);
+      const publicKeys = await this.getPublicKeys({
+        publicKeys: options?.publicKeys
+      });
+      let signingKey;
+      if (options?.sign) {
+        await this.initializeKeys();
+        if (options.privateKey) {
+          const key = await openpgp.readPrivateKey({
+            armoredKey: options.privateKey
+          });
+          if (options.passphrase) {
+            signingKey = await openpgp.decryptKey({
+              privateKey: key,
+              passphrase: options.passphrase
+            });
+          } else {
+            signingKey = key;
+          }
+        } else if (this.privateKeys && this.privateKeys.length > 0) {
+          signingKey = this.privateKeys[0];
+        }
+      }
+      const encryptConfig = {
+        message: await openpgp.createMessage({ text: emailContent }),
+        encryptionKeys: publicKeys,
+        format: options?.armor !== false ? "armored" : "binary"
+      };
+      if (signingKey) {
+        encryptConfig.signingKeys = signingKey;
+      }
+      const encrypted = await openpgp.encrypt(encryptConfig);
+      this.log("Email encrypted successfully");
+      return {
+        ...message,
+        text: encrypted,
+        html: void 0,
+        // Clear HTML when encrypted
+        contentType: 'multipart/encrypted; protocol="application/pgp-encrypted"',
+        headers: {
+          ...message.headers || {},
+          "Content-Type": 'multipart/encrypted; protocol="application/pgp-encrypted"'
+        }
+      };
+    } catch (error) {
+      throw new EncryptError(
+        `Failed to encrypt email: ${error.message}`,
+        this.adapterType,
+        error
+      );
+    }
+  }
+  /**
+   * Decrypt PGP/MIME email message
+   */
+  async decryptEmail(message, options) {
+    try {
+      this.log("Decrypting email message");
+      if (!message.text) {
+        throw new DecryptError(
+          "Email message has no text content to decrypt",
+          this.adapterType
+        );
+      }
+      const privateKeys = await this.getPrivateKeys({
+        privateKey: options?.privateKey,
+        passphrase: options?.passphrase
+      });
+      let encryptedMessage;
+      try {
+        encryptedMessage = await openpgp.readMessage({
+          armoredMessage: message.text
+        });
+      } catch {
+        encryptedMessage = await openpgp.readMessage({
+          binaryMessage: Buffer.from(message.text, "base64")
+        });
+      }
+      const decryptConfig = {
+        message: encryptedMessage,
+        decryptionKeys: privateKeys,
+        format: "utf8"
+      };
+      if (options?.verify) {
+        const verificationKey = options.publicKey || this.options.publicKey;
+        if (verificationKey) {
+          decryptConfig.verificationKeys = await openpgp.readKey({
+            armoredKey: verificationKey
+          });
+        }
+      }
+      const result = await openpgp.decrypt(decryptConfig);
+      const decryptedContent = result.data;
+      let verified = false;
+      let verificationError;
+      let signerKeyId;
+      let signerFingerprint;
+      if (options?.verify) {
+        const verificationKey = options.publicKey || this.options.publicKey;
+        if (!verificationKey) {
+          verificationError = "Public key required for signature verification";
+          this.log("Email signature verification skipped: no public key");
+        } else if (!result.signatures || result.signatures.length === 0) {
+          verificationError = "No signature found in message";
+          this.log("Email signature verification skipped: no signatures");
+        } else {
+          try {
+            await result.signatures[0].verified;
+            verified = true;
+            signerKeyId = result.signatures[0].keyID.toHex();
+            const pubKey = await openpgp.readKey({
+              armoredKey: verificationKey
+            });
+            signerFingerprint = pubKey.getFingerprint();
+            this.log("Email signature verified successfully");
+          } catch (error) {
+            verificationError = error instanceof Error ? error.message : String(error);
+            this.log("Email signature verification failed", error);
+          }
+        }
+      }
+      const deserializedMessage = this.deserializeEmailContent(
+        decryptedContent,
+        message
+      );
+      this.log("Email decrypted successfully");
+      return {
+        ...deserializedMessage,
+        encrypted: true,
+        signed: result.signatures && result.signatures.length > 0,
+        verified: options?.verify ? verified : void 0,
+        verificationError,
+        signerKeyId,
+        signerFingerprint,
+        encryptionAlgorithm: "pgp"
+      };
+    } catch (error) {
+      if (error instanceof DecryptError) {
+        throw error;
+      }
+      throw new DecryptError(
+        `Failed to decrypt email: ${error.message}`,
+        this.adapterType,
+        error
+      );
+    }
+  }
+  /**
+   * Sign email message
+   */
+  async signEmail(message, options) {
+    try {
+      this.log("Signing email message");
+      const emailContent = this.serializeEmailContent(message);
+      await this.initializeKeys();
+      let signingKey;
+      if (options?.privateKey) {
+        const key = await openpgp.readPrivateKey({
+          armoredKey: options.privateKey
+        });
+        if (options.passphrase) {
+          signingKey = await openpgp.decryptKey({
+            privateKey: key,
+            passphrase: options.passphrase
+          });
+        } else {
+          signingKey = key;
+        }
+      } else if (this.privateKeys && this.privateKeys.length > 0) {
+        signingKey = this.privateKeys[0];
+      } else {
+        throw new KeyError(
+          "No private key available for signing email",
+          this.adapterType
+        );
+      }
+      const signedMessageObj = await openpgp.sign({
+        message: await openpgp.createCleartextMessage({ text: emailContent }),
+        signingKeys: signingKey,
+        format: "object"
+      });
+      const signedMessage = signedMessageObj.armor();
+      this.log("Email signed successfully");
+      return {
+        ...message,
+        text: signedMessage,
+        contentType: "text/plain; charset=utf-8",
+        headers: {
+          ...message.headers || {},
+          "Content-Type": "text/plain; charset=utf-8"
+        }
+      };
+    } catch (error) {
+      throw new SignatureError(
+        `Failed to sign email: ${error.message}`,
+        this.adapterType,
+        error
+      );
+    }
+  }
+  /**
+   * Verify email signature
+   */
+  async verifyEmail(message, options) {
+    try {
+      this.log("Verifying email signature");
+      if (!message.text) {
+        return {
+          valid: false,
+          message: "Email message has no text content to verify"
+        };
+      }
+      if (!options?.publicKey) {
+        return {
+          valid: false,
+          message: "Public key required for email signature verification"
+        };
+      }
+      const verificationKey = await openpgp.readKey({
+        armoredKey: options.publicKey
+      });
+      const signedMessage = await openpgp.readCleartextMessage({
+        cleartextMessage: message.text
+      });
+      const result = await openpgp.verify({
+        message: signedMessage,
+        verificationKeys: verificationKey
+      });
+      await result.signatures[0].verified;
+      const keyId = result.signatures[0].keyID.toHex();
+      const fingerprint = verificationKey.getFingerprint();
+      this.log("Email signature verified successfully");
+      return {
+        valid: true,
+        keyId,
+        keyFingerprint: fingerprint,
+        timestamp: /* @__PURE__ */ new Date(),
+        algorithm: "pgp"
+      };
+    } catch (error) {
+      this.log("Email signature verification failed", error);
+      return {
+        valid: false,
+        message: error.message
+      };
+    }
+  }
+  /**
+   * Serialize email content for encryption/signing
+   */
+  serializeEmailContent(message, options) {
+    const parts = [];
+    if (options?.encryptSubject) {
+      parts.push(`Subject: ${message.subject}`);
+    }
+    if (message.text) {
+      parts.push(`
+${message.text}`);
+    }
+    if (message.html) {
+      parts.push(`
+--- HTML Content ---
+${message.html}`);
+    }
+    if (message.attachments && message.attachments.length > 0) {
+      parts.push("\n--- Attachments ---");
+      for (const attachment of message.attachments) {
+        parts.push(
+          `- ${attachment.filename || "unnamed"} (${attachment.contentType}, ${attachment.size} bytes)`
+        );
+      }
+    }
+    return parts.join("\n");
+  }
+  /**
+   * Deserialize email content after decryption
+   */
+  deserializeEmailContent(content, originalMessage) {
+    const lines = content.split("\n");
+    let subject = originalMessage.subject;
+    let text = "";
+    let html;
+    let currentSection = "text";
+    for (const line of lines) {
+      if (line.startsWith("Subject: ")) {
+        subject = line.substring(9);
+      } else if (line === "--- HTML Content ---") {
+        currentSection = "html";
+      } else if (line === "--- Attachments ---") {
+        break;
+      } else if (currentSection === "text" && line.trim()) {
+        text += `${line}
+`;
+      } else if (currentSection === "html") {
+        if (!html) html = "";
+        html += `${line}
+`;
+      }
+    }
+    return {
+      ...originalMessage,
+      subject,
+      text: text.trim(),
+      html: html?.trim()
+    };
+  }
+  async getCapabilities() {
+    return {
+      textEncryption: true,
+      fileEncryption: true,
+      bufferEncryption: true,
+      streamEncryption: true,
+      emailEncryption: true,
+      signing: true,
+      verification: true,
+      keyGeneration: true,
+      keyManagement: true,
+      multipleRecipients: true,
+      symmetricEncryption: false,
+      asymmetricEncryption: true
+    };
+  }
+}
+export {
+  PGPEncryption
+};
+//# sourceMappingURL=pgp-BIhtvrNo.js.map