rowork 0.1.0

package/dist/core/agent-docs.js

@@ -0,0 +1,151 @@
+import { existsSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { activeRegistry } from "../cli/registry.js";
+import { coreModules } from "../modules/index.js";
+import { coreIntegrations } from "../modules/integrations.js";
+export const AGENTS_FILE = "AGENTS.md";
+export const CLAUDE_FILE = "CLAUDE.md";
+const BEGIN = "<!-- rowork:begin: generated by Rowork and rewritten by `rowork add`. Put your own notes OUTSIDE this block. -->";
+const END = "<!-- rowork:end -->";
+/**
+ * The block Rowork owns in AGENTS.md.
+ *
+ * Built from live data (the registered commands, the installed modules) so it
+ * cannot drift from what the project really offers. It is written for two
+ * readers at once: a person learning the project, and an AI about to change it.
+ */
+export function renderManagedSection(config, roworkVersion) {
+    const installed = config.modules ?? [];
+    const commands = (activeRegistry()?.all() ?? [])
+        .map((entry) => entry.definition)
+        .filter((definition) => !["console", "help"].includes(definition.name));
+    const lines = [
+        BEGIN,
+        `## ${config.name}: a Rowork project`,
+        "",
+        `Generated by Rowork ${roworkVersion}. roblox-ts (TypeScript compiled to Luau) + Flamework (services, controllers, components, dependency injection) + Rojo (sync into Roblox Studio).`,
+        "",
+        "### How to work here",
+        "",
+        "- **`rowork make:*` creates one file, `rowork add:*` installs a feature.** `make` puts an (almost empty) file in the right place and connects it wherever it must be included; you write its logic. `add` installs a ready-made, working pack of files (saved player data, typed networking...). Do not reimplement in `make` files what an `add` module already provides.",
+        "- **Create things with Rowork instead of writing the files by hand.** It names them, puts them in the right directory and registers them with Flamework (a class in a directory not passed to `Flamework.addPaths` compiles and then silently never runs).",
+        "- **Always pass every argument.** Without arguments a command opens interactive questions and waits for a terminal. Commands marked *guided* below do that.",
+        "- **Modules connect themselves.** When two installed modules work together, `rowork add` generates the glue (see \"Modules wired together\"); `rowork wire` retries it. Do not write that glue by hand.",
+        "- **Know what exists first:** `rowork info --json` prints the project, the installed modules and every command with its options, as JSON.",
+        "- **Check your work:** `npm run build` (or `npx rbxtsc`) must finish with no error. In Studio, `rowork dev -d` runs everything in the background, `rowork dev:logs` shows compiler errors, `rowork dev:stop` stops it.",
+        "- Files starting with `// Generated by` are rewritten by Rowork: do not edit them.",
+        "- Never edit `node_modules/`, `out/`, `include/` or `sourcemap.json`. They are build output.",
+        "",
+        "### Layout",
+        "",
+        `- \`${config.paths.services}/\`: Flamework services (server logic). \`${config.paths.controllers}/\`: controllers (client logic). \`${config.paths.shared}/\`: code shared by both.`,
+        `- \`${config.paths.source}/server/runtime.server.ts\` and \`${config.paths.source}/client/runtime.client.ts\`: entry points listing the directories Flamework scans.`,
+        "- `default.project.json`: what appears in Studio. `rokit.toml`: pinned Rojo version. `rowork.json`: Rowork's own configuration.",
+        "",
+        "### Installed modules",
+        "",
+    ];
+    if (installed.length === 0) {
+        lines.push("None yet. `rowork add` lists what can be added (player data, leaderstats, typed networking...).", "");
+    }
+    else {
+        for (const name of installed) {
+            const module = coreModules.find((candidate) => candidate.name === name);
+            lines.push(`#### ${module?.title ?? name} (\`${name}\`)`, "");
+            if (module?.agentGuide === undefined)
+                lines.push("Installed with `rowork add`. Read its files.");
+            else
+                for (const line of module.agentGuide)
+                    lines.push(`- ${line}`);
+            lines.push("");
+        }
+    }
+    const wired = coreIntegrations.filter((integration) => (config.integrations ?? []).includes(integration.name));
+    if (wired.length > 0) {
+        lines.push("### Modules wired together", "", "Rowork generated this glue because the modules below are both installed. Use it instead of writing it again.", "");
+        for (const integration of wired) {
+            lines.push(`#### ${integration.title} (\`${integration.modules.join(" + ")}\`)`, "");
+            for (const line of integration.agentGuide ?? [integration.description])
+                lines.push(`- ${line}`);
+            lines.push("");
+        }
+    }
+    const available = coreModules.filter((module) => !installed.includes(module.name));
+    if (available.length > 0) {
+        lines.push("### Modules you can still add", "");
+        for (const module of available) {
+            const needs = module.requires === undefined ? "" : ` (needs: ${module.requires.join(", ")})`;
+            lines.push(`- \`rowork add:${module.name}\`: ${module.description}${needs}`);
+        }
+        lines.push("");
+    }
+    lines.push("### Commands", "");
+    for (const command of commands) {
+        const guided = command.guided === true ? " *(guided: pass all arguments)*" : "";
+        lines.push(`- \`rowork ${command.name}\`${guided}: ${command.description}`);
+    }
+    lines.push("", "Every command has `--help`. Use `rowork info --json` for the full option list.", END);
+    return `${lines.join("\n")}\n`;
+}
+/**
+ * Creates or refreshes AGENTS.md (and a CLAUDE.md that points to it).
+ *
+ * Only the block between the markers is rewritten: anything the user wrote
+ * around it stays. An existing CLAUDE.md is never touched. Claude Code reads
+ * CLAUDE.md and most other agents read AGENTS.md, so one file holds the content
+ * and the other imports it.
+ */
+export function syncAgentDocs(projectRoot, config, roworkVersion) {
+    const touched = [];
+    const section = renderManagedSection(config, roworkVersion);
+    const agentsPath = join(projectRoot, AGENTS_FILE);
+    if (!existsSync(agentsPath)) {
+        writeFileSync(agentsPath, `# ${config.name}\n\n${section}`, "utf8");
+        touched.push(AGENTS_FILE);
+    }
+    else {
+        const current = readFileSync(agentsPath, "utf8");
+        const start = current.indexOf("<!-- rowork:begin");
+        const end = current.indexOf(END);
+        const next = start !== -1 && end > start
+            ? `${current.slice(0, start)}${section.trimEnd()}${current.slice(end + END.length)}`
+            : `${current.trimEnd()}\n\n${section}`;
+        if (next !== current) {
+            writeFileSync(agentsPath, next, "utf8");
+            touched.push(AGENTS_FILE);
+        }
+    }
+    const claudePath = join(projectRoot, CLAUDE_FILE);
+    if (!existsSync(claudePath)) {
+        writeFileSync(claudePath, "@AGENTS.md\n", "utf8");
+        touched.push(CLAUDE_FILE);
+    }
+    return touched;
+}
+/** Removes the Rowork block when leaving Rowork; deletes files that held nothing else. */
+export function removeAgentDocs(projectRoot) {
+    const touched = [];
+    const agentsPath = join(projectRoot, AGENTS_FILE);
+    if (existsSync(agentsPath)) {
+        const current = readFileSync(agentsPath, "utf8");
+        const start = current.indexOf("<!-- rowork:begin");
+        const end = current.indexOf(END);
+        if (start !== -1 && end > start) {
+            const rest = `${current.slice(0, start)}${current.slice(end + END.length)}`;
+            // A file that only held the generated title and block held nothing of the user's.
+            const remaining = rest.replace(/^# .*$/m, "").trim();
+            if (remaining === "")
+                rmSync(agentsPath);
+            else
+                writeFileSync(agentsPath, `${rest.trim()}\n`, "utf8");
+            touched.push(AGENTS_FILE);
+        }
+    }
+    const claudePath = join(projectRoot, CLAUDE_FILE);
+    if (existsSync(claudePath) && readFileSync(claudePath, "utf8").trim() === "@AGENTS.md" && !existsSync(agentsPath)) {
+        rmSync(claudePath);
+        touched.push(CLAUDE_FILE);
+    }
+    return touched;
+}
+//# sourceMappingURL=agent-docs.js.map

package/dist/core/assets.d.ts

@@ -0,0 +1,96 @@
+import type { AssetType } from "./open-cloud.js";
+export declare const LOCK_FILE = "assets.lock.json";
+export declare const KEY_NAME = "ROWORK_ROBLOX_API_KEY";
+export declare const DEFAULT_FOLDER = "assets";
+/** Roblox's documented ceiling for a model upload. */
+export declare const MAX_MODEL_BYTES: number;
+/** And for a video (also at most 5 minutes and 4096x2160; uploading needs an ID-verified account aged 13 or more). */
+export declare const MAX_VIDEO_BYTES: number;
+export interface AssetFile {
+    /** Path inside the assets folder, with `/` on every system. */
+    relative: string;
+    absolute: string;
+    type: AssetType;
+    contentType: string;
+    sha256: string;
+    size: number;
+}
+export interface SkippedFile {
+    relative: string;
+    reason: string;
+}
+export interface LockEntry {
+    sha256: string;
+    type: AssetType;
+    assetId?: string;
+    /** An upload that had not finished: followed again on the next run. */
+    operation?: string;
+    moderation?: string;
+    uploadedAt?: string;
+}
+export interface Lock {
+    version: 1;
+    assets: Record<string, LockEntry>;
+}
+/** Walks the assets folder. Hidden files are ignored, unsupported ones are reported. */
+export declare function scanAssets(projectRoot: string, folder: string): {
+    files: AssetFile[];
+    skipped: SkippedFile[];
+};
+export declare function readLock(projectRoot: string): Lock;
+/** Sorted keys, so the file only changes when an asset does and diffs stay readable. */
+export declare function writeLock(projectRoot: string, lock: Lock): void;
+export type Action = "upload" | "resume" | "unchanged";
+export interface PlannedAsset {
+    file: AssetFile;
+    action: Action;
+}
+/**
+ * What a run has to do. A file is uploaded again only when its content changed: the
+ * hash in the lock file is what makes `rowork assets` safe to run as often as you like.
+ * (An image cannot be updated in place, so a changed image becomes a new asset.)
+ */
+export declare function planAssets(files: AssetFile[], lock: Lock): PlannedAsset[];
+/**
+ * A moderation state that lets the asset be used. Unknown states are not assumed safe.
+ * Roblox writes it as `Approved` (seen with a real upload), its documentation as
+ * `MODERATION_STATE_APPROVED`: both are accepted, in any letter case.
+ */
+export declare function isApproved(moderation: string | undefined): boolean;
+/**
+ * The TypeScript file that lets the code name an asset instead of a number.
+ *
+ * Only files that still exist and are approved are listed, so the code never points
+ * at something that was deleted or refused. It is laid out the way Prettier writes it,
+ * because generated code has to pass the project's formatter.
+ */
+export declare function renderAssetsModule(lock: Lock, present: Set<string>): {
+    source: string;
+    waiting: string[];
+};
+/**
+ * Finds the Open Cloud API key: the environment first, then `.env`.
+ *
+ * A key that sits in `.env` is refused if git would commit that file. The history of
+ * a repository outlives any key rotation, and this one is going to be public.
+ */
+export declare function readApiKey(projectRoot: string): {
+    key: string;
+    source: "environment" | ".env";
+} | undefined;
+/** A pasted key is one token: no spaces, no quotes, nothing that could break a `.env` line. */
+export declare function looksLikeApiKey(text: string): boolean;
+/**
+ * Stores the key in `.env`, in that order: first make sure git ignores `.env`, and only
+ * then write the key. Other lines of the file are kept. The file is readable by its owner only.
+ */
+export declare function saveApiKey(projectRoot: string, key: string): void;
+export declare function assetsFolder(config: {
+    assets?: {
+        folder?: string;
+    };
+}): string;
+/** Bytes as a short human string. */
+export declare function humanSize(bytes: number): string;
+export declare function statSize(path: string): number;
+//# sourceMappingURL=assets.d.ts.map

package/dist/core/assets.js

@@ -0,0 +1,268 @@
+import { spawnSync } from "node:child_process";
+import { createHash } from "node:crypto";
+import { chmodSync, existsSync, readFileSync, readdirSync, statSync, writeFileSync } from "node:fs";
+import { extname, join } from "node:path";
+import { RoworkError } from "../cli/errors.js";
+import { toFieldName } from "../modules/player-data.js";
+export const LOCK_FILE = "assets.lock.json";
+export const KEY_NAME = "ROWORK_ROBLOX_API_KEY";
+export const DEFAULT_FOLDER = "assets";
+/** What each file extension is uploaded as, from Roblox's list of supported formats. */
+const KINDS = {
+    ".png": { type: "Image", contentType: "image/png" },
+    ".jpg": { type: "Image", contentType: "image/jpeg" },
+    ".jpeg": { type: "Image", contentType: "image/jpeg" },
+    ".bmp": { type: "Image", contentType: "image/bmp" },
+    ".tga": { type: "Image", contentType: "image/x-tga" },
+    ".mp3": { type: "Audio", contentType: "audio/mpeg" },
+    ".ogg": { type: "Audio", contentType: "audio/ogg" },
+    ".wav": { type: "Audio", contentType: "audio/wav" },
+    ".flac": { type: "Audio", contentType: "audio/flac" },
+    ".fbx": { type: "Model", contentType: "model/fbx" },
+    ".gltf": { type: "Model", contentType: "model/gltf+json" },
+    ".glb": { type: "Model", contentType: "model/gltf-binary" },
+    ".rbxm": { type: "Model", contentType: "model/x-rbxm" },
+    ".rbxmx": { type: "Model", contentType: "model/x-rbxmx" },
+    ".mp4": { type: "Video", contentType: "video/mp4" },
+    ".mov": { type: "Video", contentType: "video/quicktime" },
+};
+/** Roblox's documented ceiling for a model upload. */
+export const MAX_MODEL_BYTES = 20 * 1024 * 1024;
+/** And for a video (also at most 5 minutes and 4096x2160; uploading needs an ID-verified account aged 13 or more). */
+export const MAX_VIDEO_BYTES = 3.75 * 1024 * 1024 * 1024;
+/** Walks the assets folder. Hidden files are ignored, unsupported ones are reported. */
+export function scanAssets(projectRoot, folder) {
+    const base = join(projectRoot, folder);
+    const files = [];
+    const skipped = [];
+    const walk = (directory, prefix) => {
+        for (const entry of readdirSync(directory, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name))) {
+            if (entry.name.startsWith("."))
+                continue;
+            const relative = prefix === "" ? entry.name : `${prefix}/${entry.name}`;
+            const absolute = join(directory, entry.name);
+            if (entry.isDirectory()) {
+                walk(absolute, relative);
+                continue;
+            }
+            const kind = KINDS[extname(entry.name).toLowerCase()];
+            if (kind === undefined) {
+                skipped.push({ relative, reason: `${extname(entry.name) || "no extension"} is not a format Rowork uploads yet` });
+                continue;
+            }
+            const content = readFileSync(absolute);
+            files.push({
+                relative,
+                absolute,
+                type: kind.type,
+                contentType: kind.contentType,
+                sha256: createHash("sha256").update(content).digest("hex"),
+                size: content.length,
+            });
+        }
+    };
+    if (existsSync(base))
+        walk(base, "");
+    return { files, skipped };
+}
+export function readLock(projectRoot) {
+    try {
+        const parsed = JSON.parse(readFileSync(join(projectRoot, LOCK_FILE), "utf8"));
+        return { version: 1, assets: parsed.assets ?? {} };
+    }
+    catch {
+        return { version: 1, assets: {} };
+    }
+}
+/** Sorted keys, so the file only changes when an asset does and diffs stay readable. */
+export function writeLock(projectRoot, lock) {
+    const assets = Object.fromEntries(Object.entries(lock.assets).sort(([a], [b]) => a.localeCompare(b)));
+    writeFileSync(join(projectRoot, LOCK_FILE), `${JSON.stringify({ version: 1, assets }, undefined, 2)}\n`, "utf8");
+}
+/**
+ * What a run has to do. A file is uploaded again only when its content changed: the
+ * hash in the lock file is what makes `rowork assets` safe to run as often as you like.
+ * (An image cannot be updated in place, so a changed image becomes a new asset.)
+ */
+export function planAssets(files, lock) {
+    return files.map((file) => {
+        const known = lock.assets[file.relative];
+        // A different type means it was uploaded the old way (images used to go up as Decals,
+        // whose id does not reliably load in an ImageLabel): send it again as what it is now.
+        if (known === undefined || known.sha256 !== file.sha256 || known.type !== file.type)
+            return { file, action: "upload" };
+        if (known.assetId === undefined && known.operation !== undefined)
+            return { file, action: "resume" };
+        return { file, action: known.assetId === undefined ? "upload" : "unchanged" };
+    });
+}
+/**
+ * A moderation state that lets the asset be used. Unknown states are not assumed safe.
+ * Roblox writes it as `Approved` (seen with a real upload), its documentation as
+ * `MODERATION_STATE_APPROVED`: both are accepted, in any letter case.
+ */
+export function isApproved(moderation) {
+    return moderation === undefined || /^(?:MODERATION_STATE_)?APPROVED$/i.test(moderation);
+}
+function usable(entry) {
+    return entry.assetId !== undefined && isApproved(entry.moderation);
+}
+function keyFor(segment) {
+    return toFieldName(segment.replace(/\.[^.]+$/, "")) || segment;
+}
+/**
+ * The TypeScript file that lets the code name an asset instead of a number.
+ *
+ * Only files that still exist and are approved are listed, so the code never points
+ * at something that was deleted or refused. It is laid out the way Prettier writes it,
+ * because generated code has to pass the project's formatter.
+ */
+export function renderAssetsModule(lock, present) {
+    const tree = {};
+    const waiting = [];
+    const owner = new Map();
+    for (const [relative, entry] of Object.entries(lock.assets)) {
+        if (!present.has(relative))
+            continue;
+        if (!usable(entry)) {
+            waiting.push(`${relative} (${entry.moderation ?? "no asset id yet"})`);
+            continue;
+        }
+        const segments = relative.split("/");
+        let node = tree;
+        segments.forEach((segment, index) => {
+            const isFile = index === segments.length - 1;
+            const key = keyFor(segment);
+            const path = segments.slice(0, index + 1).join("/");
+            const previous = owner.get(`${segments.slice(0, index).map(keyFor).join(".")}.${key}`);
+            if (previous !== undefined && previous !== path) {
+                throw new RoworkError(`\`${previous}\` and \`${path}\` would both be called \`${key}\`.`, {
+                    hint: "Rename one of them so each asset has its own name.",
+                });
+            }
+            owner.set(`${segments.slice(0, index).map(keyFor).join(".")}.${key}`, path);
+            if (isFile)
+                node[key] = `rbxassetid://${entry.assetId}`;
+            else
+                node = (node[key] = node[key] ?? {});
+        });
+    }
+    const quote = (name) => (/^[A-Za-z_$][\w$]*$/.test(name) ? name : JSON.stringify(name));
+    const lines = [];
+    const write = (node, depth) => {
+        for (const key of Object.keys(node).sort()) {
+            const value = node[key];
+            const pad = "\t".repeat(depth);
+            if (typeof value === "string") {
+                lines.push(`${pad}${quote(key)}: ${JSON.stringify(value)},`);
+            }
+            else {
+                lines.push(`${pad}${quote(key)}: {`);
+                write(value, depth + 1);
+                lines.push(`${pad}},`);
+            }
+        }
+    };
+    write(tree, 1);
+    const body = lines.length === 0 ? "{}" : `{\n${lines.join("\n")}\n}`;
+    return {
+        source: [
+            "// Generated by `rowork assets`. Do not edit: this file is rewritten every time.",
+            "// Each name is a file in the assets folder; the value is what Roblox knows it as.",
+            `export const Assets = ${body} as const;`,
+            "",
+        ].join("\n"),
+        waiting,
+    };
+}
+/** Reads a `.env` file: `NAME=value`, optional quotes, `#` comments. */
+function readDotenv(projectRoot) {
+    let source;
+    try {
+        source = readFileSync(join(projectRoot, ".env"), "utf8");
+    }
+    catch {
+        return {};
+    }
+    const values = {};
+    for (const line of source.split(/\r?\n/)) {
+        const match = /^\s*(?:export\s+)?([A-Za-z_][A-Za-z0-9_]*)\s*=\s*(.*?)\s*$/.exec(line);
+        if (match === null || line.trim().startsWith("#"))
+            continue;
+        values[match[1]] = match[2].replace(/^(['"])(.*)\1$/, "$2");
+    }
+    return values;
+}
+/**
+ * Finds the Open Cloud API key: the environment first, then `.env`.
+ *
+ * A key that sits in `.env` is refused if git would commit that file. The history of
+ * a repository outlives any key rotation, and this one is going to be public.
+ */
+export function readApiKey(projectRoot) {
+    const fromEnvironment = process.env[KEY_NAME];
+    if (fromEnvironment !== undefined && fromEnvironment !== "")
+        return { key: fromEnvironment, source: "environment" };
+    const fromFile = readDotenv(projectRoot)[KEY_NAME];
+    if (fromFile === undefined || fromFile === "")
+        return undefined;
+    if (existsSync(join(projectRoot, ".git"))) {
+        const ignored = spawnSync("git", ["check-ignore", "-q", ".env"], { cwd: projectRoot });
+        if (ignored.status === 1) {
+            throw new RoworkError("`.env` holds your Roblox API key, but git does not ignore that file.", {
+                hint: "Add a line `.env` to your .gitignore first: a key that gets committed must be considered leaked.",
+            });
+        }
+    }
+    return { key: fromFile, source: ".env" };
+}
+/** A pasted key is one token: no spaces, no quotes, nothing that could break a `.env` line. */
+export function looksLikeApiKey(text) {
+    return /^[A-Za-z0-9+/=_-]{16,}$/.test(text);
+}
+/**
+ * Stores the key in `.env`, in that order: first make sure git ignores `.env`, and only
+ * then write the key. Other lines of the file are kept. The file is readable by its owner only.
+ */
+export function saveApiKey(projectRoot, key) {
+    const gitignore = join(projectRoot, ".gitignore");
+    const current = existsSync(gitignore) ? readFileSync(gitignore, "utf8") : "";
+    if (!current.split(/\r?\n/).some((line) => line.trim() === ".env")) {
+        const separator = current === "" || current.endsWith("\n") ? "" : "\n";
+        writeFileSync(gitignore, `${current}${separator}.env\n`, "utf8");
+    }
+    const file = join(projectRoot, ".env");
+    const lines = existsSync(file) ? readFileSync(file, "utf8").split(/\r?\n/) : [];
+    const entry = `${KEY_NAME}=${key}`;
+    const index = lines.findIndex((line) => new RegExp(`^\\s*(?:export\\s+)?${KEY_NAME}\\s*=`).test(line));
+    if (index >= 0) {
+        lines[index] = entry;
+    }
+    else {
+        while (lines.length > 0 && lines[lines.length - 1] === "")
+            lines.pop();
+        lines.push(entry);
+    }
+    writeFileSync(file, `${lines.join("\n")}\n`, "utf8");
+    try {
+        chmodSync(file, 0o600);
+    }
+    catch {
+        // Not every file system has permissions (Windows): the .gitignore entry is what protects it there.
+    }
+}
+export function assetsFolder(config) {
+    return config.assets?.folder ?? DEFAULT_FOLDER;
+}
+/** Bytes as a short human string. */
+export function humanSize(bytes) {
+    if (bytes < 1024)
+        return `${bytes} B`;
+    if (bytes < 1024 * 1024)
+        return `${(bytes / 1024).toFixed(1)} KB`;
+    return `${(bytes / 1024 / 1024).toFixed(1)} MB`;
+}
+export function statSize(path) {
+    return statSync(path).size;
+}
+//# sourceMappingURL=assets.js.map

package/dist/core/background.d.ts

@@ -0,0 +1,47 @@
+/** Set in the background process, so it knows to clean up after itself. */
+export declare const DAEMON_ENV = "ROWORK_DEV_DAEMON";
+export interface DevRecord {
+    pid: number;
+    startedAt: string;
+    port: number;
+    /** In a terminal of its own, or detached with `dev -d`. Older records have none. */
+    mode?: "foreground" | "background";
+}
+export interface DashboardRecord {
+    pid: number;
+    port: number;
+    /** The address WITH its secret token: this file is as private as the token itself. */
+    url: string;
+}
+export declare function runDirectory(projectRoot: string): string;
+export declare const logFile: (root: string) => string;
+export declare function isAlive(pid: number): boolean;
+export declare function readRecord(projectRoot: string): DevRecord | undefined;
+export declare function writeRecord(projectRoot: string, record: DevRecord): void;
+export declare function clearRecord(projectRoot: string): void;
+/** The background `rowork dev` of this project, if one is really running. */
+export declare function runningRecord(projectRoot: string): DevRecord | undefined;
+/** Last `lines` lines of the background log. */
+export declare function tailLog(projectRoot: string, lines: number): string[];
+/**
+ * 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 declare function spawnBackground(projectRoot: string, script: string, args: string[]): number;
+/** Stops the process and everything it started. Returns false if it had to be forced. */
+export declare function stopProcess(pid: number): Promise<boolean>;
+/**
+ * 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 declare function writeDashboardRecord(root: string, record: DashboardRecord): void;
+export declare function clearDashboardRecord(root: string): void;
+/** The dashboard of this project, if its process is really alive. A stale record is removed. */
+export declare function runningDashboard(root: string): DashboardRecord | undefined;
+//# sourceMappingURL=background.d.ts.map