cluaupp 0.1.1 → 0.1.4

package/src/architecture.js

@@ -3,6 +3,7 @@
 const path = require("path");
 const { emit } = require("./emit");
 const { collectLibraries, insertRequires, requireCluauppLib } = require("./libs");
+const { organizeDecls, janitorNames, emitSection, joinBlocks, SECTION, ENTRY_FN } = require("./layout");
 const {
 	VALUE_CLASSES,
 	analyze,
@@ -27,9 +28,9 @@ function cluauppLib(name) {
 
 function emitTypes(plan) {
 	const lines = [header(plan).trimEnd(), ""];
-	lines.push('local ReplicatedStorage = game:GetService("ReplicatedStorage")');
-	lines.push(`local Occlude = ${cluauppLib("Occlude")}`);
-	lines.push(`local ArrayIndexer = ${cluauppLib("ArrayIndexer")}`);
+	lines.push('const ReplicatedStorage = game:GetService("ReplicatedStorage")');
+	lines.push(`const Occlude = ${cluauppLib("Occlude")}`);
+	lines.push(`const ArrayIndexer = ${cluauppLib("ArrayIndexer")}`);
 	lines.push("");
 
 	if (plan.stats.length > 0) {
@@ -60,6 +61,7 @@ function emitTypes(plan) {
 		manifest.push("		Get: (player: Player) -> PlayerCache?,");
 		manifest.push("		Ensure: (player: Player) -> PlayerCache,");
 		manifest.push("		Clear: (player: Player) -> (),");
+		manifest.push("		ClearAll: () -> (),");
 		manifest.push("	},");
 	}
 	if (plan.roles.players) {
@@ -100,23 +102,26 @@ function emitTypes(plan) {
 }
 
 function emitPlayersManager(plan) {
-	return `${header(plan)}
-local Players = game:GetService("Players")
-local ReplicatedStorage = game:GetService("ReplicatedStorage")
-local Janitor = ${cluauppLib("Janitor")}
-type Janitor = Janitor.Janitor
+	return `${header(plan).trimEnd()}
+
+const Players = game:GetService("Players")
+const ReplicatedStorage = game:GetService("ReplicatedStorage")
+const Janitor = ${cluauppLib("Janitor")}
 
+type Janitor = Janitor.Janitor
 export type PlayerHandler = (player: Player) -> ()
 
 local PlayersManager = {}
 local lifetime: Janitor? = nil
+local leaveHandler: PlayerHandler? = nil
 
 function PlayersManager.Start(onPlayer: PlayerHandler, onLeave: PlayerHandler?)
 	PlayersManager.Stop()
 	local janitor = Janitor.new()
 	lifetime = janitor
+	leaveHandler = onLeave
 
-	local function accept(player: Player)
+	const function accept(player: Player)
 		onPlayer(player)
 	end
 
@@ -134,6 +139,13 @@ function PlayersManager.Stop()
 	if lifetime == nil then
 		return
 	end
+	local onLeave = leaveHandler
+	leaveHandler = nil
+	if onLeave then
+		for _, player in Players:GetPlayers() do
+			onLeave(player)
+		end
+	end
 	lifetime:Cleanup()
 	lifetime = nil
 end
@@ -146,11 +158,11 @@ function emitCacheController(plan) {
 	const types = plan.typesName;
 	const folder = plan.folderName || "leaderstats";
 	const lines = [header(plan).trimEnd(), ""];
-	lines.push(`local Types = require(script.Parent.${types})`);
+	lines.push(`const Types = require(script.Parent.${types})`);
 	lines.push("");
-	lines.push(`local FOLDER_NAME = "${folder}"`);
-	lines.push("local cache: { [Player]: Types.PlayerCache } = {}");
+	lines.push(`const FOLDER_NAME = "${folder}"`);
 	lines.push("");
+	lines.push("local cache: { [Player]: Types.PlayerCache } = {}");
 	lines.push("local CacheController = {}");
 	lines.push("");
 	lines.push("function CacheController.Get(player: Player): Types.PlayerCache?");
@@ -201,6 +213,10 @@ function emitCacheController(plan) {
 	lines.push("	cache[player] = nil");
 	lines.push("end");
 	lines.push("");
+	lines.push("function CacheController.ClearAll()");
+	lines.push("	table.clear(cache)");
+	lines.push("end");
+	lines.push("");
 	lines.push("return CacheController");
 	lines.push("");
 	return lines.join("\n");
@@ -209,13 +225,13 @@ function emitCacheController(plan) {
 function emitMain(plan) {
 	const lines = [header(plan).trimEnd(), ""];
 	if (plan.roles.players) {
-		lines.push("local PlayersManager = require(script.Parent.PlayersManager)");
+		lines.push("const PlayersManager = require(script.Parent.PlayersManager)");
 	}
 	if (plan.roles.cache) {
-		lines.push("local CacheController = require(script.Parent.CacheController)");
+		lines.push("const CacheController = require(script.Parent.CacheController)");
 	}
 	if (plan.roles.domain) {
-		lines.push(`local ${plan.roles.domain} = require(script.Parent.${plan.roles.domain})`);
+		lines.push(`const ${plan.roles.domain} = require(script.Parent.${plan.roles.domain})`);
 	}
 	lines.push("");
 	lines.push("local Main = {}");
@@ -242,9 +258,15 @@ function emitMain(plan) {
 	if (plan.roles.domain) {
 		lines.push(`	${plan.roles.domain}.Stop()`);
 	}
+	if (plan.roles.cache) {
+		lines.push("	CacheController.ClearAll()");
+	}
 	if (plan.roles.players) {
 		lines.push("	PlayersManager.Stop()");
 	}
+	if (!plan.roles.domain && !plan.roles.cache && !plan.roles.players) {
+		lines.push("	return");
+	}
 	lines.push("end");
 	lines.push("");
 	lines.push("return Main");
@@ -258,6 +280,10 @@ function emitBootstrap(plan) {
 }
 
 function emitConfig(plan, ast, options) {
+	const owned = (ast.body || []).some((decl) => decl.owner);
+	if (owned) {
+		return `${header(plan).trimEnd()}\n\n${emit(ast, { ...options, skipHeader: true, skipInit: true }).trimEnd()}\n`;
+	}
 	const lines = [];
 	if (plan.onlyConsts) {
 		lines.push(header(plan).trimEnd());
@@ -282,48 +308,54 @@ function emitConfig(plan, ast, options) {
 	}
 	if ((ast.body || []).some((decl) => decl.type === "function" && decl.name === "init")) {
 		lines.push("	Start = init,");
+		lines.push("	Init = init,");
+		lines.push("	init = init,");
 	}
 	lines.push("}");
 	lines.push("");
 	return lines.join("\n");
 }
 
+function emitDecls(decls, options) {
+	if (!decls || decls.length === 0) {
+		return "";
+	}
+	return emit({ type: "program", body: decls }, { ...options, skipHeader: true, skipInit: true }).trimEnd();
+}
+
 function emitDomainController(plan, ast, options) {
-	const absorbCache = plan.roles.cache;
 	const keep = (ast.body || []).filter((decl) => {
-		if (decl.type === "decl" || decl.type === "proto") {
-			return true;
-		}
-		if (decl.type !== "function") {
-			return false;
-		}
-		if (decl.name === "init") {
-			return true;
-		}
-		const classified = plan.functions.find((item) => item.name === decl.name);
-		if (absorbCache && classified && classified.absorb === "cache") {
-			return false;
-		}
-		return true;
+		return decl.type === "decl" || decl.type === "proto" || decl.type === "function" || decl.type === "expr";
 	});
+	const groups = organizeDecls(keep);
 	const subset = { type: "program", body: keep };
-	const code = emit(subset, { ...options, skipHeader: true, skipInit: true }).trimEnd();
 	const name = plan.roles.domain;
 	const libs = collectLibraries(options.source || "", subset);
-	const body = `${header(plan)}${code}
-
-local ${name} = {}
-
-function ${name}.Start()
-	${keep.some((decl) => decl.type === "function" && decl.name === "init") ? "init()" : "return"}
-end
-
-function ${name}.Stop()
-	return
-end
-
-return ${name}
-`;
+	const entry = keep.find((decl) => decl.type === "function" && ENTRY_FN.test(decl.name || ""));
+	const bootExprs = keep.filter((decl) => decl.type === "expr");
+	const janitors = janitorNames(keep);
+	const closer = keep.find((decl) => decl.type === "function" && /^(OnClose|Cleanup|Shutdown)$/i.test(decl.name));
+	const stopLines = [];
+	if (janitors.length > 0) {
+		for (const janitor of janitors) {
+			stopLines.push(`	${janitor}:Cleanup()`);
+		}
+	} else if (closer) {
+		stopLines.push(`	${closer.name}()`);
+	} else {
+		stopLines.push("	return");
+	}
+	const boot = entry
+		? `	${entry.name}()`
+		: bootExprs.length
+			? emitDecls(bootExprs, options)
+					.split("\n")
+					.map((line) => (line ? `\t${line}` : line))
+					.join("\n")
+			: "	return";
+	const startFn = `function ${name}.Start()\n	${name}.Stop()\n${boot}\nend`;
+	const stopFn = `function ${name}.Stop()\n${stopLines.join("\n")}\nend`;
+	const body = `${header(plan).trimEnd()}\n\n${emitSection(SECTION.api, emitDecls(groups.api, options))}${emitSection(SECTION.constants, emitDecls(groups.constants, options))}${emitSection(SECTION.variables, joinBlocks([emitDecls(groups.variables, options), `local ${name} = {}`]))}${emitSection(SECTION.support, emitDecls(groups.support, options))}${emitSection(SECTION.principal, joinBlocks([emitDecls(groups.principal, options), startFn]))}${emitSection(SECTION.cleanup, joinBlocks([emitDecls(groups.cleanup, options), stopFn]))}${emitSection(SECTION.returns, `return ${name}`)}`;
 	return insertRequires(body, libs);
 }
 
@@ -331,10 +363,34 @@ function emitModule(plan, ast, options) {
 	return emitConfig(plan, ast, options);
 }
 
+function emitScriptMeta(runContext) {
+	return `${JSON.stringify(
+		{
+			className: "Script",
+			properties: {
+				RunContext: `Enum.RunContext.${runContext}`,
+			},
+		},
+		null,
+		"\t",
+	)}\n`;
+}
+
+function serviceBootName(plan) {
+	if (plan.isClient) {
+		return "init.client.luau";
+	}
+	return "init.luau";
+}
+
 function serviceFiles(plan, ast, options, dir) {
 	const folder = `${dir}/${plan.serviceName}`;
-	const boot = plan.isClient ? "init.client.luau" : "init.server.luau";
-	const files = [{ name: `${folder}/${boot}`, contents: emitBootstrap(plan) }, { name: `${folder}/Main.luau`, contents: emitMain(plan) }];
+	const boot = serviceBootName(plan);
+	const files = [{ name: `${folder}/${boot}`, contents: emitBootstrap(plan) }];
+	if (!plan.isClient && plan.runContext) {
+		files.push({ name: `${folder}/init.meta.json`, contents: emitScriptMeta(plan.runContext) });
+	}
+	files.push({ name: `${folder}/Main.luau`, contents: emitMain(plan) });
 	if (plan.roles.players) {
 		files.push({ name: `${folder}/PlayersManager.luau`, contents: emitPlayersManager(plan) });
 	}
@@ -365,11 +421,15 @@ function planOutput(ast, fileName, options = {}) {
 
 	if (plan.kind === "service") {
 		const serviceDir = outDir || (plan.isClient ? "client" : "server");
+		const folder = `${serviceDir}/${plan.serviceName}`;
+		const stale = plan.isClient
+			? [`${folder}/init.luau`, `${folder}/init.server.luau`, `${folder}/init.meta.json`]
+			: [`${folder}/init.server.luau`, `${folder}/init.client.luau`];
 		return {
 			kind: "service",
 			plan,
 			files: serviceFiles(plan, ast, options, serviceDir),
-			stale: [rel.replace(/\.(cpp|cc|cxx|c|h|hpp|hh)$/i, ".luau")],
+			stale,
 		};
 	}
 

package/src/cli.js

@@ -3,7 +3,8 @@
 const fs = require("fs");
 const path = require("path");
 const { compileService } = require("./compile");
-const { isSourceFile, isHeaderFile, toLuauPath } = require("./preprocess");
+const { isSourceFile, isHeaderFile, toLuauPath, siblingImplementation } = require("./preprocess");
+const { syncEditorSupport, installEditorSupport } = require("./intellisense");
 const pkg = require("../package.json");
 
 function printHelp() {
@@ -13,6 +14,8 @@ Usage:
   cluaupp init [folder]    create a game (src/server, src/client, src/shared)
   cluaupp build [folder]   transpile src → out (PascalCase services)
   cluaupp watch [folder]   rebuild on save
+  cluaupp lsp [folder]     language server (stdio JSON-RPC)
+  cluaupp intellisense     install Cursor/VS Code IntelliSense
   cluaupp --version        print version
   cluaupp --help           this help
 
@@ -47,8 +50,11 @@ function tryRm(target) {
 	}
 }
 
-function copyFileIfChanged(src, dest) {
-	if (fs.existsSync(dest)) {
+function copyFileIfChanged(src, dest, mode = "fill") {
+	if (mode === "fill" && fs.existsSync(dest)) {
+		return;
+	}
+	if (mode === "update" && fs.existsSync(dest)) {
 		const from = fs.statSync(src);
 		const to = fs.statSync(dest);
 		if (from.size === to.size && from.mtimeMs <= to.mtimeMs) {
@@ -67,7 +73,7 @@ function copyFileIfChanged(src, dest) {
 	}
 }
 
-function syncDir(from, to) {
+function syncDir(from, to, mode = "fill") {
 	if (!fs.existsSync(from)) {
 		return;
 	}
@@ -76,9 +82,9 @@ function syncDir(from, to) {
 		const src = path.join(from, entry.name);
 		const dest = path.join(to, entry.name);
 		if (entry.isDirectory()) {
-			syncDir(src, dest);
+			syncDir(src, dest, mode);
 		} else {
-			copyFileIfChanged(src, dest);
+			copyFileIfChanged(src, dest, mode);
 		}
 	}
 }
@@ -141,7 +147,7 @@ function collectFiles(dir, files = []) {
 }
 
 function siblingCpp(file) {
-	return file.replace(/\.(h|hpp|hh)$/i, ".cpp");
+	return siblingImplementation(file) || file.replace(/\.(h|hpp|hh)$/i, ".cpp");
 }
 
 function resolveKey(file) {
@@ -214,29 +220,13 @@ function pruneOut(root, config, written, failedPrefixes) {
 	removeEmptyOutDirs(outDir, root);
 }
 
-function build(root, options = {}) {
-	const exitOnError = options.exitOnError !== false;
-	const syncVendor = options.syncVendor !== false;
-	const config = loadConfig(root);
-	if (syncVendor) {
-		copyRuntime(root);
-		copyHeaders(root);
-	}
+function compileProject(root, config) {
 	const srcDir = path.join(root, config.rootDir);
 	const files = collectCpp(srcDir);
-	if (files.length === 0) {
-		console.error("no .cpp/.h/.hpp files in", config.rootDir);
-		pruneOut(root, config, new Set(), []);
-		if (exitOnError) {
-			process.exit(1);
-		}
-		return { failed: 0, written: new Set() };
-	}
-
 	const fileSet = new Set(files.map((file) => path.resolve(file)));
-	let failed = 0;
-	const written = new Set();
-	const failedPrefixes = [];
+	const jobs = [];
+	const errors = [];
+
 	for (const file of files) {
 		if (isHeaderFile(file) && fileSet.has(path.resolve(siblingCpp(file)))) {
 			continue;
@@ -251,48 +241,166 @@ function build(root, options = {}) {
 				outName: toLuauPath(rel),
 				architecture: config.architecture !== false,
 				includeDirs: [path.dirname(file), srcDir, path.join(root, "include")],
+				srcDir,
 			});
-			for (const artifact of result.files) {
-				const dest = path.join(root, config.outDir, artifact.name);
-				fs.mkdirSync(path.dirname(dest), { recursive: true });
-				fs.writeFileSync(dest, artifact.contents, "utf8");
-				written.add(resolveKey(dest));
-				console.log("cluaupp:", rel, "→", path.relative(root, dest));
+			jobs.push({ rel, files: result.files, stale: result.stale || [] });
+		} catch (err) {
+			errors.push({ rel, prefixes: sourcePrefixes(rel), message: err.message });
+		}
+	}
+
+	return { files, jobs, errors };
+}
+
+function writeTextIfChanged(dest, contents) {
+	if (fs.existsSync(dest) && fs.readFileSync(dest, "utf8") === contents) {
+		return false;
+	}
+	fs.mkdirSync(path.dirname(dest), { recursive: true });
+	fs.writeFileSync(dest, contents, "utf8");
+	return true;
+}
+
+function writeJobs(root, config, jobs) {
+	const written = new Set();
+	for (const job of jobs) {
+		for (const artifact of job.files) {
+			const dest = path.join(root, config.outDir, artifact.name);
+			const changed = writeTextIfChanged(dest, artifact.contents);
+			written.add(resolveKey(dest));
+			if (changed) {
+				console.log("cluaupp:", job.rel, "→", path.relative(root, dest));
 			}
-			for (const stale of result.stale || []) {
-				const dest = path.join(root, config.outDir, stale);
-				if (fs.existsSync(dest) && !written.has(resolveKey(dest))) {
-					if (tryRm(dest)) {
-						console.log("cluaupp: removed", path.relative(root, dest));
-					}
+		}
+		for (const stale of job.stale) {
+			const dest = path.join(root, config.outDir, stale);
+			if (fs.existsSync(dest) && !written.has(resolveKey(dest))) {
+				if (tryRm(dest)) {
+					console.log("cluaupp: removed", path.relative(root, dest));
 				}
 			}
-		} catch (err) {
-			failed += 1;
-			failedPrefixes.push(...sourcePrefixes(rel));
+		}
+	}
+	return written;
+}
+
+function libsPresent(root) {
+	const libs = path.join(root, "libs");
+	return fs.existsSync(libs) && fs.readdirSync(libs).length > 0;
+}
+
+function ensureVendor(root) {
+	copyRuntime(root);
+	copyHeaders(root);
+}
+
+function build(root, options = {}) {
+	const exitOnError = options.exitOnError !== false;
+	const holdOnError = options.holdOnError === true;
+	const config = loadConfig(root);
+	if (options.syncVendor !== false) {
+		ensureVendor(root);
+	}
+	const srcDir = path.join(root, config.rootDir);
+	if (!fs.existsSync(srcDir) || collectCpp(srcDir).length === 0) {
+		console.error("no .cpp/.h/.hpp files in", config.rootDir);
+		if (!holdOnError) {
+			pruneOut(root, config, new Set(), []);
+		}
+		if (exitOnError) {
+			process.exit(1);
+		}
+		return { failed: 0, written: new Set() };
+	}
+
+	const compiled = compileProject(root, config);
+	if (compiled.errors.length > 0) {
+		for (const err of compiled.errors) {
 			console.error(err.message);
 		}
+		if (holdOnError) {
+			console.error(`cluaupp: out not updated (${compiled.errors.length} compile error${compiled.errors.length === 1 ? "" : "s"})`);
+			try {
+				syncEditorSupport(root, config);
+			} catch (err) {
+				console.error("cluaupp: intellisense sync failed", err.message);
+			}
+			return { failed: compiled.errors.length, written: new Set() };
+		}
 	}
+
+	const written = writeJobs(root, config, compiled.jobs);
+	const failedPrefixes = compiled.errors.flatMap((err) => err.prefixes);
 	pruneOut(root, config, written, failedPrefixes);
-	if (failed > 0 && exitOnError) {
+	try {
+		syncEditorSupport(root, config);
+	} catch (err) {
+		console.error("cluaupp: intellisense sync failed", err.message);
+	}
+	if (compiled.errors.length > 0 && exitOnError) {
 		process.exit(1);
 	}
-	return { failed, written };
+	return { failed: compiled.errors.length, written };
 }
 
-function init(dest) {
+async function init(dest) {
 	const template = path.join(__dirname, "..", "templates", "game");
 	const include = path.join(__dirname, "..", "include");
 	copyDir(template, dest);
 	copyDir(include, path.join(dest, "include"));
 	copyRuntime(dest);
+	syncEditorSupport(dest);
+	const installed = await installEditorSupport();
 	console.log("Cluaupp ready in", dest);
 	console.log("  cluaupp build");
 	console.log("  rojo serve");
+	if (installed.local.length || (installed.cpp && installed.cpp.status === "installed")) {
+		console.log("  reload Cursor (Ctrl+Shift+P → Developer: Reload Window)");
+	}
+}
+
+function pidAlive(pid) {
+	try {
+		process.kill(pid, 0);
+		return true;
+	} catch {
+		return false;
+	}
+}
+
+function acquireWatchLock(root) {
+	const file = path.join(root, ".cluaupp-watch.lock");
+	if (fs.existsSync(file)) {
+		const pid = Number(fs.readFileSync(file, "utf8").trim());
+		if (Number.isFinite(pid) && pid !== process.pid && pidAlive(pid)) {
+			console.error(`cluaupp: watch already running (pid ${pid}). Stop it first — two watchers make Rojo crash on libs/.`);
+			process.exit(1);
+		}
+	}
+	fs.writeFileSync(file, String(process.pid), "utf8");
+	const release = () => {
+		try {
+			if (fs.existsSync(file) && fs.readFileSync(file, "utf8").trim() === String(process.pid)) {
+				fs.unlinkSync(file);
+			}
+		} catch {
+			// ignore
+		}
+	};
+	process.on("exit", release);
+	process.on("SIGINT", () => {
+		release();
+		process.exit(0);
+	});
+	process.on("SIGTERM", () => {
+		release();
+		process.exit(0);
+	});
 }
 
 function watch(root) {
-	build(root, { exitOnError: false, syncVendor: true });
+	acquireWatchLock(root);
+	build(root, { exitOnError: false, syncVendor: false, holdOnError: true });
 	const config = loadConfig(root);
 	const dir = path.join(root, config.rootDir);
 	let timer = null;
@@ -306,7 +414,7 @@ function watch(root) {
 		}
 		running = true;
 		try {
-			build(root, { exitOnError: false, syncVendor: false });
+			build(root, { exitOnError: false, syncVendor: false, holdOnError: true });
 		} catch (err) {
 			console.error(err.message);
 		} finally {
@@ -318,30 +426,56 @@ function watch(root) {
 		}
 	};
 
-	console.log("watching", dir);
+	console.log("cluaupp", pkg.version, "watching", dir, "(libs untouched)");
 	if (!fs.existsSync(dir)) {
 		fs.mkdirSync(dir, { recursive: true });
 	}
 	fs.watch(dir, { recursive: true }, () => {
 		clearTimeout(timer);
-		timer = setTimeout(run, 200);
+		timer = setTimeout(run, 400);
 	});
 }
 
-const args = process.argv.slice(2);
-const cmd = args[0] || "help";
-const cwd = process.cwd();
-
-if (cmd === "init") {
-	init(path.resolve(cwd, args[1] || "."));
-} else if (cmd === "build") {
-	build(path.resolve(cwd, args[1] || "."));
-} else if (cmd === "watch") {
-	watch(path.resolve(cwd, args[1] || "."));
-} else if (cmd === "--version" || cmd === "-v" || cmd === "version") {
-	console.log(pkg.version);
-} else {
-	printHelp();
+function dispatch(args) {
+	const cmd = args[0] || "help";
+	const cwd = process.cwd();
+	if (cmd === "init") {
+		return init(path.resolve(cwd, args[1] || ".")).catch((err) => {
+			console.error(err.message || err);
+			process.exit(1);
+		});
+	} else if (cmd === "build") {
+		build(path.resolve(cwd, args[1] || "."));
+	} else if (cmd === "watch") {
+		watch(path.resolve(cwd, args[1] || "."));
+	} else if (cmd === "lsp") {
+		const { start } = require("./lsp");
+		start({ projectRoot: path.resolve(cwd, args[1] || ".") });
+	} else if (cmd === "intellisense" || cmd === "intelisense") {
+		const root = path.resolve(cwd, args[1] || ".");
+		syncEditorSupport(root, loadConfig(root));
+		return installEditorSupport().then((installed) => {
+			console.log("cluaupp: compile_commands.json, .clangd, and .vscode updated in", root);
+			if (installed.local.length) {
+				for (const dest of installed.local) {
+					console.log("cluaupp: Cluaupp IntelliSense", dest);
+				}
+			}
+		}).catch((err) => {
+			console.error(err.message || err);
+			process.exit(1);
+		});
+	} else if (cmd === "--version" || cmd === "-v" || cmd === "version") {
+		console.log(pkg.version);
+	} else {
+		printHelp();
+	}
+}
+
+const launchedAsCli =
+	require.main && ["cli.js", "cluaupp.js", "cluau.js"].includes(path.basename(require.main.filename));
+if (launchedAsCli) {
+	dispatch(process.argv.slice(2));
 }
 
-module.exports = { build, watch };
+module.exports = { build, watch, dispatch };

package/src/client/init.client.cpp

@@ -0,0 +1,5 @@
+#include <cluaupp/roblox.hpp>
+
+void init() {
+	print("Cluaupp client ok");
+}