462 lines
18 KiB
JavaScript
462 lines
18 KiB
JavaScript
#!/usr/bin/env node
|
|
/**
|
|
* obsidian — MCP-Server fuer Self-hosted LiveSync (CouchDB) oben auf
|
|
* https://vpn.your-domain.com/obsidiannotes (Konto jarvis).
|
|
*
|
|
* Der Tresor ist Jarvis' Haupt-Dokumentationsbereich (Obsidian/Markdown). Der
|
|
* Server liest und schreibt direkt im CouchDB-Datenbankschema von
|
|
* Self-hosted LiveSync 1.0 (Protocol v2):
|
|
* - Eine Datei = ein Metadata-Dokument { path, ctime, mtime, size, eden,
|
|
* children, type: "plain" | "newnote" }, _id = klein-gefalteter Pfad.
|
|
* - Ihr Inhalt = ein oder mehrere Chunk-Dokumente { type: "leaf", data }.
|
|
* Bei type "plain" ist data literal (decode = direkt), bei "newnote"
|
|
* Base64 (decode = base64). children referenziert die Chunks in
|
|
* Reihenfolge; Konkatenieren ergibt den Dateiinhalt.
|
|
*
|
|
* Sicherheitsmodell:
|
|
* - Nur der dedizierte CouchDB-User jarvis (kein Admin). Zugangsdaten aus
|
|
* der Datei OBSIDIAN_PASSFILE (600, uid 1000) — nie im Config-Text.
|
|
* - TLS-Verifizierung wird bewusst NICHT deaktiviert (Zertifikat von
|
|
* vpn.your-domain.com wird normal geprueft; falls das Zert an Stelle der
|
|
* Einrichtung abweicht: OBSIDIAN_TLS_INSECURE=1 im Server-Env setzen).
|
|
* - create/update/delete nur als beabsichtigte Schreibzugriffe. Lesungen
|
|
* liefern keine geheimen Werte ausser Notizinhalt.
|
|
* - Session-/Zugangsdaten werden nie geloggt.
|
|
*/
|
|
'use strict';
|
|
|
|
const https = require('https');
|
|
const fs = require('fs');
|
|
const { pathToFileURL } = require('url');
|
|
|
|
const URL = (process.env.OBSIDIAN_COUCH_URL || 'https://vpn.your-domain.com').replace(/\/$/, '');
|
|
const DB = process.env.OBSIDIAN_COUCH_DB || 'obsidiannotes';
|
|
const PASSFILE = process.env.OBSIDIAN_PASSFILE || '/home/node/.openclaw/mcp/.couchpass';
|
|
const COMMONLIB = process.env.OBSIDIAN_COMMONLIB || '/home/node/.openclaw/obsidian-commonlib/node_modules/@vrtmrz/livesync-commonlib/dist/index.js';
|
|
const TLS_INSECURE = String(process.env.OBSIDIAN_TLS_INSECURE || '0') === '1';
|
|
const TIMEOUT_MS = 20000;
|
|
|
|
// stdout belongs exclusively to MCP JSON-RPC; Commonlib emits diagnostics via console.
|
|
console.log = () => {};
|
|
console.info = () => {};
|
|
console.debug = () => {};
|
|
|
|
let cachedAuth = null;
|
|
let manipulatorPromise = null;
|
|
|
|
function readAuth() {
|
|
if (cachedAuth) return cachedAuth;
|
|
let st;
|
|
try { st = fs.statSync(PASSFILE); } catch (e) { throw new Error(`Passwortdatei nicht lesbar: ${PASSFILE}`); }
|
|
if ((st.mode & 0o077) !== 0) throw new Error(`Passwortdatei nicht restriktiv (Modus ${st.mode & 0o777}).`);
|
|
if (st.uid !== 1000) throw new Error(`Passwortdatei gehoert uid ${st.uid}, erwartet 1000.`);
|
|
const t = fs.readFileSync(PASSFILE, 'utf8').trim();
|
|
const idx = t.indexOf(':');
|
|
if (idx <= 0) throw new Error('Passwortdatei hat ungueltiges Format (user:pass).');
|
|
cachedAuth = { user: t.slice(0, idx), pass: t.slice(idx + 1) };
|
|
return cachedAuth;
|
|
}
|
|
|
|
function request(method, path, body) {
|
|
return new Promise((resolve, reject) => {
|
|
const auth = readAuth();
|
|
const data = body === undefined ? undefined : JSON.stringify(body);
|
|
const timeout = setTimeout(() => { r.destroy(new Error('Timeout')); }, TIMEOUT_MS);
|
|
const r = https.request({
|
|
hostname: URL.replace(/^https:\/\//, ''),
|
|
port: 443,
|
|
path,
|
|
method,
|
|
rejectUnauthorized: !TLS_INSECURE,
|
|
headers: {
|
|
Authorization: 'Basic ' + Buffer.from(`${auth.user}:${auth.pass}`).toString('base64'),
|
|
Accept: 'application/json',
|
|
...(data ? { 'Content-Type': 'application/json', 'Content-Length': Buffer.byteLength(data) } : {}),
|
|
},
|
|
}, (res) => {
|
|
let s = '';
|
|
res.on('data', (c) => { s += c; });
|
|
res.on('end', () => {
|
|
clearTimeout(timeout);
|
|
let j = null;
|
|
try { j = JSON.parse(s); } catch (e) { /* non-JSON */ }
|
|
resolve({ status: res.statusCode, json: j });
|
|
});
|
|
});
|
|
r.on('error', (e) => { clearTimeout(timeout); reject(e); });
|
|
if (data) r.write(data);
|
|
r.end();
|
|
});
|
|
}
|
|
|
|
function enc(p) { return encodeURIComponent(p); }
|
|
|
|
async function getDoc(id) {
|
|
const r = await request('GET', `/${DB}/${enc(id)}`);
|
|
if (r.status === 404) return null;
|
|
if (r.status < 200 || r.status >= 300) throw new Error(`GET ${id}: ${r.status}`);
|
|
return r.json;
|
|
}
|
|
|
|
async function allDocs() {
|
|
const r = await request('GET', `/${DB}/_all_docs?include_docs=true`);
|
|
const rows = r.json && r.json.rows ? r.json.rows.map((x) => x.doc) : [];
|
|
return rows.filter((d) => d && d._id && !d._deleted);
|
|
}
|
|
|
|
function isFileMeta(d) {
|
|
return Boolean(d && d.path && !d._deleted && (d.type === 'plain' || d.type === 'newnote') && typeof d.children === 'object');
|
|
}
|
|
|
|
async function findMeta(path) {
|
|
const docs = await allDocs();
|
|
return docs.find((d) => isFileMeta(d) && d.path === path) ||
|
|
docs.find((d) => isFileMeta(d) && String(d.path).toLowerCase() === String(path).toLowerCase());
|
|
}
|
|
|
|
async function getManipulator() {
|
|
if (manipulatorPromise) return manipulatorPromise;
|
|
manipulatorPromise = (async () => {
|
|
const milestone = await request('GET', `/${DB}/${enc('_local/obsydian_livesync_milestone')}`);
|
|
const preferred = milestone.json && milestone.json.tweak_values && milestone.json.tweak_values.PREFERRED;
|
|
if (!preferred) throw new Error('LiveSync-PREFERRED-Einstellungen fehlen im Milestone-Dokument.');
|
|
if (preferred.encrypt || preferred.usePathObfuscation || preferred.enableCompression) {
|
|
throw new Error('Verschluesselung, Pfadverschleierung oder Kompression ist aktiv; Schreiben wird sicherheitshalber verweigert.');
|
|
}
|
|
const { DirectFileManipulator } = await import(pathToFileURL(COMMONLIB).href);
|
|
const auth = readAuth();
|
|
const client = new DirectFileManipulator({
|
|
url: URL,
|
|
username: auth.user,
|
|
password: auth.pass,
|
|
database: DB,
|
|
passphrase: undefined,
|
|
obfuscatePassphrase: undefined,
|
|
idDerivationVersion: preferred.idDerivationVersion ?? 0,
|
|
encryptInternalMetadata: preferred.encryptInternalMetadata ?? false,
|
|
useDynamicIterationCount: preferred.useDynamicIterationCount ?? false,
|
|
customChunkSize: preferred.customChunkSize ?? 0,
|
|
minimumChunkSize: preferred.minimumChunkSize ?? 20,
|
|
hashAlg: preferred.hashAlg || 'xxhash64',
|
|
useEden: preferred.useEden ?? false,
|
|
maxChunksInEden: preferred.maxChunksInEden ?? 10,
|
|
maxTotalLengthInEden: preferred.maxTotalLengthInEden ?? 1024,
|
|
maxAgeInEden: preferred.maxAgeInEden ?? 10,
|
|
enableCompression: false,
|
|
handleFilenameCaseSensitive: preferred.handleFilenameCaseSensitive ?? false,
|
|
chunkSplitterVersion: preferred.chunkSplitterVersion || 'v3-rabin-karp',
|
|
E2EEAlgorithm: preferred.E2EEAlgorithm || 'v2',
|
|
});
|
|
await client.ready.promise;
|
|
return client;
|
|
})();
|
|
return manipulatorPromise;
|
|
}
|
|
|
|
function fmtTime(ms) {
|
|
if (!ms) return '-';
|
|
return new Date(ms).toISOString().replace('T', ' ').replace('Z', 'UTC').slice(0, 19);
|
|
}
|
|
|
|
function fmtBytes(n) {
|
|
if (n >= 1024 * 1024) return (n / 1048576).toFixed(2) + ' MiB';
|
|
if (n >= 1024) return (n / 1024).toFixed(1) + ' KiB';
|
|
return n + ' B';
|
|
}
|
|
|
|
/* ---------- Werkzeuge ---------- */
|
|
|
|
async function status() {
|
|
const u = await request('GET', '/');
|
|
const db = await request('GET', `/${DB}`);
|
|
return {
|
|
error: false,
|
|
text: [
|
|
'## Obsidian / LiveSync (CouchDB)',
|
|
'',
|
|
`- Server: ${URL} (CouchDB ${u.json && u.json.version ? u.json.version : '?'})`,
|
|
`- Datenbank: ${DB} (Dokumente: ${db.json ? db.json.doc_count : '?'})`,
|
|
`- Konto: ${readAuth().user}`,
|
|
'',
|
|
'Haupt-Dokumentationsbereich (Jarvis) — Markdown-Notizen, syncen per LiveSync zu allen Obsidian-Geraeten.',
|
|
].join('\n'),
|
|
};
|
|
}
|
|
|
|
async function listNotes(args) {
|
|
const docs = await allDocs();
|
|
const files = docs.filter(isFileMeta)
|
|
.map((d) => ({ path: d.path, size: d.size || 0, mtime: d.mtime || 0, type: d.type === 'newnote' ? 'binar' : 'text', chunks: Array.isArray(d.children) ? d.children.length : 0 }))
|
|
.sort((a, b) => a.path.localeCompare(b.path));
|
|
const prefix = args && args.prefix ? String(args.prefix) : '';
|
|
const filtered = prefix ? files.filter((f) => f.path.toLowerCase().startsWith(prefix.toLowerCase())) : files;
|
|
const limit = Math.min(1000, Math.max(1, Number((args && args.limit) || 200)));
|
|
const shown = filtered.slice(0, limit);
|
|
const totalBytes = filtered.reduce((s, f) => s + (f.size || 0), 0);
|
|
const lines = [
|
|
'## Obsidian-Notizen',
|
|
'',
|
|
`Dateien: ${filtered.length} (${fmtBytes(totalBytes)})${filtered.length > shown.length ? ', angezeigt ' + shown.length : ''}`,
|
|
'',
|
|
'| Pfad | Groesse | Geaendert | Chunks |',
|
|
'|---|---|---|---|',
|
|
];
|
|
for (const f of shown) {
|
|
lines.push(`| ${f.path.replace(/\|/g, '\\|')} | ${fmtBytes(f.size)} | ${fmtTime(f.mtime)} | ${f.chunks} |`);
|
|
}
|
|
if (!shown.length) lines.push('| (keine Notizen) |');
|
|
return { error: false, text: lines.join('\n') };
|
|
}
|
|
|
|
async function readNote(args) {
|
|
const path = String((args && args.path) || '').trim();
|
|
if (!path) return { error: true, text: 'Pfad fehlt.' };
|
|
const meta = await findMeta(path);
|
|
if (!meta) return { error: true, text: `Notiz nicht gefunden: ${path}` };
|
|
const chunks = [];
|
|
for (const id of meta.children || []) {
|
|
const c = await getDoc(id);
|
|
if (!c) throw new Error(`Chunk ${id} von ${path} fehlt.`);
|
|
chunks.push(c.data || '');
|
|
}
|
|
let content = chunks.join('');
|
|
if (meta.type === 'newnote') content = Buffer.from(content, 'base64').toString('utf8');
|
|
if (content.length > 60000) content = content.slice(0, 60000) + '\n\n… (gekuerzt)';
|
|
return {
|
|
error: false,
|
|
text: [
|
|
`## ${path}`,
|
|
'',
|
|
`_${fmtTime(meta.mtime)}, ${fmtBytes(meta.size)}_`,
|
|
'',
|
|
content,
|
|
].join('\n'),
|
|
};
|
|
}
|
|
|
|
async function writeNote(args) {
|
|
const path = String((args && args.path) || '').trim();
|
|
const content = String((args && args.content) === undefined ? '' : args.content);
|
|
if (!path) return { error: true, text: 'Pfad fehlt (z. B. "Doku/Projekt.md").' };
|
|
if (!path.toLowerCase().endsWith('.md')) return { error: true, text: 'Schreiben ist auf Markdown-Notizen (.md) begrenzt.' };
|
|
const existing = await findMeta(path);
|
|
const now = Date.now();
|
|
const size = Buffer.byteLength(content, 'utf8');
|
|
const client = await getManipulator();
|
|
const ok = await client.put(path, new Blob([content], { type: 'text/plain' }), {
|
|
ctime: existing ? existing.ctime : now,
|
|
mtime: now,
|
|
size,
|
|
}, 'plain');
|
|
if (!ok) throw new Error(`LiveSync-Commonlib konnte ${path} nicht speichern.`);
|
|
const saved = await findMeta(path);
|
|
if (!saved) throw new Error(`Gespeicherte Metadata fuer ${path} nicht gefunden.`);
|
|
return {
|
|
error: false,
|
|
text: `## Gespeichert: ${path}\n\n- Dokument: ${saved._id}\n- Groesse: ${fmtBytes(size)} (${saved.children.length} Chunk(s))\n- Zeit: ${fmtTime(now)}\n- Writer: LiveSync Commonlib 0.1.36\n\n${content.length > 400 ? content.slice(0, 400) + '\n…' : content}`,
|
|
};
|
|
}
|
|
|
|
async function deleteNote(args) {
|
|
const path = String((args && args.path) || '').trim();
|
|
if (!path) return { error: true, text: 'Pfad fehlt.' };
|
|
const meta = await findMeta(path);
|
|
if (!meta) return { error: true, text: `Notiz nicht gefunden: ${path}` };
|
|
const client = await getManipulator();
|
|
const ok = await client.delete(path);
|
|
if (!ok) throw new Error(`LiveSync-Commonlib konnte ${path} nicht loeschen.`);
|
|
return { error: false, text: `## Geloescht: ${path}\n\n(LiveSync-konforme Loeschung ueber Commonlib; Chunks bleiben fuer Sync/GC erhalten.)` };
|
|
}
|
|
|
|
async function searchNotes(args) {
|
|
const text = String((args && args.text) || '').trim().toLowerCase();
|
|
const limit = Math.min(50, Math.max(1, Number((args && args.limit) || 10)));
|
|
if (!text) return { error: true, text: 'Suchtext fehlt.' };
|
|
const docs = await allDocs();
|
|
const files = docs.filter(isFileMeta);
|
|
const hits = [];
|
|
outer:
|
|
for (const meta of files) {
|
|
if (hits.length >= limit) break;
|
|
const chunks = [];
|
|
for (const id of meta.children || []) {
|
|
const c = await getDoc(id);
|
|
if (c) chunks.push(c.data || '');
|
|
}
|
|
let content = chunks.join('');
|
|
if (meta.type === 'newnote') content = Buffer.from(content, 'base64').toString('utf8');
|
|
const idx = content.toLowerCase().indexOf(text);
|
|
if (idx >= 0) {
|
|
const start = Math.max(0, idx - 60);
|
|
const snippet = (start > 0 ? '…' : '') + content.slice(start, idx + text.length + 120).replace(/\n+/g, ' ').replace(/\|/g, '\\|');
|
|
hits.push({ path: meta.path, snippet });
|
|
}
|
|
}
|
|
const lines = [
|
|
`## Suche: ${(args && args.text)}`,
|
|
'',
|
|
`Treffer: ${hits.length}${hits.length >= limit ? ' (Limit)' : ''}`,
|
|
'',
|
|
...hits.map((h) => `- **${h.path}**: ${h.snippet}`),
|
|
];
|
|
if (!hits.length) lines.push('(keine Treffer)');
|
|
return { error: false, text: lines.join('\n') };
|
|
}
|
|
|
|
const TOOLS = [
|
|
{
|
|
name: 'obsidian_status',
|
|
description: 'Zeigt Server- und Vaultzustand (CouchDB-Version, Datenbank, Dokumentanzahl, Konto). Lesend.',
|
|
inputSchema: { type: 'object', properties: {}, additionalProperties: false },
|
|
},
|
|
{
|
|
name: 'obsidian_list_notes',
|
|
description: 'Listet Obsidian-Notizen (Pfad, Groesse, Aenderungszeit, Chunk-Anzahl), optional gefiltert nach Pfad-Praefix. Lesend.',
|
|
inputSchema: {
|
|
type: 'object',
|
|
properties: {
|
|
prefix: { type: 'string', description: 'Nur Notizen unter diesem Pfad-Praefix, z. B. "Doku/".' },
|
|
limit: { type: 'integer', description: 'Max. Zeilen (1-1000, Standard 200).' },
|
|
},
|
|
additionalProperties: false,
|
|
},
|
|
},
|
|
{
|
|
name: 'obsidian_read_note',
|
|
description: 'Liest eine Obsidian-Notiz vollstaendig (Markdown) anhand ihres Pfads, z. B. "Projekt/X.md". Lesend.',
|
|
inputSchema: {
|
|
type: 'object',
|
|
properties: {
|
|
path: { type: 'string', description: 'Vault-Pfad der Notiz (inkl. .md).' },
|
|
},
|
|
required: ['path'],
|
|
additionalProperties: false,
|
|
},
|
|
},
|
|
{
|
|
name: 'obsidian_search_notes',
|
|
description: 'Durchsucht Notizinhalte nach einem Text (Gross-/Kleinschreibung egal) und liefert Pfad + Trefferschnipsel. Lesend.',
|
|
inputSchema: {
|
|
type: 'object',
|
|
properties: {
|
|
text: { type: 'string', description: 'Suchtext.' },
|
|
limit: { type: 'integer', description: 'Max. Treffer (1-50, Standard 10).' },
|
|
},
|
|
required: ['text'],
|
|
additionalProperties: false,
|
|
},
|
|
},
|
|
{
|
|
name: 'obsidian_write_note',
|
|
description:
|
|
'Legt eine Notiz an oder ueberschreibt sie (Markdown) unter dem angegebenen Pfad — Jarvis\' Haupt-Dokumentation. Inhalt wird als Chunk-Dokumente schema-konform im LiveSync-Vault gespeichert. SCHREIBEND.',
|
|
inputSchema: {
|
|
type: 'object',
|
|
properties: {
|
|
path: { type: 'string', description: 'Vault-Pfad, z. B. "Doku/Projekt.md".' },
|
|
content: { type: 'string', description: 'Markdown-Inhalt (ueberschreibt die Notiz).' },
|
|
},
|
|
required: ['path', 'content'],
|
|
additionalProperties: false,
|
|
},
|
|
},
|
|
{
|
|
name: 'obsidian_delete_note',
|
|
description: 'Loescht eine Obsidian-Notiz (Pfad). Vorher mit obsidian_read_note bestaetigen. SCHREIBEND, destruktiv.',
|
|
inputSchema: {
|
|
type: 'object',
|
|
properties: {
|
|
path: { type: 'string', description: 'Vault-Pfad der zu loeschenden Notiz.' },
|
|
},
|
|
required: ['path'],
|
|
additionalProperties: false,
|
|
},
|
|
},
|
|
];
|
|
|
|
/* ---------- MCP-Rahmen (wie bitwarden.js) ---------- */
|
|
|
|
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) {
|
|
replyError(null, -32700, 'Parse error');
|
|
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: 'obsidian', 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: {
|
|
title: name.replace(/_/g, ' '),
|
|
readOnlyHint: /^obsidian_(status|list_notes|read_note|search_notes)$/.test(name),
|
|
destructiveHint: name === 'obsidian_delete_note',
|
|
idempotentHint: name !== 'obsidian_delete_note',
|
|
openWorldHint: true,
|
|
},
|
|
})),
|
|
});
|
|
return;
|
|
}
|
|
if (method === 'tools/call') {
|
|
const name = params && params.name;
|
|
const args = (params && params.arguments) || {};
|
|
const dispatch = {
|
|
obsidian_status: () => status(),
|
|
obsidian_list_notes: () => listNotes(args),
|
|
obsidian_read_note: () => readNote(args),
|
|
obsidian_search_notes: () => searchNotes(args),
|
|
obsidian_write_note: () => writeNote(args),
|
|
obsidian_delete_note: () => deleteNote(args),
|
|
};
|
|
const fn = dispatch[name];
|
|
if (!fn) {
|
|
reply(id, { content: [{ type: 'text', text: `Unbekanntes oder nicht freigegebenes Werkzeug: ${name}` }], isError: true });
|
|
return;
|
|
}
|
|
fn()
|
|
.then((r) => {
|
|
if (r.error) reply(id, { content: [{ type: 'text', text: r.text }], isError: true });
|
|
else reply(id, { content: [{ type: 'text', text: r.text }], isError: false });
|
|
})
|
|
.catch((e) => reply(id, { content: [{ type: 'text', text: `Interner Fehler: ${e.message || e}` }], isError: true }));
|
|
return;
|
|
}
|
|
replyError(id, -32601, 'Method not found');
|
|
}
|