@trlc/super-memory 1.1.1 → 1.3.0

package/README.md

@@ -2,12 +2,12 @@
 
 **Never forget a conversation again.**
 
-AI-powered persistent memory with cloud sync. Works with OpenClaw and any LLM workflow.
+AI-powered persistent memory with end-to-end encryption and cloud sync. Works with OpenClaw and any LLM workflow.
 
 ## Installation
 
 ```bash
-npm install -g @redlobstercartel/super-memory
+npm install -g @trlc/super-memory
 ```
 
 ## Quick Start
@@ -16,17 +16,20 @@ npm install -g @redlobstercartel/super-memory
 # Initialize with your license key
 super-memory init --license=XXXX-XXXX-XXXX-XXXX
 
-# Save a memory
+# Save a memory (encrypted locally + cloud)
 super-memory save "Fixed CORS by adding proxy middleware" --category=problem
 
 # Search your memories
 super-memory search "cors error"
 
-# Sync across devices
+# Sync across devices (encrypted)
 super-memory sync
 
 # Check status
 super-memory status
+
+# Open local dashboard
+super-memory dashboard
 ```
 
 ## Commands
@@ -34,10 +37,46 @@ super-memory status
 | Command | Description |
 |---------|-------------|
 | `init` | Initialize with license key |
-| `save` | Save a memory to cloud |
+| `save` | Save a memory (local + encrypted cloud) |
 | `search` | Search memories semantically |
-| `sync` | Sync with cloud storage |
-| `status` | Show license and stats |
+| `sync` | Sync with cloud storage (encrypted) |
+| `status` | Show license, local/cloud stats, sync status |
+| `dashboard` | Open local web dashboard |
+| `index-update` | Update MEMORY_INDEX.md + auto-curate |
+| `curate` | Auto-curate memories to MEMORY.md |
+| `flush` | Save critical context before compaction |
+| `maintenance` | Run weekly review and get suggestions |
+
+## Web Dashboard
+
+Access your memories from any device:
+
+**https://redlobstercartel.ai/super-memory/dashboard**
+
+Features:
+- 🔐 Secure login with session tokens (24h)
+- 🔒 End-to-end encryption (AES-256)
+- 🔍 Search and filter by category
+- 📊 Activity log and security summary
+- 🌐 Access from any device
+
+## Security & Privacy
+
+### End-to-End Encryption
+
+- **AES-256-CBC** encryption for all cloud data
+- **PBKDF2** key derivation from your license key
+- **Client-side encryption**: Data encrypted before transmission
+- **Zero-knowledge**: We cannot read your memories
+
+### Security Features
+
+- Rate limiting: 60 requests/minute
+- Memory size limit: 10KB per entry
+- Memory count limit: 1,000 per user
+- Session tokens with 24h expiration
+- Complete audit logging
+- Multi-tenant isolation
 
 ## Categories
 
@@ -48,18 +87,30 @@ super-memory status
 | `decision` | 🟤 | Important decisions made |
 | `discovery` | 🟣 | New learnings, insights |
 
-## Pricing
+## Architecture
+
+```
+┌─────────────┐     ┌─────────────┐     ┌─────────────┐
+│   Local     │────▶│  Encrypted  │◀────│   Web       │
+│   (.md)     │     │   Cloud     │     │  Dashboard  │
+│             │◀────│  (Convex)   │────▶│             │
+└─────────────┘     └─────────────┘     └─────────────┘
+       │                   │                   │
+       ▼                   ▼                   ▼
+  Always accessible    Encrypted at rest    Decrypted in
+  (offline capable)    (zero-knowledge)     browser only
+```
 
-| Plan | Price |
-|------|-------|
-| Monthly | $19/month |
-| Lifetime | $190 one-time |
+## Pricing
 
-Both plans include unlimited memories and cloud sync.
+| Plan | Price | Features |
+|------|-------|----------|
+| Monthly | $19/month | Unlimited memories, cloud sync, dashboard |
+| Lifetime | $190 one-time | Unlimited memories, cloud sync, dashboard, all future updates |
 
 ## OpenClaw Integration
 
-Super Memory is designed to work with OpenClaw. After installing, you can use:
+Super Memory is designed to work with OpenClaw:
 
 ```
 @super-memory save "your memory" --category=discovery
@@ -67,12 +118,18 @@ Super Memory is designed to work with OpenClaw. After installing, you can use:
 @super-memory sync
 ```
 
+## Documentation
+
+- 📖 Installation Guide: https://redlobstercartel.ai/super-memory/install
+- 🌐 Web Dashboard: https://redlobstercartel.ai/super-memory/dashboard
+- 🦞 Landing Page: https://redlobstercartel.ai/super-memory
+
 ## Links
 
-- 🌐 Website: https://theredlobstercartel.com/super-memory
-- 📧 Support: support@theredlobstercartel.com
-- 🐦 Twitter: @RedLobsterCartel
+- 🌐 Website: https://redlobstercartel.ai/super-memory
+- 📧 Support: support@redlobstercartel.ai
+- 📦 npm: https://www.npmjs.com/package/@trlc/super-memory
 
 ---
 
-*🦞 The Red Lobster Cartel - Never forget a conversation again.*
+*🦞 The Red Lobster Cartel - Never forget a conversation again.*

package/dist/commands/save.js

@@ -0,0 +1,98 @@
+/**
+ * Save Command
+ * Saves memory locally and encrypted to cloud
+ */
+import { existsSync, mkdirSync, appendFileSync } from 'fs';
+import { join } from 'path';
+import { loadConfig, getMemoryDir } from '../utils/config.js';
+import { deriveKey, encrypt } from '../utils/crypto.js';
+const CONVEX_URL = 'https://clear-lemming-473.convex.cloud';
+export async function cmdSave(args) {
+    const config = loadConfig();
+    if (!config) {
+        console.error('❌ Not initialized. Run: super-memory init --license=YOUR_KEY');
+        process.exit(1);
+    }
+    // Parse arguments
+    const contentArg = args.find(arg => !arg.startsWith('--'));
+    const categoryArg = args.find(arg => arg.startsWith('--category='))?.split('=')[1];
+    if (!contentArg) {
+        console.error('❌ Usage: super-memory save "Your memory content" --category=discovery');
+        process.exit(1);
+    }
+    const category = categoryArg || 'discovery';
+    const validCategories = ['gotcha', 'problem', 'decision', 'discovery'];
+    if (!validCategories.includes(category)) {
+        console.error(`❌ Invalid category. Use: ${validCategories.join(', ')}`);
+        process.exit(1);
+    }
+    console.log('💾 Saving memory...\n');
+    // 1. Save locally
+    const memoryDir = getMemoryDir();
+    if (!existsSync(memoryDir)) {
+        mkdirSync(memoryDir, { recursive: true });
+    }
+    const today = new Date().toISOString().split('T')[0];
+    const dailyFile = join(memoryDir, `${today}.md`);
+    const emojis = {
+        gotcha: '🔴',
+        problem: '🟡',
+        decision: '🟤',
+        discovery: '🟣',
+    };
+    const timestamp = new Date().toISOString();
+    const entry = `- ${emojis[category]} ${contentArg} (${timestamp})\n`;
+    appendFileSync(dailyFile, entry);
+    console.log(`✅ Saved locally: ${dailyFile}`);
+    // 2. Encrypt and save to cloud
+    try {
+        // Generate salt or get existing
+        const saltResponse = await fetch(`${CONVEX_URL}/api/query`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                path: 'memories:getSalt',
+                args: { licenseKey: config.licenseKey },
+            }),
+        });
+        const saltResult = await saltResponse.json();
+        const salt = saltResult.value?.salt || generateSalt();
+        // Derive key and encrypt
+        const key = deriveKey(config.licenseKey, salt);
+        const { encrypted, iv } = encrypt(contentArg, key);
+        // Push to Convex
+        const pushResponse = await fetch(`${CONVEX_URL}/api/mutation`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                path: 'memories:push',
+                args: {
+                    licenseKey: config.licenseKey,
+                    encryptedContent: encrypted,
+                    iv,
+                    salt,
+                    category,
+                    timestamp: Date.now(),
+                },
+            }),
+        });
+        const pushResult = await pushResponse.json();
+        if (pushResult.status === 'error') {
+            throw new Error(pushResult.errorMessage);
+        }
+        console.log(`✅ Synced to cloud (encrypted)`);
+        console.log(`\n🦞 Memory saved securely!\n`);
+    }
+    catch (error) {
+        console.warn(`⚠️  Cloud sync failed: ${error.message}`);
+        console.log(`   Memory saved locally only. Run 'super-memory sync' to retry.\n`);
+    }
+}
+function generateSalt() {
+    const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+    let salt = '';
+    for (let i = 0; i < 32; i++) {
+        salt += chars.charAt(Math.floor(Math.random() * chars.length));
+    }
+    return salt;
+}

package/dist/commands/status.js

@@ -0,0 +1,116 @@
+/**
+ * Status Command
+ * Shows local and sync status
+ */
+import { existsSync, readFileSync, readdirSync } from 'fs';
+import { join } from 'path';
+import { loadConfig, getMemoryDir, getBaseDir } from '../utils/config.js';
+const CONVEX_URL = 'https://clear-lemming-473.convex.cloud';
+export async function cmdStatus() {
+    const config = loadConfig();
+    if (!config) {
+        console.error('❌ Not initialized. Run: super-memory init --license=YOUR_KEY');
+        process.exit(1);
+    }
+    console.log('\n🦞 ============================================');
+    console.log('   SUPER MEMORY STATUS');
+    console.log('   ============================================\n');
+    // License info
+    console.log('📋 License:');
+    console.log(`   Key: ${config.licenseKey.slice(0, 4)}***${config.licenseKey.slice(-4)}`);
+    console.log(`   Plan: ${config.plan === 'monthly' ? 'Monthly ($19/month)' : 'Lifetime ($190 one-time)'}`);
+    console.log(`   Device: ${config.deviceId}`);
+    console.log(`   Installed: ${new Date(config.installedAt).toLocaleDateString()}`);
+    if (config.lastSyncAt) {
+        console.log(`   Last Sync: ${new Date(config.lastSyncAt).toLocaleString()}`);
+    }
+    console.log();
+    // Local stats
+    const stats = getLocalStats();
+    console.log('💾 Local Storage:');
+    console.log(`   Total Memories: ${stats.total}`);
+    console.log(`   🔴 Gotchas: ${stats.gotchas}`);
+    console.log(`   🟡 Problems: ${stats.problems}`);
+    console.log(`   🟤 Decisions: ${stats.decisions}`);
+    console.log(`   🟣 Discoveries: ${stats.discoveries}`);
+    console.log();
+    // Cloud stats
+    try {
+        const response = await fetch(`${CONVEX_URL}/api/query`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                path: 'memories:stats',
+                args: { licenseKey: config.licenseKey },
+            }),
+        });
+        const result = await response.json();
+        if (result.status === 'success' && result.value) {
+            const cloudStats = result.value;
+            console.log('☁️  Cloud Storage (Encrypted):');
+            console.log(`   Total Memories: ${cloudStats.total}`);
+            console.log(`   🔴 Gotchas: ${cloudStats.gotchas}`);
+            console.log(`   🟡 Problems: ${cloudStats.problems}`);
+            console.log(`   🟤 Decisions: ${cloudStats.decisions}`);
+            console.log(`   🟣 Discoveries: ${cloudStats.discoveries}`);
+            console.log();
+            // Sync status
+            if (stats.total !== cloudStats.total) {
+                console.log('⚠️  Sync Status: Out of sync');
+                console.log(`   Local: ${stats.total} | Cloud: ${cloudStats.total}`);
+                console.log(`   Run: super-memory sync\n`);
+            }
+            else {
+                console.log('✅ Sync Status: In sync\n');
+            }
+        }
+        else {
+            console.log('☁️  Cloud Storage: Unable to fetch stats\n');
+        }
+    }
+    catch (error) {
+        console.log('☁️  Cloud Storage: Offline or unavailable\n');
+    }
+    // Storage location
+    const baseDir = getBaseDir();
+    console.log('📁 Storage Location:');
+    console.log(`   ${baseDir}`);
+    console.log();
+}
+function getLocalStats() {
+    const memoryDir = getMemoryDir();
+    const stats = {
+        total: 0,
+        gotchas: 0,
+        problems: 0,
+        decisions: 0,
+        discoveries: 0,
+    };
+    if (!existsSync(memoryDir)) {
+        return stats;
+    }
+    const files = readdirSync(memoryDir).filter(f => f.endsWith('.md'));
+    for (const file of files) {
+        const content = readFileSync(join(memoryDir, file), 'utf-8');
+        const lines = content.split('\n');
+        for (const line of lines) {
+            if (line.includes('🔴')) {
+                stats.gotchas++;
+                stats.total++;
+            }
+            else if (line.includes('🟡')) {
+                stats.problems++;
+                stats.total++;
+            }
+            else if (line.includes('🟤')) {
+                stats.decisions++;
+                stats.total++;
+            }
+            else if (line.includes('🟣')) {
+                stats.discoveries++;
+                stats.total++;
+            }
+        }
+    }
+    return stats;
+}

package/dist/commands/sync.js

@@ -0,0 +1,91 @@
+/**
+ * Sync Command
+ * Bidirectional sync between local and cloud
+ */
+import { existsSync, readFileSync, writeFileSync } from 'fs';
+import { join } from 'path';
+import { loadConfig } from '../utils/config.js';
+import { deriveKey, decrypt } from '../utils/crypto.js';
+const CONVEX_URL = 'https://clear-lemming-473.convex.cloud';
+export async function cmdSync() {
+    const config = loadConfig();
+    if (!config) {
+        console.error('❌ Not initialized. Run: super-memory init --license=YOUR_KEY');
+        process.exit(1);
+    }
+    console.log('🔄 Syncing memories...\n');
+    try {
+        // Pull from cloud
+        const response = await fetch(`${CONVEX_URL}/api/query`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                path: 'memories:pull',
+                args: { licenseKey: config.licenseKey },
+            }),
+        });
+        const result = await response.json();
+        if (result.status === 'error') {
+            throw new Error(result.errorMessage);
+        }
+        const memories = result.value || [];
+        if (memories.length === 0) {
+            console.log('✅ No new memories to sync from cloud\n');
+            return;
+        }
+        console.log(`📥 Downloaded ${memories.length} memories from cloud`);
+        // Decrypt and save locally
+        let syncedCount = 0;
+        const memoryDir = getMemoryDir();
+        for (const mem of memories) {
+            try {
+                // Derive key and decrypt
+                const key = deriveKey(config.licenseKey, mem.salt);
+                const decrypted = decrypt(mem.encryptedContent, key, mem.iv);
+                if (!decrypted) {
+                    console.warn(`⚠️  Failed to decrypt memory ${mem._id}`);
+                    continue;
+                }
+                // Save to daily file
+                const date = new Date(mem.createdAt).toISOString().split('T')[0];
+                const dailyFile = join(memoryDir, `${date}.md`);
+                // Check if already exists
+                if (existsSync(dailyFile)) {
+                    const existing = readFileSync(dailyFile, 'utf-8');
+                    if (existing.includes(decrypted)) {
+                        continue; // Skip duplicates
+                    }
+                }
+                const emojis = {
+                    gotcha: '🔴',
+                    problem: '🟡',
+                    decision: '🟤',
+                    discovery: '🟣',
+                };
+                const entry = `- ${emojis[mem.category] || '🟣'} ${decrypted} (${new Date(mem.createdAt).toISOString()})\n`;
+                const fs = await import('fs');
+                fs.appendFileSync(dailyFile, entry);
+                syncedCount++;
+            }
+            catch (err) {
+                console.warn(`⚠️  Error processing memory: ${err}`);
+            }
+        }
+        // Update last sync in config
+        const configPath = join(getMemoryDir(), '..', '.super-memory', 'config.json');
+        const currentConfig = JSON.parse(readFileSync(configPath, 'utf-8'));
+        currentConfig.lastSyncAt = Date.now();
+        writeFileSync(configPath, JSON.stringify(currentConfig, null, 2));
+        console.log(`\n✅ Sync complete!`);
+        console.log(`   Downloaded: ${syncedCount} memories`);
+        console.log(`   Last sync: ${new Date().toLocaleString()}\n`);
+    }
+    catch (error) {
+        console.error(`❌ Sync failed: ${error.message}\n`);
+        process.exit(1);
+    }
+}
+function getMemoryDir() {
+    const { homedir } = require('os');
+    return join(homedir(), '.openclaw', 'workspace', 'memory');
+}

package/dist/index.js

@@ -19,7 +19,7 @@ import { cmdFlush } from './commands/flush.js';
 import { cmdMaintenance } from './commands/maintenance.js';
 import { cmdCategorize } from './commands/categorize.js';
 import { cmdCurate } from './commands/curate.js';
-import { existsSync, mkdirSync, writeFileSync, readFileSync, appendFileSync } from 'fs';
+import { existsSync, mkdirSync, writeFileSync, readFileSync, appendFileSync, readdirSync } from 'fs';
 import { homedir } from 'os';
 import { join } from 'path';
 import readline from 'readline';
@@ -257,6 +257,7 @@ async function cmdInit(args) {
    super-memory search "query"
    super-memory sync
    super-memory status
+   super-memory dashboard
 
 🦞 Welcome to The Red Lobster Cartel!
 `);
@@ -266,6 +267,16 @@ async function cmdInit(args) {
         process.exit(1);
     }
 }
+import { deriveKey, encrypt, decrypt } from './utils/crypto.js';
+// Generate random salt
+function generateSalt() {
+    const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+    let salt = '';
+    for (let i = 0; i < 32; i++) {
+        salt += chars.charAt(Math.floor(Math.random() * chars.length));
+    }
+    return salt;
+}
 // COMMAND: save
 async function cmdSave(args) {
     const config = loadConfig();
@@ -286,7 +297,7 @@ async function cmdSave(args) {
         console.error(`❌ Invalid category. Use: ${validCategories.join(', ')}`);
         process.exit(1);
     }
-    console.log('💾 Saving memory...');
+    console.log('💾 Saving memory...\n');
     // Save locally first
     const memoryDir = getMemoryDir();
     const today = new Date().toISOString().split('T')[0];
@@ -300,28 +311,49 @@ async function cmdSave(args) {
         writeFileSync(dailyPath, `# Memory Log - ${today}\n${entry}`);
     }
     console.log('✅ Saved locally');
-    // Sync to cloud
+    // Encrypt and sync to cloud
     try {
-        const result = await convexCall('sync:push', {
-            licenseKey: config.licenseKey,
-            deviceId: config.deviceId,
-            memories: [{
-                    content,
+        // Get or generate salt
+        const saltResponse = await fetch(`${CONVEX_URL}/api/query`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                path: 'memories:getSalt',
+                args: { licenseKey: config.licenseKey },
+            }),
+        });
+        const saltResult = await saltResponse.json();
+        const salt = saltResult.value?.salt || generateSalt();
+        // Derive key and encrypt
+        const key = deriveKey(config.licenseKey, salt);
+        const { encrypted, iv } = encrypt(content, key);
+        // Push to cloud
+        const pushResponse = await fetch(`${CONVEX_URL}/api/mutation`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                path: 'memories:push',
+                args: {
+                    licenseKey: config.licenseKey,
+                    encryptedContent: encrypted,
+                    iv,
+                    salt,
                     category,
-                    layer: 3,
-                    source: `${today}.md`,
-                }],
+                    timestamp: Date.now(),
+                },
+            }),
         });
-        if (result.success) {
-            config.lastSyncVersion = result.newVersion;
-            saveConfig(config);
-            console.log(`☁️  Synced to cloud (v${result.newVersion})`);
+        const pushResult = await pushResponse.json();
+        if (pushResult.status === 'error') {
+            throw new Error(pushResult.errorMessage);
         }
+        console.log(`☁️  Synced to cloud (encrypted)`);
+        console.log(`\n🦞 Memory saved securely!\n`);
     }
     catch (error) {
         console.warn(`⚠️  Cloud sync failed: ${error.message}`);
+        console.log(`   Memory saved locally only. Run 'super-memory sync' to retry.\n`);
     }
-    console.log(`\n${emoji[category]} Memory saved: "${content.substring(0, 50)}${content.length > 50 ? '...' : ''}"`);
 }
 // COMMAND: search
 async function cmdSearch(args) {
@@ -366,19 +398,70 @@ async function cmdSync(args) {
     }
     console.log('🔄 Syncing with cloud...\n');
     try {
-        const result = await convexCall('sync:pull', {
-            licenseKey: config.licenseKey,
-            deviceId: config.deviceId,
-            lastSyncVersion: config.lastSyncVersion,
+        // Pull from cloud
+        const response = await fetch(`${CONVEX_URL}/api/query`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                path: 'memories:pull',
+                args: { licenseKey: config.licenseKey },
+            }),
         });
-        console.log(`📥 Pulled ${result.memories.length} new memories`);
-        console.log(`📊 Current version: ${result.latestVersion}`);
-        config.lastSyncVersion = result.latestVersion;
+        const result = await response.json();
+        if (result.status === 'error') {
+            throw new Error(result.errorMessage);
+        }
+        const memories = result.value || [];
+        if (memories.length === 0) {
+            console.log('✅ No new memories to sync from cloud\n');
+            return;
+        }
+        console.log(`📥 Downloaded ${memories.length} memories from cloud`);
+        // Decrypt and save locally
+        let syncedCount = 0;
+        const memoryDir = getMemoryDir();
+        for (const mem of memories) {
+            try {
+                // Derive key and decrypt
+                const key = deriveKey(config.licenseKey, mem.salt);
+                const decrypted = decrypt(mem.encryptedContent, key, mem.iv);
+                if (!decrypted) {
+                    console.warn(`⚠️  Failed to decrypt memory ${mem._id}`);
+                    continue;
+                }
+                // Save to daily file
+                const date = new Date(mem.createdAt).toISOString().split('T')[0];
+                const dailyFile = join(memoryDir, `${date}.md`);
+                // Check if already exists
+                if (existsSync(dailyFile)) {
+                    const existing = readFileSync(dailyFile, 'utf-8');
+                    if (existing.includes(decrypted)) {
+                        continue; // Skip duplicates
+                    }
+                }
+                const emojis = {
+                    gotcha: '🔴',
+                    problem: '🟡',
+                    decision: '🟤',
+                    discovery: '🟣',
+                };
+                const entry = `\n${emojis[mem.category] || '🟣'} [${mem.category.toUpperCase()}] ${decrypted}\n`;
+                appendFileSync(dailyFile, entry);
+                syncedCount++;
+            }
+            catch (err) {
+                console.warn(`⚠️  Error processing memory: ${err}`);
+            }
+        }
+        // Update last sync
+        config.lastSyncAt = Date.now();
         saveConfig(config);
-        console.log('\n✅ Sync complete!');
+        console.log(`\n✅ Sync complete!`);
+        console.log(`   Downloaded: ${syncedCount} memories`);
+        console.log(`   Last sync: ${new Date().toLocaleString()}\n`);
     }
     catch (error) {
-        console.error(`❌ Sync failed: ${error.message}`);
+        console.error(`❌ Sync failed: ${error.message}\n`);
     }
 }
 // COMMAND: status
@@ -392,30 +475,91 @@ async function cmdStatus(args) {
 🦞 Super Memory Status
 ======================
 `);
-    console.log(`📋 License: ${config.licenseKey}`);
-    console.log(`📦 Plan: ${config.plan}`);
+    console.log(`📋 License: ${config.licenseKey.slice(0, 4)}***${config.licenseKey.slice(-4)}`);
+    console.log(`📦 Plan: ${config.plan === 'monthly' ? 'Monthly ($19/month)' : 'Lifetime ($190 one-time)'}`);
     console.log(`🖥️  Device: ${config.deviceId}`);
-    console.log(`📅 Installed: ${config.installedAt}`);
-    console.log(`🔢 Version: ${config.version}`);
-    console.log(`📊 Last Sync Version: ${config.lastSyncVersion}`);
+    console.log(`📅 Installed: ${new Date(config.installedAt).toLocaleDateString()}`);
+    if (config.lastSyncAt) {
+        console.log(`🔄 Last Sync: ${new Date(config.lastSyncAt).toLocaleString()}`);
+    }
+    console.log();
+    // Local stats
+    const localStats = getLocalStats();
+    console.log('💾 Local Storage:');
+    console.log(`   Total Memories: ${localStats.total}`);
+    console.log(`   🔴 Gotchas: ${localStats.gotchas}`);
+    console.log(`   🟡 Problems: ${localStats.problems}`);
+    console.log(`   🟤 Decisions: ${localStats.decisions}`);
+    console.log(`   🟣 Discoveries: ${localStats.discoveries}`);
+    console.log();
+    // Cloud stats
     try {
-        const stats = await convexQuery('license:getStats', {
-            licenseKey: config.licenseKey,
+        const response = await fetch(`${CONVEX_URL}/api/query`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                path: 'memories:stats',
+                args: { licenseKey: config.licenseKey },
+            }),
         });
-        console.log(`\n☁️  Cloud Stats:`);
-        console.log(`   Total Memories: ${stats.totalMemories}`);
-        console.log(`   🔴 Gotchas: ${stats.memoriesByCategory.gotcha}`);
-        console.log(`   🟡 Problems: ${stats.memoriesByCategory.problem}`);
-        console.log(`   🟤 Decisions: ${stats.memoriesByCategory.decision}`);
-        console.log(`   🟣 Discoveries: ${stats.memoriesByCategory.discovery}`);
-        console.log(`   Devices: ${stats.totalDevices}`);
-        if (stats.lastSyncAt) {
-            console.log(`   Last Sync: ${new Date(stats.lastSyncAt).toLocaleString()}`);
+        const result = await response.json();
+        if (result.status === 'success' && result.value) {
+            const cloudStats = result.value;
+            console.log('☁️  Cloud Storage (Encrypted):');
+            console.log(`   Total Memories: ${cloudStats.total}`);
+            console.log(`   🔴 Gotchas: ${cloudStats.gotchas}`);
+            console.log(`   🟡 Problems: ${cloudStats.problems}`);
+            console.log(`   🟤 Decisions: ${cloudStats.decisions}`);
+            console.log(`   🟣 Discoveries: ${cloudStats.discoveries}`);
+            console.log();
+            // Sync status
+            if (localStats.total !== cloudStats.total) {
+                console.log('⚠️  Sync Status: Out of sync');
+                console.log(`   Local: ${localStats.total} | Cloud: ${cloudStats.total}`);
+                console.log(`   Run: super-memory sync\n`);
+            }
+            else {
+                console.log('✅ Sync Status: In sync\n');
+            }
+        }
+        else {
+            console.log('☁️  Cloud Storage: Unable to fetch stats\n');
         }
     }
     catch (error) {
-        console.warn(`\n⚠️  Could not fetch cloud stats: ${error.message}`);
+        console.log('☁️  Cloud Storage: Offline or unavailable\n');
+    }
+}
+// Helper function for local stats
+function getLocalStats() {
+    const stats = { total: 0, gotchas: 0, problems: 0, decisions: 0, discoveries: 0 };
+    const memoryDir = getMemoryDir();
+    if (!existsSync(memoryDir))
+        return stats;
+    const files = readdirSync(memoryDir).filter(f => f.endsWith('.md'));
+    for (const file of files) {
+        const content = readFileSync(join(memoryDir, file), 'utf-8');
+        const lines = content.split('\n');
+        for (const line of lines) {
+            if (line.includes('🔴')) {
+                stats.gotchas++;
+                stats.total++;
+            }
+            else if (line.includes('🟡')) {
+                stats.problems++;
+                stats.total++;
+            }
+            else if (line.includes('🟤')) {
+                stats.decisions++;
+                stats.total++;
+            }
+            else if (line.includes('🟣')) {
+                stats.discoveries++;
+                stats.total++;
+            }
+        }
     }
+    return stats;
 }
 // COMMAND: help
 function cmdHelp() {
@@ -437,6 +581,10 @@ COMMANDS:
 
   status                       Show status and stats
 
+  dashboard                    Open web dashboard
+    --port=8765               Custom port
+    --no-browser              Don't auto-open browser
+
   index-update                 Update progressive MEMORY_INDEX.md (Layer 4)
                                Also auto-curates to MEMORY.md
 

package/dist/utils/crypto.js

@@ -0,0 +1,42 @@
+// Super Memory SaaS - Crypto Utilities
+// The Red Lobster Cartel 🦞
+import CryptoJS from 'crypto-js';
+/**
+ * Deriva uma chave de 256 bits a partir da licenseKey e do salt usando PBKDF2.
+ */
+export function deriveKey(licenseKey, salt) {
+    const iterations = 10000;
+    const keySize = 256 / 32; // 8 words = 256 bits
+    return CryptoJS.PBKDF2(licenseKey, salt, {
+        keySize,
+        iterations
+    }).toString();
+}
+/**
+ * Encripta o conteúdo usando AES-256-GCM (simulado via AES-CBC do crypto-js por simplicidade no bundle,
+ * mas recomendado usar Web Crypto API para GCM real em produção).
+ * Retorna o conteúdo encriptado e o IV em Base64.
+ */
+export function encrypt(content, key) {
+    const iv = CryptoJS.lib.WordArray.random(128 / 8);
+    const encrypted = CryptoJS.AES.encrypt(content, CryptoJS.enc.Hex.parse(key), {
+        iv: iv,
+        mode: CryptoJS.mode.CBC,
+        padding: CryptoJS.pad.Pkcs7
+    });
+    return {
+        encrypted: encrypted.toString(),
+        iv: iv.toString()
+    };
+}
+/**
+ * Desencripta o conteúdo usando a chave e o IV fornecidos.
+ */
+export function decrypt(encrypted, key, iv) {
+    const decrypted = CryptoJS.AES.decrypt(encrypted, CryptoJS.enc.Hex.parse(key), {
+        iv: CryptoJS.enc.Hex.parse(iv),
+        mode: CryptoJS.mode.CBC,
+        padding: CryptoJS.pad.Pkcs7
+    });
+    return decrypted.toString(CryptoJS.enc.Utf8);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@trlc/super-memory",
-  "version": "1.1.1",
+  "version": "1.3.0",
   "description": "Super Memory CLI - AI-powered persistent memory by The Red Lobster Cartel",
   "main": "dist/index.js",
   "bin": {
@@ -35,9 +35,11 @@
     "node": ">=18"
   },
   "dependencies": {
-    "convex": "^1.17.4"
+    "convex": "^1.17.4",
+    "crypto-js": "^4.2.0"
   },
   "devDependencies": {
+    "@types/crypto-js": "^4.2.2",
     "@types/node": "^22.0.0",
     "typescript": "^5.7.0"
   }