myceliumail 1.0.5 → 1.0.7

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/lib/license.ts

@@ -0,0 +1,215 @@
+/**
+ * Myceliumail License Verification
+ * 
+ * Ed25519-based license verification for Pro features.
+ * Public key is embedded; private key is kept by treebird for signing.
+ */
+
+import nacl from 'tweetnacl';
+import util from 'tweetnacl-util';
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+import { loadKnownKeys } from './crypto.js';
+
+// License storage location
+const LICENSE_DIR = join(homedir(), '.myceliumail');
+const LICENSE_FILE = join(LICENSE_DIR, 'license.key');
+
+// Treebird's public key for license verification (Ed25519)
+// Use the same key as Spidersan for unified licensing
+const TREEBIRD_PUBLIC_KEY = 'XqIqSlybZGKkKemgLKKl8P9MepnObhcJcxxZHtgG8/o=';
+
+// Free tier limits
+export const FREE_TIER_LIMITS = {
+    maxImportedKeys: 5,
+};
+
+// Pro features
+export type ProFeature =
+    | 'unlimited_keys'
+    | 'mcp_server'
+    | 'cloud_sync'
+    | 'key_backup'
+    | 'realtime_watch';
+
+export interface LicenseData {
+    email: string;
+    plan: 'free' | 'pro';
+    expiresAt: string;    // ISO date
+    issuedAt: string;     // ISO date
+    features: ProFeature[];
+}
+
+export interface License {
+    data: LicenseData;
+    isValid: boolean;
+    isExpired: boolean;
+}
+
+/**
+ * Ensure license directory exists
+ */
+function ensureLicenseDir(): void {
+    if (!existsSync(LICENSE_DIR)) {
+        mkdirSync(LICENSE_DIR, { recursive: true });
+    }
+}
+
+/**
+ * Parse a license string into components
+ * Format: LICENSE_V1.BASE64_DATA.BASE64_SIGNATURE
+ */
+function parseLicenseString(licenseString: string): { version: string; data: string; signature: string } | null {
+    const parts = licenseString.trim().split('.');
+    if (parts.length !== 3) return null;
+
+    const [version, data, signature] = parts;
+    if (version !== 'LICENSE_V1') return null;
+
+    return { version, data, signature };
+}
+
+/**
+ * Verify a license string using Ed25519 detached signature
+ */
+export function verifyLicense(licenseString: string): License | null {
+    try {
+        const parsed = parseLicenseString(licenseString);
+        if (!parsed) return null;
+
+        const dataBytes = util.decodeBase64(parsed.data);
+
+        // Verify detached Ed25519 signature
+        const publicKey = util.decodeBase64(TREEBIRD_PUBLIC_KEY);
+        const signatureBytes = util.decodeBase64(parsed.signature);
+
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const isValid = (nacl as any).sign.detached.verify(dataBytes, signatureBytes, publicKey);
+        if (!isValid) return null;
+
+        const dataString = util.encodeUTF8(dataBytes);
+        const data = JSON.parse(dataString) as LicenseData;
+
+        const expiresAt = new Date(data.expiresAt);
+        const isExpired = expiresAt < new Date();
+
+        return {
+            data,
+            isValid: true,
+            isExpired,
+        };
+    } catch {
+        return null;
+    }
+}
+
+/**
+ * Save a license key to disk
+ */
+export function saveLicense(licenseString: string): boolean {
+    try {
+        ensureLicenseDir();
+        writeFileSync(LICENSE_FILE, licenseString.trim(), { mode: 0o600 });
+        return true;
+    } catch {
+        return false;
+    }
+}
+
+/**
+ * Load the saved license from disk
+ */
+export function loadLicense(): License | null {
+    if (!existsSync(LICENSE_FILE)) return null;
+
+    try {
+        const licenseString = readFileSync(LICENSE_FILE, 'utf-8');
+        return verifyLicense(licenseString);
+    } catch {
+        return null;
+    }
+}
+
+/**
+ * Check if user has a valid Pro license
+ */
+export function isPro(): boolean {
+    const license = loadLicense();
+    if (!license) return false;
+    if (!license.isValid) return false;
+    if (license.isExpired) return false;
+    return license.data.plan === 'pro';
+}
+
+/**
+ * Check if a specific Pro feature is enabled
+ */
+export function hasFeature(feature: ProFeature): boolean {
+    const license = loadLicense();
+    if (!license || !license.isValid || license.isExpired) return false;
+    return license.data.features.includes(feature);
+}
+
+/**
+ * Get license status summary
+ */
+export function getLicenseStatus(): {
+    plan: 'free' | 'pro';
+    email?: string;
+    expiresAt?: string;
+    features: ProFeature[];
+    daysRemaining?: number;
+} {
+    const license = loadLicense();
+
+    if (!license || !license.isValid || license.isExpired) {
+        return {
+            plan: 'free',
+            features: [],
+        };
+    }
+
+    const expiresAt = new Date(license.data.expiresAt);
+    const now = new Date();
+    const daysRemaining = Math.ceil((expiresAt.getTime() - now.getTime()) / (1000 * 60 * 60 * 24));
+
+    return {
+        plan: license.data.plan,
+        email: license.data.email,
+        expiresAt: license.data.expiresAt,
+        features: license.data.features,
+        daysRemaining,
+    };
+}
+
+/**
+ * Check imported key limit and throw if exceeded (for free tier)
+ */
+export function checkKeyLimit(): void {
+    if (isPro()) return; // Pro has unlimited
+
+    const knownKeys = loadKnownKeys();
+    const keyCount = Object.keys(knownKeys).length;
+
+    if (keyCount >= FREE_TIER_LIMITS.maxImportedKeys) {
+        console.error(`\n🍄 Free tier limit reached: ${keyCount}/${FREE_TIER_LIMITS.maxImportedKeys} imported keys`);
+        console.error('');
+        console.error('   Options:');
+        console.error('   • Remove unused keys from ~/.myceliumail/keys/known_keys.json');
+        console.error('   • Upgrade: myceliumail.dev/pro for unlimited keys');
+        console.error('');
+        process.exit(1);
+    }
+}
+
+/**
+ * Print Pro upsell message (soft sell)
+ */
+export function printProUpsell(feature: string): void {
+    if (isPro()) return;
+
+    console.log('');
+    console.log(`💎 Pro tip: Upgrade for ${feature}`);
+    console.log('   myceliumail.dev/pro');
+}

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()