@xgamesfun/xcore 0.1.0 → 0.2.1

package/lib/publish/client.mjs

@@ -1,6 +1,6 @@
-// Talking to games.fun from the kit: signing in, and the publish calls (games.fun's kit routes).
+// Talking to xgames.fun from the kit: signing in, and the publish calls (xgames.fun's kit routes).
 //
-// Sign in (`xcore login`) never sees a password: the person's own browser signs in to games.fun and approves this
+// Sign in (`xcore login`) never sees a password: the person's own browser signs in to xgames.fun and approves this
 // computer; the kit receives a one-time code on a loopback address only it listens on (127.0.0.1, a free port, for
 // five minutes) and trades it, with a secret it never sent anywhere (PKCE), for a publish token. `--code` is the same
 // without the loopback: the page shows the code and the person pastes it here. The token is kept by lib/credentials.mjs
@@ -8,9 +8,10 @@
 import { createServer } from 'node:http';
 import { createHash, randomBytes } from 'node:crypto';
 import os from 'node:os';
-import { deleteSecret, loadSecret, saveSecret } from '../credentials.mjs';
+import { deleteSecret, listEntries, loadSecret, saveSecret } from '../credentials.mjs';
+import { CMD } from '../command.mjs';
 
-/** games.fun's Studio. GAMESFUN_STUDIO points the kit at another one (a local Studio while developing). */
+/** xgames.fun's Studio. GAMESFUN_STUDIO points the kit at another one (a local Studio while developing). */
 export const DEFAULT_STUDIO = 'https://xgames.fun'; // canonical Studio origin; old aliases remain available for existing clients
 export function studioOrigin(env = process.env) {
   const raw = String(env.GAMESFUN_STUDIO ?? '').trim() || DEFAULT_STUDIO;
@@ -25,9 +26,11 @@ export function studioOrigin(env = process.env) {
     throw new Error(`GAMESFUN_STUDIO must be an https address (or http on this machine): ${raw}`);
   return u.origin;
 }
+// The key the sign-in is kept under. It is an identifier, not the platform's name: 0.1.0 and the kit save under "games.fun <origin>",
+// so it stays that, or everyone would be signed out by an upgrade and their old token could not be revoked.
 export const credentialKey = origin => `games.fun ${origin}`;
 /**
- * games.fun's own origins for a Studio origin, as its publish route counts them (playOrigin and studioOriginFor): the
+ * xgames.fun's own origins for a Studio origin, as its publish route counts them (playOrigin and studioOriginFor): the
  * Studio and its play host, play.<studio host> (play.localhost:<port> for a Studio on this machine). A backend.json
  * that lists one of them is refused there; the game reaches its own host without listing it.
  */
@@ -61,7 +64,7 @@ export async function login({
   env = process.env,
   fetchImpl = fetch,
 } = {}) {
-  // A games.fun without the kit's routes (not deployed yet) answers 404 here: say so now, not after a 5-minute wait.
+  // A xgames.fun without the kit's routes (not deployed yet) answers 404 here: say so now, not after a 5-minute wait.
   await call(origin, '/api/kit/me', { fetchImpl }).catch(e => {
     if (e.status !== 401) throw e;
   });
@@ -71,7 +74,7 @@ export async function login({
   let code;
   if (byCode) {
     const url = `${origin}/kit/connect?${params}`;
-    log(`Open this page, sign in to games.fun and approve this computer:\n  ${url}`);
+    log(`Open this page, sign in to xgames.fun and approve this computer:\n  ${url}`);
     await open?.(url);
     code = String(await prompt('Paste the code the page shows: ')).trim();
   } else {
@@ -116,7 +119,7 @@ export async function login({
       server.listen(0, '127.0.0.1', async () => {
         params.set('port', String(server.address().port));
         const url = `${origin}/kit/connect?${params}`;
-        log(`Opening games.fun in your browser to sign in. If it does not open, visit:\n  ${url}`);
+        log(`Opening xgames.fun in your browser to sign in. If it does not open, visit:\n  ${url}`);
         try {
           await open?.(url);
         } catch {}
@@ -145,23 +148,128 @@ export async function savedLogin(origin = studioOrigin(), { env = process.env }
   return s ? { token: s.secret, email: s.meta.email, expiresAt: s.meta.expiresAt, store: s.store } : null;
 }
 
-/** Log out: revoke the token at games.fun (when it answers) and forget it here. → { revoked, forgot } */
+/** The words for where a token is kept (`store` as saveSecret names it). */
+export const storeWords = store =>
+  store === 'file'
+    ? 'a file only you can read'
+    : store === 'dpapi'
+      ? 'a file encrypted for your Windows user'
+      : store === 'keychain'
+        ? 'the macOS keychain'
+        : store === 'secret-service'
+          ? 'the Secret Service'
+          : (store ?? 'the secret store');
+
+/**
+ * Where this computer's sign-in to `origin` stands, in one word, with what to run next:
+ *   signed-out --login--> signed-in --(30 days)--> expired --login--> signed-in;   signed-in --logout--> signed-out
+ *   unreadable: the record says a token is kept in a store this session cannot read (the Secret Service over SSH,
+ *   a locked keyring); signing in again here fixes it.
+ * → { state, studio, email?, expiresAt?, store?, token? (signed-in only), words, next }
+ */
+export async function signInState(origin = studioOrigin(), { env = process.env, now = Date.now() } = {}) {
+  const entry = (await listEntries({ env }))[credentialKey(origin)];
+  if (!entry)
+    return { state: 'signed-out', studio: origin, words: `Not signed in to ${origin}.`, next: `${CMD} login` };
+  const facts = { studio: origin, email: entry.email ?? null, expiresAt: entry.expiresAt ?? null, store: entry.store };
+  const s = await savedLogin(origin, { env });
+  if (!s)
+    return {
+      state: 'unreadable',
+      ...facts,
+      words: `Signed in to ${origin} as ${facts.email}, but its token is kept in ${storeWords(entry.store)}, which this session cannot read (over SSH the Secret Service is not reachable). Sign in again here, or use the session that signed in.`,
+      next: `${CMD} login`,
+    };
+  if (s.expiresAt && Date.parse(s.expiresAt) <= now)
+    return {
+      state: 'expired',
+      ...facts,
+      words: `The sign-in to ${origin} as ${facts.email} ended on ${s.expiresAt.slice(0, 10)}. Sign in again.`,
+      next: `${CMD} login`,
+    };
+  return {
+    state: 'signed-in',
+    ...facts,
+    token: s.token,
+    words: `Signed in to ${origin} as ${facts.email} until ${facts.expiresAt} (token in ${storeWords(entry.store)}).`,
+    next: `${CMD} publish`,
+  };
+}
+
+/**
+ * Log out: revoke the token at xgames.fun (when it answers) and forget it here. → { revoked, forgot, why? }
+ * `why`, when something was forgotten but not revoked: 'unreadable' (this session cannot read the token, so it was
+ * never sent), 'ended' (xgames.fun says it had already expired or been revoked), 'offline' (xgames.fun did not answer)
+ * or 'refused' (xgames.fun answered with an error).
+ */
 export async function logout(origin = studioOrigin(), { env = process.env, fetchImpl = fetch } = {}) {
   const s = await savedLogin(origin, { env });
-  let revoked = false;
+  let revoked = false,
+    why = 'unreadable';
   if (s) {
     try {
       await call(origin, '/api/kit/token', { method: 'DELETE', token: s.token, fetchImpl });
       revoked = true;
-    } catch {
-      /* offline or already revoked */
+    } catch (e) {
+      why = e.status === 401 || e.status === 403 ? 'ended' : e.status === 0 || e.status >= 500 ? 'offline' : 'refused';
     }
   }
   const forgot = await deleteSecret(credentialKey(origin), { env });
-  return { revoked, forgot };
+  return forgot && !revoked ? { revoked, forgot, why } : { revoked, forgot };
+}
+
+/**
+ * An answer Studio sent as {"$download": url}: its JSON over 4 MB (Vercel's 4.5 MB answer limit), written to its
+ * bucket and signed for a while, which a call fetches and reads as the answer. Nothing of the sign-in goes with it.
+ */
+const downloadOf = v =>
+  v && typeof v === 'object' && !Array.isArray(v) && Object.keys(v).length === 1 && typeof v.$download === 'string'
+    ? v.$download
+    : null;
+async function followDownload(url, fetchImpl) {
+  let u = null;
+  try {
+    u = new URL(url);
+  } catch {
+    /* not an address */
+  }
+  if (
+    !u ||
+    !(u.protocol === 'https:' || (u.protocol === 'http:' && /^(localhost|127\.0\.0\.1|\[::1\])$/.test(u.hostname)))
+  )
+    throw Object.assign(
+      new Error("xgames.fun's answer was too big to send directly, and its download address is not one xcore follows"),
+      { status: 0 },
+    );
+  let res;
+  try {
+    res = await fetchImpl(u.href);
+  } catch (e) {
+    throw Object.assign(
+      new Error(
+        `xgames.fun's answer was too big to send directly, and its download did not come (${e.cause?.code ?? e.message}): try again`,
+      ),
+      { status: 0 },
+    );
+  }
+  if (!res.ok)
+    throw Object.assign(
+      new Error(`xgames.fun's answer was too big to send directly, and its download failed (${res.status}): try again`),
+      { status: res.status },
+    );
+  try {
+    return JSON.parse(await res.text());
+  } catch {
+    throw Object.assign(new Error("xgames.fun's answer was too big to send directly, and its download is not JSON"), {
+      status: 0,
+    });
+  }
 }
 
-/** One JSON call to games.fun (`headers`: more, such as the GitHub OIDC credential's). Throws an Error with games.fun's own words (and .status). */
+/**
+ * One JSON call to xgames.fun (`headers`: more, such as the GitHub OIDC credential's). An answer over 4 MB that Studio
+ * sent as {"$download": url} is fetched from there. Throws an Error with xgames.fun's own words (and .status).
+ */
 export async function call(origin, route, { method = 'GET', body, token, headers = {}, fetchImpl = fetch } = {}) {
   let res;
   try {
@@ -175,7 +283,7 @@ export async function call(origin, route, { method = 'GET', body, token, headers
       body: body ? JSON.stringify(body) : undefined,
     });
   } catch (e) {
-    throw Object.assign(new Error(`Could not reach games.fun at ${origin} (${e.cause?.code ?? e.message}).`), {
+    throw Object.assign(new Error(`Could not reach xgames.fun at ${origin} (${e.cause?.code ?? e.message}).`), {
       status: 0,
     });
   }
@@ -190,15 +298,17 @@ export async function call(origin, route, { method = 'GET', body, token, headers
     const words =
       value?.error ??
       (res.status === 404
-        ? `games.fun at ${origin} does not offer publishing from the command line yet.`
-        : `games.fun answered ${res.status}.`);
-    // `code`: games.fun's word for why ('plan', 'taken'…); `answered`: false when the route itself is not there (a
-    // games.fun older than the command)
+        ? `xgames.fun at ${origin} does not offer publishing from the command line yet.`
+        : `xgames.fun answered ${res.status}.`);
+    // `code`: xgames.fun's word for why ('plan', 'taken'…); `answered`: false when the route itself is not there (a
+    // xgames.fun older than the command); `answer`: the rest of what it said (a refused migration's name and why)
     throw Object.assign(new Error(words), {
       status: res.status,
       answered: value != null,
       ...(value?.code ? { code: value.code } : {}),
+      ...(value && typeof value === 'object' ? { answer: value } : {}),
     });
   }
-  return value;
+  const download = downloadOf(value);
+  return download ? followDownload(download, fetchImpl) : value;
 }

package/lib/publish/gate.mjs

@@ -2,11 +2,12 @@
 // caller's: this package's page check for a game made anywhere (../check.mjs), or the kit's six gates for a game the
 // kit made (the kit passes its own `check`). A pass is remembered in <game>/.gamesfun/gate.json with the files'
 // fingerprint (./tree.mjs), so publishing again without a change does not check again; any change to a published file
-// checks again. A game whose checks fail can still go up as a private draft (a version in the person's games.fun
+// checks again. A game whose checks fail can still go up as a private draft (a version in the person's xgames.fun
 // Studio, with no public link), and the person is told which checks failed.
 import { mkdir, readFile, writeFile } from 'node:fs/promises';
 import path from 'node:path';
 import { buildTree } from './tree.mjs';
+import { stateFolder } from '../state-folder.mjs';
 
 export const gateFile = dir => path.join(dir, '.gamesfun', 'gate.json');
 
@@ -18,7 +19,7 @@ export async function readGate(dir) {
   }
 }
 
-/** The report games.fun records with the version: {pass, quick, passed, ran, failed:[{n, name}], at, kit, run}. */
+/** The report xgames.fun records with the version: {pass, quick, passed, ran, failed:[{n, name}], at, kit, run}. */
 export function reportOf(summary, kit = null) {
   if (!summary) return { pass: false, quick: false, passed: 0, ran: 0, failed: [], at: null, kit, run: null };
   return {
@@ -54,6 +55,7 @@ export async function gate(
   const report = reportOf(summary, kit);
   if (after !== before)
     return { report: { ...report, pass: false }, fingerprint: after, ran: true, reused: false, changedDuring: true };
+  await stateFolder(dir);
   await mkdir(path.dirname(gateFile(dir)), { recursive: true });
   await writeFile(
     gateFile(dir),

package/lib/publish/hosting.mjs

@@ -1,4 +1,4 @@
-// What games.fun's play host does with a published game's files, as the kit checks it before a publish (pure: no Node
+// What xgames.fun's play host does with a published game's files, as the kit checks it before a publish (pure: no Node
 // imports; the headers and types are the play origin's own, ../play-policy.mjs). README.md is the person's page for
 // it; ./scan.mjs holds the secret scan and the backend origins, which the service runs again on its side.
 //
@@ -7,7 +7,7 @@
 //                       the host's "not found" page (no fallback to index.html, so a deep link of a client-side router
 //                       works only from the entry page). No server-side rendering: code that runs on a server goes in
 //                       server/ (gf-server-v1, docs/SERVER.md), answering /api/*.
-//   Where it is served  at its own origin's root once published; under a folder in games.fun Studio's preview and in
+//   Where it is served  at its own origin's root once published; under a folder in xgames.fun Studio's preview and in
 //                       the kit's dev server (/game/). Paths from the root (/assets/x.js) break there: a game uses
 //                       relative URLs.
 //   Paths the host owns /api/* (the game's server, when it has one), /platform/v1/* (sign-in, saves, scores), the
@@ -21,7 +21,7 @@
 //   Limits              what GET /api/kit/me says (`limits`); DEFAULT_LIMITS when the kit cannot ask (offline).
 import { MIME, mimeFor, playHeaders } from '../play-policy.mjs';
 
-/** The host's limits for one published game, as games.fun states them today (README.md "What the hosting takes"); publish reads the account's own. */
+/** The host's limits for one published game, as xgames.fun states them today (README.md "What the hosting takes"); publish reads the account's own. */
 export const DEFAULT_LIMITS = Object.freeze({
   files: 3000,
   totalBytes: 100 * 1024 * 1024,
@@ -65,8 +65,8 @@ export const UNTYPED_CODE = /\.(cjs|jsx|tsx?|vue|svelte|scss|sass|less)$/i;
  * already checked: lib/publish/scan.mjs backendOrigins): the play origin's own (lib/play-policy.mjs
  * playHeaders). The page check sends the same.
  */
-export const pageHeaders = (backend = [], mime = null) =>
-  playHeaders({ studioOrigin: null, backend, ...(mime ? { mime } : {}) });
+export const pageHeaders = (backend = [], mime = null, files = []) =>
+  playHeaders({ studioOrigin: null, backend, files, ...(mime ? { mime } : {}) });
 /** The page policy (Content-Security-Policy) alone. */
 export const pagePolicy = (backend = []) => pageHeaders(backend)['content-security-policy'];