@fedify/cli 2.0.0-pr.474.1879 → 2.0.0-pr.479.1900

package/dist/mod.js

@@ -7,7 +7,8 @@ import command_default from "./generate-vocab/command.js";
 import "./generate-vocab/mod.js";
 import { inboxCommand, runInbox } from "./inbox.js";
 import action_default from "./init/action/mod.js";
-import { initCommand } from "./init/command.js";
+import { initCommand, testInitCommand } from "./init/command.js";
+import action_default$1 from "./init/test/action.js";
 import "./init/mod.js";
 import { nodeInfoCommand, runNodeInfo } from "./nodeinfo.js";
 import { lookupCommand, runLookup } from "./lookup.js";
@@ -19,7 +20,7 @@ import { or } from "@optique/core";
 import { run } from "@optique/run";
 
 //#region src/mod.ts
-const command$1 = or(initCommand, webFingerCommand, lookupCommand, inboxCommand, nodeInfoCommand, tunnelCommand, command_default);
+const command$1 = or(initCommand, webFingerCommand, lookupCommand, inboxCommand, nodeInfoCommand, tunnelCommand, command_default, testInitCommand);
 async function main() {
 	const result = run(command$1, {
 		programName: "fedify",
@@ -32,6 +33,7 @@ async function main() {
 	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);
 }
 await main();
 

package/dist/nodeinfo.js

@@ -3,7 +3,7 @@
     
 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 { argument, command, constant, flag, merge, message, object, option, optional, or, string, text } from "@optique/core";
 import { print, printError } from "@optique/run";
 import process from "node:process";
 import { getNodeInfo } from "@fedify/fedify";
@@ -58,7 +58,7 @@ async function runNodeInfo(command$1) {
 			process.exit(1);
 		}
 		spinner.succeed("NodeInfo document fetched.");
-		console.log(formatObject(nodeInfo$1, void 0, true));
+		print(message`${text(formatObject(nodeInfo$1, void 0, true))}`);
 		return;
 	}
 	const nodeInfo = await getNodeInfo(url, {
@@ -153,15 +153,15 @@ async function runNodeInfo(command$1) {
 	}
 	console.log(layout.join("\n"));
 }
-function indent(text, depth) {
-	return text.replace(/\n/g, "\n" + " ".repeat(depth));
+function indent(text$1, depth) {
+	return text$1.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 text$1 = await response.text();
+	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;

package/dist/utils.js

@@ -2,12 +2,14 @@
       import { Temporal } from "@js-temporal/polyfill";
     
 import { writeFile } from "node:fs/promises";
+import { message } from "@optique/core";
+import { print, printError } from "@optique/run";
 import process from "node:process";
 import util from "node:util";
 import { isObject } from "@fxts/core";
 import { Chalk } from "chalk";
 import { highlight } from "cli-highlight";
-import { toMerged } from "es-toolkit";
+import { flow, toMerged } from "es-toolkit";
 import { spawn } from "node:child_process";
 
 //#region src/utils.ts
@@ -34,34 +36,99 @@ function set(key, f) {
 		};
 	};
 }
-const merge = (source = {}) => (target = {}) => toMerged(target, source);
+const merge$1 = (source = {}) => (target = {}) => toMerged(target, source);
 const isNotFoundError = (e) => isObject(e) && "code" in e && e.code === "ENOENT";
-const runSubCommand = (command, options) => new Promise((resolve, reject) => {
-	const child = spawn(command[0], command.slice(1), options);
+var CommandError = class extends Error {
+	commandLine;
+	constructor(message$1, stdout, stderr, code, command$1) {
+		super(message$1);
+		this.stdout = stdout;
+		this.stderr = stderr;
+		this.code = code;
+		this.command = command$1;
+		this.name = "CommandError";
+		this.commandLine = command$1.join(" ");
+	}
+};
+const runSubCommand = async (command$1, options) => {
+	const commands = command$1.reduce((acc, cur) => {
+		if (cur === "&&") acc.push([]);
+		else {
+			if (acc.length === 0) acc.push([]);
+			acc[acc.length - 1].push(cur);
+		}
+		return acc;
+	}, []);
+	const results = {
+		stdout: "",
+		stderr: ""
+	};
+	for (const cmd of commands) try {
+		const result = await runSingularCommand(cmd, options);
+		results.stdout += (results.stdout ? "\n" : "") + result.stdout;
+		results.stderr += (results.stderr ? "\n" : "") + result.stderr;
+	} catch (e) {
+		if (e instanceof CommandError) {
+			results.stdout += (results.stdout ? "\n" : "") + e.stdout;
+			results.stderr += (results.stderr ? "\n" : "") + e.stderr;
+		}
+		throw e;
+	}
+	return results;
+};
+const runSingularCommand = (command$1, options) => new Promise((resolve, reject) => {
 	let stdout = "";
 	let stderr = "";
+	const child = spawn(command$1[0], command$1.slice(1), options);
 	child.stdout?.on("data", (data) => {
 		stdout += data.toString();
 	});
 	child.stderr?.on("data", (data) => {
 		stderr += data.toString();
 	});
-	child.on("close", () => {
-		resolve({
+	child.on("close", (code) => {
+		if (code === 0) resolve({
 			stdout: stdout.trim(),
 			stderr: stderr.trim()
 		});
+		else reject(new CommandError(`Command exited with code ${code ?? "unknown"}`, stdout.trim(), stderr.trim(), code ?? -1, command$1));
 	});
 	child.on("error", (error) => {
 		reject(error);
 	});
 });
 const getCwd = () => process.cwd();
-const replace = (pattern, replacement) => (text) => text.replace(pattern, replacement);
+const replace = (pattern, replacement) => (text$1) => text$1.replace(pattern, replacement);
+const replaceAll = (pattern, replacement) => (text$1) => text$1.replaceAll(pattern, replacement);
 const getOsType = () => process.platform;
 const formatJson = (obj) => JSON.stringify(obj, null, 2) + "\n";
 const notEmpty = (s) => s.length > 0;
 const exit = (code) => process.exit(code);
+/**
+* ```haskell
+* product::[[a], [b], ...] -> [[a, b, ...]]
+* ```
+*
+* Cartesian product of the input iterables.
+* Inspired by Python's `itertools.product`.
+*
+* @param {...Iterable<unknown>} iters - The input iterables to compute the Cartesian product.
+* @returns {Generator<ItersItems<T>>} A generator that yields arrays containing one element from each iterable.
+*
+* @example
+* ```ts
+* const iter1 = [1, 2];
+* const iter2 = ['a', 'b'];
+* const iter3 = [true, false];
+* const productIter = product(iter1, iter2, iter3);
+* console.log(Array.from(productIter)); // Output: [[1, 'a', true], [1, 'a', false], [
+*/
+function* product(...[head, ...tail]) {
+	if (!head) yield [];
+	else for (const x of head) for (const xs of product(...tail)) yield [x, ...xs];
+}
+const printMessage = flow(message, print);
+const printErrorMessage = flow(message, printError);
 
 //#endregion
-export { colorEnabled, colors, exit, formatJson, formatObject, getCwd, getOsType, isNotFoundError, merge, notEmpty, replace, runSubCommand, set };
+export { CommandError, colorEnabled, colors, exit, formatJson, formatObject, getCwd, getOsType, isNotFoundError, merge$1 as merge, notEmpty, printErrorMessage, printMessage, product, replace, replaceAll, runSubCommand, set };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fedify/cli",
-  "version": "2.0.0-pr.474.1879+be9e2989",
+  "version": "2.0.0-pr.479.1900+0b40bf02",
   "description": "CLI toolchain for Fedify and debugging ActivityPub",
   "keywords": [
     "fedify",
@@ -71,10 +71,10 @@
     "ora": "^8.2.0",
     "shiki": "^1.6.4",
     "srvx": "^0.8.7",
-    "@fedify/fedify": "2.0.0-pr.474.1879+be9e2989",
-    "@fedify/vocab-runtime": "2.0.0-pr.474.1879+be9e2989",
-    "@fedify/vocab-tools": "2.0.0-pr.474.1879+be9e2989",
-    "@fedify/sqlite": "2.0.0-pr.474.1879+be9e2989"
+    "@fedify/sqlite": "2.0.0-pr.479.1900+0b40bf02",
+    "@fedify/fedify": "2.0.0-pr.479.1900+0b40bf02",
+    "@fedify/vocab-tools": "2.0.0-pr.479.1900+0b40bf02",
+    "@fedify/vocab-runtime": "2.0.0-pr.479.1900+0b40bf02"
   },
   "devDependencies": {
     "@types/bun": "^1.2.23",

package/src/inbox.tsx

@@ -103,14 +103,6 @@ export const inboxCommand = command(
         }),
         "An ephemeral ActivityPub inbox for testing purposes.",
       ),
-      authorizedFetch: option(
-        "-A",
-        "--authorized-fetch",
-        {
-          description:
-            message`Require HTTP Signatures for all incoming requests. Returns 401 for unsigned requests.`,
-        },
-      ),
     }),
     debugOption,
   ),
@@ -127,7 +119,6 @@ export async function runInbox(
   const fetch = createFetchHandler({
     actorName: command.actorName,
     actorSummary: command.actorSummary,
-    requireHttpSignature: command.authorizedFetch,
   });
   const sendDeleteToPeers = createSendDeleteToPeers({
     actorName: command.actorName,
@@ -508,11 +499,7 @@ app.get("/r/:idx{[0-9]+}", (c) => {
 });
 
 function createFetchHandler(
-  actorOptions: {
-    actorName: string;
-    actorSummary: string;
-    requireHttpSignature?: boolean;
-  },
+  actorOptions: { actorName: string; actorSummary: string },
 ): (request: Request) => Promise<Response> {
   return async function fetch(request: Request): Promise<Response> {
     const timestamp = Temporal.Now.instant();
@@ -534,7 +521,6 @@ function createFetchHandler(
         actorName: actorOptions.actorName,
         actorSummary: actorOptions.actorSummary,
       },
-      requireHttpSignature: actorOptions.requireHttpSignature,
       onNotAcceptable: app.fetch.bind(app),
       onNotFound: app.fetch.bind(app),
       onUnauthorized: app.fetch.bind(app),

package/src/init/action/configs.ts

@@ -1,4 +1,15 @@
-import { join as joinPath } from "node:path";
+import {
+  concat,
+  filter,
+  keys,
+  map,
+  pick,
+  pipe,
+  toArray,
+} from "@fxts/core/index.js";
+import { uniq } from "es-toolkit";
+import { join as joinPath, relative } from "node:path";
+import { merge } from "../../utils.ts";
 import biome from "../json/biome.json" with { type: "json" };
 import vscodeSettingsForDeno from "../json/vscode-settings-for-deno.json" with {
   type: "json",
@@ -7,6 +18,8 @@ import vscodeSettings from "../json/vscode-settings.json" with {
   type: "json",
 };
 import type { InitCommandData } from "../types.ts";
+import { PACKAGES_PATH } from "./const.ts";
+import { getDependencies, getDevDependencies, joinDepsReg } from "./deps.ts";
 
 /**
  * Loads Deno configuration object with compiler options, unstable features, and tasks.
@@ -16,20 +29,46 @@ import type { InitCommandData } from "../types.ts";
  * @returns Configuration object with path and Deno-specific settings
  */
 export const loadDenoConfig = (
-  { kv, mq, initializer, dir }: InitCommandData,
+  data: InitCommandData,
 ) => ({
-  path: joinPath(dir, "deno.json"),
+  path: "deno.json",
   data: {
-    compilerOptions: initializer.compilerOptions,
+    ...pick(["compilerOptions", "tasks"], data.initializer),
+    unstable: getUnstable(data),
+    nodeModulesDir: "auto",
+    imports: joinDepsReg("deno")(getDependencies(data)),
+    ...(data.testMode ? { links: getLinks(data) } : {}),
   },
-  unstable: [
-    "temporal",
-    ...kv.denoUnstable ?? [],
-    ...mq.denoUnstable ?? [],
-  ],
-  tasks: initializer.tasks,
 });
 
+const getUnstable = <T extends Pick<InitCommandData, "kv" | "mq">>({
+  kv: { denoUnstable: kv = [] },
+  mq: { denoUnstable: mq = [] },
+}: T) =>
+  pipe(
+    ["temporal"],
+    concat(kv),
+    concat(mq),
+    toArray,
+    uniq,
+  );
+
+const getLinks = <
+  T extends Pick<InitCommandData, "kv" | "mq" | "initializer" | "dir">,
+>({ kv, mq, initializer, dir }: T) =>
+  pipe(
+    { "@fedify/fedify": "" },
+    merge(initializer.dependencies),
+    merge(kv.dependencies),
+    merge(mq.dependencies),
+    keys,
+    filter((dep) => dep.includes("@fedify/")),
+    map((dep) => dep.replace("@fedify/", "")),
+    map((dep) => joinPath(PACKAGES_PATH, dep)),
+    map((absolutePath) => relative(dir, absolutePath)),
+    toArray,
+  );
+
 /**
  * Loads TypeScript configuration object for Node.js/Bun projects.
  * Uses compiler options from the framework initializer.
@@ -51,11 +90,15 @@ export const loadTsConfig = ({ initializer, dir }: InitCommandData) => ({
  * @param param0 - Destructured initialization data containing initializer and directory
  * @returns Configuration object with path and package.json settings
  */
-export const loadPackageJson = ({ initializer, dir }: InitCommandData) => ({
-  path: joinPath(dir, "package.json"),
+export const loadPackageJson = (
+  data: InitCommandData,
+) => ({
+  path: "package.json",
   data: {
     type: "module",
-    scripts: initializer.tasks,
+    scripts: data.initializer.tasks,
+    dependencies: getDependencies(data),
+    devDependencies: getDevDependencies(data),
   },
 });
 

package/src/init/action/const.ts

@@ -0,0 +1,9 @@
+import { join as joinPath } from "node:path";
+
+export const PACKAGES_PATH = joinPath(
+  import.meta.dirname!, // action
+  "..", // init
+  "..", // src
+  "..", // cli
+  "..", // packages
+);

package/src/init/action/deps.ts

@@ -1,7 +1,18 @@
-import { entries, map, pipe, toArray } from "@fxts/core";
-import { merge } from "../../utils.ts";
+import {
+  always,
+  entries,
+  filter,
+  fromEntries,
+  map,
+  pipe,
+  when,
+} from "@fxts/core";
+import { join as joinPath } from "node:path";
+import { merge, replace } from "../../utils.ts";
 import { PACKAGE_VERSION } from "../lib.ts";
 import type { InitCommandData, PackageManager } from "../types.ts";
+import { PACKAGES_PATH } from "./const.ts";
+import { isDeno } from "./utils.ts";
 
 type Deps = Record<string, string>;
 
@@ -9,11 +20,15 @@ type Deps = Record<string, string>;
  * 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
+ * @param data - Web Framework initializer, key-value store and
+ *               message queue descriptions
  * @returns A record of dependencies with their versions
  */
 export const getDependencies = (
-  { initializer, kv, mq }: InitCommandData,
+  { initializer, kv, mq, testMode, packageManager }: Pick<
+    InitCommandData,
+    "initializer" | "kv" | "mq" | "packageManager" | "testMode"
+  >,
 ): Deps =>
   pipe(
     {
@@ -23,16 +38,54 @@ export const getDependencies = (
     merge(initializer.dependencies),
     merge(kv.dependencies),
     merge(mq.dependencies),
+    when(
+      always(testMode),
+      isDeno({ packageManager }) ? removeFedifyDeps : addLocalFedifyDeps,
+    ),
+    normalizePackageNames(packageManager),
   );
 
-/** Gathers all devDependencies required for the project based on the initializer,
- * key-value store, and message queue configurations, including Biome for linting/formatting.
+const removeFedifyDeps = (deps: Deps): Deps =>
+  pipe(
+    deps,
+    entries,
+    filter(([name]) => !name.includes("@fedify")),
+    fromEntries,
+  );
+
+const addLocalFedifyDeps = (deps: Deps): Deps =>
+  pipe(
+    deps,
+    entries,
+    map(when(
+      ([name]) => name.includes("@fedify/"),
+      (
+        [name, _version],
+      ): [string, string] => [name, convertFedifyToLocal(name)],
+    )),
+    fromEntries,
+  );
+
+const convertFedifyToLocal = (name: string): string =>
+  pipe(
+    name,
+    replace("@fedify/", ""),
+    (pkg) => joinPath(PACKAGES_PATH, pkg),
+  );
+
+/** 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
+ * @param data - Web Framework initializer, key-value store
+ *               and message queue descriptions
  * @returns A record of devDependencies with their versions
  */
 export const getDevDependencies = (
-  { initializer, kv, mq }: InitCommandData,
+  { initializer, kv, mq, packageManager }: Pick<
+    InitCommandData,
+    "initializer" | "kv" | "mq" | "packageManager"
+  >,
 ): Deps =>
   pipe(
     {
@@ -41,14 +94,16 @@ export const getDevDependencies = (
     merge(initializer.devDependencies),
     merge(kv.devDependencies),
     merge(mq.devDependencies),
+    normalizePackageNames(packageManager),
   );
 
 /**
- * Generates the command-line arguments needed to add dependencies or devDependencies
- * using the specified package manager.
+ * 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
+ * @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
  */
 export function* getAddDepsArgs<
@@ -60,34 +115,47 @@ export function* getAddDepsArgs<
 }
 
 /**
- * Joins package names with their versions for installation commands.
- * For Deno, it prefixes packages with 'jsr:' unless they already start with 'npm:'.
+ * Joins package names with their versions for installation dependencies.
+ * For Deno, it prefixes packages with 'jsr:'
+ * unless they already start with 'npm:' or 'jsr:'.
  *
  * @param data - Package manager and dependencies to be joined with versions
- * @returns `${registry}:${package}@${version}`[] for deno or `${package}@${version}`[] for others
+ * @returns \{ name: `${registry}:${package}@${version}` } for deno
  */
-export const joinDepsVer = <
-  T extends { packageManager: PackageManager; dependencies: Deps },
->({ packageManager: pm, dependencies }: T): string[] =>
+export const joinDepsReg = (pm: PackageManager) => //
+(dependencies: Deps): Deps =>
   pipe(
     dependencies,
     entries,
-    map(([name, version]) =>
-      `${getPackageName(pm, name)}@${getPackageVersion(pm, version)}`
-    ),
-    toArray,
+    map(([name, version]): [string, string] => [
+      name.substring(4),
+      `${name}@${getPackageVersion(pm, version)}`,
+    ]),
+    fromEntries,
   );
 
-const getPackageName = (pm: PackageManager, name: string) =>
-  pm !== "deno"
-    ? name
-    : name.startsWith("npm:")
-    ? name.substring(4)
-    : !name.startsWith("npm:")
-    ? `jsr:${name}`
-    : name;
-
 const getPackageVersion = (pm: PackageManager, version: string) =>
   pm !== "deno" && version.includes("+")
     ? version.substring(0, version.indexOf("+"))
     : version;
+
+const normalizePackageNames = (pm: PackageManager) => (deps: Deps): Deps =>
+  pipe(
+    deps,
+    entries,
+    map(([name, version]): [string, string] => [
+      getPackageName(pm, name),
+      version,
+    ]),
+    fromEntries,
+  );
+
+const getPackageName = (pm: PackageManager, name: string) =>
+  pm !== "deno"
+    ? name.startsWith("npm:")
+      ? name.replace("npm:", "") // not deno, have npm: prefix, remove it
+      : name // not deno, no prefix, keep it
+    : name.startsWith("npm:")
+    ? name // deno, have npm: prefix, keep it
+    : `jsr:${name}` // deno, no prefix, add jsr: prefix
+;

package/src/init/action/install.ts

@@ -1,59 +1,24 @@
-import { always, concat, pipe, tap, toArray, unless, when } from "@fxts/core";
-import { notEmpty, runSubCommand, set } from "../../utils.ts";
+import { apply, pipe } from "@fxts/core";
+import { CommandError, runSubCommand } from "../../utils.ts";
 import type { InitCommandData } from "../types.ts";
-import {
-  getAddDepsArgs,
-  getDependencies,
-  getDevDependencies,
-  joinDepsVer,
-} from "./deps.ts";
-import { noticeErrorWhileAddDeps } from "./notice.ts";
-import { isDeno } from "./utils.ts";
 
 const installDependencies = (data: InitCommandData) =>
   pipe(
     data,
-    tap(installDeps),
-    unless(isDeno, tap(installDevDeps)),
-  );
+    ({ packageManager, dir }) =>
+      [[packageManager, "install"], { cwd: dir }] as //
+      Parameters<typeof runSubCommand>,
+    apply(runSubCommand),
+  ).catch((e) => {
+    if (e instanceof CommandError) {
+      console.error(
+        `Failed to install dependencies using ${data.packageManager}.`,
+      );
+      console.error("Command:", e.commandLine);
+      if (e.stderr) console.error("Error:", e.stderr);
+      throw e;
+    }
+    throw e;
+  });
 
 export default installDependencies;
-
-type Deps = Record<string, string>;
-
-const installDeps = (data: InitCommandData) =>
-  pipe(
-    data,
-    set("dependencies", getDependencies),
-    getAddDepsCommand,
-    when(notEmpty, runAddDeps(data)),
-  );
-
-const installDevDeps = (data: InitCommandData) =>
-  pipe(
-    data,
-    set("dependencies", getDevDependencies),
-    set("dev", always(true)),
-    getAddDepsCommand,
-    when(notEmpty, runAddDeps(data)),
-  );
-
-const getAddDepsCommand = <
-  T extends InitCommandData & {
-    dependencies: Deps;
-    dev?: boolean;
-  },
->(data: T) =>
-  pipe(
-    data,
-    joinDepsVer,
-    when(notEmpty<string[]>, concat(getAddDepsArgs(data))),
-    toArray,
-  );
-
-const runAddDeps =
-  <T extends { dir: string }>({ dir }: T) => (command: string[]) =>
-    runSubCommand(command, {
-      cwd: dir,
-      stdio: "inherit",
-    }).catch(noticeErrorWhileAddDeps(command));

package/src/init/action/notice.ts

@@ -1,14 +1,14 @@
-import { message } from "@optique/core";
-import { print, printError } from "@optique/run";
+import { text } from "@optique/core";
 import { flow } from "es-toolkit";
-import { colors, type RequiredNotNull } from "../../utils.ts";
+import {
+  colors,
+  printErrorMessage,
+  printMessage,
+  type RequiredNotNull,
+} from "../../utils.ts";
 import type { InitCommand } from "../command.ts";
 import type { InitCommandData } from "../types.ts";
 
-type PrintMessage = (...args: Parameters<typeof message>) => void;
-const printMessage: PrintMessage = flow(message, print);
-const printErrorMessage: PrintMessage = flow(message, printError);
-
 export function drawDinosaur() {
   const d = flow(colors.bgBlue, colors.black);
   const f = colors.blue;
@@ -80,16 +80,18 @@ export const noticeConfigEnv = () =>
   printMessage`Note that you probably want to edit the ${".env"} file.
 It currently contains the following values:\n`;
 
-export const noticeEnvKeyValue = ([key, value]: [string, string]) =>
-  printMessage`  ${key}=${value}`;
+export const noticeEnvKeyValue = ([key, value]: [string, string]) => {
+  printMessage`${text(`  ${key}='${value}'`)}`;
+};
 
-export function noticeHowToRun(
+export const noticeHowToRun = (
   { initializer: { instruction, federationFile } }: InitCommandData,
-) {
-  printMessage`${instruction}`;
-  printMessage`Start by editing the ${federationFile} file to define your federation!
+) =>
+  printMessage`
+${instruction}
+    
+Start by editing the ${text(federationFile)} file to define your federation!
 `;
-}
 
 export function noticeErrorWhileAddDeps(command: string[]) {
   return (error: unknown) => {