@firenet-designs/fnd-cli 2.4.0 → 2.7.0

package/dist/lib/webflow.d.ts

@@ -0,0 +1,80 @@
+/**
+ * Minimal Webflow Data API v2 client — only what `fnd alt-text` needs.
+ *
+ * Two kinds of images live in a Webflow site and they are updated through
+ * completely different endpoints:
+ *
+ *   site asset library   /v2/sites/:site/assets        -> PATCH /v2/assets/:id  {altText}
+ *   CMS image fields     /v2/collections/:id/items     -> PATCH /v2/collections/:id/items  {items[].fieldData}
+ *
+ * Read endpoints are async generators that paginate internally, so callers just
+ * `for await` and never deal with offsets.
+ *
+ * SECURITY: the API key is a site-wide bearer token. It is only ever put in an
+ * Authorization header — never logged, never included in an error message (we
+ * report the URL pathname, not the full URL, in case a token ever ends up in a
+ * query string).
+ */
+export interface WebflowAuth {
+    apiKey: string;
+    siteId: string;
+}
+export interface Asset {
+    altText: null | string;
+    contentType: string;
+    displayName: string;
+    hostedUrl: string;
+    id: string;
+    originalFileName: string;
+    siteId: string;
+}
+export interface Collection {
+    displayName: string;
+    id: string;
+    singularName: string;
+    slug: string;
+}
+/** A single CMS image value. `alt` is null until someone (or this command) fills it in. */
+export interface ImageField {
+    alt: null | string;
+    fileId: string;
+    url: string;
+}
+export interface CollectionItem {
+    fieldData: Record<string, ImageField | ImageField[] | unknown>;
+    id: string;
+    isArchived: boolean;
+    isDraft: boolean;
+}
+/**
+ * Every asset in the site's asset library, oldest page first.
+ *
+ * @yields each asset, one page of 100 at a time.
+ */
+export declare function getAssets(auth: WebflowAuth, limit?: number): AsyncGenerator<Asset>;
+/** Every CMS collection on the site. Not paginated by Webflow. */
+export declare const getCollections: (auth: WebflowAuth) => Promise<Collection[]>;
+/**
+ * Every item in a collection.
+ *
+ * Reads from STAGING by default (the `/live` endpoint is opt-in) to match
+ * `updateCollectionItem`, which also writes to staging — so a run's changes
+ * need publishing in Webflow before they show on the live site.
+ *
+ * @yields each item in the collection.
+ */
+export declare function getCollectionItems(auth: WebflowAuth, collectionId: string, { limit, staging }?: {
+    limit?: number;
+    staging?: boolean;
+}): AsyncGenerator<CollectionItem>;
+/** Set the alt text on a site asset. */
+export declare const updateAssetAltText: (auth: WebflowAuth, assetId: string, altText: string) => Promise<void>;
+/** Patch one item's fieldData. Only the fields present in `fieldData` are touched. */
+export declare const updateCollectionItem: (auth: WebflowAuth, collectionId: string, itemId: string, fieldData: Record<string, unknown>) => Promise<void>;
+/**
+ * Webflow hands back untyped `fieldData`, so image fields are duck-typed: a
+ * single image is an object with a `url`, a multi-image field is an array of
+ * those (an empty array counts — it is still an image field, just empty).
+ */
+export declare const isImageField: (value: unknown) => value is ImageField;
+export declare const isImagesField: (value: unknown) => value is ImageField[];

package/dist/lib/webflow.js

@@ -0,0 +1,122 @@
+/**
+ * Minimal Webflow Data API v2 client — only what `fnd alt-text` needs.
+ *
+ * Two kinds of images live in a Webflow site and they are updated through
+ * completely different endpoints:
+ *
+ *   site asset library   /v2/sites/:site/assets        -> PATCH /v2/assets/:id  {altText}
+ *   CMS image fields     /v2/collections/:id/items     -> PATCH /v2/collections/:id/items  {items[].fieldData}
+ *
+ * Read endpoints are async generators that paginate internally, so callers just
+ * `for await` and never deal with offsets.
+ *
+ * SECURITY: the API key is a site-wide bearer token. It is only ever put in an
+ * Authorization header — never logged, never included in an error message (we
+ * report the URL pathname, not the full URL, in case a token ever ends up in a
+ * query string).
+ */
+const API = 'https://api.webflow.com/v2';
+/** How many times a 429 is retried before the request is allowed to fail. */
+const RATE_LIMIT_RETRIES = 3;
+/** Fallback wait when Webflow rate-limits us without a Retry-After header. */
+const RATE_LIMIT_FALLBACK_MS = 15_000;
+const sleep = (ms) => new Promise((resolve) => {
+    setTimeout(resolve, ms);
+});
+/**
+ * One request against the Webflow API, with a bounded retry on 429.
+ *
+ * A full site run is hundreds of sequential requests spread over however long
+ * the vision model takes, so hitting the per-minute cap is a matter of site
+ * size, not of anything the caller did wrong — dying on it would throw away all
+ * the work done so far.
+ */
+const request = async (auth, url, init = {}) => {
+    const { pathname } = new URL(url);
+    const method = init.method ?? 'GET';
+    for (let attempt = 0;; attempt++) {
+        // eslint-disable-next-line no-await-in-loop
+        const resp = await fetch(url, {
+            ...init,
+            headers: { Authorization: `Bearer ${auth.apiKey}`, ...init.headers },
+        });
+        // eslint-disable-next-line no-await-in-loop
+        if (resp.ok)
+            return (await resp.json());
+        if (resp.status === 429 && attempt < RATE_LIMIT_RETRIES) {
+            const retryAfter = Number(resp.headers.get('retry-after'));
+            // eslint-disable-next-line no-await-in-loop
+            await sleep(Number.isFinite(retryAfter) && retryAfter > 0 ? retryAfter * 1000 : RATE_LIMIT_FALLBACK_MS);
+            continue;
+        }
+        // eslint-disable-next-line no-await-in-loop
+        const body = await resp.text().catch(() => '');
+        throw new Error(`Webflow ${method} ${pathname} failed (${resp.status} ${resp.statusText})${body ? `: ${body.slice(0, 300)}` : ''}`);
+    }
+};
+/**
+ * Every asset in the site's asset library, oldest page first.
+ *
+ * @yields each asset, one page of 100 at a time.
+ */
+export async function* getAssets(auth, limit = 100) {
+    for (let page = 0;; page++) {
+        const url = new URL(`${API}/sites/${auth.siteId}/assets`);
+        url.searchParams.set('offset', `${page * limit}`);
+        url.searchParams.set('limit', `${limit}`);
+        // eslint-disable-next-line no-await-in-loop
+        const data = await request(auth, url);
+        yield* data.assets;
+        if (page + 1 >= Math.ceil(data.pagination.total / data.pagination.limit))
+            return;
+    }
+}
+/** Every CMS collection on the site. Not paginated by Webflow. */
+export const getCollections = async (auth) => {
+    const data = await request(auth, `${API}/sites/${auth.siteId}/collections`);
+    return data.collections;
+};
+/**
+ * Every item in a collection.
+ *
+ * Reads from STAGING by default (the `/live` endpoint is opt-in) to match
+ * `updateCollectionItem`, which also writes to staging — so a run's changes
+ * need publishing in Webflow before they show on the live site.
+ *
+ * @yields each item in the collection.
+ */
+export async function* getCollectionItems(auth, collectionId, { limit = 100, staging = true } = {}) {
+    for (let page = 0;; page++) {
+        const url = new URL(`${API}/collections/${collectionId}/items${staging ? '' : '/live'}`);
+        url.searchParams.set('offset', `${page * limit}`);
+        url.searchParams.set('limit', `${limit}`);
+        // eslint-disable-next-line no-await-in-loop
+        const data = await request(auth, url);
+        yield* data.items;
+        if (page + 1 >= Math.ceil(data.pagination.total / data.pagination.limit))
+            return;
+    }
+}
+/** Set the alt text on a site asset. */
+export const updateAssetAltText = async (auth, assetId, altText) => {
+    await request(auth, `${API}/assets/${assetId}`, {
+        body: JSON.stringify({ altText }),
+        headers: { 'Content-Type': 'application/json' },
+        method: 'PATCH',
+    });
+};
+/** Patch one item's fieldData. Only the fields present in `fieldData` are touched. */
+export const updateCollectionItem = async (auth, collectionId, itemId, fieldData) => {
+    await request(auth, `${API}/collections/${collectionId}/items`, {
+        body: JSON.stringify({ items: [{ fieldData, id: itemId }] }),
+        headers: { 'Content-Type': 'application/json' },
+        method: 'PATCH',
+    });
+};
+/**
+ * Webflow hands back untyped `fieldData`, so image fields are duck-typed: a
+ * single image is an object with a `url`, a multi-image field is an array of
+ * those (an empty array counts — it is still an image field, just empty).
+ */
+export const isImageField = (value) => typeof value === 'object' && value !== null && !Array.isArray(value) && 'url' in value;
+export const isImagesField = (value) => Array.isArray(value) && value.every((entry) => isImageField(entry));

package/dist/lib/workspace.d.ts

@@ -1,4 +1,3 @@
-import type { RpcConfig } from './rpc.js';
 /**
  * Mutagen-backed workspace helpers.
  *
@@ -23,9 +22,10 @@ import type { RpcConfig } from './rpc.js';
  * Mutagen auto-deploys its agent to the remote over that same SSH connection;
  * nothing to install on the remote by hand.
  *
- * The one reverse tunnel that remains is optional and unrelated to files: with
+ * The reverse tunnels that remain are optional and unrelated to files: with
  * --devtools we open `ssh -R` so the remote's chrome-devtools MCP can reach the
- * caller's LOCAL browser.
+ * caller's LOCAL browser, and with --with-tool we open one so the remote's
+ * fnd-tools MCP can reach the tools server running on the caller.
  */
 export interface SshTarget {
     host: string;
@@ -40,6 +40,17 @@ export interface PortPair {
 }
 /** For --devtools: `local` is the browser's remote-debugging port on the caller's machine. */
 export type DevtoolsPorts = PortPair;
+/**
+ * The workspace tools MCP (--with-tool): the reverse-tunnel port pair for the
+ * loopback MCP server started on the caller, plus the raw `--with-tool` values
+ * for the plan display. Undefined when no tool was requested.
+ */
+export interface ToolsMcp {
+    /** The `--with-tool` values selected, verbatim, for the plan summary. */
+    names: string[];
+    /** `local` = the caller's MCP server port; `remote` = the port opened on the workspace host. */
+    port: PortPair;
+}
 /**
  * Which side wins when the same path changed on both ends since the last sync.
  * `remote` = this server (the box where the workspace shell runs); `local` = the
@@ -61,12 +72,12 @@ export interface WorkspaceContext {
     localUser: string;
     /** Where the mirror lives on the REMOTE, e.g. /home/fnd/<localUser>/<localDirName>. */
     remoteDir: string;
-    /** Local-command RPC server + tunnel, when --rpc was passed; undefined otherwise. */
-    rpc?: RpcConfig;
     /** Which endpoint wins conflicts (the Mutagen alpha in two-way-resolved); undefined flags conflicts instead. */
     source?: SyncSource;
     /** Unique Mutagen session name for this workspace. */
     syncName: string;
+    /** Tools MCP server + tunnel, when --with-tool was passed; undefined otherwise. */
+    tools?: ToolsMcp;
 }
 export declare const DEFAULT_MOUNT_BASE = "/home/fnd";
 /** Parse a `user@host` string, throwing a friendly error otherwise. */
@@ -91,8 +102,8 @@ export declare const buildContext: (opts: {
     devtools?: DevtoolsPorts;
     ignoreVcs?: boolean;
     remoteBase: string;
-    rpc?: RpcConfig;
     source?: SyncSource;
+    tools?: ToolsMcp;
 }) => WorkspaceContext;
 /**
  * Translate one .gitignore line into Mutagen ignore patterns. `base` is the
@@ -136,10 +147,18 @@ export interface RemoteCleanupOptions {
     deleteRemoteDir?: boolean;
     /** Strip this project's chrome-devtools MCP entry — only when the workspace registered one (--devtools). */
     removeDevtoolsMcp?: boolean;
-    /** Strip this project's local-shell MCP entry — only when the workspace registered one (--rpc). */
-    removeRpcMcp?: boolean;
+    /** Strip this project's fnd-tools MCP entry — only when the workspace registered one (--with-tool). */
+    removeToolsMcp?: boolean;
 }
-/** Run the remote-side teardown over a fresh ssh connection. */
+/**
+ * Run the remote-side teardown over a fresh ssh connection. Forces a remote PTY
+ * with `-tt`: the MCP-remove step runs under an *interactive* login shell
+ * (`$SHELL -lic`, so `claude2` aliases in rc files resolve — see
+ * `claudeMcpRemoveScript`), and an interactive bash without a PTY prints
+ * "cannot set terminal process group / no job control in this shell". `-tt`
+ * forces allocation even when this cleanup runs without a local TTY, mirroring
+ * the `-t` the interactive session ssh uses.
+ */
 export declare const runRemoteCleanup: (target: string, remoteDir: string, opts?: RemoteCleanupOptions) => Promise<number>;
 /**
  * The remote-side teardown script. Runs from inside the workspace dir so the
@@ -161,7 +180,7 @@ export declare const hasMutagen: () => boolean;
  * winner. When a `source` is given, it becomes the Mutagen alpha endpoint and
  * the mode switches to two-way-resolved (alpha always wins conflicts), so
  * `--source remote` puts the server first and `--source local` puts this
- * machine first. Labels let `workspace cleanup` find and terminate orphans.
+ * machine first. Labels let `workspace --cleanup` find and terminate orphans.
  * `ctx.ignores` (from --ignore-vcs) excludes gitignored paths from the sync so
  * each side keeps its own build artifacts and platform-specific binaries.
  */

package/dist/lib/workspace.js

@@ -60,9 +60,9 @@ export const buildContext = (opts) => {
         localDirName,
         localUser,
         remoteDir,
-        rpc: opts.rpc,
         source: opts.source,
         syncName: buildSyncName(localDirName),
+        tools: opts.tools,
     };
 };
 /**
@@ -155,8 +155,31 @@ export const collectVcsIgnores = (rootDir) => {
 export const shQuote = (value) => `'${value.replaceAll("'", `'\\''`)}'`;
 /** MCP server name registered for the workspace's chrome-devtools tunnel. */
 const DEVTOOLS_MCP_NAME = 'chrome-devtools';
-/** MCP server name registered for the --rpc local-command tunnel. */
-const RPC_MCP_NAME = 'local-shell';
+/** MCP server name registered for the --with-tool tools tunnel. */
+const TOOLS_MCP_NAME = 'fnd-tools';
+/**
+ * The `claude` CLIs an MCP entry is registered with / removed from. `claude2` is
+ * an overflow instance some remotes run alongside `claude`; both need the same
+ * project-local MCP config so whichever the user opens sees the workspace tools.
+ * Each is guarded by its own `command -v` — a remote without a given CLI just
+ * skips it. Keep add and remove over the same list so cleanup is complete.
+ *
+ * These are emitted as LITERAL command words, never `for cli in …; do "$cli" …`.
+ * On some remotes `claude2` is a shell *alias* (defined in ~/.bashrc / ~/.zshrc),
+ * and aliases are only expanded when the command word is a literal read by the
+ * parser — an alias never expands from a variable like `"$cli"`. Alias support is
+ * also why the add/remove blocks run under an *interactive* login shell (see the
+ * `-lic` note below): rc files, where the alias lives, are sourced only for
+ * interactive shells.
+ */
+const CLAUDE_CLIS = ['claude', 'claude2'];
+/**
+ * Emit a guarded per-CLI block for each entry in {@link CLAUDE_CLIS}. `cli` is
+ * interpolated literally (not via a variable) so a shell-alias `claude2` still
+ * expands. `command -v` gates each one so a remote missing a CLI just skips it;
+ * `body(cli)` returns the lines to run inside the guard.
+ */
+const forEachClaudeCli = (body) => CLAUDE_CLIS.flatMap((cli) => [`if command -v ${cli} >/dev/null 2>&1; then`, ...body(cli).map((l) => `  ${l}`), 'fi']);
 /**
  * Bash lines (run on the REMOTE, from inside the workspace dir) that register the
  * chrome-devtools MCP with the `claude` CLI. Local scope keys off the current
@@ -164,41 +187,44 @@ const RPC_MCP_NAME = 'local-shell';
  * A prior entry is cleared first so a re-connect after a crashed session is
  * idempotent. Skips gracefully if the claude CLI is missing.
  *
- * The block runs inside a login shell (`$SHELL -lc`): the outer script arrives as
- * a non-login ssh command whose PATH lacks the node/nvm/volta/Homebrew dirs that
- * login profiles add, so a bare `command -v claude` misses an installed CLI. A
- * login shell reproduces the same PATH the interactive session below gets.
+ * The block runs inside an *interactive* login shell (`$SHELL -lic`). Login (`-l`)
+ * because the outer script arrives as a non-login ssh command whose PATH lacks the
+ * node/nvm/volta/Homebrew dirs that login profiles add, so a bare `command -v
+ * claude` would miss an installed CLI. Interactive (`-i`) because on some remotes
+ * `claude2` is a shell alias defined in ~/.bashrc / ~/.zshrc, and those rc files
+ * are sourced only for interactive shells — a plain `-lc` command shell never sees
+ * the alias. The `ssh -t` PTY is what lets `-i` run without job-control warnings.
  */
 const claudeDevtoolsAddScript = (remotePort, okMessage) => {
     const body = [
-        'if command -v claude >/dev/null 2>&1; then',
-        `  claude mcp remove ${DEVTOOLS_MCP_NAME} >/dev/null 2>&1 || true`,
-        `  claude mcp add ${DEVTOOLS_MCP_NAME} -- npx -y chrome-devtools-mcp@latest --browserUrl http://127.0.0.1:${remotePort}`,
-        `  echo ${shQuote(okMessage)}`,
-        'else',
-        '  echo "WARNING: claude CLI not found on the remote; skipped chrome-devtools MCP config." >&2',
-        'fi',
+        'configured=""',
+        ...forEachClaudeCli((cli) => [
+            `${cli} mcp remove ${DEVTOOLS_MCP_NAME} >/dev/null 2>&1 || true`,
+            `${cli} mcp add ${DEVTOOLS_MCP_NAME} -- npx -y chrome-devtools-mcp@latest --browserUrl http://127.0.0.1:${remotePort}`,
+            'configured=1',
+        ]),
+        `if [ -n "$configured" ]; then echo ${shQuote(okMessage)}; else echo "WARNING: claude CLI not found on the remote; skipped chrome-devtools MCP config." >&2; fi`,
     ].join('\n');
-    return [`"\${SHELL:-bash}" -lc ${shQuote(body)}`];
+    return [`"\${SHELL:-bash}" -lic ${shQuote(body)}`];
 };
 /**
  * Bash lines (run on the REMOTE, from inside the workspace dir) that register the
- * --rpc local-shell MCP with the `claude` CLI as a Streamable HTTP server. The
+ * --with-tool fnd-tools MCP with the `claude` CLI as a Streamable HTTP server. The
  * URL points at the reverse-tunnelled port, which the workspace's `ssh -R`
- * forwards back to the RPC server on the calling machine. Same login-shell and
+ * forwards back to the tools server on the calling machine. Same login-shell and
  * idempotency reasoning as `claudeDevtoolsAddScript`.
  */
-const claudeRpcAddScript = (remotePort, okMessage) => {
+const claudeToolsAddScript = (remotePort, okMessage) => {
     const body = [
-        'if command -v claude >/dev/null 2>&1; then',
-        `  claude mcp remove ${RPC_MCP_NAME} >/dev/null 2>&1 || true`,
-        `  claude mcp add --transport http ${RPC_MCP_NAME} http://127.0.0.1:${remotePort}/mcp`,
-        `  echo ${shQuote(okMessage)}`,
-        'else',
-        '  echo "WARNING: claude CLI not found on the remote; skipped local-shell MCP config." >&2',
-        'fi',
+        'configured=""',
+        ...forEachClaudeCli((cli) => [
+            `${cli} mcp remove ${TOOLS_MCP_NAME} >/dev/null 2>&1 || true`,
+            `${cli} mcp add --transport http ${TOOLS_MCP_NAME} http://127.0.0.1:${remotePort}/mcp`,
+            'configured=1',
+        ]),
+        `if [ -n "$configured" ]; then echo ${shQuote(okMessage)}; else echo "WARNING: claude CLI not found on the remote; skipped fnd-tools MCP config." >&2; fi`,
     ].join('\n');
-    return [`"\${SHELL:-bash}" -lc ${shQuote(body)}`];
+    return [`"\${SHELL:-bash}" -lic ${shQuote(body)}`];
 };
 /**
  * Bash lines (run on the REMOTE, from inside the workspace dir) that remove an
@@ -208,12 +234,13 @@ const claudeRpcAddScript = (remotePort, okMessage) => {
  * `claudeDevtoolsAddScript`.
  */
 const claudeMcpRemoveScript = (name) => {
-    const body = [
-        'if command -v claude >/dev/null 2>&1; then',
-        `  claude mcp remove ${name}`,
-        'fi'
-    ].join('\n');
-    return [`"\${SHELL:-bash}" -lc ${shQuote(body)}`];
+    const body = forEachClaudeCli((cli) => [
+        // Tolerate failure: if the entry was never registered (or already gone) the
+        // remove exits non-zero — that's success for us, so never let it abort the
+        // rest of the teardown (dir deletion, the other CLI, …).
+        `${cli} mcp remove ${name} >/dev/null 2>&1 || true`,
+    ]).join('\n');
+    return [`"\${SHELL:-bash}" -lic ${shQuote(body)}`];
 };
 /**
  * The bash script the remote runs for the interactive session. Mutagen already
@@ -225,8 +252,8 @@ export const buildRemoteScript = (ctx) => {
     const devtoolsSetup = ctx.devtools
         ? claudeDevtoolsAddScript(ctx.devtools.remote, `Configured chrome-devtools MCP for this workspace (browser via 127.0.0.1:${ctx.devtools.remote}).`)
         : [];
-    const rpcSetup = ctx.rpc
-        ? claudeRpcAddScript(ctx.rpc.ports.remote, `Configured local-shell MCP for this workspace (runs ${ctx.rpc.shell} commands on the calling machine via 127.0.0.1:${ctx.rpc.ports.remote}).`)
+    const toolsSetup = ctx.tools
+        ? claudeToolsAddScript(ctx.tools.port.remote, `Configured fnd-tools MCP for this workspace (${ctx.tools.names.join(', ')} on the calling machine via 127.0.0.1:${ctx.tools.port.remote}).`)
         : [];
     return [
         'set -u',
@@ -236,15 +263,23 @@ export const buildRemoteScript = (ctx) => {
         'cd "$DIR" || { echo "ERROR: could not enter $DIR" >&2; exit 1; }',
         // Register the MCPs from inside $DIR: `claude mcp add` local scope keys off cwd.
         ...devtoolsSetup,
-        ...rpcSetup,
+        ...toolsSetup,
         'echo "Workspace ready at $DIR — files sync in the background (exit to stop syncing)."',
         // eslint-disable-next-line no-template-curly-in-string -- shell parameter expansion, not a JS template
         '"${SHELL:-bash}" -l',
     ].join('\n');
 };
-/** Run the remote-side teardown over a fresh ssh connection. */
+/**
+ * Run the remote-side teardown over a fresh ssh connection. Forces a remote PTY
+ * with `-tt`: the MCP-remove step runs under an *interactive* login shell
+ * (`$SHELL -lic`, so `claude2` aliases in rc files resolve — see
+ * `claudeMcpRemoveScript`), and an interactive bash without a PTY prints
+ * "cannot set terminal process group / no job control in this shell". `-tt`
+ * forces allocation even when this cleanup runs without a local TTY, mirroring
+ * the `-t` the interactive session ssh uses.
+ */
 export const runRemoteCleanup = (target, remoteDir, opts = {}) => new Promise((resolve, reject) => {
-    const child = spawn('ssh', [target, buildCleanupScript(remoteDir, opts)], { stdio: 'inherit' });
+    const child = spawn('ssh', ['-tt', target, buildCleanupScript(remoteDir, opts)], { stdio: 'inherit' });
     child.once('error', reject);
     child.once('close', (code) => resolve(code ?? 0));
 });
@@ -261,7 +296,7 @@ export const buildCleanupScript = (remoteDir, opts = {}) => [
     `DIR=${shQuote(remoteDir)}`,
     'cd "$DIR" 2>/dev/null || { echo "Nothing to clean up: $DIR is gone." >&2; exit 0; }',
     ...(opts.removeDevtoolsMcp ? claudeMcpRemoveScript(DEVTOOLS_MCP_NAME) : []),
-    ...(opts.removeRpcMcp ? claudeMcpRemoveScript(RPC_MCP_NAME) : []),
+    ...(opts.removeToolsMcp ? claudeMcpRemoveScript(TOOLS_MCP_NAME) : []),
     // Remove the workspace dir last: cd out first so we don't rm the cwd out from
     // under the shell, then delete it. Only when explicitly requested.
     ...(opts.deleteRemoteDir
@@ -287,7 +322,7 @@ export const hasMutagen = () => {
  * winner. When a `source` is given, it becomes the Mutagen alpha endpoint and
  * the mode switches to two-way-resolved (alpha always wins conflicts), so
  * `--source remote` puts the server first and `--source local` puts this
- * machine first. Labels let `workspace cleanup` find and terminate orphans.
+ * machine first. Labels let `workspace --cleanup` find and terminate orphans.
  * `ctx.ignores` (from --ignore-vcs) excludes gitignored paths from the sync so
  * each side keeps its own build artifacts and platform-specific binaries.
  */