@thezelijah/majik-message 1.0.0

package/dist/core/utils/majik-file-utils.js

@@ -0,0 +1,153 @@
+import APITranscoder from "./APITranscoder";
+export async function importMajikFileData(file) {
+    if (!file)
+        throw new Error("Invalid file.");
+    if (!file.name.endsWith(".mjkb")) {
+        throw new Error("Oops! Only .mjkb files are allowed. Please load a valid MajikFile.");
+    }
+    try {
+        // Step 1: Read as base64 text
+        const base64String = (await readBlobFile(file));
+        // Step 2: base64 → JSON
+        const jsonString = base64DecodeUtf8(base64String);
+        const parsedData = JSON.parse(jsonString);
+        // Step 3: Decrypt
+        const decryptedData = APITranscoder.decryptPayload(parsedData);
+        return decryptedData;
+    }
+    catch (error) {
+        console.error("Import Error:", error);
+        throw new Error("Failed to import and decrypt .mjkb file.");
+    }
+}
+export async function loadSavedMajikFileData(file) {
+    try {
+        const content = await readBlobFile(file);
+        // Step 2: base64 → UTF-8 JSON string
+        const jsonString = base64DecodeUtf8(content);
+        // Step 3: Parse encrypted payload
+        const parsedData = JSON.parse(jsonString);
+        const decryptedData = APITranscoder.decryptPayload(parsedData);
+        const MajikFileData = decryptedData;
+        return MajikFileData;
+    }
+    catch (error) {
+        console.error("Loading Autosaved File Error: ", error);
+        throw new Error("Failed to load autosaved .MajikFile file.");
+    }
+}
+export function autoSaveMajikFileData(json, version = "1.0.0") {
+    const rawData = {
+        j: json,
+        s: secureTimecode(),
+        v: version,
+    };
+    const generatedRQC = APITranscoder.generateRQC();
+    const encryptedData = APITranscoder.encryptPayload(rawData, generatedRQC);
+    const dataString = JSON.stringify(encryptedData);
+    // 🔐 Convert JSON string to base64
+    const base64Encoded = base64EncodeUtf8(dataString);
+    const blobData = prepareToBlobFile(base64Encoded);
+    return blobData;
+}
+export function exportMajikFileData(json, name, version = "1.0.0") {
+    const rawData = {
+        j: json,
+        s: secureTimecode(),
+        v: version,
+    };
+    const generatedRQC = APITranscoder.generateRQC();
+    const encryptedData = APITranscoder.encryptPayload(rawData, generatedRQC);
+    const dataString = JSON.stringify(encryptedData);
+    // 🔐 Convert JSON string to base64
+    const base64Encoded = base64EncodeUtf8(dataString);
+    const blobData = prepareToBlobFile(base64Encoded);
+    downloadBlob(blobData, "MajikFile", name);
+}
+// Prepare Blob file from various input types
+export function prepareToBlobFile(data) {
+    return new Blob([data], { type: "text/plain" });
+}
+// Download Blob file
+function downloadBlob(blob, filetype, fileName) {
+    const file = new File([blob], `${fileName}.${filetype}`, { type: blob.type });
+    const tryShare = async () => {
+        if (typeof navigator !== "undefined" &&
+            navigator.canShare &&
+            navigator.canShare({ files: [file] })) {
+            try {
+                await navigator.share({
+                    files: [file],
+                    title: fileName,
+                    text: `Download ${fileName}.${filetype}`,
+                });
+                return;
+            }
+            catch (error) {
+                console.warn("Share not supported in desktop:", error);
+                // Fallback continues
+            }
+        }
+        // Fallback to download
+        const url = URL.createObjectURL(blob);
+        const a = document.createElement("a");
+        a.href = url;
+        a.download = `${fileName}.${filetype}`;
+        document.body.appendChild(a);
+        a.click();
+        document.body.removeChild(a);
+        URL.revokeObjectURL(url);
+    };
+    // Ensure it's wrapped in a user-triggered event like a button click
+    void tryShare();
+}
+// Read Blob file and decode its content
+function readBlobFile(blob) {
+    return new Promise((resolve, reject) => {
+        const reader = new FileReader();
+        reader.onload = () => resolve(reader.result);
+        reader.onerror = () => reject(new Error("Error reading file"));
+        reader.readAsText(blob);
+    });
+}
+/**
+ * Converts a Unix timestamp, Date object, ISO string, or null/undefined into a secure Base64 string.
+ * Defaults to the current time if input is null or undefined.
+ *
+ * @param {(number | Date | string | null | undefined)} input - The time input.
+ * @returns {string} A secure Base64 encoded string generated from the timestamp.
+ * @throws {Error} Throws an error if the input is not a valid time format.
+ */
+function secureTimecode(input) {
+    const unixTimestamp = (() => {
+        if (input === null || input === undefined)
+            return Math.floor(Date.now() / 1000);
+        if (typeof input === "number")
+            return input;
+        if (input instanceof Date)
+            return Math.floor(input.getTime() / 1000);
+        if (typeof input === "string")
+            return Math.floor(new Date(input).getTime() / 1000);
+        throw new Error("Invalid input type. Must be Unix timestamp, Date object, or ISO string.");
+    })();
+    const unixArray = Array.from(String(unixTimestamp), Number);
+    const reversedArray = [...unixArray].reverse();
+    const invertedArray = [];
+    for (let i = 0; i < unixArray.length; i++) {
+        invertedArray.push(unixArray[i], reversedArray[i]);
+    }
+    return btoa(String.fromCharCode(...invertedArray));
+}
+export function base64EncodeUtf8(str) {
+    const bytes = new TextEncoder().encode(str);
+    let binary = "";
+    bytes.forEach((b) => {
+        binary += String.fromCharCode(b);
+    });
+    return btoa(binary);
+}
+export function base64DecodeUtf8(base64) {
+    const binary = atob(base64);
+    const bytes = Uint8Array.from(binary, (c) => c.charCodeAt(0));
+    return new TextDecoder().decode(bytes);
+}

package/dist/core/utils/utilities.d.ts

@@ -0,0 +1,22 @@
+export declare function arrayToBase64(data: Uint8Array): string;
+export declare function base64ToUint8Array(base64: string): Uint8Array;
+export declare function arrayBufferToBase64(buffer: ArrayBuffer): string;
+export declare function base64ToArrayBuffer(base64: string): ArrayBuffer;
+export declare function base64ToUtf8(base64: string): string;
+export declare function utf8ToBase64(str: string): string;
+export declare function concatArrayBuffers(a: ArrayBuffer, b: ArrayBuffer): ArrayBuffer;
+export declare function concatUint8Arrays(a: Uint8Array, b: Uint8Array): Uint8Array;
+export interface MnemonicJSON {
+    seed: string[];
+    id: string;
+    phrase?: string;
+}
+/**
+ * Converts a space-separated seed phrase string into MnemonicJSON
+ */
+export declare function seedToJSON(seed: string, id: string, phrase?: string): MnemonicJSON;
+/**
+ * Converts MnemonicJSON into a single space-separated string
+ */
+export declare function jsonToSeed(json: MnemonicJSON): string;
+export declare function seedStringToArray(seed: string): string[];

package/dist/core/utils/utilities.js

@@ -0,0 +1,80 @@
+/* ================================
+ * Utilities
+ * ================================ */
+// utils/utilities.ts
+export function arrayToBase64(data) {
+    let binary = "";
+    const bytes = data;
+    const len = bytes.byteLength;
+    for (let i = 0; i < len; i++) {
+        binary += String.fromCharCode(bytes[i]);
+    }
+    return btoa(binary);
+}
+export function base64ToUint8Array(base64) {
+    return new Uint8Array(base64ToArrayBuffer(base64));
+}
+export function arrayBufferToBase64(buffer) {
+    const bytes = new Uint8Array(buffer);
+    let binary = "";
+    const chunkSize = 0x8000;
+    for (let i = 0; i < bytes.length; i += chunkSize) {
+        binary += String.fromCharCode(...bytes.subarray(i, i + chunkSize));
+    }
+    return btoa(binary);
+}
+export function base64ToArrayBuffer(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.buffer;
+}
+export function base64ToUtf8(base64) {
+    const buf = base64ToArrayBuffer(base64);
+    return new TextDecoder().decode(new Uint8Array(buf));
+}
+export function utf8ToBase64(str) {
+    const bytes = new TextEncoder().encode(str);
+    return arrayBufferToBase64(bytes.buffer);
+}
+export function concatArrayBuffers(a, b) {
+    const tmp = new Uint8Array(a.byteLength + b.byteLength);
+    tmp.set(new Uint8Array(a), 0);
+    tmp.set(new Uint8Array(b), a.byteLength);
+    return tmp.buffer;
+}
+export function concatUint8Arrays(a, b) {
+    const out = new Uint8Array(a.byteLength + b.byteLength);
+    out.set(a, 0);
+    out.set(b, a.byteLength);
+    return out;
+}
+/**
+ * Converts a space-separated seed phrase string into MnemonicJSON
+ */
+export function seedToJSON(seed, id, phrase) {
+    return {
+        seed: seed
+            .trim()
+            .split(/\s+/)
+            .map((w) => w.toLowerCase())
+            .filter(Boolean),
+        id,
+        phrase,
+    };
+}
+/**
+ * Converts MnemonicJSON into a single space-separated string
+ */
+export function jsonToSeed(json) {
+    return json.seed.join(" ");
+}
+export function seedStringToArray(seed) {
+    return seed
+        .trim()
+        .split(/\s+/)
+        .map((w) => w.toLowerCase())
+        .filter(Boolean);
+}

package/dist/index.d.ts

@@ -0,0 +1,13 @@
+export * from "./majik-message";
+export type * from "./core/types";
+export * from "./core/contacts/majik-contact";
+export * from "./core/contacts/majik-contact-directory";
+export * from "./core/crypto/constants";
+export * from "./core/crypto/crypto-provider";
+export * from "./core/crypto/encryption-engine";
+export * from "./core/crypto/keystore";
+export * from "./core/messages/message-envelope";
+export * from "./core/messages/envelope-cache";
+export * from "./core/scanner/scanner-engine";
+export * from "./core/utils/APITranscoder";
+export * from "./core/utils/utilities";

package/dist/index.js

@@ -0,0 +1,12 @@
+export * from "./majik-message";
+export * from "./core/contacts/majik-contact";
+export * from "./core/contacts/majik-contact-directory";
+export * from "./core/crypto/constants";
+export * from "./core/crypto/crypto-provider";
+export * from "./core/crypto/encryption-engine";
+export * from "./core/crypto/keystore";
+export * from "./core/messages/message-envelope";
+export * from "./core/messages/envelope-cache";
+export * from "./core/scanner/scanner-engine";
+export * from "./core/utils/APITranscoder";
+export * from "./core/utils/utilities";

package/dist/majik-message.d.ts

@@ -0,0 +1,202 @@
+import { MajikContact, type MajikContactMeta, type SerializedMajikContact } from "./core/contacts/majik-contact";
+import { MessageEnvelope } from "./core/messages/message-envelope";
+import { EnvelopeCache, type EnvelopeCacheItem, type EnvelopeCacheJSON } from "./core/messages/envelope-cache";
+import { KeyStore } from "./core/crypto/keystore";
+import { MajikContactDirectory, type MajikContactDirectoryData } from "./core/contacts/majik-contact-directory";
+import type { MAJIK_API_RESPONSE } from "./core/types";
+type MajikMessageEvents = "message" | "envelope" | "untrusted" | "error";
+export interface MajikMessageConfig {
+    keyStore: KeyStore;
+    contactDirectory?: MajikContactDirectory;
+    envelopeCache?: EnvelopeCache;
+}
+export interface MajikMessageJSON {
+    id: string;
+    contacts: MajikContactDirectoryData;
+    envelopeCache: EnvelopeCacheJSON;
+    ownAccounts?: {
+        accounts: SerializedMajikContact[];
+        order: string[];
+    };
+}
+type EventCallback = (...args: any[]) => void;
+export declare class MajikMessage {
+    private pinHash?;
+    private id;
+    private contactDirectory;
+    private envelopeCache;
+    private scanner;
+    private listeners;
+    private ownAccounts;
+    private ownAccountsOrder;
+    private autosaveTimer;
+    private autosaveIntervalMs;
+    private autosaveDebounceMs;
+    constructor(config: MajikMessageConfig, id?: 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.
+     */
+    createAccount(passphrase: string, label?: string): Promise<{
+        id: string;
+        fingerprint: string;
+        backup: string;
+    }>;
+    /**
+     * Import an account from a backup blob (created with `exportIdentityBackup`) and unlock it.
+     */
+    importAccountFromBackup(backupBase64: string, passphrase: string, label?: string): Promise<{
+        id: string;
+        fingerprint: string;
+    }>;
+    /**
+     * Generate a BIP39 mnemonic for backup (12 words by default).
+     */
+    generateMnemonic(): string;
+    /**
+     * Export a mnemonic-encrypted backup for an unlocked identity.
+     */
+    exportAccountMnemonicBackup(id: string, mnemonic: string): Promise<string>;
+    /**
+     * Import an account from a mnemonic-encrypted backup blob and store it using `passphrase`.
+     */
+    importAccountFromMnemonicBackup(backupBase64: string, mnemonic: string, passphrase: string, label?: string): Promise<{
+        id: string;
+        fingerprint: string;
+    }>;
+    /**
+     * Create a new account deterministically from `mnemonic` and store it encrypted with `passphrase`.
+     * Returns the created identity id (which equals fingerprint) and fingerprint.
+     */
+    createAccountFromMnemonic(mnemonic: string, passphrase: string, label?: string): Promise<{
+        id: string;
+        fingerprint: string;
+        backup: string;
+    }>;
+    addOwnAccount(account: MajikContact): void;
+    listOwnAccounts(): MajikContact[];
+    getOwnAccountById(id: string): MajikContact | undefined;
+    /**
+     * Set an active account (moves it to index 0)
+     */
+    setActiveAccount(id: string): boolean;
+    getActiveAccount(): MajikContact | null;
+    isAccountActive(id: string): boolean;
+    /**
+     * Remove an own account from the in-memory registry.
+     */
+    removeOwnAccount(id: string): boolean;
+    /**
+     * Retrieve a contact from the directory by ID.
+     * Validates that the input is a non-empty string.
+     * Returns the MajikContact instance or null if not found.
+     */
+    getContactByID(id: string): MajikContact | null;
+    /**
+     * Returns a JSON string representation of a contact
+     * suitable for sharing.
+     */
+    exportContactAsJSON(contactId: string): Promise<string | null>;
+    /**
+     * Returns a compact base64 string for sharing a contact.
+     * Encodes JSON payload into base64.
+     */
+    exportContactAsString(contactId: string): Promise<string | null>;
+    importContactFromJSON(jsonStr: string): Promise<MAJIK_API_RESPONSE>;
+    /**
+     * List cached envelopes stored in the local cache (most recent first).
+     * Returns objects: { id, envelope, timestamp, source }
+     */
+    listCachedEnvelopes(offset?: number, limit?: number): Promise<EnvelopeCacheItem[]>;
+    /**
+     * Clear cached envelopes stored in the local cache.
+     */
+    clearCachedEnvelopes(): Promise<boolean>;
+    hasOwnIdentity(fingerprint: string): Promise<boolean>;
+    /**
+     * Attempt to decrypt a given envelope and return the plaintext string.
+     * Will prompt to unlock identity if necessary.
+     */
+    decryptEnvelope(envelope: MessageEnvelope, bypassIdentity?: boolean): Promise<string>;
+    importContactFromString(base64Str: string): Promise<void>;
+    addContact(contact: MajikContact): void;
+    removeContact(id: string): void;
+    updateContactMeta(id: string, meta: Partial<MajikContactMeta>): void;
+    blockContact(id: string): void;
+    unblockContact(id: string): void;
+    listContacts(all?: boolean): MajikContact[];
+    /**
+     * Update the passphrase for an identity.
+     * - `id` defaults to the current active account if not provided.
+     * - Throws if no active account exists or passphrase is invalid.
+     */
+    updatePassphrase(currentPassphrase: string, newPassphrase: string, id?: string): Promise<void>;
+    /**
+     * Encrypts a plaintext message for a single recipient (solo message)
+     * Returns a MessageEnvelope instance and caches it automatically.
+     */
+    encryptSoloMessage(toId: string, plaintext: string, cache?: boolean): Promise<MessageEnvelope>;
+    /**
+     * Encrypts a plaintext message for a group of recipients.
+     * Returns a unified group MessageEnvelope instance.
+     */
+    encryptGroupMessage(recipientIds: string[], plaintext: string, cache?: boolean): Promise<MessageEnvelope>;
+    sendMessage(recipients: string[], plaintext: string): Promise<MessageEnvelope>;
+    /**
+     * Encrypts currently selected text in the browser DOM for given recipients.
+     * If `recipients` is empty, defaults to the first own account.
+     * Returns the fully serialized base64 envelope string for the scanner.
+     */
+    encryptSelectedTextForScanner(recipients?: string[]): Promise<string | null>;
+    /**
+     * Encrypt a provided plaintext string and return a serialized MajikMessage envelope string.
+     * Supports single or multiple recipients. Safe to call from background contexts.
+     */
+    encryptTextForScanner(plaintext: string, recipients?: string[], cache?: boolean): Promise<string | null>;
+    /**
+     * Encrypt text for a given target (label or ID).
+     * - If target is self or not found, just encrypt normally.
+     * - If target is another contact, always make a group message including self + target.
+     */
+    encryptForTarget(target: string, // can be label or id
+    plaintext: string): Promise<string | null>;
+    scanDOM(rootNode: Node): void;
+    startDOMObserver(rootNode: Node): void;
+    stopDOMObserver(): void;
+    on(event: MajikMessageEvents, callback: EventCallback): void;
+    private emit;
+    private handleEnvelope;
+    /**
+     * Ensure an identity is unlocked. If locked, prompt the user for a passphrase.
+     * `promptFn` can be provided to show a custom UI: either synchronous returning string
+     * or async Promise<string>. If omitted, falls back to `window.prompt`.
+     */
+    ensureIdentityUnlocked(id: string, promptFn?: (identityId: string) => string | Promise<string>): Promise<CryptoKey | {
+        raw: Uint8Array;
+    }>;
+    isPassphraseValid(passphrase: string, id?: string): Promise<boolean>;
+    toJSON(): Promise<MajikMessageJSON>;
+    static fromJSON(json: MajikMessageJSON): Promise<MajikMessage>;
+    /**
+     * Set a PIN (stores hash). Passphrase is any string; we store SHA-256(base64) of it.
+     */
+    setPIN(pin: string): Promise<void>;
+    clearPIN(): Promise<void>;
+    isValidPIN(pin: string): Promise<boolean>;
+    getPinHash(): string | null;
+    private static hashPIN;
+    private autosaveIntervalId;
+    private attachAutosaveHandlers;
+    startAutosave(): void;
+    stopAutosave(): void;
+    private scheduleAutosave;
+    /** Save current state into IndexedDB (autosave). */
+    saveState(): Promise<void>;
+    /** Load state from IndexedDB and apply to this instance. */
+    loadState(): Promise<void>;
+    /**
+     * Try to load an existing state from IDB; if none exists, create a fresh instance and save it.
+     */
+    static loadOrCreate(config: MajikMessageConfig): Promise<MajikMessage>;
+}
+export {};