@fedify/cli 2.3.0-dev.994 → 2.3.1

package/dist/lookup.js

@@ -1,22 +1,20 @@
 import "@js-temporal/polyfill";
-import { getContextLoader, getDocumentLoader as getDocumentLoader$1 } from "./docloader.js";
+import { FEDIBIRD_QUOTE_IRI, IN_REPLY_TO_IRI, MISSKEY_QUOTE_IRI, QUOTE_IRI, QUOTE_URL_IRI } from "./lookup/command.js";
+import { colorEnabled, colors, describeError, formatObject } from "./utils.js";
 import { configureLogging } from "./log.js";
+import { getContextLoader, getDocumentLoader as getDocumentLoader$1 } from "./docloader.js";
 import { spawnTemporaryServer } from "./tempserver.js";
-import { colorEnabled, colors, formatObject } from "./utils.js";
-import { configContext } from "./config.js";
-import { createTunnelServiceOption, userAgentOption } from "./options.js";
 import { renderImages } from "./imagerenderer.js";
-import { url } from "@optique/core/message";
-import { path, printError } from "@optique/run";
 import process from "node:process";
-import { argument, choice, command, constant, flag, float, integer, map, merge, message as message$1, multiple, object, option, optionNames, optional, or, string, withDefault } from "@optique/core";
+import { message, optionNames } from "@optique/core";
+import { printError } from "@optique/run";
+import { createWriteStream } from "node:fs";
+import { UrlError, expandIPv6Address, isValidPublicIPv4Address, isValidPublicIPv6Address } from "@fedify/vocab-runtime";
 import { generateCryptoKeyPair, getAuthenticatedDocumentLoader, respondWithObject } from "@fedify/fedify";
-import { Application, Collection, CryptographicKey, Object as Object$1, lookupObject, traverseCollection } from "@fedify/vocab";
 import { getLogger } from "@logtape/logtape";
 import ora from "ora";
-import { UrlError, expandIPv6Address, isValidPublicIPv4Address, isValidPublicIPv6Address } from "@fedify/vocab-runtime";
-import { bindConfig } from "@optique/config";
-import { createWriteStream } from "node:fs";
+import { Application, Collection, CryptographicKey, Object as Object$1, lookupObject, traverseCollection } from "@fedify/vocab";
+import { url } from "@optique/core/message";
 import { isIP } from "node:net";
 //#region src/lookup.ts
 const logger = getLogger([
@@ -24,116 +22,6 @@ const logger = getLogger([
 	"cli",
 	"lookup"
 ]);
-const IN_REPLY_TO_IRI = "https://www.w3.org/ns/activitystreams#inReplyTo";
-const QUOTE_IRI = "https://w3id.org/fep/044f#quote";
-const QUOTE_URL_IRI = "https://www.w3.org/ns/activitystreams#quoteUrl";
-const MISSKEY_QUOTE_IRI = "https://misskey-hub.net/ns#_misskey_quote";
-const FEDIBIRD_QUOTE_IRI = "http://fedibird.com/ns#quoteUri";
-const recurseProperties = [
-	"replyTarget",
-	"quote",
-	"quoteUrl",
-	IN_REPLY_TO_IRI,
-	QUOTE_IRI,
-	QUOTE_URL_IRI,
-	MISSKEY_QUOTE_IRI,
-	FEDIBIRD_QUOTE_IRI
-];
-const suppressErrorsOption = bindConfig(flag("-S", "--suppress-errors", { description: message$1`Suppress partial errors during traversal or recursion.` }), {
-	context: configContext,
-	key: (config) => config.lookup?.suppressErrors ?? false,
-	default: false
-});
-const allowPrivateAddressOption = bindConfig(flag("-p", "--allow-private-address", { description: message$1`Allow private IP addresses for URLs discovered \
-during traversal or recursive object fetches. Recursive JSON-LD \
-context URLs always remain blocked. URLs explicitly provided on the \
-command line always allow private addresses.` }), {
-	context: configContext,
-	key: (config) => config.lookup?.allowPrivateAddress ?? false,
-	default: false
-});
-const authorizedFetchOption = withDefault(object("Authorized fetch options", {
-	authorizedFetch: bindConfig(map(flag("-a", "--authorized-fetch", { description: message$1`Sign the request with an one-time key.` }), () => true), {
-		context: configContext,
-		key: (config) => config.lookup?.authorizedFetch ? true : void 0
-	}),
-	firstKnock: bindConfig(option("--first-knock", choice(["draft-cavage-http-signatures-12", "rfc9421"]), { description: message$1`The first-knock spec for ${optionNames(["-a", "--authorized-fetch"])}. It is used for the double-knocking technique.` }), {
-		context: configContext,
-		key: (config) => config.lookup?.firstKnock ?? "draft-cavage-http-signatures-12",
-		default: "draft-cavage-http-signatures-12"
-	}),
-	tunnelService: optional(createTunnelServiceOption())
-}), {
-	authorizedFetch: false,
-	firstKnock: void 0,
-	tunnelService: void 0
-});
-const lookupModeOption = withDefault(or(object("Recurse options", {
-	traverse: constant(false),
-	recurse: bindConfig(option("--recurse", choice(recurseProperties, { metavar: "PROPERTY" }), { description: message$1`Recursively follow a relationship property.` }), {
-		context: configContext,
-		key: (config) => config.lookup?.recurse
-	}),
-	recurseDepth: bindConfig(option("--recurse-depth", integer({
-		min: 1,
-		metavar: "DEPTH"
-	}), { description: message$1`Maximum recursion depth for ${optionNames(["--recurse"])}.` }), {
-		context: configContext,
-		key: (config) => config.lookup?.recurseDepth,
-		default: 20
-	}),
-	suppressErrors: suppressErrorsOption
-}), object("Traverse options", {
-	traverse: bindConfig(flag("-t", "--traverse", { description: message$1`Traverse the given collection(s) to fetch all items.` }), {
-		context: configContext,
-		key: (config) => config.lookup?.traverse ?? false,
-		default: false
-	}),
-	recurse: constant(void 0),
-	recurseDepth: constant(void 0),
-	suppressErrors: suppressErrorsOption
-})), {
-	traverse: false,
-	recurse: void 0,
-	recurseDepth: void 0,
-	suppressErrors: false
-});
-const lookupCommand = command("lookup", merge(object({ command: constant("lookup") }), lookupModeOption, authorizedFetchOption, merge("Network options", userAgentOption, object({
-	allowPrivateAddress: allowPrivateAddressOption,
-	timeout: optional(bindConfig(option("-T", "--timeout", float({
-		min: 0,
-		metavar: "SECONDS"
-	}), { description: message$1`Set timeout for network requests in seconds.` }), {
-		context: configContext,
-		key: (config) => config.lookup?.timeout
-	}))
-})), object("Arguments", { urls: multiple(argument(string({ metavar: "URL_OR_HANDLE" }), { description: message$1`One or more URLs or handles to look up.` }), { min: 1 }) }), object("Output options", {
-	reverse: bindConfig(flag("--reverse", { description: message$1`Reverse the output order of fetched objects or items.` }), {
-		context: configContext,
-		key: (config) => config.lookup?.reverse ?? false,
-		default: false
-	}),
-	format: bindConfig(optional(or(map(flag("-r", "--raw", { description: message$1`Print the fetched JSON-LD document as is.` }), () => "raw"), map(flag("-C", "--compact", { description: message$1`Compact the fetched JSON-LD document.` }), () => "compact"), map(flag("-e", "--expand", { description: message$1`Expand the fetched JSON-LD document.` }), () => "expand"))), {
-		context: configContext,
-		key: (config) => config.lookup?.defaultFormat ?? "default",
-		default: "default"
-	}),
-	separator: bindConfig(option("-s", "--separator", string({ metavar: "SEPARATOR" }), { description: message$1`Specify the separator between adjacent output objects or collection items.` }), {
-		context: configContext,
-		key: (config) => config.lookup?.separator ?? "----",
-		default: "----"
-	}),
-	output: optional(option("-o", "--output", path({
-		metavar: "OUTPUT_PATH",
-		type: "file",
-		allowCreate: true
-	}), { description: message$1`Specify the output file path.` }))
-})), {
-	brief: message$1`Look up Activity Streams objects.`,
-	description: message$1`Look up Activity Streams objects by URL or actor handle.
-
-The arguments can be either URLs or actor handles (e.g., ${"@username@domain"}), and they can be multiple.`
-});
 var TimeoutError = class extends Error {
 	name = "TimeoutError";
 	constructor(message) {
@@ -282,10 +170,10 @@ function wrapDocumentLoaderWithTimeout(loader, timeoutSeconds) {
 function handleTimeoutError(spinner, timeoutSeconds, url) {
 	const urlText = url ? ` for: ${colors.red(url)}` : "";
 	spinner.fail(`Request timed out after ${timeoutSeconds} seconds${urlText}.`);
-	printError(message$1`Try increasing the timeout with ${optionNames(["-T", "--timeout"])} option or check network connectivity.`);
+	printError(message`Try increasing the timeout with ${optionNames(["-T", "--timeout"])} option or check network connectivity.`);
 }
 function isPrivateAddressError(error) {
-	const lowerMessage = (error instanceof Error ? error.message : String(error)).toLowerCase();
+	const lowerMessage = describeError(error).toLowerCase();
 	if (error instanceof UrlError) return lowerMessage.includes("invalid or private address") || lowerMessage.includes("localhost is not allowed");
 	return lowerMessage.includes("private address") || lowerMessage.includes("private ip") || lowerMessage.includes("localhost") || lowerMessage.includes("loopback");
 }
@@ -308,7 +196,7 @@ function isPrivateAddressTarget(target) {
 	return getPrivateUrlCandidate(target) != null;
 }
 function getPrivateContextUrl(error) {
-	const errorMessage = error instanceof Error ? error.message : String(error);
+	const errorMessage = describeError(error);
 	if (!(error instanceof Error) || error.name !== "jsonld.InvalidUrl" || !errorMessage.includes("valid JSON-LD object")) return null;
 	const structuredError = error;
 	const structuredUrl = getPrivateUrlCandidate(structuredError.details?.url) ?? getPrivateUrlCandidate(structuredError.url);
@@ -318,10 +206,10 @@ function getPrivateContextUrl(error) {
 	return getPrivateUrlCandidate(match[1]);
 }
 function printRecursivePrivateAddressHint() {
-	printError(message$1`The recursive target appears to be private or localhost.  Try with ${optionNames(["-p", "--allow-private-address"])}, or use ${optionNames(["-S", "--suppress-errors"])} to skip blocked steps.`);
+	printError(message`The recursive target appears to be private or localhost.  Try with ${optionNames(["-p", "--allow-private-address"])}, or use ${optionNames(["-S", "--suppress-errors"])} to skip blocked steps.`);
 }
 function printRecursivePrivateContextHint(privateContextUrl) {
-	printError(message$1`Recursive JSON-LD context URL ${url(privateContextUrl)} is always blocked, even with ${optionNames(["-p", "--allow-private-address"])}.  Use ${optionNames(["-S", "--suppress-errors"])} to skip blocked steps.`);
+	printError(message`Recursive JSON-LD context URL ${url(privateContextUrl)} is always blocked, even with ${optionNames(["-p", "--allow-private-address"])}.  Use ${optionNames(["-S", "--suppress-errors"])} to skip blocked steps.`);
 }
 function getLookupFailureHint(error, options = {}) {
 	if (isPrivateAddressError(error)) return options.recursive ? "recursive-private-address" : "private-address";
@@ -338,13 +226,13 @@ function printLookupFailureHint(authLoader, error, options = {}) {
 	if (!shouldPrintLookupFailureHint(authLoader, hint)) return;
 	switch (hint) {
 		case "private-address":
-			printError(message$1`The URL appears to be private or localhost.  Try with ${optionNames(["-p", "--allow-private-address"])}.`);
+			printError(message`The URL appears to be private or localhost.  Try with ${optionNames(["-p", "--allow-private-address"])}.`);
 			return;
 		case "recursive-private-address":
 			printRecursivePrivateAddressHint();
 			return;
 		case "authorized-fetch":
-			printError(message$1`It may be a private object.  Try with ${optionNames(["-a", "--authorized-fetch"])}.`);
+			printError(message`It may be a private object.  Try with ${optionNames(["-a", "--authorized-fetch"])}.`);
 			return;
 	}
 }
@@ -418,7 +306,7 @@ async function runLookup(command, deps = {}) {
 		...deps
 	};
 	if (command.urls.length < 1) {
-		printError(message$1`At least one URL or actor handle must be provided.`);
+		printError(message`At least one URL or actor handle must be provided.`);
 		effectiveDeps.exit(1);
 	}
 	if (command.debug) await configureLogging();
@@ -472,6 +360,7 @@ async function runLookup(command, deps = {}) {
 		effectiveDeps.exit(cleanupFailed && code === 0 ? 1 : code);
 	};
 	if (command.authorizedFetch) {
+		const firstKnock = command.firstKnock ?? "draft-cavage-http-signatures-12";
 		spinner.text = "Generating a one-time key pair...";
 		const key = await generateCryptoKeyPair();
 		spinner.text = "Spinning up a temporary ActivityPub server...";
@@ -511,7 +400,7 @@ async function runLookup(command, deps = {}) {
 			userAgent: command.userAgent,
 			specDeterminer: {
 				determineSpec() {
-					return command.firstKnock;
+					return firstKnock;
 				},
 				rememberSpec() {}
 			}
@@ -521,7 +410,7 @@ async function runLookup(command, deps = {}) {
 			userAgent: command.userAgent,
 			specDeterminer: {
 				determineSpec() {
-					return command.firstKnock;
+					return firstKnock;
 				},
 				rememberSpec() {}
 			}
@@ -559,7 +448,7 @@ async function runLookup(command, deps = {}) {
 			}
 			if (current == null) {
 				spinner.fail(`Failed to fetch object: ${colors.red(url)}.`);
-				if (authLoader == null) printError(message$1`It may be a private object.  Try with ${optionNames(["-a", "--authorized-fetch"])}.`);
+				if (authLoader == null) printError(message`It may be a private object.  Try with ${optionNames(["-a", "--authorized-fetch"])}.`);
 				await finalizeAndExit(1);
 				return;
 			}
@@ -601,7 +490,7 @@ async function runLookup(command, deps = {}) {
 				else if (error instanceof RecursiveLookupError) {
 					spinner.fail(`Failed to recursively fetch object: ${colors.red(error.target)}.`);
 					if (!command.allowPrivateAddress && isPrivateAddressTarget(error.target)) printRecursivePrivateAddressHint();
-					else if (authLoader == null) printError(message$1`It may be a private object.  Try with ${optionNames(["-a", "--authorized-fetch"])}.`);
+					else if (authLoader == null) printError(message`It may be a private object.  Try with ${optionNames(["-a", "--authorized-fetch"])}.`);
 				} else {
 					spinner.fail("Failed to recursively fetch object.");
 					const privateContextUrl = getPrivateContextUrl(error);
@@ -611,7 +500,7 @@ async function runLookup(command, deps = {}) {
 						return;
 					}
 					const hint = getLookupFailureHint(error, { recursive: true });
-					if (shouldSuggestSuppressErrorsForLookupFailure(authLoader, hint)) printError(message$1`Use the ${optionNames(["-S", "--suppress-errors"])} option to suppress partial errors.`);
+					if (shouldSuggestSuppressErrorsForLookupFailure(authLoader, hint)) printError(message`Use the ${optionNames(["-S", "--suppress-errors"])} option to suppress partial errors.`);
 					else printLookupFailureHint(authLoader, error, { recursive: true });
 				}
 				await finalizeAndExit(1);
@@ -685,7 +574,7 @@ async function runLookup(command, deps = {}) {
 			}
 			if (collection == null) {
 				spinner.fail(`Failed to fetch object: ${colors.red(url)}.`);
-				if (authLoader == null) printError(message$1`It may be a private object.  Try with ${optionNames(["-a", "--authorized-fetch"])}.`);
+				if (authLoader == null) printError(message`It may be a private object.  Try with ${optionNames(["-a", "--authorized-fetch"])}.`);
 				await finalizeAndExit(1);
 				return;
 			}
@@ -747,7 +636,7 @@ async function runLookup(command, deps = {}) {
 				else {
 					spinner.fail(`Failed to complete the traversal for: ${colors.red(url)}.`);
 					const hint = getLookupFailureHint(error);
-					if (shouldSuggestSuppressErrorsForLookupFailure(authLoader, hint)) printError(message$1`Use the ${optionNames(["-S", "--suppress-errors"])} option to suppress partial errors.`);
+					if (shouldSuggestSuppressErrorsForLookupFailure(authLoader, hint)) printError(message`Use the ${optionNames(["-S", "--suppress-errors"])} option to suppress partial errors.`);
 					else printLookupFailureHint(authLoader, error);
 				}
 				await finalizeAndExit(1);
@@ -782,7 +671,7 @@ async function runLookup(command, deps = {}) {
 		const url = command.urls[i];
 		if (obj == null) {
 			spinner.fail(`Failed to fetch ${colors.red(url)}`);
-			if (authLoader == null) printError(message$1`It may be a private object.  Try with ${optionNames(["-a", "--authorized-fetch"])}.`);
+			if (authLoader == null) printError(message`It may be a private object.  Try with ${optionNames(["-a", "--authorized-fetch"])}.`);
 			success = false;
 		} else {
 			spinner.succeed(`Fetched object: ${colors.green(url)}`);
@@ -818,4 +707,4 @@ async function runLookup(command, deps = {}) {
 	if (success && command.output) spinner.succeed(`Successfully wrote output to ${colors.green(command.output)}.`);
 }
 //#endregion
-export { lookupCommand, runLookup };
+export { runLookup };

package/dist/mod.js

@@ -1,28 +1,10 @@
 #!/usr/bin/env -S node --disable-warning=ExperimentalWarning
 import "@js-temporal/polyfill";
-import runGenerateVocab from "./generate-vocab/action.js";
-import "./generate-vocab/mod.js";
-import { runInbox } from "./inbox.js";
-import { runInit } from "./init/mod.js";
-import { runNodeInfo } from "./nodeinfo.js";
-import { runLookup } from "./lookup.js";
-import { runRelay } from "./relay.js";
-import { runTunnel } from "./tunnel.js";
-import runWebFinger from "./webfinger/action.js";
-import "./webfinger/mod.js";
-import { runCli } from "./runner.js";
+import { parseCliProgram } from "./runner.js";
 import process from "node:process";
 //#region src/mod.ts
 async function main() {
-	const result = await runCli(process.argv.slice(2));
-	if (result.command === "init") await runInit(result);
-	else if (result.command === "lookup") await runLookup(result);
-	else if (result.command === "webfinger") await runWebFinger(result);
-	else if (result.command === "inbox") await runInbox(result);
-	else if (result.command === "nodeinfo") await runNodeInfo(result);
-	else if (result.command === "tunnel") await runTunnel(result);
-	else if (result.command === "generate-vocab") await runGenerateVocab(result);
-	else if (result.command === "relay") await runRelay(result);
+	await (await parseCliProgram(process.argv.slice(2))).run();
 }
 await main();
 //#endregion

package/dist/nodeinfo.js

@@ -1,20 +1,22 @@
 import "@js-temporal/polyfill";
-import { colors, formatObject } from "./utils.js";
 import { configContext } from "./config.js";
 import { userAgentOption } from "./options.js";
-import { print, printError } from "@optique/run";
+import { colors, formatObject } from "./utils.js";
 import process from "node:process";
 import { argument, command, constant, flag, group, merge, message, object, string, text } from "@optique/core";
-import { getNodeInfo } from "@fedify/fedify";
-import { getLogger } from "@logtape/logtape";
-import ora from "ora";
-import { getUserAgent } from "@fedify/vocab-runtime";
-import { bindConfig } from "@optique/config";
+import { print, printError } from "@optique/run";
 import os from "node:os";
+import { bindConfig } from "@optique/config";
+import { getUserAgent } from "@fedify/vocab-runtime";
+import { getNodeInfo } from "@fedify/fedify";
 import { createJimp } from "@jimp/core";
 import webp from "@jimp/wasm-webp";
+import { getLogger } from "@logtape/logtape";
 import { isICO, parseICO } from "icojs";
 import { defaultFormats, defaultPlugins, intToRGBA } from "jimp";
+import { Buffer } from "node:buffer";
+import ora from "ora";
+import { PNG } from "pngjs";
 //#region src/nodeinfo.ts
 const logger = getLogger([
 	"fedify",
@@ -25,6 +27,43 @@ const Jimp = createJimp({
 	formats: [...defaultFormats, webp],
 	plugins: defaultPlugins
 });
+const PNG_SIGNATURE = [
+	137,
+	80,
+	78,
+	71,
+	13,
+	10,
+	26,
+	10
+];
+function toUint8Array(buffer) {
+	return buffer instanceof Uint8Array ? buffer : new Uint8Array(buffer);
+}
+function toNodeBuffer(buffer) {
+	return Buffer.from(toUint8Array(buffer));
+}
+function isPng(buffer) {
+	const bytes = toUint8Array(buffer);
+	return PNG_SIGNATURE.every((byte, index) => bytes[index] === byte);
+}
+async function decodePng(buffer) {
+	return await new Promise((resolve, reject) => {
+		new PNG().parse(toNodeBuffer(buffer), (error, png) => {
+			if (error != null) reject(error);
+			else resolve(png);
+		});
+	});
+}
+async function readImage(buffer) {
+	if (!isPng(buffer)) return await Jimp.read(toNodeBuffer(buffer));
+	const png = await decodePng(buffer);
+	return new Jimp({
+		width: png.width,
+		height: png.height,
+		data: png.data
+	});
+}
 const nodeInfoOption = merge(object("Display options", {
 	raw: bindConfig(flag("-r", "--raw", { description: message`Show NodeInfo document in the raw JSON format` }), {
 		context: configContext,
@@ -46,15 +85,17 @@ const nodeInfoOption = merge(object("Display options", {
 	key: (config) => config.nodeinfo?.bestEffort ?? false,
 	default: false
 }) }));
-const nodeInfoCommand = command("nodeinfo", merge(object("Arguments", {
+const nodeInfoOptions = merge(object("Arguments", {
 	command: constant("nodeinfo"),
 	host: argument(string({ metavar: "HOST" }), { description: message`Bare hostname or a full URL of the instance` })
-}), nodeInfoOption, group("Network options", userAgentOption)), {
+}), nodeInfoOption, group("Network options", userAgentOption));
+const nodeInfoMetadata = {
 	brief: message`Get information about a remote node using the NodeInfo protocol`,
 	description: message`Get information about a remote node using the NodeInfo protocol.
 
 The argument is the hostname of the remote node, or the URL of the remote node.`
-});
+};
+command("nodeinfo", nodeInfoOptions, nodeInfoMetadata);
 async function runNodeInfo(command) {
 	const spinner = ora({
 		text: "Fetching a NodeInfo document...",
@@ -101,7 +142,7 @@ async function runNodeInfo(command) {
 					if (images.length < 1) throw new Error("No images found in the ICO file.");
 					buffer = images[0].buffer;
 				}
-				layout = getAsciiArt(await Jimp.read(buffer), DEFAULT_IMAGE_WIDTH, checkTerminalColorSupport(), colors).split("\n").map((line) => ` ${line}  `);
+				layout = getAsciiArt(await readImage(buffer), DEFAULT_IMAGE_WIDTH, checkTerminalColorSupport(), colors).split("\n").map((line) => ` ${line}  `);
 				defaultWidth = 41;
 			} else {
 				logger.error("Failed to fetch the favicon: {status} {statusText}", {
@@ -270,4 +311,4 @@ function getAsciiArt(image, width = DEFAULT_IMAGE_WIDTH, colorSupport, colors) {
 	return art;
 }
 //#endregion
-export { Jimp, nodeInfoCommand, runNodeInfo };
+export { Jimp, nodeInfoMetadata, nodeInfoOptions, runNodeInfo };

package/dist/options.js

@@ -1,8 +1,8 @@
 import "@js-temporal/polyfill";
 import { configContext } from "./config.js";
 import { choice, constant, flag, map, merge, message, object, option, optional, or, string, withDefault } from "@optique/core";
-import { getUserAgent } from "@fedify/vocab-runtime";
 import { bindConfig } from "@optique/config";
+import { getUserAgent } from "@fedify/vocab-runtime";
 //#region src/options.ts
 /**
 * Available tunneling services for exposing local servers to the public internet.

package/dist/relay/command.js

@@ -5,7 +5,7 @@ import { command, constant, group, integer, merge, message, multiple, object, op
 import { bindConfig } from "@optique/config";
 import { choice as choice$1 } from "@optique/core/valueparser";
 //#region src/relay/command.ts
-const relayCommand = command("relay", merge(object("Relay options", {
+const relayOptions = merge(object("Relay options", {
 	command: constant("relay"),
 	protocol: bindConfig(option("-p", "--protocol", choice$1(["mastodon", "litepub"], { metavar: "TYPE" }), { description: message`The relay protocol to use. ${value("mastodon")} for Mastodon-compatible relay, ${value("litepub")} for LitePub-compatible relay.` }), {
 		context: configContext,
@@ -40,11 +40,13 @@ const relayCommand = command("relay", merge(object("Relay options", {
 		key: (config) => config.relay?.rejectFollow ?? [],
 		default: []
 	})
-}), group("Tunnel options", createTunnelOption("relay"))), {
+}), group("Tunnel options", createTunnelOption("relay")));
+const relayMetadata = {
 	brief: message`Run an ephemeral ActivityPub relay server.`,
 	description: message`Spins up an ActivityPub relay server that forwards activities between federated instances. The server can use either Mastodon or LitePub compatible relay protocol.
 
 By default, the server is tunneled to the public internet for external access. Use ${optionName("--no-tunnel")} to run locally only.`
-});
+};
+command("relay", relayOptions, relayMetadata);
 //#endregion
-export { relayCommand };
+export { relayMetadata, relayOptions };

package/dist/relay.js

@@ -1,16 +1,16 @@
 import "@js-temporal/polyfill";
+import { colors, matchesActor } from "./utils.js";
 import { configureLogging } from "./log.js";
 import { tableStyle } from "./table.js";
 import { spawnTemporaryServer } from "./tempserver.js";
-import { colors, matchesActor } from "./utils.js";
 import process from "node:process";
 import { MemoryKvStore } from "@fedify/fedify";
 import { getLogger } from "@logtape/logtape";
-import Table from "cli-table3";
 import ora from "ora";
-import { createRelay } from "@fedify/relay";
 import { SqliteKvStore } from "@fedify/sqlite";
 import { DatabaseSync } from "node:sqlite";
+import Table from "cli-table3";
+import { createRelay } from "@fedify/relay";
 //#region src/relay.ts
 const logger = getLogger([
 	"fedify",

package/dist/runner.js

@@ -1,25 +1,17 @@
 import "@js-temporal/polyfill";
-import generateVocabCommand from "./generate-vocab/command.js";
-import "./generate-vocab/mod.js";
-import { version } from "./deno.js";
-import { initCommand } from "./init/mod.js";
 import { configContext, tryLoadToml } from "./config.js";
 import { globalOptions } from "./options.js";
-import { nodeInfoCommand } from "./nodeinfo.js";
-import { lookupCommand } from "./lookup.js";
-import { inboxCommand } from "./inbox/command.js";
-import { relayCommand } from "./relay/command.js";
-import { tunnelCommand } from "./tunnel.js";
-import { webFingerCommand } from "./webfinger/command.js";
-import "./webfinger/mod.js";
-import { printError, run } from "@optique/run";
+import { describeError } from "./utils.js";
+import { activityPubCommands, generatingCommands, networkCommands } from "./commands.js";
+import { version } from "./deno.js";
 import process from "node:process";
-import { group, merge, message, or } from "@optique/core";
-import { join } from "node:path";
+import { command, group, map, merge, message, or } from "@optique/core";
+import { printError, run } from "@optique/run";
 import { merge as merge$1 } from "es-toolkit";
 import { readFileSync } from "node:fs";
-import { parse } from "smol-toml";
 import { homedir } from "node:os";
+import { join } from "node:path";
+import { parse } from "smol-toml";
 //#region src/runner.ts
 /**
 * Returns the system-wide configuration file paths.
@@ -39,36 +31,35 @@ function getUserConfigPath() {
 	if (process.platform === "win32") return join(process.env.APPDATA || join(homedir(), "AppData", "Roaming"), "fedify", "config.toml");
 	return join(process.env.XDG_CONFIG_HOME || join(homedir(), ".config"), "fedify", "config.toml");
 }
-const command$1 = merge(or(group("Generating code", or(initCommand, generateVocabCommand)), group("ActivityPub tools", or(webFingerCommand, lookupCommand, inboxCommand, nodeInfoCommand, relayCommand)), group("Network tools", tunnelCommand)), globalOptions);
-function loadConfig(parsed) {
-	if (parsed.ignoreConfig) return void 0;
-	const system = getSystemConfigPaths().map(tryLoadToml).reduce((acc, config) => merge$1(acc, config), {});
-	const user = tryLoadToml(getUserConfigPath());
-	const project = tryLoadToml(join(process.cwd(), ".fedify.toml"));
-	let custom = {};
-	if (parsed.configPath) try {
-		custom = parse(readFileSync(parsed.configPath, "utf-8"));
-	} catch (error) {
-		printError(message`Could not load config file at ${parsed.configPath}: ${error instanceof Error ? error.message : String(error)}`);
-		process.exit(1);
+const selectedCommand = "__fedifyCliSelectedCommand";
+const selectedRun = "__fedifyCliRunCommand";
+function staticCommandParser(staticCommand) {
+	if (staticCommand.path.length < 1) throw new TypeError("Static command path must not be empty.");
+	let parser = staticCommand.parser;
+	for (let i = staticCommand.path.length - 1; i >= 0; i--) {
+		const name = staticCommand.path[i];
+		if (name == null) throw new TypeError("Static command path contains an empty segment.");
+		parser = command(name, parser, i === staticCommand.path.length - 1 ? staticCommand.metadata : void 0);
 	}
-	return {
-		config: [
-			system,
-			user,
-			project,
-			custom
-		].reduce((acc, config) => merge$1(acc, config), {}),
-		meta: void 0
-	};
+	const runCommand = staticCommand.run;
+	return map(parser, (value) => ({
+		...value,
+		[selectedCommand]: staticCommand,
+		[selectedRun]: (globalOptions) => runCommand({
+			...value,
+			...globalOptions
+		})
+	}));
 }
-/**
-* Runs the Fedify CLI with the given command-line arguments.
-* @param args Command-line arguments, usually `process.argv.slice(2)`.
-* @returns The parsed command result from Optique's runner.
-*/
-function runCli(args) {
-	return run(command$1, {
+function staticCommandsParser(commands) {
+	const parsers = commands.map(staticCommandParser);
+	if (parsers.length < 1) throw new TypeError("Static command group must not be empty.");
+	return parsers.length === 1 ? parsers[0] : or(...parsers);
+}
+const runnableCommand = merge(or(group("Generating code", staticCommandsParser(generatingCommands)), group("ActivityPub tools", staticCommandsParser(activityPubCommands)), group("Network tools", staticCommandsParser(networkCommands))), globalOptions);
+map(runnableCommand, ({ [selectedCommand]: _selectedCommand, [selectedRun]: _selectedRun, ...value }) => value);
+function getRunOptions(args) {
+	return {
 		contexts: [configContext],
 		contextOptions: { load: loadConfig },
 		programName: "fedify",
@@ -90,7 +81,41 @@ function runCli(args) {
 		maxWidth: process.stdout.columns,
 		showDefault: true,
 		showChoices: true
-	});
+	};
+}
+function loadConfig(parsed) {
+	if (parsed.ignoreConfig) return void 0;
+	const system = getSystemConfigPaths().map(tryLoadToml).reduce((acc, config) => merge$1(acc, config), {});
+	const user = tryLoadToml(getUserConfigPath());
+	const project = tryLoadToml(join(process.cwd(), ".fedify.toml"));
+	let custom = {};
+	if (parsed.configPath) try {
+		custom = parse(readFileSync(parsed.configPath, "utf-8"));
+	} catch (error) {
+		printError(message`Could not load config file at ${parsed.configPath}: ${describeError(error)}`);
+		process.exit(1);
+	}
+	return {
+		config: [
+			system,
+			user,
+			project,
+			custom
+		].reduce((acc, config) => merge$1(acc, config), {}),
+		meta: void 0
+	};
+}
+function toCliProgram(parsed) {
+	const { [selectedCommand]: command, [selectedRun]: runCommand, ...value } = parsed;
+	const publicValue = value;
+	return {
+		command,
+		value: publicValue,
+		run: () => runCommand(publicValue)
+	};
+}
+async function parseCliProgram(args) {
+	return toCliProgram(await run(runnableCommand, getRunOptions(args)));
 }
 //#endregion
-export { runCli };
+export { parseCliProgram };