@cybermem/cli 0.6.0

package/README.md

@@ -0,0 +1,5 @@
+# @cybermem/mcp
+
+Universal Long-Term Memory for AI Agents.
+
+🌐 [cybermem.dev](https://cybermem.dev) · 📖 [Docs](https://docs.cybermem.dev) · 📦 [GitHub](https://github.com/mikhailkogan17/cybermem)

package/dist/commands/__tests__/backup.test.js

@@ -0,0 +1,75 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const execa_1 = __importDefault(require("execa"));
+const fs_1 = __importDefault(require("fs"));
+const backup_1 = require("../backup");
+// Mock dependencies
+jest.mock('execa');
+jest.mock('fs');
+jest.mock('path', () => ({
+    ...jest.requireActual('path'),
+    resolve: jest.fn((...args) => args.join('/')),
+    basename: jest.fn((p) => p.split('/').pop() || ''),
+    dirname: jest.fn((p) => p.split('/').slice(0, -1).join('/') || '/'),
+}));
+// Mock console to keep output clean
+const originalConsoleLog = console.log;
+const originalConsoleError = console.error;
+describe('backup command', () => {
+    beforeAll(() => {
+        console.log = jest.fn();
+        console.error = jest.fn();
+    });
+    afterAll(() => {
+        console.log = originalConsoleLog;
+        console.error = originalConsoleError;
+    });
+    beforeEach(() => {
+        jest.clearAllMocks();
+        // Default process.cwd
+        jest.spyOn(process, 'cwd').mockReturnValue('/mock/cwd');
+    });
+    it('should create a backup successfully when openmemory container exists', async () => {
+        // Mock docker inspect success
+        execa_1.default.mockResolvedValueOnce({ exitCode: 0 });
+        // Mock docker run success
+        execa_1.default.mockResolvedValueOnce({ exitCode: 0 });
+        // Mock fs.existsSync to true (file created)
+        fs_1.default.existsSync.mockReturnValue(true);
+        // Mock fs.statSync
+        fs_1.default.statSync.mockReturnValue({ size: 5 * 1024 * 1024 }); // 5MB
+        await (0, backup_1.backup)({});
+        // Expect docker inspect check
+        expect(execa_1.default).toHaveBeenCalledWith('docker', ['inspect', 'cybermem-openmemory']);
+        // Expect docker run tar
+        const tarCall = execa_1.default.mock.calls[1];
+        expect(tarCall[0]).toBe('docker');
+        expect(tarCall[1]).toContain('run');
+        expect(tarCall[1]).toContain('tar');
+        expect(tarCall[1]).toContain('czf');
+        // Check volumes from
+        expect(tarCall[1]).toContain('--volumes-from');
+        expect(tarCall[1]).toContain('cybermem-openmemory');
+    });
+    it('should fail if openmemory container does not exist', async () => {
+        // Mock inspect failure
+        execa_1.default.mockRejectedValueOnce(new Error('No such container'));
+        const exitSpy = jest.spyOn(process, 'exit').mockImplementation((() => { }));
+        await (0, backup_1.backup)({});
+        expect(console.error).toHaveBeenCalledWith(expect.stringContaining('not found'));
+        expect(exitSpy).toHaveBeenCalledWith(1);
+    });
+    it('should error if backup file is not created', async () => {
+        execa_1.default.mockResolvedValue({ exitCode: 0 }); // inspect OK
+        execa_1.default.mockResolvedValue({ exitCode: 0 }); // run OK
+        // Mock file check false
+        fs_1.default.existsSync.mockReturnValue(false);
+        const exitSpy = jest.spyOn(process, 'exit').mockImplementation((() => { }));
+        await (0, backup_1.backup)({});
+        expect(console.error).toHaveBeenCalledWith(expect.stringContaining('Backup failed'));
+        expect(exitSpy).toHaveBeenCalledWith(1);
+    });
+});

package/dist/commands/__tests__/restore.test.js

@@ -0,0 +1,70 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const execa_1 = __importDefault(require("execa"));
+const fs_1 = __importDefault(require("fs"));
+const restore_1 = require("../restore");
+jest.mock('execa');
+jest.mock('fs');
+jest.mock('path', () => ({
+    ...jest.requireActual('path'),
+    resolve: jest.fn((...args) => args.join('/')),
+    basename: jest.fn((p) => p.split('/').pop() || ''),
+    dirname: jest.fn((p) => p.split('/').slice(0, -1).join('/') || '/'),
+}));
+const originalConsoleLog = console.log;
+const originalConsoleError = console.error;
+describe('restore command', () => {
+    beforeAll(() => {
+        console.log = jest.fn();
+        console.error = jest.fn();
+    });
+    afterAll(() => {
+        console.log = originalConsoleLog;
+        console.error = originalConsoleError;
+    });
+    beforeEach(() => {
+        jest.clearAllMocks();
+        jest.spyOn(process, 'cwd').mockReturnValue('/mock/cwd');
+    });
+    it('should restore successfully', async () => {
+        // Mock file exists
+        fs_1.default.existsSync.mockReturnValue(true);
+        // Mock docker stop (success)
+        execa_1.default.mockResolvedValueOnce({ exitCode: 0 });
+        // Mock docker run tar (success)
+        execa_1.default.mockResolvedValueOnce({ exitCode: 0 });
+        // Mock docker start (success)
+        execa_1.default.mockResolvedValueOnce({ exitCode: 0 });
+        await (0, restore_1.restore)('backup.tar.gz', {});
+        // Check docker stop
+        expect(execa_1.default).toHaveBeenCalledWith('docker', ['stop', 'cybermem-openmemory']);
+        // Check docker run tar
+        const tarCall = execa_1.default.mock.calls[1];
+        expect(tarCall[0]).toBe('docker');
+        expect(tarCall[1]).toContain('run');
+        expect(tarCall[1]).toContain('tar xzf /backup/backup.tar.gz -C / && chown -R 1001:1001 /data');
+        // Check docker start
+        expect(execa_1.default).toHaveBeenCalledWith('docker', ['start', 'cybermem-openmemory']);
+    });
+    it('should ignore docker stop error (if container not running)', async () => {
+        fs_1.default.existsSync.mockReturnValue(true);
+        // Mock docker stop FAIL
+        execa_1.default.mockRejectedValueOnce(new Error('No such container'));
+        // Mock succeeding calls
+        execa_1.default.mockResolvedValue({ exitCode: 0 });
+        await (0, restore_1.restore)('backup.tar.gz', {});
+        // Should still proceed to restore
+        expect(execa_1.default).toHaveBeenCalledWith('docker', expect.arrayContaining(['run']));
+        expect(execa_1.default).toHaveBeenCalledWith('docker', ['start', 'cybermem-openmemory']);
+    });
+    it('should fail if backup file missing', async () => {
+        fs_1.default.existsSync.mockReturnValue(false);
+        const exitSpy = jest.spyOn(process, 'exit').mockImplementation((() => { }));
+        await (0, restore_1.restore)('mia.tar.gz', {});
+        expect(console.error).toHaveBeenCalledWith(expect.stringContaining('not found'));
+        expect(exitSpy).toHaveBeenCalledWith(1);
+    });
+});

package/dist/commands/backup.js

@@ -0,0 +1,52 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.backup = backup;
+const chalk_1 = __importDefault(require("chalk"));
+const execa_1 = __importDefault(require("execa"));
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+async function backup(options) {
+    const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+    const filename = `cybermem-backup-${timestamp}.tar.gz`;
+    const outputPath = path_1.default.resolve(process.cwd(), filename);
+    console.log(chalk_1.default.blue(`📦 Creating backup: ${filename}...`));
+    try {
+        // Check if container exists
+        try {
+            await (0, execa_1.default)('docker', ['inspect', 'cybermem-openmemory']);
+        }
+        catch (e) {
+            console.error(chalk_1.default.red('Error: cybermem-openmemory container not found. Is CyberMem installed?'));
+            process.exit(1);
+        }
+        // Use a transient alpine container to tar the /data volume
+        // We mount the current working directory to /backup in the container
+        // And we use --volumes-from to access the data volume of the running service
+        const cmd = [
+            'run', '--rm',
+            '--volumes-from', 'cybermem-openmemory',
+            '-v', `${process.cwd()}:/backup`,
+            'alpine',
+            'tar', 'czf', `/backup/${filename}`, '-C', '/', 'data'
+        ];
+        console.log(chalk_1.default.gray(`Running: docker ${cmd.join(' ')}`));
+        await (0, execa_1.default)('docker', cmd, { stdio: 'inherit' });
+        if (fs_1.default.existsSync(outputPath)) {
+            const stats = fs_1.default.statSync(outputPath);
+            const sizeMb = (stats.size / 1024 / 1024).toFixed(2);
+            console.log(chalk_1.default.green(`\n✅ Backup created successfully!`));
+            console.log(`File: ${chalk_1.default.bold(outputPath)}`);
+            console.log(`Size: ${sizeMb} MB`);
+        }
+        else {
+            throw new Error('Backup file not found after generation.');
+        }
+    }
+    catch (error) {
+        console.error(chalk_1.default.red('Backup failed:'), error);
+        process.exit(1);
+    }
+}

package/dist/commands/deploy.js

@@ -0,0 +1,242 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deploy = deploy;
+const chalk_1 = __importDefault(require("chalk"));
+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"));
+async function deploy(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 {
+        // 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)) {
+            // 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');
+            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...'));
+            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') {
+            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']);
+            // 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.'));
+            }
+            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')}`;
+                // Replace OM_API_KEY with generated key
+                if (envContent.includes('OM_API_KEY=')) {
+                    envContent = envContent.replace(/OM_API_KEY=.*/, `OM_API_KEY=${newKey}`);
+                }
+                else {
+                    envContent += `\nOM_API_KEY=${newKey}\n`;
+                }
+                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) {
+        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/commands/restore.js

@@ -0,0 +1,62 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.restore = restore;
+const chalk_1 = __importDefault(require("chalk"));
+const execa_1 = __importDefault(require("execa"));
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+async function restore(file, options) {
+    if (!file) {
+        console.error(chalk_1.default.red('Error: Please specify the backup file to restore.'));
+        console.log(`Usage: npx @cybermem/mcp restore <file>`);
+        process.exit(1);
+    }
+    const backupPath = path_1.default.resolve(process.cwd(), file);
+    if (!fs_1.default.existsSync(backupPath)) {
+        console.error(chalk_1.default.red(`Error: File not found at ${backupPath}`));
+        process.exit(1);
+    }
+    console.log(chalk_1.default.blue(`♻️  Restoring from: ${path_1.default.basename(backupPath)}...`));
+    console.log(chalk_1.default.yellow('⚠️  This will overwrite current data!'));
+    try {
+        // 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']);
+        }
+        catch (e) {
+            console.log(chalk_1.default.gray('Container not running (or not found), proceeding...'));
+        }
+        // 2. Restore data using transient alpine container
+        console.log(chalk_1.default.blue('Extracting data to volume...'));
+        // We handle both absolute paths (by mounting dir) or relative
+        const dir = path_1.default.dirname(backupPath);
+        const filename = path_1.default.basename(backupPath);
+        const cmd = [
+            'run', '--rm',
+            '--volumes-from', 'cybermem-openmemory', // Access the volume even if container is stopped
+            '-v', `${dir}:/backup`,
+            'alpine',
+            'sh', '-c',
+            // Extract to root / (since backup was relative to /data we need to be careful how it was packed)
+            // In backup we did: tar czf ... -C / data
+            // So it contains "data/..."
+            // Extracting to / will put it in /data
+            `tar xzf /backup/${filename} -C / && chown -R 1001:1001 /data`
+        ];
+        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']);
+        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.'));
+        process.exit(1);
+    }
+}

package/dist/index.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const commander_1 = require("commander");
+const backup_1 = require("./commands/backup");
+const deploy_1 = require("./commands/deploy");
+const restore_1 = require("./commands/restore");
+const program = new commander_1.Command();
+program
+    .name('mcp')
+    .description('CyberMem - Deploy your AI memory server in one command')
+    .version('1.0.0');
+// Default Command: Deploy
+program
+    .command('deploy', { isDefault: true })
+    .description('Deploy CyberMem (Default)')
+    .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(deploy_1.deploy);
+program
+    .command('backup')
+    .description('Backup CyberMem data to a tarball')
+    .action(backup_1.backup);
+program
+    .command('restore')
+    .description('Restore CyberMem data from a backup file')
+    .argument('<file>', 'Backup file to restore')
+    .action(restore_1.restore);
+program.parse(process.argv);

package/dist/templates/ansible/inventory/hosts.ini

@@ -0,0 +1,3 @@
+[rpi]
+# Replace with your RPi IP address
+raspberrypi.local ansible_user=pi ansible_ssh_pass=Darwin1809 ansible_python_interpreter=/usr/bin/python3