@quenty/nevermore-cli 4.51.0 → 4.52.0

package/src/utils/job-context/batch-script-job-context.ts

@@ -122,7 +122,7 @@ export class BatchScriptJobContext implements JobContext {
       maxChunkBytes?: number;
       reporter?: Reporter;
       /**
-       * Places already built by `batch bundle`, run instead of building. They
+       * Places already built by `batch bundle --test`, run instead of building. They
        * upload to `batchPlaceId` in `batchUniverseId`, which are then required.
        * The context owns `buildContext` and cleans it up like its own build.
        */

package/src/utils/open-cloud/open-cloud-client.test.ts

@@ -733,6 +733,21 @@ describe('OpenCloudClient asset owner lookups', () => {
   });
 });
 
+describe('OpenCloudClient.createExecutionTaskAsync', () => {
+  it('refuses a script over the 4 MB limit without sending it', async () => {
+    const fakeLimiter = { fetchAsync: vi.fn() };
+    const client = new OpenCloudClient({
+      apiKey: 'key',
+      rateLimiter: fakeLimiter as unknown as RateLimiter,
+    });
+
+    await expect(
+      client.createExecutionTaskAsync(1, 2, 3, 'a'.repeat(4_000_001))
+    ).rejects.toThrow('over the Open Cloud limit of 4 MB');
+    expect(fakeLimiter.fetchAsync).not.toHaveBeenCalled();
+  });
+});
+
 describe('getTaskReturnValues', () => {
   function makeTask(overrides: Partial<LuauTask>): LuauTask {
     return {

package/src/utils/open-cloud/open-cloud-client.ts

@@ -28,6 +28,8 @@ import { recompressPlace } from '../build/place-recompression.js';
  */
 export const PLACE_UPLOAD_MAX_BYTES = 150 * 1024 * 1024;
 
+export const LUAU_EXECUTION_SCRIPT_MAX_BYTES = 4_000_000;
+
 /**
  * One engine message, with the severity Open Cloud reported for it.
  *
@@ -397,6 +399,15 @@ export class OpenCloudClient {
     timeoutMs?: number,
     onRateLimitWait?: (wait: RateLimitWait) => void
   ): Promise<LuauTask> {
+    const scriptBytes = Buffer.byteLength(script, 'utf-8');
+    if (scriptBytes > LUAU_EXECUTION_SCRIPT_MAX_BYTES) {
+      throw new Error(
+        `The script is ${_formatMegabytes(
+          scriptBytes
+        )}, over the Open Cloud limit of 4 MB for a Luau execution script`
+      );
+    }
+
     const apiKey = await this._resolveApiKeyAsync();
     const url = `https://apis.roblox.com/cloud/v2/universes/${universeId}/places/${placeId}/versions/${placeVersion}/luau-execution-session-tasks`;
 

package/src/utils/testing/runner/prebuilt-batch-bundle.test.ts

@@ -249,4 +249,24 @@ describe('prebuilt batch bundle', () => {
       'Unsupported bundle format'
     );
   });
+
+  it('names the right command for a deploy bundle, before its unexpected entries', async () => {
+    const file = await writeRawAsync([
+      {
+        path: 'manifest.json',
+        body: JSON.stringify({
+          formatVersion: 1,
+          kind: 'deploy',
+          target: 'integration',
+          places: [],
+        }),
+      },
+      { path: 'place-1.rbxl', body: 'place bytes' },
+      { path: 'project-1.json', body: '{}' },
+    ]);
+
+    await expect(readAsync(file)).rejects.toThrow(
+      'This is a deploy bundle, not a tests bundle. Run it with "nevermore batch deploy --bundle <file>".'
+    );
+  });
 });

package/src/utils/testing/runner/prebuilt-batch-bundle.ts

@@ -1,13 +1,16 @@
 import * as fs from 'fs/promises';
-import { createReadStream, createWriteStream } from 'fs';
 import * as path from 'path';
 import * as tar from 'tar';
 import { BuildContext } from '@quenty/nevermore-template-helpers';
 import { type CombinedPlaceChunk } from './combined-project-generator.js';
 import { PLACE_UPLOAD_MAX_BYTES } from '../../open-cloud/open-cloud-client.js';
+import {
+  PACKAGE_NAME_PATTERN,
+  readUntrustedTarAsync,
+} from '../../bundle/untrusted-tar.js';
 
 /**
- * Places built by `nevermore batch bundle`, unpacked from a
+ * Places built by `nevermore batch bundle --test`, unpacked from a
  * `*.nevermore.tests.tar` and ready for `batch test --bundle` to run.
  */
 export interface PrebuiltBatchBundle {
@@ -24,6 +27,7 @@ export interface PrebuiltBatchPackage {
 
 interface ManifestFile {
   formatVersion: number;
+  kind?: 'tests';
   chunks: Array<{
     file: string;
     packages: Array<{ name: string; slug: string; hasJestConfig: boolean }>;
@@ -39,10 +43,6 @@ const MAX_CHUNKS = 32;
 const MAX_PACKAGES = 1000;
 const MAX_MANIFEST_BYTES = 1024 * 1024;
 const CHUNK_FILE_PATTERN = /^place-\d{1,3}\.rbxl$/;
-// Names reach the bot's PR comment, so a fork's bundle gets no Markdown links,
-// images, URLs, tables or @mentions: only a leading scope `@`, and plain text
-// for a multi-place target's place name ("pkg - Hub (Test)").
-const PACKAGE_NAME_PATTERN = /^@?[\p{L}\p{N} /()+.,'_~-]{1,200}$/u;
 const SLUG_PATTERN = /^[A-Za-z0-9_.-]{1,100}$/;
 
 export async function writePrebuiltBatchBundleAsync(
@@ -55,6 +55,7 @@ export async function writePrebuiltBatchBundleAsync(
   try {
     const manifest: ManifestFile = {
       formatVersion: FORMAT_VERSION,
+      kind: 'tests',
       chunks: [],
     };
     for (const [index, chunk] of chunks.entries()) {
@@ -107,7 +108,19 @@ export async function readPrebuiltBatchBundleAsync(
   });
   const dir = buildContext.buildDir;
   try {
-    const { manifestText, placeSizes } = await _unpackAsync(file, dir);
+    const { manifestText, entrySizes: placeSizes } =
+      await readUntrustedTarAsync(file, dir, {
+        kind: 'tests',
+        manifestName: MANIFEST_FILE_NAME,
+        maxManifestBytes: MAX_MANIFEST_BYTES,
+        isEntryAllowed: (name) => CHUNK_FILE_PATTERN.test(name),
+        maxEntries: MAX_CHUNKS,
+        maxEntriesMessage: `Bundle must hold at most ${MAX_CHUNKS} places`,
+        checkEntrySize: (name, size) =>
+          size > PLACE_UPLOAD_MAX_BYTES
+            ? `${name} is over the place upload limit`
+            : undefined,
+      });
     return { ..._parseManifest(manifestText, dir, placeSizes), buildContext };
   } catch (err) {
     await buildContext.cleanupAsync();
@@ -115,82 +128,6 @@ export async function readPrebuiltBatchBundleAsync(
   }
 }
 
-async function _unpackAsync(
-  file: string,
-  dir: string
-): Promise<{ manifestText: string; placeSizes: Map<string, number> }> {
-  let manifestText: string | undefined;
-  const placeSizes = new Map<string, number>();
-  const writes: Promise<void>[] = [];
-  let failure: Error | undefined;
-
-  const parser = new tar.Parser({
-    strict: true,
-    onReadEntry: (entry) => {
-      const name = entry.path;
-      const reject = (message: string) => {
-        failure ??= new Error(message);
-        entry.resume();
-      };
-
-      if (entry.type !== 'File' && entry.type !== 'OldFile') {
-        return reject(`Bundle entry ${name} is not a regular file`);
-      }
-
-      if (name === MANIFEST_FILE_NAME) {
-        if (manifestText !== undefined || entry.size > MAX_MANIFEST_BYTES) {
-          return reject('Bundle has more than one manifest, or one too large');
-        }
-        const parts: Buffer[] = [];
-        entry.on('data', (part: Buffer) => parts.push(part));
-        entry.on('end', () => {
-          manifestText = Buffer.concat(parts).toString('utf-8');
-        });
-        return;
-      }
-
-      if (!CHUNK_FILE_PATTERN.test(name) || placeSizes.has(name)) {
-        return reject(`Bundle has an unexpected entry: ${name}`);
-      }
-      if (placeSizes.size >= MAX_CHUNKS) {
-        return reject(`Bundle must hold at most ${MAX_CHUNKS} places`);
-      }
-      if (entry.size > PLACE_UPLOAD_MAX_BYTES) {
-        return reject(`${name} is over the place upload limit`);
-      }
-      placeSizes.set(name, entry.size);
-      writes.push(
-        new Promise<void>((resolve, rejectWrite) => {
-          const out = createWriteStream(path.join(dir, name));
-          out.on('finish', () => resolve());
-          out.on('error', rejectWrite);
-          entry.on('error', rejectWrite);
-          entry.pipe(out);
-        })
-      );
-    },
-  });
-
-  await new Promise<void>((resolve, rejectRead) => {
-    const input = createReadStream(file);
-    input.on('error', rejectRead);
-    parser.on('error', (err: Error) =>
-      rejectRead(new Error(`Bundle is not a valid tar file: ${err.message}`))
-    );
-    parser.on('end', () => resolve());
-    input.pipe(parser);
-  });
-  await Promise.all(writes);
-
-  if (failure) {
-    throw failure;
-  }
-  if (manifestText === undefined) {
-    throw new Error(`Bundle is missing ${MANIFEST_FILE_NAME}`);
-  }
-  return { manifestText, placeSizes };
-}
-
 function _parseManifest(
   manifestText: string,
   dir: string,