myceliumail 1.0.9 → 1.0.13

package/src/commands/tags.ts

@@ -0,0 +1,102 @@
+/**
+ * tags command - List all unique hashtags from 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';
+
+/**
+ * Extract hashtag from subject (e.g., "#wake-feature: Message" -> "wake-feature")
+ */
+function extractTag(subject: string | null): string | null {
+    if (!subject) return null;
+    const match = subject.match(/^#([a-zA-Z0-9_-]+):/);
+    return match ? match[1].toLowerCase() : null;
+}
+
+export function createTagsCommand(): Command {
+    return new Command('tags')
+        .description('List all unique hashtags from your messages')
+        .option('--json', 'Output as JSON')
+        .action(async (options) => {
+            const config = loadConfig();
+            const agentId = config.agentId;
+
+            if (agentId === 'anonymous') {
+                console.error('❌ Agent ID not configured.');
+                process.exit(1);
+            }
+
+            try {
+                // Fetch all messages (up to 500)
+                const messages = await storage.getInbox(agentId, { limit: 500 });
+                const keyPair = loadKeyPair(agentId);
+
+                // Count tags
+                const tagCounts: Record<string, { count: number, unread: number }> = {};
+
+                for (const msg of messages) {
+                    let subject = msg.subject;
+
+                    // Try to decrypt if encrypted
+                    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);
+                                subject = parsed.subject || subject;
+                            }
+                        } catch {
+                            // Keep original subject
+                        }
+                    }
+
+                    const tag = extractTag(subject);
+                    if (tag) {
+                        if (!tagCounts[tag]) {
+                            tagCounts[tag] = { count: 0, unread: 0 };
+                        }
+                        tagCounts[tag].count++;
+                        if (!msg.read) {
+                            tagCounts[tag].unread++;
+                        }
+                    }
+                }
+
+                const tagList = Object.entries(tagCounts)
+                    .sort((a, b) => b[1].count - a[1].count)
+                    .map(([tag, stats]) => ({ tag, ...stats }));
+
+                if (options.json) {
+                    console.log(JSON.stringify({ tags: tagList }, null, 2));
+                    return;
+                }
+
+                if (tagList.length === 0) {
+                    console.log('📭 No tagged messages found');
+                    console.log('\n💡 Tag messages by prefixing subject with #tag:');
+                    console.log('   mycmail send wsan "#wake-feature: Need help"');
+                    return;
+                }
+
+                console.log('🏷️  Message Tags\n');
+                for (const { tag, count, unread } of tagList) {
+                    const unreadMarker = unread > 0 ? ` (${unread} unread)` : '';
+                    console.log(`  #${tag}: ${count} message${count > 1 ? 's' : ''}${unreadMarker}`);
+                }
+
+                console.log('\n💡 Filter by tag: mycmail inbox --tag <tag>');
+
+            } catch (error) {
+                console.error('❌ Failed to fetch tags:', error);
+                process.exit(1);
+            }
+        });
+}

package/src/commands/wake.ts

@@ -0,0 +1,228 @@
+/**
+ * wake command - Start a new session
+ * 
+ * Shows inbox count, active collabs, and last session time.
+ * Designed for agent session lifecycle management.
+ */
+
+import { Command } from 'commander';
+import { loadConfig } from '../lib/config.js';
+import { loadKeyPair, decryptMessage } from '../lib/crypto.js';
+import { generateDigest, sendDigestToWatsan } from '../lib/watson-digest.js';
+import * as storage from '../storage/supabase.js';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+
+interface SessionData {
+    lastWake: string | null;
+    lastClose: string | null;
+    activeCollabs: string[];
+}
+
+function getSessionPath(): string {
+    return path.join(os.homedir(), '.mycmail', 'session.json');
+}
+
+function loadSession(): SessionData {
+    const sessionPath = getSessionPath();
+    try {
+        if (fs.existsSync(sessionPath)) {
+            return JSON.parse(fs.readFileSync(sessionPath, 'utf-8'));
+        }
+    } catch {
+        // Ignore errors, return default
+    }
+    return { lastWake: null, lastClose: null, activeCollabs: [] };
+}
+
+function saveSession(data: SessionData): void {
+    const sessionPath = getSessionPath();
+    const dir = path.dirname(sessionPath);
+    if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+    }
+    fs.writeFileSync(sessionPath, JSON.stringify(data, null, 2));
+}
+
+function formatTimeSince(date: string | null): string {
+    if (!date) return 'Never';
+    const now = new Date();
+    const then = new Date(date);
+    const diffMs = now.getTime() - then.getTime();
+    const diffMins = Math.floor(diffMs / 60000);
+    const diffHours = Math.floor(diffMins / 60);
+    const diffDays = Math.floor(diffHours / 24);
+
+    if (diffMins < 1) return 'Just now';
+    if (diffMins < 60) return `${diffMins} minutes ago`;
+    if (diffHours < 24) return `${diffHours} hours ago`;
+    return `${diffDays} days ago`;
+}
+
+function extractTag(subject: string | null): string | null {
+    if (!subject) return null;
+    const match = subject.match(/^#([a-zA-Z0-9_-]+):/);
+    return match ? match[1].toLowerCase() : null;
+}
+
+interface TagDigest {
+    tag: string;
+    count: number;
+    unread: number;
+}
+
+async function getTagDigest(agentId: string, messages: any[]): Promise<TagDigest[]> {
+    const keyPair = loadKeyPair(agentId);
+    const tagCounts: Record<string, { count: number; unread: number }> = {};
+
+    for (const msg of messages) {
+        let subject = msg.subject;
+
+        // Try to decrypt if encrypted
+        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);
+                    subject = parsed.subject || subject;
+                }
+            } catch {
+                // Keep original subject
+            }
+        }
+
+        const tag = extractTag(subject);
+        if (tag) {
+            if (!tagCounts[tag]) {
+                tagCounts[tag] = { count: 0, unread: 0 };
+            }
+            tagCounts[tag].count++;
+            if (!msg.read) {
+                tagCounts[tag].unread++;
+            }
+        }
+    }
+
+    return Object.entries(tagCounts)
+        .sort((a, b) => b[1].unread - a[1].unread)
+        .slice(0, 5)
+        .map(([tag, stats]) => ({ tag, ...stats }));
+}
+
+export function createWakeCommand(): Command {
+    return new Command('wake')
+        .description('Start a new session - check inbox, collabs, and announce presence')
+        .option('--json', 'Output as JSON (for scripting)')
+        .option('-q, --quiet', 'Minimal output')
+        .option('--silent', 'No output (only exit code)')
+        .option('--digest', 'Show hashtag digest and active threads')
+        .action(async (options) => {
+            const config = loadConfig();
+            const agentId = config.agentId;
+
+            if (agentId === 'anonymous') {
+                if (!options.silent) {
+                    console.error('❌ Agent ID not configured.');
+                }
+                process.exit(1);
+            }
+
+            try {
+                // Load session data
+                const session = loadSession();
+
+                // Check if this is a duplicate wake (idempotency)
+                if (session.lastWake) {
+                    const lastWakeTime = new Date(session.lastWake);
+                    const now = new Date();
+                    const diffMins = (now.getTime() - lastWakeTime.getTime()) / 60000;
+
+                    // If woken up less than 5 minutes ago, skip re-registration
+                    if (diffMins < 5 && !options.json) {
+                        if (!options.silent && !options.quiet) {
+                            console.log(`⏰ Already woke ${Math.floor(diffMins)} min ago. Use --force to re-wake.`);
+                        }
+                        // Still show status but don't re-register
+                    }
+                }
+
+                // Get inbox count
+                const messages = await storage.getInbox(agentId, { limit: 100 });
+                const unreadCount = messages.filter(m => !m.read).length;
+                const totalCount = messages.length;
+
+                // Update session
+                session.lastWake = new Date().toISOString();
+                saveSession(session);
+
+                // Output based on mode
+                if (options.silent) {
+                    process.exit(0);
+                }
+
+                if (options.json) {
+                    const output = {
+                        agentId,
+                        inbox: {
+                            total: totalCount,
+                            unread: unreadCount
+                        },
+                        lastClose: session.lastClose,
+                        activeCollabs: session.activeCollabs,
+                        wakeTime: session.lastWake
+                    };
+                    console.log(JSON.stringify(output, null, 2));
+                    return;
+                }
+
+                // Standard output
+                console.log(`\n🌅 Good morning, ${agentId}!\n`);
+                console.log(`📬 Inbox: ${unreadCount} unread / ${totalCount} total`);
+                console.log(`📋 Active collabs: ${session.activeCollabs.length}`);
+                console.log(`🕐 Last close: ${formatTimeSince(session.lastClose)}`);
+
+                // Show digest if requested
+                if (options.digest) {
+                    const digest = await getTagDigest(agentId, messages);
+                    if (digest.length > 0) {
+                        console.log('\n🏷️  Active Threads:');
+                        for (const { tag, count, unread } of digest) {
+                            const unreadMarker = unread > 0 ? ` (${unread} new)` : '';
+                            console.log(`   #${tag}: ${count}${unreadMarker}`);
+                        }
+                    }
+                }
+
+                if (!options.quiet) {
+                    console.log('\n💡 Tip: Run \'mycmail inbox\' to read messages');
+                }
+
+                console.log('\n✅ Session started!\n');
+
+                // Send digest to watson (unencrypted)
+                if (!options.silent) {
+                    try {
+                        const wakeDigest = await generateDigest(agentId, 'wake');
+                        await sendDigestToWatsan(wakeDigest);
+                        if (!options.quiet) {
+                            console.log('📊 Digest sent to watson');
+                        }
+                    } catch {
+                        // Silent fail - digest is optional
+                    }
+                }
+
+            } catch (error) {
+                if (!options.silent) {
+                    console.error('❌ Wake failed:', error);
+                }
+                process.exit(1);
+            }
+        });
+}

package/src/dashboard/public/app.js

@@ -521,3 +521,120 @@ loadInbox();
 
 // Poll every 30 seconds as fallback (Realtime handles instant updates)
 setInterval(() => loadInbox(true), 30000);
+
+// ============== COMPOSE MESSAGE FUNCTIONS ==============
+
+let availableAgents = [];
+
+// Load available agents for compose dropdown
+async function loadAvailableAgents() {
+    try {
+        const res = await fetch('/api/config/agents');
+        const data = await res.json();
+        availableAgents = data.agents || [];
+        updateAgentDropdown();
+    } catch (err) {
+        console.error('Failed to load agents:', err);
+    }
+}
+
+function updateAgentDropdown() {
+    const select = document.getElementById('compose-from');
+    if (!select) return;
+
+    if (availableAgents.length === 0) {
+        select.innerHTML = `<option value="${currentAgentId}">${currentAgentId}</option>`;
+    } else {
+        select.innerHTML = availableAgents.map(agent =>
+            `<option value="${agent}" ${agent === 'treebird' ? 'selected' : ''}>${agent}</option>`
+        ).join('');
+    }
+}
+
+function showComposeModal() {
+    loadAvailableAgents();
+    document.getElementById('compose-modal').classList.remove('hidden');
+    document.getElementById('compose-to').focus();
+}
+
+function hideComposeModal() {
+    document.getElementById('compose-modal').classList.add('hidden');
+    // Clear form
+    document.getElementById('compose-to').value = '';
+    document.getElementById('compose-subject').value = '';
+    document.getElementById('compose-body').value = '';
+    document.getElementById('compose-files').value = '';
+}
+
+async function sendNewMessage() {
+    const from = document.getElementById('compose-from').value;
+    const to = document.getElementById('compose-to').value.trim();
+    const subject = document.getElementById('compose-subject').value.trim();
+    const body = document.getElementById('compose-body').value;
+    const fileInput = document.getElementById('compose-files');
+
+    if (!to) {
+        alert('Please enter a recipient');
+        return;
+    }
+    if (!subject) {
+        alert('Please enter a subject');
+        return;
+    }
+    if (!body.trim()) {
+        alert('Please enter a message');
+        return;
+    }
+
+    // Process attachments
+    const attachments = [];
+    const MAX_SIZE = 5 * 1024 * 1024; // 5MB
+
+    if (fileInput && fileInput.files.length > 0) {
+        for (const file of fileInput.files) {
+            if (file.size > MAX_SIZE) {
+                alert(`File "${file.name}" exceeds 5MB limit`);
+                return;
+            }
+            const base64 = await readFileAsBase64(file);
+            attachments.push({
+                name: file.name,
+                type: file.type || 'application/octet-stream',
+                data: base64,
+                size: file.size
+            });
+        }
+    }
+
+    try {
+        console.log('Sending message from:', from, 'to:', to);
+        const response = await fetch('/api/send', {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                to: to,
+                subject: subject,
+                body: body,
+                from: from,
+                attachments: attachments.length > 0 ? attachments : undefined
+            })
+        });
+
+        const result = await response.json();
+        console.log('Send result:', result);
+
+        if (!response.ok || !result.success) {
+            throw new Error(result.error || 'Failed to send');
+        }
+
+        hideComposeModal();
+        alert('Message sent!' + (attachments.length > 0 ? ` (${attachments.length} attachment(s))` : ''));
+        loadInbox(true);
+    } catch (err) {
+        console.error('Send message error:', err);
+        alert('Failed to send message: ' + err.message);
+    }
+}
+
+// Load agents on startup
+loadAvailableAgents();

package/src/dashboard/public/index.html

@@ -45,17 +45,75 @@
                 <div
                     class="p-4 border-b border-gray-800 bg-gray-900/50 backdrop-blur flex items-center justify-between">
                     <h2 class="text-xl font-semibold text-gray-200">Inbox</h2>
-                    <button onclick="loadInbox(false)"
-                        class="p-2 text-gray-400 hover:text-white hover:bg-gray-800 rounded-lg transition-colors"
-                        title="Refresh inbox">
-                        🔄
-                    </button>
+                    <div class="flex gap-2">
+                        <button onclick="showComposeModal()"
+                            class="px-3 py-1.5 bg-purple-600 text-white text-sm rounded-lg hover:bg-purple-500 transition-colors flex items-center gap-1.5"
+                            title="Compose new message">
+                            ✉️ Compose
+                        </button>
+                        <button onclick="loadInbox(false)"
+                            class="p-2 text-gray-400 hover:text-white hover:bg-gray-800 rounded-lg transition-colors"
+                            title="Refresh inbox">
+                            🔄
+                        </button>
+                    </div>
                 </div>
                 <div id="inbox-list" class="flex-1 overflow-y-auto p-2 space-y-2">
                     <!-- Messages will act here -->
                 </div>
             </div>
 
+            <!-- Compose Modal -->
+            <div id="compose-modal"
+                class="hidden fixed inset-0 bg-black/70 backdrop-blur-sm z-50 flex items-center justify-center p-4">
+                <div
+                    class="bg-gray-900 rounded-2xl border border-gray-700 shadow-2xl w-full max-w-2xl max-h-[90vh] overflow-y-auto">
+                    <div class="p-6 border-b border-gray-800 flex justify-between items-center">
+                        <h2 class="text-2xl font-bold text-white">✉️ Compose Message</h2>
+                        <button onclick="hideComposeModal()"
+                            class="text-gray-400 hover:text-white text-2xl">&times;</button>
+                    </div>
+                    <div class="p-6 space-y-4">
+                        <div class="grid grid-cols-2 gap-4">
+                            <div>
+                                <label class="block text-gray-400 mb-2">From:</label>
+                                <select id="compose-from"
+                                    class="w-full bg-gray-800 border border-gray-700 rounded-lg px-4 py-3 text-white focus:border-purple-500 focus:outline-none">
+                                    <option value="">Loading agents...</option>
+                                </select>
+                            </div>
+                            <div>
+                                <label class="block text-gray-400 mb-2">To:</label>
+                                <input type="text" id="compose-to" placeholder="recipient agent ID"
+                                    class="w-full bg-gray-800 border border-gray-700 rounded-lg px-4 py-3 text-white focus:border-purple-500 focus:outline-none">
+                            </div>
+                        </div>
+                        <div>
+                            <label class="block text-gray-400 mb-2">Subject:</label>
+                            <input type="text" id="compose-subject" placeholder="Message subject"
+                                class="w-full bg-gray-800 border border-gray-700 rounded-lg px-4 py-3 text-white focus:border-purple-500 focus:outline-none">
+                        </div>
+                        <div>
+                            <label class="block text-gray-400 mb-2">Message:</label>
+                            <textarea id="compose-body" rows="8" placeholder="Write your message..."
+                                class="w-full bg-gray-800 border border-gray-700 rounded-lg px-4 py-3 text-white focus:border-purple-500 focus:outline-none resize-none"></textarea>
+                        </div>
+                        <div>
+                            <label class="block text-gray-400 mb-2">Attachments (optional):</label>
+                            <input type="file" id="compose-files" multiple
+                                class="w-full bg-gray-800 border border-gray-700 rounded-lg px-4 py-3 text-white file:mr-4 file:py-2 file:px-4 file:rounded file:border-0 file:bg-purple-600 file:text-white file:cursor-pointer">
+                        </div>
+                        <div class="flex gap-4 justify-end pt-4">
+                            <button onclick="hideComposeModal()"
+                                class="px-6 py-3 bg-gray-800 text-gray-300 rounded-lg hover:bg-gray-700">Cancel</button>
+                            <button onclick="sendNewMessage()"
+                                class="px-6 py-3 bg-purple-600 text-white rounded-lg hover:bg-purple-500 font-medium">Send
+                                Message</button>
+                        </div>
+                    </div>
+                </div>
+            </div>
+
             <!-- Message Detail -->
             <div
                 class="col-span-8 bg-gray-900 rounded-xl border border-gray-800 flex flex-col overflow-hidden relative">

package/src/dashboard/routes.ts

@@ -46,9 +46,38 @@ export async function registerRoutes(fastify: FastifyInstance) {
     const config = loadConfig();
     const agentId = config.agentId;
 
-    // GET /api/inbox
+    // GET /api/config/agents - List all agent IDs with keys
+    fastify.get('/api/config/agents', async (request, reply) => {
+        const agents = listOwnKeys();
+        // Include config agent if not already in list
+        if (agentId && !agents.includes(agentId)) {
+            agents.unshift(agentId);
+        }
+        return { agents };
+    });
+
+    // GET /api/inbox - Now supports multi-agent queries
     fastify.get('/api/inbox', async (request, reply) => {
-        const messages = await storage.getInbox(agentId, { limit: 100 });
+        const queryAgents = (request.query as { agents?: string }).agents;
+
+        let messages;
+        if (queryAgents) {
+            // Use specific agents if provided
+            const agentIds = queryAgents.split(',').map(s => s.trim());
+            messages = await storage.getMultiAgentInbox(agentIds, { limit: 100 });
+        } else {
+            // Default: get messages for ALL agents with keys
+            const allAgentIds = listOwnKeys();
+            if (agentId && !allAgentIds.includes(agentId)) {
+                allAgentIds.unshift(agentId);
+            }
+            if (allAgentIds.length > 0) {
+                messages = await storage.getMultiAgentInbox(allAgentIds, { limit: 100 });
+            } else {
+                // Fallback to single agent query
+                messages = await storage.getInbox(agentId, { limit: 100 });
+            }
+        }
 
         // Decrypt encrypted messages using all available keys
         const decrypted = messages.map(tryDecryptWithAllKeys);

package/src/lib/update-check.ts

@@ -6,8 +6,12 @@
  */
 
 import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'fs';
-import { join } from 'path';
+import { join, dirname } from 'path';
 import { homedir } from 'os';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
 
 const CONFIG_DIR = join(homedir(), '.myceliumail');
 const UPDATE_CACHE = join(CONFIG_DIR, 'update-cache.json');
@@ -24,9 +28,8 @@ interface UpdateCache {
  */
 function getCurrentVersion(): string {
     try {
-        // Read from the installed package
-        const packagePath = new URL('../package.json', import.meta.url);
-        const pkg = JSON.parse(readFileSync(packagePath, 'utf-8'));
+        // Read from the installed package (2 levels up from dist/lib/)
+        const pkg = JSON.parse(readFileSync(join(__dirname, '../../package.json'), 'utf-8'));
         return pkg.version;
     } catch {
         return '0.0.0';