onlymcp 0.9.1 → 0.11.0

package/dist/bin/cli.js

@@ -5,18 +5,24 @@ import open from 'open';
 import QRCode from 'qrcode';
 import { createRequire } from 'node:module';
 import { homedir } from 'node:os';
-import { appendFileSync, existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { createWriteStream, existsSync, mkdirSync } from 'node:fs';
+import { pipeline } from 'node:stream/promises';
+import { Readable } from 'node:stream';
 import { dirname, join } from 'node:path';
-import { ApiClient } from '../apiClient.js';
+import { ApiClient, ApiError } from '../apiClient.js';
 import { Keyring } from '../auth/keyring.js';
 import { pollForToken } from '../auth/deviceLogin.js';
 import { TtlCache } from '../cache.js';
-import { targets } from '../install.js';
+import { planInstall, writeInstallTarget } from '../install.js';
 import { stubDirs } from '../paths.js';
 import { writeStubs } from '../stubs.js';
 import { collect } from '../import/collect.js';
 import { buildImportPlan } from '../import/plan.js';
 import { countPlan, runUpload } from '../import/upload.js';
+import { countTargets, isEmpty, planPrune, runPrune } from '../import/prune.js';
+import { syncMemoryToDisk } from '../memorySync.js';
+import { unpackArchive } from '../export/unpack.js';
+import { deviceLabel } from '../identity.js';
 const baseUrl = process.env.ONLYMCP_API_URL ?? 'https://only-mcp.com';
 // Die Version kommt aus der package.json und steht nicht ein zweites Mal hier
 // als Literal: sonst meldet `onlymcp --version` nach der ersten
@@ -39,32 +45,16 @@ function safeOpenUrl(url, expectedOrigin) {
         return false;
     }
 }
-// `writeFileSync` allein wuerde ~/.claude.json oder ~/.gemini/settings.json
-// komplett ersetzen und damit jede andere dort gespeicherte Einstellung
-// wegwerfen. Eine vorhandene, aber kaputte Datei wird nie stillschweigend
-// ueberschrieben, lieber ein Fehler als ein Datenverlust.
-function mergeJsonMcpServer(path, key, value) {
-    let existing = {};
-    if (existsSync(path)) {
-        const raw = readFileSync(path, 'utf8').trim();
-        if (raw) {
-            try {
-                existing = JSON.parse(raw);
-            }
-            catch {
-                throw new Error(`${path} enthaelt ungueltiges JSON. Nichts geschrieben.`);
-            }
-        }
-    }
-    const mcpServers = existing.mcpServers ?? {};
-    existing.mcpServers = { ...mcpServers, [key]: value };
-    writeFileSync(path, `${JSON.stringify(existing, null, 2)}\n`, 'utf8');
-}
 program
     .command('login')
-    .description('Dieses Geraet mit OnlyMCP verbinden')
+    .description('Connect this device to OnlyMCP')
     .action(async () => {
     intro('OnlyMCP');
+    // Einmal ehrlich sagen, was mitgeht, BEVOR es mitgeht. Die beiden Werte
+    // stehen nachher in der Geraeteliste dieses Kontos, sonst nirgends - aber
+    // wer sie nicht schicken will, soll das erfahren, solange er noch abbrechen
+    // kann.
+    log.info(`This device will register itself as: ${await deviceLabel()}`);
     const res = await fetch(`${baseUrl}/api/auth/device/code`, {
         method: 'POST',
         headers: { 'content-type': 'application/json' },
@@ -81,99 +71,197 @@ program
         await open(d.verification_uri_complete).catch(() => { });
     }
     const s = spinner();
-    s.start('Warte auf Bestaetigung');
+    s.start('Waiting for confirmation');
     const token = await pollForToken(baseUrl, d.device_code, d.interval ?? 5);
     Keyring.save(token);
-    s.stop('Verbunden');
+    s.stop('Connected');
     const api = new ApiClient(baseUrl, () => Keyring.read());
-    let counts = { skills: 0, agents: 0, files: 0 };
-    for (const dir of stubDirs())
-        counts = await writeStubs(api, dir);
-    outro(`${counts.skills} Skills, ${counts.agents} Agents, ${counts.files} Dateien bereit`);
+    const counts = await writeStubsEverywhere(api);
+    outro(`${counts.skills} skills, ${counts.agents} agents, ${counts.files} files ready`);
 });
+/**
+ * Stubs in jeden Ordner, den ein Client auf diesem Geraet liest.
+ *
+ * Gezaehlt wird ueber alle Ordner zusammen, nicht der letzte: bis Aufgabe 12
+ * ueberschrieb die Schleife ihr Ergebnis bei jedem Durchlauf und meldete
+ * deshalb die Zahlen des zuletzt beschriebenen Ordners als Gesamtzahl.
+ */
+async function writeStubsEverywhere(api) {
+    const total = { skills: 0, agents: 0, files: 0, kept: [] };
+    for (const dir of stubDirs()) {
+        const c = await writeStubs(api, dir);
+        total.skills += c.skills;
+        total.agents += c.agents;
+        total.files += c.files;
+        for (const k of c.kept)
+            total.kept.push(`${dir}/${k}`);
+    }
+    return total;
+}
+/**
+ * Reports a finished import or sync, for the "last import / last sync" line on the devices page.
+ * A report that fails (an older server answering 404, no network, a timeout) prints nothing and
+ * changes nothing: the command already succeeded.
+ */
+async function reportRun(api, kind, files) {
+    try {
+        await api.reportRun(kind, files);
+    }
+    catch {
+        /* deliberately silent, see above */
+    }
+}
+/**
+ * Ends this device's session on the server (next round A6). Clearing only the keyring left the
+ * session alive there, where it kept counting as a device until it expired. Best effort: null when
+ * the session ended, else what went wrong, and the logout goes on on this machine either way.
+ */
+async function endServerSession(token) {
+    try {
+        await new ApiClient(baseUrl, () => token).signOut();
+        return null;
+    }
+    catch (e) {
+        if (e instanceof ApiError && e.status > 0)
+            return `HTTP ${e.status}`;
+        return e instanceof Error ? e.message : String(e);
+    }
+}
 program
     .command('logout')
-    .description('Anmeldung und Cache auf diesem Geraet loeschen')
+    .description("End this device's session, then remove its login and cache")
     .action(async () => {
+    // The server first, while the token is still here to name the session by.
+    const token = Keyring.read();
+    const failure = token ? await endServerSession(token) : null;
     Keyring.clear();
     await new TtlCache().clear();
-    log.success('Abgemeldet');
+    if (failure) {
+        log.warn(`The session on the server could not be ended (${failure}). It counts as a device until it ` +
+            'expires, or until you remove it in the dashboard under Sessions and devices.');
+        log.success('Logged out on this device');
+        return;
+    }
+    log.success('Logged out');
 });
 program
     .command('status')
-    .description('Zeigt, ob dieses Geraet angemeldet ist')
+    .description('Show whether this device is logged in')
     .action(() => {
-    log.info(Keyring.read() ? 'angemeldet' : 'nicht angemeldet');
+    log.info(Keyring.read() ? 'logged in' : 'not logged in');
 });
 program
     .command('sync')
-    .description('Stub-Dateien neu schreiben')
-    .action(async () => {
+    .description('Rewrite the stub files')
+    .option('--memory <dir>', 'Also write memory as files into this folder')
+    .action(async (opts) => {
     const api = new ApiClient(baseUrl, () => Keyring.read());
-    let counts = { skills: 0, agents: 0, files: 0 };
-    for (const dir of stubDirs())
-        counts = await writeStubs(api, dir);
-    log.success(`${counts.skills} Skills, ${counts.agents} Agents, ${counts.files} Dateien`);
+    const counts = await writeStubsEverywhere(api);
+    log.success(`${counts.skills} skills, ${counts.agents} agents, ${counts.files} files`);
+    if (counts.kept.length > 0) {
+        // Stubs liegen in denselben Ordnern, aus denen importiert wird. Was
+        // dort schon stand und kein Stub war, bleibt stehen - aber nicht
+        // stillschweigend, sonst sucht jemand einen Stub, der nie geschrieben
+        // wurde. Gekuerzt, weil ein Geraet mit 270 eigenen Agent-Dateien sonst
+        // 270 Zeilen bekaeme und die Erfolgsmeldung aus dem Bild schoebe.
+        log.warn([
+            `Left untouched, because something of your own is already there (${counts.kept.length})`,
+            ...counts.kept.slice(0, 10).map((k) => `  ${k}`),
+            ...(counts.kept.length > 10 ? [`  ... and ${counts.kept.length - 10} more`] : []),
+        ].join('\n'));
+    }
+    // Every file this run wrote: the stubs, the skills' companion files, and (below) memory.
+    const stubFiles = counts.skills + counts.agents + counts.files;
+    if (!opts.memory) {
+        await reportRun(api, 'sync', stubFiles);
+        return;
+    }
+    const m = await syncMemoryToDisk(api, opts.memory);
+    log.success(`${m.written} memory files to ${opts.memory}`);
+    if (m.collisions.length > 0) {
+        log.warn([
+            'Team files with a path an existing file of yours already has',
+            ...m.collisions.map((p) => `  ${p}`),
+        ].join('\n'));
+    }
+    if (m.refused.length > 0) {
+        log.warn(['Paths refused', ...m.refused.map((p) => `  ${p}`)].join('\n'));
+    }
+    if (m.failures.length > 0) {
+        log.error([`${m.failures.length} failed`, ...m.failures.map((f) => `  ${f.what}   ${f.code}`)].join('\n'));
+        process.exitCode = 1;
+    }
+    // A sync with failures is not a successful one: nothing is reported for it.
+    if (m.failures.length === 0)
+        await reportRun(api, 'sync', stubFiles + m.written);
 });
 program
     .command('install')
-    .description('OnlyMCP in einem MCP-Client eintragen')
-    .option('--client <id>', 'claude, codex oder gemini')
-    .option('--print', 'nur ausgeben, nichts schreiben')
+    .description('Register OnlyMCP in an MCP client')
+    .option('--client <id>', 'claude-code, codex or gemini-cli (aliases: claude, gemini)')
+    .option('--all', 'Write every config file that already exists on this machine')
+    .option('--print', 'Only print, write nothing')
     .action((opts) => {
     // ONLYMCP_HOME ist dieselbe Testschleuse wie in paths.ts: damit trifft
     // kein Testlauf jemals den echten ~/.codex- oder ~/.claude-Ordner.
-    const all = targets(process.env.ONLYMCP_HOME ?? homedir());
-    if (!opts.client) {
-        log.info(`Bekannte Clients: ${all.map((t) => t.id).join(', ')}`);
-        log.info('Fuer jeden anderen MCP-Client: --print und den Schnipsel selbst eintragen.');
-        return;
-    }
-    const t = all.find((x) => x.id === opts.client);
-    if (!t) {
-        // Kein Raten. Ein falsch geratener Pfad ueberschreibt sonst eine fremde
-        // Konfigurationsdatei.
-        log.error(`Unbekannter Client. Bekannt: ${all.map((x) => x.id).join(', ')}`);
-        process.exitCode = 1;
-        return;
-    }
-    if (opts.print) {
-        log.info(`${t.label} -> ${t.configPath}`);
-        console.log(t.snippet);
-        // Bewusst keine zweite Zeile mit ONLYMCP_STUB_DIRS: die Variable steht
-        // seit install.ts im Schnipsel selbst. Zwei Wege, dasselbe zu setzen,
-        // laden dazu ein, beide zu gehen.
-        return;
-    }
-    mkdirSync(dirname(t.configPath), { recursive: true });
-    try {
-        if (t.id === 'codex') {
-            // TOML wird angehaengt, nicht ersetzt. Ein zweiter Lauf haengt sonst
-            // ein zweites [mcp_servers.onlymcp] an, und zwei gleiche Tabellen
-            // machen die Datei fuer die meisten TOML-Parser ungueltig.
-            const already = existsSync(t.configPath) && readFileSync(t.configPath, 'utf8').includes('[mcp_servers.onlymcp]');
-            if (already) {
-                log.info(`${t.label} ist bereits eingerichtet: ${t.configPath}`);
-                return;
+    const home = process.env.ONLYMCP_HOME ?? homedir();
+    const outcome = planInstall(home, opts);
+    /** Writes one target, or only prints it with --print. Shared by --client and --all. */
+    function apply(t) {
+        if (opts.print) {
+            log.info(`${t.name} -> ${t.configPath}`);
+            console.log(t.snippet);
+            // Bewusst keine zweite Zeile mit ONLYMCP_STUB_DIRS: die Variable steht
+            // seit install.ts im Schnipsel selbst. Zwei Wege, dasselbe zu setzen,
+            // laden dazu ein, beide zu gehen.
+            return;
+        }
+        try {
+            const result = writeInstallTarget(t);
+            if (result === 'already-present') {
+                log.info(`${t.name} is already set up: ${t.configPath}`);
+            }
+            else {
+                log.success(`${t.name} set up: ${t.configPath}`);
             }
-            appendFileSync(t.configPath, `\n${t.snippet}`);
         }
-        else {
-            const parsed = JSON.parse(t.snippet);
-            const entry = Object.entries(parsed.mcpServers)[0];
-            if (!entry)
-                throw new Error(`${t.label}: leerer mcpServers-Schnipsel.`);
-            mergeJsonMcpServer(t.configPath, entry[0], entry[1]);
+        catch (e) {
+            log.error(e instanceof Error ? e.message : String(e));
+            process.exitCode = 1;
         }
     }
-    catch (e) {
-        log.error(e instanceof Error ? e.message : String(e));
-        process.exitCode = 1;
-        return;
+    switch (outcome.kind) {
+        case 'conflicting-options':
+            log.error('Pass either --client <id> or --all, not both.');
+            process.exitCode = 2;
+            return;
+        case 'missing-client':
+            log.info(`Known clients: ${outcome.targets.map((t) => t.id).join(', ')}`);
+            log.info('Pass --client <id>, or --all.');
+            process.exitCode = 2;
+            return;
+        case 'unknown-client':
+            // Kein Raten. Ein falsch geratener Pfad ueberschreibt sonst eine
+            // fremde Konfigurationsdatei.
+            log.error(`Unknown client. Known: ${outcome.targets.map((t) => t.id).join(', ')}`);
+            process.exitCode = 1;
+            return;
+        case 'none-present-for-all':
+            log.error('No known client is set up on this machine yet.');
+            log.info(`Pass --client <id> to write its config anyway. Known: ${outcome.targets.map((t) => t.id).join(', ')}.`);
+            process.exitCode = 2;
+            return;
+        case 'single':
+            apply(outcome.target);
+            return;
+        case 'all':
+            for (const t of outcome.present)
+                apply(t);
+            if (outcome.skipped.length > 0) {
+                log.info(`Skipped, not set up on this machine: ${outcome.skipped.map((t) => t.id).join(', ')}`);
+            }
+            return;
     }
-    if (t.stubDir)
-        mkdirSync(t.stubDir, { recursive: true });
-    log.success(`${t.label} eingerichtet: ${t.configPath}`);
 });
 function formatBytes(bytes) {
     if (bytes < 1024)
@@ -191,44 +279,54 @@ function printPlan(plan, roots) {
     const withFiles = plan.skills.filter((s) => s.files.length > 0).length;
     const fileBytes = plan.skills.reduce((n, s) => n + sumBytes(s.files), 0);
     if (roots.skills) {
-        log.message(`Skills   ${String(plan.skills.length).padStart(4)} aus ${roots.skills}\n` +
-            `         ${String(files).padStart(4)} weitere Dateien in ${withFiles} Skills   ` +
+        log.message(`Skills   ${String(plan.skills.length).padStart(4)} from ${roots.skills}\n` +
+            `         ${String(files).padStart(4)} more files across ${withFiles} skills   ` +
             `${formatBytes(sumBytes(plan.skills) + fileBytes)}`);
     }
     if (roots.agents) {
-        log.message(`Agents   ${String(plan.agents.length).padStart(4)} aus ${roots.agents}   ${formatBytes(sumBytes(plan.agents))}`);
+        log.message(`Agents   ${String(plan.agents.length).padStart(4)} from ${roots.agents}   ${formatBytes(sumBytes(plan.agents))}`);
     }
     if (roots.memory) {
-        log.message(`Memory   ${String(plan.memory.length).padStart(4)} aus ${roots.memory}   ${formatBytes(sumBytes(plan.memory))}`);
+        log.message(`Memory   ${String(plan.memory.length).padStart(4)} from ${roots.memory}   ${formatBytes(sumBytes(plan.memory))}`);
     }
     if (plan.skipped.length > 0) {
         const byReason = new Map();
         for (const s of plan.skipped)
             byReason.set(s.reason, (byReason.get(s.reason) ?? 0) + 1);
-        log.message(['Uebersprungen', ...[...byReason].map(([reason, n]) => `  ${String(n).padStart(4)}  ${reason}`)].join('\n'));
+        log.message(['Skipped', ...[...byReason].map(([reason, n]) => `  ${String(n).padStart(4)}  ${reason}`)].join('\n'));
+    }
+    if (plan.noDescription.length > 0) {
+        // Geht trotzdem hoch. Gemeldet, weil die Liste im Dashboard und die
+        // Stubs auf jedem Geraet von der Beschreibung leben und ein Skill ohne
+        // sie dort als blosser Name steht.
+        log.warn(['Missing a description in the SKILL.md header', ...plan.noDescription.map((n) => `  ${n}`)].join('\n'));
     }
     if (plan.flagged.length > 0) {
         log.warn([
-            'Zurueckgehalten wegen moeglicher Zugangsdaten (nichts davon geht raus)',
+            'Held back over possible credentials (none of it left this machine)',
             ...plan.flagged.flatMap((f) => [
                 `  ${f.relative}`,
-                ...f.hits.map((h) => `      Zeile ${h.line}   Regel ${h.rule}   ${h.excerpt}`),
+                ...f.hits.map((h) => `      line ${h.line}   rule ${h.rule}   ${h.excerpt}`),
             ]),
         ].join('\n'));
     }
 }
 program
     .command('import')
-    .description('Bestehende lokale Skills, Agents und Memory nach OnlyMCP holen')
-    .option('--skills <dir>', 'Ordner mit Skill-Unterordnern')
-    .option('--agents <dir>', 'Ordner mit Agent-Dateien')
+    .description('Bring existing local skills, agents and memory into OnlyMCP')
+    .option('--skills <dir>', 'Folder with skill subfolders, or a plugin cache')
+    .option('--agents <dir>', 'Folder with agent files')
     // --memory hat mit Absicht keine Vorgabe. Skills und Agents liegen an einem
     // bekannten Pfad, an dem nur Skills und Agents liegen. Ein Memory-Ordner
     // nicht: eine Vorgabe auf irgendjemandes Notizen zu richten und die
     // hochzuladen waere das Schlimmste, was dieser Befehl tun koennte.
-    .option('--memory <dir>', 'Ordner mit Memory-Dateien (keine Vorgabe)')
-    .option('--dry-run', 'Nur zeigen, was hochginge, und beenden')
-    .option('--yes', 'Ohne Rueckfrage hochladen')
+    .option('--memory <dir>', 'Folder with memory files (no default)')
+    .option('--dry-run', 'Only show what would be uploaded, then stop')
+    .option('--yes', 'Upload without asking first')
+    // --prune loescht im Konto. Es hat deshalb bewusst KEINE Abkuerzung ueber
+    // --yes: die Liste wird immer gezeigt und immer einzeln bestaetigt, auch
+    // wenn der Upload selbst unbeaufsichtigt laeuft.
+    .option('--prune', 'Delete, after confirmation, what the account holds and the source no longer has')
     .action(async (opts) => {
     // Dieselbe Testschleuse wie in install.ts und paths.ts.
     const home = process.env.ONLYMCP_HOME ?? homedir();
@@ -239,7 +337,7 @@ program
     };
     intro('OnlyMCP Import');
     const s = spinner();
-    s.start('Lese die Ordner');
+    s.start('Reading the folders');
     let plan;
     try {
         const [skills, agents, memory] = await Promise.all([
@@ -247,27 +345,29 @@ program
             existsSync(roots.agents) ? collect(roots.agents) : Promise.resolve([]),
             roots.memory && existsSync(roots.memory) ? collect(roots.memory) : Promise.resolve([]),
         ]);
-        plan = buildImportPlan({ skills, agents, memory });
+        plan = buildImportPlan({ skills, agents, memory }, { skillsRoot: roots.skills });
     }
     catch (e) {
-        s.stop('Abgebrochen');
+        s.stop('Aborted');
         log.error(e instanceof Error ? e.message : String(e));
         process.exitCode = 1;
         return;
     }
-    s.stop('Gelesen');
+    s.stop('Read');
     printPlan(plan, {
         skills: existsSync(roots.skills) ? roots.skills : undefined,
         agents: existsSync(roots.agents) ? roots.agents : undefined,
         memory: roots.memory && existsSync(roots.memory) ? roots.memory : undefined,
     });
     const total = countPlan(plan);
-    if (total === 0) {
-        outro('Nichts zu tun.');
+    // Mit --prune gibt es auch dann etwas zu tun, wenn nichts hochgeht: genau
+    // ein leerer Quellordner ist der Fall, in dem am meisten geloescht wuerde.
+    if (total === 0 && !opts.prune) {
+        outro('Nothing to do.');
         return;
     }
-    if (opts.dryRun) {
-        outro('Nichts hochgeladen (--dry-run).');
+    if (opts.dryRun && !opts.prune) {
+        outro('Nothing uploaded (--dry-run).');
         return;
     }
     const api = new ApiClient(baseUrl, () => Keyring.read());
@@ -275,37 +375,37 @@ program
     // behebender Fehler. Die Gegenmassnahme ist eine Zeile Ausgabe.
     try {
         const me = await api.getMe();
-        log.info(`Ziel   ${baseUrl}   als ${me.email}   Stufe ${me.plan.name}`);
+        log.info(`Target   ${baseUrl}   as ${me.email}   plan ${me.plan.name}`);
     }
     catch (e) {
-        log.error(`Nicht angemeldet oder Server nicht erreichbar (${e instanceof Error ? e.message : String(e)}).`);
-        log.info('Zuerst: onlymcp login');
+        log.error(`Not logged in, or the server is unreachable (${e instanceof Error ? e.message : String(e)}).`);
+        log.info('First: npx onlymcp login');
         process.exitCode = 1;
         return;
     }
-    if (!opts.yes) {
+    if (total > 0 && !opts.yes && !opts.dryRun) {
         if (!process.stdin.isTTY) {
             // Ohne Terminal gibt es keine Rueckfrage, also auch keinen Upload.
             // Wer das automatisieren will, sagt --yes und hat den Plan vorher mit
             // --dry-run gesehen.
-            log.error('Kein Terminal fuer die Rueckfrage. Erst --dry-run ansehen, dann --yes.');
+            log.error('No terminal for the prompt. Run --dry-run first, then --yes.');
             process.exitCode = 1;
             return;
         }
-        const go = await confirm({ message: `${total} Eintraege hochladen?`, initialValue: false });
+        const go = await confirm({ message: `Upload ${total} entries?`, initialValue: false });
         if (isCancel(go) || !go) {
-            cancel('Abgebrochen. Nichts hochgeladen.');
+            cancel('Cancelled. Nothing uploaded.');
             return;
         }
         if (plan.flagged.length > 0) {
             const release = await multiselect({
-                message: 'Zurueckgehaltene Dateien trotzdem mitschicken?',
+                message: 'Send the held-back files anyway?',
                 options: plan.flagged.map((f) => ({ value: f.relative, label: f.relative })),
                 required: false,
                 initialValues: [],
             });
             if (isCancel(release)) {
-                cancel('Abgebrochen. Nichts hochgeladen.');
+                cancel('Cancelled. Nothing uploaded.');
                 return;
             }
             if (release.length > 0) {
@@ -323,23 +423,141 @@ program
                     skills: clear(skills),
                     agents: clear(agents),
                     memory: clear(memory),
+                }, { skillsRoot: roots.skills });
+            }
+        }
+    }
+    if (total > 0 && !opts.dryRun) {
+        const up = spinner();
+        up.start('Uploading');
+        const result = await runUpload(api, plan, (done, all, label) => {
+            up.message(`${done}/${all}  ${label}`);
+        });
+        up.stop('Done');
+        log.success(`${result.skills} skills, ${result.skillFiles} skill files, ` +
+            `${result.agents} agents, ${result.memory} memory files`);
+        if (result.failures.length > 0) {
+            log.error([`${result.failures.length} failed`, ...result.failures.map((f) => `  ${f.what}   ${f.code}`)].join('\n'));
+            process.exitCode = 1;
+        }
+        else {
+            await reportRun(api, 'import', result.skills + result.skillFiles + result.agents + result.memory);
+        }
+    }
+    if (opts.prune) {
+        // Verglichen wird nur, was auch gelesen wurde. Ohne --memory sagt ein
+        // Import gar nichts ueber Memory aus, und "steht im Konto, fehlt in der
+        // Quelle" waere dort keine Aussage, sondern ein Unfall.
+        const covered = {
+            skills: existsSync(roots.skills),
+            agents: existsSync(roots.agents),
+            memory: Boolean(roots.memory && existsSync(roots.memory)),
+        };
+        const targets = await planPrune(api, plan, covered);
+        if (isEmpty(targets)) {
+            log.info('Nothing to delete: the account holds nothing the source does not know.');
+        }
+        else {
+            // Vollstaendig aufgezaehlt, nicht gezaehlt. Eine Zahl zu bestaetigen
+            // heisst, etwas zu bestaetigen, das man nicht gesehen hat.
+            log.warn([
+                'Would delete (only your own, nothing from a team, nothing archived)',
+                ...targets.skills.map((n) => `  Skill    ${n}`),
+                ...targets.agents.map((n) => `  Agent    ${n}`),
+                ...targets.memory.map((p) => `  Memory   ${p}`),
+            ].join('\n'));
+            if (opts.dryRun) {
+                log.info('Nothing deleted (--dry-run).');
+            }
+            else if (!process.stdin.isTTY) {
+                // Kein --yes-Durchgriff: geloescht wird nur von Hand.
+                log.error('No terminal for the prompt. Nothing deleted.');
+                process.exitCode = 1;
+            }
+            else {
+                const go = await confirm({
+                    message: `Delete ${countTargets(targets)} entries in the account?`,
+                    initialValue: false,
                 });
+                if (isCancel(go) || !go) {
+                    log.info('Nothing deleted.');
+                }
+                else {
+                    const pruned = await runPrune(api, targets);
+                    log.success(`${pruned.deleted} deleted`);
+                    if (pruned.failures.length > 0) {
+                        log.error([
+                            `${pruned.failures.length} failed`,
+                            ...pruned.failures.map((f) => `  ${f.what}   ${f.code}`),
+                        ].join('\n'));
+                        process.exitCode = 1;
+                    }
+                }
             }
         }
     }
-    const up = spinner();
-    up.start('Lade hoch');
-    const result = await runUpload(api, plan, (done, all, label) => {
-        up.message(`${done}/${all}  ${label}`);
-    });
-    up.stop('Fertig');
-    log.success(`${result.skills} Skills, ${result.skillFiles} Skill-Dateien, ` +
-        `${result.agents} Agents, ${result.memory} Memory-Dateien`);
-    if (result.failures.length > 0) {
-        log.error([`${result.failures.length} fehlgeschlagen`, ...result.failures.map((f) => `  ${f.what}   ${f.code}`)].join('\n'));
+    outro(opts.dryRun ? 'Nothing changed (--dry-run).' : 'Then: npx onlymcp sync on every device.');
+});
+program
+    .command('export')
+    .description('Get everything out of the account: memory, skills, agents, connections')
+    .option('--out <dir>', 'Unpack the archive into this folder')
+    .option('--zip <file>', 'Keep the archive as a file')
+    .option('--scope <scope>', 'personal, all or team:<id>', 'all')
+    .option('--types <list>', 'memory,skills,agents,connections')
+    .action(async (opts) => {
+    // Genau eines von beiden. Beides hiesse zweimal herunterladen, keines
+    // hiesse, die teuerste Leseoperation des Produkts ins Nichts zu schicken.
+    if ((opts.out ? 1 : 0) + (opts.zip ? 1 : 0) !== 1) {
+        log.error('Either --out <folder> or --zip <file>, not both and not neither.');
+        process.exitCode = 1;
+        return;
+    }
+    intro('OnlyMCP Export');
+    const api = new ApiClient(baseUrl, () => Keyring.read());
+    const s = spinner();
+    s.start('Fetching the archive');
+    let res;
+    try {
+        res = await api.exportArchive({
+            scope: opts.scope,
+            types: opts.types?.split(',').map((t) => t.trim()).filter((t) => t !== ''),
+        });
+    }
+    catch (e) {
+        s.stop('Aborted');
+        log.error(e instanceof Error ? e.message : String(e));
+        log.info('Not logged in? First: npx onlymcp login');
+        process.exitCode = 1;
+        return;
+    }
+    if (opts.zip) {
+        // In die Datei geschrieben, waehrend es ankommt. Ein Konto mit zwei
+        // Gigabyte soll nicht erst zwei Gigabyte Arbeitsspeicher kosten.
+        mkdirSync(dirname(opts.zip), { recursive: true });
+        await pipeline(Readable.fromWeb(res.body), createWriteStream(opts.zip));
+        s.stop('Done');
+        outro(`Archive: ${opts.zip}`);
+        return;
+    }
+    const bytes = new Uint8Array(await res.arrayBuffer());
+    const result = await unpackArchive(bytes, opts.out);
+    s.stop('Done');
+    log.success(`${result.written} files in ${opts.out}`);
+    if (result.refused.length > 0) {
+        log.warn(['Not written, path in the archive is not allowed', ...result.refused.map((p) => `  ${p}`)].join('\n'));
+    }
+    if (result.failed.length > 0) {
+        // Auf Windows der Normalfall fuer einen Skill mit Namensraum: der
+        // Doppelpunkt ist dort kein zulaessiges Zeichen in einem Ordnernamen.
+        log.warn([
+            "Not written, the filename doesn't work on this system",
+            ...result.failed.map((f) => `  ${f.path}   ${f.reason}`),
+            'With --zip <file> the archive stays unchanged.',
+        ].join('\n'));
         process.exitCode = 1;
     }
-    outro('Danach: onlymcp sync auf jedem Geraet.');
+    outro(`Restore: npx onlymcp import --skills ${opts.out}/skills --agents ${opts.out}/agents --memory ${opts.out}/memory`);
 });
 await program.parseAsync();
 //# sourceMappingURL=cli.js.map