@quenty/nevermore-cli 4.50.1 → 4.52.0

package/src/commands/batch-command/batch-test-command.ts

@@ -11,6 +11,8 @@ import { getApiKeyAsync } from '@quenty/nevermore-cli-helpers';
 import { runBatchAsync } from '../../utils/batch/batch-runner.js';
 import { renderBatchOutcome } from '../../utils/testing/parsers/batch-log-renderer.js';
 import { emitDiagnostic } from '../../utils/testing/parsers/batch-log-parser.js';
+import { type DeployTarget } from '@quenty/nevermore-deploy';
+import { type BuildContext } from '@quenty/nevermore-template-helpers';
 import { createBasePlaceResolver } from '../../utils/build/base-place-resolver-factory.js';
 import {
   type JobContext,
@@ -37,9 +39,13 @@ import {
   createTestCommentConfig,
 } from '../../utils/testing/reporting/index.js';
 import {
+  executePreparedTestAsync,
   runSingleTestAsync,
+  type SingleTestOptions,
   type SingleTestResult,
 } from '../../utils/testing/runner/test-runner.js';
+import { type CombinedPlaceChunk } from '../../utils/testing/runner/combined-project-generator.js';
+import { readPrebuiltBatchBundleAsync } from '../../utils/testing/runner/prebuilt-batch-bundle.js';
 import { isCI } from '../../utils/nevermore-cli-utils.js';
 
 interface BatchTestArgs extends NevermoreGlobalArgs {
@@ -56,6 +62,7 @@ interface BatchTestArgs extends NevermoreGlobalArgs {
   batchUniverseId?: number;
   maxPlaceMb?: number;
   timeout?: number;
+  bundle?: string;
 }
 
 export const batchTestCommand: CommandModule<
@@ -129,6 +136,14 @@ export const batchTestCommand: CommandModule<
             'Max script execution time in seconds for the whole batch. Sent to the Open Cloud API so Roblox cancels server-side on overrun. Max 300s (API limit). (default: 300)',
           type: 'number',
         })
+        .option('bundle', {
+          describe:
+            'Run the places in a *.nevermore.tests.tar written by "batch bundle --test" instead of finding ' +
+            'and building packages. The bundle never chooses where it is uploaded: ' +
+            'that is --batch-place-id/--batch-universe-id, or else the test place this ' +
+            'checkout gives one of its packages.',
+          type: 'string',
+        })
         // Accepted only to fail with a useful message. A batch runs one shared
         // script across packages, so there is nothing for arbitrary Luau to mean
         // here — but yargs strict mode would otherwise reject it with a bare
@@ -137,14 +152,30 @@ export const batchTestCommand: CommandModule<
           hidden: true,
           type: 'string',
         })
+        .option('script-file', {
+          hidden: true,
+          type: 'string',
+        })
         .check((args) => {
-          if (args.scriptText !== undefined) {
+          if (args.scriptText !== undefined || args.scriptFile !== undefined) {
             throw new Error(
-              '--script-text is not supported by "batch test", which runs one shared script for all packages.\n' +
+              '--script-text and --script-file are not supported by "batch test", which runs one shared script for all packages.\n' +
                 'Run it against a single package instead:\n' +
                 '  cd <package> && nevermore test --cloud --script-text \'print("hi")\''
             );
           }
+          if (args.bundle !== undefined) {
+            if (args.all || args.limit !== undefined) {
+              throw new Error(
+                '--bundle runs every package in the bundle; drop --all and --limit.'
+              );
+            }
+            if (args.aggregated === false) {
+              throw new Error(
+                '--bundle runs an aggregated batch; drop --no-aggregated.'
+              );
+            }
+          }
           return true;
         })
     );
@@ -160,12 +191,38 @@ export const batchTestCommand: CommandModule<
 };
 
 async function _runAsync(args: BatchTestArgs): Promise<void> {
-  let packages = args.all
-    ? await discoverAllTestableBatchTargetsAsync()
-    : await discoverChangedTestableBatchTargetsAsync(args.base!);
+  const prebuilt =
+    args.bundle !== undefined
+      ? await _loadPrebuiltRunAsync(args, args.bundle)
+      : undefined;
+  let exitCode: number | undefined;
+  try {
+    exitCode = await _runPackagesAsync(args, prebuilt);
+  } finally {
+    await prebuilt?.buildContext.cleanupAsync();
+  }
+
+  // Node.js fetch (undici) keeps TCP connections alive in a global pool,
+  // which prevents the event loop from draining. Explicit exit required.
+  if (exitCode !== undefined) {
+    process.exit(exitCode);
+  }
+}
 
-  if (args.limit && args.limit > 0) {
-    packages = packages.slice(0, args.limit);
+async function _runPackagesAsync(
+  args: BatchTestArgs,
+  prebuilt: PrebuiltRun | undefined
+): Promise<number | undefined> {
+  let packages: BatchTarget[];
+  if (prebuilt) {
+    packages = prebuilt.packages;
+  } else {
+    packages = args.all
+      ? await discoverAllTestableBatchTargetsAsync()
+      : await discoverChangedTestableBatchTargetsAsync(args.base!);
+    if (args.limit && args.limit > 0) {
+      packages = packages.slice(0, args.limit);
+    }
   }
 
   if (packages.length === 0) {
@@ -173,7 +230,7 @@ async function _runAsync(args: BatchTestArgs): Promise<void> {
       'No testable packages found. Packages need a deploy.nevermore.json with a "test" target.\n' +
         'Run "nevermore deploy init" inside a package to set one up.'
     );
-    return;
+    return undefined;
   }
 
   if (args.dryrun) {
@@ -181,7 +238,7 @@ async function _runAsync(args: BatchTestArgs): Promise<void> {
     OutputHelper.info(
       `[DRYRUN] Would test ${packages.length} packages: ${names}`
     );
-    return;
+    return undefined;
   }
 
   const cloud = args.cloud ?? false;
@@ -273,8 +330,8 @@ async function _runAsync(args: BatchTestArgs): Promise<void> {
 
   const batchContext = aggregated
     ? new BatchScriptJobContext(innerContext, packages, {
-        batchPlaceId: args.batchPlaceId,
-        batchUniverseId: args.batchUniverseId,
+        batchPlaceId: prebuilt?.target.placeId ?? args.batchPlaceId,
+        batchUniverseId: prebuilt?.target.universeId ?? args.batchUniverseId,
         batchTimeoutMs: timeoutMs,
         // Only an upload is size-limited, so a local run stays one place
         // unless asked to split.
@@ -285,6 +342,10 @@ async function _runAsync(args: BatchTestArgs): Promise<void> {
             ? undefined
             : Infinity,
         reporter,
+        prebuilt: prebuilt && {
+          chunks: prebuilt.chunks,
+          buildContext: prebuilt.buildContext,
+        },
       })
     : undefined;
   const context: JobContext = batchContext ?? innerContext;
@@ -326,7 +387,8 @@ async function _runAsync(args: BatchTestArgs): Promise<void> {
           pkg,
           context,
           timeoutMs,
-          aggregated
+          aggregated,
+          prebuilt?.hasJestConfig.get(pkg.name)
         );
 
         return {
@@ -360,19 +422,17 @@ async function _runAsync(args: BatchTestArgs): Promise<void> {
   }
 
   await reporter.stopAsync();
-
-  // Node.js fetch (undici) keeps TCP connections alive in a global pool,
-  // which prevents the event loop from draining. Explicit exit required.
-  process.exit(exitCode);
+  return exitCode;
 }
 
 async function _runWithRetryAsync(
   pkg: BatchTarget,
   context: JobContext,
   timeoutMs: number,
-  aggregated: boolean
+  aggregated: boolean,
+  prebuiltHasJestConfig: boolean | undefined
 ): Promise<SingleTestResult> {
-  const opts = {
+  const opts: SingleTestOptions = {
     packagePath: pkg.path,
     packageName: pkg.name,
     timeoutMs,
@@ -382,11 +442,95 @@ async function _runWithRetryAsync(
     suppressCountsProvenance: aggregated,
   };
 
+  if (prebuiltHasJestConfig !== undefined) {
+    return _retryOnTransientAsync(pkg.name, async () =>
+      executePreparedTestAsync(
+        context,
+        {
+          builtPlace: await context.buildPlaceAsync(opts),
+          scriptContent: '',
+          hasJestConfig: prebuiltHasJestConfig,
+        },
+        opts
+      )
+    );
+  }
+
   return _retryOnTransientAsync(pkg.name, () =>
     runSingleTestAsync(context, opts)
   );
 }
 
+interface PrebuiltRun {
+  target: DeployTarget;
+  packages: BatchTarget[];
+  chunks: CombinedPlaceChunk[];
+  hasJestConfig: Map<string, boolean>;
+  buildContext: BuildContext;
+}
+
+async function _loadPrebuiltRunAsync(
+  args: BatchTestArgs,
+  bundleFile: string
+): Promise<PrebuiltRun> {
+  const bundle = await readPrebuiltBatchBundleAsync(bundleFile);
+  let target: DeployTarget;
+  try {
+    target = await _resolvePrebuiltTargetAsync(
+      args,
+      new Set(bundle.packages.map((p) => p.name))
+    );
+  } catch (err) {
+    await bundle.buildContext.cleanupAsync();
+    throw err;
+  }
+
+  OutputHelper.info(
+    `Running ${bundle.packages.length} prebuilt package${
+      bundle.packages.length === 1 ? '' : 's'
+    } in ${bundle.chunks.length} place${
+      bundle.chunks.length === 1 ? '' : 's'
+    } on place ${target.placeId}.`
+  );
+
+  return {
+    target,
+    packages: bundle.packages.map((p) => ({
+      name: p.name,
+      packageName: p.name,
+      path: process.cwd(),
+      target,
+    })),
+    chunks: bundle.chunks,
+    hasJestConfig: new Map(
+      bundle.packages.map((p) => [p.name, p.hasJestConfig])
+    ),
+    buildContext: bundle.buildContext,
+  };
+}
+
+/**
+ * Where a bundle uploads to, picked the way a normal batch run picks it: the
+ * test place of one of its packages, read from this checkout rather than from
+ * the bundle.
+ */
+async function _resolvePrebuiltTargetAsync(
+  args: BatchTestArgs,
+  bundledNames: Set<string>
+): Promise<DeployTarget> {
+  const known = await discoverAllTestableBatchTargetsAsync();
+  const base = known.find((t) => bundledNames.has(t.name)) ?? known[0];
+  const universeId = args.batchUniverseId ?? base?.target.universeId;
+  const placeId = args.batchPlaceId ?? base?.target.placeId;
+  if (!universeId || !placeId) {
+    throw new Error(
+      'No test place to upload the bundle to: this checkout has no testable ' +
+        'package. Pass --batch-place-id and --batch-universe-id.'
+    );
+  }
+  return { universeId, placeId, project: '' };
+}
+
 /**
  * Run something once more if it failed for a reason that tends not to repeat.
  *

package/src/commands/batch-command/index.ts

@@ -1,5 +1,6 @@
 import { Argv, CommandModule } from 'yargs';
 import { NevermoreGlobalArgs } from '../../args/global-args.js';
+import { batchBundleCommand } from './batch-bundle-command.js';
 import { batchDeployCommand } from './batch-deploy-command.js';
 import { batchTestCommand } from './batch-test-command.js';
 
@@ -8,6 +9,7 @@ export class BatchCommand<T> implements CommandModule<T, NevermoreGlobalArgs> {
   public describe = 'Run operations across multiple packages';
 
   public builder = (args: Argv<T>) => {
+    args.command(batchBundleCommand as any);
     args.command(batchDeployCommand as any);
     args.command(batchTestCommand as any);
     return args as Argv<NevermoreGlobalArgs>;

package/src/commands/deploy-command/index.ts

@@ -711,6 +711,13 @@ export class DeployCommand<T> implements CommandModule<T, DeployArgs> {
           return {
             packageName: buildTarget.name,
             placeId: uploadedTarget.placeId,
+            universeId: uploadedTarget.universeId,
+            target: targetName,
+            version,
+            published: publish,
+            basePlaceVersion: builtPlace.basePlaceVersion,
+            commit: deployGitInfo.version,
+            branch: deployGitInfo.branch,
             success: true,
             logs: `${action} v${version}`,
             progressSummary: {

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

@@ -1,3 +1,4 @@
+import * as fs from 'fs/promises';
 import * as path from 'path';
 import { Argv, CommandModule } from 'yargs';
 import { OutputHelper } from '@quenty/cli-output-helpers';
@@ -36,6 +37,7 @@ export interface TestProjectArgs extends NevermoreGlobalArgs {
   placeId?: number;
   scriptTemplate?: string;
   scriptText?: string;
+  scriptFile?: string;
   output?: string;
   timeout?: number;
 }
@@ -58,7 +60,7 @@ export class TestProjectCommand<T>
     });
     args.option('logs', {
       describe:
-        'Show execution logs. Defaults on with --script-text, whose output is the whole point of the run',
+        'Show execution logs. Defaults on with --script-text and --script-file, whose output is the whole point of the run',
       type: 'boolean',
     });
     args.option('universe-id', {
@@ -78,6 +80,12 @@ export class TestProjectCommand<T>
       describe:
         'Luau code to execute directly instead of the configured script template',
       type: 'string',
+      conflicts: 'script-file',
+    });
+    args.option('script-file', {
+      describe:
+        'Path to a Luau file to execute directly, like --script-text but without the command line length limit',
+      type: 'string',
     });
     args.option('output', {
       describe: 'Write JSON results to this file',
@@ -98,7 +106,16 @@ export class TestProjectCommand<T>
     // A probe run exists to show its output. Hiding it behind an opt-in flag
     // made --script-text look broken enough that a workaround was written into
     // the docs instead of a bug report.
-    const showLogs = args.logs ?? args.scriptText !== undefined;
+    let scriptText = args.scriptText;
+    if (args.scriptFile !== undefined) {
+      try {
+        scriptText = await fs.readFile(args.scriptFile, 'utf-8');
+      } catch {
+        OutputHelper.error(`Script file not found: ${args.scriptFile}`);
+        process.exit(1);
+      }
+    }
+    const showLogs = args.logs ?? scriptText !== undefined;
     const useSpinner = process.stdout.isTTY && !args.verbose;
 
     const reporter = new CompositeReporter(
@@ -168,7 +185,7 @@ export class TestProjectCommand<T>
             placeId: args.placeId,
             scriptTemplate: args.scriptTemplate,
           },
-          scriptText: args.scriptText,
+          scriptText,
           timeoutMs:
             args.timeout !== undefined ? args.timeout * 1000 : undefined,
         });

package/src/commands/tools-command/ci-post-deploy-results.ts

@@ -49,8 +49,8 @@ export const ciPostDeployResultsCommand: CommandModule<
       .option('run-outcome', {
         describe:
           'Outcome of the deploy step (e.g. "success", "failure"). ' +
-          'When the results file is missing and run-outcome is "success", ' +
-          'posts a neutral "no deploys" comment instead of an error.',
+          'When the results file is missing, "success" posts a neutral comment, ' +
+          '"cancelled" posts nothing, and anything else posts a failure.',
         type: 'string',
       });
   },
@@ -62,6 +62,13 @@ export const ciPostDeployResultsCommand: CommandModule<
       } catch {
         OutputHelper.warn(`Results file not found: ${args.input}`);
 
+        if (args.runOutcome === 'cancelled') {
+          OutputHelper.info(
+            'Deploy step was cancelled; leaving the PR comment to the run that replaced it.'
+          );
+          return;
+        }
+
         const reporters = _createGithubReporters(undefined);
 
         if (args.runOutcome === 'success') {

package/src/commands/tools-command/ci-post-test-results.ts

@@ -27,6 +27,7 @@ type ErrorReporter = Reporter & {
 interface CiPostTestResultsArgs extends NevermoreGlobalArgs {
   input: string;
   runOutcome?: string;
+  sourcemap?: string;
 }
 
 /** Create the standard set of GitHub reporters for posting results. */
@@ -58,8 +59,14 @@ export const ciPostTestResultsCommand: CommandModule<
       .option('run-outcome', {
         describe:
           'Outcome of the test step (e.g. "success", "failure"). ' +
-          'When the results file is missing and run-outcome is "success", ' +
-          'posts a neutral "no tests" comment instead of an error.',
+          'When the results file is missing, "success" posts a neutral comment, ' +
+          '"cancelled" posts nothing, and anything else posts a failure.',
+        type: 'string',
+      })
+      .option('sourcemap', {
+        describe:
+          'Sourcemap that test failure annotations resolve files against ' +
+          '(default: sourcemap.json in the current directory)',
         type: 'string',
       });
   },
@@ -71,6 +78,13 @@ export const ciPostTestResultsCommand: CommandModule<
       } catch {
         OutputHelper.warn(`Results file not found: ${args.input}`);
 
+        if (args.runOutcome === 'cancelled') {
+          OutputHelper.info(
+            'Test step was cancelled; leaving the PR comment to the run that replaced it.'
+          );
+          return;
+        }
+
         const reporters = _createGithubReporters(undefined);
 
         if (args.runOutcome === 'success') {
@@ -100,7 +114,10 @@ export const ciPostTestResultsCommand: CommandModule<
       }
 
       // Emit test failure annotations
-      const sourcemapResolver = tryLoadSourcemapResolver(process.cwd());
+      const sourcemapResolver = tryLoadSourcemapResolver(
+        process.cwd(),
+        args.sourcemap
+      );
       const workspace = await tryLoadAnnotationWorkspaceAsync(process.cwd());
       const parsedDiagnostics: Diagnostic[] = [];
       for (const failure of state.getFailures()) {

package/src/utils/batch/changed-packages-utils.ts

@@ -126,6 +126,29 @@ export async function discoverChangedTestableBatchTargetsAsync(
   return _requireScriptTemplate(flattenToBatchTargets(packages));
 }
 
+/**
+ * The places `batch deploy` deploys, and `batch bundle --deploy` builds for a
+ * later deploy. One function so the two can never pick different places: a
+ * fork's bundle must hold what a same-repo run would have deployed.
+ */
+export async function discoverDeployBatchTargetsAsync(options: {
+  targetName: string;
+  all?: boolean;
+  base: string;
+  limit?: number;
+}): Promise<BatchTarget[]> {
+  const discovered = options.all
+    ? await discoverAllTargetPackagesAsync(options.targetName)
+    : await discoverChangedTargetPackagesAsync(
+        options.base,
+        options.targetName
+      );
+  const batchTargets = flattenToBatchTargets(discovered);
+  return options.limit && options.limit > 0
+    ? batchTargets.slice(0, options.limit)
+    : batchTargets;
+}
+
 /**
  * Fan a list of TargetPackages out into BatchTargets — one per place. A
  * single-place package produces one BatchTarget with the package name; a

package/src/utils/build/build.ts

@@ -10,6 +10,12 @@ export interface DeployOverrides {
   placeId?: number;
   scriptTemplate?: string;
   placeFile?: string;
+  /**
+   * Rojo project the base place merge grafts by, in place of the target's own.
+   * Set together with `placeFile` when the place was built from a different
+   * checkout, so the merge follows the project that built it.
+   */
+  projectFile?: string;
 }
 
 export interface BuildPlaceOptions {
@@ -35,6 +41,7 @@ export interface BuildPlaceOptions {
   overrides?: DeployOverrides;
   reporter?: Reporter;
   packageName?: string;
+  deferBasePlaceMerge?: boolean;
 }
 
 /**

package/src/utils/bundle/untrusted-tar.ts

@@ -0,0 +1,160 @@
+import { createReadStream, createWriteStream } from 'fs';
+import * as path from 'path';
+import * as tar from 'tar';
+
+// 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)").
+export const PACKAGE_NAME_PATTERN = /^@?[\p{L}\p{N} /()+.,'_~-]{1,200}$/u;
+
+export type BundleKind = 'tests' | 'deploy';
+
+const RUN_COMMANDS: Record<BundleKind, string> = {
+  tests: 'nevermore batch test --bundle <file>',
+  deploy: 'nevermore batch deploy --bundle <file>',
+};
+
+export interface UntrustedTarOptions {
+  kind: BundleKind;
+  /** The one entry read into memory rather than written to `dir`. */
+  manifestName: string;
+  maxManifestBytes: number;
+  /** Every other entry must pass this, by its exact path in the archive. */
+  isEntryAllowed: (name: string) => boolean;
+  maxEntries: number;
+  /** Message for an archive holding more than `maxEntries` entries. */
+  maxEntriesMessage: string;
+  /** Returns an error message when `size` is too large for this entry. */
+  checkEntrySize: (name: string, size: number) => string | undefined;
+}
+
+export interface UntrustedTarContents {
+  manifestText: string;
+  /** Size of each entry written into `dir`, keyed by its archive path. */
+  entrySizes: Map<string, number>;
+}
+
+/**
+ * Read a bundle written by a fork's CI run into `dir`. Entries are read from the
+ * archive, never extracted by it: only regular files whose paths match
+ * `entryPattern` (or are the manifest) are accepted, so a path can never leave
+ * `dir` and a link can never be followed.
+ */
+export async function readUntrustedTarAsync(
+  file: string,
+  dir: string,
+  options: UntrustedTarOptions
+): Promise<UntrustedTarContents> {
+  let manifestText: string | undefined;
+  const entrySizes = new Map<string, number>();
+  const writes: Promise<void>[] = [];
+  let failure: Error | undefined;
+  // Write errors are recorded rather than rejected: the promises are awaited
+  // only once parsing ends, and one rejecting before then is unhandled.
+  const fail = (err: Error) => {
+    failure ??= err;
+  };
+
+  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 === options.manifestName) {
+        if (
+          manifestText !== undefined ||
+          entry.size > options.maxManifestBytes
+        ) {
+          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 (!options.isEntryAllowed(name) || entrySizes.has(name)) {
+        return reject(`Bundle has an unexpected entry: ${name}`);
+      }
+      if (entrySizes.size >= options.maxEntries) {
+        return reject(options.maxEntriesMessage);
+      }
+      const sizeError = options.checkEntrySize(name, entry.size);
+      if (sizeError) {
+        return reject(sizeError);
+      }
+      entrySizes.set(name, entry.size);
+      writes.push(
+        new Promise<void>((resolve) => {
+          const done = (err?: Error) => {
+            if (err) {
+              fail(err);
+            }
+            resolve();
+          };
+          const out = createWriteStream(path.join(dir, name));
+          out.on('finish', () => done());
+          out.on('error', (err) => {
+            done(err);
+            entry.resume();
+          });
+          entry.on('error', (err: unknown) =>
+            done(err instanceof Error ? err : new Error(String(err)))
+          );
+          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);
+
+  _checkKind(manifestText, options.kind);
+  if (failure) {
+    throw failure;
+  }
+  if (manifestText === undefined) {
+    throw new Error(`Bundle is missing ${options.manifestName}`);
+  }
+  return { manifestText, entrySizes };
+}
+
+function _checkKind(manifestText: string | undefined, expected: BundleKind) {
+  if (manifestText === undefined) {
+    return;
+  }
+  let kind: unknown;
+  try {
+    kind = (JSON.parse(manifestText) as { kind?: unknown })?.kind;
+  } catch {
+    return;
+  }
+  if (kind === undefined || kind === expected) {
+    return;
+  }
+  if (kind === 'tests' || kind === 'deploy') {
+    throw new Error(
+      `This is a ${kind} bundle, not a ${expected} bundle. Run it with "${RUN_COMMANDS[kind]}".`
+    );
+  }
+  throw new Error(`Bundle is of an unknown kind (expected ${expected})`);
+}

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

@@ -6,9 +6,16 @@ import {
   summarizeError,
 } from '@quenty/cli-output-helpers/reporting';
 
-/** Deploy-specific result that extends the generic PackageResult with placeId. */
+/** Deploy-specific result that extends the generic PackageResult with what was deployed where. */
 export interface BatchDeployResult extends PackageResult {
   placeId: number;
+  universeId?: number;
+  target?: string;
+  version?: number;
+  published?: boolean;
+  basePlaceVersion?: number;
+  commit?: string;
+  branch?: string;
 }
 
 /**