myceliumail 1.0.5 → 1.0.7

package/mcp-server/src/server.ts

@@ -14,6 +14,7 @@ import { z } from 'zod';
 import * as crypto from './lib/crypto.js';
 import * as storage from './lib/storage.js';
 import { getAgentId } from './lib/config.js';
+import { requireProLicense } from './lib/license.js';
 
 // Create the MCP server
 const server = new McpServer({
@@ -379,6 +380,9 @@ server.tool(
 
 // Start the server
 async function main() {
+    // Verify Pro license before starting
+    requireProLicense();
+
     const transport = new StdioServerTransport();
     await server.connect(transport);
     console.error('Myceliumail MCP server running');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "myceliumail",
-  "version": "1.0.5",
+  "version": "1.0.7",
   "description": "End-to-End Encrypted Messaging for AI Agents",
   "main": "dist/index.js",
   "type": "module",

package/src/bin/myceliumail.ts

@@ -23,6 +23,9 @@ import { createReadCommand } from '../commands/read.js';
 import { createDashboardCommand } from '../commands/dashboard.js';
 import { createBroadcastCommand } from '../commands/broadcast.js';
 import { createWatchCommand } from '../commands/watch.js';
+import { createExportCommand } from '../commands/export.js';
+import { createStatusCommand } from '../commands/status.js';
+import { createActivateCommand, createLicenseStatusCommand } from '../commands/activate.js';
 
 const program = new Command();
 
@@ -49,6 +52,13 @@ program.addCommand(createReadCommand());
 program.addCommand(createDashboardCommand());
 program.addCommand(createBroadcastCommand());
 program.addCommand(createWatchCommand());
+program.addCommand(createExportCommand());
+program.addCommand(createStatusCommand());
+
+// License management
+program.addCommand(createActivateCommand());
+program.addCommand(createLicenseStatusCommand());
 
 // Parse and run
 program.parse();
+

package/src/commands/activate.ts

@@ -0,0 +1,85 @@
+/**
+ * License Activation Command
+ * 
+ * Activates a Pro license key.
+ * Usage: mycmail activate <license-key>
+ */
+
+import { Command } from 'commander';
+import { verifyLicense, saveLicense, getLicenseStatus, FREE_TIER_LIMITS } from '../lib/license.js';
+import { loadKnownKeys } from '../lib/crypto.js';
+
+export function createActivateCommand(): Command {
+    return new Command('activate')
+        .description('Activate a Pro license key')
+        .argument('<license-key>', 'Your license key from myceliumail.dev/pro')
+        .action(async (licenseKey: string) => {
+            console.log('🍄 Activating license...\n');
+
+            // Verify the license
+            const license = verifyLicense(licenseKey);
+
+            if (!license) {
+                console.error('❌ Invalid license key');
+                console.error('   Please check your key and try again.');
+                console.error('   Get a license at: myceliumail.dev/pro');
+                process.exit(1);
+            }
+
+            if (license.isExpired) {
+                console.error('❌ This license has expired');
+                console.error(`   Expired on: ${new Date(license.data.expiresAt).toLocaleDateString()}`);
+                console.error('   Renew at: myceliumail.dev/pro');
+                process.exit(1);
+            }
+
+            // Save the license
+            const saved = saveLicense(licenseKey);
+            if (!saved) {
+                console.error('❌ Failed to save license');
+                console.error('   Please check file permissions for ~/.myceliumail/');
+                process.exit(1);
+            }
+
+            // Show success
+            const status = getLicenseStatus();
+            console.log('✅ Pro License activated!\n');
+            console.log(`   Email:    ${status.email}`);
+            console.log(`   Plan:     ${status.plan.toUpperCase()}`);
+            console.log(`   Expires:  ${new Date(status.expiresAt!).toLocaleDateString()}`);
+            console.log(`   Features: ${status.features.join(', ')}`);
+            console.log('');
+            console.log('🍄 Thank you for supporting Myceliumail!');
+        });
+}
+
+export function createLicenseStatusCommand(): Command {
+    return new Command('license')
+        .description('Show license status and plan details')
+        .action(async () => {
+            const status = getLicenseStatus();
+            const knownKeys = loadKnownKeys();
+            const keyCount = Object.keys(knownKeys).length;
+
+            console.log('🍄 Myceliumail License Status\n');
+
+            if (status.plan === 'pro') {
+                console.log(`   Plan:      💎 Pro`);
+                console.log(`   Email:     ${status.email}`);
+                console.log(`   Expires:   ${new Date(status.expiresAt!).toLocaleDateString()} (${status.daysRemaining} days)`);
+                console.log(`   Features:  ${status.features.join(', ')}`);
+                console.log(`   Keys:      ${keyCount} imported (unlimited)`);
+            } else {
+                console.log(`   Plan:      Free`);
+                console.log(`   Keys:      ${keyCount}/${FREE_TIER_LIMITS.maxImportedKeys} imported`);
+                console.log('');
+                console.log('   💎 Upgrade to Pro for:');
+                console.log('      • Unlimited imported keys');
+                console.log('      • MCP Server integration');
+                console.log('      • Cloud key backup/restore');
+                console.log('      • Real-time notifications');
+                console.log('');
+                console.log('   Get Pro: myceliumail.dev/pro');
+            }
+        });
+}

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/key-import.ts

@@ -4,6 +4,7 @@
 
 import { Command } from 'commander';
 import { saveKnownKey, getKnownKey } from '../lib/crypto.js';
+import { checkKeyLimit } from '../lib/license.js';
 
 export function createKeyImportCommand(): Command {
     return new Command('key-import')
@@ -26,6 +27,11 @@ export function createKeyImportCommand(): Command {
                 return;
             }
 
+            // Check key limit for free tier (only for new keys)
+            if (!existing) {
+                checkKeyLimit();
+            }
+
             saveKnownKey(agentId, publicKey);
 
             console.log(`✅ Imported public key for ${agentId}`);
@@ -33,3 +39,4 @@ export function createKeyImportCommand(): Command {
             console.log('\n🔐 You can now send encrypted messages to this agent');
         });
 }
+

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;
+}