@nibgat/aide 0.0.0-stage → 0.2.0

package/src/device.mjs

@@ -0,0 +1,488 @@
+/**
+ * Cihaz modu (terminal/OS yönetimi): bu makineyi Ai-de'ye cihaz olarak bağlar. Masaüstü uygulamasının çalıştırıcısıyla
+ * aynı protokol (`/ws/device`): sunucu personelin terminal ve dosya işlerini bu makinede, yalnızca çalışma klasöründe ve
+ * yazma/komut için kullanıcı onayıyla yürütür. Ekransız sunucularda `--approve-all` ile (bilerek) onaysız çalışır.
+ */
+import { exec, execFile } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+import path from 'node:path';
+import fs from 'node:fs';
+import os from 'node:os';
+import { settings, ask, AideError } from './client.mjs';
+import { c } from './ui.mjs';
+
+const MAX_OUTPUT = 20000;
+const IGNORED = new Set(['node_modules', '.git', 'dist', '.next', '__pycache__']);
+
+const jail = (workspaceDir, raw = '.') => {
+    const resolved = path.resolve(workspaceDir, String(raw || '.').replace(/^['"]|['"]$/g, ''));
+    const relative = path.relative(workspaceDir, resolved);
+
+    if(relative.startsWith('..') || path.isAbsolute(relative)) {
+        throw new Error(`"${raw}" çalışma klasörünün dışında; erişim engellendi.`);
+    }
+
+    return resolved;
+};
+
+const listDir = (dir, depth = 0, lines = []) => {
+    if(depth > 2 || lines.length > 300) {
+        return lines;
+    }
+
+    for(const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+        if(IGNORED.has(entry.name)) {
+            continue;
+        }
+
+        lines.push(`${'  '.repeat(depth)}${entry.isDirectory() ? '📁' : '📄'} ${entry.name}`);
+
+        if(entry.isDirectory()) {
+            listDir(path.join(dir, entry.name), depth + 1, lines);
+        }
+    }
+
+    return lines;
+};
+
+const searchFiles = (dir, needle, results = []) => {
+    for(const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+        if(IGNORED.has(entry.name) || results.length >= 50) {
+            continue;
+        }
+
+        const full = path.join(dir, entry.name);
+
+        if(entry.isDirectory()) {
+            searchFiles(full, needle, results);
+        } else if(fs.statSync(full).size < 1024 * 1024) {
+            fs.readFileSync(full, 'utf8').split('\n').forEach((line, index) => {
+                if(results.length < 50 && line.includes(needle)) {
+                    results.push(`${full}:${index + 1}: ${line.trim().slice(0, 160)}`);
+                }
+            });
+        }
+    }
+
+    return results;
+};
+
+const codeEditor = async (workspaceDir, args, approve) => {
+    const action = String(args.action || 'read').toLowerCase();
+    const target = jail(workspaceDir, args.path || args.filePath || args.dirPath || '.');
+
+    if(action === 'list') {
+        return listDir(target).join('\n') || '(boş klasör)';
+    }
+
+    if(action === 'read') {
+        return fs.readFileSync(target, 'utf8').slice(0, MAX_OUTPUT);
+    }
+
+    if(action === 'search' || action === 'find_files') {
+        return searchFiles(target, String(args.query || args.pattern || '')).join('\n') || 'Eşleşme yok.';
+    }
+
+    if(action === 'write' || action === 'edit') {
+        if(!(await approve(`Dosya ${action === 'write' ? 'yazılacak' : 'düzenlenecek'}: ${target}`))) {
+            throw new Error('Kullanıcı dosya işlemini onaylamadı.');
+        }
+
+        fs.mkdirSync(path.dirname(target), { recursive: true });
+
+        if(action === 'write') {
+            fs.writeFileSync(target, String(args.content ?? ''), 'utf8');
+
+            return `Yazıldı: ${target}`;
+        }
+
+        const current = fs.readFileSync(target, 'utf8');
+        const search = String(args.search ?? args.oldText ?? '');
+
+        if(!search || !current.includes(search)) {
+            throw new Error('Düzenlenecek metin dosyada bulunamadı.');
+        }
+
+        fs.writeFileSync(target, current.replace(search, String(args.replace ?? args.newText ?? '')), 'utf8');
+
+        return `Düzenlendi: ${target}`;
+    }
+
+    throw new Error(`Desteklenmeyen işlem: ${action}`);
+};
+
+const terminal = async (workspaceDir, args, approve) => {
+    const command = String(args.command || '').trim();
+
+    if(!command) {
+        throw new Error('Komut boş.');
+    }
+
+    const cwd = jail(workspaceDir, args.cwd || '.');
+
+    if(!(await approve(`Komut çalıştırılacak (${cwd}):\n  ${c.bold(command)}`))) {
+        throw new Error('Kullanıcı komutu onaylamadı.');
+    }
+
+    return new Promise((resolve) => {
+        exec(command, {
+            shell: process.platform === 'win32' ? 'powershell.exe' : '/bin/sh',
+            maxBuffer: 4 * 1024 * 1024,
+            windowsHide: true,
+            timeout: 120000,
+            cwd
+        }, (error, stdout, stderr) => {
+            const output = `${stdout || ''}${stderr ? `\n[stderr]\n${stderr}` : ''}`.slice(0, MAX_OUTPUT);
+
+            resolve(error && !stdout ? `Çıkış kodu ${error.code ?? '?'}: ${output || error.message}` : output || '(çıktı yok)');
+        });
+    });
+};
+
+/** Sistem durumu (salt okuma, onaysız): sunucudaki src/services/systemInfo.js ile aynı biçim. */
+const run = (file, args) => new Promise((resolve) => {
+    execFile(file, args, { timeout: 15000, maxBuffer: 2 * 1024 * 1024, windowsHide: true }, (error, stdout) => resolve(error ? '' : String(stdout || '')));
+});
+
+const gb = (bytes) => `${(bytes / 1073741824).toFixed(1)} GB`;
+
+const disks = async () => {
+    if(process.platform === 'win32') {
+        const json = await run('powershell.exe', ['-NoProfile', '-Command', 'Get-PSDrive -PSProvider FileSystem | Select-Object Name,Used,Free | ConvertTo-Json -Compress']);
+        try {
+            const rows = [].concat(JSON.parse(json || '[]'));
+            return rows.filter((row) => row.Used !== null && row.Free !== null).map((row) => `${row.Name}: ${gb(row.Used)} dolu / ${gb(row.Used + row.Free)} (%${Math.round(row.Used / (row.Used + row.Free) * 100)})`);
+        } catch {
+            return [];
+        }
+    }
+    const text = await run('df', ['-kP']);
+    return text.split('\n').slice(1).map((line) => line.trim().split(/\s+/)).filter((cols) => cols.length >= 6 && /^\//.test(cols[5]) && !/^\/(dev|run|sys|proc|snap)/.test(cols[5])).map((cols) => `${cols[5]}: ${gb(Number(cols[2]) * 1024)} dolu / ${gb(Number(cols[1]) * 1024)} (${cols[4]})`);
+};
+
+const topProcesses = async () => {
+    if(process.platform === 'win32') {
+        const json = await run('powershell.exe', ['-NoProfile', '-Command', 'Get-Process | Sort-Object WS -Descending | Select-Object -First 8 Name,Id,WS | ConvertTo-Json -Compress']);
+        try {
+            return [].concat(JSON.parse(json || '[]')).map((row) => `${row.Name} (PID ${row.Id}): ${gb(row.WS)}`);
+        } catch {
+            return [];
+        }
+    }
+    const text = await run('ps', process.platform === 'darwin' ? ['-axo', 'pid=,rss=,comm=', '-m'] : ['-eo', 'pid=,rss=,comm=', '--sort=-rss']);
+    return text.split('\n').filter(Boolean).slice(0, 8).map((line) => {
+        const [pid, rss, ...name] = line.trim().split(/\s+/);
+        return `${name.join(' ').split('/').pop()} (PID ${pid}): ${gb(Number(rss) * 1024)}`;
+    });
+};
+
+const systemInfo = async (label = 'Ai-de sunucusu') => {
+    const [diskLines, processLines] = await Promise.all([disks(), topProcesses()]);
+    const total = os.totalmem();
+    const free = os.freemem();
+    const hours = Math.round(os.uptime() / 3600);
+    return [
+        `${label}: ${os.hostname()} · ${os.type()} ${os.release()} (${os.arch()})`,
+        `CPU: ${os.cpus()[0]?.model || '?'} × ${os.cpus().length} · yük ${os.loadavg().map((value) => value.toFixed(2)).join(' / ')}`,
+        `Bellek: ${gb(total - free)} dolu / ${gb(total)} (%${Math.round((total - free) / total * 100)})`,
+        `Açık süre: ${hours >= 24 ? `${Math.floor(hours / 24)} gün ${hours % 24} saat` : `${hours} saat`}`,
+        `Diskler:\n${diskLines.map((line) => `- ${line}`).join('\n') || '- (okunamadı)'}`,
+        `En çok bellek kullanan süreçler:\n${processLines.map((line) => `- ${line}`).join('\n') || '- (okunamadı)'}`
+    ].join('\n');
+};
+
+/** Bağlı veri kaynağı köprüsü: @aide/connectors kuruluysa (repo içinde ya da yanında) yerel ağdaki veritabanlarını sorgular. */
+const loadConnectors = async () => {
+    try {
+        return await import('@aide/connectors/runtime');
+    } catch {
+        return null;
+    }
+};
+
+const webSocketClass = async () => {
+    if(typeof globalThis.WebSocket === 'function') {
+        return globalThis.WebSocket;
+    }
+
+    try {
+        return (await import('ws')).default;
+    } catch {
+        throw new AideError('Cihaz modu için Node 22+ (yerleşik WebSocket) ya da "ws" paketi gerekli.');
+    }
+};
+
+/**
+ * Cihazı bağlar ve işleri dinler. Onaylar sıralı sorulur (aynı anda iki soru ekrana düşmez).
+ * Bayraklar: --workspace <klasör> (varsayılan: bulunulan klasör), --approve-all, --read-only.
+ */
+const connectDevice = async (flags) => {
+    const { server, token } = settings(flags);
+
+    if(!server || !token) {
+        throw new AideError('Önce giriş yapın: aide login');
+    }
+
+    const workspaceDir = path.resolve(String(flags.workspace || process.cwd()));
+    const WebSocketImpl = await webSocketClass();
+    const connectors = await loadConnectors();
+    const tools = ['code_editor', 'terminal', 'system_info', ...(connectors ? ['data_query'] : [])];
+    let queue = Promise.resolve();
+    let stopped = false;
+
+    fs.mkdirSync(workspaceDir, { recursive: true });
+
+    // Onaylar sıraya girer; ekransız ortamda --approve-all yoksa yazma/komut reddedilir
+    const approve = (message) => {
+        const decision = queue.then(async () => {
+            if(flags['read-only']) {
+                return false;
+            }
+
+            if(flags['approve-all']) {
+                console.log(`${c.yellow('⚑')} ${message} ${c.dim('(otomatik onay)')}`);
+                return true;
+            }
+
+            if(!process.stdin.isTTY) {
+                return false;
+            }
+
+            return /^(e|evet|y|yes)$/i.test(await ask(`${c.yellow('?')} ${message}\n  Onaylıyor musunuz? (e/H) `));
+        });
+
+        queue = decision.catch(() => false);
+
+        return decision;
+    };
+
+    const handle = async (socket, message) => {
+        const summary = message.tool === 'terminal' ? String(message.args?.command || '') : `${message.args?.action || ''} ${message.args?.path || ''}`.trim();
+
+        console.log(`${c.accent('●')} ${c.bold(message.tool)} ${c.dim(summary.slice(0, 120))}`);
+
+        try {
+            const output = message.tool === 'terminal'
+                ? await terminal(workspaceDir, message.args || {}, approve)
+                : message.tool === 'system_info'
+                    ? await systemInfo(`Cihaz (${os.hostname()})`)
+                : message.tool === 'code_editor'
+                    ? await codeEditor(workspaceDir, message.args || {}, approve)
+                    : message.tool === 'data_query' && connectors
+                        ? await runDataQuery(connectors, message.args || {})
+                        : (() => {
+                            throw new Error(`Bu cihazda desteklenmeyen araç: ${message.tool}`);
+                        })();
+
+            socket.send(JSON.stringify({ type: 'result', id: message.id, ok: true, output }));
+            console.log(c.dim(`  ✓ tamamlandı (${String(output).length} karakter)`));
+        } catch (error) {
+            socket.send(JSON.stringify({ type: 'result', id: message.id, ok: false, output: error.message }));
+            console.log(c.red(`  ✗ ${error.message}`));
+        }
+    };
+
+    const connect = () => new Promise((resolve) => {
+        const url = `${server.replace(/^http/i, 'ws')}/ws/device?token=${encodeURIComponent(token)}`;
+        const socket = new WebSocketImpl(url);
+
+        socket.addEventListener('open', () => {
+            socket.send(JSON.stringify({ type: 'hello', deviceName: `${os.hostname()} (aide-cli)`, platform: `${process.platform}-${process.arch}`, workspaceDir, tools }));
+            console.log(`${c.green('✓')} Bağlandı: ${server} · klasör: ${workspaceDir} · araçlar: ${tools.join(', ')}${flags['approve-all'] ? c.yellow(' · ONAYSIZ MOD') : ''}`);
+        });
+        socket.addEventListener('message', (event) => {
+            try {
+                const message = JSON.parse(String(event.data));
+
+                if(message.type === 'invoke') {
+                    void handle(socket, message);
+                }
+            } catch {
+                // geçersiz mesaj
+            }
+        });
+        socket.addEventListener('close', () => resolve());
+        socket.addEventListener('error', () => null);
+    });
+
+    process.on('SIGINT', () => {
+        stopped = true;
+        console.log(c.dim('\nCihaz bağlantısı kapatıldı.'));
+        process.exit(0);
+    });
+
+    console.log(c.dim('Cihaz modu: personel bu makinede dosya/komut işleri yapabilir. Çıkış: Ctrl+C'));
+
+    while(!stopped) {
+        await connect();
+
+        if(!stopped) {
+            console.log(c.dim('Bağlantı koptu; 5 sn sonra yeniden denenecek…'));
+            await new Promise((resolve) => setTimeout(resolve, 5000));
+        }
+    }
+};
+
+const runDataQuery = async (runtime, args) => {
+    // Cihaz kullanıcının kendi ağındadır: yerel ağdaki REST API'lere erişim burada serbesttir (sunucuda SSRF koruması açık)
+    process.env.ALLOW_PRIVATE_DATASOURCE_URLS = 'true';
+    const driver = runtime.createDriver(args.config || {}, args.secrets || {});
+
+    if(args.op === 'test') {
+        await driver.test();
+
+        return JSON.stringify({ ok: true });
+    }
+
+    if(args.op === 'discover') {
+        return JSON.stringify(await driver.discover());
+    }
+
+    return JSON.stringify(await driver.query(runtime.validateIR(args.ir || {})));
+};
+
+// ─────────────────────────────── servis olarak kurulum ───────────────────────────────
+
+const SERVICE = 'aide-device';
+const MAC_LABEL = 'app.aide.device';
+const WIN_TASK = 'Ai-de Cihaz';
+
+const runQuiet = (file, args) => new Promise((resolve) => {
+    execFile(file, args, { timeout: 30000, windowsHide: true }, (error, stdout, stderr) => resolve({ ok: !error, output: String(stdout || stderr || error?.message || '').trim() }));
+});
+
+/** Servisin çalıştıracağı komut: node + bu CLI + device connect (ekransız: onay sorulamaz → varsayılan salt okuma). */
+const serviceCommand = (flags) => ({
+    script: fileURLToPath(new URL('../aide.mjs', import.meta.url)),
+    workspace: path.resolve(String(flags.workspace || process.cwd())),
+    mode: flags['approve-all'] ? '--approve-all' : '--read-only',
+    node: process.execPath
+});
+
+/** Platforma göre kurulum adımları: yazılacak dosyalar, çalıştırılacak komutlar, silinecekler. */
+const serviceSteps = (action, flags) => {
+    const { node, script, workspace, mode } = serviceCommand(flags);
+    const home = os.homedir();
+    const steps = [];
+
+    if(process.platform === 'linux') {
+        const unit = path.join(home, '.config', 'systemd', 'user', `${SERVICE}.service`);
+        const content = [
+            '[Unit]',
+            'Description=Ai-de cihaz çalıştırıcısı',
+            'After=network-online.target',
+            '',
+            '[Service]',
+            `ExecStart="${node}" "${script}" device connect --workspace "${workspace}" ${mode}`,
+            'Restart=always',
+            'RestartSec=10',
+            '',
+            '[Install]',
+            'WantedBy=default.target',
+            ''
+        ].join('\n');
+
+        if(action === 'install') {
+            steps.push({ write: unit, content }, { run: ['systemctl', ['--user', 'daemon-reload']] }, { run: ['systemctl', ['--user', 'enable', '--now', SERVICE]] });
+        } else if(action === 'uninstall') {
+            steps.push({ run: ['systemctl', ['--user', 'disable', '--now', SERVICE]], optional: true }, { remove: unit }, { run: ['systemctl', ['--user', 'daemon-reload']] });
+        } else {
+            steps.push({ run: ['systemctl', ['--user', 'is-active', SERVICE]] });
+        }
+    } else if(process.platform === 'darwin') {
+        const plist = path.join(home, 'Library', 'LaunchAgents', `${MAC_LABEL}.plist`);
+        const domain = `gui/${process.getuid?.() ?? 501}`;
+        const log = path.join(home, 'Library', 'Logs', 'aide-device.log');
+        const args = [node, script, 'device', 'connect', '--workspace', workspace, mode].map((item) => `        <string>${item}</string>`);
+        const content = [
+            '<?xml version="1.0" encoding="UTF-8"?>',
+            '<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">',
+            '<plist version="1.0">',
+            '<dict>',
+            `    <key>Label</key><string>${MAC_LABEL}</string>`,
+            '    <key>ProgramArguments</key>',
+            '    <array>',
+            ...args,
+            '    </array>',
+            '    <key>RunAtLoad</key><true/>',
+            '    <key>KeepAlive</key><true/>',
+            `    <key>StandardOutPath</key><string>${log}</string>`,
+            `    <key>StandardErrorPath</key><string>${log}</string>`,
+            '</dict>',
+            '</plist>',
+            ''
+        ].join('\n');
+
+        if(action === 'install') {
+            steps.push({ write: plist, content }, { run: ['launchctl', ['bootout', `${domain}/${MAC_LABEL}`]], optional: true }, { run: ['launchctl', ['bootstrap', domain, plist]] });
+        } else if(action === 'uninstall') {
+            steps.push({ run: ['launchctl', ['bootout', `${domain}/${MAC_LABEL}`]], optional: true }, { remove: plist });
+        } else {
+            steps.push({ run: ['launchctl', ['print', `${domain}/${MAC_LABEL}`]] });
+        }
+    } else if(process.platform === 'win32') {
+        // Gizli pencereli başlatıcı (wscript): oturum açılışında konsol penceresi açılmaz
+        const launcher = path.join(home, '.aide', 'aide-device.vbs');
+        const quoted = (value) => `""${value}""`;
+        const content = `CreateObject("WScript.Shell").Run "${quoted(node)} ${quoted(script)} device connect --workspace ${quoted(workspace)} ${mode}", 0, False\r\n`;
+
+        if(action === 'install') {
+            steps.push({ write: launcher, content }, { run: ['schtasks', ['/Create', '/TN', WIN_TASK, '/TR', `wscript.exe "${launcher}"`, '/SC', 'ONLOGON', '/RL', 'LIMITED', '/F']] }, { run: ['schtasks', ['/Run', '/TN', WIN_TASK]] });
+        } else if(action === 'uninstall') {
+            steps.push({ run: ['schtasks', ['/End', '/TN', WIN_TASK]], optional: true }, { run: ['schtasks', ['/Delete', '/TN', WIN_TASK, '/F']] }, { remove: launcher });
+        } else {
+            steps.push({ run: ['schtasks', ['/Query', '/TN', WIN_TASK]] });
+        }
+    } else {
+        throw new AideError(`Bu işletim sistemi için servis kurulumu yok (${process.platform}); aide device connect ile elle çalıştırın.`);
+    }
+
+    return { steps, mode, workspace };
+};
+
+/**
+ * `aide device install|uninstall|status`: açılışta kendiliğinden kalkan servis (Linux systemd kullanıcı servisi, macOS
+ * LaunchAgent, Windows oturum açılışı görevi). `--dry` yalnızca ne yapacağını gösterir.
+ */
+const manageService = async (action, flags) => {
+    const { steps, mode, workspace } = serviceSteps(action, flags);
+
+    if(action === 'install' && flags['approve-all']) {
+        console.log(c.yellow('⚑ ONAYSIZ MOD: personelin bu makinedeki dosya ve komut işleri onay sorulmadan yürür. Yalnızca güvendiğiniz sunucular için.'));
+    }
+
+    for(const step of steps) {
+        if(flags.dry) {
+            console.log(c.dim(step.write ? `yazılacak: ${step.write}\n${step.content.trim().split('\n').map((line) => `    ${line}`).join('\n')}` : step.remove ? `silinecek: ${step.remove}` : `çalıştırılacak: ${step.run[0]} ${step.run[1].join(' ')}`));
+            continue;
+        }
+
+        if(step.write) {
+            fs.mkdirSync(path.dirname(step.write), { recursive: true });
+            // wscript UTF-8 okumaz: Türkçe karakterli yollar (Masaüstü) için .vbs UTF-16LE + BOM yazılır
+            fs.writeFileSync(step.write, step.write.endsWith('.vbs') ? Buffer.from(`\ufeff${step.content}`, 'utf16le') : step.content, { mode: 0o600 });
+        } else if(step.remove) {
+            fs.rmSync(step.remove, { force: true });
+        } else {
+            const result = await runQuiet(step.run[0], step.run[1]);
+
+            if(action === 'status') {
+                console.log(result.ok ? result.output.split('\n').slice(0, 8).join('\n') : c.dim('Servis kurulu değil ya da çalışmıyor.'));
+                return;
+            }
+
+            if(!result.ok && !step.optional) {
+                throw new AideError(`${step.run[0]} başarısız: ${result.output.slice(0, 200)}`);
+            }
+        }
+    }
+
+    if(!flags.dry && action !== 'status') {
+        console.log(c.green(action === 'install' ? `✓ Servis kuruldu: açılışta kendiliğinden bağlanır (${mode === '--read-only' ? 'salt okuma' : 'onaysız'}, klasör: ${workspace}).` : '✓ Servis kaldırıldı.'));
+    }
+};
+
+export {
+    manageService,
+    connectDevice
+};