Initial commit: Clean OpenClaw Jarvis Open-Source Template
This commit is contained in:
commit
ac4601b257
28 files changed
+7718
No files matched your search
+468
@@ -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');
|
||||
}
|
||||
Reference in new issue
Block a user