@profullstack/qryptchat 0.1.0

package/dist/chunk-9kkxje88.js

@@ -0,0 +1,1348 @@
+import {
+  sessionPath,
+  baseUrl,
+  loadSession,
+  saveSession,
+  clearSession
+} from "./chunk-fb6zrz6m.js";
+
+// src/cli/crypto.js
+import { MlKem1024 as MlKem10242 } from "mlkem";
+
+// src/lib/crypto/post-quantum-encryption.js
+import { MlKem1024, MlKem768 } from "mlkem";
+
+// src/lib/crypto/index.js
+import { chacha20poly1305 } from "@noble/ciphers/chacha.js";
+var CRYPTO_CONFIG = {
+  KYBER: {
+    PUBLIC_KEY_SIZE: 1568,
+    PRIVATE_KEY_SIZE: 3168,
+    CIPHERTEXT_SIZE: 1568,
+    SHARED_SECRET_SIZE: 32
+  },
+  DILITHIUM: {
+    PUBLIC_KEY_SIZE: 2592,
+    PRIVATE_KEY_SIZE: 4864,
+    SIGNATURE_SIZE: 4595
+  },
+  CHACHA20_POLY1305: {
+    KEY_SIZE: 32,
+    NONCE_SIZE: 12,
+    TAG_SIZE: 16
+  },
+  HKDF: {
+    HASH: "SHA-256",
+    SALT_SIZE: 32,
+    INFO_PREFIX: "QryptChat-v1"
+  }
+};
+var Base64 = {
+  encode(bytes) {
+    let binary = "";
+    for (let i = 0;i < bytes.length; i++) {
+      binary += String.fromCharCode(bytes[i]);
+    }
+    return btoa(binary);
+  },
+  decode(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;
+  }
+};
+
+class SecureRandom {
+  static getRandomBytes(length) {
+    const bytes = new Uint8Array(length);
+    crypto.getRandomValues(bytes);
+    return bytes;
+  }
+  static generateSalt() {
+    return this.getRandomBytes(CRYPTO_CONFIG.HKDF.SALT_SIZE);
+  }
+  static generateNonce() {
+    return this.getRandomBytes(CRYPTO_CONFIG.CHACHA20_POLY1305.NONCE_SIZE);
+  }
+}
+
+class HKDF {
+  static async derive(inputKeyMaterial, salt, info, length) {
+    const key = await crypto.subtle.importKey("raw", inputKeyMaterial, { name: "HKDF" }, false, ["deriveKey", "deriveBits"]);
+    const derivedBits = await crypto.subtle.deriveBits({
+      name: "HKDF",
+      hash: CRYPTO_CONFIG.HKDF.HASH,
+      salt,
+      info: new TextEncoder().encode(`${CRYPTO_CONFIG.HKDF.INFO_PREFIX}-${info}`)
+    }, key, length * 8);
+    return new Uint8Array(derivedBits);
+  }
+  static async deriveRootAndChainKeys(sharedSecret, salt, context) {
+    const derivedKey = await this.derive(sharedSecret, salt, context, 64);
+    return {
+      rootKey: derivedKey.slice(0, 32),
+      chainKey: derivedKey.slice(32, 64)
+    };
+  }
+  static async deriveMessageKey(chainKey, messageNumber) {
+    const info = `MessageKey-${messageNumber}`;
+    return await this.derive(chainKey, new Uint8Array(0), info, CRYPTO_CONFIG.CHACHA20_POLY1305.KEY_SIZE);
+  }
+}
+
+class ChaCha20Poly1305 {
+  static async encrypt(key, nonce, plaintext, additionalData = new Uint8Array(0)) {
+    try {
+      const cipher = chacha20poly1305(key, nonce, additionalData);
+      const ciphertext = cipher.encrypt(plaintext);
+      return ciphertext;
+    } catch (error) {
+      throw new EncryptionError(`ChaCha20-Poly1305 encryption failed: ${error.message}`);
+    }
+  }
+  static async decrypt(key, nonce, ciphertext, additionalData = new Uint8Array(0)) {
+    try {
+      const cipher = chacha20poly1305(key, nonce, additionalData);
+      const plaintext = cipher.decrypt(ciphertext);
+      return plaintext;
+    } catch (error) {
+      throw new DecryptionError(`ChaCha20-Poly1305 decryption failed: ${error.message}`);
+    }
+  }
+}
+
+class CryptoError extends Error {
+  constructor(message, code) {
+    super(message);
+    this.name = "CryptoError";
+    this.code = code;
+  }
+}
+class EncryptionError extends CryptoError {
+  constructor(message) {
+    super(message, "ENCRYPTION_ERROR");
+    this.name = "EncryptionError";
+  }
+}
+
+class DecryptionError extends CryptoError {
+  constructor(message) {
+    super(message, "DECRYPTION_ERROR");
+    this.name = "DecryptionError";
+  }
+}
+class CryptoUtils {
+  static constantTimeEqual(a, b) {
+    if (a.length !== b.length) {
+      return false;
+    }
+    let result = 0;
+    for (let i = 0;i < a.length; i++) {
+      result |= a[i] ^ b[i];
+    }
+    return result === 0;
+  }
+  static secureClear(data) {
+    if (data && data.fill) {
+      data.fill(0);
+    }
+  }
+  static concatenate(...arrays) {
+    const totalLength = arrays.reduce((sum, arr) => sum + arr.length, 0);
+    const result = new Uint8Array(totalLength);
+    let offset = 0;
+    for (const array of arrays) {
+      result.set(array, offset);
+      offset += array.length;
+    }
+    return result;
+  }
+  static generateKeyId() {
+    const randomBytes = SecureRandom.getRandomBytes(16);
+    return Base64.encode(randomBytes).replace(/[+/=]/g, "").substring(0, 22);
+  }
+  static async hash(data) {
+    const hashBuffer = await crypto.subtle.digest("SHA-256", data);
+    return new Uint8Array(hashBuffer);
+  }
+  static validateKeySize(key, algorithm, keyType) {
+    const config = CRYPTO_CONFIG[algorithm];
+    if (!config) {
+      throw new CryptoError(`Unknown algorithm: ${algorithm}`);
+    }
+    const expectedSize = config[`${keyType.toUpperCase()}_KEY_SIZE`];
+    if (!expectedSize) {
+      throw new CryptoError(`Unknown key type: ${keyType} for algorithm: ${algorithm}`);
+    }
+    if (key.length !== expectedSize) {
+      throw new CryptoError(`Invalid ${keyType} key size for ${algorithm}. Expected ${expectedSize}, got ${key.length}`);
+    }
+  }
+}
+
+// src/lib/crypto/indexed-db-manager.js
+var DB_NAME = "QryptChatKeys";
+var DB_VERSION = 1;
+var STORE_NAME = "keypairs";
+
+class IndexedDBManager {
+  db = null;
+  async openDB() {
+    if (this.db) {
+      return this.db;
+    }
+    return new Promise((resolve, reject) => {
+      const request = indexedDB.open(DB_NAME, DB_VERSION);
+      request.onupgradeneeded = (event) => {
+        const db = event.target.result;
+        db.createObjectStore(STORE_NAME, { keyPath: "id" });
+      };
+      request.onsuccess = (event) => {
+        this.db = event.target.result;
+        resolve(this.db);
+      };
+      request.onerror = (event) => {
+        reject("Error opening IndexedDB: " + event.target.error);
+      };
+    });
+  }
+  async set(id, value) {
+    const db = await this.openDB();
+    return new Promise((resolve, reject) => {
+      const transaction = db.transaction([STORE_NAME], "readwrite");
+      const store = transaction.objectStore(STORE_NAME);
+      const request = store.put({ id, value });
+      request.onsuccess = () => {
+        resolve(undefined);
+      };
+      request.onerror = (event) => {
+        reject("Error saving to IndexedDB: " + event.target.error);
+      };
+    });
+  }
+  async get(id) {
+    const db = await this.openDB();
+    return new Promise((resolve, reject) => {
+      const transaction = db.transaction([STORE_NAME], "readonly");
+      const store = transaction.objectStore(STORE_NAME);
+      const request = store.get(id);
+      request.onsuccess = (event) => {
+        const target = event.target;
+        resolve(target.result ? target.result.value : null);
+      };
+      request.onerror = (event) => {
+        reject("Error reading from IndexedDB: " + event.target.error);
+      };
+    });
+  }
+  async delete(id) {
+    const db = await this.openDB();
+    return new Promise((resolve, reject) => {
+      const transaction = db.transaction([STORE_NAME], "readwrite");
+      const store = transaction.objectStore(STORE_NAME);
+      const request = store.delete(id);
+      request.onsuccess = () => {
+        resolve(undefined);
+      };
+      request.onerror = (event) => {
+        reject("Error deleting from IndexedDB: " + event.target.error);
+      };
+    });
+  }
+}
+var indexedDBManager = new IndexedDBManager;
+
+// src/lib/crypto/post-quantum-encryption.js
+class PostQuantumEncryptionService {
+  constructor() {
+    this.userKeys = null;
+    this.userKeys768 = null;
+    this.publicKeyCache = new Map;
+    this.isInitialized = false;
+    this.storageKey = "qryptchat_pq_keypair";
+    this.storageKey768 = "qryptchat_pq_keypair_768";
+    this.kemAlgorithm = new MlKem1024;
+    this.kemName = "ML-KEM-1024";
+    this.kemAlgorithm768 = new MlKem768;
+    this.kemName768 = "ML-KEM-768";
+    this.ML_KEM_768_PUBLIC_KEY_SIZE = 1184;
+    this.ML_KEM_1024_PUBLIC_KEY_SIZE = 1568;
+  }
+  async initialize() {
+    if (typeof window !== "undefined") {
+      await Promise.all([
+        this.loadUserKeys(),
+        this.loadUserKeys768()
+      ]);
+      if (!this.userKeys) {
+        await this.generateUserKeys();
+      }
+      if (!this.userKeys768) {
+        await this.generateUserKeys768();
+      }
+    }
+    this.isInitialized = true;
+    console.log(`\uD83D\uDD10 Post-quantum encryption service initialized (${this.kemName} with ${this.kemName768} backward compatibility)`);
+  }
+  async getUserKeys() {
+    if (this.userKeys) {
+      return this.userKeys;
+    }
+    await this.loadUserKeys();
+    if (this.userKeys) {
+      return this.userKeys;
+    }
+    return await this.generateUserKeys();
+  }
+  async generateUserKeys() {
+    try {
+      console.log(`\uD83D\uDD10 Generating ${this.kemName} key pair...`);
+      const keyPair = await this.kemAlgorithm.generateKeyPair();
+      const publicKey = Base64.encode(keyPair[0]);
+      const privateKey = Base64.encode(keyPair[1]);
+      this.userKeys = { publicKey, privateKey };
+      if (typeof window !== "undefined") {
+        const keyData = {
+          publicKey,
+          privateKey,
+          algorithm: this.kemName,
+          timestamp: Date.now(),
+          version: "3.0"
+        };
+        await indexedDBManager.set(this.storageKey, keyData);
+      }
+      console.log(`\uD83D\uDD10 Generated new ${this.kemName} key pair`);
+      if (typeof window !== "undefined") {
+        window.dispatchEvent(new CustomEvent("qryptchat:keys-generated"));
+      }
+      return this.userKeys;
+    } catch (error) {
+      console.error("\uD83D\uDD10 Failed to generate post-quantum keys:", error);
+      throw error;
+    }
+  }
+  async loadUserKeys() {
+    try {
+      if (typeof window === "undefined")
+        return;
+      const keyData = await indexedDBManager.get(this.storageKey);
+      if (!keyData)
+        return;
+      if (keyData.publicKey && keyData.privateKey && keyData.algorithm === this.kemName) {
+        this.userKeys = {
+          publicKey: keyData.publicKey,
+          privateKey: keyData.privateKey
+        };
+        console.log(`\uD83D\uDD10 Loaded ${this.kemName} keys from storage`);
+      } else if (keyData.algorithm && keyData.algorithm !== this.kemName) {
+        console.warn(`\uD83D\uDD10 Stored keys use ${keyData.algorithm}, but current algorithm is ${this.kemName}. Keys need regeneration.`);
+      }
+    } catch (error) {
+      console.error("\uD83D\uDD10 Failed to load post-quantum keys:", error);
+    }
+  }
+  async loadUserKeys768() {
+    try {
+      if (typeof window === "undefined")
+        return;
+      const keyData = await indexedDBManager.get(this.storageKey768);
+      if (!keyData)
+        return;
+      if (keyData.publicKey && keyData.privateKey && keyData.algorithm === this.kemName768) {
+        this.userKeys768 = {
+          publicKey: keyData.publicKey,
+          privateKey: keyData.privateKey
+        };
+        console.log(`\uD83D\uDD10 Loaded ${this.kemName768} keys from storage (for backward compatibility)`);
+      }
+    } catch (error) {
+      console.error("\uD83D\uDD10 Failed to load ML-KEM-768 keys:", error);
+    }
+  }
+  async getPublicKey() {
+    const keys = await this.getUserKeys();
+    return keys.publicKey;
+  }
+  storePublicKey(userId, publicKey) {
+    this.publicKeyCache.set(userId, publicKey);
+    console.log(`\uD83D\uDD10 Stored ${this.kemName} public key for user: ${userId}`);
+  }
+  getStoredPublicKey(userId) {
+    return this.publicKeyCache.get(userId) || null;
+  }
+  async encryptForRecipient(message, recipientPublicKey) {
+    try {
+      if (!this.isInitialized) {
+        throw new Error("Post-quantum encryption service not initialized");
+      }
+      console.log(`\uD83D\uDD10 Encrypting message using ML-KEM-1024...`);
+      if (!recipientPublicKey || typeof recipientPublicKey !== "string") {
+        throw new Error("Invalid recipient public key format");
+      }
+      if (!/^[A-Za-z0-9+/=]+$/.test(recipientPublicKey)) {
+        throw new Error("Public key contains invalid Base64 characters");
+      }
+      let recipientPubKeyBytes;
+      try {
+        recipientPubKeyBytes = Base64.decode(recipientPublicKey);
+      } catch (decodeError) {
+        console.error("\uD83D\uDD10 [ERROR] Failed to decode public key from Base64:", decodeError);
+        throw new Error("Failed to decode public key");
+      }
+      recipientPubKeyBytes = this.stripKeyHeaderIfPresent(recipientPubKeyBytes);
+      if (recipientPubKeyBytes.length !== this.ML_KEM_1024_PUBLIC_KEY_SIZE && recipientPubKeyBytes.length !== this.ML_KEM_768_PUBLIC_KEY_SIZE) {
+        throw new Error(`Invalid recipient public key size: ${recipientPubKeyBytes.length} bytes. ` + `Expected ${this.ML_KEM_1024_PUBLIC_KEY_SIZE} (ML-KEM-1024) or ${this.ML_KEM_768_PUBLIC_KEY_SIZE} (ML-KEM-768). ` + `Recipient may need to use Nuclear Key Reset in Settings.`);
+      }
+      let kemAlgorithm = this.kemAlgorithm;
+      let kemName = this.kemName;
+      console.log(`\uD83D\uDD10 [DEBUG] Recipient public key length: ${recipientPubKeyBytes.length} bytes`);
+      if (!this.isValidPublicKey(recipientPubKeyBytes)) {
+        console.error(`\uD83D\uDD10 [ERROR] Invalid public key format detected (length: ${recipientPubKeyBytes.length} bytes)`);
+        throw new Error("Invalid public key format");
+      }
+      if (recipientPubKeyBytes.length === this.ML_KEM_768_PUBLIC_KEY_SIZE) {
+        console.log(`\uD83D\uDD10 [COMPATIBILITY] Detected ML-KEM-768 public key, using ML-KEM-768 for encryption`);
+        try {
+          const [kem768Ciphertext, kem768SharedSecret] = await this.kemAlgorithm768.encap(recipientPubKeyBytes);
+          const salt = SecureRandom.generateSalt();
+          const chachaKey = await HKDF.derive(kem768SharedSecret, salt, "ChaCha20-Poly1305", 32);
+          const nonce = SecureRandom.generateNonce();
+          const plaintext = new TextEncoder().encode(message);
+          const messageCiphertext = await ChaCha20Poly1305.encrypt(chachaKey, nonce, plaintext);
+          const encryptedMessage = {
+            v: 3,
+            alg: this.kemName768,
+            kem: Base64.encode(kem768Ciphertext),
+            s: Base64.encode(salt),
+            n: Base64.encode(nonce),
+            c: Base64.encode(messageCiphertext),
+            t: Date.now()
+          };
+          CryptoUtils.secureClear(chachaKey);
+          CryptoUtils.secureClear(kem768SharedSecret);
+          const result = JSON.stringify(encryptedMessage);
+          console.log(`\uD83D\uDD10 ✅ Encrypted message using ${this.kemName768}`);
+          return result;
+        } catch (kem768Error) {
+          console.error(`\uD83D\uDD10 ❌ ML-KEM-768 encryption failed:`, kem768Error);
+          throw kem768Error;
+        }
+      } else {
+        kemAlgorithm = this.kemAlgorithm;
+        kemName = this.kemName;
+      }
+      try {
+        const [kemCiphertext, sharedSecret] = await kemAlgorithm.encap(recipientPubKeyBytes);
+        const salt = SecureRandom.generateSalt();
+        const chachaKey = await HKDF.derive(sharedSecret, salt, "ChaCha20-Poly1305", 32);
+        const nonce = SecureRandom.generateNonce();
+        const plaintext = new TextEncoder().encode(message);
+        const messageCiphertext = await ChaCha20Poly1305.encrypt(chachaKey, nonce, plaintext);
+        const encryptedMessage = {
+          v: 3,
+          alg: kemName,
+          kem: Base64.encode(kemCiphertext),
+          s: Base64.encode(salt),
+          n: Base64.encode(nonce),
+          c: Base64.encode(messageCiphertext),
+          t: Date.now()
+        };
+        CryptoUtils.secureClear(chachaKey);
+        CryptoUtils.secureClear(sharedSecret);
+        const result = JSON.stringify(encryptedMessage);
+        console.log(`\uD83D\uDD10 ✅ Encrypted message using ${kemName}`);
+        return result;
+      } catch (encapError) {
+        console.error(`\uD83D\uDD10 ❌ ML-KEM encapsulation failed:`, encapError);
+        const keyInfo = this.analyzePublicKey(recipientPubKeyBytes);
+        console.log(`\uD83D\uDD10 [DEBUG] Public key analysis:`, keyInfo);
+        throw new Error(`ML-KEM encryption failed: ${encapError.message}`);
+      }
+    } catch (error) {
+      console.error(`\uD83D\uDD10 ❌ All encryption methods failed:`, error);
+      throw new Error("Unable to encrypt message with any available method");
+    }
+  }
+  analyzePublicKey(keyBytes) {
+    try {
+      let zeroCount = 0;
+      let nonAsciiCount = 0;
+      for (let i = 0;i < keyBytes.length; i++) {
+        if (keyBytes[i] === 0)
+          zeroCount++;
+        if (keyBytes[i] > 127)
+          nonAsciiCount++;
+      }
+      const info = {
+        length: keyBytes.length,
+        format: keyBytes.length === this.ML_KEM_1024_PUBLIC_KEY_SIZE ? "ML-KEM-1024" : keyBytes.length === this.ML_KEM_768_PUBLIC_KEY_SIZE ? "ML-KEM-768" : "unknown",
+        firstBytes: Array.from(keyBytes.slice(0, 8)),
+        zeroCount,
+        nonAsciiCount,
+        validKey: zeroCount < 50 && keyBytes.length > 1000
+      };
+      return info;
+    } catch (e) {
+      const errorMessage = e instanceof Error ? e.message : String(e);
+      return { error: errorMessage };
+    }
+  }
+  async generateUserKeys768() {
+    try {
+      console.log(`\uD83D\uDD10 Generating ${this.kemName768} key pair for backward compatibility...`);
+      const keyPair = await this.kemAlgorithm768.generateKeyPair();
+      const publicKey = Base64.encode(keyPair[0]);
+      const privateKey = Base64.encode(keyPair[1]);
+      this.userKeys768 = { publicKey, privateKey };
+      if (typeof window !== "undefined") {
+        const keyData = {
+          publicKey,
+          privateKey,
+          algorithm: this.kemName768,
+          timestamp: Date.now(),
+          version: "3.0"
+        };
+        await indexedDBManager.set(this.storageKey768, keyData);
+      }
+      console.log(`\uD83D\uDD10 Generated new ${this.kemName768} key pair for backward compatibility`);
+      return this.userKeys768;
+    } catch (error) {
+      console.error("\uD83D\uDD10 Failed to generate ML-KEM-768 keys:", error);
+      throw error;
+    }
+  }
+  async getUserKeys768() {
+    if (this.userKeys768) {
+      return this.userKeys768;
+    }
+    await this.loadUserKeys768();
+    if (this.userKeys768) {
+      return this.userKeys768;
+    }
+    return await this.generateUserKeys768();
+  }
+  async decryptFromSender(encryptedContent, senderPublicKey) {
+    try {
+      if (!this.isInitialized) {
+        throw new Error("Post-quantum encryption service not initialized");
+      }
+      console.log(`\uD83D\uDD10 [DEBUG] Starting decryption...`);
+      console.log(`\uD83D\uDD10 [DEBUG] Encrypted content type:`, typeof encryptedContent);
+      console.log(`\uD83D\uDD10 [DEBUG] Encrypted content length:`, encryptedContent?.length || 0);
+      console.log(`\uD83D\uDD10 [DEBUG] Encrypted content preview:`, encryptedContent?.substring(0, 100) || "N/A");
+      let messageData;
+      try {
+        messageData = JSON.parse(encryptedContent);
+        console.log(`\uD83D\uDD10 [DEBUG] Successfully parsed JSON, algorithm:`, messageData.alg);
+      } catch (parseError) {
+        const errorMessage = parseError instanceof Error ? parseError.message : String(parseError);
+        console.log("\uD83D\uDD10 [DEBUG] Content is not JSON, parse error:", errorMessage);
+        console.log("\uD83D\uDD10 [DEBUG] Raw content that failed to parse:", encryptedContent);
+        return "[Encrypted message]";
+      }
+      const version = messageData.v || messageData.version || 0;
+      const algorithm = messageData.alg || messageData.algorithm || "";
+      const kemCiphertextBase64 = messageData.kem || messageData.kemCiphertext || "";
+      const saltBase64 = messageData.s || messageData.salt || "";
+      const nonceBase64 = messageData.n || messageData.nonce || "";
+      const ciphertextBase64 = messageData.c || messageData.ciphertext || "";
+      let decryptionAlgorithm, userKeysToUse;
+      if (algorithm === this.kemName) {
+        console.log(`\uD83D\uDD10 [DEBUG] Using ${this.kemName} for decryption`);
+        decryptionAlgorithm = this.kemAlgorithm;
+        userKeysToUse = await this.getUserKeys();
+      } else if (algorithm === this.kemName768) {
+        console.log(`\uD83D\uDD10 [DEBUG] Using ${this.kemName768} for decryption`);
+        decryptionAlgorithm = this.kemAlgorithm768;
+        userKeysToUse = await this.getUserKeys768();
+      } else if (algorithm === "FALLBACK-AES-GCM" || algorithm === "FALLBACK-AES") {
+        console.log("\uD83D\uDD10 [LEGACY] AES encrypted message detected - no longer supported");
+        return "[Legacy encrypted message - please delete]";
+      } else {
+        if (!version || version !== 3 || !kemCiphertextBase64 || !saltBase64 || !nonceBase64 || !ciphertextBase64) {
+          console.log("\uD83D\uDD10 [DEBUG] Content is not post-quantum encrypted format, fields:", {
+            version,
+            algorithm,
+            hasKem: !!kemCiphertextBase64,
+            hasSalt: !!saltBase64,
+            hasNonce: !!nonceBase64,
+            hasCiphertext: !!ciphertextBase64
+          });
+          return "[Encrypted message - format error]";
+        }
+        console.log(`\uD83D\uDD10 [DEBUG] Unknown algorithm "${algorithm}", trying ML-KEM-1024 first, then ML-KEM-768 if needed`);
+        try {
+          decryptionAlgorithm = this.kemAlgorithm;
+          userKeysToUse = await this.getUserKeys();
+          console.log(`\uD83D\uDD10 [DEBUG] Using keys with algorithm ${this.kemName}`);
+          console.log(`\uD83D\uDD10 [DEBUG] Public key length:`, userKeysToUse?.publicKey?.length || 0);
+          let privateKeyBytes = Base64.decode(userKeysToUse.privateKey);
+          const kemCiphertext = Base64.decode(kemCiphertextBase64);
+          privateKeyBytes = this.stripKeyHeaderIfPresent(privateKeyBytes);
+          console.log(`\uD83D\uDD10 [DEBUG] Decoded private key length:`, privateKeyBytes.length);
+          console.log(`\uD83D\uDD10 [DEBUG] Decoded KEM ciphertext length:`, kemCiphertext.length);
+          console.log(`\uD83D\uDD10 [DEBUG] Starting ML-KEM decapsulation with algorithm:`, this.kemName);
+          const sharedSecret = await decryptionAlgorithm.decap(kemCiphertext, privateKeyBytes);
+          console.log(`\uD83D\uDD10 [DEBUG] ML-KEM decapsulation successful, shared secret length:`, sharedSecret.length);
+        } catch (err1024) {
+          console.warn(`\uD83D\uDD10 [DEBUG] ML-KEM-1024 decryption failed, trying ML-KEM-768. Error:`, err1024);
+          try {
+            decryptionAlgorithm = this.kemAlgorithm768;
+            userKeysToUse = await this.getUserKeys768();
+            console.log(`\uD83D\uDD10 [DEBUG] Using keys with algorithm ${this.kemName768}`);
+            console.log(`\uD83D\uDD10 [DEBUG] Public key length:`, userKeysToUse?.publicKey?.length || 0);
+            const privateKeyBytes = Base64.decode(userKeysToUse.privateKey);
+            const kemCiphertext = Base64.decode(kemCiphertextBase64);
+            console.log(`\uD83D\uDD10 [DEBUG] Decoded private key length:`, privateKeyBytes.length);
+            console.log(`\uD83D\uDD10 [DEBUG] Decoded KEM ciphertext length:`, kemCiphertext.length);
+            console.log(`\uD83D\uDD10 [DEBUG] Starting ML-KEM decapsulation with algorithm:`, this.kemName768);
+            const sharedSecret = await decryptionAlgorithm.decap(kemCiphertext, privateKeyBytes);
+            console.log(`\uD83D\uDD10 [DEBUG] ML-KEM decapsulation successful, shared secret length:`, sharedSecret.length);
+          } catch (err768) {
+            console.error(`\uD83D\uDD10 [DEBUG] ML-KEM-768 decryption also failed. Error:`, err768);
+            return "[Encrypted message - could not decrypt with any supported algorithm]";
+          }
+        }
+      }
+      console.log(`\uD83D\uDD10 [DEBUG] Using keys with algorithm ${userKeysToUse ? algorithm === this.kemName768 ? this.kemName768 : this.kemName : "unknown"}`);
+      console.log(`\uD83D\uDD10 [DEBUG] Public key length:`, userKeysToUse?.publicKey?.length || 0);
+      let privateKeyBytes = Base64.decode(userKeysToUse.privateKey);
+      const kemCiphertext = Base64.decode(kemCiphertextBase64);
+      privateKeyBytes = this.stripKeyHeaderIfPresent(privateKeyBytes);
+      const targetPrivateKeySize = algorithm === this.kemName768 ? 2400 : 3168;
+      if (privateKeyBytes.length !== targetPrivateKeySize) {
+        throw new Error(`Invalid private key size: expected ${targetPrivateKeySize} bytes, got ${privateKeyBytes.length}. ` + `Please use Nuclear Key Reset in Settings to generate new encryption keys.`);
+      }
+      console.log(`\uD83D\uDD10 [DEBUG] Decoded private key length:`, privateKeyBytes.length);
+      console.log(`\uD83D\uDD10 [DEBUG] Decoded KEM ciphertext length:`, kemCiphertext.length);
+      console.log(`\uD83D\uDD10 [DEBUG] Starting ML-KEM decapsulation with algorithm:`, algorithm === this.kemName768 ? this.kemName768 : this.kemName);
+      const sharedSecret = await decryptionAlgorithm.decap(kemCiphertext, privateKeyBytes);
+      console.log(`\uD83D\uDD10 [DEBUG] ML-KEM decapsulation successful, shared secret length:`, sharedSecret.length);
+      const salt = Base64.decode(saltBase64);
+      const chachaKey = await HKDF.derive(sharedSecret, salt, "ChaCha20-Poly1305", 32);
+      const nonce = Base64.decode(nonceBase64);
+      const messageCiphertext = Base64.decode(ciphertextBase64);
+      console.log(`\uD83D\uDD10 [DEBUG] Nonce length:`, nonce.length);
+      console.log(`\uD83D\uDD10 [DEBUG] Message ciphertext length:`, messageCiphertext.length);
+      console.log(`\uD83D\uDD10 [DEBUG] Starting ChaCha20-Poly1305 decryption...`);
+      const plaintext = await ChaCha20Poly1305.decrypt(chachaKey, nonce, messageCiphertext);
+      console.log(`\uD83D\uDD10 [DEBUG] ChaCha20-Poly1305 decryption successful, plaintext length:`, plaintext.length);
+      const messageText = new TextDecoder("utf-8").decode(plaintext);
+      CryptoUtils.secureClear(chachaKey);
+      CryptoUtils.secureClear(sharedSecret);
+      console.log(`\uD83D\uDD10 ✅ Successfully decrypted message using ${algorithm === this.kemName768 ? this.kemName768 : this.kemName}`);
+      return messageText;
+    } catch (error) {
+      console.error(`\uD83D\uDD10 ❌ Failed to decrypt message with ${this.kemName}:`, error);
+      if (error instanceof Error && error.stack) {
+        console.error(`\uD83D\uDD10 ❌ Error stack:`, error.stack);
+      }
+      const errorMsg = error instanceof Error ? error.message : String(error);
+      if (errorMsg.includes("Algorithm mismatch")) {
+        return "[Message encrypted with different keys]";
+      }
+      return "[Encrypted message - decryption failed]";
+    }
+  }
+  async clearUserKeys() {
+    this.userKeys = null;
+    this.userKeys768 = null;
+    this.publicKeyCache.clear();
+    if (typeof window !== "undefined") {
+      await Promise.all([
+        indexedDBManager.delete(this.storageKey),
+        indexedDBManager.delete(this.storageKey768)
+      ]);
+    }
+    console.log(`\uD83D\uDD10 Cleared all encryption keys`);
+  }
+  async exportUserKeys() {
+    const keys1024 = await this.getUserKeys();
+    const keys768 = await this.getUserKeys768();
+    return {
+      keys1024: {
+        publicKey: keys1024.publicKey,
+        privateKey: keys1024.privateKey,
+        algorithm: this.kemName
+      },
+      keys768: {
+        publicKey: keys768.publicKey,
+        privateKey: keys768.privateKey,
+        algorithm: this.kemName768
+      }
+    };
+  }
+  async importUserKeys(publicKey, privateKey, algorithm = this.kemName) {
+    if (algorithm === this.kemName) {
+      this.userKeys = { publicKey, privateKey };
+      if (typeof window !== "undefined") {
+        const keyData = {
+          publicKey,
+          privateKey,
+          algorithm,
+          timestamp: Date.now(),
+          version: "3.0"
+        };
+        await indexedDBManager.set(this.storageKey, keyData);
+      }
+    } else if (algorithm === this.kemName768) {
+      this.userKeys768 = { publicKey, privateKey };
+      if (typeof window !== "undefined") {
+        const keyData = {
+          publicKey,
+          privateKey,
+          algorithm,
+          timestamp: Date.now(),
+          version: "3.0"
+        };
+        await indexedDBManager.set(this.storageKey768, keyData);
+      }
+    } else {
+      console.warn(`\uD83D\uDD10 Importing keys with unknown algorithm ${algorithm}`);
+    }
+    console.log(`\uD83D\uDD10 Imported ${algorithm} keys`);
+  }
+  isValidPublicKey(publicKeyBytes) {
+    const is1024Size = Math.abs(publicKeyBytes.length - this.ML_KEM_1024_PUBLIC_KEY_SIZE) <= 32;
+    const is768Size = Math.abs(publicKeyBytes.length - this.ML_KEM_768_PUBLIC_KEY_SIZE) <= 32;
+    if (!is1024Size && !is768Size) {
+      console.warn(`\uD83D\uDD10 [VALIDATE] Public key has unusual length: ${publicKeyBytes.length} bytes`);
+      console.warn(`\uD83D\uDD10 [VALIDATE] Expected ~${this.ML_KEM_1024_PUBLIC_KEY_SIZE} or ~${this.ML_KEM_768_PUBLIC_KEY_SIZE} bytes`);
+    }
+    let zeroCount = 0;
+    for (let i = 0;i < Math.min(50, publicKeyBytes.length); i++) {
+      if (publicKeyBytes[i] === 0) {
+        zeroCount++;
+      }
+    }
+    if (zeroCount > 40) {
+      console.error(`\uD83D\uDD10 [VALIDATE] Public key appears to be corrupted (${zeroCount} zeros in header)`);
+      return false;
+    }
+    console.log(`\uD83D\uDD10 [VALIDATE] Valid key detected (${publicKeyBytes.length} bytes, ${is1024Size ? "ML-KEM-1024" : "ML-KEM-768"} format)`);
+    return true;
+  }
+  stripKeyHeaderIfPresent(keyBytes) {
+    if (keyBytes.length > 8 && keyBytes[0] === 75 && keyBytes[1] === 89 && keyBytes[2] === 66 && keyBytes[3] === 69 && keyBytes[4] === 82) {
+      console.log('\uD83D\uDD10 [CRITICAL] Detected "KYBER" header in key - this key format cannot be repaired');
+      console.log("\uD83D\uDD10 [CRITICAL] Please use the Nuclear Key Reset in settings to generate new clean keys");
+      return new Uint8Array(this.ML_KEM_1024_PUBLIC_KEY_SIZE);
+    }
+    return keyBytes;
+  }
+  getAlgorithmInfo() {
+    return {
+      primaryAlgorithm: {
+        name: this.kemName,
+        type: "Post-Quantum KEM + Symmetric Encryption",
+        keyExchange: this.kemName,
+        encryption: "ChaCha20-Poly1305",
+        quantumResistant: true,
+        securityLevel: 5
+      },
+      compatibilityAlgorithm: {
+        name: this.kemName768,
+        type: "Post-Quantum KEM + Symmetric Encryption",
+        keyExchange: this.kemName768,
+        encryption: "ChaCha20-Poly1305",
+        quantumResistant: true,
+        securityLevel: 3
+      },
+      multiAlgorithmSupport: true
+    };
+  }
+  validatePublicKeyFormat(publicKeyBase64) {
+    try {
+      if (!publicKeyBase64 || typeof publicKeyBase64 !== "string") {
+        console.error("\uD83D\uDD10 [VALIDATE] Public key is null or not a string");
+        return null;
+      }
+      let keyBytes = Base64.decode(publicKeyBase64);
+      keyBytes = this.stripKeyHeaderIfPresent(keyBytes);
+      if (!this.isValidPublicKey(keyBytes)) {
+        console.warn("\uD83D\uDD10 [VALIDATE] Public key failed validation checks");
+        return null;
+      }
+      return keyBytes;
+    } catch (error) {
+      console.error("\uD83D\uDD10 [VALIDATE] Error validating public key format:", error);
+      return null;
+    }
+  }
+  validateKeySize(keyBytes, targetSize, keyType = "key") {
+    if (keyBytes.length === targetSize) {
+      return keyBytes;
+    }
+    throw new Error(`Invalid ML-KEM ${keyType} size: expected ${targetSize} bytes, got ${keyBytes.length} bytes. ` + `Please use the Nuclear Key Reset in Settings to generate new encryption keys.`);
+  }
+}
+var postQuantumEncryption = new PostQuantumEncryptionService;
+
+// src/cli/crypto.js
+var METHODS = ["log", "info", "warn", "error", "debug"];
+async function quietly(fn) {
+  const saved = METHODS.map((m) => console[m]);
+  for (const m of METHODS)
+    console[m] = () => {};
+  try {
+    return await fn();
+  } finally {
+    METHODS.forEach((m, i) => console[m] = saved[i]);
+  }
+}
+function keyring(keys) {
+  const service = new PostQuantumEncryptionService;
+  service.userKeys = { publicKey: keys.keys1024.publicKey, privateKey: keys.keys1024.privateKey };
+  if (keys.keys768)
+    service.userKeys768 = { publicKey: keys.keys768.publicKey, privateKey: keys.keys768.privateKey };
+  service.isInitialized = true;
+  return {
+    encrypt: (text, recipientPublicKey) => quietly(() => service.encryptForRecipient(text, recipientPublicKey)),
+    decrypt: (content) => quietly(() => service.decryptFromSender(content, ""))
+  };
+}
+async function ephemeralKeypair() {
+  const [publicKey, privateKey] = await new MlKem10242().generateKeyPair();
+  return { publicKey: Base64.encode(publicKey), privateKey: Base64.encode(privateKey) };
+}
+async function openKeyBlob(blob, ephemeral) {
+  const ring = keyring({ keys1024: ephemeral });
+  const text = await ring.decrypt(blob);
+  let keys;
+  try {
+    keys = JSON.parse(text);
+  } catch {
+    throw new Error("Could not open the keys the browser sent. Run qc login again.");
+  }
+  if (!keys?.keys1024?.publicKey || !keys?.keys1024?.privateKey)
+    throw new Error("The browser sent no usable keys.");
+  return { keys1024: keys.keys1024, keys768: keys.keys768 };
+}
+
+// src/cli/api.js
+class QcError extends Error {
+  constructor(message, status) {
+    super(message);
+    this.name = "QcError";
+    this.status = status;
+  }
+}
+
+class QcClient {
+  constructor(session, options = {}) {
+    this.session = session;
+    this.base = baseUrl(session, options.env);
+    this.save = options.save ?? ((s) => saveSession(s, options.env));
+    this.fetch = options.fetch ?? globalThis.fetch;
+    this.ring = keyring(session.keys);
+    this.refreshing = null;
+  }
+  get me() {
+    return this.session.user;
+  }
+  async refresh() {
+    this.refreshing ??= (async () => {
+      const res = await this.fetch(`${this.base}/api/cli/token`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ grant_type: "refresh_token", refresh_token: this.session.refresh_token })
+      });
+      const body = await res.json().catch(() => ({}));
+      if (!res.ok)
+        throw new QcError(body.error_description || "Your session has ended. Run qc login.", 401);
+      this.session = { ...this.session, ...body };
+      this.save(this.session);
+    })().finally(() => {
+      this.refreshing = null;
+    });
+    return this.refreshing;
+  }
+  async token() {
+    const expiresAt = Number(this.session.expires_at || 0) * 1000;
+    if (expiresAt && expiresAt - Date.now() < 60000)
+      await this.refresh();
+    return this.session.access_token;
+  }
+  async request(path, { method = "GET", body, signal, retry = true } = {}) {
+    const res = await this.fetch(`${this.base}${path}`, {
+      method,
+      signal,
+      headers: {
+        Authorization: `Bearer ${await this.token()}`,
+        ...body !== undefined ? { "Content-Type": "application/json" } : {}
+      },
+      body: body !== undefined ? JSON.stringify(body) : undefined
+    });
+    if (res.status === 401 && retry) {
+      await this.refresh();
+      return this.request(path, { method, body, signal, retry: false });
+    }
+    const data = await res.json().catch(() => ({}));
+    if (!res.ok)
+      throw new QcError(data.error_description || data.error || `HTTP ${res.status}`, res.status);
+    return data;
+  }
+  async conversations() {
+    const { conversations = [] } = await this.request("/api/conversations/load", { method: "POST", body: {} });
+    return conversations.map((c) => ({ ...c, title: conversationTitle(c, this.me) }));
+  }
+  async messages(conversationId, { limit = 100, before } = {}) {
+    const { messages = [], hasMore = false } = await this.request("/api/messages/load", {
+      method: "POST",
+      body: { conversationId, limit, ...before ? { before } : {} }
+    });
+    const out = [];
+    for (const m of messages) {
+      let text;
+      if (m.message_type === "file" || m.has_attachments) {
+        text = m.encrypted_content ? await this.ring.decrypt(m.encrypted_content) : "";
+        text = `\uD83D\uDCCE ${text && text !== "[File attachment]" ? `${text} ` : ""}(attachment: open qrypt.chat to download)`;
+      } else {
+        text = m.encrypted_content ? await this.ring.decrypt(m.encrypted_content) : "";
+      }
+      out.push({
+        id: m.id,
+        conversationId: m.conversation_id,
+        senderId: m.sender_id,
+        sender: m.sender?.display_name || m.sender?.username || "unknown",
+        username: m.sender?.username || "",
+        mine: m.sender_id === this.me?.id,
+        text,
+        at: m.created_at
+      });
+    }
+    return { messages: out, hasMore };
+  }
+  async send(conversationId, text) {
+    const { participants = [] } = await this.request(`/api/chat/conversations/${encodeURIComponent(conversationId)}/participants`);
+    const userIds = participants.map((p) => p.user_id);
+    if (!userIds.length)
+      throw new QcError("This conversation has no participants");
+    const { public_keys: keys = {} } = await this.request("/api/crypto/public-keys", { method: "POST", body: { user_ids: userIds } });
+    const encryptedContents = {};
+    const missing = [];
+    for (const id of userIds) {
+      if (!keys[id]) {
+        missing.push(id);
+        continue;
+      }
+      encryptedContents[id] = await this.ring.encrypt(text, keys[id]);
+    }
+    if (!Object.keys(encryptedContents).length)
+      throw new QcError("No participant has a public key yet");
+    const { message } = await this.request("/api/messages/send", {
+      method: "POST",
+      body: { conversationId, encryptedContents, messageType: "text" }
+    });
+    return { message, skipped: missing.length };
+  }
+  typing(conversationId, on) {
+    return this.request(`/api/typing/${on ? "start" : "stop"}`, { method: "POST", body: { conversationId } }).catch(() => {});
+  }
+  async events(onEvent, { signal, onStatus = () => {} } = {}) {
+    let delay = 1000;
+    while (!signal?.aborted) {
+      onStatus("connecting");
+      try {
+        const res = await this.fetch(`${this.base}/api/events`, {
+          headers: { Authorization: `Bearer ${await this.token()}`, Accept: "text/event-stream" },
+          signal
+        });
+        if (res.status === 401) {
+          await this.refresh();
+          continue;
+        }
+        if (!res.ok || !res.body)
+          throw new Error(`HTTP ${res.status}`);
+        onStatus("live");
+        delay = 1000;
+        await readSse(res.body, onEvent);
+      } catch (err) {
+        if (signal?.aborted)
+          break;
+        if (err instanceof QcError && err.status === 401)
+          throw err;
+      }
+      if (signal?.aborted)
+        break;
+      onStatus("offline");
+      await sleep(delay, signal);
+      delay = Math.min(delay * 2, 30000);
+    }
+  }
+}
+async function readSse(body, onEvent) {
+  const decoder = new TextDecoder;
+  let buffer = "";
+  for await (const chunk of body) {
+    buffer += decoder.decode(chunk, { stream: true });
+    let at;
+    while ((at = buffer.indexOf(`
+
+`)) !== -1) {
+      const frame = buffer.slice(0, at);
+      buffer = buffer.slice(at + 2);
+      let type = "message";
+      const data = [];
+      for (const line of frame.split(`
+`)) {
+        if (line.startsWith("event:"))
+          type = line.slice(6).trim();
+        else if (line.startsWith("data:"))
+          data.push(line.slice(5).trimStart());
+      }
+      if (!data.length)
+        continue;
+      let parsed;
+      try {
+        parsed = JSON.parse(data.join(`
+`));
+      } catch {
+        parsed = data.join(`
+`);
+      }
+      onEvent({ type, data: parsed?.payload ?? parsed?.data ?? parsed });
+    }
+  }
+}
+function sleep(ms, signal) {
+  return new Promise((resolve) => {
+    const t = setTimeout(resolve, ms);
+    signal?.addEventListener("abort", () => {
+      clearTimeout(t);
+      resolve();
+    });
+  });
+}
+function conversationTitle(c, me) {
+  if (c.name)
+    return c.name;
+  const others = (c.participants || []).filter((p) => p.user_id !== me?.id).map((p) => p.user?.display_name || p.user?.username).filter(Boolean);
+  return others.length ? others.join(", ") : "Just you";
+}
+
+// src/cli/login.js
+import { createHash, randomBytes } from "node:crypto";
+import { createServer } from "node:http";
+import { hostname } from "node:os";
+import { spawn } from "node:child_process";
+import { createInterface } from "node:readline/promises";
+
+// src/lib/auth/cli-match.js
+var ALPHABET = "ABCDEFGHJKLMNPQRSTUVWXYZ23456789";
+async function matchCode(challenge, kemPublicKey) {
+  const bytes = new Uint8Array(await globalThis.crypto.subtle.digest("SHA-256", new TextEncoder().encode(`qc-login
+${challenge}
+${kemPublicKey}`)));
+  let out = "";
+  for (let i = 0;i < 8; i++)
+    out += ALPHABET[bytes[i] % ALPHABET.length];
+  return `${out.slice(0, 4)}-${out.slice(4)}`;
+}
+
+// src/cli/login.js
+var b64url = (buf) => Buffer.from(buf).toString("base64url");
+var TIMEOUT_MS = 5 * 60 * 1000;
+var PAGE = (title, body) => `<!doctype html><meta charset="utf-8"><title>${title}</title>
+<style>body{font:16px system-ui,sans-serif;display:grid;place-items:center;min-height:90vh;background:#0b0d12;color:#e6e8ee}main{max-width:28rem;text-align:center}</style>
+<main><h1>${title}</h1><p>${body}</p></main>`;
+function openBrowser(url, { platform = process.platform, env = process.env } = {}) {
+  if (env.QC_NO_BROWSER || (env.SSH_CONNECTION || env.SSH_TTY) && !env.DISPLAY && !env.WAYLAND_DISPLAY && platform === "linux") {
+    return false;
+  }
+  const [cmd, args] = platform === "darwin" ? ["open", [url]] : platform === "win32" ? ["cmd", ["/c", "start", "", url]] : ["xdg-open", [url]];
+  try {
+    const child = spawn(cmd, args, { stdio: "ignore", detached: true });
+    child.on("error", () => {});
+    child.unref();
+    return true;
+  } catch {
+    return false;
+  }
+}
+function waitForCallback(server, state) {
+  return new Promise((resolve, reject) => {
+    const timer = setTimeout(() => reject(new Error("Timed out waiting for the browser (5 minutes). Run qc login again.")), TIMEOUT_MS);
+    server.on("request", (req, res) => {
+      const url = new URL(req.url, "http://127.0.0.1");
+      if (url.pathname !== "/callback") {
+        res.writeHead(404).end();
+        return;
+      }
+      const done = (status, title, body) => {
+        res.writeHead(status, { "Content-Type": "text/html; charset=utf-8" }).end(PAGE(title, body));
+      };
+      if (url.searchParams.get("state") !== state) {
+        done(400, "That was not this login", "The state did not match. Go back to your terminal.");
+        return;
+      }
+      clearTimeout(timer);
+      const error = url.searchParams.get("error");
+      if (error) {
+        done(200, "Not approved", "Nothing was shared. You can close this tab.");
+        reject(new Error(error === "access_denied" ? "Login was denied in the browser." : `Login failed: ${error}`));
+        return;
+      }
+      done(200, "Signed in", "You can close this tab and go back to your terminal.");
+      resolve(url.searchParams.get("code"));
+    });
+  });
+}
+async function login(options = {}) {
+  const env = options.env ?? process.env;
+  const print = options.print ?? ((line) => process.stderr.write(`${line}
+`));
+  const base = (options.base ?? baseUrl(null, env)).replace(/\/+$/, "");
+  const verifier = b64url(randomBytes(32));
+  const challenge = b64url(createHash("sha256").update(verifier).digest());
+  const state = b64url(randomBytes(16));
+  const ephemeral = await ephemeralKeypair();
+  let server;
+  let redirectUri = "oob";
+  if (!options.oob) {
+    server = createServer();
+    await new Promise((resolve) => server.listen(0, "127.0.0.1", resolve));
+    redirectUri = `http://127.0.0.1:${server.address().port}/callback`;
+  }
+  const url = new URL("/cli/authorize", base);
+  for (const [k, v] of Object.entries({
+    response_type: "code",
+    code_challenge: challenge,
+    code_challenge_method: "S256",
+    redirect_uri: redirectUri,
+    state,
+    client_name: `qc on ${hostname()}`,
+    kem: ephemeral.publicKey
+  })) {
+    url.searchParams.set(k, v);
+  }
+  const match = await matchCode(challenge, ephemeral.publicKey);
+  print("");
+  print(`  Confirmation code: ${match}`);
+  print("  Check that the browser shows the same code before you approve.");
+  print("");
+  const opened = !options.oob && openBrowser(url.toString(), { env });
+  print(opened ? "  Opened your browser. If it did not, open:" : "  Open this link in a browser where you are signed in to qrypt.chat:");
+  print(`  ${url.toString()}`);
+  print("");
+  let code;
+  try {
+    if (server) {
+      code = await waitForCallback(server, state);
+    } else {
+      const rl = createInterface({ input: process.stdin, output: process.stderr });
+      code = (await rl.question("  Paste the code from the browser: ")).trim();
+      rl.close();
+    }
+  } finally {
+    server?.close();
+  }
+  if (!code)
+    throw new Error("No code came back from the browser.");
+  const res = await fetch(`${base}/api/cli/token`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ grant_type: "authorization_code", code, code_verifier: verifier, redirect_uri: redirectUri })
+  });
+  const token = await res.json().catch(() => ({}));
+  if (!res.ok)
+    throw new Error(token.error_description || token.error || `Sign-in failed (HTTP ${res.status})`);
+  const keys = await openKeyBlob(token.key_blob, ephemeral);
+  const session = {
+    base,
+    access_token: token.access_token,
+    refresh_token: token.refresh_token,
+    expires_at: token.expires_at,
+    user: token.user,
+    keys,
+    created_at: new Date().toISOString()
+  };
+  saveSession(session, env);
+  return session;
+}
+
+// src/cli/commands.js
+var HELP2 = `qc: qrypt.chat in your terminal (end-to-end encrypted, ML-KEM-1024)
+
+Usage:
+  qc                      open the chat client (signs you in first if needed)
+  qc login [--oob]        sign in through your browser; --oob to paste a code (SSH)
+  qc logout               forget this terminal's session and keys
+  qc whoami               who this terminal is signed in as
+  qc chats                list your chats
+  qc read <chat> [-n 20]  print the last messages of a chat
+  qc send <chat> <text>   send a message (text "-" reads stdin)
+  qc listen               print new messages as they arrive (NDJSON with --json)
+  qc mcp                  run as an MCP server on stdio (list_chats, read_chat, send_message)
+
+<chat> is a chat id or part of its name. Options: --json, --url <server> (or QC_URL).
+Keys and session live in ${"$"}QC_HOME or ~/.config/qc (mode 0600).`;
+function parseArgs2(argv) {
+  const args = { _: [], flags: {} };
+  for (let i = 0;i < argv.length; i++) {
+    const a = argv[i];
+    if (a === "--") {
+      args._.push(...argv.slice(i + 1));
+      break;
+    }
+    if (a.startsWith("--")) {
+      const [k, v] = a.slice(2).split("=", 2);
+      if (v !== undefined)
+        args.flags[k] = v;
+      else if (["url", "n", "limit"].includes(k) && argv[i + 1] !== undefined)
+        args.flags[k] = argv[++i];
+      else
+        args.flags[k] = true;
+    } else if (a === "-n" && argv[i + 1] !== undefined) {
+      args.flags.n = argv[++i];
+    } else if (a === "-h") {
+      args.flags.help = true;
+    } else if (a === "-v") {
+      args.flags.version = true;
+    } else {
+      args._.push(a);
+    }
+  }
+  return args;
+}
+function findChat2(chats, query) {
+  const q = String(query).toLowerCase();
+  const byId = chats.find((c) => c.id === query);
+  if (byId)
+    return byId;
+  const exact = chats.filter((c) => c.title.toLowerCase() === q);
+  if (exact.length === 1)
+    return exact[0];
+  const some = chats.filter((c) => c.title.toLowerCase().includes(q));
+  if (some.length === 1)
+    return some[0];
+  if (some.length > 1)
+    throw new Error(`"${query}" matches ${some.length} chats: ${some.map((c) => c.title).join(", ")}`);
+  throw new Error(`No chat matches "${query}". Try qc chats.`);
+}
+async function client(flags, { interactive = false } = {}) {
+  if (flags.url)
+    process.env.QC_URL = flags.url;
+  let session = loadSession();
+  if (!session) {
+    if (!interactive)
+      throw new Error("Not signed in. Run qc login.");
+    session = await login({ oob: !!flags.oob });
+  }
+  return new QcClient(session);
+}
+var stamp = (iso) => new Date(iso).toLocaleString(undefined, { dateStyle: "short", timeStyle: "short" });
+async function readStdin() {
+  let text = "";
+  for await (const chunk of process.stdin)
+    text += chunk;
+  return text;
+}
+async function main2(argv, { version = "0.0.0" } = {}) {
+  const { _: [cmd, ...rest], flags } = parseArgs2(argv);
+  const out = (line) => process.stdout.write(`${line}
+`);
+  const json = (value) => out(JSON.stringify(value, null, flags.json === "compact" ? 0 : 2));
+  if (flags.version)
+    return out(`qc ${version}`);
+  if (flags.help || cmd === "help")
+    return out(HELP2);
+  if (flags.url)
+    process.env.QC_URL = flags.url;
+  switch (cmd) {
+    case undefined:
+    case "tui": {
+      if (!process.stdout.isTTY)
+        throw new Error("qc needs a terminal. For scripts use qc chats / read / send / listen.");
+      const c = await client(flags, { interactive: true });
+      const { runTui } = await import("./tui.js");
+      return runTui(c, { initialChat: rest[0] });
+    }
+    case "login": {
+      const session = await login({ oob: !!flags.oob });
+      return out(`Signed in as @${session.user?.username ?? "unknown"} on ${session.base}. Keys saved to ${sessionPath()}.`);
+    }
+    case "logout":
+      clearSession();
+      return out("Signed out. This terminal no longer holds your keys.");
+    case "whoami": {
+      const session = loadSession();
+      if (!session)
+        throw new Error("Not signed in. Run qc login.");
+      return flags.json ? json({ user: session.user, base: session.base }) : out(`@${session.user?.username} (${session.user?.display_name ?? ""}) on ${session.base}`);
+    }
+    case "chats":
+    case "ls": {
+      const chats = await (await client(flags)).conversations();
+      if (flags.json)
+        return json(chats.map((c) => ({ id: c.id, title: c.title, type: c.type, updated_at: c.updated_at, participants: c.participants?.length ?? 0 })));
+      for (const c of chats)
+        out(`${c.id}  ${c.title}`);
+      return;
+    }
+    case "read": {
+      if (!rest[0])
+        throw new Error("Usage: qc read <chat> [-n 20]");
+      const c = await client(flags);
+      const chat = findChat2(await c.conversations(), rest[0]);
+      const { messages } = await c.messages(chat.id, { limit: 100 });
+      const last = messages.slice(-Math.max(1, Number(flags.n || flags.limit || 20)));
+      if (flags.json)
+        return json(last);
+      for (const m of last)
+        out(`[${stamp(m.at)}] ${m.mine ? "you" : m.sender}: ${m.text}`);
+      return;
+    }
+    case "send": {
+      if (!rest[0] || rest.length < 2)
+        throw new Error('Usage: qc send <chat> <text>   (text "-" reads stdin)');
+      const text = rest[1] === "-" && rest.length === 2 ? (await readStdin()).trim() : rest.slice(1).join(" ");
+      if (!text)
+        throw new Error("Nothing to send.");
+      const c = await client(flags);
+      const chat = findChat2(await c.conversations(), rest[0]);
+      const { message, skipped } = await c.send(chat.id, text);
+      if (flags.json)
+        return json({ id: message?.id, conversation: chat.id, skipped });
+      return out(`Sent to ${chat.title}${skipped ? ` (${skipped} participant(s) have no key yet)` : ""}.`);
+    }
+    case "listen": {
+      const c = await client(flags);
+      const chats = await c.conversations();
+      const titles = new Map(chats.map((x) => [x.id, x.title]));
+      for (const x of chats)
+        await c.messages(x.id, { limit: 1 }).catch(() => {});
+      const seen = new Set;
+      await c.events(async ({ type, data }) => {
+        if (type !== "NEW_MESSAGE" || !data?.message?.conversation_id)
+          return;
+        const id = data.message.conversation_id;
+        const { messages } = await c.messages(id, { limit: 100 });
+        for (const m of messages.slice(-5)) {
+          if (seen.has(m.id) || m.id !== data.message.id)
+            continue;
+          seen.add(m.id);
+          if (flags.json)
+            out(JSON.stringify({ chat: id, title: titles.get(id), ...m }));
+          else
+            out(`[${stamp(m.at)}] ${titles.get(id) ?? id} · ${m.mine ? "you" : m.sender}: ${m.text}`);
+        }
+      }, { onStatus: (s) => process.stderr.write(`qc: ${s}
+`) });
+      return;
+    }
+    case "mcp": {
+      const { serveMcp } = await import("./mcp.js");
+      return serveMcp(await client(flags), { version });
+    }
+    default:
+      throw new Error(`Unknown command "${cmd}".
+
+${HELP2}`);
+  }
+}
+
+export { HELP2, parseArgs2, findChat2, main2 };