#!/usr/bin/env node /** * memos — MCP-Server fuer die Memos-Instanz (http://YOUR_SERVER_IP:5230, v0.25.2). * * Zweck: Changelog-Pflege und Notizen auf der vom User betriebenen Memos-Plattform. * * Sicherheitsmodell: * - Feste Basis-URL aus MEMOS_URL (kein Host/Port aus Tool-Eingaben -> kein SSRF). * - Personal-Access-Token (JWT, nie-ablaufend) liegt in einer Datei (MEMOS_TOKEN_FILE, * uid 1000, Modus 600), nie im Config-Text; wird nie geloggt. * - Texte auf MAX_CHARS begrenzt, Timeouts hart. Loschen/Anlegen/Aendern sind klar * als Schreibwerkzeuge annotiert. */ 'use strict'; const http = require('http'); const fs = require('fs'); const TIMEOUT_MS = 8000; const MAX_CHARS = 50000; const MEMOS_BASE = process.env.MEMOS_URL || 'http://YOUR_SERVER_IP:5230'; const VIS = ['PUBLIC', 'PROTECTED', 'PRIVATE']; function readMemosToken() { const p = process.env.MEMOS_TOKEN_FILE; if (!p) return { error: 'MEMOS_TOKEN_FILE ist nicht gesetzt.' }; let st; try { st = fs.statSync(p); } catch (e) { return { error: `Token-Datei nicht lesbar: ${p}` }; } if ((st.mode & 0o077) !== 0) return { error: `Token-Datei ist nicht restriktiv berechtigt (Modus ${st.mode & 0o777}).` }; if (st.uid !== 1000) return { error: `Token-Datei gehoert uid ${st.uid}, erwartet 1000.` }; try { const t = fs.readFileSync(p, 'utf8').trim(); if (!t) return { error: 'Token-Datei ist leer.' }; return { token: t }; } catch (e) { return { error: 'Token-Datei konnte nicht gelesen werden.' }; } } function request(path, token, options) { return new Promise((resolve) => { const started = Date.now(); const method = (options && options.method) || 'GET'; const body = options && options.body; const headers = { Authorization: `Bearer ${token}`, ...(body ? { 'Content-Type': 'application/json' } : {}) }; const req = http.request(MEMOS_BASE + path, { timeout: TIMEOUT_MS, method, headers }, (res) => { let data = ''; let done = false; const finish = () => { if (done) return; done = true; let parsed = null; let parseError = null; if (data) { try { parsed = JSON.parse(data); } catch (e) { parseError = 'Antwort ist kein JSON'; } } resolve({ code: res.statusCode || 0, ms: Date.now() - started, parsed, parseError, body: data.slice(0, MAX_CHARS) }); }; res.on('data', (d) => { data += d; if (data.length > MAX_CHARS * 2) { res.destroy(); finish(); } }); res.on('end', finish); res.on('close', finish); res.on('error', finish); }); req.on('timeout', () => { req.destroy(); resolve({ code: 0, ms: Date.now() - started, parsed: null, parseError: 'timeout' }); }); req.on('error', (e) => resolve({ code: 0, ms: Date.now() - started, parsed: null, parseError: String(e.message || e) })); if (body) req.write(JSON.stringify(body)); req.end(); }); } function apiError(r, fallback) { let desc = fallback; if (r.parsed && typeof r.parsed === 'object') { const e = []; if (r.parsed.message) e.push(String(r.parsed.message)); if (r.parsed.code !== undefined) e.push(`code=${r.parsed.code}`); if (e.length) desc = e.join('; '); } if (!desc && r.parseError) desc = r.parseError; return desc; } function memoId(args) { let id = String(((args && args.id) || (args && args.name) || '')).trim(); return id.replace(/^memos\//, ''); } function fmtTime(iso) { if (!iso) return '-'; return String(iso).replace('T', ' ').replace('Z', 'U').slice(0, 16); } function fmtVisibility(v) { const s = String(v || '?').toLowerCase(); if (s === 'public') return 'oeffentlich'; if (s === 'private') return 'privat'; if (s === 'protected') return 'geschuetzt'; return String(v || '?'); } const TOOLS = [ { name: 'me', description: 'Zeigt, mit welchem Memos-Konto Jarvis schreibt (Username, Rolle ADMIN/NORMAL, Anzeigename, E-Mail). Lesend.', inputSchema: { type: 'object', properties: {}, additionalProperties: false }, }, { name: 'list_memos', description: 'Listet die neuesten Memos (Standard: 10, max. 100). Ausgabe als Tabelle mit ID, Zeit, Sichtbarkeit und Textanriss. Lesend.', inputSchema: { type: 'object', properties: { limit: { type: 'integer', description: 'Anzahl (1-100, Standard 10).' }, page_token: { type: 'string', description: 'Paginierung: nextPageToken aus einem frueheren Aufruf.' }, }, additionalProperties: false, }, }, { name: 'get_memo', description: 'Liefert ein einzelnes Memo im Volltext (Markdown), mit Sichtbarkeit, Erstell-/Aenderzeitpunkt und optionalen Struktur-Feldern. Lesend.', inputSchema: { type: 'object', properties: { id: { type: 'string', description: 'Memo-ID oder vollstaendiger Name, z.B. "memos/KB4xxxx" oder "KB4xxxx".' }, }, required: ['id'], additionalProperties: false, }, }, { name: 'search_memos', description: 'Durchsucht Memos nach einem Textfragment (Gross-/Kleinschreibung egal). Arbeitet ueber die letzten Seiten und filtert clientseitig. Lesend.', inputSchema: { type: 'object', properties: { text: { type: 'string', description: 'Suchtext (Substring im Inhalt).' }, limit: { type: 'integer', description: 'Scantiefe (Anzahl zu pruefender Memos, max. 500, Standard 100).' }, }, required: ['text'], additionalProperties: false, }, }, { name: 'create_memo', description: 'Legt ein neues Memo/Changelog-Notiz auf der Memos-Plattform an. Standard-Sichtbarkeit "PUBLIC" (Changelog). Liefert die neue Memo-ID.', inputSchema: { type: 'object', properties: { content: { type: 'string', description: 'Inhalt als Markdown. Tags koennen als "#name" oder "memos/name" geschrieben werden.' }, visibility: { type: 'string', enum: ['PUBLIC', 'PROTECTED', 'PRIVATE'], description: 'Sichtbarkeit (Standard PUBLIC).' }, }, required: ['content'], additionalProperties: false, }, }, { name: 'update_memo', description: 'Aendert Inhalt und/oder Sichtbarkeit eines bestehenden Memos (genaues AIP-updateMask). Liefert den neuen Zustand.', inputSchema: { type: 'object', properties: { id: { type: 'string', description: 'Memo-ID oder Name, z.B. "memos/KB4xxxx".' }, content: { type: 'string', description: 'Neuer Inhalt (Markdown).' }, visibility: { type: 'string', enum: ['PUBLIC', 'PROTECTED', 'PRIVATE'], description: 'Neue Sichtbarkeit.' }, }, required: ['id'], additionalProperties: false, }, }, { name: 'delete_memo', description: 'Loescht ein Memo dauerhaft (nur eigenes Konto, Rolle ADMIN/NORMAL). Vorsicht: nicht rueckgaengig. Liefert Bestaetigung oder Fehler.', inputSchema: { type: 'object', properties: { id: { type: 'string', description: 'Memo-ID oder Name, z.B. "memos/KB4xxxx".' }, }, required: ['id'], additionalProperties: false, }, }, ]; async function me() { const auth = readMemosToken(); if (auth.error) return { error: true, text: `Token nicht verfuegbar: ${auth.error}` }; const r = await request('/api/v1/auth/sessions/current', auth.token); if (r.code !== 200 || !r.parsed || !r.parsed.user) { return { error: true, text: `Identitaet nicht lesbar: HTTP ${r.code} (${apiError(r, '')})` }; } const u = r.parsed.user; const lines = [ '## Memos-Konto', '', `- Username: **${u.username || '?'}**`, `- Name: ${u.displayName || '-'}`, `- Rolle: ${u.role === 'ADMIN' ? 'Administrator' : u.role || '-'}`, `- E-Mail: ${u.email || '-'}`, `- Resource: ${u.name || '-'}`, `- Zustand: ${u.state || '-'}`, ]; return { error: false, text: lines.join('\n') }; } async function listMemos(args) { const auth = readMemosToken(); if (auth.error) return { error: true, text: `Token nicht verfuegbar: ${auth.error}` }; const limit = Math.min(100, Math.max(1, Number((args && args.limit) || 10))); const pt = (args && args.page_token) ? encodeURIComponent(String(args.page_token)) : ''; const r = await request(`/api/v1/memos?pageSize=${limit}${pt ? '&pageToken=' + pt : ''}`, auth.token); if (r.code !== 200 || !r.parsed) { return { error: true, text: `Liste nicht lesbar: HTTP ${r.code} (${apiError(r, '')})` }; } const memos = Array.isArray(r.parsed.memos) ? r.parsed.memos : []; const lines = [ '## Memos', '', `Angezeigt: ${memos.length}${r.parsed.nextPageToken ? ' (weitere Seiten vorhanden)' : ''}`, '', '| ID | Zeit | Sichtbarkeit | Inhalt (Anriss) |', '|---|---|---|---|', ]; for (const m of memos) { const id = String(m.name || '').replace(/^memos\//, ''); lines.push(`| ${id} | ${fmtTime(m.displayTime || m.createTime)} | ${fmtVisibility(m.visibility)} | ${String(m.content || '').replace(/\n+/g, ' ').slice(0, 80)} |`); } if (r.parsed.nextPageToken) lines.push('', `Naechste Seite: page_token=\`${r.parsed.nextPageToken}\``); return { error: false, text: lines.join('\n') }; } async function getMemo(args) { const auth = readMemosToken(); if (auth.error) return { error: true, text: `Token nicht verfuegbar: ${auth.error}` }; const id = memoId(args); if (!id) return { error: true, text: 'Memo-ID fehlt.' }; const r = await request(`/api/v1/memos/${encodeURIComponent(id)}`, auth.token); if (r.code !== 200 || !r.parsed) { return { error: true, text: `Memo ${id} nicht lesbar: HTTP ${r.code} (${apiError(r, '')})` }; } const m = r.parsed; const lines = [ `## Memo ${id}`, '', `- Sichtbarkeit: ${fmtVisibility(m.visibility)}`, `- Erstellt: ${fmtTime(m.createTime)}`, m.updateTime ? `- Geaendert: ${fmtTime(m.updateTime)}` : null, `- Angezeigt: ${fmtTime(m.displayTime)}`, m.creator ? `- Autor: ${m.creator}` : null, '', '### Inhalt', '', String(m.content || '(leer)').slice(0, MAX_CHARS), ].filter((l) => l !== null); return { error: false, text: lines.join('\n') }; } async function searchMemos(args) { const auth = readMemosToken(); if (auth.error) return { error: true, text: `Token nicht verfuegbar: ${auth.error}` }; const text = String((args && args.text) || '').trim().toLowerCase(); if (!text) return { error: true, text: 'Suchtext fehlt.' }; const scan = Math.min(500, Math.max(1, Number((args && args.limit) || 100))); const hits = []; let pageToken = ''; let fetched = 0; while (fetched < scan) { const size = Math.min(100, scan - fetched); const path = `/api/v1/memos?pageSize=${size}${pageToken ? '&pageToken=' + encodeURIComponent(pageToken) : ''}`; const r = await request(path, auth.token); if (r.code !== 200 || !r.parsed) { return { error: true, text: `Suche fehlgeschlagen: HTTP ${r.code} (${apiError(r, '')})` }; } const memos = Array.isArray(r.parsed.memos) ? r.parsed.memos : []; for (const m of memos) { if (String(m.content || '').toLowerCase().indexOf(text) >= 0) hits.push(m); } fetched += memos.length; pageToken = r.parsed.nextPageToken || ''; if (!pageToken) break; } const lines = ['## Suche: ' + (args.text) + '', '', `Gefunden: ${hits.length} Treffer (gescannt: ${fetched})`, '']; if (fetched > scan) lines.splice(1, 0, '', `(Scan auf ${scan} begrenzt, weitere Seiten moeglich)`, ''); if (hits.length) { lines.push('| ID | Zeit | Inhalt |', '|---|---|---|'); for (const m of hits.slice(0, 30)) { const id = String(m.name || '').replace(/^memos\//, ''); lines.push(`| ${id} | ${fmtTime(m.displayTime || m.createTime)} | ${String(m.content || '').replace(/\n+/g, ' ').slice(0, 100)} |`); } } return { error: false, text: lines.join('\n') }; } async function createMemo(args) { const auth = readMemosToken(); if (auth.error) return { error: true, text: `Token nicht verfuegbar: ${auth.error}` }; const content = String((args && args.content) || '').trim(); if (!content) return { error: true, text: 'Inhalt fehlt (content).' }; let vis = String((args && args.visibility) || 'PUBLIC').toUpperCase(); if (!VIS.includes(vis)) return { error: true, text: `Ungueltige Sichtbarkeit "${vis}". Erlaubt: ${VIS.join(', ')}.` }; const r = await request('/api/v1/memos', auth.token, { method: 'POST', body: { content, visibility: vis } }); if (r.code !== 200 || !r.parsed || !r.parsed.name) { return { error: true, text: `Anlegen fehlgeschlagen: HTTP ${r.code} (${apiError(r, '')})` }; } const id = String(r.parsed.name).replace(/^memos\//, ''); return { error: false, text: `## Memo angelegt\n\n- ID: ${id}\n- Sichtbarkeit: ${fmtVisibility(vis)}\n- Erstellt: ${fmtTime(r.parsed.createTime)}\n\nAbrufbar mit get_memo (id=${id}).`, }; } async function updateMemo(args) { const auth = readMemosToken(); if (auth.error) return { error: true, text: `Token nicht verfuegbar: ${auth.error}` }; const id = memoId(args); if (!id) return { error: true, text: 'Memo-ID fehlt.' }; const body = {}; const mask = []; if (args && args.content !== undefined) { body.content = String(args.content); mask.push('content'); } if (args && args.visibility !== undefined) { let vis = String(args.visibility).toUpperCase(); if (!VIS.includes(vis)) return { error: true, text: `Ungueltige Sichtbarkeit "${vis}".` }; body.visibility = vis; mask.push('visibility'); } if (!mask.length) return { error: true, text: 'Nichts zu aendern (content und/oder visibility angeben).' }; const r = await request(`/api/v1/memos/${encodeURIComponent(id)}?updateMask=${mask.join(',')}`, auth.token, { method: 'PATCH', body, }); if (r.code !== 200 || !r.parsed) { return { error: true, text: `Aendern fehlgeschlagen: HTTP ${r.code} (${apiError(r, '')})` }; } const m = r.parsed; return { error: false, text: `## Memo aktualisiert\n\n- ID: ${String(m.name || '').replace(/^memos\//, '')}\n- Sichtbarkeit: ${fmtVisibility(m.visibility)}\n- Geaendert: ${fmtTime(m.updateTime)}`.replace('## Memo aktualisiert\n\n- ID: \n', '## Memo aktualisiert\n\n- ID: ' + id + '\n'), }; } async function deleteMemo(args) { const auth = readMemosToken(); if (auth.error) return { error: true, text: `Token nicht verfuegbar: ${auth.error}` }; const id = memoId(args); if (!id) return { error: true, text: 'Memo-ID fehlt.' }; const r = await request(`/api/v1/memos/${encodeURIComponent(id)}`, auth.token, { method: 'DELETE' }); if (r.code !== 200 && r.code !== 204) { return { error: true, text: `Loeschen fehlgeschlagen: HTTP ${r.code} (${apiError(r, '')})` }; } return { error: false, text: `Memo ${id} geloescht.` }; } 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 toolAnnotations(name) { const write = ['create_memo', 'update_memo', 'delete_memo'].includes(name); return { title: name.replace(/_/g, ' '), readOnlyHint: !write, destructiveHint: name === 'delete_memo', idempotentHint: name === 'delete_memo' || name === 'update_memo', openWorldHint: true, }; } 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: 'memos', version: '1.0.0' }, }); return; } if (method === 'ping') { reply(id, {}); return; } if (method === 'tools/list') { reply(id, { tools: TOOLS.map(({ name, description, inputSchema }) => ({ name, description, inputSchema, annotations: toolAnnotations(name), })), }); return; } if (method === 'tools/call') { const name = params && params.name; const args = (params && params.arguments) || {}; const dispatch = { me: [false, () => me()], list_memos: [false, () => listMemos(args)], get_memo: [false, () => getMemo(args)], search_memos: [false, () => searchMemos(args)], create_memo: [false, () => createMemo(args)], update_memo: [false, () => updateMemo(args)], delete_memo: [false, () => deleteMemo(args)], }; const entry = dispatch[name]; if (!entry) { reply(id, { content: [{ type: 'text', text: `Unbekanntes Werkzeug: ${name}` }], isError: true }); return; } entry[1]() .then((r) => reply(id, { content: [{ type: 'text', text: r.text }], isError: Boolean(r.error) })) .catch((e) => reply(id, { content: [{ type: 'text', text: `Interner Fehler: ${e.message || e}` }], isError: true })); return; } replyError(id, -32601, 'Method not found'); }