@cybermem/cli 0.6.11 → 0.7.7

package/dist/commands/backup.js

@@ -16,10 +16,10 @@ async function backup(options) {
     try {
         // Check if container exists
         try {
-            await (0, execa_1.default)('docker', ['inspect', 'cybermem-openmemory']);
+            await (0, execa_1.default)('docker', ['inspect', 'cybermem-mcp']);
         }
         catch (e) {
-            console.error(chalk_1.default.red('Error: cybermem-openmemory container not found. Is CyberMem installed?'));
+            console.error(chalk_1.default.red('Error: cybermem-mcp container not found. Is CyberMem installed?'));
             process.exit(1);
         }
         // Use a transient alpine container to tar the /data volume
@@ -27,7 +27,7 @@ async function backup(options) {
         // And we use --volumes-from to access the data volume of the running service
         const cmd = [
             'run', '--rm',
-            '--volumes-from', 'cybermem-openmemory',
+            '--volumes-from', 'cybermem-mcp',
             '-v', `${process.cwd()}:/backup`,
             'alpine',
             'tar', 'czf', `/backup/${filename}`, '-C', '/', 'data'

package/dist/commands/dashboard.js

@@ -0,0 +1,90 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dashboard = dashboard;
+const chalk_1 = __importDefault(require("chalk"));
+const fs_1 = __importDefault(require("fs"));
+const net_1 = __importDefault(require("net"));
+const open_1 = __importDefault(require("open"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const TOKEN_FILE = path_1.default.join(os_1.default.homedir(), ".cybermem", "token.json");
+const checkPort = (port) => {
+    return new Promise((resolve) => {
+        const socket = new net_1.default.Socket();
+        const onError = () => {
+            socket.destroy();
+            resolve(false);
+        };
+        socket.setTimeout(500);
+        socket.once("error", onError);
+        socket.once("timeout", onError);
+        socket.connect(port, "localhost", () => {
+            socket.end();
+            resolve(true);
+        });
+    });
+};
+/**
+ * Get stored token from ~/.cybermem/token.json
+ */
+function getStoredToken() {
+    try {
+        if (!fs_1.default.existsSync(TOKEN_FILE))
+            return null;
+        const data = JSON.parse(fs_1.default.readFileSync(TOKEN_FILE, "utf-8"));
+        if (new Date(data.expires_at) < new Date()) {
+            console.warn(chalk_1.default.yellow("Token expired. Run: cybermem-cli login"));
+            return null;
+        }
+        return data.access_token;
+    }
+    catch {
+        return null;
+    }
+}
+async function dashboard(options) {
+    console.log(chalk_1.default.blue("Checking CyberMem stack status..."));
+    const [dashboardUp, prometheusUp] = await Promise.all([
+        checkPort(3000),
+        checkPort(9092),
+    ]);
+    if (!dashboardUp) {
+        console.error(chalk_1.default.red("❌ Dashboard is NOT running on port 3000."));
+        console.log(chalk_1.default.yellow("Run 'cybermem up' or 'cd packages/dashboard && npm run dev' to start it."));
+    }
+    else {
+        console.log(chalk_1.default.green("✅ Dashboard is running on port 3000."));
+    }
+    if (!prometheusUp) {
+        console.warn(chalk_1.default.yellow("⚠️  Prometheus is NOT running on port 9092."));
+        console.warn(chalk_1.default.gray("   Charts will be empty. Run 'cybermem up' or 'docker-compose up' to enable metrics."));
+    }
+    else {
+        console.log(chalk_1.default.green("✅ Prometheus is running on port 9092."));
+    }
+    if (dashboardUp) {
+        console.log(chalk_1.default.blue("\nOpening dashboard..."));
+        await (0, open_1.default)("http://localhost:3000");
+    }
+    else {
+        // Try remote dashboard if local isn't up
+        const token = getStoredToken();
+        if (token) {
+            // Check for remote URL from environment or config
+            const remoteUrl = process.env.CYBERMEM_DASHBOARD_URL;
+            if (remoteUrl) {
+                console.log(chalk_1.default.blue("\nOpening remote dashboard..."));
+                await (0, open_1.default)(`${remoteUrl}/api/auth/token?token=${token}`);
+            }
+            else {
+                console.log(chalk_1.default.gray("\nTip: Set CYBERMEM_DASHBOARD_URL to open remote dashboard."));
+            }
+        }
+        else {
+            console.log(chalk_1.default.gray("\nTip: Run 'cybermem-cli login' to enable remote access."));
+        }
+    }
+}

package/dist/commands/init.js

@@ -3,63 +3,247 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.initCommand = void 0;
+exports.init = init;
 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.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' }
-            ]
+async function init(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(`Initializing CyberMem (${target})...`));
+    try {
+        // 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");
         }
-    ]);
-    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 (!fs_1.default.existsSync(templateDir)) {
+            templateDir = path_1.default.resolve(process.cwd(), "packages/cli/templates");
+        }
+        if (!fs_1.default.existsSync(templateDir)) {
+            // Fallback for different build structures
+            templateDir = path_1.default.resolve(__dirname, "../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");
+            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
+            if (!fs_1.default.existsSync(envFile)) {
+                console.log(chalk_1.default.yellow(`Initializing local configuration in ${configDir}...`));
+                const templateEnv = path_1.default.join(templateDir, "envs/local.env");
+                const envContent = fs_1.default.readFileSync(templateEnv, "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..."));
+            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,
+                    OM_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" || target === "vps") {
+            const composeFile = path_1.default.join(templateDir, "docker-compose.yml");
+            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",
+                },
+            ]);
+            const 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"]);
+            // 1.5 Check and fix Docker architecture (64-bit kernel with 32-bit Docker)
+            console.log(chalk_1.default.blue("Checking Docker architecture..."));
+            try {
+                const { stdout: kernelArch } = await (0, execa_1.default)("ssh", [
+                    sshHost,
+                    "uname -m",
+                ]);
+                const { stdout: dockerArch } = await (0, execa_1.default)("ssh", [
+                    sshHost,
+                    'docker version --format "{{.Server.Arch}}" 2>/dev/null || echo "unknown"',
+                ]);
+                if (kernelArch.trim() === "aarch64" && dockerArch.trim() !== "arm64") {
+                    console.log(chalk_1.default.yellow(`⚠️  Docker is ${dockerArch.trim()}, kernel is aarch64. Installing arm64 Docker...`));
+                    const installCmd = `
+                        sudo systemctl stop docker docker.socket 2>/dev/null || true
+                        curl -fsSL https://download.docker.com/linux/static/stable/aarch64/docker-27.5.1.tgz -o /tmp/docker.tgz
+                        sudo tar -xzf /tmp/docker.tgz -C /usr/local/bin --strip-components=1
+                        sudo /usr/local/bin/dockerd &
+                        sleep 5
+                        docker version --format "{{.Server.Arch}}"
+                    `;
+                    const { stdout } = await (0, execa_1.default)("ssh", [sshHost, installCmd], {
+                        shell: true,
+                    });
+                    if (stdout.includes("arm64")) {
+                        console.log(chalk_1.default.green("✅ Docker arm64 installed successfully"));
+                    }
+                    else {
+                        console.log(chalk_1.default.yellow("⚠️  Docker arm64 install may need manual verification"));
+                    }
+                }
+                else if (dockerArch.trim() === "arm64") {
+                    console.log(chalk_1.default.green(`✅ Docker is already arm64`));
+                }
+                else {
+                    console.log(chalk_1.default.gray(`Docker arch: ${dockerArch.trim()}, kernel: ${kernelArch.trim()}`));
+                }
+            }
+            catch (e) {
+                console.log(chalk_1.default.yellow(`⚠️  Docker arch check skipped: ${e.message}`));
+            }
+            // 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."));
             }
-        ]);
-        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;
+            catch (e) {
+                console.log(chalk_1.default.yellow("Generating remote configuration..."));
+                let templateName = "rpi.env";
+                if (target === "vps")
+                    templateName = "vps.env";
+                else if (useTailscale)
+                    templateName = "rpi-tailscale.env";
+                const templateEnv = path_1.default.join(templateDir, "envs", templateName);
+                let envContent = fs_1.default.readFileSync(templateEnv, "utf-8");
+                const newKey = `cm-${crypto_1.default.randomBytes(16).toString("hex")}`;
+                // Replace OM_API_KEY with generated key
+                if (envContent.includes("OM_API_KEY=")) {
+                    envContent = envContent.replace(/OM_API_KEY=.*/, `OM_API_KEY=${newKey}`);
+                }
+                const tempEnv = path_1.default.join(os_1.default.tmpdir(), "cybermem-remote.env");
+                fs_1.default.writeFileSync(tempEnv, envContent);
+                await (0, execa_1.default)("scp", [tempEnv, `${sshHost}:~/.cybermem/.env`]);
+                fs_1.default.unlinkSync(tempEnv);
+                console.log(chalk_1.default.green(`✅ Security configuration generated (${templateName}).`));
             }
-            // 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}`);
+            // 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 {
-                envContent += `\nOM_API_KEY=${newKey}\n`;
+                console.log(chalk_1.default.gray("\n💡 For remote access, re-run with: npx @cybermem/cli --rpi --remote-access"));
             }
-            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.'));
+    catch (error) {
+        console.error(chalk_1.default.red("Deployment failed:"), error);
+        process.exit(1);
     }
-});
+}

package/dist/commands/login.js

@@ -0,0 +1,165 @@
+"use strict";
+/**
+ * CyberMem CLI Auth Module
+ *
+ * Token storage and browser-based OAuth login flow.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.login = login;
+const chalk_1 = __importDefault(require("chalk"));
+const fs = __importStar(require("fs"));
+const http = __importStar(require("http"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const AUTH_DIR = path.join(os.homedir(), ".cybermem");
+const TOKEN_FILE = path.join(AUTH_DIR, "token.json");
+const AUTH_URL = process.env.CYBERMEM_AUTH_URL || "https://cybermem.dev";
+/**
+ * Ensure the .cybermem directory exists
+ */
+function ensureAuthDir() {
+    if (!fs.existsSync(AUTH_DIR)) {
+        fs.mkdirSync(AUTH_DIR, { recursive: true, mode: 0o700 });
+    }
+}
+/**
+ * Save token to disk
+ */
+function saveToken(token, expiresIn, email, name) {
+    ensureAuthDir();
+    const expiresAt = new Date(Date.now() + expiresIn * 1000);
+    const data = {
+        access_token: token,
+        expires_at: expiresAt.toISOString(),
+        email,
+        name,
+    };
+    fs.writeFileSync(TOKEN_FILE, JSON.stringify(data, null, 2), { mode: 0o600 });
+}
+/**
+ * Start OAuth login flow
+ * Opens browser and waits for callback with token
+ */
+async function login() {
+    return new Promise((resolve, reject) => {
+        // Find available port
+        const server = http.createServer();
+        server.listen(0, "127.0.0.1", () => {
+            const address = server.address();
+            if (!address || typeof address === "string") {
+                reject(new Error("Failed to start callback server"));
+                return;
+            }
+            const port = address.port;
+            const callbackUrl = `http://localhost:${port}/callback`;
+            // Redirect to landing auth endpoint which starts GitHub flow
+            // We pass our local callbackUrl as 'redirect' param to the intermediate CLI callback handler
+            const authUrl = `${AUTH_URL}/api/auth/signin?callbackUrl=${encodeURIComponent(`${AUTH_URL}/api/auth/cli/callback?redirect=${encodeURIComponent(callbackUrl)}`)}`;
+            console.log(chalk_1.default.blue("🔐 Opening browser for GitHub login..."));
+            console.log(chalk_1.default.gray(`   If browser doesn't open, visit: ${authUrl}`));
+            // Open browser
+            const open = async (url) => {
+                const { default: openBrowser } = await Promise.resolve().then(() => __importStar(require("open")));
+                await openBrowser(url);
+            };
+            open(authUrl);
+            // Handle callback
+            server.on("request", async (req, res) => {
+                if (!req.url?.startsWith("/callback")) {
+                    res.writeHead(404);
+                    res.end("Not found");
+                    return;
+                }
+                const url = new URL(req.url, `http://localhost:${port}`);
+                const token = url.searchParams.get("token");
+                if (!token) {
+                    res.writeHead(400);
+                    res.end("Missing token");
+                    server.close();
+                    reject(new Error("No token received"));
+                    return;
+                }
+                // Decode token to get user info (JWT payload)
+                let email;
+                let name;
+                try {
+                    const payload = JSON.parse(Buffer.from(token.split(".")[1], "base64").toString());
+                    email = payload.email;
+                    name = payload.name;
+                }
+                catch {
+                    // Ignore decode errors
+                }
+                // Save token (30 days expiry)
+                saveToken(token, 30 * 24 * 60 * 60, email, name);
+                // Send success page
+                res.writeHead(200, { "Content-Type": "text/html" });
+                res.end(`
+          <!DOCTYPE html>
+          <html>
+          <head>
+            <title>CyberMem - Logged In</title>
+            <style>
+              body { font-family: system-ui; text-align: center; padding: 50px; background: #0a0a0a; color: #fff; }
+              h1 { color: #22c55e; }
+              .logo { font-size: 48px; margin-bottom: 20px; }
+            </style>
+          </head>
+          <body>
+            <div class="logo">🧠</div>
+            <h1>Successfully Logged In!</h1>
+            <p>You can close this window and return to your terminal.</p>
+            <p style="color: #888;">Logged in as: ${email || name || "Unknown"}</p>
+          </body>
+          </html>
+        `);
+                console.log("");
+                console.log(chalk_1.default.green("✅ Successfully logged in as:"), chalk_1.default.bold(email || name || "Unknown"));
+                console.log(chalk_1.default.gray(`   Token saved to: ${TOKEN_FILE}`));
+                server.close();
+                resolve();
+            });
+            // Timeout after 5 minutes
+            setTimeout(() => {
+                server.close();
+                reject(new Error("Login timeout - no callback received"));
+            }, 5 * 60 * 1000);
+        });
+    });
+}

package/dist/commands/reset.js

@@ -10,7 +10,7 @@ const ora_1 = __importDefault(require("ora"));
 async function reset() {
     const spinner = (0, ora_1.default)('Resetting CyberMem database...').start();
     try {
-        const containerName = 'cybermem-openmemory';
+        const containerName = 'cybermem-mcp';
         // Check if container exists
         try {
             (0, child_process_1.execSync)(`docker inspect ${containerName}`, { stdio: 'pipe' });

package/dist/commands/restore.js

@@ -25,7 +25,7 @@ async function restore(file, options) {
         // 1. Stop the OpenMemory service to safely write to DB
         console.log(chalk_1.default.blue('Stopping OpenMemory service...'));
         try {
-            await (0, execa_1.default)('docker', ['stop', 'cybermem-openmemory']);
+            await (0, execa_1.default)('docker', ['stop', 'cybermem-mcp']);
         }
         catch (e) {
             console.log(chalk_1.default.gray('Container not running (or not found), proceeding...'));
@@ -37,7 +37,7 @@ async function restore(file, options) {
         const filename = path_1.default.basename(backupPath);
         const cmd = [
             'run', '--rm',
-            '--volumes-from', 'cybermem-openmemory', // Access the volume even if container is stopped
+            '--volumes-from', 'cybermem-mcp', // Access the volume even if container is stopped
             '-v', `${dir}:/backup`,
             'alpine',
             'sh', '-c',
@@ -50,13 +50,13 @@ async function restore(file, options) {
         await (0, execa_1.default)('docker', cmd, { stdio: 'inherit' });
         // 3. Restart the service
         console.log(chalk_1.default.blue('Restarting OpenMemory service...'));
-        await (0, execa_1.default)('docker', ['start', 'cybermem-openmemory']);
+        await (0, execa_1.default)('docker', ['start', 'cybermem-mcp']);
         console.log(chalk_1.default.green(`\n✅ Restore completed successfully!`));
         console.log('Your memory has been recovered.');
     }
     catch (error) {
         console.error(chalk_1.default.red('Restore failed:'), error);
-        console.log(chalk_1.default.yellow('Suggestion: Check if Docker is running and "cybermem-openmemory" container exists.'));
+        console.log(chalk_1.default.yellow('Suggestion: Check if Docker is running and "cybermem-mcp" container exists.'));
         process.exit(1);
     }
 }