@thezelijah/majik-message 1.0.17 → 1.0.18

package/dist/core/contacts/majik-contact.d.ts

@@ -54,6 +54,7 @@ export declare class MajikContact {
     isMajikahIdentityChecked(): boolean;
     isMajikahRegistered(): boolean;
     setMajikahStatus(status: boolean): this;
+    getDisplayName(): Promise<string>;
     /**
      * Support both CryptoKey and raw-key wrappers (fallbacks when WebCrypto X25519 unsupported)
      */

package/dist/core/contacts/majik-contact.js

@@ -114,6 +114,9 @@ export class MajikContact {
         this.majikah_registered = status;
         return this;
     }
+    async getDisplayName() {
+        return this.meta.label || (await this.getPublicKeyBase64());
+    }
     /**
      * Support both CryptoKey and raw-key wrappers (fallbacks when WebCrypto X25519 unsupported)
      */

package/dist/core/crypto/keystore.d.ts

@@ -31,13 +31,13 @@ export declare class KeyStoreError extends Error {
  * ⚠️ Background-only. Never expose private keys to content scripts.
  */
 export declare class KeyStore {
-    private static DB_NAME;
+    private static deviceID;
     private static STORE_NAME;
     private static DB_VERSION;
     private static dbPromise;
     private static unlockedIdentities;
     static onUnlockRequested?: (id: string) => string | Promise<string>;
-    private static computeChecksum;
+    static init(deviceID: string): void;
     private static getDB;
     private static putSerializedIdentity;
     private static getSerializedIdentity;

package/dist/core/crypto/keystore.js

@@ -28,7 +28,7 @@ export class KeyStoreError extends Error {
  * ⚠️ Background-only. Never expose private keys to content scripts.
  */
 export class KeyStore {
-    static DB_NAME = "MajikMessageKeyStore";
+    static deviceID = "default";
     static STORE_NAME = "identities";
     static DB_VERSION = 1;
     static dbPromise = null;
@@ -37,22 +37,18 @@ export class KeyStore {
     // Optional callback: invoked when UI needs to request a passphrase to unlock an identity.
     // Should return the passphrase string or a Promise<string>.
     static onUnlockRequested;
-    /* ================================
-     * Chrome Storage Helpers
-     * ================================ */
-    static async computeChecksum(identities) {
-        const json = JSON.stringify(identities);
-        const hash = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(json));
-        return arrayBufferToBase64(hash);
-    }
     /* ================================
      * IndexedDB Helpers
      * ================================ */
+    static init(deviceID) {
+        this.deviceID = deviceID;
+    }
     static async getDB() {
         if (this.dbPromise)
             return this.dbPromise;
+        const dbName = this.deviceID;
         this.dbPromise = new Promise((resolve, reject) => {
-            const request = indexedDB.open(this.DB_NAME, this.DB_VERSION);
+            const request = indexedDB.open(dbName, this.DB_VERSION);
             request.onupgradeneeded = () => {
                 const db = request.result;
                 if (!db.objectStoreNames.contains(this.STORE_NAME)) {

package/dist/core/messages/envelope-cache.d.ts

@@ -28,13 +28,14 @@ export interface EnvelopeCacheItem {
     message?: string;
 }
 export declare class EnvelopeCache {
+    private userProfile;
     private dbPromise;
     private dbName;
     private storeName;
     private maxEntries?;
     private memoryCache;
     private memoryCacheSize;
-    constructor(config?: EnvelopeCacheConfig);
+    constructor(config?: EnvelopeCacheConfig, userProfile?: string);
     private initDB;
     private getEnvelopeId;
     set(envelope: MessageEnvelope, source?: string): Promise<void>;

package/dist/core/messages/envelope-cache.js

@@ -15,6 +15,7 @@ export class EnvelopeCacheError extends Error {
  * EnvelopeCache
  * ------------------------------- */
 export class EnvelopeCache {
+    userProfile = "default";
     dbPromise;
     dbName;
     storeName;
@@ -22,12 +23,13 @@ export class EnvelopeCache {
     // In-memory cache
     memoryCache;
     memoryCacheSize;
-    constructor(config) {
-        this.dbName = config?.dbName || "MajikEnvelopeDB";
+    constructor(config, userProfile = "default") {
+        this.dbName = config?.dbName || `MajikEnvelopeDB_${userProfile}`;
         this.storeName = config?.storeName || "envelopes";
         this.maxEntries = config?.maxEntries;
         this.memoryCacheSize = config?.memoryCacheSize || 100;
         this.memoryCache = new Map();
+        this.userProfile = userProfile || "default";
         this.dbPromise = this.initDB();
     }
     /* -------------------------------
@@ -35,6 +37,7 @@ export class EnvelopeCache {
      * ------------------------------- */
     initDB() {
         return new Promise((resolve, reject) => {
+            console.log("DB: ", this.dbName);
             const request = indexedDB.open(this.dbName, 1);
             request.onupgradeneeded = (event) => {
                 const db = event.target.result;

package/dist/core/utils/idb-majik-system.d.ts

@@ -7,9 +7,9 @@ export interface MajikIDBSaveData {
 interface MajikAutosaveSchema {
     majikdata: MajikIDBSaveData;
 }
-export declare function initDB(): Promise<IDBPDatabase<MajikAutosaveSchema>>;
-export declare function idbSaveBlob(id: string, data: Blob): Promise<void>;
-export declare function idbLoadBlob(id: string): Promise<MajikIDBSaveData | undefined>;
+export declare function initDB(name?: string): Promise<IDBPDatabase<MajikAutosaveSchema>>;
+export declare function idbSaveBlob(id: string, data: Blob, name?: string): Promise<void>;
+export declare function idbLoadBlob(id: string, name?: string): Promise<MajikIDBSaveData | undefined>;
 export declare function deleteBlob(id: string): Promise<void>;
 export declare function clearAllBlobs(): Promise<void>;
 export {};

package/dist/core/utils/idb-majik-system.js

@@ -1,9 +1,10 @@
 // lib/indexedDB.ts
 import { openDB } from "idb";
 let dbPromise;
-export function initDB() {
+export function initDB(name = "default") {
     if (!dbPromise) {
-        dbPromise = openDB("MajikAutosaveDB", 1, {
+        const dbName = `MajikAutosaveDB_${name}`;
+        dbPromise = openDB(dbName, 1, {
             upgrade(db) {
                 if (!db.objectStoreNames.contains("majikdata")) {
                     db.createObjectStore("majikdata", { keyPath: "id" });
@@ -13,13 +14,13 @@ export function initDB() {
     }
     return dbPromise;
 }
-export async function idbSaveBlob(id, data) {
-    const db = await initDB();
+export async function idbSaveBlob(id, data, name = "default") {
+    const db = await initDB(name);
     await db.put("majikdata", { id, data, savedAt: Date.now() });
 }
-export async function idbLoadBlob(id) {
+export async function idbLoadBlob(id, name = "default") {
     try {
-        const db = await initDB();
+        const db = await initDB(name);
         return await db.get("majikdata", id);
     }
     catch (err) {

package/dist/majik-message.d.ts

@@ -27,6 +27,7 @@ export interface MajikMessageJSON {
 }
 type EventCallback = (...args: any[]) => void;
 export declare class MajikMessage {
+    private userProfile;
     private pinHash?;
     private id;
     private contactDirectory;
@@ -38,7 +39,8 @@ export declare class MajikMessage {
     private autosaveTimer;
     private autosaveIntervalMs;
     private autosaveDebounceMs;
-    constructor(config: MajikMessageConfig, id?: string);
+    private unlocked;
+    constructor(config: MajikMessageConfig, id?: string, userProfile?: string);
     /**
      * Create a new account (generates identity via KeyStore) and add it as an own account.
      * Returns the created identity id and a backup blob (base64) that the user should store.
@@ -205,6 +207,7 @@ export declare class MajikMessage {
     ensureIdentityUnlocked(id: string, promptFn?: (identityId: string) => string | Promise<string>): Promise<CryptoKey | {
         raw: Uint8Array;
     }>;
+    isUnlocked(): boolean;
     isPassphraseValid(passphrase: string, id?: string): Promise<boolean>;
     toJSON(): Promise<MajikMessageJSON>;
     static fromJSON<T extends MajikMessage>(this: new (config: MajikMessageConfig, id?: string) => T, json: MajikMessageJSON): Promise<T>;
@@ -228,6 +231,6 @@ export declare class MajikMessage {
     /**
      * Try to load an existing state from IDB; if none exists, create a fresh instance and save it.
      */
-    static loadOrCreate<T extends MajikMessage>(this: MajikMessageStatic<T>, config: MajikMessageConfig): Promise<T>;
+    static loadOrCreate<T extends MajikMessage>(this: MajikMessageStatic<T>, config: MajikMessageConfig, userProfile?: string): Promise<T>;
 }
 export {};

package/dist/majik-message.js

@@ -14,6 +14,7 @@ import { idbLoadBlob, idbSaveBlob } from "./core/utils/idb-majik-system";
 import { MajikMessageChat } from "./core/database/chat/majik-message-chat";
 import { MajikCompressor } from "./core/compressor/majik-compressor";
 export class MajikMessage {
+    userProfile = "default";
     // Optional PIN protection (hashed). If set, UI should prompt for PIN to unlock.
     pinHash = null;
     id;
@@ -26,11 +27,14 @@ export class MajikMessage {
     autosaveTimer = null;
     autosaveIntervalMs = 15000; // periodic backup interval
     autosaveDebounceMs = 500; // debounce for rapid changes
-    constructor(config, id) {
+    unlocked = false;
+    constructor(config, id, userProfile = "default") {
+        this.userProfile = userProfile || "default";
         this.id = id || arrayToBase64(randomBytes(32));
         this.contactDirectory =
             config.contactDirectory || new MajikContactDirectory();
-        this.envelopeCache = config.envelopeCache || new EnvelopeCache();
+        this.envelopeCache =
+            config.envelopeCache || new EnvelopeCache(undefined, userProfile);
         // Initialize scanner
         this.scanner = new ScannerEngine({
             contactDirectory: this.contactDirectory,
@@ -142,6 +146,10 @@ export class MajikMessage {
             if (!this.contactDirectory.hasContact(account.id)) {
                 this.contactDirectory.addContact(account);
             }
+            if (!this.getActiveAccount()) {
+                this.setActiveAccount(account.id);
+                this.unlocked = true;
+            }
         }
         catch (e) {
             // ignore if contact can't be added
@@ -356,44 +364,51 @@ export class MajikMessage {
      * Will prompt to unlock identity if necessary.
      */
     async decryptEnvelope(envelope, bypassIdentity = false) {
-        const fingerprint = envelope.extractFingerprint();
-        const authorizedAccount = this.listContacts(true).find((a) => a.fingerprint === fingerprint);
-        if (!authorizedAccount) {
-            throw new Error("No matching own account to decrypt this envelope");
-        }
-        let privateKey;
-        if (bypassIdentity) {
-            const activeAccount = this.getActiveAccount();
-            if (!activeAccount) {
-                throw new Error("No active account available to bypass identity check");
-            }
-            privateKey = await KeyStore.getPrivateKey(activeAccount.id);
-        }
-        else {
-            privateKey = await this.ensureIdentityUnlocked(authorizedAccount.id);
-        }
-        if (!privateKey) {
-            throw new Error("No private key found for this fingerprint.");
-        }
-        let decrypted;
         if (envelope.isGroup()) {
-            const recipientKey = envelope.getRecipientKey(fingerprint);
-            if (!recipientKey) {
-                throw new Error("No recipient key found for this fingerprint");
+            // Group message - try all own accounts
+            const ownAccounts = this.listOwnAccounts();
+            if (ownAccounts.length === 0) {
+                throw new Error("No own accounts available to decrypt group message");
+            }
+            for (const ownAccount of ownAccounts) {
+                try {
+                    const privateKey = await this.ensureIdentityUnlocked(ownAccount.id);
+                    const decrypted = await EncryptionEngine.decryptGroupMessage(envelope.extractEncryptedPayload(), privateKey, ownAccount.fingerprint);
+                    // Decompress if needed
+                    let plaintext = decrypted;
+                    if (decrypted.startsWith("mjkcmp:")) {
+                        plaintext = (await MajikCompressor.decompress("plaintext", decrypted));
+                    }
+                    await this.envelopeCache.set(envelope, typeof window !== "undefined" && window.location
+                        ? window.location.hostname
+                        : "extension");
+                    return plaintext;
+                }
+                catch (err) {
+                    // This account can't decrypt, try next
+                    continue;
+                }
             }
-            decrypted = await EncryptionEngine.decryptGroupMessage(envelope.extractEncryptedPayload(), privateKey, fingerprint);
+            throw new Error("None of your accounts can decrypt this group message");
         }
         else {
-            decrypted = await EncryptionEngine.decryptSoloMessage(envelope.extractEncryptedPayload(), privateKey);
-        }
-        let plaintext = decrypted;
-        if (decrypted.startsWith("mjkcmp:")) {
-            plaintext = (await MajikCompressor.decompress("plaintext", decrypted));
+            // Solo message - original logic
+            const fingerprint = envelope.extractFingerprint();
+            const ownAccount = this.listOwnAccounts().find((a) => a.fingerprint === fingerprint);
+            if (!ownAccount) {
+                throw new Error("No matching account to decrypt this envelope");
+            }
+            const privateKey = await this.ensureIdentityUnlocked(ownAccount.id);
+            const decrypted = await EncryptionEngine.decryptSoloMessage(envelope.extractEncryptedPayload(), privateKey);
+            let plaintext = decrypted;
+            if (decrypted.startsWith("mjkcmp:")) {
+                plaintext = (await MajikCompressor.decompress("plaintext", decrypted));
+            }
+            await this.envelopeCache.set(envelope, typeof window !== "undefined" && window.location
+                ? window.location.hostname
+                : "extension");
+            return plaintext;
         }
-        await this.envelopeCache.set(envelope, typeof window !== "undefined" && window.location
-            ? window.location.hostname
-            : "extension");
-        return plaintext;
     }
     async importContactFromString(base64Str) {
         const jsonStr = base64ToUtf8(base64Str);
@@ -519,16 +534,20 @@ export class MajikMessage {
         const payloadBytes = new TextEncoder().encode(JSON.stringify(payload));
         // Envelope structure: [version byte][sender fingerprint][payload bytes]
         const versionByte = new Uint8Array([2]);
-        // Use sender fingerprint for group envelope
-        const activeAccount = this.getActiveAccount();
-        if (!activeAccount)
-            throw new Error("No active account to send from");
-        const fingerprintBytes = new Uint8Array(base64ToArrayBuffer(activeAccount.fingerprint));
+        // // Use sender fingerprint for group envelope
+        // const activeAccount = this.getActiveAccount();
+        // if (!activeAccount) throw new Error("No active account to send from");
+        // const fingerprintBytes = new Uint8Array(
+        //   base64ToArrayBuffer(activeAccount.fingerprint),
+        // );
+        // ✅ Use a special marker instead of a specific fingerprint
+        // Option 1: All zeros to indicate "multi-recipient"
+        const markerBytes = new Uint8Array(32).fill(0);
         // Combine all parts into a single Uint8Array
-        const blob = new Uint8Array(versionByte.length + fingerprintBytes.length + payloadBytes.length);
+        const blob = new Uint8Array(versionByte.length + markerBytes.length + payloadBytes.length);
         blob.set(versionByte, 0);
-        blob.set(fingerprintBytes, versionByte.length);
-        blob.set(payloadBytes, versionByte.length + fingerprintBytes.length);
+        blob.set(markerBytes, versionByte.length);
+        blob.set(payloadBytes, versionByte.length + markerBytes.length);
         // Wrap as MessageEnvelope
         const envelope = new MessageEnvelope(blob.buffer);
         if (!!cache) {
@@ -755,38 +774,60 @@ export class MajikMessage {
         if (cached)
             return;
         const fingerprint = envelope.extractFingerprint();
-        // contact is the directory entry (useful for metadata); ownAccount
-        // must match fingerprint for this device to be able to decrypt.
-        const contact = this.contactDirectory.getContactByFingerprint(fingerprint);
-        const ownAccount = this.listOwnAccounts().find((a) => a.fingerprint === fingerprint);
-        // If this envelope isn't addressed to one of our own accounts, mark as untrusted
-        if (!ownAccount) {
-            this.emit("untrusted", envelope);
-            return;
-        }
-        try {
-            // Ensure identity unlocked; try interactive prompt if needed
-            const privateKey = await this.ensureIdentityUnlocked(ownAccount.id);
-            let decrypted;
-            if (envelope.isGroup()) {
-                const recipientKey = envelope.getRecipientKey(fingerprint);
-                if (!recipientKey) {
-                    throw new Error("No recipient key found for this fingerprint");
+        // Check if this is a group message (all zeros or special marker)
+        const isGroupMessage = envelope.isGroup();
+        if (isGroupMessage) {
+            // For group messages, try all own accounts until one works
+            const ownAccounts = this.listOwnAccounts();
+            if (ownAccounts.length === 0) {
+                this.emit("untrusted", envelope);
+                return;
+            }
+            let decrypted = null;
+            let successfulAccount = null;
+            for (const ownAccount of ownAccounts) {
+                try {
+                    const privateKey = await this.ensureIdentityUnlocked(ownAccount.id);
+                    // Try to decrypt with this account
+                    decrypted = await EncryptionEngine.decryptGroupMessage(envelope.extractEncryptedPayload(), privateKey, ownAccount.fingerprint);
+                    successfulAccount = ownAccount;
+                    break; // Success! Stop trying other accounts
+                }
+                catch (err) {
+                    // This account doesn't have access, try next one
+                    continue;
                 }
-                decrypted = await EncryptionEngine.decryptGroupMessage(envelope.extractEncryptedPayload(), privateKey, fingerprint);
             }
-            else {
-                decrypted = await EncryptionEngine.decryptSoloMessage(envelope.extractEncryptedPayload(), privateKey);
+            if (!decrypted || !successfulAccount) {
+                this.emit("untrusted", envelope);
+                return;
             }
-            // Cache envelope (record source as current hostname when available)
+            // Cache and emit
             await this.envelopeCache.set(envelope, typeof window !== "undefined" && window.location
                 ? window.location.hostname
                 : "extension");
             this.scheduleAutosave();
-            this.emit("message", decrypted, envelope, contact);
+            this.emit("message", decrypted, envelope, successfulAccount);
         }
-        catch (err) {
-            this.emit("error", err, { envelope });
+        else {
+            // Solo message - original logic
+            const ownAccount = this.listOwnAccounts().find((a) => a.fingerprint === fingerprint);
+            if (!ownAccount) {
+                this.emit("untrusted", envelope);
+                return;
+            }
+            try {
+                const privateKey = await this.ensureIdentityUnlocked(ownAccount.id);
+                const decrypted = await EncryptionEngine.decryptSoloMessage(envelope.extractEncryptedPayload(), privateKey);
+                await this.envelopeCache.set(envelope, typeof window !== "undefined" && window.location
+                    ? window.location.hostname
+                    : "extension");
+                this.scheduleAutosave();
+                this.emit("message", decrypted, envelope, ownAccount);
+            }
+            catch (err) {
+                this.emit("error", err, { envelope });
+            }
         }
     }
     /**
@@ -817,13 +858,19 @@ export class MajikMessage {
             else if (typeof window !== "undefined" && window.prompt) {
                 passphrase = window.prompt("Enter passphrase to unlock identity:", "");
             }
-            if (!passphrase)
+            if (!passphrase) {
+                this.unlocked = false;
                 throw new Error("Unlock cancelled");
+            }
             // Attempt to unlock
             await KeyStore.unlockIdentity(id, passphrase);
+            this.unlocked = true;
             return await KeyStore.getPrivateKey(id);
         }
     }
+    isUnlocked() {
+        return this.unlocked;
+    }
     async isPassphraseValid(passphrase, id) {
         const target = id ? this.getOwnAccountById(id) : this.getActiveAccount();
         if (!target)
@@ -1023,7 +1070,7 @@ export class MajikMessage {
         try {
             const jsonDocument = await this.toJSON();
             const autosaveBlob = autoSaveMajikFileData(jsonDocument);
-            await idbSaveBlob("majik-message-state", autosaveBlob);
+            await idbSaveBlob("majik-message-state", autosaveBlob, this.userProfile);
         }
         catch (err) {
             console.error("Failed to save MajikMessage state:", err);
@@ -1032,7 +1079,7 @@ export class MajikMessage {
     /** Load state from IndexedDB and apply to this instance. */
     async loadState() {
         try {
-            const autosaveData = await idbLoadBlob("majik-message-state");
+            const autosaveData = await idbLoadBlob("majik-message-state", this.userProfile);
             if (!autosaveData?.data)
                 return;
             const blobFile = autosaveData.data;
@@ -1053,9 +1100,9 @@ export class MajikMessage {
     /**
      * Try to load an existing state from IDB; if none exists, create a fresh instance and save it.
      */
-    static async loadOrCreate(config) {
+    static async loadOrCreate(config, userProfile = "default") {
         try {
-            const saved = await idbLoadBlob("majik-message-state");
+            const saved = await idbLoadBlob("majik-message-state", userProfile);
             if (saved?.data) {
                 const loaded = await loadSavedMajikFileData(saved.data);
                 const parsedJSON = loaded.j;

package/package.json

@@ -2,7 +2,7 @@
   "name": "@thezelijah/majik-message",
   "type": "module",
   "description": "Encrypt and decrypt messages on any website. Secure chats with keypairs and seed-based accounts. Open source.",
-  "version": "1.0.17",
+  "version": "1.0.18",
   "license": "Apache-2.0",
   "author": "Zelijah",
   "main": "./dist/index.js",