ravensight-playtest 0.5.1 → 0.6.0

package/src/commands/assets.js

@@ -0,0 +1,62 @@
+import path from 'node:path';
+
+import { loadConfig } from '../config.js';
+import EXIT from '../run/exit.js';
+import { scanUsage } from '../assets/integration.js';
+import { buildInventory, countsLine, DEFAULT_ASSETS_DIR, describeFile, formatBytes, warningKinds } from '../assets/inventory.js';
+
+/**
+ * `ravensight-playtest assets`: what a project's art and audio folder holds, as
+ * measured on this machine. It needs no login, sends nothing anywhere and costs
+ * nothing, so it can be run as often as a studio likes before a feature job.
+ *
+ * @param {Object} flags
+ * @param {Object} [injected] test seam
+ * @returns {Promise<number>} an exit code
+ */
+export async function assetsCommand(flags = {}, injected = {}) {
+  const log = injected.log || (line => console.log(line));
+  const repoRoot = path.resolve(flags.repoRoot || process.cwd());
+  const config = await loadConfig({ repoRoot }).catch(() => null);
+  const projectDir = path.resolve(repoRoot, flags.godotProject || config?.godot_project || '.');
+  const folder = flags.assetsDir || config?.assets_dir || DEFAULT_ASSETS_DIR;
+  const grid = Number.isInteger(flags.grid) && flags.grid > 0 ? flags.grid : null;
+  if (flags.grid !== undefined && !grid) {
+    log('--grid has to be a whole number of art pixels across, such as 32.');
+    return EXIT.ENVIRONMENT;
+  }
+  let inventory;
+  try {
+    inventory = await buildInventory({ projectDir, folder, grid });
+  } catch (error) {
+    log(`The project could not be read: ${String(error && error.message)}`);
+    return EXIT.ENVIRONMENT;
+  }
+  if (!inventory.ok) {
+    log(inventory.reason);
+    return EXIT.ENVIRONMENT;
+  }
+  if (!inventory.exists) {
+    log(`There is no folder ${folder} in this project. Put your art and audio there, or name the folder with --assets-dir. A feature uses placeholders for anything it cannot find.`);
+    return flags.assetsDir ? EXIT.ENVIRONMENT : EXIT.OK;
+  }
+  const usage = await scanUsage({ projectDir, inventory });
+  if (flags.json) {
+    (injected.json || (value => console.log(JSON.stringify(value, null, 2))))({ ...inventory, usage: { used: usage.used, unused: usage.unused, built_in_code: usage.built_in_code } });
+    return EXIT.OK;
+  }
+  const used = new Set(usage.used);
+  log(`${inventory.folder}: ${countsLine(inventory.counts)}. ${usage.used.length} used by the project, ${usage.unused.length} unused.`);
+  for (const file of inventory.files) {
+    log(`${file.path}  ${[file.format, formatBytes(file.bytes), describeFile(file)].filter(Boolean).join(', ')}${used.has(file.path) ? '' : '  (unused)'}`);
+    for (const item of file.warnings) log(`  warning: ${item.text}`);
+  }
+  for (const item of inventory.warnings) log(`warning: ${item.text}`);
+  if (inventory.truncated) log(`Only the first ${inventory.counts.files} files are listed.`);
+  const kinds = warningKinds(inventory);
+  log(kinds.length === 0 ? 'No warnings.' : `${kinds.reduce((sum, item) => sum + item.count, 0)} warning(s).`);
+  log('This read your files on this machine and sent nothing.');
+  return EXIT.OK;
+}
+
+export default assetsCommand;

package/src/commands/build.js

@@ -0,0 +1,81 @@
+import { readFile, stat } from 'node:fs/promises';
+import { createContext } from '../api/index.js';
+import { resolveGameId } from '../config.js';
+import { withAuthHandling } from '../auth/session.js';
+import { preflightBuildArchive, limitsFromProfile } from '../hosted/archivePreflight.js';
+import { uploadHostedBuild } from '../hosted/buildUpload.js';
+import { CliError, ExitCode } from '../errors.js';
+import { ui } from '../ui/index.js';
+
+// TTY animation stays live while I/O awaits. Piped logs receive at most one
+// byte update per second, plus phase boundaries and the final byte count.
+export function buildUploadProgress({ json = false, now = Date.now } = {}) {
+  let spin, phase, last = 0, finished = false;
+  const labels = { capabilities: 'Checking available build profiles', preflight: 'Checking ZIP metadata',
+    hash: 'Hashing archive', reservation: 'Requesting the confirmed validation hold',
+    upload: 'Streaming archive bytes', completion: 'Submitting the original upload for validation' };
+  return {
+    update(event) {
+      if (json || ui.isQuiet()) return;
+      const at = now(), changed = phase !== event.phase;
+      const complete = event.totalBytes !== undefined && event.completedBytes === event.totalBytes;
+      if (!changed && at - last < 1000 && (!complete || finished)) return;
+      const label = labels[event.phase] + (event.totalBytes === undefined ? ''
+        : `: ${ui.bytes(event.completedBytes)} / ${ui.bytes(event.totalBytes)}`);
+      if (changed) { spin?.stop(); spin = ui.spinner(label); phase = event.phase; }
+      else spin.update(label);
+      last = at; finished = complete;
+    },
+    stop() { spin?.stop(); spin = null; phase = null; finished = false; }
+  };
+}
+
+export async function buildPreflight(filename, flags = {}) {
+  let profile;
+  if (flags.capacity) {
+    const info = await stat(flags.capacity);
+    if (!info.isFile() || info.size > 65536) throw new CliError('Choose a capacity profile JSON file no larger than 64 KiB.');
+    profile = JSON.parse(await readFile(flags.capacity, 'utf8'));
+  }
+  const result = await preflightBuildArchive(filename, { format: profile?.format || flags.format,
+    entrypoint: flags.entrypoint, limits: profile ? limitsFromProfile(profile) : undefined,
+    requirements: profile?.capacity?.requirements });
+  if (flags.json) ui.json(result);
+  else {
+    ui.ok(`ZIP metadata passed: ${result.entries} entries; ${ui.bytes(result.archiveBytes)} uploaded, ${ui.bytes(result.expandedBytes)} expanded.`);
+    ui.info('No wallet charge or upload was requested. Server validation and runtime compatibility checks are still required.');
+  }
+  return ExitCode.OK;
+}
+
+export async function buildUpload(filename, flags = {}, deps = {}) {
+  const context = deps.context || await createContext({ apiUrl: flags.apiUrl, repoRoot: flags.repoRoot, requireAuth: true });
+  return withAuthHandling(context, async () => {
+    const progress = buildUploadProgress({ json: Boolean(flags.json) });
+    try {
+      const result = await uploadHostedBuild({ filename, gameId: resolveGameId(flags, context.config), profileVersion: flags.profile,
+        entrypoint: flags.entrypoint, repoRoot: context.repoRoot, api: context.api, apiUrl: context.api.apiUrl,
+        journalPath: flags.journal, dryRun: Boolean(flags.dryRun), fetchImpl: deps.fetch,
+        confirm: deps.confirm || (question => ui.confirm(question, { yes: Boolean(flags.yes) })),
+        onProgress: event => progress.update(event),
+        onPrepared: prepared => {
+          progress.stop();
+          if (flags.json) return;
+          ui.info(`ZIP metadata checked: ${prepared.entries} entries; ${ui.bytes(prepared.archiveBytes)} archive, ${ui.bytes(prepared.expandedBytes)} expanded.`);
+          const limit = prepared.limits;
+          ui.info(`Selected limits: archive ${ui.bytes(limit.archiveBytes)}, expanded ${ui.bytes(limit.expandedBytes)}, file ${ui.bytes(limit.fileBytes)}, ${limit.files} entries, depth ${limit.depth}, ratio ${limit.ratio}:1.`);
+          const required = prepared.capacity?.requirements;
+          if (required) ui.info(`Server profile: ${required.os}/${required.architecture}, ${required.cpuVcpus} CPU, ${ui.bytes(required.memoryBytes)} RAM. Runtime and license readiness must come from the server.`);
+          if (Number.isSafeInteger(prepared.funding?.minimumFundingCents)) ui.info(`Server prepaid funding minimum: $${(prepared.funding.minimumFundingCents / 100).toFixed(2)}; the separate gameplay price is quoted after validation.`);
+          ui.info('Static validation hold: $0.49 from prepaid funds, returned after safe cleanup. A gameplay quote is separate. No top-up is performed.');
+          ui.info('Passing this local check does not establish GPU, licensing or game runtime compatibility.');
+        }
+      });
+      progress.stop();
+      if (flags.json) ui.json(result);
+      else if (result.state === 'awaiting_validation') ui.ok(`Uploaded ${result.buildId}; awaiting server validation. Journal: ${result.journal}`);
+      else ui.info(result.state === 'declined' ? 'Upload declined; no reservation requested.' : 'Preflight finished; no reservation requested.');
+      return result.state === 'declined' ? ExitCode.CANCELED : ExitCode.OK;
+    } finally { progress.stop(); }
+  });
+}

package/src/commands/check.js

@@ -425,7 +425,7 @@ export async function runChecks(flags = {}, deps = {}) {
         'login',
         games.length > 0 ? 'pass' : 'warn',
         games.length > 0
-          ? `${who}, valid, scoped to ${plural(games.length, 'game')}: ${games.map(gameLabel).join(', ')}`
+          ? `${who}, valid, scoped to ${plural(games.length, 'game')}: ${games.slice(0, MAX_GAMES_LISTED).map(gameLabel).join(', ')}${games.length > MAX_GAMES_LISTED ? `, and ${games.length - MAX_GAMES_LISTED} more (check --json lists them all)` : ''}`
           : `${who}, valid, but scoped to no games`,
         games.length > 0 ? null : 'run ravensight-playtest login again and approve the game for this token'
       ));
@@ -742,6 +742,9 @@ export async function firstScreenRow(measure, url, { authed, gameId, priced }) {
  * @param {Object} [deps]
  * @returns {Promise<number>} exit code, 3 when anything failed
  */
+/** Games named on check's login row; the rest are counted, and --json has them all. */
+export const MAX_GAMES_LISTED = 5;
+
 export async function check(flags = {}, deps = {}) {
   const progress = flags.json ? {} : { onProgress: line => ui.info(line) };
   const { rows, ok, cli, login, project, brief, build, automation } = await runChecks(flags, { ...progress, ...deps });