myceliumail 1.0.2 → 1.0.3

package/src/commands/key-announce.ts

@@ -0,0 +1,70 @@
+/**
+ * key-announce command - Publish your public key to Supabase
+ */
+
+import { Command } from 'commander';
+import { loadConfig, hasSupabaseConfig } from '../lib/config.js';
+import { hasKeyPair, loadKeyPair, getPublicKeyBase64 } from '../lib/crypto.js';
+
+export function createKeyAnnounceCommand(): Command {
+    return new Command('key-announce')
+        .description('Publish your public key to the network')
+        .action(async () => {
+            const config = loadConfig();
+            const agentId = config.agentId;
+
+            // Check for keypair
+            if (!hasKeyPair(agentId)) {
+                console.error(`❌ No keypair found for ${agentId}`);
+                console.log('   Run: mycmail keygen');
+                process.exit(1);
+            }
+
+            // Check for Supabase
+            if (!hasSupabaseConfig(config)) {
+                console.error('❌ Supabase not configured');
+                console.log('   Set supabase_url and supabase_key in ~/.myceliumail/config.json');
+                process.exit(1);
+            }
+
+            const keyPair = loadKeyPair(agentId);
+            if (!keyPair) {
+                console.error('❌ Failed to load keypair');
+                process.exit(1);
+            }
+
+            const publicKey = getPublicKeyBase64(keyPair);
+
+            try {
+                // Make direct Supabase request
+                const url = `${config.supabaseUrl}/rest/v1/agent_keys`;
+                const response = await fetch(url, {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json',
+                        'apikey': config.supabaseKey!,
+                        'Authorization': `Bearer ${config.supabaseKey}`,
+                        'Prefer': 'resolution=merge-duplicates',
+                    },
+                    body: JSON.stringify({
+                        agent_id: agentId,
+                        public_key: publicKey,
+                        updated_at: new Date().toISOString(),
+                    }),
+                });
+
+                if (!response.ok) {
+                    const error = await response.text();
+                    throw new Error(error);
+                }
+
+                console.log('📢 Public key announced successfully!\n');
+                console.log(`Agent ID: ${agentId}`);
+                console.log(`Public Key: ${publicKey}`);
+                console.log('\n✅ Other agents can now send you encrypted messages');
+            } catch (error) {
+                console.error('❌ Failed to announce key:', error);
+                process.exit(1);
+            }
+        });
+}

package/src/commands/key-import.ts

@@ -0,0 +1,35 @@
+/**
+ * key-import command - Import a peer's public key
+ */
+
+import { Command } from 'commander';
+import { saveKnownKey, getKnownKey } from '../lib/crypto.js';
+
+export function createKeyImportCommand(): Command {
+    return new Command('key-import')
+        .description('Import a peer agent\'s public key')
+        .argument('<agent>', 'Agent ID to import key for')
+        .argument('<key>', 'Base64 encoded public key')
+        .option('-f, --force', 'Overwrite existing key')
+        .action(async (agentId: string, publicKey: string, options) => {
+            // Validate key format (basic check)
+            if (publicKey.length < 40) {
+                console.error('❌ Invalid key format. Expected base64 encoded NaCl public key.');
+                process.exit(1);
+            }
+
+            const existing = getKnownKey(agentId);
+            if (existing && !options.force) {
+                console.log(`⚠️  Key already exists for ${agentId}`);
+                console.log(`Existing key: ${existing.slice(0, 20)}...`);
+                console.log('\nUse --force to overwrite');
+                return;
+            }
+
+            saveKnownKey(agentId, publicKey);
+
+            console.log(`✅ Imported public key for ${agentId}`);
+            console.log(`Key: ${publicKey.slice(0, 20)}...`);
+            console.log('\n🔐 You can now send encrypted messages to this agent');
+        });
+}

package/src/commands/keygen.ts

@@ -0,0 +1,44 @@
+/**
+ * keygen command - Generate encryption keypair
+ */
+
+import { Command } from 'commander';
+import { loadConfig } from '../lib/config.js';
+import {
+    generateKeyPair,
+    saveKeyPair,
+    hasKeyPair,
+    getPublicKeyBase64,
+    loadKeyPair
+} from '../lib/crypto.js';
+
+export function createKeygenCommand(): Command {
+    return new Command('keygen')
+        .description('Generate a new encryption keypair')
+        .option('-f, --force', 'Overwrite existing keypair')
+        .action(async (options) => {
+            const config = loadConfig();
+            const agentId = config.agentId;
+
+            if (hasKeyPair(agentId) && !options.force) {
+                console.log(`⚠️  Keypair already exists for ${agentId}`);
+                const existingPair = loadKeyPair(agentId);
+                if (existingPair) {
+                    console.log(`📧 Your public key: ${getPublicKeyBase64(existingPair)}`);
+                }
+                console.log('\nUse --force to regenerate (⚠️  this will invalidate existing encrypted messages)');
+                return;
+            }
+
+            const keyPair = generateKeyPair();
+            saveKeyPair(agentId, keyPair);
+
+            const publicKey = getPublicKeyBase64(keyPair);
+
+            console.log('🔐 Keypair generated successfully!\n');
+            console.log(`Agent ID: ${agentId}`);
+            console.log(`📧 Your public key (share with other agents):\n`);
+            console.log(publicKey);
+            console.log('\n✅ Keys stored in ~/.myceliumail/keys/');
+        });
+}

package/src/commands/keys.ts

@@ -0,0 +1,55 @@
+/**
+ * keys command - List known public keys
+ */
+
+import { Command } from 'commander';
+import { loadConfig } from '../lib/config.js';
+import {
+    loadKnownKeys,
+    listOwnKeys,
+    loadKeyPair,
+    getPublicKeyBase64
+} from '../lib/crypto.js';
+
+export function createKeysCommand(): Command {
+    return new Command('keys')
+        .description('List known public keys')
+        .option('-a, --all', 'Show full keys (not truncated)')
+        .action(async (options) => {
+            const config = loadConfig();
+            const ownKeys = listOwnKeys();
+            const knownKeys = loadKnownKeys();
+
+            console.log('🔐 Encryption Keys\n');
+
+            // Own keys
+            console.log('── Your Keys ──');
+            if (ownKeys.length === 0) {
+                console.log('  No keypairs generated. Run: mycmail keygen');
+            } else {
+                for (const agentId of ownKeys) {
+                    const keyPair = loadKeyPair(agentId);
+                    if (keyPair) {
+                        const pubKey = getPublicKeyBase64(keyPair);
+                        const display = options.all ? pubKey : `${pubKey.slice(0, 20)}...`;
+                        const marker = agentId === config.agentId ? ' (active)' : '';
+                        console.log(`  ${agentId}${marker}: ${display}`);
+                    }
+                }
+            }
+
+            // Known peer keys
+            console.log('\n── Peer Keys ──');
+            const peerEntries = Object.entries(knownKeys);
+            if (peerEntries.length === 0) {
+                console.log('  No peer keys imported. Use: mycmail key-import <agent> <key>');
+            } else {
+                for (const [agentId, pubKey] of peerEntries) {
+                    const display = options.all ? pubKey : `${pubKey.slice(0, 20)}...`;
+                    console.log(`  ${agentId}: ${display}`);
+                }
+            }
+
+            console.log('\n💡 Tip: Use --all to show full keys');
+        });
+}

package/src/commands/read.ts

@@ -0,0 +1,97 @@
+/**
+ * read command - Read a specific message
+ */
+
+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 createReadCommand(): Command {
+    return new Command('read')
+        .description('Read a specific message')
+        .argument('<id>', 'Message ID (can be partial)')
+        .action(async (messageId: string) => {
+            const config = loadConfig();
+            const agentId = config.agentId;
+
+            try {
+                // Get message - handle partial ID
+                const message = await storage.getMessage(messageId);
+
+                if (!message) {
+                    // Try to find by partial ID
+                    const inbox = await storage.getInbox(agentId, { limit: 100 });
+                    const found = inbox.find(m => m.id.startsWith(messageId));
+
+                    if (!found) {
+                        console.error(`❌ Message not found: ${messageId}`);
+                        process.exit(1);
+                    }
+
+                    return readAndDisplay(found, agentId);
+                }
+
+                await readAndDisplay(message, agentId);
+            } catch (error) {
+                console.error('❌ Failed to read message:', error);
+                process.exit(1);
+            }
+        });
+}
+
+async function readAndDisplay(message: Awaited<ReturnType<typeof storage.getMessage>>, agentId: string): Promise<void> {
+    if (!message) return;
+
+    // Mark as read
+    await storage.markAsRead(message.id);
+
+    let subject = message.subject;
+    let body = message.body;
+
+    // Decrypt if encrypted
+    if (message.encrypted && message.ciphertext && message.nonce && message.senderPublicKey) {
+        const keyPair = loadKeyPair(agentId);
+
+        if (!keyPair) {
+            console.log('⚠️  Cannot decrypt: no keypair found');
+            console.log('   Generate keypair with: mycmail keygen');
+        } else {
+            try {
+                const decrypted = 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;
+                    console.log('🔓 Message decrypted\n');
+                } else {
+                    console.log('⚠️  Decryption failed\n');
+                }
+            } catch (e) {
+                console.log('⚠️  Failed to parse decrypted message\n');
+            }
+        }
+    }
+
+    // Display message
+    console.log('━'.repeat(60));
+    console.log(`From:    ${message.sender}`);
+    console.log(`To:      ${message.recipient}`);
+    console.log(`Date:    ${message.createdAt.toLocaleString()}`);
+    console.log(`Subject: ${subject}`);
+    if (message.encrypted) {
+        console.log(`🔐       Encrypted message`);
+    }
+    console.log('━'.repeat(60));
+    console.log('');
+    console.log(body);
+    console.log('');
+    console.log('━'.repeat(60));
+    console.log(`ID: ${message.id}`);
+    console.log('\n💡 Reply with: mycmail reply <id> "<message>"');
+}

package/src/commands/send.ts

@@ -0,0 +1,89 @@
+/**
+ * send command - Send a message to another agent
+ * 
+ * Messages are encrypted by default. Use --plaintext to send unencrypted.
+ */
+
+import { Command } from 'commander';
+import { loadConfig } from '../lib/config.js';
+import {
+    loadKeyPair,
+    getKnownKey,
+    encryptMessage,
+    decodePublicKey
+} from '../lib/crypto.js';
+import * as storage from '../storage/supabase.js';
+
+export function createSendCommand(): Command {
+    return new Command('send')
+        .description('Send a message to another agent (encrypted by default)')
+        .argument('<recipient>', 'Recipient agent ID')
+        .argument('<subject>', 'Message subject')
+        .option('-m, --message <body>', 'Message body (or provide via stdin)')
+        .option('-p, --plaintext', 'Send unencrypted (not recommended)')
+        .action(async (recipient: string, 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;
+            let messageOptions;
+            let encrypted = false;
+
+            // Encrypt by default unless --plaintext is specified
+            if (!options.plaintext) {
+                const senderKeyPair = loadKeyPair(sender);
+                const recipientPubKeyB64 = getKnownKey(recipient);
+
+                if (senderKeyPair && recipientPubKeyB64) {
+                    try {
+                        const recipientPubKey = decodePublicKey(recipientPubKeyB64);
+                        const payload = JSON.stringify({ subject, body });
+                        const encryptedData = encryptMessage(payload, recipientPubKey, senderKeyPair);
+
+                        messageOptions = {
+                            encrypted: true,
+                            ciphertext: encryptedData.ciphertext,
+                            nonce: encryptedData.nonce,
+                            senderPublicKey: encryptedData.senderPublicKey,
+                        };
+                        encrypted = true;
+                    } catch (err) {
+                        console.warn('⚠️  Encryption failed, sending plaintext:', (err as Error).message);
+                    }
+                } else {
+                    // Warn user but don't block
+                    if (!senderKeyPair) {
+                        console.warn('⚠️  No keypair found. Run: mycmail keygen');
+                    }
+                    if (!recipientPubKeyB64) {
+                        console.warn(`⚠️  No public key for ${recipient}. Run: mycmail key-import ${recipient} <key>`);
+                    }
+                    console.warn('   Sending as plaintext (use -p to suppress this warning)\n');
+                }
+            }
+
+            try {
+                const message = await storage.sendMessage(
+                    sender,
+                    recipient,
+                    subject,
+                    body,
+                    messageOptions
+                );
+
+                console.log(`\n✅ Message sent to ${recipient}`);
+                console.log(`   ID: ${message.id}`);
+                console.log(`   Subject: ${subject}`);
+                console.log(`   ${encrypted ? '🔐 Encrypted' : '📨 Plaintext'}`);
+            } catch (error) {
+                console.error('❌ Failed to send message:', error);
+                process.exit(1);
+            }
+        });
+}

package/src/commands/watch.ts

@@ -0,0 +1,101 @@
+/**
+ * Watch Command
+ * 
+ * Listen for new messages in real-time and show desktop notifications.
+ */
+
+import { Command } from 'commander';
+import notifier from 'node-notifier';
+import { loadConfig } from '../lib/config.js';
+import { subscribeToMessages, closeConnection } from '../lib/realtime.js';
+
+export function createWatchCommand(): Command {
+    const command = new Command('watch')
+        .description('Watch for new messages in real-time')
+        .option('-a, --agent <id>', 'Agent ID to watch (default: current agent)')
+        .option('-q, --quiet', 'Suppress console output, only show notifications')
+        .action(async (options) => {
+            const config = loadConfig();
+            const agentId = options.agent || config.agentId;
+
+            if (!options.quiet) {
+                console.log(`\n🍄 Watching inbox for ${agentId}...`);
+                console.log('Press Ctrl+C to stop\n');
+            }
+
+            const channel = subscribeToMessages(
+                agentId,
+                (message) => {
+                    // Show console output
+                    if (!options.quiet) {
+                        const time = new Date(message.created_at).toLocaleTimeString();
+                        console.log(`📬 [${time}] New message from ${message.from_agent}`);
+                        console.log(`   Subject: ${message.subject}`);
+                        if (!message.encrypted) {
+                            const preview = message.message.length > 80
+                                ? message.message.substring(0, 80) + '...'
+                                : message.message;
+                            console.log(`   Preview: ${preview}`);
+                        } else {
+                            console.log(`   🔒 [Encrypted]`);
+                        }
+                        console.log();
+                    }
+
+                    // Show desktop notification
+                    const preview = message.encrypted
+                        ? '🔒 Encrypted message'
+                        : message.message.length > 100
+                            ? message.message.substring(0, 100) + '...'
+                            : message.message;
+
+                    notifier.notify({
+                        title: `📬 ${message.from_agent}: ${message.subject}`,
+                        message: preview,
+                        sound: true,
+                        wait: false,
+                    });
+                },
+                (status, error) => {
+                    if (!options.quiet) {
+                        switch (status) {
+                            case 'SUBSCRIBED':
+                                console.log('✅ Connected to Supabase Realtime\n');
+                                break;
+                            case 'CLOSED':
+                                console.log('🔌 Connection closed');
+                                break;
+                            case 'CHANNEL_ERROR':
+                                console.error('❌ Channel error:', error?.message);
+                                break;
+                            case 'TIMED_OUT':
+                                console.error('⏱️ Connection timed out');
+                                break;
+                        }
+                    }
+                }
+            );
+
+            if (!channel) {
+                console.error('❌ Failed to start watching. Check your Supabase configuration.');
+                process.exit(1);
+            }
+
+            // Handle graceful shutdown
+            const cleanup = async () => {
+                if (!options.quiet) {
+                    console.log('\n👋 Stopping watch...');
+                }
+                await closeConnection();
+                process.exit(0);
+            };
+
+            process.on('SIGINT', cleanup);
+            process.on('SIGTERM', cleanup);
+
+            // Keep the process running
+            await new Promise(() => { });
+        });
+
+    return command;
+}