@fedify/init 2.2.0-pr.715.28 → 2.2.0-pr.731.34

package/README.md

@@ -25,7 +25,8 @@ Supported options
 
 The initializer supports the following project configurations:
 
- -  **Web frameworks**: Bare-bones, [Hono], [Nitro], [Next.js], [Elysia], [Express]
+ -  **Web frameworks**: Bare-bones, [Hono], [Nitro], [Next.js], [Elysia],
+    [Express]
  -  **Package managers**: Deno, pnpm, Bun, Yarn, npm
  -  **Key-value stores**: In-Memory, Deno KV, Redis, PostgreSQL
  -  **Message queues**: In-Process, Deno KV, Redis, PostgreSQL, AMQP

package/dist/action/mod.js

@@ -4,7 +4,7 @@ import { makeDirIfHyd } from "./dir.js";
 import { drawDinosaur, noticeHowToRun, noticeOptions, noticePrecommand } from "./notice.js";
 import recommendConfigEnv from "./env.js";
 import { hasCommand, installDependencies, isDry, runPrecommand } from "./utils.js";
-import { patchFiles, recommendPatchFiles } from "./patch.js";
+import { assertNoGeneratedFileConflicts, patchFiles, recommendPatchFiles } from "./patch.js";
 import recommendDependencies from "./recommend.js";
 import setData from "./set.js";
 import { pipe, tap, unless, when } from "@fxts/core";
@@ -28,6 +28,6 @@ import process from "node:process";
 const runInit = (options) => pipe(options, tap(drawDinosaur), setTestMode, askOptions, tap(noticeOptions), setData, when(isDry, handleDryRun), unless(isDry, handleHydRun), tap(recommendConfigEnv), tap(noticeHowToRun));
 const setTestMode = set("testMode", () => Boolean(process.env["FEDIFY_TEST_MODE"]));
 const handleDryRun = (data) => pipe(data, tap(when(hasCommand, noticePrecommand)), tap(recommendPatchFiles), tap(recommendDependencies));
-const handleHydRun = (data) => pipe(data, tap(makeDirIfHyd), tap(when(hasCommand, runPrecommand)), tap(patchFiles), tap(installDependencies));
+const handleHydRun = (data) => pipe(data, tap(makeDirIfHyd), tap(assertNoGeneratedFileConflicts), tap(when(hasCommand, runPrecommand)), tap(patchFiles), tap(installDependencies));
 //#endregion
 export { runInit as default };

package/dist/action/patch.js

@@ -6,8 +6,33 @@ import { devToolConfigs, loadDenoConfig, loadPackageJson, loadTsConfig } from ".
 import { getImports, loadFederation, loadLogging } from "./templates.js";
 import { always, apply, entries, map, pipe, pipeLazy, tap } from "@fxts/core";
 import { toMerged } from "es-toolkit";
-import { readFile } from "node:fs/promises";
+import { access, readFile } from "node:fs/promises";
+import { join as join$1 } from "node:path";
 //#region src/action/patch.ts
+const jsonsCache = /* @__PURE__ */ new Map();
+const getJsonsCacheKey = (data) => JSON.stringify({
+	dir: data.dir,
+	packageManager: data.packageManager,
+	dryRun: data.dryRun,
+	testMode: data.testMode,
+	env: data.env,
+	initializer: {
+		compilerOptions: data.initializer.compilerOptions ?? {},
+		dependencies: data.initializer.dependencies ?? {},
+		devDependencies: data.initializer.devDependencies ?? {},
+		tasks: data.initializer.tasks ?? {}
+	},
+	kv: {
+		dependencies: data.kv.dependencies ?? {},
+		denoUnstable: data.kv.denoUnstable ?? [],
+		devDependencies: data.kv.devDependencies ?? {}
+	},
+	mq: {
+		dependencies: data.mq.dependencies ?? {},
+		denoUnstable: data.mq.denoUnstable ?? [],
+		devDependencies: data.mq.devDependencies ?? {}
+	}
+});
 /**
 * Main function that initializes the project by creating necessary files and configurations.
 * Handles both dry-run mode (recommending files) and actual file creation.
@@ -20,6 +45,24 @@ import { readFile } from "node:fs/promises";
 const patchFiles = (data) => pipe(data, set("files", getFiles), set("jsons", getJsons), createFiles);
 const recommendPatchFiles = (data) => pipe(data, set("files", getFiles), set("jsons", getJsons), recommendFiles);
 /**
+* Verifies that `--allow-non-empty` will not modify files that already
+* existed before any framework scaffolding command runs.  This only covers
+* files that Fedify writes itself; framework scaffolders may still reject
+* unrelated pre-existing files independently.
+*/
+async function assertNoGeneratedFileConflicts(data) {
+	if (!data.allowNonEmpty) return;
+	const conflicts = await getExistingGeneratedFiles(data);
+	if (conflicts.length > 0) throw new GeneratedFileConflictError(conflicts);
+}
+var GeneratedFileConflictError = class extends Error {
+	constructor(conflicts) {
+		super(formatConflictMessage(conflicts));
+		this.conflicts = conflicts;
+		this.name = "GeneratedFileConflictError";
+	}
+};
+/**
 * Generates text-based files (TypeScript, environment files) for the project.
 * Creates federation configuration, logging setup, environment variables, and
 * framework-specific files by processing templates and combining them with
@@ -46,17 +89,57 @@ const getFiles = async (data) => ({
 * @param data - The initialization command data
 * @returns A record of file paths to their JSON object content
 */
-const getJsons = (data) => data.packageManager === "deno" ? {
-	"deno.json": loadDenoConfig(data).data,
-	[devToolConfigs["vscSetDeno"].path]: devToolConfigs["vscSetDeno"].data,
-	[devToolConfigs["vscExtDeno"].path]: devToolConfigs["vscExtDeno"].data
-} : {
-	...data.initializer.compilerOptions ? { "tsconfig.json": loadTsConfig(data).data } : {},
-	"package.json": loadPackageJson(data).data,
-	[devToolConfigs["biome"].path]: devToolConfigs["biome"].data,
-	[devToolConfigs["vscSet"].path]: devToolConfigs["vscSet"].data,
-	[devToolConfigs["vscExt"].path]: devToolConfigs["vscExt"].data
+const getJsons = (data) => {
+	const cacheKey = getJsonsCacheKey(data);
+	const cached = jsonsCache.get(cacheKey);
+	if (cached != null) return cached;
+	const jsons = data.packageManager === "deno" ? {
+		"deno.json": loadDenoConfig(data).data,
+		[devToolConfigs["vscSetDeno"].path]: devToolConfigs["vscSetDeno"].data,
+		[devToolConfigs["vscExtDeno"].path]: devToolConfigs["vscExtDeno"].data
+	} : {
+		...data.initializer.compilerOptions ? { "tsconfig.json": loadTsConfig(data).data } : {},
+		"package.json": loadPackageJson(data).data,
+		[devToolConfigs["biome"].path]: devToolConfigs["biome"].data,
+		[devToolConfigs["vscSet"].path]: devToolConfigs["vscSet"].data,
+		[devToolConfigs["vscExt"].path]: devToolConfigs["vscExt"].data
+	};
+	jsonsCache.set(cacheKey, jsons);
+	return jsons;
+};
+/**
+* Returns only the file paths written directly by Fedify after any framework
+* scaffolding command finishes.  Files created by
+* `WebFrameworkInitializer.command` are intentionally excluded.
+*/
+const getGeneratedFilePaths = (data) => [
+	data.initializer.federationFile,
+	data.initializer.loggingFile,
+	".env",
+	...Object.keys(data.initializer.files ?? {}),
+	...Object.keys(getJsons(data))
+];
+const getExistingGeneratedFiles = async (data) => {
+	const paths = [...new Set(getGeneratedFilePaths(data))];
+	return (await Promise.all(paths.map(async (path) => {
+		return await pathExists(join$1(data.dir, path)) ? path : null;
+	}))).filter((path) => path != null);
+};
+const pathExists = async (path) => {
+	try {
+		await access(path);
+		return true;
+	} catch (e) {
+		throwUnlessNotExists(e);
+		return false;
+	}
 };
+const formatConflictMessage = (conflicts) => [
+	"Cannot initialize in a non-empty directory because these generated files",
+	"already exist:",
+	...conflicts.map((path) => ` - ${path}`),
+	"Remove the conflicting files or choose another directory."
+].join("\n");
 /**
 * Handles dry-run mode by recommending files to be created without actually
 * creating them.
@@ -138,4 +221,4 @@ const appendText = (prev, data) => prev ? `${prev}\n${data}` : data;
 */
 const readFileIfExists = (path) => readFile(path, "utf8").catch(pipeLazy(tap(throwUnlessNotExists), always("")));
 //#endregion
-export { patchFiles, recommendPatchFiles };
+export { assertNoGeneratedFileConflicts, patchFiles, recommendPatchFiles };

package/dist/action/templates.js

@@ -15,13 +15,19 @@ import { toMerged } from "es-toolkit";
 */
 const loadFederation = async ({ imports, projectName, kv, mq, packageManager }) => pipe(await readTemplate("defaults/federation.ts"), replace(/\/\* imports \*\//, imports), replace(/\/\* logger \*\//, JSON.stringify(projectName)), replace(/\/\* kv \*\//, convertEnv(kv.object, packageManager)), replace(/\/\* queue \*\//, convertEnv(mq.object, packageManager)));
 /**
-* Loads the logging configuration file content from template.
-* Reads the default logging template and replaces the project name placeholder.
+* Loads logging configuration file content for the initializer.
 *
-* @param param0 - Destructured object containing the project name
+* `loadLogging` accepts the full {@link InitCommandData} so it can read the
+* project name and the framework initializer.  It uses {@link readTemplate} to
+* read `initializer.loggingTemplate` when provided, or falls back to
+* *defaults/logging.ts*, then replaces the project name placeholder.
+*
+* @param param0 - {@link InitCommandData} containing `projectName` and
+*   `initializer`; `initializer.loggingTemplate` selects a framework-specific
+*   logging template when present.
 * @returns The complete logging configuration file content as a string
 */
-const loadLogging = async ({ projectName }) => pipe(await readTemplate("defaults/logging.ts"), replace(/\/\* project name \*\//, JSON.stringify(projectName)));
+const loadLogging = async ({ projectName, initializer }) => pipe(await readTemplate(initializer.loggingTemplate ?? "defaults/logging.ts"), replace(/\/\* project name \*\//, JSON.stringify(projectName)));
 /**
 * Generates import statements for KV store and message queue dependencies.
 * Merges imports from both KV and MQ configurations and creates proper

package/dist/ask/dir.js

@@ -18,6 +18,10 @@ import toggle from "inquirer-toggle";
 */
 const fillDir = async (options) => {
 	const dir = options.dir ?? await askDir(getCwd());
+	if (options.allowNonEmpty) return {
+		...options,
+		dir
+	};
 	return await askIfNonEmpty(dir) ? {
 		...options,
 		dir

package/dist/command.d.ts

@@ -5,7 +5,7 @@ import { InferValue } from "@optique/core";
 /**
  * The `@optique/core` option schema for the `fedify init` command.
  * Defines `dir`, `webFramework`, `packageManager`, `kvStore`, `messageQueue`,
- * and `dryRun` options that the CLI parser will accept.
+ * `dryRun`, and `allowNonEmpty` options that the CLI parser will accept.
  */
 declare const initOptions: _$_optique_core0.Parser<"sync", {
   readonly dir: string;
@@ -14,6 +14,7 @@ declare const initOptions: _$_optique_core0.Parser<"sync", {
   readonly kvStore: "postgres" | "mysql" | "in-memory" | "redis" | "denokv";
   readonly messageQueue: "postgres" | "mysql" | "redis" | "denokv" | "in-process" | "amqp";
   readonly dryRun: boolean;
+  readonly allowNonEmpty: boolean;
 }, {
   readonly dir: [_$_optique_core0.ValueParserResult<string>];
   readonly webFramework: [_$_optique_core0.ValueParserResult<"bare-bones" | "hono" | "nitro" | "next" | "elysia" | "astro" | "express" | "nuxt" | "solidstart">];
@@ -21,6 +22,7 @@ declare const initOptions: _$_optique_core0.Parser<"sync", {
   readonly kvStore: [_$_optique_core0.ValueParserResult<"postgres" | "mysql" | "in-memory" | "redis" | "denokv">];
   readonly messageQueue: [_$_optique_core0.ValueParserResult<"postgres" | "mysql" | "redis" | "denokv" | "in-process" | "amqp">];
   readonly dryRun: _$_optique_core0.ValueParserResult<boolean>;
+  readonly allowNonEmpty: _$_optique_core0.ValueParserResult<boolean>;
 }>;
 /**
  * The `fedify init` CLI command parser.
@@ -32,6 +34,7 @@ declare const initCommand: _$_optique_core0.Parser<"sync", {
   readonly kvStore: "postgres" | "mysql" | "in-memory" | "redis" | "denokv";
   readonly messageQueue: "postgres" | "mysql" | "redis" | "denokv" | "in-process" | "amqp";
   readonly dryRun: boolean;
+  readonly allowNonEmpty: boolean;
 } & {
   readonly command: "init";
 }, ["matched", string] | ["parsing", Record<string | symbol, unknown>]>;

package/dist/command.js

@@ -9,7 +9,7 @@ const messageQueue = optional(option("-m", "--message-queue", choice(MESSAGE_QUE
 /**
 * The `@optique/core` option schema for the `fedify init` command.
 * Defines `dir`, `webFramework`, `packageManager`, `kvStore`, `messageQueue`,
-* and `dryRun` options that the CLI parser will accept.
+* `dryRun`, and `allowNonEmpty` options that the CLI parser will accept.
 */
 const initOptions = object("Initialization options", {
 	dir: optional(argument(path({ metavar: "DIR" }), { description: message`The project directory to initialize.  If a specified directory does not exist, it will be created.` })),
@@ -17,7 +17,8 @@ const initOptions = object("Initialization options", {
 	packageManager,
 	kvStore,
 	messageQueue,
-	dryRun: option("--dry-run", { description: message`Perform a trial run with no changes made.` })
+	dryRun: option("--dry-run", { description: message`Perform a trial run with no changes made.` }),
+	allowNonEmpty: option("--allow-non-empty", { description: message`Allow initializing in a non-empty directory when the selected framework scaffolder supports it, failing if any generated file already exists.` })
 });
 /**
 * The `fedify init` CLI command parser.

package/dist/deno.js

@@ -1,4 +1,4 @@
 //#region deno.json
-var version = "2.2.0-pr.715.28+06979f5f";
+var version = "2.2.0-pr.731.34+1e1bb860";
 //#endregion
 export { version };

package/dist/json/biome.js

@@ -1,7 +1,10 @@
 //#region src/json/biome.json
 var biome_default = {
-	$schema: "https://biomejs.dev/schemas/1.8.3/schema.json",
-	organizeImports: { "enabled": true },
+	$schema: "https://biomejs.dev/schemas/2.4.9/schema.json",
+	assist: {
+		"enabled": true,
+		"actions": { "source": { "organizeImports": "on" } }
+	},
 	formatter: {
 		"enabled": true,
 		"indentStyle": "space",

package/dist/json/biome.json

@@ -1,7 +1,12 @@
 {
-  "$schema": "https://biomejs.dev/schemas/1.8.3/schema.json",
-  "organizeImports": {
-    "enabled": true
+  "$schema": "https://biomejs.dev/schemas/2.4.9/schema.json",
+  "assist": {
+    "enabled": true,
+    "actions": {
+      "source": {
+        "organizeImports": "on"
+      }
+    }
   },
   "formatter": {
     "enabled": true,

package/dist/lib.js

@@ -3,14 +3,14 @@ import kv_default from "./json/kv.js";
 import mq_default from "./json/mq.js";
 import pm_default from "./json/pm.js";
 import rt_default from "./json/rt.js";
-import { isNotFoundError } from "./utils.js";
+import { CommandError, isNotFoundError, runSubCommand } from "./utils.js";
 import { entries, evolve, fromEntries, isObject, map, negate, pipe, throwIf } from "@fxts/core";
 import process from "node:process";
 import $ from "@david/dax";
 import { getLogger } from "@logtape/logtape";
 import { toMerged } from "es-toolkit";
 import { readFileSync } from "node:fs";
-import { mkdir, readdir, writeFile } from "node:fs/promises";
+import { mkdir, readFile, readdir, stat, writeFile } from "node:fs/promises";
 import { dirname, join as join$1 } from "node:path";
 //#region src/lib.ts
 /** The current `@fedify/init` package version, read from *deno.json*. */
@@ -119,17 +119,161 @@ const isNotExistsError = (e) => isObject(e) && "code" in e && e.code === "ENOENT
 */
 const throwUnlessNotExists = throwIf(negate(isNotExistsError));
 /**
-* Checks whether a directory is empty or does not exist.
-* Returns `true` if the directory has no entries or does not exist yet.
+* Checks whether a directory is safe to initialize as an empty project.
+* Returns `true` if the directory does not exist, has no entries, or only
+* contains an unborn Git repository created by `git init`.
 */
 const isDirectoryEmpty = async (path) => {
 	try {
-		return (await readdir(path)).length === 0;
+		const files = await readdir(path);
+		if (files.length === 0) return true;
+		if (files.length === 1 && files[0] === ".git") return await isUnbornGitRepository(path);
+		return false;
 	} catch (e) {
 		throwUnlessNotExists(e);
 		return true;
 	}
 };
+const isUnbornGitRepository = async (path) => {
+	if (await hasGitHeadCommit(path)) return false;
+	return await looksLikeUnbornGitRepository(path);
+};
+const hasGitHeadCommit = async (path) => {
+	try {
+		await runSubCommand([
+			"git",
+			"-C",
+			path,
+			"rev-parse",
+			"--verify",
+			"HEAD^{commit}"
+		], {});
+		return true;
+	} catch (e) {
+		if (isNotFoundError(e) || e instanceof CommandError) return false;
+		logger.debug("Failed to resolve Git HEAD in {path}: {error}", {
+			path,
+			error: e
+		});
+		return false;
+	}
+};
+const looksLikeUnbornGitRepository = async (path) => {
+	const gitDir = join$1(path, ".git");
+	if (!await isDirectory(gitDir)) return false;
+	if (!await isDirectory(join$1(gitDir, "objects"))) return false;
+	if (!await isDirectory(join$1(gitDir, "refs"))) return false;
+	const head = await readGitFile(join$1(gitDir, "HEAD"));
+	if (head == null) return false;
+	if (!isValidHeadRef(head)) return false;
+	if (await hasAnyLooseRef(gitDir)) return false;
+	if (await hasAnyPackedRef(gitDir)) return false;
+	if (await hasAnyObjectFile(gitDir)) return false;
+	if (await hasAnyGitStatePath(gitDir)) return false;
+	return true;
+};
+const isValidHeadRef = (head) => {
+	const match = head.trim().match(/^ref: (refs\/heads\/\S+)$/);
+	if (match == null) return false;
+	return !match[1].includes("..");
+};
+const hasAnyLooseRef = async (gitDir) => await hasAnyFile(join$1(gitDir, "refs"), "Git refs");
+const hasAnyObjectFile = async (gitDir) => await hasAnyFile(join$1(gitDir, "objects"), "Git objects");
+const hasAnyFile = async (dir, description) => {
+	let entries;
+	try {
+		entries = await readdir(dir, { withFileTypes: true });
+	} catch (e) {
+		if (isNotFoundError(e)) return false;
+		logger.debug("Failed to read {description} in {path}: {error}", {
+			description,
+			path: dir,
+			error: e
+		});
+		return true;
+	}
+	for (const entry of entries) {
+		const path = join$1(dir, entry.name);
+		if (entry.isDirectory()) {
+			if (await hasAnyFile(path, description)) return true;
+		} else return true;
+	}
+	return false;
+};
+const GIT_STATE_PATHS = [
+	"AUTO_MERGE",
+	"BISECT_LOG",
+	"CHERRY_PICK_HEAD",
+	"FETCH_HEAD",
+	"MERGE_HEAD",
+	"MERGE_MODE",
+	"MERGE_MSG",
+	"ORIG_HEAD",
+	"REBASE_HEAD",
+	"REVERT_HEAD",
+	"SQUASH_MSG",
+	"index",
+	"logs",
+	"modules",
+	"rebase-apply",
+	"rebase-merge",
+	"sequencer",
+	"shallow",
+	"worktrees"
+];
+const hasAnyGitStatePath = async (gitDir) => {
+	for (const path of GIT_STATE_PATHS) if (await pathExists(join$1(gitDir, path))) return true;
+	return false;
+};
+const pathExists = async (path) => {
+	try {
+		await stat(path);
+		return true;
+	} catch (e) {
+		if (isNotFoundError(e)) return false;
+		logger.debug("Failed to stat Git state path {path}: {error}", {
+			path,
+			error: e
+		});
+		return true;
+	}
+};
+const hasAnyPackedRef = async (gitDir) => {
+	let packedRefs;
+	try {
+		packedRefs = await readFile(join$1(gitDir, "packed-refs"), "utf8");
+	} catch (e) {
+		if (isNotFoundError(e)) return false;
+		logger.debug("Failed to read Git packed refs in {path}: {error}", {
+			path: gitDir,
+			error: e
+		});
+		return true;
+	}
+	return packedRefs.split(/\r?\n/).some((line) => {
+		const trimmed = line.trim();
+		if (trimmed === "" || trimmed.startsWith("#") || trimmed.startsWith("^")) return false;
+		return true;
+	});
+};
+const readGitFile = async (path) => {
+	try {
+		return await readFile(path, "utf8");
+	} catch (e) {
+		if (!isNotFoundError(e)) logger.debug("Failed to read Git file {path}: {error}", {
+			path,
+			error: e
+		});
+		return null;
+	}
+};
+const isDirectory = async (path) => {
+	try {
+		return (await stat(path)).isDirectory();
+	} catch {
+		return false;
+	}
+};
 /** Returns `true` if the current run is in test mode. */
 const isTest = ({ testMode }) => testMode;
 //#endregion

package/dist/templates/astro/src/middleware.ts.tpl

@@ -1,3 +1,4 @@
+import "./logging.ts";
 import { fedifyMiddleware } from "@fedify/astro";
 import federation from "./federation.ts";
 

package/dist/templates/next/instrumentation.ts.tpl

@@ -0,0 +1,5 @@
+export async function register() {
+  if (process.env.NEXT_RUNTIME === "nodejs") {
+    await import("./logging");
+  }
+}

package/dist/templates/nitro/server/plugins/logging.ts.tpl

@@ -0,0 +1,3 @@
+import "../logging";
+
+export default function setupLogging() {}

package/dist/templates/nuxt/server/logging.ts.tpl

@@ -0,0 +1,23 @@
+import { configure, getConsoleSink } from "@logtape/logtape";
+import { AsyncLocalStorage } from "node:async_hooks";
+
+export default configure({
+  contextLocalStorage: new AsyncLocalStorage(),
+  sinks: {
+    console: getConsoleSink(),
+  },
+  filters: {},
+  loggers: [
+    {
+      category: /* project name */,
+      lowestLevel: "debug",
+      sinks: ["console"],
+    },
+    { category: "fedify", lowestLevel: "info", sinks: ["console"] },
+    {
+      category: ["logtape", "meta"],
+      lowestLevel: "warning",
+      sinks: ["console"],
+    },
+  ],
+});

package/dist/templates/nuxt/server/plugins/logging.ts.tpl

@@ -0,0 +1,5 @@
+import loggingConfigured from "../logging";
+
+export default defineNitroPlugin(async () => {
+  await loggingConfigured;
+});

package/dist/types.d.ts

@@ -22,6 +22,8 @@ interface WebFrameworkInitializer {
   federationFile: string;
   /** Relative path where the logging configuration file will be created. */
   loggingFile: string;
+  /** Optional template path for the logging configuration file. */
+  loggingTemplate?: string;
   /**
    * Additional files to create, keyed by relative path to file content.
    * Do not use `".env"` as a key — use the {@link env} property instead so

package/dist/utils.js

@@ -4,7 +4,7 @@ import { print, printError } from "@optique/run";
 import { flow, toMerged } from "es-toolkit";
 import { message } from "@optique/core";
 import { Chalk } from "chalk";
-import "node:child_process";
+import { spawn } from "node:child_process";
 /** Chalk instance configured based on {@link colorEnabled}. */
 const colors = new Chalk(process.stdout.isTTY && !("NO_COLOR" in process.env && process.env.NO_COLOR !== "") ? {} : { level: 0 });
 /** Type guard that checks whether a value is a `Promise`. */
@@ -53,6 +53,79 @@ const formatJson = (obj) => JSON.stringify(obj, null, 2) + "\n";
 const notEmpty = (s) => s.length > 0;
 /** Type guard that checks whether an error is a "file not found" (`ENOENT`) error. */
 const isNotFoundError = (e) => isObject(e) && "code" in e && e.code === "ENOENT";
+/**
+* Error thrown when a spawned shell command exits with a non-zero code.
+* Captures stdout, stderr, exit code, and the original command array.
+*/
+var CommandError = class extends Error {
+	commandLine;
+	constructor(message, stdout, stderr, code, command) {
+		super(message);
+		this.stdout = stdout;
+		this.stderr = stderr;
+		this.code = code;
+		this.command = command;
+		this.name = "CommandError";
+		this.commandLine = command.join(" ");
+	}
+};
+/**
+* Executes a shell command (or a chain of commands joined by `"&&"`) as child
+* processes and returns the combined stdout/stderr output.
+* Throws a {@link CommandError} if any command in the chain exits with a
+* non-zero code.
+*
+* @param command - The command as an array of strings; use `"&&"` to chain
+* @param options - Options forwarded to `node:child_process.spawn`
+* @returns A promise resolving to `{ stdout, stderr }`
+*/
+const runSubCommand = async (command, options) => {
+	const commands = command.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 (error) {
+		if (error instanceof CommandError) {
+			results.stdout += (results.stdout ? "\n" : "") + error.stdout;
+			results.stderr += (results.stderr ? "\n" : "") + error.stderr;
+		}
+		throw error;
+	}
+	return results;
+};
+const runSingularCommand = (command, options) => new Promise((resolve, reject) => {
+	let stdout = "";
+	let stderr = "";
+	const child = spawn(command[0], command.slice(1), options);
+	child.stdout?.on("data", (data) => {
+		stdout += data.toString();
+	});
+	child.stderr?.on("data", (data) => {
+		stderr += data.toString();
+	});
+	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));
+	});
+	child.on("error", (error) => {
+		reject(error);
+	});
+});
 /** Returns the current working directory. */
 const getCwd = () => process.cwd();
 /** Returns the current OS platform (e.g., `"darwin"`, `"win32"`, `"linux"`). */
@@ -76,4 +149,4 @@ const printMessage = flow(message, print);
 /** Prints a formatted error message to stderr using `@optique/run`'s `printError`. */
 const printErrorMessage = flow(message, printError);
 //#endregion
-export { colors, formatJson, getCwd, getOsType, isNotFoundError, merge$1 as merge, notEmpty, printErrorMessage, printMessage, product, replace, replaceAll, set };
+export { CommandError, colors, formatJson, getCwd, getOsType, isNotFoundError, merge$1 as merge, notEmpty, printErrorMessage, printMessage, product, replace, replaceAll, runSubCommand, set };

package/dist/webframeworks/next.js

@@ -21,6 +21,7 @@ const nextDescription = {
 		federationFile: "federation/index.ts",
 		loggingFile: "logging.ts",
 		files: {
+			"instrumentation.ts": await readTemplate("next/instrumentation.ts"),
 			"middleware.ts": await readTemplate("next/middleware.ts"),
 			...pm !== "deno" && { "eslint.config.ts": await readTemplate("defaults/eslint.config.ts") }
 		},

package/dist/webframeworks/nitro.js

@@ -18,6 +18,7 @@ const nitroDescription = {
 		loggingFile: "server/logging.ts",
 		env: testMode ? { HOST: "127.0.0.1" } : {},
 		files: {
+			"server/plugins/logging.ts": await readTemplate("nitro/server/plugins/logging.ts"),
 			"server/middleware/federation.ts": await readTemplate("nitro/server/middleware/federation.ts"),
 			"server/error.ts": await readTemplate("nitro/server/error.ts"),
 			"nitro.config.ts": await readTemplate("nitro/nitro.config.ts"),

package/dist/webframeworks/nuxt.js

@@ -18,9 +18,11 @@ const nuxtDescription = {
 		},
 		federationFile: "server/federation.ts",
 		loggingFile: "server/logging.ts",
+		loggingTemplate: "nuxt/server/logging.ts",
 		env: testMode ? { HOST: "127.0.0.1" } : {},
 		files: {
 			"nuxt.config.ts": await readTemplate("nuxt/nuxt.config.ts"),
+			"server/plugins/logging.ts": await readTemplate("nuxt/server/plugins/logging.ts"),
 			...pm !== "deno" && { "eslint.config.ts": await readTemplate("defaults/eslint.config.ts") }
 		},
 		tasks: pm !== "deno" ? { "lint": "eslint ." } : {},

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fedify/init",
-  "version": "2.2.0-pr.715.28+06979f5f",
+  "version": "2.2.0-pr.731.34+1e1bb860",
   "description": "Project initializer for Fedify",
   "keywords": [
     "fedify",
@@ -52,8 +52,8 @@
     "@fxts/core": "^1.20.0",
     "@inquirer/prompts": "^7.8.4",
     "@logtape/logtape": "^2.0.5",
-    "@optique/core": "^1.0.0",
-    "@optique/run": "^1.0.0",
+    "@optique/core": "^1.0.2",
+    "@optique/run": "^1.0.2",
     "chalk": "^5.6.2",
     "es-toolkit": "1.43.0",
     "inquirer-toggle": "^1.0.1"