@moonbase.sh/cli 0.0.0-next-20261001173449

package/README.md

@@ -0,0 +1,119 @@
+# @moonbase.sh/cli
+
+Publish product releases to Moonbase from the command line or a CI job, in one command.
+
+```bash
+export MOONBASE_ENDPOINT=https://acme.moonbase.sh
+export MOONBASE_API_KEY=mb_...
+
+npx @moonbase.sh/cli release moon-terminal v1.4.0 "dist/Moon Terminal.dmg" "dist/Moon Terminal Setup.exe" --notes-file NOTES.md --publish
+```
+
+That uploads both files, creates release 1.4.0 of the product `moon-terminal` from them, and
+publishes it. It needs Node.js 20 or later.
+
+`MOONBASE_ENDPOINT` is your account's address and `MOONBASE_API_KEY` an API key. Both are under
+Account settings > Developer in Moonbase. Every command also takes them as `--endpoint` and
+`--api-key`, which win over the variables. Keep the key secret: in CI, put it in a secret rather
+than in the workflow file. Prefer the variable to `--api-key` on a machine you share, since other
+users can see a command's options while it runs, and your shell history keeps them.
+
+## Commands
+
+### `release <product-id> <version> <file...>`
+
+Uploads the files and creates the release from them. Before it uploads anything, it checks that the
+product exists, that the release does not (unless you pass `--add`) and that every file is there.
+
+- The version is `MAJOR.MINOR.PATCH`. A leading `v` is dropped, so a Git tag like `v1.4.0` works as
+  it is.
+- Each download is named after its file.
+- A file's platform is guessed from its extension (`.dmg` and `.pkg` are Mac, `.exe` and `.msi`
+  Windows, `.deb`, `.rpm` and `.AppImage` Linux), then from a word in its name (`mac`, `win`,
+  `linux`), and is Universal otherwise. Its architecture is guessed from a word in its name (`arm64`,
+  `x64`, `x86_64`, `universal` and the like) and is left out otherwise. The command lists what it
+  guessed before it uploads. `--platform` and `--arch` set them for every file instead.
+- A file larger than 64 MiB is sent in parts, four at a time, and a part that fails is retried.
+
+| Option | |
+|---|---|
+| `--notes <text>` | The release notes |
+| `--notes-file <path>` | Read the release notes from a file |
+| `--platform <name>` | `Universal`, `Windows`, `Linux`, `Mac`, `iOS` or `Android` |
+| `--arch <name>` | `Universal`, `X86`, `X64`, `Arm` or `Arm64` |
+| `--publish` | Publish the release, so customers can download it. Without it the release stays unpublished. |
+| `--add` | If the release exists, add the files to it. A file with the same name, platform and architecture as one already there replaces it. |
+| `--json` | Print the release as JSON |
+| `--endpoint <url>` | Your account's address, instead of `MOONBASE_ENDPOINT` |
+| `--api-key <key>` | An API key, instead of `MOONBASE_API_KEY` |
+
+### `publish <product-id> <version>`
+
+Publishes a release, so customers can download it. Takes `--json`, `--endpoint` and `--api-key`.
+
+### `upload <file>`
+
+Uploads one file and prints its key, for adding it to a release through the API or
+[`@moonbase.sh/api`](https://www.npmjs.com/package/@moonbase.sh/api). Takes `--endpoint` and
+`--api-key`.
+
+Progress and messages go to stderr, so stdout holds only the key or, with `--json`, the release.
+The exit code is 0 when the command worked, 1 when it failed and 2 when it was run the wrong way.
+
+## GitHub Actions
+
+Release when a version tag is pushed:
+
+```yaml
+on:
+  push:
+    tags: ['v*']
+
+jobs:
+  release:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - run: ./build.sh # puts the installers in dist/
+      - run: npx @moonbase.sh/cli release moon-terminal ${{ github.ref_name }} dist/* --publish
+        env:
+          MOONBASE_ENDPOINT: https://acme.moonbase.sh
+          MOONBASE_API_KEY: ${{ secrets.MOONBASE_API_KEY }}
+```
+
+When each platform builds on its own runner, let each job add its files with `--add`, and publish
+once they all have:
+
+```yaml
+jobs:
+  build:
+    strategy:
+      matrix:
+        os: [macos-latest, windows-latest, ubuntu-latest]
+    runs-on: ${{ matrix.os }}
+    steps:
+      - uses: actions/checkout@v4
+      - run: ./build.sh
+        shell: bash
+      # bash, so `dist/*` is expanded on Windows too.
+      - run: npx @moonbase.sh/cli release moon-terminal ${{ github.ref_name }} dist/* --add
+        shell: bash
+        env:
+          MOONBASE_ENDPOINT: https://acme.moonbase.sh
+          MOONBASE_API_KEY: ${{ secrets.MOONBASE_API_KEY }}
+
+  publish:
+    needs: build
+    runs-on: ubuntu-latest
+    steps:
+      - run: npx @moonbase.sh/cli publish moon-terminal ${{ github.ref_name }}
+        env:
+          MOONBASE_ENDPOINT: https://acme.moonbase.sh
+          MOONBASE_API_KEY: ${{ secrets.MOONBASE_API_KEY }}
+```
+
+Jobs that finish at the same moment are fine: when Moonbase turns one job's change away because
+another's landed first, the command sends it again. A rerun of a job replaces the files it added
+before, since they have the same names.
+
+To keep a workflow on a version you have tried, pin it: `npx @moonbase.sh/cli@0.1 release ...`.

package/dist/cli.js

@@ -0,0 +1,448 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import process2 from "process";
+
+// src/main.ts
+import fs from "fs";
+import process from "process";
+import { parseArgs } from "util";
+import { ConflictError, MoonbaseClient, MoonbaseError, NotAuthenticatedError, NotFoundError } from "@moonbase.sh/api";
+
+// package.json
+var version = "0.0.0-next-20261001173449";
+
+// src/files.ts
+import path from "path";
+import { Architecture, Platform } from "@moonbase.sh/api";
+var platformByExtension = {
+  exe: Platform.Windows,
+  msi: Platform.Windows,
+  msix: Platform.Windows,
+  appx: Platform.Windows,
+  dmg: Platform.Mac,
+  pkg: Platform.Mac,
+  deb: Platform.Linux,
+  rpm: Platform.Linux,
+  appimage: Platform.Linux,
+  snap: Platform.Linux,
+  flatpak: Platform.Linux
+};
+var platformByWord = [
+  [["mac", "macos", "osx", "darwin"], Platform.Mac],
+  [["win", "windows", "win32", "win64"], Platform.Windows],
+  [["linux"], Platform.Linux]
+];
+var archByWord = [
+  [["arm64", "aarch64"], Architecture.Arm64],
+  [["x86_64", "x86-64", "x64", "amd64"], Architecture.X64],
+  [["x86", "i386", "i686", "ia32"], Architecture.X86],
+  [["armv7", "armv7l", "armhf"], Architecture.Arm],
+  [["universal"], Architecture.Universal]
+];
+var contentTypeByExtension = {
+  "7z": "application/x-7z-compressed",
+  "appimage": "application/vnd.appimage",
+  "deb": "application/vnd.debian.binary-package",
+  "dmg": "application/x-apple-diskimage",
+  "exe": "application/vnd.microsoft.portable-executable",
+  "gz": "application/gzip",
+  "msi": "application/x-msi",
+  "pdf": "application/pdf",
+  "rpm": "application/x-rpm",
+  "tar": "application/x-tar",
+  "tgz": "application/gzip",
+  "zip": "application/zip"
+};
+function describeFile(filePath, size, overrides = {}) {
+  const name = path.basename(filePath);
+  const extension = path.extname(name).slice(1).toLowerCase();
+  const words = name.slice(0, name.length - path.extname(name).length).toLowerCase();
+  return {
+    path: filePath,
+    name,
+    size,
+    platform: overrides.platform ?? platformByExtension[extension] ?? findWord(words, platformByWord) ?? Platform.Universal,
+    arch: overrides.arch ?? findWord(words, archByWord),
+    contentType: contentTypeByExtension[extension] ?? "application/octet-stream"
+  };
+}
+function findWord(text, table) {
+  return table.find(([words]) => words.some((word) => new RegExp(`(^|[^a-z0-9])${word}($|[^a-z0-9])`).test(text)))?.[1];
+}
+function parseVersion(input) {
+  const match = /^v?(\d+)\.(\d+)\.(\d+)$/i.exec(input.trim());
+  return match ? match.slice(1).map(Number).join(".") : void 0;
+}
+function parsePlatform(input) {
+  return Object.values(Platform).find((platform) => platform.toLowerCase() === input.toLowerCase());
+}
+function parseArch(input) {
+  return Object.values(Architecture).find((arch) => arch !== Architecture.Unknown && arch.toLowerCase() === input.toLowerCase());
+}
+function formatBytes(bytes) {
+  const units = ["bytes", "KB", "MB", "GB", "TB"];
+  let value = bytes;
+  let unit = 0;
+  while (value >= 1e3 && unit < units.length - 1) {
+    value /= 1e3;
+    unit++;
+  }
+  return unit === 0 ? `${bytes} bytes` : `${value.toFixed(1)} ${units[unit]}`;
+}
+
+// src/main.ts
+var UsageError = class extends Error {
+  constructor(message, command) {
+    super(message);
+    this.command = command;
+  }
+};
+var silentLogger = { debug: () => {
+}, log: () => {
+}, warn: () => {
+}, error: () => {
+} };
+var raceAttempts = 6;
+var help = {
+  main: `Usage: moonbase <command> [options]
+
+Publish product releases to Moonbase from the command line or a CI job.
+
+Commands:
+  release <product-id> <version> <file...>   Upload files and create a release from them
+  upload <file>                              Upload one file and print its key
+  publish <product-id> <version>             Publish a release
+
+Environment:
+  MOONBASE_ENDPOINT   Your account's address, like https://acme.moonbase.sh
+  MOONBASE_API_KEY    An API key
+Both are under Account settings > Developer in Moonbase. Every command also takes them as
+--endpoint and --api-key.
+
+Run "moonbase help <command>" for a command's options.
+`,
+  release: `Usage: moonbase release <product-id> <version> <file...> [options]
+
+Uploads the files and creates the release from them. The version is MAJOR.MINOR.PATCH, and a
+leading "v" is dropped, so a Git tag like v1.4.0 works as it is. The release stays unpublished
+unless you pass --publish.
+
+A file's platform is guessed from its extension (.dmg and .pkg are Mac, .exe and .msi Windows,
+.deb, .rpm and .AppImage Linux), then from a word in its name (mac, win, linux), and is Universal
+otherwise. Its architecture is guessed from a word in its name (arm64, x64, x86_64, universal) and
+is left out otherwise. --platform and --arch set them for every file instead.
+
+Options:
+  --notes <text>        The release notes
+  --notes-file <path>   Read the release notes from a file
+  --platform <name>     Universal, Windows, Linux, Mac, iOS or Android
+  --arch <name>         Universal, X86, X64, Arm or Arm64
+  --publish             Publish the release, so customers can download it
+  --add                 If the release exists, add the files to it. A file with the same name,
+                        platform and architecture as one already there replaces it.
+  --json                Print the release as JSON
+  --endpoint <url>      Your account's address, instead of MOONBASE_ENDPOINT
+  --api-key <key>       An API key, instead of MOONBASE_API_KEY. Other users of the machine
+                        can see it while the command runs, so prefer the variable.
+`,
+  upload: `Usage: moonbase upload <file> [options]
+
+Uploads a file and prints its key, for adding it to a release with the API.
+
+Options:
+  --endpoint <url>      Your account's address, instead of MOONBASE_ENDPOINT
+  --api-key <key>       An API key, instead of MOONBASE_API_KEY. Other users of the machine
+                        can see it while the command runs, so prefer the variable.
+`,
+  publish: `Usage: moonbase publish <product-id> <version> [options]
+
+Publishes a release, so customers can download it.
+
+Options:
+  --json                Print the release as JSON
+  --endpoint <url>      Your account's address, instead of MOONBASE_ENDPOINT
+  --api-key <key>       An API key, instead of MOONBASE_API_KEY. Other users of the machine
+                        can see it while the command runs, so prefer the variable.
+`
+};
+async function main(argv, io) {
+  const [command, ...args] = argv;
+  try {
+    switch (command) {
+      case "release":
+        return await release(args, io);
+      case "upload":
+        return await upload(args, io);
+      case "publish":
+        return await publish(args, io);
+      case "help":
+      case "--help":
+      case "-h":
+        io.stdout.write(help[args[0]] ?? help.main);
+        return 0;
+      case "--version":
+        io.stdout.write(`${version}
+`);
+        return 0;
+      case void 0:
+        io.stderr.write(help.main);
+        return 2;
+      default:
+        throw new UsageError(`There is no command "${command}".`, "main");
+    }
+  } catch (error) {
+    if (error instanceof UsageError) {
+      io.stderr.write(`${error.message}
+`);
+      if (error.command)
+        io.stderr.write(`Run "moonbase help${error.command === "main" ? "" : ` ${error.command}`}" for how to use it.
+`);
+      return 2;
+    }
+    io.stderr.write(`Error: ${describeError(error)}
+`);
+    return 1;
+  }
+}
+async function release(args, io) {
+  const { values, positionals } = parse("release", () => parseArgs({
+    args,
+    allowPositionals: true,
+    options: {
+      "notes": { type: "string" },
+      "notes-file": { type: "string" },
+      "platform": { type: "string" },
+      "arch": { type: "string" },
+      "publish": { type: "boolean", default: false },
+      "add": { type: "boolean", default: false },
+      "json": { type: "boolean", default: false },
+      "endpoint": { type: "string" },
+      "api-key": { type: "string" },
+      "help": { type: "boolean", short: "h", default: false }
+    }
+  }));
+  if (values.help) {
+    io.stdout.write(help.release);
+    return 0;
+  }
+  const [productId, versionArgument, ...paths] = positionals;
+  if (!productId || !versionArgument || paths.length === 0)
+    throw new UsageError("release takes a product ID, a version and at least one file.", "release");
+  const version2 = readVersion(versionArgument, "release");
+  if (values.notes !== void 0 && values["notes-file"] !== void 0)
+    throw new UsageError("Pass --notes or --notes-file, not both.", "release");
+  const platform = values.platform === void 0 ? void 0 : parsePlatform(values.platform);
+  if (values.platform !== void 0 && !platform)
+    throw new UsageError(`There is no platform "${values.platform}".`, "release");
+  const arch = values.arch === void 0 ? void 0 : parseArch(values.arch);
+  if (values.arch !== void 0 && !arch)
+    throw new UsageError(`There is no architecture "${values.arch}".`, "release");
+  const description = values["notes-file"] !== void 0 ? await fs.promises.readFile(values["notes-file"], "utf8") : values.notes;
+  const files = await inspectFiles(paths, { platform, arch });
+  const client = connect(values.endpoint, values["api-key"], io);
+  try {
+    await client.products.get(productId);
+  } catch (error) {
+    if (error instanceof NotFoundError)
+      throw new Error(`There is no product with the ID "${productId}".`);
+    throw error;
+  }
+  let existing = await findRelease(client, productId, version2);
+  if (existing && !values.add)
+    throw new Error(`Release ${version2} of ${productId} already exists. Pass --add to add these files to it.`);
+  io.stderr.write(`${existing ? "Adding to" : "Creating"} release ${version2} of ${productId}:
+`);
+  const nameWidth = Math.max(...files.map((file) => file.name.length));
+  for (const file of files)
+    io.stderr.write(`  ${file.name.padEnd(nameWidth)}  ${[file.platform, file.arch].filter(Boolean).join(", ")}, ${formatBytes(file.size)}
+`);
+  const downloads = [];
+  for (const file of files)
+    downloads.push({ name: file.name, platform: file.platform, arch: file.arch, key: await uploadFile(client, file, io) });
+  let result;
+  if (!existing) {
+    try {
+      result = await retryRace(io, () => client.products.createRelease(productId, { version: version2, description, downloads }, { publishImmediately: values.publish }));
+      io.stderr.write(`Created release ${version2} of ${productId}${values.publish ? " and published it" : ""}.
+`);
+    } catch (error) {
+      if (!(error instanceof ConflictError && values.add))
+        throw error;
+      existing = await findRelease(client, productId, version2);
+    }
+  }
+  if (!result) {
+    if (description !== void 0)
+      io.stderr.write(`Release ${version2} already existed, so its notes were left as they were.
+`);
+    for (const download of downloads)
+      result = await retryRace(io, () => client.products.addReleaseDownload(productId, version2, download));
+    io.stderr.write(`Added ${downloads.length === 1 ? "the file" : `${downloads.length} files`} to release ${version2} of ${productId}.
+`);
+    if (existing?.publishedAt)
+      io.stderr.write(`The release was already published, so customers can download them now.
+`);
+    if (values.publish && !existing?.publishedAt) {
+      result = await retryRace(io, () => client.products.publishRelease(productId, version2));
+      io.stderr.write(`Published it.
+`);
+    }
+  }
+  if (!result.publishedAt)
+    io.stderr.write(`It is not published yet. Publish it with: moonbase publish ${productId} ${version2}
+`);
+  if (values.json)
+    io.stdout.write(`${JSON.stringify(result, void 0, 2)}
+`);
+  return 0;
+}
+async function upload(args, io) {
+  const { values, positionals } = parse("upload", () => parseArgs({
+    args,
+    allowPositionals: true,
+    options: {
+      "endpoint": { type: "string" },
+      "api-key": { type: "string" },
+      "help": { type: "boolean", short: "h", default: false }
+    }
+  }));
+  if (values.help) {
+    io.stdout.write(help.upload);
+    return 0;
+  }
+  if (positionals.length !== 1)
+    throw new UsageError("upload takes one file.", "upload");
+  const [file] = await inspectFiles(positionals);
+  const client = connect(values.endpoint, values["api-key"], io);
+  io.stdout.write(`${await uploadFile(client, file, io)}
+`);
+  return 0;
+}
+async function publish(args, io) {
+  const { values, positionals } = parse("publish", () => parseArgs({
+    args,
+    allowPositionals: true,
+    options: {
+      "json": { type: "boolean", default: false },
+      "endpoint": { type: "string" },
+      "api-key": { type: "string" },
+      "help": { type: "boolean", short: "h", default: false }
+    }
+  }));
+  if (values.help) {
+    io.stdout.write(help.publish);
+    return 0;
+  }
+  const [productId, versionArgument, ...rest] = positionals;
+  if (!productId || !versionArgument || rest.length > 0)
+    throw new UsageError("publish takes a product ID and a version.", "publish");
+  const version2 = readVersion(versionArgument, "publish");
+  const client = connect(values.endpoint, values["api-key"], io);
+  let result;
+  try {
+    result = await retryRace(io, () => client.products.publishRelease(productId, version2));
+  } catch (error) {
+    if (error instanceof NotFoundError)
+      throw new Error(`There is no release ${version2} of a product with the ID "${productId}".`);
+    throw error;
+  }
+  io.stderr.write(`Published release ${version2} of ${productId}.
+`);
+  if (values.json)
+    io.stdout.write(`${JSON.stringify(result, void 0, 2)}
+`);
+  return 0;
+}
+function parse(command, read) {
+  try {
+    return read();
+  } catch (error) {
+    throw new UsageError(error instanceof Error ? error.message : String(error), command);
+  }
+}
+function readVersion(argument, command) {
+  const version2 = parseVersion(argument);
+  if (!version2)
+    throw new UsageError(`"${argument}" is not a version. Use MAJOR.MINOR.PATCH, like 1.4.0.`, command);
+  return version2;
+}
+function connect(endpointOption, apiKeyOption, io) {
+  let endpoint = endpointOption ?? io.env.MOONBASE_ENDPOINT;
+  const apiKey = apiKeyOption ?? io.env.MOONBASE_API_KEY;
+  if (!endpoint)
+    throw new UsageError("Set MOONBASE_ENDPOINT, or pass --endpoint, to your account's address, like https://acme.moonbase.sh. It is under Account settings > Developer in Moonbase.");
+  if (!apiKey)
+    throw new UsageError("Set MOONBASE_API_KEY, or pass --api-key, to an API key from Account settings > Developer in Moonbase.");
+  if (!/^https?:\/\//i.test(endpoint))
+    endpoint = `https://${endpoint}`;
+  return io.createClient?.(endpoint, apiKey) ?? new MoonbaseClient({ endpoint, apiKey, logger: silentLogger });
+}
+async function inspectFiles(paths, overrides) {
+  if (typeof fs.openAsBlob !== "function")
+    throw new Error(`Uploading needs Node.js 20 or later, and this is ${process.version}.`);
+  const files = [];
+  for (const filePath of paths) {
+    const stats = await fs.promises.stat(filePath).catch(() => void 0);
+    if (!stats)
+      throw new Error(`There is no file at ${filePath}.`);
+    if (!stats.isFile())
+      throw new Error(`${filePath} is not a file. Archive a folder, like a .app bundle, before uploading it.`);
+    files.push(describeFile(filePath, stats.size, overrides));
+  }
+  const seen = /* @__PURE__ */ new Set();
+  for (const file of files) {
+    const identity = [file.name, file.platform, file.arch].join("/");
+    if (seen.has(identity))
+      throw new Error(`Two of the files are ${file.name} for ${[file.platform, file.arch].filter(Boolean).join(", ")}, and a release holds only one.`);
+    seen.add(identity);
+  }
+  return files;
+}
+async function uploadFile(client, file, io) {
+  io.stderr.write(`Uploading ${file.name}
+`);
+  const { key } = await client.downloads.upload(await fs.openAsBlob(file.path, { type: file.contentType }), {
+    contentType: file.contentType,
+    onProgress: ({ uploadedBytes, totalBytes }) => {
+      if (uploadedBytes < totalBytes)
+        io.stderr.write(`  ${formatBytes(uploadedBytes)} of ${formatBytes(totalBytes)} (${Math.floor(uploadedBytes / totalBytes * 100)}%)
+`);
+    }
+  });
+  return key;
+}
+async function retryRace(io, write) {
+  for (let attempt = 1; ; attempt++) {
+    try {
+      return await write();
+    } catch (error) {
+      const status = error instanceof MoonbaseError ? error.problemDetails?.status : void 0;
+      if (attempt >= raceAttempts || status === void 0 || status < 500)
+        throw error;
+      const pause = 500 + Math.floor(Math.random() * 2500);
+      await (io.wait?.(pause) ?? new Promise((resolve) => setTimeout(resolve, pause)));
+    }
+  }
+}
+async function findRelease(client, productId, version2) {
+  let page = await client.products.queryReleases(productId, { pageSize: 100 });
+  while (true) {
+    const found = page.items.find((release2) => release2.version === version2);
+    if (found || !page.hasMore)
+      return found;
+    page = await page.getNext();
+  }
+}
+function describeError(error) {
+  if (error instanceof NotAuthenticatedError)
+    return "Moonbase did not accept the API key.";
+  if (error instanceof MoonbaseError && error.problemDetails)
+    return error.problemDetails.detail ?? `${error.problemDetails.title} (HTTP ${error.problemDetails.status})`;
+  return error instanceof Error ? error.message : String(error);
+}
+
+// src/cli.ts
+main(process2.argv.slice(2), { env: process2.env, stdout: process2.stdout, stderr: process2.stderr }).then((exitCode) => {
+  process2.exitCode = exitCode;
+});

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "@moonbase.sh/cli",
+  "type": "module",
+  "version": "0.0.0-next-20261001173449",
+  "description": "Publish product releases to Moonbase.sh from the command line or a CI job",
+  "author": "Tobias Lønnerød Madsen <m@dsen.tv>",
+  "license": "MIT",
+  "bin": {
+    "moonbase": "./dist/cli.js"
+  },
+  "files": [
+    "dist/**"
+  ],
+  "engines": {
+    "node": ">=20.0.0"
+  },
+  "dependencies": {
+    "@moonbase.sh/api": "0.0.0-next-20261001173449"
+  },
+  "devDependencies": {
+    "@types/node": "^20.19.33",
+    "tsup": "^8.5.0",
+    "typescript": "~5.8.3",
+    "vitest": "^2.1.4"
+  },
+  "scripts": {
+    "build": "tsup src/cli.ts --format esm --target node20",
+    "dev": "tsup src/cli.ts --format esm --target node20 --watch",
+    "type-check": "tsc --noEmit -p tsconfig.typecheck.json",
+    "lint": "eslint . --cache --cache-location node_modules/.cache/eslint/ --cache-strategy content",
+    "lint:fix": "eslint . --cache --cache-location node_modules/.cache/eslint/ --cache-strategy content --fix",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:integration": "TEST_INTEGRATION=true vitest run"
+  }
+}