rowork 0.1.0

package/dist/cli/registry.d.ts

@@ -0,0 +1,37 @@
+import type { CommandDefinition } from "../plugins/api.js";
+/** Where a command came from, used to arbitrate name conflicts. */
+export type CommandOrigin = {
+    kind: "core";
+} | {
+    kind: "plugin";
+    pluginName: string;
+} | {
+    kind: "local";
+    file: string;
+};
+export interface RegisteredCommand {
+    definition: CommandDefinition;
+    origin: CommandOrigin;
+}
+/**
+ * Registry of every command, whatever its source.
+ *
+ * Conflict arbitration: core always wins. Without this rule a third-party
+ * plugin could silently hijack `rowork init`. Between plugins, first
+ * registration wins and the conflict is reported.
+ */
+export declare class CommandRegistry {
+    private readonly commands;
+    private readonly aliases;
+    register(definition: CommandDefinition, origin: CommandOrigin): void;
+    all(): RegisteredCommand[];
+    has(name: string): boolean;
+}
+/**
+ * The registry of the running CLI, for internal features that need to list
+ * commands (the console's help and completion). Deliberately not part of the
+ * public plugin API: exposing it there would freeze the registry's shape.
+ */
+export declare function setActiveRegistry(registry: CommandRegistry): void;
+export declare function activeRegistry(): CommandRegistry | undefined;
+//# sourceMappingURL=registry.d.ts.map

package/dist/cli/registry.js

@@ -0,0 +1,61 @@
+import { logger } from "../ui/logger.js";
+function describeOrigin(origin) {
+    switch (origin.kind) {
+        case "core":
+            return "Rowork core";
+        case "plugin":
+            return `plugin ${origin.pluginName}`;
+        case "local":
+            return `local file ${origin.file}`;
+    }
+}
+/**
+ * Registry of every command, whatever its source.
+ *
+ * Conflict arbitration: core always wins. Without this rule a third-party
+ * plugin could silently hijack `rowork init`. Between plugins, first
+ * registration wins and the conflict is reported.
+ */
+export class CommandRegistry {
+    commands = new Map();
+    aliases = new Map();
+    register(definition, origin) {
+        const existing = this.commands.get(definition.name);
+        if (existing !== undefined) {
+            if (existing.origin.kind === "core" || origin.kind !== "core") {
+                logger.warn(`Skipping command \`${definition.name}\`: already provided by ${describeOrigin(existing.origin)} ` +
+                    `(attempted by ${describeOrigin(origin)}).`);
+                return;
+            }
+            logger.warn(`Command \`${definition.name}\` from ${describeOrigin(existing.origin)} replaced by Rowork core.`);
+        }
+        this.commands.set(definition.name, { definition, origin });
+        for (const alias of definition.aliases ?? []) {
+            const owner = this.aliases.get(alias);
+            if (owner !== undefined && owner !== definition.name) {
+                logger.warn(`Skipping alias \`${alias}\`: already taken by \`${owner}\`.`);
+                continue;
+            }
+            this.aliases.set(alias, definition.name);
+        }
+    }
+    all() {
+        return [...this.commands.values()].sort((a, b) => a.definition.name.localeCompare(b.definition.name));
+    }
+    has(name) {
+        return this.commands.has(name);
+    }
+}
+let active;
+/**
+ * The registry of the running CLI, for internal features that need to list
+ * commands (the console's help and completion). Deliberately not part of the
+ * public plugin API: exposing it there would freeze the registry's shape.
+ */
+export function setActiveRegistry(registry) {
+    active = registry;
+}
+export function activeRegistry() {
+    return active;
+}
+//# sourceMappingURL=registry.js.map

package/dist/commands/add.d.ts

@@ -0,0 +1,8 @@
+import type { ModuleDefinition } from "../modules/types.js";
+import { type CommandDefinition } from "../plugins/api.js";
+/** Does running the module with no option ask questions? See `ModuleDefinition.asksQuestions`. */
+export declare function moduleAsks(definition: ModuleDefinition): boolean;
+/** One `add:<name>` command per module, so each can have its own flags. */
+export declare function moduleCommand(definition: ModuleDefinition): CommandDefinition;
+export declare const addCommand: CommandDefinition;
+//# sourceMappingURL=add.d.ts.map

package/dist/commands/add.js

@@ -0,0 +1,77 @@
+import { RoworkError } from "../cli/errors.js";
+import { coreModules } from "../modules/index.js";
+import { installModule, installedModules } from "../core/modules.js";
+import { defineCommand } from "../plugins/api.js";
+import { answered, prompts, requireInteractive } from "../ui/prompt.js";
+import { requireProject } from "./make.js";
+/** Does running the module with no option ask questions? See `ModuleDefinition.asksQuestions`. */
+export function moduleAsks(definition) {
+    return definition.asksQuestions ?? (definition.options ?? []).length > 0;
+}
+/** One `add:<name>` command per module, so each can have its own flags. */
+export function moduleCommand(definition) {
+    return defineCommand({
+        name: `add:${definition.name}`,
+        guided: moduleAsks(definition),
+        description: `Add the ${definition.title} module: ${definition.description}`,
+        options: [
+            ...(definition.options ?? []),
+            ...(definition.dependencies === undefined
+                ? []
+                : [{ flags: "--no-install", description: "do not run npm install" }]),
+        ],
+        async run(context) {
+            const { root } = requireProject(context, `add:${definition.name}`);
+            // Guided when nothing was given on the command line.
+            const scripted = Object.keys(context.options).some((key) => key !== "install" && context.options[key] !== undefined);
+            // A module with nothing to ask (the linter) runs anywhere, terminal or not.
+            const asksQuestions = moduleAsks(definition);
+            if (!scripted && asksQuestions) {
+                requireInteractive(`add:${definition.name}`, `rowork add:${definition.name} <options> (see --help)`);
+            }
+            await installModule(context, definition, root, !scripted && asksQuestions);
+        },
+    });
+}
+export const addCommand = defineCommand({
+    name: "add",
+    guided: true,
+    arguments: [{ name: "module", description: "the feature to add, e.g. player-data (omit it to choose from a list)", required: false }],
+    description: "Add a ready-made feature (a working pack of files) to your game, chosen from a list.",
+    async run(context) {
+        requireProject(context, "add");
+        // `rowork add player-data`: the guided version of that module, no list.
+        const named = context.args["module"];
+        if (typeof named === "string") {
+            const wanted = named.replace(/^add:/, "");
+            const module = coreModules.find((candidate) => candidate.name === wanted);
+            if (module === undefined) {
+                const close = coreModules.filter((candidate) => candidate.name.startsWith(wanted.slice(0, 3))).map((candidate) => candidate.name);
+                throw new RoworkError(`There is no feature called \`${wanted}\`.`, {
+                    hint: `Available: ${coreModules.map((candidate) => candidate.name).join(", ")}.${close.length > 0 ? ` Did you mean ${close.join(", ")}?` : ""}`,
+                });
+            }
+            if (moduleAsks(module)) {
+                requireInteractive(`add ${module.name}`, `rowork add:${module.name} <options> (see --help)`);
+            }
+            await moduleCommand(module).run({ ...context, args: {}, options: {} });
+            return;
+        }
+        requireInteractive("add", "rowork add:<module> (run `rowork --help` to list them)");
+        const installed = installedModules(context);
+        prompts.intro("rowork add");
+        const chosen = answered(await prompts.select({
+            message: "Which feature do you want to add? (a working pack, not an empty file)",
+            options: coreModules.map((module) => ({
+                value: module.name,
+                label: installed.includes(module.name) ? `${module.title} (installed)` : module.title,
+                hint: module.description,
+            })),
+        }));
+        const module = coreModules.find((candidate) => candidate.name === chosen);
+        if (module === undefined)
+            return;
+        await moduleCommand(module).run({ ...context, args: {}, options: {} });
+    },
+});
+//# sourceMappingURL=add.js.map

package/dist/commands/assets-setup.d.ts

@@ -0,0 +1,18 @@
+import { type Creator } from "../core/open-cloud.js";
+import { type CommandContext } from "../plugins/api.js";
+export declare const KEY_HELP_URL = "https://create.roblox.com/dashboard/credentials";
+export declare function parseCreator(text: string): Creator;
+/** The creator from the flag, the project, or a question. */
+export declare function resolveCreator(context: CommandContext, configured: Creator | undefined): Promise<Creator>;
+/** Remembers the owner in rowork.json. Only the owner: the key never goes there. */
+export declare function saveCreator(root: string, creator: Creator): void;
+/**
+ * Walks the user through getting a key and stores it, so nobody has to edit a file by hand.
+ * The key is only kept once Roblox has accepted it, and only ever written to `.env`.
+ */
+export declare function setUpApiKey(context: CommandContext, root: string): Promise<{
+    key: string;
+    source: ".env";
+}>;
+export declare const assetsSetupCommand: import("../plugins/api.js").CommandDefinition;
+//# sourceMappingURL=assets-setup.d.ts.map

package/dist/commands/assets-setup.js

@@ -0,0 +1,136 @@
+import { readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import pc from "picocolors";
+import { RoworkError } from "../cli/errors.js";
+import { KEY_NAME, looksLikeApiKey, readApiKey, saveApiKey } from "../core/assets.js";
+import { CONFIG_FILENAME } from "../core/config.js";
+import { OpenCloud } from "../core/open-cloud.js";
+import { openBrowser } from "../dashboard/open.js";
+import { defineCommand } from "../plugins/api.js";
+import { answered, isInteractive, prompts } from "../ui/prompt.js";
+import { requireProject } from "./make.js";
+export const KEY_HELP_URL = "https://create.roblox.com/dashboard/credentials";
+export function parseCreator(text) {
+    const match = /^(?:(user|group):)?(\d+)$/.exec(text.trim());
+    if (match === null) {
+        throw new RoworkError(`\`${text}\` is not a creator.`, { hint: "Write user:123456 or group:123456 (a bare number means a user)." });
+    }
+    return { type: match[1] ?? "user", id: match[2] };
+}
+/** The creator from the flag, the project, or a question. */
+export async function resolveCreator(context, configured) {
+    const flag = context.options["creator"];
+    if (typeof flag === "string")
+        return parseCreator(flag);
+    if (configured !== undefined)
+        return configured;
+    if (!isInteractive()) {
+        throw new RoworkError("Roblox needs to know who owns the assets.", {
+            hint: "Run once with --creator user:<your user id> (or group:<group id>). It is remembered in rowork.json.",
+        });
+    }
+    const type = answered(await prompts.select({
+        message: "Who owns the assets you upload?",
+        options: [
+            { value: "user", label: "Me (my Roblox account)" },
+            { value: "group", label: "A group" },
+        ],
+    }));
+    const id = answered(await prompts.text({
+        message: type === "user" ? "Your Roblox user id (the number in your profile address)" : "The group id (the number in the group address)",
+        validate: (value) => (/^\d+$/.test((value ?? "").trim()) ? undefined : "Digits only."),
+    })).trim();
+    return { type, id };
+}
+/** Remembers the owner in rowork.json. Only the owner: the key never goes there. */
+export function saveCreator(root, creator) {
+    const file = join(root, CONFIG_FILENAME);
+    const config = JSON.parse(readFileSync(file, "utf8"));
+    config.assets = { ...config.assets, creator };
+    writeFileSync(file, `${JSON.stringify(config, undefined, 2)}\n`, "utf8");
+}
+const STEPS = [
+    `1. Open ${KEY_HELP_URL}, click "Create API Key" and give it a name (for example Rowork).`,
+    '2. Under "Access Permissions", open "Select API System" and pick "assets".',
+    "3. Tick asset:read and asset:write. Nothing else: do not add legacy-assets or asset-permissions,",
+    "   a key with fewer rights does less damage if it ever leaks.",
+    '4. Under "Security", restrict it to your IP address and set an expiry date.',
+    '5. Click "Save & Generate Key", then copy the key: Roblox shows it only once.',
+    "",
+    "Then paste it below. You will also be asked for your Roblox user id (the number in your profile address).",
+].join("\n");
+/**
+ * Walks the user through getting a key and stores it, so nobody has to edit a file by hand.
+ * The key is only kept once Roblox has accepted it, and only ever written to `.env`.
+ */
+export async function setUpApiKey(context, root) {
+    prompts.note(STEPS, "Create a Roblox API key");
+    const open = answered(await prompts.confirm({ message: "Open that page in your browser?", initialValue: true }));
+    if (open)
+        openBrowser(KEY_HELP_URL);
+    for (;;) {
+        const pasted = answered(await prompts.password({
+            message: "Paste the key here (it is hidden, and never shown again)",
+            validate: (value) => (looksLikeApiKey((value ?? "").trim()) ? undefined : "That does not look like an API key: paste it whole, without spaces or quotes."),
+        })).trim();
+        const spinner = prompts.spinner();
+        spinner.start("Asking Roblox whether it accepts this key");
+        const verdict = await new OpenCloud(pasted).verifyKey();
+        if (verdict === "accepted") {
+            spinner.stop("Roblox accepts the key.");
+            saveApiKey(root, pasted);
+            context.logger.success(`Saved in ${pc.bold(".env")} (git ignores that file). Rowork never prints it.`);
+            return { key: pasted, source: ".env" };
+        }
+        spinner.stop(pc.red(verdict === "refused" ? "Roblox refused the key." : "Could not reach Roblox."));
+        if (verdict === "refused") {
+            context.logger.info("Check that you ticked asset:read and asset:write, that the key has not expired, and that its IP restriction includes this computer.");
+        }
+        const again = answered(await prompts.confirm({ message: "Try another key?", initialValue: true }));
+        if (!again)
+            throw new RoworkError("No key was saved.", { hint: `Run \`rowork assets:setup\` again when you have one, or set ${KEY_NAME} yourself.` });
+    }
+}
+export const assetsSetupCommand = defineCommand({
+    name: "assets:setup",
+    description: "Set up the Roblox API key and owner that `rowork assets` needs (guided, done once).",
+    guided: true,
+    options: [
+        { flags: "--creator <who>", description: "who owns the uploads: user:<id> or group:<id> (remembered in rowork.json)" },
+        { flags: "--check", description: "only check the key and owner already set up (works without a terminal)" },
+    ],
+    async run(context) {
+        const { root, config } = requireProject(context, "assets:setup");
+        const { logger } = context;
+        const check = context.options["check"] === true;
+        if (!check && !isInteractive()) {
+            throw new RoworkError("`rowork assets:setup` needs a terminal to ask for the key (it is never taken from an argument).", {
+                hint: `Outside a terminal, set ${KEY_NAME} in the environment and run \`rowork assets:setup --check --creator user:<id>\`.`,
+            });
+        }
+        let found = readApiKey(root);
+        if (!check) {
+            const replace = found === undefined ||
+                answered(await prompts.confirm({ message: `A key is already set up (${found.source}). Replace it?`, initialValue: false }));
+            if (replace)
+                found = await setUpApiKey(context, root);
+        }
+        if (found === undefined) {
+            throw new RoworkError("No Roblox API key found.", { hint: `Run \`rowork assets:setup\` in a terminal, or set ${KEY_NAME}.` });
+        }
+        if (check) {
+            const verdict = await new OpenCloud(found.key).verifyKey();
+            if (verdict !== "accepted") {
+                throw new RoworkError(verdict === "refused" ? "Roblox refused the key." : "Could not reach Roblox to check the key.", {
+                    hint: "Check its permissions (asset:read, asset:write), its expiry and its IP restriction.",
+                });
+            }
+            logger.success(`The key (${found.source}) is accepted by Roblox.`);
+        }
+        const creator = await resolveCreator(context, config.assets?.creator);
+        saveCreator(root, creator);
+        logger.success(`Assets will be owned by ${creator.type === "user" ? "user" : "group"} ${creator.id}.`);
+        logger.info(`Ready: drop files in ${pc.bold("assets/")} and run \`rowork assets\`.`);
+    },
+});
+//# sourceMappingURL=assets-setup.js.map

package/dist/commands/assets.d.ts

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

package/dist/commands/assets.js

@@ -0,0 +1,153 @@
+import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import pc from "picocolors";
+import { RoworkError } from "../cli/errors.js";
+import { DEFAULT_FOLDER, KEY_NAME, LOCK_FILE, MAX_MODEL_BYTES, MAX_VIDEO_BYTES, assetsFolder, humanSize, planAssets, readApiKey, readLock, renderAssetsModule, scanAssets, writeLock, } from "../core/assets.js";
+import { CONFIG_FILENAME } from "../core/config.js";
+import { OpenCloud } from "../core/open-cloud.js";
+import { defineCommand } from "../plugins/api.js";
+import { answered, isInteractive, prompts } from "../ui/prompt.js";
+import { requireProject } from "./make.js";
+import { KEY_HELP_URL, resolveCreator, saveCreator, setUpApiKey } from "./assets-setup.js";
+const LABEL = { upload: "upload   ", resume: "resume   ", unchanged: "unchanged" };
+export const assetsCommand = defineCommand({
+    name: "assets",
+    description: "Upload the files of your assets folder to Roblox, and use their ids by name in your code.",
+    guided: true,
+    options: [
+        { flags: "--creator <who>", description: "who owns the uploads: user:<id> or group:<id> (remembered in rowork.json)" },
+        { flags: "--dry-run", description: "show what would be uploaded and change nothing" },
+        { flags: "--yes", description: "do not ask for confirmation" },
+    ],
+    async run(context) {
+        const { root, config } = requireProject(context, "assets");
+        const { logger } = context;
+        const folder = assetsFolder(config);
+        const folderPath = join(root, folder);
+        const { files, skipped } = scanAssets(root, folder);
+        if (files.length === 0 && Object.keys(readLock(root).assets).length === 0) {
+            mkdirSync(folderPath, { recursive: true });
+            writeFileSync(join(folderPath, ".gitkeep"), "", { flag: "a" });
+            logger.info(`Nothing to upload yet. Drop images (png, jpg), sounds (mp3, ogg, wav, flac), models (fbx, glb, rbxm) or videos (mp4, mov) in ${pc.bold(`${folder}/`)}, then run \`rowork assets\` again.`);
+            return;
+        }
+        for (const file of skipped)
+            logger.warn(`${file.relative}: ${file.reason}, skipped.`);
+        const lock = readLock(root);
+        const plan = planAssets(files, lock);
+        const todo = plan.filter((entry) => entry.action !== "unchanged");
+        logger.info(pc.bold(`${folder}/`));
+        for (const entry of plan) {
+            logger.step(`${LABEL[entry.action]} ${entry.file.relative} ${pc.dim(`(${entry.file.type}, ${humanSize(entry.file.size)})`)}`);
+        }
+        logger.blank();
+        const present = new Set(files.map((file) => file.relative));
+        const writeModule = () => {
+            const rendered = renderAssetsModule(readLock(root), present);
+            const target = join(root, config.paths.shared);
+            mkdirSync(target, { recursive: true });
+            writeFileSync(join(target, "assets.ts"), rendered.source, "utf8");
+            return { waiting: rendered.waiting };
+        };
+        if (todo.length === 0) {
+            writeModule();
+            logger.success("Everything is already uploaded. Your code uses it as `Assets` from shared/assets.");
+            return;
+        }
+        if (context.options["dryRun"] === true) {
+            logger.info(`Dry run: ${todo.length} file(s) would be uploaded, nothing was changed.`);
+            return;
+        }
+        // The key and the owner are needed before any question about confirming: fail early.
+        let found = readApiKey(root);
+        if (found === undefined) {
+            if (!isInteractive()) {
+                throw new RoworkError("No Roblox API key found.", { hint: `Run \`rowork assets:setup\` in a terminal, or set ${KEY_NAME} in the environment. ${KEY_HELP_URL}` });
+            }
+            logger.info("No Roblox API key yet: let's set it up, it takes a minute and is done once.");
+            found = await setUpApiKey(context, root);
+        }
+        const creator = await resolveCreator(context, config.assets?.creator);
+        if (context.options["yes"] !== true) {
+            if (!isInteractive()) {
+                throw new RoworkError("`rowork assets` asks for confirmation before uploading.", { hint: "Outside a terminal, add --yes (and --dry-run first to preview)." });
+            }
+            const owner = `${creator.type === "user" ? "your account" : "group"} ${creator.id}`;
+            const confirmed = answered(await prompts.confirm({ message: `Upload ${todo.length} file(s) to Roblox, owned by ${owner}?`, initialValue: true }));
+            if (!confirmed) {
+                prompts.cancel("Nothing was uploaded.");
+                return;
+            }
+        }
+        saveCreator(root, creator);
+        const cloud = new OpenCloud(found.key);
+        let failures = 0;
+        for (const { file, action } of todo) {
+            try {
+                if (action === "upload" && file.type === "Model" && file.size > MAX_MODEL_BYTES) {
+                    throw new RoworkError(`${file.relative} is ${humanSize(file.size)}: Roblox accepts models up to 20 MB.`);
+                }
+                if (action === "upload" && file.type === "Video" && file.size > MAX_VIDEO_BYTES) {
+                    throw new RoworkError(`${file.relative} is ${humanSize(file.size)}: Roblox accepts videos up to 3.75 GB.`);
+                }
+                let operation = lock.assets[file.relative]?.operation;
+                if (action === "upload") {
+                    operation = await cloud.createAsset({
+                        file: readFileSync(file.absolute),
+                        fileName: file.relative.split("/").pop() ?? file.relative,
+                        contentType: file.contentType,
+                        assetType: file.type,
+                        displayName: (file.relative.split("/").pop() ?? file.relative).replace(/\.[^.]+$/, "").slice(0, 50),
+                        description: "Uploaded with Rowork",
+                        creator,
+                    });
+                    // Written at once: if the run is interrupted, the next one resumes instead of uploading twice.
+                    lock.assets[file.relative] = { sha256: file.sha256, type: file.type, operation };
+                    writeLock(root, lock);
+                }
+                const result = await cloud.waitForOperation(operation);
+                if (result.failure !== undefined)
+                    throw new RoworkError(result.failure);
+                const entry = { ...(lock.assets[file.relative] ?? { sha256: file.sha256, type: file.type }) };
+                if (result.pending) {
+                    lock.assets[file.relative] = entry;
+                    writeLock(root, lock);
+                    logger.warn(`${file.relative}: Roblox is still processing it. Run \`rowork assets\` again in a moment.`);
+                    continue;
+                }
+                delete entry.operation;
+                lock.assets[file.relative] = {
+                    ...entry,
+                    ...(result.assetId === undefined ? {} : { assetId: result.assetId }),
+                    ...(result.moderation === undefined ? {} : { moderation: result.moderation }),
+                    uploadedAt: new Date().toISOString(),
+                };
+                writeLock(root, lock);
+                logger.success(`${file.relative} -> rbxassetid://${result.assetId ?? "?"}${result.moderation === undefined ? "" : pc.dim(`  (${result.moderation})`)}`);
+            }
+            catch (error) {
+                const message = error instanceof Error ? cloud.redact(error.message) : "unknown error";
+                // A refused key fails every file the same way: stop instead of trying them all.
+                if (error instanceof RoworkError && /refused the API key/.test(error.message))
+                    throw error;
+                failures += 1;
+                logger.error(`${file.relative}: ${message}`);
+                if (error instanceof RoworkError && error.hint !== undefined)
+                    logger.info(`  ${cloud.redact(error.hint)}`);
+            }
+        }
+        const { waiting } = writeModule();
+        logger.blank();
+        logger.info(`Written ${join(config.paths.shared, "assets.ts")}. In your code: ${pc.bold("Assets.<folder>.<name>")}, e.g. \`image.Image = Assets.icons.sword\`.`);
+        if (waiting.length > 0) {
+            logger.warn("Not in Assets yet (waiting for Roblox, or refused):");
+            for (const line of waiting)
+                logger.info(`  ${line}`);
+            logger.info("Run `rowork assets` again later to pick them up.");
+        }
+        logger.info(pc.dim(`Commit ${LOCK_FILE}: it is what stops files from being uploaded twice. Never commit your API key.`));
+        if (failures > 0)
+            process.exitCode = 1;
+    },
+});
+//# sourceMappingURL=assets.js.map

package/dist/commands/console.d.ts

@@ -0,0 +1,4 @@
+/** Splits a line into arguments, keeping "quoted text" together. */
+export declare function tokenize(line: string): string[];
+export declare const consoleCommand: import("../plugins/api.js").CommandDefinition;
+//# sourceMappingURL=console.d.ts.map

package/dist/commands/console.js

@@ -0,0 +1,141 @@
+import { spawn } from "node:child_process";
+import { createInterface } from "node:readline/promises";
+import pc from "picocolors";
+import { RoworkError } from "../cli/errors.js";
+import { activeRegistry } from "../cli/registry.js";
+import { defineCommand } from "../plugins/api.js";
+import { requireInteractive } from "../ui/prompt.js";
+/** Marks child processes so the console cannot be nested inside itself. */
+const IN_CONSOLE = "ROWORK_IN_CONSOLE";
+const BUILTINS = [
+    { name: "help", description: "list the commands" },
+    { name: "clear", description: "clear the screen" },
+    { name: "exit", description: "leave the console (or press Ctrl+D)" },
+];
+/** Splits a line into arguments, keeping "quoted text" together. */
+export function tokenize(line) {
+    const tokens = [];
+    const pattern = /"([^"]*)"|'([^']*)'|(\S+)/g;
+    for (const match of line.matchAll(pattern)) {
+        tokens.push(match[1] ?? match[2] ?? match[3] ?? "");
+    }
+    return tokens;
+}
+function commandNames() {
+    const registered = activeRegistry()?.all().map((entry) => entry.definition.name) ?? [];
+    return [...registered, ...BUILTINS.map((builtin) => builtin.name)].sort();
+}
+function printHelp() {
+    const entries = [
+        ...(activeRegistry()?.all().map((entry) => ({
+            name: entry.definition.name,
+            description: entry.definition.description,
+        })) ?? []),
+        ...BUILTINS,
+    ].filter((entry) => entry.name !== "console");
+    const width = Math.max(...entries.map((entry) => entry.name.length));
+    process.stderr.write("\n");
+    for (const entry of entries) {
+        process.stderr.write(`  ${pc.cyan(entry.name.padEnd(width))}  ${entry.description}\n`);
+    }
+    process.stderr.write(`\n  ${pc.dim("Add --help to any command for its options.")}\n\n`);
+}
+/**
+ * Runs one line as a normal `rowork` process.
+ *
+ * A child process rather than an in-process call: guided prompts, `--help`,
+ * error reporting and the Ctrl+C handling of `rowork dev` then behave exactly
+ * as they do outside the console, with no shared state to leak between
+ * commands. The console itself ignores Ctrl+C while a command runs, so
+ * stopping `dev` returns to the prompt instead of closing everything.
+ */
+function runLine(tokens, cwd) {
+    return new Promise((resolve) => {
+        const script = process.argv[1];
+        if (script === undefined) {
+            resolve();
+            return;
+        }
+        const ignore = () => { };
+        process.on("SIGINT", ignore);
+        const child = spawn(process.execPath, [script, "--cwd", cwd, ...tokens], {
+            stdio: "inherit",
+            env: { ...process.env, [IN_CONSOLE]: "1" },
+        });
+        const finish = () => {
+            process.off("SIGINT", ignore);
+            resolve();
+        };
+        child.on("error", (error) => {
+            process.stderr.write(`${pc.red("error")} ${error.message}\n`);
+            finish();
+        });
+        child.on("close", finish);
+    });
+}
+export const consoleCommand = defineCommand({
+    name: "console",
+    guided: true,
+    description: "Open an interactive Rowork prompt: type commands without retyping `rowork`.",
+    async run(context) {
+        if (process.env[IN_CONSOLE] !== undefined) {
+            throw new RoworkError("You are already in the Rowork console.");
+        }
+        requireInteractive("console", "rowork <command>");
+        const label = context.config?.name ?? "rowork";
+        const promptText = `${pc.bold(pc.cyan(label))}${pc.dim(" >")} `;
+        process.stderr.write(`${pc.bold("Rowork console")} ${pc.dim(`v${context.roworkVersion}`)}\n` +
+            pc.dim("Type a command (make, dev, studio...). `help` lists them, `exit` leaves.\n\n"));
+        const history = [];
+        for (;;) {
+            // A fresh interface per line: guided commands take over the terminal
+            // with their own prompts, and two readers on stdin would fight.
+            const rl = createInterface({
+                input: process.stdin,
+                output: process.stderr,
+                history: [...history],
+                completer: (line) => {
+                    const names = commandNames();
+                    const hits = line.includes(" ") ? [] : names.filter((name) => name.startsWith(line));
+                    return [hits.length > 0 ? hits : [], line];
+                },
+            });
+            let line;
+            try {
+                line = await rl.question(promptText);
+            }
+            catch {
+                // Ctrl+D or a closed input.
+                rl.close();
+                return;
+            }
+            rl.close();
+            const tokens = tokenize(line.trim());
+            if (tokens[0] === "rowork")
+                tokens.shift();
+            if (tokens.length === 0)
+                continue;
+            history.unshift(line.trim());
+            const [first] = tokens;
+            if (first === "exit" || first === "quit")
+                return;
+            if (first === "clear") {
+                process.stderr.write("\x1bc");
+                continue;
+            }
+            if (first === "help" || first === "?") {
+                printHelp();
+                continue;
+            }
+            // Commander would dump the whole usage for a typo: say it in one line.
+            if (first !== undefined && !first.startsWith("-") && !commandNames().includes(first)) {
+                const close = commandNames().filter((name) => name.startsWith(first.slice(0, 3)));
+                process.stderr.write(`${pc.red("error")} Unknown command \`${first}\`.${close.length > 0 ? ` Did you mean ${close.map((name) => `\`${name}\``).join(", ")}?` : ""} Type \`help\` for the list.\n\n`);
+                continue;
+            }
+            await runLine(tokens, context.cwd);
+            process.stderr.write("\n");
+        }
+    },
+});
+//# sourceMappingURL=console.js.map

package/dist/commands/dashboard.d.ts

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