@onceworlds/cli 0.3.0 → 0.4.0

package/README.md

@@ -9,8 +9,9 @@ players) with no server code.
 Deploys run from GitHub Actions: GitHub vouches for the repo, so there are no API
 keys. The easiest setup is to import the repo at https://onceworlds.com/dashboard/new,
 which adds `onceworlds.json` and `.github/workflows/onceworlds.yml` for you (that
-workflow also builds with npm, pnpm, yarn or bun when there's a build script). By
-hand, the minimum is:
+workflow also builds with npm, pnpm, yarn or bun when there's a build script). To write
+the same files into a folder before it is on GitHub, run `npx @onceworlds/cli init` there.
+By hand, the minimum is:
 
 ```yaml
 name: Deploy to Onceworlds
@@ -66,7 +67,8 @@ the dashboard can change it too, and the file wins again only when this value ch
 `controls` (`[{ "keys": ["W", "A", "S", "D"], "action": "Move" }]`, up to 12) and `help` (up to 400
 characters) fill "How to play" in the platform menu. The rest fills in the game page: `genre`, a square `icon` (at least 128×128),
 16:9 `thumbnails` (at least 480 wide; the first is the cover) and `badges` (`id`,
-`name`, `description` and an optional square `icon`). Images are PNG, JPEG, WebP
+`name`, `description` and an optional square `icon`). A game page holds at most 5
+thumbnails and videos together, and a game at most 50 badges. Images are PNG, JPEG, WebP
 or GIF up to 5 MB, with paths relative to `onceworlds.json`. Live deploys apply
 these fields only when they change, so edits made in the dashboard last until then.
 
@@ -77,6 +79,13 @@ from the running game and commit them under `store/`. `onceworlds doctor` says w
 
 ## Commands
 
+- `onceworlds init [dir]` sets a game folder up, with the files the dashboard's import commits. It writes
+  `onceworlds.json` (the link and name come from `package.json`'s name or the folder's; `dir` is your build's
+  output folder when `package.json` has a build script, else `.` or the folder with your `index.html`),
+  `.github/workflows/onceworlds.yml`, and the guide for AI coding tools as `AGENTS.md` with a `CLAUDE.md` that
+  imports it (next to a `AGENTS.md` of your own it writes `ONCEWORLDS.md` and adds a pointer to yours). It never
+  overwrites a file you have: `--force` replaces only what init writes, never your own `AGENTS.md` or `CLAUDE.md`.
+  Then commit, push, and import the repo at https://onceworlds.com/dashboard/new.
 - `onceworlds deploy [dir]` uploads only the files that changed and publishes the game
   (the workflow runs it). It lists every file it skipped because Onceworlds can't serve it.
 - `onceworlds dev [dir]` deploys to a local Onceworlds platform (for platform development)

package/dist/cli.js

@@ -1,11 +1,11 @@
 #!/usr/bin/env node
 
 // src/index.ts
-import { execFileSync } from "node:child_process";
+import { execFileSync as execFileSync2 } from "node:child_process";
 import { createHash } from "node:crypto";
 import { watch } from "node:fs";
-import { readdir, readFile } from "node:fs/promises";
-import { join, resolve, sep } from "node:path";
+import { readdir as readdir2, readFile as readFile2, stat as stat2 } from "node:fs/promises";
+import { join as join2, resolve, sep } from "node:path";
 import { parseArgs } from "node:util";
 
 // src/doctor.ts
@@ -74,7 +74,7 @@ function checkListing(config, file = "onceworlds.json") {
     note("listing-icon", `No "icon": the game's card shows a plain colored placeholder. Add a square image (512\xD7512, simple, no words), like "icon": "store/icon.png".`);
   }
   if (!Array.isArray(config.thumbnails) || config.thumbnails.length === 0) {
-    note("listing-thumbnails", 'No "thumbnails": the game page and its card have no cover. Add three or more 16:9 pictures (1280\xD7720) of the game being played; the first is the cover.');
+    note("listing-thumbnails", 'No "thumbnails": the game page and its card have no cover. Add 3-5 16:9 pictures (1280\xD7720) of the game being played; the first is the cover.');
   }
   if (!filled(config.genre)) note("listing-genre", `No "genre": players can't find the game under a Discover genre. Pick one of the genres in AGENTS.md.`);
   const noControls = !Array.isArray(config.controls) || config.controls.length === 0;
@@ -168,6 +168,12 @@ function checkGame(files) {
   return found.sort((a, b) => a.file.localeCompare(b.file) || a.line - b.line);
 }
 
+// src/init.ts
+import { execFileSync } from "node:child_process";
+import { randomBytes } from "node:crypto";
+import { mkdir, readdir, readFile, stat, writeFile } from "node:fs/promises";
+import { basename, dirname, join } from "node:path";
+
 // ../protocol/src/index.ts
 var OIDC_AUDIENCE = "onceworlds";
 var LIMITS = {
@@ -214,6 +220,11 @@ var LIMITS = {
   idleAfterMs: 3e4,
   /** A running match whose connected players have all been idle this long is over: nobody is playing. */
   idleAbandonMs: 5 * 6e4,
+  /**
+   * Rated matches two accounts on opposite sides may play against each other in one game's ladder per UTC day: past it,
+   * their matches aren't rated, so two accounts that keep getting matched in a quiet game can't farm wins.
+   */
+  rankedPairMatchesPerDay: 5,
   chatLength: 200,
   chatIntervalMs: 750,
   chatHistory: 50,
@@ -234,7 +245,7 @@ var LIMITS = {
   envValueBytes: 4 * 1024,
   /** All of a game's public variables together, as injected into its pages. */
   envTotalBytes: 16 * 1024,
-  /** Proxied request bodies: routes that take a file (audio to transcribe, an image to edit, model inputs on Replicate and fal). */
+  /** Proxied request bodies: routes that take a file (audio to transcribe, an image to edit). */
   proxyRequestBytes: 1024 * 1024,
   /** Proxied JSON bodies for text, embeddings and image generation. */
   proxyTextRequestBytes: 256 * 1024,
@@ -264,7 +275,7 @@ var LIMITS = {
   errorReportsPerPage: 10,
   gameNameLength: 60,
   gameDescriptionLength: 1e3,
-  galleryItems: 10,
+  galleryItems: 5,
   mediaImageBytes: 5 * 1024 * 1024,
   mediaVideoBytes: 30 * 1024 * 1024,
   /** GIFs are served as they are (never resized), so they're small: at most this many bytes and pixels a side. */
@@ -273,7 +284,7 @@ var LIMITS = {
   /** Media an account uploads in the dashboard (or a repo owner's deploys add to game pages) in any 24 hours. */
   mediaUploadsPerDay: 200,
   mediaBytesPerDay: 500 * 1024 * 1024,
-  badgesPerGame: 100,
+  badgesPerGame: 50,
   /** The menu's "How to play": up to this many controls (each with a few keys and a short action), and a few lines of help. */
   controlHints: 12,
   controlHintKeys: 4,
@@ -287,6 +298,8 @@ var LIMITS = {
   gamesPerOwner: 50,
   /** New games per creator in any rolling 24-hour period. Redeploys do not count. */
   gamesCreatedPerCreatorPerDay: 3,
+  /** An account made with just a username (no email, Google or GitHub) can publish a new game by upload once it is this old. */
+  uploadAccountAgeMs: 7 * 24 * 60 * 6e4,
   deploysPerOwnerPerDay: 100,
   /** Finished versions retained per game, including its live version. */
   deploymentsKeptPerGame: 10,
@@ -294,6 +307,10 @@ var LIMITS = {
   /** Files listed by all of a repo owner's deploys in any 24 hours (each is a record to keep and clean up). */
   deployEntriesPerOwnerPerDay: 1e5,
   bioLength: 500,
+  /** Settings > Download my data: rows from any one table, the characters of saves, and how often an account may ask. */
+  exportRows: 2e3,
+  exportSaveChars: 4 * 1024 * 1024,
+  exportEveryMs: 60 * 6e4,
   friendsMax: 200,
   /** Requests one player has sent that are still waiting. */
   friendRequestsMax: 100,
@@ -417,10 +434,213 @@ function isValidDeployPath(path) {
 }
 var SLUG_RE = /^[a-z0-9](?:[a-z0-9-]{0,38}[a-z0-9])?$/;
 var RESERVED_SLUGS = /* @__PURE__ */ new Set(["www", "api", "play", "admin", "static", "assets", "docs", "status"]);
+var NEW_GAME_RESERVED_SLUGS = /* @__PURE__ */ new Set([
+  "star-party",
+  "login",
+  "log-in",
+  "logon",
+  "logout",
+  "signin",
+  "sign-in",
+  "signup",
+  "sign-up",
+  "register",
+  "auth",
+  "oauth",
+  "sso",
+  "verify",
+  "verified",
+  "verification",
+  "support",
+  "help",
+  "helpdesk",
+  "contact",
+  "official",
+  "staff",
+  "team",
+  "moderator",
+  "moderators",
+  "mod",
+  "mods",
+  "security",
+  "account",
+  "accounts",
+  "password",
+  "passwords",
+  "reset",
+  "billing",
+  "payment",
+  "payments",
+  "robux",
+  "vbucks",
+  "v-bucks",
+  "nitro",
+  "gift",
+  "gifts",
+  "giftcard",
+  "free",
+  "settings",
+  "dashboard",
+  "discover",
+  "games",
+  "users",
+  "friends",
+  "notifications",
+  "terms",
+  "privacy",
+  "changelog",
+  "create",
+  "guide",
+  "about",
+  "blog",
+  "news",
+  "mail",
+  "email"
+]);
+var NEW_GAME_RESERVED_PREFIXES = ["onceworlds", "admin", "free-"];
+var SLUG_AUTH_WORDS = /* @__PURE__ */ new Set(["login", "logon", "signin", "signon", "signup", "verify", "verification", "password", "passwords", "billing"]);
+var BRANDS = ["onceworlds", "roblox", "robux", "vbucks", "fortnite", "minecraft", "xbox", "playstation", "nintendo"];
+var LOOKALIKES = {
+  "0": "o",
+  "3": "e",
+  "4": "a",
+  "5": "s",
+  "7": "t",
+  "8": "b",
+  "@": "a",
+  "$": "s",
+  "|": "l",
+  "!": "i",
+  "\u0430": "a",
+  "\u0432": "b",
+  "\u0435": "e",
+  "\u043A": "k",
+  "\u043C": "m",
+  "\u043D": "h",
+  "\u043E": "o",
+  "\u0440": "p",
+  "\u0441": "c",
+  "\u0442": "t",
+  "\u0443": "y",
+  "\u0445": "x",
+  "\u0455": "s",
+  "\u0456": "i",
+  "\u0458": "j",
+  "\u04CF": "l",
+  "\u0501": "d",
+  "\u051D": "w",
+  "\u03B1": "a",
+  "\u03B2": "b",
+  "\u03B5": "e",
+  "\u03B9": "i",
+  "\u03BA": "k",
+  "\u03BD": "v",
+  "\u03BF": "o",
+  "\u03C1": "p",
+  "\u03C4": "t",
+  "\u03C5": "u",
+  "\u03C7": "x",
+  "\u03C9": "w"
+};
 function isValidSlug(slug) {
   return SLUG_RE.test(slug) && !slug.includes("--") && !RESERVED_SLUGS.has(slug);
 }
+function isReservedSlug(slug, newGame = true) {
+  if (RESERVED_SLUGS.has(slug)) return true;
+  if (!newGame) return false;
+  if (NEW_GAME_RESERVED_SLUGS.has(slug) || NEW_GAME_RESERVED_PREFIXES.some((prefix) => slug.startsWith(prefix))) return true;
+  if (!SLUG_RE.test(slug)) return false;
+  const parts = slug.split("-");
+  if (parts.some((part, i) => SLUG_AUTH_WORDS.has(part) || SLUG_AUTH_WORDS.has(part + (parts[i + 1] ?? "")))) return true;
+  return hasBrand(slug);
+}
+function foldedWords(text) {
+  const base = text.normalize("NFKD").toLowerCase().replace(/[\u0300-\u036f]/g, "");
+  const variants = [];
+  for (const one of ["l", "i"]) {
+    const mapped = [...base].map((c) => c === "1" ? one : LOOKALIKES[c] ?? c);
+    const words = mapped.map((c) => /[a-z]/.test(c) ? c : /[0-9]/.test(c) ? "" : " ").join("").split(" ").filter(Boolean);
+    variants.push(words, words.map((w) => w.replace(/vv/g, "w")));
+  }
+  return variants;
+}
+function hasBrand(text) {
+  for (const words of foldedWords(text)) {
+    if (words.some((word) => BRANDS.some((brand) => word.includes(brand)))) return true;
+    for (let i = 0; i < words.length; i++) {
+      let joined = words[i];
+      for (let j = i + 1; j < words.length && joined.length < 16; j++) {
+        joined += words[j];
+        if (BRANDS.includes(joined)) return true;
+      }
+    }
+  }
+  return false;
+}
 var DEFAULT_PRODUCTION_BRANCH = "main";
+function deployWorkflow() {
+  return `name: Deploy to Onceworlds
+
+# Branches only: tags don't deploy.
+on:
+  push:
+    branches: ['**']
+
+# A newer push to the same branch replaces a deploy still running.
+concurrency:
+  group: onceworlds-\${{ github.ref }}
+  cancel-in-progress: true
+
+permissions:
+  contents: read
+  id-token: write # lets the Onceworlds CLI prove which repo is deploying; no API keys needed
+
+jobs:
+  deploy:
+    runs-on: ubuntu-latest
+    steps:
+      # The build never needs the repo's GitHub token, so it isn't left in .git/config.
+      - uses: actions/checkout@v5
+        with:
+          persist-credentials: false
+
+      - uses: actions/setup-node@v5
+        with:
+          node-version: 22
+
+      - uses: oven-sh/setup-bun@0c5077e51419868618aeaa5fe8019c62421857d6 # v2.2.0
+        if: hashFiles('bun.lock', 'bun.lockb') != ''
+
+      # Only if package.json has a build script, with the package manager its lockfile belongs to.
+      - name: Build
+        run: |
+          if [ ! -f package.json ] || [ "$(npm pkg get scripts.build)" = "{}" ]; then
+            exit 0
+          elif [ -f pnpm-lock.yaml ]; then
+            corepack enable
+            pnpm install --frozen-lockfile
+            pnpm run build
+          elif [ -f yarn.lock ]; then
+            corepack enable
+            yarn install
+            yarn run build
+          elif [ -f bun.lock ] || [ -f bun.lockb ]; then
+            bun install
+            bun run build
+          elif [ -f package-lock.json ]; then
+            npm ci
+            npm run build
+          else
+            npm install
+            npm run build
+          fi
+
+      # Pushes to the production branch (set in the dashboard or onceworlds.json,
+      # default "main") go live; other branches get a preview URL in the job log.
+      - name: Deploy
+        run: npx --yes @onceworlds/cli@0 deploy
+`;
+}
 var BADGE_KEY_RE = /^[a-z0-9](?:[a-z0-9-]{0,38}[a-z0-9])?$/;
 var GENRES = [
   "Action",
@@ -521,10 +741,136 @@ function imageSizeProblem(slot, width, height) {
   return null;
 }
 
+// src/init.ts
+var OUTPUT_DIRS = ["dist", "build", "out", "public", "web", "www", "export"];
+var WORKFLOW_PATH = ".github/workflows/onceworlds.yml";
+async function init(dir, options) {
+  const log = options.log ?? console.log;
+  const { force } = options;
+  const at = (path) => join(dir, path);
+  const read = (path) => readFile(at(path), "utf8").catch(() => null);
+  const exists = (path) => stat(at(path)).then(() => true, () => false);
+  const lines = [];
+  let kept = false;
+  const put = async (path, content, label = path) => {
+    try {
+      await mkdir(dirname(at(path)), { recursive: true });
+      await writeFile(at(path), content, { flag: force ? "w" : "wx" });
+      lines.push(`  wrote  ${label}`);
+    } catch (err) {
+      if (err.code !== "EEXIST") throw err;
+      lines.push(`  kept   ${path} (it exists already)`);
+      kept = true;
+    }
+  };
+  const append = async (path, existing, line, label) => {
+    await writeFile(at(path), `${existing.trimEnd()}
+
+${line}
+`);
+    lines.push(`  wrote  ${label}`);
+  };
+  const pkg = await readPackage(dir);
+  const source = typeof pkg?.name === "string" && pkg.name.replace(/^@[^/]+\//, "") || basename(dir);
+  const fromName = slugFrom(source);
+  const slug = fromName ?? `game-${randomBytes(3).toString("hex")}`;
+  const found = await findDir(pkg, exists);
+  const branch = defaultBranch(dir);
+  const config = { slug, name: titleFrom(source), description: "", dir: found.dir, ...branch ? { productionBranch: branch } : {} };
+  await put("onceworlds.json", `${JSON.stringify(config, null, 2)}
+`, `onceworlds.json (link "${slug}", publishing "${found.dir}")`);
+  const present = await findWorkflow(dir);
+  if (present && present !== WORKFLOW_PATH) lines.push(`  kept   ${present} (it already deploys with the Onceworlds CLI)`);
+  else await put(WORKFLOW_PATH, deployWorkflow());
+  const guide = await fetchGuide(options.fetch ?? fetch, options.api, (line) => lines.push(line));
+  const agents = await read("AGENTS.md");
+  const separate = agents !== null && !/^# Onceworlds\b/.test(agents);
+  const guidePath = separate ? "ONCEWORLDS.md" : "AGENTS.md";
+  if (guide !== null) await put(guidePath, guide);
+  if (guide !== null || await exists(guidePath)) {
+    if (separate && !agents.includes("ONCEWORLDS.md")) {
+      await append("AGENTS.md", agents, "## Onceworlds\n\nThis game is published on Onceworlds. Read ONCEWORLDS.md for the platform rules and SDK.", "AGENTS.md (a pointer to ONCEWORLDS.md)");
+    }
+    const claude = await read("CLAUDE.md");
+    if (claude === null) await put("CLAUDE.md", `@${guidePath}
+`);
+    else if (!claude.includes(guidePath)) await append("CLAUDE.md", claude, `@${guidePath}`, `CLAUDE.md (a pointer to ${guidePath})`);
+  }
+  for (const line of lines) log(line);
+  if (fromName === null) log(`  note   "${source}" can't be a game's link, so the link is ${slug}. Change slug in onceworlds.json.`);
+  if (found.note) log(`  note   ${found.note}`);
+  if (kept) log("  note   --force replaces the files init writes. Your own AGENTS.md and CLAUDE.md are never replaced.");
+  log(`
+Next:
+  1. Check onceworlds.json: "slug" is your game's link (onceworlds.com/play/<slug>) and "name" is its title.
+  2. Commit these files and push the repo to GitHub.
+  3. Open ${options.api}/dashboard/new, import the repo, and every push publishes your game.`);
+}
+async function readPackage(dir) {
+  try {
+    const parsed = JSON.parse(await readFile(join(dir, "package.json"), "utf8"));
+    return parsed && typeof parsed === "object" ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+function slugFrom(name) {
+  const slug = name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 40).replace(/-+$/, "");
+  return isValidSlug(slug) && !isReservedSlug(slug) ? slug : null;
+}
+function titleFrom(name) {
+  const title = name.replace(/[-_.]+/g, " ").trim().replace(/\s+/g, " ").replace(/\b\w/g, (c) => c.toUpperCase());
+  return (title || "My Game").slice(0, LIMITS.gameNameLength);
+}
+async function findDir(pkg, exists) {
+  if (typeof pkg?.scripts?.build === "string") {
+    const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+    const out = deps.next ? "out" : deps["react-scripts"] || deps["@sveltejs/kit"] ? "build" : "dist";
+    return { dir: out, note: `"dir" is ${out}, where the build script is expected to write the game. Change it in onceworlds.json if yours writes elsewhere.` };
+  }
+  if (await exists("index.html")) return { dir: "." };
+  for (const name of OUTPUT_DIRS) if (await exists(`${name}/index.html`)) return { dir: name };
+  return { dir: ".", note: `No index.html here yet. Set "dir" in onceworlds.json to the folder that has your game's index.html.` };
+}
+function defaultBranch(dir) {
+  const git = (args) => {
+    try {
+      return execFileSync("git", args, { cwd: dir, stdio: ["ignore", "pipe", "ignore"] }).toString().trim() || null;
+    } catch {
+      return null;
+    }
+  };
+  return git(["symbolic-ref", "-q", "--short", "refs/remotes/origin/HEAD"])?.replace(/^origin\//, "") ?? git(["symbolic-ref", "-q", "--short", "HEAD"]);
+}
+async function findWorkflow(dir) {
+  const folder = join(dir, ".github/workflows");
+  const names = await readdir(folder).catch(() => []);
+  for (const name of names.filter((n) => /\.ya?ml$/.test(n)).slice(0, 20)) {
+    if ((await readFile(join(folder, name), "utf8").catch(() => "")).includes("@onceworlds/cli")) return `.github/workflows/${name}`;
+  }
+  return null;
+}
+async function fetchGuide(fetcher, api, warn) {
+  const url = `${api}/agents.md`;
+  let problem;
+  try {
+    const res = await fetcher(url, { signal: AbortSignal.timeout(1e4) });
+    const text = res.ok ? await res.text() : "";
+    if (text.trim()) return text;
+    problem = res.ok ? "it is empty" : `${res.status}`;
+  } catch (err) {
+    problem = err instanceof Error ? err.message : String(err);
+  }
+  warn(`  ! Skipped AGENTS.md and CLAUDE.md: could not fetch ${url} (${problem}). Run init again when it works.`);
+  return null;
+}
+
 // src/index.ts
 var PRODUCTION_API = "https://onceworlds.com";
 var LOCAL_API = "http://localhost:8787";
 var USAGE = `Usage:
+  onceworlds init [project-dir]     Set a game folder up for Onceworlds: writes onceworlds.json, the GitHub workflow
+                                    that publishes every push, and AGENTS.md and CLAUDE.md for AI coding tools
   onceworlds deploy [project-dir]   Upload the game and publish it (to ${PRODUCTION_API})
   onceworlds dev [project-dir]      Deploy to a local platform (${LOCAL_API}), then redeploy on every change
   onceworlds doctor [project-dir]   Look for what games often ship with: no viewport tag, small text fields,
@@ -536,6 +882,8 @@ Options:
   --token <t>     Local platform's deploy token (default: "dev")
   --players <n>   dev: also print links for players 2 to n, to play a multiplayer game with yourself
   --strict        doctor: exit with an error when it finds a likely bug (not for notes)
+  --force         init: replace onceworlds.json, the workflow and the guide when they exist already
+                  (never your own AGENTS.md or CLAUDE.md)
 
 Deploys to onceworlds.com run from GitHub Actions: the repo's Onceworlds
 workflow runs this on every push, and GitHub vouches for the repo.
@@ -555,6 +903,7 @@ async function main() {
       token: { type: "string" },
       players: { type: "string" },
       strict: { type: "boolean" },
+      force: { type: "boolean" },
       help: { type: "boolean", short: "h" }
     }
   });
@@ -565,7 +914,10 @@ async function main() {
   }
   const projectDir = resolve(projectArg ?? ".");
   const api = (values.api ?? process.env.ONCEWORLDS_API ?? (command === "dev" ? LOCAL_API : PRODUCTION_API)).replace(/\/+$/, "");
-  if (command === "deploy") {
+  if (command === "init") {
+    if (!(await stat2(projectDir).catch(() => null))?.isDirectory()) throw new CliError(`${projectDir} isn't a folder.`);
+    await init(projectDir, { api, force: values.force === true });
+  } else if (command === "deploy") {
     await deploy(projectDir, api, values.token);
   } else if (command === "dev") {
     const players = Number(values.players ?? 1);
@@ -618,7 +970,7 @@ async function deploy(projectDir, api, tokenArg, quiet = false) {
     console.log(`  \u2191 uploading ${uploads.length} changed file(s), ${formatBytes(uploads.reduce((s, f) => s + f.size, 0))}`);
   }
   await runPool(uploads, 6, async (file) => {
-    const body = await readFile(file.abs);
+    const body = await readFile2(file.abs);
     await send("PUT", `${api}/api/deploy/${start.deploymentId}/blobs/${file.hash}`, start.uploadToken, body);
   });
   const result = await send("POST", `${api}/api/deploy/${start.deploymentId}/finalize`, start.uploadToken, {});
@@ -639,7 +991,7 @@ async function dev(projectDir, api, tokenArg, players = 1) {
   for (let n = 2; n <= players; n++) console.log(`  Player ${n}: ${first.playUrl}?player=${n}&watch`);
   console.log(`  Watching ${root}. Press Ctrl+C to stop.
 `);
-  const projectSignature = async () => signature((await collectFiles(root)).files) + await readFile(join(projectDir, "onceworlds.json"), "utf8").catch(() => "");
+  const projectSignature = async () => signature((await collectFiles(root)).files) + await readFile2(join2(projectDir, "onceworlds.json"), "utf8").catch(() => "");
   let lastSignature = await projectSignature();
   let timer;
   let running = false;
@@ -682,7 +1034,7 @@ async function readSources(files) {
   const sources = [];
   for (const file of files) {
     if (!/\.(html?|m?js|css)$/i.test(file.path) || file.size > 15e5) continue;
-    sources.push({ path: file.path, text: await readFile(file.abs, "utf8") });
+    sources.push({ path: file.path, text: await readFile2(file.abs, "utf8") });
   }
   return sources;
 }
@@ -704,10 +1056,10 @@ ${warnings} likely problem${warnings === 1 ? "" : "s"}, ${findings.length - warn
   if (strict && warnings > 0) process.exitCode = 1;
 }
 async function loadConfig(projectDir) {
-  const file = join(projectDir, "onceworlds.json");
+  const file = join2(projectDir, "onceworlds.json");
   let config;
   try {
-    config = JSON.parse(await readFile(file, "utf8"));
+    config = JSON.parse(await readFile2(file, "utf8"));
   } catch (err) {
     const missing = err.code === "ENOENT";
     throw new CliError(missing ? `No onceworlds.json in ${projectDir}.
@@ -728,7 +1080,7 @@ async function loadStore(projectDir, config) {
     if (!abs.startsWith(projectDir + sep)) throw new CliError(`"${field}" in onceworlds.json (${value}) must be inside the project folder.`);
     let data;
     try {
-      data = await readFile(abs);
+      data = await readFile2(abs);
     } catch {
       throw new CliError(`"${field}" in onceworlds.json: ${value} doesn't exist.`);
     }
@@ -792,13 +1144,13 @@ async function collectFiles(root) {
   async function walk(dir, prefix) {
     let entries;
     try {
-      entries = await readdir(dir, { withFileTypes: true });
+      entries = await readdir2(dir, { withFileTypes: true });
     } catch {
       throw new CliError(`Cannot read ${dir}. Check "dir" in onceworlds.json.`);
     }
     for (const entry of entries.sort((a, b) => a.name.localeCompare(b.name))) {
       if (entry.name.startsWith(".") || QUIET_SKIPS.has(entry.name)) continue;
-      const abs = join(dir, entry.name);
+      const abs = join2(dir, entry.name);
       const path = prefix + entry.name;
       if (entry.isDirectory()) {
         await walk(abs, `${path}/`);
@@ -807,7 +1159,7 @@ async function collectFiles(root) {
           if (!QUIET_EXTENSIONS.has(extensionOf(path))) skipped.push(path);
           continue;
         }
-        const data = await readFile(abs);
+        const data = await readFile2(abs);
         if (data.byteLength > LIMITS.deployFileBytes) {
           throw new CliError(`${path} is ${formatBytes(data.byteLength)}; files can be at most ${formatBytes(LIMITS.deployFileBytes)}.`);
         }
@@ -825,7 +1177,7 @@ function signature(files) {
 function gitInfo(cwd) {
   const run = (args) => {
     try {
-      return execFileSync("git", args, { cwd, stdio: ["ignore", "pipe", "ignore"] }).toString().trim() || void 0;
+      return execFileSync2("git", args, { cwd, stdio: ["ignore", "pipe", "ignore"] }).toString().trim() || void 0;
     } catch {
       return void 0;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onceworlds/cli",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "description": "Deploy games to Onceworlds.",
   "homepage": "https://onceworlds.com",
   "type": "module",