rowork 0.1.0

package/dist/commands/dashboard.js

@@ -0,0 +1,50 @@
+import pc from "picocolors";
+import { RoworkError } from "../cli/errors.js";
+import { runningDashboard } from "../core/background.js";
+import { openBrowser } from "../dashboard/open.js";
+import { startDashboard } from "../dashboard/server.js";
+import { defineCommand } from "../plugins/api.js";
+import { requireProject } from "./make.js";
+export const dashboardCommand = defineCommand({
+    name: "dashboard",
+    description: "Open a local web dashboard for the project: state, modules and the live output of `dev`.",
+    options: [
+        { flags: "--port <port>", description: "port to listen on (default: any free one)" },
+        { flags: "--no-open", description: "print the address without opening a browser" },
+    ],
+    async run(context) {
+        const { root } = requireProject(context, "dashboard");
+        // `rowork dev` already runs one: open that instead of starting a second server.
+        const existing = runningDashboard(root);
+        if (existing !== undefined) {
+            context.logger.success("The dashboard is already running (started by `rowork dev`).");
+            context.logger.info(`  ${pc.bold(existing.url)}`);
+            if (context.options["open"] !== false)
+                openBrowser(existing.url);
+            return;
+        }
+        const rawPort = context.options["port"];
+        const port = typeof rawPort === "string" ? Number(rawPort) : 0;
+        if (!Number.isInteger(port) || port < 0 || port > 65535) {
+            throw new RoworkError(`\`${String(rawPort)}\` is not a valid port.`, { hint: "Use a number between 0 and 65535." });
+        }
+        const dashboard = await startDashboard({ projectRoot: root, roworkVersion: context.roworkVersion, port }).catch((error) => {
+            throw new RoworkError("Could not start the dashboard.", {
+                hint: error instanceof Error ? error.message : String(error),
+            });
+        });
+        context.logger.success("Dashboard running. Only this computer can reach it.");
+        context.logger.info(`  ${pc.bold(dashboard.url)}`);
+        context.logger.info(pc.dim("  The address carries a secret token: do not share it. Press Ctrl+C to stop."));
+        if (context.options["open"] !== false)
+            openBrowser(dashboard.url);
+        await new Promise((resolve) => {
+            const stop = () => resolve();
+            for (const signal of ["SIGINT", "SIGTERM", "SIGHUP", "SIGBREAK"])
+                process.once(signal, stop);
+        });
+        await dashboard.close();
+        context.logger.info("Dashboard stopped.");
+    },
+});
+//# sourceMappingURL=dashboard.js.map

package/dist/commands/dev-background.d.ts

@@ -0,0 +1,3 @@
+export declare const devStopCommand: import("../plugins/api.js").CommandDefinition;
+export declare const devLogsCommand: import("../plugins/api.js").CommandDefinition;
+//# sourceMappingURL=dev-background.d.ts.map

package/dist/commands/dev-background.js

@@ -0,0 +1,87 @@
+import { existsSync, openSync, readSync, closeSync, statSync } from "node:fs";
+import pc from "picocolors";
+import { RoworkError } from "../cli/errors.js";
+import { clearDashboardRecord, clearRecord, logFile, runningRecord, stopProcess, tailLog } from "../core/background.js";
+import { defineCommand } from "../plugins/api.js";
+function requireRoot(root, command) {
+    if (root === undefined) {
+        throw new RoworkError(`\`rowork ${command}\` must run inside a Rowork project.`, {
+            hint: "No rowork.json found here or in any parent directory.",
+        });
+    }
+    return root;
+}
+export const devStopCommand = defineCommand({
+    name: "dev:stop",
+    description: "Stop the `rowork dev` running in the background.",
+    async run(context) {
+        const root = requireRoot(context.projectRoot, "dev:stop");
+        const record = runningRecord(root);
+        if (record === undefined) {
+            context.logger.info("No `rowork dev` is running in the background.");
+            return;
+        }
+        context.logger.step(`stopping rowork dev (pid ${record.pid})`);
+        const clean = await stopProcess(record.pid);
+        clearRecord(root);
+        clearDashboardRecord(root);
+        if (clean) {
+            context.logger.success("Stopped.");
+        }
+        else {
+            context.logger.warn(`It did not stop in time and was killed. If port ${record.port} is still busy, look for a leftover rojo process.`);
+        }
+    },
+});
+export const devLogsCommand = defineCommand({
+    name: "dev:logs",
+    description: "Show the output of the background `rowork dev` (compiler errors included).",
+    options: [
+        { flags: "-n, --lines <count>", description: "how many recent lines to show (default 40)" },
+        { flags: "-f, --follow", description: "keep printing new output until Ctrl+C" },
+    ],
+    async run(context) {
+        const root = requireRoot(context.projectRoot, "dev:logs");
+        const file = logFile(root);
+        if (!existsSync(file)) {
+            throw new RoworkError("There is no background log yet.", {
+                hint: "Start one with `rowork dev -d`.",
+            });
+        }
+        const rawLines = context.options["lines"];
+        const count = typeof rawLines === "string" ? Number(rawLines) : 40;
+        if (!Number.isInteger(count) || count < 1) {
+            throw new RoworkError(`\`${String(rawLines)}\` is not a valid line count.`);
+        }
+        for (const line of tailLog(root, count))
+            process.stdout.write(`${line}\n`);
+        if (context.options["follow"] !== true) {
+            if (runningRecord(root) === undefined) {
+                context.logger.info(pc.dim("(rowork dev is not running in the background)"));
+            }
+            return;
+        }
+        // Follow: print what is appended, until Ctrl+C.
+        let offset = statSync(file).size;
+        await new Promise((resolve) => {
+            const timer = setInterval(() => {
+                const size = statSync(file).size;
+                if (size < offset)
+                    offset = 0; // the log was restarted
+                if (size === offset)
+                    return;
+                const buffer = Buffer.alloc(size - offset);
+                const fd = openSync(file, "r");
+                readSync(fd, buffer, 0, buffer.length, offset);
+                closeSync(fd);
+                offset = size;
+                process.stdout.write(buffer);
+            }, 300);
+            process.once("SIGINT", () => {
+                clearInterval(timer);
+                resolve();
+            });
+        });
+    },
+});
+//# sourceMappingURL=dev-background.js.map

package/dist/commands/dev.d.ts

@@ -0,0 +1,2 @@
+export declare const devCommand: import("../plugins/api.js").CommandDefinition;
+//# sourceMappingURL=dev.d.ts.map

package/dist/commands/dev.js

@@ -0,0 +1,270 @@
+import { createWriteStream, existsSync, mkdirSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import pc from "picocolors";
+import { RoworkError } from "../cli/errors.js";
+import { resolveProjectPath } from "../core/config.js";
+import { run as runBinary } from "../core/exec.js";
+import { clearDashboardRecord, clearRecord, DAEMON_ENV, logFile, isAlive, runDirectory, runningDashboard, runningRecord, spawnBackground, tailLog, writeDashboardRecord, writeRecord, } from "../core/background.js";
+import { openBrowser } from "../dashboard/open.js";
+import { startDashboard } from "../dashboard/server.js";
+import { unmappedScopes } from "../core/rojo-edit.js";
+import { findStoreRojoPlugin, needsStudioSetup, warnAboutStorePlugin } from "../core/studio.js";
+import { readRojoPin, rojoIsAtLeast } from "../core/versions.js";
+import { findMissing, isPortFree, pathWithLocalBinaries, installAdvice } from "../core/toolchain.js";
+import { defineCommand } from "../plugins/api.js";
+import { Supervisor } from "../process/supervisor.js";
+export const devCommand = defineCommand({
+    name: "dev",
+    description: "Run the compiler, the Rojo server and the sourcemap watcher together.",
+    options: [
+        { flags: "--no-compile", description: "skip the roblox-ts compiler" },
+        { flags: "--no-rojo", description: "skip the Rojo server" },
+        { flags: "--no-sourcemap", description: "skip the sourcemap watcher" },
+        { flags: "--port <port>", description: "port for the Rojo server" },
+        { flags: "-d, --detach", description: "run in the background; stop with `rowork dev:stop`" },
+        { flags: "--no-dashboard", description: "do not start the local web dashboard" },
+        { flags: "--open", description: "open the dashboard in your browser" },
+    ],
+    async run(context) {
+        const { projectRoot, config } = context;
+        if (projectRoot === undefined || config === undefined) {
+            throw new RoworkError("`rowork dev` must run inside a Rowork project.", {
+                hint: "No rowork.json found here or in any parent directory. Create one with `rowork init <name>`.",
+            });
+        }
+        const isDaemon = process.env[DAEMON_ENV] !== undefined;
+        const already = isDaemon ? undefined : runningRecord(projectRoot);
+        if (already !== undefined) {
+            throw new RoworkError(`\`rowork dev\` is already running for this project (pid ${already.pid}).`, {
+                hint: "Stop it with `rowork dev:stop`, or read what it prints with `rowork dev:logs`.",
+            });
+        }
+        const rojoProject = resolveProjectPath(projectRoot, config.paths.rojoProject);
+        if (!existsSync(rojoProject)) {
+            throw new RoworkError(`Rojo project file not found: ${config.paths.rojoProject}`, {
+                hint: "Check `paths.rojoProject` in rowork.json.",
+            });
+        }
+        if (!existsSync(join(projectRoot, "node_modules"))) {
+            throw new RoworkError("Dependencies are not installed.", {
+                hint: "Run `npm install` first.",
+            });
+        }
+        const tasks = [];
+        if (context.options["compile"] !== false) {
+            tasks.push({ name: "compile", command: "rbxtsc", args: ["-w"], paint: pc.cyan });
+        }
+        if (context.options["rojo"] !== false) {
+            const args = ["serve", config.paths.rojoProject];
+            const port = context.options["port"];
+            if (typeof port === "string")
+                args.push("--port", port);
+            tasks.push({ name: "rojo", command: "rojo", args, paint: pc.magenta });
+        }
+        if (context.options["sourcemap"] !== false) {
+            // The Flamework transformer resolves instance paths through the Rojo
+            // project, and roblox-ts tooling reads sourcemap.json. Keeping it
+            // regenerated automatically removes a whole class of "works on my
+            // machine" path errors.
+            tasks.push({
+                name: "sourcemap",
+                command: "rojo",
+                args: ["sourcemap", config.paths.rojoProject, "--output", "sourcemap.json", "--watch"],
+                paint: pc.blue,
+            });
+        }
+        // Fail before anything starts, with the fix, instead of letting each task
+        // die separately with a bare `spawn ENOENT` buried in the unified log.
+        const required = [];
+        if (context.options["compile"] !== false)
+            required.push({ command: "rbxtsc", source: "npm" });
+        if (context.options["rojo"] !== false || context.options["sourcemap"] !== false) {
+            required.push({ command: "rojo", source: "rokit" });
+        }
+        const missing = findMissing(required, projectRoot);
+        if (missing.length > 0) {
+            throw new RoworkError(`Missing tool${missing.length > 1 ? "s" : ""}: ${missing.map((tool) => tool.command).join(", ")}.`, { hint: installAdvice(missing) });
+        }
+        // A package folder that is installed but not mapped in the Rojo project never reaches the game.
+        // Studio only says "Infinite yield possible", and a React interface silently never starts.
+        const rojoFile = context.config?.paths.rojoProject ?? "default.project.json";
+        try {
+            const unmapped = unmappedScopes(readFileSync(join(projectRoot, rojoFile), "utf8"), projectRoot);
+            for (const scope of unmapped) {
+                context.logger.warn(`${rojoFile} does not map ${scope}, so the game will not contain it (Studio waits for it forever, and a React interface never appears).`);
+                context.logger.info(`  Add next to "@rbxts", under "rbxts_include" > "node_modules": "${scope}": { "$path": "node_modules/${scope}" }`);
+            }
+        }
+        catch {
+            // A project file we cannot read is Rojo's error to report, not this check's.
+        }
+        // Rojo's own report of a busy port is a 15-line "Rojo crashed" that also
+        // takes the compiler down. The usual cause is a previous `rowork dev` that
+        // is still running, so say so, before anything starts.
+        if (context.options["rojo"] !== false) {
+            const rawPort = context.options["port"];
+            const port = typeof rawPort === "string" ? Number(rawPort) : 34872;
+            if (!Number.isInteger(port) || port < 1 || port > 65535) {
+                throw new RoworkError(`\`${String(rawPort)}\` is not a valid port.`, {
+                    hint: "Use a number between 1 and 65535, e.g. --port 34873",
+                });
+            }
+            if (!(await isPortFree(port))) {
+                throw new RoworkError(`Port ${port} is already in use.`, {
+                    hint: [
+                        "Another `rowork dev` (or Rojo) is probably still running, for example in a terminal you closed.",
+                        `Find it: ${process.platform === "win32" ? `netstat -ano | findstr :${port}` : `ss -ltnp | grep ${port}   (or: lsof -i :${port})`}`,
+                        `Or use another port: rowork dev --port ${port + 1}`,
+                    ].join("\n      "),
+                });
+            }
+        }
+        // The Creator Store plugin lags behind Rojo's releases: with Rojo 7.7 or newer it fails
+        // with a misleading "Can't parse JSON". Say so before the user loses time on it.
+        if (needsStudioSetup() && rojoIsAtLeast(readRojoPin(projectRoot), 7, 7) && findStoreRojoPlugin() !== undefined) {
+            warnAboutStorePlugin(context.logger);
+        }
+        await ensureInitialBuild(context, projectRoot, config.paths.out);
+        if (tasks.length === 0) {
+            throw new RoworkError("Every task was disabled, nothing left to run.");
+        }
+        if (context.options["detach"] === true && !isDaemon) {
+            await startInBackground(context, projectRoot);
+            return;
+        }
+        context.logger.info(`${pc.bold(config.name)} ${pc.dim(projectRoot)}`);
+        for (const task of tasks) {
+            context.logger.step(`${task.paint(task.name)} ${pc.dim(`${task.command} ${task.args.join(" ")}`)}`);
+        }
+        context.logger.info(pc.dim("Press Ctrl+C to stop everything."));
+        context.logger.blank();
+        // The output goes to a file too, so the dashboard and `dev:logs` see what a terminal sees.
+        // (Detached, the process's own output already IS that file.)
+        let logStream;
+        if (!isDaemon) {
+            mkdirSync(runDirectory(projectRoot), { recursive: true });
+            logStream = createWriteStream(logFile(projectRoot), { flags: "w" });
+            writeRecord(projectRoot, {
+                pid: process.pid,
+                startedAt: new Date().toISOString(),
+                port: typeof context.options["port"] === "string" ? Number(context.options["port"]) : 34872,
+                mode: "foreground",
+            });
+        }
+        let dashboard;
+        if (context.options["dashboard"] !== false) {
+            try {
+                dashboard = await startDashboard({ projectRoot, roworkVersion: context.roworkVersion, port: 0 });
+                writeDashboardRecord(projectRoot, { pid: process.pid, port: dashboard.port, url: dashboard.url });
+                context.logger.info(`Dashboard: ${pc.bold(dashboard.url)}`);
+                context.logger.info(pc.dim("  Only this computer can reach it. Do not share the address: it carries a secret token."));
+                if (context.options["open"] === true && !isDaemon)
+                    openBrowser(dashboard.url);
+            }
+            catch (error) {
+                // The dashboard is a convenience: never let it stop the game from being built.
+                context.logger.warn(`The dashboard did not start: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
+        // However this ends, leave no record of a process that is gone.
+        process.once("exit", () => {
+            clearRecord(projectRoot);
+            clearDashboardRecord(projectRoot);
+        });
+        const supervisor = new Supervisor({
+            tasks,
+            cwd: projectRoot,
+            logger: context.logger,
+            ...(logStream === undefined ? {} : { onOutput: (text) => logStream?.write(text) }),
+        });
+        const code = await supervisor.run();
+        await dashboard?.close();
+        logStream?.end();
+        clearRecord(projectRoot);
+        clearDashboardRecord(projectRoot);
+        if (code !== 0)
+            process.exitCode = code;
+    },
+});
+/**
+ * Rojo refuses to start when a `$path` in the project file does not exist yet,
+ * and on a fresh clone `out/` and `include/` only appear once roblox-ts has
+ * compiled. Starting all tasks at once therefore kills Rojo instantly and takes
+ * everything else down with it. One blocking build first removes that race.
+ */
+async function ensureInitialBuild(context, projectRoot, outDirectory) {
+    if (context.options["compile"] === false)
+        return;
+    if (existsSync(join(projectRoot, outDirectory)) && existsSync(join(projectRoot, "include")))
+        return;
+    context.logger.info("First run: compiling once so Rojo has something to serve...");
+    try {
+        await runBinary("rbxtsc", [], {
+            cwd: projectRoot,
+            env: { PATH: pathWithLocalBinaries(projectRoot) },
+        });
+    }
+    catch (cause) {
+        throw new RoworkError("The initial build failed.", {
+            hint: "Fix the compiler errors above, then run `rowork dev` again.",
+            cause,
+        });
+    }
+    context.logger.blank();
+}
+/**
+ * Relaunches `rowork dev` detached from this terminal.
+ *
+ * Every check and the first build already ran in the foreground, so their
+ * errors are visible here instead of ending up in a log nobody is reading.
+ */
+async function startInBackground(context, projectRoot) {
+    const script = process.argv[1];
+    if (script === undefined)
+        throw new RoworkError("Cannot find the Rowork entry point to relaunch.");
+    const args = [];
+    for (const flag of ["compile", "rojo", "sourcemap", "dashboard"]) {
+        if (context.options[flag] === false)
+            args.push(`--no-${flag}`);
+    }
+    const port = context.options["port"];
+    if (typeof port === "string")
+        args.push("--port", port);
+    const pid = spawnBackground(projectRoot, script, args);
+    writeRecord(projectRoot, {
+        pid,
+        startedAt: new Date().toISOString(),
+        port: typeof port === "string" ? Number(port) : 34872,
+        mode: "background",
+    });
+    // A task that cannot start dies within a second or two: wait for that, so a
+    // failure is reported now with its cause rather than discovered later.
+    for (let waited = 0; waited < 4000; waited += 200) {
+        await new Promise((resolve) => setTimeout(resolve, 200));
+        if (!isAlive(pid)) {
+            clearRecord(projectRoot);
+            for (const line of tailLog(projectRoot, 15))
+                context.logger.info(pc.dim(`  ${line}`));
+            throw new RoworkError("`rowork dev` stopped right after starting in the background.", {
+                hint: `Full output: ${logFile(projectRoot)}`,
+            });
+        }
+    }
+    context.logger.success(`rowork dev is running in the background (pid ${pid}).`);
+    context.logger.info(`  Output:  rowork dev:logs   (add -f to follow)`);
+    context.logger.info(`  Stop it: rowork dev:stop`);
+    // The background process starts its dashboard a moment after itself.
+    if (context.options["dashboard"] !== false) {
+        for (let waited = 0; waited < 3000; waited += 200) {
+            const running = runningDashboard(projectRoot);
+            if (running !== undefined) {
+                context.logger.info(`  Dashboard: ${pc.bold(running.url)}`);
+                if (context.options["open"] === true)
+                    openBrowser(running.url);
+                break;
+            }
+            await new Promise((resolve) => setTimeout(resolve, 200));
+        }
+    }
+}
+//# sourceMappingURL=dev.js.map

package/dist/commands/eject.d.ts

@@ -0,0 +1,2 @@
+export declare const ejectCommand: import("../plugins/api.js").CommandDefinition;
+//# sourceMappingURL=eject.d.ts.map

package/dist/commands/eject.js

@@ -0,0 +1,136 @@
+import { existsSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import pc from "picocolors";
+import { RoworkError } from "../cli/errors.js";
+import { runningRecord, stopProcess, clearRecord } from "../core/background.js";
+import { removeAgentDocs, AGENTS_FILE } from "../core/agent-docs.js";
+import { CONFIG_FILENAME } from "../core/config.js";
+import { run as runBinary } from "../core/exec.js";
+import { isOnPlainPath } from "../core/toolchain.js";
+import { defineCommand } from "../plugins/api.js";
+import { answered, isInteractive, prompts } from "../ui/prompt.js";
+import { requireProject } from "./make.js";
+/** What `rowork dev` runs, written as plain npm scripts. */
+function replacementScripts(rojoProject) {
+    return {
+        // npm runs `predev` first: the same "compile once so Rojo has something to
+        // serve" that `rowork dev` does before starting the watchers.
+        predev: "rbxtsc",
+        dev: [
+            "concurrently -k -n compile,rojo,sourcemap",
+            '"rbxtsc -w"',
+            `"rojo serve ${rojoProject}"`,
+            `"rojo sourcemap ${rojoProject} --output sourcemap.json --watch"`,
+        ].join(" "),
+    };
+}
+function indentOf(source) {
+    return /^\t/m.test(source) ? "\t" : 2;
+}
+export const ejectCommand = defineCommand({
+    name: "eject",
+    guided: true,
+    description: "Leave Rowork: keep a project that runs with plain tools, and remove Rowork's files.",
+    options: [
+        { flags: "--yes", description: "do not ask for confirmation" },
+        { flags: "--dry-run", description: "show what would change, and change nothing" },
+        { flags: "--no-install", description: "do not install `concurrently` (the dev script needs it)" },
+    ],
+    async run(context) {
+        const { root, config } = requireProject(context, "eject");
+        const manifestPath = join(root, "package.json");
+        if (!existsSync(manifestPath)) {
+            throw new RoworkError("No package.json to update.", {
+                hint: "Eject rewrites the `dev` script of package.json.",
+            });
+        }
+        const manifestSource = readFileSync(manifestPath, "utf8");
+        const manifest = JSON.parse(manifestSource);
+        const scripts = manifest.scripts ?? {};
+        const wanted = replacementScripts(config.paths.rojoProject);
+        // Only replace a `dev` script that is Rowork's own. A script the user wrote
+        // or edited is theirs, and eject must not overwrite it.
+        const devIsRowork = scripts["dev"] === undefined || /^rowork(\s|$)/.test(scripts["dev"]);
+        const changes = [];
+        if (devIsRowork) {
+            changes.push('package.json: `dev` becomes "concurrently" running rbxtsc -w, rojo serve and rojo sourcemap');
+            changes.push("package.json: adds `predev` (one build first, so Rojo can start)");
+            changes.push("package.json: adds `concurrently` to devDependencies");
+        }
+        else {
+            changes.push(`package.json: keeps your own \`dev\` script ("${scripts["dev"]}")`);
+        }
+        const readmePath = join(root, "README.md");
+        const readme = existsSync(readmePath) ? readFileSync(readmePath, "utf8") : "";
+        const readmeChanges = /rowork dev/.test(readme);
+        if (readmeChanges)
+            changes.push("README.md: `rowork dev` becomes `npm run dev`");
+        if (existsSync(join(root, AGENTS_FILE)))
+            changes.push(`${AGENTS_FILE}: Rowork's generated block removed (your own notes stay)`);
+        changes.push(`${CONFIG_FILENAME}: removed`);
+        if (existsSync(join(root, ".rowork")))
+            changes.push(".rowork/: removed (background dev pid and log)");
+        const record = runningRecord(root);
+        if (record !== undefined)
+            changes.push(`stops the background rowork dev (pid ${record.pid})`);
+        context.logger.info(pc.bold("Ejecting will:"));
+        for (const change of changes)
+            context.logger.step(change);
+        context.logger.blank();
+        context.logger.info(pc.dim("Your source code, default.project.json, tsconfig.json and rokit.toml are not touched."));
+        context.logger.info(pc.dim("Generated code never imports Rowork, so it keeps working as is."));
+        context.logger.blank();
+        if (context.options["dryRun"] === true) {
+            context.logger.info("Dry run: nothing was changed.");
+            return;
+        }
+        if (context.options["yes"] !== true) {
+            if (!isInteractive()) {
+                throw new RoworkError("`rowork eject` asks for confirmation.", {
+                    hint: "Outside a terminal, add --yes (and --dry-run first to preview).",
+                });
+            }
+            const confirmed = answered(await prompts.confirm({
+                message: "Leave Rowork? `rowork` commands stop working in this project.",
+                initialValue: false,
+            }));
+            if (!confirmed) {
+                prompts.cancel("Nothing changed.");
+                return;
+            }
+        }
+        if (record !== undefined) {
+            await stopProcess(record.pid);
+            clearRecord(root);
+        }
+        if (devIsRowork) {
+            manifest.scripts = { ...scripts, ...wanted };
+            writeFileSync(manifestPath, `${JSON.stringify(manifest, undefined, indentOf(manifestSource))}\n`, "utf8");
+            if (context.options["install"] !== false) {
+                context.logger.step("installing concurrently (npm)");
+                context.logger.blank();
+                await runBinary("npm", ["install", "--save-dev", "concurrently"], { cwd: root });
+            }
+            else {
+                context.logger.warn("Skipped installing `concurrently`: run `npm install --save-dev concurrently` before `npm run dev`.");
+            }
+        }
+        if (readmeChanges)
+            writeFileSync(readmePath, readme.replace(/rowork dev/g, "npm run dev"), "utf8");
+        removeAgentDocs(root);
+        rmSync(join(root, ".rowork"), { recursive: true, force: true });
+        rmSync(join(root, CONFIG_FILENAME), { force: true });
+        context.logger.blank();
+        context.logger.success("Ejected. This project no longer needs Rowork.");
+        // Rowork also looked in ~/.rokit/bin on its own. Plain npm scripts will not.
+        if (!isOnPlainPath("rojo")) {
+            context.logger.blank();
+            context.logger.warn("`rojo` is not on your PATH, so `npm run dev` will not find it.");
+            context.logger.info("Add Rokit's directory to your PATH (~/.rokit/bin, or %USERPROFILE%\\.rokit\\bin on Windows) and reopen the terminal.");
+        }
+        context.logger.blank();
+        context.logger.info("Run it with:  npm run dev");
+        context.logger.info("Build once:   npm run build");
+    },
+});
+//# sourceMappingURL=eject.js.map

package/dist/commands/index.d.ts

@@ -0,0 +1,8 @@
+import type { CommandDefinition } from "../plugins/api.js";
+/**
+ * Core commands, listed explicitly rather than discovered by glob: the compiler
+ * checks them, startup stays fast, and no phantom command can slip into the
+ * published package.
+ */
+export declare const coreCommands: CommandDefinition[];
+//# sourceMappingURL=index.d.ts.map

package/dist/commands/index.js

@@ -0,0 +1,54 @@
+import { coreModules } from "../modules/index.js";
+import { addCommand, moduleCommand } from "./add.js";
+import { assetsCommand } from "./assets.js";
+import { assetsSetupCommand } from "./assets-setup.js";
+import { consoleCommand } from "./console.js";
+import { agentsSyncCommand, infoCommand } from "./info.js";
+import { updateCommand } from "./update.js";
+import { wireCommand } from "./wire.js";
+import { dashboardCommand } from "./dashboard.js";
+import { devCommand } from "./dev.js";
+import { ejectCommand } from "./eject.js";
+import { devLogsCommand, devStopCommand } from "./dev-background.js";
+import { initCommand } from "./init.js";
+import { makeCommand } from "./make-menu.js";
+import { makeEventCommand } from "./make-event.js";
+import { makeStatCommand } from "./make-stat.js";
+import { makeScreenCommand, makeUiCommand } from "./make-ui.js";
+import { makeComponentCommand, makeControllerCommand, makeServiceCommand } from "./make.js";
+import { startCommand } from "./start.js";
+import { studioCommand, studioSetupCommand } from "./studio.js";
+/**
+ * Core commands, listed explicitly rather than discovered by glob: the compiler
+ * checks them, startup stays fast, and no phantom command can slip into the
+ * published package.
+ */
+export const coreCommands = [
+    startCommand,
+    initCommand,
+    devCommand,
+    devStopCommand,
+    dashboardCommand,
+    assetsCommand,
+    assetsSetupCommand,
+    devLogsCommand,
+    makeCommand,
+    makeServiceCommand,
+    makeControllerCommand,
+    makeComponentCommand,
+    makeStatCommand,
+    makeEventCommand,
+    makeScreenCommand,
+    makeUiCommand,
+    studioCommand,
+    studioSetupCommand,
+    consoleCommand,
+    addCommand,
+    ejectCommand,
+    infoCommand,
+    updateCommand,
+    wireCommand,
+    agentsSyncCommand,
+    ...coreModules.map(moduleCommand),
+];
+//# sourceMappingURL=index.js.map

package/dist/commands/info.d.ts

@@ -0,0 +1,3 @@
+export declare const infoCommand: import("../plugins/api.js").CommandDefinition;
+export declare const agentsSyncCommand: import("../plugins/api.js").CommandDefinition;
+//# sourceMappingURL=info.d.ts.map