myceliumail 1.0.2 → 1.0.3

package/src/storage/local.ts

@@ -0,0 +1,209 @@
+/**
+ * Local JSON Storage Adapter
+ * 
+ * Stores messages in a local JSON file for offline/testing use.
+ */
+
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+import { randomUUID } from 'crypto';
+import type { Message, InboxOptions } from '../types/index.js';
+
+const DATA_DIR = join(homedir(), '.myceliumail', 'data');
+const MESSAGES_FILE = join(DATA_DIR, 'messages.json');
+
+interface StoredMessage extends Omit<Message, 'createdAt'> {
+    createdAt: string;
+}
+
+/**
+ * Ensure data directory exists
+ */
+function ensureDataDir(): void {
+    if (!existsSync(DATA_DIR)) {
+        mkdirSync(DATA_DIR, { recursive: true });
+    }
+}
+
+/**
+ * Load all messages from storage
+ */
+function loadMessages(): StoredMessage[] {
+    if (!existsSync(MESSAGES_FILE)) return [];
+    try {
+        return JSON.parse(readFileSync(MESSAGES_FILE, 'utf-8'));
+    } catch {
+        return [];
+    }
+}
+
+/**
+ * Save messages to storage
+ */
+function saveMessages(messages: StoredMessage[]): void {
+    ensureDataDir();
+    writeFileSync(MESSAGES_FILE, JSON.stringify(messages, null, 2));
+}
+
+/**
+ * Convert stored message to Message type
+ */
+function toMessage(stored: StoredMessage): Message {
+    return {
+        ...stored,
+        createdAt: new Date(stored.createdAt),
+    };
+}
+
+/**
+ * Send a message (store locally)
+ */
+export async function sendMessage(
+    sender: string,
+    recipient: string | string[],
+    subject: string,
+    body: string,
+    options?: {
+        encrypted?: boolean;
+        ciphertext?: string;
+        nonce?: string;
+        senderPublicKey?: string;
+        attachments?: { name: string; type: string; data: string; size: number }[];
+    }
+): Promise<Message> {
+    const messages = loadMessages();
+
+    // Handle multi-recipient
+    const recipientList = Array.isArray(recipient) ? recipient : [recipient];
+    const primaryRecipient = recipientList[0];
+
+    const newMessage: StoredMessage = {
+        id: randomUUID(),
+        sender,
+        recipient: primaryRecipient,
+        recipients: recipientList.length > 1 ? recipientList : undefined,
+        subject: options?.encrypted ? '' : subject,
+        body: options?.encrypted ? '' : body,
+        encrypted: options?.encrypted || false,
+        ciphertext: options?.ciphertext,
+        nonce: options?.nonce,
+        senderPublicKey: options?.senderPublicKey,
+        attachments: options?.attachments,
+        read: false,
+        archived: false,
+        createdAt: new Date().toISOString(),
+    };
+
+    messages.push(newMessage);
+    saveMessages(messages);
+
+    return toMessage(newMessage);
+}
+
+/**
+ * Get inbox messages for an agent (use 'all' for all messages)
+ */
+export async function getInbox(agentId: string, options?: InboxOptions): Promise<Message[]> {
+    const messages = loadMessages();
+
+    let filtered = agentId === 'all'
+        ? messages.filter(m => !m.archived)
+        : messages.filter(m =>
+            (m.recipient === agentId || m.recipients?.includes(agentId)) && !m.archived
+        );
+
+    if (options?.unreadOnly) {
+        filtered = filtered.filter(m => !m.read);
+    }
+
+    // Sort by date descending (newest first)
+    filtered.sort((a, b) =>
+        new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime()
+    );
+
+    if (options?.limit) {
+        filtered = filtered.slice(0, options.limit);
+    }
+
+    return filtered.map(toMessage);
+}
+
+/**
+ * Get a specific message by ID
+ */
+export async function getMessage(id: string): Promise<Message | null> {
+    const messages = loadMessages();
+    const found = messages.find(m => m.id === id);
+    return found ? toMessage(found) : null;
+}
+
+/**
+ * Mark message as read by an agent
+ */
+export async function markAsRead(id: string, agentId?: string): Promise<boolean> {
+    const messages = loadMessages();
+    const index = messages.findIndex(m => m.id === id);
+    if (index === -1) return false;
+
+    // Initialize readBy if not present
+    if (!messages[index].readBy) {
+        messages[index].readBy = [];
+    }
+
+    // Add agent to readBy if provided and not already there
+    if (agentId && !messages[index].readBy!.includes(agentId)) {
+        messages[index].readBy!.push(agentId);
+    }
+
+    // Legacy compat
+    messages[index].read = true;
+
+    saveMessages(messages);
+    return true;
+}
+
+/**
+ * Delete a message
+ */
+export async function deleteMessage(id: string): Promise<boolean> {
+    const messages = loadMessages();
+    const index = messages.findIndex(m => m.id === id);
+    if (index === -1) return false;
+
+    messages.splice(index, 1);
+    saveMessages(messages);
+    return true;
+}
+
+/**
+ * Archive a message
+ */
+export async function archiveMessage(id: string): Promise<boolean> {
+    const messages = loadMessages();
+    const index = messages.findIndex(m => m.id === id);
+    if (index === -1) return false;
+
+    messages[index].archived = true;
+    saveMessages(messages);
+    return true;
+}
+
+/**
+ * Get sent messages
+ */
+export async function getSent(agentId: string, limit?: number): Promise<Message[]> {
+    const messages = loadMessages();
+
+    let filtered = messages.filter(m => m.sender === agentId);
+
+    filtered.sort((a, b) =>
+        new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime()
+    );
+
+    if (limit) {
+        filtered = filtered.slice(0, limit);
+    }
+
+    return filtered.map(toMessage);
+}

package/src/storage/supabase.ts

@@ -0,0 +1,336 @@
+/**
+ * Supabase Storage Adapter
+ * 
+ * Stores messages in Supabase PostgreSQL for cloud sync.
+ * Falls back to local storage if Supabase is not configured.
+ */
+
+import { loadConfig, hasSupabaseConfig } from '../lib/config.js';
+import type { Message, InboxOptions } from '../types/index.js';
+import * as local from './local.js';
+
+// Simple fetch-based Supabase client (no dependencies)
+interface SupabaseClient {
+    url: string;
+    key: string;
+}
+
+function createClient(): SupabaseClient | null {
+    const config = loadConfig();
+
+    // Force local storage if mode is 'local'
+    if (config.storageMode === 'local') {
+        return null;
+    }
+
+    // Check if Supabase is configured
+    if (!hasSupabaseConfig(config)) {
+        // Error if mode is 'supabase' but not configured
+        if (config.storageMode === 'supabase') {
+            console.error('❌ MYCELIUMAIL_STORAGE=supabase but Supabase not configured!');
+            console.error('   Set SUPABASE_URL and SUPABASE_ANON_KEY environment variables.');
+        }
+        return null;
+    }
+
+    return {
+        url: config.supabaseUrl!,
+        key: config.supabaseKey!,
+    };
+}
+
+async function supabaseRequest<T>(
+    client: SupabaseClient,
+    path: string,
+    options: RequestInit = {}
+): Promise<T> {
+    const url = `${client.url}/rest/v1${path}`;
+
+    // Create abort controller for timeout
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), 10000); // 10 second timeout
+
+    try {
+        const response = await fetch(url, {
+            ...options,
+            signal: controller.signal,
+            headers: {
+                'Content-Type': 'application/json',
+                'apikey': client.key,
+                'Authorization': `Bearer ${client.key}`,
+                'Prefer': options.method === 'POST' ? 'return=representation' : 'return=minimal',
+                ...options.headers,
+            },
+        });
+
+        clearTimeout(timeoutId);
+
+        if (!response.ok) {
+            const error = await response.text();
+            throw new Error(`Supabase error: ${error}`);
+        }
+
+        if (response.status === 204) return {} as T;
+        return response.json() as Promise<T>;
+    } catch (error) {
+        clearTimeout(timeoutId);
+        if (error instanceof Error && error.name === 'AbortError') {
+            throw new Error('Supabase request timed out after 10 seconds');
+        }
+        throw error;
+    }
+}
+
+/**
+ * Send a message via Supabase
+ */
+export async function sendMessage(
+    sender: string,
+    recipient: string | string[],
+    subject: string,
+    body: string,
+    options?: {
+        encrypted?: boolean;
+        ciphertext?: string;
+        nonce?: string;
+        senderPublicKey?: string;
+        attachments?: { name: string; type: string; data: string; size: number }[];
+    }
+): Promise<Message> {
+    const client = createClient();
+
+    // Fall back to local if no Supabase
+    if (!client) {
+        return local.sendMessage(sender, recipient, subject, body, options);
+    }
+
+    const payload = {
+        from_agent: sender,
+        to_agent: recipient,
+        subject: options?.encrypted ? '🔒 [Encrypted Message]' : subject,
+        message: options?.encrypted ? JSON.stringify({
+            ciphertext: options?.ciphertext,
+            nonce: options?.nonce,
+            sender_public_key: options?.senderPublicKey,
+        }) : body,
+        encrypted: options?.encrypted || false,
+    };
+
+    const [result] = await supabaseRequest<Array<{
+        id: string;
+        from_agent: string;
+        to_agent: string;
+        subject: string;
+        message: string;
+        encrypted: boolean;
+        read: boolean;
+        created_at: string;
+    }>>(client, '/agent_messages', {
+        method: 'POST',
+        body: JSON.stringify(payload),
+    });
+
+    // Parse encrypted message if needed
+    let parsedMessage = result.message;
+    let ciphertext, nonce, senderPublicKey;
+    if (result.encrypted && result.message) {
+        try {
+            const encrypted = JSON.parse(result.message);
+            ciphertext = encrypted.ciphertext;
+            nonce = encrypted.nonce;
+            senderPublicKey = encrypted.sender_public_key;
+        } catch {
+            // Not JSON, treat as plaintext
+        }
+    }
+
+    return {
+        id: result.id,
+        sender: result.from_agent,
+        recipient: result.to_agent,
+        subject: result.subject || '',
+        body: result.encrypted ? '' : result.message,
+        encrypted: result.encrypted,
+        ciphertext,
+        nonce,
+        senderPublicKey,
+        read: result.read,
+        archived: false, // Not in response
+        createdAt: new Date(result.created_at),
+    };
+}
+
+/**
+ * Get inbox messages from Supabase
+ */
+export async function getInbox(agentId: string, options?: InboxOptions): Promise<Message[]> {
+    const client = createClient();
+
+    if (!client) {
+        return local.getInbox(agentId, options);
+    }
+
+    let query = `/agent_messages?to_agent=eq.${agentId}&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
+ */
+export async function getMessage(id: string): Promise<Message | null> {
+    const client = createClient();
+
+    if (!client) {
+        return local.getMessage(id);
+    }
+
+    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, `/agent_messages?id=eq.${id}`);
+
+    if (results.length === 0) return null;
+
+    const r = results[0];
+
+    // 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),
+    };
+}
+
+/**
+ * Mark message as read
+ */
+export async function markAsRead(id: string, agentId?: string): Promise<boolean> {
+    const client = createClient();
+
+    if (!client) {
+        return local.markAsRead(id, agentId);
+    }
+
+    try {
+        await supabaseRequest(client, `/agent_messages?id=eq.${id}`, {
+            method: 'PATCH',
+            body: JSON.stringify({ read: true }),
+        });
+        return true;
+    } catch {
+        return false;
+    }
+}
+
+/**
+ * Archive a message
+ */
+export async function archiveMessage(id: string): Promise<boolean> {
+    const client = createClient();
+
+    if (!client) {
+        return local.archiveMessage(id);
+    }
+
+    try {
+        await supabaseRequest(client, `/agent_messages?id=eq.${id}`, {
+            method: 'PATCH',
+            body: JSON.stringify({ archived: true }),
+        });
+        return true;
+    } catch {
+        return false;
+    }
+}
+
+/**
+ * Delete a message
+ */
+export async function deleteMessage(id: string): Promise<boolean> {
+    const client = createClient();
+
+    if (!client) {
+        return local.deleteMessage(id);
+    }
+
+    try {
+        await supabaseRequest(client, `/agent_messages?id=eq.${id}`, {
+            method: 'DELETE',
+        });
+        return true;
+    } catch {
+        return false;
+    }
+}

package/src/types/index.ts

@@ -0,0 +1,53 @@
+/**
+ * Myceliumail Type Definitions
+ */
+
+export interface Attachment {
+    name: string;      // filename
+    type: string;      // MIME type
+    data: string;      // base64 encoded
+    size: number;      // original size in bytes
+}
+
+export interface Message {
+    id: string;
+    sender: string;
+    recipient: string;            // Primary recipient (for backwards compat)
+    recipients?: string[];        // Multi-recipient support
+    subject: string;
+    body: string;
+    encrypted: boolean;
+    ciphertext?: string;
+    nonce?: string;
+    senderPublicKey?: string;
+    read?: boolean;               // Legacy - kept for backwards compat
+    readBy?: string[];            // Array of agents who read this
+    archived: boolean;
+    attachments?: Attachment[];
+    createdAt: Date;
+}
+
+export interface Channel {
+    name: string;
+    description?: string;
+    isPublic: boolean;
+    createdBy: string;
+    createdAt: Date;
+}
+
+export interface Agent {
+    id: string;
+    publicKey?: string;
+    status?: string;
+    lastSeen?: Date;
+}
+
+export interface SendOptions {
+    encrypt?: boolean;
+    priority?: 'low' | 'normal' | 'high' | 'urgent';
+}
+
+export interface InboxOptions {
+    unreadOnly?: boolean;
+    limit?: number;
+}

package/supabase/migrations/000_myceliumail_setup.sql

@@ -0,0 +1,93 @@
+-- Myceliumail: Agent Messaging with E2E Encryption
+-- Apply to Supabase to enable cloud message storage
+
+-- Agent messages table with encryption support
+CREATE TABLE IF NOT EXISTS agent_messages (
+    id uuid PRIMARY KEY DEFAULT gen_random_uuid(),
+    sender text NOT NULL,
+    recipient text NOT NULL,
+    subject text,
+    body text,
+    
+    -- Encryption fields (NaCl box)
+    encrypted boolean DEFAULT false,
+    ciphertext text,                -- base64 encrypted payload
+    nonce text,                     -- base64 nonce
+    sender_public_key text,         -- base64 sender's public key
+    
+    -- Message state
+    read boolean DEFAULT false,
+    archived boolean DEFAULT false,
+    
+    -- Metadata
+    message_type text DEFAULT 'direct', -- direct, channel, broadcast, system
+    thread_id uuid,                     -- for threaded conversations
+    reply_to uuid,                      -- parent message
+    priority text DEFAULT 'normal',     -- low, normal, high, urgent
+    
+    created_at timestamptz DEFAULT now(),
+    updated_at timestamptz DEFAULT now()
+);
+
+-- Indexes for common queries
+CREATE INDEX IF NOT EXISTS idx_agent_messages_recipient 
+    ON agent_messages(recipient, read, archived);
+CREATE INDEX IF NOT EXISTS idx_agent_messages_sender 
+    ON agent_messages(sender, created_at);
+CREATE INDEX IF NOT EXISTS idx_agent_messages_thread 
+    ON agent_messages(thread_id) WHERE thread_id IS NOT NULL;
+
+-- Agent public keys registry
+CREATE TABLE IF NOT EXISTS agent_keys (
+    agent_id text PRIMARY KEY,
+    public_key text NOT NULL,        -- base64 encoded
+    created_at timestamptz DEFAULT now(),
+    updated_at timestamptz DEFAULT now()
+);
+
+-- Channels table
+CREATE TABLE IF NOT EXISTS channels (
+    name text PRIMARY KEY,
+    description text,
+    is_public boolean DEFAULT true,
+    created_by text NOT NULL,
+    created_at timestamptz DEFAULT now()
+);
+
+-- Channel membership
+CREATE TABLE IF NOT EXISTS channel_members (
+    channel_name text REFERENCES channels(name) ON DELETE CASCADE,
+    agent_id text,
+    joined_at timestamptz DEFAULT now(),
+    notify_level text DEFAULT 'all', -- all, mentions, none
+    PRIMARY KEY (channel_name, agent_id)
+);
+
+-- RLS Policies
+ALTER TABLE agent_messages ENABLE ROW LEVEL SECURITY;
+ALTER TABLE agent_keys ENABLE ROW LEVEL SECURITY;
+
+-- Allow all authenticated access (agents auth via service key)
+CREATE POLICY "Agents can read their own messages"
+    ON agent_messages FOR SELECT
+    USING (true);
+
+CREATE POLICY "Agents can insert messages"
+    ON agent_messages FOR INSERT
+    WITH CHECK (true);
+
+CREATE POLICY "Agents can update their own received messages"
+    ON agent_messages FOR UPDATE
+    USING (true);
+
+CREATE POLICY "Anyone can read public keys"
+    ON agent_keys FOR SELECT
+    USING (true);
+
+CREATE POLICY "Agents can insert their own key"
+    ON agent_keys FOR INSERT
+    WITH CHECK (true);
+
+CREATE POLICY "Agents can update their own key"
+    ON agent_keys FOR UPDATE
+    USING (true);

package/supabase/migrations/001_enable_realtime.sql

@@ -0,0 +1,10 @@
+-- Enable Realtime for agent_messages table
+-- This allows the mycmail watch command to receive push notifications
+
+-- Enable Realtime publication for agent_messages table
+ALTER PUBLICATION supabase_realtime ADD TABLE agent_messages;
+
+-- Note: By default, Realtime listens to all events (INSERT, UPDATE, DELETE).
+-- If you want to limit to specific events, use:
+-- ALTER PUBLICATION supabase_realtime ADD TABLE ONLY agent_messages 
+--   WITH (publish = 'insert');