@anastops/cli 0.1.0 → 1.1.0

package/dist/commands/init.js

@@ -1,98 +1,692 @@
 /**
  * anastops init command
  *
- * Initialize Anastops in the current project
+ * Initialize Anastops with secure credential generation and Docker infrastructure
+ *
+ * Creates:
+ * - ~/.anastops/.env (user-level credentials, auto-discovered by MCP server)
+ * - ~/.anastops/docker/ (Docker infrastructure files)
+ * - ./docker/.env (if in workspace with docker-compose)
+ * - MCP server registration (Claude Desktop or Cursor)
+ *
+ * This enables npm-installed users to get full infrastructure without cloning the repo.
  */
-import { existsSync, mkdirSync, writeFileSync, readFileSync } from 'fs';
+import { execSync, spawn } from 'child_process';
+import { randomBytes } from 'crypto';
+import { existsSync, mkdirSync, writeFileSync, readFileSync, chmodSync } from 'fs';
+import { homedir, platform } from 'os';
 import { join } from 'path';
 import chalk from 'chalk';
 import ora from 'ora';
+/**
+ * Check if a command exists in PATH
+ */
+function commandExists(command) {
+    try {
+        const checkCmd = platform() === 'win32' ? 'where' : 'which';
+        execSync(`${checkCmd} ${command}`, { stdio: 'ignore' });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Check if Docker daemon is running
+ */
+function isDockerRunning() {
+    try {
+        execSync('docker info', { stdio: 'ignore' });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Run a command and return stdout/stderr
+ */
+function runCommand(command, cwd) {
+    return new Promise((resolve) => {
+        const [cmd, ...args] = command.split(' ');
+        const child = spawn(cmd ?? '', args, { cwd, shell: true });
+        let stdout = '';
+        let stderr = '';
+        child.stdout?.on('data', (data) => {
+            stdout += data.toString();
+        });
+        child.stderr?.on('data', (data) => {
+            stderr += data.toString();
+        });
+        child.on('close', (code) => {
+            resolve({
+                success: code === 0,
+                output: stdout.trim(),
+                error: stderr.trim(),
+            });
+        });
+        child.on('error', (err) => {
+            resolve({
+                success: false,
+                output: '',
+                error: err.message,
+            });
+        });
+    });
+}
+/**
+ * Check if anastops Docker volumes exist
+ */
+function volumesExist() {
+    try {
+        const result = execSync('docker volume ls --format "{{.Name}}"', {
+            encoding: 'utf-8',
+            stdio: ['pipe', 'pipe', 'pipe'],
+        });
+        return result.includes('anastops-mongodb') || result.includes('anastops-redis');
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Remove existing anastops containers and volumes
+ * Required when regenerating credentials since MongoDB ignores new credentials with existing data
+ */
+async function cleanupDockerResources() {
+    try {
+        // Stop containers (ignore errors if not running)
+        try {
+            execSync('docker stop anastops-mongodb anastops-redis 2>/dev/null', { stdio: 'pipe' });
+        }
+        catch {
+            // Containers may not be running
+        }
+        // Remove containers (ignore errors if not exist)
+        try {
+            execSync('docker rm anastops-mongodb anastops-redis 2>/dev/null', { stdio: 'pipe' });
+        }
+        catch {
+            // Containers may not exist
+        }
+        // Remove volumes (this is critical for credential changes)
+        try {
+            execSync('docker volume rm anastops-mongodb anastops-redis 2>/dev/null', { stdio: 'pipe' });
+        }
+        catch {
+            // Volumes may not exist
+        }
+        return { success: true, message: 'Cleaned up existing containers and volumes' };
+    }
+    catch (error) {
+        return {
+            success: false,
+            message: error instanceof Error ? error.message : 'Failed to cleanup Docker resources',
+        };
+    }
+}
+/**
+ * Wait for containers to be healthy
+ */
+async function waitForContainers(dockerDir, timeoutMs = 60000) {
+    const startTime = Date.now();
+    while (Date.now() - startTime < timeoutMs) {
+        try {
+            const result = execSync('docker-compose ps --format json 2>/dev/null || docker compose ps --format json', { cwd: dockerDir, encoding: 'utf-8' });
+            // Parse container status
+            const lines = result.trim().split('\n').filter(Boolean);
+            const containers = lines
+                .map((line) => {
+                try {
+                    return JSON.parse(line);
+                }
+                catch {
+                    return null;
+                }
+            })
+                .filter((c) => c !== null);
+            if (containers.length >= 2) {
+                const allHealthy = containers.every((c) => c.Health === 'healthy' || c.State === 'running');
+                if (allHealthy) {
+                    return { healthy: true, status: 'All containers running' };
+                }
+            }
+        }
+        catch {
+            // Continue waiting
+        }
+        await new Promise((resolve) => setTimeout(resolve, 2000));
+    }
+    return { healthy: false, status: 'Timeout waiting for containers' };
+}
+/**
+ * Docker Compose configuration - PERSISTENT mode (bind mounts to host filesystem)
+ * Data stored in ~/.anastops/data/ and survives container removal
+ */
+const DOCKER_COMPOSE_PERSISTENT = `version: '3.8'
+
+# Anastops Docker Infrastructure - PERSISTENT MODE
+# Generated by: anastops init --persistent
+# Data stored in: ~/.anastops/data/
+# Credentials in: ../.env (auto-loaded by docker-compose)
+
+services:
+  redis:
+    image: redis:7.2-alpine
+    container_name: anastops-redis
+    ports:
+      - "127.0.0.1:6380:6379"
+    volumes:
+      - ../data/redis:/data
+      - ./redis.conf:/usr/local/etc/redis/redis.conf:ro
+    command: >
+      redis-server /usr/local/etc/redis/redis.conf
+      --requirepass \${REDIS_PASSWORD:?REDIS_PASSWORD required}
+    healthcheck:
+      test: ["CMD", "redis-cli", "-a", "\${REDIS_PASSWORD}", "--no-auth-warning", "ping"]
+      interval: 5s
+      timeout: 3s
+      retries: 5
+    restart: unless-stopped
+
+  mongodb:
+    image: mongo:7.0
+    container_name: anastops-mongodb
+    ports:
+      - "127.0.0.1:27018:27017"
+    volumes:
+      - ../data/mongodb:/data/db
+      - ./mongo-init.js:/docker-entrypoint-initdb.d/mongo-init.js:ro
+    environment:
+      MONGO_INITDB_ROOT_USERNAME: \${MONGO_ROOT_USERNAME:?MONGO_ROOT_USERNAME required}
+      MONGO_INITDB_ROOT_PASSWORD: \${MONGO_ROOT_PASSWORD:?MONGO_ROOT_PASSWORD required}
+      MONGO_INITDB_DATABASE: anastops
+    healthcheck:
+      test: ["CMD", "mongosh", "--quiet", "--eval", "db.adminCommand('ping')"]
+      interval: 10s
+      timeout: 5s
+      retries: 5
+    restart: unless-stopped
+
+networks:
+  default:
+    name: anastops-network
+`;
+/**
+ * Docker Compose configuration - EPHEMERAL mode (no data persistence)
+ * Data destroyed when containers are removed
+ */
+const DOCKER_COMPOSE_EPHEMERAL = `version: '3.8'
+
+# Anastops Docker Infrastructure - EPHEMERAL MODE
+# Generated by: anastops init --ephemeral
+# WARNING: Data is NOT persisted - destroyed when containers stop
+# Credentials in: ../.env (auto-loaded by docker-compose)
+
+services:
+  redis:
+    image: redis:7.2-alpine
+    container_name: anastops-redis
+    ports:
+      - "127.0.0.1:6380:6379"
+    volumes:
+      - ./redis.conf:/usr/local/etc/redis/redis.conf:ro
+    command: >
+      redis-server /usr/local/etc/redis/redis.conf
+      --requirepass \${REDIS_PASSWORD:?REDIS_PASSWORD required}
+    healthcheck:
+      test: ["CMD", "redis-cli", "-a", "\${REDIS_PASSWORD}", "--no-auth-warning", "ping"]
+      interval: 5s
+      timeout: 3s
+      retries: 5
+    restart: unless-stopped
+
+  mongodb:
+    image: mongo:7.0
+    container_name: anastops-mongodb
+    ports:
+      - "127.0.0.1:27018:27017"
+    volumes:
+      - ./mongo-init.js:/docker-entrypoint-initdb.d/mongo-init.js:ro
+    environment:
+      MONGO_INITDB_ROOT_USERNAME: \${MONGO_ROOT_USERNAME:?MONGO_ROOT_USERNAME required}
+      MONGO_INITDB_ROOT_PASSWORD: \${MONGO_ROOT_PASSWORD:?MONGO_ROOT_PASSWORD required}
+      MONGO_INITDB_DATABASE: anastops
+    healthcheck:
+      test: ["CMD", "mongosh", "--quiet", "--eval", "db.adminCommand('ping')"]
+      interval: 10s
+      timeout: 5s
+      retries: 5
+    restart: unless-stopped
+
+networks:
+  default:
+    name: anastops-network
+`;
+const REDIS_CONF = `# Anastops Redis Configuration
+
+# Persistence
+save 900 1
+save 300 10
+save 60 10000
+appendonly yes
+appendfsync everysec
+
+# Memory
+maxmemory 256mb
+maxmemory-policy allkeys-lru
+
+# Security
+bind 0.0.0.0
+protected-mode yes
+
+# Logging
+loglevel notice
+
+# Performance
+tcp-keepalive 300
+timeout 0
+
+# Keyspace notifications for session events
+notify-keyspace-events Ex
+`;
+const MONGO_INIT_JS = `// Anastops MongoDB Initialization Script
+db = db.getSiblingDB('anastops');
+
+// Sessions collection
+db.createCollection('sessions', {
+  validator: {
+    $jsonSchema: {
+      bsonType: 'object',
+      required: ['_id', 'status', 'created_at'],
+      properties: {
+        _id: { bsonType: 'string' },
+        status: { enum: ['active', 'completed', 'archived'] },
+        objective: { bsonType: 'string' },
+        created_at: { bsonType: 'date' },
+        updated_at: { bsonType: 'date' },
+        metadata: { bsonType: 'object' }
+      }
+    }
+  }
+});
+
+// Tasks collection
+db.createCollection('tasks', {
+  validator: {
+    $jsonSchema: {
+      bsonType: 'object',
+      required: ['_id', 'session_id', 'status', 'created_at'],
+      properties: {
+        _id: { bsonType: 'string' },
+        session_id: { bsonType: 'string' },
+        status: { enum: ['pending', 'running', 'completed', 'failed', 'cancelled'] },
+        created_at: { bsonType: 'date' }
+      }
+    }
+  }
+});
+
+// Artifacts collection
+db.createCollection('artifacts');
+
+// Metrics collection (time-series, 90-day TTL)
+db.createCollection('metrics', {
+  timeseries: {
+    timeField: 'timestamp',
+    metaField: 'metadata',
+    granularity: 'minutes'
+  },
+  expireAfterSeconds: 7776000
+});
+
+// Create indexes
+db.sessions.createIndex({ status: 1 });
+db.sessions.createIndex({ created_at: -1 });
+db.tasks.createIndex({ session_id: 1 });
+db.tasks.createIndex({ status: 1 });
+db.artifacts.createIndex({ session_id: 1 });
+
+print('Anastops MongoDB initialization complete');
+`;
+/**
+ * Generate a cryptographically secure random password
+ */
+function generatePassword(length = 32) {
+    const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+    const bytes = randomBytes(length);
+    let password = '';
+    for (let i = 0; i < length; i++) {
+        const byte = bytes[i];
+        if (byte !== undefined) {
+            password += chars[byte % chars.length];
+        }
+    }
+    return password;
+}
+/**
+ * Generate .env file content with credentials
+ */
+function generateEnvContent(redisPassword, mongoUsername, mongoPassword) {
+    return `# Anastops Credentials
+# Generated by: anastops init
+# Generated on: ${new Date().toISOString()}
+#
+# SECURITY WARNING: Do not commit this file to version control!
+# This file contains sensitive credentials.
+
+# Redis Configuration
+REDIS_PASSWORD=${redisPassword}
+
+# MongoDB Configuration
+MONGO_ROOT_USERNAME=${mongoUsername}
+MONGO_ROOT_PASSWORD=${mongoPassword}
+
+# Pre-built connection URLs (for convenience)
+REDIS_URL=redis://:${redisPassword}@localhost:6380
+MONGODB_URL=mongodb://${mongoUsername}:${mongoPassword}@localhost:27018/anastops?authSource=admin
+`;
+}
 export async function initCommand(options) {
     const spinner = ora('Initializing Anastops...').start();
     try {
+        const home = homedir();
         const cwd = process.cwd();
-        // Create .anastops directory
-        const configDir = join(cwd, '.anastops');
-        if (!existsSync(configDir)) {
-            mkdirSync(configDir, { recursive: true });
-        }
-        // Create config file
-        const configPath = join(configDir, 'config.json');
-        const config = {
-            version: '0.1.0',
-            default_provider: 'claude',
-            context_budget: 1600,
-            routing: {
-                tiers: {
-                    1: { provider: 'local', model: 'agent-booster' },
-                    2: { provider: 'gemini', model: 'gemini-2.0-flash' },
-                    3: { provider: 'claude', model: 'claude-haiku' },
-                    4: { provider: 'claude', model: 'claude-sonnet' },
-                    5: { provider: 'claude', model: 'claude-opus' },
-                },
-            },
-            memory: {
-                redis_url: 'redis://localhost:6380',
-                mongodb_url: 'mongodb://localhost:27018/anastops',
-            },
-        };
-        writeFileSync(configPath, JSON.stringify(config, null, 2));
-        spinner.succeed('Created .anastops/config.json');
-        // Set up Docker if not skipped
-        if (!options.skipDocker) {
-            const dockerSpinner = ora('Checking Docker setup...').start();
-            const dockerComposePath = join(cwd, 'docker', 'docker-compose.yml');
-            if (existsSync(dockerComposePath)) {
-                dockerSpinner.succeed('Docker Compose file found');
-                console.log(chalk.dim('  Run: npm run docker:up to start Redis and MongoDB'));
+        // 1. Create ~/.anastops directory
+        const userConfigDir = join(home, '.anastops');
+        if (!existsSync(userConfigDir)) {
+            mkdirSync(userConfigDir, { recursive: true });
+        }
+        // 2. Generate or load credentials
+        const userEnvPath = join(userConfigDir, '.env');
+        let redisPassword;
+        let mongoUsername;
+        let mongoPassword;
+        if (existsSync(userEnvPath) && options.regenerate !== true) {
+            spinner.info('Existing credentials found at ~/.anastops/.env');
+            // Parse existing credentials
+            const content = readFileSync(userEnvPath, 'utf-8');
+            const match = {
+                redis: content.match(/REDIS_PASSWORD=([^\n]+)/),
+                mongoUser: content.match(/MONGO_ROOT_USERNAME=([^\n]+)/),
+                mongoPwd: content.match(/MONGO_ROOT_PASSWORD=([^\n]+)/),
+            };
+            redisPassword = match.redis?.[1] ?? generatePassword();
+            mongoUsername = match.mongoUser?.[1] ?? 'admin';
+            mongoPassword = match.mongoPwd?.[1] ?? generatePassword();
+        }
+        else {
+            spinner.text = 'Generating secure credentials...';
+            redisPassword = generatePassword();
+            mongoUsername = 'admin';
+            mongoPassword = generatePassword();
+        }
+        // 3. Write user-level credentials (~/.anastops/.env)
+        const envContent = generateEnvContent(redisPassword, mongoUsername, mongoPassword);
+        writeFileSync(userEnvPath, envContent);
+        if (platform() !== 'win32') {
+            chmodSync(userEnvPath, 0o600); // Read/write for owner only
+        }
+        spinner.succeed('Created ~/.anastops/.env with secure credentials');
+        // 4. Create Docker infrastructure files and start containers
+        let dockerStarted = false;
+        let dockerError = null;
+        const userDockerDir = join(userConfigDir, 'docker');
+        const userDataDir = join(userConfigDir, 'data');
+        // Determine storage mode: persistent (default) or ephemeral
+        const isEphemeral = options.ephemeral === true;
+        const isPersistent = !isEphemeral; // persistent is default unless --ephemeral is specified
+        if (options.skipDocker !== true) {
+            const modeLabel = isPersistent ? 'persistent' : 'ephemeral';
+            const dockerSpinner = ora(`Setting up Docker infrastructure (${modeLabel} mode)...`).start();
+            // Always clean up existing Docker resources when running init
+            // This ensures credentials in containers match what's in .env
+            // MongoDB ignores MONGO_INITDB_* env vars if data already exists in volumes
+            if (isDockerRunning() && volumesExist()) {
+                dockerSpinner.text = 'Removing existing containers and volumes...';
+                const cleanup = await cleanupDockerResources();
+                if (cleanup.success) {
+                    dockerSpinner.text = `Setting up Docker infrastructure (${modeLabel} mode)...`;
+                }
+                // Continue even if cleanup fails - we'll try to start fresh
+            }
+            // Create ~/.anastops/docker/ with all required files
+            if (!existsSync(userDockerDir)) {
+                mkdirSync(userDockerDir, { recursive: true });
+            }
+            // Create data directories for persistent mode
+            if (isPersistent) {
+                const mongoDataDir = join(userDataDir, 'mongodb');
+                const redisDataDir = join(userDataDir, 'redis');
+                if (!existsSync(mongoDataDir)) {
+                    mkdirSync(mongoDataDir, { recursive: true });
+                }
+                if (!existsSync(redisDataDir)) {
+                    mkdirSync(redisDataDir, { recursive: true });
+                }
+                dockerSpinner.text = 'Created ~/.anastops/data/ directories...';
+            }
+            // Write docker-compose.yml based on storage mode
+            const dockerComposeContent = isPersistent
+                ? DOCKER_COMPOSE_PERSISTENT
+                : DOCKER_COMPOSE_EPHEMERAL;
+            writeFileSync(join(userDockerDir, 'docker-compose.yml'), dockerComposeContent);
+            // Write redis.conf
+            writeFileSync(join(userDockerDir, 'redis.conf'), REDIS_CONF);
+            // Write mongo-init.js
+            writeFileSync(join(userDockerDir, 'mongo-init.js'), MONGO_INIT_JS);
+            // Write .env file in docker directory
+            writeFileSync(join(userDockerDir, '.env'), envContent);
+            if (platform() !== 'win32') {
+                chmodSync(join(userDockerDir, '.env'), 0o600);
+            }
+            dockerSpinner.succeed('Created ~/.anastops/docker/ with infrastructure files');
+            // Also sync to local docker/.env if in workspace with docker-compose
+            const localDockerCompose = join(cwd, 'docker', 'docker-compose.yml');
+            if (existsSync(localDockerCompose)) {
+                const localDockerEnv = join(cwd, 'docker', '.env');
+                writeFileSync(localDockerEnv, envContent);
+                if (platform() !== 'win32') {
+                    chmodSync(localDockerEnv, 0o600);
+                }
+                console.log(chalk.dim('  Also synced to ./docker/.env'));
+            }
+            // Check Docker availability and start containers
+            const startSpinner = ora('Checking Docker installation...').start();
+            // Check if docker command exists
+            if (!commandExists('docker')) {
+                startSpinner.fail('Docker not found');
+                dockerError = 'docker-not-installed';
+            }
+            else if (!isDockerRunning()) {
+                startSpinner.fail('Docker daemon not running');
+                dockerError = 'docker-not-running';
             }
             else {
-                dockerSpinner.info('Docker Compose not found. Run from the package root for Docker setup.');
+                // Check for docker-compose or docker compose
+                const hasDockerCompose = commandExists('docker-compose');
+                const composeCmd = hasDockerCompose ? 'docker-compose' : 'docker compose';
+                startSpinner.text = 'Starting Docker containers...';
+                // Run docker-compose up -d
+                const result = await runCommand(`${composeCmd} up -d`, userDockerDir);
+                if (!result.success) {
+                    startSpinner.fail('Failed to start Docker containers');
+                    dockerError = result.error || 'Unknown error starting containers';
+                }
+                else {
+                    startSpinner.text = 'Waiting for containers to be healthy...';
+                    // Wait for containers to be healthy
+                    const healthCheck = await waitForContainers(userDockerDir, 60000);
+                    if (healthCheck.healthy) {
+                        startSpinner.succeed('Docker containers started and healthy');
+                        dockerStarted = true;
+                    }
+                    else {
+                        startSpinner.warn('Containers started but health check inconclusive');
+                        dockerStarted = true; // Still mark as started, just warn
+                    }
+                }
             }
         }
-        // Set up MCP server registration if not skipped
-        if (!options.skipMcp) {
+        // 5. Set up MCP server registration
+        if (options.skipMcp !== true) {
             const mcpSpinner = ora('Setting up MCP server...').start();
-            // Create MCP config for Claude Desktop
-            const mcpConfigDir = join(process.env['HOME'] ?? '', '.config', 'claude');
-            if (!existsSync(mcpConfigDir)) {
-                mkdirSync(mcpConfigDir, { recursive: true });
-            }
-            const mcpConfigPath = join(mcpConfigDir, 'claude_desktop_config.json');
-            const mcpConfig = {
-                mcpServers: {
-                    anastops: {
-                        command: 'npx',
-                        args: ['@anastops/mcp-server'],
-                    },
+            // Determine MCP config location based on platform/IDE
+            const mcpConfigs = [
+                { name: 'Cursor', path: join(home, '.cursor', 'mcp.json') },
+                {
+                    name: 'Claude Desktop',
+                    path: join(home, '.config', 'claude', 'claude_desktop_config.json'),
                 },
-            };
-            // Check if config exists and merge
-            if (existsSync(mcpConfigPath)) {
+            ];
+            // Detect if running from local development (monorepo) or npm install
+            // Look for mcp-server dist relative to this CLI's location
+            const cliDir = join(cwd, 'packages', 'cli');
+            const localMcpServer = join(cwd, 'packages', 'mcp-server', 'dist', 'index.js');
+            const isLocalDev = existsSync(cliDir) && existsSync(localMcpServer);
+            // MCP server config - NO credentials, they're auto-discovered
+            let mcpServerEntry;
+            if (isLocalDev) {
+                // Local development: use node + direct path
+                mcpServerEntry = {
+                    command: 'node',
+                    args: [localMcpServer],
+                    env: {
+                        HOME: home,
+                        PATH: '/usr/local/bin:/usr/bin:/bin:/opt/homebrew/bin',
+                    },
+                };
+                console.log(chalk.dim('  Using local development mode (direct path)'));
+            }
+            else {
+                // npm installed: use npx
+                mcpServerEntry = {
+                    command: 'npx',
+                    args: ['@anastops/mcp-server'],
+                    env: {
+                        HOME: home,
+                        PATH: process.env['PATH'] ?? '/usr/local/bin:/usr/bin:/bin',
+                    },
+                };
+            }
+            let registeredCount = 0;
+            for (const { name, path: configPath } of mcpConfigs) {
+                const configDir = join(configPath, '..');
+                if (!existsSync(configDir)) {
+                    mkdirSync(configDir, { recursive: true });
+                }
                 try {
-                    console.log('DEBUG: Reading file:', mcpConfigPath);
-                    const existing = JSON.parse(readFileSync(mcpConfigPath, 'utf-8'));
-                    existing.mcpServers = existing.mcpServers ?? {};
-                    existing.mcpServers.anastops = mcpConfig.mcpServers.anastops;
-                    writeFileSync(mcpConfigPath, JSON.stringify(existing, null, 2));
+                    let config = {};
+                    if (existsSync(configPath)) {
+                        config = JSON.parse(readFileSync(configPath, 'utf-8'));
+                    }
+                    config.mcpServers = config.mcpServers ?? {};
+                    config.mcpServers.anastops = mcpServerEntry;
+                    writeFileSync(configPath, JSON.stringify(config, null, 2));
+                    registeredCount++;
+                    console.log(chalk.dim(`  Registered with ${name}`));
                 }
                 catch {
-                    writeFileSync(mcpConfigPath, JSON.stringify(mcpConfig, null, 2));
+                    // Skip if we can't write to this config
                 }
             }
+            if (registeredCount > 0) {
+                mcpSpinner.succeed(`MCP server registered (${registeredCount} IDE${registeredCount > 1 ? 's' : ''})`);
+            }
             else {
-                writeFileSync(mcpConfigPath, JSON.stringify(mcpConfig, null, 2));
+                mcpSpinner.warn('Could not register MCP server automatically');
             }
-            mcpSpinner.succeed('MCP server registered for Claude Desktop');
         }
         // Summary
         console.log('');
-        console.log(chalk.green('✓ Anastops initialized successfully!'));
+        console.log(chalk.green('Anastops initialized successfully!'));
+        console.log('');
+        console.log(chalk.bold('Created:'));
+        console.log(`  ${chalk.cyan('~/.anastops/.env')}           Credentials (auto-discovered by MCP)`);
+        console.log(`  ${chalk.cyan('~/.anastops/docker/')}        Docker infrastructure files`);
+        if (isPersistent) {
+            console.log(`  ${chalk.cyan('~/.anastops/data/')}          Persistent data storage`);
+        }
+        console.log('');
+        console.log(chalk.bold('Storage Mode:'));
+        if (isPersistent) {
+            console.log(`  ${chalk.green('Persistent')} - Data survives container removal`);
+            console.log(`  ${chalk.dim('Location:')} ~/.anastops/data/`);
+        }
+        else {
+            console.log(`  ${chalk.yellow('Ephemeral')} - Data destroyed when containers stop`);
+        }
+        console.log('');
+        console.log(chalk.bold('Connection URLs:'));
+        console.log(`  ${chalk.dim('Redis:')}    redis://:****@localhost:6380`);
+        console.log(`  ${chalk.dim('MongoDB:')} mongodb://****:****@localhost:27018/anastops`);
+        console.log('');
+        // Show Docker status and instructions
+        if (dockerStarted) {
+            console.log(chalk.bold('Infrastructure Status:'));
+            console.log(`  ${chalk.green('Redis:')}    Running on port 6380`);
+            console.log(`  ${chalk.green('MongoDB:')} Running on port 27018`);
+            console.log('');
+            console.log(chalk.bold('Next steps:'));
+            console.log(chalk.dim('  1. Check health:'), 'anastops doctor');
+            console.log(chalk.dim('  2. Restart your IDE'), 'to reload the MCP server');
+        }
+        else if (dockerError !== null) {
+            console.log(chalk.bold.yellow('Docker Setup Required:'));
+            console.log('');
+            if (dockerError === 'docker-not-installed') {
+                console.log(chalk.red('  Docker is not installed on this system.'));
+                console.log('');
+                console.log(chalk.bold('  How to install Docker:'));
+                if (platform() === 'darwin') {
+                    console.log('    macOS: brew install --cask docker');
+                    console.log('           or download from https://docker.com/products/docker-desktop');
+                }
+                else if (platform() === 'win32') {
+                    console.log('    Windows: Download from https://docker.com/products/docker-desktop');
+                }
+                else {
+                    console.log('    Linux: sudo apt install docker.io docker-compose');
+                    console.log('           or follow https://docs.docker.com/engine/install/');
+                }
+            }
+            else if (dockerError === 'docker-not-running') {
+                console.log(chalk.red('  Docker daemon is not running.'));
+                console.log('');
+                console.log(chalk.bold('  How to start Docker:'));
+                if (platform() === 'darwin') {
+                    console.log('    macOS: Open Docker Desktop from Applications');
+                }
+                else if (platform() === 'win32') {
+                    console.log('    Windows: Start Docker Desktop from Start Menu');
+                }
+                else {
+                    console.log('    Linux: sudo systemctl start docker');
+                }
+            }
+            else {
+                console.log(chalk.red(`  Error: ${dockerError}`));
+            }
+            console.log('');
+            console.log(chalk.bold('  After Docker is ready, start containers manually:'));
+            console.log(`    ${chalk.cyan('cd ~/.anastops/docker && docker-compose up -d')}`);
+            console.log('');
+            console.log(chalk.bold('Next steps:'));
+            console.log(chalk.dim('  1. Install/start Docker (see above)'));
+            console.log(chalk.dim('  2. Start containers:'), 'cd ~/.anastops/docker && docker-compose up -d');
+            console.log(chalk.dim('  3. Check health:'), 'anastops doctor');
+            console.log(chalk.dim('  4. Restart your IDE'), 'to reload the MCP server');
+        }
+        else {
+            // Docker was skipped
+            console.log(chalk.bold('Next steps:'));
+            console.log(chalk.dim('  1. Start Docker containers:'));
+            console.log(`     ${chalk.cyan('cd ~/.anastops/docker && docker-compose up -d')}`);
+            console.log(chalk.dim('  2. Check health:'), 'anastops doctor');
+            console.log(chalk.dim('  3. Restart your IDE'), 'to reload the MCP server');
+        }
         console.log('');
-        console.log('Next steps:');
-        console.log(chalk.dim('  1. Start infrastructure:'), 'npm run docker:up');
-        console.log(chalk.dim('  2. Check health:'), 'anastops doctor');
-        console.log(chalk.dim('  3. Create a session:'), 'anastops spawn "Your objective"');
+        console.log(chalk.dim('Note: MCP server auto-discovers credentials from ~/.anastops/.env'));
         console.log('');
     }
     catch (error) {