Files

337 lines
14 KiB
JavaScript

#!/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}`);
}