@hominis/fireforge 0.55.0 → 0.60.0

package/dist/src/commands/wire.js

@@ -1,350 +1,61 @@
 // SPDX-License-Identifier: EUPL-1.2
-import { join, relative } from 'node:path';
-import { Command } from 'commander';
-import { DEFAULT_BROWSER_SUBSCRIPT_DIR, wireSubscript, } from '../core/browser-wire.js';
-import { getProjectPaths, loadConfig } from '../core/config.js';
-import { furnaceConfigExists as checkFurnaceConfigExists, loadFurnaceConfig, } from '../core/furnace-config.js';
-import { consumeParserFallbackEvents } from '../core/parser-fallback.js';
-import { DEFAULT_DOM_TARGET, probeDomFragmentInsertionPoint } from '../core/wire-dom-fragment.js';
-import { coerceToCall, validateWireName as validateWireExpression } from '../core/wire-utils.js';
-import { InvalidArgumentError } from '../errors/base.js';
-import { toError } from '../utils/errors.js';
-import { pathExists } from '../utils/fs.js';
-import { info, intro, outro, success, warn } from '../utils/logger.js';
-import { pickDefined } from '../utils/options.js';
-import { isContainedRelativePath, isExplicitAbsolutePath, isPathInsideRoot, stripEnginePrefix, toRootRelativePath, } from '../utils/paths.js';
-import { normalizePathSlashes } from '../utils/paths.js';
-const BROWSER_BASE_DIR = 'browser/base';
-function printWireDryRun(engineDir, name, subscriptDir, domFilePath, domTargetPath, options) {
-    info('[dry-run] Would wire subscript:');
-    info(`  source: ${subscriptDir}/${name}.js`);
-    info(`  browser-main.js: loadSubScript("chrome://browser/content/${name}.js")`);
-    if (options.init) {
-        // Show the coerced form so the preview matches the emitted block.
-        // Echoing the raw input ("X.init") does not reflect that the real run
-        // writes `X.init();` to browser-init.js.
-        info(`  browser-init.js: ${coerceToCall(options.init)}`);
-    }
-    if (options.destroy) {
-        info(`  browser-init.js onUnload(): ${coerceToCall(options.destroy)}`);
-    }
-    if (domFilePath) {
-        const includePath = normalizePathSlashes(relative(join(engineDir, subscriptDir), join(engineDir, domFilePath)));
-        info(`  ${domTargetPath}: #include ${includePath}`);
-    }
-    const relPath = normalizePathSlashes(relative(join(engineDir, BROWSER_BASE_DIR), join(engineDir, subscriptDir)));
-    info(`  jar.mn: content/browser/${name}.js (${relPath}/${name}.js)`);
-    outro('Dry run complete');
-}
-/**
- * Resolves the chrome document the `#include` directive is inserted into.
- *
- * Preference order:
- *   1. `--target <path>` CLI flag (explicit caller intent)
- *   2. First entry of `furnace.json.tokenHostDocuments` (fork-configured
- *      chrome doc list, already consumed by the missing-token-link
- *      validator and the doctor check)
- *   3. `browser/base/content/browser.xhtml` (upstream default)
- *
- * Step 2 is silent: a missing or invalid furnace.json falls through to the
- * upstream default rather than surfacing a warning, because forks that don't
- * use furnace shouldn't have to configure anything.
- */
-async function resolveDomTargetPath(projectRoot, explicit) {
-    if (explicit !== undefined) {
-        return explicit;
-    }
-    if (await checkFurnaceConfigExists(projectRoot)) {
-        try {
-            const furnaceConfig = await loadFurnaceConfig(projectRoot);
-            const first = furnaceConfig.tokenHostDocuments?.[0];
-            if (first !== undefined && first.length > 0) {
-                return first;
-            }
-        }
-        catch {
-            // Fall through to the default. A broken furnace.json should not block
-            // the wire command. The doctor surfaces that issue separately.
-        }
-    }
-    return DEFAULT_DOM_TARGET;
-}
-/**
- * Validates a subscript name supplied on the command line. Subscripts are
- * resolved into filenames under the subscript directory and registered in
- * jar.mn by this name, so any path separator or `..` segment would let
- * the caller write outside the intended directory or corrupt the manifest.
- * Mirrors the validation already applied to setup's binaryName and furnace
- * custom component targetPath.
- */
-function validateWireName(name) {
-    if (!/^[a-zA-Z_][a-zA-Z0-9_-]*$/.test(name)) {
-        throw new InvalidArgumentError(`Subscript name "${name}" is invalid. ` +
-            'Names must start with a letter or underscore and contain only letters, digits, underscores, or hyphens. ' +
-            'Path separators and parent-directory segments are not permitted.', 'name');
-    }
-}
-/**
- * Asserts that the resolved chrome document both exists on disk and exposes
- * an insertion anchor (`#include browser-sets.inc` or `<html:body>`) that
- * `addDomFragment` can splice into. Fires in dry-run and real-run mode
- * alike, so the preview and execution agree on whether the target is
- * wireable before any disk mutations happen. Running it only on the real
- * branch lets the dry-run produce a plausible-looking plan the real run then
- * refuses with `Could not find insertion point in chrome document`.
- */
-async function assertDomTargetIsWireable(projectRoot, domFilePath, domTargetPath) {
-    const paths = getProjectPaths(projectRoot);
-    if (!(await pathExists(join(paths.engine, domTargetPath)))) {
-        throw new InvalidArgumentError(`Chrome document not found in engine: ${domTargetPath}\n` +
-            'Set "tokenHostDocuments" in furnace.json (first entry is used by wire) ' +
-            'or pass --target <path>.', 'target');
-    }
-    try {
-        await probeDomFragmentInsertionPoint(paths.engine, domFilePath, domTargetPath);
-    }
-    catch (probeError) {
-        throw new InvalidArgumentError(`${toError(probeError).message}\n` +
-            `The resolved chrome document ${domTargetPath} does not expose an insertion anchor ` +
-            'that `fireforge wire` recognises (`#include browser-sets.inc` or `<html:body>`). ' +
-            'Add one of those anchors to the chrome doc, or target a document that has them via ' +
-            '`--target <path>`.', 'target');
-    }
-}
-async function resolveWireSubscriptDir(projectRoot, options) {
-    let subscriptDir = DEFAULT_BROWSER_SUBSCRIPT_DIR;
-    try {
-        const config = await loadConfig(projectRoot);
-        if (config.wire?.subscriptDir) {
-            subscriptDir = config.wire.subscriptDir;
-        }
-    }
-    catch (error) {
-        warn(`Using default wire.subscriptDir because fireforge.json could not be loaded: ${toError(error).message}`);
-    }
-    if (options.subscriptDir) {
-        if (!isContainedRelativePath(options.subscriptDir)) {
-            throw new InvalidArgumentError(`Subscript directory must stay within engine/: ${options.subscriptDir}`, 'subscriptDir');
-        }
-        subscriptDir = options.subscriptDir;
-    }
-    return subscriptDir;
-}
-async function ensureSubscriptSourceExists(projectRoot, subscriptDir, name, dryRun) {
-    const paths = getProjectPaths(projectRoot);
-    const subscriptPath = join(paths.engine, subscriptDir, `${name}.js`);
-    if (!(await pathExists(subscriptPath))) {
-        if (dryRun) {
-            info(`Note: ${subscriptDir}/${name}.js does not exist yet — the real wire command will require it before writing. Create the file before re-running without --dry-run.`);
-        }
-        else {
-            throw new InvalidArgumentError(`Subscript file not found: ${subscriptDir}/${name}.js\n` +
-                'Create the file in engine/ before wiring.', 'name');
-        }
-    }
-}
-/**
- * Validates the `--dom` fragment argument and computes its engine-root-
- * relative path. Accepts absolute, repo-root-relative (`engine/...`), and
- * engine-relative inputs. Rejects missing files and paths escaping
- * engine/. Returns undefined when `--dom` was not supplied.
- */
-async function resolveDomFragmentPath(projectRoot, dom) {
-    // Validate the DOM fragment file exists and compute its path relative to
-    // the engine root. Accepts three shapes:
-    //  - Absolute paths (`/project/engine/browser/base/content/foo.inc.xhtml`)
-    //  - Repo-root-relative forms (`engine/browser/base/content/foo.inc.xhtml`)
-    //  - Engine-relative forms (`browser/base/content/foo.inc.xhtml`)
-    //
-    // Without the engine-prefix normalization, an `engine/…`-prefixed relative
-    // path from the repo root double-roots through
-    // `toRootRelativePath(engineDir, …)`: `resolve(engineDir, 'engine/…')`
-    // lands at `engineDir/engine/…`, still "inside" engineDir but named as a
-    // second-level `engine/…` entry, and the computed `#include` then reads
-    // `../../../engine/browser/base/content/foo.inc.xhtml`. Absolute inputs are
-    // already handled correctly by `toRootRelativePath`, so the prefix is only
-    // stripped when the input is relative.
-    if (!dom)
-        return undefined;
-    {
-        const paths = getProjectPaths(projectRoot);
-        const domCandidate = isExplicitAbsolutePath(dom) ? dom : stripEnginePrefix(dom);
-        // `pathExists` resolves relative paths against CWD, so an
-        // engine-relative `domCandidate` (e.g.
-        // `browser/base/content/foo.inc.xhtml`) would be probed inside the
-        // operator's shell directory rather than the engine root and fail "DOM
-        // fragment file not found" even when the file is sitting at
-        // engine/<path>. Mirror `register.ts`: probe the absolute path as-is,
-        // otherwise join with `paths.engine` first. The `isPathInsideRoot` /
-        // `toRootRelativePath` calls below keep operating on `domCandidate`
-        // because they internally resolve relative candidates against the engine
-        // root, matching the probe path built here.
-        const domProbePath = isExplicitAbsolutePath(domCandidate)
-            ? domCandidate
-            : join(paths.engine, domCandidate);
-        if (!(await pathExists(domProbePath))) {
-            throw new InvalidArgumentError(`DOM fragment file not found: ${dom}`, 'dom');
-        }
-        if (!isPathInsideRoot(paths.engine, domCandidate)) {
-            throw new InvalidArgumentError(`DOM fragment file must stay within engine/: ${dom}`, 'dom');
-        }
-        return toRootRelativePath(paths.engine, domCandidate);
-    }
-}
-/**
- * Builds the wireSubscript option bag from the command flags, omitting
- * every key whose flag is absent (exactOptionalPropertyTypes) and the
- * defaults the lower layer already assumes.
- */
-function buildWireSubscriptOptions(options, domFilePath, domTargetPath, subscriptDir) {
-    return {
-        ...(options.init !== undefined ? { init: options.init } : {}),
-        ...(options.destroy !== undefined ? { destroy: options.destroy } : {}),
-        ...(domFilePath !== undefined ? { domFilePath } : {}),
-        ...(domFilePath !== undefined && domTargetPath !== DEFAULT_DOM_TARGET ? { domTargetPath } : {}),
-        ...(options.after !== undefined ? { after: options.after } : {}),
-        ...(subscriptDir !== DEFAULT_BROWSER_SUBSCRIPT_DIR ? { subscriptDir } : {}),
-        dryRun: false,
-    };
-}
-/**
- * Surfaces any regex parser fallbacks the wiring run consumed, so the
- * operator knows which files were mutated by the regex path rather than
- * the AST path.
- */
-function reportParserFallbacks() {
-    const parserFallbacks = consumeParserFallbackEvents();
-    if (parserFallbacks.length > 0) {
-        const contexts = [...new Set(parserFallbacks.map((event) => event.context))];
-        info(`Legacy parser fallback was used for ${contexts.length} file${contexts.length === 1 ? '' : 's'}: ${contexts.join(', ')}`);
-    }
-}
-/**
- * Prints the per-mutation success/skip rows for a completed (non-dry-run)
- * wire invocation.
- */
-function reportWireResult(result, name, options, domFilePath, domTargetPath) {
-    if (result.subscriptAdded) {
-        success(`Added loadSubScript for ${name}.js to browser-main.js`);
-    }
-    else {
-        info(`${name}.js already registered in browser-main.js (skipped)`);
-    }
-    if (options.init) {
-        if (result.initAdded) {
-            success(`Added init expression to browser-init.js onLoad()`);
-        }
-        else {
-            info(`Init expression already present in browser-init.js (skipped)`);
-        }
-    }
-    if (options.destroy) {
-        if (result.destroyAdded) {
-            success(`Added destroy expression to browser-init.js onUnload()`);
-        }
-        else {
-            info(`Destroy expression already present in browser-init.js (skipped)`);
-        }
-    }
-    if (domFilePath) {
-        if (result.domInserted) {
-            success(`Inserted #include directive into ${domTargetPath}`);
-        }
-        else {
-            info(`#include directive already present in ${domTargetPath} (skipped)`);
-        }
-    }
-    if (result.jarMnResult.skipped) {
-        info(`${name}.js already registered in jar.mn (skipped)`);
-    }
-    else {
-        success(`Registered ${name}.js in ${result.jarMnResult.manifest}`);
-    }
-}
-/**
- * Wires a chrome subscript into the browser.
- *
- * @param projectRoot - Root directory of the project
- * @param name - Subscript name (without .js extension)
- * @param options - Command options
- */
-export async function wireCommand(projectRoot, name, options = {}) {
-    intro('Wire');
-    validateWireName(name);
-    if (options.after !== undefined) {
-        // --after references an existing init block by its subscript name, so
-        // it must follow the same naming rules as `name` itself. Without this
-        // check, a caller could sneak a path-traversal segment in through
-        // --after and have it forwarded unchanged to the lookup layer.
-        validateWireName(options.after);
-    }
-    // Validate init/destroy expressions before the dry-run/real fork so both
-    // paths enforce the same contract. Validating only inside
-    // `addInitToBrowserInit`/`addDestroyToBrowserInit` (the real-execution
-    // path) lets `--dry-run --init 'void 0'` succeed and render a plausible
-    // preview even though the real run rejects the same arguments.
-    if (options.init !== undefined) {
-        validateWireExpression(options.init, 'init expression');
-    }
-    if (options.destroy !== undefined) {
-        validateWireExpression(options.destroy, 'destroy expression');
-    }
-    consumeParserFallbackEvents();
-    const subscriptDir = await resolveWireSubscriptDir(projectRoot, options);
-    const domFilePath = await resolveDomFragmentPath(projectRoot, options.dom);
-    // Resolve the chrome document the `#include` directive will land in. Only
-    // consulted when `--dom` is supplied, but resolved here anyway so the
-    // dry-run plan can print the target accurately.
-    //
-    // `stripEnginePrefix` is applied so
-    // `--target engine/browser/base/browser.xhtml` and
-    // `--target browser/base/browser.xhtml` are treated identically, matching
-    // the `--dom` normalization above. Absolute `--target` paths stay absolute
-    // (the containment check downstream rejects them).
-    const normalizedTarget = options.target !== undefined && !isExplicitAbsolutePath(options.target)
-        ? stripEnginePrefix(options.target)
-        : options.target;
-    if (normalizedTarget !== undefined && !isContainedRelativePath(normalizedTarget)) {
-        throw new InvalidArgumentError(`Target chrome document must stay within engine/: ${options.target ?? ''}`, 'target');
-    }
-    const domTargetPath = await resolveDomTargetPath(projectRoot, normalizedTarget);
-    if (domFilePath) {
-        await assertDomTargetIsWireable(projectRoot, domFilePath, domTargetPath);
-    }
-    // Verify the subscript file exists in engine/, skipping for dry-run:
-    // preview is meant to show the mutation plan without requiring the
-    // subscript to already exist, matching the "plan before write" pattern
-    // setup scripts rely on.
-    //
-    // The check stays advisory rather than fatal in dry-run because
-    // "wire first, create file after" is a legitimate use of preview. But a
-    // dry-run over a typo would otherwise produce a plausible plan and the
-    // real command then refuse with `Subscript file not found`. The info line
-    // surfaces the mismatch in preview mode.
-    await ensureSubscriptSourceExists(projectRoot, subscriptDir, name, options.dryRun ?? false);
-    if (options.dryRun) {
-        printWireDryRun(getProjectPaths(projectRoot).engine, name, subscriptDir, domFilePath, domTargetPath, options);
-        return;
-    }
-    const result = await wireSubscript(projectRoot, name, buildWireSubscriptOptions(options, domFilePath, domTargetPath, subscriptDir));
-    reportParserFallbacks();
-    reportWireResult(result, name, options, domFilePath, domTargetPath);
-    outro('Wiring complete');
-}
-/** Registers the wire command on the CLI program. */
-export function registerWire(program, { getProjectRoot, withErrorHandling }) {
-    program
-        .command('wire <name>')
-        .description('Wire a chrome subscript into the browser')
-        .option('--init <expression>', 'Init expression for browser-init.js onLoad()')
-        .option('--destroy <expression>', 'Destroy expression for browser-init.js onUnload()')
-        .option('--dom <file>', 'XHTML fragment file to insert into the chrome document')
-        .option('--dry-run', 'Show what would be changed without writing')
-        .option('--after <name>', 'Insert init block after the block for this name')
-        .option('--subscript-dir <dir>', 'Subscript directory relative to engine/ (default: browser/base/content)')
-        .option('--target <path>', 'Chrome document to insert --dom into, relative to engine/ ' +
-        '(default: first entry of furnace.json tokenHostDocuments, else browser/base/content/browser.xhtml)')
-        .action(withErrorHandling(async (name, options) => {
-        await wireCommand(getProjectRoot(), name, pickDefined(options));
-    }));
-}
+import { arg, defineCommand, lockOptions, lockWaitMs, opt } from '../cli/command.js';
+import { markerComment } from '../config/index.js';
+import { editTracked, enginePathOf, trackedFiles } from '../mode/index.js';
+import { loadProject } from '../project/index.js';
+import { applyEdits, planWire } from '../register/index.js';
+export const wire = defineCommand({
+    name: 'wire',
+    summary: 'Wire a chrome subscript into the browser',
+    description: 'Loads <name>.js from browser-main.js, optionally calls init from onLoad and destroy from ' +
+        'onUnload in browser-init.js, optionally #includes a DOM fragment into the top-level chrome ' +
+        'document, and registers the script in browser/base/jar.mn. Every edit is planned before ' +
+        'any is written. Where scripts live and the chrome document are the wire.subscriptDir and ' +
+        'wire.domTarget keys of fireforge.json.',
+    group: 'Authoring',
+    args: { name: arg.string('Subscript name, without .js') },
+    options: {
+        init: opt.string('Expression called from onLoad, such as Feature.init', {
+            valueName: 'expression',
+        }),
+        destroy: opt.string('Expression called from onUnload, such as Feature.destroy', {
+            valueName: 'expression',
+        }),
+        dom: opt.string('DOM fragment (.inc.xhtml) to #include into the chrome document', {
+            valueName: 'path',
+        }),
+        after: opt.string('Subscript whose init block the new init block follows', {
+            valueName: 'name',
+        }),
+        dryRun: opt.flag('Show the planned edits without writing'),
+        ...lockOptions,
+    },
+    json: true,
+    run: async (ctx, { name }, opts) => {
+        const project = await loadProject(ctx.cwd, ctx.env);
+        const { config } = project;
+        const files = await trackedFiles(project, { declare: true });
+        const plan = await planWire(files, {
+            name,
+            subscriptDir: config.wire.subscriptDir,
+            marker: `${markerComment(config)}:`,
+            requireSubscript: !opts.dryRun,
+            init: opts.init,
+            destroy: opts.destroy,
+            after: opts.after,
+            dom: opts.dom === undefined
+                ? undefined
+                : { file: enginePathOf(project, opts.dom), target: config.wire.domTarget },
+        });
+        if (!opts.dryRun) {
+            await editTracked(project, { label: `wiring ${name}`, command: 'wire', waitMs: lockWaitMs(opts.waitLock) }, (tx) => applyEdits(tx, files, plan.edits));
+        }
+        const verb = opts.dryRun ? 'Would change' : 'Changed';
+        for (const step of plan.steps) {
+            ctx.out.line(step.present
+                ? `Already in place: ${step.path}: ${step.change}`
+                : `${verb} ${step.path}: ${step.change}`);
+        }
+        ctx.out.json({ name, dryRun: opts.dryRun, steps: plan.steps.map((step) => ({ ...step })) });
+    },
+});

package/dist/src/commands/workspace.js

@@ -0,0 +1,117 @@
+// SPDX-License-Identifier: EUPL-1.2
+import { arg, defineCommand, lockOptions, opt } from '../cli/command.js';
+import { addWorkspace, removeWorkspace, repairWorkspace, } from '../engine/index.js';
+import { FireForgeError } from '../kernel/errors.js';
+import { listAllWorkspaces } from '../mode/index.js';
+import { hostPaths, loadProject } from '../project/index.js';
+/** The options of every command that works in a workspace. */
+export const workspaceOptions = {
+    workspace: opt.string('Source mode: use this pool workspace instead of the best free one ("fireforge workspace list" names them)', { valueName: 'name' }),
+    ...lockOptions,
+};
+/** The project the command was run in, or undefined outside one: the pool belongs to the host. */
+async function projectHere(ctx) {
+    try {
+        return await loadProject(ctx.cwd, ctx.env);
+    }
+    catch (error) {
+        if (error instanceof FireForgeError && error.code === 'project-not-found')
+            return undefined;
+        throw error;
+    }
+}
+function row(workspace) {
+    const state = workspace.holders.length > 0
+        ? `leased by PID ${workspace.holders.map((holder) => holder.pid).join(', ')}`
+        : 'free';
+    const last = workspace.lessee === undefined ? 'never leased' : `last used by ${workspace.lessee.root}`;
+    return `${workspace.name}  ${workspace.pin}  ${workspace.built ? 'built' : 'not built'}  ${state}  ${last}`;
+}
+const list = defineCommand({
+    name: 'list',
+    summary: 'List the workspaces of this host',
+    json: true,
+    run: async (ctx) => {
+        const { engine, pool } = await listAllWorkspaces(hostPaths(ctx.env), await projectHere(ctx));
+        if (engine !== undefined) {
+            const state = engine.holders.length > 0 ? `in use by PID ${engine.holders.join(', ')}` : 'free';
+            ctx.out.line(`engine  ${engine.path}  ${state}`);
+        }
+        for (const workspace of pool)
+            ctx.out.line(row(workspace));
+        if (engine === undefined && pool.length === 0)
+            ctx.out.line('The pool is empty.');
+        ctx.out.json({
+            engine: engine ?? null,
+            workspaces: pool.map((workspace) => ({
+                name: workspace.name,
+                path: workspace.dir,
+                pin: workspace.pin,
+                commit: workspace.commit,
+                built: workspace.built,
+                clonedFrom: workspace.clonedFrom ?? null,
+                lessee: workspace.lessee ?? null,
+                holders: workspace.holders.map((holder) => holder.pid),
+            })),
+        });
+    },
+});
+const add = defineCommand({
+    name: 'add',
+    summary: "Create a workspace on the project's Firefox",
+    description: 'Checks the pinned Firefox out of the pristine repository. With --from, clones the engine of ' +
+        'another workspace copy-on-write instead, with what is recorded about its content. Either way ' +
+        'the new workspace needs a full build: an object directory is tied to the path it was ' +
+        'configured at, so a build is never copied or moved to another workspace.',
+    args: { name: arg.string('Name of the new workspace') },
+    options: {
+        from: opt.string("Clone this workspace's engine, without its builds", { valueName: 'name' }),
+    },
+    json: true,
+    run: async (ctx, { name }, { from }) => {
+        const project = await loadProject(ctx.cwd, ctx.env);
+        const workspace = await addWorkspace(project.host, name, { pin: project.config.firefox, from });
+        ctx.out.line(`Created workspace "${workspace.name}" at ${workspace.dir}`);
+        ctx.out.line(from === undefined
+            ? 'It needs a full build before it is useful.'
+            : `The builds of "${from}" were not copied (a build cannot be moved to another path): it needs a full build.`);
+        ctx.out.json({
+            name: workspace.name,
+            path: workspace.dir,
+            pin: workspace.pin,
+            built: workspace.built,
+        });
+    },
+});
+const remove = defineCommand({
+    name: 'remove',
+    summary: 'Delete a workspace and its build',
+    args: { name: arg.string('The workspace') },
+    json: true,
+    run: async (ctx, { name }) => {
+        await removeWorkspace(hostPaths(ctx.env), name);
+        ctx.out.line(`Removed workspace "${name}"`);
+        ctx.out.json({ name, removed: true });
+    },
+});
+const repair = defineCommand({
+    name: 'repair',
+    summary: "Reset a workspace's engine to the pristine Firefox, keeping its build",
+    description: 'Restores every file of the engine, removes what was added, and forgets what was recorded ' +
+        "about the engine's content (materialized files, deployed components, test runs), so the " +
+        "next command that leases the workspace applies the project's source afresh. The object " +
+        'directory and the release build stay.',
+    args: { name: arg.string('The workspace') },
+    json: true,
+    run: async (ctx, { name }) => {
+        await repairWorkspace(hostPaths(ctx.env), name);
+        ctx.out.line(`Reset workspace "${name}" to the pristine source`);
+        ctx.out.json({ name, repaired: true });
+    },
+});
+export const workspace = defineCommand({
+    name: 'workspace',
+    summary: 'Manage the host pool of engine workspaces',
+    group: 'Engine',
+    subcommands: [list, add, remove, repair],
+});