@rushstack/rush-sdk 5.100.1 → 5.101.0-pr3949.3

package/README.md

@@ -4,18 +4,110 @@ This is a companion package for the Rush tool. See the [@microsoft/rush](https:/
 
 ⚠ **_THIS PACKAGE IS EXPERIMENTAL_** ⚠
 
-The **@rushstack/rush-sdk** package acts as a lightweight proxy for accessing the APIs of the **@microsoft/rush-lib** engine. It is intended to support three different use cases:
+The **@rushstack/rush-sdk** package acts as a lightweight proxy for accessing the APIs of the **@microsoft/rush-lib** engine. It is intended to support five different use cases:
 
-1. Rush plugins should import from **@rushstack/rush-sdk** instead of **@microsoft/rush-lib**. This gives plugins full access to Rush APIs while avoiding a redundant installation of those packages. At runtime, the APIs will be bound to the correct `rushVersion` from **rush.json**, and guaranteed to be the same **@microsoft/rush-lib** module instance as the plugin host.
+1. **Rush plugins:** Rush plugins should import from **@rushstack/rush-sdk** instead of **@microsoft/rush-lib**. This gives plugins full access to Rush APIs while avoiding a redundant installation of those packages. At runtime, the APIs will be bound to the correct `rushVersion` from **rush.json**, and guaranteed to be the same **@microsoft/rush-lib** module instance as the plugin host.
 
-2. When authoring unit tests for a Rush plugin, developers should add **@microsoft/rush-lib** to their **package.json** `devDependencies`. In this context, **@rushstack/rush-sdk** will resolve to that instance for testing purposes.
+2. **Unit tests:** When authoring unit tests (for a Rush plugin, for example), developers should add **@microsoft/rush-lib** to their **package.json** `devDependencies` and add **@rushstack/rush-sdk** to the regular `dependencies`. In this context, **@rushstack/rush-sdk** will resolve to the locally installed instance for testing purposes.
 
-3. For projects within a monorepo that use **@rushstack/rush-sdk** during their build process, child processes will inherit the installation of Rush that invoked them. This is communicated using the `_RUSH_LIB_PATH` environment variable.
+3. **Rush subprocesses:** For tools within a monorepo that import **@rushstack/rush-sdk** during their build process, child processes will inherit the installation of Rush that invoked them. This is communicated using the `_RUSH_LIB_PATH` environment variable.
 
-4. For scripts and tools that are designed to be used in a Rush monorepo, in the future **@rushstack/rush-sdk** will automatically invoke **install-run-rush.js** and load the local installation. This ensures that tools load a compatible version of the Rush engine for the given branch. Once this is implemented, **@rushstack/rush-sdk** can replace **@microsoft/rush-lib** entirely as the official API interface, with the latter serving as the underlying implementation.
+4. **Monorepo tools:** For scripts and tools that are designed to be used in a Rush monorepo, **@rushstack/rush-sdk** will automatically invoke **install-run-rush.js** and load the local installation. This ensures that tools load a compatible version of the Rush engine for the given branch.
+
+5. **Advanced scenarios:** The secondary `@rushstack/rush-sdk/loader` entry point can be imported by tools that need to explicitly control where **@microsoft/rush-lib** gets loaded from. This API also allows monitoring installation and canceling the operation.  This API is used by the Rush Stack VS Code extension, for example.
 
 The **@rushstack/rush-sdk** API declarations are identical to the corresponding version of **@microsoft/rush-lib**.
 
+## Basic usage
+
+Here's an example of basic usage that works with cases 1-4 above:
+
+```ts
+// CommonJS notation:
+const { RushConfiguration } = require('@rushstack/rush-sdk');
+
+const config = RushConfiguration.loadFromDefaultLocation();
+console.log(config.commonFolder);
+```
+
+```ts
+// TypeScript notation:
+import { RushConfiguration } from '@rushstack/rush-sdk';
+
+const config = RushConfiguration.loadFromDefaultLocation();
+console.log(config.commonFolder);
+```
+
+## Loader API
+
+Here's a basic example of how to manually load **@rushstack/rush-sdk** and monitor installation progress:
+
+```ts
+import { RushSdkLoader, ISdkCallbackEvent } from '@rushstack/rush-sdk/loader';
+
+if (!RushSdkLoader.isLoaded) {
+  await RushSdkLoader.loadAsync({
+    // the search for rush.json starts here:
+    rushJsonSearchFolder: "path/to/my-repo/apps/my-app",
+
+    onNotifyEvent: (event: ISdkCallbackEvent) => {
+      if (event.logMessage) {
+        // Your tool can show progress about the loading:
+        if (event.logMessage.kind === 'info') {
+          console.log(event.logMessage.text);
+        }
+      }
+    }
+  });
+}
+
+// Any subsequent attempts to call require() will return the same instance
+// that was loaded above.
+const rushSdk = require('@rushstack/rush-sdk');
+const config = rushSdk.RushConfiguration.loadFromDefaultLocation();
+```
+
+Here's a more elaborate example illustrating other API features:
+
+```ts
+import { RushSdkLoader, ISdkCallbackEvent } from '@rushstack/rush-sdk/loader';
+
+// Use an AbortController to cancel the operation after a certain time period
+const abortController = new AbortController();
+setTimeout(() => {
+  abortController.abort();
+}, 1000);
+
+if (!RushSdkLoader.isLoaded) {
+  await RushSdkLoader.loadAsync({
+    // the search for rush.json starts here:
+    rushJsonSearchFolder: "path/to/my-repo/apps/my-app",
+
+    abortSignal: abortController.signal,
+
+    onNotifyEvent: (event: ISdkCallbackEvent) => {
+      if (event.logMessage) {
+        // Your tool can show progress about the loading:
+        if (event.logMessage.kind === 'info') {
+          console.log(event.logMessage.text);
+        }
+      }
+
+      if (event.progressPercent !== undefined) {
+        // If installation takes a long time, your tool can display a progress bar
+        displayYourProgressBar(event.progressPercent);
+      }
+    }
+  });
+}
+
+// Any subsequent attempts to call require() will return the same instance
+// that was loaded above.
+const rushSdk = require('@rushstack/rush-sdk');
+const config = rushSdk.RushConfiguration.loadFromDefaultLocation();
+```
+
+
 ## Importing internal APIs
 
 Backwards compatibility is only guaranteed for the APIs marked as `@public` in the official `rush-lib.d.ts` entry point.

package/dist/loader.d.ts

@@ -0,0 +1,92 @@
+/// <reference types="node" />
+
+/**
+ * Options for {@link RushSdkLoader.loadAsync}
+ * @public
+ */
+export declare interface ILoadSdkAsyncOptions {
+    /**
+     * The folder to start from when searching for the Rush workspace configuration.
+     * If this folder does not contain a `rush.json` file, then each parent folder
+     * will be searched.  If `rush.json` is not found, then the SDK fails to load.
+     */
+    rushJsonSearchFolder?: string;
+    /**
+     * A cancellation token that the caller can use to prematurely abort the operation.
+     */
+    abortSignal?: AbortSignal;
+    /**
+     * Allows the caller to monitor the progress of the operation.
+     */
+    onNotifyEvent?: SdkNotifyEventCallback;
+}
+
+/**
+ * Type of {@link ISdkCallbackEvent.logMessage}
+ * @public
+ */
+export declare interface IProgressBarCallbackLogMessage {
+    /**
+     * A status message to print in the log window, or `undefined` if there are
+     * no further messages.  This string may contain newlines.
+     */
+    text: string;
+    /**
+     * The type of message.  More message types may be added in the future.
+     */
+    kind: 'info' | 'debug';
+}
+
+/**
+ * Event options for {@link ILoadSdkAsyncOptions.onNotifyEvent}
+ * @public
+ */
+export declare interface ISdkCallbackEvent {
+    /**
+     * Allows the caller to display log information about the operation.
+     */
+    logMessage: IProgressBarCallbackLogMessage | undefined;
+    /**
+     * Allows the caller to display a progress bar for long-running operations.
+     *
+     * @remarks
+     * If a long-running operation is required, then `progressPercent` will
+     * start at 0.0 and count upwards and finish at 100.0 if the operation completes
+     * successfully.  If the long-running operation has not yet started, or
+     * is not required, then the value will be `undefined`.
+     */
+    progressPercent: number | undefined;
+}
+
+/**
+ * Exposes operations that control how the `@microsoft/rush-lib` engine is
+ * located and loaded.
+ * @public
+ */
+export declare class RushSdkLoader {
+    /**
+     * Throws an "AbortError" exception if abortSignal.aborted is true.
+     */
+    private static _checkForCancel;
+    /**
+     * Returns true if the Rush engine has already been loaded.
+     */
+    static get isLoaded(): boolean;
+    /**
+     * Manually load the Rush engine based on rush.json found for `rushJsonSearchFolder`.
+     * Throws an exception if {@link RushSdkLoader.isLoaded} is already `true`.
+     *
+     * @remarks
+     * This API supports an callback that can be used display a progress bar,
+     * log of operations, and allow the operation to be canceled prematurely.
+     */
+    static loadAsync(options?: ILoadSdkAsyncOptions): Promise<void>;
+}
+
+/**
+ * Type of {@link ILoadSdkAsyncOptions.onNotifyEvent}
+ * @public
+ */
+export declare type SdkNotifyEventCallback = (sdkEvent: ISdkCallbackEvent) => void;
+
+export { }

package/dist/rush-lib.d.ts

@@ -209,6 +209,62 @@ export declare class ChangeManager {
  */
 export declare type CloudBuildCacheProviderFactory = (buildCacheJson: IBuildCacheJson) => ICloudBuildCacheProvider | Promise<ICloudBuildCacheProvider>;
 
+/**
+ * Use this class to load and save the "common/config/rush/cobuild.json" config file.
+ * This file provides configuration options for the Rush Cobuild feature.
+ * @beta
+ */
+export declare class CobuildConfiguration {
+    private static _jsonSchema;
+    /**
+     * Indicates whether the cobuild feature is enabled.
+     * Typically it is enabled in the cobuild.json config file.
+     *
+     * Note: The orchestrator (or local users) should always have to opt into running with cobuilds by
+     * providing a cobuild context id. Even if cobuilds are "enabled" as a feature, they don't
+     * actually turn on for that particular build unless the cobuild context id is provided as an
+     * non-empty string.
+     */
+    readonly cobuildEnabled: boolean;
+    /**
+     * Cobuild context id
+     *
+     * @remarks
+     * The cobuild feature won't be enabled until the context id is provided as an non-empty string.
+     */
+    readonly cobuildContextId: string | undefined;
+    /**
+     * This is a name of the participating cobuild runner. It can be specified by the environment variable
+     * RUSH_COBUILD_RUNNER_ID. If it is not provided, a random id will be generated to identify the runner.
+     */
+    readonly cobuildRunnerId: string;
+    /**
+     * If true, Rush will automatically handle the leaf project with build cache "disabled" by writing
+     * to the cache in a special "log files only mode". This is useful when you want to use Cobuilds
+     * to improve the performance in CI validations and the leaf projects have not enabled cache.
+     */
+    readonly cobuildLeafProjectLogOnlyAllowed: boolean;
+    private _cobuildLockProvider;
+    private readonly _cobuildLockProviderFactory;
+    private readonly _cobuildJson;
+    private constructor();
+    /**
+     * Attempts to load the cobuild.json data from the standard file path `common/config/rush/cobuild.json`.
+     * If the file has not been created yet, then undefined is returned.
+     */
+    static tryLoadAsync(terminal: ITerminal, rushConfiguration: RushConfiguration, rushSession: RushSession): Promise<CobuildConfiguration | undefined>;
+    static getCobuildConfigFilePath(rushConfiguration: RushConfiguration): string;
+    private static _loadAsync;
+    createLockProviderAsync(terminal: ITerminal): Promise<void>;
+    destroyLockProviderAsync(): Promise<void>;
+    get cobuildLockProvider(): ICobuildLockProvider;
+}
+
+/**
+ * @beta
+ */
+export declare type CobuildLockProviderFactory = (cobuildJson: ICobuildJson) => ICobuildLockProvider | Promise<ICobuildLockProvider>;
+
 /**
  * Use this class to load and save the "common/config/rush/common-versions.json" config file.
  * This config file stores dependency version information that affects all projects in the repo.
@@ -338,6 +394,10 @@ export declare class EnvironmentConfiguration {
     private static _buildCacheCredential;
     private static _buildCacheEnabled;
     private static _buildCacheWriteAllowed;
+    private static _cobuildEnabled;
+    private static _cobuildContextId;
+    private static _cobuildRunnerId;
+    private static _cobuildLeafProjectLogOnlyAllowed;
     private static _gitBinaryPath;
     private static _tarBinaryPath;
     /**
@@ -393,6 +453,26 @@ export declare class EnvironmentConfiguration {
      * See {@link EnvironmentVariableNames.RUSH_BUILD_CACHE_WRITE_ALLOWED}
      */
     static get buildCacheWriteAllowed(): boolean | undefined;
+    /**
+     * If set, enables or disables the cobuild feature.
+     * See {@link EnvironmentVariableNames.RUSH_COBUILD_ENABLED}
+     */
+    static get cobuildEnabled(): boolean | undefined;
+    /**
+     * Provides a determined cobuild context id if configured
+     * See {@link EnvironmentVariableNames.RUSH_COBUILD_CONTEXT_ID}
+     */
+    static get cobuildContextId(): string | undefined;
+    /**
+     * Provides a determined cobuild runner id if configured
+     * See {@link EnvironmentVariableNames.RUSH_COBUILD_RUNNER_ID}
+     */
+    static get cobuildRunnerId(): string | undefined;
+    /**
+     * If set, enables or disables the cobuild leaf project log only feature.
+     * See {@link EnvironmentVariableNames.RUSH_COBUILD_LEAF_PROJECT_LOG_ONLY_ALLOWED}
+     */
+    static get cobuildLeafProjectLogOnlyAllowed(): boolean | undefined;
     /**
      * Allows the git binary path to be explicitly provided.
      * See {@link EnvironmentVariableNames.RUSH_GIT_BINARY_PATH}
@@ -550,6 +630,43 @@ export declare const EnvironmentVariableNames: {
      * this environment variable is ignored.
      */
     readonly RUSH_BUILD_CACHE_WRITE_ALLOWED: "RUSH_BUILD_CACHE_WRITE_ALLOWED";
+    /**
+     * Setting this environment variable overrides the value of `cobuildEnabled` in the `cobuild.json`
+     * configuration file.
+     *
+     * @remarks
+     * Specify `1` to enable the cobuild or `0` to disable it.
+     *
+     * If there is no cobuild configured, then this environment variable is ignored.
+     */
+    readonly RUSH_COBUILD_ENABLED: "RUSH_COBUILD_ENABLED";
+    /**
+     * Setting this environment variable opts into running with cobuilds. The context id should be the same across
+     * multiple VMs, but changed when it is a new round of cobuilds.
+     *
+     * e.g. `Build.BuildNumber` in Azure DevOps Pipeline.
+     *
+     * @remarks
+     * If there is no cobuild configured, then this environment variable is ignored.
+     */
+    readonly RUSH_COBUILD_CONTEXT_ID: "RUSH_COBUILD_CONTEXT_ID";
+    /**
+     * Explicitly specifies a name for each participating cobuild runner.
+     *
+     * Setting this environment variable opts into running with cobuilds.
+     *
+     * @remarks
+     * This environment variable is optional, if it is not provided, a random id is used.
+     *
+     * If there is no cobuild configured, then this environment variable is ignored.
+     */
+    readonly RUSH_COBUILD_RUNNER_ID: "RUSH_COBUILD_RUNNER_ID";
+    /**
+     * If this variable is set to "1", When getting distributed builds, Rush will automatically handle the leaf project
+     * with build cache "disabled" by writing to the cache in a special "log files only mode". This is useful when you
+     * want to use Cobuilds to improve the performance in CI validations and the leaf projects have not enabled cache.
+     */
+    readonly RUSH_COBUILD_LEAF_PROJECT_LOG_ONLY_ALLOWED: "RUSH_COBUILD_LEAF_PROJECT_LOG_ONLY_ALLOWED";
     /**
      * Explicitly specifies the path for the Git binary that is invoked by certain Rush operations.
      */
@@ -713,6 +830,114 @@ export declare interface ICloudBuildCacheProvider {
     deleteCachedCredentialsAsync(terminal: ITerminal): Promise<void>;
 }
 
+/**
+ * @beta
+ */
+export declare interface ICobuildCompletedState {
+    status: OperationStatus.Success | OperationStatus.SuccessWithWarning | OperationStatus.Failure;
+    /**
+     * Completed state points to the cache id that was used to store the build cache.
+     * Note: Cache failed builds in a separate cache id
+     */
+    cacheId: string;
+}
+
+/**
+ * @beta
+ */
+export declare interface ICobuildContext {
+    /**
+     * The key for acquiring lock.
+     */
+    lockKey: string;
+    /**
+     * The expire time of the lock in seconds.
+     */
+    lockExpireTimeInSeconds: number;
+    /**
+     * The key for storing completed state.
+     */
+    completedStateKey: string;
+    /**
+     * The contextId is provided by the monorepo maintainer, it reads from environment variable {@link EnvironmentVariableNames.RUSH_COBUILD_CONTEXT_ID}.
+     * It ensure only the builds from the same given contextId cooperated.
+     */
+    contextId: string;
+    /**
+     * The id of the cluster. The operations in the same cluster share the same clusterId and
+     * will be executed on the same machine.
+     */
+    clusterId: string;
+    /**
+     * The id of the runner. The identifier for the running machine.
+     *
+     * It can be specified via assigning `RUSH_COBUILD_RUNNER_ID` environment variable.
+     */
+    runnerId: string;
+    /**
+     * The id of the cache entry. It should be kept the same as the normal cacheId from ProjectBuildCache.
+     * Otherwise, there is a discrepancy in the success case wherein turning on cobuilds will
+     * fail to populate the normal build cache.
+     */
+    cacheId: string;
+    /**
+     * The name of NPM package
+     *
+     * Example: `@scope/MyProject`
+     */
+    packageName: string;
+    /**
+     * The name of the phase.
+     *
+     * Example: _phase:build
+     */
+    phaseName: string;
+}
+
+/**
+ * @beta
+ */
+export declare interface ICobuildJson {
+    cobuildEnabled: boolean;
+    cobuildLockProvider: string;
+}
+
+/**
+ * @beta
+ */
+export declare interface ICobuildLockProvider {
+    /**
+     * The callback function invoked to connect to the lock provider.
+     * For example, initializing the connection to the redis server.
+     */
+    connectAsync(): Promise<void>;
+    /**
+     * The callback function invoked to disconnect the lock provider.
+     */
+    disconnectAsync(): Promise<void>;
+    /**
+     * The callback function to acquire a lock with a lock key and specific contexts.
+     *
+     * NOTE: This lock implementation must be a ReentrantLock. It says the lock might be acquired
+     * multiple times, since tasks in the same cluster can be run in the same VM.
+     */
+    acquireLockAsync(context: Readonly<ICobuildContext>): Promise<boolean>;
+    /**
+     * The callback function to renew a lock with a lock key and specific contexts.
+     *
+     * NOTE: If the lock key expired
+     */
+    renewLockAsync(context: Readonly<ICobuildContext>): Promise<void>;
+    /**
+     * The callback function to set completed state.
+     */
+    setCompletedStateAsync(context: Readonly<ICobuildContext>, state: ICobuildCompletedState): Promise<void>;
+    /**
+     * The callback function to get completed state.
+     */
+    getCompletedStateAsync(context: Readonly<ICobuildContext>): Promise<ICobuildCompletedState | undefined>;
+}
+
 /**
  * A collection of environment variables
  * @public
@@ -750,6 +975,10 @@ export declare interface ICreateOperationsContext {
      * The configuration for the build cache, if the feature is enabled.
      */
     readonly buildCacheConfiguration: BuildCacheConfiguration | undefined;
+    /**
+     * The configuration for the cobuild, if cobuild feature and build cache feature are both enabled.
+     */
+    readonly cobuildConfiguration: CobuildConfiguration | undefined;
     /**
      * The set of custom parameters for the executing command.
      * Maps from the `longName` field in command-line.json to the parser configuration in ts-command-line.
@@ -1109,6 +1338,10 @@ export declare interface IOperationExecutionResult {
      * The value indicates the duration of the same operation without cache hit.
      */
     readonly nonCachedDurationMs: number | undefined;
+    /**
+     * The id of the runner which actually runs the building process in cobuild mode.
+     */
+    readonly cobuildRunnerId: string | undefined;
 }
 
 /**
@@ -1118,6 +1351,8 @@ export declare interface _IOperationMetadata {
     durationInSeconds: number;
     logPath: string;
     errorLogPath: string;
+    cobuildContextId: string | undefined;
+    cobuildRunnerId: string | undefined;
 }
 
 /**
@@ -1160,10 +1395,6 @@ export declare interface IOperationRunner {
      * Name of the operation, for logging.
      */
     readonly name: string;
-    /**
-     * This flag determines if the operation is allowed to be skipped if up to date.
-     */
-    isSkipAllowed: boolean;
     /**
      * Indicates that this runner's duration has meaning.
      */
@@ -1177,10 +1408,6 @@ export declare interface IOperationRunner {
      * exit code
      */
     warningsAreAllowed: boolean;
-    /**
-     * Indicates if the output of this operation may be written to the cache
-     */
-    isCacheWriteAllowed: boolean;
     /**
      * Method to be executed for the operation.
      */
@@ -1219,6 +1446,33 @@ export declare interface IOperationRunnerContext {
      * Object used to track elapsed time.
      */
     stopwatch: IStopwatchResult;
+    /**
+     * The current execution status of an operation. Operations start in the 'ready' state,
+     * but can be 'blocked' if an upstream operation failed. It is 'executing' when
+     * the operation is executing. Once execution is complete, it is either 'success' or
+     * 'failure'.
+     */
+    status: OperationStatus;
+    /**
+     * Error which occurred while executing this operation, this is stored in case we need
+     * it later (for example to re-print errors at end of execution).
+     */
+    error?: Error;
+    /**
+     * The set of operations that depend on this operation.
+     */
+    readonly consumers: Set<IOperationRunnerContext>;
+    /**
+     * The operation runner that is executing this operation.
+     */
+    readonly runner: IOperationRunner;
+    /**
+     * Normally the incremental build logic will rebuild changed projects as well as
+     * any projects that directly or indirectly depend on a changed project.
+     * If true, then the incremental build logic will only rebuild changed projects and
+     * ignore dependent projects.
+     */
+    readonly changedProjectsOnly: boolean;
 }
 
 /**
@@ -1234,6 +1488,8 @@ export declare interface _IOperationStateFileOptions {
  */
 export declare interface _IOperationStateJson {
     nonCachedDurationMs: number;
+    cobuildContextId: string | undefined;
+    cobuildRunnerId: string | undefined;
 }
 
 /**
@@ -2056,7 +2312,7 @@ export declare class _OperationMetadataManager {
      * Example: `.rush/temp/operation/_phase_build/error.log`
      */
     get relativeFilepaths(): string[];
-    saveAsync({ durationInSeconds, logPath, errorLogPath }: _IOperationMetadata): Promise<void>;
+    saveAsync({ durationInSeconds, cobuildContextId, cobuildRunnerId, logPath, errorLogPath }: _IOperationMetadata): Promise<void>;
     tryRestoreAsync({ terminal, logPath, errorLogPath }: {
         terminal: ITerminal;
         logPath: string;
@@ -2099,10 +2355,18 @@ export declare enum OperationStatus {
      * The Operation is on the queue, ready to execute (but may be waiting for dependencies)
      */
     Ready = "READY",
+    /**
+     * The Operation is Queued
+     */
+    Queued = "QUEUED",
     /**
      * The Operation is currently executing
      */
     Executing = "EXECUTING",
+    /**
+     * The Operation is currently executing by a remote process
+     */
+    RemoteExecuting = "REMOTE EXECUTING",
     /**
      * The Operation completed successfully and did not write to standard output
      */
@@ -2260,7 +2524,10 @@ export declare class PhasedCommandHooks {
      * Hook invoked before operation start
      * Hook is series for stable output.
      */
-    readonly beforeExecuteOperations: AsyncSeriesHook<[Map<Operation, IOperationExecutionResult>]>;
+    readonly beforeExecuteOperations: AsyncSeriesHook<[
+    Map<Operation, IOperationExecutionResult>,
+    ICreateOperationsContext
+    ]>;
     /**
      * Hook invoked when operation status changed
      * Hook is series for stable output.
@@ -2272,6 +2539,14 @@ export declare class PhasedCommandHooks {
      * Hook is series for stable output.
      */
     readonly afterExecuteOperations: AsyncSeriesHook<[IExecutionResult, ICreateOperationsContext]>;
+    /**
+     * Hook invoked before executing a operation.
+     */
+    readonly beforeExecuteOperation: AsyncSeriesHook<[IOperationRunnerContext]>;
+    /**
+     * Hook invoked after executing a operation.
+     */
+    readonly afterExecuteOperation: AsyncSeriesHook<[IOperationRunnerContext]>;
     /**
      * Hook invoked after a run has finished and the command is watching for changes.
      * May be used to display additional relevant data to the user.
@@ -3415,6 +3690,10 @@ export declare class RushConstants {
      * Changing this ensures that cache entries generated by an old version will no longer register as a cache hit.
      */
     static readonly buildCacheVersion: number;
+    /**
+     * Cobuild configuration file.
+     */
+    static readonly cobuildFilename: string;
     /**
      * Per-project configuration filename.
      */
@@ -3584,12 +3863,15 @@ declare class RushPluginsConfiguration {
 export declare class RushSession {
     private readonly _options;
     private readonly _cloudBuildCacheProviderFactories;
+    private readonly _cobuildLockProviderFactories;
     readonly hooks: RushLifecycleHooks;
     constructor(options: IRushSessionOptions);
     getLogger(name: string): ILogger;
     get terminalProvider(): ITerminalProvider;
     registerCloudBuildCacheProviderFactory(cacheProviderName: string, factory: CloudBuildCacheProviderFactory): void;
     getCloudBuildCacheProviderFactory(cacheProviderName: string): CloudBuildCacheProviderFactory | undefined;
+    registerCobuildLockProviderFactory(cobuildLockProviderName: string, factory: CobuildLockProviderFactory): void;
+    getCobuildLockProviderFactory(cobuildLockProviderName: string): CobuildLockProviderFactory | undefined;
 }
 
 /**