@elontools/runner 3.1.0

package/dist/index.js

@@ -0,0 +1,1241 @@
+#!/usr/bin/env node
+/**
+ * Runner v3 - Core Entry Point (Node.js/TypeScript)
+ * Executa comandos enviados pelo backend via API
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+import { spawn } from 'child_process';
+import * as crypto from 'crypto';
+// ============================================================================
+// CONFIGURATION
+// ============================================================================
+let config = {
+    serverUrl: 'https://elontools.com',
+    mode: 'headless',
+};
+const startTime = Date.now();
+// Parse CLI arguments + fallback to config.json
+function parseArgs() {
+    const args = process.argv.slice(2);
+    for (const arg of args) {
+        if (arg.startsWith('--server-url=')) {
+            config.serverUrl = arg.split('=')[1];
+        }
+        else if (arg.startsWith('--pairing-token=')) {
+            config.pairingToken = arg.split('=')[1];
+        }
+        else if (arg.startsWith('--runner-id=')) {
+            config.runnerId = arg.split('=')[1];
+        }
+        else if (arg.startsWith('--runner-token=')) {
+            config.runnerToken = arg.split('=')[1];
+        }
+        else if (arg.startsWith('--mode=')) {
+            config.mode = arg.split('=')[1] || 'headless';
+        }
+        else if (arg.startsWith('--config-path=')) {
+            config.configPath = arg.split('=')[1];
+        }
+    }
+    // Fallback: read ~/.elon-runner/config.json if missing runner credentials
+    if (!config.runnerId || !config.runnerToken) {
+        try {
+            const homeDir = os.homedir();
+            const configPath = config.configPath || path.join(homeDir, '.elon-runner', 'config.json');
+            if (fs.existsSync(configPath)) {
+                const saved = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+                if (!config.runnerId && saved.runnerId)
+                    config.runnerId = saved.runnerId;
+                if (!config.runnerToken && saved.runnerToken)
+                    config.runnerToken = saved.runnerToken;
+                if (!config.serverUrl && saved.serverUrl)
+                    config.serverUrl = saved.serverUrl;
+                if (saved.mode)
+                    config.mode = saved.mode;
+                logger.info('📂 Config loaded from ' + configPath, {
+                    hasRunnerId: !!config.runnerId,
+                    hasRunnerToken: !!config.runnerToken,
+                });
+            }
+        }
+        catch (err) {
+            logger.warn('Failed to read config.json fallback', err);
+        }
+    }
+    logger.info('✅ Runner v3 iniciado', {
+        serverUrl: config.serverUrl,
+        mode: config.mode,
+        hasPairingToken: !!config.pairingToken,
+        hasRunnerId: !!config.runnerId,
+        hasRunnerToken: !!config.runnerToken,
+    });
+}
+// ============================================================================
+// LOGGER
+// ============================================================================
+const logger = {
+    info: (msg, data) => {
+        console.log(`[${new Date().toISOString()}] ℹ️  ${msg}`, data ? JSON.stringify(data) : '');
+    },
+    success: (msg, data) => {
+        console.log(`[${new Date().toISOString()}] ✅ ${msg}`, data ? JSON.stringify(data) : '');
+    },
+    warn: (msg, data) => {
+        console.warn(`[${new Date().toISOString()}] ⚠️  ${msg}`, data ? JSON.stringify(data) : '');
+    },
+    error: (msg, err) => {
+        console.error(`[${new Date().toISOString()}] ❌ ${msg}`, err ? JSON.stringify(err) : '');
+    },
+};
+// ============================================================================
+// API INTEGRATION
+// ============================================================================
+async function registerRunner() {
+    if (!config.pairingToken) {
+        logger.error('Pairing token não fornecido');
+        return false;
+    }
+    try {
+        logger.info('📝 Registrando runner com API...');
+        const os = require('os');
+        const platform = os.platform() === 'darwin' ? 'macos' : os.platform() === 'win32' ? 'windows' : 'linux';
+        const arch = os.arch() === 'arm64' ? 'arm64' : 'x64';
+        const hostname = os.hostname() || 'elon-runner';
+        const response = await fetch(`${config.serverUrl}/api/v1/runner-v3/register`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify({
+                pairing_token: config.pairingToken,
+                name: hostname,
+                os: platform,
+                arch: arch,
+                mode: config.mode || 'ui',
+                version: process.env.ELON_VERSION || '3.1.1',
+            }),
+        });
+        if (!response.ok) {
+            logger.error(`Falha ao registrar: ${response.status}`, await response.text());
+            return false;
+        }
+        const json = (await response.json());
+        logger.info('Register response: ' + JSON.stringify(json));
+        // API returns { success, data: { success, data: { runner_id, runner_token } } }
+        const data = json?.data?.data || json?.data || json;
+        logger.info('Parsed data: runner_id=' + data?.runner_id + ' runner_token=' + (data?.runner_token ? 'rt3_***' : 'MISSING'));
+        config.runnerId = data.runner_id;
+        config.runnerToken = data.runner_token;
+        logger.info('Config after register: runnerId=' + config.runnerId + ' hasToken=' + !!config.runnerToken);
+        config.pairingToken = undefined; // Remove após registrar
+        logger.success(`✅ Runner registrado — Runner ID: ${config.runnerId}`);
+        return true;
+    }
+    catch (error) {
+        logger.error('Erro ao registrar runner', error);
+        return false;
+    }
+}
+// Cache permissions — detect ONCE at startup, never re-trigger dialogs
+let cachedPermissions = null;
+let permissionsDetectedAt = 0;
+const PERM_CACHE_MS = 10 * 60 * 1000; // re-check every 10 min (file perms only, not screen)
+function detectPermissions() {
+    // Return cache if fresh
+    if (cachedPermissions && (Date.now() - permissionsDetectedAt < PERM_CACHE_MS)) {
+        return cachedPermissions;
+    }
+    const home = os.homedir();
+    const perms = {
+        desktop: false,
+        documents: false,
+        downloads: false,
+        screen_capture: cachedPermissions?.screen_capture ?? false, // never re-test screen capture
+        accessibility: cachedPermissions?.accessibility ?? false,
+        microphone: cachedPermissions?.microphone ?? false,
+    };
+    if (process.platform !== 'darwin') {
+        cachedPermissions = { desktop: true, documents: true, downloads: true, screen_capture: true, accessibility: true, microphone: true };
+        permissionsDetectedAt = Date.now();
+        return cachedPermissions;
+    }
+    // File access: try readdirSync on protected folders (safe — no dialog if already granted/denied)
+    const folderMap = {
+        'Desktop': 'desktop',
+        'Documents': 'documents',
+        'Downloads': 'downloads',
+    };
+    for (const [folder, key] of Object.entries(folderMap)) {
+        try {
+            const p = path.join(home, folder);
+            if (fs.existsSync(p)) {
+                fs.readdirSync(p);
+                perms[key] = true;
+            }
+        }
+        catch {
+            perms[key] = false;
+        }
+    }
+    // Screen capture & accessibility: ONLY detect ONCE at first call
+    // These trigger macOS permission dialogs, so never re-run
+    if (!cachedPermissions) {
+        // Accessibility: check via AppleScript
+        try {
+            const { execSync } = require('child_process');
+            execSync('osascript -e \'tell application "System Events" to get name of first process\'', { timeout: 3000, stdio: 'pipe' });
+            perms.accessibility = true;
+        }
+        catch {
+            perms.accessibility = false;
+        }
+        // Screen capture: DO NOT run screencapture — it triggers dialog every time if denied
+        // Instead just mark as unknown/false; actual status detected when user enables capture via dashboard
+        perms.screen_capture = false;
+        // Microphone: basic check (no dialog trigger)
+        try {
+            const { execSync } = require('child_process');
+            execSync('system_profiler SPAudioDataType 2>/dev/null | head -1', { timeout: 3000, stdio: 'pipe' });
+            perms.microphone = true;
+        }
+        catch {
+            perms.microphone = false;
+        }
+    }
+    cachedPermissions = perms;
+    permissionsDetectedAt = Date.now();
+    return perms;
+}
+async function sendHeartbeat() {
+    if (!config.runnerId || !config.runnerToken) {
+        logger.warn('Sem runner_id/token para heartbeat');
+        return;
+    }
+    try {
+        const openclawBin = findOpenClawBinary();
+        const permissions = detectPermissions();
+        const payload = {
+            status: 'online',
+            has_openclaw: !!openclawBin,
+            permissions,
+        };
+        const response = await fetch(`${config.serverUrl}/api/v1/runner-v3/poll/${config.runnerId}/heartbeat`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'Authorization': `Bearer ${config.runnerToken}`,
+            },
+            body: JSON.stringify(payload),
+        });
+        if (!response.ok) {
+            const errText = await response.text();
+            logger.error(`Heartbeat falhou (${response.status}): ${errText}`);
+        }
+        else {
+            logger.info('💓 Heartbeat enviado', { uptime: Math.round((Date.now() - startTime) / 1000) });
+        }
+    }
+    catch (error) {
+        logger.warn('Erro ao enviar heartbeat', error instanceof Error ? error.message : error);
+    }
+}
+async function pullJobs() {
+    if (!config.runnerId || !config.runnerToken) {
+        return [];
+    }
+    try {
+        const response = await fetch(`${config.serverUrl}/api/v1/runner-v3/poll/${config.runnerId}/pull`, {
+            method: 'GET',
+            headers: {
+                'Authorization': `Bearer ${config.runnerToken}`,
+            },
+        });
+        if (!response.ok) {
+            return [];
+        }
+        return (await response.json()).jobs || [];
+    }
+    catch (error) {
+        logger.warn('Erro ao pull jobs', error);
+        return [];
+    }
+}
+async function reportJobResult(jobId, result) {
+    if (!config.runnerId || !config.runnerToken) {
+        return;
+    }
+    try {
+        await fetch(`${config.serverUrl}/api/v1/runner-v3/poll/${config.runnerId}/report`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'Authorization': `Bearer ${config.runnerToken}`,
+            },
+            body: JSON.stringify({
+                job_id: jobId,
+                status: result.status,
+                output: result.output,
+                error: result.error,
+            }),
+        });
+        logger.success('📤 Job result reportado', { jobId, status: result.status });
+    }
+    catch (error) {
+        logger.error('Erro ao reportar job result', error);
+    }
+}
+// ============================================================================
+// JOB EXECUTION
+// ============================================================================
+async function executeJob(job) {
+    logger.info('🚀 Executando job', { jobId: job.id, command: job.command });
+    try {
+        const result = await executeCommand(job.command, job.args || []);
+        return {
+            status: 'completed',
+            output: result.stdout,
+            error: null,
+        };
+    }
+    catch (error) {
+        return {
+            status: 'failed',
+            output: '',
+            error: error.message || 'Unknown error',
+        };
+    }
+}
+function executeCommand(command, args) {
+    return new Promise((resolve, reject) => {
+        const proc = spawn(command, args, {
+            shell: process.env.SHELL || true,
+            stdio: 'pipe',
+            env: getShellEnv(),
+            cwd: os.homedir(),
+        });
+        let stdout = '';
+        let stderr = '';
+        proc.stdout?.on('data', (data) => {
+            stdout += data.toString();
+            process.stdout.write(data);
+        });
+        proc.stderr?.on('data', (data) => {
+            stderr += data.toString();
+            process.stderr.write(data);
+        });
+        proc.on('close', (code) => {
+            if (code === 0) {
+                resolve({ stdout, stderr });
+            }
+            else {
+                reject(new Error(`Command failed with code ${code}: ${stderr}`));
+            }
+        });
+        proc.on('error', (error) => {
+            reject(error);
+        });
+    });
+}
+// ============================================================================
+// SYSTEM INFO
+// ============================================================================
+function getPlatform() {
+    return process.platform; // 'darwin' (macOS), 'linux', 'win32' (Windows)
+}
+function getArch() {
+    return process.arch; // 'arm64', 'x64', etc
+}
+// ============================================================================
+// FILE SYNC
+// ============================================================================
+const SYNC_INTERVAL_MS = 60000; // every 60s
+const MAX_FILE_SIZE = 512 * 1024; // 512KB max per file
+const MAX_FILES_PER_PUSH = 100;
+let lastFileHashes = {};
+const IGNORE_PATTERNS = [
+    'node_modules', '.git', '.DS_Store', 'dist', 'build', '.next',
+    '__pycache__', '.venv', 'venv', '.env', 'secrets',
+    '.elon-runner', 'runner.log',
+];
+const TEXT_EXTENSIONS = new Set([
+    '.md', '.txt', '.ts', '.tsx', '.js', '.jsx', '.json', '.yaml', '.yml',
+    '.toml', '.html', '.css', '.scss', '.sh', '.bash', '.zsh', '.py',
+    '.rb', '.go', '.rs', '.sql', '.env.example', '.gitignore', '.cfg',
+    '.ini', '.conf', '.xml', '.csv', '.log', '.dockerfile', '.makefile',
+]);
+function shouldIgnore(name) {
+    return IGNORE_PATTERNS.some(p => name === p || name.startsWith('.'));
+}
+function isTextFile(filePath) {
+    const ext = path.extname(filePath).toLowerCase();
+    const base = path.basename(filePath).toLowerCase();
+    return TEXT_EXTENSIONS.has(ext) || base === 'dockerfile' || base === 'makefile' || base === '.gitignore';
+}
+function scanDir(dir, prefix = '') {
+    const results = [];
+    try {
+        const entries = fs.readdirSync(dir, { withFileTypes: true });
+        for (const entry of entries) {
+            if (shouldIgnore(entry.name))
+                continue;
+            const fullPath = path.join(dir, entry.name);
+            const relPath = prefix ? `${prefix}/${entry.name}` : entry.name;
+            if (entry.isDirectory()) {
+                results.push(...scanDir(fullPath, relPath));
+            }
+            else if (entry.isFile() && isTextFile(entry.name)) {
+                try {
+                    const stat = fs.statSync(fullPath);
+                    if (stat.size > MAX_FILE_SIZE)
+                        continue;
+                    const content = fs.readFileSync(fullPath, 'utf-8');
+                    results.push({ file_path: relPath, content, size_bytes: stat.size });
+                }
+                catch { }
+            }
+            if (results.length >= MAX_FILES_PER_PUSH * 2)
+                break;
+        }
+    }
+    catch { }
+    return results;
+}
+// ============================================================================
+// FILE ACCESS PERMISSIONS (macOS protected folders)
+// ============================================================================
+// Folders that require macOS TCC consent (triggers dialog once)
+const PROTECTED_FOLDERS = ['Desktop', 'Documents', 'Downloads'];
+// Non-protected folders — never trigger dialogs
+const SAFE_FOLDERS = ['Projects', 'Developer', 'dev', '.elon-runner'];
+// Cache: which protected folders the user granted access to
+const grantedFolders = new Set();
+let permissionsProbed = false;
+/**
+ * Probe protected folders ONCE at startup.
+ * Each folder triggers a macOS dialog if not yet consented.
+ * We try fs.readdirSync — if it works, user allowed it. If it throws, denied.
+ * This runs ONCE so the user sees each dialog only once (not on every sync).
+ */
+function probeFilePermissions() {
+    if (permissionsProbed)
+        return;
+    permissionsProbed = true;
+    const homeDir = os.homedir();
+    logger.info('📂 Solicitando permissões de arquivo (macOS)...');
+    for (const folder of PROTECTED_FOLDERS) {
+        const fullPath = path.join(homeDir, folder);
+        try {
+            if (!fs.existsSync(fullPath))
+                continue;
+            // This triggers the macOS permission dialog if not yet granted
+            fs.readdirSync(fullPath);
+            grantedFolders.add(fullPath);
+            logger.success(`📂 Acesso permitido: ~/${folder}`);
+        }
+        catch (err) {
+            logger.warn(`📂 Acesso negado ou inexistente: ~/${folder} — ${err.code || err.message}`);
+        }
+    }
+    // Safe folders — always add if they exist
+    for (const folder of SAFE_FOLDERS) {
+        const fullPath = path.join(homeDir, folder);
+        try {
+            if (fs.existsSync(fullPath) && fs.statSync(fullPath).isDirectory()) {
+                grantedFolders.add(fullPath);
+            }
+        }
+        catch { }
+    }
+    logger.info(`📂 Pastas acessíveis: ${grantedFolders.size}`, [...grantedFolders].map(p => path.basename(p)));
+}
+async function syncFiles() {
+    if (!config.runnerId || !config.runnerToken)
+        return;
+    try {
+        // Use only folders that were granted access during startup probe
+        const scanDirs = [...grantedFolders];
+        let allFiles = [];
+        for (const dir of scanDirs) {
+            const dirName = path.basename(dir);
+            const files = scanDir(dir, dirName);
+            allFiles.push(...files);
+            if (allFiles.length >= MAX_FILES_PER_PUSH * 2)
+                break;
+        }
+        // Filter to only changed files (hash check)
+        const changedFiles = [];
+        const newHashes = {};
+        for (const f of allFiles) {
+            const hash = crypto.createHash('md5').update(f.content).digest('hex');
+            newHashes[f.file_path] = hash;
+            if (lastFileHashes[f.file_path] !== hash) {
+                changedFiles.push(f);
+            }
+        }
+        lastFileHashes = newHashes;
+        if (changedFiles.length === 0)
+            return;
+        // Push in batches
+        const batch = changedFiles.slice(0, MAX_FILES_PER_PUSH);
+        const response = await fetch(`${config.serverUrl}/api/v1/runner-v3/poll/${config.runnerId}/push-files`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'Authorization': `Bearer ${config.runnerToken}`,
+            },
+            body: JSON.stringify({ files: batch }),
+        });
+        if (response.ok) {
+            const json = (await response.json());
+            logger.info(`📁 Files synced: ${json?.data?.files_synced || batch.length} files`);
+        }
+        else {
+            logger.warn(`File sync failed: ${response.status}`);
+        }
+    }
+    catch (error) {
+        logger.warn('File sync error', error instanceof Error ? error.message : error);
+    }
+}
+// ============================================================================
+// TERMINAL COMMAND EXECUTION
+// ============================================================================
+const TERMINAL_TIMEOUT_MS = 300000; // 5 min max per command
+// Build full PATH for macOS (Homebrew, nvm, etc)
+function getShellEnv() {
+    const home = os.homedir();
+    const existing = process.env.PATH || '/usr/bin:/bin';
+    const extraPaths = [
+        '/opt/homebrew/bin',
+        '/opt/homebrew/sbin',
+        '/usr/local/bin',
+        '/usr/local/sbin',
+        `${home}/.nvm/versions/node/current/bin`,
+        `${home}/.volta/bin`,
+        `${home}/.bun/bin`,
+    ];
+    return {
+        ...process.env,
+        PATH: [...extraPaths, existing].join(':'),
+        HOME: home,
+        USER: os.userInfo().username,
+        LANG: 'en_US.UTF-8',
+    };
+}
+async function executeTerminalCommand(cmd) {
+    logger.info(`🖥️ Executando comando terminal [${cmd.id}]`, { command: cmd.command });
+    const shellEnv = getShellEnv();
+    // Use user's default shell on macOS, fallback to /bin/sh
+    const userShell = process.env.SHELL || '/bin/zsh';
+    const isZsh = userShell.includes('zsh');
+    // Wrap command to source profile for full env
+    const wrappedCmd = isZsh
+        ? `source ~/.zshrc 2>/dev/null; ${cmd.command}`
+        : cmd.command;
+    const proc = spawn(wrappedCmd, [], {
+        shell: userShell,
+        cwd: cmd.cwd || os.homedir(),
+        stdio: 'pipe',
+        env: shellEnv,
+    });
+    let buffer = '';
+    let flushTimeout = null;
+    let done = false;
+    const flushBuffer = async (status, exitCode) => {
+        if (flushTimeout) {
+            clearTimeout(flushTimeout);
+            flushTimeout = null;
+        }
+        const chunk = buffer;
+        buffer = '';
+        try {
+            await fetch(`${config.serverUrl}/api/v1/runner-v3/poll/${config.runnerId}/terminal/output`, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'Authorization': `Bearer ${config.runnerToken}`,
+                },
+                body: JSON.stringify({
+                    command_id: cmd.id,
+                    output_chunk: chunk,
+                    status,
+                    exit_code: exitCode,
+                }),
+            });
+        }
+        catch { }
+    };
+    const scheduleFlush = () => {
+        if (flushTimeout)
+            return;
+        flushTimeout = setTimeout(async () => {
+            flushTimeout = null;
+            if (buffer.length > 0 && !done) {
+                await flushBuffer('running');
+            }
+        }, 500);
+    };
+    proc.stdout?.on('data', (data) => {
+        buffer += data.toString();
+        scheduleFlush();
+    });
+    proc.stderr?.on('data', (data) => {
+        buffer += data.toString();
+        scheduleFlush();
+    });
+    // Timeout kill
+    const killTimer = setTimeout(() => {
+        if (!done) {
+            logger.warn(`⏱️ Comando terminal atingiu timeout (${TERMINAL_TIMEOUT_MS}ms) [${cmd.id}]`);
+            proc.kill('SIGKILL');
+        }
+    }, TERMINAL_TIMEOUT_MS);
+    proc.on('close', async (code) => {
+        done = true;
+        clearTimeout(killTimer);
+        const exitCode = code ?? -1;
+        const status = exitCode === 0 ? 'completed' : 'error';
+        await flushBuffer(status, exitCode);
+        logger.info(`✅ Comando terminal finalizado [${cmd.id}]`, { exitCode, status });
+    });
+    proc.on('error', async (err) => {
+        done = true;
+        clearTimeout(killTimer);
+        buffer += `\n[Erro ao executar: ${err.message}]`;
+        await flushBuffer('error', -1);
+        logger.error(`❌ Erro ao executar comando terminal [${cmd.id}]`, err.message);
+    });
+}
+async function pollTerminalCommands() {
+    if (!config.runnerId || !config.runnerToken) {
+        logger.warn('🖥️ Terminal poll skipped: no runnerId/token');
+        return;
+    }
+    try {
+        const res = await fetch(`${config.serverUrl}/api/v1/runner-v3/poll/${config.runnerId}/terminal/pending`, {
+            headers: { 'Authorization': `Bearer ${config.runnerToken}` },
+        });
+        if (!res.ok)
+            return;
+        const data = (await res.json());
+        // API returns { success, data: { success, data: { commands } } } due to nested success() wrapper
+        const cmds = data?.data?.data?.commands || data?.data?.commands || data?.commands || [];
+        if (cmds.length > 0) {
+            logger.info(`🖥️ ${cmds.length} comando(s) terminal pendente(s)`);
+        }
+        for (const cmd of cmds) {
+            executeTerminalCommand(cmd).catch(() => { });
+        }
+    }
+    catch { }
+}
+// ============================================================================
+// SCREEN CAPTURE & UI CONTROL (macOS)
+// ============================================================================
+const SCREEN_CAPTURE_INTERVAL_MS = 2000; // Capture every 2s
+let screenCaptureActive = false;
+let screenCaptureInterval = null;
+let isCapturing = false;
+/**
+ * Capture screen on macOS using native screencapture command
+ */
+let screenPermissionGranted = false;
+let screenPermissionCheckedAt = 0;
+const SCREEN_PERMISSION_RECHECK_MS = 120000; // Re-check every 2 min
+/**
+ * Check screen recording permission WITHOUT triggering the system dialog.
+ * Uses CGPreflightScreenCaptureAccess() via Python — returns true/false silently.
+ */
+async function checkScreenPermission() {
+    try {
+        const { execSync } = await import('child_process');
+        const result = execSync(`python3 -c "import Quartz; print('1' if Quartz.CGPreflightScreenCaptureAccess() else '0')" 2>/dev/null`, { timeout: 5000, encoding: 'utf-8' }).trim();
+        return result === '1';
+    }
+    catch {
+        // Fallback: assume not granted
+        return false;
+    }
+}
+async function captureScreen() {
+    if (process.platform !== 'darwin')
+        return null;
+    // Check permission silently (no dialog) — cache result, re-check periodically
+    const now = Date.now();
+    if (!screenPermissionGranted || (now - screenPermissionCheckedAt > SCREEN_PERMISSION_RECHECK_MS)) {
+        screenPermissionGranted = await checkScreenPermission();
+        screenPermissionCheckedAt = now;
+        if (!screenPermissionGranted) {
+            // Only log once per check cycle
+            if (now - screenPermissionCheckedAt < 1000) {
+                logger.warn('📸 Gravação de tela não autorizada. Conceda em: Ajustes do Sistema → Privacidade → Gravação de Tela → Elon Tools');
+            }
+            return null;
+        }
+        else {
+            logger.success('📸 Permissão de gravação de tela OK');
+        }
+    }
+    if (!screenPermissionGranted)
+        return null;
+    const tmpFile = `/tmp/elon-screen-${Date.now()}.jpg`;
+    try {
+        const { execSync } = await import('child_process');
+        execSync(`screencapture -x -t jpg -C "${tmpFile}"`, { timeout: 5000, stdio: 'pipe' });
+        if (!fs.existsSync(tmpFile))
+            return null;
+        const data = fs.readFileSync(tmpFile);
+        fs.unlinkSync(tmpFile);
+        return data.length > 500 ? data : null;
+    }
+    catch (err) {
+        logger.warn('📸 Screen capture failed:', err.message);
+        // Permission might have been revoked
+        screenPermissionGranted = false;
+        try {
+            fs.unlinkSync(tmpFile);
+        }
+        catch { }
+        return null;
+    }
+}
+/**
+ * Upload captured frame to backend
+ */
+async function uploadFrame(frameData) {
+    try {
+        await fetch(`${config.serverUrl}/api/v1/runner-v3-ui/${config.runnerId}/ui/frame`, {
+            method: 'POST',
+            headers: {
+                'Authorization': `Bearer ${config.runnerToken}`,
+                'Content-Type': 'image/jpeg',
+            },
+            body: frameData,
+        });
+    }
+    catch { }
+}
+/**
+ * Screen capture loop — runs every 2s when in UI mode
+ */
+async function screenCaptureLoop() {
+    if (!config.runnerId || !config.runnerToken)
+        return;
+    if (isCapturing)
+        return;
+    isCapturing = true;
+    try {
+        const frame = await captureScreen();
+        if (frame && frame.length > 0) {
+            await uploadFrame(frame);
+        }
+    }
+    catch { }
+    isCapturing = false;
+}
+/**
+ * Execute a UI command (mouse/keyboard) on macOS
+ */
+async function executeUICommand(cmd) {
+    if (process.platform !== 'darwin') {
+        logger.warn(`🖱️ UI commands not supported on ${process.platform}`);
+        return;
+    }
+    const { execSync } = await import('child_process');
+    const d = cmd.data;
+    try {
+        switch (cmd.type) {
+            case 'mouse_move': {
+                const x = Number(d.x), y = Number(d.y);
+                // Use AppleScript for mouse move
+                execSync(`osascript -e 'tell application "System Events" to set position of mouse to {${x}, ${y}}'`, { timeout: 3000 });
+                break;
+            }
+            case 'click': {
+                const x = Number(d.x), y = Number(d.y);
+                execSync(`osascript -e '
+          do shell script "python3 -c \\"
+import Quartz
+evt = Quartz.CGEventCreateMouseEvent(None, Quartz.kCGEventMouseMoved, (${x}, ${y}), Quartz.kCGMouseButtonLeft)
+Quartz.CGEventPost(Quartz.kCGHIDEventTap, evt)
+import time; time.sleep(0.05)
+evt = Quartz.CGEventCreateMouseEvent(None, Quartz.kCGEventLeftMouseDown, (${x}, ${y}), Quartz.kCGMouseButtonLeft)
+Quartz.CGEventPost(Quartz.kCGHIDEventTap, evt)
+evt = Quartz.CGEventCreateMouseEvent(None, Quartz.kCGEventLeftMouseUp, (${x}, ${y}), Quartz.kCGMouseButtonLeft)
+Quartz.CGEventPost(Quartz.kCGHIDEventTap, evt)
+\\"'`, { timeout: 5000 });
+                break;
+            }
+            case 'double_click': {
+                const x = Number(d.x), y = Number(d.y);
+                execSync(`osascript -e '
+          do shell script "python3 -c \\"
+import Quartz
+for i in range(2):
+    evt = Quartz.CGEventCreateMouseEvent(None, Quartz.kCGEventLeftMouseDown, (${x}, ${y}), Quartz.kCGMouseButtonLeft)
+    Quartz.CGEventSetIntegerValueField(evt, Quartz.kCGMouseEventClickState, i+1)
+    Quartz.CGEventPost(Quartz.kCGHIDEventTap, evt)
+    evt = Quartz.CGEventCreateMouseEvent(None, Quartz.kCGEventLeftMouseUp, (${x}, ${y}), Quartz.kCGMouseButtonLeft)
+    Quartz.CGEventSetIntegerValueField(evt, Quartz.kCGMouseEventClickState, i+1)
+    Quartz.CGEventPost(Quartz.kCGHIDEventTap, evt)
+\\"'`, { timeout: 5000 });
+                break;
+            }
+            case 'right_click': {
+                const x = Number(d.x), y = Number(d.y);
+                execSync(`osascript -e '
+          do shell script "python3 -c \\"
+import Quartz
+evt = Quartz.CGEventCreateMouseEvent(None, Quartz.kCGEventMouseMoved, (${x}, ${y}), Quartz.kCGMouseButtonRight)
+Quartz.CGEventPost(Quartz.kCGHIDEventTap, evt)
+import time; time.sleep(0.05)
+evt = Quartz.CGEventCreateMouseEvent(None, Quartz.kCGEventRightMouseDown, (${x}, ${y}), Quartz.kCGMouseButtonRight)
+Quartz.CGEventPost(Quartz.kCGHIDEventTap, evt)
+evt = Quartz.CGEventCreateMouseEvent(None, Quartz.kCGEventRightMouseUp, (${x}, ${y}), Quartz.kCGMouseButtonRight)
+Quartz.CGEventPost(Quartz.kCGHIDEventTap, evt)
+\\"'`, { timeout: 5000 });
+                break;
+            }
+            case 'key_press': {
+                const key = String(d.key);
+                execSync(`osascript -e 'tell application "System Events" to keystroke "${key.replace(/"/g, '\\"')}"'`, { timeout: 3000 });
+                break;
+            }
+            case 'key_combo': {
+                const keys = d.keys || [];
+                // Map modifier names to AppleScript
+                const modMap = {
+                    'cmd': 'command down', 'command': 'command down',
+                    'ctrl': 'control down', 'control': 'control down',
+                    'alt': 'option down', 'option': 'option down',
+                    'shift': 'shift down',
+                };
+                const modifiers = keys.slice(0, -1).map(k => modMap[k.toLowerCase()] || '').filter(Boolean);
+                const finalKey = keys[keys.length - 1] || '';
+                if (modifiers.length > 0 && finalKey) {
+                    execSync(`osascript -e 'tell application "System Events" to keystroke "${finalKey}" using {${modifiers.join(', ')}}'`, { timeout: 3000 });
+                }
+                else if (finalKey) {
+                    execSync(`osascript -e 'tell application "System Events" to keystroke "${finalKey}"'`, { timeout: 3000 });
+                }
+                break;
+            }
+            case 'type_text': {
+                const text = String(d.text || '');
+                // Type text character by character via AppleScript
+                execSync(`osascript -e 'tell application "System Events" to keystroke "${text.replace(/\\/g, '\\\\').replace(/"/g, '\\"')}"'`, { timeout: 10000 });
+                break;
+            }
+            case 'scroll': {
+                const x = Number(d.x), y = Number(d.y), deltaY = Number(d.deltaY);
+                execSync(`osascript -e '
+          do shell script "python3 -c \\"
+import Quartz
+evt = Quartz.CGEventCreateScrollWheelEvent(None, Quartz.kCGScrollEventUnitLine, 1, ${deltaY > 0 ? -3 : 3})
+Quartz.CGEventPost(Quartz.kCGHIDEventTap, evt)
+\\"'`, { timeout: 3000 });
+                break;
+            }
+            case 'drag': {
+                const fromX = Number(d.fromX), fromY = Number(d.fromY);
+                const toX = Number(d.toX), toY = Number(d.toY);
+                execSync(`osascript -e '
+          do shell script "python3 -c \\"
+import Quartz, time
+evt = Quartz.CGEventCreateMouseEvent(None, Quartz.kCGEventLeftMouseDown, (${fromX}, ${fromY}), Quartz.kCGMouseButtonLeft)
+Quartz.CGEventPost(Quartz.kCGHIDEventTap, evt)
+time.sleep(0.1)
+steps = 10
+for i in range(1, steps+1):
+    x = ${fromX} + (${toX}-${fromX})*i/steps
+    y = ${fromY} + (${toY}-${fromY})*i/steps
+    evt = Quartz.CGEventCreateMouseEvent(None, Quartz.kCGEventLeftMouseDragged, (x, y), Quartz.kCGMouseButtonLeft)
+    Quartz.CGEventPost(Quartz.kCGHIDEventTap, evt)
+    time.sleep(0.02)
+evt = Quartz.CGEventCreateMouseEvent(None, Quartz.kCGEventLeftMouseUp, (${toX}, ${toY}), Quartz.kCGMouseButtonLeft)
+Quartz.CGEventPost(Quartz.kCGHIDEventTap, evt)
+\\"'`, { timeout: 10000 });
+                break;
+            }
+            case 'enable_screen_capture': {
+                if (!screenCaptureActive) {
+                    const hasPermission = await checkScreenPermission();
+                    if (hasPermission) {
+                        screenCaptureActive = true;
+                        screenCaptureInterval = setInterval(() => screenCaptureLoop().catch(() => { }), SCREEN_CAPTURE_INTERVAL_MS);
+                        logger.success('📸 Screen capture ATIVADO pelo dashboard');
+                    }
+                    else {
+                        logger.warn('📸 Permissão de gravação de tela não concedida. Conceda em: Ajustes do Sistema → Privacidade → Gravação de Tela → Elon Tools');
+                    }
+                }
+                break;
+            }
+            case 'disable_screen_capture': {
+                if (screenCaptureActive && screenCaptureInterval) {
+                    clearInterval(screenCaptureInterval);
+                    screenCaptureInterval = null;
+                    screenCaptureActive = false;
+                    logger.info('📸 Screen capture DESATIVADO pelo dashboard');
+                }
+                break;
+            }
+            default:
+                logger.warn(`🖱️ Unknown UI command type: ${cmd.type}`);
+        }
+        logger.info(`🖱️ UI command executed: ${cmd.type} [${cmd.id}]`);
+    }
+    catch (err) {
+        logger.error(`🖱️ UI command failed: ${cmd.type} [${cmd.id}]`, err.message);
+    }
+}
+/**
+ * Poll and execute UI commands from backend
+ */
+async function pollUICommands() {
+    if (!config.runnerId || !config.runnerToken)
+        return;
+    try {
+        const res = await fetch(`${config.serverUrl}/api/v1/runner-v3-ui/${config.runnerId}/ui/pull`, {
+            headers: { 'Authorization': `Bearer ${config.runnerToken}` },
+        });
+        if (!res.ok)
+            return;
+        const data = (await res.json());
+        const cmds = data?.commands || [];
+        for (const cmd of cmds) {
+            await executeUICommand(cmd);
+        }
+    }
+    catch { }
+}
+// ============================================================================
+// CHAT SYNC — Read OpenClaw JSONL + push to backend
+// ============================================================================
+const OPENCLAW_DATA_DIR = path.join(os.homedir(), '.openclaw');
+const CHAT_SYNC_INTERVAL_MS = 3000;
+let lastSyncedTimestamp = {}; // per session_key
+let chatSyncInitialDone = false;
+/**
+ * Find OpenClaw session JSONL files
+ */
+function findOpenClawSessions() {
+    const sessions = [];
+    // Standard OpenClaw paths:
+    // ~/.openclaw/agents/<agentId>/sessions/<sessionKey>/transcript.jsonl
+    // ~/.openclaw/agents/<agentId>/agent/config.yaml (for agent name)
+    const agentsDir = path.join(OPENCLAW_DATA_DIR, 'agents');
+    if (!fs.existsSync(agentsDir))
+        return sessions;
+    try {
+        const agentIds = fs.readdirSync(agentsDir).filter(d => {
+            try {
+                return fs.statSync(path.join(agentsDir, d)).isDirectory();
+            }
+            catch {
+                return false;
+            }
+        });
+        for (const agentId of agentIds) {
+            // Try to read agent name from config
+            let agentName = agentId;
+            try {
+                const configPath = path.join(agentsDir, agentId, 'agent', 'config.yaml');
+                if (fs.existsSync(configPath)) {
+                    const configContent = fs.readFileSync(configPath, 'utf-8');
+                    const nameMatch = configContent.match(/^name:\s*["']?([^"'\n]+)/m);
+                    if (nameMatch)
+                        agentName = nameMatch[1].trim();
+                }
+            }
+            catch { }
+            const sessionsDir = path.join(agentsDir, agentId, 'sessions');
+            if (!fs.existsSync(sessionsDir))
+                continue;
+            try {
+                const sessionDirs = fs.readdirSync(sessionsDir).filter(d => {
+                    try {
+                        return fs.statSync(path.join(sessionsDir, d)).isDirectory();
+                    }
+                    catch {
+                        return false;
+                    }
+                });
+                for (const sessionDir of sessionDirs) {
+                    // Look for transcript.jsonl or messages.jsonl
+                    const transcriptPath = path.join(sessionsDir, sessionDir, 'transcript.jsonl');
+                    const messagesPath = path.join(sessionsDir, sessionDir, 'messages.jsonl');
+                    const filePath = fs.existsSync(transcriptPath) ? transcriptPath : fs.existsSync(messagesPath) ? messagesPath : null;
+                    if (filePath) {
+                        const sessionKey = `agent:${agentId}:${sessionDir}`;
+                        sessions.push({ sessionKey, filePath, agentName });
+                    }
+                }
+            }
+            catch { }
+        }
+    }
+    catch { }
+    return sessions;
+}
+/**
+ * Parse JSONL file and extract messages
+ */
+function parseJSONLMessages(filePath, afterTimestamp) {
+    const messages = [];
+    try {
+        const content = fs.readFileSync(filePath, 'utf-8');
+        const lines = content.split('\n').filter(l => l.trim());
+        for (const line of lines) {
+            try {
+                const entry = JSON.parse(line);
+                // OpenClaw JSONL format: { role, content, timestamp, ... }
+                // Or: { type: "message", role, content, ... }
+                const role = entry.role || (entry.type === 'assistant' ? 'assistant' : entry.type === 'user' ? 'user' : null);
+                const content = entry.content || entry.text || entry.message || '';
+                const timestamp = entry.timestamp || entry.ts || entry.created_at || new Date().toISOString();
+                if (!role || !content)
+                    continue;
+                // Skip system/tool messages for chat display
+                if (role === 'system' || role === 'tool' || role === 'tool_call')
+                    continue;
+                // Filter by timestamp
+                if (afterTimestamp && timestamp <= afterTimestamp)
+                    continue;
+                messages.push({
+                    id: entry.id || `cm_${crypto.createHash('md5').update(line).digest('hex').slice(0, 16)}`,
+                    role,
+                    content: typeof content === 'string' ? content : JSON.stringify(content),
+                    timestamp,
+                });
+            }
+            catch { }
+        }
+    }
+    catch { }
+    return messages;
+}
+/**
+ * Sync chat messages from OpenClaw to backend
+ */
+async function syncChatMessages() {
+    if (!config.runnerId || !config.runnerToken)
+        return;
+    const sessions = findOpenClawSessions();
+    if (sessions.length === 0)
+        return;
+    for (const session of sessions) {
+        try {
+            const isFullSync = !chatSyncInitialDone;
+            const afterTs = lastSyncedTimestamp[session.sessionKey];
+            const messages = parseJSONLMessages(session.filePath, isFullSync ? undefined : afterTs);
+            if (messages.length === 0)
+                continue;
+            const response = await fetch(`${config.serverUrl}/api/v1/runner-v3/poll/${config.runnerId}/chat-sync`, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'Authorization': `Bearer ${config.runnerToken}`,
+                },
+                body: JSON.stringify({
+                    sessionKey: session.sessionKey,
+                    sessionId: session.sessionKey,
+                    agentName: session.agentName,
+                    messages,
+                    isFullSync,
+                }),
+            });
+            if (response.ok) {
+                // Update last synced timestamp
+                const lastMsg = messages[messages.length - 1];
+                if (lastMsg) {
+                    lastSyncedTimestamp[session.sessionKey] = lastMsg.timestamp;
+                }
+                if (messages.length > 0) {
+                    logger.info(`💬 Chat synced: ${session.sessionKey} (${messages.length} msgs, agent: ${session.agentName})`);
+                }
+            }
+            else {
+                logger.warn(`Chat sync failed for ${session.sessionKey}: ${response.status}`);
+            }
+        }
+        catch (err) {
+            logger.warn('Chat sync error', err instanceof Error ? err.message : err);
+        }
+    }
+    chatSyncInitialDone = true;
+}
+/**
+ * Poll pending chat messages from user → inject into OpenClaw
+ */
+async function pollChatPending() {
+    if (!config.runnerId || !config.runnerToken)
+        return;
+    try {
+        const response = await fetch(`${config.serverUrl}/api/v1/runner-v3/poll/${config.runnerId}/chat-pending`, {
+            headers: { 'Authorization': `Bearer ${config.runnerToken}` },
+        });
+        if (!response.ok)
+            return;
+        const json = (await response.json());
+        const messages = json?.data?.messages || [];
+        for (const msg of messages) {
+            try {
+                // Inject message into OpenClaw via CLI
+                // openclaw chat send --session <sessionKey> --message <content>
+                const sessionKey = msg.session_key || 'agent:main:main';
+                const content = msg.content || '';
+                if (!content)
+                    continue;
+                // Use openclaw CLI to inject the message
+                const openclawBin = findOpenClawBinary();
+                if (openclawBin) {
+                    const proc = spawn(openclawBin, ['chat', 'send', '--session', sessionKey, '--message', content], {
+                        env: getShellEnv(),
+                        timeout: 30000,
+                    });
+                    await new Promise((resolve) => {
+                        proc.on('close', () => resolve());
+                        proc.on('error', () => resolve());
+                    });
+                }
+                // Ack the message
+                await fetch(`${config.serverUrl}/api/v1/runner-v3/poll/${config.runnerId}/chat-ack`, {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json',
+                        'Authorization': `Bearer ${config.runnerToken}`,
+                    },
+                    body: JSON.stringify({ message_id: msg.id }),
+                });
+            }
+            catch { }
+        }
+    }
+    catch { }
+}
+/**
+ * Find openclaw binary in common paths
+ */
+function findOpenClawBinary() {
+    const candidates = [
+        '/opt/homebrew/bin/openclaw',
+        '/usr/local/bin/openclaw',
+        path.join(os.homedir(), '.nvm/versions/node', 'openclaw'),
+        path.join(os.homedir(), '.volta/bin/openclaw'),
+    ];
+    // Also check PATH
+    const pathDirs = (process.env.PATH || '').split(':');
+    for (const dir of pathDirs) {
+        candidates.push(path.join(dir, 'openclaw'));
+    }
+    for (const candidate of candidates) {
+        try {
+            if (fs.existsSync(candidate))
+                return candidate;
+        }
+        catch { }
+    }
+    return null;
+}
+// ============================================================================
+// MAIN LOOP
+// ============================================================================
+async function main() {
+    try {
+        parseArgs();
+        // 1. Register if needed
+        if (config.pairingToken && !config.runnerId) {
+            const registered = await registerRunner();
+            if (!registered) {
+                logger.error('Falha ao registrar runner, encerrando');
+                process.exit(1);
+            }
+        }
+        // 1.5. Probe file permissions (macOS protected folders — triggers dialogs ONCE)
+        if (process.platform === 'darwin') {
+            probeFilePermissions();
+        }
+        // 2. Start heartbeat loop (every 30s)
+        setInterval(() => {
+            sendHeartbeat().catch(() => { }); // Silent fail
+        }, 30000);
+        // Send first heartbeat immediately
+        await sendHeartbeat();
+        // 3. Start job polling loop (every 5s)
+        setInterval(async () => {
+            try {
+                const jobs = await pullJobs();
+                for (const job of jobs) {
+                    const result = await executeJob(job);
+                    await reportJobResult(job.id, result);
+                }
+            }
+            catch (error) {
+                logger.error('Erro no job loop', error);
+            }
+        }, 5000);
+        // Poll jobs immediately
+        const initialJobs = await pullJobs();
+        for (const job of initialJobs) {
+            const result = await executeJob(job);
+            await reportJobResult(job.id, result);
+        }
+        // 4. Start file sync (every 60s)
+        setTimeout(() => syncFiles().catch(() => { }), 5000); // first sync after 5s
+        setInterval(() => syncFiles().catch(() => { }), SYNC_INTERVAL_MS);
+        // 5. Terminal command polling (every 2s)
+        logger.info('🖥️ Iniciando terminal polling (2s interval)...');
+        setInterval(() => {
+            pollTerminalCommands().catch((err) => {
+                logger.error('Terminal poll error', err?.message || err);
+            });
+        }, 2000);
+        // First poll immediately
+        pollTerminalCommands().catch((err) => {
+            logger.error('Terminal first poll error', err?.message || err);
+        });
+        // 6. UI commands polling (UI mode only, macOS) — screen capture is OFF by default
+        // Screen capture only starts when user explicitly enables it via dashboard
+        if (config.mode === 'ui' && process.platform === 'darwin') {
+            logger.info('🖱️ Iniciando UI command polling (500ms interval)...');
+            logger.info('📸 Screen capture DESATIVADO por padrão — ative pelo dashboard quando necessário');
+            setInterval(() => pollUICommands().catch(() => { }), 500);
+        }
+        // 7. Chat sync — sync OpenClaw JSONL messages + poll pending (every 3s)
+        logger.info('💬 Iniciando chat sync (3s interval)...');
+        setInterval(() => {
+            syncChatMessages().catch(() => { });
+            pollChatPending().catch(() => { });
+        }, 3000);
+        // First sync after 2s
+        setTimeout(() => {
+            syncChatMessages().catch(() => { });
+            pollChatPending().catch(() => { });
+        }, 2000);
+        logger.success('🎯 Runner v3 operacional (com terminal + chat)');
+        // Keep process alive
+        process.on('SIGINT', () => {
+            logger.info('🛑 Encerrando runner...');
+            process.exit(0);
+        });
+        process.on('SIGTERM', () => {
+            logger.info('🛑 Encerrando runner (SIGTERM)...');
+            process.exit(0);
+        });
+    }
+    catch (error) {
+        logger.error('Erro fatal', error);
+        process.exit(1);
+    }
+}
+// ============================================================================
+// START
+// ============================================================================
+main().catch((error) => {
+    logger.error('Erro ao iniciar main', error);
+    process.exit(1);
+});
+//# sourceMappingURL=index.js.map