swarm-deploy 0.0.0 → 0.2.0

package/dist/cli.js

@@ -0,0 +1,751 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.USAGE = void 0;
+exports.main = main;
+const b4a_1 = __importDefault(require("b4a"));
+const error_code_js_1 = require("./error-code.js");
+const _fs_1 = __importDefault(require("#fs"));
+const _os_1 = __importDefault(require("#os"));
+const _path_1 = __importDefault(require("#path"));
+const _process_1 = __importDefault(require("#process"));
+const errors_js_1 = require("./errors.js");
+const identity_js_1 = require("./identity.js");
+const files_js_1 = require("./files.js");
+const symlinks_js_1 = require("./symlinks.js");
+const hooks_module_js_1 = require("./hooks-module.js");
+const server_js_1 = require("./server.js");
+const client_js_1 = require("./client.js");
+const COMMANDS = new Set(['keygen', 'public-key', 'server', 'upload']);
+const HELP_ARGS = new Set(['--help', '-h']);
+const MS_PER_DAY = 24 * 60 * 60 * 1000;
+const MAX_SEED_FILE_BYTES = 65;
+const SERVER_SEED_ENV = 'SWARM_DEPLOY_SERVER_SEED';
+const CLIENT_SEED_ENV = 'SWARM_DEPLOY_CLIENT_SEED';
+const USAGE = [
+    'Usage:',
+    '  swarm-deploy keygen --out <seed-file>',
+    '  swarm-deploy public-key (--seed-file <seed-file> | --seed <64-lower-hex>)',
+    '  swarm-deploy server (--seed-file <seed-file> | --seed <64-lower-hex>) --storage <dir> --allow-key <64-lower-hex> --max-file-bytes <bytes> --max-staging-bytes <bytes> [--allow-key <64-lower-hex>]... [--max-storage-bytes <bytes>] [--max-age-days <days>] [--replace-name <safe-basename>]... [--artifact-pattern <template>]... [--max-count <count>] [--max-versions <count> --version-granularity <major|minor>] [--symlink <selector> <link-name>]... [--hooks <module>]',
+    '  swarm-deploy upload (--seed-file <seed-file> | --seed <64-lower-hex>) --server-key <64-lower-hex> [--idle-timeout <milliseconds>] [--no-source-parent] <file-or-directory>',
+    '',
+    'Use exactly one seed source. A command-specific environment variable is also accepted.'
+].join('\n');
+exports.USAGE = USAGE;
+class CliError extends Error {
+    exitCode;
+    constructor(message, exitCode = 2) {
+        super(message);
+        this.name = 'CliError';
+        this.exitCode = exitCode;
+    }
+}
+function usageError(message) {
+    return new CliError(`${message}\n${USAGE}`, 2);
+}
+function configError(message) {
+    return new CliError(message, 2);
+}
+function basenameOf(value) {
+    try {
+        return _path_1.default.basename(String(value));
+    }
+    catch {
+        return String(value);
+    }
+}
+function isRuntime(value) {
+    const base = basenameOf(value);
+    return base === 'node' || base === 'node.exe' || base === 'bare' || base === 'bare.exe';
+}
+function isScript(value) {
+    const base = basenameOf(value);
+    return base === 'swarm-deploy' || base === 'swarm-deploy.js';
+}
+function normalizeArgv(argv) {
+    const args = Array.from(argv || []);
+    if (args.length >= 2 && isRuntime(args[0]) && isScript(args[1]))
+        return args.slice(2);
+    if (args.length >= 1 && isScript(args[0]))
+        return args.slice(1);
+    return args;
+}
+function platformName() {
+    return _os_1.default.platform();
+}
+function noFollowFlag() {
+    if (_fs_1.default.constants?.O_NOFOLLOW !== undefined)
+        return _fs_1.default.constants.O_NOFOLLOW;
+    const platform = platformName();
+    if (platform === 'darwin')
+        return 0x100;
+    if (platform === 'linux')
+        return 0x20000;
+    throw configError('Safe file open is unsupported on this platform');
+}
+function exclusiveCreateFlag() {
+    if (_fs_1.default.constants?.O_EXCL !== undefined)
+        return _fs_1.default.constants.O_EXCL;
+    const platform = platformName();
+    if (platform === 'darwin')
+        return 0x800;
+    if (platform === 'linux')
+        return 0x80;
+    throw configError('Safe exclusive create is unsupported on this platform');
+}
+function createFileFlag() {
+    if (_fs_1.default.constants?.O_CREAT !== undefined)
+        return _fs_1.default.constants.O_CREAT;
+    const platform = platformName();
+    if (platform === 'darwin')
+        return 0x200;
+    if (platform === 'linux')
+        return 0x40;
+    throw configError('Safe exclusive create is unsupported on this platform');
+}
+function createSeedFlags() {
+    const constants = _fs_1.default.constants || {};
+    return (constants.O_WRONLY ?? 1) | createFileFlag() | exclusiveCreateFlag() | noFollowFlag();
+}
+function readFlags() {
+    return (_fs_1.default.constants?.O_RDONLY ?? 0) | noFollowFlag();
+}
+function parsePositiveSafeInteger(value, name) {
+    if (typeof value !== 'string' || !/^[1-9][0-9]*$/.test(value) || value.length > 16) {
+        throw usageError(`Invalid ${name}`);
+    }
+    const number = Number(value);
+    if (!Number.isSafeInteger(number) || number <= 0)
+        throw usageError(`Invalid ${name}`);
+    return number;
+}
+function parseMaxAgeDays(value) {
+    const days = parsePositiveSafeInteger(value, 'max-age-days');
+    if (days > Math.floor(Number.MAX_SAFE_INTEGER / MS_PER_DAY)) {
+        throw usageError('Invalid max-age-days');
+    }
+    return days * MS_PER_DAY;
+}
+function envHas(env, name) {
+    return !!env && Object.prototype.hasOwnProperty.call(env, name) && env[name] !== undefined;
+}
+function parseSeedText(text, label) {
+    if (typeof text !== 'string')
+        throw configError(`Invalid ${label}`);
+    const body = text.endsWith('\n') ? text.slice(0, -1) : text;
+    if (text !== body && text !== `${body}\n`)
+        throw configError(`Invalid ${label}`);
+    if (!/^[0-9a-f]{64}$/.test(body))
+        throw configError(`Invalid ${label}`);
+    return (0, identity_js_1.parseSeed)(body);
+}
+async function writeAll(handle, bytes) {
+    let offset = 0;
+    while (offset < bytes.byteLength) {
+        const written = await handle.write(bytes, offset, bytes.byteLength - offset, offset);
+        const count = typeof written === 'number' ? written : written.bytesWritten;
+        if (!Number.isSafeInteger(count) || count <= 0)
+            throw configError('Unable to write seed file');
+        offset += count;
+    }
+}
+async function readAll(handle, size) {
+    const bytes = b4a_1.default.alloc(size);
+    let offset = 0;
+    while (offset < size) {
+        const read = await handle.read(bytes, offset, size - offset, offset);
+        const count = typeof read === 'number' ? read : read.bytesRead;
+        if (!Number.isSafeInteger(count) || count <= 0)
+            throw configError('Unable to read file');
+        offset += count;
+    }
+    return bytes;
+}
+async function syncDirectory(directory) {
+    const handle = await _fs_1.default.promises.open(directory, 'r');
+    try {
+        if (typeof handle.sync === 'function')
+            await handle.sync();
+    }
+    finally {
+        await handle.close();
+    }
+}
+async function openNoFollowRead(filePath, label) {
+    try {
+        return await _fs_1.default.promises.open(filePath, readFlags());
+    }
+    catch (err) {
+        if ((0, error_code_js_1.errorCode)(err) === 'ELOOP' || (0, error_code_js_1.errorCode)(err) === 'EISDIR') {
+            throw configError(`${label} must be a regular file`);
+        }
+        throw configError(`Unable to read ${label}`);
+    }
+}
+async function readBoundedRegularFile(filePath, maxBytes, label) {
+    let stat;
+    try {
+        stat = await _fs_1.default.promises.lstat(filePath);
+    }
+    catch {
+        throw configError(`Unable to read ${label}`);
+    }
+    if (stat.isSymbolicLink() || !stat.isFile())
+        throw configError(`${label} must be a regular file`);
+    if (!Number.isSafeInteger(stat.size) || stat.size < 0 || stat.size > maxBytes) {
+        throw configError(`Invalid ${label}`);
+    }
+    const handle = await openNoFollowRead(filePath, label);
+    try {
+        const opened = await handle.stat();
+        if (!opened.isFile() || opened.size !== stat.size)
+            throw configError(`Invalid ${label}`);
+        return b4a_1.default.toString(await readAll(handle, stat.size), 'utf8');
+    }
+    finally {
+        await handle.close().catch(() => { });
+    }
+}
+async function readSeedFile(filePath) {
+    const text = await readBoundedRegularFile(filePath, MAX_SEED_FILE_BYTES, 'seed file');
+    if (text.length < 64)
+        throw configError('Invalid seed file');
+    return parseSeedText(text, 'seed file');
+}
+async function removeSeedTemporary(filePath) {
+    try {
+        await _fs_1.default.promises.unlink(filePath);
+    }
+    catch (err) {
+        if ((0, error_code_js_1.errorCode)(err) === 'ENOENT')
+            return;
+        throw configError('Unable to remove temporary seed file');
+    }
+    try {
+        await syncDirectory(_path_1.default.dirname(filePath));
+    }
+    catch { }
+}
+async function writeSeedFile(filePath, seedHex) {
+    if (typeof filePath !== 'string' || filePath.length === 0)
+        throw usageError('Missing --out');
+    const directory = _path_1.default.dirname(filePath);
+    const temporary = _path_1.default.join(directory, `.${_path_1.default.basename(filePath)}.${b4a_1.default.toString((0, identity_js_1.generateSeed)(), 'hex')}.tmp`);
+    try {
+        await _fs_1.default.promises.lstat(filePath);
+        throw configError('Refusing to overwrite existing seed file');
+    }
+    catch (err) {
+        if (err instanceof CliError)
+            throw err;
+        if ((0, error_code_js_1.errorCode)(err) !== 'ENOENT')
+            throw configError('Unable to create seed file');
+    }
+    let handle = null;
+    try {
+        handle = await _fs_1.default.promises.open(temporary, createSeedFlags(), 0o600);
+    }
+    catch (err) {
+        throw configError('Unable to create seed file');
+    }
+    try {
+        const opened = await handle.stat();
+        if (!opened.isFile())
+            throw configError('Unable to create seed file');
+        if (typeof handle.chmod === 'function')
+            await handle.chmod(0o600);
+        await writeAll(handle, b4a_1.default.from(`${seedHex}\n`));
+        await handle.sync();
+    }
+    catch (err) {
+        await handle.close().catch(() => { });
+        handle = null;
+        await removeSeedTemporary(temporary);
+        if (err instanceof CliError)
+            throw err;
+        throw configError('Unable to write seed file');
+    }
+    await handle.close();
+    handle = null;
+    try {
+        await _fs_1.default.promises.link(temporary, filePath);
+        await syncDirectory(directory);
+    }
+    catch (err) {
+        await removeSeedTemporary(temporary);
+        if ((0, error_code_js_1.errorCode)(err) === 'EEXIST')
+            throw configError('Refusing to overwrite existing seed file');
+        throw configError('Unable to create seed file');
+    }
+    await removeSeedTemporary(temporary);
+}
+function isCanonicalHexToken(value) {
+    return typeof value === 'string' && /^[0-9a-f]{64}$/.test(value);
+}
+function rejectUnexpectedSeed() {
+    throw usageError('Seed strings must be passed with --seed');
+}
+function parseOptions(args, allowed, repeatable = new Set(), keyValues = new Set(), flags = new Set(), pairs = new Set()) {
+    const options = Object.create(null);
+    const repeatedOptions = Object.create(null);
+    const pairOptions = Object.create(null);
+    const flagOptions = Object.create(null);
+    const positionals = [];
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (isCanonicalHexToken(arg) && !keyValues.has(args[i - 1])) {
+            rejectUnexpectedSeed();
+        }
+        if (arg.startsWith('-')) {
+            if (arg.includes('=') || !allowed.has(arg))
+                throw usageError('Unknown option');
+            if (!repeatable.has(arg) &&
+                !pairs.has(arg) &&
+                (Object.prototype.hasOwnProperty.call(options, arg) ||
+                    Object.prototype.hasOwnProperty.call(repeatedOptions, arg) ||
+                    Object.prototype.hasOwnProperty.call(flagOptions, arg))) {
+                throw usageError('Duplicate option');
+            }
+            // A flag takes no value, so the next argument keeps its own meaning.
+            if (flags.has(arg)) {
+                flagOptions[arg] = true;
+                continue;
+            }
+            if (pairs.has(arg)) {
+                const first = args[i + 1];
+                const second = args[i + 2];
+                if (first === undefined ||
+                    first.startsWith('-') ||
+                    second === undefined ||
+                    second.startsWith('-')) {
+                    throw usageError('Missing option value');
+                }
+                if (isCanonicalHexToken(second) && !keyValues.has(arg))
+                    rejectUnexpectedSeed();
+                const values = pairOptions[arg] || [];
+                values.push([first, second]);
+                pairOptions[arg] = values;
+                i += 2;
+                continue;
+            }
+            const value = args[i + 1];
+            if (value === undefined || value.startsWith('-')) {
+                throw usageError('Missing option value');
+            }
+            if (isCanonicalHexToken(value) && !keyValues.has(arg))
+                rejectUnexpectedSeed();
+            if (repeatable.has(arg)) {
+                const values = repeatedOptions[arg] || [];
+                values.push(value);
+                repeatedOptions[arg] = values;
+            }
+            else {
+                options[arg] = value;
+            }
+            i++;
+            continue;
+        }
+        positionals.push(arg);
+    }
+    return { options, repeatedOptions, pairOptions, flagOptions, positionals };
+}
+function requireOption(options, name) {
+    if (typeof options[name] !== 'string' || options[name].length === 0) {
+        throw usageError(`Missing ${name}`);
+    }
+    return options[name];
+}
+function requirePositionals(positionals, count, label) {
+    if (positionals.length !== count)
+        throw usageError(label);
+    return positionals;
+}
+async function resolveSeed({ seedFile, seedText, env, envName, role }) {
+    const hasFile = seedFile !== undefined;
+    const hasText = seedText !== undefined;
+    const hasEnv = envHas(env, envName);
+    if (Number(hasFile) + Number(hasText) + Number(hasEnv) > 1) {
+        throw configError(`${role} seed must be provided by exactly one source`);
+    }
+    if (hasFile)
+        return await readSeedFile(seedFile);
+    if (hasText)
+        return parseSeedText(seedText, `${role} seed`);
+    if (hasEnv)
+        return parseSeedText(String(env[envName]), `${role} seed`);
+    throw usageError(`${role} seed is required`);
+}
+function writeLine(stream, line) {
+    if (!stream || typeof stream.write !== 'function')
+        return;
+    stream.write(line.endsWith('\n') ? line : `${line}\n`);
+}
+function createLogger(io) {
+    const write = (level, message, details) => {
+        try {
+            if (!io.stderr || typeof io.stderr.write !== 'function')
+                return;
+            const suffix = details && typeof details === 'object' ? ` ${JSON.stringify(details)}` : '';
+            io.stderr.write(`${level}: ${message}${suffix}\n`);
+        }
+        catch { }
+    };
+    return {
+        info(message, details) {
+            write('info', message, details);
+        },
+        warn(message, details) {
+            write('warn', message, details);
+        },
+        error(message, details) {
+            write('error', message, details);
+        }
+    };
+}
+function attachSignals(proc, handler) {
+    if (!proc || typeof proc.on !== 'function')
+        return () => { };
+    proc.on('SIGINT', handler);
+    proc.on('SIGTERM', handler);
+    return () => {
+        if (typeof proc.off === 'function') {
+            proc.off('SIGINT', handler);
+            proc.off('SIGTERM', handler);
+            return;
+        }
+        if (typeof proc.removeListener === 'function') {
+            proc.removeListener('SIGINT', handler);
+            proc.removeListener('SIGTERM', handler);
+        }
+    };
+}
+function onceClose(resource) {
+    let pending = null;
+    return () => {
+        if (!pending) {
+            pending = Promise.resolve().then(() => resource && typeof resource.close === 'function' ? resource.close() : undefined);
+        }
+        return pending;
+    };
+}
+function isConfigFailure(err) {
+    if (err instanceof CliError)
+        return err.exitCode === 2;
+    if (!(err instanceof errors_js_1.SwarmDeployError))
+        return false;
+    return (err.code === errors_js_1.ERRORS.INVALID_SEED ||
+        err.code === errors_js_1.ERRORS.INVALID_PUBLIC_KEY ||
+        err.code === errors_js_1.ERRORS.PROTOCOL_INVALID ||
+        err.code === errors_js_1.ERRORS.SERVER_KEY_MISMATCH);
+}
+function exitCodeFor(err) {
+    if (typeof err === 'object' &&
+        err !== null &&
+        'exitCode' in err &&
+        typeof err.exitCode === 'number') {
+        return err.exitCode;
+    }
+    return isConfigFailure(err) ? 2 : 1;
+}
+function errorMessage(err) {
+    if (!err)
+        return 'Unknown error';
+    if (typeof err === 'object') {
+        if ('message' in err && typeof err.message === 'string' && err.message.length > 0) {
+            return err.message;
+        }
+        if ('name' in err && typeof err.name === 'string' && err.name.length > 0)
+            return err.name;
+    }
+    return 'Error';
+}
+function writeError(io, err) {
+    try {
+        if (!io.stderr || typeof io.stderr.write !== 'function')
+            return;
+        const message = errorMessage(err);
+        io.stderr.write(message.endsWith('\n') ? message : `${message}\n`);
+    }
+    catch { }
+}
+async function runKeygen(args) {
+    const { options, positionals } = parseOptions(args, new Set(['--out']));
+    requirePositionals(positionals, 0, 'keygen does not accept positional arguments');
+    const out = requireOption(options, '--out');
+    const seed = (0, identity_js_1.generateSeed)();
+    const seedHex = b4a_1.default.toString(seed, 'hex');
+    await writeSeedFile(out, seedHex);
+    return b4a_1.default.toString((0, identity_js_1.publicKeyFromSeed)(seed), 'hex');
+}
+async function runPublicKey(args) {
+    const { options, positionals } = parseOptions(args, new Set(['--seed-file', '--seed']), new Set(), new Set(['--seed']));
+    requirePositionals(positionals, 0, 'public-key does not accept positional arguments');
+    const hasFile = options['--seed-file'] !== undefined;
+    const hasText = options['--seed'] !== undefined;
+    if (hasFile === hasText)
+        throw usageError('public-key requires exactly one seed source');
+    const seed = hasFile
+        ? await readSeedFile(requireOption(options, '--seed-file'))
+        : parseSeedText(requireOption(options, '--seed'), 'seed');
+    return b4a_1.default.toString((0, identity_js_1.publicKeyFromSeed)(seed), 'hex');
+}
+async function runServer(args, env, io) {
+    const { options, repeatedOptions, pairOptions, positionals } = parseOptions(args, new Set([
+        '--seed-file',
+        '--seed',
+        '--storage',
+        '--allow-key',
+        '--max-file-bytes',
+        '--max-staging-bytes',
+        '--max-storage-bytes',
+        '--max-age-days',
+        '--replace-name',
+        '--artifact-pattern',
+        '--max-count',
+        '--max-versions',
+        '--version-granularity',
+        '--symlink',
+        '--hooks'
+    ]), new Set(['--replace-name', '--allow-key', '--artifact-pattern', '--symlink']), new Set(['--allow-key', '--seed']), new Set(), new Set(['--symlink']));
+    requirePositionals(positionals, 0, 'server does not accept positional arguments');
+    const storageDir = requireOption(options, '--storage');
+    const maxFileBytes = parsePositiveSafeInteger(requireOption(options, '--max-file-bytes'), 'max-file-bytes');
+    const maxStagingBytes = parsePositiveSafeInteger(requireOption(options, '--max-staging-bytes'), 'max-staging-bytes');
+    const maxStorageBytes = options['--max-storage-bytes'] === undefined
+        ? undefined
+        : parsePositiveSafeInteger(options['--max-storage-bytes'], 'max-storage-bytes');
+    const maxAge = options['--max-age-days'] === undefined ? undefined : parseMaxAgeDays(options['--max-age-days']);
+    let replaceNames;
+    try {
+        replaceNames = (0, files_js_1.validateReplaceNames)(repeatedOptions['--replace-name'] || []);
+    }
+    catch {
+        throw usageError('Invalid --replace-name');
+    }
+    const artifactPatterns = repeatedOptions['--artifact-pattern'];
+    const maxCount = options['--max-count'] === undefined
+        ? undefined
+        : parsePositiveSafeInteger(options['--max-count'], 'max-count');
+    const maxVersions = options['--max-versions'] === undefined
+        ? undefined
+        : parsePositiveSafeInteger(options['--max-versions'], 'max-versions');
+    const granularity = options['--version-granularity'];
+    if (granularity !== undefined && granularity !== 'major' && granularity !== 'minor') {
+        throw usageError('Invalid --version-granularity');
+    }
+    const seed = await resolveSeed({
+        seedFile: options['--seed-file'],
+        seedText: options['--seed'],
+        env,
+        envName: SERVER_SEED_ENV,
+        role: 'server'
+    });
+    const allowedKeyValues = repeatedOptions['--allow-key'] || [];
+    if (allowedKeyValues.length === 0)
+        throw usageError('Missing --allow-key');
+    const allowedKeys = new Set();
+    try {
+        for (const value of allowedKeyValues) {
+            const parsed = (0, identity_js_1.parsePublicKey)(value);
+            const encoded = b4a_1.default.toString(parsed, 'hex');
+            if ([...allowedKeys].some((candidate) => b4a_1.default.toString(candidate, 'hex') === encoded)) {
+                throw new Error('duplicate');
+            }
+            allowedKeys.add(parsed);
+        }
+    }
+    catch {
+        throw usageError('Invalid --allow-key');
+    }
+    let hooks;
+    if (options['--hooks'] !== undefined) {
+        try {
+            hooks = await (0, hooks_module_js_1.loadHooksModule)(options['--hooks'], io.cwd ?? _process_1.default.cwd());
+        }
+        catch (err) {
+            throw configError(errorMessage(err));
+        }
+    }
+    const symlinkPairs = pairOptions['--symlink'] || [];
+    const symlinks = symlinkPairs.map(([selector, name]) => ({ selector, name }));
+    try {
+        (0, symlinks_js_1.compileSymlinkRules)(symlinks);
+    }
+    catch {
+        throw usageError('Invalid --symlink');
+    }
+    const ServerImpl = io.Server || server_js_1.Server;
+    let server;
+    try {
+        server = new ServerImpl({
+            seed,
+            storageDir,
+            allowedKeys,
+            maxFileBytes,
+            maxStagingBytes,
+            maxStorageBytes,
+            maxAge,
+            replaceNames,
+            artifactPatterns,
+            maxCount,
+            maxVersions,
+            versionGranularity: granularity,
+            ...(symlinks.length > 0 ? { symlinks } : {}),
+            hooks,
+            dht: io.dht,
+            logger: createLogger(io)
+        });
+    }
+    catch (err) {
+        throw new CliError(errorMessage(err), 2);
+    }
+    const proc = io.process || _process_1.default;
+    const close = onceClose(server);
+    let resolveStopped;
+    const stopped = new Promise((resolve) => {
+        resolveStopped = resolve;
+    });
+    const onSignal = () => {
+        close().then(resolveStopped, resolveStopped);
+    };
+    const detach = attachSignals(proc, onSignal);
+    let runError = null;
+    try {
+        try {
+            await server.listen();
+        }
+        catch (err) {
+            runError = new CliError(errorMessage(err), 1);
+        }
+        if (!runError) {
+            writeLine(io.stdout, b4a_1.default.toString(server.publicKey, 'hex'));
+            writeLine(io.stdout, 'ready');
+            await stopped;
+        }
+    }
+    finally {
+        detach();
+        try {
+            await close();
+        }
+        catch {
+            if (!runError)
+                runError = new CliError('Cleanup failed', 1);
+        }
+    }
+    if (runError)
+        throw runError;
+    return 0;
+}
+function printUploadResult(result, io) {
+    writeLine(io.stdout, `${result.name} ${result.kind} ${result.status}`);
+    return result.status === 'COMMITTED' || result.status === 'ALREADY_COMMITTED' ? 0 : 1;
+}
+async function runUpload(args, env, io) {
+    const { options, flagOptions, positionals } = parseOptions(args, new Set(['--seed-file', '--seed', '--server-key', '--idle-timeout', '--no-source-parent']), new Set(), new Set(['--server-key', '--seed']), new Set(['--no-source-parent']));
+    const [inputPath] = requirePositionals(positionals, 1, 'upload requires a file or directory');
+    const seed = await resolveSeed({
+        seedFile: options['--seed-file'],
+        seedText: options['--seed'],
+        env,
+        envName: CLIENT_SEED_ENV,
+        role: 'client'
+    });
+    let serverPublicKey;
+    try {
+        serverPublicKey = (0, identity_js_1.parsePublicKey)(requireOption(options, '--server-key'));
+    }
+    catch {
+        throw usageError('Invalid --server-key');
+    }
+    const idleTimeout = options['--idle-timeout'] === undefined
+        ? io.idleTimeout
+        : parsePositiveSafeInteger(options['--idle-timeout'], 'idle-timeout');
+    const ClientImpl = io.Client || client_js_1.Client;
+    let client;
+    try {
+        client = new ClientImpl({
+            seed,
+            serverPublicKey,
+            dht: io.dht,
+            connectTimeout: io.connectTimeout,
+            idleTimeout,
+            ...(flagOptions['--no-source-parent'] ? { includeSourceParent: false } : {}),
+            logger: createLogger(io)
+        });
+    }
+    catch (err) {
+        throw new CliError(errorMessage(err), 2);
+    }
+    const proc = io.process || _process_1.default;
+    const close = onceClose(client);
+    const detach = attachSignals(proc, () => {
+        close().then(() => { }, () => { });
+    });
+    let runError = null;
+    let code = 0;
+    try {
+        try {
+            const result = await client.upload(inputPath);
+            code = printUploadResult(result, io);
+        }
+        catch (err) {
+            runError = new CliError(errorMessage(err), 1);
+        }
+    }
+    finally {
+        detach();
+        try {
+            await close();
+        }
+        catch {
+            if (!runError && code === 0)
+                runError = new CliError('Cleanup failed', 1);
+        }
+    }
+    if (runError)
+        throw runError;
+    return code;
+}
+async function dispatch(argv, env, io) {
+    if (argv.length === 1 && HELP_ARGS.has(argv[0])) {
+        writeLine(io.stdout, USAGE);
+        return 0;
+    }
+    if (argv.length === 0)
+        throw usageError('Missing command');
+    const command = argv[0];
+    if (isCanonicalHexToken(command))
+        rejectUnexpectedSeed();
+    if (!COMMANDS.has(command))
+        throw usageError('Unknown command');
+    const args = argv.slice(1);
+    if (command === 'keygen') {
+        writeLine(io.stdout, await runKeygen(args));
+        return 0;
+    }
+    if (command === 'public-key') {
+        writeLine(io.stdout, await runPublicKey(args));
+        return 0;
+    }
+    if (command === 'server')
+        return runServer(args, env, io);
+    return runUpload(args, env, io);
+}
+async function main(argv, env, io = {}) {
+    const streams = {
+        stdout: io.stdout || _process_1.default.stdout,
+        stderr: io.stderr || _process_1.default.stderr
+    };
+    const context = { ...io, ...streams };
+    try {
+        return await dispatch(normalizeArgv(argv), env || {}, context);
+    }
+    catch (err) {
+        writeError(context, err);
+        return exitCodeFor(err);
+    }
+}
+//# sourceMappingURL=cli.js.map