@cloudhal/cli 0.0.0-stage → 0.1.1

package/dist/src/assets.js

@@ -0,0 +1,189 @@
+/**
+ * Where the CLI finds the things it ships: the built Studio, the starters and the official skills.
+ *
+ * - Published package: `dist/assets/{studio,starters,skills}` (copied by scripts/build-packages.ts).
+ * - Monorepo: `apps/studio/dist`, `starters/`, `skills/official`.
+ */
+import { access, readdir, readFile, realpath } from "node:fs/promises";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const here = path.dirname(fileURLToPath(import.meta.url));
+
+async function exists(p        )                   {
+  try {
+    await access(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/** The CLI package root, from either `src/` (monorepo) or `dist/src/` (published). */
+async function packageRoot()                  {
+  let dir = here;
+  for (let i = 0; i < 5; i++) {
+    const pkg = path.join(dir, "package.json");
+    if (await exists(pkg)) {
+      const name = (JSON.parse(await readFile(pkg, "utf8"))                     ).name;
+      if (name === "@cloudhal/cli") return dir;
+    }
+    dir = path.dirname(dir);
+  }
+  throw new Error("could not locate the @cloudhal/cli package root");
+}
+
+                                                         
+
+const MONOREPO                            = {
+  studio: "../../apps/studio/dist",
+  starters: "../../starters",
+  skills: "../../skills/official",
+};
+
+/**
+ * The directory for an asset kind, or undefined when neither layout has it. Running from source
+ * (the monorepo) prefers the live monorepo folders — a `dist/assets` left by an earlier
+ * `build:packages` would be stale; running from `dist/` (published) prefers the shipped copy.
+ */
+export async function assetDir(kind           )                              {
+  const root = await packageRoot();
+  const shipped = path.join(root, "dist/assets", kind);
+  const monorepo = path.resolve(root, MONOREPO[kind]);
+  const fromDist = here.split(path.sep).includes("dist");
+  for (const candidate of fromDist ? [shipped, monorepo] : [monorepo, shipped])
+    if (await exists(candidate)) return candidate;
+  return undefined;
+}
+
+/** Monorepo root (has pnpm-workspace.yaml) above the CLI package, when running from source. */
+export async function monorepoRoot()                              {
+  const root = path.resolve(await packageRoot(), "../..");
+  return (await exists(path.join(root, "pnpm-workspace.yaml"))) ? root : undefined;
+}
+
+/** Reads the `catalog:` block of a pnpm-workspace.yaml (flat `name: version` lines). */
+export function parseCatalog(yaml        )                         {
+  const out                         = {};
+  const block = yaml.split(/\r?\n/);
+  let inCatalog = false;
+  for (const line of block) {
+    if (/^catalog:\s*$/.test(line)) {
+      inCatalog = true;
+      continue;
+    }
+    if (inCatalog && /^\S/.test(line)) break;
+    const m = inCatalog ? line.match(/^\s+"?([^":]+)"?:\s*(\S+)\s*$/) : null;
+    if (m) out[m[1]          ] = m[2]          ;
+  }
+  return out;
+}
+
+/**
+ * Third-party peers of the `@cloudhal/*` packages that a project must install exactly once (one
+ * Astro for the renderer, the CLI and the project): pinned to the version the monorepo tests with.
+ */
+export const SHARED_PEERS = ["astro"]         ;
+
+                                     
+                                                                                                 
+                                    
+                                           
+                                  
+                                                                             
+                                     
+                                                                            
+                                
+ 
+
+                                     
+     
+                                                                                            
+                                                                                              
+     
+                             
+ 
+
+/** Replaces `workspace:` and `catalog:` specifiers so a project installs outside the monorepo. */
+export function materializeDependencies(
+  pkg                         ,
+  versions                    ,
+  options                     = {},
+)                          {
+  const out = { ...pkg };
+  for (const field of [
+    "dependencies",
+    "devDependencies",
+    "peerDependencies",
+    "optionalDependencies",
+  ]) {
+    const deps = out[field]                                      ;
+    if (!deps) continue;
+    const next                         = {};
+    for (const [name, spec] of Object.entries(deps)) {
+      if (spec.startsWith("workspace:")) next[name] = workspaceSpec(name, versions, options);
+      else if (spec.startsWith("catalog:")) {
+        const v = versions.installed?.[name] ?? versions.catalog[name];
+        if (!v) throw new Error(`${name} is not in the pnpm catalog`);
+        next[name] = v;
+      } else next[name] = spec;
+    }
+    out[field] = next;
+  }
+  return out;
+}
+
+function workspaceSpec(
+  name        ,
+  versions                    ,
+  options                    ,
+)         {
+  if (options.linkFrom !== undefined) {
+    const dir = versions.dirs?.[name];
+    if (!dir) throw new Error(`no package folder known for ${name}`);
+    return `link:${path.relative(options.linkFrom, dir).split(path.sep).join("/")}`;
+  }
+  const v = versions.workspace[name];
+  if (!v) throw new Error(`no published version known for ${name}`);
+  // Exact, like `pnpm publish` writes `workspace:*`: the packages are released together.
+  return v;
+}
+
+async function readJson(file        )                                               {
+  try {
+    return JSON.parse(await readFile(file, "utf8"))                           ;
+  } catch {
+    return undefined;
+  }
+}
+
+/** Versions as the monorepo defines them right now (for running the CLI from source). */
+export async function monorepoVersions(root        )                              {
+  const catalog = parseCatalog(await readFile(path.join(root, "pnpm-workspace.yaml"), "utf8"));
+  const workspace                         = {};
+  const dirs                         = {};
+  const installed                         = {};
+  for (const group of ["packages", "apps"]) {
+    let names           = [];
+    try {
+      names = await readdir(path.join(root, group));
+    } catch {
+      continue;
+    }
+    for (const n of names) {
+      const dir = path.join(root, group, n);
+      const p = await readJson(path.join(dir, "package.json"));
+      if (typeof p?.name !== "string" || typeof p.version !== "string") continue;
+      workspace[p.name] = p.version;
+      dirs[p.name] = await realpath(dir);
+      // A peer as this package resolves it in the monorepo: the version the tests ran with.
+      const peers = (p.peerDependencies ?? {})                          ;
+      for (const peer of SHARED_PEERS) {
+        if (installed[peer] || !peers[peer]) continue;
+        const got = await readJson(path.join(dir, "node_modules", peer, "package.json"));
+        if (typeof got?.version === "string") installed[peer] = got.version;
+      }
+    }
+  }
+  return { workspace, catalog, installed, dirs };
+}

package/dist/src/blocks.d.ts

@@ -0,0 +1,26 @@
+import { type BlockRegistry, type PropsSchema } from "@cloudhal/core-ts/blocks";
+/** Where a project declares its block types. */
+export declare const BLOCK_TYPES_FILE: string;
+/** Where a theme declares its design settings (RFC-0017 §1). */
+export declare const THEME_SETTINGS_FILE: string;
+/** Where a theme writes its design rules for agents (RFC-0021 §1). */
+export declare const THEME_DESIGN_FILE: string;
+/** The theme's file, when the project has one. */
+export declare function blockTypesFile(projectDir: string): Promise<string | undefined>;
+/** The theme's settings file, when the project has one. */
+export declare function themeSettingsFile(projectDir: string): Promise<string | undefined>;
+/** The theme's DESIGN.md, when it ships one (RFC-0021 §1). */
+export declare function themeDesignFile(projectDir: string): Promise<string | undefined>;
+/** The theme's DESIGN.md text, cut at the site rules' limit; `undefined` when there is none. */
+export declare function loadThemeDesign(projectDir: string): Promise<string | undefined>;
+/**
+ * The theme's design settings schema (`src/settings.ts` → `themeSettings`), checked against the
+ * props subset; `undefined` when the theme declares none.
+ */
+export declare function loadThemeSettings(projectDir: string): Promise<PropsSchema | undefined>;
+/**
+ * The deployment's registry: the built-ins and the theme's types, checked (names, the props
+ * subset, examples against their own schema; a built-in's name is refused). Throws with every
+ * problem listed, naming the file.
+ */
+export declare function loadBlockRegistry(projectDir: string): Promise<BlockRegistry>;

package/dist/src/blocks.js

@@ -0,0 +1,102 @@
+/**
+ * The theme's block types (RFC-0015 §6): `src/blocks.ts` in the project, pure data exported as
+ * `blockTypes` (type imports only, so it loads without the project's dependencies). `cloudhal studio`, `mcp` and `deploy` load it so the
+ * store validates, Studio offers and agents list the theme's types next to the built-ins.
+ */
+import { readFile, stat } from "node:fs/promises";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+import {
+                     
+                 
+  BlockTypeError,
+  checkPropsSchema,
+  createBlockRegistry,
+                   
+} from "@cloudhal/core-ts/blocks";
+import { DESIGN_MAX_LENGTH } from "@cloudhal/core-ts/design";
+
+/** Where a project declares its block types. */
+export const BLOCK_TYPES_FILE = path.join("src", "blocks.ts");
+/** Where a theme declares its design settings (RFC-0017 §1). */
+export const THEME_SETTINGS_FILE = path.join("src", "settings.ts");
+/** Where a theme writes its design rules for agents (RFC-0021 §1). */
+export const THEME_DESIGN_FILE = path.join("src", "DESIGN.md");
+
+const exists = (file        ) =>
+  stat(file).then(
+    (s) => s.isFile(),
+    () => false,
+  );
+
+/** The theme's file, when the project has one. */
+export async function blockTypesFile(projectDir        )                              {
+  const file = path.join(projectDir, BLOCK_TYPES_FILE);
+  return (await exists(file)) ? file : undefined;
+}
+
+/** The theme's settings file, when the project has one. */
+export async function themeSettingsFile(projectDir        )                              {
+  const file = path.join(projectDir, THEME_SETTINGS_FILE);
+  return (await exists(file)) ? file : undefined;
+}
+
+/** The theme's DESIGN.md, when it ships one (RFC-0021 §1). */
+export async function themeDesignFile(projectDir        )                              {
+  const file = path.join(projectDir, THEME_DESIGN_FILE);
+  return (await exists(file)) ? file : undefined;
+}
+
+/** The theme's DESIGN.md text, cut at the site rules' limit; `undefined` when there is none. */
+export async function loadThemeDesign(projectDir        )                              {
+  const file = await themeDesignFile(projectDir);
+  if (!file) return undefined;
+  const text = (await readFile(file, "utf8")).trim();
+  return text ? text.slice(0, DESIGN_MAX_LENGTH) : undefined;
+}
+
+/** A project file's exports, naming the file when it does not load. */
+async function importData(file        , name        )                                   {
+  try {
+    return (await import(pathToFileURL(file).href))                           ;
+  } catch (e) {
+    throw new Error(
+      `${name}: ${(e         ).message}. Keep the file data only, with type imports only (\`import type\`).`,
+    );
+  }
+}
+
+/**
+ * The theme's design settings schema (`src/settings.ts` → `themeSettings`), checked against the
+ * props subset; `undefined` when the theme declares none.
+ */
+export async function loadThemeSettings(projectDir        )                                   {
+  const file = await themeSettingsFile(projectDir);
+  if (!file) return undefined;
+  const { themeSettings } = await importData(file, THEME_SETTINGS_FILE);
+  const issues = checkPropsSchema(themeSettings);
+  if (issues.length)
+    throw new Error(
+      `${THEME_SETTINGS_FILE}: themeSettings ${issues.map((i) => `${i.path || "(root)"}: ${i.message}`).join("; ")}`,
+    );
+  return themeSettings               ;
+}
+
+/**
+ * The deployment's registry: the built-ins and the theme's types, checked (names, the props
+ * subset, examples against their own schema; a built-in's name is refused). Throws with every
+ * problem listed, naming the file.
+ */
+export async function loadBlockRegistry(projectDir        )                         {
+  const file = await blockTypesFile(projectDir);
+  if (!file) return createBlockRegistry();
+  const mod = (await importData(file, BLOCK_TYPES_FILE))                            ;
+  if (!Array.isArray(mod.blockTypes))
+    throw new Error(`${BLOCK_TYPES_FILE}: export \`blockTypes\` (defineBlockTypes([...]))`);
+  try {
+    return createBlockRegistry(mod.blockTypes               );
+  } catch (e) {
+    if (e instanceof BlockTypeError) throw new Error(`${BLOCK_TYPES_FILE}: ${e.issues.join("; ")}`);
+    throw e;
+  }
+}

package/dist/src/cli/commands-content.d.ts

@@ -0,0 +1,7 @@
+import { type CliCommand } from "./types.js";
+export declare const CONTENT_COMMANDS: {
+    migrate: CliCommand;
+    media: CliCommand;
+    search: CliCommand;
+    comments: CliCommand;
+};

package/dist/src/cli/commands-content.js

@@ -0,0 +1,145 @@
+import {
+  commentsExportCli,
+  commentsImportCli,
+  commentsStatusCli,
+  describeCommentsStatus,
+} from "../commands/comments.js";
+import { describeMediaImport, mediaGc, mediaImportUrls, mediaVerify } from "../commands/media.js";
+import { describePlaceholders, mediaPlaceholders } from "../commands/media-placeholders.js";
+import { describeMigration, migrateTags } from "../commands/migrate.js";
+import { describeReindex, searchReindex } from "../commands/search.js";
+import {                  remoteFlags, subcommands } from "./types.js";
+
+/** `cloudhal migrate`, `media`, `search`, `comments`: the site's content and its stores. */
+
+const migrateCommand             = async (rest, values, { projectDir }) => {
+  const [what] = rest;
+  if (what !== "tags-to-terms")
+    throw new Error("usage: cloudhal migrate tags-to-terms [--dry-run] [--revert <id>]");
+  if (values.revert !== undefined && values["dry-run"])
+    throw new Error("--dry-run and --revert cannot be combined");
+  const result = await migrateTags({
+    projectDir,
+    ...(values["dry-run"] ? { dryRun: true } : {}),
+    ...(values.revert !== undefined ? { revert: values.revert } : {}),
+  });
+  for (const line of describeMigration(result)) console.log(line);
+  return 0;
+};
+
+const mediaImportUrlsCommand             = async (_rest, values, { projectDir }) => {
+  if (values.revert !== undefined && values["dry-run"])
+    throw new Error("--dry-run and --revert cannot be combined");
+  const result = await mediaImportUrls({
+    projectDir,
+    ...(values["dry-run"] ? { dryRun: true } : {}),
+    ...(values["include-markdown"] ? { includeMarkdown: true } : {}),
+    ...(values.revert !== undefined ? { revert: values.revert } : {}),
+    ...(values["allow-host"]?.length ? { allowHosts: values["allow-host"] } : {}),
+  });
+  for (const line of describeMediaImport(result)) console.log(line);
+  return 0;
+};
+
+const mediaVerifyCommand             = async (rest, _values, { projectDir }) => {
+  const [assetId] = rest;
+  const r = await mediaVerify({ projectDir, ...(assetId ? { assetId } : {}) });
+  console.log(`checked ${r.checked}: ${r.ok.length} ok, ${r.problems.length} problem(s)`);
+  for (const p of r.problems) console.log(`  ${p.assetId}: ${p.problem}`);
+  return r.problems.length ? 1 : 0;
+};
+
+const mediaGcCommand             = async (_rest, values, { projectDir }) => {
+  const r = await mediaGc({ projectDir, ...(values["dry-run"] ? { dryRun: true } : {}) });
+  console.log(
+    `${r.dryRun ? "would delete" : "deleted"} ${r.collected.length} unreferenced file(s)`,
+  );
+  return 0;
+};
+
+const mediaPlaceholdersCommand             = async (_rest, values, { projectDir }) => {
+  const r = await mediaPlaceholders({
+    projectDir,
+    ...remoteFlags(values),
+    ...(values.all ? { all: true } : {}),
+    ...(values["dry-run"] ? { dryRun: true } : {}),
+  });
+  console.log(describePlaceholders(r));
+  return r.failed.length ? 1 : 0;
+};
+
+const mediaCommand = subcommands(
+  {
+    "import-urls": mediaImportUrlsCommand,
+    verify: mediaVerifyCommand,
+    gc: mediaGcCommand,
+    placeholders: mediaPlaceholdersCommand,
+  },
+  "usage: cloudhal media import-urls|verify|gc|placeholders",
+);
+
+const searchCommand             = async (rest, values, { projectDir }) => {
+  const [what] = rest;
+  if (what !== "reindex") throw new Error("usage: cloudhal search reindex [--remote]");
+  const report = await searchReindex({ projectDir, ...remoteFlags(values) });
+  console.log(describeReindex(report));
+  return 0;
+};
+
+const commentsStatusCommand             = async (_rest, values, { projectDir }) => {
+  const s = await commentsStatusCli({ projectDir, ...remoteFlags(values) });
+  for (const line of describeCommentsStatus(s)) console.log(line);
+  return 0;
+};
+
+const commentsExportCommand             = async (_rest, values, { projectDir }) => {
+  const personal = values["with-personal-data"] === true;
+  if (personal && !values.out)
+    throw new Error(
+      "--with-personal-data needs --out <file> (the file holds email addresses; it is written owner-only)",
+    );
+  const r = await commentsExportCli({
+    projectDir,
+    ...remoteFlags(values),
+    ...(personal ? { personal: true } : {}),
+    ...(values.out ? { out: values.out } : {}),
+    log: (l) => process.stderr.write(`${l}\n`),
+  });
+  if (values.out)
+    console.log(
+      `wrote ${values.out}: ${r.comments} comment(s)${personal ? `, ${r.commenters} commenter(s) with their email` : ""}`,
+    );
+  else process.stdout.write(r.text);
+  return 0;
+};
+
+const commentsImportCommand             = async (_rest, values, { projectDir }) => {
+  if (!values.in) throw new Error("usage: cloudhal comments import --in <file> [--remote]");
+  const r = await commentsImportCli({
+    projectDir,
+    ...remoteFlags(values),
+    file: values.in,
+    log: (l) => console.log(l),
+  });
+  console.log(
+    `${r.imported} imported, ${r.skipped} already there${r.commenters ? `, ${r.commenters} commenter email(s) stored` : ""}${r.invalid.length ? `, ${r.invalid.length} refused` : ""}`,
+  );
+  for (const p of r.invalid) console.log(`  line ${p.line}${p.id ? ` (${p.id})` : ""}: ${p.error}`);
+  return r.invalid.length ? 1 : 0;
+};
+
+const commentsCommand = subcommands(
+  {
+    status: commentsStatusCommand,
+    export: commentsExportCommand,
+    import: commentsImportCommand,
+  },
+  "usage: cloudhal comments status|export|import",
+);
+
+export const CONTENT_COMMANDS = {
+  migrate: migrateCommand,
+  media: mediaCommand,
+  search: searchCommand,
+  comments: commentsCommand,
+}                                     ;

package/dist/src/cli/commands-local.d.ts

@@ -0,0 +1,13 @@
+import { type CliCommand } from "./types.js";
+export declare const LOCAL_COMMANDS: {
+    init: CliCommand;
+    dev: CliCommand;
+    snapshot: CliCommand;
+    build: CliCommand;
+    studio: CliCommand;
+    mcp: CliCommand;
+    render: CliCommand;
+    motion: CliCommand;
+    tokens: CliCommand;
+    chrome: CliCommand;
+};

package/dist/src/cli/commands-local.js

@@ -0,0 +1,167 @@
+import { isAgentMode,            } from "@cloudhal/agent-runtime";
+import { build, dev } from "../commands/astro.js";
+import { chromeGet, chromeSet } from "../commands/chrome.js";
+import { init } from "../commands/init.js";
+import { mcp } from "../commands/mcp.js";
+import { describeMotionAudit, motionAudit } from "../commands/motion.js";
+import { describeRender, render } from "../commands/render.js";
+import { snapshot } from "../commands/snapshot.js";
+import { studio } from "../commands/studio.js";
+import { tokensExport } from "../commands/tokens.js";
+import { detectPackageManager, nextSteps } from "../project-setup.js";
+import {                  untilSignal } from "./types.js";
+
+/** `cloudhal init`, `dev`, `snapshot`, `build`, `studio`, `mcp`: the project on this machine. */
+
+const initCommand             = async (rest, values) => {
+  const dir = rest[0];
+  if (!dir) throw new Error("usage: cloudhal init <dir>");
+  const r = await init({
+    dir,
+    ...(values.name ? { name: values.name } : {}),
+    ...(values.starter ? { starter: values.starter } : {}),
+    log: (l) => console.log(`  ${l}`),
+  });
+  const steps = nextSteps(dir, r.linked ? "pnpm" : detectPackageManager());
+  console.log(`\nCreated ${r.projectDir}\n\n${steps.map((l) => `  ${l}`).join("\n")}\n`);
+  return 0;
+};
+
+const devCommand             = async (_rest, values, { projectDir }) => {
+  const server = await dev({
+    projectDir,
+    ...(values.port ? { port: Number(values.port) } : {}),
+    ...(values.host ? { host: true } : {}),
+  });
+  if (server.url) console.log(`cloudhal dev → ${server.url}`);
+  await untilSignal();
+  await server.stop();
+  return 0;
+};
+
+const snapshotCommand             = async (_rest, values, { projectDir }) => {
+  const snap = await snapshot({
+    projectDir,
+    ...(values.label ? { label: values.label } : {}),
+    ...(values.publish ? { publish: true } : {}),
+  });
+  console.log(
+    `${snap.id}  nodes=${snap.nodes.length}  +${snap.summary.added} ~${snap.summary.changed} -${snap.summary.removed}${values.publish ? "  (published)" : ""}`,
+  );
+  return 0;
+};
+
+const buildCommand             = async (_rest, values, { projectDir }) => {
+  const r = await build({
+    projectDir,
+    ...(values.snapshot ? { snapshotId: values.snapshot } : {}),
+  });
+  console.log(`built ${r.outDir} from ${r.snapshotId}`);
+  return 0;
+};
+
+const studioCommand             = async (_rest, values, { projectDir }) => {
+  const s = await studio({
+    projectDir,
+    ...(values.port ? { port: Number(values.port) } : {}),
+    ...(values["no-auth"] ? { noAuth: true } : {}),
+  });
+  console.log(`cloudhal studio → ${s.url}`);
+  await untilSignal();
+  await s.stop();
+  return 0;
+};
+
+const mcpCommand             = async (_rest, values, { projectDir }) => {
+  const server = await mcp({
+    projectDir,
+    ...(values.scopes ? { scopes: values.scopes.split(",").map((s) => s.trim())            } : {}),
+    ...(values.skills ? { skillsDir: values.skills } : {}),
+    ...(values["preview-url"] ? { previewUrl: values["preview-url"] } : {}),
+    ...(values.mode
+      ? (() => {
+          if (!isAgentMode(values.mode)) throw new Error(`unknown --mode "${values.mode}"`);
+          return { mode: values.mode };
+        })()
+      : {}),
+  });
+  await untilSignal((resolve) => process.stdin.once("close", () => resolve()));
+  await server.stop();
+  return 0;
+};
+
+/** `cloudhal render`, `motion`, `tokens`, `chrome`: the design and look of the local site. */
+
+const renderCommand             = async (rest, values, { projectDir }) => {
+  const [target] = rest;
+  if (!target)
+    throw new Error(
+      "usage: cloudhal render <path|url> [--width 1440,390] [--scheme dark] [--motion full] [--frames 4]",
+    );
+  const report = await render({
+    projectDir,
+    target,
+    ...(values.base ? { base: values.base } : {}),
+    ...(values.width ? { widths: values.width.split(",").map(Number) } : {}),
+    ...(values.scheme ? { scheme: values.scheme } : {}),
+    ...(values.motion ? { motion: values.motion } : {}),
+    ...(values.frames ? { frames: Number(values.frames) } : {}),
+    ...(values.out ? { out: values.out } : {}),
+  });
+  console.log(describeRender(report));
+  return report.checks.every((c) => c.ok) ? 0 : 2;
+};
+
+const motionCommand             = async (rest, values, { projectDir }) => {
+  const [what] = rest;
+  if (what !== "audit") throw new Error("usage: cloudhal motion audit [--path <p>]");
+  const audit = await motionAudit({
+    projectDir,
+    ...(values.path ? { path: values.path } : {}),
+  });
+  console.log(describeMotionAudit(audit));
+  return audit.pages.some((p) => p.warnings.length) ? 2 : 0;
+};
+
+const chromeCommand             = async (rest, values, { projectDir }) => {
+  const [what] = rest;
+  if (what === "get") {
+    const json = await chromeGet({ projectDir, ...(values.file ? { file: values.file } : {}) });
+    if (values.file) console.log(`wrote ${values.file}`);
+    else process.stdout.write(json);
+    return 0;
+  }
+  if (what === "set") {
+    await chromeSet({ projectDir, ...(values.file ? { file: values.file } : {}) });
+    console.log("chrome saved; publish to show it on the site");
+    return 0;
+  }
+  throw new Error("usage: cloudhal chrome get [--file <f>] | set --file <f>");
+};
+
+const tokensCommand             = async (rest, values, { projectDir }) => {
+  const [what] = rest;
+  if (what !== "export")
+    throw new Error("usage: cloudhal tokens export [--format dtcg] [--out <file>]");
+  const json = await tokensExport({
+    projectDir,
+    ...(values.format ? { format: values.format } : {}),
+    ...(values.out ? { out: values.out } : {}),
+  });
+  if (values.out) console.log(`wrote ${values.out}`);
+  else process.stdout.write(json);
+  return 0;
+};
+
+export const LOCAL_COMMANDS = {
+  init: initCommand,
+  dev: devCommand,
+  snapshot: snapshotCommand,
+  build: buildCommand,
+  studio: studioCommand,
+  mcp: mcpCommand,
+  render: renderCommand,
+  motion: motionCommand,
+  tokens: tokensCommand,
+  chrome: chromeCommand,
+}                                     ;

package/dist/src/cli/commands-ops.d.ts

@@ -0,0 +1,6 @@
+import { type CliCommand } from "./types.js";
+export declare const OPS_COMMANDS: {
+    analytics: CliCommand;
+    schedules: CliCommand;
+    ai: CliCommand;
+};