myceliumail 1.0.2 → 1.0.3

package/mcp-server/package.json

@@ -0,0 +1,49 @@
+{
+    "name": "myceliumail-mcp",
+    "version": "1.0.7",
+    "description": "MCP server for Myceliumail - End-to-End Encrypted Messaging for AI Agents",
+    "type": "module",
+    "main": "dist/server.js",
+    "bin": {
+        "myceliumail-mcp": "./dist/server.js"
+    },
+    "scripts": {
+        "build": "tsc",
+        "dev": "tsc --watch",
+        "start": "node dist/server.js",
+        "prepublishOnly": "npm run build"
+    },
+    "keywords": [
+        "mcp",
+        "model-context-protocol",
+        "claude",
+        "ai-agents",
+        "messaging",
+        "encrypted",
+        "e2e",
+        "myceliumail"
+    ],
+    "author": "Treebird",
+    "license": "MIT",
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/treebird/myceliumail"
+    },
+    "homepage": "https://github.com/treebird/myceliumail#readme",
+    "bugs": {
+        "url": "https://github.com/treebird/myceliumail/issues"
+    },
+    "dependencies": {
+        "@modelcontextprotocol/sdk": "^1.0.0",
+        "tweetnacl": "^1.0.3",
+        "tweetnacl-util": "^0.15.1",
+        "zod": "^3.22.0"
+    },
+    "devDependencies": {
+        "@types/node": "^20.10.0",
+        "typescript": "^5.3.0"
+    },
+    "engines": {
+        "node": ">=18.0.0"
+    }
+}

package/mcp-server/src/lib/config.ts

@@ -0,0 +1,55 @@
+/**
+ * Myceliumail MCP - Config Module
+ * 
+ * Reads configuration from:
+ * 1. Environment variables (highest priority)
+ * 2. ~/.myceliumail/config.json (fallback)
+ */
+
+import { existsSync, readFileSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+
+const CONFIG_FILE = join(homedir(), '.myceliumail', 'config.json');
+
+interface FileConfig {
+    agent_id?: string;
+    supabase_url?: string;
+    supabase_key?: string;
+}
+
+let cachedFileConfig: FileConfig | null = null;
+
+function loadFileConfig(): FileConfig {
+    if (cachedFileConfig) return cachedFileConfig;
+
+    if (existsSync(CONFIG_FILE)) {
+        try {
+            const raw = readFileSync(CONFIG_FILE, 'utf-8');
+            cachedFileConfig = JSON.parse(raw);
+            return cachedFileConfig!;
+        } catch {
+            // Invalid config file - ignore
+        }
+    }
+    return {};
+}
+
+export function getAgentId(): string {
+    return process.env.MYCELIUMAIL_AGENT_ID ||
+        process.env.MYCELIUMAIL_AGENT ||
+        loadFileConfig().agent_id ||
+        'anonymous';
+}
+
+export function getSupabaseUrl(): string | undefined {
+    return process.env.SUPABASE_URL || loadFileConfig().supabase_url;
+}
+
+export function getSupabaseKey(): string | undefined {
+    return process.env.SUPABASE_ANON_KEY || loadFileConfig().supabase_key;
+}
+
+export function hasSupabase(): boolean {
+    return !!(getSupabaseUrl() && getSupabaseKey());
+}

package/mcp-server/src/lib/crypto.ts

@@ -0,0 +1,150 @@
+/**
+ * Myceliumail MCP - Crypto Module
+ * 
+ * NaCl encryption for agent messaging.
+ */
+
+import nacl from 'tweetnacl';
+import util from 'tweetnacl-util';
+import { existsSync, mkdirSync, readFileSync, writeFileSync, readdirSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+
+const KEYS_DIR = join(homedir(), '.myceliumail', 'keys');
+
+export interface KeyPair {
+    publicKey: Uint8Array;
+    secretKey: Uint8Array;
+}
+
+export interface EncryptedMessage {
+    ciphertext: string;
+    nonce: string;
+    senderPublicKey: string;
+}
+
+function ensureKeysDir(): void {
+    if (!existsSync(KEYS_DIR)) {
+        mkdirSync(KEYS_DIR, { recursive: true });
+    }
+}
+
+export function generateKeyPair(): KeyPair {
+    return nacl.box.keyPair();
+}
+
+export function saveKeyPair(agentId: string, keyPair: KeyPair): void {
+    ensureKeysDir();
+    const serialized = {
+        publicKey: util.encodeBase64(keyPair.publicKey),
+        secretKey: util.encodeBase64(keyPair.secretKey),
+    };
+    const path = join(KEYS_DIR, `${agentId}.key.json`);
+    writeFileSync(path, JSON.stringify(serialized, null, 2), { mode: 0o600 });
+}
+
+export function loadKeyPair(agentId: string): KeyPair | null {
+    const path = join(KEYS_DIR, `${agentId}.key.json`);
+    if (!existsSync(path)) return null;
+
+    try {
+        const data = JSON.parse(readFileSync(path, 'utf-8'));
+        return {
+            publicKey: util.decodeBase64(data.publicKey),
+            secretKey: util.decodeBase64(data.secretKey),
+        };
+    } catch {
+        return null;
+    }
+}
+
+export function hasKeyPair(agentId: string): boolean {
+    return existsSync(join(KEYS_DIR, `${agentId}.key.json`));
+}
+
+export function getPublicKeyBase64(keyPair: KeyPair): string {
+    return util.encodeBase64(keyPair.publicKey);
+}
+
+export function encryptMessage(
+    message: string,
+    recipientPublicKey: Uint8Array,
+    senderKeyPair: KeyPair
+): EncryptedMessage {
+    const messageBytes = util.decodeUTF8(message);
+    const nonce = nacl.randomBytes(nacl.box.nonceLength);
+
+    const ciphertext = nacl.box(
+        messageBytes,
+        nonce,
+        recipientPublicKey,
+        senderKeyPair.secretKey
+    );
+
+    return {
+        ciphertext: util.encodeBase64(ciphertext),
+        nonce: util.encodeBase64(nonce),
+        senderPublicKey: util.encodeBase64(senderKeyPair.publicKey),
+    };
+}
+
+export function decryptMessage(
+    encrypted: EncryptedMessage,
+    recipientKeyPair: KeyPair
+): string | null {
+    try {
+        const ciphertext = util.decodeBase64(encrypted.ciphertext);
+        const nonce = util.decodeBase64(encrypted.nonce);
+        const senderPublicKey = util.decodeBase64(encrypted.senderPublicKey);
+
+        const decrypted = nacl.box.open(
+            ciphertext,
+            nonce,
+            senderPublicKey,
+            recipientKeyPair.secretKey
+        );
+
+        if (!decrypted) return null;
+        return util.encodeUTF8(decrypted);
+    } catch {
+        return null;
+    }
+}
+
+export function loadKnownKeys(): Record<string, string> {
+    const path = join(KEYS_DIR, 'known_keys.json');
+    if (!existsSync(path)) return {};
+    try {
+        return JSON.parse(readFileSync(path, 'utf-8'));
+    } catch {
+        return {};
+    }
+}
+
+export function saveKnownKey(agentId: string, publicKeyBase64: string): void {
+    ensureKeysDir();
+    const keys = loadKnownKeys();
+    keys[agentId] = publicKeyBase64;
+    writeFileSync(join(KEYS_DIR, 'known_keys.json'), JSON.stringify(keys, null, 2));
+}
+
+export function getKnownKey(agentId: string): string | null {
+    const keys = loadKnownKeys();
+    return keys[agentId] || null;
+}
+
+export function listOwnKeys(): string[] {
+    ensureKeysDir();
+    try {
+        const files = readdirSync(KEYS_DIR);
+        return files
+            .filter(f => f.endsWith('.key.json'))
+            .map(f => f.replace('.key.json', ''));
+    } catch {
+        return [];
+    }
+}
+
+export function decodePublicKey(base64: string): Uint8Array {
+    return util.decodeBase64(base64);
+}

package/mcp-server/src/lib/storage.ts

@@ -0,0 +1,267 @@
+/**
+ * Myceliumail MCP - Storage Module
+ * 
+ * Local JSON storage with optional Supabase sync.
+ */
+
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+import { randomUUID } from 'crypto';
+import { getSupabaseUrl, getSupabaseKey, hasSupabase } from './config.js';
+
+const DATA_DIR = join(homedir(), '.myceliumail', 'data');
+const MESSAGES_FILE = join(DATA_DIR, 'messages.json');
+
+export interface Message {
+    id: string;
+    sender: string;
+    recipient: string;
+    subject: string;
+    body: string;
+    encrypted: boolean;
+    ciphertext?: string;
+    nonce?: string;
+    senderPublicKey?: string;
+    read: boolean;
+    archived: boolean;
+    createdAt: Date;
+}
+
+interface StoredMessage extends Omit<Message, 'createdAt'> {
+    createdAt: string;
+}
+
+function ensureDataDir(): void {
+    if (!existsSync(DATA_DIR)) {
+        mkdirSync(DATA_DIR, { recursive: true });
+    }
+}
+
+function loadLocalMessages(): StoredMessage[] {
+    if (!existsSync(MESSAGES_FILE)) return [];
+    try {
+        return JSON.parse(readFileSync(MESSAGES_FILE, 'utf-8'));
+    } catch {
+        return [];
+    }
+}
+
+function saveLocalMessages(messages: StoredMessage[]): void {
+    ensureDataDir();
+    writeFileSync(MESSAGES_FILE, JSON.stringify(messages, null, 2));
+}
+
+function toMessage(stored: StoredMessage): Message {
+    return { ...stored, createdAt: new Date(stored.createdAt) };
+}
+
+// Supabase helpers
+async function supabaseRequest<T>(path: string, options: RequestInit = {}): Promise<T> {
+    const url = `${getSupabaseUrl()}/rest/v1${path}`;
+
+    const response = await fetch(url, {
+        ...options,
+        headers: {
+            'Content-Type': 'application/json',
+            'apikey': getSupabaseKey()!,
+            'Authorization': `Bearer ${getSupabaseKey()}`,
+            'Prefer': options.method === 'POST' ? 'return=representation' : 'return=minimal',
+            ...options.headers,
+        },
+    });
+
+    if (!response.ok) {
+        const text = await response.text();
+        console.error(`Supabase request failed (${response.status}): ${text}`);
+        throw new Error(text);
+    }
+
+    if (response.status === 204) return {} as T;
+    return response.json() as Promise<T>;
+}
+
+export async function sendMessage(
+    sender: string,
+    recipient: string,
+    subject: string,
+    body: string,
+    options?: {
+        encrypted?: boolean;
+        ciphertext?: string;
+        nonce?: string;
+        senderPublicKey?: string;
+    }
+): Promise<Message> {
+    const newMessage: StoredMessage = {
+        id: randomUUID(),
+        sender,
+        recipient,
+        subject: options?.encrypted ? '' : subject,
+        body: options?.encrypted ? '' : body,
+        encrypted: options?.encrypted || false,
+        ciphertext: options?.ciphertext,
+        nonce: options?.nonce,
+        senderPublicKey: options?.senderPublicKey,
+        read: false,
+        archived: false,
+        createdAt: new Date().toISOString(),
+    };
+
+    if (hasSupabase()) {
+        try {
+            const [result] = await supabaseRequest<StoredMessage[]>('/agent_messages', {
+                method: 'POST',
+                body: JSON.stringify({
+                    from_agent: newMessage.sender,
+                    to_agent: newMessage.recipient,
+                    subject: newMessage.subject || null,
+                    message: newMessage.body || null,
+                    encrypted: newMessage.encrypted,
+                    ciphertext: newMessage.ciphertext,
+                    nonce: newMessage.nonce,
+                    sender_public_key: newMessage.senderPublicKey,
+                }),
+            });
+            return toMessage({
+                ...newMessage,
+                id: (result as unknown as { id: string }).id
+            });
+        } catch (err) {
+            console.error('sendMessage failed, falling back to local:', err);
+            // Fall through to local
+        }
+    }
+
+    // Local storage
+    const messages = loadLocalMessages();
+    messages.push(newMessage);
+    saveLocalMessages(messages);
+    return toMessage(newMessage);
+}
+
+export async function getInbox(
+    agentId: string,
+    options?: { unreadOnly?: boolean; limit?: number }
+): Promise<Message[]> {
+    if (hasSupabase()) {
+        try {
+            let query = `/agent_messages?to_agent=eq.${agentId}&order=created_at.desc`;
+            if (options?.unreadOnly) query += '&read=eq.false';
+            if (options?.limit) query += `&limit=${options.limit}`;
+
+            const results = await supabaseRequest<Array<{
+                id: string; from_agent: string; to_agent: string;
+                subject: string; message: string; encrypted: boolean;
+                ciphertext: string; nonce: string; sender_public_key: string;
+                read: boolean; created_at: string;
+            }>>(query);
+
+            return results.map(r => ({
+                id: r.id,
+                sender: r.from_agent,
+                recipient: r.to_agent,
+                subject: r.subject || '',
+                body: r.message || '',
+                encrypted: r.encrypted,
+                ciphertext: r.ciphertext,
+                nonce: r.nonce,
+                senderPublicKey: r.sender_public_key,
+                read: r.read,
+                archived: false,
+                createdAt: new Date(r.created_at),
+            }));
+        } catch (err) {
+            console.error('getInbox failed, falling back to local:', err);
+            // Fall through to local
+        }
+    }
+
+    // Local storage
+    const messages = loadLocalMessages();
+    let filtered = messages.filter(m => m.recipient === agentId && !m.archived);
+    if (options?.unreadOnly) filtered = filtered.filter(m => !m.read);
+    filtered.sort((a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime());
+    if (options?.limit) filtered = filtered.slice(0, options.limit);
+    return filtered.map(toMessage);
+}
+
+export async function getMessage(id: string): Promise<Message | null> {
+    if (hasSupabase()) {
+        try {
+            const results = await supabaseRequest<Array<{
+                id: string; from_agent: string; to_agent: string;
+                subject: string; message: string; encrypted: boolean;
+                ciphertext: string; nonce: string; sender_public_key: string;
+                read: boolean; created_at: string;
+            }>>(`/agent_messages?id=eq.${id}`);
+
+            if (results.length > 0) {
+                const r = results[0];
+                return {
+                    id: r.id,
+                    sender: r.from_agent,
+                    recipient: r.to_agent,
+                    subject: r.subject || '',
+                    body: r.message || '',
+                    encrypted: r.encrypted,
+                    ciphertext: r.ciphertext,
+                    nonce: r.nonce,
+                    senderPublicKey: r.sender_public_key,
+                    read: r.read,
+                    archived: false,
+                    createdAt: new Date(r.created_at),
+                };
+            }
+        } catch (err) {
+            console.error('getMessage failed, falling back to local:', err);
+            // Fall through
+        }
+    }
+
+    const messages = loadLocalMessages();
+    const found = messages.find(m => m.id === id);
+    return found ? toMessage(found) : null;
+}
+
+export async function markAsRead(id: string): Promise<boolean> {
+    if (hasSupabase()) {
+        try {
+            await supabaseRequest(`/agent_messages?id=eq.${id}`, {
+                method: 'PATCH',
+                body: JSON.stringify({ read: true }),
+            });
+            return true;
+        } catch {
+            // Fall through
+        }
+    }
+
+    const messages = loadLocalMessages();
+    const idx = messages.findIndex(m => m.id === id);
+    if (idx === -1) return false;
+    messages[idx].read = true;
+    saveLocalMessages(messages);
+    return true;
+}
+
+export async function archiveMessage(id: string): Promise<boolean> {
+    if (hasSupabase()) {
+        try {
+            await supabaseRequest(`/agent_messages?id=eq.${id}`, {
+                method: 'PATCH',
+                body: JSON.stringify({ archived: true }),
+            });
+            return true;
+        } catch {
+            // Fall through
+        }
+    }
+
+    const messages = loadLocalMessages();
+    const idx = messages.findIndex(m => m.id === id);
+    if (idx === -1) return false;
+    messages[idx].archived = true;
+    saveLocalMessages(messages);
+    return true;
+}