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

package/dist/init/command.js

@@ -3,7 +3,7 @@
     
 import { debugOption } from "../globals.js";
 import { KV_STORE, MESSAGE_QUEUE, PACKAGE_MANAGER, WEB_FRAMEWORK } from "./const.js";
-import { argument, choice, command, constant, message, object, option, optionNames, optional } from "@optique/core";
+import { argument, choice, command, constant, message, multiple, object, option, optionNames, optional } from "@optique/core";
 import { path } from "@optique/run";
 
 //#region src/init/command.ts
@@ -11,6 +11,7 @@ const webFramework = optional(option("-w", "--web-framework", choice(WEB_FRAMEWO
 const packageManager = optional(option("-p", "--package-manager", choice(PACKAGE_MANAGER, { metavar: "PACKAGE_MANAGER" }), { description: message`The package manager to use for installing dependencies.` }));
 const kvStore = optional(option("-k", "--kv-store", choice(KV_STORE, { metavar: "KV_STORE" }), { description: message`The key-value store to use for caching and some other features.` }));
 const messageQueue = optional(option("-m", "--message-queue", choice(MESSAGE_QUEUE, { metavar: "MESSAGE_QUEUE" }), { description: message`The message queue to use for background tasks.` }));
+const testMode = option("--test-mode", { description: message`The test mode to use for testing purposes.` });
 const initCommand = command("init", object("Initialization options", {
 	command: constant("init"),
 	dir: optional(argument(path({ metavar: "DIR" }), { description: message`The project directory to initialize.  If a specified directory does not exist, it will be created.` })),
@@ -19,7 +20,8 @@ const initCommand = command("init", object("Initialization options", {
 	kvStore,
 	messageQueue,
 	dryRun: option("-d", "--dry-run", { description: message`Perform a trial run with no changes made.` }),
-	debugOption
+	debugOption,
+	testMode
 }), {
 	brief: message`Initialize a new Fedify project directory.`,
 	description: message`Initialize a new Fedify project directory.
@@ -28,6 +30,21 @@ By default, it initializes the current directory.  You can specify a different d
 
 Unless you specify all options (${optionNames(["-w", "--web-framework"])}, ${optionNames(["-p", "--package-manager"])}, ${optionNames(["-k", "--kv-store"])}, and ${optionNames(["-m", "--message-queue"])}), it will prompt you to select the options interactively.`
 });
+const testInitCommand = command("test-init", object("Initialization options", {
+	command: constant("test-init"),
+	webFramework: multiple(webFramework),
+	packageManager: multiple(packageManager),
+	kvStore: multiple(kvStore),
+	messageQueue: multiple(messageQueue),
+	hydRun: option("-h", "--hyd-run", { description: message`Test with files creations and installations.` }),
+	dryRun: option("-d", "--dry-run", { description: message`Log outputs without creating files.` }),
+	debugOption
+}), {
+	brief: message`Test an initializing command .`,
+	description: message`Test an initializing command on temporary directories.
+
+Unless you specify all options (${optionNames(["-w", "--web-framework"])}, ${optionNames(["-p", "--package-manager"])}, ${optionNames(["-k", "--kv-store"])}, and ${optionNames(["-m", "--message-queue"])}), it will test all combinations of the options.`
+});
 
 //#endregion
-export { initCommand };
+export { initCommand, testInitCommand };

package/dist/init/lib.js

@@ -45,14 +45,14 @@ async function isPackageManagerAvailable(pm) {
 	return false;
 }
 const readTemplate = (templatePath) => readFileSync(join(import.meta.dirname, "templates", ...(templatePath + ".tpl").split("/")), "utf8");
-const getInstruction = (pm) => message`
+const getInstruction = (pm, port) => message`
 To start the server, run the following command:
 
   ${commandLine(getDevCommand(pm))}
 
 Then, try look up an actor from your server:
 
-  ${commandLine("fedify lookup http://localhost:8000/users/john")}
+  ${commandLine(`fedify lookup http://localhost:${port}/users/john`)}
 
 `;
 const getDevCommand = (pm) => pm === "deno" ? "deno task dev" : pm === "bun" ? "bun dev" : `${pm} run dev`;
@@ -92,18 +92,20 @@ const isDirectoryEmpty = async (path$1) => {
 		return true;
 	}
 };
+/**
+* Converts a package manager to its corresponding runtime.
+* @param pm - The package manager (deno, bun, npm, yarn, pnpm)
+* @returns The runtime name (deno, bun, or node)
+*/
+const packageManagerToRuntime = (pm) => pm === "deno" ? "deno" : pm === "bun" ? "bun" : "node";
 const getNextInitCommand = (pm) => [
 	...createNextAppCommand(pm),
 	".",
-	"--ts",
-	"--app",
-	"--biome",
-	"--skip-install"
+	"--yes"
 ];
 const createNextAppCommand = (pm) => pm === "deno" ? [
 	"deno",
-	"run",
-	"-A",
+	"-Ar",
 	"npm:create-next-app@latest"
 ] : pm === "bun" ? [
 	"bun",
@@ -118,13 +120,17 @@ const getNitroInitCommand = (pm) => [
 	...createNitroAppCommand(pm),
 	pm === "deno" ? "npm:giget@latest" : "giget@latest",
 	"nitro",
-	"."
+	".",
+	"&&",
+	"rm",
+	"nitro.config.ts"
 ];
 const createNitroAppCommand = (pm) => pm === "deno" ? [
 	"deno",
 	"run",
 	"-A"
 ] : pm === "bun" ? ["bunx"] : pm === "npm" ? ["npx"] : [pm, "dlx"];
+const isTest = ({ testMode }) => testMode;
 
 //#endregion
-export { PACKAGE_VERSION, createFile, getInstallUrl, getInstruction, getLabel, getNextInitCommand, getNitroInitCommand, isDirectoryEmpty, isPackageManagerAvailable, kvStores, logger, messageQueues, readTemplate, throwUnlessNotExists };
+export { PACKAGE_VERSION, createFile, getDevCommand, getInstallUrl, getInstruction, getLabel, getNextInitCommand, getNitroInitCommand, isDirectoryEmpty, isPackageManagerAvailable, isTest, kvStores, logger, messageQueues, packageManagerToRuntime, readTemplate, throwUnlessNotExists };

package/dist/init/mod.js

@@ -2,4 +2,5 @@
       import { Temporal } from "@js-temporal/polyfill";
     
 import action_default from "./action/mod.js";
-import { initCommand } from "./command.js";
+import { initCommand, testInitCommand } from "./command.js";
+import action_default$1 from "./test/action.js";

package/dist/init/templates/nitro/.env.test.tpl

@@ -0,0 +1 @@
+HOST=127.0.0.1

package/dist/init/templates/nitro/nitro.config.ts.tpl

@@ -1,5 +1,14 @@
-// https://nitro.unjs.io/config
+import { defineNitroConfig } from "nitropack/config"
+
+// https://nitro.build/config
 export default defineNitroConfig({
+  errorHandler: "~/error",
+  esbuild: {
+    options: {
+      target: "esnext",
+    },
+  },
+  compatibilityDate: "latest",
   srcDir: "server",
-  errorHandler: "~/error"
-});
+  imports: false
+});

package/dist/init/test/action.js

@@ -0,0 +1,15 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+    
+import { set } from "../../utils.js";
+import { fillEmptyOptions } from "./fill.js";
+import { isDryRun, isHydRun, runTests } from "./run.js";
+import { emptyTestDir, genRunId, genTestDirPrefix, logTestDir } from "./utils.js";
+import { pipe, tap, when } from "@fxts/core";
+
+//#region src/init/test/action.ts
+const runTestInit = (options) => pipe(options, set("runId", genRunId), set("testDirPrefix", genTestDirPrefix), tap(emptyTestDir), fillEmptyOptions, tap(when(isHydRun, runTests(false))), tap(when(isDryRun, runTests(true))), tap(logTestDir));
+var action_default = runTestInit;
+
+//#endregion
+export { action_default as default };

package/dist/init/test/create.js

@@ -0,0 +1,100 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+    
+import { CommandError, printErrorMessage, printMessage, product, runSubCommand } from "../../utils.js";
+import pm_default from "../json/pm.js";
+import webframeworks_default from "../webframeworks.js";
+import { kvStores, messageQueues } from "../lib.js";
+import { join, sep } from "node:path";
+import { appendFile, mkdir } from "node:fs/promises";
+import { values } from "@optique/core";
+import process from "node:process";
+import { filter, isEmpty, pipe, toArray } from "@fxts/core";
+
+//#region src/init/test/create.ts
+const BANNED_PMS = ["bun", "yarn"];
+const createTestApp = (testDirPrefix, dry) => async (options) => {
+	const testDir = join(testDirPrefix, ...options);
+	const vals = values(testDir.split(sep).slice(-4));
+	try {
+		const result = await runSubCommand(toArray(genInitCommand(testDir, dry, options)), {
+			cwd: join(import.meta.dirname, "../../.."),
+			stdio: [
+				"ignore",
+				"pipe",
+				"pipe"
+			]
+		});
+		await saveOutputs(testDir, result);
+		printMessage`  Pass: ${vals}`;
+		return testDir;
+	} catch (error) {
+		if (error instanceof CommandError) await saveOutputs(testDir, {
+			stdout: error.stdout,
+			stderr: error.stderr
+		});
+		else {
+			const errorMessage = error instanceof Error ? error.message : String(error);
+			await saveOutputs(testDir, {
+				stdout: "",
+				stderr: errorMessage
+			});
+		}
+		printMessage`  Fail: ${vals}`;
+		return "";
+	}
+};
+var create_default = createTestApp;
+function* genInitCommand(testDir, dry, [webFramework, packageManager, kvStore, messageQueue]) {
+	yield "deno";
+	yield "run";
+	yield "-A";
+	yield "src/mod.ts";
+	yield "init";
+	yield testDir;
+	yield "-w";
+	yield webFramework;
+	yield "-p";
+	yield packageManager;
+	yield "-k";
+	yield kvStore;
+	yield "-m";
+	yield messageQueue;
+	yield "--test-mode";
+	if (dry) yield "-d";
+}
+const generateTestCases = ({ webFramework, packageManager, kvStore, messageQueue }) => {
+	const pms = filterPackageManager(packageManager);
+	exitIfCasesEmpty([
+		webFramework,
+		pms,
+		kvStore,
+		messageQueue
+	]);
+	return product(webFramework, pms, kvStore, messageQueue);
+};
+const filterPackageManager = (pm) => pipe(pm, filter((pm$1) => BANNED_PMS.includes(pm$1) ? printErrorMessage`${pm_default[pm$1]["label"]} is not \
+supported in test mode yet because ${pm_default[pm$1]["label"]} don't \
+support local file dependencies properly.` : true), toArray);
+const exitIfCasesEmpty = (cases) => {
+	if (cases.some(isEmpty)) {
+		printErrorMessage`No test cases to run. Exiting.`;
+		process.exit(1);
+	}
+};
+const saveOutputs = async (dirPath, { stdout, stderr }) => {
+	await mkdir(dirPath, { recursive: true });
+	if (stdout) await appendFile(join(dirPath, "out.txt"), stdout + "\n", "utf8");
+	if (stderr) await appendFile(join(dirPath, "err.txt"), stderr + "\n", "utf8");
+};
+function filterOptions(options) {
+	const [wf, pm, kv, mq] = options;
+	return [
+		webframeworks_default[wf].packageManagers,
+		kvStores[kv].packageManagers,
+		messageQueues[mq].packageManagers
+	].every((pms) => pms.includes(pm));
+}
+
+//#endregion
+export { create_default as default, filterOptions, generateTestCases };

package/dist/init/test/fill.js

@@ -0,0 +1,26 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+    
+import { KV_STORE, MESSAGE_QUEUE, PACKAGE_MANAGER, WEB_FRAMEWORK } from "../const.js";
+import { isEmpty, pipe } from "@fxts/core";
+
+//#region src/init/test/fill.ts
+const fillEmptyOptions = (options) => pipe(options, fillWebFramework, fillPackageManager, fillKVStore, fillMessageQueue, fillRunMode);
+const fillOption = (key, allValues) => (options) => ({
+	...options,
+	[key]: isEmpty(options[key]) ? allValues : options[key].filter((i) => allValues.includes(i))
+});
+const fillWebFramework = fillOption("webFramework", WEB_FRAMEWORK);
+const fillPackageManager = fillOption("packageManager", PACKAGE_MANAGER);
+const fillKVStore = fillOption("kvStore", KV_STORE);
+const fillMessageQueue = fillOption("messageQueue", MESSAGE_QUEUE);
+const fillRunMode = (options) => ({
+	...options,
+	...options.hydRun || options.dryRun ? {} : {
+		hydRun: true,
+		dryRun: true
+	}
+});
+
+//#endregion
+export { fillEmptyOptions };

package/dist/init/test/lookup.js

@@ -0,0 +1,189 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+    
+import { printErrorMessage, printMessage, runSubCommand } from "../../utils.js";
+import webframeworks_default from "../webframeworks.js";
+import { getDevCommand } from "../lib.js";
+import { join, sep } from "node:path";
+import { values } from "@optique/core";
+import process from "node:process";
+import { spawn } from "node:child_process";
+import { createWriteStream } from "node:fs";
+
+//#region src/init/test/lookup.ts
+const HANDLE = "john";
+const STARTUP_TIMEOUT = 3e4;
+const CWD = process.cwd();
+const BANNED_WFS = ["next"];
+/**
+* Run servers for all generated apps and test them with the lookup command.
+*
+* @param dirs - Array of paths to generated app directories
+*/
+async function runServerAndReadUser(dirs) {
+	const valid = dirs.filter(Boolean);
+	if (valid.length === 0) {
+		printErrorMessage`\nNo directories to lookup test.`;
+		return;
+	}
+	const filtered = filterWebFrameworks(valid);
+	printMessage`\nLookup Test start for ${String(filtered.length)} app(s)!`;
+	const results = await Array.fromAsync(filtered, testApp);
+	const successCount = results.filter(Boolean).length;
+	const failCount = results.length - successCount;
+	printMessage`Lookup Test Results:
+  Total: ${String(results.length)}
+  Passed: ${String(successCount)}
+  Failed: ${String(failCount)}\n\n`;
+}
+function filterWebFrameworks(dirs) {
+	const wfs = new Set(dirs.map((dir) => dir.split(sep).slice(-4, -3)[0]));
+	const hasBanned = BANNED_WFS.filter((wf) => wfs.has(wf));
+	if (!hasBanned) return dirs;
+	const bannedLabels = hasBanned.map((wf) => webframeworks_default[wf]["label"]);
+	printErrorMessage`\n${values(bannedLabels)} is not supported in test mode yet.`;
+	return dirs.filter((dir) => !BANNED_WFS.includes(dir.split(sep).slice(-4, -3)[0]));
+}
+/**
+* Run the dev server and test with lookup command.
+*/
+async function testApp(dir) {
+	const [wf, pm, kv, mq] = dir.split(sep).slice(-4);
+	printMessage`  Testing ${values([
+		wf,
+		pm,
+		kv,
+		mq
+	])}...`;
+	const result = await serverClosure(dir, getDevCommand(pm), sendLookup);
+	printMessage`    Lookup ${result ? "successful" : "failed"} for ${values([
+		wf,
+		pm,
+		kv,
+		mq
+	])}!`;
+	if (!result) printMessage`    Check out these files for more details:
+      ${join(dir, "out.txt")}
+      ${join(dir, "err.txt")}\n`;
+	printMessage`\n`;
+	return result;
+}
+const sendLookup = async (port) => {
+	const serverUrl = `http://localhost:${port}`;
+	const lookupTarget = `${serverUrl}/users/${HANDLE}`;
+	printMessage`    Waiting for server to start at ${serverUrl}...`;
+	const isReady = await waitForServer(serverUrl, STARTUP_TIMEOUT);
+	if (!isReady) {
+		printErrorMessage`Server did not start within \
+${String(STARTUP_TIMEOUT)}ms`;
+		return false;
+	}
+	printMessage`    Server is ready. Running lookup command...`;
+	try {
+		await runSubCommand([
+			"deno",
+			"task",
+			"cli",
+			"lookup",
+			lookupTarget
+		], { cwd: CWD });
+		return true;
+	} catch (error) {
+		if (error instanceof Error) printErrorMessage`${error.message}`;
+	}
+	return false;
+};
+/**
+* Wait for the server to be ready by checking if it responds to requests.
+*/
+async function waitForServer(url, timeout) {
+	const startTime = Date.now();
+	while (Date.now() - startTime < timeout) {
+		try {
+			const response = await fetch(url, { signal: AbortSignal.timeout(1e3) });
+			if (response.ok) return true;
+		} catch {}
+		await new Promise((resolve) => setTimeout(resolve, 500));
+	}
+	return false;
+}
+async function serverClosure(dir, cmd, callback) {
+	const devCommand = cmd.split(" ");
+	const serverProcess = spawn(devCommand[0], devCommand.slice(1), {
+		cwd: dir,
+		stdio: [
+			"ignore",
+			"pipe",
+			"pipe"
+		],
+		detached: true
+	});
+	const stdout = createWriteStream(join(dir, "out.txt"), { flags: "a" });
+	const stderr = createWriteStream(join(dir, "err.txt"), { flags: "a" });
+	serverProcess.stdout?.pipe(stdout);
+	serverProcess.stderr?.pipe(stderr);
+	try {
+		const port = await determinePort(serverProcess);
+		return await callback(port);
+	} finally {
+		try {
+			process.kill(-serverProcess.pid, "SIGKILL");
+		} catch {
+			serverProcess.kill("SIGKILL");
+			stdout.end();
+			stderr.end();
+		}
+	}
+}
+function determinePort(server) {
+	return new Promise((resolve, reject) => {
+		const timeout = setTimeout(() => {
+			reject(/* @__PURE__ */ new Error("Timeout: Could not determine port from server output"));
+		}, STARTUP_TIMEOUT);
+		let stdoutData = "";
+		let stderrData = "";
+		const portPatterns = [
+			/listening on.*:(\d+)/i,
+			/server.*:(\d+)/i,
+			/port\s*:?\s*(\d+)/i,
+			/localhost:(\d+)/i,
+			/0\.0\.0\.0:(\d+)/i,
+			/127\.0\.0\.1:(\d+)/i,
+			/https?:\/\/[^:]+:(\d+)/i
+		];
+		const checkForPort = (data) => {
+			for (const pattern of portPatterns) {
+				const match = data.match(pattern);
+				if (match && match[1]) {
+					const port = Number.parseInt(match[1], 10);
+					if (port > 0 && port < 65536) {
+						clearTimeout(timeout);
+						return port;
+					}
+				}
+			}
+			return null;
+		};
+		server.stdout.on("data", (chunk) => {
+			stdoutData += chunk.toString();
+			const port = checkForPort(stdoutData);
+			if (port) resolve(port);
+		});
+		server.stderr.on("data", (chunk) => {
+			stderrData += chunk.toString();
+			const port = checkForPort(stderrData);
+			if (port) resolve(port);
+		});
+		server.on("error", (err) => {
+			clearTimeout(timeout);
+			reject(err);
+		});
+		server.on("exit", (code) => {
+			clearTimeout(timeout);
+			reject(/* @__PURE__ */ new Error(`Server exited with code ${code} before port could be determined`));
+		});
+	});
+}
+
+//#endregion
+export { runServerAndReadUser };

package/dist/init/test/run.js

@@ -0,0 +1,26 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+    
+import { printMessage } from "../../utils.js";
+import create_default, { filterOptions, generateTestCases } from "./create.js";
+import { runServerAndReadUser } from "./lookup.js";
+import { join } from "node:path";
+import { optionNames } from "@optique/core";
+import { filter, map as map$1, pipe, tap } from "@fxts/core";
+
+//#region src/init/test/run.ts
+const isDryRun = ({ dryRun }) => dryRun;
+const isHydRun = ({ hydRun }) => hydRun;
+const runTests = (dry) => ({ testDirPrefix, dryRun, hydRun,...options }) => pipe(options, printStartMessage, generateTestCases, filter(filterOptions), map$1(create_default(join(testDirPrefix, getMid(dryRun, hydRun, dry)), dry)), Array.fromAsync, runServerAndReadUser);
+const printStartMessage = tap(() => printMessage`\n
+Init Test start!
+Options: ${optionNames([
+	"Web Framework",
+	"Package Manager",
+	"KV Store",
+	"Message Queue"
+])}`);
+const getMid = (dryRun, hydRun, dry) => dryRun === hydRun ? dry ? "dry" : "hyd" : "";
+
+//#endregion
+export { isDryRun, isHydRun, runTests };

package/dist/init/test/utils.js

@@ -0,0 +1,17 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+    
+import { printMessage } from "../../utils.js";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+//#region src/init/test/utils.ts
+const genRunId = () => `${Date.now()}-${Math.random().toString(36).slice(2)}`;
+const genTestDirPrefix = ({ runId }) => join(tmpdir(), "fedify-init", runId);
+const emptyTestDir = ({ testDirPrefix }) => Deno.remove(testDirPrefix, { recursive: true }).catch(() => {});
+const logTestDir = ({ runId, testDirPrefix }) => printMessage`Test run completed.
+Run ID: ${runId}
+Path: ${testDirPrefix}`;
+
+//#endregion
+export { emptyTestDir, genRunId, genTestDirPrefix, logTestDir };

package/dist/init/webframeworks.js

@@ -3,8 +3,7 @@
     
 import { replace } from "../utils.js";
 import { PACKAGE_MANAGER } from "./const.js";
-import { PACKAGE_VERSION, getInstruction, getNextInitCommand, getNitroInitCommand, readTemplate } from "./lib.js";
-import { message } from "@optique/core";
+import { PACKAGE_VERSION, getInstruction, getNextInitCommand, getNitroInitCommand, packageManagerToRuntime, readTemplate } from "./lib.js";
 import { pipe } from "@fxts/core";
 
 //#region src/init/webframeworks.ts
@@ -12,27 +11,30 @@ const webFrameworks = {
 	hono: {
 		label: "Hono",
 		packageManagers: PACKAGE_MANAGER,
-		init: (projectName, pm) => ({
+		init: ({ projectName, packageManager: pm }) => ({
 			dependencies: pm === "deno" ? {
 				"@std/dotenv": "^0.225.2",
 				"@hono/hono": "^4.5.0",
-				"@hongminhee/x-forwarded-fetch": "^0.2.0"
+				"@hongminhee/x-forwarded-fetch": "^0.2.0",
+				"@fedify/hono": PACKAGE_VERSION
 			} : pm === "bun" ? {
 				hono: "^4.5.0",
-				"x-forwarded-fetch": "^0.2.0"
+				"x-forwarded-fetch": "^0.2.0",
+				"@fedify/hono": PACKAGE_VERSION
 			} : {
 				"@dotenvx/dotenvx": "^1.14.1",
 				hono: "^4.5.0",
 				"@hono/node-server": "^1.12.0",
 				tsx: "^4.17.0",
-				"x-forwarded-fetch": "^0.2.0"
+				"x-forwarded-fetch": "^0.2.0",
+				"@fedify/hono": PACKAGE_VERSION
 			},
 			devDependencies: pm === "bun" ? { "@types/bun": "^1.1.6" } : {},
-			federationFile: message`src/federation.ts`,
+			federationFile: "src/federation.ts",
 			loggingFile: "src/logging.ts",
 			files: {
-				"src/app.tsx": pipe("hono/app.tsx", readTemplate, replace(/\/\* hono \*\//, pm === "deno" ? "@hono/hono" : "hono")).replace(/\/\* logger \*\//, projectName),
-				"src/index.ts": readTemplate(`hono/index/${pm}.ts`)
+				"src/app.tsx": pipe("hono/app.tsx", readTemplate, replace(/\/\* hono \*\//, pm === "deno" ? "@hono/hono" : "hono"), replace(/\/\* logger \*\//, projectName)),
+				"src/index.ts": readTemplate(`hono/index/${packageManagerToRuntime(pm)}.ts`)
 			},
 			compilerOptions: pm === "deno" ? void 0 : {
 				"lib": ["ESNext", "DOM"],
@@ -50,20 +52,16 @@ const webFrameworks = {
 				"dev": pm === "deno" ? "deno run -A --watch ./src/index.ts" : pm === "bun" ? "bun run --hot ./src/index.ts" : "dotenvx run -- tsx watch ./src/index.ts",
 				"prod": pm === "deno" ? "deno run -A ./src/index.ts" : pm === "bun" ? "bun run ./src/index.ts" : "dotenvx run -- node --import tsx ./src/index.ts"
 			},
-			instruction: getInstruction(pm)
-		})
+			instruction: getInstruction(pm, 8e3)
+		}),
+		defaultPort: 8e3
 	},
 	express: {
 		label: "Express",
-		packageManagers: [
-			"bun",
-			"npm",
-			"yarn",
-			"pnpm"
-		],
-		init: (projectName, pm) => ({
+		packageManagers: PACKAGE_MANAGER,
+		init: ({ projectName, packageManager: pm }) => ({
 			dependencies: {
-				express: "^4.19.2",
+				"npm:express": "^4.19.2",
 				"@fedify/express": PACKAGE_VERSION,
 				...pm !== "deno" && pm !== "bun" ? {
 					"@dotenvx/dotenvx": "^1.14.1",
@@ -74,7 +72,7 @@ const webFrameworks = {
 				"@types/express": "^4.17.21",
 				...pm === "bun" ? { "@types/bun": "^1.1.6" } : {}
 			},
-			federationFile: message`src/federation.ts`,
+			federationFile: "src/federation.ts",
 			loggingFile: "src/logging.ts",
 			files: {
 				"src/app.ts": readTemplate("express/app.ts").replace(/\/\* logger \*\//, projectName),
@@ -91,41 +89,45 @@ const webFrameworks = {
 				"strict": true
 			},
 			tasks: {
-				"dev": pm === "bun" ? "bun run --hot ./src/index.ts" : "dotenvx run -- tsx watch ./src/index.ts",
-				"prod": pm === "bun" ? "bun run ./src/index.ts" : "dotenvx run -- node --import tsx ./src/index.ts"
+				"dev": pm === "bun" ? "bun run --hot ./src/index.ts" : pm === "deno" ? "deno run --allow-net --allow-env --allow-sys --watch ./src/index.ts" : "dotenvx run -- tsx watch ./src/index.ts",
+				"prod": pm === "bun" ? "bun run ./src/index.ts" : pm === "deno" ? "deno run --allow-net --allow-env --allow-sys ./src/index.ts" : "dotenvx run -- node --import tsx ./src/index.ts"
 			},
-			instruction: getInstruction(pm)
-		})
+			instruction: getInstruction(pm, 8e3)
+		}),
+		defaultPort: 8e3
 	},
 	nitro: {
 		label: "Nitro",
 		packageManagers: PACKAGE_MANAGER,
-		init: (_, pm) => ({
+		init: ({ packageManager: pm, testMode }) => ({
 			command: getNitroInitCommand(pm),
 			dependencies: { "@fedify/h3": PACKAGE_VERSION },
-			federationFile: message`server/federation.ts`,
+			federationFile: "server/federation.ts",
 			loggingFile: "server/logging.ts",
 			files: {
 				"server/middleware/federation.ts": readTemplate("nitro/server/middleware/federation.ts"),
 				"server/error.ts": readTemplate("nitro/server/error.ts"),
-				"nitro.config.ts": readTemplate("nitro/nitro.config.ts")
+				"nitro.config.ts": readTemplate("nitro/nitro.config.ts"),
+				...testMode ? { ".env": readTemplate("nitro/.env.test") } : {}
 			},
-			instruction: getInstruction(pm)
-		})
+			instruction: getInstruction(pm, 3e3)
+		}),
+		defaultPort: 3e3
 	},
 	next: {
 		label: "Next.js",
 		packageManagers: PACKAGE_MANAGER,
-		init: (_, pm) => ({
+		init: ({ packageManager: pm }) => ({
 			label: "Next.js",
 			command: getNextInitCommand(pm),
 			dependencies: { "@fedify/next": PACKAGE_VERSION },
 			devDependencies: { "@types/node": "^20.11.2" },
-			federationFile: message`federation/index.ts`,
+			federationFile: "federation/index.ts",
 			loggingFile: "logging.ts",
 			files: { "middleware.ts": readTemplate("next/middleware.ts") },
-			instruction: getInstruction(pm)
-		})
+			instruction: getInstruction(pm, 3e3)
+		}),
+		defaultPort: 3e3
 	}
 };
 var webframeworks_default = webFrameworks;