rowork 0.1.0

package/dist/core/background.js

@@ -0,0 +1,149 @@
+import { spawn as spawnDetached, spawnSync } from "node:child_process";
+import { closeSync, existsSync, mkdirSync, openSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+/** Set in the background process, so it knows to clean up after itself. */
+export const DAEMON_ENV = "ROWORK_DEV_DAEMON";
+export function runDirectory(projectRoot) {
+    return join(projectRoot, ".rowork", "run");
+}
+const pidFile = (root) => join(runDirectory(root), "dev.pid");
+export const logFile = (root) => join(runDirectory(root), "dev.log");
+export function isAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        // EPERM means the process exists but belongs to someone else.
+        return error.code === "EPERM";
+    }
+}
+/**
+ * Guards against a recycled PID: after a reboot, an old pid file could name an
+ * unrelated process, and `dev:stop` must never signal that. Where `ps` exists
+ * the command line must mention rowork; Windows has no cheap equivalent, so
+ * there the liveness check alone applies.
+ */
+function looksLikeRowork(pid) {
+    if (process.platform === "win32")
+        return true;
+    const result = spawnSync("ps", ["-p", String(pid), "-o", "command="], { encoding: "utf8" });
+    if (result.status !== 0)
+        return true;
+    return /rowork/i.test(result.stdout);
+}
+export function readRecord(projectRoot) {
+    try {
+        return JSON.parse(readFileSync(pidFile(projectRoot), "utf8"));
+    }
+    catch {
+        return undefined;
+    }
+}
+export function writeRecord(projectRoot, record) {
+    mkdirSync(runDirectory(projectRoot), { recursive: true });
+    writeFileSync(pidFile(projectRoot), `${JSON.stringify(record)}\n`, "utf8");
+}
+export function clearRecord(projectRoot) {
+    rmSync(pidFile(projectRoot), { force: true });
+}
+/** The background `rowork dev` of this project, if one is really running. */
+export function runningRecord(projectRoot) {
+    const record = readRecord(projectRoot);
+    if (record === undefined)
+        return undefined;
+    if (!isAlive(record.pid) || !looksLikeRowork(record.pid)) {
+        clearRecord(projectRoot); // stale: the process is gone
+        return undefined;
+    }
+    return record;
+}
+/** Last `lines` lines of the background log. */
+export function tailLog(projectRoot, lines) {
+    if (!existsSync(logFile(projectRoot)))
+        return [];
+    return readFileSync(logFile(projectRoot), "utf8").split("\n").filter(Boolean).slice(-lines);
+}
+/**
+ * Starts `rowork dev` detached from this terminal and returns its pid.
+ *
+ * A session and process group of its own on POSIX, so closing the terminal
+ * neither reaches it nor stops it; no console window on Windows.
+ */
+export function spawnBackground(projectRoot, script, args) {
+    mkdirSync(runDirectory(projectRoot), { recursive: true });
+    const log = openSync(logFile(projectRoot), "w");
+    const child = spawnDetached(process.execPath, [script, "--cwd", projectRoot, "dev", ...args], {
+        cwd: projectRoot,
+        detached: true,
+        stdio: ["ignore", log, log],
+        env: { ...process.env, [DAEMON_ENV]: "1" },
+        windowsHide: true,
+    });
+    child.unref();
+    closeSync(log);
+    if (child.pid === undefined)
+        throw new Error("could not start the background process");
+    return child.pid;
+}
+/** Stops the process and everything it started. Returns false if it had to be forced. */
+export async function stopProcess(pid) {
+    if (process.platform === "win32") {
+        // The tasks are children of the supervisor: taskkill /T takes the whole tree.
+        await new Promise((resolve) => {
+            const killer = spawnDetached("taskkill", ["/pid", String(pid), "/T", "/F"], { stdio: "ignore" });
+            killer.on("error", () => resolve());
+            killer.on("close", () => resolve());
+        });
+        return true;
+    }
+    // SIGTERM lets the supervisor stop each task's process tree itself.
+    try {
+        process.kill(pid, "SIGTERM");
+    }
+    catch {
+        return true;
+    }
+    for (let waited = 0; waited < 10000; waited += 100) {
+        if (!isAlive(pid))
+            return true;
+        await new Promise((resolve) => setTimeout(resolve, 100));
+    }
+    try {
+        process.kill(pid, "SIGKILL");
+    }
+    catch {
+        // Gone in the meantime.
+    }
+    return false;
+}
+const dashboardFile = (root) => join(runDirectory(root), "dashboard.json");
+/**
+ * Remembers the dashboard that is running, so `rowork dev -d` can print its address
+ * and `rowork dashboard` can open it instead of starting a second one.
+ *
+ * The address holds the secret token, so the file is readable by its owner only
+ * (mode 0600; on Windows the user profile already is private) and lives in
+ * `.rowork/run/`, which the generated .gitignore excludes.
+ */
+export function writeDashboardRecord(root, record) {
+    mkdirSync(runDirectory(root), { recursive: true });
+    writeFileSync(dashboardFile(root), `${JSON.stringify(record)}\n`, { encoding: "utf8", mode: 0o600 });
+}
+export function clearDashboardRecord(root) {
+    rmSync(dashboardFile(root), { force: true });
+}
+/** The dashboard of this project, if its process is really alive. A stale record is removed. */
+export function runningDashboard(root) {
+    try {
+        const record = JSON.parse(readFileSync(dashboardFile(root), "utf8"));
+        if (isAlive(record.pid) && looksLikeRowork(record.pid))
+            return record;
+    }
+    catch {
+        // No record, or unreadable: nothing is running as far as Rowork knows.
+    }
+    clearDashboardRecord(root);
+    return undefined;
+}
+//# sourceMappingURL=background.js.map

package/dist/core/config.d.ts

@@ -0,0 +1,9 @@
+import { type RoworkConfig } from "../plugins/api.js";
+export declare const CONFIG_FILENAME = "rowork.json";
+/** Walks up the directory tree until a rowork.json is found. */
+export declare function findProjectRoot(from: string): string | undefined;
+export declare function loadConfig(projectRoot: string): RoworkConfig;
+export declare function defaultConfig(name: string): RoworkConfig;
+/** Resolves a config path relative to the project root. */
+export declare function resolveProjectPath(projectRoot: string, path: string): string;
+//# sourceMappingURL=config.d.ts.map

package/dist/core/config.js

@@ -0,0 +1,62 @@
+import { existsSync, readFileSync } from "node:fs";
+import { dirname, isAbsolute, join, parse, resolve } from "node:path";
+import { RoworkError } from "../cli/errors.js";
+import { ROWORK_PLUGIN_API_VERSION } from "../plugins/api.js";
+export const CONFIG_FILENAME = "rowork.json";
+/** Walks up the directory tree until a rowork.json is found. */
+export function findProjectRoot(from) {
+    let current = resolve(from);
+    const { root } = parse(current);
+    for (;;) {
+        if (existsSync(join(current, CONFIG_FILENAME)))
+            return current;
+        if (current === root)
+            return undefined;
+        const parent = dirname(current);
+        if (parent === current)
+            return undefined;
+        current = parent;
+    }
+}
+export function loadConfig(projectRoot) {
+    const file = join(projectRoot, CONFIG_FILENAME);
+    let parsed;
+    try {
+        parsed = JSON.parse(readFileSync(file, "utf8"));
+    }
+    catch (cause) {
+        throw new RoworkError(`${CONFIG_FILENAME} is unreadable or malformed.`, {
+            hint: `Check the JSON syntax of ${file}.`,
+            cause,
+        });
+    }
+    if (typeof parsed !== "object" || parsed === null) {
+        throw new RoworkError(`${CONFIG_FILENAME} must contain a JSON object.`);
+    }
+    const config = parsed;
+    if (config.roworkApiVersion !== ROWORK_PLUGIN_API_VERSION) {
+        throw new RoworkError(`This project targets Rowork API v${String(config.roworkApiVersion)}, this CLI provides v${ROWORK_PLUGIN_API_VERSION}.`, { hint: "Update Rowork, or adjust `roworkApiVersion` in rowork.json." });
+    }
+    return config;
+}
+export function defaultConfig(name) {
+    return {
+        name,
+        roworkApiVersion: ROWORK_PLUGIN_API_VERSION,
+        language: "roblox-ts",
+        paths: {
+            source: "src",
+            out: "out",
+            rojoProject: "default.project.json",
+            services: "src/server/services",
+            controllers: "src/client/controllers",
+            shared: "src/shared",
+        },
+        plugins: [],
+    };
+}
+/** Resolves a config path relative to the project root. */
+export function resolveProjectPath(projectRoot, path) {
+    return isAbsolute(path) ? path : resolve(projectRoot, path);
+}
+//# sourceMappingURL=config.js.map

package/dist/core/exec.d.ts

@@ -0,0 +1,22 @@
+export interface RunOptions {
+    cwd: string;
+    /** Whether the tool's own output reaches the terminal. */
+    stdio?: "inherit" | "ignore";
+    /** Extra environment variables, merged over the current ones. */
+    env?: Record<string, string>;
+}
+/**
+ * Runs an external executable.
+ *
+ * Every external tool Rowork drives on Windows (`npm`, `rojo`, `rbxtsc`) is a
+ * `.cmd` shim, and since the fix for CVE-2024-27980 Node refuses to spawn one
+ * without `shell: true`, failing with EINVAL. Turning the shell on instead
+ * would make every argument a shell injection vector, and a hostile
+ * rowork.json could then run arbitrary commands on a contributor's machine.
+ *
+ * cross-spawn is the standard way out: it invokes `cmd.exe` itself and escapes
+ * the arguments, so no argument is ever interpreted as a command. It is also
+ * why `.cmd` is never appended by hand anywhere in this codebase.
+ */
+export declare function run(command: string, args: string[], options: RunOptions): Promise<void>;
+//# sourceMappingURL=exec.d.ts.map

package/dist/core/exec.js

@@ -0,0 +1,38 @@
+import spawn from "cross-spawn";
+import { RoworkError } from "../cli/errors.js";
+/**
+ * Runs an external executable.
+ *
+ * Every external tool Rowork drives on Windows (`npm`, `rojo`, `rbxtsc`) is a
+ * `.cmd` shim, and since the fix for CVE-2024-27980 Node refuses to spawn one
+ * without `shell: true`, failing with EINVAL. Turning the shell on instead
+ * would make every argument a shell injection vector, and a hostile
+ * rowork.json could then run arbitrary commands on a contributor's machine.
+ *
+ * cross-spawn is the standard way out: it invokes `cmd.exe` itself and escapes
+ * the arguments, so no argument is ever interpreted as a command. It is also
+ * why `.cmd` is never appended by hand anywhere in this codebase.
+ */
+export function run(command, args, options) {
+    return new Promise((resolvePromise, rejectPromise) => {
+        const child = spawn(command, args, {
+            cwd: options.cwd,
+            stdio: options.stdio ?? "inherit",
+            env: { ...process.env, ...options.env },
+        });
+        child.on("error", (cause) => {
+            rejectPromise(new RoworkError(`Could not run \`${command}\`.`, {
+                hint: `Make sure \`${command}\` is installed and available on your PATH.`,
+                cause,
+            }));
+        });
+        child.on("close", (code) => {
+            if (code === 0) {
+                resolvePromise();
+                return;
+            }
+            rejectPromise(new RoworkError(`\`${command} ${args.join(" ")}\` exited with code ${String(code)}.`));
+        });
+    });
+}
+//# sourceMappingURL=exec.js.map

package/dist/core/format-generated.d.ts

@@ -0,0 +1,12 @@
+import type { Logger } from "../plugins/api.js";
+/**
+ * Runs the project's own Prettier over files Rowork just wrote or edited.
+ *
+ * A generator cannot know where a formatter will wrap a line: a long name pushes an import
+ * or a tag past the line width and the project's `format:check` then fails on code the
+ * user never touched. Asking the formatter itself is the only answer that stays right when
+ * its settings change. Nothing to do (and nothing said) when the project has no Prettier:
+ * the code is still correct, only laid out a little differently.
+ */
+export declare function formatGenerated(projectRoot: string, files: string[], logger: Logger): Promise<void>;
+//# sourceMappingURL=format-generated.d.ts.map

package/dist/core/format-generated.js

@@ -0,0 +1,28 @@
+import { RoworkError } from "../cli/errors.js";
+import { run } from "./exec.js";
+import { findExecutable, pathWithLocalBinaries } from "./toolchain.js";
+/**
+ * Runs the project's own Prettier over files Rowork just wrote or edited.
+ *
+ * A generator cannot know where a formatter will wrap a line: a long name pushes an import
+ * or a tag past the line width and the project's `format:check` then fails on code the
+ * user never touched. Asking the formatter itself is the only answer that stays right when
+ * its settings change. Nothing to do (and nothing said) when the project has no Prettier:
+ * the code is still correct, only laid out a little differently.
+ */
+export async function formatGenerated(projectRoot, files, logger) {
+    if (files.length === 0 || findExecutable("prettier", projectRoot) === undefined)
+        return;
+    try {
+        await run("prettier", ["--write", ...files], {
+            cwd: projectRoot,
+            stdio: "ignore",
+            env: { PATH: pathWithLocalBinaries(projectRoot) },
+        });
+    }
+    catch (error) {
+        const detail = error instanceof RoworkError ? error.message : String(error);
+        logger.warn(`Could not format the new files with Prettier (${detail}). Run \`npm run format\` if your formatter complains.`);
+    }
+}
+//# sourceMappingURL=format-generated.js.map

package/dist/core/generate.d.ts

@@ -0,0 +1,37 @@
+import type { Logger } from "../plugins/api.js";
+/** Flamework's own naming convention: `Inventory` -> `InventoryService`. */
+export declare function withSuffix(pascalName: string, suffix: string): string;
+/** Turns anything typed by the user into a class-safe PascalCase name. */
+export declare function toClassBase(raw: string): string;
+export interface GenerateOptions {
+    projectRoot: string;
+    /** Directory to write into, relative to the project root. */
+    directory: string;
+    fileName: string;
+    /** Template name under `templates/<templateRoot>/`, without the `.ts.tmpl` suffix. */
+    template: string;
+    /** Directory under `templates/` holding the template. Defaults to `make`. */
+    templateRoot?: string;
+    variables: Record<string, string>;
+    force: boolean;
+    /** What to do when the file exists and `force` is off. Defaults to failing. */
+    ifExists?: "fail" | "skip";
+}
+/**
+ * Writes one generated file and returns its path relative to the project, or
+ * undefined when it already existed and `ifExists` is "skip".
+ */
+export declare function generateFile(options: GenerateOptions): string | undefined;
+/** Relative module specifier from one project directory to a file (no extension). */
+export declare function importPath(projectRoot: string, fromDirectory: string, toFile: string): string;
+/**
+ * Makes sure a runtime entry file scans a directory.
+ *
+ * Flamework only discovers what `addPaths` lists, so a class written to a
+ * directory that is not listed compiles fine and then silently never runs.
+ * Returns true when the file was changed. The edit is a plain text insertion
+ * next to the existing `addPaths` calls; if the file does not look the way Rowork
+ * generated it, nothing is touched and the caller is told to do it by hand.
+ */
+export declare function ensureFlameworkPath(runtimeFile: string, directory: string, logger: Logger): boolean;
+//# sourceMappingURL=generate.d.ts.map

package/dist/core/generate.js

@@ -0,0 +1,94 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { join, relative } from "node:path";
+import { RoworkError } from "../cli/errors.js";
+import { renderString, templatesRoot } from "../templates/engine.js";
+import { resolveProjectPath } from "./config.js";
+/** Flamework's own naming convention: `Inventory` -> `InventoryService`. */
+export function withSuffix(pascalName, suffix) {
+    return pascalName.endsWith(suffix) && pascalName.length > suffix.length
+        ? pascalName
+        : `${pascalName}${suffix}`;
+}
+/** Turns anything typed by the user into a class-safe PascalCase name. */
+export function toClassBase(raw) {
+    const pascal = raw
+        .split(/[^A-Za-z0-9]+/)
+        .filter((part) => part.length > 0)
+        .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
+        .join("");
+    if (!/^[A-Z][A-Za-z0-9]*$/.test(pascal)) {
+        throw new RoworkError(`\`${raw}\` cannot be turned into a class name.`, {
+            hint: "Use letters and digits, starting with a letter: e.g. Inventory, or player-stats.",
+        });
+    }
+    return pascal;
+}
+/**
+ * Writes one generated file and returns its path relative to the project, or
+ * undefined when it already existed and `ifExists` is "skip".
+ */
+export function generateFile(options) {
+    const directory = resolveProjectPath(options.projectRoot, options.directory);
+    const target = join(directory, options.fileName);
+    const shown = relative(options.projectRoot, target);
+    if (existsSync(target) && !options.force) {
+        if (options.ifExists === "skip")
+            return undefined;
+        throw new RoworkError(`${shown} already exists.`, {
+            hint: "Pick another name, or pass --force to overwrite it.",
+        });
+    }
+    // `name.ts.tmpl` by default; a template that is not TypeScript carries its own
+    // extension in its name (`eslint.config.mjs` is stored as `eslint.config.mjs.tmpl`).
+    const base = join(templatesRoot(), options.templateRoot ?? "make", options.template);
+    const source = readFileSync(existsSync(`${base}.ts.tmpl`) ? `${base}.ts.tmpl` : `${base}.tmpl`, "utf8");
+    mkdirSync(directory, { recursive: true });
+    writeFileSync(target, renderString(source, options.variables), "utf8");
+    return shown;
+}
+/** Relative module specifier from one project directory to a file (no extension). */
+export function importPath(projectRoot, fromDirectory, toFile) {
+    const path = relative(resolveProjectPath(projectRoot, fromDirectory), resolveProjectPath(projectRoot, toFile))
+        .split("\\")
+        .join("/");
+    return path.startsWith(".") ? path : `./${path}`;
+}
+/**
+ * Makes sure a runtime entry file scans a directory.
+ *
+ * Flamework only discovers what `addPaths` lists, so a class written to a
+ * directory that is not listed compiles fine and then silently never runs.
+ * Returns true when the file was changed. The edit is a plain text insertion
+ * next to the existing `addPaths` calls; if the file does not look the way Rowork
+ * generated it, nothing is touched and the caller is told to do it by hand.
+ */
+export function ensureFlameworkPath(runtimeFile, directory, logger) {
+    const posixDirectory = directory.split("\\").join("/");
+    if (!existsSync(runtimeFile)) {
+        logger.warn(`${runtimeFile} not found: add Flamework.addPaths("${posixDirectory}") yourself.`);
+        return false;
+    }
+    const source = readFileSync(runtimeFile, "utf8");
+    const alreadyListed = new RegExp(`Flamework\\.addPaths\\(\\s*["']${posixDirectory.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}["']\\s*\\)`);
+    if (alreadyListed.test(source))
+        return false;
+    // Keep the addPaths calls together: insert after the last one when there is
+    // one, and otherwise right before ignite().
+    const calls = [...source.matchAll(/^[ \t]*Flamework\.addPaths\([^\n]*\);?[ \t]*$/gm)];
+    const last = calls.at(-1);
+    const line = `Flamework.addPaths("${posixDirectory}");`;
+    if (last !== undefined) {
+        const indent = /^[ \t]*/.exec(last[0])?.[0] ?? "";
+        const end = last.index + last[0].length;
+        writeFileSync(runtimeFile, `${source.slice(0, end)}\n${indent}${line}${source.slice(end)}`, "utf8");
+        return true;
+    }
+    const ignite = /^([ \t]*)Flamework\.ignite\(\);?/m.exec(source);
+    if (ignite === null) {
+        logger.warn(`Could not find Flamework.ignite() in ${runtimeFile}: add ${line} yourself.`);
+        return false;
+    }
+    writeFileSync(runtimeFile, `${source.slice(0, ignite.index)}${ignite[1] ?? ""}${line}\n\n${source.slice(ignite.index)}`, "utf8");
+    return true;
+}
+//# sourceMappingURL=generate.js.map

package/dist/core/github-release.d.ts

@@ -0,0 +1,28 @@
+export interface ReleaseAsset {
+    name: string;
+    browser_download_url: string;
+    /** `sha256:<hex>`, published by GitHub for recent release assets only. */
+    digest?: string | null;
+}
+export interface Release {
+    tag_name: string;
+    assets?: ReleaseAsset[];
+}
+/** Fetches a release of `owner/repo`: the latest one, or the one tagged `tag`. */
+export declare function getRelease(repository: string, tag?: string): Promise<Release>;
+export interface DownloadedAsset {
+    data: Buffer;
+    /** False when GitHub published no checksum, so nothing could be verified. */
+    verified: boolean;
+}
+/**
+ * Downloads a release asset and checks it against the SHA-256 GitHub publishes.
+ *
+ * A published checksum that does not match always fails. A missing checksum
+ * fails too unless `allowUnverified` is set: older releases predate checksums,
+ * and the caller decides whether the artifact is worth the risk.
+ */
+export declare function downloadAsset(asset: ReleaseAsset, options?: {
+    allowUnverified?: boolean;
+}): Promise<DownloadedAsset>;
+//# sourceMappingURL=github-release.d.ts.map

package/dist/core/github-release.js

@@ -0,0 +1,38 @@
+import { createHash } from "node:crypto";
+const HEADERS = { "User-Agent": "rowork" };
+/** Fetches a release of `owner/repo`: the latest one, or the one tagged `tag`. */
+export async function getRelease(repository, tag) {
+    const path = tag === undefined ? "latest" : `tags/${tag}`;
+    const url = `https://api.github.com/repos/${repository}/releases/${path}`;
+    // A stalled connection must not hang the CLI: the API answers in well under a second.
+    const response = await fetch(url, { headers: HEADERS, signal: AbortSignal.timeout(20_000) });
+    if (!response.ok)
+        throw new Error(`${url} answered ${response.status}`);
+    return (await response.json());
+}
+/**
+ * Downloads a release asset and checks it against the SHA-256 GitHub publishes.
+ *
+ * A published checksum that does not match always fails. A missing checksum
+ * fails too unless `allowUnverified` is set: older releases predate checksums,
+ * and the caller decides whether the artifact is worth the risk.
+ */
+export async function downloadAsset(asset, options = {}) {
+    const response = await fetch(asset.browser_download_url, { headers: HEADERS });
+    if (!response.ok)
+        throw new Error(`${asset.browser_download_url} answered ${response.status}`);
+    const data = Buffer.from(await response.arrayBuffer());
+    const expected = asset.digest?.replace(/^sha256:/, "");
+    if (expected === undefined) {
+        if (options.allowUnverified !== true) {
+            throw new Error(`${asset.name} has no published checksum`);
+        }
+        return { data, verified: false };
+    }
+    const actual = createHash("sha256").update(data).digest("hex");
+    if (actual !== expected) {
+        throw new Error(`checksum mismatch for ${asset.name} (expected ${expected}, got ${actual})`);
+    }
+    return { data, verified: true };
+}
+//# sourceMappingURL=github-release.js.map

package/dist/core/info.d.ts

@@ -0,0 +1,77 @@
+import { type RoworkConfig } from "../plugins/api.js";
+/**
+ * Everything Rowork knows about a project and about itself, as plain data.
+ *
+ * One source for `rowork info --json` and for the dashboard, so the two can never
+ * disagree about what is installed or which commands exist.
+ */
+export declare function collectInfo(input: {
+    config: RoworkConfig | undefined;
+    projectRoot: string | undefined;
+    roworkVersion: string;
+}): {
+    rowork: {
+        version: string;
+        pluginApiVersion: number;
+    };
+    project: {
+        name: string;
+        root: string;
+        language: "roblox-ts";
+        paths: {
+            source: string;
+            out: string;
+            rojoProject: string;
+            services: string;
+            controllers: string;
+            shared: string;
+        };
+        modules: string[];
+        integrations: string[];
+        dev: {
+            pid: number;
+            port: number;
+            mode: "foreground" | "background";
+        } | null;
+        devRunningInBackground: {
+            pid: number;
+            port: number;
+        } | null;
+    } | null;
+    modules: {
+        name: string;
+        title: string;
+        description: string;
+        installed: boolean;
+        requires: string[];
+        dependencies: string[];
+        command: string;
+        options: {
+            flags: string;
+            description: string;
+        }[];
+    }[];
+    integrations: {
+        name: string;
+        title: string;
+        description: string;
+        modules: string[];
+        applied: boolean;
+    }[];
+    commands: {
+        name: string;
+        description: string;
+        guided: boolean;
+        arguments: {
+            name: string;
+            description: string;
+            required: boolean;
+            variadic: boolean;
+        }[];
+        options: {
+            flags: string;
+            description: string;
+        }[];
+    }[];
+};
+//# sourceMappingURL=info.d.ts.map

package/dist/core/info.js

@@ -0,0 +1,65 @@
+import { activeRegistry } from "../cli/registry.js";
+import { coreModules } from "../modules/index.js";
+import { coreIntegrations } from "../modules/integrations.js";
+import { ROWORK_PLUGIN_API_VERSION } from "../plugins/api.js";
+import { runningRecord } from "./background.js";
+/**
+ * Everything Rowork knows about a project and about itself, as plain data.
+ *
+ * One source for `rowork info --json` and for the dashboard, so the two can never
+ * disagree about what is installed or which commands exist.
+ */
+export function collectInfo(input) {
+    const { config, projectRoot } = input;
+    const installed = config?.modules ?? [];
+    const appliedIntegrations = config?.integrations ?? [];
+    const dev = projectRoot === undefined ? undefined : runningRecord(projectRoot);
+    const modules = coreModules.map((module) => ({
+        name: module.name,
+        title: module.title,
+        description: module.description,
+        installed: installed.includes(module.name),
+        requires: module.requires ?? [],
+        dependencies: module.dependencies ?? [],
+        command: `add:${module.name}`,
+        options: (module.options ?? []).map((option) => ({ flags: option.flags, description: option.description })),
+    }));
+    const integrations = coreIntegrations.map((integration) => ({
+        name: integration.name,
+        title: integration.title,
+        description: integration.description,
+        modules: integration.modules,
+        applied: appliedIntegrations.includes(integration.name),
+    }));
+    const commands = (activeRegistry()?.all() ?? []).map(({ definition }) => ({
+        name: definition.name,
+        description: definition.description,
+        guided: definition.guided === true,
+        arguments: (definition.arguments ?? []).map((argument) => ({
+            name: argument.name,
+            description: argument.description,
+            required: argument.required ?? true,
+            variadic: argument.variadic === true,
+        })),
+        options: (definition.options ?? []).map((option) => ({ flags: option.flags, description: option.description })),
+    }));
+    return {
+        rowork: { version: input.roworkVersion, pluginApiVersion: ROWORK_PLUGIN_API_VERSION },
+        project: projectRoot === undefined || config === undefined
+            ? null
+            : {
+                name: config.name,
+                root: projectRoot,
+                language: config.language,
+                paths: config.paths,
+                modules: installed,
+                integrations: appliedIntegrations,
+                dev: dev === undefined ? null : { pid: dev.pid, port: dev.port, mode: dev.mode ?? "background" },
+                devRunningInBackground: dev === undefined || dev.mode === "foreground" ? null : { pid: dev.pid, port: dev.port },
+            },
+        modules,
+        integrations,
+        commands,
+    };
+}
+//# sourceMappingURL=info.js.map