myceliumail 1.0.2 → 1.0.4

package/mcp-server/src/server.ts

@@ -0,0 +1,387 @@
+#!/usr/bin/env node
+
+/**
+ * Myceliumail MCP Server
+ * 
+ * Exposes Myceliumail messaging as MCP tools for Claude Desktop
+ * and other MCP-compatible clients.
+ */
+
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { z } from 'zod';
+
+import * as crypto from './lib/crypto.js';
+import * as storage from './lib/storage.js';
+import { getAgentId } from './lib/config.js';
+
+// Create the MCP server
+const server = new McpServer({
+    name: 'myceliumail',
+    version: '1.0.0',
+});
+
+// Tool: check_inbox
+server.tool(
+    'check_inbox',
+    'Check your Myceliumail inbox for messages',
+    {
+        unread_only: z.boolean().optional().describe('Only show unread messages'),
+        limit: z.number().optional().describe('Maximum number of messages to return'),
+    },
+    async ({ unread_only, limit }) => {
+        const agentId = getAgentId();
+        const messages = await storage.getInbox(agentId, {
+            unreadOnly: unread_only,
+            limit: limit || 10,
+        });
+
+        if (messages.length === 0) {
+            return {
+                content: [{ type: 'text', text: '📭 No messages in inbox' }],
+            };
+        }
+
+        const formatted = messages.map(msg => {
+            const status = msg.read ? '  ' : '● ';
+            const encrypted = msg.encrypted ? '🔐 ' : '';
+            return `${status}${encrypted}[${msg.id.slice(0, 8)}] From: ${msg.sender} | ${msg.subject || '(no subject)'} | ${msg.createdAt.toLocaleString()}`;
+        }).join('\n');
+
+        return {
+            content: [{
+                type: 'text',
+                text: `📬 Inbox (${messages.length} messages):\n\n${formatted}`
+            }],
+        };
+    }
+);
+
+// Tool: read_message
+server.tool(
+    'read_message',
+    'Read a specific message by ID',
+    {
+        message_id: z.string().describe('Message ID (can be partial)'),
+    },
+    async ({ message_id }) => {
+        const agentId = getAgentId();
+        let message = await storage.getMessage(message_id);
+
+        // Try partial ID match
+        if (!message) {
+            const inbox = await storage.getInbox(agentId, { limit: 100 });
+            message = inbox.find(m => m.id.startsWith(message_id)) || null;
+        }
+
+        if (!message) {
+            return {
+                content: [{ type: 'text', text: `❌ Message not found: ${message_id}` }],
+            };
+        }
+
+        // Mark as read
+        await storage.markAsRead(message.id);
+
+        // Decrypt if needed
+        let subject = message.subject;
+        let body = message.body;
+
+        if (message.encrypted && message.ciphertext && message.nonce && message.senderPublicKey) {
+            const keyPair = crypto.loadKeyPair(agentId);
+            if (keyPair) {
+                try {
+                    const decrypted = crypto.decryptMessage({
+                        ciphertext: message.ciphertext,
+                        nonce: message.nonce,
+                        senderPublicKey: message.senderPublicKey,
+                    }, keyPair);
+                    if (decrypted) {
+                        const parsed = JSON.parse(decrypted);
+                        subject = parsed.subject || subject;
+                        body = parsed.body || body;
+                    }
+                } catch {
+                    body = '[Failed to decrypt]';
+                }
+            } else {
+                body = '[Cannot decrypt - no keypair]';
+            }
+        }
+
+        const encrypted = message.encrypted ? '\n🔐 Encrypted: Yes' : '';
+        const text = `━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+From:    ${message.sender}
+To:      ${message.recipient}
+Date:    ${message.createdAt.toLocaleString()}
+Subject: ${subject}${encrypted}
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+${body}
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+ID: ${message.id}`;
+
+        return {
+            content: [{ type: 'text', text }],
+        };
+    }
+);
+
+// Tool: send_message
+server.tool(
+    'send_message',
+    'Send a message to another agent',
+    {
+        recipient: z.string().describe('Recipient agent ID'),
+        subject: z.string().describe('Message subject'),
+        body: z.string().describe('Message body'),
+        encrypt: z.boolean().optional().describe('Encrypt the message (requires key exchange)'),
+    },
+    async ({ recipient, subject, body, encrypt }) => {
+        const sender = getAgentId();
+
+        if (sender === 'anonymous') {
+            return {
+                content: [{ type: 'text', text: '❌ Agent ID not configured. Set MYCELIUMAIL_AGENT_ID environment variable.' }],
+            };
+        }
+
+        let messageOptions;
+
+        if (encrypt) {
+            const senderKeyPair = crypto.loadKeyPair(sender);
+            if (!senderKeyPair) {
+                return {
+                    content: [{ type: 'text', text: '❌ No keypair found. Use generate_keys first.' }],
+                };
+            }
+
+            const recipientPubKeyB64 = crypto.getKnownKey(recipient);
+            if (!recipientPubKeyB64) {
+                return {
+                    content: [{ type: 'text', text: `❌ No public key found for ${recipient}. Use import_key first.` }],
+                };
+            }
+
+            const recipientPubKey = crypto.decodePublicKey(recipientPubKeyB64);
+            const payload = JSON.stringify({ subject, body });
+            const encrypted = crypto.encryptMessage(payload, recipientPubKey, senderKeyPair);
+
+            messageOptions = {
+                encrypted: true,
+                ciphertext: encrypted.ciphertext,
+                nonce: encrypted.nonce,
+                senderPublicKey: encrypted.senderPublicKey,
+            };
+        }
+
+        try {
+            const message = await storage.sendMessage(sender, recipient, subject, body, messageOptions);
+            const encInfo = encrypt ? ' (🔐 encrypted)' : '';
+            return {
+                content: [{
+                    type: 'text',
+                    text: `✅ Message sent to ${recipient}${encInfo}\nID: ${message.id}`
+                }],
+            };
+        } catch (error) {
+            return {
+                content: [{ type: 'text', text: `❌ Failed to send: ${error}` }],
+            };
+        }
+    }
+);
+
+// Tool: reply_message
+server.tool(
+    'reply_message',
+    'Reply to a message',
+    {
+        message_id: z.string().describe('ID of message to reply to'),
+        body: z.string().describe('Reply message body'),
+        encrypt: z.boolean().optional().describe('Encrypt the reply'),
+    },
+    async ({ message_id, body, encrypt }) => {
+        const agentId = getAgentId();
+
+        // Find original message
+        let original = await storage.getMessage(message_id);
+        if (!original) {
+            const inbox = await storage.getInbox(agentId, { limit: 100 });
+            original = inbox.find(m => m.id.startsWith(message_id)) || null;
+        }
+
+        if (!original) {
+            return {
+                content: [{ type: 'text', text: `❌ Message not found: ${message_id}` }],
+            };
+        }
+
+        // Send reply to original sender
+        const subject = original.subject.startsWith('Re: ')
+            ? original.subject
+            : `Re: ${original.subject}`;
+
+        let messageOptions;
+        if (encrypt) {
+            const senderKeyPair = crypto.loadKeyPair(agentId);
+            const recipientPubKeyB64 = crypto.getKnownKey(original.sender);
+
+            if (senderKeyPair && recipientPubKeyB64) {
+                const recipientPubKey = crypto.decodePublicKey(recipientPubKeyB64);
+                const payload = JSON.stringify({ subject, body });
+                const encrypted = crypto.encryptMessage(payload, recipientPubKey, senderKeyPair);
+                messageOptions = {
+                    encrypted: true,
+                    ciphertext: encrypted.ciphertext,
+                    nonce: encrypted.nonce,
+                    senderPublicKey: encrypted.senderPublicKey,
+                };
+            }
+        }
+
+        const message = await storage.sendMessage(agentId, original.sender, subject, body, messageOptions);
+        const encInfo = encrypt && messageOptions ? ' (🔐 encrypted)' : '';
+
+        return {
+            content: [{
+                type: 'text',
+                text: `✅ Reply sent to ${original.sender}${encInfo}\nID: ${message.id}`
+            }],
+        };
+    }
+);
+
+// Tool: generate_keys
+server.tool(
+    'generate_keys',
+    'Generate encryption keypair for this agent',
+    {
+        force: z.boolean().optional().describe('Overwrite existing keypair'),
+    },
+    async ({ force }) => {
+        const agentId = getAgentId();
+
+        if (crypto.hasKeyPair(agentId) && !force) {
+            const existing = crypto.loadKeyPair(agentId);
+            if (existing) {
+                const pubKey = crypto.getPublicKeyBase64(existing);
+                return {
+                    content: [{
+                        type: 'text',
+                        text: `⚠️ Keypair already exists for ${agentId}\n\n📧 Your public key:\n${pubKey}\n\nUse force=true to regenerate.`
+                    }],
+                };
+            }
+        }
+
+        const keyPair = crypto.generateKeyPair();
+        crypto.saveKeyPair(agentId, keyPair);
+        const publicKey = crypto.getPublicKeyBase64(keyPair);
+
+        return {
+            content: [{
+                type: 'text',
+                text: `🔐 Keypair generated for ${agentId}\n\n📧 Your public key (share with other agents):\n${publicKey}`
+            }],
+        };
+    }
+);
+
+// Tool: list_keys
+server.tool(
+    'list_keys',
+    'List all known encryption keys',
+    {},
+    async () => {
+        const agentId = getAgentId();
+        const ownKeys = crypto.listOwnKeys();
+        const knownKeys = crypto.loadKnownKeys();
+
+        let output = '🔐 Encryption Keys\n\n── Your Keys ──\n';
+
+        if (ownKeys.length === 0) {
+            output += 'No keypairs. Use generate_keys to create one.\n';
+        } else {
+            for (const id of ownKeys) {
+                const kp = crypto.loadKeyPair(id);
+                if (kp) {
+                    const marker = id === agentId ? ' (active)' : '';
+                    output += `${id}${marker}: ${crypto.getPublicKeyBase64(kp).slice(0, 20)}...\n`;
+                }
+            }
+        }
+
+        output += '\n── Peer Keys ──\n';
+        const peers = Object.entries(knownKeys);
+        if (peers.length === 0) {
+            output += 'No peer keys. Use import_key to add one.\n';
+        } else {
+            for (const [id, key] of peers) {
+                output += `${id}: ${key.slice(0, 20)}...\n`;
+            }
+        }
+
+        return {
+            content: [{ type: 'text', text: output }],
+        };
+    }
+);
+
+// Tool: import_key
+server.tool(
+    'import_key',
+    "Import another agent's public key for encrypted messaging",
+    {
+        agent_id: z.string().describe('Agent ID to import key for'),
+        public_key: z.string().describe('Base64 encoded public key'),
+    },
+    async ({ agent_id, public_key }) => {
+        if (public_key.length < 40) {
+            return {
+                content: [{ type: 'text', text: '❌ Invalid key format. Expected base64 NaCl public key.' }],
+            };
+        }
+
+        crypto.saveKnownKey(agent_id, public_key);
+
+        return {
+            content: [{
+                type: 'text',
+                text: `✅ Imported public key for ${agent_id}\n\n🔐 You can now send encrypted messages to this agent.`
+            }],
+        };
+    }
+);
+
+// Tool: archive_message
+server.tool(
+    'archive_message',
+    'Archive a message (remove from inbox)',
+    {
+        message_id: z.string().describe('Message ID to archive'),
+    },
+    async ({ message_id }) => {
+        const success = await storage.archiveMessage(message_id);
+
+        if (success) {
+            return {
+                content: [{ type: 'text', text: `✅ Message archived: ${message_id}` }],
+            };
+        } else {
+            return {
+                content: [{ type: 'text', text: `❌ Message not found: ${message_id}` }],
+            };
+        }
+    }
+);
+
+// Start the server
+async function main() {
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.error('Myceliumail MCP server running');
+}
+
+main().catch(console.error);

package/mcp-server/tsconfig.json

@@ -0,0 +1,26 @@
+{
+    "compilerOptions": {
+        "target": "ES2022",
+        "module": "Node16",
+        "moduleResolution": "Node16",
+        "lib": [
+            "ES2022"
+        ],
+        "outDir": "./dist",
+        "rootDir": "./src",
+        "strict": true,
+        "esModuleInterop": true,
+        "skipLibCheck": true,
+        "forceConsistentCasingInFileNames": true,
+        "declaration": true,
+        "sourceMap": true,
+        "resolveJsonModule": true
+    },
+    "include": [
+        "src/**/*"
+    ],
+    "exclude": [
+        "node_modules",
+        "dist"
+    ]
+}

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "myceliumail",
-  "version": "1.0.2",
+  "version": "1.0.4",
   "description": "End-to-End Encrypted Messaging for AI Agents",
   "main": "dist/index.js",
   "type": "module",
   "bin": {
-    "mycmail": "dist/bin/myceliumail.js",
-    "myceliumail": "dist/bin/myceliumail.js"
+    "mycmail": "./dist/bin/myceliumail.js",
+    "myceliumail": "./dist/bin/myceliumail.js"
   },
   "scripts": {
     "build": "tsc",
@@ -25,8 +25,17 @@
     "e2e",
     "cli"
   ],
-  "author": "Treebird",
+  "author": "Treebird <treebird@treebird.dev>",
   "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/treebird7/myceliumail"
+  },
+  "homepage": "https://github.com/treebird7/myceliumail#readme",
+  "bugs": {
+    "url": "https://github.com/treebird7/myceliumail/issues"
+  },
+  "readme": "README.md",
   "dependencies": {
     "@fastify/cors": "^11.2.0",
     "@fastify/static": "^8.3.0",

package/src/bin/myceliumail.ts

@@ -0,0 +1,54 @@
+#!/usr/bin/env node
+
+/**
+ * Myceliumail CLI
+ * 
+ * End-to-End Encrypted Messaging for AI Agents
+ */
+
+// Load environment variables from .env file
+import 'dotenv/config';
+
+import { Command } from 'commander';
+import { loadConfig } from '../lib/config.js';
+
+// Import commands
+import { createKeygenCommand } from '../commands/keygen.js';
+import { createKeysCommand } from '../commands/keys.js';
+import { createKeyImportCommand } from '../commands/key-import.js';
+import { createKeyAnnounceCommand } from '../commands/key-announce.js';
+import { createSendCommand } from '../commands/send.js';
+import { createInboxCommand } from '../commands/inbox.js';
+import { createReadCommand } from '../commands/read.js';
+import { createDashboardCommand } from '../commands/dashboard.js';
+import { createBroadcastCommand } from '../commands/broadcast.js';
+import { createWatchCommand } from '../commands/watch.js';
+
+const program = new Command();
+
+program
+    .name('mycmail')
+    .description('🍄 Myceliumail - End-to-End Encrypted Messaging for AI Agents')
+    .version('1.0.0');
+
+// Show current agent in help
+const config = loadConfig();
+program.addHelpText('after', `
+Current agent: ${config.agentId}
+Config: ~/.myceliumail/config.json
+`);
+
+// Register commands
+program.addCommand(createKeygenCommand());
+program.addCommand(createKeysCommand());
+program.addCommand(createKeyImportCommand());
+program.addCommand(createKeyAnnounceCommand());
+program.addCommand(createSendCommand());
+program.addCommand(createInboxCommand());
+program.addCommand(createReadCommand());
+program.addCommand(createDashboardCommand());
+program.addCommand(createBroadcastCommand());
+program.addCommand(createWatchCommand());
+
+// Parse and run
+program.parse();

package/src/commands/broadcast.ts

@@ -0,0 +1,70 @@
+/**
+ * broadcast command - Send a message to all known agents
+ */
+
+import { Command } from 'commander';
+import { loadConfig } from '../lib/config.js';
+import { getKnownKeys } from '../lib/crypto.js';
+import * as storage from '../storage/supabase.js';
+
+// Known agent aliases
+const AGENT_ALIASES: Record<string, string> = {
+    'mycs': 'mycsan',
+    'treeb': 'treebird',
+};
+
+function resolveAlias(agent: string): string {
+    return AGENT_ALIASES[agent] || agent;
+}
+
+export function createBroadcastCommand(): Command {
+    return new Command('broadcast')
+        .description('Send a message to all known agents')
+        .argument('<subject>', 'Message subject/body')
+        .option('-m, --message <body>', 'Message body (optional)')
+        .action(async (subject: string, options) => {
+            const config = loadConfig();
+            const sender = config.agentId;
+
+            if (sender === 'anonymous') {
+                console.error('❌ Agent ID not configured.');
+                console.error('Set MYCELIUMAIL_AGENT_ID or configure ~/.myceliumail/config.json');
+                process.exit(1);
+            }
+
+            const body = options.message || subject;
+
+            // Get all known agents from keys
+            const knownKeys = getKnownKeys();
+            const recipients = Object.keys(knownKeys).filter(agent => agent !== sender);
+
+            if (recipients.length === 0) {
+                console.error('❌ No known agents to broadcast to.');
+                console.error('Import agent keys first:');
+                console.error('  mycmail key-import <agent> <their-public-key>');
+                process.exit(1);
+            }
+
+            console.log(`📢 Broadcasting to ${recipients.length} agents...`);
+            console.log(`   Recipients: ${recipients.join(', ')}\n`);
+
+            let sent = 0;
+            let failed = 0;
+
+            for (const recipient of recipients) {
+                try {
+                    await storage.sendMessage(sender, recipient, subject, body);
+                    console.log(`   ✅ ${recipient}`);
+                    sent++;
+                } catch (error) {
+                    console.log(`   ❌ ${recipient}: ${error}`);
+                    failed++;
+                }
+            }
+
+            console.log(`\n📬 Broadcast complete: ${sent} sent, ${failed} failed`);
+        });
+}
+
+// Export alias resolver for use in send command
+export { resolveAlias, AGENT_ALIASES };

package/src/commands/dashboard.ts

@@ -0,0 +1,19 @@
+import { Command } from 'commander';
+import { startDashboard } from '../dashboard/server.js';
+
+export function createDashboardCommand(): Command {
+    return new Command('dashboard')
+        .description('Start web dashboard on localhost:3737')
+        .option('-p, --port <port>', 'Port to run on', '3737')
+        .action(async (options) => {
+            const port = parseInt(options.port, 10);
+            console.log(`\n🍄 Starting Myceliumail Dashboard...`);
+            await startDashboard(port);
+            // Help text
+            console.log(`\n   ➜  http://localhost:${port}`);
+            console.log('\nPress Ctrl+C to stop');
+
+            // Keep process alive
+            await new Promise(() => { });
+        });
+}

package/src/commands/inbox.ts

@@ -0,0 +1,75 @@
+/**
+ * inbox command - List incoming messages
+ */
+
+import { Command } from 'commander';
+import { loadConfig } from '../lib/config.js';
+import { loadKeyPair, decryptMessage } from '../lib/crypto.js';
+import * as storage from '../storage/supabase.js';
+
+export function createInboxCommand(): Command {
+    return new Command('inbox')
+        .description('List incoming messages')
+        .option('-u, --unread', 'Show only unread messages')
+        .option('-l, --limit <n>', 'Limit number of messages', '10')
+        .action(async (options) => {
+            const config = loadConfig();
+            const agentId = config.agentId;
+
+            if (agentId === 'anonymous') {
+                console.error('❌ Agent ID not configured.');
+                console.error('Set MYCELIUMAIL_AGENT_ID or configure ~/.myceliumail/config.json');
+                process.exit(1);
+            }
+
+            try {
+                const messages = await storage.getInbox(agentId, {
+                    unreadOnly: options.unread,
+                    limit: parseInt(options.limit, 10),
+                });
+
+                if (messages.length === 0) {
+                    console.log('📭 No messages');
+                    return;
+                }
+
+                console.log(`📬 Inbox for ${agentId} (${messages.length} messages)\n`);
+
+                const keyPair = loadKeyPair(agentId);
+
+                for (const msg of messages) {
+                    const readMarker = msg.read ? '  ' : '● ';
+                    const encryptedMarker = msg.encrypted ? '🔐 ' : '';
+                    const date = msg.createdAt.toLocaleString();
+
+                    let displaySubject = msg.subject;
+
+                    // Try to decrypt if encrypted and we have keys
+                    if (msg.encrypted && keyPair && msg.ciphertext && msg.nonce && msg.senderPublicKey) {
+                        try {
+                            const decrypted = decryptMessage({
+                                ciphertext: msg.ciphertext,
+                                nonce: msg.nonce,
+                                senderPublicKey: msg.senderPublicKey,
+                            }, keyPair);
+
+                            if (decrypted) {
+                                const parsed = JSON.parse(decrypted);
+                                displaySubject = parsed.subject || '[Decrypted]';
+                            }
+                        } catch {
+                            displaySubject = '[Encrypted]';
+                        }
+                    }
+
+                    console.log(`${readMarker}${encryptedMarker}${msg.id.slice(0, 8)} | From: ${msg.sender} | ${displaySubject}`);
+                    console.log(`   ${date}`);
+                }
+
+                console.log('\n💡 Use: mycmail read <id> to read a message');
+            } catch (error) {
+                console.error('❌ Failed to fetch inbox:', error);
+                process.exit(1);
+            }
+        });
+}