@fedify/init 2.2.0-dev.635 → 2.2.0-dev.652

package/dist/test/lookup.js

@@ -1,185 +1,111 @@
-import { printErrorMessage, printMessage, runSubCommand } from "../utils.js";
-import { getDevCommand } from "../lib.js";
+import { printErrorMessage, printMessage } from "../utils.js";
+import { getDevCommand, kvStores, messageQueues, packageManagers } from "../lib.js";
 import webFrameworks from "../webframeworks/mod.js";
-import process from "node:process";
+import { replacePortInApp, reservePort } from "./port.js";
+import { STARTUP_TIMEOUT, serverClosure, waitForServer } from "./server.js";
+import { join } from "@fxts/core";
+import $ from "@david/dax";
+import { join as join$1, sep } from "node:path";
 import { values } from "@optique/core";
-import { spawn } from "node:child_process";
-import { createWriteStream } from "node:fs";
-import { join, sep } from "node:path";
-import { isEmpty } from "@fxts/core/index.js";
 //#region src/test/lookup.ts
 const HANDLE = "john";
-const STARTUP_TIMEOUT = 3e4;
-const CWD = process.cwd();
-const BANNED_WFS = ["next"];
+const BANNED_LOOKUP_REASONS = {
+	"next,*,*,*": "Next.js doesn't support remote packages",
+	"solidstart,deno,*,*": "Error occurred while loading submodules in Deno",
+	"astro,deno,*,*": "Astro doesn't support remote packages in Deno"
+};
+const BANNED_LOOKUP_CASES = Object.keys(BANNED_LOOKUP_REASONS).map((key) => key.split(","));
 /**
 * Run servers for all generated apps and test them with the lookup command.
 *
 * @param dirs - Array of paths to generated app directories
 */
 async function runServerAndLookupUser(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 valid = dirs.filter(Boolean).filter(isTestable);
+	printSkippedCases(dirs);
+	if (valid.length === 0) printErrorMessage`\nNo directories to lookup test.`;
+	printMessage``;
+	printMessage`Lookup Test start for ${String(valid.length)} app(s)!`;
+	const results = await Array.fromAsync(valid, 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`;
+	printFailedCases(valid, results);
+}
+const parseLookupCase = (dir) => dir.split(sep).slice(-4);
+const matchesLookupCasePattern = (target) => (pattern) => pattern.every((value, index) => value === "*" || value === target[index]);
+const isTestable = (dir) => !BANNED_LOOKUP_CASES.some(matchesLookupCasePattern(parseLookupCase(dir)));
+function printSkippedCases(dirs) {
+	const matchedPatterns = new Set(dirs.filter(Boolean).flatMap((dir) => BANNED_LOOKUP_CASES.filter(matchesLookupCasePattern(parseLookupCase(dir))).map(join(","))));
+	if (matchedPatterns.size > 0) {
+		printMessage``;
+		printMessage`Skipped the following lookup cases due to known issues:`;
+	}
+	for (const key of matchedPatterns) {
+		const reason = BANNED_LOOKUP_REASONS[key] ?? "unknown reason";
+		printMessage`  - ${values(Array.from(getLabels(key.split(","))))}: ${reason}`;
+	}
+}
+function* getLabels([wf, pm, kv, mq]) {
+	if (wf !== "*") yield webFrameworks[wf].label;
+	if (pm !== "*") yield packageManagers[pm].label;
+	if (kv !== "*") yield kvStores[kv].label;
+	if (mq !== "*") yield messageQueues[mq].label;
 }
-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 (isEmpty(hasBanned)) return dirs;
-	printErrorMessage`\n${values(hasBanned.map((wf) => webFrameworks[wf]["label"]))} is not supported in lookup test yet.`;
-	return dirs.filter((dir) => !BANNED_WFS.includes(dir.split(sep).slice(-4, -3)[0]));
+function printFailedCases(valid, results) {
+	if (results.every(Boolean)) return;
+	printMessage`Failed cases:`;
+	for (let i = 0; i < results.length; i++) if (!results[i]) {
+		const dir = valid[i];
+		printMessage`  - ${values(parseLookupCase(dir))}: ${dir}`;
+	}
 }
 /**
 * Run the dev server and test with lookup command.
 */
 async function testApp(dir) {
-	const [wf, pm, kv, mq] = dir.split(sep).slice(-4);
+	const [wf, pm, kv, mq] = parseLookupCase(dir);
 	printMessage`  Testing ${values([
 		wf,
 		pm,
 		kv,
 		mq
 	])}...`;
-	const result = await serverClosure(dir, getDevCommand(pm), webFrameworks[wf].defaultPort, sendLookup).catch(() => false);
+	const defaultPort = webFrameworks[wf].defaultPort;
+	const { port, release } = await reservePort();
+	await replacePortInApp(dir, wf, defaultPort, port);
+	printMessage`    Using port ${String(port)}`;
+	const result = await serverClosure(dir, getDevCommand(pm), port, sendLookup, release).catch(() => false);
 	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")} and 
-      ${join(dir, "err.txt")}\n`;
+	if (!result) printMessage`    Check out these files for more details: \
+${join$1(dir, "out.txt")} and \
+${join$1(dir, "err.txt")}\n`;
 	printMessage`\n`;
 	return result;
 }
-const sendLookup = async (port) => {
+async function sendLookup(port) {
 	const serverUrl = `http://localhost:${port}`;
 	const lookupTarget = `${serverUrl}/users/${HANDLE}`;
 	printMessage`    Waiting for server to start at ${serverUrl}...`;
-	if (!await waitForServer(serverUrl, STARTUP_TIMEOUT)) {
-		printErrorMessage`Server did not start within \
-${String(STARTUP_TIMEOUT)}ms`;
+	if (!await waitForServer(serverUrl)) {
+		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;
+		return (await $`deno task cli lookup ${lookupTarget} -p`.stdin("null").stdout("piped").stderr("piped").noThrow().spawn()).stdout.includes(`id: URL '${lookupTarget}',`);
 	} 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 {
-			if ((await fetch(url, { signal: AbortSignal.timeout(1e3) })).ok) return true;
-		} catch {}
-		await new Promise((resolve) => setTimeout(resolve, 500));
-	}
-	return false;
-}
-async function serverClosure(dir, cmd, defaultPort, 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 {
-		return await callback(await determinePort(serverProcess).catch((err) => {
-			printErrorMessage`Failed to determine server port: ${err.message}`;
-			printErrorMessage`Use default port ${String(defaultPort)} for lookup.`;
-			return defaultPort;
-		}));
-	} 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,
-			/https?:\/\/localhost:(\d+)/i,
-			/https?:\/\/0\.0\.0\.0:(\d+)/i,
-			/https?:\/\/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 { runServerAndLookupUser as default };

package/dist/test/mod.js

@@ -1,13 +1,14 @@
 import { testInitCommand } from "../command.js";
 import runTestInit from "./action.js";
+import process from "node:process";
 import { run } from "@optique/run";
 //#region src/test/mod.ts
 async function main() {
-	console.log("Running test-init command...");
 	await runTestInit(run(testInitCommand, {
 		programName: "fedify-test-init",
 		help: "both"
 	}));
+	process.exit(0);
 }
 await main();
 //#endregion

package/dist/test/port.js

@@ -0,0 +1,128 @@
+import { printErrorMessage, printMessage } from "../utils.js";
+import process from "node:process";
+import { appendFile, readFile, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { execFile } from "node:child_process";
+import { createConnection, createServer } from "node:net";
+//#region src/test/port.ts
+/**
+* Check if a port is currently in use by attempting a TCP connection.
+*/
+function isPortInUse(port, timeout = 1e3) {
+	return new Promise((resolve) => {
+		const socket = createConnection({
+			port,
+			host: "localhost"
+		});
+		socket.setTimeout(timeout);
+		socket.once("connect", () => {
+			socket.destroy();
+			resolve(true);
+		});
+		socket.once("timeout", () => {
+			socket.destroy();
+			resolve(false);
+		});
+		socket.once("error", () => {
+			socket.destroy();
+			resolve(false);
+		});
+	});
+}
+/**
+* Poll until the port is free or timeout is reached.
+* Returns true if the port was released, false if still occupied.
+*/
+async function waitForPortRelease(port, timeout = 5e3) {
+	const start = Date.now();
+	while (Date.now() - start < timeout) {
+		if (!await isPortInUse(port)) return true;
+		await new Promise((r) => setTimeout(r, 500));
+	}
+	return false;
+}
+/**
+* Attempt to kill any process listening on the given port using lsof.
+*/
+async function killProcessOnPort(port) {
+	try {
+		const pids = await new Promise((resolve, reject) => {
+			execFile("lsof", [
+				"-t",
+				`-i:${port}`,
+				"-sTCP:LISTEN"
+			], (err, stdout) => {
+				if (err) reject(err);
+				else resolve(stdout);
+			});
+		});
+		for (const pid of pids.trim().split("\n").filter(Boolean)) try {
+			process.kill(parseInt(pid, 10), "SIGKILL");
+		} catch {}
+	} catch {}
+}
+/**
+* Reserve a free port by binding to port 0 and letting the OS assign one.
+* The socket is held until the returned `release` function is called,
+* eliminating the race window between discovery and actual use.
+*/
+function reservePort() {
+	return new Promise((resolve, reject) => {
+		const server = createServer();
+		server.listen(0, () => {
+			const addr = server.address();
+			if (addr == null || typeof addr === "string") {
+				server.close();
+				reject(/* @__PURE__ */ new Error("Failed to get port from server"));
+				return;
+			}
+			resolve({
+				port: addr.port,
+				release: () => new Promise((r) => server.close(() => r()))
+			});
+		});
+		server.on("error", reject);
+	});
+}
+const ENTRY_FILES = {
+	"bare-bones": "src/main.ts",
+	express: "src/index.ts",
+	hono: "src/index.ts",
+	elysia: "src/index.ts"
+};
+/**
+* Replace the hardcoded default port with `newPort` in the generated test
+* app's source files.  Strategy varies by framework.
+*/
+async function replacePortInApp(dir, wf, defaultPort, newPort) {
+	if (defaultPort === newPort) return;
+	const entryFile = ENTRY_FILES[wf];
+	if (entryFile) {
+		const filePath = join(dir, entryFile);
+		await writeFile(filePath, (await readFile(filePath, "utf8")).replaceAll(String(defaultPort), String(newPort)));
+		return;
+	}
+	if (wf === "nitro") {
+		await appendFile(join(dir, ".env"), `\nPORT=${newPort}\n`);
+		return;
+	}
+	if (wf === "astro") {
+		const configPath = join(dir, "astro.config.ts");
+		await writeFile(configPath, (await readFile(configPath, "utf8")).replace("defineConfig({", `defineConfig({\n  server: { port: ${newPort} },`));
+		return;
+	}
+	printErrorMessage`Unknown framework ${wf} — cannot replace port.`;
+}
+/**
+* Ensure a port is fully released after killing a server process.
+* If the port is still occupied after waiting, force-kill the holder.
+*/
+async function ensurePortReleased(port) {
+	if (!await waitForPortRelease(port, 5e3)) {
+		printMessage`    Port ${String(port)} still in use — force-killing...`;
+		await killProcessOnPort(port);
+		await waitForPortRelease(port, 3e3);
+	}
+}
+//#endregion
+export { ensurePortReleased, killProcessOnPort, replacePortInApp, reservePort };

package/dist/test/run.js

@@ -2,8 +2,8 @@ import { printMessage } from "../utils.js";
 import createTestApp, { filterOptions, generateTestCases } from "./create.js";
 import runServerAndLookupUser from "./lookup.js";
 import { always, filter, map, pipe, tap, unless } from "@fxts/core";
-import { optionNames } from "@optique/core";
 import { join as join$1 } from "node:path";
+import { optionNames } from "@optique/core";
 //#region src/test/run.ts
 const runTests = (dry) => ({ testDirPrefix, dryRun, hydRun, ...options }) => pipe(options, printStartMessage(dry), generateTestCases, filter(filterOptions), map(createTestApp(join$1(testDirPrefix, getMid(dryRun, hydRun, dry)), dry)), Array.fromAsync, unless(always(dry), runServerAndLookupUser));
 const printStartMessage = (dry) => tap(() => printMessage`\n

package/dist/test/server.js

@@ -0,0 +1,137 @@
+import { printErrorMessage } from "../utils.js";
+import { ensurePortReleased, killProcessOnPort } from "./port.js";
+import $ from "@david/dax";
+import { createWriteStream } from "node:fs";
+import { join } from "node:path";
+//#region src/test/server.ts
+const STARTUP_TIMEOUT = 1e4;
+/**
+* Wait for the server to be ready by checking if it responds to requests.
+*/
+async function waitForServer(url, timeout = STARTUP_TIMEOUT) {
+	const startTime = Date.now();
+	while (Date.now() - startTime < timeout) {
+		try {
+			const response = await fetch(url, { signal: AbortSignal.timeout(1e3) });
+			const ok = response.ok;
+			await response.body?.cancel();
+			if (ok) return true;
+		} catch {}
+		await new Promise((resolve) => setTimeout(resolve, 500));
+	}
+	return false;
+}
+async function serverClosure(dir, cmd, defaultPort, callback, releasePort) {
+	await releasePort?.();
+	const serverProcess = $`${cmd.split(" ")}`.cwd(dir).env("PORT", String(defaultPort)).stdin("null").stdout("piped").stderr("piped").noThrow().spawn();
+	serverProcess.catch(() => {});
+	const [stdoutForFile, stdoutForPort] = serverProcess.stdout().tee();
+	const [stderrForFile, stderrForPort] = serverProcess.stderr().tee();
+	const cleanup = new AbortController();
+	const outFile = createWriteStream(join(dir, "out.txt"), { flags: "a" });
+	const errFile = createWriteStream(join(dir, "err.txt"), { flags: "a" });
+	const pipeOutDone = pipeStream(stdoutForFile, outFile, cleanup.signal);
+	const pipeErrDone = pipeStream(stderrForFile, errFile, cleanup.signal);
+	let port = defaultPort;
+	try {
+		port = await determinePort(stdoutForPort, stderrForPort, cleanup.signal).catch((err) => {
+			printErrorMessage`Failed to determine server port: ${err.message}`;
+			printErrorMessage`Use default port ${String(defaultPort)} for lookup.`;
+			return defaultPort;
+		});
+		return await callback(port);
+	} finally {
+		try {
+			serverProcess.kill("SIGKILL");
+		} catch {}
+		cleanup.abort();
+		await Promise.all([pipeOutDone, pipeErrDone]).catch(() => {});
+		await killProcessOnPort(port);
+		outFile.end();
+		errFile.end();
+		await ensurePortReleased(port);
+	}
+}
+function determinePort(stdout, stderr, signal) {
+	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 = "";
+		let streamsEnded = 0;
+		const portPatterns = [
+			/listening on.*:(\d+)/i,
+			/server.*:(\d+)/i,
+			/port\s*:?\s*(\d+)/i,
+			/https?:\/\/localhost:(\d+)/i,
+			/https?:\/\/0\.0\.0\.0:(\d+)/i,
+			/https?:\/\/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;
+		};
+		const onStreamEnd = () => {
+			streamsEnded++;
+			if (streamsEnded === 2) {
+				clearTimeout(timeout);
+				reject(/* @__PURE__ */ new Error("Server exited before port could be determined"));
+			}
+		};
+		const readStream = async (stream, onData) => {
+			const reader = stream.getReader();
+			const onAbort = () => void reader.cancel().catch(() => {});
+			signal?.addEventListener("abort", onAbort, { once: true });
+			const decoder = new TextDecoder();
+			try {
+				while (true) {
+					const { done, value } = await reader.read();
+					if (done) break;
+					onData(decoder.decode(value, { stream: true }));
+				}
+			} catch {} finally {
+				signal?.removeEventListener("abort", onAbort);
+				reader.releaseLock();
+				onStreamEnd();
+			}
+		};
+		readStream(stdout, (chunk) => {
+			stdoutData += chunk;
+			const port = checkForPort(stdoutData);
+			if (port) resolve(port);
+		});
+		readStream(stderr, (chunk) => {
+			stderrData += chunk;
+			const port = checkForPort(stderrData);
+			if (port) resolve(port);
+		});
+	});
+}
+async function pipeStream(readable, writable, signal) {
+	const reader = readable.getReader();
+	const onAbort = () => void reader.cancel().catch(() => {});
+	signal?.addEventListener("abort", onAbort, { once: true });
+	try {
+		while (true) {
+			const { done, value } = await reader.read();
+			if (done) break;
+			writable.write(value);
+		}
+	} catch {} finally {
+		signal?.removeEventListener("abort", onAbort);
+		reader.releaseLock();
+	}
+}
+//#endregion
+export { STARTUP_TIMEOUT, serverClosure, waitForServer };

package/dist/utils.d.ts

@@ -1,7 +1,5 @@
-import { message } from "@optique/core";
 import { toMerged } from "es-toolkit";
-import { spawn } from "node:child_process";
-
+import { message } from "@optique/core";
 //#region src/utils.d.ts
 /** Makes all properties of `T` required and non-nullable. */
 type RequiredNotNull<T> = { [P in keyof T]: NonNullable<T[P]> };

package/dist/utils.js

@@ -1,10 +1,9 @@
 import { isObject } from "@fxts/core";
 import process from "node:process";
 import { print, printError } from "@optique/run";
+import { flow, toMerged } from "es-toolkit";
 import { message } from "@optique/core";
 import { Chalk } from "chalk";
-import { flow, toMerged } from "es-toolkit";
-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,85 +52,10 @@ 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"`). */
 const getOsType = () => process.platform;
-/** Exits the process with the given exit code. */
-const exit = (code) => process.exit(code);
 /**
 * Generates the cartesian product of multiple iterables.
 * Used by the test suite to enumerate all option combinations.
@@ -151,4 +75,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 { CommandError, colors, exit, formatJson, getCwd, getOsType, isNotFoundError, merge$1 as merge, notEmpty, printErrorMessage, printMessage, product, replace, replaceAll, runSubCommand, set };
+export { colors, formatJson, getCwd, getOsType, isNotFoundError, merge$1 as merge, notEmpty, printErrorMessage, printMessage, product, replace, replaceAll, set };

package/dist/webframeworks/astro.js

@@ -1,5 +1,6 @@
 import { PACKAGE_VERSION, readTemplate } from "../lib.js";
 import { PACKAGE_MANAGER } from "../const.js";
+import { npm__astrojs_node, npm__deno_astro_adapter, npm__types_node_22, npm_typescript } from "../json/deps.js";
 import { defaultDenoDependencies, defaultDevDependencies } from "./const.js";
 import { getInstruction } from "./utils.js";
 //#region src/webframeworks/astro.ts
@@ -11,17 +12,17 @@ const astroDescription = {
 		command: Array.from(getAstroInitCommand(pm)),
 		dependencies: pm === "deno" ? {
 			...defaultDenoDependencies,
-			"@deno/astro-adapter": "npm:@deno/astro-adapter@^0.3.2",
+			"@deno/astro-adapter": `npm:@deno/astro-adapter@${npm__deno_astro_adapter}`,
 			"@fedify/astro": PACKAGE_VERSION
 		} : {
-			"@astrojs/node": "^9.5.4",
+			"@astrojs/node": npm__astrojs_node,
 			"@fedify/astro": PACKAGE_VERSION
 		},
 		devDependencies: {
 			...defaultDevDependencies,
 			...pm !== "deno" ? {
-				typescript: "^5.9.3",
-				"@types/node": "^22.17.0"
+				typescript: npm_typescript,
+				"@types/node": npm__types_node_22
 			} : {}
 		},
 		federationFile: "src/federation.ts",
@@ -65,6 +66,7 @@ function* getAstroInitCommand(pm) {
 	yield "--no-git";
 	yield "--skip-houston";
 	yield "-y";
+	if (pm !== "deno") yield "--no-install";
 	yield "&&";
 	yield "rm";
 	yield "astro.config.mjs";