@usestatemachines/cli 0.0.0-stage → 0.1.0

package/dist/io.js

@@ -0,0 +1,1017 @@
+import { execFile, fork, spawn } from 'node:child_process';
+import { randomBytes } from 'node:crypto';
+import { constants } from 'node:fs';
+import * as fs from 'node:fs/promises';
+import { homedir, hostname, constants as osConstants } from 'node:os';
+import path from 'node:path';
+import process from 'node:process';
+import { fileURLToPath } from 'node:url';
+import { promisify } from 'node:util';
+import { CliError } from './errors.js';
+function errno(error) {
+    return typeof error === 'object' &&
+        error !== null &&
+        'code' in error &&
+        typeof error.code === 'string'
+        ? error.code
+        : null;
+}
+function check(options, now = Date.now()) {
+    if (options.signal.aborted) {
+        throw new CliError('cli.cancelled');
+    }
+    if (options.deadline !== null && options.deadline <= now) {
+        throw new CliError('cli.wait_timeout');
+    }
+}
+function budget(options, maximum) {
+    return Math.max(0, Math.min(maximum, options.deadline === null ? maximum : options.deadline - Date.now()));
+}
+function effectSignal(options) {
+    return options.deadline === null
+        ? options.signal
+        : AbortSignal.any([
+            options.signal,
+            AbortSignal.timeout(budget(options, 2_147_483_647)),
+        ]);
+}
+async function sleep(milliseconds, options) {
+    check(options);
+    await new Promise((resolve, reject) => {
+        const finish = () => {
+            options.signal.removeEventListener('abort', abort);
+            resolve();
+        };
+        const timer = setTimeout(finish, budget(options, milliseconds));
+        const abort = () => {
+            clearTimeout(timer);
+            reject(new CliError('cli.cancelled'));
+        };
+        options.signal.addEventListener('abort', abort, { once: true });
+    });
+    check(options);
+}
+function owner() {
+    return { hostname: hostname(), pid: process.pid };
+}
+function liveness(candidate, local) {
+    if (candidate.hostname !== local.hostname) {
+        return 'unknown';
+    }
+    try {
+        process.kill(candidate.pid, 0);
+        return 'alive';
+    }
+    catch (error) {
+        return errno(error) === 'ESRCH' ? 'dead' : 'unknown';
+    }
+}
+async function inspect(file) {
+    try {
+        const stat = await fs.lstat(file);
+        return {
+            kind: stat.isSymbolicLink()
+                ? 'symlink'
+                : stat.isDirectory()
+                    ? 'directory'
+                    : stat.isFile()
+                        ? 'file'
+                        : 'other',
+            mode: stat.mode & 0o777,
+        };
+    }
+    catch (error) {
+        if (errno(error) === 'ENOENT') {
+            return { kind: 'missing' };
+        }
+        throw error;
+    }
+}
+async function realDirectory(directory, create, privateLeaf) {
+    const parent = path.dirname(directory);
+    if (create) {
+        await fs.mkdir(parent, { recursive: true, mode: 0o700 });
+    }
+    const resolved = path.join(await fs.realpath(parent), path.basename(directory));
+    let entry = await inspect(resolved);
+    if (entry.kind === 'missing' && create) {
+        try {
+            await fs.mkdir(resolved, { mode: 0o700 });
+        }
+        catch (error) {
+            if (errno(error) !== 'EEXIST') {
+                throw error;
+            }
+        }
+        entry = await inspect(resolved);
+    }
+    if (entry.kind !== 'directory') {
+        throw new CliError('cli.config_io');
+    }
+    if (privateLeaf && process.platform !== 'win32') {
+        await fs.chmod(resolved, 0o700);
+    }
+    return resolved;
+}
+async function realFile(file, create, privateLeaf = false) {
+    const absolute = path.resolve(file);
+    return path.join(await realDirectory(path.dirname(absolute), create, privateLeaf), path.basename(absolute));
+}
+const utf8 = new TextDecoder('utf-8', { fatal: true, ignoreBOM: true });
+async function safeReadBytes(file) {
+    const entry = await inspect(file);
+    if (entry.kind === 'missing') {
+        return null;
+    }
+    if (entry.kind !== 'file') {
+        throw new CliError('cli.config_io');
+    }
+    const resolved = await realFile(file, false);
+    let handle;
+    try {
+        handle = await fs.open(resolved, constants.O_RDONLY | (constants.O_NOFOLLOW ?? 0));
+    }
+    catch (error) {
+        if (errno(error) === 'ENOENT') {
+            return null;
+        }
+        throw error;
+    }
+    try {
+        if (!(await handle.stat()).isFile()) {
+            throw new CliError('cli.config_io');
+        }
+        return await handle.readFile();
+    }
+    finally {
+        await handle.close();
+    }
+}
+async function safeRead(file) {
+    const bytes = await safeReadBytes(file);
+    if (bytes === null) {
+        return null;
+    }
+    try {
+        return utf8.decode(bytes);
+    }
+    catch {
+        throw new CliError('cli.file_not_utf8', {
+            message: `${file} is not valid UTF-8. Save it as UTF-8 and try again.`,
+        });
+    }
+}
+async function syncDirectory(directory) {
+    let handle;
+    try {
+        handle = await fs.open(directory, constants.O_RDONLY);
+        await handle.sync();
+    }
+    catch (error) {
+        const code = errno(error);
+        if (code !== 'EINVAL' &&
+            code !== 'ENOTSUP' &&
+            !(process.platform === 'win32' && (code === 'EPERM' || code === 'EISDIR'))) {
+            throw error;
+        }
+    }
+    finally {
+        await handle?.close();
+    }
+}
+async function writeCandidate(file, text, mode) {
+    const handle = await fs.open(file, constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL, mode);
+    try {
+        await handle.writeFile(text, 'utf8');
+        await handle.sync();
+    }
+    finally {
+        await handle.close();
+    }
+}
+async function removeOwned(file) {
+    try {
+        await fs.unlink(file);
+    }
+    catch (error) {
+        if (errno(error) !== 'ENOENT') {
+            throw error;
+        }
+    }
+}
+// Windows refuses to open, link over or delete a file that another process
+// is deleting or holds without delete sharing. Lock contention causes both.
+function windowsSharing(error) {
+    const code = errno(error);
+    return (process.platform === 'win32' &&
+        (code === 'EPERM' || code === 'EACCES' || code === 'EBUSY'));
+}
+function busyAsMissing(error) {
+    if (windowsSharing(error)) {
+        return null;
+    }
+    throw error;
+}
+function parseLock(text) {
+    let value;
+    try {
+        value = JSON.parse(text);
+    }
+    catch {
+        return null;
+    }
+    if (typeof value !== 'object' ||
+        value === null ||
+        !('hostname' in value) ||
+        typeof value.hostname !== 'string' ||
+        !('pid' in value) ||
+        typeof value.pid !== 'number' ||
+        !Number.isSafeInteger(value.pid) ||
+        value.pid <= 0 ||
+        !('nonce' in value) ||
+        typeof value.nonce !== 'string' ||
+        !/^[0-9a-f]{16,64}$/.test(value.nonce)) {
+        return null;
+    }
+    return { hostname: value.hostname, pid: value.pid, nonce: value.nonce };
+}
+async function staleLock(file, holder) {
+    if (holder === null) {
+        return new CliError('cli.config_lock_invalid', {
+            message: `The configuration lock ${file} is unreadable. If no other statemachines command is running, delete ${file} and try again.`,
+        });
+    }
+    const taken = await fs.stat(file).then((stat) => Math.round((Date.now() - stat.mtimeMs) / 60_000), () => 0);
+    return new CliError('cli.config_lock_invalid', {
+        message: `The configuration lock ${file} belongs to process ${holder.pid} on ${holder.hostname}, taken ${taken} minutes ago. If that process is not running, delete ${file} and try again.`,
+    });
+}
+export function createSystemFiles(local = owner()) {
+    const protect = async (action) => {
+        try {
+            return await action();
+        }
+        catch (error) {
+            if (error instanceof CliError) {
+                throw error;
+            }
+            throw new CliError('cli.config_io');
+        }
+    };
+    const write = (file, content, privacy, options, replace) => protect(async () => {
+        check(options);
+        const destination = await realFile(file, true, privacy === 'private');
+        const directory = path.dirname(destination);
+        const entry = await inspect(destination);
+        if (entry.kind !== 'file' && entry.kind !== 'missing') {
+            throw new CliError('cli.config_io');
+        }
+        if (!replace && entry.kind === 'file') {
+            return false;
+        }
+        const temporary = path.join(directory, `.state-${randomBytes(16).toString('hex')}.tmp`);
+        try {
+            await writeCandidate(temporary, content, privacy === 'public' ? 0o644 : 0o600);
+            check(options);
+            const current = await inspect(destination);
+            if (current.kind !== 'file' && current.kind !== 'missing') {
+                throw new CliError('cli.config_io');
+            }
+            if (replace) {
+                await fs.rename(temporary, destination);
+            }
+            else {
+                try {
+                    await fs.link(temporary, destination);
+                }
+                catch (error) {
+                    if (errno(error) === 'EEXIST') {
+                        return false;
+                    }
+                    throw error;
+                }
+            }
+            await syncDirectory(directory);
+            return true;
+        }
+        finally {
+            await removeOwned(temporary);
+        }
+    });
+    return {
+        read: (file, options) => protect(async () => {
+            check(options);
+            return safeRead(file);
+        }),
+        readBytes: (file, options) => protect(async () => {
+            check(options);
+            return safeReadBytes(file);
+        }),
+        inspect: (file, options) => protect(async () => {
+            check(options);
+            return inspect(file);
+        }),
+        async atomicWrite(file, content, privacy, options) {
+            await write(file, content, privacy, options, true);
+        },
+        createIfMissing: (file, content, privacy, options) => write(file, content, privacy, options, false),
+        remove: (file, options) => protect(async () => {
+            check(options);
+            const entry = await inspect(file);
+            if (entry.kind === 'missing') {
+                return;
+            }
+            if (entry.kind !== 'file') {
+                throw new CliError('cli.config_io');
+            }
+            const resolved = await realFile(file, false);
+            await fs.unlink(resolved);
+            await syncDirectory(path.dirname(resolved));
+        }),
+        withLock: async (requested, options, action) => {
+            check(options);
+            const file = await protect(() => realFile(requested, true, true));
+            const directory = path.dirname(file);
+            const identity = JSON.stringify({
+                ...local,
+                nonce: randomBytes(16).toString('hex'),
+            });
+            const candidate = path.join(directory, `.lock-${randomBytes(16).toString('hex')}.tmp`);
+            const deadline = Date.now() + budget(options, 10_000);
+            let acquired = false;
+            const claim = async (target) => {
+                try {
+                    await fs.link(candidate, target);
+                    return true;
+                }
+                catch (error) {
+                    if (errno(error) !== 'EEXIST' && !windowsSharing(error)) {
+                        throw error;
+                    }
+                }
+                const existing = await safeRead(target).catch(busyAsMissing);
+                if (existing === null) {
+                    return false;
+                }
+                const holder = parseLock(existing);
+                const status = holder === null ? 'unknown' : liveness(holder, local);
+                if (holder === null || status === 'unknown') {
+                    throw await staleLock(target, holder);
+                }
+                if (status === 'dead') {
+                    const marker = `${file}.takeover-${holder.nonce}`;
+                    if (await claim(marker)) {
+                        try {
+                            if ((await safeRead(target).catch(busyAsMissing)) === existing) {
+                                await fs.unlink(target).catch(busyAsMissing);
+                            }
+                        }
+                        finally {
+                            await fs.unlink(marker);
+                        }
+                    }
+                }
+                return false;
+            };
+            try {
+                await protect(async () => {
+                    await writeCandidate(candidate, identity, 0o600);
+                    for (;;) {
+                        acquired = await claim(file);
+                        if (acquired) {
+                            break;
+                        }
+                        check(options);
+                        if (Date.now() >= deadline) {
+                            throw new CliError('cli.config_locked');
+                        }
+                        await sleep(Math.min(25, Math.max(1, deadline - Date.now())), options);
+                    }
+                    await syncDirectory(directory);
+                    check(options);
+                });
+                return await action();
+            }
+            finally {
+                await protect(async () => {
+                    if (acquired && (await safeRead(file)) === identity) {
+                        await fs.unlink(file);
+                        await syncDirectory(directory);
+                    }
+                    await removeOwned(candidate);
+                });
+            }
+        },
+        findRepositoryRoot: (from, options) => protect(async () => {
+            let current = path.resolve(from);
+            for (;;) {
+                check(options);
+                const git = await inspect(path.join(current, '.git'));
+                if (git.kind === 'directory' || git.kind === 'file') {
+                    return current;
+                }
+                const parent = path.dirname(current);
+                if (parent === current) {
+                    return null;
+                }
+                current = parent;
+            }
+        }),
+    };
+}
+export function createSystemGit() {
+    const run = async (root, args, options) => {
+        check(options);
+        const environment = Object.fromEntries(Object.entries(process.env).filter(([key]) => !key.startsWith('GIT_')));
+        return new Promise((resolve, reject) => {
+            const child = spawn('git', ['-C', root, ...args], {
+                env: environment,
+                stdio: ['ignore', 'pipe', 'ignore'],
+                shell: false,
+            });
+            const chunks = [];
+            let failed = false;
+            child.stdout.on('data', (chunk) => chunks.push(chunk));
+            child.once('error', () => {
+                failed = true;
+            });
+            const cancel = () => {
+                child.kill('SIGKILL');
+            };
+            const timer = options.deadline === null
+                ? null
+                : setTimeout(cancel, budget(options, 2_147_483_647));
+            options.signal.addEventListener('abort', cancel, { once: true });
+            child.once('close', (code) => {
+                if (timer !== null) {
+                    clearTimeout(timer);
+                }
+                options.signal.removeEventListener('abort', cancel);
+                try {
+                    check(options);
+                    if (failed || code === null) {
+                        throw new CliError('cli.git');
+                    }
+                    resolve({ code, output: Buffer.concat(chunks).toString('utf8') });
+                }
+                catch (error) {
+                    reject(error);
+                }
+            });
+            if (options.signal.aborted) {
+                cancel();
+            }
+        });
+    };
+    return {
+        async fileStatus(target, options) {
+            const tracked = await run(target.repositoryRoot, [
+                '--literal-pathspecs',
+                'ls-files',
+                '--cached',
+                '-z',
+                '--',
+                target.path,
+            ], options);
+            if (tracked.code !== 0) {
+                throw new CliError('cli.git');
+            }
+            const ignored = await run(target.repositoryRoot, ['check-ignore', '--quiet', '--no-index', '--', target.path], options);
+            if (ignored.code !== 0 && ignored.code !== 1) {
+                throw new CliError('cli.git');
+            }
+            return {
+                tracked: tracked.output.length > 0,
+                ignored: ignored.code === 0,
+            };
+        },
+    };
+}
+function parseKeychainRequest(value) {
+    if (typeof value !== 'object' || value === null || !('kind' in value)) {
+        return null;
+    }
+    if (value.kind === 'probe') {
+        return { kind: 'probe' };
+    }
+    if (!('service' in value) ||
+        typeof value.service !== 'string' ||
+        !('account' in value) ||
+        typeof value.account !== 'string') {
+        return null;
+    }
+    if (value.kind === 'get' || value.kind === 'delete') {
+        return { kind: value.kind, service: value.service, account: value.account };
+    }
+    if (value.kind === 'set' &&
+        'value' in value &&
+        typeof value.value === 'string') {
+        return {
+            kind: 'set',
+            service: value.service,
+            account: value.account,
+            value: value.value,
+        };
+    }
+    return null;
+}
+function parseKeychainResult(value) {
+    if (typeof value !== 'object' || value === null || !('kind' in value)) {
+        return { kind: 'invalid-helper-response' };
+    }
+    if (value.kind === 'value' &&
+        'value' in value &&
+        typeof value.value === 'string') {
+        return { kind: 'value', value: value.value };
+    }
+    switch (value.kind) {
+        case 'available':
+        case 'missing':
+        case 'written':
+        case 'deleted':
+        case 'module-unavailable':
+        case 'operation-failed':
+            return { kind: value.kind };
+        default:
+            return { kind: 'invalid-helper-response' };
+    }
+}
+export function createNativeExecutor(helper = new URL('./native-helper.js', import.meta.url)) {
+    return async (request, options) => {
+        if (options.signal.aborted) {
+            throw new CliError('cli.cancelled');
+        }
+        const remaining = budget(options, 10_000);
+        if (remaining === 0) {
+            return { kind: 'timed-out' };
+        }
+        return new Promise((resolve, reject) => {
+            const environment = {};
+            for (const key of [
+                'HOME',
+                'USER',
+                'LOGNAME',
+                'PATH',
+                'SystemRoot',
+                'WINDIR',
+                'APPDATA',
+                'LOCALAPPDATA',
+                'USERPROFILE',
+                'DBUS_SESSION_BUS_ADDRESS',
+                'XDG_RUNTIME_DIR',
+                'DISPLAY',
+            ]) {
+                const value = process.env[key];
+                if (value !== undefined) {
+                    environment[key] = value;
+                }
+            }
+            const child = fork(fileURLToPath(helper), [], {
+                env: environment,
+                execArgv: [],
+                stdio: ['ignore', 'ignore', 'ignore', 'ipc'],
+            });
+            let outcome = null;
+            let cancelled = false;
+            let finished = false;
+            const kill = () => {
+                if (child.exitCode === null && child.signalCode === null) {
+                    child.kill('SIGKILL');
+                }
+            };
+            const abort = () => {
+                cancelled = true;
+                kill();
+            };
+            const timer = setTimeout(() => {
+                outcome = { kind: 'timed-out' };
+                kill();
+            }, remaining);
+            options.signal.addEventListener('abort', abort, { once: true });
+            child.on('message', (message) => {
+                if (outcome !== null || cancelled) {
+                    return;
+                }
+                const result = parseKeychainResult(message);
+                const compatible = result.kind === 'module-unavailable' ||
+                    result.kind === 'operation-failed' ||
+                    result.kind === 'invalid-helper-response' ||
+                    (request.kind === 'probe' && result.kind === 'available') ||
+                    (request.kind === 'get' &&
+                        (result.kind === 'value' || result.kind === 'missing')) ||
+                    (request.kind === 'set' && result.kind === 'written') ||
+                    (request.kind === 'delete' &&
+                        (result.kind === 'deleted' || result.kind === 'missing'));
+                outcome = compatible ? result : { kind: 'invalid-helper-response' };
+                kill();
+            });
+            child.on('error', () => {
+                outcome ??= { kind: 'operation-failed' };
+                kill();
+            });
+            child.once('close', () => {
+                if (finished) {
+                    return;
+                }
+                finished = true;
+                clearTimeout(timer);
+                options.signal.removeEventListener('abort', abort);
+                if (cancelled) {
+                    reject(new CliError('cli.cancelled'));
+                }
+                else {
+                    resolve(outcome ?? { kind: 'invalid-helper-response' });
+                }
+            });
+            child.send(request, (error) => {
+                if (error !== null) {
+                    outcome ??= { kind: 'operation-failed' };
+                    kill();
+                }
+            });
+            if (options.signal.aborted) {
+                abort();
+            }
+        });
+    };
+}
+export async function nativeOperation(request, load = () => import('@napi-rs/keyring')) {
+    let module;
+    try {
+        module = await load();
+    }
+    catch {
+        return { kind: 'module-unavailable' };
+    }
+    if (request.kind === 'probe') {
+        return { kind: 'available' };
+    }
+    try {
+        const entry = new module.Entry(request.service, request.account, {
+            linux: { store: 'secret-service' },
+        });
+        switch (request.kind) {
+            case 'get': {
+                const value = entry.getPassword();
+                return value === null ? { kind: 'missing' } : { kind: 'value', value };
+            }
+            case 'set':
+                entry.setPassword(request.value);
+                return { kind: 'written' };
+            case 'delete':
+                return { kind: entry.deleteCredential() ? 'deleted' : 'missing' };
+        }
+    }
+    catch {
+        return { kind: 'operation-failed' };
+    }
+}
+export function runNativeHelper() {
+    if (process.send === undefined) {
+        process.exitCode = 1;
+        return;
+    }
+    process.once('message', (message) => {
+        const request = parseKeychainRequest(message);
+        const operation = request === null
+            ? Promise.resolve({ kind: 'invalid-helper-response' })
+            : nativeOperation(request);
+        void operation.then((result) => {
+            process.send?.(result, () => {
+                process.disconnect();
+            });
+        });
+    });
+}
+export async function createHttpLease(proxy, options) {
+    check(options);
+    const { EnvHttpProxyAgent, fetch: request } = await import('undici');
+    const dispatcher = new EnvHttpProxyAgent({
+        httpProxy: proxy.http ?? '',
+        httpsProxy: proxy.https ?? proxy.http ?? '',
+        noProxy: proxy.noProxy ?? '',
+    });
+    const lifetime = new AbortController();
+    let closed = false;
+    return {
+        async fetch(input, init) {
+            check(options);
+            if (closed) {
+                throw new CliError('cli.network');
+            }
+            const source = new Request(input, init);
+            const signal = AbortSignal.any([
+                options.signal,
+                lifetime.signal,
+                source.signal,
+                ...(options.deadline === null
+                    ? []
+                    : [AbortSignal.timeout(budget(options, 2_147_483_647))]),
+            ]);
+            const body = source.method === 'GET' || source.method === 'HEAD'
+                ? undefined
+                : await source.arrayBuffer();
+            const response = await request(source.url, {
+                method: source.method,
+                headers: [...source.headers.entries()],
+                body,
+                signal,
+                redirect: source.redirect,
+                dispatcher,
+            });
+            const responseHeaders = new Headers();
+            response.headers.forEach((value, key) => {
+                responseHeaders.append(key, value);
+            });
+            const reader = response.body?.getReader();
+            const stream = reader
+                ? new ReadableStream({
+                    async pull(controller) {
+                        const result = await reader.read();
+                        if (result.done) {
+                            controller.close();
+                            return;
+                        }
+                        const chunk = result.value;
+                        if (!(chunk instanceof Uint8Array)) {
+                            throw new CliError('cli.invalid_response');
+                        }
+                        controller.enqueue(chunk);
+                    },
+                    async cancel(reason) {
+                        await reader.cancel(reason);
+                    },
+                })
+                : null;
+            return new Response(stream, {
+                status: response.status,
+                statusText: response.statusText,
+                headers: responseHeaders,
+            });
+        },
+        async close() {
+            if (!closed) {
+                closed = true;
+                lifetime.abort();
+                await dispatcher.close();
+            }
+        },
+    };
+}
+const execFileAsync = promisify(execFile);
+async function inTerminalForeground(platform) {
+    try {
+        if (platform === 'linux') {
+            const stat = await fs.readFile('/proc/self/stat', 'utf8');
+            const fields = stat.slice(stat.lastIndexOf(')') + 2).split(' ');
+            return fields[2] === fields[5];
+        }
+        const { stdout } = await execFileAsync('ps', [
+            '-o',
+            'pgid=,tpgid=',
+            '-p',
+            String(process.pid),
+        ]);
+        const [group, foreground] = stdout.trim().split(/\s+/);
+        return group === foreground;
+    }
+    catch {
+        return false;
+    }
+}
+export function createSystemIo() {
+    const controller = new AbortController();
+    let forwarding = false;
+    let activeChild = null;
+    const interrupt = (signal) => {
+        activeChild?.(signal);
+        forwarding = true;
+        controller.abort(signal);
+        forwarding = false;
+    };
+    const platform = process.platform;
+    const relayed = platform === 'win32'
+        ? ['SIGINT', 'SIGTERM', 'SIGHUP']
+        : ['SIGINT', 'SIGQUIT', 'SIGTERM', 'SIGHUP'];
+    for (const signal of relayed) {
+        process.on(signal, interrupt);
+    }
+    if (platform !== 'linux' && platform !== 'darwin' && platform !== 'win32') {
+        throw new CliError('cli.internal');
+    }
+    const home = homedir();
+    const environment = { ...process.env };
+    const platformPath = platform === 'win32' ? path.win32 : path.posix;
+    const configuredDirectory = platform === 'win32' ? environment.APPDATA : environment.XDG_CONFIG_HOME;
+    const configDirectory = configuredDirectory && platformPath.isAbsolute(configuredDirectory)
+        ? configuredDirectory
+        : platformPath.join(home, ...(platform === 'win32' ? ['AppData', 'Roaming'] : ['.config']));
+    const local = owner();
+    const leases = new Set();
+    const write = (stream) => async (value) => {
+        await new Promise((resolve, reject) => {
+            stream.write(value, (error) => (error ? reject(error) : resolve()));
+        });
+    };
+    const host = {
+        environment,
+        platform,
+        home,
+        cwd: process.cwd(),
+        nodeVersion: process.versions.node,
+        owner: local,
+        terminal: process.stdin.isTTY
+            ? process.stdout.isTTY
+                ? 'both'
+                : 'stdin'
+            : process.stdout.isTTY
+                ? 'stdout'
+                : 'none',
+        configHome: platformPath.join(configDirectory, 'statemachines'),
+    };
+    return {
+        host,
+        signal: controller.signal,
+        stdout: { write: write(process.stdout) },
+        stderr: { write: write(process.stderr) },
+        stdin: process.stdin,
+        files: createSystemFiles(local),
+        git: createSystemGit(),
+        now: () => Date.now(),
+        sleep,
+        randomBytes: (length) => randomBytes(length),
+        nativeKeychain: { executeInChild: createNativeExecutor() },
+        prompt: {
+            async multiselect(question, choices, initialValues, options) {
+                check(options);
+                const { createPrompter } = await import('./prompt.js');
+                try {
+                    return await createPrompter(process.stdin, process.stderr).multiselect(question, choices, initialValues, {
+                        ...options,
+                        signal: effectSignal(options),
+                    });
+                }
+                catch (error) {
+                    check(options);
+                    throw error;
+                }
+            },
+            async confirm(question, options) {
+                check(options);
+                const { createPrompter } = await import('./prompt.js');
+                try {
+                    return await createPrompter(process.stdin, process.stderr).confirm(question, { ...options, signal: effectSignal(options) });
+                }
+                catch (error) {
+                    check(options);
+                    throw error;
+                }
+            },
+            async select(question, choices, options) {
+                check(options);
+                const { createPrompter } = await import('./prompt.js');
+                try {
+                    return await createPrompter(process.stdin, process.stderr).select(question, choices, { ...options, signal: effectSignal(options) });
+                }
+                catch (error) {
+                    check(options);
+                    throw error;
+                }
+            },
+        },
+        child: {
+            async liveness(candidate, options) {
+                check(options);
+                return liveness(candidate, local);
+            },
+            async run(spec) {
+                check(spec.options);
+                const [{ default: crossSpawn }, foreground] = await Promise.all([
+                    import('cross-spawn'),
+                    platform !== 'win32' && inTerminalForeground(platform),
+                ]);
+                check(spec.options);
+                return new Promise((resolve, reject) => {
+                    const child = crossSpawn(spec.command, [...spec.args], {
+                        cwd: spec.cwd,
+                        env: { ...spec.environment },
+                        stdio: [
+                            spec.stdin,
+                            spec.output === 'stderr' ? process.stderr : 'inherit',
+                            'inherit',
+                        ],
+                        shell: false,
+                    });
+                    let started = false;
+                    let startFailed = false;
+                    const forward = (signal) => {
+                        child.kill(signal);
+                    };
+                    const relay = (signal) => {
+                        if (platform !== 'win32' &&
+                            !(foreground && (signal === 'SIGINT' || signal === 'SIGQUIT'))) {
+                            forward(signal);
+                        }
+                    };
+                    activeChild = relay;
+                    const abort = () => {
+                        if (!forwarding) {
+                            const reason = spec.options.signal.reason;
+                            forward(relayed.find((signal) => signal === reason) ?? 'SIGTERM');
+                        }
+                    };
+                    const timer = spec.options.deadline === null
+                        ? null
+                        : setTimeout(() => forward('SIGKILL'), budget(spec.options, 2_147_483_647));
+                    spec.options.signal.addEventListener('abort', abort, { once: true });
+                    child.once('spawn', () => {
+                        started = true;
+                    });
+                    child.on('error', (error) => {
+                        startFailed ||= !started || errno(error) === 'ENOENT';
+                    });
+                    child.once('close', (code, signal) => {
+                        if (timer !== null) {
+                            clearTimeout(timer);
+                        }
+                        spec.options.signal.removeEventListener('abort', abort);
+                        if (activeChild === relay) {
+                            activeChild = null;
+                        }
+                        if (startFailed) {
+                            reject(new CliError('cli.child_start'));
+                        }
+                        else {
+                            resolve(signal === null
+                                ? { kind: 'exit', code: code ?? 1 }
+                                : { kind: 'signal', signal });
+                        }
+                    });
+                    if (spec.options.signal.aborted) {
+                        abort();
+                    }
+                });
+            },
+        },
+        async http(proxy, options) {
+            const lease = await createHttpLease(proxy, options);
+            leases.add(lease);
+            return lease;
+        },
+        async detectAgent() {
+            const { determineAgent } = await import('@vercel/detect-agent');
+            const detected = await determineAgent();
+            return detected.isAgent ? { name: detected.agent.name } : null;
+        },
+        async openBrowser(url, options) {
+            check(options);
+            try {
+                const { default: open } = await import('open');
+                await open(url, { wait: false });
+                check(options);
+                return 'opened';
+            }
+            catch (error) {
+                if (error instanceof CliError) {
+                    throw error;
+                }
+                return 'failed';
+            }
+        },
+        async close() {
+            for (const signal of relayed) {
+                process.off(signal, interrupt);
+            }
+            await Promise.all([...leases].map((lease) => lease.close()));
+        },
+    };
+}
+export async function runProcess(main) {
+    const io = createSystemIo();
+    let result;
+    try {
+        result = await main(process.argv.slice(2), io);
+    }
+    catch (error) {
+        await io.close();
+        throw error;
+    }
+    if (typeof result === 'number') {
+        process.exitCode = result;
+        await io.close();
+        return;
+    }
+    try {
+        await io.close();
+    }
+    catch { }
+    if (result.kind === 'exit') {
+        process.exitCode = result.code;
+    }
+    else {
+        process.exitCode = 128 + osConstants.signals[result.signal];
+        if (process.platform !== 'win32') {
+            process.kill(process.pid, result.signal);
+        }
+    }
+}