myceliumail 1.0.4 → 1.0.6

package/src/commands/export.ts

@@ -0,0 +1,212 @@
+/**
+ * export command - Export messages for RAG/backup
+ */
+
+import { Command } from 'commander';
+import { writeFileSync } from 'fs';
+import { loadConfig } from '../lib/config.js';
+import { loadKeyPair, decryptMessage } from '../lib/crypto.js';
+import * as storage from '../storage/supabase.js';
+import type { Message } from '../types/index.js';
+
+interface ExportOptions {
+    format: 'jsonl' | 'json' | 'md';
+    output?: string;
+    from?: string;
+    since?: string;
+    limit?: string;
+    decrypt?: boolean;
+}
+
+interface ExportedMessage {
+    id: string;
+    from: string;
+    to: string;
+    subject: string;
+    content: string;
+    encrypted: boolean;
+    created_at: string;
+}
+
+/**
+ * Decrypt a message if possible
+ */
+function tryDecrypt(msg: Message, keyPair: { publicKey: Uint8Array; secretKey: Uint8Array } | null): { subject: string; content: string } {
+    if (!msg.encrypted) {
+        return { subject: msg.subject, content: msg.body };
+    }
+
+    if (!keyPair || !msg.ciphertext || !msg.nonce || !msg.senderPublicKey) {
+        return { subject: msg.subject, content: '[Encrypted - No keys available]' };
+    }
+
+    try {
+        const decrypted = decryptMessage({
+            ciphertext: msg.ciphertext,
+            nonce: msg.nonce,
+            senderPublicKey: msg.senderPublicKey,
+        }, keyPair);
+
+        if (decrypted) {
+            const parsed = JSON.parse(decrypted);
+            return {
+                subject: parsed.subject || msg.subject,
+                content: parsed.body || parsed.message || decrypted,
+            };
+        }
+    } catch {
+        // Decryption failed
+    }
+
+    return { subject: msg.subject, content: '[Encrypted - Decryption failed]' };
+}
+
+/**
+ * Format messages as JSONL (one JSON object per line)
+ */
+function formatJsonl(messages: ExportedMessage[]): string {
+    return messages.map(m => JSON.stringify(m)).join('\n');
+}
+
+/**
+ * Format messages as JSON array with metadata
+ */
+function formatJson(messages: ExportedMessage[], agentId: string): string {
+    return JSON.stringify({
+        exported_at: new Date().toISOString(),
+        agent_id: agentId,
+        message_count: messages.length,
+        messages,
+    }, null, 2);
+}
+
+/**
+ * Format messages as Markdown
+ */
+function formatMarkdown(messages: ExportedMessage[], agentId: string): string {
+    const lines: string[] = [
+        `# Myceliumail Archive - ${agentId}`,
+        `Exported: ${new Date().toLocaleString()}`,
+        `Total messages: ${messages.length}`,
+        '',
+    ];
+
+    for (const msg of messages) {
+        const date = new Date(msg.created_at).toLocaleString();
+        const encMarker = msg.encrypted ? ' 🔐' : '';
+        lines.push('---');
+        lines.push(`## 📬 From: ${msg.from}${encMarker} | ${date}`);
+        lines.push(`**Subject:** ${msg.subject}`);
+        lines.push('');
+        lines.push(msg.content);
+        lines.push('');
+    }
+
+    return lines.join('\n');
+}
+
+export function createExportCommand(): Command {
+    return new Command('export')
+        .description('Export messages for RAG/backup (JSONL, JSON, or Markdown)')
+        .option('-f, --format <format>', 'Output format: jsonl, json, md', 'jsonl')
+        .option('-o, --output <file>', 'Output file (default: stdout)')
+        .option('--from <agent>', 'Filter by sender')
+        .option('--since <date>', 'Filter messages after date (ISO 8601)')
+        .option('-l, --limit <n>', 'Max messages to export', '100')
+        .option('-d, --decrypt', 'Attempt to decrypt encrypted messages')
+        .action(async (options: ExportOptions) => {
+            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);
+            }
+
+            // Validate format
+            const format = options.format.toLowerCase() as 'jsonl' | 'json' | 'md';
+            if (!['jsonl', 'json', 'md'].includes(format)) {
+                console.error('❌ Invalid format. Use: jsonl, json, or md');
+                process.exit(1);
+            }
+
+            try {
+                // Fetch messages
+                const messages = await storage.getInbox(agentId, {
+                    limit: parseInt(options.limit || '100', 10),
+                });
+
+                if (messages.length === 0) {
+                    console.error('📭 No messages to export');
+                    process.exit(0);
+                }
+
+                // Load keys for decryption if requested
+                const keyPair = options.decrypt ? loadKeyPair(agentId) : null;
+
+                // Filter by sender if specified
+                let filtered = messages;
+                if (options.from) {
+                    const fromLower = options.from.toLowerCase();
+                    filtered = filtered.filter(m => m.sender.toLowerCase() === fromLower);
+                }
+
+                // Filter by date if specified
+                if (options.since) {
+                    const sinceDate = new Date(options.since);
+                    if (!isNaN(sinceDate.getTime())) {
+                        filtered = filtered.filter(m => m.createdAt >= sinceDate);
+                    }
+                }
+
+                if (filtered.length === 0) {
+                    console.error('📭 No messages match filters');
+                    process.exit(0);
+                }
+
+                // Transform to export format
+                const exported: ExportedMessage[] = filtered.map(msg => {
+                    const { subject, content } = options.decrypt
+                        ? tryDecrypt(msg, keyPair)
+                        : { subject: msg.subject, content: msg.encrypted ? '[Encrypted]' : msg.body };
+
+                    return {
+                        id: msg.id,
+                        from: msg.sender,
+                        to: msg.recipient as string,
+                        subject,
+                        content,
+                        encrypted: msg.encrypted,
+                        created_at: msg.createdAt.toISOString(),
+                    };
+                });
+
+                // Format output
+                let output: string;
+                switch (format) {
+                    case 'jsonl':
+                        output = formatJsonl(exported);
+                        break;
+                    case 'json':
+                        output = formatJson(exported, agentId);
+                        break;
+                    case 'md':
+                        output = formatMarkdown(exported, agentId);
+                        break;
+                }
+
+                // Write to file or stdout
+                if (options.output) {
+                    writeFileSync(options.output, output);
+                    console.error(`✅ Exported ${filtered.length} messages to ${options.output}`);
+                } else {
+                    console.log(output);
+                }
+
+            } catch (error) {
+                console.error('❌ Export failed:', error);
+                process.exit(1);
+            }
+        });
+}

package/src/commands/send.ts

@@ -2,6 +2,7 @@
  * send command - Send a message to another agent
  * 
  * Messages are encrypted by default. Use --plaintext to send unencrypted.
+ * Message body can be provided via -m flag, stdin pipe, or defaults to subject.
  */
 
 import { Command } from 'commander';
@@ -14,16 +15,36 @@ import {
 } from '../lib/crypto.js';
 import * as storage from '../storage/supabase.js';
 
+/**
+ * Read from stdin if data is being piped
+ */
+async function readStdin(): Promise<string | null> {
+    // Check if stdin is a TTY (interactive terminal) - if so, no piped data
+    if (process.stdin.isTTY) {
+        return null;
+    }
+
+    return new Promise((resolve) => {
+        let data = '';
+        process.stdin.setEncoding('utf8');
+        process.stdin.on('data', (chunk) => { data += chunk; });
+        process.stdin.on('end', () => { resolve(data.trim() || null); });
+        // Timeout after 100ms if no data
+        setTimeout(() => resolve(null), 100);
+    });
+}
+
 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('-m, --message <body>', 'Message body (or pipe via stdin)')
         .option('-p, --plaintext', 'Send unencrypted (not recommended)')
         .action(async (recipient: string, subject: string, options) => {
             const config = loadConfig();
             const sender = config.agentId;
+            const normalizedRecipient = recipient.toLowerCase();
 
             if (sender === 'anonymous') {
                 console.error('❌ Agent ID not configured.');
@@ -31,14 +52,20 @@ export function createSendCommand(): Command {
                 process.exit(1);
             }
 
-            const body = options.message || subject;
+            // Try to get body from: 1) -m option, 2) stdin pipe, 3) subject
+            let body = options.message;
+            if (!body) {
+                const stdinData = await readStdin();
+                body = stdinData || subject;
+            }
+
             let messageOptions;
             let encrypted = false;
 
             // Encrypt by default unless --plaintext is specified
             if (!options.plaintext) {
                 const senderKeyPair = loadKeyPair(sender);
-                const recipientPubKeyB64 = getKnownKey(recipient);
+                const recipientPubKeyB64 = getKnownKey(normalizedRecipient);
 
                 if (senderKeyPair && recipientPubKeyB64) {
                     try {
@@ -62,7 +89,7 @@ export function createSendCommand(): Command {
                         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(`⚠️  No public key for ${normalizedRecipient}. Run: mycmail key-import ${normalizedRecipient} <key>`);
                     }
                     console.warn('   Sending as plaintext (use -p to suppress this warning)\n');
                 }
@@ -71,13 +98,13 @@ export function createSendCommand(): Command {
             try {
                 const message = await storage.sendMessage(
                     sender,
-                    recipient,
+                    normalizedRecipient,
                     subject,
                     body,
                     messageOptions
                 );
 
-                console.log(`\n✅ Message sent to ${recipient}`);
+                console.log(`\n✅ Message sent to ${normalizedRecipient}`);
                 console.log(`   ID: ${message.id}`);
                 console.log(`   Subject: ${subject}`);
                 console.log(`   ${encrypted ? '🔐 Encrypted' : '📨 Plaintext'}`);
@@ -87,3 +114,4 @@ export function createSendCommand(): Command {
             }
         });
 }
+

package/src/commands/status.ts

@@ -0,0 +1,114 @@
+/**
+ * Status Command
+ * 
+ * Check the current inbox notification status from the status file.
+ * This allows agents to quickly check if they have new mail without
+ * running the watch command.
+ */
+
+import { Command } from 'commander';
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+
+interface InboxStatus {
+    status: 0 | 1 | 2;  // 0=none, 1=new message, 2=urgent
+    count: number;
+    lastMessage?: {
+        from: string;
+        subject: string;
+        time: string;
+        encrypted: boolean;
+    };
+    updatedAt: string;
+}
+
+const STATUS_FILE_PATH = join(homedir(), '.mycmail', 'inbox_status.json');
+
+/**
+ * Read current inbox status
+ */
+function readInboxStatus(): InboxStatus | null {
+    try {
+        if (existsSync(STATUS_FILE_PATH)) {
+            const content = readFileSync(STATUS_FILE_PATH, 'utf-8');
+            return JSON.parse(content);
+        }
+    } catch {
+        // Return null if file doesn't exist or is invalid
+    }
+    return null;
+}
+
+/**
+ * Clear inbox status (set to 0)
+ */
+function clearInboxStatus(): void {
+    const dir = join(homedir(), '.mycmail');
+    if (!existsSync(dir)) {
+        mkdirSync(dir, { recursive: true });
+    }
+    const status: InboxStatus = { status: 0, count: 0, updatedAt: new Date().toISOString() };
+    writeFileSync(STATUS_FILE_PATH, JSON.stringify(status, null, 2));
+}
+
+export function createStatusCommand(): Command {
+    const command = new Command('status')
+        .description('Check inbox notification status (0=none, 1=new, 2=urgent)')
+        .option('--clear', 'Clear the status (acknowledge messages)')
+        .option('--json', 'Output as JSON')
+        .option('--number-only', 'Output only the status number (0, 1, or 2)')
+        .action(async (options) => {
+            if (options.clear) {
+                clearInboxStatus();
+                if (!options.numberOnly) {
+                    console.log('✅ Status cleared');
+                } else {
+                    console.log('0');
+                }
+                return;
+            }
+
+            const status = readInboxStatus();
+
+            if (!status) {
+                if (options.json) {
+                    console.log(JSON.stringify({ status: 0, count: 0, message: 'No status file found' }));
+                } else if (options.numberOnly) {
+                    console.log('0');
+                } else {
+                    console.log('📭 No status file found. Run `mycmail watch --status-file` to enable.');
+                }
+                return;
+            }
+
+            if (options.numberOnly) {
+                console.log(status.status.toString());
+                return;
+            }
+
+            if (options.json) {
+                console.log(JSON.stringify(status, null, 2));
+                return;
+            }
+
+            // Human-readable output
+            const statusEmoji = status.status === 0 ? '📭' : status.status === 1 ? '📬' : '🚨';
+            const statusText = status.status === 0 ? 'No new messages' : status.status === 1 ? 'New message(s)' : 'URGENT message(s)';
+
+            console.log(`\n${statusEmoji} ${statusText}`);
+            console.log(`   Count: ${status.count}`);
+
+            if (status.lastMessage) {
+                console.log(`   Last: ${status.lastMessage.from} - "${status.lastMessage.subject}"`);
+                if (status.lastMessage.encrypted) {
+                    console.log(`   🔒 Message is encrypted`);
+                }
+            }
+
+            console.log(`   Updated: ${new Date(status.updatedAt).toLocaleString()}`);
+            console.log();
+        });
+
+    return command;
+}

package/src/commands/watch.ts

@@ -6,26 +6,112 @@
 
 import { Command } from 'commander';
 import notifier from 'node-notifier';
+import { writeFileSync, mkdirSync, existsSync, readFileSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
 import { loadConfig } from '../lib/config.js';
 import { subscribeToMessages, closeConnection } from '../lib/realtime.js';
 
+interface InboxStatus {
+    status: 0 | 1 | 2;  // 0=none, 1=new message, 2=urgent
+    count: number;
+    lastMessage?: {
+        from: string;
+        subject: string;
+        time: string;
+        encrypted: boolean;
+    };
+    updatedAt: string;
+}
+
+const STATUS_FILE_PATH = join(homedir(), '.mycmail', 'inbox_status.json');
+
+/**
+ * Read current inbox status, or return default
+ */
+function readInboxStatus(): InboxStatus {
+    try {
+        if (existsSync(STATUS_FILE_PATH)) {
+            const content = readFileSync(STATUS_FILE_PATH, 'utf-8');
+            return JSON.parse(content);
+        }
+    } catch {
+        // Return default if file doesn't exist or is invalid
+    }
+    return { status: 0, count: 0, updatedAt: new Date().toISOString() };
+}
+
+/**
+ * Write inbox status to file
+ */
+function writeInboxStatus(status: InboxStatus): void {
+    const dir = join(homedir(), '.mycmail');
+    if (!existsSync(dir)) {
+        mkdirSync(dir, { recursive: true });
+    }
+    writeFileSync(STATUS_FILE_PATH, JSON.stringify(status, null, 2));
+}
+
+/**
+ * Clear inbox status (set to 0)
+ */
+export function clearInboxStatus(): void {
+    writeInboxStatus({ status: 0, count: 0, updatedAt: new Date().toISOString() });
+}
+
 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')
+        .option('-s, --status-file', 'Write notification status to ~/.mycmail/inbox_status.json')
+        .option('--clear-status', 'Clear the status file and exit')
         .action(async (options) => {
+            // Handle --clear-status flag
+            if (options.clearStatus) {
+                clearInboxStatus();
+                console.log('✅ Inbox status cleared (set to 0)');
+                return;
+            }
+
             const config = loadConfig();
             const agentId = options.agent || config.agentId;
 
             if (!options.quiet) {
                 console.log(`\n🍄 Watching inbox for ${agentId}...`);
+                if (options.statusFile) {
+                    console.log(`📝 Status file: ${STATUS_FILE_PATH}`);
+                    // Initialize status file to 0 at start
+                    clearInboxStatus();
+                }
                 console.log('Press Ctrl+C to stop\n');
             }
 
             const channel = subscribeToMessages(
                 agentId,
                 (message) => {
+                    // Update status file if enabled
+                    if (options.statusFile) {
+                        const currentStatus = readInboxStatus();
+                        // Detect urgency: check for "urgent" in subject (case-insensitive)
+                        const isUrgent = message.subject?.toLowerCase().includes('urgent');
+                        const newStatus: InboxStatus = {
+                            status: isUrgent ? 2 : 1,
+                            count: currentStatus.count + 1,
+                            lastMessage: {
+                                from: message.from_agent,
+                                subject: message.subject,
+                                time: message.created_at,
+                                encrypted: message.encrypted,
+                            },
+                            updatedAt: new Date().toISOString(),
+                        };
+                        writeInboxStatus(newStatus);
+                        if (!options.quiet) {
+                            console.log(`📝 Status file updated (status: ${newStatus.status}, count: ${newStatus.count})`);
+                        }
+                    }
+
                     // Show console output
                     if (!options.quiet) {
                         const time = new Date(message.created_at).toLocaleTimeString();

package/src/lib/config.ts

@@ -56,7 +56,7 @@ export function loadConfig(): Config {
 
     // Merge with env taking precedence
     const config: Config = {
-        agentId: envAgentId || fileConfig.agentId || 'anonymous',
+        agentId: (envAgentId || fileConfig.agentId || 'anonymous').toLowerCase(),
         supabaseUrl: envSupabaseUrl || fileConfig.supabaseUrl,
         supabaseKey: envSupabaseKey || fileConfig.supabaseKey,
         storageMode: envStorageMode || fileConfig.storageMode || 'auto',

package/src/lib/crypto.ts

@@ -157,7 +157,7 @@ export function loadKnownKeys(): Record<string, string> {
 export function saveKnownKey(agentId: string, publicKeyBase64: string): void {
     ensureKeysDir();
     const keys = loadKnownKeys();
-    keys[agentId] = publicKeyBase64;
+    keys[agentId.toLowerCase()] = publicKeyBase64;
     writeFileSync(join(KEYS_DIR, 'known_keys.json'), JSON.stringify(keys, null, 2));
 }
 
@@ -166,7 +166,7 @@ export function saveKnownKey(agentId: string, publicKeyBase64: string): void {
  */
 export function getKnownKey(agentId: string): string | null {
     const keys = loadKnownKeys();
-    return keys[agentId] || null;
+    return keys[agentId.toLowerCase()] || null;
 }
 
 /**
@@ -181,8 +181,9 @@ export function getKnownKeys(): Record<string, string> {
  */
 export function deleteKnownKey(agentId: string): boolean {
     const keys = loadKnownKeys();
-    if (!(agentId in keys)) return false;
-    delete keys[agentId];
+    const normalizedId = agentId.toLowerCase();
+    if (!(normalizedId in keys)) return false;
+    delete keys[normalizedId];
     writeFileSync(join(KEYS_DIR, 'known_keys.json'), JSON.stringify(keys, null, 2));
     return true;
 }

package/src/storage/local.ts

@@ -107,10 +107,12 @@ export async function sendMessage(
 export async function getInbox(agentId: string, options?: InboxOptions): Promise<Message[]> {
     const messages = loadMessages();
 
+    const normalizedAgentId = agentId.toLowerCase();
     let filtered = agentId === 'all'
         ? messages.filter(m => !m.archived)
         : messages.filter(m =>
-            (m.recipient === agentId || m.recipients?.includes(agentId)) && !m.archived
+            (m.recipient.toLowerCase() === normalizedAgentId ||
+                m.recipients?.some(r => r.toLowerCase() === normalizedAgentId)) && !m.archived
         );
 
     if (options?.unreadOnly) {
@@ -194,8 +196,9 @@ export async function archiveMessage(id: string): Promise<boolean> {
  */
 export async function getSent(agentId: string, limit?: number): Promise<Message[]> {
     const messages = loadMessages();
+    const normalizedAgentId = agentId.toLowerCase();
 
-    let filtered = messages.filter(m => m.sender === agentId);
+    let filtered = messages.filter(m => m.sender.toLowerCase() === normalizedAgentId);
 
     filtered.sort((a, b) =>
         new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime()