@quenty/nevermore-cli 4.43.3 → 4.44.0

package/src/commands/install-package-command.ts

@@ -6,9 +6,17 @@ import { Argv, CommandModule } from 'yargs';
 import { OutputHelper } from '@quenty/cli-output-helpers';
 import { NevermoreGlobalArgs } from '../args/global-args.js';
 import { runCommandAsync } from '../utils/nevermore-cli-utils.js';
+import {
+  buildAddPackagesCommand,
+  detectPackageManagerAsync,
+  isPackageManager,
+  PACKAGE_MANAGERS,
+  PackageManager,
+} from '../utils/package-manager-utils.js';
 
 export interface InstallPackageArgs extends NevermoreGlobalArgs {
   packages: string[];
+  packageManager?: string;
 }
 
 /**
@@ -27,19 +35,65 @@ export class InstallPackageCommand<T>
     }
   }
 
+  /**
+   * Lists the published `@quenty/*` package names, without the scope.
+   *
+   * The registry caps search results at 250 per request, well under the number
+   * of published packages, so this pages through until the reported total is
+   * covered.
+   */
   private static async _getPackages(): Promise<string[]> {
+    const pageSize = 250;
+    const names = new Set<string>();
+
+    try {
+      let from = 0;
+      for (;;) {
+        const response = await fetch(
+          `https://registry.npmjs.org/-/v1/search?text=@quenty/&size=${pageSize}&from=${from}`
+        );
+        const data = await response.json();
+        const objects: any[] = data.objects ?? [];
+
+        for (const entry of objects) {
+          const name: string = entry.package?.name ?? '';
+          if (name.startsWith('@quenty/')) {
+            names.add(name.slice('@quenty/'.length));
+          }
+        }
+
+        from += objects.length;
+        if (objects.length < pageSize || from >= (data.total ?? 0)) {
+          break;
+        }
+      }
+    } catch {
+      return [];
+    }
+
+    return [...names].sort();
+  }
+
+  /**
+   * Asks the registry about one package directly. Returns undefined when the
+   * registry can't be reached, so an offline run doesn't look like a typo.
+   */
+  private static async _packageExistsAsync(
+    scopedName: string
+  ): Promise<boolean | undefined> {
     try {
       const response = await fetch(
-        'https://registry.npmjs.org/-/v1/search?text=@quenty/&size=1000'
+        `https://registry.npmjs.org/${scopedName.replace('/', '%2f')}`,
+        { method: 'HEAD' }
       );
-      const data = await response.json();
-      return data.objects
-        .map((obj: any) => obj.package.name)
-        .filter((name: string) => name.startsWith('@quenty/'))
-        .map((name: string) => name.replace('@quenty/', ''))
-        .sort();
+
+      if (response.status === 404) {
+        return false;
+      }
+
+      return response.ok ? true : undefined;
     } catch {
-      return [];
+      return undefined;
     }
   }
 
@@ -53,9 +107,34 @@ export class InstallPackageCommand<T>
         return packages.filter((name) => !current || name.startsWith(current));
       },
     });
+    args.option('package-manager', {
+      describe:
+        'Package manager to install with. Detected from the project by default.',
+      type: 'string',
+      choices: PACKAGE_MANAGERS as unknown as string[],
+    });
     return args as Argv<InstallPackageArgs>;
   }
 
+  private static async _resolvePackageManagerAsync(
+    args: InstallPackageArgs,
+    srcRoot: string
+  ): Promise<PackageManager> {
+    const requested = args.packageManager;
+    if (requested) {
+      if (!isPackageManager(requested)) {
+        throw new Error(
+          `Unsupported package manager '${requested}'. Expected one of: ${PACKAGE_MANAGERS.join(
+            ', '
+          )}`
+        );
+      }
+      return requested;
+    }
+
+    return detectPackageManagerAsync(srcRoot);
+  }
+
   public async handler(args: InstallPackageArgs) {
     const srcRoot = process.cwd();
 
@@ -67,22 +146,36 @@ export class InstallPackageCommand<T>
       InstallPackageCommand._validatePackageName(packageName)
     );
 
-    const availablePackages = await InstallPackageCommand._getPackages();
+    const prefixedPackages = args.packages.map(
+      (packageName) => `@quenty/${packageName}`
+    );
+
+    const existence = await Promise.all(
+      prefixedPackages.map((scopedName) =>
+        InstallPackageCommand._packageExistsAsync(scopedName)
+      )
+    );
     const invalidPackages = args.packages.filter(
-      (packageName) => !availablePackages.includes(packageName)
+      (_, index) => existence[index] === false
     );
 
     if (invalidPackages.length > 0) {
       throw new Error(`Invalid packages: ${invalidPackages.join(', ')}`);
     }
 
-    const prefixedPackages = args.packages.map(
-      (packageName) => `@quenty/${packageName}`
+    const packageManager =
+      await InstallPackageCommand._resolvePackageManagerAsync(args, srcRoot);
+
+    OutputHelper.info(
+      `Installing packages with ${packageManager}: ${args.packages.join(', ')}`
     );
 
-    OutputHelper.info(`Installing packages: ${args.packages.join(', ')}`);
+    const { command, args: commandArgs } = buildAddPackagesCommand(
+      packageManager,
+      prefixedPackages
+    );
 
-    await runCommandAsync(args, 'npm', ['install', ...prefixedPackages], {
+    await runCommandAsync(args, command, commandArgs, {
       cwd: srcRoot,
     });
   }

package/src/utils/deploy/deploy-github-columns.ts

@@ -11,16 +11,26 @@ export interface BatchDeployResult extends PackageResult {
   placeId: number;
 }
 
-/** Shared config for the deploy results GitHub comment reporter. */
-export function createDeployCommentConfig(): GithubCommentTableConfig {
+/**
+ * Shared config for the deploy results GitHub comment reporter.
+ *
+ * Takes the labels rather than fixing them, because a publish and a deploy are
+ * different words and the command already knows which it is doing. Without
+ * this the comment said "Failed" for a run whose terminal output said "DEPLOY
+ * FAILED" — the same run, described two ways.
+ */
+export function createDeployCommentConfig(labels?: {
+  successLabel?: string;
+  failureLabel?: string;
+}): GithubCommentTableConfig {
   return {
     heading: 'Deploy Results',
     commentMarker: '<!-- nevermore-deploy-results -->',
     sectionId: 'deploy',
     extraColumns: [createErrorColumn(), createTryItColumn()],
     errorHeading: 'Deploy Results',
-    successLabel: 'Deployed',
-    failureLabel: 'Failed',
+    successLabel: labels?.successLabel ?? 'Deployed',
+    failureLabel: labels?.failureLabel ?? 'DEPLOY FAILED',
     summaryVerb: 'deployed',
   };
 }

package/src/utils/deploy/deploy-metadata.ts

@@ -25,7 +25,7 @@ export type DeployMetadataAttributes = Record<
 const INJECT_SCRIPT_PATH = resolvePackagePath(
   import.meta.url,
   'build-scripts',
-  'transform-inject-deploy-metadata.luau'
+  'transform-inject-deploy-metadata.lua'
 );
 
 function _git(args: string[]): string | undefined {

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

@@ -17,6 +17,7 @@ import {
   type DeployPlaceOptions,
   type RunScriptOptions,
   type ScriptRunResult,
+  type JobLogs,
 } from './job-context.js';
 import { type OpenCloudClient } from '../open-cloud/open-cloud-client.js';
 import { type BasePlaceResolver } from '@quenty/nevermore-deploy';
@@ -24,7 +25,7 @@ import { type BasePlaceResolver } from '@quenty/nevermore-deploy';
 const MERGE_SCRIPT_PATH = resolvePackagePath(
   import.meta.url,
   'build-scripts',
-  'transform-rojo-merge-place.luau'
+  'transform-rojo-merge-place.lua'
 );
 
 interface SharedRojoBuild {
@@ -300,7 +301,7 @@ export abstract class BaseJobContext implements JobContext {
     deployment: Deployment,
     options: RunScriptOptions
   ): Promise<ScriptRunResult>;
-  abstract getLogsAsync(deployment: Deployment): Promise<string>;
+  abstract getLogsAsync(deployment: Deployment): Promise<JobLogs>;
   abstract releaseAsync(deployment: Deployment): Promise<void>;
 
   async disposeAsync(): Promise<void> {

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

@@ -12,6 +12,7 @@ import {
   type JobContext,
   type RunScriptOptions,
   type ScriptRunResult,
+  type JobLogs,
 } from './job-context.js';
 import { type BuildPlaceOptions } from '../build/build.js';
 import { type BatchTarget } from '../batch/changed-packages-utils.js';
@@ -21,9 +22,15 @@ import {
   generateCombinedProjectAsync,
 } from '../testing/runner/combined-project-generator.js';
 import {
+  type BatchDiagnosticLevel,
   type BatchPackageResult,
   parseBatchTestLogs,
 } from '../testing/parsers/batch-log-parser.js';
+import { type LogFetchStats } from '../testing/log-fetch-stats.js';
+import {
+  toRenderableLines,
+  type RenderableLogLine,
+} from '../testing/parsers/batch-log-renderer.js';
 
 /** Per-package deployment handle. Wraps a shared inner deployment. */
 class BatchDeployment implements Deployment {
@@ -50,6 +57,28 @@ interface CombinedBuildState {
  * package configured with one — those belong in `nevermore batch test
  * --no-aggregated`, or in an integration deploy.
  */
+/**
+ * Everything one aggregated batch produced, as data.
+ *
+ * The execution used to parse, render and print from in here. Printing from a
+ * job context put presentation in the transport, bypassed whatever reporter the
+ * command had chosen — output written straight to the console is invisible to a
+ * SpinnerReporter's capture — and left the whole path untestable without spying
+ * on `console.log`. The context returns this instead, and the command layer
+ * decides what to show.
+ */
+export interface BatchExecutionOutcome {
+  results: Map<string, BatchPackageResult>;
+  /** The run's output, typed by severity and not yet rendered. */
+  lines: RenderableLogLine[];
+  /** What the fetch had to do to collect it; absent for a transport that cannot say. */
+  stats?: LogFetchStats;
+  /** What reading the log turned up, to report after the log itself. */
+  diagnostics: Array<{ level: BatchDiagnosticLevel; message: string }>;
+  /** Section slug to package name, for whoever titles the sections. */
+  slugToPackage: Map<string, string>;
+}
+
 export class BatchScriptJobContext implements JobContext {
   private _inner: JobContext;
   private _batchTargets: BatchTarget[];
@@ -62,7 +91,7 @@ export class BatchScriptJobContext implements JobContext {
   // Lazy-promise state
   private _combinedBuildPromise?: Promise<CombinedBuildState>;
   private _deployPromise?: Promise<Deployment>;
-  private _executionPromise?: Promise<Map<string, BatchPackageResult>>;
+  private _executionPromise?: Promise<BatchExecutionOutcome>;
 
   // State for cleanup
   private _combinedBuildContext?: BuildContext;
@@ -124,8 +153,8 @@ export class BatchScriptJobContext implements JobContext {
     options: RunScriptOptions
   ): Promise<ScriptRunResult> {
     const batchDeployment = deployment as BatchDeployment;
-    const packageResults = await this._getBatchExecutionAsync();
-    const result = packageResults.get(batchDeployment.packageName);
+    const { results } = await this._getBatchExecutionAsync();
+    const result = results.get(batchDeployment.packageName);
 
     if (!result) {
       return { success: false };
@@ -135,15 +164,39 @@ export class BatchScriptJobContext implements JobContext {
       success: result.success,
       durationMs: result.durationMs,
       errorMessage: result.error,
+      // returnValues stays absent: one execution covers every package, so
+      // nothing it returns belongs to any single one of them. The batch runner
+      // folds each package's own results into the batch summary, which the log
+      // parser has already split back out — so they are handed over decoded
+      // rather than left for the caller to find in a return value that is not
+      // this package's.
+      testResults: result.testResults,
+      logsLost: result.logsLost,
     };
   }
 
-  async getLogsAsync(deployment: Deployment): Promise<string> {
-    const batchDeployment = deployment as BatchDeployment;
-    const packageResults = await this._getBatchExecutionAsync();
-    const result = packageResults.get(batchDeployment.packageName);
+  /**
+   * Run the batch if it has not run, and hand back everything it produced.
+   *
+   * Public so the command layer can render the run once, before the
+   * per-package loop asks for results — which is also what keeps the shared
+   * build and upload out of any one package's async context.
+   */
+  async getExecutionOutcomeAsync(): Promise<BatchExecutionOutcome> {
+    return this._getBatchExecutionAsync();
+  }
 
-    return result?.logs ?? '';
+  async getLogsAsync(deployment: Deployment): Promise<JobLogs> {
+    const batchDeployment = deployment as BatchDeployment;
+    const { results, stats } = await this._getBatchExecutionAsync();
+    const result = results.get(batchDeployment.packageName);
+
+    // The text is this package's section; the stats describe the one fetch that
+    // pulled every section, which is what happened to any package whose own
+    // section went missing from it. Messages stay empty: severity is per
+    // message across the whole window, and slicing it per package would need
+    // the section boundaries the parser already resolved.
+    return { text: result?.logs ?? '', messages: [], stats };
   }
 
   async releaseAsync(_deployment: Deployment): Promise<void> {
@@ -257,7 +310,7 @@ export class BatchScriptJobContext implements JobContext {
     return deployment;
   }
 
-  private _getBatchExecutionAsync(): Promise<Map<string, BatchPackageResult>> {
+  private _getBatchExecutionAsync(): Promise<BatchExecutionOutcome> {
     if (!this._executionPromise) {
       this._executionPromise = this._doBatchExecutionAsync();
       // On rejection, clear the promise so that a retry re-triggers the batch
@@ -268,9 +321,7 @@ export class BatchScriptJobContext implements JobContext {
     return this._executionPromise;
   }
 
-  private async _doBatchExecutionAsync(): Promise<
-    Map<string, BatchPackageResult>
-  > {
+  private async _doBatchExecutionAsync(): Promise<BatchExecutionOutcome> {
     const buildState = await this._getCombinedBuildAsync();
     const deployment = await this._getSharedDeploymentAsync();
     const { slugMap } = buildState.combinedResult;
@@ -278,7 +329,7 @@ export class BatchScriptJobContext implements JobContext {
     // Build the batch Luau script from the template
     const templatePath = resolveTemplatePath(
       import.meta.url,
-      'batch-test-runner.luau'
+      'batch-test-runner.lua'
     );
     const template = await fs.readFile(templatePath, 'utf-8');
 
@@ -300,8 +351,9 @@ export class BatchScriptJobContext implements JobContext {
       timeoutMs: this._batchTimeoutMs,
     });
 
-    // Fetch the combined logs
-    const rawLogs = await this._inner.getLogsAsync(deployment);
+    // Fetch the combined logs, with the severity and fetch that produced them.
+    const logs = await this._inner.getLogsAsync(deployment);
+    const rawLogs = logs.text;
 
     if (!result.success) {
       const stateInfo = result.taskState ? ` (state: ${result.taskState})` : '';
@@ -319,7 +371,36 @@ export class BatchScriptJobContext implements JobContext {
       OutputHelper.verbose(`Raw batch logs:\n${rawLogs || '(empty)'}`);
     }
 
-    // Parse into per-package results
-    return parseBatchTestLogs(rawLogs, slugMap);
+    // Parse into per-package results. Diagnostics are collected rather than
+    // printed: they describe the log window, so they belong after it, and that
+    // is the caller's ordering to make.
+    const diagnostics: Array<{ level: BatchDiagnosticLevel; message: string }> =
+      [];
+    const results = parseBatchTestLogs(rawLogs, slugMap, {
+      logFetchStats: logs.stats,
+      // The batch script returns the same summary it prints. Handing both over
+      // lets the parser read the copy that cannot arrive truncated, and fall
+      // back to the printed one on a transport that carries no return channel.
+      returnValues: result.returnValues,
+      onDiagnostic: (level, message) => diagnostics.push({ level, message }),
+    });
+
+    const slugToPackage = new Map<string, string>();
+    for (const [packageName, slug] of slugMap) {
+      slugToPackage.set(slug, packageName);
+    }
+
+    // Typed messages when the transport carries severity; otherwise the joined
+    // text, which renders uncolored rather than guessed at.
+    const messages =
+      logs.messages.length > 0 ? logs.messages : [{ message: rawLogs }];
+
+    return {
+      results,
+      lines: toRenderableLines(messages),
+      stats: logs.stats,
+      diagnostics,
+      slugToPackage,
+    };
   }
 }

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

@@ -0,0 +1,112 @@
+/**
+ * Unit tests for CloudJobContext.runScriptAsync — validates what a finished
+ * Open Cloud task reports back as a ScriptRunResult, in particular that a task
+ * which produced no output stays distinguishable from one that returned nothing.
+ */
+
+import { describe, it, expect, vi, afterEach } from 'vitest';
+import { type Reporter } from '@quenty/cli-output-helpers/reporting';
+import { CloudJobContext } from './cloud-job-context.js';
+import {
+  type LuauTask,
+  type OpenCloudClient,
+} from '../open-cloud/open-cloud-client.js';
+import { type Deployment } from './job-context.js';
+
+function createReporter(): Reporter {
+  return {
+    onPackagePhaseChange: vi.fn(),
+    onPackageProgressUpdate: vi.fn(),
+    onPackageStart: vi.fn(),
+    onPackageResult: vi.fn(),
+  } as unknown as Reporter;
+}
+
+/**
+ * A client whose task completes as `completedTask`. The real deployment handle
+ * is private to the context, so the test passes the three fields runScriptAsync
+ * reads off it.
+ */
+function createContext(completedTask: Partial<LuauTask>) {
+  const task = {
+    path: 'universes/1/places/2/versions/3/luau-execution-session-tasks/4',
+    createTime: '2026-01-01T00:00:00Z',
+    updateTime: '2026-01-01T00:01:00Z',
+    user: 'users/1',
+    state: 'COMPLETE',
+    script: 'return 1',
+    ...completedTask,
+  } as LuauTask;
+
+  const client = {
+    createExecutionTaskAsync: vi.fn(async () => task),
+    pollTaskCompletionAsync: vi.fn(async () => task),
+  } as unknown as OpenCloudClient;
+
+  const context = new CloudJobContext(createReporter(), client);
+  const deployment = {
+    universeId: 1,
+    placeId: 2,
+    version: 3,
+  } as unknown as Deployment;
+
+  return { context, deployment };
+}
+
+describe('CloudJobContext.runScriptAsync', () => {
+  afterEach(() => {
+    vi.useRealTimers();
+  });
+
+  it('reports the values the script returned', async () => {
+    // Fake timers keep the client-side timeout race from leaving a live timer
+    // behind; nothing in the run itself waits on one.
+    vi.useFakeTimers();
+    const { context, deployment } = createContext({
+      state: 'COMPLETE',
+      output: { results: [{ slug: 'maid', counts: { passed: 1014 } }] },
+    });
+
+    const result = await context.runScriptAsync(deployment, {
+      scriptContent: 'return results',
+      packageName: 'maid',
+    });
+
+    expect(result.success).toBe(true);
+    expect(result.returnValues).toEqual([
+      { slug: 'maid', counts: { passed: 1014 } },
+    ]);
+  });
+
+  it('reports an empty result when the task returned nothing', async () => {
+    vi.useFakeTimers();
+    const { context, deployment } = createContext({
+      state: 'COMPLETE',
+      output: {},
+    });
+
+    const result = await context.runScriptAsync(deployment, {
+      scriptContent: 'print("hi")',
+      packageName: 'maid',
+    });
+
+    expect(result.returnValues).toEqual([]);
+  });
+
+  it('leaves returnValues absent when a failed task carried no output', async () => {
+    vi.useFakeTimers();
+    const { context, deployment } = createContext({
+      state: 'FAILED',
+      output: undefined,
+    });
+
+    const result = await context.runScriptAsync(deployment, {
+      scriptContent: 'return huge',
+      packageName: 'maid',
+    });
+
+    expect(result.success).toBe(false);
+    expect(result.taskState).toBe('FAILED');
+    expect(result.returnValues).toBeUndefined();
+  });
+});

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

@@ -1,5 +1,6 @@
 import { type Reporter } from '@quenty/cli-output-helpers/reporting';
 import {
+  getTaskReturnValues,
   type LuauTask,
   type OpenCloudClient,
 } from '../open-cloud/open-cloud-client.js';
@@ -8,6 +9,7 @@ import { buildPlaceNameAsync, timeoutAsync } from '../nevermore-cli-utils.js';
 import {
   type Deployment,
   type DeployPlaceOptions,
+  type JobLogs,
   type RunScriptOptions,
   type ScriptRunResult,
 } from './job-context.js';
@@ -134,27 +136,31 @@ export class CloudJobContext extends BaseJobContext {
       success: completedTask.state === 'COMPLETE',
       taskState: completedTask.state,
       errorMessage,
+      returnValues: getTaskReturnValues(completedTask),
     };
   }
 
-  async getLogsAsync(deployment: Deployment): Promise<string> {
+  async getLogsAsync(deployment: Deployment): Promise<JobLogs> {
     const cloudDeployment = deployment as CloudDeployment;
 
     if (!cloudDeployment.taskPath) {
       throw new Error('No task has been run yet');
     }
 
-    const logs = await this._openCloudClient!.getRawTaskLogsAsync(
+    const fetched = await this._openCloudClient!.getRawTaskLogsAsync(
       cloudDeployment.taskPath
     );
 
     if (cloudDeployment.taskState && cloudDeployment.taskState !== 'COMPLETE') {
-      return [logs, `Task ended with state: ${cloudDeployment.taskState}`]
-        .filter(Boolean)
-        .join('\n');
+      const note = `Task ended with state: ${cloudDeployment.taskState}`;
+      return {
+        text: [fetched.text, note].filter(Boolean).join('\n'),
+        messages: [...fetched.messages, { message: note }],
+        stats: fetched.stats,
+      };
     }
 
-    return logs;
+    return fetched;
   }
 
   async releaseAsync(_deployment: Deployment): Promise<void> {