deepdebug-local-agent 1.0.3 → 1.0.4

package/bin/install.js

@@ -1,282 +1,564 @@
 #!/usr/bin/env node
 
 /**
- * deepdebug-local-agent CLI
+ * DeepDebug Local Agent - Interactive Installer with Authorization Flow
+ *
+ * Supports: Windows, macOS, Linux
  *
  * Usage:
- *   npx deepdebug-local-agent install   — installs and starts the agent as a service
- *   npx deepdebug-local-agent start     — starts the agent
- *   npx deepdebug-local-agent stop      — stops the agent
- *   npx deepdebug-local-agent status    — shows agent status
- *   npx deepdebug-local-agent run       — runs the agent in the foreground (dev mode)
+ *   npx deepdebug-local-agent install
+ *   npx deepdebug-local-agent install --api-key=YOUR_KEY
+ *   npx deepdebug-local-agent start
+ *   npx deepdebug-local-agent stop
+ *   npx deepdebug-local-agent status
  */
 
-import { execSync, spawn } from 'child_process';
-import { existsSync, mkdirSync, writeFileSync, readFileSync } from 'fs';
-import { join, dirname } from 'path';
-import { fileURLToPath } from 'url';
+import fs from 'fs';
+import path from 'path';
 import os from 'os';
+import crypto from 'crypto';
+import { spawn, execSync } from 'child_process';
 import readline from 'readline';
 
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-const ROOT_DIR = join(__dirname, '..');
-
-const CONFIG_DIR = join(os.homedir(), '.deepdebug');
-const CONFIG_FILE = join(CONFIG_DIR, 'config.json');
-const DEFAULT_PORT = 5055;
-const DEFAULT_GATEWAY = 'https://gateway.insptech.pt';
-const AGENT_NAME = 'deepdebug-agent';
-
-const BLUE   = '\x1b[34m';
-const GREEN  = '\x1b[32m';
-const YELLOW = '\x1b[33m';
-const RED    = '\x1b[31m';
-const BOLD   = '\x1b[1m';
-const RESET  = '\x1b[0m';
-
-const log  = (msg) => console.log(`${BLUE}[DeepDebug]${RESET} ${msg}`);
-const ok   = (msg) => console.log(`${GREEN}✓${RESET} ${msg}`);
-const warn = (msg) => console.log(`${YELLOW}⚠${RESET}  ${msg}`);
-const err  = (msg) => console.log(`${RED}✗${RESET} ${msg}`);
-const bold = (msg) => `${BOLD}${msg}${RESET}`;
-
-function printBanner() {
-    console.log('');
-    console.log(`${BLUE}${BOLD}╔═══════════════════════════════════════╗${RESET}`);
-    console.log(`${BLUE}${BOLD}║      Insptech AI — DeepDebug Agent    ║${RESET}`);
-    console.log(`${BLUE}${BOLD}║         deepdebug-local-agent         ║${RESET}`);
-    console.log(`${BLUE}${BOLD}╚═══════════════════════════════════════╝${RESET}`);
-    console.log('');
+// ============================================
+// Configuration
+// ============================================
+const CONFIG_DIR = path.join(os.homedir(), '.deepdebug');
+const CONFIG_FILE = path.join(CONFIG_DIR, 'config.json');
+const MACHINE_ID_FILE = path.join(CONFIG_DIR, 'machine-id');
+const API_BASE_URL = process.env.DEEPDEBUG_API_URL || 'https://deepdebug-gateway-lszyf7c4ia-uc.a.run.app';
+const DOCKER_IMAGE = 'williambella/deepdebug-local-agent:latest';
+
+// ============================================
+// Cross-platform utilities
+// ============================================
+const isWindows = os.platform() === 'win32';
+const isMac = os.platform() === 'darwin';
+const isLinux = os.platform() === 'linux';
+
+function getOsType() {
+    if (isWindows) return 'WINDOWS';
+    if (isMac) return 'MACOS';
+    if (isLinux) return 'LINUX';
+    return 'UNKNOWN';
 }
 
-function ask(question) {
-    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
-    return new Promise(resolve => rl.question(question, ans => { rl.close(); resolve(ans.trim()); }));
+function getOsVersion() {
+    return `${os.type()} ${os.release()}`;
 }
 
-function loadConfig() {
-    try {
-        if (existsSync(CONFIG_FILE)) {
-            return JSON.parse(readFileSync(CONFIG_FILE, 'utf8'));
-        }
-    } catch {}
-    return {};
+// ============================================
+// Console colors (cross-platform)
+// ============================================
+const colors = {
+    reset: '\x1b[0m',
+    bright: '\x1b[1m',
+    green: '\x1b[32m',
+    yellow: '\x1b[33m',
+    red: '\x1b[31m',
+    cyan: '\x1b[36m',
+    magenta: '\x1b[35m',
+    blue: '\x1b[34m'
+};
+
+function log(message, color = 'reset') {
+    console.log(`${colors[color]}${message}${colors.reset}`);
 }
 
-function saveConfig(cfg) {
-    if (!existsSync(CONFIG_DIR)) mkdirSync(CONFIG_DIR, { recursive: true });
-    writeFileSync(CONFIG_FILE, JSON.stringify(cfg, null, 2), 'utf8');
+function logSuccess(message) {
+    console.log(`${colors.green}✅ ${message}${colors.reset}`);
 }
 
-function checkNodeVersion() {
-    const major = parseInt(process.version.slice(1).split('.')[0]);
-    if (major < 18) {
-        err(`Node.js ${process.version} detected. Version 18 or higher is required.`);
-        err('Download: https://nodejs.org');
-        process.exit(1);
-    }
-    ok(`Node.js ${process.version} detected`);
+function logError(message) {
+    console.log(`${colors.red}❌ ${message}${colors.reset}`);
 }
 
-function getServerScript() {
-    // Try common locations
-    const candidates = [
-        join(ROOT_DIR, 'server.js'),
-        join(ROOT_DIR, 'src', 'server.js'),
-    ];
-    for (const c of candidates) {
-        if (existsSync(c)) return c;
-    }
-    // Fallback: server.js next to bin/
-    return join(ROOT_DIR, 'server.js');
+function logInfo(message) {
+    console.log(`${colors.cyan}ℹ️  ${message}${colors.reset}`);
 }
 
-// ─── Platform detection ───────────────────────────────────────────────────────
+function logWarning(message) {
+    console.log(`${colors.yellow}⚠️  ${message}${colors.reset}`);
+}
+
+// ============================================
+// Input utilities
+// ============================================
+async function prompt(question) {
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout
+    });
 
-const platform = os.platform(); // 'win32' | 'darwin' | 'linux'
+    return new Promise((resolve) => {
+        rl.question(`${colors.cyan}${question}${colors.reset}`, (answer) => {
+            rl.close();
+            resolve(answer.trim());
+        });
+    });
+}
 
-function getPidFile() {
-    return join(CONFIG_DIR, 'agent.pid');
+async function promptYesNo(question, defaultYes = true) {
+    const hint = defaultYes ? '(Y/n)' : '(y/N)';
+    const answer = await prompt(`${question} ${hint}: `);
+    if (answer === '') return defaultYes;
+    return answer.toLowerCase() === 'y' || answer.toLowerCase() === 'yes';
 }
 
-function readPid() {
+// ============================================
+// Machine ID generation (unique per machine)
+// ============================================
+function getMachineId() {
+    if (fs.existsSync(MACHINE_ID_FILE)) {
+        return fs.readFileSync(MACHINE_ID_FILE, 'utf-8').trim();
+    }
+
+    let machineId;
     try {
-        const pid = parseInt(readFileSync(getPidFile(), 'utf8').trim());
-        return isNaN(pid) ? null : pid;
-    } catch { return null; }
+        if (isWindows) {
+            try {
+                const result = execSync('wmic bios get serialnumber', { encoding: 'utf-8' });
+                const serial = result.split('\n')[1]?.trim();
+                if (serial && serial !== 'To be filled by O.E.M.') {
+                    machineId = crypto.createHash('sha256').update(serial).digest('hex').substring(0, 32);
+                }
+            } catch {}
+        } else if (isMac) {
+            try {
+                const result = execSync('ioreg -rd1 -c IOPlatformExpertDevice | grep IOPlatformUUID', { encoding: 'utf-8' });
+                const match = result.match(/"([A-F0-9-]+)"/);
+                if (match) {
+                    machineId = crypto.createHash('sha256').update(match[1]).digest('hex').substring(0, 32);
+                }
+            } catch {}
+        } else if (isLinux) {
+            try {
+                if (fs.existsSync('/etc/machine-id')) {
+                    const mid = fs.readFileSync('/etc/machine-id', 'utf-8').trim();
+                    machineId = crypto.createHash('sha256').update(mid).digest('hex').substring(0, 32);
+                }
+            } catch {}
+        }
+    } catch (e) {}
+
+    if (!machineId) {
+        const seed = `${os.hostname()}-${os.userInfo().username}-${Date.now()}-${crypto.randomBytes(8).toString('hex')}`;
+        machineId = crypto.createHash('sha256').update(seed).digest('hex').substring(0, 32);
+    }
+
+    ensureConfigDir();
+    fs.writeFileSync(MACHINE_ID_FILE, machineId, { mode: 0o600 });
+    return machineId;
 }
 
-function isRunning(pid) {
-    try { process.kill(pid, 0); return true; } catch { return false; }
+function getMachineName() {
+    return os.hostname();
 }
 
-// ─── Commands ─────────────────────────────────────────────────────────────────
+// ============================================
+// Config management
+// ============================================
+function ensureConfigDir() {
+    if (!fs.existsSync(CONFIG_DIR)) {
+        fs.mkdirSync(CONFIG_DIR, { recursive: true, mode: 0o700 });
+    }
+}
 
-async function cmdInstall() {
-    printBanner();
-    log('Starting installation...');
-    console.log('');
+function saveConfig(config) {
+    ensureConfigDir();
+    fs.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2), { mode: 0o600 });
+    logSuccess(`Configuration saved to: ${CONFIG_FILE}`);
+}
 
-    checkNodeVersion();
+function loadConfig() {
+    if (fs.existsSync(CONFIG_FILE)) {
+        try {
+            return JSON.parse(fs.readFileSync(CONFIG_FILE, 'utf-8'));
+        } catch (error) {
+            return null;
+        }
+    }
+    return null;
+}
 
-    // Read or create config
-    let cfg = loadConfig();
+function isConfigured() {
+    const config = loadConfig();
+    return config && config.authorizationToken && config.tenantId;
+}
 
-    // Prompt for API Key if not set
-    if (!cfg.apiKey) {
-        console.log(`${YELLOW}You need an API Key from the Insptech AI platform.${RESET}`);
-        console.log(`Open ${bold('https://app.insptech.pt')} → Settings → Agent → Generate API Key`);
-        console.log('');
-        const key = await ask('  Enter your API Key: ');
-        if (!key || key.length < 10) {
-            err('Invalid API Key. Installation aborted.');
-            process.exit(1);
-        }
-        cfg.apiKey = key;
-    } else {
-        ok('API Key already configured');
+// ============================================
+// Permission definitions
+// ============================================
+const PERMISSIONS = [
+    { id: 'read_files', name: 'Read Files', description: 'Read source code files in your workspaces', required: true },
+    { id: 'write_config', name: 'Write Configuration', description: 'Create configuration files in ~/.deepdebug', required: true },
+    { id: 'send_snippets', name: 'Send Code Snippets', description: 'Send code snippets to DeepDebug for AI analysis (encrypted)', required: true },
+    { id: 'execute_build', name: 'Execute Build Commands', description: 'Run build commands (maven, npm, gradle)', required: false },
+    { id: 'apply_patches', name: 'Apply Code Patches', description: 'Apply AI-suggested code fixes to your files', required: false },
+    { id: 'git_operations', name: 'Git Operations', description: 'Perform git operations (commit, branch)', required: false },
+    { id: 'create_pr', name: 'Create Pull Requests', description: 'Create pull requests with suggested fixes', required: false }
+];
+
+// ============================================
+// Authorization display
+// ============================================
+function displayAuthorizationTerms() {
+    console.log();
+    log('╔══════════════════════════════════════════════════════════════════╗', 'yellow');
+    log('║                    AUTHORIZATION REQUEST                          ║', 'yellow');
+    log('╚══════════════════════════════════════════════════════════════════╝', 'yellow');
+    console.log();
+    log('The DeepDebug Local Agent needs your permission to:', 'bright');
+    console.log();
+    log('Required permissions:', 'cyan');
+    PERMISSIONS.filter(p => p.required).forEach(p => {
+        log(`  ✓ ${p.name}`, 'green');
+        log(`    ${p.description}`, 'reset');
+    });
+    console.log();
+    log('Optional permissions (you can enable/disable later):', 'cyan');
+    PERMISSIONS.filter(p => !p.required).forEach(p => {
+        log(`  ○ ${p.name}`, 'yellow');
+        log(`    ${p.description}`, 'reset');
+    });
+    console.log();
+    log('Security notes:', 'magenta');
+    log('  • Your code is only analyzed when errors occur', 'reset');
+    log('  • Code snippets are encrypted in transit (TLS 1.3)', 'reset');
+    log('  • You can revoke this authorization at any time', 'reset');
+    log('  • Full audit trail is maintained in your dashboard', 'reset');
+    console.log();
+    log('Privacy Policy: https://deepdebug.ai/privacy', 'blue');
+    log('Terms of Service: https://deepdebug.ai/terms', 'blue');
+    console.log();
+}
+
+async function selectPermissions() {
+    const granted = PERMISSIONS.filter(p => p.required).map(p => p.id);
+    console.log();
+    log('Select optional permissions:', 'cyan');
+    console.log();
+    for (const perm of PERMISSIONS.filter(p => !p.required)) {
+        const enable = await promptYesNo(`  Enable "${perm.name}"?`, false);
+        if (enable) granted.push(perm.id);
     }
+    return granted;
+}
 
-    if (!cfg.gatewayUrl) cfg.gatewayUrl = DEFAULT_GATEWAY;
-    if (!cfg.port)       cfg.port = DEFAULT_PORT;
+// ============================================
+// API functions
+// ============================================
+async function authorizeWithServer(apiKey, permissions) {
+    const machineId = getMachineId();
+    const machineName = getMachineName();
+    const osType = getOsType();
+    const osVersion = getOsVersion();
+    const agentVersion = getAgentVersion();
 
-    saveConfig(cfg);
-    ok(`Configuration saved to ${CONFIG_FILE}`);
+    logInfo('Requesting authorization from DeepDebug server...');
 
-    // Install npm dependencies if needed
-    const nodeModules = join(ROOT_DIR, 'node_modules');
-    if (!existsSync(nodeModules)) {
-        log('Installing dependencies...');
-        try {
-            execSync('npm install --production', { cwd: ROOT_DIR, stdio: 'inherit' });
-            ok('Dependencies installed');
-        } catch (e) {
-            warn('Could not install dependencies automatically. Run: npm install');
+    try {
+        const response = await fetch(`${API_BASE_URL}/api/v1/agent/authorize`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                apiKey,
+                machineId,
+                machineName,
+                osType,
+                osVersion,
+                permissions,
+                workspacePaths: [], // Empty - workspaces configured in dashboard
+                agentVersion
+            })
+        });
+        const data = await response.json();
+        if (data.success) {
+            return { success: true, ...data };
         }
-    } else {
-        ok('Dependencies already installed');
+        return { success: false, error: data.message || 'Authorization failed' };
+    } catch (error) {
+        return { success: false, error: `Failed to connect: ${error.message}` };
     }
+}
+
+async function validateAuthorization(token, machineId) {
+    try {
+        const response = await fetch(`${API_BASE_URL}/api/v1/agent/validate`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ authorizationToken: token, machineId })
+        });
+        return await response.json();
+    } catch (error) {
+        return { valid: false, message: error.message };
+    }
+}
 
-    console.log('');
+function getAgentVersion() {
+    try {
+        const pkgPath = path.join(path.dirname(new URL(import.meta.url).pathname), '..', 'package.json');
+        return JSON.parse(fs.readFileSync(pkgPath, 'utf-8')).version || '1.0.0';
+    } catch { return '1.0.0'; }
+}
 
-    // Start the agent
-    await cmdStart(cfg);
+// ============================================
+// Docker functions
+// ============================================
+function isDockerInstalled() {
+    try { execSync('docker --version', { stdio: 'ignore' }); return true; } catch { return false; }
+}
 
-    console.log('');
-    ok(bold('Agent registered successfully'));
-    console.log('');
-    log(`Health check: ${bold(`http://localhost:${cfg.port}/health`)}`);
-    log(`Platform:     ${bold('https://app.insptech.pt')}`);
-    console.log('');
+function isDockerRunning() {
+    try { execSync('docker info', { stdio: 'ignore' }); return true; } catch { return false; }
 }
 
-async function cmdStart(cfg) {
-    cfg = cfg || loadConfig();
+function isAgentContainerRunning() {
+    try {
+        const result = execSync('docker ps --filter "name=deepdebug-agent" --format "{{.Names}}"', { encoding: 'utf-8' });
+        return result.trim() === 'deepdebug-agent';
+    } catch { return false; }
+}
 
-    const pid = readPid();
-    if (pid && isRunning(pid)) {
-        ok(`Agent is already running (PID ${pid})`);
-        return;
+function startDockerAgent(config) {
+    try {
+        try { execSync('docker stop deepdebug-agent', { stdio: 'ignore' }); execSync('docker rm deepdebug-agent', { stdio: 'ignore' }); } catch {}
+        logInfo('Pulling latest DeepDebug Local Agent image...');
+        execSync(`docker pull ${DOCKER_IMAGE}`, { stdio: 'inherit' });
+
+        let configMount = CONFIG_DIR;
+        if (isWindows) {
+            configMount = configMount.replace(/\\/g, '/').replace(/^([A-Za-z]):/, '/$1');
+        }
+
+        const dockerArgs = [
+            'run', '-d', '--name', 'deepdebug-agent', '-p', '5055:5055',
+            '-v', `${configMount}:/home/deepdebug/.deepdebug:ro`,
+            '-e', `DEEPDEBUG_GATEWAY_URL=${config.gatewayUrl}`,
+            '-e', `DEEPDEBUG_TENANT_ID=${config.tenantId}`,
+            '-e', `DEEPDEBUG_AUTH_TOKEN=${config.authorizationToken}`,
+            '--restart', 'unless-stopped', DOCKER_IMAGE
+        ];
+        execSync(`docker ${dockerArgs.join(' ')}`, { stdio: 'inherit' });
+        logSuccess('DeepDebug Local Agent started successfully!');
+        return true;
+    } catch (error) {
+        logError(`Failed to start Docker container: ${error.message}`);
+        return false;
     }
+}
 
-    const serverScript = getServerScript();
-    if (!existsSync(serverScript)) {
-        err(`Server script not found: ${serverScript}`);
-        process.exit(1);
+// ============================================
+// Commands
+// ============================================
+async function install(options = {}) {
+    console.log();
+    log('╔══════════════════════════════════════════════════════════════════╗', 'magenta');
+    log('║           DeepDebug Local Agent - Installation                    ║', 'magenta');
+    log('╚══════════════════════════════════════════════════════════════════╝', 'magenta');
+    console.log();
+    logInfo(`Detected OS: ${getOsType()} (${getOsVersion()})`);
+    logInfo(`Machine: ${getMachineName()}`);
+    console.log();
+
+    if (isConfigured() && !options.force) {
+        const config = loadConfig();
+        logInfo(`Already configured for tenant: ${config.tenantName || config.tenantId}`);
+        if (!await promptYesNo('Do you want to reconfigure?', false)) {
+            logInfo('Run "npx deepdebug-local-agent start" to start the agent.');
+            return;
+        }
     }
 
-    log(`Starting agent on port ${cfg.port || DEFAULT_PORT}...`);
+    let apiKey = options.apiKey;
+    if (!apiKey) {
+        console.log();
+        log('┌────────────────────────────────────────────────────────────────┐', 'cyan');
+        log('│  Find your API Key: DeepDebug Dashboard → Settings → Agent    │', 'cyan');
+        log('└────────────────────────────────────────────────────────────────┘', 'cyan');
+        console.log();
+        apiKey = await prompt('Enter your API Key: ');
+    }
+    if (!apiKey) { logError('API Key is required'); process.exit(1); }
 
-    const env = {
-        ...process.env,
-        NODE_ENV: 'production',
-        PORT: String(cfg.port || DEFAULT_PORT),
-        DEEPDEBUG_API_KEY: cfg.apiKey || '',
-        GATEWAY_URL: cfg.gatewayUrl || DEFAULT_GATEWAY,
+    displayAuthorizationTerms();
+    if (!await promptYesNo('Do you authorize the DeepDebug Local Agent with these permissions?', false)) {
+        logWarning('Authorization declined. Installation cancelled.');
+        process.exit(0);
+    }
+
+    const permissions = await selectPermissions();
+    logInfo(`Selected permissions: ${permissions.join(', ')}`);
+
+    console.log();
+    const authResult = await authorizeWithServer(apiKey, permissions);
+    if (!authResult.success) { logError(`Authorization failed: ${authResult.error}`); process.exit(1); }
+    logSuccess(`Authorized for tenant: ${authResult.tenantName}`);
+
+    const config = {
+        authorizationToken: authResult.authorizationToken,
+        authorizationId: authResult.authorizationId,
+        tenantId: authResult.tenantId,
+        tenantName: authResult.tenantName,
+        gatewayUrl: authResult.gatewayUrl,
+        websocketUrl: authResult.websocketUrl,
+        permissions,
+        machineId: getMachineId(),
+        machineName: getMachineName(),
+        osType: getOsType(),
+        installedAt: new Date().toISOString(),
+        expiresAt: authResult.expiresAt
     };
+    saveConfig(config);
+
+    console.log();
+    logInfo('Checking Docker installation...');
+    if (!isDockerInstalled()) {
+        logWarning('Docker is not installed.');
+        log(`Please install Docker Desktop: https://www.docker.com/products/docker-desktop/`, 'blue');
+        logInfo('After installing, run: npx deepdebug-local-agent start');
+        return;
+    }
+    if (!isDockerRunning()) {
+        logWarning('Docker is not running. Please start Docker Desktop.');
+        logInfo('Then run: npx deepdebug-local-agent start');
+        return;
+    }
+    logSuccess('Docker is installed and running');
 
-    const child = spawn(process.execPath, [serverScript], {
-        env,
-        detached: true,
-        stdio: 'ignore',
-        cwd: ROOT_DIR,
-    });
+    console.log();
+    if (await promptYesNo('Start DeepDebug Local Agent now?', true)) {
+        await start();
+    } else {
+        logInfo('To start later: npx deepdebug-local-agent start');
+    }
 
-    child.unref();
+    console.log();
+    log('╔══════════════════════════════════════════════════════════════════╗', 'green');
+    log('║                    Installation Complete! 🎉                      ║', 'green');
+    log('╚══════════════════════════════════════════════════════════════════╝', 'green');
+    console.log();
+    logInfo('Workspaces can be configured in the DeepDebug dashboard.');
+    log('Dashboard: https://deepdebug.ai/settings/agent', 'blue');
+    console.log();
+}
 
-    // Save PID
-    if (!existsSync(CONFIG_DIR)) mkdirSync(CONFIG_DIR, { recursive: true });
-    writeFileSync(getPidFile(), String(child.pid), 'utf8');
+async function start() {
+    console.log();
+    log('🚀 Starting DeepDebug Local Agent...', 'cyan');
+    const config = loadConfig();
+    if (!config?.authorizationToken) { logError('Not configured. Run "npx deepdebug-local-agent install" first.'); process.exit(1); }
 
-    // Wait a moment and verify
-    await new Promise(r => setTimeout(r, 1500));
+    logInfo('Validating authorization...');
+    const validation = await validateAuthorization(config.authorizationToken, config.machineId);
+    if (!validation.valid) { logError(`Authorization invalid: ${validation.message}`); process.exit(1); }
+    logSuccess('Authorization valid');
 
-    if (isRunning(child.pid)) {
-        ok(`Agent started (PID ${child.pid})`);
-    } else {
-        warn('Agent may have failed to start. Check logs or run in foreground: npx deepdebug-local-agent run');
+    if (!isDockerInstalled()) { logError('Docker is not installed.'); process.exit(1); }
+    if (!isDockerRunning()) { logError('Docker is not running.'); process.exit(1); }
+
+    if (isAgentContainerRunning()) {
+        logWarning('Agent is already running.');
+        if (!await promptYesNo('Restart it?', false)) return;
     }
-}
 
-function cmdStop() {
-    const pid = readPid();
-    if (!pid) { warn('No PID file found. Agent may not be running.'); return; }
-    if (!isRunning(pid)) { warn(`No process with PID ${pid}. Agent is not running.`); return; }
-    try {
-        process.kill(pid, 'SIGTERM');
-        ok(`Agent stopped (PID ${pid})`);
-    } catch (e) {
-        err(`Failed to stop agent: ${e.message}`);
+    if (startDockerAgent(config)) {
+        console.log();
+        logSuccess('Agent is running!');
+        logInfo('Dashboard: https://deepdebug.ai/monitoring');
+        logInfo('Local API: http://localhost:5055/health');
+        logInfo('Logs: docker logs -f deepdebug-agent');
     }
 }
 
-function cmdStatus() {
-    const cfg = loadConfig();
-    const pid = readPid();
-    const port = cfg.port || DEFAULT_PORT;
-    console.log('');
-    console.log(`${BOLD}DeepDebug Local Agent — Status${RESET}`);
-    console.log('─'.repeat(40));
-    if (pid && isRunning(pid)) {
-        console.log(`  Process : ${GREEN}Running${RESET} (PID ${pid})`);
+async function stop() {
+    log('🛑 Stopping DeepDebug Local Agent...', 'yellow');
+    try { execSync('docker stop deepdebug-agent', { stdio: 'inherit' }); logSuccess('Agent stopped.'); }
+    catch { logWarning('Agent is not running.'); }
+}
+
+async function status() {
+    console.log();
+    log('╔══════════════════════════════════════════════════════════════════╗', 'cyan');
+    log('║              DeepDebug Local Agent - Status                       ║', 'cyan');
+    log('╚══════════════════════════════════════════════════════════════════╝', 'cyan');
+    console.log();
+    logInfo(`OS: ${getOsType()} | Machine: ${getMachineName()}`);
+
+    const config = loadConfig();
+    if (config) {
+        logSuccess(`Configured for: ${config.tenantName || config.tenantId}`);
+        logInfo(`Permissions: ${config.permissions?.join(', ') || 'N/A'}`);
+    } else {
+        logWarning('Not configured. Run: npx deepdebug-local-agent install');
+    }
+
+    if (isDockerInstalled() && isDockerRunning() && isAgentContainerRunning()) {
+        logSuccess('Agent: Running');
+        try {
+            const resp = await fetch('http://localhost:5055/health');
+            logSuccess(resp.ok ? 'Health: OK' : 'Health: Degraded');
+        } catch { logWarning('Health: Cannot connect'); }
     } else {
-        console.log(`  Process : ${RED}Not running${RESET}`);
+        logWarning('Agent: Not running');
     }
-    console.log(`  Port    : ${port}`);
-    console.log(`  Config  : ${CONFIG_FILE}`);
-    console.log(`  Gateway : ${cfg.gatewayUrl || DEFAULT_GATEWAY}`);
-    console.log(`  Health  : http://localhost:${port}/health`);
-    console.log('');
+    console.log();
 }
 
-function cmdRun() {
-    // Foreground mode — useful for debugging
-    const cfg = loadConfig();
-    const serverScript = getServerScript();
-    const env = {
-        ...process.env,
-        NODE_ENV: 'development',
-        PORT: String(cfg.port || DEFAULT_PORT),
-        DEEPDEBUG_API_KEY: cfg.apiKey || '',
-        GATEWAY_URL: cfg.gatewayUrl || DEFAULT_GATEWAY,
-    };
-    log(`Running in foreground on port ${cfg.port || DEFAULT_PORT} (Ctrl+C to stop)...`);
-    const child = spawn(process.execPath, [serverScript], { env, stdio: 'inherit', cwd: ROOT_DIR });
-    child.on('exit', code => process.exit(code || 0));
+async function logs() {
+    spawn('docker', ['logs', '-f', 'deepdebug-agent'], { stdio: 'inherit' });
+}
+
+async function uninstall() {
+    if (!await promptYesNo('Uninstall DeepDebug Local Agent?', false)) return;
+    try { execSync('docker stop deepdebug-agent', { stdio: 'ignore' }); execSync('docker rm deepdebug-agent', { stdio: 'ignore' }); } catch {}
+    if (fs.existsSync(CONFIG_FILE)) fs.unlinkSync(CONFIG_FILE);
+    if (fs.existsSync(MACHINE_ID_FILE)) fs.unlinkSync(MACHINE_ID_FILE);
+    try { fs.rmdirSync(CONFIG_DIR); } catch {}
+    logSuccess('DeepDebug Local Agent uninstalled.');
 }
 
-// ─── Entry point ──────────────────────────────────────────────────────────────
+function showHelp() {
+    console.log(`
+DeepDebug Local Agent - AI-powered debugging assistant
+
+Usage: npx deepdebug-local-agent <command>
+
+Commands:
+  install     Configure and authorize the agent
+  start       Start the agent
+  stop        Stop the agent
+  status      Show agent status
+  logs        Show agent logs
+  uninstall   Remove the agent
+
+Options:
+  --api-key=KEY    Provide API key
+  --force          Force reconfiguration
+  --help           Show this help
+
+Documentation: https://docs.deepdebug.ai
+  `);
+}
 
-const command = process.argv[2] || 'install';
+// ============================================
+// Main
+// ============================================
+const args = process.argv.slice(2);
+const command = args[0];
+const options = {};
+args.forEach(arg => {
+    if (arg.startsWith('--api-key=')) options.apiKey = arg.split('=')[1];
+    if (arg === '--force') options.force = true;
+});
 
 switch (command) {
-    case 'install': cmdInstall().catch(e => { err(e.message); process.exit(1); }); break;
-    case 'start':   cmdStart().catch(e => { err(e.message); process.exit(1); });   break;
-    case 'stop':    cmdStop();    break;
-    case 'status':  cmdStatus();  break;
-    case 'run':     cmdRun();     break;
-    default:
-        console.log(`Usage: npx deepdebug-local-agent [install|start|stop|status|run]`);
-        process.exit(1);
+    case 'install': install(options); break;
+    case 'start': start(); break;
+    case 'stop': stop(); break;
+    case 'status': status(); break;
+    case 'logs': logs(); break;
+    case 'uninstall': uninstall(); break;
+    case 'help': case '--help': case '-h': showHelp(); break;
+    default: if (command) logError(`Unknown command: ${command}`); showHelp();
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "deepdebug-local-agent",
-  "version": "1.0.3",
+  "version": "1.0.4",
   "description": "DeepDebug Local Agent - AI-powered code debugging assistant",
   "private": false,
   "type": "module",