@fedify/cli 2.3.0-dev.1358 → 2.3.0-dev.1361

package/dist/commands.js

@@ -1,110 +0,0 @@
-import "@js-temporal/polyfill";
-import { benchMetadata, benchOptions } from "./bench/command.js";
-import { generateVocabMetadata, generateVocabOptions } from "./generate-vocab/command.js";
-import { inboxMetadata, inboxOptions } from "./inbox/command.js";
-import { lookupMetadata, lookupOptions } from "./lookup/command.js";
-import { nodeInfoMetadata, nodeInfoOptions, runNodeInfo } from "./nodeinfo.js";
-import { relayMetadata, relayOptions } from "./relay/command.js";
-import { runTunnel, tunnelMetadata, tunnelOptions } from "./tunnel.js";
-import { webFingerMetadata, webFingerOptions } from "./webfinger/command.js";
-import { constant, merge, message, object, optionNames } from "@optique/core";
-import { initOptions, runInit } from "@fedify/init";
-import { defineCommand } from "@optique/discover";
-//#region src/commands.ts
-function defineCliCommand(command) {
-	const { run, ...definition } = command;
-	return {
-		...defineCommand({
-			...definition,
-			handler: (_value) => {}
-		}),
-		run
-	};
-}
-const generatingCommands = [defineCliCommand({
-	path: ["init"],
-	parser: merge(initOptions, object({ command: constant("init") })),
-	metadata: {
-		brief: message`Initialize a new Fedify project directory.`,
-		description: message`Initialize a new Fedify project directory.
-
-By default, it initializes the current directory.  You can specify a different directory as an argument.
-
-Unless you specify all options (${optionNames(["-w", "--web-framework"])}, ${optionNames(["-p", "--package-manager"])}, ${optionNames(["-k", "--kv-store"])}, and ${optionNames(["-m", "--message-queue"])}), it will prompt you to select the options interactively.`
-	},
-	run: runInit
-}), defineCliCommand({
-	path: ["generate-vocab"],
-	parser: generateVocabOptions,
-	metadata: generateVocabMetadata,
-	run: async (value) => {
-		const { default: runGenerateVocab } = await import("./generate-vocab/action.js");
-		return await runGenerateVocab(value);
-	}
-})];
-const activityPubCommands = [
-	defineCliCommand({
-		path: ["webfinger"],
-		parser: webFingerOptions,
-		metadata: webFingerMetadata,
-		run: async (value) => {
-			const { default: runWebFinger } = await import("./webfinger/action.js");
-			return await runWebFinger(value);
-		}
-	}),
-	defineCliCommand({
-		path: ["lookup"],
-		parser: lookupOptions,
-		metadata: lookupMetadata,
-		run: async (value) => {
-			const { runLookup } = await import("./lookup.js");
-			return await runLookup(value);
-		}
-	}),
-	defineCliCommand({
-		path: ["inbox"],
-		parser: inboxOptions,
-		metadata: inboxMetadata,
-		run: async (value) => {
-			const { runInbox } = await import("./inbox.js");
-			return await runInbox(value);
-		}
-	}),
-	defineCliCommand({
-		path: ["nodeinfo"],
-		parser: nodeInfoOptions,
-		metadata: nodeInfoMetadata,
-		run: runNodeInfo
-	}),
-	defineCliCommand({
-		path: ["relay"],
-		parser: relayOptions,
-		metadata: relayMetadata,
-		run: async (value) => {
-			const { runRelay } = await import("./relay.js");
-			return await runRelay(value);
-		}
-	}),
-	defineCliCommand({
-		path: ["bench"],
-		parser: benchOptions,
-		metadata: benchMetadata,
-		run: async (value) => {
-			const { runBench } = await import("./bench/mod.js");
-			return await runBench(value);
-		}
-	})
-];
-const networkCommands = [defineCliCommand({
-	path: ["tunnel"],
-	parser: tunnelOptions,
-	metadata: tunnelMetadata,
-	run: runTunnel
-})];
-[
-	...generatingCommands,
-	...activityPubCommands,
-	...networkCommands
-];
-//#endregion
-export { activityPubCommands, generatingCommands, networkCommands };

package/dist/lookup/command.js

@@ -1,121 +0,0 @@
-import "@js-temporal/polyfill";
-import { configContext } from "../config.js";
-import { createTunnelServiceOption, userAgentOption } from "../options.js";
-import { argument, choice, command, constant, flag, float, integer, map, merge, message, multiple, object, option, optionNames, optional, or, string, withDefault } from "@optique/core";
-import { path } from "@optique/run";
-import { bindConfig } from "@optique/config";
-//#region src/lookup/command.ts
-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`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`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`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: 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`Recursively follow a relationship property.` }), {
-		context: configContext,
-		key: (config) => config.lookup?.recurse
-	}),
-	recurseDepth: bindConfig(option("--recurse-depth", integer({
-		min: 1,
-		metavar: "DEPTH"
-	}), { description: message`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`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 lookupOptions = 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`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", {
-	reverse: bindConfig(flag("--reverse", { description: message`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`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.` }))
-}));
-const lookupMetadata = {
-	brief: message`Look up Activity Streams objects.`,
-	description: message`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.`
-};
-command("lookup", lookupOptions, lookupMetadata);
-//#endregion
-export { FEDIBIRD_QUOTE_IRI, IN_REPLY_TO_IRI, MISSKEY_QUOTE_IRI, QUOTE_IRI, QUOTE_URL_IRI, authorizedFetchOption, lookupMetadata, lookupOptions };