@xgamesfun/xcore 0.1.0 → 0.2.1

package/commands/files.mjs

@@ -0,0 +1,106 @@
+// `xcore files ls|put|get|rm|usage`: the game's project files (env.GF.files), on this machine (the ones `xcore dev`
+// serves) or, with --live, on xgames.fun (../lib/files.mjs).
+import { existsSync } from 'node:fs';
+import { writeFile } from 'node:fs/promises';
+import path from 'node:path';
+import { guard, parse, printJson, UsageError } from '../lib/cli.mjs';
+import { named, resolveGame } from '../lib/games.mjs';
+import { filesGet, filesList, filesPut, filesRemove, filesUsage } from '../lib/files.mjs';
+import { CMD } from '../lib/command.mjs';
+
+const usage = `Usage: xcore files ls [prefix/] [--dir <game>] [--live] [--json]
+       xcore files put <file> [path] [--public] [--type <mime>] [--dir <game>] [--live] [--json]
+       xcore files get <path> [--out <file>] [--force] [--dir <game>] [--live] [--json]
+       xcore files rm <path> [--dir <game>] [--live] [--json]
+       xcore files usage [--dir <game>] [--live] [--json]
+
+The game's project files: files you or the game's server write, never players (replays, generated levels, content
+packs, a large saved world). The server reads and writes them with env.GF.files (docs/SERVER.md, "Project files").
+Without --live, the ones on this machine that ${CMD} dev gives the server (kept in .gamesfun/dev/files/, never
+published); with --live, the game's files on xgames.fun (each call kept in the game's audit log).
+  ls [prefix/]       the files, or those in one folder ("replays/")
+  put <file> [path]  a file from this machine, at [path] (default: its name). --public serves it at
+                     https://<slug>.xgamesusercontent.com/<path>, another site (here: the files origin xcore dev
+                     prints); without it only the game's server reads it. Up to 25 MB a file
+  get <path>         a file's bytes, into --out <file> (default: its name here; --force writes over one)
+  rm <path>          delete one
+  usage              the bytes kept, against the game's cap (Free: 100 MB)
+A path is letters, digits, . _ and -, with / between folders: levels/forest-3.json.
+--dir <game> names the game's folder (default: the one you are in).`;
+
+const mb = n =>
+  n >= 1048576 ? `${(n / 1048576).toFixed(1)} MB` : n >= 1024 ? `${(n / 1024).toFixed(1)} KB` : `${n} bytes`;
+
+export default {
+  name: 'files',
+  summary: "the game's project files (env.GF.files): ls, put, get, rm, usage; here, or --live on xgames.fun",
+  usage,
+  run: args =>
+    guard(async () => {
+      const { values, positionals } = parse(
+        args,
+        {
+          live: { type: 'boolean' },
+          public: { type: 'boolean' },
+          type: { type: 'string' },
+          out: { type: 'string' },
+          force: { type: 'boolean' },
+          dir: { type: 'string' },
+        },
+        usage,
+      );
+      const [verb, a, b] = positionals;
+      if (!['ls', 'put', 'get', 'rm', 'usage'].includes(verb)) throw new UsageError(usage);
+      if (['put', 'get', 'rm'].includes(verb) && !a)
+        throw new UsageError(`${verb} needs ${verb === 'put' ? 'a file' : 'a path'}\n\n${usage}`);
+      const dir = await resolveGame(values.dir);
+      const live = !!values.live;
+      const where = live ? 'on xgames.fun' : 'on this machine';
+      const json = values.json ? printJson : null;
+
+      if (verb === 'ls') {
+        const r = await filesList(dir, { live, prefix: a ?? '' });
+        if (json) return json(r);
+        if (!r.items.length) console.log(`${named(dir)} has no project files ${where}${a ? ` in ${a}` : ''}.`);
+        for (const f of r.items)
+          console.log(`${f.public ? 'public ' : 'private'}  ${mb(f.bytes).padStart(9)}  ${f.path}  (${f.type})`);
+        if (r.after) console.log(`… more after ${r.after}`);
+        return 0;
+      }
+      if (verb === 'put') {
+        const r = await filesPut(dir, a, b ?? null, { live, isPublic: !!values.public, type: values.type ?? null });
+        if (json) return json(r);
+        console.log(
+          `Put ${r.path} ${where} (${mb(r.bytes)}${values.public ? ', public' : ', only the game’s server reads it'}).${r.url ? `\n  ${r.url}` : values.public && !live ? `\n  served at the files origin ${CMD} dev prints, /${r.path}` : ''}`,
+        );
+        return 0;
+      }
+      if (verb === 'get') {
+        const r = await filesGet(dir, a, { live });
+        const out = path.resolve(values.out ?? path.basename(a));
+        if (json && !values.out) {
+          const { body, ...facts } = r;
+          return json({ ...facts, base64: body.toString('base64') });
+        }
+        if (existsSync(out) && !values.force)
+          throw new UsageError(`${out} is there already: --force writes over it, or --out <file>\n\n${usage}`);
+        await writeFile(out, r.body);
+        const { body: _body, ...facts } = r;
+        if (json) return json({ ...facts, file: out });
+        console.log(`Got ${r.path} from ${where} (${mb(r.bytes)}, ${r.type}) into ${out}.`);
+        return 0;
+      }
+      if (verb === 'rm') {
+        const r = await filesRemove(dir, a, { live });
+        if (json) return json(r);
+        console.log(r.deleted ? `Deleted ${a} ${where}.` : `${a} was not there ${where}.`);
+        return 0;
+      }
+      const r = await filesUsage(dir, { live });
+      if (json) return json(r);
+      console.log(
+        `${named(dir)}'s project files ${where}: ${r.files} file${r.files === 1 ? '' : 's'}, ${mb(r.bytes)} of ${mb(r.cap)}.`,
+      );
+      return 0;
+    }, args),
+};

package/commands/login.mjs

@@ -1,39 +1,31 @@
 import { createInterface } from 'node:readline/promises';
 import { guard, parse, printJson } from '../lib/cli.mjs';
 import { openUrl } from '../lib/open.mjs';
-import { login, savedLogin, studioOrigin } from '../lib/publish/client.mjs';
+import { login, signInState, storeWords, studioOrigin } from '../lib/publish/client.mjs';
 import { storeName } from '../lib/credentials.mjs';
 import { CMD } from '../lib/command.mjs';
 
 const usage = `Usage: xcore login [--code] [--status] [--json]
 
-Sign in to games.fun so you can publish your games (${CMD} publish). Your browser opens games.fun: sign in
+Sign in to xgames.fun so you can publish your games (${CMD} publish). Your browser opens xgames.fun: sign in
 there and approve this computer. xcore never sees your password; it keeps a publish token for 30 days in
 ${storeName()} (never in a game or in this folder). ${CMD} logout ends it.
   --code     no browser on this machine (SSH, a container): open the printed link anywhere and paste the code it shows
   --status   who this computer is signed in as, and where the token is kept
-GAMESFUN_STUDIO=<origin> signs in to another games.fun (a local Studio while developing).`;
+GAMESFUN_STUDIO=<origin> signs in to another xgames.fun (a local Studio while developing).`;
 
 export default {
   name: 'login',
-  summary: 'sign in to games.fun so you can publish your games',
+  summary: 'sign in to xgames.fun so you can publish your games',
   usage,
   run: args =>
     guard(async () => {
       const { values } = parse(args, { code: { type: 'boolean' }, status: { type: 'boolean' } }, usage);
       const origin = studioOrigin();
       if (values.status) {
-        const s = await savedLogin(origin);
-        const out = s
-          ? { studio: origin, email: s.email, expiresAt: s.expiresAt, store: s.store }
-          : { studio: origin, signedIn: false };
-        if (values.json) printJson(out);
-        else
-          console.log(
-            s
-              ? `Signed in to ${origin} as ${s.email} until ${s.expiresAt} (token in ${s.store === 'file' ? 'a file only you can read' : s.store}).`
-              : `Not signed in to ${origin}. Run: ${CMD} login`,
-          );
+        const { token: _token, words, ...s } = await signInState(origin);
+        if (values.json) printJson({ ...s, signedIn: s.state === 'signed-in' });
+        else console.log(s.state === 'signed-in' ? words : `${words} Run: ${s.next}`);
         return 0;
       }
       const rl = values.code ? createInterface({ input: process.stdin, output: process.stderr }) : null;
@@ -48,11 +40,11 @@ export default {
         if (values.json) printJson({ studio: origin, ...r });
         else
           console.log(
-            `Signed in to ${origin} as ${r.email}. The token is kept in ${r.store === 'file' ? 'a file only you can read' : r.store === 'dpapi' ? 'a file encrypted for your Windows user' : r.store === 'keychain' ? 'the macOS keychain' : 'the Secret Service'} until ${new Date(r.expiresAt).toISOString().slice(0, 10)}. Next: ${CMD} publish`,
+            `Signed in to ${origin} as ${r.email}. The token is kept in ${storeWords(r.store)} until ${new Date(r.expiresAt).toISOString().slice(0, 10)}. Next: ${CMD} publish`,
           );
         return 0;
       } finally {
         rl?.close();
       }
-    }),
+    }, args),
 };

package/commands/logout.mjs

@@ -3,12 +3,23 @@ import { logout, studioOrigin } from '../lib/publish/client.mjs';
 
 const usage = `Usage: xcore logout [--json]
 
-Sign this computer out of games.fun: the publish token is revoked at games.fun and forgotten on this computer. Your
+Sign this computer out of xgames.fun: the publish token is revoked at xgames.fun and forgotten on this computer. Your
 published games stay published.`;
 
+// signed out here, but not revoked at xgames.fun: why, and whether anything is left to do
+const NOT_REVOKED = {
+  ended: o => `Signed out of ${o}; its token had already ended there (expired or revoked).`,
+  unreadable: o =>
+    `Forgot the sign-in on this computer, but this session could not read its token (it is kept where this session cannot reach, such as the Secret Service over SSH), so it was not revoked at ${o}. It ends by itself when it expires; revoke it from xgames.fun if you need it gone sooner.`,
+  offline: o =>
+    `Forgot the token on this computer, but ${o} did not answer, so it may still be live until it expires; revoke it from xgames.fun if you need to.`,
+  refused: o =>
+    `Forgot the token on this computer, but ${o} did not revoke it, so it may still be live until it expires; revoke it from xgames.fun if you need to.`,
+};
+
 export default {
   name: 'logout',
-  summary: 'sign this computer out of games.fun (revokes its publish token)',
+  summary: 'sign this computer out of xgames.fun (revokes its publish token)',
   usage,
   run: args =>
     guard(async () => {
@@ -22,8 +33,8 @@ export default {
             ? `This computer was not signed in to ${origin}.`
             : r.revoked
               ? `Signed out of ${origin}; the token is revoked.`
-              : `Forgot the token on this computer, but ${origin} did not answer, so it may still be live until it expires; revoke it from games.fun if you need to.`,
+              : NOT_REVOKED[r.why](origin),
         );
       return 0;
-    }),
+    }, args),
 };

package/commands/loot.mjs

@@ -25,7 +25,7 @@ A game's economy on loot, one shared Solana program (devnet only until it is aud
   xcore loot help                  everything else xsolana does (its help says \`xsolana <command>\`: run each as
                                    \`xcore loot <command>\`)
 The file is ${ECONOMY_FILE} (loot.json in a game made before it was named so). Its RPC is XSOLANA_RPC_URL (in .env),
-else games.fun's shared devnet RPC. Published, the page uses the shared relay, which counts every call toward the game's
+else xgames.fun's shared devnet RPC. Published, the page uses the shared relay, which counts every call toward the game's
 plan, unless the game brings its own RPC: ${CMD} add rpc (docs/SERVER.md, "The economy's own RPC").`;
 
 const ADD_USAGE = `Usage: xcore loot add [game] [--json]
@@ -62,7 +62,7 @@ export default {
         );
         for (const s of r.steps) console.log(`  - ${s}`);
         return 0;
-      });
+      }, args);
     const xsolana = solanaCommand();
     if (!xsolana) {
       console.error(

package/commands/plan.mjs

@@ -1,4 +1,4 @@
-// `xcore plan`: a game's backend plan on games.fun (../lib/publish/plans.mjs).
+// `xcore plan`: a game's backend plan on xgames.fun (../lib/publish/plans.mjs).
 import { guard, parse, printJson, UsageError } from '../lib/cli.mjs';
 import { resolveGame } from '../lib/games.mjs';
 import { accountPlan, describeAccount, describeGame, gamePlan, setActive } from '../lib/publish/plans.mjs';
@@ -9,24 +9,25 @@ const usage = `Usage: xcore plan [dir] [--json]
        xcore plan activate [dir] [--json]
        xcore plan deactivate [dir] [--json]
 
-What a game's backend may use on games.fun (its server, saves and scores), and what it used this month.
+What a game's backend may use on xgames.fun (its server, saves and scores), and what it used this month.
   Free       every game, by default: a small server (50 ms of CPU a request, 600 requests a minute) and $1 of use a
              month; past that its server is capped (slow) until the month ends
-  Creator    a game in one of your paid game slots: 200 ms a request, 6,000 requests a minute, 1 GB of saves, and
-             $10 of use a month per slot, shared by your Creator games
-  Scale      granted by games.fun for a game that needs more
+  Creator    a game in one of your paid slots: 200 ms a request, 6,000 requests a minute, 1 GB of saves, and
+             $10 of use a month per paid slot, shared by your Creator games
+  Scale      granted by xgames.fun for a game that needs more
 Every plan lets sites of yours embed the game (Free 3, Creator 10, Scale 25: ${CMD} embed); Creator and Scale serve
 it on domains of your own (1 and 5: ${CMD} domain).
-A slot is $15 for 30 days, prepaid in SOL or USDC on games.fun (Studio → Plans; no automatic renewal), and moves
-between your games at any time without changing the bill. Usage credit, bought the same way, lets Creator games go
-past what their slots include (at twice what games.fun pays) instead of slowing down.
-  activate     put this folder's game in a free slot
-  deactivate   take it out (it goes back to Free and the slot is free for another game)
-  --all        your slots and every game's plan`;
+Every game sits in a slot. Everyone gets 2 free slots, whose games run on Free; any more games need a paid slot,
+$15 for 30 days, prepaid in SOL or USDC on xgames.fun (your console → Plans; no automatic renewal), whose game runs on
+Creator. A paid slot moves between your games at any time without changing the bill. Usage credit, bought the same way,
+lets Creator games go past what their slots include (at twice what xgames.fun pays) instead of slowing down.
+  activate     move this folder's game to a paid slot (its free slot opens for another game)
+  deactivate   move it back to a free slot (one must be open; its paid slot opens for another game)
+  --all        your free and paid slots and every game's plan`;
 
 export default {
   name: 'plan',
-  summary: "a game's backend plan on games.fun (Free, Creator, Scale): its limits, this month's use, game slots",
+  summary: "a game's backend plan on xgames.fun (Free, Creator, Scale): its limits, this month's use, game slots",
   usage,
   run: args =>
     guard(async () => {
@@ -37,7 +38,7 @@ export default {
       const out = values.json ? printJson : null;
       const plain = e => {
         if (e?.status === 404)
-          throw new Error(`this games.fun does not offer plans yet (${CMD} plan needs a newer games.fun).`);
+          throw new Error(`this xgames.fun does not offer plans yet (${CMD} plan needs a newer xgames.fun).`);
         throw e;
       };
       if (values.all) {
@@ -57,7 +58,9 @@ export default {
       const r = await setActive(dir, verb === 'activate').catch(e => {
         if (e?.status === 409)
           throw new Error(
-            `${e.message} Free one with ${CMD} plan deactivate <another game>, or buy a slot on games.fun (Studio → Plans, in SOL or USDC).`,
+            e.code === 'no-free-slot'
+              ? `${e.message} Archive a game you no longer need on your console (xgames.fun/console), or move another game to a paid slot.`
+              : `${e.message} Open one with ${CMD} plan deactivate <another game>, or buy a paid slot on xgames.fun (your console → Plans, in SOL or USDC).`,
           );
         return plain(e);
       });
@@ -66,13 +69,13 @@ export default {
         const what =
           verb === 'activate'
             ? r.changed
-              ? 'In a slot: Creator from its next request.'
-              : 'Already in a slot.'
+              ? 'In a paid slot: Creator from its next request; its free slot is open for another game.'
+              : 'Already in a paid slot.'
             : r.changed
-              ? 'Out of its slot: Free from its next request, and the slot is free.'
-              : 'It was not in a slot.';
+              ? 'Back in a free slot: Free from its next request, and its paid slot is open for another game.'
+              : 'It was not in a paid slot.';
         console.log(`${what}\n${describeGame(r)}`);
       }
       return 0;
-    }),
+    }, args),
 };

package/commands/publish.mjs

@@ -1,4 +1,4 @@
-// `xcore publish`: a game to games.fun at a link anyone can play (../lib/publish/index.mjs). publishCommand makes the
+// `xcore publish`: a game to xgames.fun at a link anyone can play (../lib/publish/index.mjs). publishCommand makes the
 // command: this package's own, which checks a game by the page check, and the kit's (@xgamesfun/kit), which passes its
 // six gates, its name, its upkeep and its own way of finding a game. A game the kit made goes to the kit's (../bin).
 import { guard, parse, printJson } from '../lib/cli.mjs';
@@ -11,27 +11,27 @@ import { CMD } from '../lib/command.mjs';
 
 const usage = `Usage: xcore publish [dir] [--draft] [--new] [--title <name>] [--status] [--check [--verify [--port <n>]]] [--json]
 
-Put a game on games.fun at a link anyone can play: games.fun hosts it, you need no server. Sign in first
+Put a game on xgames.fun at a link anyone can play: xgames.fun hosts it, you need no server. Sign in first
 (${CMD} login). The game's checks gate it: they must pass on the files you publish (they run now unless nothing
 changed since they last passed; a game you brought: the page check, a game the kit made: its six gates). A game whose
 checks fail goes up as a private draft only, and you are told which checks failed. Files that look like keys, .env
 files and links refuse it; evidence/, hidden files and the makers' notes at the top (README.md, NOTES.md, LAUNCH.md…)
-are left out. Only files games.fun does not have yet are uploaded. The link is unlisted: only people you give it to
+are left out. Only files xgames.fun does not have yet are uploaded. The link is unlisted: only people you give it to
 find it. Publishing the same folder again makes a new version at the same link. A game with its own server code
-(server/, a gf-server-v1 Worker) sends it bundled as one file, when games.fun takes server code; server/ is never a
+(server/, a gf-server-v1 Worker) sends it bundled as one file, when xgames.fun takes server code; server/ is never a
 public file.
 In a GitHub Actions job with permissions id-token: write, the job's own OIDC token signs it in place of a login.
 A brought game (${CMD} adopt) is built first when it has a build; its published folder (gamesfun.json page.out)
 goes up, with its server/ bundle when it has one.
-  --draft        a private version in your games.fun Studio, no public link
+  --draft        a private version in your xgames.fun Studio, no public link
   --new          publish as a new game (a new link), not an update of this folder's game
-  --title <name> the game's name on games.fun (default: its title)
+  --title <name> the game's name on xgames.fun (default: its title)
   --status       this folder's link and the account it is published from; publishes nothing
   --check        the offline checks only (files, secrets, backend origins, the server bundle); publishes nothing
   --verify       with --check: also run the publish gate's checks on these files and remember a pass, so the
                  publish after it does not run them again (the GitHub Action's check step)
   --port <n>     with --verify: the port its page check serves on (default: any free one)
-GAMESFUN_STUDIO=<origin> publishes to another games.fun (a local Studio while developing).`;
+GAMESFUN_STUDIO=<origin> publishes to another xgames.fun (a local Studio while developing).`;
 
 /**
  * The publish command. check, label, prepare, rpcFile: as publishGame takes them (the kit's six gates, its name, its
@@ -49,7 +49,7 @@ export function publishCommand({
   const own = { check, label, ...(prepare ? { prepare } : {}), ...(rpcFile ? { rpcFile } : {}) };
   return {
     name: 'publish',
-    summary: 'put a game on games.fun at a link anyone can play (unlisted)',
+    summary: 'put a game on xgames.fun at a link anyone can play (unlisted)',
     usage,
     run: args =>
       guard(async () => {
@@ -75,7 +75,13 @@ export function publishCommand({
             console.log(
               s.signedIn
                 ? `Signed in to ${origin} as ${s.signedIn.email ?? s.signedIn.as}.`
-                : `Not signed in to ${origin} (${CMD} login).`,
+                : s.signIn.oidcError
+                  ? `GitHub's OIDC token could not be had: ${s.signIn.oidcError}`
+                  : s.signIn.state === 'expired'
+                    ? `The sign-in to ${origin} ended on ${String(s.signIn.expiresAt).slice(0, 10)} (${CMD} login).`
+                    : s.signIn.state === 'unreadable'
+                      ? `Signed in to ${origin} as ${s.signIn.email}, but this session cannot read the token (${CMD} login here).`
+                      : `Not signed in to ${origin} (${CMD} login).`,
             );
             console.log(statusLine(named(dir), origin, s));
           }
@@ -126,6 +132,16 @@ export function publishCommand({
           newGame: values.new,
           title: values.title ?? null,
           progress: values.json ? () => {} : l => console.error(l),
+        }).catch(e => {
+          // A new game needs one of the account's 2 free slots (xgames.fun's words say so); name the commands that free one.
+          if (e?.code === 'no-free-slot')
+            throw Object.assign(
+              new Error(
+                `${e.message}\n  ${CMD} plan activate <another game's folder>   moves that game to a paid slot\n  ${CMD} plan --all   your slots and games; archive one on ${origin}/console`,
+              ),
+              { status: e.status, code: e.code },
+            );
+          throw e;
         });
         if (values.json) printJson(r);
         else
@@ -136,7 +152,7 @@ export function publishCommand({
             ).join('\n'),
           );
         return r.url || values.draft ? 0 : 1;
-      }),
+      }, args),
   };
 }
 
@@ -148,20 +164,30 @@ const failedNames = failed => failed.map(c => `${c.n} ${c.name}`).join('; ');
 
 /** `publish --status`: where this folder's game is published, and whether it is live. */
 function statusLine(where, origin, s) {
-  if (!s.known) return `${where} has not been published to ${origin} yet.`;
-  const at = s.known.url ? `published at ${s.known.url}` : 'a private draft';
   let live = '';
-  if (s.live?.error) live = ` games.fun says: ${s.live.error}`;
+  if (s.live?.error) live = ` xgames.fun says: ${s.live.error}`;
   else if (s.live) live = s.live.published ? ` Live: version ${s.live.version?.number}.` : ' Not live now.';
-  const own = s.known.gameUrl ? `\n  the game itself: ${s.known.gameUrl}` : '';
-  return `${where} is ${at} (version ${s.known.lastVersion}).${live}${own}`;
+  const own = s.known?.gameUrl ? `\n  the game itself: ${s.known.gameUrl}` : '';
+  const v = s.known?.lastVersion;
+  switch (s.link) {
+    case 'never':
+      return `${where} has not been published to ${origin} yet.`;
+    case 'started':
+      return `${where} was started on ${origin}, but no version finished going up. Run ${CMD} publish again: it goes on with the same game.${live}`;
+    case 'draft':
+      return `${where} is a private draft (version ${v}).${live}${own}`;
+    case 'draft-over-public':
+      return `${where} is published at ${s.known.url}; its latest version (${v}) is a private draft, so an earlier version is the one playing.${live}${own}`;
+    default:
+      return `${where} is published at ${s.known.url} (version ${v}).${live}${own}`;
+  }
 }
 
 /** `publish --check` when nothing is refused: what goes up, and the server bundle when there is one. */
 function checkLines(where, out, p) {
   const talks = p.backend.length ? ` It may talk to: ${p.backend.join(', ')}.` : '';
   const lines = [
-    `${where}: ${out.files} files${out.added?.length ? ` (with the ${plural(out.added.length, 'record')} games.fun keeps: ${out.added.join(', ')})` : ''}, ${(out.bytes / 1048576).toFixed(1)} MB, nothing refused.${talks} ` +
+    `${where}: ${out.files} files${out.added?.length ? ` (with the ${plural(out.added.length, 'record')} xgames.fun keeps: ${out.added.join(', ')})` : ''}, ${(out.bytes / 1048576).toFixed(1)} MB, nothing refused.${talks} ` +
       `Left out: ${out.skipped.join(', ') || 'nothing'}.`,
   ];
   const sv = out.server;
@@ -171,9 +197,16 @@ function checkLines(where, out, p) {
       ...(sv.compatibilityFlags.length ? [sv.compatibilityFlags.join(', ')] : []),
     ];
     lines.push(
-      `  server code: ${sv.entry} bundled from ${plural(sv.files.length, 'file')} (${sv.files.join(', ')}) ` +
-        `into one ${kb(sv.bytes)} file, sha256 ${sv.sha256.slice(0, 12)}…${extras.map(e => `, ${e}`).join('')}; ` +
-        'server/ and gamesfun.json are not public files',
+      sv.stock
+        ? `  server code: xcore's stock server (${kb(sv.bytes)}, sha256 ${sv.sha256.slice(0, 12)}…), which serves the page's api/db/ from the game's database under gamesfun.json → database.collections`
+        : `  server code: ${sv.entry} bundled from ${plural(sv.files.length, 'file')} (${sv.files.join(', ')}) ` +
+            `into one ${kb(sv.bytes)} file, sha256 ${sv.sha256.slice(0, 12)}…${extras.map(e => `, ${e}`).join('')}; ` +
+            'server/ and gamesfun.json are not public files',
+      ...(sv.database
+        ? [
+            `  database: env.${sv.database.binding}, ${sv.database.migrations.length ? `${plural(sv.database.migrations.length, 'migration')} (${sv.database.migrations.join(', ')})` : 'no migrations'}`,
+          ]
+        : []),
       ...sv.warnings.map(w => `  ${w}`),
     );
   }
@@ -198,7 +231,7 @@ function publishedLines(where, r) {
     `  the game itself: ${r.gameUrl}`,
   ];
   if (r.friendsUrl) lines.push(`  play with friends: ${r.friendsUrl}`);
-  lines.push(`  uploaded ${r.uploaded} new files; games.fun already had ${r.alreadyThere}.`);
+  lines.push(`  uploaded ${r.uploaded} new files; xgames.fun already had ${r.alreadyThere}.`);
   if (r.server) {
     lines.push(
       r.server.sent
@@ -209,7 +242,7 @@ function publishedLines(where, r) {
   return lines;
 }
 
-/** A publish saved as a private draft: asked for with --draft, refused by games.fun, or its checks failed. */
+/** A publish saved as a private draft: asked for with --draft, refused by xgames.fun, or its checks failed. */
 function draftLines(where, r, folder = where) {
   const lines = [`Saved ${where} as a private draft (version ${r.version.number}): ${r.studioUrl}`];
   if (r.publishError) lines.push(`  not published: ${r.publishError}`);

package/commands/secret.mjs

@@ -1,4 +1,4 @@
-// `xcore secret set|list|delete`: a game server's own secrets on games.fun (../lib/publish/secrets.mjs).
+// `xcore secret set|list|delete`: a game server's own secrets on xgames.fun (../lib/publish/secrets.mjs).
 import { readFile } from 'node:fs/promises';
 import { guard, parse, printJson, UsageError } from '../lib/cli.mjs';
 import { resolveGame, shown } from '../lib/games.mjs';
@@ -11,12 +11,12 @@ const usage = `Usage: xcore secret set <NAME> [dir] [--from-file <path> | --from
        xcore secret delete <NAME> [dir] [--json]
 
 A key your game's server needs and no player may see (a voucher-signing key, an outside API's key, an RPC URL with
-its key): the server reads it as env.<NAME>. games.fun keeps the value only on the server's host (Cloudflare), never
+its key): the server reads it as env.<NAME>. xgames.fun keeps the value only on the server's host (Cloudflare), never
 shows it again and never gives it to the page. Set it after the game is published with its server/; it reaches the
 server's next request, with no publish. On this machine, ${CMD} dev reads the same names from the game folder's
 .dev.vars (NAME=value lines; a hidden file, so publish never sends it; keep it out of git).
   set <NAME>         the value from --from-file, or the folder's .dev.vars (--from-dev-vars: the same key as under
-                     xcore dev), or --new-key: a new Ed25519 key made here and sent to games.fun only, never kept on
+                     xcore dev), or --new-key: a new Ed25519 key made here and sent to xgames.fun only, never kept on
                      this machine (it prints the key's address: a voucher key's goes in the grant), else from stdin
                      when it is piped, else typed (not shown)
   list               the names (values are never shown)
@@ -71,7 +71,7 @@ async function fromDevVars(dir, name) {
 
 export default {
   name: 'secret',
-  summary: "a game server's secrets on games.fun (env.<NAME>): set, list, delete; never the page's",
+  summary: "a game server's secrets on xgames.fun (env.<NAME>): set, list, delete; never the page's",
   usage,
   run: args =>
     guard(async () => {
@@ -129,9 +129,9 @@ export default {
         );
         if (made)
           console.log(
-            `It is a new key, made here and kept only on games.fun's server. Its address: ${made.address}\nA voucher key's address goes in the grant's "vouchers" in xsolana.json (then ${CMD} loot approve).`,
+            `It is a new key, made here and kept only on xgames.fun's server. Its address: ${made.address}\nA voucher key's address goes in the grant's "vouchers" in xsolana.json (then ${CMD} loot approve).`,
           );
       }
       return 0;
-    }),
+    }, args),
 };