@moonbase.sh/cli 0.0.0-next-20261001173449 → 0.0.0

package/package.json

@@ -1,36 +1 @@
-{
-  "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"
-  }
-}
+{ "name": "@moonbase.sh/cli", "version": "0.0.0", "description": "Placeholder for the Moonbase CLI. The first release is 0.1.0.", "license": "MIT" }

package/README.md

@@ -1,119 +0,0 @@
-# @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

@@ -1,448 +0,0 @@
-#!/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;
-});