@quenty/nevermore-cli 4.22.0 → 4.23.0

package/src/utils/job-context/cloud-job-context.ts

@@ -30,22 +30,30 @@ class CloudDeployment implements Deployment {
 }
 
 export class CloudJobContext extends BaseJobContext {
-  constructor(openCloudClient: OpenCloudClient) {
-    super(openCloudClient);
+  constructor(reporter: Reporter, openCloudClient: OpenCloudClient) {
+    super(reporter, openCloudClient);
   }
 
   async deployBuiltPlaceAsync(
-    reporter: Reporter,
     options: DeployPlaceOptions
   ): Promise<Deployment> {
     const { builtPlace, packageName, packagePath } = options;
     const { rbxlPath, target } = builtPlace;
 
-    reporter.onPackagePhaseChange(packageName, 'uploading');
+    this._reporter.onPackagePhaseChange(packageName, 'uploading');
+
     const version = await this._openCloudClient!.uploadPlaceAsync(
       target.universeId,
       target.placeId,
-      rbxlPath
+      rbxlPath,
+      undefined,
+      (transferred, total) => {
+        this._reporter.onPackageProgressUpdate(packageName, {
+          kind: 'bytes',
+          transferredBytes: transferred,
+          totalBytes: total,
+        });
+      }
     );
 
     // Eagerly release build artifacts after upload (disposeAsync is safety net)
@@ -62,13 +70,12 @@ export class CloudJobContext extends BaseJobContext {
 
   async runScriptAsync(
     deployment: Deployment,
-    reporter: Reporter,
     options: RunScriptOptions
   ): Promise<ScriptRunResult> {
     const cloudDeployment = deployment as CloudDeployment;
     const { scriptContent, packageName, timeoutMs = 120_000 } = options;
 
-    reporter.onPackagePhaseChange(packageName, 'scheduling');
+    this._reporter.onPackagePhaseChange(packageName, 'scheduling');
     const task = await this._openCloudClient!.createExecutionTaskAsync(
       cloudDeployment.universeId,
       cloudDeployment.placeId,
@@ -76,11 +83,20 @@ export class CloudJobContext extends BaseJobContext {
       scriptContent
     );
 
+    let pollCount = 0;
     const completedTask = await Promise.race([
       this._openCloudClient!.pollTaskCompletionAsync(task.path, (state) => {
+        pollCount++;
         if (state === 'PROCESSING') {
-          reporter.onPackagePhaseChange(packageName, 'executing');
+          this._reporter.onPackagePhaseChange(packageName, 'executing');
         }
+        const label = state === 'QUEUED' ? 'queued' : `poll #${pollCount}`;
+        this._reporter.onPackageProgressUpdate(packageName, {
+          kind: 'steps',
+          completed: pollCount,
+          total: 0,
+          label,
+        });
       }),
       timeoutAsync(timeoutMs, `Test timed out after ${timeoutMs / 1000}s`),
     ]);

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

@@ -1,4 +1,3 @@
-import { type Reporter } from '@quenty/cli-output-helpers/reporting';
 import { type BuildPlaceOptions, type BuiltPlace } from '../build/build.js';
 
 export type { BuiltPlace } from '../build/build.js';
@@ -32,10 +31,10 @@ export interface JobContext {
   buildPlaceAsync(options: BuildPlaceOptions): Promise<BuiltPlace>;
 
   /** Deploy a built place to the execution environment. Returns a handle for subsequent operations. */
-  deployBuiltPlaceAsync(reporter: Reporter, options: DeployPlaceOptions): Promise<Deployment>;
+  deployBuiltPlaceAsync(options: DeployPlaceOptions): Promise<Deployment>;
 
   /** Execute a Luau script in a deployed place. */
-  runScriptAsync(deployment: Deployment, reporter: Reporter, options: RunScriptOptions): Promise<ScriptRunResult>;
+  runScriptAsync(deployment: Deployment, options: RunScriptOptions): Promise<ScriptRunResult>;
 
   /** Retrieve raw logs from the most recent script execution on this deployment. */
   getLogsAsync(deployment: Deployment): Promise<string>;

package/src/utils/job-context/local-job-context.ts

@@ -24,12 +24,11 @@ class LocalDeployment implements Deployment {
 export class LocalJobContext extends BaseJobContext {
   private _deployments = new Set<LocalDeployment>();
 
-  constructor(openCloudClient?: OpenCloudClient) {
-    super(openCloudClient);
+  constructor(reporter: Reporter, openCloudClient?: OpenCloudClient) {
+    super(reporter, openCloudClient);
   }
 
   async deployBuiltPlaceAsync(
-    reporter: Reporter,
     options: DeployPlaceOptions
   ): Promise<Deployment> {
     const { builtPlace, packageName } = options;
@@ -38,7 +37,7 @@ export class LocalJobContext extends BaseJobContext {
       placePath: builtPlace.rbxlPath,
       onPhase: (phase) => {
         if (phase === 'launching' || phase === 'connecting') {
-          reporter.onPackagePhaseChange(packageName, phase);
+          this._reporter.onPackagePhaseChange(packageName, phase);
         }
       },
     });
@@ -52,13 +51,12 @@ export class LocalJobContext extends BaseJobContext {
 
   async runScriptAsync(
     deployment: Deployment,
-    reporter: Reporter,
     options: RunScriptOptions
   ): Promise<ScriptRunResult> {
     const localDeployment = deployment as LocalDeployment;
     const { scriptContent, packageName, timeoutMs } = options;
 
-    reporter.onPackagePhaseChange(packageName, 'executing');
+    this._reporter.onPackagePhaseChange(packageName, 'executing');
 
     try {
       const result = await localDeployment.bridge.executeAsync({

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

@@ -106,7 +106,8 @@ export class OpenCloudClient {
     universeId: number,
     placeId: number,
     rbxlPath: string,
-    publish?: boolean
+    publish?: boolean,
+    onProgress?: (transferredBytes: number, totalBytes: number) => void
   ): Promise<number> {
     OutputHelper.verbose(
       `Uploading to https://www.roblox.com/games/${placeId}/place ...`
@@ -114,19 +115,50 @@ export class OpenCloudClient {
 
     const apiKey = await this._resolveApiKeyAsync();
     const fileBuffer = await fs.readFile(rbxlPath);
-    const body = new Uint8Array(fileBuffer);
+    const totalBytes = fileBuffer.length;
     const versionType = publish ? 'Published' : 'Saved';
     const url = `https://apis.roblox.com/universes/v1/${universeId}/places/${placeId}/versions?versionType=${versionType}`;
 
-    const response = await this._rateLimiter.fetchAsync(url, {
-      method: 'POST',
-      headers: {
-        'Content-Type': 'application/octet-stream',
-        Accept: 'application/json',
-        'X-API-Key': apiKey,
-      },
-      body,
-    });
+    const headers: Record<string, string> = {
+      'Content-Type': 'application/octet-stream',
+      Accept: 'application/json',
+      'X-API-Key': apiKey,
+    };
+
+    let response: Response;
+
+    if (onProgress) {
+      // Wrap the buffer in a ReadableStream that reports bytes as each chunk
+      // is consumed by the transport, giving real-time upload progress.
+      const CHUNK_SIZE = 64 * 1024;
+      let offset = 0;
+      const stream = new ReadableStream<Uint8Array>({
+        pull(controller) {
+          if (offset >= totalBytes) {
+            controller.close();
+            return;
+          }
+          const end = Math.min(offset + CHUNK_SIZE, totalBytes);
+          controller.enqueue(fileBuffer.subarray(offset, end));
+          offset = end;
+          onProgress(offset, totalBytes);
+        },
+      });
+
+      // fetch with ReadableStream body requires duplex: 'half' in Node
+      response = await this._rateLimiter.fetchAsync(url, {
+        method: 'POST',
+        headers,
+        body: stream,
+        duplex: 'half',
+      } as RequestInit);
+    } else {
+      response = await this._rateLimiter.fetchAsync(url, {
+        method: 'POST',
+        headers,
+        body: new Uint8Array(fileBuffer),
+      });
+    }
 
     if (!response.ok) {
       const text = await response.text();

package/src/utils/testing/parsers/batch-log-parser.ts

@@ -1,9 +1,11 @@
 import { OutputHelper } from '@quenty/cli-output-helpers';
+import { type ParsedTestCounts, parseTestCounts } from '../test-log-parser.js';
 
 export interface BatchPackageResult {
   slug: string;
   success: boolean;
   logs: string;
+  testCounts?: ParsedTestCounts;
 }
 
 const BEGIN_MARKER = '===BATCH_TEST_BEGIN ';
@@ -136,7 +138,8 @@ export function parseBatchTestLogs(
       );
     }
 
-    results.set(packageName, { slug, success, logs: sectionLogs });
+    const testCounts = sectionLogs ? parseTestCounts(sectionLogs) : undefined;
+    results.set(packageName, { slug, success, logs: sectionLogs, testCounts });
   }
 
   return results;

package/src/utils/testing/runner/combined-project-generator.ts

@@ -28,6 +28,16 @@ interface RojoNode {
   [key: string]: unknown;
 }
 
+import { type StepProgress } from '@quenty/cli-output-helpers/reporting';
+
+/** Progress callbacks for granular phase reporting during combined builds. */
+export interface CombinedBuildProgress {
+  onPackageBuildStart?(packageName: string): void;
+  onPackageBuildComplete?(packageName: string): void;
+  onCombineStart?(): void;
+  onStepProgress?(progress: StepProgress): void;
+}
+
 /** Per-package build info collected during phase 1. */
 interface PackageBuildInfo {
   slug: string;
@@ -47,8 +57,9 @@ export async function generateCombinedProjectAsync(options: {
   repoRoot: string;
   batchPlaceId?: number;
   batchUniverseId?: number;
+  progress?: CombinedBuildProgress;
 }): Promise<CombinedProjectResult> {
-  const { packages, batchPlaceId, batchUniverseId } = options;
+  const { packages, batchPlaceId, batchUniverseId, progress } = options;
 
   if (packages.length === 0) {
     throw new Error('No packages provided for combined project generation');
@@ -64,6 +75,7 @@ export async function generateCombinedProjectAsync(options: {
 
   // ── Phase 1: Build each package individually ──
 
+  let buildIndex = 0;
   for (const pkg of packages) {
     const configPath = resolveDeployConfigPath(pkg.path);
     const config = await loadDeployConfigAsync(configPath);
@@ -92,7 +104,16 @@ export async function generateCombinedProjectAsync(options: {
     // Build this package's .rbxl
     const rbxlPath = buildContext.resolvePath(`${slug}.rbxl`);
     OutputHelper.verbose(`Building ${pkg.name} (${slug})...`);
+    progress?.onPackageBuildStart?.(pkg.name);
     await buildContext.rojoBuildAsync({ projectPath, output: rbxlPath });
+    buildIndex++;
+    progress?.onPackageBuildComplete?.(pkg.name);
+    progress?.onStepProgress?.({
+      kind: 'steps',
+      completed: buildIndex,
+      total: packages.length,
+      label: pkg.name,
+    });
 
     // Resolve scriptTemplate path
     if (!target.scriptTemplate) {
@@ -123,6 +144,12 @@ export async function generateCombinedProjectAsync(options: {
   OutputHelper.verbose(
     `Merging ${builds.length} packages into combined .rbxl...`
   );
+  progress?.onCombineStart?.();
+  progress?.onStepProgress?.({
+    kind: 'steps',
+    completed: 0,
+    total: builds.length,
+  });
   await buildContext.executeLuneTransformScriptAsync(luneScriptPath, ...luneArgs);
 
   OutputHelper.verbose(

package/src/utils/testing/runner/test-runner.ts

@@ -1,13 +1,13 @@
 import * as fs from 'fs/promises';
 import * as path from 'path';
 import { randomUUID } from 'crypto';
-import { type Reporter } from '@quenty/cli-output-helpers/reporting';
 import { type JobContext } from '../../job-context/job-context.js';
-import { parseTestLogs } from '../test-log-parser.js';
+import { type ParsedTestCounts, parseTestLogs, parseTestCounts } from '../test-log-parser.js';
 
 export interface SingleTestResult {
   success: boolean;
   logs: string;
+  testCounts?: ParsedTestCounts;
 }
 
 export interface SingleTestOptions {
@@ -26,7 +26,6 @@ export interface SingleTestOptions {
  */
 export async function runSingleTestAsync(
   context: JobContext,
-  reporter: Reporter,
   options: SingleTestOptions
 ): Promise<SingleTestResult> {
   const {
@@ -41,21 +40,20 @@ export async function runSingleTestAsync(
     targetName: 'test',
     outputFileName: `test-${sessionId}.rbxl`,
     packagePath,
-    reporter,
     packageName,
   });
 
   const scriptContent =
     scriptText ?? (await readTestScriptAsync(packagePath, builtPlace.target.scriptTemplate));
 
-  const deployment = await context.deployBuiltPlaceAsync(reporter, {
+  const deployment = await context.deployBuiltPlaceAsync({
     builtPlace,
     packageName,
     packagePath,
   });
 
   try {
-    const result = await context.runScriptAsync(deployment, reporter, {
+    const result = await context.runScriptAsync(deployment, {
       scriptContent,
       packageName,
       timeoutMs,
@@ -67,6 +65,7 @@ export async function runSingleTestAsync(
     return {
       success: result.success && parsed.success,
       logs: parsed.logs,
+      testCounts: parseTestCounts(parsed.logs),
     };
   } finally {
     await context.releaseAsync(deployment);

package/src/utils/testing/test-log-parser.ts

@@ -1,8 +1,15 @@
 import { OutputHelper } from '@quenty/cli-output-helpers';
 
+export interface ParsedTestCounts {
+  passed: number;
+  failed: number;
+  total: number;
+}
+
 export interface ParsedTestLogs {
   success: boolean;
   logs: string;
+  testCounts?: ParsedTestCounts;
 }
 
 /**
@@ -25,5 +32,31 @@ export function parseTestLogs(rawOutput: string): ParsedTestLogs {
   return {
     success: !hasJestFailures && !hasRuntimeError,
     logs: rawOutput,
+    testCounts: parseTestCounts(rawOutput),
   };
 }
+
+/**
+ * Parse Jest "Tests: N failed, N passed, N total" line into structured counts.
+ * Returns undefined if no test summary line is found.
+ */
+export function parseTestCounts(rawOutput: string): ParsedTestCounts | undefined {
+  const clean = OutputHelper.stripAnsi(rawOutput);
+
+  // Match "Tests:  2 failed, 23 passed, 25 total" or "Tests:  25 passed, 25 total"
+  const match = clean.match(/Tests:\s+(.+?)\s+total/);
+  if (!match) return undefined;
+
+  const prefix = match[1];
+  const totalMatch = clean.match(/Tests:\s+.+?(\d+)\s+total/);
+  if (!totalMatch) return undefined;
+
+  const total = parseInt(totalMatch[1], 10);
+  const passedMatch = prefix.match(/(\d+)\s+passed/);
+  const failedMatch = prefix.match(/(\d+)\s+failed/);
+
+  const passed = passedMatch ? parseInt(passedMatch[1], 10) : 0;
+  const failed = failedMatch ? parseInt(failedMatch[1], 10) : 0;
+
+  return { passed, failed, total };
+}

package/templates/batch-test-runner.luau

@@ -84,15 +84,6 @@ for _, slug in packageSlugs do
 	-- the marker in the log stream.
 	RunService.Heartbeat:Wait()
 
-	if testOk then
-		print("===BATCH_TEST_END " .. slug .. " PASS===")
-		table.insert(results, { slug = slug, success = true })
-	else
-		warn("[BatchTest] " .. slug .. ": " .. tostring(testErr))
-		print("===BATCH_TEST_END " .. slug .. " FAIL===")
-		table.insert(results, { slug = slug, success = false, error = tostring(testErr) })
-	end
-
 	-- CLEANUP: restore service state
 	allPackages[slug].Parent = nil
 	for _, c in workspace:GetChildren() do
@@ -119,6 +110,15 @@ for _, slug in packageSlugs do
 	for _ = 1, 3 do
 		RunService.Heartbeat:Wait()
 	end
+
+	if testOk then
+		print("===BATCH_TEST_END " .. slug .. " PASS===")
+		table.insert(results, { slug = slug, success = true })
+	else
+		warn("[BatchTest] " .. slug .. ": " .. tostring(testErr))
+		print("===BATCH_TEST_END " .. slug .. " FAIL===")
+		table.insert(results, { slug = slug, success = false, error = tostring(testErr) })
+	end
 end
 
 -- Restore all packages