knowmind 0.3.6 → 0.3.8
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/CHANGELOG.md +286 -273
- package/README.de.md +231 -207
- package/README.md +229 -207
- package/package.json +63 -63
- package/scripts/registry-fassung-vorhanden.mjs +92 -0
- package/scripts/tools-abgleich.mjs +66 -66
- package/src/client.js +143 -143
- package/src/init.js +831 -831
- package/src/install.js +371 -371
- package/src/mcp-starter.py +119 -119
- package/src/mcp-stdio.js +387 -387
- package/src/tools-fallback.json +657 -466
package/src/mcp-stdio.js
CHANGED
|
@@ -1,387 +1,387 @@
|
|
|
1
|
-
/**
|
|
2
|
-
* Lokaler MCP-Stdio-Server — dünner Proxy auf die Knowmind-Plattform.
|
|
3
|
-
*
|
|
4
|
-
* Forwarded JSON-RPC-Requests von stdin an den Remote-MCP-Endpoint
|
|
5
|
-
* (POST {apiUrl}/api/mcp/v1) und schreibt die Antworten auf stdout. Damit kann
|
|
6
|
-
* Knowmind in jeden lokalen MCP-fähigen Client (Claude Code, Claude Desktop,
|
|
7
|
-
* ChatGPT, Cursor, ...) eingebunden werden, ohne dass der Client Bearer-Token
|
|
8
|
-
* kennen muss — der CLI-Wrapper verwaltet die Auth.
|
|
9
|
-
*
|
|
10
|
-
* DESIGN: Seit 0.1.18 ist dieser Server ein reiner Proxy. Tool-Definitionen,
|
|
11
|
-
* Namen (knowmind_recall, knowmind_store_memory, ...), Schemas und
|
|
12
|
-
* Safety-Annotations kommen direkt vom Server (tools/list wird durchgereicht).
|
|
13
|
-
* Dadurch können lokale Definitionen nie mehr vom Server-Stand abweichen —
|
|
14
|
-
* genau diese Abweichung (Punkt- vs. Unterstrich-Namen) hatte 0.1.17 unbrauchbar
|
|
15
|
-
* gemacht, nachdem die Plattform auf das MCP-Namensschema umgestellt wurde.
|
|
16
|
-
*
|
|
17
|
-
* Seit 0.1.20 wird auch `initialize` an den Server durchgereicht, damit die
|
|
18
|
-
* serverseitigen `instructions` (der client-übergreifende Pflege-Hebel) und die
|
|
19
|
-
* tatsächlichen serverInfo/capabilities den Client erreichen. Bei Server-
|
|
20
|
-
* Fehler/Offline fällt der Proxy auf einen lokalen Default zurück.
|
|
21
|
-
*
|
|
22
|
-
* Seit 0.1.22 gibt es einen DISCOVERY-MODUS: Ist KEIN Token konfiguriert,
|
|
23
|
-
* beantwortet der Proxy `initialize`, `tools/list` und `prompts/list` über die
|
|
24
|
-
* ÖFFENTLICHE Server-Discovery (GET {apiUrl}/api/mcp/v1 — liefert Name, Version
|
|
25
|
-
* und alle Tool-Definitionen ohne Auth). Damit funktioniert Introspection
|
|
26
|
-
* (z. B. Verzeichnis-Crawler wie Glama) ohne Account; erst `tools/call`
|
|
27
|
-
* verlangt einen Token und verweist klar auf `knowmind login`. Ein
|
|
28
|
-
* konfigurierter, aber UNGÜLTIGER Token führt weiterhin zum harten
|
|
29
|
-
* Verbindungsfehler, damit MCP-Clients nicht fälschlich „connected" anzeigen.
|
|
30
|
-
*
|
|
31
|
-
* Protokoll: stdio mit zeilenweise JSON (NDJSON-Style). Jedes Frame ist ein
|
|
32
|
-
* vollständiges JSON-RPC-Objekt.
|
|
33
|
-
*/
|
|
34
|
-
import { readFileSync } from "node:fs";
|
|
35
|
-
import { loadConfig, VERSION } from "./config.js";
|
|
36
|
-
import { createInterface } from "node:readline";
|
|
37
|
-
|
|
38
|
-
/** Methoden, die lokal beantwortet werden (alles andere geht an den Server). */
|
|
39
|
-
const LOCAL_METHODS = new Set(["initialize", "ping"]);
|
|
40
|
-
|
|
41
|
-
/**
|
|
42
|
-
* Lokaler Fallback-result für `initialize`, falls der Server nicht erreichbar
|
|
43
|
-
* ist oder keine verwertbare Antwort liefert. Hält den Proxy offline-robust.
|
|
44
|
-
* Die serverInfo.version stammt aus der package.json (VERSION).
|
|
45
|
-
*/
|
|
46
|
-
function localInitializeResult() {
|
|
47
|
-
return {
|
|
48
|
-
protocolVersion: "2025-06-18",
|
|
49
|
-
serverInfo: { name: "knowmind", version: VERSION },
|
|
50
|
-
capabilities: { tools: {}, prompts: {} },
|
|
51
|
-
};
|
|
52
|
-
}
|
|
53
|
-
|
|
54
|
-
async function forwardToServer(method, params) {
|
|
55
|
-
const { apiUrl, token } = loadConfig();
|
|
56
|
-
if (!token)
|
|
57
|
-
throw new Error("Knowmind: kein Token konfiguriert. `knowmind login` zuerst.");
|
|
58
|
-
|
|
59
|
-
const r = await fetch(`${apiUrl}/api/mcp/v1`, {
|
|
60
|
-
method: "POST",
|
|
61
|
-
headers: {
|
|
62
|
-
"content-type": "application/json",
|
|
63
|
-
authorization: `Bearer ${token}`,
|
|
64
|
-
},
|
|
65
|
-
body: JSON.stringify({ jsonrpc: "2.0", id: 1, method, params }),
|
|
66
|
-
});
|
|
67
|
-
let data;
|
|
68
|
-
try {
|
|
69
|
-
data = await r.json();
|
|
70
|
-
} catch {
|
|
71
|
-
// HTTP-Status ohne parsebaren JSON-Body sauber als JSON-RPC-Fehler melden.
|
|
72
|
-
return {
|
|
73
|
-
error: {
|
|
74
|
-
code: r.ok ? -32700 : -32000,
|
|
75
|
-
message: r.ok
|
|
76
|
-
? "Knowmind-Server lieferte kein gültiges JSON."
|
|
77
|
-
: `Knowmind-Server: HTTP ${r.status}`,
|
|
78
|
-
},
|
|
79
|
-
};
|
|
80
|
-
}
|
|
81
|
-
return data;
|
|
82
|
-
}
|
|
83
|
-
|
|
84
|
-
function write(obj) {
|
|
85
|
-
process.stdout.write(JSON.stringify(obj) + "\n");
|
|
86
|
-
}
|
|
87
|
-
|
|
88
|
-
/**
|
|
89
|
-
* Öffentliche Server-Discovery (kein Auth nötig): GET {apiUrl}/api/mcp/v1
|
|
90
|
-
* liefert { name, version, protocolVersion, tools: [...] }. Grundlage des
|
|
91
|
-
* Discovery-Modus ohne Token.
|
|
92
|
-
*/
|
|
93
|
-
async function fetchPublicDiscovery() {
|
|
94
|
-
const { apiUrl } = loadConfig();
|
|
95
|
-
const r = await fetch(`${apiUrl}/api/mcp/v1`, {
|
|
96
|
-
headers: { accept: "application/json" },
|
|
97
|
-
});
|
|
98
|
-
if (!r.ok) throw new Error(`Knowmind-Server: HTTP ${r.status}`);
|
|
99
|
-
return await r.json();
|
|
100
|
-
}
|
|
101
|
-
|
|
102
|
-
/**
|
|
103
|
-
* Probiert den konfigurierten Token gegen den Server. Liefert
|
|
104
|
-
* { ok: true } oder { ok: false, reason: "..." }. Wird in der
|
|
105
|
-
* `initialize`-Phase aufgerufen, damit der MCP-Client (Claude Code,
|
|
106
|
-
* Codex, Cursor) bei ungültigem Token NICHT „connected ✓" anzeigt,
|
|
107
|
-
* sondern eine klare Fehlermeldung.
|
|
108
|
-
*/
|
|
109
|
-
async function probeAuth() {
|
|
110
|
-
let cfg;
|
|
111
|
-
try {
|
|
112
|
-
cfg = loadConfig();
|
|
113
|
-
} catch (e) {
|
|
114
|
-
return { ok: false, reason: `Config nicht lesbar: ${e.message}` };
|
|
115
|
-
}
|
|
116
|
-
if (!cfg.token) {
|
|
117
|
-
return {
|
|
118
|
-
ok: false,
|
|
119
|
-
reason:
|
|
120
|
-
"Kein Knowmind-Token konfiguriert. Kostenloses Konto + Token: https://knowmind.de/signin?mode=register (danach Dashboard -> API-Tokens), dann `knowmind login` im Terminal.",
|
|
121
|
-
};
|
|
122
|
-
}
|
|
123
|
-
if (!cfg.token.startsWith("kmt_")) {
|
|
124
|
-
return {
|
|
125
|
-
ok: false,
|
|
126
|
-
reason:
|
|
127
|
-
"Konfigurierter Token hat ein ungültiges Format (erwartet: kmt_…). Bitte `knowmind login` neu ausführen.",
|
|
128
|
-
};
|
|
129
|
-
}
|
|
130
|
-
try {
|
|
131
|
-
const r = await fetch(`${cfg.apiUrl}/api/mcp/v1`, {
|
|
132
|
-
method: "POST",
|
|
133
|
-
headers: {
|
|
134
|
-
"content-type": "application/json",
|
|
135
|
-
authorization: `Bearer ${cfg.token}`,
|
|
136
|
-
},
|
|
137
|
-
body: JSON.stringify({
|
|
138
|
-
jsonrpc: "2.0",
|
|
139
|
-
id: 1,
|
|
140
|
-
method: "tools/call",
|
|
141
|
-
params: { name: "knowmind_health", arguments: {} },
|
|
142
|
-
}),
|
|
143
|
-
});
|
|
144
|
-
if (!r.ok) {
|
|
145
|
-
return {
|
|
146
|
-
ok: false,
|
|
147
|
-
reason:
|
|
148
|
-
`Knowmind-Server antwortet mit HTTP ${r.status}. Token wahrscheinlich abgelaufen — bitte "knowmind login" neu ausführen.`,
|
|
149
|
-
};
|
|
150
|
-
}
|
|
151
|
-
const data = await r.json();
|
|
152
|
-
if (data.error) {
|
|
153
|
-
return {
|
|
154
|
-
ok: false,
|
|
155
|
-
reason:
|
|
156
|
-
`Knowmind-Server lehnt Token ab: ${data.error.message ?? "unbekannter Grund"}. Bitte "knowmind login" neu ausführen.`,
|
|
157
|
-
};
|
|
158
|
-
}
|
|
159
|
-
return { ok: true };
|
|
160
|
-
} catch (e) {
|
|
161
|
-
return {
|
|
162
|
-
ok: false,
|
|
163
|
-
reason: `Knowmind-Server nicht erreichbar (${cfg.apiUrl}): ${e.message}`,
|
|
164
|
-
};
|
|
165
|
-
}
|
|
166
|
-
}
|
|
167
|
-
|
|
168
|
-
/**
|
|
169
|
-
* Die mitgelieferte Werkzeugliste.
|
|
170
|
-
*
|
|
171
|
-
* Sie ist der Rückfall, wenn die Discovery nicht erreichbar ist, und sie
|
|
172
|
-
* veraltet, sobald der Server ein Werkzeug bekommt. `npm run tools:abgleich`
|
|
173
|
-
* vergleicht sie mit der Discovery und schlägt an, sobald beide auseinander
|
|
174
|
-
* laufen.
|
|
175
|
-
*/
|
|
176
|
-
function ladeFallback() {
|
|
177
|
-
try {
|
|
178
|
-
const pfad = new URL("./tools-fallback.json", import.meta.url);
|
|
179
|
-
return JSON.parse(readFileSync(pfad, "utf8"));
|
|
180
|
-
} catch {
|
|
181
|
-
return { tools: [], stand: "unbekannt" };
|
|
182
|
-
}
|
|
183
|
-
}
|
|
184
|
-
|
|
185
|
-
function fallbackTools() {
|
|
186
|
-
const d = ladeFallback();
|
|
187
|
-
return Array.isArray(d.tools) ? d.tools : [];
|
|
188
|
-
}
|
|
189
|
-
|
|
190
|
-
function fallbackStand() {
|
|
191
|
-
return ladeFallback().stand || "unbekannt";
|
|
192
|
-
}
|
|
193
|
-
|
|
194
|
-
export async function runStdioServer() {
|
|
195
|
-
// Kein Token konfiguriert → Discovery-Modus: initialize/tools/list laufen
|
|
196
|
-
// über die öffentliche Server-Discovery, tools/call verlangt Login.
|
|
197
|
-
let discoveryMode = false;
|
|
198
|
-
try {
|
|
199
|
-
discoveryMode = !loadConfig().token;
|
|
200
|
-
} catch {
|
|
201
|
-
discoveryMode = true;
|
|
202
|
-
}
|
|
203
|
-
|
|
204
|
-
// Auth einmal am Start prüfen (nur wenn ein Token vorhanden ist). Das
|
|
205
|
-
// Ergebnis cachen — der MCP-Client soll sofort beim initialize wissen,
|
|
206
|
-
// ob die Verbindung wirklich steht.
|
|
207
|
-
const auth = discoveryMode
|
|
208
|
-
? {
|
|
209
|
-
ok: false,
|
|
210
|
-
reason:
|
|
211
|
-
"Kein Knowmind-Token konfiguriert. Kostenloses Konto + Token: https://knowmind.de/signin?mode=register (danach Dashboard -> API-Tokens), dann `knowmind login` im Terminal.",
|
|
212
|
-
}
|
|
213
|
-
: await probeAuth();
|
|
214
|
-
if (discoveryMode) {
|
|
215
|
-
process.stderr.write(
|
|
216
|
-
"[knowmind] Kein Token — Discovery-Modus: initialize/tools/list öffentlich, tools/call erfordert `knowmind login`.\n",
|
|
217
|
-
);
|
|
218
|
-
} else if (!auth.ok) {
|
|
219
|
-
process.stderr.write(`[knowmind] AUTH-FEHLER: ${auth.reason}\n`);
|
|
220
|
-
}
|
|
221
|
-
|
|
222
|
-
const rl = createInterface({ input: process.stdin });
|
|
223
|
-
for await (const line of rl) {
|
|
224
|
-
const trimmed = line.trim();
|
|
225
|
-
if (!trimmed) continue;
|
|
226
|
-
let req;
|
|
227
|
-
try {
|
|
228
|
-
req = JSON.parse(trimmed);
|
|
229
|
-
} catch {
|
|
230
|
-
write({
|
|
231
|
-
jsonrpc: "2.0",
|
|
232
|
-
id: null,
|
|
233
|
-
error: { code: -32700, message: "Parse error" },
|
|
234
|
-
});
|
|
235
|
-
continue;
|
|
236
|
-
}
|
|
237
|
-
try {
|
|
238
|
-
// Notifications (kein id-Feld) bekommen per JSON-RPC keine Antwort.
|
|
239
|
-
const isNotification = req.id === undefined && typeof req.method === "string" && req.method.startsWith("notifications/");
|
|
240
|
-
if (isNotification) continue;
|
|
241
|
-
|
|
242
|
-
if (discoveryMode) {
|
|
243
|
-
if (req.method === "ping") {
|
|
244
|
-
write({ jsonrpc: "2.0", id: req.id ?? null, result: {} });
|
|
245
|
-
continue;
|
|
246
|
-
}
|
|
247
|
-
if (req.method === "initialize") {
|
|
248
|
-
// serverInfo/protocolVersion möglichst aus der öffentlichen
|
|
249
|
-
// Discovery übernehmen; bei Fehler lokaler Default.
|
|
250
|
-
const initResult = localInitializeResult();
|
|
251
|
-
try {
|
|
252
|
-
const pub = await fetchPublicDiscovery();
|
|
253
|
-
if (pub && typeof pub === "object") {
|
|
254
|
-
if (typeof pub.protocolVersion === "string")
|
|
255
|
-
initResult.protocolVersion = pub.protocolVersion;
|
|
256
|
-
initResult.serverInfo = {
|
|
257
|
-
name: "knowmind",
|
|
258
|
-
version:
|
|
259
|
-
typeof pub.version === "string" ? pub.version : VERSION,
|
|
260
|
-
};
|
|
261
|
-
}
|
|
262
|
-
} catch {
|
|
263
|
-
// offline → lokaler Default reicht für initialize.
|
|
264
|
-
}
|
|
265
|
-
write({ jsonrpc: "2.0", id: req.id ?? null, result: initResult });
|
|
266
|
-
continue;
|
|
267
|
-
}
|
|
268
|
-
if (req.method === "tools/list") {
|
|
269
|
-
let tools = [];
|
|
270
|
-
try {
|
|
271
|
-
const pub = await fetchPublicDiscovery();
|
|
272
|
-
tools = Array.isArray(pub?.tools) ? pub.tools : [];
|
|
273
|
-
} catch (e) {
|
|
274
|
-
// Der Weg zur Discovery kann versperrt sein: eine Sandbox ohne
|
|
275
|
-
// Netz, ein Verzeichnis-Crawler hinter einer Firewall. Vorher gab
|
|
276
|
-
// es hier einen Fehler, und der Aufrufer sah KEIN einziges
|
|
277
|
-
// Werkzeug — für eine Inspektion sieht das aus wie ein Server ohne
|
|
278
|
-
// Funktionen. Deshalb der mitgelieferte Stand.
|
|
279
|
-
tools = fallbackTools();
|
|
280
|
-
process.stderr.write(
|
|
281
|
-
`knowmind: Discovery nicht erreichbar (${e instanceof Error ? e.message : String(e)}), ` +
|
|
282
|
-
`nutze die mitgelieferte Werkzeugliste (${tools.length} Werkzeuge, Stand ${fallbackStand()}).
|
|
283
|
-
`,
|
|
284
|
-
);
|
|
285
|
-
}
|
|
286
|
-
write({ jsonrpc: "2.0", id: req.id ?? null, result: { tools } });
|
|
287
|
-
continue;
|
|
288
|
-
}
|
|
289
|
-
if (req.method === "prompts/list") {
|
|
290
|
-
write({ jsonrpc: "2.0", id: req.id ?? null, result: { prompts: [] } });
|
|
291
|
-
continue;
|
|
292
|
-
}
|
|
293
|
-
// tools/call & Co. brauchen einen Token → klare Fehlermeldung.
|
|
294
|
-
write({
|
|
295
|
-
jsonrpc: "2.0",
|
|
296
|
-
id: req.id ?? null,
|
|
297
|
-
error: {
|
|
298
|
-
code: -32001,
|
|
299
|
-
message: `Knowmind: ${auth.reason}`,
|
|
300
|
-
},
|
|
301
|
-
});
|
|
302
|
-
continue;
|
|
303
|
-
}
|
|
304
|
-
|
|
305
|
-
if (!auth.ok && req.method !== "ping") {
|
|
306
|
-
// Initialize (und alles weitere) FEHLSCHLAGEN lassen, damit der
|
|
307
|
-
// MCP-Client „connected" nicht fälschlich anzeigt. Claude Code,
|
|
308
|
-
// Codex und Cursor werten -32001 als harte Connection-Failure.
|
|
309
|
-
write({
|
|
310
|
-
jsonrpc: "2.0",
|
|
311
|
-
id: req.id ?? null,
|
|
312
|
-
error: {
|
|
313
|
-
code: -32001,
|
|
314
|
-
message: `Knowmind nicht verbunden: ${auth.reason}`,
|
|
315
|
-
},
|
|
316
|
-
});
|
|
317
|
-
continue;
|
|
318
|
-
}
|
|
319
|
-
|
|
320
|
-
if (LOCAL_METHODS.has(req.method)) {
|
|
321
|
-
if (req.method === "ping") {
|
|
322
|
-
write({ jsonrpc: "2.0", id: req.id ?? null, result: {} });
|
|
323
|
-
continue;
|
|
324
|
-
}
|
|
325
|
-
// initialize: An den Server durchreichen und serverInfo / instructions /
|
|
326
|
-
// capabilities aus der Server-Antwort übernehmen. Nur so erreichen die
|
|
327
|
-
// serverseitigen `instructions` (der automatische Pflege-Hebel) den
|
|
328
|
-
// MCP-Client. Bei Server-Fehler/Offline auf den lokalen Default
|
|
329
|
-
// zurückfallen — Proxy-Charakter und Offline-Robustheit bleiben.
|
|
330
|
-
let initResult = localInitializeResult();
|
|
331
|
-
try {
|
|
332
|
-
const upstreamInit = await forwardToServer("initialize", req.params);
|
|
333
|
-
const serverResult =
|
|
334
|
-
upstreamInit && typeof upstreamInit === "object" && "result" in upstreamInit
|
|
335
|
-
? upstreamInit.result
|
|
336
|
-
: null;
|
|
337
|
-
if (serverResult && typeof serverResult === "object") {
|
|
338
|
-
initResult = {
|
|
339
|
-
// protocolVersion vom Server, sonst lokaler Default.
|
|
340
|
-
protocolVersion: serverResult.protocolVersion ?? initResult.protocolVersion,
|
|
341
|
-
// serverInfo vom Server (Name/Version aus zentraler Quelle), sonst lokal.
|
|
342
|
-
serverInfo: serverResult.serverInfo ?? initResult.serverInfo,
|
|
343
|
-
// capabilities vom Server, sonst lokal.
|
|
344
|
-
capabilities: serverResult.capabilities ?? initResult.capabilities,
|
|
345
|
-
// instructions NUR übernehmen, wenn der Server sie liefert.
|
|
346
|
-
...(typeof serverResult.instructions === "string"
|
|
347
|
-
? { instructions: serverResult.instructions }
|
|
348
|
-
: {}),
|
|
349
|
-
};
|
|
350
|
-
}
|
|
351
|
-
} catch (e) {
|
|
352
|
-
// Server nicht erreichbar o.Ä. → lokaler Default. Der Client soll trotzdem
|
|
353
|
-
// initialisieren können; Tool-Calls scheitern dann ohnehin mit klarer Meldung.
|
|
354
|
-
process.stderr.write(
|
|
355
|
-
`[knowmind] initialize-Forward fehlgeschlagen, lokaler Default: ${e instanceof Error ? e.message : String(e)}\n`,
|
|
356
|
-
);
|
|
357
|
-
}
|
|
358
|
-
write({ jsonrpc: "2.0", id: req.id ?? null, result: initResult });
|
|
359
|
-
continue;
|
|
360
|
-
}
|
|
361
|
-
|
|
362
|
-
// Alles andere (tools/list, tools/call, prompts/list, prompts/get, …)
|
|
363
|
-
// geht 1:1 an den Server — Definitionen bleiben dadurch immer synchron.
|
|
364
|
-
const upstream = await forwardToServer(req.method, req.params);
|
|
365
|
-
// Upstream-Response hat eigene jsonrpc/id-Felder — die müssen durch
|
|
366
|
-
// die Client-id ersetzt werden, damit der Client korrekt zuordnet.
|
|
367
|
-
const response = {
|
|
368
|
-
jsonrpc: "2.0",
|
|
369
|
-
id: req.id ?? null,
|
|
370
|
-
};
|
|
371
|
-
if (upstream && typeof upstream === "object" && "result" in upstream) {
|
|
372
|
-
response.result = upstream.result;
|
|
373
|
-
} else if (upstream && typeof upstream === "object" && "error" in upstream) {
|
|
374
|
-
response.error = upstream.error;
|
|
375
|
-
} else {
|
|
376
|
-
response.result = upstream;
|
|
377
|
-
}
|
|
378
|
-
write(response);
|
|
379
|
-
} catch (e) {
|
|
380
|
-
write({
|
|
381
|
-
jsonrpc: "2.0",
|
|
382
|
-
id: req?.id ?? null,
|
|
383
|
-
error: { code: -32603, message: e instanceof Error ? e.message : String(e) },
|
|
384
|
-
});
|
|
385
|
-
}
|
|
386
|
-
}
|
|
387
|
-
}
|
|
1
|
+
/**
|
|
2
|
+
* Lokaler MCP-Stdio-Server — dünner Proxy auf die Knowmind-Plattform.
|
|
3
|
+
*
|
|
4
|
+
* Forwarded JSON-RPC-Requests von stdin an den Remote-MCP-Endpoint
|
|
5
|
+
* (POST {apiUrl}/api/mcp/v1) und schreibt die Antworten auf stdout. Damit kann
|
|
6
|
+
* Knowmind in jeden lokalen MCP-fähigen Client (Claude Code, Claude Desktop,
|
|
7
|
+
* ChatGPT, Cursor, ...) eingebunden werden, ohne dass der Client Bearer-Token
|
|
8
|
+
* kennen muss — der CLI-Wrapper verwaltet die Auth.
|
|
9
|
+
*
|
|
10
|
+
* DESIGN: Seit 0.1.18 ist dieser Server ein reiner Proxy. Tool-Definitionen,
|
|
11
|
+
* Namen (knowmind_recall, knowmind_store_memory, ...), Schemas und
|
|
12
|
+
* Safety-Annotations kommen direkt vom Server (tools/list wird durchgereicht).
|
|
13
|
+
* Dadurch können lokale Definitionen nie mehr vom Server-Stand abweichen —
|
|
14
|
+
* genau diese Abweichung (Punkt- vs. Unterstrich-Namen) hatte 0.1.17 unbrauchbar
|
|
15
|
+
* gemacht, nachdem die Plattform auf das MCP-Namensschema umgestellt wurde.
|
|
16
|
+
*
|
|
17
|
+
* Seit 0.1.20 wird auch `initialize` an den Server durchgereicht, damit die
|
|
18
|
+
* serverseitigen `instructions` (der client-übergreifende Pflege-Hebel) und die
|
|
19
|
+
* tatsächlichen serverInfo/capabilities den Client erreichen. Bei Server-
|
|
20
|
+
* Fehler/Offline fällt der Proxy auf einen lokalen Default zurück.
|
|
21
|
+
*
|
|
22
|
+
* Seit 0.1.22 gibt es einen DISCOVERY-MODUS: Ist KEIN Token konfiguriert,
|
|
23
|
+
* beantwortet der Proxy `initialize`, `tools/list` und `prompts/list` über die
|
|
24
|
+
* ÖFFENTLICHE Server-Discovery (GET {apiUrl}/api/mcp/v1 — liefert Name, Version
|
|
25
|
+
* und alle Tool-Definitionen ohne Auth). Damit funktioniert Introspection
|
|
26
|
+
* (z. B. Verzeichnis-Crawler wie Glama) ohne Account; erst `tools/call`
|
|
27
|
+
* verlangt einen Token und verweist klar auf `knowmind login`. Ein
|
|
28
|
+
* konfigurierter, aber UNGÜLTIGER Token führt weiterhin zum harten
|
|
29
|
+
* Verbindungsfehler, damit MCP-Clients nicht fälschlich „connected" anzeigen.
|
|
30
|
+
*
|
|
31
|
+
* Protokoll: stdio mit zeilenweise JSON (NDJSON-Style). Jedes Frame ist ein
|
|
32
|
+
* vollständiges JSON-RPC-Objekt.
|
|
33
|
+
*/
|
|
34
|
+
import { readFileSync } from "node:fs";
|
|
35
|
+
import { loadConfig, VERSION } from "./config.js";
|
|
36
|
+
import { createInterface } from "node:readline";
|
|
37
|
+
|
|
38
|
+
/** Methoden, die lokal beantwortet werden (alles andere geht an den Server). */
|
|
39
|
+
const LOCAL_METHODS = new Set(["initialize", "ping"]);
|
|
40
|
+
|
|
41
|
+
/**
|
|
42
|
+
* Lokaler Fallback-result für `initialize`, falls der Server nicht erreichbar
|
|
43
|
+
* ist oder keine verwertbare Antwort liefert. Hält den Proxy offline-robust.
|
|
44
|
+
* Die serverInfo.version stammt aus der package.json (VERSION).
|
|
45
|
+
*/
|
|
46
|
+
function localInitializeResult() {
|
|
47
|
+
return {
|
|
48
|
+
protocolVersion: "2025-06-18",
|
|
49
|
+
serverInfo: { name: "knowmind", version: VERSION },
|
|
50
|
+
capabilities: { tools: {}, prompts: {} },
|
|
51
|
+
};
|
|
52
|
+
}
|
|
53
|
+
|
|
54
|
+
async function forwardToServer(method, params) {
|
|
55
|
+
const { apiUrl, token } = loadConfig();
|
|
56
|
+
if (!token)
|
|
57
|
+
throw new Error("Knowmind: kein Token konfiguriert. `knowmind login` zuerst.");
|
|
58
|
+
|
|
59
|
+
const r = await fetch(`${apiUrl}/api/mcp/v1`, {
|
|
60
|
+
method: "POST",
|
|
61
|
+
headers: {
|
|
62
|
+
"content-type": "application/json",
|
|
63
|
+
authorization: `Bearer ${token}`,
|
|
64
|
+
},
|
|
65
|
+
body: JSON.stringify({ jsonrpc: "2.0", id: 1, method, params }),
|
|
66
|
+
});
|
|
67
|
+
let data;
|
|
68
|
+
try {
|
|
69
|
+
data = await r.json();
|
|
70
|
+
} catch {
|
|
71
|
+
// HTTP-Status ohne parsebaren JSON-Body sauber als JSON-RPC-Fehler melden.
|
|
72
|
+
return {
|
|
73
|
+
error: {
|
|
74
|
+
code: r.ok ? -32700 : -32000,
|
|
75
|
+
message: r.ok
|
|
76
|
+
? "Knowmind-Server lieferte kein gültiges JSON."
|
|
77
|
+
: `Knowmind-Server: HTTP ${r.status}`,
|
|
78
|
+
},
|
|
79
|
+
};
|
|
80
|
+
}
|
|
81
|
+
return data;
|
|
82
|
+
}
|
|
83
|
+
|
|
84
|
+
function write(obj) {
|
|
85
|
+
process.stdout.write(JSON.stringify(obj) + "\n");
|
|
86
|
+
}
|
|
87
|
+
|
|
88
|
+
/**
|
|
89
|
+
* Öffentliche Server-Discovery (kein Auth nötig): GET {apiUrl}/api/mcp/v1
|
|
90
|
+
* liefert { name, version, protocolVersion, tools: [...] }. Grundlage des
|
|
91
|
+
* Discovery-Modus ohne Token.
|
|
92
|
+
*/
|
|
93
|
+
async function fetchPublicDiscovery() {
|
|
94
|
+
const { apiUrl } = loadConfig();
|
|
95
|
+
const r = await fetch(`${apiUrl}/api/mcp/v1`, {
|
|
96
|
+
headers: { accept: "application/json" },
|
|
97
|
+
});
|
|
98
|
+
if (!r.ok) throw new Error(`Knowmind-Server: HTTP ${r.status}`);
|
|
99
|
+
return await r.json();
|
|
100
|
+
}
|
|
101
|
+
|
|
102
|
+
/**
|
|
103
|
+
* Probiert den konfigurierten Token gegen den Server. Liefert
|
|
104
|
+
* { ok: true } oder { ok: false, reason: "..." }. Wird in der
|
|
105
|
+
* `initialize`-Phase aufgerufen, damit der MCP-Client (Claude Code,
|
|
106
|
+
* Codex, Cursor) bei ungültigem Token NICHT „connected ✓" anzeigt,
|
|
107
|
+
* sondern eine klare Fehlermeldung.
|
|
108
|
+
*/
|
|
109
|
+
async function probeAuth() {
|
|
110
|
+
let cfg;
|
|
111
|
+
try {
|
|
112
|
+
cfg = loadConfig();
|
|
113
|
+
} catch (e) {
|
|
114
|
+
return { ok: false, reason: `Config nicht lesbar: ${e.message}` };
|
|
115
|
+
}
|
|
116
|
+
if (!cfg.token) {
|
|
117
|
+
return {
|
|
118
|
+
ok: false,
|
|
119
|
+
reason:
|
|
120
|
+
"Kein Knowmind-Token konfiguriert. Kostenloses Konto + Token: https://knowmind.de/signin?mode=register (danach Dashboard -> API-Tokens), dann `knowmind login` im Terminal.",
|
|
121
|
+
};
|
|
122
|
+
}
|
|
123
|
+
if (!cfg.token.startsWith("kmt_")) {
|
|
124
|
+
return {
|
|
125
|
+
ok: false,
|
|
126
|
+
reason:
|
|
127
|
+
"Konfigurierter Token hat ein ungültiges Format (erwartet: kmt_…). Bitte `knowmind login` neu ausführen.",
|
|
128
|
+
};
|
|
129
|
+
}
|
|
130
|
+
try {
|
|
131
|
+
const r = await fetch(`${cfg.apiUrl}/api/mcp/v1`, {
|
|
132
|
+
method: "POST",
|
|
133
|
+
headers: {
|
|
134
|
+
"content-type": "application/json",
|
|
135
|
+
authorization: `Bearer ${cfg.token}`,
|
|
136
|
+
},
|
|
137
|
+
body: JSON.stringify({
|
|
138
|
+
jsonrpc: "2.0",
|
|
139
|
+
id: 1,
|
|
140
|
+
method: "tools/call",
|
|
141
|
+
params: { name: "knowmind_health", arguments: {} },
|
|
142
|
+
}),
|
|
143
|
+
});
|
|
144
|
+
if (!r.ok) {
|
|
145
|
+
return {
|
|
146
|
+
ok: false,
|
|
147
|
+
reason:
|
|
148
|
+
`Knowmind-Server antwortet mit HTTP ${r.status}. Token wahrscheinlich abgelaufen — bitte "knowmind login" neu ausführen.`,
|
|
149
|
+
};
|
|
150
|
+
}
|
|
151
|
+
const data = await r.json();
|
|
152
|
+
if (data.error) {
|
|
153
|
+
return {
|
|
154
|
+
ok: false,
|
|
155
|
+
reason:
|
|
156
|
+
`Knowmind-Server lehnt Token ab: ${data.error.message ?? "unbekannter Grund"}. Bitte "knowmind login" neu ausführen.`,
|
|
157
|
+
};
|
|
158
|
+
}
|
|
159
|
+
return { ok: true };
|
|
160
|
+
} catch (e) {
|
|
161
|
+
return {
|
|
162
|
+
ok: false,
|
|
163
|
+
reason: `Knowmind-Server nicht erreichbar (${cfg.apiUrl}): ${e.message}`,
|
|
164
|
+
};
|
|
165
|
+
}
|
|
166
|
+
}
|
|
167
|
+
|
|
168
|
+
/**
|
|
169
|
+
* Die mitgelieferte Werkzeugliste.
|
|
170
|
+
*
|
|
171
|
+
* Sie ist der Rückfall, wenn die Discovery nicht erreichbar ist, und sie
|
|
172
|
+
* veraltet, sobald der Server ein Werkzeug bekommt. `npm run tools:abgleich`
|
|
173
|
+
* vergleicht sie mit der Discovery und schlägt an, sobald beide auseinander
|
|
174
|
+
* laufen.
|
|
175
|
+
*/
|
|
176
|
+
function ladeFallback() {
|
|
177
|
+
try {
|
|
178
|
+
const pfad = new URL("./tools-fallback.json", import.meta.url);
|
|
179
|
+
return JSON.parse(readFileSync(pfad, "utf8"));
|
|
180
|
+
} catch {
|
|
181
|
+
return { tools: [], stand: "unbekannt" };
|
|
182
|
+
}
|
|
183
|
+
}
|
|
184
|
+
|
|
185
|
+
function fallbackTools() {
|
|
186
|
+
const d = ladeFallback();
|
|
187
|
+
return Array.isArray(d.tools) ? d.tools : [];
|
|
188
|
+
}
|
|
189
|
+
|
|
190
|
+
function fallbackStand() {
|
|
191
|
+
return ladeFallback().stand || "unbekannt";
|
|
192
|
+
}
|
|
193
|
+
|
|
194
|
+
export async function runStdioServer() {
|
|
195
|
+
// Kein Token konfiguriert → Discovery-Modus: initialize/tools/list laufen
|
|
196
|
+
// über die öffentliche Server-Discovery, tools/call verlangt Login.
|
|
197
|
+
let discoveryMode = false;
|
|
198
|
+
try {
|
|
199
|
+
discoveryMode = !loadConfig().token;
|
|
200
|
+
} catch {
|
|
201
|
+
discoveryMode = true;
|
|
202
|
+
}
|
|
203
|
+
|
|
204
|
+
// Auth einmal am Start prüfen (nur wenn ein Token vorhanden ist). Das
|
|
205
|
+
// Ergebnis cachen — der MCP-Client soll sofort beim initialize wissen,
|
|
206
|
+
// ob die Verbindung wirklich steht.
|
|
207
|
+
const auth = discoveryMode
|
|
208
|
+
? {
|
|
209
|
+
ok: false,
|
|
210
|
+
reason:
|
|
211
|
+
"Kein Knowmind-Token konfiguriert. Kostenloses Konto + Token: https://knowmind.de/signin?mode=register (danach Dashboard -> API-Tokens), dann `knowmind login` im Terminal.",
|
|
212
|
+
}
|
|
213
|
+
: await probeAuth();
|
|
214
|
+
if (discoveryMode) {
|
|
215
|
+
process.stderr.write(
|
|
216
|
+
"[knowmind] Kein Token — Discovery-Modus: initialize/tools/list öffentlich, tools/call erfordert `knowmind login`.\n",
|
|
217
|
+
);
|
|
218
|
+
} else if (!auth.ok) {
|
|
219
|
+
process.stderr.write(`[knowmind] AUTH-FEHLER: ${auth.reason}\n`);
|
|
220
|
+
}
|
|
221
|
+
|
|
222
|
+
const rl = createInterface({ input: process.stdin });
|
|
223
|
+
for await (const line of rl) {
|
|
224
|
+
const trimmed = line.trim();
|
|
225
|
+
if (!trimmed) continue;
|
|
226
|
+
let req;
|
|
227
|
+
try {
|
|
228
|
+
req = JSON.parse(trimmed);
|
|
229
|
+
} catch {
|
|
230
|
+
write({
|
|
231
|
+
jsonrpc: "2.0",
|
|
232
|
+
id: null,
|
|
233
|
+
error: { code: -32700, message: "Parse error" },
|
|
234
|
+
});
|
|
235
|
+
continue;
|
|
236
|
+
}
|
|
237
|
+
try {
|
|
238
|
+
// Notifications (kein id-Feld) bekommen per JSON-RPC keine Antwort.
|
|
239
|
+
const isNotification = req.id === undefined && typeof req.method === "string" && req.method.startsWith("notifications/");
|
|
240
|
+
if (isNotification) continue;
|
|
241
|
+
|
|
242
|
+
if (discoveryMode) {
|
|
243
|
+
if (req.method === "ping") {
|
|
244
|
+
write({ jsonrpc: "2.0", id: req.id ?? null, result: {} });
|
|
245
|
+
continue;
|
|
246
|
+
}
|
|
247
|
+
if (req.method === "initialize") {
|
|
248
|
+
// serverInfo/protocolVersion möglichst aus der öffentlichen
|
|
249
|
+
// Discovery übernehmen; bei Fehler lokaler Default.
|
|
250
|
+
const initResult = localInitializeResult();
|
|
251
|
+
try {
|
|
252
|
+
const pub = await fetchPublicDiscovery();
|
|
253
|
+
if (pub && typeof pub === "object") {
|
|
254
|
+
if (typeof pub.protocolVersion === "string")
|
|
255
|
+
initResult.protocolVersion = pub.protocolVersion;
|
|
256
|
+
initResult.serverInfo = {
|
|
257
|
+
name: "knowmind",
|
|
258
|
+
version:
|
|
259
|
+
typeof pub.version === "string" ? pub.version : VERSION,
|
|
260
|
+
};
|
|
261
|
+
}
|
|
262
|
+
} catch {
|
|
263
|
+
// offline → lokaler Default reicht für initialize.
|
|
264
|
+
}
|
|
265
|
+
write({ jsonrpc: "2.0", id: req.id ?? null, result: initResult });
|
|
266
|
+
continue;
|
|
267
|
+
}
|
|
268
|
+
if (req.method === "tools/list") {
|
|
269
|
+
let tools = [];
|
|
270
|
+
try {
|
|
271
|
+
const pub = await fetchPublicDiscovery();
|
|
272
|
+
tools = Array.isArray(pub?.tools) ? pub.tools : [];
|
|
273
|
+
} catch (e) {
|
|
274
|
+
// Der Weg zur Discovery kann versperrt sein: eine Sandbox ohne
|
|
275
|
+
// Netz, ein Verzeichnis-Crawler hinter einer Firewall. Vorher gab
|
|
276
|
+
// es hier einen Fehler, und der Aufrufer sah KEIN einziges
|
|
277
|
+
// Werkzeug — für eine Inspektion sieht das aus wie ein Server ohne
|
|
278
|
+
// Funktionen. Deshalb der mitgelieferte Stand.
|
|
279
|
+
tools = fallbackTools();
|
|
280
|
+
process.stderr.write(
|
|
281
|
+
`knowmind: Discovery nicht erreichbar (${e instanceof Error ? e.message : String(e)}), ` +
|
|
282
|
+
`nutze die mitgelieferte Werkzeugliste (${tools.length} Werkzeuge, Stand ${fallbackStand()}).
|
|
283
|
+
`,
|
|
284
|
+
);
|
|
285
|
+
}
|
|
286
|
+
write({ jsonrpc: "2.0", id: req.id ?? null, result: { tools } });
|
|
287
|
+
continue;
|
|
288
|
+
}
|
|
289
|
+
if (req.method === "prompts/list") {
|
|
290
|
+
write({ jsonrpc: "2.0", id: req.id ?? null, result: { prompts: [] } });
|
|
291
|
+
continue;
|
|
292
|
+
}
|
|
293
|
+
// tools/call & Co. brauchen einen Token → klare Fehlermeldung.
|
|
294
|
+
write({
|
|
295
|
+
jsonrpc: "2.0",
|
|
296
|
+
id: req.id ?? null,
|
|
297
|
+
error: {
|
|
298
|
+
code: -32001,
|
|
299
|
+
message: `Knowmind: ${auth.reason}`,
|
|
300
|
+
},
|
|
301
|
+
});
|
|
302
|
+
continue;
|
|
303
|
+
}
|
|
304
|
+
|
|
305
|
+
if (!auth.ok && req.method !== "ping") {
|
|
306
|
+
// Initialize (und alles weitere) FEHLSCHLAGEN lassen, damit der
|
|
307
|
+
// MCP-Client „connected" nicht fälschlich anzeigt. Claude Code,
|
|
308
|
+
// Codex und Cursor werten -32001 als harte Connection-Failure.
|
|
309
|
+
write({
|
|
310
|
+
jsonrpc: "2.0",
|
|
311
|
+
id: req.id ?? null,
|
|
312
|
+
error: {
|
|
313
|
+
code: -32001,
|
|
314
|
+
message: `Knowmind nicht verbunden: ${auth.reason}`,
|
|
315
|
+
},
|
|
316
|
+
});
|
|
317
|
+
continue;
|
|
318
|
+
}
|
|
319
|
+
|
|
320
|
+
if (LOCAL_METHODS.has(req.method)) {
|
|
321
|
+
if (req.method === "ping") {
|
|
322
|
+
write({ jsonrpc: "2.0", id: req.id ?? null, result: {} });
|
|
323
|
+
continue;
|
|
324
|
+
}
|
|
325
|
+
// initialize: An den Server durchreichen und serverInfo / instructions /
|
|
326
|
+
// capabilities aus der Server-Antwort übernehmen. Nur so erreichen die
|
|
327
|
+
// serverseitigen `instructions` (der automatische Pflege-Hebel) den
|
|
328
|
+
// MCP-Client. Bei Server-Fehler/Offline auf den lokalen Default
|
|
329
|
+
// zurückfallen — Proxy-Charakter und Offline-Robustheit bleiben.
|
|
330
|
+
let initResult = localInitializeResult();
|
|
331
|
+
try {
|
|
332
|
+
const upstreamInit = await forwardToServer("initialize", req.params);
|
|
333
|
+
const serverResult =
|
|
334
|
+
upstreamInit && typeof upstreamInit === "object" && "result" in upstreamInit
|
|
335
|
+
? upstreamInit.result
|
|
336
|
+
: null;
|
|
337
|
+
if (serverResult && typeof serverResult === "object") {
|
|
338
|
+
initResult = {
|
|
339
|
+
// protocolVersion vom Server, sonst lokaler Default.
|
|
340
|
+
protocolVersion: serverResult.protocolVersion ?? initResult.protocolVersion,
|
|
341
|
+
// serverInfo vom Server (Name/Version aus zentraler Quelle), sonst lokal.
|
|
342
|
+
serverInfo: serverResult.serverInfo ?? initResult.serverInfo,
|
|
343
|
+
// capabilities vom Server, sonst lokal.
|
|
344
|
+
capabilities: serverResult.capabilities ?? initResult.capabilities,
|
|
345
|
+
// instructions NUR übernehmen, wenn der Server sie liefert.
|
|
346
|
+
...(typeof serverResult.instructions === "string"
|
|
347
|
+
? { instructions: serverResult.instructions }
|
|
348
|
+
: {}),
|
|
349
|
+
};
|
|
350
|
+
}
|
|
351
|
+
} catch (e) {
|
|
352
|
+
// Server nicht erreichbar o.Ä. → lokaler Default. Der Client soll trotzdem
|
|
353
|
+
// initialisieren können; Tool-Calls scheitern dann ohnehin mit klarer Meldung.
|
|
354
|
+
process.stderr.write(
|
|
355
|
+
`[knowmind] initialize-Forward fehlgeschlagen, lokaler Default: ${e instanceof Error ? e.message : String(e)}\n`,
|
|
356
|
+
);
|
|
357
|
+
}
|
|
358
|
+
write({ jsonrpc: "2.0", id: req.id ?? null, result: initResult });
|
|
359
|
+
continue;
|
|
360
|
+
}
|
|
361
|
+
|
|
362
|
+
// Alles andere (tools/list, tools/call, prompts/list, prompts/get, …)
|
|
363
|
+
// geht 1:1 an den Server — Definitionen bleiben dadurch immer synchron.
|
|
364
|
+
const upstream = await forwardToServer(req.method, req.params);
|
|
365
|
+
// Upstream-Response hat eigene jsonrpc/id-Felder — die müssen durch
|
|
366
|
+
// die Client-id ersetzt werden, damit der Client korrekt zuordnet.
|
|
367
|
+
const response = {
|
|
368
|
+
jsonrpc: "2.0",
|
|
369
|
+
id: req.id ?? null,
|
|
370
|
+
};
|
|
371
|
+
if (upstream && typeof upstream === "object" && "result" in upstream) {
|
|
372
|
+
response.result = upstream.result;
|
|
373
|
+
} else if (upstream && typeof upstream === "object" && "error" in upstream) {
|
|
374
|
+
response.error = upstream.error;
|
|
375
|
+
} else {
|
|
376
|
+
response.result = upstream;
|
|
377
|
+
}
|
|
378
|
+
write(response);
|
|
379
|
+
} catch (e) {
|
|
380
|
+
write({
|
|
381
|
+
jsonrpc: "2.0",
|
|
382
|
+
id: req?.id ?? null,
|
|
383
|
+
error: { code: -32603, message: e instanceof Error ? e.message : String(e) },
|
|
384
|
+
});
|
|
385
|
+
}
|
|
386
|
+
}
|
|
387
|
+
}
|