#!/usr/bin/env node /** * shell-tools — MCP-Server mit begrenzter Shell-/SSH-Faehigkeit fuer Jarvis. * * Design: * - ssh_host bindet mit einem **eingeschraenkten SSH-Schluessel** an den Host. * Der Schluessel erzwingt auf dem Host das Waechter-Skript * (command="..." in authorized_keys, root-eigentuemer). Der Waechter protokolliert * jeden Befehl nach /var/log/jarvis-ssh.log und blockt: Aenderungen am eigenen * Zugang/Schutz, global destruktive Befehle, Aenderungen an der Trading-Instanz * (ai-orchestrator-*, /mnt/disk1/Development-DATA/AI-Platform/openclaw/) und an * der eigenen Policy (…/openclaw-jarvis/config/openclaw.json, config/mcp/) sowie * destruktive Docker-Befehle. * * Ehrliche Grenze: Das ist Schutz vor Fehlern/Fluegelbruch, keine echte Sandbox. * Ein Bewusst/Boedwilliger Koennte mit root-Shell konstruierte Umgehungen bauen. * Deshalb: jede Ausfuehrung wird lokal (AUDIT_FILE) und hostseitig protokolliert. * * - exec_local fuehrt Befehle im Container (uid 1000, Workspace) aus. Der lokale * Schutz greift fuer die eigene Policy-Konfiguration (openclaw.json, mcp/), * ist aber nur eine Denylist (keine Sandbox). */ 'use strict'; const { spawn } = require('child_process'); const fs = require('fs'); const path = require('path'); const HOST = process.env.SSH_HOST || 'YOUR_SERVER_IP'; const USER = process.env.SSH_USER || 'root'; const KEY = process.env.SSH_KEY_FILE || '/home/node/.openclaw/ssh/id_ed25519'; const KHOSTS = process.env.SSH_KNOWN_HOSTS || '/home/node/.openclaw/ssh/known_hosts'; const AUDIT = process.env.AUDIT_FILE || '/home/node/.openclaw/workspaces/jarvis/.shell-audit.log'; const WORKSPACE = process.env.WORKSPACE || '/home/node/.openclaw/workspaces/jarvis'; const MAX_CHARS = 40000; function audit(entry) { try { fs.mkdirSync(path.dirname(AUDIT), { recursive: true }); fs.appendFileSync(AUDIT, JSON.stringify({ ts: new Date().toISOString(), ...entry }) + '\n'); } catch (e) { // Audit darf den Aufruf nicht unterbrechen. } } // ------------------------- Denylists (lokal, ergaenzend) ------------------------- const LOCAL_DESTRUCT = [ /mkfs/i, /wipefs/i, /blkdiscard/i, /dd[^\n]*of=\/dev\//i, /shutdown/i, /reboot/i, /poweroff/i, /(^|[[:space:]])(halt)([[:space:]]|$)/i, /rm\s+-[a-zA-Z]*r[a-zA-Z]*f\s+\//i, /systemctl\s+(stop|restart|mask|disable)/i, ]; const SELF_POLICY = [/openclaw-jarvis\/config\/openclaw\.json/i, /openclaw-jarvis\/config\/mcp\//i]; function blockedLocal(cmd) { if (!cmd || !cmd.trim()) return 'leerer Befehl'; if (LOCAL_DESTRUCT.some((re) => re.test(cmd))) return 'global destruktiv'; if (SELF_POLICY.some((re) => re.test(cmd))) return 'eigene Policy (openclaw.json/mcp) ist tabu'; return null; } // ------------------------- Gemeinsame Runner ------------------------- function run(args, opts) { return new Promise((resolve) => { const timeoutMs = opts.timeoutMs || 30000; const p = spawn(args[0], args.slice(1), { env: { ...process.env, LANG: 'C', LC_ALL: 'C' }, stdio: ['ignore', 'pipe', 'pipe'], }); let out = ''; let done = false; const finish = (code, extra) => { if (done) return; done = true; resolve({ code: code === null ? -1 : code, out: out.slice(0, MAX_CHARS), truncated: out.length > MAX_CHARS, ...extra }); }; const t = setTimeout(() => { try { p.kill('SIGKILL'); } catch (e) {} finish(-2, { error: `timeout nach ${timeoutMs} ms` }); }, timeoutMs + 2000); p.on('exit', (c, s) => { clearTimeout(t); finish(c === null ? (s && s.code) || -1 : c); }); p.on('error', (e) => { clearTimeout(t); finish(-1, { error: String(e.message || e) }); }); p.stdout.on('data', (d) => (out += d)); p.stderr.on('data', (d) => (out += d)); }); } async function execLocal(args) { const cmd = String((args && args.command) || '').trim(); const timeout = Math.min(60, Math.max(3, Number((args && args.timeout_seconds) || 30))) * 1000; const block = blockedLocal(cmd); if (block) { audit({ tool: 'exec_local', command: cmd, blocked: block }); return { isError: true, text: `exec_local VERWEIGERT (lokaler Schutz: ${block}). Aenderungen an der eigenen Konfiguration (openclaw.json, config/mcp/) und global destruktive Befehle sind nicht erlaubt.`, }; } const r = await run(['sh', '-c', cmd], { timeoutMs: timeout }); audit({ tool: 'exec_local', command: cmd, exit: r.code, ms: r.ms || 0, out_len: r.out.length, error: r.error || null }); const body = r.error ? `\n(FEHLER: ${r.error})` : ''; const out = (r.out || '').trim() || '(keine Ausgabe)'; return { text: `## exec_local (Container, uid 1000, Workspace)\n\n- Befehl: \`${cmd}\`\n- Exit-Code: ${r.code}${r.truncated ? ', Ausgabe gekuerzt' : ''}\n\n\`\`\`\n${out}${body}\n\`\`\``, isError: r.code !== 0, }; } async function sshHost(args) { const cmd = String((args && args.command) || '').trim(); const timeout = Math.min(60, Math.max(3, Number((args && args.timeout_seconds) || 30))) * 1000; if (!cmd) return { isError: true, text: 'ssh_host: Befehl fehlt.' }; const sshArgs = [ 'ssh', '-i', KEY, '-o', 'BatchMode=yes', '-o', 'StrictHostKeyChecking=accept-new', '-o', `UserKnownHostsFile=${KHOSTS}`, '-o', 'ConnectTimeout=8', '-o', 'LogLevel=ERROR', `${USER}@${HOST}`, cmd, ]; const r = await run(sshArgs, { timeoutMs: timeout }); audit({ tool: 'ssh_host', host: HOST, command: cmd, exit: r.code, ms: r.ms || 0, out_len: r.out.length, error: r.error || null, blocked: (r.out || '').match(/^VERWEIGERT/) ? true : null }); const out = (r.out || '').trim() || '(keine Ausgabe)'; let note = ''; if (/^VERWEIGERT/.test(out)) note = '\n> Der Host-Waechter hat diesen Befehl abgelehnt (Log: /var/log/jarvis-ssh.log).'; else if (r.error) note = `\n(FEHLER: ${r.error})`; return { text: `## ssh_host (${USER}@${HOST}, bewaucht & protokolliert)\n\n- Befehl: \`${cmd}\`\n- Exit-Code: ${r.code}${r.truncated ? ', Ausgabe gekuerzt' : ''}\n\n\`\`\`\n${out}\n\`\`\`${note}`, isError: r.code !== 0, }; } function shellAudit(args) { const n = Math.min(200, Math.max(1, Number((args && args.tail_lines) || 30))); let data = ''; try { data = fs.readFileSync(AUDIT, 'utf8'); } catch (e) { return { text: `## Shell-Audit\n\n_Keine Eintraege (${AUDIT} nicht vorhanden)_` }; } const lines = data.trim().split('\n').filter(Boolean); const tail = lines.slice(-n); const pretty = tail.map((l) => { try { const j = JSON.parse(l); return `[${j.ts}] ${j.tool} exit=${j.exit ?? '?'}${j.blocked ? ' BLOCKIERT(' + j.blocked + ')' : ''}: ${(j.command || '').slice(0, 300)}`; } catch (e) { return l; } }); return { text: `## Shell-Audit (letzte ${tail.length} von ${lines.length})\n\n${pretty.map((l) => '- ' + l).join('\n')}`, }; } const TOOLS = [ { name: 'ssh_host', description: 'Fuehrt einen Befehl als root auf dem Unraid-Host aus. Der Host-Waechter protokolliert alles und blockt Aenderungen an der Trading-Instanz (ai-orchestrator-*, …/AI-Platform/openclaw/), an der eigenen OpenClaw-Policy (…/openclaw-jarvis/config/openclaw.json und config/mcp/), global destruktive Befehle und destruktive Docker-Befehle. Lesen ist erlaubt (ls, cat, tail, grep, docker inspect/logs/stats, smartctl …).', inputSchema: { type: 'object', properties: { command: { type: 'string', description: 'Vollstaendiger Shell-Befehl, z.B. "uptime" oder "df -h /mnt/disk1".' }, timeout_seconds: { type: 'integer', description: 'Timeout 3-60 s (Standard 30).' }, }, required: ['command'], additionalProperties: false, }, }, { name: 'exec_local', description: 'Fuehrt einen Befehl im eigenen Container aus (uid 1000, Working-Dir = Workspace). Nuetztlich fuer node/curl/Datei-Proben. Aenderungen an openclaw.json und config/mcp/ sind lokal gesperrt.', inputSchema: { type: 'object', properties: { command: { type: 'string', description: 'Shell-Befehl im Container, z.B. "df -h /home/node" oder "node -e \"...\""' }, timeout_seconds: { type: 'integer', description: 'Timeout 3-60 s (Standard 30).' }, }, required: ['command'], additionalProperties: false, }, }, { name: 'shell_audit', description: 'Zeigt die letzten Eintraege der Shell-Ausfuehrungsprotokolle (lokal; hostseitig /var/log/jarvis-ssh.log per ssh_host lesbar).', inputSchema: { type: 'object', properties: { tail_lines: { type: 'integer', description: 'Anzahl der letzten Eintraege (1-200, Standard 30).' }, }, additionalProperties: false, }, }, ]; function reply(id, result) { process.stdout.write(JSON.stringify({ jsonrpc: '2.0', id, result }) + '\n'); } function replyError(id, code, message) { process.stdout.write(JSON.stringify({ jsonrpc: '2.0', id, error: { code, message } }) + '\n'); } let buf = ''; process.stdin.setEncoding('utf8'); process.stdin.on('data', (chunk) => { buf += chunk; let idx; while ((idx = buf.indexOf('\n')) >= 0) { const line = buf.slice(0, idx).trim(); buf = buf.slice(idx + 1); if (!line) continue; handle(line); } }); function handle(line) { let msg; try { msg = JSON.parse(line); } catch (e) { process.stdout.write(JSON.stringify({ jsonrpc: '2.0', id: null, error: { code: -32700, message: 'Parse error' } }) + '\n'); return; } const { id, method, params } = msg; if (method === 'notifications/initialized' || (id === undefined && method)) return; if (method === 'initialize') { reply(id, { protocolVersion: (params && params.protocolVersion) || '2024-11-05', capabilities: { tools: {} }, serverInfo: { name: 'shell-tools', version: '1.0.0' }, }); return; } if (method === 'ping') { reply(id, {}); return; } if (method === 'tools/list') { reply(id, { tools: TOOLS.map(({ name, description, inputSchema }) => { const destructive = name === 'ssh_host' || name === 'exec_local'; return { name, description, inputSchema, annotations: { title: name.replace(/_/g, ' '), readOnlyHint: !destructive, destructiveHint: destructive, idempotentHint: true, openWorldHint: true, }, }; }), }); return; } if (method === 'tools/call') { const name = params && params.name; const args = (params && params.arguments) || {}; const run = async () => { let out; if (name === 'ssh_host') out = await sshHost(args); else if (name === 'exec_local') out = await execLocal(args); else if (name === 'shell_audit') out = shellAudit(args); else return { text: `Unbekanntes Werkzeug: ${name}`, isError: true }; return { content: [{ type: 'text', text: out.text }], isError: Boolean(out.isError) }; }; run() .then((r) => reply(id, r)) .catch((e) => reply(id, { content: [{ type: 'text', text: String(e && e.message) }], isError: true })); return; } if (id !== undefined) replyError(id, -32601, `Method not found: ${method}`); }