@fedify/cli 1.8.12 → 2.0.0-dev.1757

package/dist/inbox.js

@@ -0,0 +1,315 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+    
+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 { 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 { Accept, Activity, Application, Delete, Endpoints, Follow, Image, MemoryKvStore, PUBLIC_COLLECTION, createFederation, generateCryptoKeyPair, getActorHandle, isActor, lookupObject } from "@fedify/fedify";
+import { getLogger } from "@logtape/logtape";
+import Table from "cli-table3";
+import { Hono } from "hono";
+import process from "node:process";
+import ora from "ora";
+import { jsx } from "hono/jsx/jsx-runtime";
+
+//#region src/inbox.tsx
+const logger = getLogger([
+	"fedify",
+	"cli",
+	"inbox"
+]);
+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), { 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.` });
+async function runInbox(command$1) {
+	const fetch = createFetchHandler({
+		actorName: command$1.actorName,
+		actorSummary: command$1.actorSummary
+	});
+	const sendDeleteToPeers = createSendDeleteToPeers({
+		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 });
+	spinner.succeed(`The ephemeral ActivityPub server is up and running: ${colors.green(server.url.href)}`);
+	process.on("SIGINT", () => {
+		spinner.stop();
+		const peersCnt = Object.keys(peers).length;
+		spinner.start(`Sending Delete(Application) activities to the ${peersCnt} ${peersCnt === 1 ? "peer" : "peers"}...`);
+		sendDeleteToPeers(server).then(() => {
+			spinner.text = "Stopping server...";
+			server.close().then(() => {
+				spinner.succeed("Server stopped.");
+				process.exit(0);
+			});
+		});
+	});
+	spinner.start();
+	const fedCtx = federation.createContext(server.url, {
+		activityIndex: -1,
+		actorName: command$1.actorName,
+		actorSummary: command$1.actorSummary
+	});
+	if (command$1.acceptFollow != null && command$1.acceptFollow.length > 0) acceptFollows.push(...command$1.acceptFollow ?? []);
+	if (command$1.follow != null && command$1.follow.length > 0) {
+		spinner.text = "Following actors...";
+		const documentLoader = await fedCtx.getDocumentLoader({ identifier: "i" });
+		for (const uri of command$1.follow) {
+			spinner.text = `Following ${colors.green(uri)}...`;
+			const actor = await lookupObject(uri, { documentLoader });
+			if (!isActor(actor)) {
+				spinner.fail(`Not an actor: ${colors.red(uri)}`);
+				spinner.start();
+				continue;
+			}
+			if (actor.id != null) peers[actor.id?.href] = actor;
+			await fedCtx.sendActivity({ identifier: "i" }, actor, new Follow({
+				id: new URL(`#follows/${actor.id?.href}`, fedCtx.getActorUri("i")),
+				actor: fedCtx.getActorUri("i"),
+				object: actor.id
+			}));
+			spinner.succeed(`Sent follow request to ${colors.green(uri)}.`);
+			spinner.start();
+		}
+	}
+	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) {
+	return async function sendDeleteToPeers(server) {
+		const ctx = federation.createContext(new Request(server.url), {
+			activityIndex: -1,
+			actorName: actorOptions.actorName,
+			actorSummary: actorOptions.actorSummary
+		});
+		const actor = await ctx.getActor("i");
+		try {
+			await ctx.sendActivity({ identifier: "i" }, Object.values(peers), new Delete({
+				id: new URL(`#delete`, actor.id),
+				actor: actor.id,
+				to: PUBLIC_COLLECTION,
+				object: actor
+			}));
+		} catch (error) {
+			logger.error("Failed to send Delete(Application) activities to peers:\n{error}", { error });
+		}
+	};
+}
+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,
+		style: {
+			head: [],
+			border: []
+		}
+	});
+	table.push({ "Actor handle:": colors.green(`i@${fedCtx.getActorUri("i").host}`) }, { "Actor URI:": colors.green(fedCtx.getActorUri("i").href) }, { "Actor inbox:": colors.green(fedCtx.getInboxUri("i").href) }, { "Shared inbox:": colors.green(fedCtx.getInboxUri().href) });
+	console.log(table.toString());
+}
+async function printActivityEntry(idx, entry) {
+	const request = entry.request.clone();
+	const response = entry.response?.clone();
+	const url = new URL(request.url);
+	const activity = entry.activity;
+	const object$1 = await activity?.getObject();
+	const table = new Table({
+		chars: tableStyle,
+		style: {
+			head: [],
+			border: []
+		}
+	});
+	table.push({ "Request #:": colors.bold(idx.toString()) }, { "Activity type:": activity == null ? colors.red("failed to parse") : colors.green(`${activity.constructor.name}(${object$1?.constructor.name})`) }, { "HTTP request:": `${request.method === "POST" ? colors.green("POST") : colors.red(request.method)} ${url.pathname + url.search}` }, ...response == null ? [] : [{ "HTTP response:": `${response.ok ? colors.green(response.status.toString()) : colors.red(response.status.toString())} ${response.statusText}` }], { "Details": new URL(`/r/${idx}`, url).href });
+	console.log(table.toString());
+}
+function getHandle(c) {
+	const url = new URL(c.req.url);
+	return `@i@${url.host}`;
+}
+const app = new Hono();
+app.get("/", (c) => c.redirect("/r"));
+app.get("/r", (c) => c.html(/* @__PURE__ */ jsx(ActivityListPage, {
+	handle: getHandle(c),
+	entries: activities
+})));
+app.get("/r/:idx{[0-9]+}", (c) => {
+	const idx = parseInt(c.req.param("idx"));
+	const tab = c.req.query("tab") ?? "request";
+	const activity = activities[idx];
+	if (activity == null) return c.notFound();
+	if (tab !== "request" && tab !== "response" && tab !== "raw-activity" && tab !== "compact-activity" && tab !== "expanded-activity" && tab !== "logs") return c.notFound();
+	return c.html(/* @__PURE__ */ jsx(ActivityEntryPage, {
+		handle: getHandle(c),
+		idx,
+		entry: activity,
+		tabPage: tab
+	}));
+});
+function createFetchHandler(actorOptions) {
+	return async function fetch(request) {
+		const timestamp = Temporal.Now.instant();
+		const idx = activities.length;
+		const pathname = new URL(request.url).pathname;
+		if (pathname === "/r" || pathname.startsWith("/r/")) return app.fetch(request);
+		const inboxRequest = pathname === "/inbox" || pathname.startsWith("/i/inbox");
+		if (inboxRequest) {
+			recordingSink.startRecording();
+			activities.push({
+				timestamp,
+				request: request.clone(),
+				logs: []
+			});
+		}
+		const response = await federation.fetch(request, {
+			contextData: {
+				activityIndex: inboxRequest ? idx : -1,
+				actorName: actorOptions.actorName,
+				actorSummary: actorOptions.actorSummary
+			},
+			onNotAcceptable: app.fetch.bind(app),
+			onNotFound: app.fetch.bind(app),
+			onUnauthorized: app.fetch.bind(app)
+		});
+		if (inboxRequest) {
+			recordingSink.stopRecording();
+			activities[idx].response = response.clone();
+			activities[idx].logs = recordingSink.getRecords();
+			await printActivityEntry(idx, activities[idx]);
+		}
+		return response;
+	};
+}
+
+//#endregion
+export { inboxCommand, runInbox };

package/dist/init/action/configs.js

@@ -0,0 +1,81 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+    
+import biome_default from "../json/biome.js";
+import vscode_settings_for_deno_default from "../json/vscode-settings-for-deno.js";
+import vscode_settings_default from "../json/vscode-settings.js";
+import { join } from "node:path";
+
+//#region src/init/action/configs.ts
+/**
+* Loads Deno configuration object with compiler options, unstable features, and tasks.
+* Combines unstable features required by KV store and message queue with framework-specific options.
+*
+* @param param0 - Destructured initialization data containing KV, MQ, initializer, and directory
+* @returns Configuration object with path and Deno-specific settings
+*/
+const loadDenoConfig = ({ kv, mq, initializer, dir }) => ({
+	path: join(dir, "deno.json"),
+	data: { compilerOptions: initializer.compilerOptions },
+	unstable: [
+		"temporal",
+		...kv.denoUnstable ?? [],
+		...mq.denoUnstable ?? []
+	],
+	tasks: initializer.tasks
+});
+/**
+* Loads TypeScript configuration object for Node.js/Bun projects.
+* Uses compiler options from the framework initializer.
+*
+* @param param0 - Destructured initialization data containing initializer and directory
+* @returns Configuration object with path and TypeScript compiler options
+*/
+const loadTsConfig = ({ initializer, dir }) => ({
+	path: join(dir, "tsconfig.json"),
+	data: { compilerOptions: initializer.compilerOptions }
+});
+/**
+* Loads package.json configuration object for Node.js/Bun projects.
+* Sets up ES modules and includes framework-specific npm scripts.
+*
+* @param param0 - Destructured initialization data containing initializer and directory
+* @returns Configuration object with path and package.json settings
+*/
+const loadPackageJson = ({ initializer, dir }) => ({
+	path: join(dir, "package.json"),
+	data: {
+		type: "module",
+		scripts: initializer.tasks
+	}
+});
+/**
+* Configuration objects for various development tool setup files.
+* Contains predefined configurations for code formatting, VS Code settings, and extensions
+* based on the project type (Node.js/Bun or Deno).
+*/
+const devToolConfigs = {
+	biome: {
+		path: join("biome.json"),
+		data: biome_default
+	},
+	vscExt: {
+		path: join(".vscode", "extensions.json"),
+		data: { recommendations: ["biomejs.biome"] }
+	},
+	vscSet: {
+		path: join(".vscode", "settings.json"),
+		data: vscode_settings_default
+	},
+	vscSetDeno: {
+		path: join(".vscode", "settings.json"),
+		data: vscode_settings_for_deno_default
+	},
+	vscExtDeno: {
+		path: join(".vscode", "extensions.json"),
+		data: { recommendations: ["denoland.vscode-deno"] }
+	}
+};
+
+//#endregion
+export { devToolConfigs, loadDenoConfig, loadPackageJson, loadTsConfig };

package/dist/init/action/deps.js

@@ -0,0 +1,52 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+    
+import { merge } from "../../utils.js";
+import { PACKAGE_VERSION } from "../lib.js";
+import { entries, map, pipe, toArray } from "@fxts/core";
+
+//#region src/init/action/deps.ts
+/**
+* Gathers all dependencies required for the project based on the initializer,
+* key-value store, and message queue configurations.
+*
+* @param data - Web Framework initializer, key-value store and message queue descriptions
+* @returns A record of dependencies with their versions
+*/
+const getDependencies = ({ initializer, kv, mq }) => pipe({
+	"@fedify/fedify": PACKAGE_VERSION,
+	"@logtape/logtape": "^1.1.0"
+}, merge(initializer.dependencies), merge(kv.dependencies), merge(mq.dependencies));
+/** Gathers all devDependencies required for the project based on the initializer,
+* key-value store, and message queue configurations, including Biome for linting/formatting.
+*
+* @param data - Web Framework initializer, key-value store and message queue descriptions
+* @returns A record of devDependencies with their versions
+*/
+const getDevDependencies = ({ initializer, kv, mq }) => pipe({ "@biomejs/biome": "^2.2.4" }, merge(initializer.devDependencies), merge(kv.devDependencies), merge(mq.devDependencies));
+/**
+* Generates the command-line arguments needed to add dependencies or devDependencies
+* using the specified package manager.
+* If it is devDependencies, the '-D' flag is included.
+*
+* @param param0 - Object containing the package manager and a boolean indicating if dev dependencies are to be added
+* @yields The command-line arguments as strings
+*/
+function* getAddDepsArgs({ packageManager, dev = false }) {
+	yield packageManager;
+	yield "add";
+	if (dev) yield "-D";
+}
+/**
+* Joins package names with their versions for installation commands.
+* For Deno, it prefixes packages with 'jsr:' unless they already start with 'npm:'.
+*
+* @param data - Package manager and dependencies to be joined with versions
+* @returns `${registry}:${package}@${version}`[] for deno or `${package}@${version}`[] for others
+*/
+const joinDepsVer = ({ packageManager: pm, dependencies }) => pipe(dependencies, entries, map(([name, version]) => `${getPackageName(pm, name)}@${getPackageVersion(pm, version)}`), toArray);
+const getPackageName = (pm, name) => pm !== "deno" ? name : name.startsWith("npm:") ? name.substring(4) : !name.startsWith("npm:") ? `jsr:${name}` : name;
+const getPackageVersion = (pm, version) => pm !== "deno" && version.includes("+") ? version.substring(0, version.indexOf("+")) : version;
+
+//#endregion
+export { getAddDepsArgs, getDependencies, getDevDependencies, joinDepsVer };

package/dist/init/action/dir.js

@@ -0,0 +1,16 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+    
+import { mkdir } from "node:fs/promises";
+
+//#region src/init/action/dir.ts
+/**
+* Creates the target directory if it does not exist.
+*
+* @param data - The directory
+* @returns A promise that resolves when the directory is created
+*/
+const makeDirIfHyd = ({ dir }) => mkdir(dir, { recursive: true });
+
+//#endregion
+export { makeDirIfHyd };

package/dist/init/action/env.js

@@ -0,0 +1,13 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+    
+import { notEmpty } from "../../utils.js";
+import { noticeConfigEnv, noticeEnvKeyValue } from "./notice.js";
+import { entries, forEach, pipeLazy, tap, toArray, when } from "@fxts/core";
+
+//#region src/init/action/env.ts
+const recommendConfigEnv = pipeLazy((data) => data.env, entries, toArray, when(notEmpty, tap(noticeConfigEnv)), forEach(noticeEnvKeyValue));
+var env_default = recommendConfigEnv;
+
+//#endregion
+export { env_default as default };

package/dist/init/action/install.js

@@ -0,0 +1,22 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+    
+import { notEmpty, runSubCommand, set } from "../../utils.js";
+import { noticeErrorWhileAddDeps } from "./notice.js";
+import { getAddDepsArgs, getDependencies, getDevDependencies, joinDepsVer } from "./deps.js";
+import { isDeno } from "./utils.js";
+import { always, concat, pipe, tap, toArray, unless, when } from "@fxts/core";
+
+//#region src/init/action/install.ts
+const installDependencies = (data) => pipe(data, tap(installDeps), unless(isDeno, tap(installDevDeps)));
+var install_default = installDependencies;
+const installDeps = (data) => pipe(data, set("dependencies", getDependencies), getAddDepsCommand, when(notEmpty, runAddDeps(data)));
+const installDevDeps = (data) => pipe(data, set("dependencies", getDevDependencies), set("dev", always(true)), getAddDepsCommand, when(notEmpty, runAddDeps(data)));
+const getAddDepsCommand = (data) => pipe(data, joinDepsVer, when(notEmpty, concat(getAddDepsArgs(data))), toArray);
+const runAddDeps = ({ dir }) => (command) => runSubCommand(command, {
+	cwd: dir,
+	stdio: "inherit"
+}).catch(noticeErrorWhileAddDeps(command));
+
+//#endregion
+export { install_default as default };

package/dist/init/action/mod.js

@@ -0,0 +1,39 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+    
+import ask_default from "../ask/mod.js";
+import { makeDirIfHyd } from "./dir.js";
+import { drawDinosaur, noticeHowToRun, noticeOptions, noticePrecommand } from "./notice.js";
+import env_default from "./env.js";
+import { hasCommand, isDry } from "./utils.js";
+import install_default from "./install.js";
+import { patchFiles, recommendPatchFiles } from "./patch.js";
+import precommand_default from "./precommand.js";
+import recommend_default from "./recommend.js";
+import set_default from "./set.js";
+import { pipe, tap, unless, when } from "@fxts/core";
+
+//#region src/init/action/mod.ts
+/**
+*             options: InitCommand
+*                ├ drawDinosaur
+*          ┌─────┴──────┐
+*          │ askOptions │ InitCommand -> InitCommandOptions
+*          └─────┬──────┘
+*                ├ noticeOptions
+*           ┌────┴────┐
+*           │ setData │ InitCommandOptions -> InitCommandData
+*           └────┬────┘
+*              ┌─┴─┐ isDry
+* handleDryRun ┤   ├ handleHydRun
+*              └─┬─┘
+*                ├ recommendConfigEnv
+*                ├ noticeHowToRun
+*/
+const runInit = (options) => pipe(options, tap(drawDinosaur), ask_default, tap(noticeOptions), set_default, when(isDry, handleDryRun), unless(isDry, handleHydRun), tap(env_default), tap(noticeHowToRun));
+var action_default = runInit;
+const handleDryRun = (data) => pipe(data, tap(when(hasCommand, noticePrecommand)), tap(recommendPatchFiles), tap(recommend_default));
+const handleHydRun = (data) => pipe(data, tap(makeDirIfHyd), tap(when(hasCommand, precommand_default)), tap(patchFiles), tap(install_default));
+
+//#endregion
+export { action_default as default };

package/dist/init/action/notice.js

@@ -0,0 +1,62 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+    
+import { colors } from "../../utils.js";
+import { message } from "@optique/core";
+import { print, printError } from "@optique/run";
+import { flow } from "es-toolkit";
+
+//#region src/init/action/notice.ts
+const printMessage = flow(message, print);
+const printErrorMessage = flow(message, printError);
+function drawDinosaur() {
+	const d = flow(colors.bgBlue, colors.black);
+	const f = colors.blue;
+	console.error(`\
+${d("             ___   ")}  ${f(" _____        _ _  __")}
+${d("            /'_')  ")}  ${f("|  ___|__  __| (_)/ _|_   _")}
+${d("     .-^^^-/  /    ")}  ${f("| |_ / _ \\/ _` | | |_| | | |")}
+${d("   __/       /     ")}  ${f("|  _|  __/ (_| | |  _| |_| |")}
+${d("  <__.|_|-|_|      ")}  ${f("|_|  \\___|\\__,_|_|_|  \\__, |")}
+${d("                   ")}  ${f("                      |___/")}
+`);
+}
+const noticeOptions = ({ packageManager, webFramework, kvStore, messageQueue }) => printMessage`
+  Package manager: ${packageManager};
+  Web framework: ${webFramework};
+  Key–value store: ${kvStore};
+  Message queue: ${messageQueue};
+`;
+function noticePrecommand({ initializer: { command: command$1 }, dir }) {
+	printMessage`📦 Would run command:`;
+	printMessage`  cd ${dir}`;
+	printMessage`  ${command$1.join(" ")}\n`;
+}
+const noticeFilesToCreate = () => printMessage`📄 Would create files:\n`;
+const noticeFilesToInsert = () => printMessage`Would create/update JSON files:\n`;
+const noticeDepsIfExist = () => printMessage`📦 Would install dependencies:`;
+const noticeDevDepsIfExist = () => printMessage`📦 Would install dev dependencies:`;
+const noticeDeps = ([name, version]) => printMessage`${name}@${version}`;
+function displayFile(path$1, content, emoji = "📄") {
+	printMessage`${emoji} ${path$1}`;
+	printMessage`${"─".repeat(60)}`;
+	printMessage`${content}`;
+	printMessage`${"─".repeat(60)}\n`;
+}
+const noticeConfigEnv = () => printMessage`Note that you probably want to edit the ${".env"} file.
+It currently contains the following values:\n`;
+const noticeEnvKeyValue = ([key, value]) => printMessage`  ${key}=${value}`;
+function noticeHowToRun({ initializer: { instruction, federationFile } }) {
+	printMessage`${instruction}`;
+	printMessage`Start by editing the ${federationFile} file to define your federation!
+`;
+}
+function noticeErrorWhileAddDeps(command$1) {
+	return (error) => {
+		printErrorMessage`The command ${command$1.join(" ")} failed with the error: ${String(error)}`;
+		throw new Error("Failed to add dependencies.");
+	};
+}
+
+//#endregion
+export { displayFile, drawDinosaur, noticeConfigEnv, noticeDeps, noticeDepsIfExist, noticeDevDepsIfExist, noticeEnvKeyValue, noticeErrorWhileAddDeps, noticeFilesToCreate, noticeFilesToInsert, noticeHowToRun, noticeOptions, noticePrecommand };