@cybermem/mcp 0.1.0 → 0.5.0

package/README.md

@@ -1,49 +1,5 @@
 # @cybermem/mcp
 
-Official TypeScript MCP Server for CyberMem.
+Universal Long-Term Memory for AI Agents.
 
-## Configuration
-
-### Option A: Local (Standard)
-If you are running CyberMem locally on your machine, use `npx` to spawn the MCP server. It will bridge the connection to your local Docker instance.
-
-**Claude Desktop Config (`~/Library/Application Support/Claude/claude_desktop_config.json`):**
-```json
-{
-  "mcpServers": {
-    "cybermem": {
-      "command": "npx",
-      "args": [
-        "-y",
-        "@cybermem/mcp"
-      ],
-      "env": {
-        "CYBERMEM_URL": "http://localhost:8080/memory",
-        "CYBERMEM_API_KEY": "your-api-key"
-      }
-    }
-  }
-}
-```
-
-### Option B: Remote (RPi / Cloud)
-If you have deployed CyberMem to a Raspberry Pi or Cloud VPS, **do not use npx**. Instead, connect directly to the remote SSE endpoint.
-
-**Claude Desktop Config:**
-```json
-{
-  "mcpServers": {
-    "cybermem-remote": {
-      "url": "http://<your-rpi-ip>:8080/mcp",
-      "transport": "sse",
-      "headers": {
-        "x-api-key": "your-api-key"
-      }
-    }
-  }
-}
-```
-
-## Environment Variables
-- `CYBERMEM_URL`: URL to the OpenMemory API (default: `http://localhost:8080/memory`)
-- `CYBERMEM_API_KEY`: Your API Key (found in `~/.cybermem/.env`)
+🌐 [cybermem.dev](https://cybermem.dev) · 📖 [Docs](https://docs.cybermem.dev) · 📦 [GitHub](https://github.com/mikhailkogan17/cybermem)

package/dist/commands/deploy.js

@@ -0,0 +1,230 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deployCommand = void 0;
+const chalk_1 = __importDefault(require("chalk"));
+const commander_1 = require("commander");
+const crypto_1 = __importDefault(require("crypto"));
+const execa_1 = __importDefault(require("execa"));
+const fs_1 = __importDefault(require("fs"));
+const inquirer_1 = __importDefault(require("inquirer"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+exports.deployCommand = new commander_1.Command('deploy')
+    .description('Deploy CyberMem services')
+    .option('-t, --target <target>', 'Deployment target (local, rpi, vps)', 'local')
+    .option('-h, --host <host>', 'SSH Host (user@ip) for remote deployment')
+    .option('--remote-access', 'Enable remote access via Tailscale Funnel (HTTPS)', false)
+    .option('--tailscale', 'Alias for --remote-access (deprecated)', false)
+    .option('--caddy', 'Use Caddy for automatic HTTPS (VPS only)')
+    .action(async (options) => {
+    const target = options.target;
+    const useTailscale = options.remoteAccess || options.tailscale;
+    const useCaddy = options.caddy;
+    console.log(chalk_1.default.blue(`Deploying to ${target}...`));
+    try {
+        // Resolve Template Directory (Support both Dev and Prod)
+        // Resolve Template Directory (Support both Dev and Prod)
+        // In Prod: __dirname is dist/commands, so templates is ../templates (dist/templates)
+        // In Dev (ts-node): __dirname is src/commands, so templates is ../../templates (root/packages/cli/templates)
+        // Try production path first (dist/templates)
+        let templateDir = path_1.default.resolve(__dirname, '../templates');
+        // If not found, try development path (src/../../templates)
+        if (!fs_1.default.existsSync(templateDir)) {
+            templateDir = path_1.default.resolve(__dirname, '../../templates');
+        }
+        // Final sanity check
+        if (!fs_1.default.existsSync(templateDir)) {
+            // Fallback for when running from root with ts-node directly (unlikely but possible)
+            templateDir = path_1.default.resolve(process.cwd(), 'packages/cli/templates');
+        }
+        if (!fs_1.default.existsSync(templateDir)) {
+            throw new Error(`Templates not found at ${templateDir}. Please ensure package is built correctly.`);
+        }
+        if (target === 'local') {
+            const composeFile = path_1.default.join(templateDir, 'docker-compose.yml');
+            const internalEnvExample = path_1.default.join(templateDir, 'envs/local.example');
+            if (!fs_1.default.existsSync(composeFile)) {
+                console.error(chalk_1.default.red(`Internal Error: Template not found at ${composeFile}`));
+                process.exit(1);
+            }
+            // Home Directory Config
+            const homeDir = os_1.default.homedir();
+            const configDir = path_1.default.join(homeDir, '.cybermem');
+            const envFile = path_1.default.join(configDir, '.env');
+            const dataDir = path_1.default.join(configDir, 'data');
+            // 1. Ensure ~/.cybermem exists
+            if (!fs_1.default.existsSync(configDir)) {
+                fs_1.default.mkdirSync(configDir, { recursive: true });
+                fs_1.default.mkdirSync(dataDir, { recursive: true });
+            }
+            // 2. Local Mode: Simplified setup without mandatory API key
+            if (!fs_1.default.existsSync(envFile)) {
+                console.log(chalk_1.default.yellow(`Initializing local configuration in ${configDir}...`));
+                const envContent = fs_1.default.readFileSync(internalEnvExample, 'utf-8');
+                fs_1.default.writeFileSync(envFile, envContent);
+                console.log(chalk_1.default.green(`Created .env at ${envFile}`));
+            }
+            console.log(chalk_1.default.blue('Starting CyberMem services in Local Mode...'));
+            // Execute docker-compose with internal file and USER HOME env
+            // Note: We pass CYBERMEM_API_KEY="" explicitly for local mode to trigger keyless bypass
+            await (0, execa_1.default)('docker-compose', [
+                '-f', composeFile,
+                '--env-file', envFile,
+                '--project-name', 'cybermem',
+                'up', '-d', '--remove-orphans'
+            ], {
+                stdio: 'inherit',
+                env: {
+                    ...process.env,
+                    DATA_DIR: dataDir,
+                    CYBERMEM_ENV_PATH: envFile,
+                    CYBERMEM_API_KEY: ''
+                }
+            });
+            console.log(chalk_1.default.green('\n🎉 CyberMem Installed!'));
+            console.log('');
+            console.log(chalk_1.default.bold('Next Steps:'));
+            console.log(`  1. Open ${chalk_1.default.underline('http://localhost:3000/client-connect')} to connect your MCP clients`);
+            console.log(`  2. Default password: ${chalk_1.default.bold('admin')} (you'll be prompted to change it)`);
+            console.log('');
+            console.log(chalk_1.default.dim('Local mode is active: No API key required for connections from this laptop.'));
+        }
+        else if (target === 'rpi') {
+            const composeFile = path_1.default.join(templateDir, 'docker-compose.yml');
+            const internalEnvExample = path_1.default.join(templateDir, 'envs/rpi.example');
+            let sshHost = options.host;
+            if (!sshHost) {
+                const answers = await inquirer_1.default.prompt([
+                    {
+                        type: 'input',
+                        name: 'host',
+                        message: 'Enter SSH Host (e.g. pi@raspberrypi.local):',
+                        validate: (input) => input.includes('@') ? true : 'Format must be user@host'
+                    }
+                ]);
+                sshHost = answers.host;
+            }
+            console.log(chalk_1.default.blue(`Remote deploying to ${sshHost}...`));
+            // 1. Create remote directory
+            await (0, execa_1.default)('ssh', [sshHost, 'mkdir -p ~/.cybermem/data']);
+            // 2. Initial Env Setup (if missing)
+            // We read remote file check using ssh
+            try {
+                await (0, execa_1.default)('ssh', [sshHost, '[ -f ~/.cybermem/.env ]']);
+                console.log(chalk_1.default.gray('Remote .env exists, skipping generation.'));
+            }
+            catch (e) {
+                console.log(chalk_1.default.yellow('Generating remote .env...'));
+                let envContent = fs_1.default.readFileSync(internalEnvExample, 'utf-8');
+                const newKey = `sk-${crypto_1.default.randomBytes(16).toString('hex')}`;
+                if (envContent.includes('CYBERMEM_API_KEY=')) {
+                    envContent = envContent.replace(/CYBERMEM_API_KEY=.*/, `CYBERMEM_API_KEY=${newKey}`);
+                }
+                // Write to temp file then scp
+                const tempEnv = path_1.default.join(os_1.default.tmpdir(), 'cybermem-rpi.env');
+                fs_1.default.writeFileSync(tempEnv, envContent);
+                await (0, execa_1.default)('scp', [tempEnv, `${sshHost}:~/.cybermem/.env`]);
+                fs_1.default.unlinkSync(tempEnv);
+            }
+            // 3. Copy Docker Compose
+            console.log(chalk_1.default.blue('Uploading templates...'));
+            await (0, execa_1.default)('scp', [composeFile, `${sshHost}:~/.cybermem/docker-compose.yml`]);
+            // 4. Run Docker Compose Remotely
+            console.log(chalk_1.default.blue('Starting services on RPi...'));
+            // We pass CYBERMEM_ENV_PATH explicitly as ~/.cybermem/.env and DATA_DIR as ~/.cybermem/data
+            // The template uses ${CYBERMEM_ENV_PATH} and maps volumes.
+            // We need to set these vars in the shell when running docker-compose
+            const remoteCmd = `
+                export CYBERMEM_ENV_PATH=~/.cybermem/.env
+                export DATA_DIR=~/.cybermem/data
+                docker-compose -f ~/.cybermem/docker-compose.yml up -d --remove-orphans
+            `;
+            await (0, execa_1.default)('ssh', [sshHost, remoteCmd], { stdio: 'inherit' });
+            console.log(chalk_1.default.green('\n✅ RPi deployment successful!'));
+            // Parse host from ssh string for convenience
+            const hostIp = sshHost.split('@')[1];
+            console.log(chalk_1.default.bold('Access Points (LAN):'));
+            console.log(`  - Dashboard:   ${chalk_1.default.underline(`http://${hostIp}:3000`)} (admin/admin)`);
+            console.log(`  - OpenMemory:  ${chalk_1.default.underline(`http://${hostIp}:8080`)}`);
+            // Tailscale Funnel setup
+            if (useTailscale) {
+                console.log(chalk_1.default.blue('\n🔗 Setting up Remote Access (Tailscale Funnel)...'));
+                try {
+                    // 1. Check/Install Tailscale
+                    try {
+                        await (0, execa_1.default)('ssh', [sshHost, 'which tailscale']);
+                    }
+                    catch (e) {
+                        console.log(chalk_1.default.yellow('  Tailscale not found. Installing...'));
+                        await (0, execa_1.default)('ssh', [sshHost, 'curl -fsSL https://tailscale.com/install.sh | sh'], { stdio: 'inherit' });
+                    }
+                    // 2. Auth (interactive if needed)
+                    console.log(chalk_1.default.blue('  Ensuring Tailscale is up...'));
+                    try {
+                        // Check status first to avoid re-auth if already up
+                        await (0, execa_1.default)('ssh', [sshHost, 'tailscale status']);
+                    }
+                    catch (e) {
+                        // Interactive auth
+                        console.log(chalk_1.default.yellow('  ⚠️  Tailscale authentication required. Please follow the prompts:'));
+                        await (0, execa_1.default)('ssh', [sshHost, 'sudo tailscale up'], { stdio: 'inherit' });
+                    }
+                    // 3. Configure Funnel (Verified commands)
+                    console.log(chalk_1.default.blue('  Configuring HTTPS Funnel (requires sudo access)...'));
+                    console.log(chalk_1.default.gray('  You may be prompted for your RPi password.'));
+                    // Routes:
+                    // - / -> Dashboard (3000)
+                    // - /cybermem/mcp -> MCP API (8626/mcp)
+                    await (0, execa_1.default)('ssh', ['-t', sshHost, 'sudo tailscale serve reset'], { stdio: 'inherit' }).catch(() => { });
+                    await (0, execa_1.default)('ssh', ['-t', sshHost, 'sudo tailscale serve --bg --set-path /cybermem http://127.0.0.1:8626'], { stdio: 'inherit' });
+                    await (0, execa_1.default)('ssh', ['-t', sshHost, 'sudo tailscale serve --bg http://127.0.0.1:3000'], { stdio: 'inherit' });
+                    await (0, execa_1.default)('ssh', ['-t', sshHost, 'sudo tailscale funnel --bg 443'], { stdio: 'inherit' });
+                    // Get DNS name
+                    const { stdout } = await (0, execa_1.default)('ssh', [sshHost, "tailscale status --json | jq -r '.Self.DNSName' | sed 's/\\.$//'"], { shell: true });
+                    const dnsName = stdout.trim();
+                    console.log(chalk_1.default.green('\n🌐 Remote Access Active (HTTPS):'));
+                    console.log(`  - Dashboard: ${chalk_1.default.underline(`https://${dnsName}/`)}`);
+                    console.log(`  - MCP API:   ${chalk_1.default.underline(`https://${dnsName}/cybermem/mcp`)}`);
+                }
+                catch (e) {
+                    console.log(chalk_1.default.red('\n❌ Remote Access setup failed:'));
+                    console.error(e);
+                    console.log(chalk_1.default.gray('Manual setup: curl -fsSL https://tailscale.com/install.sh | sh && sudo tailscale up'));
+                }
+            }
+            else {
+                console.log(chalk_1.default.gray('\n💡 For remote access, re-run with: cybermem deploy --target rpi --remote-access'));
+            }
+        }
+        else if (target === 'vps') {
+            console.log(chalk_1.default.yellow('VPS deployment is similar to RPi.'));
+            console.log(chalk_1.default.blue('\n📋 VPS Deployment Steps:'));
+            console.log('1. Run: cybermem deploy --target rpi --host user@your-vps-ip');
+            console.log('2. For HTTPS, choose one of:');
+            console.log(chalk_1.default.gray('   a) Tailscale Funnel: --tailscale flag'));
+            console.log(chalk_1.default.gray('   b) Caddy (recommended for public VPS):'));
+            console.log(chalk_1.default.gray('      - Install Caddy: sudo apt install caddy'));
+            console.log(chalk_1.default.gray('      - Configure /etc/caddy/Caddyfile:'));
+            console.log(chalk_1.default.cyan(`
+        cybermem.yourdomain.com {
+            reverse_proxy localhost:3000
+        }
+        api.cybermem.yourdomain.com {
+            reverse_proxy localhost:8080
+        }
+      `));
+            console.log(chalk_1.default.gray('      - Restart: sudo systemctl restart caddy'));
+            console.log(chalk_1.default.green('\n📚 Full docs: https://cybermem.dev/docs#https'));
+        }
+        else {
+            console.error(chalk_1.default.red(`Unknown target: ${target}. Use: local, rpi, or vps`));
+        }
+    }
+    catch (error) {
+        console.error(chalk_1.default.red('Deployment failed:'), error);
+        process.exit(1);
+    }
+});

package/dist/commands/init.js

@@ -0,0 +1,65 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initCommand = void 0;
+const chalk_1 = __importDefault(require("chalk"));
+const commander_1 = require("commander");
+const fs_1 = __importDefault(require("fs"));
+const inquirer_1 = __importDefault(require("inquirer"));
+const path_1 = __importDefault(require("path"));
+exports.initCommand = new commander_1.Command('init')
+    .description('Initialize CyberMem configuration')
+    .action(async () => {
+    console.log(chalk_1.default.bold.blue('🤖 CyberMem Setup Wizard'));
+    const { target } = await inquirer_1.default.prompt([
+        {
+            type: 'list',
+            name: 'target',
+            message: 'Where do you want to deploy?',
+            choices: [
+                { name: 'Local (Docker Compose)', value: 'local' },
+                { name: 'Raspberry Pi (Ansible)', value: 'rpi' },
+                { name: 'VPS (Kubernetes/Helm)', value: 'vps' }
+            ]
+        }
+    ]);
+    console.log(chalk_1.default.green(`Selected target: ${target}`));
+    if (target === 'local') {
+        const { confirm } = await inquirer_1.default.prompt([
+            {
+                type: 'confirm',
+                name: 'confirm',
+                message: 'This will create docker-compose.yml and .env in current directory. Continue?',
+                default: true
+            }
+        ]);
+        if (confirm) {
+            const templateDir = path_1.default.resolve(__dirname, '../../templates');
+            const envSrc = path_1.default.join(templateDir, 'envs/local.example');
+            if (!fs_1.default.existsSync(envSrc)) {
+                console.error(chalk_1.default.red(`Template not found at ${envSrc}.`));
+                return;
+            }
+            // Generate .env
+            let envContent = fs_1.default.readFileSync(envSrc, 'utf-8');
+            const crypto = require('crypto');
+            const newKey = `sk-${crypto.randomBytes(16).toString('hex')}`;
+            // Replace placeholder or key
+            if (envContent.includes('key-change-me') || envContent.includes('OM_API_KEY=')) {
+                envContent = envContent.replace(/OM_API_KEY=.*/, `OM_API_KEY=${newKey}`);
+            }
+            else {
+                envContent += `\nOM_API_KEY=${newKey}\n`;
+            }
+            fs_1.default.writeFileSync('.env', envContent);
+            console.log(chalk_1.default.gray('Created .env with generated API Key'));
+            console.log(chalk_1.default.gray('(Docker Compose configuration is managed internally by the CLI)'));
+            console.log(chalk_1.default.green('\nInitialization complete! Run "cybermem deploy" to start.'));
+        }
+    }
+    else {
+        console.log(chalk_1.default.yellow('Target init not fully implemented in CLI yet.'));
+    }
+});

package/dist/index.js

@@ -1,104 +1,212 @@
+#!/usr/bin/env node
 "use strict";
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const index_js_1 = require("@modelcontextprotocol/sdk/server/index.js");
-const stdio_js_1 = require("@modelcontextprotocol/sdk/server/stdio.js");
-const types_js_1 = require("@modelcontextprotocol/sdk/types.js");
-const axios_1 = __importDefault(require("axios"));
-const dotenv_1 = __importDefault(require("dotenv"));
-dotenv_1.default.config();
-const API_URL = process.env.CYBERMEM_URL || "http://localhost:8080/memory";
-const API_KEY = process.env.CYBERMEM_API_KEY || "dev-secret-key";
-const server = new index_js_1.Server({
-    name: "cybermem-mcp",
-    version: "0.1.0",
-}, {
-    capabilities: {
-        tools: {},
-    },
-});
-const tools = [
-    {
-        name: "add_memory",
-        description: "Store a new memory in CyberMem",
-        inputSchema: {
-            type: "object",
-            properties: {
-                content: { type: "string" },
-                user_id: { type: "string" },
-                tags: { type: "array", items: { type: "string" } },
-            },
-            required: ["content"],
-        },
-    },
-    {
-        name: "query_memory",
-        description: "Search for relevant memories",
-        inputSchema: {
-            type: "object",
-            properties: {
-                query: { type: "string" },
-                k: { type: "number", default: 5 },
-            },
-            required: ["query"],
-        },
-    },
-    {
-        name: "list_memories",
-        description: "List recent memories",
-        inputSchema: {
-            type: "object",
-            properties: {
-                limit: { type: "number", default: 10 },
-            },
-        },
-    }
-];
-server.setRequestHandler(types_js_1.ListToolsRequestSchema, async () => ({
-    tools,
-}));
-server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
-    const { name, arguments: args } = request.params;
+const chalk_1 = __importDefault(require("chalk"));
+const commander_1 = require("commander");
+const crypto_1 = __importDefault(require("crypto"));
+const execa_1 = __importDefault(require("execa"));
+const fs_1 = __importDefault(require("fs"));
+const inquirer_1 = __importDefault(require("inquirer"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const program = new commander_1.Command();
+program
+    .name('mcp')
+    .description('CyberMem - Deploy your AI memory server in one command')
+    .version('1.0.0')
+    .option('--rpi', 'Deploy to Raspberry Pi (default: local)')
+    .option('--vps', 'Deploy to VPS/Cloud server')
+    .option('-h, --host <host>', 'SSH Host (user@ip) for remote deployment')
+    .option('--remote-access', 'Enable Tailscale Funnel for HTTPS remote access')
+    .action(async (options) => {
+    // Determine target from flags
+    let target = 'local';
+    if (options.rpi)
+        target = 'rpi';
+    if (options.vps)
+        target = 'vps';
+    const useTailscale = options.remoteAccess;
+    console.log(chalk_1.default.blue(`Deploying CyberMem (${target})...`));
     try {
-        switch (name) {
-            case "add_memory": {
-                const response = await axios_1.default.post(`${API_URL}/add`, args, {
-                    headers: { "Authorization": `Bearer ${API_KEY}` }
-                });
-                return { content: [{ type: "text", text: JSON.stringify(response.data) }] };
+        // Resolve Template Directory (Support both Dev and Prod)
+        let templateDir = path_1.default.resolve(__dirname, '../templates');
+        if (!fs_1.default.existsSync(templateDir)) {
+            templateDir = path_1.default.resolve(__dirname, '../../templates');
+        }
+        if (!fs_1.default.existsSync(templateDir)) {
+            templateDir = path_1.default.resolve(process.cwd(), 'packages/cli/templates');
+        }
+        if (!fs_1.default.existsSync(templateDir)) {
+            throw new Error(`Templates not found at ${templateDir}. Please ensure package is built correctly.`);
+        }
+        if (target === 'local') {
+            const composeFile = path_1.default.join(templateDir, 'docker-compose.yml');
+            const internalEnvExample = path_1.default.join(templateDir, 'envs/local.example');
+            if (!fs_1.default.existsSync(composeFile)) {
+                console.error(chalk_1.default.red(`Internal Error: Template not found at ${composeFile}`));
+                process.exit(1);
             }
-            case "query_memory": {
-                const response = await axios_1.default.post(`${API_URL}/query`, args, {
-                    headers: { "Authorization": `Bearer ${API_KEY}` }
-                });
-                return { content: [{ type: "text", text: JSON.stringify(response.data) }] };
+            // Home Directory Config
+            const homeDir = os_1.default.homedir();
+            const configDir = path_1.default.join(homeDir, '.cybermem');
+            const envFile = path_1.default.join(configDir, '.env');
+            const dataDir = path_1.default.join(configDir, 'data');
+            // 1. Ensure ~/.cybermem exists
+            if (!fs_1.default.existsSync(configDir)) {
+                fs_1.default.mkdirSync(configDir, { recursive: true });
+                fs_1.default.mkdirSync(dataDir, { recursive: true });
             }
-            case "list_memories": {
-                const limit = args?.limit || 10;
-                const response = await axios_1.default.get(`${API_URL}/list?limit=${limit}`, {
-                    headers: { "Authorization": `Bearer ${API_KEY}` }
-                });
-                return { content: [{ type: "text", text: JSON.stringify(response.data) }] };
+            // 2. Local Mode: Simplified setup without mandatory API key
+            if (!fs_1.default.existsSync(envFile)) {
+                console.log(chalk_1.default.yellow(`Initializing local configuration in ${configDir}...`));
+                const envContent = fs_1.default.readFileSync(internalEnvExample, 'utf-8');
+                fs_1.default.writeFileSync(envFile, envContent);
+                console.log(chalk_1.default.green(`Created .env at ${envFile}`));
             }
-            default:
-                throw new Error(`Unknown tool: ${name}`);
+            console.log(chalk_1.default.blue('Starting CyberMem services in Local Mode...'));
+            await (0, execa_1.default)('docker-compose', [
+                '-f', composeFile,
+                '--env-file', envFile,
+                '--project-name', 'cybermem',
+                'up', '-d', '--remove-orphans'
+            ], {
+                stdio: 'inherit',
+                env: {
+                    ...process.env,
+                    DATA_DIR: dataDir,
+                    CYBERMEM_ENV_PATH: envFile,
+                    CYBERMEM_API_KEY: ''
+                }
+            });
+            console.log(chalk_1.default.green('\n🎉 CyberMem Installed!'));
+            console.log('');
+            console.log(chalk_1.default.bold('Next Steps:'));
+            console.log(`  1. Open ${chalk_1.default.underline('http://localhost:3000/client-connect')} to connect your MCP clients`);
+            console.log(`  2. Default password: ${chalk_1.default.bold('admin')} (you'll be prompted to change it)`);
+            console.log('');
+            console.log(chalk_1.default.dim('Local mode is active: No API key required for connections from this laptop.'));
+        }
+        else if (target === 'rpi') {
+            const composeFile = path_1.default.join(templateDir, 'docker-compose.yml');
+            const internalEnvExample = path_1.default.join(templateDir, 'envs/rpi.example');
+            let sshHost = options.host;
+            if (!sshHost) {
+                const answers = await inquirer_1.default.prompt([
+                    {
+                        type: 'input',
+                        name: 'host',
+                        message: 'Enter SSH Host (e.g. pi@raspberrypi.local):',
+                        validate: (input) => input.includes('@') ? true : 'Format must be user@host'
+                    }
+                ]);
+                sshHost = answers.host;
+            }
+            console.log(chalk_1.default.blue(`Remote deploying to ${sshHost}...`));
+            // 1. Create remote directory
+            await (0, execa_1.default)('ssh', [sshHost, 'mkdir -p ~/.cybermem/data']);
+            // 2. Initial Env Setup (if missing)
+            try {
+                await (0, execa_1.default)('ssh', [sshHost, '[ -f ~/.cybermem/.env ]']);
+                console.log(chalk_1.default.gray('Remote .env exists, skipping generation.'));
+            }
+            catch (e) {
+                console.log(chalk_1.default.yellow('Generating remote .env...'));
+                let envContent = fs_1.default.readFileSync(internalEnvExample, 'utf-8');
+                const newKey = `sk-${crypto_1.default.randomBytes(16).toString('hex')}`;
+                if (envContent.includes('CYBERMEM_API_KEY=')) {
+                    envContent = envContent.replace(/CYBERMEM_API_KEY=.*/, `CYBERMEM_API_KEY=${newKey}`);
+                }
+                const tempEnv = path_1.default.join(os_1.default.tmpdir(), 'cybermem-rpi.env');
+                fs_1.default.writeFileSync(tempEnv, envContent);
+                await (0, execa_1.default)('scp', [tempEnv, `${sshHost}:~/.cybermem/.env`]);
+                fs_1.default.unlinkSync(tempEnv);
+            }
+            // 3. Copy Docker Compose
+            console.log(chalk_1.default.blue('Uploading templates...'));
+            await (0, execa_1.default)('scp', [composeFile, `${sshHost}:~/.cybermem/docker-compose.yml`]);
+            // 4. Run Docker Compose Remotely
+            console.log(chalk_1.default.blue('Starting services on RPi...'));
+            // DOCKER_DEFAULT_PLATFORM=linux/arm64 forces arm64 images on RPi with 64-bit kernel but 32-bit Docker
+            const remoteCmd = `
+                export CYBERMEM_ENV_PATH=~/.cybermem/.env
+                export DATA_DIR=~/.cybermem/data
+                export DOCKER_DEFAULT_PLATFORM=linux/arm64
+                docker-compose -f ~/.cybermem/docker-compose.yml up -d --remove-orphans
+            `;
+            await (0, execa_1.default)('ssh', [sshHost, remoteCmd], { stdio: 'inherit' });
+            console.log(chalk_1.default.green('\n✅ RPi deployment successful!'));
+            const hostIp = sshHost.split('@')[1];
+            console.log(chalk_1.default.bold('Access Points (LAN):'));
+            console.log(`  - Dashboard:   ${chalk_1.default.underline(`http://${hostIp}:3000`)} (admin/admin)`);
+            console.log(`  - OpenMemory:  ${chalk_1.default.underline(`http://${hostIp}:8080`)}`);
+            // Tailscale Funnel setup
+            if (useTailscale) {
+                console.log(chalk_1.default.blue('\n🔗 Setting up Remote Access (Tailscale Funnel)...'));
+                try {
+                    try {
+                        await (0, execa_1.default)('ssh', [sshHost, 'which tailscale']);
+                    }
+                    catch (e) {
+                        console.log(chalk_1.default.yellow('  Tailscale not found. Installing...'));
+                        await (0, execa_1.default)('ssh', [sshHost, 'curl -fsSL https://tailscale.com/install.sh | sh'], { stdio: 'inherit' });
+                    }
+                    console.log(chalk_1.default.blue('  Ensuring Tailscale is up...'));
+                    try {
+                        await (0, execa_1.default)('ssh', [sshHost, 'tailscale status']);
+                    }
+                    catch (e) {
+                        console.log(chalk_1.default.yellow('  ⚠️  Tailscale authentication required. Please follow the prompts:'));
+                        await (0, execa_1.default)('ssh', [sshHost, 'sudo tailscale up'], { stdio: 'inherit' });
+                    }
+                    console.log(chalk_1.default.blue('  Configuring HTTPS Funnel (requires sudo access)...'));
+                    console.log(chalk_1.default.gray('  You may be prompted for your RPi password.'));
+                    await (0, execa_1.default)('ssh', ['-t', sshHost, 'sudo tailscale serve reset'], { stdio: 'inherit' }).catch(() => { });
+                    await (0, execa_1.default)('ssh', ['-t', sshHost, 'sudo tailscale serve --bg --set-path /cybermem http://127.0.0.1:8626'], { stdio: 'inherit' });
+                    await (0, execa_1.default)('ssh', ['-t', sshHost, 'sudo tailscale serve --bg http://127.0.0.1:3000'], { stdio: 'inherit' });
+                    await (0, execa_1.default)('ssh', ['-t', sshHost, 'sudo tailscale funnel --bg 443'], { stdio: 'inherit' });
+                    const { stdout } = await (0, execa_1.default)('ssh', [sshHost, "tailscale status --json | jq -r '.Self.DNSName' | sed 's/\\.$//'"]);
+                    const dnsName = stdout.trim();
+                    console.log(chalk_1.default.green('\n🌐 Remote Access Active (HTTPS):'));
+                    console.log(`  - Dashboard: ${chalk_1.default.underline(`https://${dnsName}/`)}`);
+                    console.log(`  - MCP API:   ${chalk_1.default.underline(`https://${dnsName}/cybermem/mcp`)}`);
+                }
+                catch (e) {
+                    console.log(chalk_1.default.red('\n❌ Remote Access setup failed:'));
+                    console.error(e);
+                    console.log(chalk_1.default.gray('Manual setup: curl -fsSL https://tailscale.com/install.sh | sh && sudo tailscale up'));
+                }
+            }
+            else {
+                console.log(chalk_1.default.gray('\n💡 For remote access, re-run with: npx @cybermem/mcp --rpi --remote-access'));
+            }
+        }
+        else if (target === 'vps') {
+            console.log(chalk_1.default.yellow('VPS deployment is similar to RPi.'));
+            console.log(chalk_1.default.blue('\n📋 VPS Deployment Steps:'));
+            console.log('1. Run: npx @cybermem/mcp --rpi --host user@your-vps-ip');
+            console.log('2. For HTTPS, choose one of:');
+            console.log(chalk_1.default.gray('   a) Tailscale Funnel: --remote-access flag'));
+            console.log(chalk_1.default.gray('   b) Caddy (recommended for public VPS):'));
+            console.log(chalk_1.default.gray('      - Install Caddy: sudo apt install caddy'));
+            console.log(chalk_1.default.gray('      - Configure /etc/caddy/Caddyfile:'));
+            console.log(chalk_1.default.cyan(`
+        cybermem.yourdomain.com {
+            reverse_proxy localhost:3000
+        }
+        api.cybermem.yourdomain.com {
+            reverse_proxy localhost:8080
+        }
+      `));
+            console.log(chalk_1.default.gray('      - Restart: sudo systemctl restart caddy'));
+            console.log(chalk_1.default.green('\n📚 Full docs: https://cybermem.dev/docs#https'));
         }
     }
     catch (error) {
-        return {
-            content: [{ type: "text", text: `Error: ${error.message}` }],
-            isError: true,
-        };
+        console.error(chalk_1.default.red('Deployment failed:'), error);
+        process.exit(1);
     }
 });
-async function run() {
-    const transport = new stdio_js_1.StdioServerTransport();
-    await server.connect(transport);
-    console.error("CyberMem MCP Server running on stdio");
-}
-run().catch((error) => {
-    console.error("Fatal error running server:", error);
-    process.exit(1);
-});
+program.parse(process.argv);