@mincraft/cli 1.2.0

package/dist/index.mjs

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+import{Option as I,program as n}from"commander";import*as v from"readline";import{createBot as M}from"mineflayer";import{SocksClient as E}from"socks";var p=class{proxy;client;server;options;logger;isLoggedIn;bot;constructor({proxy:t,client:e,server:o,options:i},s){this.proxy=t,this.client=e,this.server=o,this.options=i,this.logger=s,this.isLoggedIn=!1}async registerAndLogIn(){let t={host:this.server.host,port:this.server.port,username:this.client.account.email,auth:this.client.account.auth,version:this.client.version,hideErrors:!0};this.proxy&&(t.connect=e=>{this.connectViaProxy(e)}),this.bot=M(t),this.options.verboseLogging&&this.registerClientEvents(),this.registerBotEvents()}connectViaProxy(t){this.logger.log("connecting via proxy");let{host:e,port:o,user:i,pass:s,type:a}=this.proxy,c=this.server;E.createConnection({proxy:{host:e,port:o,type:a,userId:i,password:s},command:"connect",destination:{host:c.host,port:c.port},timeout:3e4}).then(l=>{t.setSocket(l.socket),t.emit("connect")}).catch(l=>{this.logger.error(`proxy connection failed: ${l.message}`),t.emit("error",l)})}registerClientEvents(){this.bot._client.on("connect",()=>{this.logger.log("TCP connection established")}),this.bot._client.on("login",()=>{this.logger.log("login packet received")}),this.bot._client.on("error",t=>{this.logger.error(`client error: ${t.message}`)}),this.bot._client.on("end",t=>{this.logger.warn(`client ended: ${t}`)})}registerBotEvents(){this.bot.once("spawn",()=>{let{ign:t,uuid:e}=this.client.account;this.logger.log(`logged in as ${t} (${e})`),this.isLoggedIn=!0}),this.bot.once("kicked",t=>{this.logger.warn(`kicked: ${JSON.stringify(t)}`),this.disconnect()}),this.bot.once("error",t=>{this.logger.error(`bot error: ${t.message}`),this.isLoggedIn=!1}),this.bot.once("end",t=>{this.logger.warn(`disconnected by server: ${JSON.stringify(t)}`),this.disconnect()}),this.options.logMessages&&this.bot.on("messagestr",t=>{let e=t.split(`
+`);if(e.length===1)this.logger.log(t,"chat");else{this.logger.log(e[0],"chat");for(let o=1;o<e.length;o++)this.logger.raw(`          ${e[o]}`)}})}disconnect(){this.bot&&(this.proxy?this.bot._client.socket?.destroy():this.bot.quit(),this.isLoggedIn=!1)}sendMessage(t){this.bot.chat(t)}};import*as u from"readline";function m(r){let t=(o,i="")=>`[mc${i?`/${i}`:""}] ${o}`,e=o=>{r?(u.clearLine(process.stdout,0),u.cursorTo(process.stdout,0),console.log(o),r.prompt(!0)):console.log(o)};return{log:(o,i)=>e(t(o,i)),warn:(o,i="warn")=>e(t(o,i)),error:(o,i="err")=>e(t(o,i)),raw:e}}import*as g from"fs/promises";import*as d from"path";import*as x from"esbuild";async function O(r){let e=(await x.build({entryPoints:[r],bundle:!0,write:!1,platform:"node",format:"esm",target:"es2022",loader:{".ts":"ts"},external:["mineflayer"],logLevel:"silent"})).outputFiles[0].text,o=r.replace(/\.ts$/,".macro.mjs");return await g.writeFile(o,e),o}async function S(r){try{await g.unlink(r)}catch{}}function F(r){return d.isAbsolute(r)?r:d.resolve(process.cwd(),r)}async function k(r){try{return await g.access(r),!0}catch{return!1}}async function b(r,t){let e=F(r),o=e,i=null;try{if(!await k(e))return t.logger.error(`macro file not found: ${e}`),!1;e.endsWith(".ts")&&(t.logger.log("compiling typescript macro"),i=await O(e),o=i);let c=await import(`file://${o}?t=${Date.now()}`);return typeof c.default!="function"?(t.logger.error("macro file must export a default function"),!1):(await c.default(t),!0)}catch(s){return t.logger.error(`could not load macro: ${s.message}`),!1}finally{i&&await S(i)}}var C=(i=>(i.Exit=".exit",i.Logout=".lo",i.Login=".li",i.Macro=".macro",i))(C||{});function w(r){return Object.values(C).some(t=>r.startsWith(t))}async function L(r){let t=null,e=v.createInterface({input:process.stdin,output:process.stdout}),o=m(e);e.setPrompt("> ");let i=async s=>{if(s=s.trim(),!w(s)&&!t?.isLoggedIn){o.raw("log in using .li before sending messages"),e.prompt();return}if(w(s)){let[a,...c]=s.split(" "),l=!1;switch(a){case".exit":{t?.disconnect(),e.close(),l=!0;break}case".li":{t?.isLoggedIn?o.error("client is already logged in"):(t=new p(r,o),t.registerAndLogIn());break}case".lo":{t?.isLoggedIn?t?.disconnect():o.error("client isn't logged in");break}case".macro":{if(!t?.isLoggedIn){o.error("client must be logged in to run macros");break}let f=c.join(" ");if(!f){o.error("usage: .macro <filepath>");break}let y=t.bot;y&&(o.log(`loading macro: ${f}`),await b(f,{bot:y,logger:o}));break}}l&&process.exit(0)}else t?.sendMessage(s);e.prompt()};e.on("line",i),console.log("=== mincraft REPL ==="),console.log("input plain text to send a message to the server"),console.log(`input .li to log in to ${r.server.host}`),console.log(`input .lo to log out from ${r.server.host}`),console.log("input .macro <filepath> to run a macro"),console.log("input .exit to exit the REPL"),e.prompt()}n.name("mincraft").description("Mineflayer CLI tool with supports for macros and proxies.").version("1.0.0").addHelpText("after",`
+Examples:
+$ mincraft mc.hypixel.net 1.21.4 --ign FuriousDestroyer --email you@example.com
+$ mincraft mythic.gg 1.7.10 -p 58585 --ign MangoSyrup --email you@example.com --prox proxy.com:1234:mango:secret
+`);n.argument("<host>","Server hostname").option("-p, --port <PORT>","Server port",r=>parseInt(r,10),25565);n.argument("<version>","Client version, e.g. 1.21.4");var P=["host","port","user","pass"],$=":";n.option("--prox <HOST:PORT:USER:PASS>","Connect to the server with a proxy").option("--prox-field-order <FORMAT>",'The order of the proxy credential fields, e.g. "user,pass,host,port".').option("--prox-field-sep <SEP>","The separator of the proxy credential fields").option("--prox-type <4|5>","The SOCKS proxy type",r=>parseInt(r,10),5);var T="microsoft";n.addOption(new I("--ign <IN-GAME NAME>","Player username").conflicts("uuid")).addOption(new I("--uuid <UUID>","Player UUID").conflicts("ign")).requiredOption("--email <EMAIL>","Account email").option("--auth <AUTH>","Account authentication method",T);n.option("--no-log-messages","Do not log messages your client receives").option("--verbose","Enable additional logging messages");n.action(async(r,t,e)=>{if(!e.ign&&!e.uuid&&n.error("error: must specify either --ign or --uuid"),e.proxFieldOrder){let i=e.proxyFieldSep??$;e.proxFieldOrder.split(i).every(a=>P.includes(a))||n.error("error: --prox-field-order includes invalid fields")}let o=await B(n);await L(o)});async function A(r){let e=await(await fetch(`https://sessionserver.mojang.com/session/minecraft/profile/${r}`)).json();if(!e?.name)throw new Error("Could not fetch IGN from UUID");return e.name}async function U(r){let e=await(await fetch(`https://api.mojang.com/users/profiles/minecraft/${r}`)).json();if(!e?.id)throw new Error("Could not fetch UUID from IGN");return e.id}function j(r,t,e){let o=r.split(e),i=Object.fromEntries(t.map((s,a)=>[s,o[a]]));return i.port=+i.port,i}async function B(r){let t=r.args,e=r.opts();return{server:{host:t[0],port:e.port},client:{version:t[1],account:{auth:e.auth,uuid:e.uuid??await U(e.ign),ign:e.ign??await A(e.uuid),email:e.email}},...e.prox?{proxy:{...j(e.prox,e.proxFieldOrder??P,e.proxFieldSep??$),type:e.proxType}}:{},options:{logMessages:e.noLogMessages??!0,verboseLogging:e.verbose??!1}}}var h=m(),Y=h.log,Z=h.warn,ee=h.error;n.parse();export{h as defaultLogger,ee as error,Y as log,Z as warn};

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "@mincraft/cli",
+  "version": "1.2.0",
+  "description": "Mineflayer CLI tool with support for macros and proxies",
+  "bin": {
+    "mincraft": "./dist/index.mjs"
+  },
+  "keywords": [
+    "minecraft",
+    "mineflayer",
+    "cli",
+    "macros"
+  ],
+  "dependencies": {
+    "@inquirer/prompts": "^8.1.0",
+    "commander": "^14.0.2",
+    "esbuild": "^0.27.2",
+    "mineflayer": "^4.33.0",
+    "socks": "^2.8.7",
+    "@mincraft/types": "1.2.0"
+  },
+  "devDependencies": {
+    "@types/debug": "^4.1.12",
+    "@types/node": "^25.0.3",
+    "tsup": "^8.5.1"
+  },
+  "scripts": {
+    "dev": "tsup src/index.ts --watch",
+    "build": "tsup"
+  }
+}

package/src/bot.ts

@@ -0,0 +1,146 @@
+import type { Config, Logger } from "@mincraft/types";
+import { type Bot, type BotOptions, createBot } from "mineflayer";
+import { SocksClient } from "socks";
+
+export class BotClient {
+	public proxy: Config["proxy"];
+	public client: Config["client"];
+	public server: Config["server"];
+	public options: Config["options"];
+	public logger: Logger;
+
+	public isLoggedIn: boolean;
+	public bot: Bot;
+
+	public constructor(
+		{ proxy, client, server, options }: Config,
+		logger: Logger,
+	) {
+		this.proxy = proxy;
+		this.client = client;
+		this.server = server;
+		this.options = options;
+		this.logger = logger;
+
+		this.isLoggedIn = false;
+	}
+
+	public async registerAndLogIn() {
+		const botOptions: BotOptions = {
+			host: this.server.host,
+			port: this.server.port,
+			username: this.client.account.email,
+			auth: this.client.account.auth as BotOptions["auth"],
+			version: this.client.version,
+			hideErrors: true,
+		};
+
+		if (this.proxy) {
+			botOptions.connect = (client) => {
+				this.connectViaProxy(client);
+			};
+		}
+
+		this.bot = createBot(botOptions);
+		if (this.options.verboseLogging) {
+			this.registerClientEvents();
+		}
+		this.registerBotEvents();
+	}
+
+	private connectViaProxy(client: any) {
+		this.logger.log("connecting via proxy");
+		const { host, port, user: userId, pass: password, type } = this.proxy;
+		const destination = this.server;
+
+		SocksClient.createConnection({
+			proxy: {
+				host,
+				port,
+				type,
+				userId,
+				password,
+			},
+			command: "connect",
+			destination: { host: destination.host, port: destination.port },
+			timeout: 30000,
+		})
+			.then((info) => {
+				client.setSocket(info.socket);
+				client.emit("connect");
+			})
+			.catch((err) => {
+				this.logger.error(`proxy connection failed: ${err.message}`);
+				client.emit("error", err);
+			});
+	}
+
+	private registerClientEvents() {
+		this.bot._client.on("connect", () => {
+			this.logger.log("TCP connection established");
+		});
+
+		this.bot._client.on("login", () => {
+			this.logger.log("login packet received");
+		});
+
+		this.bot._client.on("error", (err) => {
+			this.logger.error(`client error: ${err.message}`);
+		});
+
+		this.bot._client.on("end", (reason) => {
+			this.logger.warn(`client ended: ${reason}`);
+		});
+	}
+
+	private registerBotEvents() {
+		this.bot.once("spawn", () => {
+			const { ign, uuid } = this.client.account;
+			this.logger.log(`logged in as ${ign} (${uuid})`);
+			this.isLoggedIn = true;
+		});
+
+		this.bot.once("kicked", (reason) => {
+			this.logger.warn(`kicked: ${JSON.stringify(reason)}`);
+			this.disconnect();
+		});
+
+		this.bot.once("error", (err) => {
+			this.logger.error(`bot error: ${err.message}`);
+			this.isLoggedIn = false;
+		});
+
+		this.bot.once("end", (reason) => {
+			this.logger.warn(`disconnected by server: ${JSON.stringify(reason)}`);
+			this.disconnect();
+		});
+
+		if (this.options.logMessages) {
+			this.bot.on("messagestr", (message: string) => {
+				const lines = message.split("\n");
+				if (lines.length === 1) {
+					this.logger.log(message, "chat");
+				} else {
+					this.logger.log(lines[0], "chat");
+					for (let i = 1; i < lines.length; i++) {
+						this.logger.raw(`          ${lines[i]}`);
+					}
+				}
+			});
+		}
+	}
+
+	public disconnect() {
+		if (!this.bot) return;
+		if (this.proxy) {
+			this.bot._client.socket?.destroy();
+		} else {
+			this.bot.quit();
+		}
+		this.isLoggedIn = false;
+	}
+
+	public sendMessage(msg: string) {
+		this.bot.chat(msg);
+	}
+}

package/src/cli.ts

@@ -0,0 +1,164 @@
+import type { Config, ProxyCredentials } from "@mincraft/types";
+import { type Command, Option, program } from "commander";
+import { run } from "./runner";
+
+// meta
+program
+	.name("mincraft")
+	.description("Mineflayer CLI tool with supports for macros and proxies.")
+	.version("1.0.0")
+	.addHelpText(
+		"after",
+		`
+Examples:
+$ mincraft mc.hypixel.net 1.21.4 --ign FuriousDestroyer --email you@example.com
+$ mincraft mythic.gg 1.7.10 -p 58585 --ign MangoSyrup --email you@example.com --prox proxy.com:1234:mango:secret
+`,
+	);
+
+// server
+program
+	.argument("<host>", "Server hostname")
+	.option(
+		"-p, --port <PORT>",
+		"Server port",
+		(val) => parseInt(val, 10),
+		25565,
+	);
+
+// client version
+program.argument("<version>", "Client version, e.g. 1.21.4");
+
+// proxy
+const proxyFieldsInOrder = ["host", "port", "user", "pass"];
+const defaultProxyFieldSep = ":";
+program
+	.option("--prox <HOST:PORT:USER:PASS>", "Connect to the server with a proxy")
+	.option(
+		"--prox-field-order <FORMAT>",
+		'The order of the proxy credential fields, e.g. "user,pass,host,port".',
+	)
+	.option(
+		"--prox-field-sep <SEP>",
+		"The separator of the proxy credential fields",
+	)
+	.option(
+		"--prox-type <4|5>",
+		"The SOCKS proxy type",
+		(val) => parseInt(val, 10),
+		5,
+	);
+
+// account
+const defaultAuthenticationMethod = "microsoft";
+program
+	.addOption(
+		new Option("--ign <IN-GAME NAME>", "Player username").conflicts("uuid"),
+	)
+	.addOption(new Option("--uuid <UUID>", "Player UUID").conflicts("ign"))
+	.requiredOption("--email <EMAIL>", "Account email")
+	.option(
+		"--auth <AUTH>",
+		"Account authentication method",
+		defaultAuthenticationMethod,
+	);
+
+// extra options
+program
+	.option("--no-log-messages", "Do not log messages your client receives")
+	.option("--verbose", "Enable additional logging messages");
+
+program.action(async (_host, _version, options) => {
+	if (!options.ign && !options.uuid) {
+		program.error("error: must specify either --ign or --uuid");
+	}
+
+	if (options.proxFieldOrder) {
+		const proxyFieldSep = options.proxyFieldSep ?? defaultProxyFieldSep;
+		const proxyFieldNames: string[] =
+			options.proxFieldOrder.split(proxyFieldSep);
+		if (!proxyFieldNames.every((field) => proxyFieldsInOrder.includes(field))) {
+			program.error("error: --prox-field-order includes invalid fields");
+		}
+	}
+
+	const config = await getConfig(program);
+	await run(config);
+});
+
+async function getIGN(uuid: string) {
+	const res = await fetch(
+		`https://sessionserver.mojang.com/session/minecraft/profile/${uuid}`,
+	);
+	const data = (await res.json()) as { name?: string };
+	if (!data?.name) {
+		throw new Error("Could not fetch IGN from UUID");
+	}
+
+	return data.name;
+}
+
+async function getUUID(ign: string) {
+	const res = await fetch(
+		`https://api.mojang.com/users/profiles/minecraft/${ign}`,
+	);
+	const data = (await res.json()) as { id?: string };
+	if (!data?.id) {
+		throw new Error("Could not fetch UUID from IGN");
+	}
+
+	return data.id;
+}
+
+function resolveProxyCredentials(
+	proxyString: string,
+	fieldOrder: string[],
+	fieldSep: string,
+) {
+	const proxyParts = proxyString.split(fieldSep);
+	const credentials = Object.fromEntries(
+		fieldOrder.map((field, i) => [field, proxyParts[i]]),
+	) as unknown as ProxyCredentials;
+	credentials.port = +credentials.port;
+
+	return credentials;
+}
+
+async function getConfig(p: Command): Promise<Config> {
+	const args = p.args;
+	const opts = p.opts();
+
+	return {
+		server: {
+			host: args[0],
+			port: opts.port,
+		},
+		client: {
+			version: args[1],
+			account: {
+				auth: opts.auth,
+				uuid: opts.uuid ?? (await getUUID(opts.ign)),
+				ign: opts.ign ?? (await getIGN(opts.uuid)),
+				email: opts.email,
+			},
+		},
+		...(opts.prox
+			? {
+					proxy: {
+						...resolveProxyCredentials(
+							opts.prox,
+							opts.proxFieldOrder ?? proxyFieldsInOrder,
+							opts.proxFieldSep ?? defaultProxyFieldSep,
+						),
+						type: opts.proxType,
+					},
+				}
+			: {}),
+		options: {
+			logMessages: opts.noLogMessages ?? true,
+			verboseLogging: opts.verbose ?? false,
+		},
+	};
+}
+
+export { program };

package/src/index.ts

@@ -0,0 +1,9 @@
+import { program } from "./cli.js";
+import { createLogger } from "./logger.js";
+
+export const defaultLogger = createLogger();
+export const log = defaultLogger.log;
+export const warn = defaultLogger.warn;
+export const error = defaultLogger.error;
+
+program.parse();

package/src/logger.ts

@@ -0,0 +1,25 @@
+import * as readline from "node:readline";
+import type { Logger } from "@mincraft/types";
+
+export function createLogger(rl?: readline.Interface): Logger {
+	const format = (msg: string, scope = "") =>
+		`[mc${scope ? `/${scope}` : ""}] ${msg}`;
+
+	const write = (msg: string) => {
+		if (rl) {
+			readline.clearLine(process.stdout, 0);
+			readline.cursorTo(process.stdout, 0);
+			console.log(msg);
+			rl.prompt(true);
+		} else {
+			console.log(msg);
+		}
+	};
+
+	return {
+		log: (msg: string, scope?: string) => write(format(msg, scope)),
+		warn: (msg: string, scope = "warn") => write(format(msg, scope)),
+		error: (msg: string, scope = "err") => write(format(msg, scope)),
+		raw: write,
+	};
+}

package/src/macro.ts

@@ -0,0 +1,85 @@
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import type { MacroContext, MacroModule } from "@mincraft/types";
+import * as esbuild from "esbuild";
+
+async function compileToJS(filepath: string) {
+	const result = await esbuild.build({
+		entryPoints: [filepath],
+		bundle: true,
+		write: false,
+		platform: "node",
+		format: "esm",
+		target: "es2022",
+		loader: { ".ts": "ts" },
+		external: ["mineflayer"],
+		logLevel: "silent",
+	});
+
+	const jsCode = result.outputFiles[0].text;
+	const jsFilePath = filepath.replace(/\.ts$/, ".macro.mjs");
+	await fs.writeFile(jsFilePath, jsCode);
+
+	return jsFilePath;
+}
+
+async function removeCompiledFile(filepath: string) {
+	try {
+		await fs.unlink(filepath);
+	} catch {}
+}
+
+function resolveMacroPath(filepath: string) {
+	if (path.isAbsolute(filepath)) {
+		return filepath;
+	}
+	return path.resolve(process.cwd(), filepath);
+}
+
+async function fileExists(filepath: string) {
+	try {
+		await fs.access(filepath);
+		return true;
+	} catch {
+		return false;
+	}
+}
+
+export async function loadAndRunMacro(filepath: string, ctx: MacroContext) {
+	const absolutePath = resolveMacroPath(filepath);
+	let importPath = absolutePath;
+	let compiledPath: string = null;
+
+	try {
+		if (!(await fileExists(absolutePath))) {
+			ctx.logger.error(`macro file not found: ${absolutePath}`);
+			return false;
+		}
+
+		const isTypescriptFile = absolutePath.endsWith(".ts");
+
+		if (isTypescriptFile) {
+			ctx.logger.log("compiling typescript macro");
+			compiledPath = await compileToJS(absolutePath);
+			importPath = compiledPath;
+		}
+
+		const fileUrl = `file://${importPath}?t=${Date.now()}`;
+		const module = (await import(fileUrl)) as MacroModule;
+
+		if (typeof module.default !== "function") {
+			ctx.logger.error("macro file must export a default function");
+			return false;
+		}
+
+		await module.default(ctx);
+		return true;
+	} catch (err) {
+		ctx.logger.error(`could not load macro: ${(err as Error).message}`);
+		return false;
+	} finally {
+		if (compiledPath) {
+			await removeCompiledFile(compiledPath);
+		}
+	}
+}

package/src/runner.ts

@@ -0,0 +1,106 @@
+import * as readline from "node:readline";
+import type { Config } from "@mincraft/types";
+import { BotClient } from "./bot";
+import { createLogger } from "./logger";
+import { loadAndRunMacro } from "./macro";
+
+export enum BotCommand {
+	Exit = ".exit",
+	Logout = ".lo",
+	Login = ".li",
+	Macro = ".macro",
+}
+
+function isCommand(value: string) {
+	return Object.values(BotCommand).some((cmd) => value.startsWith(cmd));
+}
+
+export async function run(config: Config) {
+	let bot: BotClient | null = null;
+
+	const rl = readline.createInterface({
+		input: process.stdin,
+		output: process.stdout,
+	});
+
+	const logger = createLogger(rl);
+
+	rl.setPrompt("> ");
+
+	const handleInput = async (input: string) => {
+		input = input.trim();
+
+		if (!isCommand(input) && !bot?.isLoggedIn) {
+			logger.raw("log in using .li before sending messages");
+			rl.prompt();
+			return;
+		}
+
+		if (isCommand(input)) {
+			const [cmd, ...args] = input.split(" ");
+			let exit = false;
+
+			switch (cmd) {
+				case BotCommand.Exit: {
+					bot?.disconnect();
+					rl.close();
+					exit = true;
+					break;
+				}
+				case BotCommand.Login: {
+					if (bot?.isLoggedIn) {
+						logger.error("client is already logged in");
+					} else {
+						bot = new BotClient(config, logger);
+						bot.registerAndLogIn();
+					}
+					break;
+				}
+				case BotCommand.Logout: {
+					if (!bot?.isLoggedIn) {
+						logger.error("client isn't logged in");
+					} else {
+						bot?.disconnect();
+					}
+					break;
+				}
+				case BotCommand.Macro: {
+					if (!bot?.isLoggedIn) {
+						logger.error("client must be logged in to run macros");
+						break;
+					}
+					const filepath = args.join(" ");
+					if (!filepath) {
+						logger.error("usage: .macro <filepath>");
+						break;
+					}
+					const mineflayer = bot.bot;
+					if (mineflayer) {
+						logger.log(`loading macro: ${filepath}`);
+						await loadAndRunMacro(filepath, { bot: mineflayer, logger });
+					}
+					break;
+				}
+			}
+
+			if (exit) {
+				process.exit(0);
+			}
+		} else {
+			bot?.sendMessage(input);
+		}
+
+		rl.prompt();
+	};
+
+	rl.on("line", handleInput);
+
+	console.log("=== mincraft REPL ===");
+	console.log("input plain text to send a message to the server");
+	console.log(`input .li to log in to ${config.server.host}`);
+	console.log(`input .lo to log out from ${config.server.host}`);
+	console.log("input .macro <filepath> to run a macro");
+	console.log("input .exit to exit the REPL");
+
+	rl.prompt();
+}

package/tsconfig.json

@@ -0,0 +1,11 @@
+{
+	"compilerOptions": {
+		"target": "ES2022",
+		"lib": ["ES2023"],
+		"module": "NodeNext",
+		"moduleResolution": "NodeNext",
+		"types": ["node"]
+	},
+	"include": ["src/**/*.ts"],
+	"exclude": ["node_modules"]
+}

package/tsup.config.ts

@@ -0,0 +1,11 @@
+import { defineConfig } from "tsup";
+
+export default defineConfig({
+	entry: ["src/index.ts"],
+	format: ["esm"],
+	clean: true,
+	minify: true,
+	banner: {
+		js: "#!/usr/bin/env node",
+	},
+});