@fedify/cli 2.0.0-pr.479.1922 → 2.0.1

package/dist/log.js

@@ -47,6 +47,40 @@ await configure({
 	contextLocalStorage: new AsyncLocalStorage(),
 	reset: true
 });
+async function configureLogging() {
+	const logFile$1 = process.env["FEDIFY_LOG_FILE"];
+	await configure({
+		sinks: {
+			console: getConsoleSink(),
+			recording: recordingSink,
+			file: logFile$1 == null ? () => void 0 : getFileSink(logFile$1)
+		},
+		filters: {},
+		loggers: [
+			{
+				category: "fedify",
+				lowestLevel: "debug",
+				sinks: [
+					"console",
+					"recording",
+					"file"
+				]
+			},
+			{
+				category: "localtunnel",
+				lowestLevel: "debug",
+				sinks: ["console", "file"]
+			},
+			{
+				category: ["logtape", "meta"],
+				lowestLevel: "warning",
+				sinks: ["console", "file"]
+			}
+		],
+		reset: true,
+		contextLocalStorage: new AsyncLocalStorage()
+	});
+}
 
 //#endregion
-export { recordingSink };
+export { configureLogging, recordingSink };

package/dist/lookup.js

@@ -1,18 +1,22 @@
 
       import { Temporal } from "@js-temporal/polyfill";
     
+import { configContext } from "./config.js";
 import { getContextLoader, getDocumentLoader } from "./docloader.js";
-import { configureLogging, debugOption } from "./globals.js";
+import { configureLogging } from "./log.js";
+import { createTunnelServiceOption, userAgentOption } from "./options.js";
 import { spawnTemporaryServer } from "./tempserver.js";
 import { colorEnabled, colors, formatObject } from "./utils.js";
 import { renderImages } from "./imagerenderer.js";
+import process from "node:process";
 import { argument, choice, command, constant, flag, float, map, merge, message, multiple, object, option, optionNames, optional, or, string, withDefault } from "@optique/core";
 import { path, print, printError } from "@optique/run";
-import process from "node:process";
-import { Application, Collection, CryptographicKey, Object as Object$1, generateCryptoKeyPair, getAuthenticatedDocumentLoader, lookupObject, respondWithObject, traverseCollection } from "@fedify/fedify";
+import { createWriteStream } from "node:fs";
+import { bindConfig } from "@optique/config";
+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 { createWriteStream } from "node:fs";
 
 //#region src/lookup.ts
 const logger = getLogger([
@@ -20,28 +24,56 @@ const logger = getLogger([
 	"cli",
 	"lookup"
 ]);
-const authorizedFetchOption = withDefault(object({
-	authorizedFetch: flag("-a", "--authorized-fetch", { description: message`Sign the request with an one-time key.` }),
-	firstKnock: withDefault(option("--first-knock", choice(["draft-cavage-http-signatures-12", "rfc9421"]), { description: message`The first-knock spec for ${optionNames(["-a", "--authorized-fetch"])}. It is used for the double-knocking technique.` }), "draft-cavage-http-signatures-12")
-}), { authorizedFetch: false });
-const traverseOption = withDefault(object({
-	traverse: flag("-t", "--traverse", { description: message`Traverse the given collection(s) to fetch all items.` }),
-	suppressErrors: option("-S", "--suppress-errors", { description: message`Suppress partial errors while traversing the collection.` })
-}), { traverse: false });
-const lookupCommand = command("lookup", merge("Looking up options", object({ command: constant("lookup") }), traverseOption, authorizedFetchOption, debugOption, object({
-	urls: multiple(argument(string({ metavar: "URL_OR_HANDLE" }), { description: message`One or more URLs or handles to look up.` }), { min: 1 }),
-	format: withDefault(or(map(option("-r", "--raw", { description: message`Print the fetched JSON-LD document as is.` }), () => "raw"), map(option("-C", "--compact", { description: message`Compact the fetched JSON-LD document.` }), () => "compact"), map(option("-e", "--expand", { description: message`Expand the fetched JSON-LD document.` }), () => "expand")), "default"),
-	userAgent: optional(option("-u", "--user-agent", string({ metavar: "USER_AGENT" }), { description: message`The custom User-Agent header value.` })),
-	separator: withDefault(option("-s", "--separator", string({ metavar: "SEPARATOR" }), { description: message`Specify the separator between adjacent output objects or collection items.` }), "----"),
+const authorizedFetchOption = withDefault(object("Authorized fetch options", {
+	authorizedFetch: bindConfig(map(flag("-a", "--authorized-fetch", { description: message`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`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: createTunnelServiceOption()
+}), {
+	authorizedFetch: false,
+	firstKnock: void 0,
+	tunnelService: void 0
+});
+const traverseOption = object("Traverse options", {
+	traverse: bindConfig(flag("-t", "--traverse", { description: message`Traverse the given collection(s) to fetch all items.` }), {
+		context: configContext,
+		key: (config) => config.lookup?.traverse ?? false,
+		default: false
+	}),
+	suppressErrors: bindConfig(flag("-S", "--suppress-errors", { description: message`Suppress partial errors while traversing the collection.` }), {
+		context: configContext,
+		key: (config) => config.lookup?.suppressErrors ?? false,
+		default: false
+	})
+});
+const lookupCommand = command("lookup", merge(object({ command: constant("lookup") }), traverseOption, authorizedFetchOption, merge("Network options", userAgentOption, object({ timeout: optional(bindConfig(option("-T", "--timeout", float({
+	min: 0,
+	metavar: "SECONDS"
+}), { description: message`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`One or more URLs or handles to look up.` }), { min: 1 }) }), object("Output options", {
+	format: bindConfig(optional(or(map(flag("-r", "--raw", { description: message`Print the fetched JSON-LD document as is.` }), () => "raw"), map(flag("-C", "--compact", { description: message`Compact the fetched JSON-LD document.` }), () => "compact"), map(flag("-e", "--expand", { description: message`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`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`Specify the output file path.` })),
-	timeout: optional(option("-T", "--timeout", float({
-		min: 0,
-		metavar: "SECONDS"
-	}), { description: message`Set timeout for network requests in seconds.` }))
+	}), { description: message`Specify the output file path.` }))
 })), {
 	brief: message`Look up Activity Streams objects.`,
 	description: message`Look up Activity Streams objects by URL or actor handle.
@@ -172,7 +204,7 @@ async function runLookup(command$1) {
 				inbox: new URL("/inbox", serverUrl),
 				outbox: new URL("/outbox", serverUrl)
 			}), { contextLoader });
-		});
+		}, { service: command$1.tunnelService });
 		const baseAuthLoader = getAuthenticatedDocumentLoader({
 			keyId: new URL("#main-key", server.url),
 			privateKey: key.privateKey

package/dist/mod.js

@@ -1,39 +1,116 @@
-#!/usr/bin/env node
+#!/usr/bin/env -S node --disable-warning=ExperimentalWarning
 
       import { Temporal } from "@js-temporal/polyfill";
     
+import { configContext, tryLoadToml } from "./config.js";
 import { runGenerateVocab } from "./generate-vocab/action.js";
 import command_default from "./generate-vocab/command.js";
 import "./generate-vocab/mod.js";
+import deno_default from "./deno.js";
+import { globalOptions } from "./options.js";
 import { inboxCommand, runInbox } from "./inbox.js";
-import action_default from "./init/action/mod.js";
-import { initCommand, testInitCommand } from "./init/command.js";
-import action_default$1 from "./init/test/action.js";
-import "./init/mod.js";
+import { initCommand, runInit } from "./init/mod.js";
 import { nodeInfoCommand, runNodeInfo } from "./nodeinfo.js";
 import { lookupCommand, runLookup } from "./lookup.js";
+import { relayCommand, runRelay } from "./relay.js";
 import { runTunnel, tunnelCommand } from "./tunnel.js";
 import { runWebFinger } from "./webfinger/action.js";
 import { webFingerCommand } from "./webfinger/command.js";
 import "./webfinger/mod.js";
-import { or } from "@optique/core";
-import { run } from "@optique/run";
+import { join } from "node:path";
+import { homedir } from "node:os";
+import process from "node:process";
+import { runWithConfig } from "@optique/config/run";
+import { group, merge, message, or } from "@optique/core";
+import { printError } from "@optique/run";
+import { merge as merge$1 } from "es-toolkit";
+import { readFileSync } from "node:fs";
+import { parse } from "smol-toml";
 
 //#region src/mod.ts
-const command$1 = or(initCommand, webFingerCommand, lookupCommand, inboxCommand, nodeInfoCommand, tunnelCommand, command_default, testInitCommand);
+/**
+* Returns the system-wide configuration file paths.
+* - Linux/macOS: Searches `$XDG_CONFIG_DIRS` (default: /etc/xdg)
+* - Windows: Uses `%ProgramData%` (default: C:\ProgramData)
+*/
+function getSystemConfigPaths() {
+	if (process.platform === "win32") {
+		const programData = process.env.ProgramData || "C:\\ProgramData";
+		return [join(programData, "fedify", "config.toml")];
+	}
+	return (process.env.XDG_CONFIG_DIRS || "/etc/xdg").split(":").map((dir) => join(dir, "fedify", "config.toml"));
+}
+/**
+* Returns the user-level configuration file path.
+* - Linux/macOS: `$XDG_CONFIG_HOME/fedify/config.toml` (default: ~/.config)
+* - Windows: `%APPDATA%\fedify\config.toml`
+*/
+function getUserConfigPath() {
+	if (process.platform === "win32") {
+		const appData = process.env.APPDATA || join(homedir(), "AppData", "Roaming");
+		return join(appData, "fedify", "config.toml");
+	}
+	const xdgConfigHome = process.env.XDG_CONFIG_HOME || join(homedir(), ".config");
+	return join(xdgConfigHome, "fedify", "config.toml");
+}
+const command$1 = merge(or(group("Generating code", or(initCommand, command_default)), group("ActivityPub tools", or(webFingerCommand, lookupCommand, inboxCommand, nodeInfoCommand, relayCommand)), group("Network tools", tunnelCommand)), globalOptions);
 async function main() {
-	const result = run(command$1, {
+	const result = await runWithConfig(command$1, configContext, {
 		programName: "fedify",
-		help: "both"
+		load: (parsed) => {
+			if (parsed.ignoreConfig) return {};
+			const systemConfigs = getSystemConfigPaths().map(tryLoadToml);
+			const system = systemConfigs.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);
+			}
+			return [
+				system,
+				user,
+				project,
+				custom
+			].reduce((acc, config) => merge$1(acc, config), {});
+		},
+		args: process.argv.slice(2),
+		help: {
+			mode: "both",
+			onShow: () => process.exit(0),
+			group: "Meta commands"
+		},
+		version: {
+			mode: "both",
+			value: deno_default.version,
+			group: "Meta commands"
+		},
+		completion: {
+			mode: "command",
+			name: "both",
+			helpVisibility: "plural",
+			group: "Meta commands"
+		},
+		onError: () => process.exit(1),
+		colors: process.stdout.isTTY && (process.env.NO_COLOR == null || process.env.NO_COLOR === ""),
+		maxWidth: process.stdout.columns,
+		showDefault: true,
+		showChoices: true
 	});
-	if (result.command === "init") await action_default(result);
-	if (result.command === "lookup") await runLookup(result);
-	if (result.command === "webfinger") await runWebFinger(result);
-	if (result.command === "inbox") runInbox(result);
-	if (result.command === "nodeinfo") runNodeInfo(result);
-	if (result.command === "tunnel") await runTunnel(result);
-	if (result.command === "generate-vocab") await runGenerateVocab(result);
-	if (result.command === "test-init") await action_default$1(result);
+	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") runInbox(result);
+	else if (result.command === "nodeinfo") 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);
+	else {
+		const _exhaustiveCheck = result;
+	}
 }
 await main();
 

package/dist/nodeinfo.js

@@ -1,16 +1,18 @@
 
       import { Temporal } from "@js-temporal/polyfill";
     
-import { debugOption } from "./globals.js";
+import { configContext } from "./config.js";
+import { userAgentOption } from "./options.js";
 import { colors, formatObject } from "./utils.js";
-import { argument, command, constant, flag, merge, message, object, option, optional, or, string, text } from "@optique/core";
-import { print, printError } from "@optique/run";
+import os from "node:os";
 import process from "node:process";
+import { argument, command, constant, flag, group, merge, message, object, string, text } from "@optique/core";
+import { print, printError } from "@optique/run";
+import { bindConfig } from "@optique/config";
 import { getNodeInfo } from "@fedify/fedify";
 import { getLogger } from "@logtape/logtape";
 import ora from "ora";
 import { getUserAgent } from "@fedify/vocab-runtime";
-import os from "node:os";
 import { createJimp } from "@jimp/core";
 import webp from "@jimp/wasm-webp";
 import { isICO, parseICO } from "icojs";
@@ -26,16 +28,31 @@ const Jimp = createJimp({
 	formats: [...defaultFormats, webp],
 	plugins: defaultPlugins
 });
-const nodeInfoOption = optional(or(object({ raw: flag("-r", "--raw", { description: message`Show NodeInfo document in the raw JSON format` }) }), object({
-	bestEffort: optional(flag("-b", "--best-effort", { description: message`Parse the NodeInfo document with best effort.  If the NodeInfo document is not well-formed, the option will try to parse it as much as possible.` })),
-	noFavicon: optional(flag("--no-favicon", { description: message`Disable fetching the favicon of the instance` })),
-	metadata: optional(flag("-m", "--metadata", { description: message`Show the extra metadata of the NodeInfo, i.e., the metadata field of the document.` }))
-})));
-const userAgentOption = optional(object({ userAgent: option("-u", "--user-agent", string(), { description: message`The custom User-Agent header value.` }) }));
-const nodeInfoCommand = command("nodeinfo", merge(object({
+const nodeInfoOption = merge(object("Display options", {
+	raw: bindConfig(flag("-r", "--raw", { description: message`Show NodeInfo document in the raw JSON format` }), {
+		context: configContext,
+		key: (config) => config.nodeinfo?.raw ?? false,
+		default: false
+	}),
+	noFavicon: bindConfig(flag("--no-favicon", { description: message`Disable fetching the favicon of the instance` }), {
+		context: configContext,
+		key: (config) => config.nodeinfo?.showFavicon === false,
+		default: false
+	}),
+	metadata: bindConfig(flag("-m", "--metadata", { description: message`Show the extra metadata of the NodeInfo, i.e., the metadata field of the document.` }), {
+		context: configContext,
+		key: (config) => config.nodeinfo?.showMetadata ?? false,
+		default: false
+	})
+}), object("Parsing options", { bestEffort: bindConfig(flag("-b", "--best-effort", { description: message`Parse the NodeInfo document with best effort.  If the NodeInfo document is not well-formed, the option will try to parse it as much as possible.` }), {
+	context: configContext,
+	key: (config) => config.nodeinfo?.bestEffort ?? false,
+	default: false
+}) }));
+const nodeInfoCommand = command("nodeinfo", merge(object("Arguments", {
 	command: constant("nodeinfo"),
 	host: argument(string({ metavar: "HOST" }), { description: message`Bare hostname or a full URL of the instance` })
-}), debugOption, nodeInfoOption, userAgentOption), {
+}), nodeInfoOption, group("Network options", userAgentOption)), {
 	brief: message`Get information about a remote node using the NodeInfo protocol`,
 	description: message`Get information about a remote node using the NodeInfo protocol.
 
@@ -47,7 +64,7 @@ async function runNodeInfo(command$1) {
 		discardStdin: false
 	}).start();
 	const url = new URL(URL.canParse(command$1.host) ? command$1.host : `https://${command$1.host}`);
-	if ("raw" in command$1 && command$1.raw) {
+	if (command$1.raw) {
 		const nodeInfo$1 = await getNodeInfo(url, {
 			parse: "none",
 			userAgent: command$1.userAgent
@@ -62,19 +79,19 @@ async function runNodeInfo(command$1) {
 		return;
 	}
 	const nodeInfo = await getNodeInfo(url, {
-		parse: "bestEffort" in command$1 && command$1.bestEffort ? "best-effort" : "strict",
+		parse: command$1.bestEffort ? "best-effort" : "strict",
 		userAgent: command$1.userAgent
 	});
 	logger.debug("NodeInfo document: {nodeInfo}", { nodeInfo });
 	if (nodeInfo == void 0) {
 		spinner.fail("No NodeInfo document found or it is invalid.");
 		printError(message`No NodeInfo document found or it is invalid.`);
-		if (!("bestEffort" in command$1 && command$1.bestEffort)) printError(message`Use the -b/--best-effort option to try to parse the document anyway.`);
+		if (!command$1.bestEffort) printError(message`Use the -b/--best-effort option to try to parse the document anyway.`);
 		process.exit(1);
 	}
 	let layout;
 	let defaultWidth = 0;
-	if (!("noFavicon" in command$1 && command$1.noFavicon)) {
+	if (!command$1.noFavicon) {
 		spinner.text = "Fetching the favicon...";
 		try {
 			const faviconUrl = await getFaviconUrl(url, command$1.userAgent);
@@ -147,9 +164,9 @@ async function runNodeInfo(command$1) {
 		layout[next()] += colors.bold(colors.dim("Open registrations:"));
 		layout[next()] += "  " + (nodeInfo.openRegistrations ? "Yes" : "No");
 	}
-	if ("metadata" in command$1 && command$1.metadata && nodeInfo.metadata != null && Object.keys(nodeInfo.metadata).length > 0) {
+	if (command$1.metadata && nodeInfo.metadata != null && Object.keys(nodeInfo.metadata).length > 0) {
 		layout[next()] += colors.bold(colors.dim("Metadata:"));
-		for (const [key, value] of Object.entries(nodeInfo.metadata)) layout[next()] += `  ${colors.dim(key + ":")} ${indent(typeof value === "string" ? value : formatObject(value), defaultWidth + 4 + key.length)}`;
+		for (const [key, value$1] of Object.entries(nodeInfo.metadata)) layout[next()] += `  ${colors.dim(key + ":")} ${indent(typeof value$1 === "string" ? value$1 : formatObject(value$1), defaultWidth + 4 + key.length)}`;
 	}
 	console.log(layout.join("\n"));
 }
@@ -164,8 +181,8 @@ async function getFaviconUrl(url, userAgent) {
 	for (const match of text$1.matchAll(LINK_REGEXP)) {
 		const attrs = {};
 		for (const attrMatch of match[1].matchAll(LINK_ATTRS_REGEXP)) {
-			const [, key, value] = attrMatch;
-			attrs[key] = value.startsWith("\"") || value.startsWith("'") ? value.slice(1, -1) : value;
+			const [, key, value$1] = attrMatch;
+			attrs[key] = value$1.startsWith("\"") || value$1.startsWith("'") ? value$1.slice(1, -1) : value$1;
 		}
 		const rel = attrs.rel?.toLowerCase()?.trim()?.split(/\s+/) ?? [];
 		if (!rel.includes("icon") && !rel.includes("apple-touch-icon")) continue;
@@ -203,11 +220,11 @@ const CUBE_VALUES = [
 	215,
 	255
 ];
-const findClosestIndex = (value) => {
+const findClosestIndex = (value$1) => {
 	let minDiff = Infinity;
 	let closestIndex = 0;
 	for (let idx = 0; idx < CUBE_VALUES.length; idx++) {
-		const diff = Math.abs(value - CUBE_VALUES[idx]);
+		const diff = Math.abs(value$1 - CUBE_VALUES[idx]);
 		if (diff < minDiff) {
 			minDiff = diff;
 			closestIndex = idx;

package/dist/options.js

@@ -0,0 +1,84 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+    
+import { configContext } from "./config.js";
+import { choice, constant, flag, map, merge, message, object, option, or, string, withDefault } from "@optique/core";
+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.
+*/
+const TUNNEL_SERVICES = [
+	"localhost.run",
+	"serveo.net",
+	"pinggy.io"
+];
+/**
+* Creates a tunnel service option with customizable option names.
+*/
+function createTunnelServiceOption(optionNames$1 = ["--tunnel-service"]) {
+	return withDefault(bindConfig(option(...optionNames$1, choice(TUNNEL_SERVICES, { metavar: "SERVICE" }), { description: message`The tunneling service to use.
+By default, any of the supported tunneling services will be used
+(randomly selected for each tunnel).` }), {
+		context: configContext,
+		key: (config) => config.tunnelService
+	}), void 0);
+}
+/**
+* Creates a tunnel option that binds to a specific config section's noTunnel field.
+* Use this when tunneling can be disabled (e.g., in `inbox` and `relay`).
+*
+* @param section - The config section to read noTunnel from ("inbox" or "relay")
+* @returns An option object with `tunnel` (boolean) and `tunnelService` fields
+*/
+function createTunnelOption(section) {
+	return object({
+		tunnel: bindConfig(withDefault(map(flag("-T", "--no-tunnel", { description: message`Do not tunnel the server to the public Internet.` }), () => false), true), {
+			context: configContext,
+			key: (config) => !(config[section]?.noTunnel ?? false),
+			default: true
+		}),
+		tunnelService: createTunnelServiceOption()
+	});
+}
+const debugOption = object({ debug: bindConfig(option("-d", "--debug", { description: message`Enable debug mode.` }), {
+	context: configContext,
+	key: (config) => config.debug ?? false,
+	default: false
+}) });
+const userAgentOption = object({ userAgent: bindConfig(option("-u", "--user-agent", string({ metavar: "USER_AGENT" }), { description: message`The custom User-Agent header value.` }), {
+	context: configContext,
+	key: (config) => config.userAgent ?? getUserAgent(),
+	default: getUserAgent()
+}) });
+/**
+* Configuration file options.
+*
+* These options are mutually exclusive:
+* - `--config PATH` loads an additional config file on top of standard hierarchy
+* - `--ignore-config` skips all config files (useful for CI reproducibility)
+*
+* Returns either:
+* - `{ ignoreConfig: true }` when `--ignore-config` is specified
+* - `{ ignoreConfig: false, configPath: string }` when `--config` is specified
+* - `{ ignoreConfig: false }` when neither is specified (default)
+*/
+const configOption = withDefault(or(object({ ignoreConfig: map(flag("--ignore-config", { description: message`Ignore all configuration files.` }), () => true) }), object({
+	ignoreConfig: constant(false),
+	configPath: option("--config", string({ metavar: "PATH" }), { description: message`Load an additional configuration file.` })
+})), {
+	ignoreConfig: false,
+	configPath: void 0
+});
+/**
+* Global options that apply to all commands.
+*
+* Combines debug mode and configuration file options into a single
+* "Global options" group.
+*/
+const globalOptions = merge("Global options", debugOption, configOption);
+
+//#endregion
+export { createTunnelOption, createTunnelServiceOption, globalOptions, userAgentOption };

package/dist/relay.js

@@ -0,0 +1,136 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+    
+import { configContext } from "./config.js";
+import { configureLogging } from "./log.js";
+import { createTunnelOption } from "./options.js";
+import { tableStyle } from "./table.js";
+import { spawnTemporaryServer } from "./tempserver.js";
+import { colors, matchesActor } from "./utils.js";
+import { SqliteKvStore } from "@fedify/sqlite";
+import process from "node:process";
+import { DatabaseSync } from "node:sqlite";
+import { command, constant, group, integer, merge, message, multiple, object, option, optionName, optional, string, value } from "@optique/core";
+import { bindConfig } from "@optique/config";
+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 { choice as choice$1 } from "@optique/core/valueparser";
+
+//#region src/relay.ts
+const logger = getLogger([
+	"fedify",
+	"cli",
+	"relay"
+]);
+const relayCommand = command("relay", 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,
+		key: (config) => config.relay?.protocol ?? "mastodon",
+		default: "mastodon"
+	}),
+	persistent: optional(bindConfig(option("--persistent", string({ metavar: "PATH" }), { description: message`Path to SQLite database file for persistent storage. If not specified, uses in-memory storage which is lost when the server stops.` }), {
+		context: configContext,
+		key: (config) => config.relay?.persistent
+	})),
+	port: bindConfig(option("-P", "--port", integer({
+		min: 0,
+		max: 65535,
+		metavar: "PORT"
+	}), { description: message`The local port to listen on.` }), {
+		context: configContext,
+		key: (config) => config.relay?.port ?? 8e3,
+		default: 8e3
+	}),
+	name: bindConfig(option("-n", "--name", string({ metavar: "NAME" }), { description: message`The relay display name.` }), {
+		context: configContext,
+		key: (config) => config.relay?.name ?? "Fedify Relay",
+		default: "Fedify Relay"
+	}),
+	acceptFollow: bindConfig(multiple(option("-a", "--accept-follow", string({ metavar: "URI" }), { description: message`Accept follow requests from the given actor. The argument can be either an actor URI or a handle, or a wildcard (${"*"}). Can be specified multiple times. If a wildcard is specified, all follow requests will be accepted.` })), {
+		context: configContext,
+		key: (config) => config.relay?.acceptFollow ?? [],
+		default: []
+	}),
+	rejectFollow: bindConfig(multiple(option("-r", "--reject-follow", string({ metavar: "URI" }), { description: message`Reject follow requests from the given actor. The argument can be either an actor URI or a handle, or a wildcard (${"*"}). Can be specified multiple times. If a wildcard is specified, all follow requests will be rejected.` })), {
+		context: configContext,
+		key: (config) => config.relay?.rejectFollow ?? [],
+		default: []
+	})
+}), group("Tunnel options", createTunnelOption("relay"))), {
+	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.`
+});
+async function runRelay(command$1) {
+	if (command$1.debug) await configureLogging();
+	const spinner = ora({
+		text: "Starting relay server...",
+		discardStdin: false
+	}).start();
+	let kv;
+	if (command$1.persistent) {
+		logger.debug("Using SQLite storage at {path}.", { path: command$1.persistent });
+		const db = new DatabaseSync(command$1.persistent);
+		kv = new SqliteKvStore(db);
+	} else {
+		logger.debug("Using in-memory storage.");
+		kv = new MemoryKvStore();
+	}
+	let relay;
+	let server = null;
+	const acceptFollows = [];
+	const rejectFollows = [];
+	if (command$1.acceptFollow != null && command$1.acceptFollow.length > 0) acceptFollows.push(...command$1.acceptFollow ?? []);
+	if (command$1.rejectFollow != null && command$1.rejectFollow.length > 0) rejectFollows.push(...command$1.rejectFollow ?? []);
+	server = await spawnTemporaryServer(async (request) => {
+		return await relay.fetch(request);
+	}, {
+		noTunnel: !command$1.tunnel,
+		port: command$1.port,
+		...command$1.tunnel && { service: command$1.tunnelService }
+	});
+	relay = createRelay(command$1.protocol, {
+		origin: server?.url.origin,
+		name: command$1.name,
+		kv,
+		subscriptionHandler: async (_ctx, actor) => {
+			const isInAcceptList = await matchesActor(actor, acceptFollows);
+			const isInRejectList = await matchesActor(actor, rejectFollows);
+			return isInAcceptList && !isInRejectList;
+		}
+	});
+	spinner.succeed(`Relay server is running: ${colors.green(server.url.href)}`);
+	await printRelayInfo(relay, {
+		protocol: command$1.protocol,
+		name: command$1.name,
+		persistent: command$1.persistent
+	});
+	process.on("SIGINT", async () => {
+		spinner.start("Shutting down relay server...");
+		await server.close();
+		spinner.succeed("Relay server stopped.");
+		process.exit(0);
+	});
+}
+async function printRelayInfo(relay, options) {
+	const actorUri = await relay.getActorUri();
+	const sharedInboxUri = await relay.getSharedInboxUri();
+	const table = new Table({
+		chars: tableStyle,
+		style: {
+			head: [],
+			border: []
+		}
+	});
+	table.push({ "Actor URI:": colors.green(actorUri.href) }, { "Shared Inbox:": colors.green(sharedInboxUri.href) }, { "Protocol:": colors.green(options.protocol) }, { "Name:": colors.green(options.name) }, { "Storage:": colors.green(options.persistent ?? "in-memory") });
+	console.log(table.toString());
+	console.log("\nPress ^C to stop the relay server.");
+}
+
+//#endregion
+export { relayCommand, runRelay };