@fedify/cli 1.8.11 → 2.0.0-dev.1757

package/dist/lookup.js

@@ -0,0 +1,287 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+    
+import { getContextLoader, getDocumentLoader } from "./docloader.js";
+import { configureLogging, debugOption } from "./globals.js";
+import { spawnTemporaryServer } from "./tempserver.js";
+import { colorEnabled, colors, formatObject } from "./utils.js";
+import { renderImages } from "./imagerenderer.js";
+import { argument, choice, command, constant, flag, float, map, merge, message, multiple, object, option, optional, or, string, withDefault } from "@optique/core";
+import { path, print, printError } from "@optique/run";
+import { Application, Collection, CryptographicKey, Object as Object$1, generateCryptoKeyPair, getAuthenticatedDocumentLoader, lookupObject, respondWithObject, traverseCollection } from "@fedify/fedify";
+import { getLogger } from "@logtape/logtape";
+import process from "node:process";
+import ora from "ora";
+import { createWriteStream } from "node:fs";
+
+//#region src/lookup.ts
+const logger = getLogger([
+	"fedify",
+	"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 -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.` }), "----"),
+	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`Lookup an Activity Streams object by URL or the actor handle. The argument can be either a URL or an actor handle (e.g., @username@domain), and it can be multiple.` });
+var TimeoutError = class extends Error {
+	name = "TimeoutError";
+	constructor(message$1) {
+		super(message$1);
+		this.name = "TimeoutError";
+	}
+};
+async function findAllImages(obj) {
+	const result = [];
+	const icon = await obj.getIcon();
+	const image = await obj.getImage();
+	if (icon && icon.url instanceof URL) result.push(icon.url);
+	if (image && image.url instanceof URL) result.push(image.url);
+	return result;
+}
+async function writeObjectToStream(object$1, outputPath, format, contextLoader) {
+	const stream = outputPath ? createWriteStream(outputPath) : process.stdout;
+	let content;
+	let json = true;
+	let imageUrls = [];
+	if (format) if (format === "raw") content = await object$1.toJsonLd({ contextLoader });
+	else if (format === "compact") content = await object$1.toJsonLd({
+		format: "compact",
+		contextLoader
+	});
+	else if (format === "expand") content = await object$1.toJsonLd({
+		format: "expand",
+		contextLoader
+	});
+	else {
+		content = object$1;
+		json = false;
+	}
+	else {
+		content = object$1;
+		json = false;
+	}
+	const enableColors = colorEnabled && outputPath === void 0;
+	content = formatObject(content, enableColors, json);
+	const encoder = new TextEncoder();
+	const bytes = encoder.encode(content + "\n");
+	stream.write(bytes);
+	if (object$1 instanceof Object$1) imageUrls = await findAllImages(object$1);
+	if (!outputPath && imageUrls.length > 0) await renderImages(imageUrls);
+}
+const signalTimers = /* @__PURE__ */ new WeakMap();
+function createTimeoutSignal(timeoutSeconds) {
+	if (timeoutSeconds == null) return void 0;
+	const controller = new AbortController();
+	const timerId = setTimeout(() => {
+		controller.abort(new TimeoutError(`Request timed out after ${timeoutSeconds} seconds`));
+	}, timeoutSeconds * 1e3);
+	signalTimers.set(controller.signal, timerId);
+	return controller.signal;
+}
+function clearTimeoutSignal(signal) {
+	if (!signal) return;
+	const timerId = signalTimers.get(signal);
+	if (timerId !== void 0) {
+		clearTimeout(timerId);
+		signalTimers.delete(signal);
+	}
+}
+function wrapDocumentLoaderWithTimeout(loader, timeoutSeconds) {
+	if (timeoutSeconds == null) return loader;
+	return (url, options) => {
+		const signal = createTimeoutSignal(timeoutSeconds);
+		return loader(url, {
+			...options,
+			signal
+		}).finally(() => clearTimeoutSignal(signal));
+	};
+}
+function handleTimeoutError(spinner, timeoutSeconds, url) {
+	const urlText = url ? ` for: ${colors.red(url)}` : "";
+	spinner.fail(`Request timed out after ${timeoutSeconds} seconds${urlText}.`);
+	printError(message`Try increasing the timeout with -T/--timeout option or check network connectivity.`);
+}
+async function runLookup(command$1) {
+	if (command$1.urls.length < 1) {
+		printError(message`At least one URL or actor handle must be provided.`);
+		process.exit(1);
+	}
+	if (command$1.debug) await configureLogging();
+	const spinner = ora({
+		text: `Looking up the ${command$1.traverse ? "collection" : command$1.urls.length > 1 ? "objects" : "object"}...`,
+		discardStdin: false
+	}).start();
+	let server = void 0;
+	const baseDocumentLoader = await getDocumentLoader({ userAgent: command$1.userAgent });
+	const documentLoader = wrapDocumentLoaderWithTimeout(baseDocumentLoader, command$1.timeout);
+	const baseContextLoader = await getContextLoader({ userAgent: command$1.userAgent });
+	const contextLoader = wrapDocumentLoaderWithTimeout(baseContextLoader, command$1.timeout);
+	let authLoader = void 0;
+	if (command$1.authorizedFetch) {
+		spinner.text = "Generating a one-time key pair...";
+		const key = await generateCryptoKeyPair();
+		spinner.text = "Spinning up a temporary ActivityPub server...";
+		server = await spawnTemporaryServer((req) => {
+			const serverUrl = server?.url ?? new URL("http://localhost/");
+			if (new URL(req.url).pathname == "/.well-known/webfinger") {
+				const jrd = {
+					subject: `acct:${serverUrl.hostname}@${serverUrl.hostname}`,
+					aliases: [serverUrl.href],
+					links: [{
+						rel: "self",
+						href: serverUrl.href,
+						type: "application/activity+json"
+					}]
+				};
+				return new Response(JSON.stringify(jrd), { headers: { "Content-Type": "application/jrd+json" } });
+			}
+			return respondWithObject(new Application({
+				id: serverUrl,
+				preferredUsername: serverUrl?.hostname,
+				publicKey: new CryptographicKey({
+					id: new URL("#main-key", serverUrl),
+					owner: serverUrl,
+					publicKey: key.publicKey
+				}),
+				manuallyApprovesFollowers: true,
+				inbox: new URL("/inbox", serverUrl),
+				outbox: new URL("/outbox", serverUrl)
+			}), { contextLoader });
+		});
+		const baseAuthLoader = getAuthenticatedDocumentLoader({
+			keyId: new URL("#main-key", server.url),
+			privateKey: key.privateKey
+		}, { specDeterminer: {
+			determineSpec() {
+				return command$1.firstKnock;
+			},
+			rememberSpec() {}
+		} });
+		authLoader = wrapDocumentLoaderWithTimeout(baseAuthLoader, command$1.timeout);
+	}
+	spinner.text = `Looking up the ${command$1.traverse ? "collection" : command$1.urls.length > 1 ? "objects" : "object"}...`;
+	if (command$1.traverse) {
+		let totalItems = 0;
+		for (let urlIndex = 0; urlIndex < command$1.urls.length; urlIndex++) {
+			const url = command$1.urls[urlIndex];
+			if (urlIndex > 0) spinner.text = `Looking up collection ${urlIndex + 1}/${command$1.urls.length}...`;
+			let collection;
+			try {
+				collection = await lookupObject(url, {
+					documentLoader: authLoader ?? documentLoader,
+					contextLoader,
+					userAgent: command$1.userAgent
+				});
+			} catch (error) {
+				if (error instanceof TimeoutError) handleTimeoutError(spinner, command$1.timeout, url);
+				else {
+					spinner.fail(`Failed to fetch object: ${colors.red(url)}.`);
+					if (authLoader == null) printError(message`It may be a private object.  Try with -a/--authorized-fetch.`);
+				}
+				await server?.close();
+				process.exit(1);
+			}
+			if (collection == null) {
+				spinner.fail(`Failed to fetch object: ${colors.red(url)}.`);
+				if (authLoader == null) printError(message`It may be a private object.  Try with -a/--authorized-fetch.`);
+				await server?.close();
+				process.exit(1);
+			}
+			if (!(collection instanceof Collection)) {
+				spinner.fail(`Not a collection: ${colors.red(url)}.  The -t/--traverse option requires a collection.`);
+				await server?.close();
+				process.exit(1);
+			}
+			spinner.succeed(`Fetched collection: ${colors.green(url)}.`);
+			try {
+				let collectionItems = 0;
+				for await (const item of traverseCollection(collection, {
+					documentLoader: authLoader ?? documentLoader,
+					contextLoader,
+					suppressError: command$1.suppressErrors
+				})) {
+					if (!command$1.output && (totalItems > 0 || collectionItems > 0)) print(message`${command$1.separator}`);
+					await writeObjectToStream(item, command$1.output, command$1.format, contextLoader);
+					collectionItems++;
+					totalItems++;
+				}
+			} catch (error) {
+				logger.error("Failed to complete the traversal for {url}: {error}", {
+					url,
+					error
+				});
+				if (error instanceof TimeoutError) handleTimeoutError(spinner, command$1.timeout, url);
+				else {
+					spinner.fail(`Failed to complete the traversal for: ${colors.red(url)}.`);
+					if (authLoader == null) printError(message`It may be a private object.  Try with -a/--authorized-fetch.`);
+					else printError(message`Use the -S/--suppress-errors option to suppress partial errors.`);
+				}
+				await server?.close();
+				process.exit(1);
+			}
+		}
+		spinner.succeed("Successfully fetched all items in the collection.");
+		await server?.close();
+		process.exit(0);
+	}
+	const promises = [];
+	for (const url of command$1.urls) promises.push(lookupObject(url, {
+		documentLoader: authLoader ?? documentLoader,
+		contextLoader,
+		userAgent: command$1.userAgent
+	}).catch((error) => {
+		if (error instanceof TimeoutError) handleTimeoutError(spinner, command$1.timeout, url);
+		throw error;
+	}));
+	let objects;
+	try {
+		objects = await Promise.all(promises);
+	} catch (_error) {
+		await server?.close();
+		process.exit(1);
+	}
+	spinner.stop();
+	let success = true;
+	let i = 0;
+	for (const obj of objects) {
+		const url = command$1.urls[i];
+		if (i > 0) print(message`${command$1.separator}`);
+		i++;
+		if (obj == null) {
+			spinner.fail(`Failed to fetch ${colors.red(url)}`);
+			if (authLoader == null) printError(message`It may be a private object.  Try with -a/--authorized-fetch.`);
+			success = false;
+		} else {
+			spinner.succeed(`Fetched object: ${colors.green(url)}`);
+			await writeObjectToStream(obj, command$1.output, command$1.format, contextLoader);
+			if (i < command$1.urls.length - 1) print(message`${command$1.separator}`);
+		}
+	}
+	if (success) spinner.succeed(command$1.urls.length > 1 ? "Successfully fetched all objects." : "Successfully fetched the object.");
+	await server?.close();
+	if (!success) process.exit(1);
+	if (success && command$1.output) spinner.succeed(`Successfully wrote output to ${colors.green(command$1.output)}.`);
+}
+
+//#endregion
+export { lookupCommand, runLookup };

package/dist/mod.js

@@ -0,0 +1,34 @@
+#!/usr/bin/env node
+
+      import { Temporal } from "@js-temporal/polyfill";
+    
+import { inboxCommand, runInbox } from "./inbox.js";
+import { nodeInfoCommand, runNodeInfo } from "./nodeinfo.js";
+import { lookupCommand, runLookup } from "./lookup.js";
+import action_default from "./init/action/mod.js";
+import { initCommand } from "./init/command.js";
+import "./init/mod.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";
+
+//#region src/mod.ts
+const command$1 = or(initCommand, webFingerCommand, lookupCommand, inboxCommand, nodeInfoCommand, tunnelCommand);
+async function main() {
+	const result = run(command$1, {
+		programName: "fedify",
+		help: "both"
+	});
+	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") runTunnel(result);
+}
+await main();
+
+//#endregion

package/dist/nodeinfo.js

@@ -0,0 +1,261 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+    
+import { debugOption } from "./globals.js";
+import { colors, formatObject } from "./utils.js";
+import { argument, command, constant, flag, merge, message, object, option, optional, or, string } from "@optique/core";
+import { print, printError } from "@optique/run";
+import { getNodeInfo } from "@fedify/fedify";
+import { getLogger } from "@logtape/logtape";
+import process from "node:process";
+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";
+import { defaultFormats, defaultPlugins, intToRGBA } from "jimp";
+
+//#region src/nodeinfo.ts
+const logger = getLogger([
+	"fedify",
+	"cli",
+	"nodeinfo"
+]);
+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()) }));
+const nodeInfoCommand = command("nodeinfo", merge(object({
+	command: constant("nodeinfo"),
+	host: argument(string({ metavar: "hostname or URL" }), { description: message`Bare hostname or a full URL of the instance` })
+}), debugOption, nodeInfoOption, userAgentOption), { 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.` });
+async function runNodeInfo(command$1) {
+	const spinner = ora({
+		text: "Fetching a NodeInfo document...",
+		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) {
+		const nodeInfo$1 = await getNodeInfo(url, {
+			parse: "none",
+			userAgent: command$1.userAgent
+		});
+		if (nodeInfo$1 === void 0) {
+			spinner.fail("No NodeInfo document found.");
+			printError(message`No NodeInfo document found.`);
+			process.exit(1);
+		}
+		spinner.succeed("NodeInfo document fetched.");
+		console.log(formatObject(nodeInfo$1, void 0, true));
+		return;
+	}
+	const nodeInfo = await getNodeInfo(url, {
+		parse: "bestEffort" in command$1 && 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.`);
+		process.exit(1);
+	}
+	let layout;
+	let defaultWidth = 0;
+	if (!("noFavicon" in command$1 && command$1.noFavicon)) {
+		spinner.text = "Fetching the favicon...";
+		try {
+			const faviconUrl = await getFaviconUrl(url, command$1.userAgent);
+			const response = await fetch(faviconUrl, { headers: { "User-Agent": command$1.userAgent == null ? getUserAgent() : command$1.userAgent } });
+			if (response.ok) {
+				const contentType = response.headers.get("Content-Type");
+				let buffer = await response.arrayBuffer();
+				if (contentType === "image/vnd.microsoft.icon" || contentType === "image/x-icon" || isICO(buffer)) {
+					const images = await parseICO(buffer);
+					if (images.length < 1) throw new Error("No images found in the ICO file.");
+					buffer = images[0].buffer;
+				}
+				const image = await Jimp.read(buffer);
+				const colorSupport = checkTerminalColorSupport();
+				layout = getAsciiArt(image, DEFAULT_IMAGE_WIDTH, colorSupport, colors).split("\n").map((line) => ` ${line}  `);
+				defaultWidth = 41;
+			} else {
+				logger.error("Failed to fetch the favicon: {status} {statusText}", {
+					status: response.status,
+					statusText: response.statusText
+				});
+				layout = [""];
+			}
+		} catch (error) {
+			logger.error("Failed to fetch or render the favicon: {error}", { error });
+			layout = [""];
+		}
+	} else layout = [""];
+	spinner.succeed("NodeInfo document fetched.");
+	print(message``);
+	let i = 0;
+	const next = () => {
+		i++;
+		if (i >= layout.length) layout.push(" ".repeat(defaultWidth));
+		return i;
+	};
+	layout[i] += colors.bold(url.host);
+	layout[next()] += colors.dim("=".repeat(url.host.length));
+	layout[next()] += colors.bold(colors.dim("Software:"));
+	layout[next()] += `  ${nodeInfo.software.name} v${nodeInfo.software.version}`;
+	if (nodeInfo.software.homepage != null) layout[next()] += `  ${nodeInfo.software.homepage.href}`;
+	if (nodeInfo.software.repository != null) layout[next()] += "  " + colors.dim(nodeInfo.software.repository.href);
+	if (nodeInfo.protocols.length > 0) {
+		layout[next()] += colors.bold(colors.dim("Protocols:"));
+		for (const protocol of nodeInfo.protocols) layout[next()] += `  ${protocol}`;
+	}
+	if (nodeInfo.services?.inbound?.length ?? false) {
+		layout[next()] += colors.bold(colors.dim("Inbound services:"));
+		for (const service of nodeInfo.services?.inbound ?? []) layout[next()] += `  ${service}`;
+	}
+	if (nodeInfo.services?.outbound?.length ?? false) {
+		layout[next()] += colors.bold(colors.dim("Outbound services:"));
+		for (const service of nodeInfo.services?.outbound ?? []) layout[next()] += `  ${service}`;
+	}
+	if (nodeInfo.usage?.users != null && (nodeInfo.usage.users.total != null || nodeInfo.usage.users.activeHalfyear != null || nodeInfo.usage.users.activeMonth != null)) {
+		layout[next()] += colors.bold(colors.dim("Users:"));
+		if (nodeInfo.usage.users.total != null) layout[next()] += `  ${nodeInfo.usage.users.total.toLocaleString("en-US")} ` + colors.dim("(total)");
+		if (nodeInfo.usage.users.activeHalfyear != null) layout[next()] += `  ${nodeInfo.usage.users.activeHalfyear.toLocaleString("en-US")} ` + colors.dim("(active half year)");
+		if (nodeInfo.usage.users.activeMonth != null) layout[next()] += `  ${nodeInfo.usage.users.activeMonth.toLocaleString("en-US")} ` + colors.dim("(active month)");
+	}
+	if (nodeInfo.usage?.localPosts != null) {
+		layout[next()] += colors.bold(colors.dim("Local posts: "));
+		layout[next()] += "  " + nodeInfo.usage.localPosts.toLocaleString("en-US");
+	}
+	if (nodeInfo.usage?.localComments != null) {
+		layout[next()] += colors.bold(colors.dim("Local comments:"));
+		layout[next()] += "  " + nodeInfo.usage.localComments.toLocaleString("en-US");
+	}
+	if (nodeInfo.openRegistrations != null) {
+		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) {
+		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)}`;
+	}
+	console.log(layout.join("\n"));
+}
+function indent(text, depth) {
+	return text.replace(/\n/g, "\n" + " ".repeat(depth));
+}
+const LINK_REGEXP = /<link((?:\s+(?:[-a-z]+)=(?:"[^"]*"|'[^']*'|[^\s]+))*)\s*\/?>/gi;
+const LINK_ATTRS_REGEXP = /(?:\s+([-a-z]+)=("[^"]*"|'[^']*'|[^\s]+))/gi;
+async function getFaviconUrl(url, userAgent) {
+	const response = await fetch(url, { headers: { "User-Agent": userAgent == null ? getUserAgent() : userAgent } });
+	const text = await response.text();
+	for (const match of text.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 rel = attrs.rel?.toLowerCase()?.trim()?.split(/\s+/) ?? [];
+		if (!rel.includes("icon") && !rel.includes("apple-touch-icon")) continue;
+		if ("sizes" in attrs && attrs.sizes.match(/\d+x\d+/)) {
+			const [w, h] = attrs.sizes.split("x").map((v) => Number.parseInt(v));
+			if (w < 38 || h < 19) continue;
+		}
+		if ("href" in attrs) {
+			if (attrs.href.endsWith(".svg")) continue;
+			return new URL(attrs.href, response.url);
+		}
+	}
+	return new URL("/favicon.ico", response.url);
+}
+function checkTerminalColorSupport() {
+	const noColor = process.env.NO_COLOR;
+	if (noColor != null && noColor !== "") return "none";
+	const colorTerm = process.env.COLORTERM;
+	if (colorTerm != null && (colorTerm.includes("24bit") || colorTerm.includes("truecolor"))) return "truecolor";
+	const term = process.env.TERM;
+	if (term != null && (term.includes("256color") || term.includes("xterm") || term === "screen" || term === "tmux")) return "256color";
+	if (term != null && term !== "dumb") return "256color";
+	const isWindows = os.platform() === "win32";
+	const isWT = process.env.WT_SESSION;
+	if (isWindows && isWT != null && isWT !== "") return "truecolor";
+	return "none";
+}
+const DEFAULT_IMAGE_WIDTH = 38;
+const ASCII_CHARS = "█▓▒░@#B8&WM%*oahkbdpqwmZO0QLCJUYXzcvunxrjft/\\|()1{}[]?-_+~<>i!lI;:,\"^`'. ";
+const CUBE_VALUES = [
+	0,
+	95,
+	135,
+	175,
+	215,
+	255
+];
+const findClosestIndex = (value) => {
+	let minDiff = Infinity;
+	let closestIndex = 0;
+	for (let idx = 0; idx < CUBE_VALUES.length; idx++) {
+		const diff = Math.abs(value - CUBE_VALUES[idx]);
+		if (diff < minDiff) {
+			minDiff = diff;
+			closestIndex = idx;
+		}
+	}
+	return closestIndex;
+};
+function rgbTo256Color(r, g, b) {
+	const gray = Math.round((r + g + b) / 3);
+	const isGrayscale = Math.abs(r - gray) <= 5 && Math.abs(g - gray) <= 5 && Math.abs(b - gray) <= 5;
+	if (isGrayscale) {
+		const isExactCubeValue = CUBE_VALUES.includes(r) && r === g && g === b;
+		if (!isExactCubeValue) {
+			if (gray < 8) return 232;
+			if (gray > 238) return 255;
+			const grayIndex = Math.round((gray - 8) / 10);
+			return Math.max(232, Math.min(255, 232 + grayIndex));
+		}
+	}
+	const r6 = findClosestIndex(r);
+	const g6 = findClosestIndex(g);
+	const b6 = findClosestIndex(b);
+	return 16 + 36 * r6 + 6 * g6 + b6;
+}
+function getAsciiArt(image, width = DEFAULT_IMAGE_WIDTH, colorSupport, colors$1) {
+	const ratio = image.width / image.height;
+	const height = Math.round(width / ratio * .5);
+	image.resize({
+		w: width,
+		h: height
+	});
+	let art = "";
+	for (let y = 0; y < height; y++) {
+		for (let x = 0; x < width; x++) {
+			const pixel = image.getPixelColor(x, y);
+			const color = intToRGBA(pixel);
+			if (color.a < 1) {
+				art += " ";
+				continue;
+			}
+			const brightness = (color.r + color.g + color.b) / 3;
+			const charIndex = Math.round(brightness / 255 * 72);
+			const char = ASCII_CHARS[charIndex];
+			if (colorSupport === "truecolor") art += colors$1.rgb(color.r, color.g, color.b)(char);
+			else if (colorSupport === "256color") {
+				const colorIndex = rgbTo256Color(color.r, color.g, color.b);
+				art += colors$1.ansi256(colorIndex)(char);
+			} else art += char;
+		}
+		if (y < height - 1) art += "\n";
+	}
+	return art;
+}
+
+//#endregion
+export { Jimp, nodeInfoCommand, runNodeInfo };

package/dist/table.js

@@ -0,0 +1,24 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+    
+//#region src/table.ts
+const tableStyle = {
+	top: "─",
+	topMid: "┬",
+	topLeft: "╭",
+	topRight: "╮",
+	bottom: "─",
+	bottomMid: "┴",
+	bottomLeft: "╰",
+	bottomRight: "╯",
+	left: "│",
+	leftMid: "├",
+	mid: "─",
+	midMid: "┼",
+	right: "│",
+	rightMid: "┤",
+	middle: "│"
+};
+
+//#endregion
+export { tableStyle };

package/dist/tempserver.js

@@ -0,0 +1,71 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+    
+import { getLogger } from "@logtape/logtape";
+import { openTunnel } from "@hongminhee/localtunnel";
+import { serve } from "srvx";
+
+//#region src/tempserver.ts
+const logger = getLogger([
+	"fedify",
+	"cli",
+	"tempserver"
+]);
+async function spawnTemporaryServer(fetch, options = {}) {
+	if (options.noTunnel) {
+		const server$1 = serve({
+			port: 0,
+			hostname: "::",
+			fetch
+		});
+		await server$1.ready();
+		const url$1 = new URL(server$1.url);
+		const port$1 = url$1.port;
+		logger.debug("Temporary server is listening on port {port}.", { port: port$1 });
+		return {
+			url: new URL(`http://localhost:${port$1}`),
+			async close() {
+				await server$1.close();
+			}
+		};
+	}
+	const server = serve({
+		fetch: (request) => {
+			const url$1 = new URL(request.url);
+			url$1.protocol = "https:";
+			request = new Request(url$1, {
+				method: request.method,
+				headers: request.headers,
+				body: request.method === "GET" || request.method === "HEAD" ? null : request.body,
+				referrer: request.referrer,
+				referrerPolicy: request.referrerPolicy,
+				mode: request.mode,
+				credentials: request.credentials,
+				cache: request.cache,
+				redirect: request.redirect,
+				integrity: request.integrity,
+				keepalive: request.keepalive,
+				signal: request.signal
+			});
+			return new Response();
+		},
+		port: 0,
+		hostname: "::"
+	});
+	await server.ready();
+	const url = new URL(server.url);
+	const port = url.port;
+	logger.debug("Temporary server is listening on port {port}.", { port });
+	const tun = await openTunnel({ port: parseInt(port) });
+	logger.debug("Temporary server is tunneled to {url}.", { url: tun.url.href });
+	return {
+		url: tun.url,
+		async close() {
+			await server.close();
+			await tun.close();
+		}
+	};
+}
+
+//#endregion
+export { spawnTemporaryServer };