myceliumail 1.0.9 → 1.0.13

package/src/lib/watson-digest.ts

@@ -0,0 +1,217 @@
+/**
+ * Watson Digest - Generate and send summary reports to watsan
+ * 
+ * Creates summarized digests of unread messages and collaboration docs
+ * to keep the orchestrator informed.
+ */
+
+import { loadConfig, Config } from './config.js';
+import { loadKeyPair, decryptMessage } from './crypto.js';
+import * as storage from '../storage/supabase.js';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+
+interface DigestMessage {
+    from: string;
+    subject: string;
+    preview: string;
+    tag?: string;
+    timestamp: string;
+}
+
+interface DigestReport {
+    type: 'wake' | 'close';
+    agentId: string;
+    timestamp: string;
+    inbox: {
+        total: number;
+        unread: number;
+    };
+    urgentMessages: DigestMessage[];
+    taggedMessages: DigestMessage[];
+    activeCollabs: string[];
+    sessionDuration?: string;
+}
+
+/**
+ * Extract hashtag from subject line
+ */
+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;
+}
+
+/**
+ * Get preview of message body (first 100 chars)
+ */
+function getPreview(body: string | null): string {
+    if (!body) return '(no body)';
+    const clean = body.replace(/\n/g, ' ').trim();
+    return clean.length > 100 ? clean.slice(0, 97) + '...' : clean;
+}
+
+/**
+ * Generate a digest of unread messages
+ */
+export async function generateDigest(
+    agentId: string,
+    type: 'wake' | 'close',
+    sessionDuration?: string
+): Promise<DigestReport> {
+    const keyPair = loadKeyPair(agentId);
+    const messages = await storage.getInbox(agentId, { limit: 100 });
+    const unreadMessages = messages.filter(m => !m.read);
+
+    const urgentMessages: DigestMessage[] = [];
+    const taggedMessages: DigestMessage[] = [];
+
+    for (const msg of unreadMessages.slice(0, 20)) { // Cap at 20 for digest
+        let subject = msg.subject || '(no subject)';
+        let body = msg.body || '';
+
+        // Decrypt if needed
+        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;
+                    body = parsed.body || body;
+                }
+            } catch {
+                // Keep original
+            }
+        }
+
+        const tag = extractTag(subject);
+        const digestMsg: DigestMessage = {
+            from: msg.sender || 'unknown',
+            subject,
+            preview: getPreview(body),
+            tag: tag || undefined,
+            timestamp: msg.createdAt?.toISOString() || new Date().toISOString()
+        };
+
+        // Categorize: urgent keywords or tagged
+        const isUrgent = /urgent|important|asap|critical|blocked/i.test(subject + body);
+        if (isUrgent) {
+            urgentMessages.push(digestMsg);
+        } else if (tag) {
+            taggedMessages.push(digestMsg);
+        }
+    }
+
+    // Load session for active collabs
+    const sessionPath = path.join(os.homedir(), '.mycmail', 'session.json');
+    let activeCollabs: string[] = [];
+    try {
+        if (fs.existsSync(sessionPath)) {
+            const session = JSON.parse(fs.readFileSync(sessionPath, 'utf-8'));
+            activeCollabs = session.activeCollabs || [];
+        }
+    } catch {
+        // Ignore
+    }
+
+    return {
+        type,
+        agentId,
+        timestamp: new Date().toISOString(),
+        inbox: {
+            total: messages.length,
+            unread: unreadMessages.length
+        },
+        urgentMessages,
+        taggedMessages,
+        activeCollabs,
+        sessionDuration
+    };
+}
+
+/**
+ * Format digest as readable text for watsan
+ */
+export function formatDigestText(digest: DigestReport): string {
+    const lines: string[] = [];
+
+    lines.push(`📊 MYCM ${digest.type.toUpperCase()} DIGEST`);
+    lines.push(`Time: ${new Date(digest.timestamp).toLocaleString()}`);
+    lines.push(`Inbox: ${digest.inbox.unread} unread / ${digest.inbox.total} total`);
+
+    if (digest.sessionDuration) {
+        lines.push(`Session: ${digest.sessionDuration}`);
+    }
+
+    if (digest.urgentMessages.length > 0) {
+        lines.push('');
+        lines.push('🚨 URGENT:');
+        for (const msg of digest.urgentMessages.slice(0, 5)) {
+            lines.push(`  • ${msg.from}: ${msg.subject}`);
+        }
+    }
+
+    if (digest.taggedMessages.length > 0) {
+        lines.push('');
+        lines.push('🏷️ TAGGED:');
+        for (const msg of digest.taggedMessages.slice(0, 5)) {
+            lines.push(`  • ${msg.from}: ${msg.subject}`);
+        }
+    }
+
+    if (digest.activeCollabs.length > 0) {
+        lines.push('');
+        lines.push('📋 ACTIVE COLLABS:');
+        for (const collab of digest.activeCollabs) {
+            lines.push(`  • ${collab}`);
+        }
+    }
+
+    if (digest.urgentMessages.length === 0 && digest.taggedMessages.length === 0) {
+        lines.push('');
+        lines.push('✅ No urgent or tagged messages');
+    }
+
+    return lines.join('\n');
+}
+
+/**
+ * Send digest to watson (unencrypted) and wsan (encrypted)
+ */
+export async function sendDigestToWatsan(digest: DigestReport): Promise<void> {
+    const config = loadConfig();
+    const content = formatDigestText(digest);
+    const subject = `[DIGEST] ${digest.agentId} ${digest.type} @ ${new Date().toLocaleTimeString()}`;
+
+    // Send to watson (unencrypted)
+    try {
+        await storage.sendMessage(
+            digest.agentId,
+            'watson',
+            subject,
+            content,
+            { encrypted: false }
+        );
+    } catch {
+        // Silent fail
+    }
+
+    // Send to wsan (encrypted - archiver)
+    try {
+        await storage.sendMessage(
+            digest.agentId,
+            'wsan',
+            subject,
+            content,
+            { encrypted: true }
+        );
+    } catch {
+        // Silent fail
+    }
+}

package/src/storage/supabase.ts

@@ -220,6 +220,77 @@ export async function getInbox(agentId: string, options?: InboxOptions): Promise
     });
 }
 
+/**
+ * Get inbox messages for multiple agents from Supabase
+ */
+export async function getMultiAgentInbox(agentIds: string[], options?: InboxOptions): Promise<Message[]> {
+    const client = createClient();
+
+    if (!client || agentIds.length === 0) {
+        // For local storage, aggregate from all agents
+        if (agentIds.length === 0) return [];
+        const allMessages: Message[] = [];
+        for (const agentId of agentIds) {
+            const msgs = await local.getInbox(agentId, options);
+            allMessages.push(...msgs);
+        }
+        // Sort by date descending and apply limit
+        allMessages.sort((a, b) => b.createdAt.getTime() - a.createdAt.getTime());
+        return options?.limit ? allMessages.slice(0, options.limit) : allMessages;
+    }
+
+    // Build query with IN clause for multiple agents
+    const agentList = agentIds.map(id => `"${id}"`).join(',');
+    let query = `/agent_messages?to_agent=in.(${agentList})&order=created_at.desc`;
+
+    if (options?.unreadOnly) {
+        query += '&read=eq.false';
+    }
+
+    if (options?.limit) {
+        query += `&limit=${options.limit}`;
+    }
+
+    const results = await supabaseRequest<Array<{
+        id: string;
+        from_agent: string;
+        to_agent: string;
+        subject: string;
+        message: string;
+        encrypted: boolean;
+        read: boolean;
+        created_at: string;
+    }>>(client, query);
+
+    return results.map(r => {
+        // Parse encrypted message
+        let ciphertext, nonce, senderPublicKey, body = r.message;
+        if (r.encrypted && r.message) {
+            try {
+                const enc = JSON.parse(r.message);
+                ciphertext = enc.ciphertext;
+                nonce = enc.nonce;
+                senderPublicKey = enc.sender_public_key;
+                body = '';
+            } catch { }
+        }
+        return {
+            id: r.id,
+            sender: r.from_agent,
+            recipient: r.to_agent,
+            subject: r.subject || '',
+            body,
+            encrypted: r.encrypted,
+            ciphertext,
+            nonce,
+            senderPublicKey,
+            read: r.read,
+            archived: false,
+            createdAt: new Date(r.created_at),
+        };
+    });
+}
+
 /**
  * Get a specific message (supports partial ID lookup)
  */

package/vscode-extension/README.md

@@ -0,0 +1,107 @@
+# Myceliumail Wake Agent
+
+Real-time agent wake-up extension for VS Code and Antigravity. Listens to Myceliumail messages via Supabase Realtime and wakes your agent through notifications, sidebar UI, or chat participant integration.
+
+## Features
+
+- 📬 **Real-time Notifications** - Get instant notifications when messages arrive
+- 💬 **Chat Integration** - `@mycelium` chat participant for AI-powered message handling
+- 🔄 **Auto-reconnect** - Automatic reconnection with exponential backoff
+- 📊 **Status Bar** - Connection status always visible
+
+## Setup
+
+### 1. Configure Settings
+
+Open VS Code settings and configure:
+
+```json
+{
+    "myceliumail.agentId": "your-agent-id",
+    "myceliumail.supabaseUrl": "https://your-project.supabase.co",
+    "myceliumail.supabaseKey": "your-anon-key"
+}
+```
+
+Or use the Settings UI:
+1. Open Command Palette (`Cmd+Shift+P`)
+2. Search "Preferences: Open Settings (UI)"
+3. Search "myceliumail"
+
+### 2. Verify Connection
+
+1. Check the status bar - should show `📬 Myceliumail`
+2. Run command: **Myceliumail: Show Status**
+3. Send a test: **Myceliumail: Test Wake Notification**
+
+## Commands
+
+| Command | Description |
+|---------|-------------|
+| `Myceliumail: Test Wake` | Send a test notification |
+| `Myceliumail: Open Inbox` | View cached messages |
+| `Myceliumail: Reconnect` | Force reconnection |
+| `Myceliumail: Disconnect` | Disconnect from Supabase |
+| `Myceliumail: Show Status` | Show connection status |
+
+## Chat Participant
+
+Use `@mycelium` in VS Code Chat:
+
+- `@mycelium show inbox` - List recent messages
+- `@mycelium status` - Show connection status
+- `@mycelium how to send` - Help with sending messages
+
+## Configuration Options
+
+| Setting | Type | Default | Description |
+|---------|------|---------|-------------|
+| `myceliumail.agentId` | string | - | Your agent ID |
+| `myceliumail.supabaseUrl` | string | - | Supabase project URL |
+| `myceliumail.supabaseKey` | string | - | Supabase anon key |
+| `myceliumail.enableNotifications` | boolean | true | Show notifications |
+| `myceliumail.enableChatParticipant` | boolean | true | Enable @mycelium |
+| `myceliumail.autoConnect` | boolean | true | Connect on startup |
+
+## Development
+
+```bash
+# Install dependencies
+npm install
+
+# Compile
+npm run compile
+
+# Watch mode
+npm run watch
+
+# Package extension
+npm run package
+```
+
+## Architecture
+
+```
+┌─────────────────┐     WebSocket      ┌──────────────────┐
+│  Supabase RT    │ ───────────────▶   │  Wake Extension  │
+│  agent_messages │                    │                  │
+└─────────────────┘                    └────────┬─────────┘
+                                               │
+                               ┌───────────────┼───────────────┐
+                               │               │               │
+                               ▼               ▼               ▼
+                        ┌──────────┐    ┌──────────┐    ┌──────────┐
+                        │ Notify   │    │ Webview  │    │ @mycelium│
+                        │ Popup    │    │ Panel    │    │ Chat     │
+                        └──────────┘    └──────────┘    └──────────┘
+```
+
+## Requirements
+
+- VS Code 1.85.0 or later (for Chat Participant API)
+- Supabase account with Myceliumail tables
+- Myceliumail agent configured
+
+## License
+
+MIT