layoutbridge-spm 0.0.1 → 1.0.0

package/dist/src/mcp/setup.js

@@ -0,0 +1,608 @@
+/**
+ * Einrichtungsbefehl `layoutbridge-spm --setup` (Auftrag A-13 Nr. 1,
+ * Vermerk E-76): traegt den Server in die Konfiguration von Claude Desktop
+ * ein und legt den Lizenzschluessel am Vorgabeort ab.
+ *
+ * Nach dem Muster von `--deactivate` (E-62): kein Werkzeug im Katalog, keine
+ * Aenderung an der Schnittstelle (A-5). Fuenf feste Regeln aus dem Auftrag:
+ *   1. nur auf ausdrueckliche Eingabe (Aufruf mit --setup, nie automatisch);
+ *   2. anzeigen, fragen, dann schreiben; --dry-run schreibt nichts; ohne
+ *      Terminal Abbruch;
+ *   3. Sicherungskopie, nur `mcpServers.layoutbridge-spm` wird geaendert,
+ *      alles andere bleibt byte-genau (Eintrag wird textlich eingesetzt,
+ *      nicht die Datei neu serialisiert); ungueltiges JSON = Abbruch mit
+ *      Zeile und Spalte;
+ *   4. keine Rechte, kein Netz, kein Download; der Schluessel wird nie
+ *      uebertragen, nie protokolliert, nie in die Konfiguration geschrieben,
+ *      und die Lizenzpruefung wird nicht ausgeloest;
+ *   5. der Handweg bleibt dokumentiert (README).
+ * Deshalb importiert diese Datei nur Node-Bausteine fuer Dateien und
+ * Terminal und die Produktangaben – keinen Lizenzpruefer, kein `fetch`,
+ * kein Protokoll (Waechtertest tests/unit/setup.test.ts).
+ */
+import { copyFileSync, chmodSync, existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { createInterface } from 'node:readline';
+import { posix, win32 } from 'node:path';
+import { isDeepStrictEqual } from 'node:util';
+import { SUPPORT_EMAIL } from './product-info.js';
+/** Name des Eintrags unter `mcpServers` (= Servername, = Werkzeugpraefix in Claude Desktop). */
+export const SETUP_SERVER_KEY = 'layoutbridge-spm';
+/** Der eingetragene Befehl: Bezugsweg npm, Schluessel in license.key, deshalb kein "env". */
+export const SETUP_ENTRY = { command: 'npx', args: ['-y', 'layoutbridge-spm'] };
+/** Vorerst einziger Client (A-13 Nr. 1); andere erst auf Auftrag. */
+export const SETUP_CLIENTS = ['claude-desktop'];
+const RESTART_SENTENCE = 'Now quit Claude Desktop completely and start it again.';
+/** Liest die Optionen nach `--setup`. Unbekanntes = Fehlertext. */
+export function parseSetupArgs(argv) {
+    const options = { dryRun: false, client: 'claude-desktop', licenseKeyFile: null };
+    for (let i = 0; i < argv.length; i += 1) {
+        const arg = argv[i];
+        if (arg === '--setup')
+            continue;
+        if (arg === '--dry-run') {
+            options.dryRun = true;
+            continue;
+        }
+        const valued = /^(--client|--license-key-file)(?:=(.*))?$/.exec(arg);
+        if (valued !== null) {
+            let value = valued[2];
+            if (value === undefined) {
+                value = argv[i + 1];
+                i += 1;
+            }
+            if (value === undefined || value.length === 0 || value.startsWith('--')) {
+                return { error: valued[1] + ' needs a value.' };
+            }
+            if (valued[1] === '--client')
+                options.client = value;
+            else
+                options.licenseKeyFile = value;
+            continue;
+        }
+        return { error: 'Unknown option ' + JSON.stringify(arg) + ' for --setup. Allowed: --dry-run, --client claude-desktop, --license-key-file <path>.' };
+    }
+    if (!SETUP_CLIENTS.includes(options.client)) {
+        return { error: 'Unknown client ' + JSON.stringify(options.client) + '. Supported: ' + SETUP_CLIENTS.join(', ') + '.' };
+    }
+    return { options };
+}
+// ---------------------------------------------------------------------------
+// Pfade (E-71 fuer Claude Desktop, E-60 fuer den Schluessel)
+/** Konfigurationsdatei von Claude Desktop; `null` auf Plattformen ohne Claude Desktop. */
+export function claudeDesktopConfigPath(platform, home, env) {
+    if (platform === 'darwin')
+        return posix.join(home, 'Library', 'Application Support', 'Claude', 'claude_desktop_config.json');
+    if (platform === 'win32') {
+        const appData = env['APPDATA'] !== undefined && env['APPDATA'].length > 0 ? env['APPDATA'] : win32.join(home, 'AppData', 'Roaming');
+        return win32.join(appData, 'Claude', 'claude_desktop_config.json');
+    }
+    return null;
+}
+/** Vorgabeort des Schluessels, derselbe wie in license/key-source.ts. */
+export function setupLicenseKeyPath(platform, home) {
+    if (platform === 'darwin')
+        return posix.join(home, 'Library', 'Application Support', 'layoutbridge-spm', 'license.key');
+    if (platform === 'win32')
+        return win32.join(home, '.layoutbridge-spm', 'license.key');
+    return posix.join(home, '.layoutbridge-spm', 'license.key');
+}
+function pathApi(platform) {
+    return platform === 'win32' ? win32 : posix;
+}
+/** `claude_desktop_config.json.bak-JJJJ-MM-TT_HHMM` (Ortszeit). */
+export function backupPath(configPath, now) {
+    const pad = (n) => String(n).padStart(2, '0');
+    const stamp = `${now.getFullYear()}-${pad(now.getMonth() + 1)}-${pad(now.getDate())}_${pad(now.getHours())}${pad(now.getMinutes())}`;
+    return configPath + '.bak-' + stamp;
+}
+export class JsonPositionError extends Error {
+    line;
+    column;
+    detail;
+    constructor(line, column, detail) {
+        super(`line ${line}, column ${column}: ${detail}`);
+        this.line = line;
+        this.column = column;
+        this.detail = detail;
+    }
+}
+function lineAndColumn(text, position) {
+    let line = 1;
+    let lineStart = 0;
+    for (let i = 0; i < position && i < text.length; i += 1) {
+        if (text[i] === '\n') {
+            line += 1;
+            lineStart = i + 1;
+        }
+    }
+    return { line, column: position - lineStart + 1 };
+}
+function parseWithPositions(text) {
+    let pos = 0;
+    const fail = (detail, at = pos) => {
+        const where = lineAndColumn(text, at);
+        throw new JsonPositionError(where.line, where.column, detail);
+    };
+    const describe = () => (pos >= text.length ? 'unexpected end of file' : 'unexpected character ' + JSON.stringify(text[pos]));
+    const skip = () => {
+        while (pos < text.length && ' \t\n\r'.includes(text[pos]))
+            pos += 1;
+    };
+    const parseString = () => {
+        if (text[pos] !== '"')
+            fail(describe());
+        pos += 1;
+        for (;;) {
+            if (pos >= text.length)
+                fail('unterminated string');
+            const ch = text[pos];
+            if (ch === '"') {
+                pos += 1;
+                return;
+            }
+            if (ch < ' ')
+                fail('control character in string');
+            if (ch === '\\') {
+                const next = text[pos + 1];
+                if (next === 'u') {
+                    if (!/^[0-9a-fA-F]{4}$/.test(text.slice(pos + 2, pos + 6)))
+                        fail('invalid \\u escape');
+                    pos += 6;
+                }
+                else if (next !== undefined && '"\\/bfnrt'.includes(next)) {
+                    pos += 2;
+                }
+                else {
+                    fail('invalid escape in string');
+                }
+                continue;
+            }
+            pos += 1;
+        }
+    };
+    const parseValue = () => {
+        skip();
+        const start = pos;
+        const ch = text[pos];
+        if (ch === '{') {
+            pos += 1;
+            const members = [];
+            skip();
+            if (text[pos] === '}') {
+                pos += 1;
+                return { start, end: pos, members };
+            }
+            for (;;) {
+                skip();
+                if (text[pos] !== '"')
+                    fail(pos >= text.length ? 'unexpected end of file' : 'expected a property name in double quotes');
+                const keyStart = pos;
+                parseString();
+                const keyEnd = pos;
+                skip();
+                if (text[pos] !== ':')
+                    fail("expected ':' after property name");
+                pos += 1;
+                const value = parseValue();
+                members.push({ key: JSON.parse(text.slice(keyStart, keyEnd)), keyStart, keyEnd, value });
+                skip();
+                if (text[pos] === ',') {
+                    pos += 1;
+                    continue;
+                }
+                if (text[pos] === '}') {
+                    pos += 1;
+                    return { start, end: pos, members };
+                }
+                fail(pos >= text.length ? 'unexpected end of file' : "expected ',' or '}'");
+            }
+        }
+        if (ch === '[') {
+            pos += 1;
+            skip();
+            if (text[pos] === ']') {
+                pos += 1;
+                return { start, end: pos, members: null };
+            }
+            for (;;) {
+                parseValue();
+                skip();
+                if (text[pos] === ',') {
+                    pos += 1;
+                    continue;
+                }
+                if (text[pos] === ']') {
+                    pos += 1;
+                    return { start, end: pos, members: null };
+                }
+                fail(pos >= text.length ? 'unexpected end of file' : "expected ',' or ']'");
+            }
+        }
+        if (ch === '"') {
+            parseString();
+            return { start, end: pos, members: null };
+        }
+        const literal = /^(?:true|false|null|-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?)/.exec(text.slice(pos, pos + 400));
+        if (literal !== null) {
+            pos += literal[0].length;
+            return { start, end: pos, members: null };
+        }
+        return fail(describe());
+    };
+    skip();
+    if (pos >= text.length)
+        fail('the file is empty');
+    const root = parseValue();
+    skip();
+    if (pos < text.length)
+        fail(describe());
+    return root;
+}
+// ---------------------------------------------------------------------------
+// Eintrag textlich einsetzen
+function lineIndent(text, position) {
+    const lineStart = text.lastIndexOf('\n', position - 1) + 1;
+    return /^[ \t]*/.exec(text.slice(lineStart))?.[0] ?? '';
+}
+function serializeAt(value, indent, unit, newline) {
+    return JSON.stringify(value, null, unit).split('\n').join(newline + indent);
+}
+function lastMember(object, key) {
+    const members = object.members ?? [];
+    for (let i = members.length - 1; i >= 0; i -= 1) {
+        if (members[i].key === key)
+            return members[i];
+    }
+    return undefined;
+}
+function detectIndentUnit(text, root) {
+    const first = root.members?.[0];
+    if (first !== undefined && text.slice(root.start, first.keyStart).includes('\n')) {
+        const own = lineIndent(text, first.keyStart);
+        const outer = lineIndent(text, root.start);
+        if (own.length > outer.length)
+            return own.slice(outer.length);
+    }
+    return '  ';
+}
+/** Setzt ein Mitglied in ein Objekt ein (hinter das letzte) oder fuellt ein leeres Objekt. */
+function insertMember(text, object, key, value, unit, newline) {
+    const members = object.members;
+    const quotedKey = JSON.stringify(key);
+    if (members.length === 0) {
+        const outer = lineIndent(text, object.start);
+        const body = '{' + newline + outer + unit + quotedKey + ': ' + serializeAt(value, outer + unit, unit, newline) + newline + outer + '}';
+        return text.slice(0, object.start) + body + text.slice(object.end);
+    }
+    const last = members[members.length - 1];
+    const first = members[0];
+    const between = text.slice(last.keyEnd, last.value.start);
+    const colon = between.includes('\n') ? ': ' : between;
+    let insertion;
+    if (text.slice(object.start, first.keyStart).includes('\n')) {
+        const indent = lineIndent(text, last.keyStart);
+        insertion = ',' + newline + indent + quotedKey + colon + serializeAt(value, indent, unit, newline);
+    }
+    else {
+        insertion = ', ' + quotedKey + colon + JSON.stringify(value);
+    }
+    return text.slice(0, last.value.end) + insertion + text.slice(last.value.end);
+}
+export class SetupConfigError extends Error {
+}
+/**
+ * Berechnet den neuen Inhalt der Konfigurationsdatei. `current = null`: Datei
+ * fehlt. Alle anderen Eintraege und Schluessel bleiben byte-genau; das
+ * Ergebnis wird zur Sicherheit noch einmal geparst und verglichen.
+ */
+export function computeConfigChange(current, key = SETUP_SERVER_KEY, entry = SETUP_ENTRY) {
+    if (current === null) {
+        return { text: JSON.stringify({ mcpServers: { [key]: entry } }, null, 2) + '\n', entryState: 'new', currentEntry: undefined };
+    }
+    const bom = current.startsWith('\uFEFF') ? '\uFEFF' : '';
+    const body = current.slice(bom.length);
+    const root = parseWithPositions(body);
+    if (root.members === null)
+        throw new SetupConfigError('The configuration file does not contain a JSON object at the top level.');
+    const parsed = JSON.parse(body);
+    const newline = body.includes('\r\n') ? '\r\n' : '\n';
+    const unit = detectIndentUnit(body, root);
+    let next;
+    let entryState = 'new';
+    let currentEntry;
+    const servers = lastMember(root, 'mcpServers');
+    if (servers === undefined) {
+        next = insertMember(body, root, 'mcpServers', { [key]: entry }, unit, newline);
+    }
+    else {
+        if (servers.value.members === null)
+            throw new SetupConfigError('"mcpServers" in the configuration file is not a JSON object.');
+        const existing = lastMember(servers.value, key);
+        if (existing === undefined) {
+            next = insertMember(body, servers.value, key, entry, unit, newline);
+        }
+        else {
+            currentEntry = parsed['mcpServers'][key];
+            if (isDeepStrictEqual(currentEntry, entry))
+                return { text: null, entryState: 'same', currentEntry };
+            entryState = 'different';
+            const indent = lineIndent(body, existing.keyStart);
+            const multiline = body.slice(servers.value.start, servers.value.end).includes('\n');
+            const replacement = multiline ? serializeAt(entry, indent, unit, newline) : JSON.stringify(entry);
+            next = body.slice(0, existing.value.start) + replacement + body.slice(existing.value.end);
+        }
+    }
+    const expected = { ...parsed, mcpServers: { ...(parsed['mcpServers'] ?? {}), [key]: entry } };
+    if (!isDeepStrictEqual(JSON.parse(next), expected)) {
+        throw new SetupConfigError('Internal check failed: the changed file would not contain exactly the old content plus the new entry.');
+    }
+    return { text: bom + next, entryState, currentEntry };
+}
+export class SetupCancelled extends Error {
+}
+const isYes = (answer) => /^(y|yes|j|ja)$/i.test(answer.trim());
+function indentBlock(text, prefix) {
+    return text
+        .split('\n')
+        .map((line) => prefix + line)
+        .join('\n');
+}
+function entryText(value) {
+    return JSON.stringify(SETUP_SERVER_KEY) + ': ' + JSON.stringify(value, null, 2);
+}
+/** Schluessel aus einer Datei oder einer Eingabe bereinigen; leer = null. */
+export function cleanLicenseKey(raw) {
+    const key = raw.replace(/\[20[01]~/g, '').trim();
+    if (key.length === 0)
+        return null;
+    if (/\s/.test(key))
+        return null;
+    return key;
+}
+/**
+ * Fuehrt `--setup` aus und gibt den Rueckgabewert des Prozesses zurueck:
+ * 0 nur, wenn alles geschrieben wurde (oder nichts zu aendern war, oder
+ * --dry-run ohne Befund).
+ */
+export async function runSetup(argv, io, sys) {
+    const parsed = parseSetupArgs(argv);
+    if ('error' in parsed) {
+        io.err(parsed.error + ' Nothing was changed.\n');
+        return 1;
+    }
+    const { dryRun, licenseKeyFile } = parsed.options;
+    const configPath = claudeDesktopConfigPath(sys.platform, sys.home, sys.env);
+    if (configPath === null) {
+        io.err('Claude Desktop is available for macOS and Windows only; this computer runs ' + sys.platform + '. Nothing was changed.\n');
+        return 1;
+    }
+    if (!dryRun && !io.interactive) {
+        io.err('--setup asks before it writes and therefore needs an interactive terminal. Nothing was changed. Run it in Terminal (Mac) or PowerShell (Windows), or use --dry-run to only show the changes.\n');
+        return 1;
+    }
+    const paths = pathApi(sys.platform);
+    const keyPath = setupLicenseKeyPath(sys.platform, sys.home);
+    io.out('layoutbridge-spm setup for Claude Desktop\n');
+    io.out('Node.js: ' + sys.nodeVersion + '\n');
+    if (dryRun)
+        io.out('Dry run: nothing will be written.\n');
+    io.out('\n');
+    /* 1. Konfigurationsdatei lesen und die Aenderung berechnen (noch nichts schreiben). */
+    const configExists = existsSync(configPath);
+    let change;
+    try {
+        change = computeConfigChange(configExists ? readFileSync(configPath, 'utf8') : null);
+    }
+    catch (error) {
+        if (error instanceof JsonPositionError) {
+            io.err('The configuration file ' + configPath + ' is not valid JSON (' + error.message + '). Nothing was changed. Please correct the file (or restore a backup) and run --setup again. Support: ' + SUPPORT_EMAIL + '\n');
+            return 1;
+        }
+        if (error instanceof SetupConfigError) {
+            io.err(error.message + ' File: ' + configPath + '. Nothing was changed. Support: ' + SUPPORT_EMAIL + '\n');
+            return 1;
+        }
+        throw error;
+    }
+    const backup = configExists && change.text !== null ? backupPath(configPath, sys.now) : null;
+    io.out('Configuration file: ' + configPath + '\n');
+    if (!configExists) {
+        io.out('  The file does not exist yet and will be created.\n');
+        if (!existsSync(paths.dirname(configPath))) {
+            io.out('  Its folder does not exist either - is Claude Desktop installed? The folder will be created.\n');
+        }
+    }
+    else if (change.entryState === 'same') {
+        io.out('  The entry "' + SETUP_SERVER_KEY + '" is already set up exactly like this; the file stays unchanged.\n');
+    }
+    else {
+        io.out('  Only the entry "' + SETUP_SERVER_KEY + '" under "mcpServers" is ' + (change.entryState === 'different' ? 'replaced' : 'added') + '; everything else in the file stays exactly as it is.\n');
+        io.out('  Backup before writing: ' + backup + '\n');
+    }
+    if (change.entryState !== 'same') {
+        io.out('New entry:\n' + indentBlock(entryText(SETUP_ENTRY), '  ') + '\n');
+    }
+    io.out('\n');
+    /* 2. Schluessel: Datei, vorhandener Schluessel oder Eingabe. */
+    io.out('Licence key file: ' + keyPath + '\n');
+    let key = null;
+    let keyExisting = false;
+    try {
+        keyExisting = cleanLicenseKey(readFileSync(keyPath, 'utf8')) !== null;
+    }
+    catch {
+        keyExisting = false;
+    }
+    if (licenseKeyFile !== null) {
+        try {
+            key = cleanLicenseKey(readFileSync(licenseKeyFile, 'utf8'));
+        }
+        catch (error) {
+            io.err('The licence key file ' + licenseKeyFile + ' could not be read (' + (error instanceof Error ? error.message : String(error)) + '). Nothing was changed.\n');
+            return 1;
+        }
+        if (key === null) {
+            io.err('The licence key file ' + licenseKeyFile + ' does not contain a licence key (empty, or more than one word). Nothing was changed.\n');
+            return 1;
+        }
+        io.out('  The key is taken from ' + licenseKeyFile + ' and written to the licence key file.\n');
+    }
+    else if (keyExisting) {
+        io.out('  A licence key is already stored there.\n');
+    }
+    else {
+        io.out('  No licence key is stored there yet; you ' + (dryRun ? 'would' : 'will') + ' be asked for it (the input is not shown).\n');
+    }
+    io.out('  The key is only stored on this computer: not in the configuration file, not in the log, not sent anywhere. It is checked when a tool is first used.\n');
+    io.out('\n');
+    if (change.entryState === 'different') {
+        io.out('The entry "' + SETUP_SERVER_KEY + '" already exists:\n' + indentBlock(entryText(change.currentEntry), '  ') + '\n');
+    }
+    if (dryRun) {
+        if (change.entryState === 'different')
+            io.out('Without --dry-run you would be asked whether to replace it.\n');
+        if (licenseKeyFile === null && keyExisting)
+            io.out('Without --dry-run you would be asked whether to replace the stored licence key.\n');
+        io.out('Dry run: nothing was written.\n');
+        return 0;
+    }
+    /* 3. Rueckfragen. Nach einer Frage steht keine Leerzeile, deshalb davor eine setzen. */
+    let asked = false;
+    const ask = (question) => ((asked = true), io.ask(question));
+    const gap = () => (asked ? '\n' : '');
+    try {
+        const writeConfig = change.text !== null;
+        if (change.entryState === 'different') {
+            if (!isYes(await ask('Replace the existing entry with the new entry? [y/n] '))) {
+                io.out('The existing entry is kept. Nothing was changed.\n');
+                return 1;
+            }
+        }
+        let writeKey = key !== null;
+        if (key === null && keyExisting) {
+            writeKey = isYes(await ask('Replace the stored licence key? [y/n] '));
+            if (!writeKey)
+                io.out('The stored licence key is kept.\n');
+        }
+        if (key === null && (writeKey || !keyExisting)) {
+            asked = true;
+            key = cleanLicenseKey(await io.askHidden('Licence key (from your purchase receipt; input is hidden, finish with Enter): '));
+            if (key === null) {
+                io.err('No licence key entered (or it contains spaces). Nothing was changed.\n');
+                return 1;
+            }
+            writeKey = true;
+        }
+        if (!writeConfig && !writeKey) {
+            io.out(gap() + 'Nothing to change.\n');
+            summary(io, sys, configPath, 'unchanged', null, keyPath, 'kept');
+            return 0;
+        }
+        const plan = [];
+        if (writeConfig)
+            plan.push((configExists ? 'change ' : 'create ') + configPath + (backup !== null ? ' (backup first: ' + backup + ')' : ''));
+        if (writeKey)
+            plan.push('write the licence key to ' + keyPath);
+        io.out(gap() + 'About to:\n' + plan.map((line) => '  - ' + line).join('\n') + '\n');
+        if (!isYes(await ask('Write these changes now? [y/n] '))) {
+            io.out('Cancelled. Nothing was changed.\n');
+            return 1;
+        }
+        /* 4. Schreiben: Sicherung, Schluessel, Konfiguration. */
+        let backupWritten = null;
+        try {
+            if (writeConfig && backup !== null) {
+                copyFileSync(configPath, backup);
+                backupWritten = backup;
+            }
+            if (writeKey && key !== null) {
+                mkdirSync(paths.dirname(keyPath), { recursive: true, mode: 0o700 });
+                writeFileSync(keyPath, key + '\n', { encoding: 'utf8', mode: 0o600 });
+                chmodSync(keyPath, 0o600);
+            }
+            if (writeConfig && change.text !== null) {
+                mkdirSync(paths.dirname(configPath), { recursive: true });
+                writeFileSync(configPath, change.text, 'utf8');
+            }
+        }
+        catch (error) {
+            io.err('Writing failed: ' + (error instanceof Error ? error.message : String(error)) + (backupWritten !== null ? '. The previous configuration is saved as ' + backupWritten : '') + '. Support: ' + SUPPORT_EMAIL + '\n');
+            return 1;
+        }
+        io.out('\nDone.\n');
+        summary(io, sys, configPath, writeConfig ? (configExists ? 'changed' : 'created') : 'unchanged', backupWritten, keyPath, writeKey ? 'written' : 'kept');
+        return 0;
+    }
+    catch (error) {
+        if (error instanceof SetupCancelled) {
+            io.out('Cancelled. Nothing was changed.\n');
+            return 1;
+        }
+        throw error;
+    }
+}
+function summary(io, sys, configPath, configState, backup, keyPath, keyState) {
+    io.out('  Node.js:            ' + sys.nodeVersion + '\n');
+    io.out('  Configuration file: ' + configPath + ' (' + configState + ')\n');
+    io.out('  Backup:             ' + (backup ?? 'none') + '\n');
+    io.out('  Licence key file:   ' + keyPath + ' (' + keyState + ')\n');
+    if (configState !== 'unchanged' || keyState === 'written') {
+        io.out(RESTART_SENTENCE + (sys.platform === 'darwin' ? ' (Cmd+Q)' : ' (also close it in the notification area of the taskbar)') + '\n');
+    }
+}
+// ---------------------------------------------------------------------------
+// Terminal
+/** Ein- und Ausgabe ueber das Terminal des Aufrufs. */
+export function createTerminalIo() {
+    const stdin = process.stdin;
+    return {
+        interactive: stdin.isTTY === true && process.stdout.isTTY === true,
+        out: (text) => void process.stdout.write(text),
+        err: (text) => void process.stderr.write(text),
+        ask: (question) => new Promise((resolve) => {
+            const rl = createInterface({ input: stdin, output: process.stdout, terminal: true });
+            let answered = false;
+            rl.question(question, (answer) => {
+                answered = true;
+                rl.close();
+                resolve(answer);
+            });
+            rl.on('close', () => {
+                if (!answered) {
+                    process.stdout.write('\n');
+                    resolve('');
+                }
+            });
+        }),
+        askHidden: (question) => new Promise((resolve, reject) => {
+            /* Erst Echo aus, dann die Frage: sonst koennte schnell getippter oder
+               eingefuegter Text noch im Zeilenmodus mit Echo ankommen. */
+            stdin.setEncoding('utf8');
+            stdin.setRawMode(true);
+            process.stdout.write(question);
+            let value = '';
+            const finish = (done) => {
+                stdin.removeListener('data', onData);
+                stdin.setRawMode(false);
+                stdin.pause();
+                process.stdout.write('\n');
+                done();
+            };
+            const onData = (chunk) => {
+                for (const ch of chunk) {
+                    if (ch === '\r' || ch === '\n' || ch === '\u0004')
+                        return finish(() => resolve(value));
+                    if (ch === '\u0003')
+                        return finish(() => reject(new SetupCancelled()));
+                    if (ch === '\u007f' || ch === '\b')
+                        value = value.slice(0, -1);
+                    else if (ch >= ' ')
+                        value += ch;
+                }
+            };
+            stdin.resume();
+            stdin.on('data', onData);
+        }),
+    };
+}
+//# sourceMappingURL=setup.js.map