higherup 1.0.1 → 2.1.0

package/dist/agent.js

@@ -1,5 +1,5 @@
 /**
- * Higherup Local Agent
+ * Higherup Local Agent v2.0
  *
  * This agent runs on your local PC and connects to the Higherup service,
  * enabling secure remote command execution, file operations, and screen capture
@@ -14,12 +14,15 @@ import * as os from 'os';
 import { spawn } from 'child_process';
 import { exec } from 'child_process';
 import { promisify } from 'util';
+import * as readline from 'readline';
 const execAsync = promisify(exec);
 // Configuration
 const API_BASE_URL = process.env.HIGHERUP_API_URL || 'https://pltlcpqtivuvyeuywvql.supabase.co/functions/v1/agent-relay';
 const CONFIG_DIR = path.join(os.homedir(), '.higherup');
 const CONFIG_FILE = path.join(CONFIG_DIR, 'config.json');
-const POLL_INTERVAL = 2000; // 2 seconds
+const LOG_FILE = path.join(CONFIG_DIR, 'agent.log');
+const POLL_INTERVAL = 2000;
+const VERSION = '2.0.1';
 // Colors for terminal output
 const colors = {
     success: chalk.green,
@@ -30,7 +33,99 @@ const colors = {
     file: chalk.blue,
     dim: chalk.gray,
     bold: chalk.bold,
+    highlight: chalk.bgCyan.black,
 };
+// Logging utility
+class Logger {
+    logLevel;
+    logToFile;
+    constructor(level = 'info', logToFile = true) {
+        this.logLevel = level;
+        this.logToFile = logToFile;
+    }
+    levels = { debug: 0, info: 1, warn: 2, error: 3 };
+    shouldLog(level) {
+        return this.levels[level] >= this.levels[this.logLevel];
+    }
+    async writeToFile(message) {
+        if (this.logToFile) {
+            try {
+                const timestamp = new Date().toISOString();
+                await fs.appendFile(LOG_FILE, `[${timestamp}] ${message}\n`);
+            }
+            catch {
+                // Ignore file write errors
+            }
+        }
+    }
+    debug(message, ...args) {
+        if (this.shouldLog('debug')) {
+            console.log(colors.dim(`[DEBUG] ${message}`), ...args);
+            this.writeToFile(`DEBUG: ${message}`);
+        }
+    }
+    info(message, ...args) {
+        if (this.shouldLog('info')) {
+            console.log(colors.info(message), ...args);
+            this.writeToFile(`INFO: ${message}`);
+        }
+    }
+    warn(message, ...args) {
+        if (this.shouldLog('warn')) {
+            console.log(colors.warning(`⚠ ${message}`), ...args);
+            this.writeToFile(`WARN: ${message}`);
+        }
+    }
+    error(message, ...args) {
+        if (this.shouldLog('error')) {
+            console.error(colors.error(`✗ ${message}`), ...args);
+            this.writeToFile(`ERROR: ${message}`);
+        }
+    }
+    success(message, ...args) {
+        console.log(colors.success(`✓ ${message}`), ...args);
+        this.writeToFile(`SUCCESS: ${message}`);
+    }
+}
+const logger = new Logger();
+// Interactive prompts
+async function prompt(question, defaultValue) {
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    return new Promise((resolve) => {
+        const displayQuestion = defaultValue
+            ? `${question} (${colors.dim(defaultValue)}): `
+            : `${question}: `;
+        rl.question(displayQuestion, (answer) => {
+            rl.close();
+            resolve(answer.trim() || defaultValue || '');
+        });
+    });
+}
+async function confirm(question, defaultYes = true) {
+    const hint = defaultYes ? '[Y/n]' : '[y/N]';
+    const answer = await prompt(`${question} ${hint}`);
+    if (!answer)
+        return defaultYes;
+    return answer.toLowerCase().startsWith('y');
+}
+async function selectFromList(items, message) {
+    if (items.length === 0)
+        return null;
+    console.log(`\n${message}\n`);
+    items.forEach((item, index) => {
+        console.log(`  ${colors.bold(`${index + 1}.`)} ${item.name} ${colors.dim(`(${item.id.slice(0, 8)}...)`)}`);
+    });
+    console.log('');
+    const answer = await prompt('Select number');
+    const index = parseInt(answer) - 1;
+    if (index >= 0 && index < items.length) {
+        return items[index];
+    }
+    return null;
+}
 class HigherupAgent {
     workspacePath = '';
     workspaceId = '';
@@ -40,14 +135,21 @@ class HigherupAgent {
     isRunning = false;
     commandCount = 0;
     pollTimer = null;
+    heartbeatTimer = null;
     autonomousMode = false;
+    reconnectAttempts = 0;
+    maxReconnectAttempts = 5;
+    startTime = new Date();
+    bytesTransferred = 0;
     constructor() { }
-    async connect(workspacePath, workspaceId, apiToken, agentName, autonomous) {
+    async connect(workspacePath, workspaceId, apiToken, agentName, autonomous, autoReconnect) {
         this.workspacePath = path.resolve(workspacePath);
         this.workspaceId = workspaceId;
         this.apiToken = apiToken;
         this.agentName = agentName || `${os.hostname()}-${os.platform()}`;
         this.autonomousMode = autonomous || false;
+        this.maxReconnectAttempts = autoReconnect ? 5 : 0;
+        this.startTime = new Date();
         const spinner = ora('Connecting to Higherup service...').start();
         try {
             // Validate workspace path
@@ -62,18 +164,27 @@ class HigherupAgent {
                 agent_name: this.agentName,
                 capabilities: [
                     'command_execute',
+                    'command_stream',
                     'file_read',
                     'file_write',
                     'file_list',
+                    'file_watch',
                     'screen_capture',
+                    'screen_stream',
                     'system_info',
+                    'process_list',
+                    'env_vars',
                 ],
                 autonomous_mode: this.autonomousMode,
+                version: VERSION,
+                platform: os.platform(),
+                arch: os.arch(),
             });
             if (!response.success) {
                 throw new Error(response.error || 'Registration failed');
             }
             this.sessionId = response.session_id;
+            this.reconnectAttempts = 0;
             spinner.succeed('Connected to Higherup service!');
             this.printBanner();
             this.isRunning = true;
@@ -84,23 +195,47 @@ class HigherupAgent {
             // Handle shutdown
             process.on('SIGINT', () => this.disconnect());
             process.on('SIGTERM', () => this.disconnect());
+            process.on('uncaughtException', (err) => {
+                logger.error(`Uncaught exception: ${err.message}`);
+                this.disconnect();
+            });
         }
         catch (error) {
             spinner.fail(`Failed to connect: ${error.message}`);
+            if (this.maxReconnectAttempts > 0 && this.reconnectAttempts < this.maxReconnectAttempts) {
+                this.reconnectAttempts++;
+                const delay = Math.min(1000 * Math.pow(2, this.reconnectAttempts), 30000);
+                logger.warn(`Reconnecting in ${delay / 1000}s (attempt ${this.reconnectAttempts}/${this.maxReconnectAttempts})...`);
+                await new Promise(resolve => setTimeout(resolve, delay));
+                return this.connect(workspacePath, workspaceId, apiToken, agentName, autonomous, true);
+            }
             throw error;
         }
     }
     async apiCall(action, body) {
         const url = `${API_BASE_URL}?action=${action}`;
-        const response = await fetch(url, {
-            method: 'POST',
-            headers: {
-                'Content-Type': 'application/json',
-                'x-api-token': this.apiToken,
-            },
-            body: JSON.stringify(body),
-        });
-        return response.json();
+        try {
+            const response = await fetch(url, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'x-api-token': this.apiToken,
+                    'x-agent-version': VERSION,
+                },
+                body: JSON.stringify(body),
+            });
+            if (!response.ok) {
+                const errorText = await response.text();
+                throw new Error(`API error (${response.status}): ${errorText}`);
+            }
+            return response.json();
+        }
+        catch (error) {
+            if (error.name === 'AbortError' || error.message.includes('fetch')) {
+                throw new Error('Network error: Unable to reach Higherup service');
+            }
+            throw error;
+        }
     }
     startPolling() {
         this.pollTimer = setInterval(async () => {
@@ -117,38 +252,117 @@ class HigherupAgent {
                 }
             }
             catch (error) {
-                console.error(colors.error('Polling error:'), error);
+                logger.debug(`Polling error: ${error.message}`);
+                // Check if we should attempt reconnection
+                if (this.maxReconnectAttempts > 0 && error.message.includes('Network')) {
+                    await this.attemptReconnect();
+                }
             }
         }, POLL_INTERVAL);
     }
+    async attemptReconnect() {
+        if (this.reconnectAttempts >= this.maxReconnectAttempts) {
+            logger.error('Max reconnection attempts reached. Disconnecting...');
+            await this.disconnect();
+            return;
+        }
+        this.reconnectAttempts++;
+        logger.warn(`Connection lost. Reconnecting (${this.reconnectAttempts}/${this.maxReconnectAttempts})...`);
+        try {
+            const response = await this.apiCall('register', {
+                workspace_id: this.workspaceId,
+                agent_name: this.agentName,
+                capabilities: ['command_execute', 'file_read', 'file_write', 'file_list', 'screen_capture', 'system_info'],
+                autonomous_mode: this.autonomousMode,
+                version: VERSION,
+            });
+            if (response.success) {
+                this.sessionId = response.session_id;
+                this.reconnectAttempts = 0;
+                logger.success('Reconnected successfully!');
+            }
+        }
+        catch {
+            const delay = Math.min(1000 * Math.pow(2, this.reconnectAttempts), 30000);
+            await new Promise(resolve => setTimeout(resolve, delay));
+        }
+    }
     startHeartbeat() {
-        setInterval(async () => {
+        this.heartbeatTimer = setInterval(async () => {
             if (!this.isRunning)
                 return;
             try {
                 await this.apiCall('heartbeat', {
                     session_id: this.sessionId,
+                    stats: {
+                        commands_executed: this.commandCount,
+                        uptime: Math.floor((Date.now() - this.startTime.getTime()) / 1000),
+                        bytes_transferred: this.bytesTransferred,
+                        memory_usage: process.memoryUsage().heapUsed,
+                    },
                 });
             }
-            catch (error) {
-                console.error(colors.dim('Heartbeat failed'));
+            catch {
+                logger.debug('Heartbeat failed');
             }
-        }, 30000); // Every 30 seconds
+        }, 30000);
     }
     printBanner() {
         console.log('\n');
-        console.log(colors.bold('  ╔═══════════════════════════════════════════╗'));
-        console.log(colors.bold('  ║') + colors.info('         HIGHERUP LOCAL AGENT            ') + colors.bold('║'));
-        console.log(colors.bold('  ╚═══════════════════════════════════════════╝'));
-        console.log('');
-        console.log(colors.dim(`  Workspace: ${this.workspacePath}`));
-        console.log(colors.dim(`  Agent:     ${this.agentName}`));
-        console.log(colors.dim(`  Session:   ${this.sessionId}`));
+        console.log(colors.bold('  ╔═══════════════════════════════════════════════════╗'));
+        console.log(colors.bold('  ║') + colors.info('           HIGHERUP LOCAL AGENT v' + VERSION + '          ') + colors.bold('║'));
+        console.log(colors.bold('  ╠═══════════════════════════════════════════════════╣'));
+        console.log(colors.bold('  ║') + `  Workspace: ${colors.dim(this.workspacePath.slice(0, 35))}`.padEnd(60) + colors.bold('║'));
+        console.log(colors.bold('  ║') + `  Agent:     ${colors.dim(this.agentName)}`.padEnd(60) + colors.bold('║'));
+        console.log(colors.bold('  ║') + `  Session:   ${colors.dim(this.sessionId.slice(0, 20))}...`.padEnd(60) + colors.bold('║'));
         if (this.autonomousMode) {
-            console.log(colors.warning('  Mode:      AUTONOMOUS (unrestricted)'));
+            console.log(colors.bold('  ║') + colors.warning('  Mode:      AUTONOMOUS (unrestricted)').padEnd(59) + colors.bold('║'));
         }
+        console.log(colors.bold('  ╚═══════════════════════════════════════════════════╝'));
         console.log('');
         console.log(colors.info('  Listening for commands... Press Ctrl+C to stop.\n'));
+        console.log(colors.dim('  Commands: h=help, s=stats, q=quit\n'));
+        // Listen for keyboard commands
+        this.setupKeyboardListener();
+    }
+    setupKeyboardListener() {
+        if (process.stdin.isTTY) {
+            process.stdin.setRawMode(true);
+            process.stdin.resume();
+            process.stdin.setEncoding('utf8');
+            process.stdin.on('data', async (key) => {
+                if (key === '\u0003') { // Ctrl+C
+                    await this.disconnect();
+                }
+                else if (key === 'h') {
+                    this.printHelp();
+                }
+                else if (key === 's') {
+                    this.printStats();
+                }
+                else if (key === 'q') {
+                    await this.disconnect();
+                }
+            });
+        }
+    }
+    printHelp() {
+        console.log('\n' + colors.bold('  Keyboard Commands:'));
+        console.log('    h - Show this help');
+        console.log('    s - Show session stats');
+        console.log('    q - Quit/disconnect');
+        console.log('    Ctrl+C - Force quit\n');
+    }
+    printStats() {
+        const uptime = Math.floor((Date.now() - this.startTime.getTime()) / 1000);
+        const hours = Math.floor(uptime / 3600);
+        const minutes = Math.floor((uptime % 3600) / 60);
+        const seconds = uptime % 60;
+        console.log('\n' + colors.bold('  Session Statistics:'));
+        console.log(`    Commands executed: ${this.commandCount}`);
+        console.log(`    Uptime: ${hours}h ${minutes}m ${seconds}s`);
+        console.log(`    Data transferred: ${(this.bytesTransferred / 1024).toFixed(2)} KB`);
+        console.log(`    Memory usage: ${(process.memoryUsage().heapUsed / 1024 / 1024).toFixed(2)} MB\n`);
     }
     async processCommand(cmd) {
         const commandText = cmd.command_text;
@@ -175,6 +389,15 @@ class HigherupAgent {
             else if (commandText.startsWith('__INTERNAL_FILE_LIST__')) {
                 await this.handleFileList(cmd);
             }
+            else if (commandText.startsWith('__INTERNAL_FILE_DELETE__')) {
+                await this.handleFileDelete(cmd);
+            }
+            else if (commandText.startsWith('__INTERNAL_FILE_COPY__')) {
+                await this.handleFileCopy(cmd);
+            }
+            else if (commandText.startsWith('__INTERNAL_FILE_MOVE__')) {
+                await this.handleFileMove(cmd);
+            }
             else if (commandText.startsWith('__INTERNAL_SCREEN_CAPTURE__')) {
                 await this.handleScreenCapture(cmd);
             }
@@ -184,6 +407,15 @@ class HigherupAgent {
             else if (commandText.startsWith('__INTERNAL_SYSTEM_INFO__')) {
                 await this.handleSystemInfo(cmd);
             }
+            else if (commandText.startsWith('__INTERNAL_PROCESS_LIST__')) {
+                await this.handleProcessList(cmd);
+            }
+            else if (commandText.startsWith('__INTERNAL_ENV_VARS__')) {
+                await this.handleEnvVars(cmd);
+            }
+            else if (commandText.startsWith('__INTERNAL_SEARCH_FILES__')) {
+                await this.handleSearchFiles(cmd);
+            }
             else {
                 await this.reportResult(cmd.id, `Unknown internal command: ${commandText}`, -1, 0);
             }
@@ -201,7 +433,7 @@ class HigherupAgent {
         const filePath = path.resolve(this.workspacePath, match[1].trim());
         const encoding = (match[2] || 'utf8');
         console.log(colors.file(`[FILE READ] ${filePath}`));
-        // Security check - ensure file is within workspace
+        // Security check
         if (!filePath.startsWith(this.workspacePath)) {
             await this.reportResult(cmd.id, 'Access denied: Path outside workspace', -1, 0);
             return;
@@ -209,6 +441,7 @@ class HigherupAgent {
         try {
             const content = await fs.readFile(filePath, encoding);
             const stats = await fs.stat(filePath);
+            this.bytesTransferred += stats.size;
             const result = JSON.stringify({
                 success: true,
                 content,
@@ -237,7 +470,6 @@ class HigherupAgent {
         }
         console.log(colors.file(`[FILE WRITE] ${filePath}`));
         try {
-            // Content is stored in cmd.output as JSON
             const data = JSON.parse(cmd.output || '{}');
             const { content, encoding = 'utf8', create_dirs = true } = data;
             if (create_dirs) {
@@ -245,6 +477,7 @@ class HigherupAgent {
             }
             await fs.writeFile(filePath, content, encoding);
             const stats = await fs.stat(filePath);
+            this.bytesTransferred += stats.size;
             await this.reportResult(cmd.id, JSON.stringify({
                 success: true,
                 path: match[1].trim(),
@@ -284,6 +517,171 @@ class HigherupAgent {
             await this.reportResult(cmd.id, JSON.stringify({ success: false, error: error.message }), -1, 0);
         }
     }
+    async handleFileDelete(cmd) {
+        const match = cmd.command_text.match(/__INTERNAL_FILE_DELETE__\s+(.+)$/);
+        if (!match) {
+            await this.reportResult(cmd.id, 'Invalid file delete command', -1, 0);
+            return;
+        }
+        const filePath = path.resolve(this.workspacePath, match[1].trim());
+        // Security check
+        if (!filePath.startsWith(this.workspacePath)) {
+            await this.reportResult(cmd.id, 'Access denied: Path outside workspace', -1, 0);
+            return;
+        }
+        console.log(colors.file(`[FILE DELETE] ${filePath}`));
+        try {
+            await fs.rm(filePath, { recursive: true });
+            await this.reportResult(cmd.id, JSON.stringify({ success: true, path: match[1].trim() }), 0, 0);
+            console.log(colors.success(`  ✓ Deleted`));
+        }
+        catch (error) {
+            await this.reportResult(cmd.id, JSON.stringify({ success: false, error: error.message }), -1, 0);
+        }
+    }
+    async handleFileCopy(cmd) {
+        const match = cmd.command_text.match(/__INTERNAL_FILE_COPY__\s+(.+)\s+--to=(.+)$/);
+        if (!match) {
+            await this.reportResult(cmd.id, 'Invalid file copy command', -1, 0);
+            return;
+        }
+        const srcPath = path.resolve(this.workspacePath, match[1].trim());
+        const destPath = path.resolve(this.workspacePath, match[2].trim());
+        // Security check
+        if (!srcPath.startsWith(this.workspacePath) || !destPath.startsWith(this.workspacePath)) {
+            await this.reportResult(cmd.id, 'Access denied: Path outside workspace', -1, 0);
+            return;
+        }
+        console.log(colors.file(`[FILE COPY] ${srcPath} -> ${destPath}`));
+        try {
+            await fs.mkdir(path.dirname(destPath), { recursive: true });
+            await fs.copyFile(srcPath, destPath);
+            await this.reportResult(cmd.id, JSON.stringify({ success: true, from: match[1].trim(), to: match[2].trim() }), 0, 0);
+            console.log(colors.success(`  ✓ Copied`));
+        }
+        catch (error) {
+            await this.reportResult(cmd.id, JSON.stringify({ success: false, error: error.message }), -1, 0);
+        }
+    }
+    async handleFileMove(cmd) {
+        const match = cmd.command_text.match(/__INTERNAL_FILE_MOVE__\s+(.+)\s+--to=(.+)$/);
+        if (!match) {
+            await this.reportResult(cmd.id, 'Invalid file move command', -1, 0);
+            return;
+        }
+        const srcPath = path.resolve(this.workspacePath, match[1].trim());
+        const destPath = path.resolve(this.workspacePath, match[2].trim());
+        // Security check
+        if (!srcPath.startsWith(this.workspacePath) || !destPath.startsWith(this.workspacePath)) {
+            await this.reportResult(cmd.id, 'Access denied: Path outside workspace', -1, 0);
+            return;
+        }
+        console.log(colors.file(`[FILE MOVE] ${srcPath} -> ${destPath}`));
+        try {
+            await fs.mkdir(path.dirname(destPath), { recursive: true });
+            await fs.rename(srcPath, destPath);
+            await this.reportResult(cmd.id, JSON.stringify({ success: true, from: match[1].trim(), to: match[2].trim() }), 0, 0);
+            console.log(colors.success(`  ✓ Moved`));
+        }
+        catch (error) {
+            await this.reportResult(cmd.id, JSON.stringify({ success: false, error: error.message }), -1, 0);
+        }
+    }
+    async handleSearchFiles(cmd) {
+        const match = cmd.command_text.match(/__INTERNAL_SEARCH_FILES__\s+(.+?)(?:\s+--pattern=(.+))?$/);
+        if (!match) {
+            await this.reportResult(cmd.id, 'Invalid search command', -1, 0);
+            return;
+        }
+        const searchTerm = match[1].trim();
+        const pattern = match[2] || '*';
+        console.log(colors.file(`[SEARCH] "${searchTerm}" in ${pattern}`));
+        try {
+            const results = [];
+            await this.searchInDirectory(this.workspacePath, searchTerm, pattern, results, 100);
+            await this.reportResult(cmd.id, JSON.stringify({
+                success: true,
+                term: searchTerm,
+                results: results.slice(0, 100),
+                total: results.length,
+            }), 0, 0);
+            console.log(colors.success(`  ✓ Found ${results.length} matches`));
+        }
+        catch (error) {
+            await this.reportResult(cmd.id, JSON.stringify({ success: false, error: error.message }), -1, 0);
+        }
+    }
+    async searchInDirectory(dir, term, pattern, results, maxResults) {
+        if (results.length >= maxResults)
+            return;
+        const entries = await fs.readdir(dir, { withFileTypes: true });
+        for (const entry of entries) {
+            if (results.length >= maxResults)
+                break;
+            if (entry.name.startsWith('.') || entry.name === 'node_modules')
+                continue;
+            const fullPath = path.join(dir, entry.name);
+            if (entry.isDirectory()) {
+                await this.searchInDirectory(fullPath, term, pattern, results, maxResults);
+            }
+            else if (entry.isFile()) {
+                try {
+                    const content = await fs.readFile(fullPath, 'utf8');
+                    const lines = content.split('\n');
+                    lines.forEach((line, index) => {
+                        if (line.toLowerCase().includes(term.toLowerCase())) {
+                            results.push({
+                                path: path.relative(this.workspacePath, fullPath),
+                                line: index + 1,
+                                content: line.trim().slice(0, 200),
+                            });
+                        }
+                    });
+                }
+                catch {
+                    // Skip binary files
+                }
+            }
+        }
+    }
+    async handleProcessList(cmd) {
+        console.log(colors.info('[PROCESS LIST]'));
+        try {
+            let output;
+            if (os.platform() === 'win32') {
+                const result = await execAsync('tasklist /fo csv');
+                output = result.stdout;
+            }
+            else {
+                const result = await execAsync('ps aux');
+                output = result.stdout;
+            }
+            await this.reportResult(cmd.id, JSON.stringify({
+                success: true,
+                processes: output,
+                platform: os.platform(),
+            }), 0, 0);
+            console.log(colors.success('  ✓ Process list retrieved'));
+        }
+        catch (error) {
+            await this.reportResult(cmd.id, JSON.stringify({ success: false, error: error.message }), -1, 0);
+        }
+    }
+    async handleEnvVars(cmd) {
+        console.log(colors.info('[ENV VARS]'));
+        // Filter out sensitive env vars
+        const safeEnvVars = {};
+        const sensitivePatterns = ['PASSWORD', 'SECRET', 'TOKEN', 'KEY', 'CREDENTIAL'];
+        for (const [key, value] of Object.entries(process.env)) {
+            const isSensitive = sensitivePatterns.some(pattern => key.toUpperCase().includes(pattern));
+            safeEnvVars[key] = isSensitive ? '***REDACTED***' : (value || '');
+        }
+        await this.reportResult(cmd.id, JSON.stringify({
+            success: true,
+            env: safeEnvVars,
+        }), 0, 0);
+        console.log(colors.success('  ✓ Environment variables retrieved'));
+    }
     async listDirectory(dirPath, recursive, includeHidden) {
         const entries = await fs.readdir(dirPath, { withFileTypes: true });
         const files = [];
@@ -325,14 +723,11 @@ class HigherupAgent {
         const display = match ? parseInt(match[1]) : 0;
         console.log(colors.info(`[SCREEN CAPTURE] Display ${display}`));
         try {
-            let imagePath;
             const tempFile = path.join(os.tmpdir(), `higherup-screen-${Date.now()}.png`);
             if (os.platform() === 'darwin') {
-                // macOS
                 await execAsync(`screencapture -x -D ${display + 1} "${tempFile}"`);
             }
             else if (os.platform() === 'win32') {
-                // Windows - use PowerShell
                 const psScript = `
           Add-Type -AssemblyName System.Windows.Forms
           $screen = [System.Windows.Forms.Screen]::AllScreens[${display}]
@@ -344,7 +739,6 @@ class HigherupAgent {
                 await execAsync(`powershell -Command "${psScript}"`);
             }
             else {
-                // Linux - use scrot or import
                 try {
                     await execAsync(`scrot "${tempFile}"`);
                 }
@@ -352,12 +746,10 @@ class HigherupAgent {
                     await execAsync(`import -window root "${tempFile}"`);
                 }
             }
-            imagePath = tempFile;
-            // Read the image and convert to base64
-            const imageBuffer = await fs.readFile(imagePath);
+            const imageBuffer = await fs.readFile(tempFile);
             const base64Image = imageBuffer.toString('base64');
-            // Clean up temp file
-            await fs.unlink(imagePath).catch(() => { });
+            this.bytesTransferred += imageBuffer.length;
+            await fs.unlink(tempFile).catch(() => { });
             await this.reportResult(cmd.id, JSON.stringify({
                 success: true,
                 image: base64Image,
@@ -376,7 +768,6 @@ class HigherupAgent {
         }
     }
     async handleScreenStreamStart(cmd) {
-        // Screen streaming would require WebSocket - just acknowledge for now
         await this.reportResult(cmd.id, JSON.stringify({
             success: true,
             message: 'Screen streaming initiated. Use WebSocket for continuous frames.',
@@ -386,6 +777,21 @@ class HigherupAgent {
         console.log(colors.info('[SYSTEM INFO]'));
         try {
             const cpus = os.cpus();
+            // Get disk usage
+            let diskInfo = {};
+            try {
+                if (os.platform() === 'win32') {
+                    const { stdout } = await execAsync('wmic logicaldisk get size,freespace,caption');
+                    diskInfo = { raw: stdout };
+                }
+                else {
+                    const { stdout } = await execAsync('df -h /');
+                    diskInfo = { raw: stdout };
+                }
+            }
+            catch {
+                diskInfo = { error: 'Unable to get disk info' };
+            }
             const systemInfo = {
                 success: true,
                 os: os.platform(),
@@ -404,8 +810,12 @@ class HigherupAgent {
                     total: os.totalmem(),
                     free: os.freemem(),
                     used: os.totalmem() - os.freemem(),
+                    percent_used: ((os.totalmem() - os.freemem()) / os.totalmem() * 100).toFixed(1),
                 },
+                disk: diskInfo,
                 uptime: os.uptime(),
+                load_average: os.loadavg(),
+                network: Object.keys(os.networkInterfaces()).length,
                 workspace: {
                     path: this.workspacePath,
                     id: this.workspaceId,
@@ -414,6 +824,8 @@ class HigherupAgent {
                     name: this.agentName,
                     session: this.sessionId,
                     autonomous: this.autonomousMode,
+                    version: VERSION,
+                    commands_executed: this.commandCount,
                 },
             };
             await this.reportResult(cmd.id, JSON.stringify(systemInfo), 0, 0);
@@ -426,7 +838,6 @@ class HigherupAgent {
     async executeStreamingCommand(cmd) {
         const command = cmd.command_text.replace('__STREAM__ ', '');
         console.log(colors.command(`\n[STREAM] $ ${command}`));
-        // For streaming, we execute normally but could implement chunk reporting
         await this.executeShellCommand(cmd, command);
     }
     async executeCommand(cmd) {
@@ -437,7 +848,19 @@ class HigherupAgent {
         const startTime = Date.now();
         // Security check for dangerous commands (unless autonomous mode)
         if (!this.autonomousMode) {
-            const dangerousPatterns = ['rm -rf /', 'mkfs', 'dd if=', ':(){:|:&};:'];
+            const dangerousPatterns = [
+                'rm -rf /',
+                'rm -rf ~',
+                'rm -rf /*',
+                'mkfs',
+                'dd if=',
+                ':(){:|:&};:',
+                '> /dev/sda',
+                'chmod 777 /',
+                'chmod -R 777 /',
+                'chown root',
+                'sudo rm -rf',
+            ];
             for (const pattern of dangerousPatterns) {
                 if (command.includes(pattern)) {
                     console.log(colors.error(`  ✗ Blocked dangerous command pattern: ${pattern}`));
@@ -446,7 +869,6 @@ class HigherupAgent {
                 }
             }
         }
-        // Determine shell based on platform
         const isWindows = os.platform() === 'win32';
         const shell = isWindows ? 'cmd.exe' : '/bin/bash';
         const shellArgs = isWindows ? ['/c', command] : ['-c', command];
@@ -477,15 +899,51 @@ class HigherupAgent {
             });
             const duration = Date.now() - startTime;
             this.commandCount++;
+            this.bytesTransferred += result.output.length;
             const status = result.exitCode === 0 ? colors.success('✓') : colors.error('✗');
             console.log(colors.dim(`\n[Completed in ${duration}ms] ${status} Exit code: ${result.exitCode}\n`));
             await this.reportResult(cmd.id, result.output.slice(-10000), result.exitCode, duration);
         }
         catch (error) {
             console.log(colors.error(`\n[ERROR] ${error.message}\n`));
+            // Self-Healing Logic
+            if (this.autonomousMode) {
+                const healed = await this.attemptSelfHeal(cmd, command, error.message);
+                if (healed)
+                    return;
+            }
             await this.reportResult(cmd.id, error.message, -1, Date.now() - startTime);
         }
     }
+    async attemptSelfHeal(cmd, originalCommand, error) {
+        console.log(colors.info(`\n[SELF-HEALING] Analysing error...`));
+        // Heuristic 1: Permission Denied
+        if (error.includes('Permission denied') || error.includes('EACCES')) {
+            if (!originalCommand.startsWith('sudo ')) {
+                console.log(colors.warning(`  ➜ Detected permission issue. Retrying with sudo...`));
+                await this.executeShellCommand(cmd, `sudo ${originalCommand}`);
+                return true;
+            }
+        }
+        // Heuristic 2: Missing Dependencies (npm)
+        if (originalCommand.includes('npm') && (error.includes('sh: npm: command not found') || error.includes('ENOENT'))) {
+            // Cannot fix missing npm easily without OS detection, but we can log hint
+            console.log(colors.warning(`  ➜ Missing npm. Attempting to locate...`));
+        }
+        // Heuristic 3: GIT Lock
+        if (originalCommand.startsWith('git') && error.includes('index.lock')) {
+            console.log(colors.warning(`  ➜ Git lock detected. Removing index.lock...`));
+            try {
+                await fs.unlink(path.join(this.workspacePath, '.git', 'index.lock'));
+                await this.executeShellCommand(cmd, originalCommand);
+                return true;
+            }
+            catch {
+                // failed to clean lock
+            }
+        }
+        return false; // Could not heal
+    }
     async reportResult(commandId, output, exitCode, duration) {
         await this.apiCall('result', {
             command_id: commandId,
@@ -500,21 +958,24 @@ class HigherupAgent {
         if (this.pollTimer) {
             clearInterval(this.pollTimer);
         }
+        if (this.heartbeatTimer) {
+            clearInterval(this.heartbeatTimer);
+        }
         try {
             await this.apiCall('disconnect', {
                 session_id: this.sessionId,
                 workspace_id: this.workspaceId,
             });
         }
-        catch (error) {
+        catch {
             // Ignore disconnect errors
         }
         console.log(colors.success('Disconnected. Goodbye!\n'));
-        console.log(colors.dim(`Session stats: ${this.commandCount} commands executed\n`));
+        this.printStats();
         process.exit(0);
     }
 }
-// CLI Setup
+// Helper functions
 async function loadConfig() {
     try {
         await fs.mkdir(CONFIG_DIR, { recursive: true });
@@ -529,73 +990,237 @@ async function saveConfig(config) {
     await fs.mkdir(CONFIG_DIR, { recursive: true });
     await fs.writeFile(CONFIG_FILE, JSON.stringify(config, null, 2));
 }
+async function fetchWorkspaces(apiToken) {
+    try {
+        const response = await fetch(`${API_BASE_URL}?action=status`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'x-api-token': apiToken,
+            },
+            body: JSON.stringify({}),
+        });
+        if (!response.ok) {
+            throw new Error('Failed to fetch workspaces');
+        }
+        const data = await response.json();
+        return data.workspaces || [];
+    }
+    catch {
+        return [];
+    }
+}
+// CLI Setup
 const program = new Command();
 program
     .name('higherup')
-    .description('Higherup Local Agent - Give AI agents full access to your development environment')
-    .version('1.0.0');
+    .description('Higherup Local Agent v' + VERSION + ' - Give AI agents full access to your development environment')
+    .version(VERSION);
+// Main connect command
 program
     .command('connect')
     .description('Connect to Higherup service')
-    .requiredOption('-w, --workspace <id>', 'Workspace ID to connect')
-    .requiredOption('-p, --path <path>', 'Local workspace path', '.')
+    .option('-w, --workspace <id>', 'Workspace ID to connect')
+    .option('-p, --path <path>', 'Local workspace path')
     .option('-t, --token <token>', 'API token (or use HIGHERUP_API_TOKEN env var)')
     .option('-n, --name <name>', 'Agent name for identification')
     .option('--autonomous', 'Enable autonomous mode (unrestricted access)')
+    .option('--auto-reconnect', 'Automatically reconnect on connection loss')
     .action(async (options) => {
     const config = await loadConfig();
-    const apiToken = options.token || process.env.HIGHERUP_API_TOKEN || config.apiToken;
+    let apiToken = options.token || process.env.HIGHERUP_API_TOKEN || config.apiToken;
+    let workspaceId = options.workspace || config.defaultWorkspace;
+    let workspacePath = options.path || config.defaultPath || '.';
+    // Interactive setup if missing required options
     if (!apiToken) {
-        console.error(colors.error('Error: API token is required'));
-        console.log(colors.info('\nProvide token via:'));
-        console.log('  --token <token>');
-        console.log('  HIGHERUP_API_TOKEN environment variable');
-        console.log('  or run: higherup config --token <token>');
-        process.exit(1);
+        console.log(colors.bold('\n  ═══ Higherup Setup ═══\n'));
+        console.log(colors.dim('  Get your API token from: https://higherup.ai/dashboard/api\n'));
+        apiToken = await prompt('  Enter your API token');
+        if (!apiToken) {
+            console.error(colors.error('\n  Error: API token is required'));
+            process.exit(1);
+        }
+        if (await confirm('  Save token for future use?')) {
+            config.apiToken = apiToken;
+            await saveConfig(config);
+            console.log(colors.success('  Token saved to ~/.higherup/config.json'));
+        }
+    }
+    // Fetch and select workspace if not provided
+    if (!workspaceId) {
+        const spinner = ora('  Fetching your workspaces...').start();
+        const workspaces = await fetchWorkspaces(apiToken);
+        spinner.stop();
+        if (workspaces.length > 0) {
+            const selected = await selectFromList(workspaces, 'Select a workspace:');
+            if (selected) {
+                workspaceId = selected.id;
+            }
+        }
+        if (!workspaceId) {
+            console.log(colors.dim('\n  No workspaces found. Create one at https://higherup.ai/dashboard/workspaces'));
+            workspaceId = await prompt('  Or enter workspace ID manually');
+        }
+        if (!workspaceId) {
+            console.error(colors.error('\n  Error: Workspace ID is required'));
+            process.exit(1);
+        }
+    }
+    // Get workspace path
+    if (workspacePath === '.') {
+        const suggested = process.cwd();
+        console.log('');
+        workspacePath = await prompt(`  Workspace path`, suggested);
     }
     const agent = new HigherupAgent();
     try {
-        await agent.connect(options.path, options.workspace, apiToken, options.name, options.autonomous);
+        await agent.connect(workspacePath, workspaceId, apiToken, options.name || config.agentName, options.autonomous, options.autoReconnect);
     }
     catch (error) {
         console.error(colors.error(`\nFailed to connect: ${error.message}`));
         process.exit(1);
     }
 });
+// Quick connect with just token
+program
+    .command('quick')
+    .description('Quick connect with interactive workspace selection')
+    .action(async () => {
+    const config = await loadConfig();
+    const apiToken = process.env.HIGHERUP_API_TOKEN || config.apiToken;
+    if (!apiToken) {
+        console.error(colors.error('Error: No API token configured'));
+        console.log(colors.info('Run: higherup config --token <your-token>'));
+        process.exit(1);
+    }
+    const spinner = ora('Fetching workspaces...').start();
+    const workspaces = await fetchWorkspaces(apiToken);
+    spinner.stop();
+    if (workspaces.length === 0) {
+        console.log(colors.warning('No workspaces found.'));
+        console.log(colors.info('Create one at https://higherup.ai/dashboard/workspaces'));
+        process.exit(1);
+    }
+    const selected = await selectFromList(workspaces, 'Select a workspace:');
+    if (!selected) {
+        console.log(colors.warning('No workspace selected.'));
+        process.exit(1);
+    }
+    const agent = new HigherupAgent();
+    await agent.connect(process.cwd(), selected.id, apiToken);
+});
+// Init command for first-time setup
+program
+    .command('init')
+    .description('Initialize Higherup in current directory')
+    .action(async () => {
+    console.log(colors.bold('\n  ═══ Higherup Initialization ═══\n'));
+    const config = await loadConfig();
+    // Step 1: API Token
+    if (!config.apiToken) {
+        console.log(colors.info('  Step 1: Configure API Token'));
+        console.log(colors.dim('  Get your token from: https://higherup.ai/dashboard/api\n'));
+        const token = await prompt('  API Token');
+        if (token) {
+            config.apiToken = token;
+            console.log(colors.success('  ✓ Token saved\n'));
+        }
+    }
+    else {
+        console.log(colors.success('  ✓ API Token already configured\n'));
+    }
+    // Step 2: Default workspace
+    console.log(colors.info('  Step 2: Set Default Workspace'));
+    if (config.apiToken) {
+        const spinner = ora('  Fetching workspaces...').start();
+        const workspaces = await fetchWorkspaces(config.apiToken);
+        spinner.stop();
+        if (workspaces.length > 0) {
+            const selected = await selectFromList(workspaces, '  Select default workspace:');
+            if (selected) {
+                config.defaultWorkspace = selected.id;
+                console.log(colors.success(`\n  ✓ Default workspace: ${selected.name}`));
+            }
+        }
+        else {
+            const wsId = await prompt('  Workspace ID (or create one at dashboard)');
+            if (wsId)
+                config.defaultWorkspace = wsId;
+        }
+    }
+    // Step 3: Default path
+    console.log(colors.info('\n  Step 3: Set Default Path'));
+    const defaultPath = await prompt('  Default workspace path', process.cwd());
+    config.defaultPath = defaultPath;
+    // Step 4: Agent name
+    console.log(colors.info('\n  Step 4: Set Agent Name'));
+    const agentName = await prompt('  Agent name', `${os.hostname()}-${os.platform()}`);
+    config.agentName = agentName;
+    await saveConfig(config);
+    console.log(colors.success('\n  ═══ Setup Complete! ═══\n'));
+    console.log('  Run ' + colors.bold('higherup connect') + ' to start the agent\n');
+});
+// Config command
 program
     .command('config')
     .description('Configure default settings')
     .option('-t, --token <token>', 'Set default API token')
     .option('-w, --workspace <id>', 'Set default workspace')
+    .option('-p, --path <path>', 'Set default workspace path')
+    .option('-n, --name <name>', 'Set default agent name')
     .option('--show', 'Show current configuration')
+    .option('--reset', 'Reset all configuration')
     .action(async (options) => {
     const config = await loadConfig();
+    if (options.reset) {
+        await saveConfig({});
+        console.log(colors.success('✓ Configuration reset'));
+        return;
+    }
     if (options.show) {
         console.log(colors.bold('\nHigherup Configuration:'));
         console.log(colors.dim(`Config file: ${CONFIG_FILE}\n`));
-        console.log(`  API Token: ${config.apiToken ? colors.success('Set') : colors.warning('Not set')}`);
+        console.log(`  API Token:         ${config.apiToken ? colors.success('Set (' + config.apiToken.slice(0, 8) + '...)') : colors.warning('Not set')}`);
         console.log(`  Default Workspace: ${config.defaultWorkspace || colors.dim('Not set')}`);
+        console.log(`  Default Path:      ${config.defaultPath || colors.dim('Not set')}`);
+        console.log(`  Agent Name:        ${config.agentName || colors.dim('Not set')}`);
+        console.log(`  Log Level:         ${config.logLevel || colors.dim('info')}`);
+        console.log(`  Auto Reconnect:    ${config.autoReconnect ? colors.success('Enabled') : colors.dim('Disabled')}`);
         console.log('');
         return;
     }
+    let updated = false;
     if (options.token) {
         config.apiToken = options.token;
         console.log(colors.success('✓ API token saved'));
+        updated = true;
     }
     if (options.workspace) {
         config.defaultWorkspace = options.workspace;
         console.log(colors.success('✓ Default workspace saved'));
+        updated = true;
+    }
+    if (options.path) {
+        config.defaultPath = options.path;
+        console.log(colors.success('✓ Default path saved'));
+        updated = true;
     }
-    if (options.token || options.workspace) {
+    if (options.name) {
+        config.agentName = options.name;
+        console.log(colors.success('✓ Agent name saved'));
+        updated = true;
+    }
+    if (updated) {
         await saveConfig(config);
     }
     else {
         console.log('Use --help to see available options');
     }
 });
+// Status command
 program
     .command('status')
-    .description('Check connection status')
+    .description('Check connection status and active sessions')
     .option('-t, --token <token>', 'API token')
     .action(async (options) => {
     const config = await loadConfig();
@@ -617,17 +1242,20 @@ program
         const data = await response.json();
         spinner.stop();
         if (data.active_sessions && data.active_sessions.length > 0) {
-            console.log(colors.success('\n✓ Connected sessions:\n'));
+            console.log(colors.success('\n✓ Active Sessions:\n'));
             for (const session of data.active_sessions) {
                 console.log(`  ${colors.bold(session.agent_name || 'Agent')}`);
                 console.log(colors.dim(`    Workspace: ${session.workspaces?.name || session.workspace_id}`));
                 console.log(colors.dim(`    Connected: ${new Date(session.connected_at).toLocaleString()}`));
+                if (session.last_activity) {
+                    console.log(colors.dim(`    Last Activity: ${new Date(session.last_activity).toLocaleString()}`));
+                }
                 console.log('');
             }
         }
         else {
             console.log(colors.warning('\n⚠ No active sessions'));
-            console.log(colors.dim('Run: higherup connect -w <workspace-id> -p <path>\n'));
+            console.log(colors.dim('Run: higherup connect -w <workspace-id>\n'));
         }
     }
     catch (error) {
@@ -635,5 +1263,109 @@ program
         process.exit(1);
     }
 });
+// Logs command
+program
+    .command('logs')
+    .description('View agent logs')
+    .option('-n, --lines <number>', 'Number of lines to show', '50')
+    .option('-f, --follow', 'Follow log output')
+    .action(async (options) => {
+    try {
+        const content = await fs.readFile(LOG_FILE, 'utf8');
+        const lines = content.split('\n');
+        const numLines = parseInt(options.lines);
+        console.log(colors.bold(`\nLast ${numLines} log entries:\n`));
+        console.log(lines.slice(-numLines).join('\n'));
+    }
+    catch {
+        console.log(colors.warning('No logs found.'));
+    }
+});
+// Doctor command to diagnose issues
+program
+    .command('doctor')
+    .description('Diagnose common issues')
+    .action(async () => {
+    console.log(colors.bold('\n  Higherup Doctor - Diagnosing issues...\n'));
+    let issues = 0;
+    // Check Node version
+    const nodeVersion = process.version;
+    const majorVersion = parseInt(nodeVersion.slice(1).split('.')[0]);
+    if (majorVersion >= 18) {
+        console.log(colors.success(`  ✓ Node.js ${nodeVersion}`));
+    }
+    else {
+        console.log(colors.error(`  ✗ Node.js ${nodeVersion} (requires v18+)`));
+        issues++;
+    }
+    // Check config
+    const config = await loadConfig();
+    if (config.apiToken) {
+        console.log(colors.success('  ✓ API token configured'));
+    }
+    else {
+        console.log(colors.warning('  ⚠ API token not configured'));
+        issues++;
+    }
+    // Check network connectivity
+    try {
+        const response = await fetch('https://pltlcpqtivuvyeuywvql.supabase.co/functions/v1/agent-relay?action=ping', {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: '{}',
+        });
+        if (response.ok || response.status === 401) {
+            console.log(colors.success('  ✓ Network connectivity'));
+        }
+        else {
+            console.log(colors.error('  ✗ Cannot reach Higherup service'));
+            issues++;
+        }
+    }
+    catch {
+        console.log(colors.error('  ✗ Network error'));
+        issues++;
+    }
+    // Check screen capture tools
+    if (os.platform() === 'linux') {
+        try {
+            await execAsync('which scrot');
+            console.log(colors.success('  ✓ Screen capture tool (scrot)'));
+        }
+        catch {
+            try {
+                await execAsync('which import');
+                console.log(colors.success('  ✓ Screen capture tool (imagemagick)'));
+            }
+            catch {
+                console.log(colors.warning('  ⚠ No screen capture tool found (install scrot)'));
+            }
+        }
+    }
+    else {
+        console.log(colors.success('  ✓ Screen capture available'));
+    }
+    // Summary
+    console.log('');
+    if (issues === 0) {
+        console.log(colors.success('  All checks passed!\n'));
+    }
+    else {
+        console.log(colors.warning(`  ${issues} issue(s) found. See above for details.\n`));
+    }
+});
+// Version with more info
+program
+    .command('info')
+    .description('Show version and system information')
+    .action(() => {
+    console.log(colors.bold(`\n  Higherup Agent v${VERSION}\n`));
+    console.log(`  Node.js:  ${process.version}`);
+    console.log(`  Platform: ${os.platform()} ${os.arch()}`);
+    console.log(`  Hostname: ${os.hostname()}`);
+    console.log(`  Config:   ${CONFIG_FILE}`);
+    console.log(`  API URL:  ${API_BASE_URL}`);
+    console.log('');
+});
 program.parse();
 //# sourceMappingURL=agent.js.map