@claude-flow/cli 3.32.3 → 3.32.5

package/dist/src/prompt.js

@@ -0,0 +1,501 @@
+/**
+ * V3 CLI Interactive Prompt System
+ * Modern interactive prompts for user input
+ */
+import * as readline from 'readline';
+import { output } from './output.js';
+// ============================================
+// Core Prompt Infrastructure
+// ============================================
+class PromptManager {
+    rl = null;
+    formatter;
+    constructor(formatter = output) {
+        this.formatter = formatter;
+    }
+    createInterface() {
+        if (!this.rl) {
+            this.rl = readline.createInterface({
+                input: process.stdin,
+                output: process.stdout,
+                terminal: true
+            });
+            // Handle cleanup on exit
+            this.rl.on('close', () => {
+                this.rl = null;
+            });
+        }
+        return this.rl;
+    }
+    close() {
+        if (this.rl) {
+            this.rl.close();
+            this.rl = null;
+        }
+    }
+    async question(prompt) {
+        return new Promise((resolve) => {
+            const rl = this.createInterface();
+            rl.question(prompt, (answer) => {
+                resolve(answer);
+            });
+        });
+    }
+    // ============================================
+    // Select Prompt
+    // ============================================
+    async select(options) {
+        const { message, options: choices, default: defaultValue, pageSize = 10 } = options;
+        this.formatter.writeln();
+        this.formatter.writeln(this.formatter.bold(`? ${message}`));
+        this.formatter.writeln(this.formatter.dim('  (Use arrow keys to navigate, enter to select)'));
+        this.formatter.writeln();
+        // Find default index
+        let selectedIndex = 0;
+        if (defaultValue !== undefined) {
+            const idx = choices.findIndex(c => c.value === defaultValue);
+            if (idx !== -1)
+                selectedIndex = idx;
+        }
+        // Display options
+        const displayChoices = (currentIndex, startIndex = 0) => {
+            // Move cursor up to overwrite
+            if (startIndex > 0 || currentIndex > 0) {
+                process.stdout.write(`\x1b[${Math.min(choices.length, pageSize)}A`);
+            }
+            const endIndex = Math.min(startIndex + pageSize, choices.length);
+            for (let i = startIndex; i < endIndex; i++) {
+                const choice = choices[i];
+                const isSelected = i === currentIndex;
+                const prefix = isSelected ? this.formatter.info('>') : ' ';
+                const label = isSelected
+                    ? this.formatter.highlight(choice.label)
+                    : choice.label;
+                const hint = choice.hint ? this.formatter.dim(` - ${choice.hint}`) : '';
+                const disabled = choice.disabled ? this.formatter.dim(' (disabled)') : '';
+                this.formatter.writeln(`  ${prefix} ${label}${hint}${disabled}`);
+            }
+        };
+        // Initial display
+        displayChoices(selectedIndex);
+        return new Promise((resolve, reject) => {
+            const rl = this.createInterface();
+            // Enable raw mode for arrow key detection
+            if (process.stdin.isTTY) {
+                process.stdin.setRawMode(true);
+            }
+            process.stdin.resume();
+            const handleKeypress = (key) => {
+                const keyStr = key.toString();
+                // Arrow keys
+                if (keyStr === '\x1b[A') { // Up
+                    do {
+                        selectedIndex = (selectedIndex - 1 + choices.length) % choices.length;
+                    } while (choices[selectedIndex].disabled && selectedIndex !== 0);
+                    displayChoices(selectedIndex);
+                }
+                else if (keyStr === '\x1b[B') { // Down
+                    do {
+                        selectedIndex = (selectedIndex + 1) % choices.length;
+                    } while (choices[selectedIndex].disabled && selectedIndex !== choices.length - 1);
+                    displayChoices(selectedIndex);
+                }
+                else if (keyStr === '\r' || keyStr === '\n') { // Enter
+                    cleanup();
+                    const selected = choices[selectedIndex];
+                    if (!selected.disabled) {
+                        this.formatter.writeln();
+                        this.formatter.writeln(this.formatter.success(`Selected: ${selected.label}`));
+                        resolve(selected.value);
+                    }
+                }
+                else if (keyStr === '\x03') { // Ctrl+C
+                    cleanup();
+                    reject(new Error('User cancelled'));
+                }
+            };
+            const cleanup = () => {
+                process.stdin.removeListener('data', handleKeypress);
+                if (process.stdin.isTTY) {
+                    process.stdin.setRawMode(false);
+                }
+                this.close();
+            };
+            process.stdin.on('data', handleKeypress);
+        });
+    }
+    // ============================================
+    // Confirm Prompt
+    // ============================================
+    async confirm(options) {
+        const { message, default: defaultValue = false, active = 'Yes', inactive = 'No' } = options;
+        const defaultText = defaultValue ? `${active}/${inactive}` : `${active}/${inactive}`;
+        const hint = defaultValue ? `[${active}]` : `[${inactive}]`;
+        const prompt = `${this.formatter.bold('?')} ${message} ${this.formatter.dim(hint)} `;
+        const answer = await this.question(prompt);
+        this.close();
+        if (answer === '') {
+            return defaultValue;
+        }
+        const normalized = answer.toLowerCase().trim();
+        if (['y', 'yes', 'true', '1'].includes(normalized)) {
+            return true;
+        }
+        if (['n', 'no', 'false', '0'].includes(normalized)) {
+            return false;
+        }
+        return defaultValue;
+    }
+    // ============================================
+    // Input Prompt
+    // ============================================
+    async input(options) {
+        const { message, default: defaultValue, placeholder, validate, mask } = options;
+        let prompt = `${this.formatter.bold('?')} ${message}`;
+        if (defaultValue) {
+            prompt += ` ${this.formatter.dim(`(${defaultValue})`)}`;
+        }
+        else if (placeholder) {
+            prompt += ` ${this.formatter.dim(placeholder)}`;
+        }
+        prompt += ': ';
+        while (true) {
+            let answer;
+            if (mask) {
+                answer = await this.inputMasked(prompt);
+            }
+            else {
+                answer = await this.question(prompt);
+            }
+            // Use default if empty
+            if (answer === '' && defaultValue !== undefined) {
+                answer = defaultValue;
+            }
+            // Validate
+            if (validate) {
+                const result = validate(answer);
+                if (result !== true) {
+                    const errorMsg = typeof result === 'string' ? result : 'Invalid input';
+                    this.formatter.writeln(this.formatter.error(`  ${errorMsg}`));
+                    continue;
+                }
+            }
+            this.close();
+            return answer;
+        }
+    }
+    async inputMasked(prompt) {
+        return new Promise((resolve) => {
+            const rl = this.createInterface();
+            let password = '';
+            // Don't echo characters
+            process.stdout.write(prompt);
+            if (process.stdin.isTTY) {
+                process.stdin.setRawMode(true);
+            }
+            process.stdin.resume();
+            const handleData = (chunk) => {
+                const char = chunk.toString();
+                if (char === '\n' || char === '\r') {
+                    // Enter pressed
+                    process.stdin.removeListener('data', handleData);
+                    if (process.stdin.isTTY) {
+                        process.stdin.setRawMode(false);
+                    }
+                    process.stdout.write('\n');
+                    resolve(password);
+                }
+                else if (char === '\x7f' || char === '\x08') {
+                    // Backspace
+                    if (password.length > 0) {
+                        password = password.slice(0, -1);
+                        process.stdout.write('\b \b');
+                    }
+                }
+                else if (char === '\x03') {
+                    // Ctrl+C
+                    process.stdin.removeListener('data', handleData);
+                    if (process.stdin.isTTY) {
+                        process.stdin.setRawMode(false);
+                    }
+                    resolve('');
+                }
+                else if (char.charCodeAt(0) >= 32) {
+                    // Printable character
+                    password += char;
+                    process.stdout.write('*');
+                }
+            };
+            process.stdin.on('data', handleData);
+        });
+    }
+    // ============================================
+    // Multi-Select Prompt
+    // ============================================
+    async multiSelect(options) {
+        const { message, options: choices, default: defaultValues = [], required = false, min, max } = options;
+        this.formatter.writeln();
+        this.formatter.writeln(this.formatter.bold(`? ${message}`));
+        this.formatter.writeln(this.formatter.dim('  (Use arrow keys to navigate, space to select, enter to confirm)'));
+        this.formatter.writeln();
+        // Initialize selection state
+        const selected = new Set();
+        for (let i = 0; i < choices.length; i++) {
+            // Check both default array and individual selected property
+            if (defaultValues.includes(choices[i].value) || choices[i].selected) {
+                selected.add(i);
+            }
+        }
+        let currentIndex = 0;
+        // Display options
+        const displayChoices = () => {
+            // Move cursor up to overwrite
+            process.stdout.write(`\x1b[${choices.length}A`);
+            for (let i = 0; i < choices.length; i++) {
+                const choice = choices[i];
+                const isCurrentRow = i === currentIndex;
+                const isSelected = selected.has(i);
+                const cursor = isCurrentRow ? this.formatter.info('>') : ' ';
+                const checkbox = isSelected
+                    ? this.formatter.success('[x]')
+                    : this.formatter.dim('[ ]');
+                const label = isCurrentRow
+                    ? this.formatter.highlight(choice.label)
+                    : choice.label;
+                const hint = choice.hint ? this.formatter.dim(` - ${choice.hint}`) : '';
+                const disabled = choice.disabled ? this.formatter.dim(' (disabled)') : '';
+                this.formatter.writeln(`  ${cursor} ${checkbox} ${label}${hint}${disabled}`);
+            }
+        };
+        // Initial display
+        for (let i = 0; i < choices.length; i++) {
+            this.formatter.writeln('');
+        }
+        displayChoices();
+        return new Promise((resolve, reject) => {
+            const rl = this.createInterface();
+            if (process.stdin.isTTY) {
+                process.stdin.setRawMode(true);
+            }
+            process.stdin.resume();
+            const handleKeypress = (key) => {
+                const keyStr = key.toString();
+                if (keyStr === '\x1b[A') { // Up
+                    currentIndex = (currentIndex - 1 + choices.length) % choices.length;
+                    displayChoices();
+                }
+                else if (keyStr === '\x1b[B') { // Down
+                    currentIndex = (currentIndex + 1) % choices.length;
+                    displayChoices();
+                }
+                else if (keyStr === ' ') { // Space
+                    if (!choices[currentIndex].disabled) {
+                        if (selected.has(currentIndex)) {
+                            selected.delete(currentIndex);
+                        }
+                        else {
+                            // Check max limit
+                            if (!max || selected.size < max) {
+                                selected.add(currentIndex);
+                            }
+                        }
+                        displayChoices();
+                    }
+                }
+                else if (keyStr === '\r' || keyStr === '\n') { // Enter
+                    // Validate selection
+                    if (required && selected.size === 0) {
+                        this.formatter.writeln(this.formatter.error('  At least one option must be selected'));
+                        return;
+                    }
+                    if (min && selected.size < min) {
+                        this.formatter.writeln(this.formatter.error(`  At least ${min} options must be selected`));
+                        return;
+                    }
+                    cleanup();
+                    const selectedValues = Array.from(selected).map(i => choices[i].value);
+                    const selectedLabels = Array.from(selected).map(i => choices[i].label);
+                    this.formatter.writeln();
+                    this.formatter.writeln(this.formatter.success(`Selected: ${selectedLabels.join(', ')}`));
+                    resolve(selectedValues);
+                }
+                else if (keyStr === '\x03') { // Ctrl+C
+                    cleanup();
+                    reject(new Error('User cancelled'));
+                }
+                else if (keyStr === 'a') { // Select all
+                    if (!max || choices.length <= max) {
+                        for (let i = 0; i < choices.length; i++) {
+                            if (!choices[i].disabled) {
+                                selected.add(i);
+                            }
+                        }
+                        displayChoices();
+                    }
+                }
+                else if (keyStr === 'n') { // Select none
+                    selected.clear();
+                    displayChoices();
+                }
+            };
+            const cleanup = () => {
+                process.stdin.removeListener('data', handleKeypress);
+                if (process.stdin.isTTY) {
+                    process.stdin.setRawMode(false);
+                }
+                this.close();
+            };
+            process.stdin.on('data', handleKeypress);
+        });
+    }
+    // ============================================
+    // Text Prompt (Multi-line)
+    // ============================================
+    async text(message, placeholder) {
+        this.formatter.writeln();
+        this.formatter.writeln(this.formatter.bold(`? ${message}`));
+        if (placeholder) {
+            this.formatter.writeln(this.formatter.dim(`  ${placeholder}`));
+        }
+        this.formatter.writeln(this.formatter.dim('  (Enter an empty line to finish)'));
+        this.formatter.writeln();
+        const lines = [];
+        while (true) {
+            const line = await this.question('  > ');
+            if (line === '') {
+                break;
+            }
+            lines.push(line);
+        }
+        this.close();
+        return lines.join('\n');
+    }
+    // ============================================
+    // Number Prompt
+    // ============================================
+    async number(message, options = {}) {
+        const { default: defaultValue, min, max } = options;
+        const validate = (value) => {
+            const num = Number(value);
+            if (isNaN(num)) {
+                return 'Please enter a valid number';
+            }
+            if (min !== undefined && num < min) {
+                return `Value must be at least ${min}`;
+            }
+            if (max !== undefined && num > max) {
+                return `Value must be at most ${max}`;
+            }
+            return true;
+        };
+        const result = await this.input({
+            message,
+            default: defaultValue?.toString(),
+            validate
+        });
+        return Number(result);
+    }
+    // ============================================
+    // Autocomplete Prompt
+    // ============================================
+    async autocomplete(message, choices, options = {}) {
+        const { limit = 10 } = options;
+        this.formatter.writeln();
+        this.formatter.writeln(this.formatter.bold(`? ${message}`));
+        this.formatter.writeln(this.formatter.dim('  (Type to filter, arrow keys to navigate)'));
+        let query = '';
+        let selectedIndex = 0;
+        let filteredChoices = choices.slice(0, limit);
+        const filterChoices = (q) => {
+            if (q === '')
+                return choices.slice(0, limit);
+            const normalized = q.toLowerCase();
+            return choices
+                .filter(c => c.label.toLowerCase().includes(normalized))
+                .slice(0, limit);
+        };
+        const displayChoices = () => {
+            // Clear previous output
+            process.stdout.write(`\x1b[${filteredChoices.length + 1}A`);
+            process.stdout.write('\x1b[J');
+            // Show input
+            this.formatter.writeln(`  ${this.formatter.dim('>')} ${query}`);
+            // Show filtered options
+            for (let i = 0; i < filteredChoices.length; i++) {
+                const choice = filteredChoices[i];
+                const isSelected = i === selectedIndex;
+                const prefix = isSelected ? this.formatter.info('>') : ' ';
+                const label = isSelected ? this.formatter.highlight(choice.label) : choice.label;
+                this.formatter.writeln(`  ${prefix} ${label}`);
+            }
+        };
+        // Initial display
+        this.formatter.writeln('');
+        for (let i = 0; i < limit; i++) {
+            this.formatter.writeln('');
+        }
+        displayChoices();
+        return new Promise((resolve, reject) => {
+            const rl = this.createInterface();
+            if (process.stdin.isTTY) {
+                process.stdin.setRawMode(true);
+            }
+            process.stdin.resume();
+            const handleKeypress = (key) => {
+                const keyStr = key.toString();
+                if (keyStr === '\x1b[A') { // Up
+                    selectedIndex = Math.max(0, selectedIndex - 1);
+                    displayChoices();
+                }
+                else if (keyStr === '\x1b[B') { // Down
+                    selectedIndex = Math.min(filteredChoices.length - 1, selectedIndex + 1);
+                    displayChoices();
+                }
+                else if (keyStr === '\r' || keyStr === '\n') { // Enter
+                    if (filteredChoices.length > 0) {
+                        cleanup();
+                        const selected = filteredChoices[selectedIndex];
+                        this.formatter.writeln();
+                        this.formatter.writeln(this.formatter.success(`Selected: ${selected.label}`));
+                        resolve(selected.value);
+                    }
+                }
+                else if (keyStr === '\x7f' || keyStr === '\x08') { // Backspace
+                    query = query.slice(0, -1);
+                    filteredChoices = filterChoices(query);
+                    selectedIndex = 0;
+                    displayChoices();
+                }
+                else if (keyStr === '\x03') { // Ctrl+C
+                    cleanup();
+                    reject(new Error('User cancelled'));
+                }
+                else if (keyStr.charCodeAt(0) >= 32 && keyStr.charCodeAt(0) < 127) {
+                    // Printable character
+                    query += keyStr;
+                    filteredChoices = filterChoices(query);
+                    selectedIndex = 0;
+                    displayChoices();
+                }
+            };
+            const cleanup = () => {
+                process.stdin.removeListener('data', handleKeypress);
+                if (process.stdin.isTTY) {
+                    process.stdin.setRawMode(false);
+                }
+                this.close();
+            };
+            process.stdin.on('data', handleKeypress);
+        });
+    }
+}
+// Export singleton and convenience functions
+export const promptManager = new PromptManager();
+export const select = (options) => promptManager.select(options);
+export const confirm = (options) => promptManager.confirm(options);
+export const input = (options) => promptManager.input(options);
+export const multiSelect = (options) => promptManager.multiSelect(options);
+export const text = (message, placeholder) => promptManager.text(message, placeholder);
+export const number = (message, options) => promptManager.number(message, options);
+export const autocomplete = (message, choices, options) => promptManager.autocomplete(message, choices, options);
+//# sourceMappingURL=prompt.js.map

package/dist/src/proxy/install.d.ts

@@ -0,0 +1,29 @@
+/**
+ * `ruflo proxy install`/`update` orchestration (ADR-307): download -> verify
+ * -> extract -> place -> record. The per-user bearer token
+ * (`~/.ruflo/proxy-token`) is NOT generated here — confirmed empirically
+ * (2026-07-16) that the meta-proxy binary itself creates it on first launch
+ * (`load_or_create_token()`), so this module's job ends at a verified binary
+ * on disk plus an install manifest doctor can check against.
+ *
+ * @module proxy/install
+ */
+export declare class ExtractionError extends Error {
+    constructor(message: string);
+}
+export interface InstallOptions {
+    version: string;
+    log?: (line: string) => void;
+}
+export interface InstallResult {
+    version: string;
+    binaryPath: string;
+    sha256: string;
+}
+/**
+ * Full install pipeline. Refuses (throws) on any verification failure —
+ * never writes a partially-verified binary into the live install path.
+ */
+export declare function installProxy(opts: InstallOptions): Promise<InstallResult>;
+export declare function uninstallProxy(): Promise<boolean>;
+//# sourceMappingURL=install.d.ts.map

package/dist/src/proxy/install.js

@@ -0,0 +1,135 @@
+/**
+ * `ruflo proxy install`/`update` orchestration (ADR-307): download -> verify
+ * -> extract -> place -> record. The per-user bearer token
+ * (`~/.ruflo/proxy-token`) is NOT generated here — confirmed empirically
+ * (2026-07-16) that the meta-proxy binary itself creates it on first launch
+ * (`load_or_create_token()`), so this module's job ends at a verified binary
+ * on disk plus an install manifest doctor can check against.
+ *
+ * @module proxy/install
+ */
+import * as fs from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import { fetchReleaseAssets, detectTargetTriple, releaseArchiveExtension, releaseAssetFilename } from './release.js';
+import { verifyRelease, sha256Hex, PROXY_RELEASE_PUBKEY_PEM } from './verify.js';
+import { proxyBinaryPath, proxyInstallManifestPath } from './paths.js';
+export class ExtractionError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'ExtractionError';
+    }
+}
+function binaryNameInArchive() {
+    return process.platform === 'win32' ? 'meta-proxy.exe' : 'meta-proxy';
+}
+/**
+ * Extracts the archive via the OS's own tools — `tar` for `.tar.gz`
+ * (present on macOS/Linux/Windows 10+), PowerShell `Expand-Archive`
+ * specifically for `.zip` on Windows (not tar's bsdtar zip support — not
+ * reliable enough to lean on). Zero new archive-parsing dependency, matching
+ * this repo's existing taste for shelling out over adding a parser dep.
+ */
+async function extractArchive(archivePath, extractDir, ext) {
+    const { SafeExecutor } = await import('@claude-flow/security');
+    fs.mkdirSync(extractDir, { recursive: true });
+    if (ext === 'tar.gz') {
+        const exec = new SafeExecutor({ allowedCommands: ['tar'], timeout: 60_000 });
+        const result = await exec.execute('tar', ['xzf', archivePath, '-C', extractDir]);
+        if (result.exitCode !== 0) {
+            throw new ExtractionError(`tar extraction failed (exit ${result.exitCode}): ${result.stderr || result.stdout}`);
+        }
+        return;
+    }
+    // .zip — PowerShell Expand-Archive, single-quoted literal paths (doubling
+    // any embedded single quote per PowerShell string-literal escaping) passed
+    // as ONE argv element to -Command. shell:false means no OS shell ever
+    // tokenizes this string — only powershell.exe's own parser does.
+    const escape = (p) => p.replace(/'/g, "''");
+    const command = `Expand-Archive -LiteralPath '${escape(archivePath)}' -DestinationPath '${escape(extractDir)}' -Force`;
+    const exec = new SafeExecutor({ allowedCommands: ['powershell', 'powershell.exe'], timeout: 60_000 });
+    const result = await exec.execute('powershell', ['-NoProfile', '-NonInteractive', '-Command', command]);
+    if (result.exitCode !== 0) {
+        throw new ExtractionError(`Expand-Archive failed (exit ${result.exitCode}): ${result.stderr || result.stdout}`);
+    }
+}
+/**
+ * Full install pipeline. Refuses (throws) on any verification failure —
+ * never writes a partially-verified binary into the live install path.
+ */
+export async function installProxy(opts) {
+    const log = opts.log ?? (() => { });
+    const triple = detectTargetTriple();
+    const archiveFilename = releaseAssetFilename(opts.version, triple);
+    const workDir = fs.mkdtempSync(path.join(os.tmpdir(), 'ruflo-proxy-install-'));
+    try {
+        log(`Fetching meta-proxy ${opts.version} (${triple})...`);
+        const assets = await fetchReleaseAssets(opts.version, triple, workDir, log);
+        log('Verifying release signature and checksum...');
+        const { sha256 } = verifyRelease({
+            sumsBytes: assets.sumsBytes,
+            sigBase64: assets.sigBase64,
+            assetBytes: assets.archiveBytes,
+            assetFilename: assets.archiveFilename,
+        });
+        log(`Verified — sha256 ${sha256.slice(0, 16)}…`);
+        // fetchReleaseAssets's dev (gh) path already wrote the archive to workDir
+        // under archiveFilename; ensure it's there regardless of source so
+        // extraction always has a real file to operate on.
+        const archivePath = path.join(workDir, archiveFilename);
+        if (!fs.existsSync(archivePath)) {
+            fs.writeFileSync(archivePath, assets.archiveBytes);
+        }
+        const extractDir = path.join(workDir, 'extracted');
+        await extractArchive(archivePath, extractDir, releaseArchiveExtension(triple));
+        const extractedBinaryPath = path.join(extractDir, binaryNameInArchive());
+        if (!fs.existsSync(extractedBinaryPath)) {
+            throw new ExtractionError(`archive did not contain the expected binary at its root: ${binaryNameInArchive()}`);
+        }
+        // Defense in depth: confirm the extracted binary genuinely resolves
+        // inside extractDir (catches a symlink swap or similar), even though
+        // we only ever read one specific expected relative path, never an
+        // archive-listed one (so "zip slip" via arbitrary archive paths isn't
+        // reachable here in the first place).
+        const { PathValidator } = await import('@claude-flow/security');
+        const validator = new PathValidator({ allowedPrefixes: [extractDir] });
+        const validation = await validator.validate(extractedBinaryPath);
+        if (!validation.isValid) {
+            throw new ExtractionError(`extracted binary path failed validation: ${validation.errors.join('; ') || 'unknown'}`);
+        }
+        const finalPath = proxyBinaryPath();
+        fs.mkdirSync(path.dirname(finalPath), { recursive: true, mode: 0o700 });
+        const tmp = `${finalPath}.tmp`;
+        fs.copyFileSync(extractedBinaryPath, tmp);
+        fs.chmodSync(tmp, 0o755);
+        fs.renameSync(tmp, finalPath);
+        const liveSha = sha256Hex(fs.readFileSync(finalPath));
+        const manifest = {
+            version: opts.version,
+            sha256: liveSha,
+            verifiedAt: new Date().toISOString(),
+            pubkeyFingerprint: sha256Hex(Buffer.from(PROXY_RELEASE_PUBKEY_PEM)).slice(0, 16),
+        };
+        fs.mkdirSync(path.dirname(proxyInstallManifestPath()), { recursive: true });
+        fs.writeFileSync(proxyInstallManifestPath(), JSON.stringify(manifest, null, 2), { mode: 0o600 });
+        log(`meta-proxy ${opts.version} installed at ${finalPath}`);
+        return { version: opts.version, binaryPath: finalPath, sha256: liveSha };
+    }
+    finally {
+        fs.rmSync(workDir, { recursive: true, force: true });
+    }
+}
+export async function uninstallProxy() {
+    const binPath = proxyBinaryPath();
+    const existed = fs.existsSync(binPath);
+    if (existed)
+        fs.unlinkSync(binPath);
+    try {
+        fs.unlinkSync(proxyInstallManifestPath());
+    }
+    catch {
+        /* absent — fine */
+    }
+    return existed;
+}
+//# sourceMappingURL=install.js.map