knowmind 0.3.4 → 0.3.6
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 +273 -260
- package/README.de.md +207 -0
- package/README.md +175 -171
- package/package.json +5 -3
- package/scripts/check-distribution.mjs +114 -0
- package/scripts/sync-server-json.mjs +74 -0
- package/scripts/tools-abgleich.mjs +66 -0
- package/src/install.js +37 -2
- package/src/mcp-starter.py +119 -0
- package/src/mcp-stdio.js +387 -356
- package/src/tools-fallback.json +466 -0
|
@@ -0,0 +1,114 @@
|
|
|
1
|
+
#!/usr/bin/env node
|
|
2
|
+
// Distributions-Wächter: prüft, ob knowmind über ALLE Kanäle konsistent und auf
|
|
3
|
+
// Stand ist. Läuft täglich in CI (distribution-consistency.yml) und bei jedem
|
|
4
|
+
// Push, der package.json/server.json berührt. Bei Drift Exit 1 -> roter CI-Lauf
|
|
5
|
+
// -> GitHub mailt an den Maintainer.
|
|
6
|
+
//
|
|
7
|
+
// Wahrheitskette: package.json (Entwicklung) -> npm-latest (veröffentlicht)
|
|
8
|
+
// -> server.json -> offizielle MCP-Registry -> Aggregatoren.
|
|
9
|
+
// npm-latest ist der Anker für alles Nachgelagerte (die Registry validiert
|
|
10
|
+
// npm-Ownership+Existenz). package.json DARF voraus sein (unveröffentlichter
|
|
11
|
+
// Bump) — das ist eine Warnung, kein Fehler: es bedeutet nur "npm publish steht
|
|
12
|
+
// noch aus" (manuell, 2FA).
|
|
13
|
+
import { readFileSync } from "node:fs";
|
|
14
|
+
|
|
15
|
+
const PKG = "knowmind";
|
|
16
|
+
const REGISTRY = "https://registry.modelcontextprotocol.io/v0/servers?search=knowmind";
|
|
17
|
+
|
|
18
|
+
const root = new URL("../", import.meta.url);
|
|
19
|
+
const pkg = JSON.parse(readFileSync(new URL("package.json", root), "utf8"));
|
|
20
|
+
const sj = JSON.parse(readFileSync(new URL("server.json", root), "utf8"));
|
|
21
|
+
const glama = JSON.parse(readFileSync(new URL("glama.json", root), "utf8"));
|
|
22
|
+
|
|
23
|
+
// npm-latest per HTTP (kein child_process/Shell — plattformunabhängig).
|
|
24
|
+
async function npmLatest() {
|
|
25
|
+
const res = await fetch(`https://registry.npmjs.org/${PKG}`);
|
|
26
|
+
if (!res.ok) throw new Error(`npm-Registry HTTP ${res.status}`);
|
|
27
|
+
const data = await res.json();
|
|
28
|
+
return data["dist-tags"]?.latest;
|
|
29
|
+
}
|
|
30
|
+
|
|
31
|
+
async function registryLatest() {
|
|
32
|
+
const res = await fetch(REGISTRY);
|
|
33
|
+
if (!res.ok) throw new Error(`Registry HTTP ${res.status}`);
|
|
34
|
+
const data = await res.json();
|
|
35
|
+
const eintraege = (data.servers ?? []).filter(
|
|
36
|
+
(s) => (s.server ?? s).name === sj.name,
|
|
37
|
+
);
|
|
38
|
+
const latest = eintraege.find(
|
|
39
|
+
(s) => s._meta?.["io.modelcontextprotocol.registry/official"]?.isLatest,
|
|
40
|
+
);
|
|
41
|
+
return latest ? (latest.server ?? latest).version : null;
|
|
42
|
+
}
|
|
43
|
+
|
|
44
|
+
const cmp = (a, b) => a.localeCompare(b, undefined, { numeric: true });
|
|
45
|
+
|
|
46
|
+
const npmV = await npmLatest();
|
|
47
|
+
const regV = await registryLatest();
|
|
48
|
+
|
|
49
|
+
const fehler = [];
|
|
50
|
+
const warnung = [];
|
|
51
|
+
|
|
52
|
+
// 1. Identität: server.json.name == package.json.mcpName (Registry-Ownership)
|
|
53
|
+
if (pkg.mcpName && pkg.mcpName !== sj.name)
|
|
54
|
+
fehler.push(`Identität: package.json mcpName (${pkg.mcpName}) != server.json name (${sj.name})`);
|
|
55
|
+
|
|
56
|
+
// 2. server.json intern konsistent
|
|
57
|
+
for (const p of sj.packages ?? [])
|
|
58
|
+
if (p.version !== sj.version)
|
|
59
|
+
fehler.push(`server.json intern: packages[${p.identifier}] ${p.version} != top ${sj.version}`);
|
|
60
|
+
|
|
61
|
+
// 3. server.json zeigt auf die veröffentlichte npm-Version
|
|
62
|
+
if (sj.version !== npmV)
|
|
63
|
+
fehler.push(`server.json (${sj.version}) != npm-latest (${npmV}) — Registry-Publish nötig`);
|
|
64
|
+
|
|
65
|
+
// 4. Registry auf Stand mit npm
|
|
66
|
+
if (regV !== npmV)
|
|
67
|
+
fehler.push(`MCP-Registry (${regV ?? "fehlt"}) != npm-latest (${npmV}) — Registry-Publish nötig`);
|
|
68
|
+
|
|
69
|
+
// 4b. glama.json zeigt auf die veröffentlichte npm-Version (Glama-Listing;
|
|
70
|
+
// hing bis 2026-07-21 unbemerkt bei 0.1.25, weil hier nicht geprüft).
|
|
71
|
+
if (glama.version !== npmV)
|
|
72
|
+
fehler.push(`glama.json (${glama.version}) != npm-latest (${npmV})`);
|
|
73
|
+
|
|
74
|
+
// 5. package.json voraus = unveröffentlichter Bump (Warnung, kein Fehler)
|
|
75
|
+
if (cmp(pkg.version, npmV) > 0)
|
|
76
|
+
warnung.push(`package.json (${pkg.version}) > npm-latest (${npmV}) — npm publish steht aus (manuell, 2FA)`);
|
|
77
|
+
else if (cmp(pkg.version, npmV) < 0)
|
|
78
|
+
fehler.push(`package.json (${pkg.version}) < npm-latest (${npmV}) — Repo hinter npm, ungewöhnlich`);
|
|
79
|
+
|
|
80
|
+
console.log(`Distributions-Stand knowmind:`);
|
|
81
|
+
console.log(` package.json : ${pkg.version}`);
|
|
82
|
+
console.log(` npm-latest : ${npmV}`);
|
|
83
|
+
console.log(` server.json : ${sj.version}`);
|
|
84
|
+
console.log(` glama.json : ${glama.version}`);
|
|
85
|
+
console.log(` MCP-Registry : ${regV ?? "—"}`);
|
|
86
|
+
console.log(` mcpName/name : ${pkg.mcpName ?? "—"} / ${sj.name}`);
|
|
87
|
+
|
|
88
|
+
for (const w of warnung) console.log(` ⚠ ${w}`);
|
|
89
|
+
for (const f of fehler) console.error(` ✗ ${f}`);
|
|
90
|
+
|
|
91
|
+
// Maschinen-Flags für den CI-Heil-Schritt (nur wenn in GitHub Actions).
|
|
92
|
+
//
|
|
93
|
+
// `registry_stale` löst BEIDES aus: den Manifest-Sync (server.json + glama.json)
|
|
94
|
+
// und den Registry-Publish. glama.json gehörte bis 08.08.2026 nicht in diese
|
|
95
|
+
// Bedingung — Folge: Der Lauf heilte server.json, liess glama.json auf dem alten
|
|
96
|
+
// Stand und scheiterte danach an der eigenen Endkontrolle. Das wiederholte sich
|
|
97
|
+
// vier Tage lang täglich, ohne dass es jemandem auffiel.
|
|
98
|
+
if (process.env.GITHUB_OUTPUT) {
|
|
99
|
+
const registryStale = sj.version !== npmV || regV !== npmV || glama.version !== npmV;
|
|
100
|
+
// Nur der Registry-Publish ist teuer (Download + OIDC) und nur nötig, wenn die
|
|
101
|
+
// Registry selbst hinterherhängt.
|
|
102
|
+
const publishNoetig = sj.version !== npmV || regV !== npmV;
|
|
103
|
+
const { appendFileSync } = await import("node:fs");
|
|
104
|
+
appendFileSync(
|
|
105
|
+
process.env.GITHUB_OUTPUT,
|
|
106
|
+
`registry_stale=${registryStale ? 1 : 0}\npublish_noetig=${publishNoetig ? 1 : 0}\nnpm_latest=${npmV}\n`,
|
|
107
|
+
);
|
|
108
|
+
}
|
|
109
|
+
|
|
110
|
+
if (fehler.length) {
|
|
111
|
+
console.error(`\nDistribution NICHT synchron (${fehler.length} Drift).`);
|
|
112
|
+
process.exit(1);
|
|
113
|
+
}
|
|
114
|
+
console.log(warnung.length ? `\nSynchron (mit ${warnung.length} Hinweis).` : `\nAlle Kanäle synchron.`);
|
|
@@ -0,0 +1,74 @@
|
|
|
1
|
+
#!/usr/bin/env node
|
|
2
|
+
// Hält server.json (MCP-Registry-Manifest) an der TATSÄCHLICH auf npm
|
|
3
|
+
// veröffentlichten Version. npm ist die Quelle der Wahrheit: die offizielle
|
|
4
|
+
// Registry validiert npm-Ownership + Existenz, ein Manifest, das auf eine
|
|
5
|
+
// nicht-publizierte Version zeigt, wird mit Fehler abgelehnt. Deshalb NICHT
|
|
6
|
+
// package.json folgen (die kann einen unveröffentlichten Bump tragen), sondern
|
|
7
|
+
// npm-latest.
|
|
8
|
+
//
|
|
9
|
+
// Aufruf:
|
|
10
|
+
// node scripts/sync-server-json.mjs -> setzt auf npm-latest, schreibt
|
|
11
|
+
// node scripts/sync-server-json.mjs <version> -> setzt auf <version>, schreibt
|
|
12
|
+
// node scripts/sync-server-json.mjs --check -> nur prüfen, Exit 1 bei Abweichung
|
|
13
|
+
//
|
|
14
|
+
// Wird vom Publish-Workflow VOR dem Registry-Publish aufgerufen, damit die
|
|
15
|
+
// Registry immer == npm-latest ist, ohne dass server.json von Hand gepflegt wird.
|
|
16
|
+
import { readFileSync, writeFileSync } from "node:fs";
|
|
17
|
+
|
|
18
|
+
const PKG = "knowmind";
|
|
19
|
+
const arg = process.argv[2];
|
|
20
|
+
const checkOnly = arg === "--check";
|
|
21
|
+
|
|
22
|
+
// npm-latest per HTTP (kein child_process/Shell — plattformunabhängig).
|
|
23
|
+
async function npmLatest() {
|
|
24
|
+
const res = await fetch(`https://registry.npmjs.org/${PKG}`);
|
|
25
|
+
if (!res.ok) throw new Error(`npm-Registry HTTP ${res.status}`);
|
|
26
|
+
const data = await res.json();
|
|
27
|
+
return data["dist-tags"]?.latest;
|
|
28
|
+
}
|
|
29
|
+
|
|
30
|
+
const ziel = arg && !arg.startsWith("--") ? arg : await npmLatest();
|
|
31
|
+
if (!/^\d+\.\d+\.\d+/.test(ziel)) {
|
|
32
|
+
console.error(`Ungültige Zielversion: ${ziel}`);
|
|
33
|
+
process.exit(2);
|
|
34
|
+
}
|
|
35
|
+
|
|
36
|
+
const pfad = new URL("../server.json", import.meta.url);
|
|
37
|
+
const sj = JSON.parse(readFileSync(pfad, "utf8"));
|
|
38
|
+
const glamaPfad = new URL("../glama.json", import.meta.url);
|
|
39
|
+
const glama = JSON.parse(readFileSync(glamaPfad, "utf8"));
|
|
40
|
+
|
|
41
|
+
const abweichungen = [];
|
|
42
|
+
if (sj.version !== ziel) abweichungen.push(`version ${sj.version} -> ${ziel}`);
|
|
43
|
+
for (const p of sj.packages ?? []) {
|
|
44
|
+
if (p.version !== ziel) abweichungen.push(`packages[${p.identifier}].version ${p.version} -> ${ziel}`);
|
|
45
|
+
}
|
|
46
|
+
// glama.json (Glama-Listing) hängt an derselben Wahrheit (npm-latest).
|
|
47
|
+
if (glama.version !== ziel) abweichungen.push(`glama.json version ${glama.version} -> ${ziel}`);
|
|
48
|
+
|
|
49
|
+
// Identitäts-Invariante: server.json.name muss dem npm-mcpName entsprechen,
|
|
50
|
+
// sonst scheitert die Ownership-Validierung der Registry.
|
|
51
|
+
const pkgJson = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8"));
|
|
52
|
+
if (pkgJson.mcpName && pkgJson.mcpName !== sj.name) {
|
|
53
|
+
console.error(`FEHLER: package.json mcpName (${pkgJson.mcpName}) != server.json name (${sj.name})`);
|
|
54
|
+
process.exit(2);
|
|
55
|
+
}
|
|
56
|
+
|
|
57
|
+
if (!abweichungen.length) {
|
|
58
|
+
console.log(`server.json + glama.json bereits auf ${ziel} — nichts zu tun.`);
|
|
59
|
+
process.exit(0);
|
|
60
|
+
}
|
|
61
|
+
|
|
62
|
+
if (checkOnly) {
|
|
63
|
+
console.error(`Manifeste weichen ab:\n ${abweichungen.join("\n ")}`);
|
|
64
|
+
process.exit(1);
|
|
65
|
+
}
|
|
66
|
+
|
|
67
|
+
sj.version = ziel;
|
|
68
|
+
for (const p of sj.packages ?? []) p.version = ziel;
|
|
69
|
+
writeFileSync(pfad, JSON.stringify(sj, null, 2) + "\n");
|
|
70
|
+
if (glama.version !== ziel) {
|
|
71
|
+
glama.version = ziel;
|
|
72
|
+
writeFileSync(glamaPfad, JSON.stringify(glama, null, 2) + "\n");
|
|
73
|
+
}
|
|
74
|
+
console.log(`Manifeste -> ${ziel} gesetzt:\n ${abweichungen.join("\n ")}`);
|
|
@@ -0,0 +1,66 @@
|
|
|
1
|
+
/**
|
|
2
|
+
* Vergleicht die mitgelieferte Werkzeugliste mit der öffentlichen Discovery.
|
|
3
|
+
*
|
|
4
|
+
* `src/tools-fallback.json` ist der Rückfall, wenn der Weg zu knowmind.de
|
|
5
|
+
* versperrt ist — eine Sandbox ohne Netz, ein Verzeichnis-Crawler hinter einer
|
|
6
|
+
* Firewall. Ohne ihn sieht eine Inspektion kein einziges Werkzeug und hält den
|
|
7
|
+
* Server für leer.
|
|
8
|
+
*
|
|
9
|
+
* Der Rückfall veraltet, sobald der Server ein Werkzeug bekommt oder ein
|
|
10
|
+
* Eingabeschema ändert. Dieser Abgleich schlägt dann an. Er gehört in die
|
|
11
|
+
* Pipeline und vor jedes Release.
|
|
12
|
+
*
|
|
13
|
+
* node scripts/tools-abgleich.mjs
|
|
14
|
+
*
|
|
15
|
+
* Rückgabewert 1, wenn die Listen auseinanderlaufen; 0, wenn sie gleich sind.
|
|
16
|
+
* Ist die Discovery nicht erreichbar, endet der Lauf mit 2 — dann sagt er
|
|
17
|
+
* nichts über den Rückfall aus und darf nicht als bestanden gelten.
|
|
18
|
+
*/
|
|
19
|
+
import { readFileSync } from "node:fs";
|
|
20
|
+
|
|
21
|
+
const QUELLE = "https://knowmind.de/api/mcp/v1";
|
|
22
|
+
|
|
23
|
+
const datei = JSON.parse(
|
|
24
|
+
readFileSync(new URL("../src/tools-fallback.json", import.meta.url), "utf8"),
|
|
25
|
+
);
|
|
26
|
+
|
|
27
|
+
let live;
|
|
28
|
+
try {
|
|
29
|
+
const r = await fetch(QUELLE, { headers: { accept: "application/json" } });
|
|
30
|
+
if (!r.ok) throw new Error(`HTTP ${r.status}`);
|
|
31
|
+
live = await r.json();
|
|
32
|
+
} catch (e) {
|
|
33
|
+
console.error(`Discovery nicht erreichbar (${QUELLE}): ${e.message}`);
|
|
34
|
+
console.error("Der Abgleich sagt damit nichts über den Rückfall aus.");
|
|
35
|
+
process.exit(2);
|
|
36
|
+
}
|
|
37
|
+
|
|
38
|
+
const namen = (liste) => (liste ?? []).map((w) => w.name).sort();
|
|
39
|
+
const alt = namen(datei.tools);
|
|
40
|
+
const neu = namen(live.tools);
|
|
41
|
+
|
|
42
|
+
const fehlen = neu.filter((n) => !alt.includes(n));
|
|
43
|
+
const zuviel = alt.filter((n) => !neu.includes(n));
|
|
44
|
+
|
|
45
|
+
// Ein Werkzeug kann denselben Namen tragen und ein anderes Eingabeschema haben.
|
|
46
|
+
const schema = (liste, name) =>
|
|
47
|
+
JSON.stringify((liste ?? []).find((w) => w.name === name)?.inputSchema ?? {});
|
|
48
|
+
const geaendert = neu
|
|
49
|
+
.filter((n) => alt.includes(n))
|
|
50
|
+
.filter((n) => schema(datei.tools, n) !== schema(live.tools, n));
|
|
51
|
+
|
|
52
|
+
if (fehlen.length === 0 && zuviel.length === 0 && geaendert.length === 0) {
|
|
53
|
+
console.log(
|
|
54
|
+
`Rückfall aktuell: ${alt.length} Werkzeuge, Stand ${datei.stand}, Schemas gleich.`,
|
|
55
|
+
);
|
|
56
|
+
process.exit(0);
|
|
57
|
+
}
|
|
58
|
+
|
|
59
|
+
console.error(`Rückfall veraltet (Stand ${datei.stand}):`);
|
|
60
|
+
if (fehlen.length) console.error(` fehlen: ${fehlen.join(", ")}`);
|
|
61
|
+
if (zuviel.length) console.error(` überzählig: ${zuviel.join(", ")}`);
|
|
62
|
+
if (geaendert.length)
|
|
63
|
+
console.error(` Schema neu: ${geaendert.join(", ")}`);
|
|
64
|
+
console.error("");
|
|
65
|
+
console.error("Neu erzeugen und die Änderung mit einem Release ausliefern.");
|
|
66
|
+
process.exit(1);
|
package/src/install.js
CHANGED
|
@@ -15,6 +15,7 @@
|
|
|
15
15
|
import { mkdirSync, readFileSync, writeFileSync, existsSync } from "node:fs";
|
|
16
16
|
import { homedir, platform } from "node:os";
|
|
17
17
|
import { dirname, join } from "node:path";
|
|
18
|
+
import { fileURLToPath } from "node:url";
|
|
18
19
|
|
|
19
20
|
const DEFAULT_API = "https://knowmind.de";
|
|
20
21
|
const NPX = "npx";
|
|
@@ -126,17 +127,51 @@ function tokenRef(secretStyle, literalToken) {
|
|
|
126
127
|
}
|
|
127
128
|
}
|
|
128
129
|
|
|
130
|
+
/**
|
|
131
|
+
* Startbefehl für den MCP-Server.
|
|
132
|
+
*
|
|
133
|
+
* Unter Windows nicht direkt `npx`: Das ist ein Konsolenprogramm, und hat der
|
|
134
|
+
* KI-Client keine eigene Konsole (Desktop-Anwendung, IDE-Erweiterung), gibt
|
|
135
|
+
* Windows dem Kind bei JEDEM Werkzeugaufruf ein eigenes Fenster. Das blitzt
|
|
136
|
+
* nicht nur, es stiehlt den Tastaturfokus mitten im Tippen. Johann am
|
|
137
|
+
* 10.08.2026: „Viele werden es deshalb deinstallieren." — und er hat recht.
|
|
138
|
+
*
|
|
139
|
+
* Deshalb dazwischen `pythonw.exe` (GUI-Programm, öffnet selbst kein Fenster),
|
|
140
|
+
* das npx mit CREATE_NO_WINDOW startet und die Datenströme durchreicht. Ohne
|
|
141
|
+
* Python auf dem Rechner bleibt es beim direkten npx-Aufruf — eine ehrliche
|
|
142
|
+
* Grenze ist besser als eine halbe Lösung.
|
|
143
|
+
*/
|
|
144
|
+
function startBefehl() {
|
|
145
|
+
const pythonw = findePythonwFuerMcp();
|
|
146
|
+
if (!pythonw) return { command: NPX, args: NPX_ARGS };
|
|
147
|
+
const starter = join(dirname(fileURLToPath(import.meta.url)), "mcp-starter.py");
|
|
148
|
+
return { command: pythonw, args: [starter, NPX, ...NPX_ARGS] };
|
|
149
|
+
}
|
|
150
|
+
|
|
151
|
+
/** Vollständiger Pfad zu pythonw.exe, oder null. */
|
|
152
|
+
function findePythonwFuerMcp() {
|
|
153
|
+
if (platform() !== "win32") return null;
|
|
154
|
+
const kandidaten = [];
|
|
155
|
+
const lokal = process.env.LOCALAPPDATA;
|
|
156
|
+
for (const v of ["313", "312", "311", "310"]) {
|
|
157
|
+
if (lokal) kandidaten.push(join(lokal, "Programs", "Python", `Python${v}`, "pythonw.exe"));
|
|
158
|
+
kandidaten.push(join("C:\\", `Python${v}`, "pythonw.exe"));
|
|
159
|
+
}
|
|
160
|
+
return kandidaten.find((p) => existsSync(p)) ?? null;
|
|
161
|
+
}
|
|
162
|
+
|
|
129
163
|
// Server-Eintrag im Schema der Familie.
|
|
130
164
|
function serverEntry(ide, { apiUrl, literalToken }) {
|
|
131
165
|
const env = {
|
|
132
166
|
KNOWMIND_TOKEN: tokenRef(ide.secret, literalToken),
|
|
133
167
|
KNOWMIND_API_URL: apiUrl,
|
|
134
168
|
};
|
|
169
|
+
const { command, args } = startBefehl();
|
|
135
170
|
if (ide.family === "servers") {
|
|
136
171
|
// VS Code verlangt einen Transport-Typ.
|
|
137
|
-
return { type: "stdio", command
|
|
172
|
+
return { type: "stdio", command, args, env };
|
|
138
173
|
}
|
|
139
|
-
return { command
|
|
174
|
+
return { command, args, env };
|
|
140
175
|
}
|
|
141
176
|
|
|
142
177
|
// Vollständiges Snippet (für --print / GUI-IDEs).
|
|
@@ -0,0 +1,119 @@
|
|
|
1
|
+
# -*- coding: utf-8 -*-
|
|
2
|
+
"""Startet den knowmind-MCP-Server unter Windows ohne Konsolenfenster.
|
|
3
|
+
|
|
4
|
+
WARUM (10.08.2026, Johann): „Mein Fenster öffnet sich noch immer, wenn knowmind
|
|
5
|
+
gecalled wird. Viele werden es deshalb deinstallieren." — und nachgeschoben:
|
|
6
|
+
„Du kannst währenddessen auch nicht tippen. Sehr nervig." Das Fenster stiehlt
|
|
7
|
+
den Tastaturfokus, es ist also kein Schönheitsfehler, sondern eine Unterbrechung
|
|
8
|
+
mitten im Satz.
|
|
9
|
+
|
|
10
|
+
Ein MCP-Server wird als `node …/knowmind.js mcp` gestartet. `node.exe` ist ein
|
|
11
|
+
Konsolenprogramm; hat der startende KI-Client keine eigene Konsole — Desktop-
|
|
12
|
+
Anwendung, IDE-Erweiterung —, gibt Windows dem Kind ein eigenes Fenster. Bei
|
|
13
|
+
jedem Werkzeugaufruf blitzt es auf. Ein Gedächtnis, das bei jeder Nutzung den
|
|
14
|
+
Fokus klaut, fliegt wieder runter, egal wie gut es ist.
|
|
15
|
+
|
|
16
|
+
`node.exe` hat kein fensterloses Gegenstück. `pythonw.exe` ist ein GUI-Programm
|
|
17
|
+
und öffnet selbst keins — es gibt node eine versteckte Konsole.
|
|
18
|
+
|
|
19
|
+
WARUM DURCHREICHEN STATT VERERBEN: Die naheliegende Fassung startet node ohne
|
|
20
|
+
stdin/stdout-Umleitung, damit es die Handles des Elternprozesses erbt. Unter
|
|
21
|
+
`pythonw.exe` schlägt das fehl — als GUI-Programm hat es keine verlässlichen
|
|
22
|
+
Standard-Handles, node erbt ins Leere und die Antwort kommt nie beim Client an
|
|
23
|
+
(gemessen 10.08.2026: initialize blieb unbeantwortet). Deshalb werden die
|
|
24
|
+
Datenströme über Pipes geführt und in beide Richtungen durchgepumpt. Roh, ohne
|
|
25
|
+
Zeilenpufferung — MCP-Nachrichten dürfen nicht verzögert oder zerschnitten
|
|
26
|
+
werden.
|
|
27
|
+
|
|
28
|
+
Aufruf: pythonw.exe mcp-starter.py <befehl> [argumente]
|
|
29
|
+
z. B. … mcp-starter.py npx -y knowmind mcp
|
|
30
|
+
oder … mcp-starter.py node C:/…/knowmind.js mcp
|
|
31
|
+
"""
|
|
32
|
+
import shutil
|
|
33
|
+
import subprocess
|
|
34
|
+
import sys
|
|
35
|
+
import threading
|
|
36
|
+
|
|
37
|
+
|
|
38
|
+
|
|
39
|
+
def pumpe(quelle, ziel) -> None:
|
|
40
|
+
"""Schiebt Bytes weiter, sobald sie da sind, und schliesst am Ende sauber."""
|
|
41
|
+
try:
|
|
42
|
+
while True:
|
|
43
|
+
brocken = quelle.read(1)
|
|
44
|
+
if not brocken:
|
|
45
|
+
break
|
|
46
|
+
ziel.write(brocken)
|
|
47
|
+
ziel.flush()
|
|
48
|
+
except Exception: # noqa: BLE001 — Abbruch beim Beenden ist normal
|
|
49
|
+
pass
|
|
50
|
+
finally:
|
|
51
|
+
try:
|
|
52
|
+
ziel.close()
|
|
53
|
+
except Exception: # noqa: BLE001
|
|
54
|
+
pass
|
|
55
|
+
|
|
56
|
+
|
|
57
|
+
def _ohne_fenster():
|
|
58
|
+
"""Startet node in einer versteckten Konsole statt ganz ohne.
|
|
59
|
+
|
|
60
|
+
`CREATE_NO_WINDOW` allein nimmt dem Prozess die Konsole — und ein Kind,
|
|
61
|
+
dessen Eltern keine hat, legt sich eine neue an, die sichtbar ist. Am
|
|
62
|
+
02.09.2026 blitzte deshalb bei jedem Aufruf ein Fenster auf; gemessen
|
|
63
|
+
wurde: konsolenlos einmal Blitz in drei Läufen, versteckte Konsole
|
|
64
|
+
keinmal.
|
|
65
|
+
|
|
66
|
+
`CREATE_NEW_CONSOLE` mit `SW_HIDE` gibt dem Prozess eine eigene, aber
|
|
67
|
+
unsichtbare Konsole, die seine Kinder erben.
|
|
68
|
+
"""
|
|
69
|
+
if sys.platform != "win32":
|
|
70
|
+
return {}
|
|
71
|
+
info = subprocess.STARTUPINFO()
|
|
72
|
+
info.dwFlags |= subprocess.STARTF_USESHOWWINDOW
|
|
73
|
+
info.wShowWindow = subprocess.SW_HIDE
|
|
74
|
+
return {"startupinfo": info,
|
|
75
|
+
"creationflags": subprocess.CREATE_NEW_CONSOLE}
|
|
76
|
+
|
|
77
|
+
|
|
78
|
+
def main() -> int:
|
|
79
|
+
if len(sys.argv) < 2:
|
|
80
|
+
sys.stderr.write("Aufruf: mcp-starter.py <knowmind.js> [args...]\n")
|
|
81
|
+
return 2
|
|
82
|
+
|
|
83
|
+
# Erstes Argument ist der zu startende Befehl (node, npx, …), Rest sind
|
|
84
|
+
# dessen Argumente. Unter Windows liegt npx als .cmd vor; subprocess findet
|
|
85
|
+
# es nur über den vollen Pfad, deshalb erst auflösen.
|
|
86
|
+
befehl = list(sys.argv[1:])
|
|
87
|
+
aufgeloest = shutil.which(befehl[0])
|
|
88
|
+
if aufgeloest:
|
|
89
|
+
befehl[0] = aufgeloest
|
|
90
|
+
|
|
91
|
+
try:
|
|
92
|
+
prozess = subprocess.Popen(
|
|
93
|
+
befehl,
|
|
94
|
+
stdin=subprocess.PIPE,
|
|
95
|
+
stdout=subprocess.PIPE,
|
|
96
|
+
stderr=sys.stderr,
|
|
97
|
+
bufsize=0,
|
|
98
|
+
**_ohne_fenster(),
|
|
99
|
+
)
|
|
100
|
+
except FileNotFoundError:
|
|
101
|
+
sys.stderr.write(f"node nicht gefunden: {node}\n")
|
|
102
|
+
return 127
|
|
103
|
+
|
|
104
|
+
faeden = [
|
|
105
|
+
threading.Thread(target=pumpe, args=(sys.stdin.buffer, prozess.stdin), daemon=True),
|
|
106
|
+
threading.Thread(target=pumpe, args=(prozess.stdout, sys.stdout.buffer), daemon=True),
|
|
107
|
+
]
|
|
108
|
+
for f in faeden:
|
|
109
|
+
f.start()
|
|
110
|
+
|
|
111
|
+
try:
|
|
112
|
+
return prozess.wait()
|
|
113
|
+
except KeyboardInterrupt:
|
|
114
|
+
prozess.terminate()
|
|
115
|
+
return 0
|
|
116
|
+
|
|
117
|
+
|
|
118
|
+
if __name__ == "__main__":
|
|
119
|
+
raise SystemExit(main())
|