Initial commit: Clean OpenClaw Jarvis Open-Source Template

This commit is contained in:
jarvis-bot committed 2026-11-06 21:59:47 +00:00
commit ac4601b257
28 files changed
+7718

No files matched your search

+468
View File
@@ -0,0 +1,468 @@
#!/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');
}