#!/usr/bin/env node /** * face — MCP-Server fuer Jarvis: Gesichtserkennung und Enrollment. * * Der Server ist ein duenner Client gegen den face-service (InsightFace, CPU): * FACE_URL Basis-URL des Dienstes (Standard http://face-service:8080). * * Zusaetzlich kann er selbst ein Standbild von Home-Assistant-Kameras holen * (HA_URL + HA_TOKEN_FILE) und dann direkt an den face-service schicken * (face_recognize_camera / face_enroll_camera) - so kann Jarvis eine Kamera * auswaehlen, ohne dass ein UI-Bild vorliegt. * * Bilder koennen als Dateipfad (image_path, z.B. aus camera_snapshot) ODER als * Base64 (image_base64) uebergeben werden. */ 'use strict'; const fs = require('fs'); const path = require('path'); const FACE_URL = (process.env.FACE_URL || 'http://face-service:8080').replace(/\/+$/, ''); const FACE_TIMEOUT_MS = Number(process.env.FACE_TIMEOUT_MS || 120000); const HA_URL = (process.env.HA_URL || 'http://YOUR_SERVER_IP:8123').replace(/\/+$/, ''); const HA_TOKEN_FILE = process.env.HA_TOKEN_FILE || '/home/node/.openclaw/mcp/.ha-token'; const SNAP_DIR = process.env.HA_SNAPSHOT_DIR || '/home/node/.openclaw/workspaces/jarvis/camera-snapshots'; function readHaToken() { try { const t = fs.readFileSync(HA_TOKEN_FILE, 'utf8').trim(); if (t) return t; } catch (e) {} return (process.env.HA_TOKEN || '').trim(); } async function faceFetch(pathname, opts, timeoutMs) { const res = await fetch(FACE_URL + pathname, { ...(opts || {}), headers: { 'Content-Type': 'application/json', ...((opts && opts.headers) || {}) }, signal: AbortSignal.timeout(timeoutMs || FACE_TIMEOUT_MS), }); return res; } async function faceJson(pathname, opts, timeoutMs) { let res; try { res = await faceFetch(pathname, opts, timeoutMs); } catch (e) { throw new Error(`face-service nicht erreichbar (${FACE_URL}${pathname}): ${(e && e.message) || e}`); } const body = await res.text(); let data = null; try { data = body ? JSON.parse(body) : {}; } catch (e) {} if (!res.ok) { const detail = (data && (data.detail || data.message)) || body || ''; throw new Error(`face-service ${pathname}: HTTP ${res.status}${detail ? ` - ${detail}` : ''}`); } return data || {}; } async function haSnapshot(entity) { const token = readHaToken(); if (!token) throw new Error(`HA-Zugriffstoken fehlt (${HA_TOKEN_FILE}).`); const res = await fetch(HA_URL + `/api/camera_proxy/${encodeURIComponent(entity)}`, { headers: { Authorization: `Bearer ${token}`, Accept: 'application/json' }, signal: AbortSignal.timeout(25000), }); if (!res.ok) throw new Error(`HA camera_proxy ${entity}: HTTP ${res.status}`); const buf = Buffer.from(await res.arrayBuffer()); if (buf.length < 200) throw new Error(`Kamera ${entity} liefert kein brauchbares Bild (${buf.length} B).`); let friendly = entity; try { const st = await fetch(HA_URL + `/api/states/${encodeURIComponent(entity)}`, { headers: { Authorization: `Bearer ${token}`, Accept: 'application/json' }, signal: AbortSignal.timeout(10000), }); if (st.ok) { const j = await st.json(); friendly = (j.attributes && j.attributes.friendly_name) || entity; } } catch (e) {} return { buf, friendly }; } function imageFromArgs(args) { const p = args && args.image_path ? String(args.image_path).trim() : ''; const b64 = args && args.image_base64 ? String(args.image_base64).trim() : ''; if (p) { if (!fs.existsSync(p)) throw new Error(`image_path existiert nicht: ${p}`); const buf = fs.readFileSync(p); return { b64: buf.toString('base64'), bytes: buf.length, source: `Datei ${p}` }; } if (b64) { const clean = b64.startsWith('data:') && b64.includes(',') ? b64.split(',', 1)[1] : b64; return { b64: clean, bytes: Math.floor((clean.length * 3) / 4), source: 'image_base64' }; } throw new Error('Bild fehlt: bitte image_path oder image_base64 angeben.'); } function fmtRecognize(data, context) { const lines = [`## Gesichtserkennung${context ? `: ${context}` : ''}`, '']; if (data.enrolled_people === 0) { lines.push('Es sind noch **keine Personen eingelernt**. Nutze `face_enroll`/`face_enroll_camera`, um jemanden zu speichern.'); return lines.join('\n'); } if (!data.count) { lines.push('Keine Gesichter im Bild erkannt.'); return lines.join('\n'); } data.faces.forEach((f, i) => { const label = f.matched ? `**${f.name}**` : 'unbekannt'; const sim = f.score === null || f.score === undefined ? 'nicht eingelernt' : `Ähnlichkeit ${f.score}`; lines.push(`- Gesicht ${i + 1}: ${label} (${sim}, Detektor ${f.det_score})`); }); const known = data.faces.filter((f) => f.matched).map((f) => f.name); if (known.length) lines.push('', `Erkannt: ${[...new Set(known)].join(', ')}.`); else lines.push('', 'Niemand aus der Datenbank erkannt.'); if (Array.isArray(data.auto_learned) && data.auto_learned.length) { lines.push(''); data.auto_learned.forEach((a) => { lines.push(`Dazugelernt: **${a.name}** (Ähnlichkeit ${a.score}) → jetzt ${a.total} Trainingsbild(er).`); }); } return lines.join('\n'); } // ---------------------------------------------------------------- tools async function faceList() { const data = await faceJson('/faces'); if (!data.count) return { text: '## Eingelernte Personen\n\nNoch keine Personen gespeichert. Mit `face_enroll` (Name + Bild) oder `face_enroll_camera` (Name + Kamera) anlegen.' }; const rows = data.faces.map((f) => `- **${f.name}** — ${f.samples} Bild(er), angelegt ${f.created || '?'}`).join('\n'); return { text: `## Eingelernte Personen (${data.count})\n\n${rows}` }; } async function faceRecognize(args) { const img = imageFromArgs(args); const auto = args && args.auto_learn !== undefined ? Boolean(args.auto_learn) : false; const data = await faceJson('/recognize', { method: 'POST', body: JSON.stringify({ image: img.b64, threshold: args && args.threshold, auto_learn: auto }) }); const text = fmtRecognize(data, img.source); return { text, content: [{ type: 'text', text }] }; } async function faceRecognizeCamera(args) { const entity = String((args && args.entity_id) || '').trim(); if (!/^camera\.[\w-]+$/.test(entity)) return { isError: true, text: `face_recognize_camera: ungueltige entity_id "${entity}".` }; const auto = args && args.auto_learn !== undefined ? Boolean(args.auto_learn) : true; const snap = await haSnapshot(entity); const data = await faceJson('/recognize', { method: 'POST', body: JSON.stringify({ image: snap.buf.toString('base64'), threshold: args && args.threshold, auto_learn: auto }) }); const text = fmtRecognize(data, `Kamera ${snap.friendly}`); const content = [{ type: 'text', text }]; if (args && args.as_image !== false) content.push({ type: 'image', data: snap.buf.toString('base64'), mimeType: 'image/jpeg' }); return { text, content }; } async function faceEnroll(args) { const name = String((args && args.name) || '').trim(); if (!name) return { isError: true, text: 'face_enroll: name fehlt.' }; const img = imageFromArgs(args); const data = await faceJson('/enroll', { method: 'POST', body: JSON.stringify({ name, image: img.b64 }) }); return { text: `## Gesicht gespeichert\n\n- Person: **${data.name}**\n- Gesamtbilder: ${data.total}\n- Detektor-Score: ${data.det_score}\n- Quelle: ${img.source}` }; } async function faceEnrollCamera(args) { const name = String((args && args.name) || '').trim(); const entity = String((args && args.entity_id) || '').trim(); if (!name) return { isError: true, text: 'face_enroll_camera: name fehlt.' }; if (!/^camera\.[\w-]+$/.test(entity)) return { isError: true, text: `face_enroll_camera: ungueltige entity_id "${entity}".` }; const snap = await haSnapshot(entity); const data = await faceJson('/enroll', { method: 'POST', body: JSON.stringify({ name, image: snap.buf.toString('base64') }) }); return { text: `## Gesicht gespeichert\n\n- Person: **${data.name}**\n- Kamera: ${snap.friendly} (\`${entity}\`)\n- Gesamtbilder: ${data.total}\n- Detektor-Score: ${data.det_score}` }; } async function faceDelete(args) { const name = String((args && args.name) || '').trim(); if (!name) return { isError: true, text: 'face_delete: name fehlt.' }; await faceJson(`/faces/${encodeURIComponent(name)}`, { method: 'DELETE' }); return { text: `Person **${name}** entfernt.` }; } const TOOLS = [ { name: 'face_list', description: 'Listet alle eingelernten Personen der Gesichtserkennung mit Anzahl der Bilder.', inputSchema: { type: 'object', properties: {}, additionalProperties: false }, }, { name: 'face_recognize', description: 'Erkennt Gesichter in einem Bild und vergleicht sie mit den eingelernten Personen. Quelle: image_path (Dateipfad, z.B. aus camera_snapshot) ODER image_base64.', inputSchema: { type: 'object', properties: { image_path: { type: 'string', description: 'Pfad zu einer Bilddatei im Container.' }, image_base64: { type: 'string', description: 'Bild als Base64 (JPEG/PNG).' }, threshold: { type: 'number', description: 'Optionale Kosinus-Schwelle (Standard aus dem Dienst, 0.38).' }, auto_learn: { type: 'boolean', description: 'Erkanntes Gesicht automatisch als Trainingsbild speichern (Standard false).' }, }, additionalProperties: false, }, }, { name: 'face_recognize_camera', description: 'Holt ein Standbild einer Home-Assistant-Kamera und erkennt darauf die Personen. Ideal fuer "Wer ist auf der Wohnzimmerkamera?".', inputSchema: { type: 'object', properties: { entity_id: { type: 'string', description: 'Kamera-Entity, z.B. "camera.lsc_smart_connect_1080p_ip_indoor_mini".' }, threshold: { type: 'number', description: 'Optionale Kosinus-Schwelle.' }, auto_learn: { type: 'boolean', description: 'Erkanntes Gesicht automatisch als Trainingsbild speichern, wenn Aehnlichkeit >= 0.60 (Standard true).' }, as_image: { type: 'boolean', description: 'Standbild mitliefern (Standard true).' }, }, required: ['entity_id'], additionalProperties: false, }, }, { name: 'face_enroll', description: 'Speichert ein neues Gesicht unter einem Namen. Quelle: image_path ODER image_base64. Erkennt das groesste Gesicht im Bild.', inputSchema: { type: 'object', properties: { name: { type: 'string', description: 'Name der Person, z.B. "Pascal".' }, image_path: { type: 'string', description: 'Pfad zu einer Bilddatei im Container.' }, image_base64: { type: 'string', description: 'Bild als Base64.' }, }, required: ['name'], additionalProperties: false, }, }, { name: 'face_enroll_camera', description: 'Speichert eine Person ein, indem ein frisches Standbild einer Home-Assistant-Kamera aufgenommen wird. Wenn keine Kamera genannt ist, zuerst camera_list aufrufen.', inputSchema: { type: 'object', properties: { name: { type: 'string', description: 'Name der Person.' }, entity_id: { type: 'string', description: 'Kamera-Entity, z.B. "camera.lsc_smart_connect_1080p_ip_indoor_mini".' }, }, required: ['name', 'entity_id'], additionalProperties: false, }, }, { name: 'face_delete', description: 'Entfernt eine eingelernte Person samt Bildern.', inputSchema: { type: 'object', properties: { name: { type: 'string', description: 'Name der Person.' } }, required: ['name'], 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: 'face', version: '1.1.0' }, }); return; } if (method === 'ping') { reply(id, {}); return; } if (method === 'tools/list') { reply(id, { tools: TOOLS.map(({ name, description, inputSchema }) => ({ name, description, inputSchema, annotations: { title: name.replace(/_/g, ' '), readOnlyHint: name === 'face_list' || name === 'face_recognize', destructiveHint: name === 'face_delete', idempotentHint: false, openWorldHint: true }, })), }); return; } if (method === 'tools/call') { const name = params && params.name; const args = (params && params.arguments) || {}; const run = async () => { if (name === 'face_list') return await faceList(); if (name === 'face_recognize') return await faceRecognize(args); if (name === 'face_recognize_camera') return await faceRecognizeCamera(args); if (name === 'face_enroll') return await faceEnroll(args); if (name === 'face_enroll_camera') return await faceEnrollCamera(args); if (name === 'face_delete') return await faceDelete(args); return { isError: true, text: `Unbekanntes Werkzeug: ${name}` }; }; run() .then((r) => { const content = r.content || [{ type: 'text', text: r.text }]; reply(id, { content, isError: Boolean(r.isError) }); }) .catch((e) => reply(id, { content: [{ type: 'text', text: String((e && e.message) || e) }], isError: true })); return; } if (id !== undefined) replyError(id, -32601, `Method not found: ${method}`); }