@fedify/cli 2.0.0-pr.479.1922 → 2.0.1

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright 2024–2025 Hong Minhee
+Copyright 2024–2026 Hong Minhee
 
 Permission is hereby granted, free of charge, to any person obtaining a copy of
 this software and associated documentation files (the "Software"), to deal in

package/README.md

@@ -11,12 +11,12 @@ The `fedify` is a CLI toolchain for Fedify and debugging ActivityPub-enabled
 federated server apps.  Although it is primarily designed for developers who use
 [Fedify], it can be used with any ActivityPub-enabled server.
 
-[JSR]: https://jsr.io/@fedify/cli
 [JSR badge]: https://jsr.io/badges/@fedify/cli
-[npm]: https://www.npmjs.com/package/@fedify/cli
+[JSR]: https://jsr.io/@fedify/cli
 [npm badge]: https://img.shields.io/npm/v/@fedify/cli?logo=npm
-[GitHub Releases]: https://github.com/fedify-dev/fedify/releases
+[npm]: https://www.npmjs.com/package/@fedify/cli
 [GitHub Releases badge]: https://img.shields.io/github/v/release/fedify-dev/fedify?sort=semver&logo=github
+[GitHub Releases]: https://github.com/fedify-dev/fedify/releases
 [Fedify]: https://fedify.dev/
 
 

package/dist/cache.js

@@ -1,12 +1,26 @@
 
       import { Temporal } from "@js-temporal/polyfill";
     
-import envPaths from "env-paths";
+import { join } from "node:path";
 import { mkdir } from "node:fs/promises";
+import { homedir } from "node:os";
+import process from "node:process";
 
 //#region src/cache.ts
-const paths = envPaths("fedify", { suffix: "" });
-const DEFAULT_CACHE_DIR = paths.cache;
+/**
+* Returns the default cache directory path.
+* - Linux/macOS: `$XDG_CACHE_HOME/fedify` (default: ~/.cache/fedify)
+* - Windows: `%LOCALAPPDATA%\fedify`
+*/
+function getDefaultCacheDir() {
+	if (process.platform === "win32") {
+		const localAppData = process.env.LOCALAPPDATA || join(homedir(), "AppData", "Local");
+		return join(localAppData, "fedify");
+	}
+	const xdgCacheHome = process.env.XDG_CACHE_HOME || join(homedir(), ".cache");
+	return join(xdgCacheHome, "fedify");
+}
+const DEFAULT_CACHE_DIR = getDefaultCacheDir();
 let currentCacheDir = DEFAULT_CACHE_DIR;
 async function getCacheDir() {
 	await mkdir(currentCacheDir, { recursive: true });

package/dist/config.js

@@ -0,0 +1,105 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+    
+import { message } from "@optique/core";
+import { printError } from "@optique/run";
+import { readFileSync } from "node:fs";
+import { parse } from "smol-toml";
+import { createConfigContext } from "@optique/config";
+import { array, boolean, number, object as object$1, optional as optional$1, picklist, string as string$1 } from "valibot";
+
+//#region src/config.ts
+/**
+* Schema for the webfinger command configuration.
+*/
+const webfingerSchema = object$1({
+	allowPrivateAddress: optional$1(boolean()),
+	maxRedirection: optional$1(number())
+});
+/**
+* Schema for the lookup command configuration.
+*/
+const lookupSchema = object$1({
+	authorizedFetch: optional$1(boolean()),
+	firstKnock: optional$1(picklist(["draft-cavage-http-signatures-12", "rfc9421"])),
+	traverse: optional$1(boolean()),
+	suppressErrors: optional$1(boolean()),
+	defaultFormat: optional$1(picklist([
+		"default",
+		"raw",
+		"compact",
+		"expand"
+	])),
+	separator: optional$1(string$1()),
+	timeout: optional$1(number())
+});
+/**
+* Schema for the inbox command configuration.
+*/
+const inboxSchema = object$1({
+	actorName: optional$1(string$1()),
+	actorSummary: optional$1(string$1()),
+	authorizedFetch: optional$1(boolean()),
+	noTunnel: optional$1(boolean()),
+	follow: optional$1(array(string$1())),
+	acceptFollow: optional$1(array(string$1()))
+});
+/**
+* Schema for the relay command configuration.
+*/
+const relaySchema = object$1({
+	protocol: optional$1(picklist(["mastodon", "litepub"])),
+	port: optional$1(number()),
+	name: optional$1(string$1()),
+	persistent: optional$1(string$1()),
+	noTunnel: optional$1(boolean()),
+	acceptFollow: optional$1(array(string$1())),
+	rejectFollow: optional$1(array(string$1()))
+});
+/**
+* Schema for the nodeinfo command configuration.
+*/
+const nodeinfoSchema = object$1({
+	raw: optional$1(boolean()),
+	bestEffort: optional$1(boolean()),
+	showFavicon: optional$1(boolean()),
+	showMetadata: optional$1(boolean())
+});
+/**
+* Schema for the complete configuration file.
+*/
+const configSchema = object$1({
+	debug: optional$1(boolean()),
+	userAgent: optional$1(string$1()),
+	tunnelService: optional$1(picklist([
+		"localhost.run",
+		"serveo.net",
+		"pinggy.io"
+	])),
+	webfinger: optional$1(webfingerSchema),
+	lookup: optional$1(lookupSchema),
+	inbox: optional$1(inboxSchema),
+	relay: optional$1(relaySchema),
+	nodeinfo: optional$1(nodeinfoSchema)
+});
+/**
+* Config context for use with bindConfig().
+*/
+const configContext = createConfigContext({ schema: configSchema });
+/**
+* Try to load and parse a TOML config file.
+* Returns an empty object if the file doesn't exist.
+* Logs a warning and returns empty object for other errors (parsing, permissions).
+*/
+function tryLoadToml(filePath) {
+	try {
+		return parse(readFileSync(filePath, "utf-8"));
+	} catch (error) {
+		if (error instanceof Error && "code" in error && error.code === "ENOENT") return {};
+		printError(message`Could not load or parse config file at ${filePath}. It will be ignored.`);
+		return {};
+	}
+}
+
+//#endregion
+export { configContext, tryLoadToml };

package/dist/deno.js

@@ -3,28 +3,26 @@
     
 //#region deno.json
 var name = "@fedify/cli";
-var version = "2.0.0-pr.479.1922+564a1890";
+var version = "2.0.1";
 var license = "MIT";
 var exports = "./src/mod.ts";
 var imports = {
-	"@fxts/core": "npm:@fxts/core@^1.15.0",
 	"@hongminhee/localtunnel": "jsr:@hongminhee/localtunnel@^0.3.0",
 	"@inquirer/prompts": "npm:@inquirer/prompts@^7.8.4",
 	"@jimp/core": "npm:@jimp/core@^1.6.0",
 	"@jimp/wasm-webp": "npm:@jimp/wasm-webp@^1.6.0",
-	"@optique/core": "jsr:@optique/core@^0.6.1",
-	"@optique/run": "jsr:@optique/run@^0.6.1",
 	"@poppanator/http-constants": "npm:@poppanator/http-constants@^1.1.1",
 	"chalk": "npm:chalk@^5.6.2",
 	"cli-table3": "npm:cli-table3@^0.6.5",
-	"env-paths": "npm:env-paths@^3.0.0",
 	"fetch-mock": "npm:fetch-mock@^12.5.4",
 	"hono": "jsr:@hono/hono@^4.8.3",
 	"icojs": "npm:icojs@^0.19.5",
 	"inquirer-toggle": "npm:inquirer-toggle@^1.0.1",
 	"ora": "npm:ora@^8.2.0",
 	"shiki": "npm:shiki@^1.6.4",
+	"smol-toml": "npm:smol-toml@^1.6.0",
 	"srvx": "npm:srvx@^0.8.7",
+	"valibot": "jsr:@valibot/valibot@^1.2.0",
 	"#kv": "./src/kv.node.ts"
 };
 var exclude = [
@@ -33,10 +31,15 @@ var exclude = [
 	"fedify-cli-*.tgz",
 	"fedify-cli-*.zip"
 ];
+var publish = { "exclude": [
+	"**/*.test.ts",
+	"tsdown.config.ts",
+	"scripts/"
+] };
 var tasks = {
-	"codegen": "deno task -f @fedify/fedify codegen",
+	"codegen": "deno task -f @fedify/vocab compile",
 	"check": {
-		"command": "deno task codegen && deno fmt --check && deno lint && deno check src/**/*.ts",
+		"command": "deno fmt --check && deno lint && deno check src/**/*.ts",
 		"dependencies": ["codegen"]
 	},
 	"run": {
@@ -51,10 +54,15 @@ var tasks = {
 	"test": {
 		"command": "deno test --allow-all",
 		"dependencies": ["codegen"]
+	},
+	"test-init": {
+		"command": "FEDIFY_TEST_MODE=true deno run --allow-all src/init/test/mod.ts test-init",
+		"dependencies": ["codegen"]
 	}
 };
 var fmt = { "exclude": ["src/init/templates/**"] };
 var lint = { "exclude": ["src/init/templates/**"] };
+var test = { "exclude": ["src/init/test/**"] };
 var deno_default = {
 	name,
 	version,
@@ -62,9 +70,11 @@ var deno_default = {
 	exports,
 	imports,
 	exclude,
+	publish,
 	tasks,
 	fmt,
-	lint
+	lint,
+	test
 };
 
 //#endregion

package/dist/generate-vocab/action.js

@@ -2,10 +2,10 @@
       import { Temporal } from "@js-temporal/polyfill";
     
 import { stat } from "node:fs/promises";
+import process from "node:process";
 import { printError } from "@optique/run";
 import { generateVocab } from "@fedify/vocab-tools";
 import { message } from "@optique/core/message";
-import process from "node:process";
 
 //#region src/generate-vocab/action.ts
 async function runGenerateVocab({ schemaDir, generatedPath }) {

package/dist/imagerenderer.js

@@ -4,8 +4,8 @@
 import { Jimp } from "./nodeinfo.js";
 import path from "node:path";
 import fs from "node:fs/promises";
-import process from "node:process";
 import os from "node:os";
+import process from "node:process";
 import { encodeBase64 } from "byte-encodings/base64";
 
 //#region src/imagerenderer.ts

package/dist/inbox/rendercode.js

@@ -5,31 +5,21 @@ import { getContextLoader } from "../docloader.js";
 import { getStatusText } from "@poppanator/http-constants";
 
 //#region src/inbox/rendercode.ts
-async function renderRequest(request) {
+function renderRequest(request) {
 	request = request.clone();
 	const url = new URL(request.url);
-	let code = `${request.method} ${url.pathname + url.search}\n`;
-	for (const [key, value] of request.headers.entries()) code += `${capitalize(key)}: ${value}\n`;
-	let body;
-	try {
-		body = await request.text();
-	} catch (_) {
-		body = "[Failed to decode body; it may be binary.]";
-	}
-	code += `\n${body}`;
-	return code;
+	return renderMessage(`${request.method} ${url.pathname + url.search}`, request.headers, request);
 }
-async function renderResponse(response) {
+function renderResponse(response) {
 	response = response.clone();
-	let code = `${response.status} ${response.statusText === "" ? getStatusText(response.status) : response.statusText}\n`;
-	for (const [key, value] of response.headers.entries()) code += `${capitalize(key)}: ${value}\n`;
-	let body;
-	try {
-		body = await response.text();
-	} catch (_) {
-		body = "[Failed to decode body; it may be binary.]";
-	}
-	code += `\n${body}`;
+	const code = `${response.status} ${response.statusText === "" ? getStatusText(response.status) : response.statusText}`;
+	return renderMessage(code, response.headers, response);
+}
+async function renderMessage(code, headers, body) {
+	code += "\n";
+	for (const [key, value] of headers.entries()) code += `${capitalize(key)}: ${value}\n`;
+	const bodyText = await body.text().catch((_) => "[Failed to decode body; it may be binary.]");
+	code += `\n${bodyText}`;
 	return code;
 }
 async function renderRawActivity(request) {

package/dist/inbox.js

@@ -1,17 +1,20 @@
 
       import { Temporal } from "@js-temporal/polyfill";
     
+import { configContext } from "./config.js";
 import deno_default from "./deno.js";
 import { getDocumentLoader } from "./docloader.js";
-import { recordingSink } from "./log.js";
-import { configureLogging, debugOption } from "./globals.js";
 import { ActivityEntryPage, ActivityListPage } from "./inbox/view.js";
+import { configureLogging, recordingSink } from "./log.js";
+import { createTunnelOption } from "./options.js";
 import { tableStyle } from "./table.js";
 import { spawnTemporaryServer } from "./tempserver.js";
-import { colors } from "./utils.js";
-import { command, constant, merge, message, multiple, object, option, optional, string, withDefault } from "@optique/core";
+import { colors, matchesActor } from "./utils.js";
 import process from "node:process";
-import { Accept, Activity, Application, Delete, Endpoints, Follow, Image, MemoryKvStore, PUBLIC_COLLECTION, createFederation, generateCryptoKeyPair, getActorHandle, isActor, lookupObject } from "@fedify/fedify";
+import { command, constant, group, merge, message, multiple, object, option, string } from "@optique/core";
+import { bindConfig } from "@optique/config";
+import { MemoryKvStore, createFederation, generateCryptoKeyPair } from "@fedify/fedify";
+import { Accept, Activity, Application, Delete, Endpoints, Follow, Image, PUBLIC_COLLECTION, isActor, lookupObject } from "@fedify/vocab";
 import { getLogger } from "@logtape/logtape";
 import Table from "cli-table3";
 import { Hono } from "hono";
@@ -26,30 +29,172 @@ const logger = getLogger([
 ]);
 const inboxCommand = command("inbox", merge(object("Inbox options", {
 	command: constant("inbox"),
-	follow: optional(multiple(option("-f", "--follow", string({ metavar: "URI" }), { description: message`Follow the given actor. The argument can be either an actor URI or a handle. Can be specified multiple times.` }))),
-	acceptFollow: optional(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.` }))),
-	noTunnel: option("-T", "--no-tunnel", { description: message`Do not tunnel the ephemeral ActivityPub server to the public Internet.` }),
-	actorName: withDefault(option("--actor-name", string({ metavar: "NAME" }), { description: message`Customize the actor display name.` }), "Fedify Ephemeral Inbox"),
-	actorSummary: withDefault(option("--actor-summary", string({ metavar: "SUMMARY" }), { description: message`Customize the actor description.` }), "An ephemeral ActivityPub inbox for testing purposes.")
-}), debugOption), {
+	follow: bindConfig(multiple(option("-f", "--follow", string({ metavar: "URI" }), { description: message`Follow the given actor. The argument can be either an actor URI or a handle. Can be specified multiple times.` })), {
+		context: configContext,
+		key: (config) => config.inbox?.follow ?? [],
+		default: []
+	}),
+	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.inbox?.acceptFollow ?? [],
+		default: []
+	}),
+	actorName: bindConfig(option("--actor-name", string({ metavar: "NAME" }), { description: message`Customize the actor display name.` }), {
+		context: configContext,
+		key: (config) => config.inbox?.actorName ?? "Fedify Ephemeral Inbox",
+		default: "Fedify Ephemeral Inbox"
+	}),
+	actorSummary: bindConfig(option("--actor-summary", string({ metavar: "SUMMARY" }), { description: message`Customize the actor description.` }), {
+		context: configContext,
+		key: (config) => config.inbox?.actorSummary ?? "An ephemeral ActivityPub inbox for testing purposes.",
+		default: "An ephemeral ActivityPub inbox for testing purposes."
+	}),
+	authorizedFetch: bindConfig(option("-A", "--authorized-fetch", { description: message`Enable authorized fetch mode. Incoming requests without valid HTTP signatures will be rejected with 401 Unauthorized.` }), {
+		context: configContext,
+		key: (config) => config.inbox?.authorizedFetch ?? false,
+		default: false
+	})
+}), group("Tunnel options", createTunnelOption("inbox"))), {
 	brief: message`Run an ephemeral ActivityPub inbox server.`,
 	description: message`Spins up an ephemeral server that serves the ActivityPub inbox with an one-time actor, through a short-lived public DNS with HTTPS. You can monitor the incoming activities in real-time.`
 });
+const activities = [];
+const acceptFollows = [];
+const peers = {};
+const followers = {};
 async function runInbox(command$1) {
-	const fetch = createFetchHandler({
+	activities.length = 0;
+	acceptFollows.length = 0;
+	for (const key of Object.keys(peers)) delete peers[key];
+	for (const key of Object.keys(followers)) delete followers[key];
+	if (command$1.debug) await configureLogging();
+	const federationDocumentLoader = await getDocumentLoader();
+	const authorizedFetchEnabled = command$1.authorizedFetch ?? false;
+	const authorize = async (ctx) => {
+		if (!authorizedFetchEnabled) return true;
+		return await ctx.getSignedKey() != null;
+	};
+	const instanceActor = async (ctx, identifier) => {
+		if (identifier === "ia") return true;
+		return await authorize(ctx);
+	};
+	const federation = createFederation({
+		kv: new MemoryKvStore(),
+		documentLoaderFactory: () => federationDocumentLoader,
+		skipSignatureVerification: !authorizedFetchEnabled
+	});
+	const time = Temporal.Now.instant();
+	let actorKeyPairs = void 0;
+	let instanceActorKeyPairs = void 0;
+	federation.setActorDispatcher("/{identifier}", async (ctx, identifier) => {
+		if (identifier !== "i" && identifier !== "ia") return null;
+		const keyPairs = await ctx.getActorKeyPairs(identifier);
+		return new Application({
+			id: ctx.getActorUri(identifier),
+			preferredUsername: identifier,
+			name: identifier === "ia" ? "Instance Actor" : ctx.data.actorName,
+			summary: identifier === "ia" ? "Instance actor for signing requests" : ctx.data.actorSummary,
+			inbox: ctx.getInboxUri(identifier),
+			endpoints: new Endpoints({ sharedInbox: ctx.getInboxUri() }),
+			followers: ctx.getFollowersUri(identifier),
+			following: ctx.getFollowingUri(identifier),
+			outbox: ctx.getOutboxUri(identifier),
+			manuallyApprovesFollowers: true,
+			published: time,
+			icon: new Image({
+				url: new URL("https://fedify.dev/logo.png"),
+				mediaType: "image/png"
+			}),
+			publicKey: keyPairs[0].cryptographicKey,
+			assertionMethods: keyPairs.map((pair) => pair.multikey),
+			url: ctx.getActorUri(identifier)
+		});
+	}).setKeyPairsDispatcher(async (_ctxData, identifier) => {
+		if (identifier === "i") {
+			if (actorKeyPairs == null) actorKeyPairs = [await generateCryptoKeyPair("RSASSA-PKCS1-v1_5"), await generateCryptoKeyPair("Ed25519")];
+			return actorKeyPairs;
+		} else if (identifier === "ia") {
+			if (instanceActorKeyPairs == null) instanceActorKeyPairs = [await generateCryptoKeyPair("RSASSA-PKCS1-v1_5"), await generateCryptoKeyPair("Ed25519")];
+			return instanceActorKeyPairs;
+		}
+		return [];
+	}).authorize(instanceActor);
+	federation.setInboxListeners("/{identifier}/inbox", "/inbox").setSharedKeyDispatcher((_) => ({ identifier: "ia" })).on(Activity, async (ctx, activity) => {
+		activities[ctx.data.activityIndex].activity = activity;
+		for await (const actor of activity.getActors()) if (actor.id != null) peers[actor.id.href] = actor;
+		for await (const actor of activity.getAttributions()) if (actor.id != null) peers[actor.id.href] = actor;
+		if (activity instanceof Follow) {
+			if (acceptFollows.length < 1) return;
+			const objectId = activity.objectId;
+			if (objectId == null) return;
+			const parsed = ctx.parseUri(objectId);
+			if (parsed?.type !== "actor" || parsed.identifier !== "i") return;
+			const { identifier } = parsed;
+			const follower = await activity.getActor();
+			if (!isActor(follower)) return;
+			const accepts = await matchesActor(follower, acceptFollows);
+			if (!accepts || activity.id == null) {
+				logger.debug("Does not accept follow from {actor}.", { actor: follower.id?.href });
+				return;
+			}
+			logger.debug("Accepting follow from {actor}.", { actor: follower.id?.href });
+			followers[activity.id.href] = follower;
+			await ctx.sendActivity({ identifier }, follower, new Accept({
+				id: new URL(`#accepts/${follower.id?.href}`, ctx.getActorUri("i")),
+				actor: ctx.getActorUri(identifier),
+				object: activity.id
+			}));
+		}
+	});
+	federation.setFollowersDispatcher("/{identifier}/followers", (_ctx, identifier) => {
+		if (identifier !== "i") return null;
+		const items = [];
+		for (const follower of Object.values(followers)) {
+			if (follower.id == null) continue;
+			items.push(follower);
+		}
+		return { items };
+	}).setCounter((_ctx, identifier) => {
+		if (identifier !== "i") return null;
+		return Object.keys(followers).length;
+	}).authorize(authorize);
+	federation.setFollowingDispatcher("/{identifier}/following", (_ctx, _identifier) => null).setCounter((_ctx, _identifier) => 0).authorize(authorize);
+	federation.setOutboxDispatcher("/{identifier}/outbox", (_ctx, _identifier) => null).setCounter((_ctx, _identifier) => 0).authorize(authorize);
+	federation.setNodeInfoDispatcher("/nodeinfo/2.1", (_ctx) => {
+		return {
+			software: {
+				name: "fedify-cli",
+				version: deno_default.version,
+				repository: new URL("https://github.com/fedify-dev/fedify")
+			},
+			protocols: ["activitypub"],
+			usage: {
+				users: {
+					total: 1,
+					activeMonth: 1,
+					activeHalfyear: 1
+				},
+				localComments: 0,
+				localPosts: 0
+			}
+		};
+	});
+	const fetch = createFetchHandler(federation, {
 		actorName: command$1.actorName,
 		actorSummary: command$1.actorSummary
 	});
-	const sendDeleteToPeers = createSendDeleteToPeers({
+	const sendDeleteToPeers = createSendDeleteToPeers(federation, {
 		actorName: command$1.actorName,
 		actorSummary: command$1.actorSummary
 	});
-	if (command$1.debug) await configureLogging();
 	const spinner = ora({
 		text: "Spinning up an ephemeral ActivityPub server...",
 		discardStdin: false
 	}).start();
-	const server = await spawnTemporaryServer(fetch, { noTunnel: command$1.noTunnel });
+	const server = await spawnTemporaryServer(fetch, {
+		noTunnel: !command$1.tunnel,
+		...command$1.tunnel && { service: command$1.tunnelService }
+	});
 	spinner.succeed(`The ephemeral ActivityPub server is up and running: ${colors.green(server.url.href)}`);
 	process.on("SIGINT", () => {
 		spinner.stop();
@@ -94,61 +239,7 @@ async function runInbox(command$1) {
 	spinner.stop();
 	printServerInfo(fedCtx);
 }
-const federationDocumentLoader = await getDocumentLoader();
-const federation = createFederation({
-	kv: new MemoryKvStore(),
-	documentLoaderFactory: () => {
-		return federationDocumentLoader;
-	}
-});
-const time = Temporal.Now.instant();
-let actorKeyPairs = void 0;
-federation.setActorDispatcher("/{identifier}", async (ctx, identifier) => {
-	if (identifier !== "i") return null;
-	return new Application({
-		id: ctx.getActorUri(identifier),
-		preferredUsername: identifier,
-		name: ctx.data.actorName,
-		summary: ctx.data.actorSummary,
-		inbox: ctx.getInboxUri(identifier),
-		endpoints: new Endpoints({ sharedInbox: ctx.getInboxUri() }),
-		followers: ctx.getFollowersUri(identifier),
-		following: ctx.getFollowingUri(identifier),
-		outbox: ctx.getOutboxUri(identifier),
-		manuallyApprovesFollowers: true,
-		published: time,
-		icon: new Image({
-			url: new URL("https://fedify.dev/logo.png"),
-			mediaType: "image/png"
-		}),
-		publicKey: (await ctx.getActorKeyPairs(identifier))[0].cryptographicKey,
-		assertionMethods: (await ctx.getActorKeyPairs(identifier)).map((pair) => pair.multikey),
-		url: ctx.getActorUri(identifier)
-	});
-}).setKeyPairsDispatcher(async (_ctxData, identifier) => {
-	if (identifier !== "i") return [];
-	if (actorKeyPairs == null) actorKeyPairs = [await generateCryptoKeyPair("RSASSA-PKCS1-v1_5"), await generateCryptoKeyPair("Ed25519")];
-	return actorKeyPairs;
-});
-const activities = [];
-const acceptFollows = [];
-async function acceptsFollowFrom(actor) {
-	const actorUri = actor.id;
-	let actorHandle = void 0;
-	if (actorUri == null) return false;
-	for (let uri of acceptFollows) {
-		if (uri === "*") return true;
-		if (uri.startsWith("http:") || uri.startsWith("https:")) {
-			uri = new URL(uri).href;
-			if (uri === actorUri.href) return true;
-		}
-		if (actorHandle == null) actorHandle = await getActorHandle(actor);
-		if (actorHandle === uri) return true;
-	}
-	return false;
-}
-const peers = {};
-function createSendDeleteToPeers(actorOptions) {
+function createSendDeleteToPeers(federation, actorOptions) {
 	return async function sendDeleteToPeers(server) {
 		const ctx = federation.createContext(new Request(server.url), {
 			activityIndex: -1,
@@ -168,67 +259,6 @@ function createSendDeleteToPeers(actorOptions) {
 		}
 	};
 }
-const followers = {};
-federation.setInboxListeners("/{identifier}/inbox", "/inbox").setSharedKeyDispatcher((_) => ({ identifier: "i" })).on(Activity, async (ctx, activity) => {
-	activities[ctx.data.activityIndex].activity = activity;
-	for await (const actor of activity.getActors()) if (actor.id != null) peers[actor.id.href] = actor;
-	for await (const actor of activity.getAttributions()) if (actor.id != null) peers[actor.id.href] = actor;
-	if (activity instanceof Follow) {
-		if (acceptFollows.length < 1) return;
-		const objectId = activity.objectId;
-		if (objectId == null) return;
-		const parsed = ctx.parseUri(objectId);
-		if (parsed?.type !== "actor" || parsed.identifier !== "i") return;
-		const { identifier } = parsed;
-		const follower = await activity.getActor();
-		if (!isActor(follower)) return;
-		const accepts = await acceptsFollowFrom(follower);
-		if (!accepts || activity.id == null) {
-			logger.debug("Does not accept follow from {actor}.", { actor: follower.id?.href });
-			return;
-		}
-		logger.debug("Accepting follow from {actor}.", { actor: follower.id?.href });
-		followers[activity.id.href] = follower;
-		await ctx.sendActivity({ identifier }, follower, new Accept({
-			id: new URL(`#accepts/${follower.id?.href}`, ctx.getActorUri("i")),
-			actor: ctx.getActorUri(identifier),
-			object: activity.id
-		}));
-	}
-});
-federation.setFollowersDispatcher("/{identifier}/followers", (_ctx, identifier) => {
-	if (identifier !== "i") return null;
-	const items = [];
-	for (const follower of Object.values(followers)) {
-		if (follower.id == null) continue;
-		items.push(follower);
-	}
-	return { items };
-}).setCounter((_ctx, identifier) => {
-	if (identifier !== "i") return null;
-	return Object.keys(followers).length;
-});
-federation.setFollowingDispatcher("/{identifier}/following", (_ctx, _identifier) => null).setCounter((_ctx, _identifier) => 0);
-federation.setOutboxDispatcher("/{identifier}/outbox", (_ctx, _identifier) => null).setCounter((_ctx, _identifier) => 0);
-federation.setNodeInfoDispatcher("/nodeinfo/2.1", (_ctx) => {
-	return {
-		software: {
-			name: "fedify-cli",
-			version: deno_default.version,
-			repository: new URL("https://github.com/fedify-dev/fedify")
-		},
-		protocols: ["activitypub"],
-		usage: {
-			users: {
-				total: 1,
-				activeMonth: 1,
-				activeHalfyear: 1
-			},
-			localComments: 0,
-			localPosts: 0
-		}
-	};
-});
 function printServerInfo(fedCtx) {
 	const table = new Table({
 		chars: tableStyle,
@@ -279,7 +309,7 @@ app.get("/r/:idx{[0-9]+}", (c) => {
 		tabPage: tab
 	}));
 });
-function createFetchHandler(actorOptions) {
+function createFetchHandler(federation, actorOptions) {
 	return async function fetch(request) {
 		const timestamp = Temporal.Now.instant();
 		const idx = activities.length;

package/dist/init/mod.js

@@ -1,6 +1,6 @@
 
       import { Temporal } from "@js-temporal/polyfill";
     
-import action_default from "./action/mod.js";
-import { initCommand, testInitCommand } from "./command.js";
-import action_default$1 from "./test/action.js";
+import { initCommand, runInit } from "@fedify/init";
+
+export { initCommand, runInit };