@fedify/cli 2.0.0-pr.479.1922 → 2.0.1

package/dist/init/lib.js

@@ -1,136 +0,0 @@
-
-      import { Temporal } from "@js-temporal/polyfill";
-    
-import deno_default from "../deno.js";
-import { isNotFoundError, runSubCommand } from "../utils.js";
-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 webframeworks_default from "./webframeworks.js";
-import { dirname, join } from "node:path";
-import { mkdir, readdir, writeFile } from "node:fs/promises";
-import { commandLine, message } from "@optique/core/message";
-import process from "node:process";
-import { getLogger } from "@logtape/logtape";
-import { entries, evolve, fromEntries, isObject, map, negate, pipe, throwIf, when } from "@fxts/core";
-import { toMerged } from "es-toolkit";
-import { readFileSync } from "node:fs";
-
-//#region src/init/lib.ts
-const PACKAGE_VERSION = deno_default.version;
-const logger = getLogger([
-	"fedify",
-	"cli",
-	"init"
-]);
-const addFedifyDeps = (json) => Object.fromEntries(Object.entries(json).map(([key, value]) => [key, toMerged(value, { dependencies: { [`@fedify/${key}`]: PACKAGE_VERSION } })]));
-const kvStores = addFedifyDeps(kv_default);
-const messageQueues = addFedifyDeps(mq_default);
-const toRegExp = (str) => new RegExp(str);
-const convertPattern = (obj) => pipe(obj, entries, map(([key, value]) => [key, evolve({ outputPattern: toRegExp })(value)]), fromEntries);
-const packageManagers = convertPattern(pm_default);
-const runtimes = convertPattern(rt_default);
-const getLabel = (name) => pipe(name, whenHasLabel(webframeworks_default), whenHasLabel(packageManagers), whenHasLabel(messageQueues), whenHasLabel(kvStores), whenHasLabel(runtimes));
-const whenHasLabel = (desc) => when((name) => name in desc, (name) => desc[name].label);
-const getInstallUrl = (pm) => packageManagers[pm].installUrl;
-async function isPackageManagerAvailable(pm) {
-	if (await isCommandAvailable(packageManagers[pm])) return true;
-	if (process.platform !== "win32") return false;
-	const cmd = [packageManagers[pm].checkCommand[0] + ".cmd", ...packageManagers[pm].checkCommand.slice(1)];
-	if (await isCommandAvailable({
-		...packageManagers[pm],
-		checkCommand: cmd
-	})) return true;
-	return false;
-}
-const readTemplate = (templatePath) => readFileSync(join(import.meta.dirname, "templates", ...(templatePath + ".tpl").split("/")), "utf8");
-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:${port}/users/john`)}
-
-`;
-const getDevCommand = (pm) => pm === "deno" ? "deno task dev" : pm === "bun" ? "bun dev" : `${pm} run dev`;
-async function isCommandAvailable({ checkCommand, outputPattern }) {
-	try {
-		const { stdout } = await runSubCommand(checkCommand, { stdio: [
-			null,
-			"pipe",
-			null
-		] });
-		logger.debug("The stdout of the command {command} is: {stdout}", {
-			command: checkCommand,
-			stdout
-		});
-		return outputPattern.exec(stdout.trim()) ? true : false;
-	} catch (error) {
-		if (isNotFoundError(error)) return false;
-		logger.debug("The command {command} failed with the error: {error}", {
-			command: checkCommand,
-			error
-		});
-		throw error;
-	}
-}
-async function createFile(path$1, content) {
-	await mkdir(dirname(path$1), { recursive: true });
-	await writeFile(path$1, content);
-}
-const isNotExistsError = (e) => isObject(e) && "code" in e && e.code === "ENOENT";
-const throwUnlessNotExists = throwIf(negate(isNotExistsError));
-const isDirectoryEmpty = async (path$1) => {
-	try {
-		const files = await readdir(path$1);
-		return files.length === 0;
-	} catch (e) {
-		throwUnlessNotExists(e);
-		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),
-	".",
-	"--yes"
-];
-const createNextAppCommand = (pm) => pm === "deno" ? [
-	"deno",
-	"-Ar",
-	"npm:create-next-app@latest"
-] : pm === "bun" ? [
-	"bun",
-	"create",
-	"next-app"
-] : pm === "npm" ? ["npx", "create-next-app"] : [
-	pm,
-	"dlx",
-	"create-next-app"
-];
-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, getDevCommand, getInstallUrl, getInstruction, getLabel, getNextInitCommand, getNitroInitCommand, isDirectoryEmpty, isPackageManagerAvailable, isTest, kvStores, logger, messageQueues, packageManagerToRuntime, readTemplate, throwUnlessNotExists };

package/dist/init/templates/defaults/federation.ts.tpl

@@ -1,23 +0,0 @@
-import { createFederation, Person } from "@fedify/fedify";
-import { getLogger } from "@logtape/logtape";
-/* imports */
-
-const logger = getLogger(/* logger */);
-
-const federation = createFederation({
-  kv: /* kv */,
-  queue: /* queue */,
-});
-
-federation.setActorDispatcher(
-  "/users/{identifier}",
-  async (ctx, identifier) => {
-    return new Person({
-      id: ctx.getActorUri(identifier),
-      preferredUsername: identifier,
-      name: identifier,
-    });
-  },
-);
-
-export default federation;

package/dist/init/templates/defaults/logging.ts.tpl

@@ -1,23 +0,0 @@
-import { configure, getConsoleSink } from "@logtape/logtape";
-import { AsyncLocalStorage } from "node:async_hooks";
-
-await 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/init/templates/express/app.ts.tpl

@@ -1,16 +0,0 @@
-import { integrateFederation } from "@fedify/express";
-import { getLogger } from "@logtape/logtape";
-import express from "express";
-import federation from "./federation.ts";
-
-const logger = getLogger("/* logger */");
-
-export const app = express();
-
-app.set("trust proxy", true);
-
-app.use(integrateFederation(federation, () => undefined));
-
-app.get("/", (_, res) => res.send("Hello, Fedify!"));
-
-export default app;

package/dist/init/templates/express/index.ts.tpl

@@ -1,6 +0,0 @@
-import app from "./app.ts";
-import "./logging.ts";
-
-app.listen(8000, () => {
-  console.log("Server started at http://localhost:8000");
-});

package/dist/init/templates/hono/app.tsx.tpl

@@ -1,14 +0,0 @@
-// @ts-nocheck this file is just a template
-import { Hono } from "/* hono */";
-import { federation } from "@fedify/hono";
-import { getLogger } from "@logtape/logtape";
-import fedi from "./federation.ts";
-
-const logger = getLogger("/* logger */");
-
-const app = new Hono();
-app.use(federation(fedi, () => undefined));
-
-app.get("/", (c) => c.text("Hello, Fedify!"));
-
-export default app;

package/dist/init/templates/hono/index/bun.ts.tpl

@@ -1,10 +0,0 @@
-import { behindProxy } from "x-forwarded-fetch";
-import app from "./app.tsx";
-import "./logging.ts";
-
-const server = Bun.serve({
-  port: 8000,
-  fetch: behindProxy(app.fetch.bind(app)),
-});
-
-console.log("Server started at", server.url.href);

package/dist/init/templates/hono/index/deno.ts.tpl

@@ -1,13 +0,0 @@
-import { behindProxy } from "@hongminhee/x-forwarded-fetch";
-import "@std/dotenv/load";
-import app from "./app.tsx";
-import "./logging.ts";
-
-Deno.serve(
-  {
-    port: 8000,
-    onListen: ({ port, hostname }) =>
-      console.log("Server started at http://" + hostname + ":" + port),
-  },
-  behindProxy(app.fetch.bind(app)),
-);

package/dist/init/templates/hono/index/node.ts.tpl

@@ -1,14 +0,0 @@
-// @ts-nocheck this file is just a template
-import { serve } from "@hono/node-server";
-import { behindProxy } from "x-forwarded-fetch";
-import app from "./app.tsx";
-import "./logging.ts";
-
-serve(
-  {
-    port: 8000,
-    fetch: behindProxy(app.fetch.bind(app)),
-  },
-  (info) =>
-    console.log("Server started at http://" + info.address + ":" + info.port),
-);

package/dist/init/templates/next/middleware.ts.tpl

@@ -1,45 +0,0 @@
-import { fedifyWith } from "@fedify/next";
-import federation from "./federation";
-
-export default fedifyWith(federation)(
-/*
-  function (request: Request) {
-    // If you need to handle other requests besides federation
-    // requests in middleware, you can do it here.
-    // If you handle only federation requests in middleware,
-    // you don't need this function.
-    return NextResponse.next();
-  },
-*/
-)
-
-// This config needs because middleware process only requests with the
-// "Accept" header matching the federation accept regex.
-// More details: https://nextjs.org/docs/app/api-reference/file-conventions/middleware#config-object-optional
-export const config = {
-  runtime: "nodejs",
-  matcher: [
-    {
-      source: "/:path*",
-      has: [
-        {
-          type: "header",
-          key: "Accept",
-          value: ".*application\\/((jrd|activity|ld)\\+json|xrd\\+xml).*",
-        },
-      ],
-    },
-    {
-      source: "/:path*",
-      has: [
-        {
-          type: "header",
-          key: "content-type",
-          value: ".*application\\/((jrd|activity|ld)\\+json|xrd\\+xml).*",
-        },
-      ],
-    },
-    { source: "/.well-known/nodeinfo" },
-    { source: "/.well-known/x-nodeinfo2" },
-  ],
-};

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

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

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

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

package/dist/init/templates/nitro/server/error.ts.tpl

@@ -1,3 +0,0 @@
-import { onError } from "@fedify/h3";
-
-export default onError;

package/dist/init/templates/nitro/server/middleware/federation.ts.tpl

@@ -1,8 +0,0 @@
-
-import { integrateFederation } from "@fedify/h3";
-import federation from "../federation"
-
-export default integrateFederation(
-  federation,
-  (event, request) => undefined,
-);

package/dist/init/test/action.js

@@ -1,17 +0,0 @@
-
-      import { Temporal } from "@js-temporal/polyfill";
-    
-import { set } from "../../utils.js";
-import { fillEmptyOptions } from "./fill.js";
-import run_default 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(logTestDir), tap(when(isDryRun, run_default(true))), tap(when(isHydRun, run_default(false))));
-const isDryRun = ({ dryRun }) => dryRun;
-const isHydRun = ({ hydRun }) => hydRun;
-var action_default = runTestInit;
-
-//#endregion
-export { action_default as default };

package/dist/init/test/create.js

@@ -1,100 +0,0 @@
-
-      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

@@ -1,32 +0,0 @@
-
-      import { Temporal } from "@js-temporal/polyfill";
-    
-import { KV_STORE, MESSAGE_QUEUE, PACKAGE_MANAGER, WEB_FRAMEWORK } from "../const.js";
-import { isEmpty, omit, 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) => pipe(options, (options$1) => "noHydRun" in options$1 ? {
-	...omit(["noHydRun"], options$1),
-	hydRun: !options$1.noHydRun
-} : {
-	...options$1,
-	hydRun: true
-}, (options$1) => "noDryRun" in options$1 ? {
-	...omit(["noDryRun"], options$1),
-	dryRun: !options$1.noDryRun
-} : {
-	...options$1,
-	dryRun: true
-});
-
-//#endregion
-export { fillEmptyOptions };

package/dist/init/test/lookup.js

@@ -1,190 +0,0 @@
-
-      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";
-import { isEmpty } from "@fxts/core/index.js";
-
-//#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 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 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 (isEmpty(hasBanned)) return dirs;
-	const bannedLabels = hasBanned.map((wf) => webframeworks_default[wf]["label"]);
-	printErrorMessage`\n${values(bannedLabels)} is not supported in lookup test 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")} and 
-      ${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,
-			/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 };