@arkvenai/cli 0.5.1 → 0.6.0

package/dist/index.js

@@ -1,352 +1,81 @@
 #!/usr/bin/env node
-import fs from 'node:fs';
-import path from 'node:path';
-import readline from 'node:readline/promises';
-import { alsJson, alsSarif, alsText, exitCode } from './befund.js';
-import { baueAuftrag } from './auftrag.js';
-import { fahreFix } from './fix.js';
-import { fahreInit } from './init.js';
-import { fahreLogin, nimmEinfuegeWert, tageBis, zugangsDatei } from './login.js';
-import { fahreNeu } from './neu.js';
-import { richteBezugEin } from './npmrc.js';
-import { fahrePush, leseArkvenDatei, sammleTeile } from './push.js';
-import { alsBefunde, tiefPruefen } from './tiefpruefung.js';
-const DEKLARATION = 'arkven.json';
-import { fahrePull } from './pull.js';
-import { deklarationsBefunde } from './deklaration.js';
-import { pruefeAnker, pruefeMailArten } from './bauplan.js';
-import { pruefeVertrag } from './vertrag.js';
-import { BEFEHLE } from './befehle.js';
-const VERSION = '0.5.1';
-function gib(e, flags) {
-    if (flags.has('--sarif'))
-        return alsSarif(e, VERSION);
-    if (flags.has('--json'))
-        return alsJson(e);
-    return alsText(e);
-}
-function umbrich(einzug, text, breite = 98) {
-    const folgeEinzug = ' '.repeat(einzug.length);
-    const zeilen = [];
-    let laufend = einzug;
-    for (const wort of text.split(' ')) {
-        if (laufend.trimEnd().length > einzug.length && laufend.length + 1 + wort.length > breite) {
-            zeilen.push(laufend);
-            laufend = folgeEinzug + wort;
-        }
-        else {
-            laufend = laufend.trimEnd().length === einzug.trimEnd().length && laufend.endsWith(' ')
-                ? laufend + wort
-                : laufend + ' ' + wort;
-        }
-    }
-    zeilen.push(laufend);
-    return zeilen;
-}
-function befehlsZeilen(namen) {
-    const zeilen = [];
-    for (const name of namen) {
-        const b = BEFEHLE.find((x) => x.name === name);
-        if (!b)
-            continue;
-        const kopf = `  arkven ${b.name}${b.stelle ? ' ' + b.stelle : ''}`;
-        zeilen.push(...umbrich(kopf.padEnd(30), b.wirkung));
-        for (const s of b.schalter)
-            zeilen.push(...umbrich(`    ${s.flagge.padEnd(26)}`, s.wirkung));
-    }
-    return zeilen.join(String.fromCharCode(10));
-}
-const HILFE = `arkven ${VERSION} - eigene Projekte auf Arkven
+import { login, status, umgebung } from './befehle.js';
+import { live, pull, push } from './uebertragen.js';
+/**
+ * Die Befehlsverteilung. Sie tut selbst nichts, ausser Argumente zu lesen und den
+ * richtigen Befehl zu rufen: was hier an Logik stuende, waere an einem Ort, an dem sie
+ * niemand vermutet.
+ */
+const HILFE = `arkven -- dein Arkven auf diesem Rechner
 
-So geht der Rundlauf. Eine App, die es in Arkven schon gibt:
-  1. arkven login                    einmal pro Rechner
-  2. arkven pull                     zeigt deine Projekte, du wählst die Nummer
-  3. Änderungen machen
-  4. arkven push                     Vorschau ansehen und bestätigen
-  5. arkven push --deploy            online stellen
+  arkven login [--server=<adresse>] [--umgebung=<name>]
+      Diesen Rechner anmelden. Du bestaetigst im Browser.
 
-Ein Projekt, das auf deinem Rechner entstanden ist:
-  1. arkven login
-  2. arkven init                     schreibt arkven.json
-  3. arkven push --name="Mein Tool"  legt das Projekt in Arkven an
-  4. arkven push --deploy            online stellen
+  arkven status [--umgebung=<name>]
+      Wer du bist, welche Umgebung gilt, welche Apps es gibt.
 
-${befehlsZeilen(['new', 'init', 'check', 'auftrag', 'fix', 'login', 'pull'])}
+  arkven umgebung [<name>] [--weg=<name>]
+      Ohne Namen: alle angemeldeten Umgebungen, die aktive mit einem Stern.
+      Mit Namen: diese wird aktiv.
 
-Der Code wird nach verzeichnisse abgelegt, derselben Angabe, nach der push sammelt. pull löscht
-nie etwas: Dateien, die nur bei dir liegen, bleiben unberührt.
-${befehlsZeilen(['push'])}
+  arkven pull [--app=<kennung>] [--ja]
+      Den Quelltext einer App in diesen Ordner holen. Ohne --ja nur die Vorschau.
 
-Liegen Server und Frontend in getrennten Ordnern, sagt das arkven.json:
-  "verzeichnisse": { "server": "server", "frontend": "web" }
-Dann sammelt push beide Teile und schickt sie getrennt: das Frontend wird die Vorschau, der Server
-geht in den Container. Ohne diese Angabe bleibt alles wie bisher.
-${befehlsZeilen(['version', 'help'])}
+  arkven push [--betreff="..."] [--ja]
+      Den Quelltext von hier nach Arkven. Ohne --ja nur die Vorschau.
 
-Rückgabewerte von check: 0 alles gehalten - 1 mindestens ein blockierender Punkt - 2 nichts messbar.
-Rückgabewerte von init:  0 alles geklärt - 1 etwas bleibt zu entscheiden - 2 nichts messbar.
-Rückgabewerte von new:   0 angelegt und nachgemessen - 1 abgebrochen, nichts angelegt.
-Rückgabewerte von push:  0 übernommen - 1 etwas blockiert (Befund oder Konflikt) - 2 nichts messbar.
+  arkven live [--ja]
+      Die App live schalten. Ohne --ja nur der Hinweis, was passieren wuerde.
 
-Bei einem Konflikt bricht push ab und nennt die Dateien. Es gibt bewusst kein --force: eine
-automatische Wahl würde eine der beiden Fassungen still verlieren.
-
-${befehlsZeilen(['mcp'])}
+Ueberall moeglich: --umgebung=<name>, wenn nicht die aktive gemeint ist.
 `;
-async function frageImTerminal(text, vorschlag) {
-    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
-    try {
-        const antwort = (await rl.question(`\n${text}\n[${vorschlag ? 'J/n' : 'j/N'}] `)).trim().toLowerCase();
-        if (antwort === '')
-            return vorschlag;
-        return antwort === 'j' || antwort === 'ja' || antwort === 'y' || antwort === 'yes';
-    }
-    finally {
-        rl.close();
-    }
-}
-async function frageTextImTerminal(text) {
-    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
-    try {
-        return (await rl.question(`\n${text}\n> `)).trim();
-    }
-    finally {
-        rl.close();
-    }
+function flagge(argv, name) {
+    const mit = argv.find((a) => a.startsWith(`--${name}=`));
+    if (mit)
+        return mit.slice(name.length + 3);
+    return undefined;
 }
-async function alleZusatzBefunde(wurzel) {
-    const befunde = deklarationsBefunde(wurzel);
-    const datei = leseArkvenDatei(wurzel);
-    const v = datei['verzeichnisse'];
-    const verz = v && typeof v === 'object' && !Array.isArray(v) ? v : {};
-    const teile = sammleTeile(wurzel, {
-        ...(typeof verz.server === 'string' ? { server: verz.server } : {}),
-        ...(typeof verz.frontend === 'string' ? { frontend: verz.frontend } : {}),
-    });
-    const tief = await tiefPruefen(teile.app.sammlung.dateien, (teile.server ?? teile.app).sammlung.dateien);
-    if (!tief.erreichbar)
-        return befunde;
-    befunde.push(...alsBefunde(tief.ergebnis));
-    befunde.push(...pruefeMailArten(wurzel, tief.ergebnis.mailArten ?? []));
-    befunde.push(...pruefeAnker(teile.app.sammlung.dateien, tief.ergebnis.screens ?? []));
-    return befunde;
-}
-async function main(argv) {
-    const [befehl, ...rest] = argv;
-    const flags = new Set(rest.filter((a) => a.startsWith('--')));
-    const stellen = rest.filter((a) => !a.startsWith('--'));
+const hat = (argv, name) => argv.includes(`--${name}`);
+export async function fahre(argv, sage) {
+    const befehl = argv.find((a) => !a.startsWith('-')) ?? '';
+    const gemeinsam = { umgebung: flagge(argv, 'umgebung'), sage };
+    const bestaetigt = hat(argv, 'ja');
+    const wurzel = process.cwd();
     switch (befehl) {
-        case 'new': {
-            const name = stellen[0];
-            if (!name) {
-                console.error('`arkven new` braucht einen Namen für das neue Projekt.');
-                console.error('So kommst du weiter: `arkven new meine-app` legt ./meine-app an.');
-                return 1;
-            }
-            const e = await fahreNeu(name, { sage: (z) => console.log(z) });
-            return e.code;
-        }
-        case 'init': {
-            const wurzel = path.resolve(stellen[0] ?? process.cwd());
-            const e = await fahreInit(wurzel, {
-                sage: (z) => console.log(z),
-                frage: process.stdin.isTTY ? frageImTerminal : undefined,
-                uebernehmen: flags.has('--apply'),
-            });
-            return e.code;
-        }
-        case 'check': {
-            const wurzel = path.resolve(stellen[0] ?? process.cwd());
-            const ergebnis = pruefeVertrag(wurzel);
-            ergebnis.befunde.push(...deklarationsBefunde(wurzel));
-            if (flags.has('--tief')) {
-                const datei = leseArkvenDatei(wurzel);
-                const v = datei['verzeichnisse'];
-                const verz = v && typeof v === 'object' && !Array.isArray(v) ? v : {};
-                const teile = sammleTeile(wurzel, {
-                    ...(typeof verz.server === 'string' ? { server: verz.server } : {}),
-                    ...(typeof verz.frontend === 'string' ? { frontend: verz.frontend } : {}),
-                });
-                const serverBaum = (teile.server ?? teile.app).sammlung.dateien;
-                const appBaum = teile.app.sammlung.dateien;
-                if (!appBaum.some((d) => d.pfad === DEKLARATION)) {
-                    let ordner = wurzel;
-                    for (let i = 0; i < 3; i++) {
-                        try {
-                            const inhalt = fs.readFileSync(path.join(ordner, DEKLARATION), 'utf8');
-                            appBaum.push({ pfad: DEKLARATION, inhalt });
-                            if (ordner !== wurzel)
-                                console.log(`Deklaration aus ${ordner} gelesen (sie beschreibt das ganze Projekt).`);
-                            break;
-                        }
-                        catch {
-                            const oben = path.dirname(ordner);
-                            if (oben === ordner)
-                                break;
-                            ordner = oben;
-                        }
-                    }
-                }
-                console.log('Die Gates der Plattform laufen mit (dieselbe Prüfung wie beim Ausrollen) …');
-                const tief = await tiefPruefen(appBaum, serverBaum);
-                if (tief.erreichbar) {
-                    ergebnis.befunde.push(...alsBefunde(tief.ergebnis));
-                    ergebnis.befunde.push(...pruefeMailArten(wurzel, tief.ergebnis.mailArten ?? []));
-                    ergebnis.befunde.push(...pruefeAnker(appBaum, tief.ergebnis.screens ?? []));
-                    for (const c of tief.ergebnis.checks)
-                        if (c.ok)
-                            ergebnis.gehalten.push(c.regel ?? c.name);
-                    console.log(gib(ergebnis, flags));
-                    for (const u of tief.ergebnis.ungeprueft)
-                        console.log(`?  nicht geprüft: ${u}`);
-                    return exitCode(ergebnis);
-                }
-                ergebnis.befunde.push({
-                    regel: 'arkven/plattform-gates',
-                    schwere: 'ungeprueft',
-                    titel: 'Die Gates der Plattform sind in diesem Lauf nicht mitgelaufen.',
-                    ausweg: tief.grund,
-                });
-            }
-            console.log(gib(ergebnis, flags));
-            return exitCode(ergebnis);
-        }
-        case 'auftrag': {
-            const wurzel = path.resolve(stellen[0] ?? process.cwd());
-            const mitBauplan = pruefeVertrag(wurzel);
-            mitBauplan.befunde.push(...(await alleZusatzBefunde(wurzel)));
-            const auftrag = baueAuftrag(mitBauplan);
-            if (!auftrag) {
-                console.log('Es blockiert nichts, deshalb gibt es keinen Auftrag.');
-                return 0;
-            }
-            console.log(auftrag);
-            return 0;
-        }
-        case 'fix': {
-            const wurzel = path.resolve(stellen[0] ?? process.cwd());
-            const rundenArg = rest.find((a) => a.startsWith('--runden'));
-            const runden = Number(rundenArg?.split('=')[1] ?? rest[rest.indexOf('--runden') + 1] ?? 3);
-            if (!Number.isFinite(runden) || runden < 1 || runden > 10) {
-                console.error('`--runden` braucht eine Zahl zwischen 1 und 10.');
-                return 1;
-            }
-            console.log(`Claude Code bearbeitet gleich Dateien in ${wurzel}.`);
-            console.log('Datei-Änderungen werden dabei ohne Rückfrage übernommen - dafür hast du diesen Befehl aufgerufen.');
-            console.log('Alles andere bleibt hinter Claudes eigener Rückfrage. Es wird nichts committet und nichts gepusht.');
-            console.log('Sieh dir hinterher `git diff` an. Abbrechen mit Strg-C.\n');
-            const e = await fahreFix(wurzel, {
-                runden,
-                sage: (z) => console.log(z),
-                zusatzBefunde: () => alleZusatzBefunde(wurzel),
-            });
-            console.log('');
-            if (e.behoben.length > 0)
-                console.log(`Behoben und nachgemessen (${e.behoben.length}): ${e.behoben.join(', ')}`);
-            if (e.offen.length > 0)
-                console.log(`Weiterhin offen (${e.offen.length}): ${e.offen.join(', ')}`);
-            if (e.grund)
-                console.log(e.grund);
-            console.log(e.offen.length > 0
-                ? '\nSieh dir die Änderungen an (`git diff`) und rufe danach `arkven check` erneut auf.'
-                : '\nSieh dir die Änderungen an (`git diff`). Nächster Schritt: `arkven push --deploy`.');
-            return e.offen.length > 0 ? 1 : 0;
-        }
-        case 'version':
-        case '--version':
-        case '-v':
-            console.log(VERSION);
-            return 0;
-        case undefined:
+        case 'login':
+            return (await login({ server: flagge(argv, 'server'), umgebung: flagge(argv, 'umgebung'), sage })).code;
+        case 'status':
+            return (await status(gemeinsam)).code;
+        case 'umgebung':
+            return umgebung({
+                name: argv.filter((a) => !a.startsWith('-'))[1],
+                weg: flagge(argv, 'weg'),
+                sage,
+            }).code;
+        case 'pull':
+            return (await pull(wurzel, { ...gemeinsam, app: flagge(argv, 'app'), bestaetigt })).code;
+        case 'push':
+            return (await push(wurzel, { ...gemeinsam, app: flagge(argv, 'app'), betreff: flagge(argv, 'betreff'), bestaetigt })).code;
+        case 'live':
+            return (await live(wurzel, { ...gemeinsam, app: flagge(argv, 'app'), bestaetigt })).code;
+        case '':
         case 'help':
         case '--help':
-        case '-h':
-            console.log(HILFE);
-            return 0;
-        case 'login': {
-            const serverArg = rest.find((a) => a.startsWith('--server='))?.split('=')[1];
-            let e;
-            if (flags.has('--einfuegen')) {
-                if (!process.stdin.isTTY) {
-                    console.error('`--einfuegen` braucht ein Terminal, in das du den Wert einfügen kannst.');
-                    console.error('So kommst du weiter: den Befehl direkt in einer Eingabeaufforderung ausführen.');
-                    return 1;
-                }
-                const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
-                const wert = await rl.question('\nWert von der Bestätigungsseite einfügen (beginnt mit arkv1_):\n> ');
-                rl.close();
-                e = nimmEinfuegeWert(wert);
-            }
-            else {
-                e = await fahreLogin({ server: serverArg, sage: (z) => console.log(z) });
-            }
-            if (e.code !== 0 || !e.zugang) {
-                console.error('');
-                console.error(e.grund ?? 'Die Anmeldung ist fehlgeschlagen.');
-                return e.code;
-            }
-            const bezug = richteBezugEin(e.zugang.server, e.zugang.registryToken, path.resolve(stellen[0] ?? process.cwd()));
-            const teams = e.zugang.teams ?? [];
-            console.log('');
-            console.log(`  Angemeldet. Der Zugang gilt für ${teams.length} Team(s)${teams.length ? `: ${teams.map((t) => t.name).join(', ')}` : ''}.`);
-            console.log(`  Er läuft in ${tageBis(e.zugang.laeuftAbAm.registry)} Tagen ab und ist jederzeit in den Konto-Einstellungen entziehbar.`);
-            console.log(`  Gespeichert in ${zugangsDatei()}`);
-            console.log(`  Paketbezug eingerichtet: ${bezug.projektDatei} (Zuordnung) und ${bezug.benutzerDatei} (Token)`);
-            console.log('');
-            console.log('  `npm install @arkvenai/base` funktioniert jetzt in diesem Projekt.');
-            console.log('  Nächster Schritt: `arkven check` prüft dein Projekt.');
+            sage(HILFE);
             return 0;
-        }
-        case 'pull': {
-            const wurzel = path.resolve(stellen[0] ?? process.cwd());
-            const e = await fahrePull(wurzel, {
-                sage: (z) => console.log(z),
-                frage: process.stdin.isTTY ? (text) => frageImTerminal(text, false) : undefined,
-                ja: flags.has('--yes') || flags.has('--ja'),
-                server: rest.find((a) => a.startsWith('--server='))?.split('=')[1],
-                nurDeklaration: flags.has('--nur-deklaration'),
-                projektId: rest.find((a) => a.startsWith('--projekt='))?.split('=')[1],
-                frageText: process.stdin.isTTY ? (text) => frageTextImTerminal(text) : undefined,
-            });
-            if (e.grund) {
-                console.log('');
-                if (e.code === 0)
-                    console.log(e.grund);
-                else
-                    console.error(e.grund);
-            }
-            return e.code;
-        }
-        case 'push': {
-            const wurzel = path.resolve(stellen[0] ?? process.cwd());
-            const e = await fahrePush(wurzel, {
-                sage: (z) => console.log(z),
-                frage: process.stdin.isTTY ? (text) => frageImTerminal(text, false) : undefined,
-                frageText: process.stdin.isTTY ? (text) => frageTextImTerminal(text) : undefined,
-                ja: flags.has('--yes') || flags.has('--ja'),
-                deploy: flags.has('--deploy'),
-                server: rest.find((a) => a.startsWith('--server='))?.split('=')[1],
-                name: rest.find((a) => a.startsWith('--name='))?.split('=')[1],
-                team: rest.find((a) => a.startsWith('--team='))?.split('=')[1],
-            });
-            if (e.grund) {
-                console.log('');
-                if (e.code === 0)
-                    console.log(e.grund);
-                else
-                    console.error(e.grund);
-            }
-            return e.code;
-        }
-        case 'mcp': {
-            const { fahreMcp } = await import('./mcp.js');
-            return await fahreMcp();
-        }
         default:
-            console.error(`Unbekannter Befehl: ${befehl}`);
-            console.error('So kommst du weiter: `arkven help` zeigt, was es gibt.');
+            sage(`"${befehl}" kennt arkven nicht.`);
+            sage('');
+            sage(HILFE);
             return 1;
     }
 }
-void main(process.argv.slice(2)).then((code) => process.exit(code));
-//# sourceMappingURL=index.js.map
+// Nur ausfuehren, wenn dieses Modul der Einstieg ist -- die Probe importiert es.
+if (process.argv[1] && import.meta.url.endsWith(process.argv[1].replace(/\\/g, '/').split('/').pop() ?? '')) {
+    fahre(process.argv.slice(2), (z) => console.log(z))
+        .then((code) => process.exit(code))
+        .catch((f) => {
+        console.error(f instanceof Error ? f.message : String(f));
+        process.exit(1);
+    });
+}

package/dist/projekt.js

@@ -0,0 +1,121 @@
+import fs from 'node:fs';
+import path from 'node:path';
+export const DATEI = 'arkven.json';
+export function lesen(wurzel) {
+    try {
+        const j = JSON.parse(fs.readFileSync(path.join(wurzel, DATEI), 'utf8'));
+        return j.app ? { app: j.app, umgebung: j.umgebung, name: j.name } : null;
+    }
+    catch {
+        return null;
+    }
+}
+export function schreiben(wurzel, v) {
+    fs.writeFileSync(path.join(wurzel, DATEI), JSON.stringify(v, null, 2) + '\n', 'utf8');
+}
+/**
+ * Was NICHT mitgeschickt wird.
+ *
+ * Auf dem Server entscheidet das git; hier gibt es kein git, auf das man sich verlassen
+ * koennte -- ein frisch gezogener Ordner hat keins. Diese Liste ist deshalb bewusst
+ * kurz und nennt nur, was ueberall dasselbe bedeutet. Alles andere geht mit: eine
+ * Datei, die jemand angelegt hat, gehoert ihm, und wir raten nicht, ob er sie meint.
+ */
+const NICHT_MIT = new Set([
+    'node_modules',
+    '.git',
+    'dist',
+    'build',
+    '.next',
+    '.turbo',
+    '.cache',
+    'coverage',
+    '.arkven',
+]);
+/**
+ * Dateien ohne Endung, die trotzdem Quelltext sind. Sie stehen in EINER Liste mit denen,
+ * die den Versteckt-Filter passieren duerfen: zwei Listen fuer dieselbe Frage waren der
+ * Fehler, den die Gegenprobe gefunden hat. Die .gitignore kam durch den einen Filter
+ * und blieb am anderen haengen, weil sie keine Endung hat.
+ */
+const BEKANNT_ALS_TEXT = new Set(['.gitignore', '.env.example', '.npmrc', 'Dockerfile', 'Procfile']);
+/**
+ * Was sonst als Text lesbar ist. Bilder, Schriften und Videos gehen diesen Weg nicht:
+ * sie wuerden als kaputter Text ankommen, und das waere schlimmer als sie wegzulassen.
+ */
+const TEXT = /\.(tsx?|jsx?|mjs|cjs|css|scss|json|md|sql|html?|ya?ml|txt|svg)$/i;
+function istText(name) {
+    return BEKANNT_ALS_TEXT.has(name) || TEXT.test(name);
+}
+/** Wieviel eine einzelne Datei hoechstens wiegt. Darueber ist es kein Quelltext mehr. */
+const ZEICHEN_JE_DATEI = 400_000;
+export function sammeln(wurzel) {
+    const dateien = [];
+    const uebersprungen = [];
+    const gehen = (ordner, praefix) => {
+        let eintraege;
+        try {
+            eintraege = fs.readdirSync(ordner, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const e of eintraege) {
+            if (NICHT_MIT.has(e.name))
+                continue;
+            // Versteckte Dateien bleiben draussen, bis auf die, die zum Projekt gehoeren -
+            // dieselbe Liste, die auch "ist das Text" beantwortet. Eine .env steht bewusst
+            // NICHT darin: dort liegen Geheimnisse, und die gehen keinen Push mit.
+            if (e.name.startsWith('.') && !BEKANNT_ALS_TEXT.has(e.name))
+                continue;
+            const relativ = praefix ? `${praefix}/${e.name}` : e.name;
+            const voll = path.join(ordner, e.name);
+            if (e.isDirectory()) {
+                gehen(voll, relativ);
+                continue;
+            }
+            if (!e.isFile())
+                continue;
+            if (relativ === DATEI)
+                continue;
+            if (!istText(e.name)) {
+                uebersprungen.push(relativ);
+                continue;
+            }
+            let inhalt;
+            try {
+                inhalt = fs.readFileSync(voll, 'utf8');
+            }
+            catch {
+                uebersprungen.push(relativ);
+                continue;
+            }
+            if (inhalt.length > ZEICHEN_JE_DATEI) {
+                uebersprungen.push(relativ);
+                continue;
+            }
+            dateien.push({ pfad: relativ, inhalt });
+        }
+    };
+    gehen(wurzel, '');
+    return { dateien: dateien.sort((a, b) => a.pfad.localeCompare(b.pfad)), uebersprungen };
+}
+/** Die Grenze zwischen Oberflaeche und Server, dieselbe wie auf dem Server. */
+export function istServerDatei(pfad) {
+    return pfad === 'server' || pfad.startsWith('server/');
+}
+export function schreibenAufPlatte(wurzel, dateien) {
+    let n = 0;
+    for (const d of dateien) {
+        // Derselbe Riegel wie auf dem Server, und aus demselben Grund: nachrechnen statt
+        // ein Muster gegen ".." legen. Was von aussen kommt, darf nicht ausserhalb des
+        // Ordners landen -- auch dann nicht, wenn es vom eigenen Server kommt.
+        const ziel = path.resolve(wurzel, d.pfad);
+        if (ziel !== wurzel && !ziel.startsWith(wurzel + path.sep))
+            continue;
+        fs.mkdirSync(path.dirname(ziel), { recursive: true });
+        fs.writeFileSync(ziel, d.inhalt, 'utf8');
+        n++;
+    }
+    return n;
+}

package/dist/ruf.js

@@ -0,0 +1,45 @@
+import { createHash, randomBytes } from 'node:crypto';
+export async function ruf(server, weg, opts = {}) {
+    const adresse = `${server.replace(/\/+$/, '')}${weg}`;
+    try {
+        const res = await fetch(adresse, {
+            method: opts.methode ?? (opts.koerper ? 'POST' : 'GET'),
+            headers: {
+                ...(opts.koerper ? { 'content-type': 'application/json' } : {}),
+                ...(opts.token ? { authorization: `Bearer ${opts.token}` } : {}),
+            },
+            body: opts.koerper ? JSON.stringify(opts.koerper) : undefined,
+        });
+        const daten = (await res.json().catch(() => ({})));
+        if (!res.ok)
+            return { ok: false, status: res.status, daten };
+        return { ok: true, status: res.status, daten: daten };
+    }
+    catch (e) {
+        // Kein Netz ist kein HTTP-Fehler: Status 0 sagt dem Aufrufer, dass die Anfrage nie
+        // angekommen ist. Der Unterschied zaehlt - bei einem Push heisst das "es wurde
+        // nichts geaendert", bei einem 500 weiss man das nicht.
+        return { ok: false, status: 0, daten: {}, netz: String(e?.message ?? e) };
+    }
+}
+/**
+ * Der Satz, den ein Mensch aus einer Absage liest.
+ *
+ * Der Server schickt "fehler" und oft "ausweg". Beide gehoeren zusammen: ein Grund
+ * ohne Weg hinaus ist eine Sackgasse, und wer in einer Sackgasse steht, probiert
+ * dasselbe noch einmal.
+ */
+export function absage(a) {
+    if (a.ok)
+        return '';
+    if (a.netz)
+        return `Arkven war nicht erreichbar: ${a.netz}`;
+    const grund = String(a.daten.fehler ?? a.daten.error ?? `Arkven antwortete mit ${a.status}.`);
+    const ausweg = a.daten.ausweg ? `\n${String(a.daten.ausweg)}` : '';
+    return grund + ausweg;
+}
+export function neuesGeheimnis() {
+    const verifier = randomBytes(32).toString('base64url');
+    return { verifier, challenge: createHash('sha256').update(verifier).digest('base64url') };
+}
+export const schlafe = (ms) => new Promise((f) => setTimeout(f, ms));