onlymcp 0.10.0 → 0.11.0

package/dist/bin/cli.js

@@ -5,15 +5,15 @@ import open from 'open';
 import QRCode from 'qrcode';
 import { createRequire } from 'node:module';
 import { homedir } from 'node:os';
-import { appendFileSync, createWriteStream, 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';
@@ -45,37 +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(`Dieses Geraet meldet sich als: ${await deviceLabel()}`);
+    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' },
@@ -92,13 +71,13 @@ 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());
     const counts = await writeStubsEverywhere(api);
-    outro(`${counts.skills} Skills, ${counts.agents} Agents, ${counts.files} Dateien bereit`);
+    outro(`${counts.skills} skills, ${counts.agents} agents, ${counts.files} files ready`);
 });
 /**
  * Stubs in jeden Ordner, den ein Client auf diesem Geraet liest.
@@ -119,28 +98,66 @@ async function writeStubsEverywhere(api) {
     }
     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')
-    .option('--memory <dir>', 'Memory zusaetzlich als Dateien in diesen Ordner schreiben')
+    .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());
     const counts = await writeStubsEverywhere(api);
-    log.success(`${counts.skills} Skills, ${counts.agents} Agents, ${counts.files} Dateien`);
+    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
@@ -148,85 +165,103 @@ program
         // wurde. Gekuerzt, weil ein Geraet mit 270 eigenen Agent-Dateien sonst
         // 270 Zeilen bekaeme und die Erfolgsmeldung aus dem Bild schoebe.
         log.warn([
-            `Unberuehrt gelassen, weil dort schon etwas Eigenes liegt (${counts.kept.length})`,
+            `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 ? [`  ... und ${counts.kept.length - 10} weitere`] : []),
+            ...(counts.kept.length > 10 ? [`  ... and ${counts.kept.length - 10} more`] : []),
         ].join('\n'));
     }
-    if (!opts.memory)
+    // 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-Dateien nach ${opts.memory}`);
+    log.success(`${m.written} memory files to ${opts.memory}`);
     if (m.collisions.length > 0) {
-        log.warn(['Team-Dateien mit einem Pfad, den eine eigene Datei schon hat', ...m.collisions.map((p) => `  ${p}`)].join('\n'));
+        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(['Pfade abgelehnt', ...m.refused.map((p) => `  ${p}`)].join('\n'));
+        log.warn(['Paths refused', ...m.refused.map((p) => `  ${p}`)].join('\n'));
     }
     if (m.failures.length > 0) {
-        log.error([`${m.failures.length} fehlgeschlagen`, ...m.failures.map((f) => `  ${f.what}   ${f.code}`)].join('\n'));
+        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)
@@ -244,54 +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) {
-        // Gehen trotzdem hoch. Gemeldet, weil die Liste im Dashboard und die
+        // 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(['Ohne description im Kopf der SKILL.md', ...plan.noDescription.map((n) => `  ${n}`)].join('\n'));
+        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 oder ein Plugin-Cache')
-    .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', 'Was im Konto steht und in der Quelle fehlt, nach Rueckfrage loeschen')
+    .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();
@@ -302,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([
@@ -313,12 +348,12 @@ program
         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,
@@ -328,11 +363,11 @@ program
     // 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('Nichts zu tun.');
+        outro('Nothing to do.');
         return;
     }
     if (opts.dryRun && !opts.prune) {
-        outro('Nichts hochgeladen (--dry-run).');
+        outro('Nothing uploaded (--dry-run).');
         return;
     }
     const api = new ApiClient(baseUrl, () => Keyring.read());
@@ -340,11 +375,11 @@ 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;
     }
@@ -353,24 +388,24 @@ program
             // 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) {
@@ -394,17 +429,20 @@ program
     }
     if (total > 0 && !opts.dryRun) {
         const up = spinner();
-        up.start('Lade hoch');
+        up.start('Uploading');
         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`);
+        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} fehlgeschlagen`, ...result.failures.map((f) => `  ${f.what}   ${f.code}`)].join('\n'));
+            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
@@ -417,39 +455,39 @@ program
         };
         const targets = await planPrune(api, plan, covered);
         if (isEmpty(targets)) {
-            log.info('Nichts zu loeschen: das Konto haelt nichts, was die Quelle nicht kennt.');
+            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([
-                'Wuerde geloescht (nur Eigenes, nichts aus einem Team, nichts Archiviertes)',
+                '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('Nichts geloescht (--dry-run).');
+                log.info('Nothing deleted (--dry-run).');
             }
             else if (!process.stdin.isTTY) {
                 // Kein --yes-Durchgriff: geloescht wird nur von Hand.
-                log.error('Kein Terminal fuer die Rueckfrage. Nichts geloescht.');
+                log.error('No terminal for the prompt. Nothing deleted.');
                 process.exitCode = 1;
             }
             else {
                 const go = await confirm({
-                    message: `${countTargets(targets)} Eintraege im Konto loeschen?`,
+                    message: `Delete ${countTargets(targets)} entries in the account?`,
                     initialValue: false,
                 });
                 if (isCancel(go) || !go) {
-                    log.info('Nichts geloescht.');
+                    log.info('Nothing deleted.');
                 }
                 else {
                     const pruned = await runPrune(api, targets);
-                    log.success(`${pruned.deleted} geloescht`);
+                    log.success(`${pruned.deleted} deleted`);
                     if (pruned.failures.length > 0) {
                         log.error([
-                            `${pruned.failures.length} fehlgeschlagen`,
+                            `${pruned.failures.length} failed`,
                             ...pruned.failures.map((f) => `  ${f.what}   ${f.code}`),
                         ].join('\n'));
                         process.exitCode = 1;
@@ -458,27 +496,27 @@ program
             }
         }
     }
-    outro(opts.dryRun ? 'Nichts geaendert (--dry-run).' : 'Danach: onlymcp sync auf jedem Geraet.');
+    outro(opts.dryRun ? 'Nothing changed (--dry-run).' : 'Then: npx onlymcp sync on every device.');
 });
 program
     .command('export')
-    .description('Alles aus dem Konto holen: Memory, Skills, Agents, Verbindungen')
-    .option('--out <dir>', 'Archiv in diesen Ordner entpacken')
-    .option('--zip <file>', 'Archiv als Datei behalten')
-    .option('--scope <scope>', 'personal, all oder team:<id>', 'all')
+    .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('Entweder --out <ordner> oder --zip <datei>, nicht beides und nicht keines.');
+        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('Hole das Archiv');
+    s.start('Fetching the archive');
     let res;
     try {
         res = await api.exportArchive({
@@ -487,9 +525,9 @@ program
         });
     }
     catch (e) {
-        s.stop('Abgebrochen');
+        s.stop('Aborted');
         log.error(e instanceof Error ? e.message : String(e));
-        log.info('Nicht angemeldet? Zuerst: onlymcp login');
+        log.info('Not logged in? First: npx onlymcp login');
         process.exitCode = 1;
         return;
     }
@@ -498,28 +536,28 @@ program
         // 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('Fertig');
-        outro(`Archiv: ${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('Fertig');
-    log.success(`${result.written} Dateien in ${opts.out}`);
+    s.stop('Done');
+    log.success(`${result.written} files in ${opts.out}`);
     if (result.refused.length > 0) {
-        log.warn(['Nicht geschrieben, unzulaessiger Pfad im Archiv', ...result.refused.map((p) => `  ${p}`)].join('\n'));
+        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([
-            'Nicht geschrieben, der Dateiname geht auf diesem System nicht',
+            "Not written, the filename doesn't work on this system",
             ...result.failed.map((f) => `  ${f.path}   ${f.reason}`),
-            'Mit --zip <datei> bleibt das Archiv unveraendert erhalten.',
+            'With --zip <file> the archive stays unchanged.',
         ].join('\n'));
         process.exitCode = 1;
     }
-    outro(`Zurueckspielen: onlymcp import --skills ${opts.out}/skills --agents ${opts.out}/agents --memory ${opts.out}/memory`);
+    outro(`Restore: npx onlymcp import --skills ${opts.out}/skills --agents ${opts.out}/agents --memory ${opts.out}/memory`);
 });
 await program.parseAsync();
 //# sourceMappingURL=cli.js.map