@aws-cdk-testing/cli-integ 0.0.0

package/lib/npm.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.typescriptVersionsSync = typescriptVersionsSync;
+exports.typescriptVersionsYoungerThanDaysSync = typescriptVersionsYoungerThanDaysSync;
+const child_process_1 = require("child_process");
+const MINIMUM_VERSION = '3.9';
+/**
+ * Use NPM preinstalled on the machine to look up a list of TypeScript versions
+ */
+function typescriptVersionsSync() {
+    const { stdout } = (0, child_process_1.spawnSync)('npm', ['--silent', 'view', `typescript@>=${MINIMUM_VERSION}`, 'version', '--json'], { encoding: 'utf-8' });
+    const versions = JSON.parse(stdout);
+    return Array.from(new Set(versions.map(v => v.split('.').slice(0, 2).join('.'))));
+}
+/**
+ * Use NPM preinstalled on the machine to query publish times of versions
+ */
+function typescriptVersionsYoungerThanDaysSync(days, versions) {
+    const { stdout } = (0, child_process_1.spawnSync)('npm', ['--silent', 'view', 'typescript', 'time', '--json'], { encoding: 'utf-8' });
+    const versionTsMap = JSON.parse(stdout);
+    const cutoffDate = new Date(Date.now() - (days * 24 * 3600 * 1000));
+    const cutoffDateS = cutoffDate.toISOString();
+    const recentVersions = Object.entries(versionTsMap)
+        .filter(([_, dateS]) => dateS > cutoffDateS)
+        .map(([v]) => v);
+    // Input versions are of the form 3.9, 5.2, etc.
+    // Actual versions are of the form `3.9.15`, `5.3.0-dev.20511311`.
+    // Return only 2-digit versions for which there is a non-prerelease version in the set of recentVersions
+    // So a 2-digit versions that is followed by `.<digits>` until the end of the string.
+    return versions.filter((twoV) => {
+        const re = new RegExp(`^${reQuote(twoV)}\\.\\d+$`);
+        return recentVersions.some(fullV => fullV.match(re));
+    });
+}
+function reQuote(str) {
+    return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/npm.ts

@@ -0,0 +1,41 @@
+import { spawnSync } from 'child_process';
+
+const MINIMUM_VERSION = '3.9';
+
+/**
+ * Use NPM preinstalled on the machine to look up a list of TypeScript versions
+ */
+export function typescriptVersionsSync(): string[] {
+  const { stdout } = spawnSync('npm', ['--silent', 'view', `typescript@>=${MINIMUM_VERSION}`, 'version', '--json'], { encoding: 'utf-8' });
+
+  const versions: string[] = JSON.parse(stdout);
+  return Array.from(new Set(versions.map(v => v.split('.').slice(0, 2).join('.'))));
+}
+
+/**
+ * Use NPM preinstalled on the machine to query publish times of versions
+ */
+export function typescriptVersionsYoungerThanDaysSync(days: number, versions: string[]): string[] {
+  const { stdout } = spawnSync('npm', ['--silent', 'view', 'typescript', 'time', '--json'], { encoding: 'utf-8' });
+  const versionTsMap: Record<string, string> = JSON.parse(stdout);
+
+  const cutoffDate = new Date(Date.now() - (days * 24 * 3600 * 1000));
+  const cutoffDateS = cutoffDate.toISOString();
+
+  const recentVersions = Object.entries(versionTsMap)
+    .filter(([_, dateS]) => dateS > cutoffDateS)
+    .map(([v]) => v);
+
+  // Input versions are of the form 3.9, 5.2, etc.
+  // Actual versions are of the form `3.9.15`, `5.3.0-dev.20511311`.
+  // Return only 2-digit versions for which there is a non-prerelease version in the set of recentVersions
+  // So a 2-digit versions that is followed by `.<digits>` until the end of the string.
+  return versions.filter((twoV) => {
+    const re = new RegExp(`^${reQuote(twoV)}\\.\\d+$`);
+    return recentVersions.some(fullV => fullV.match(re));
+  });
+}
+
+function reQuote(str: string): string {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}

package/lib/package-sources/release-source.d.ts

@@ -0,0 +1,23 @@
+import { IPackageSourceSetup, IPackageSource } from './source';
+export declare class ReleasePackageSourceSetup implements IPackageSourceSetup {
+    private readonly version;
+    private readonly frameworkVersion?;
+    readonly name = "release";
+    readonly description: string;
+    private tempDir?;
+    constructor(version: string, frameworkVersion?: string | undefined);
+    prepare(): Promise<void>;
+    cleanup(): Promise<void>;
+}
+export declare class ReleasePackageSource implements IPackageSource {
+    private readonly cliPath;
+    private readonly version;
+    constructor();
+    makeCliAvailable(): Promise<void>;
+    assertJsiiPackagesAvailable(): void;
+    initializeDotnetPackages(currentDir: string): Promise<void>;
+    majorVersion(): string;
+    requestedCliVersion(): string;
+    requestedFrameworkVersion(): string;
+    requestedAlphaVersion(): string;
+}

package/lib/package-sources/release-source.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReleasePackageSource = exports.ReleasePackageSourceSetup = void 0;
+const os = require("os");
+const path = require("path");
+const fs = require("fs-extra");
+const files_1 = require("../files");
+const shell_1 = require("../shell");
+class ReleasePackageSourceSetup {
+    constructor(version, frameworkVersion) {
+        this.version = version;
+        this.frameworkVersion = frameworkVersion;
+        this.name = 'release';
+        this.description = `release @ ${this.version}`;
+    }
+    async prepare() {
+        var _a;
+        this.tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'tmpcdk'));
+        fs.mkdirSync(this.tempDir, { recursive: true });
+        await (0, shell_1.shell)(['node', require.resolve('npm'), 'install', `aws-cdk@${this.version}`], {
+            cwd: this.tempDir,
+        });
+        process.env.CDK_CLI_PATH = this.tempDir;
+        process.env.VERSION = this.version;
+        process.env.FRAMEWORK_VERSION = (_a = this.frameworkVersion) !== null && _a !== void 0 ? _a : this.version;
+    }
+    async cleanup() {
+        if (this.tempDir) {
+            (0, shell_1.rimraf)(this.tempDir);
+        }
+    }
+}
+exports.ReleasePackageSourceSetup = ReleasePackageSourceSetup;
+class ReleasePackageSource {
+    constructor() {
+        this.cliPath = process.env.CDK_CLI_PATH;
+        this.version = process.env.VERSION;
+    }
+    async makeCliAvailable() {
+        (0, shell_1.addToShellPath)(path.join(this.cliPath, 'node_modules', '.bin'));
+    }
+    assertJsiiPackagesAvailable() {
+    }
+    async initializeDotnetPackages(currentDir) {
+        if (process.env.CWD_FILES_DIR) {
+            await (0, files_1.copyDirectoryContents)(process.env.CWD_FILES_DIR, currentDir);
+        }
+    }
+    majorVersion() {
+        return this.version.split('.')[0];
+    }
+    requestedCliVersion() {
+        return this.version;
+    }
+    requestedFrameworkVersion() {
+        return process.env.FRAMEWORK_VERSION;
+    }
+    requestedAlphaVersion() {
+        const frameworkVersion = this.requestedFrameworkVersion();
+        if (frameworkVersion.includes('-rc.')) {
+            // For a pipeline release
+            return frameworkVersion.replace(/-rc\.\d+$/, '-alpha.999');
+        }
+        else {
+            // For a stable release
+            return `${frameworkVersion}-alpha.0`;
+        }
+    }
+}
+exports.ReleasePackageSource = ReleasePackageSource;
+//# sourceMappingURL=data:application/json;base64,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

package/lib/package-sources/release-source.ts

@@ -0,0 +1,81 @@
+import * as os from 'os';
+import * as path from 'path';
+import * as fs from 'fs-extra';
+import { IPackageSourceSetup, IPackageSource } from './source';
+import { copyDirectoryContents } from '../files';
+import { shell, rimraf, addToShellPath } from '../shell';
+
+export class ReleasePackageSourceSetup implements IPackageSourceSetup {
+  readonly name = 'release';
+  readonly description = `release @ ${this.version}`;
+
+  private tempDir?: string;
+
+  constructor(private readonly version: string, private readonly frameworkVersion?: string) {
+  }
+
+  public async prepare(): Promise<void> {
+    this.tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'tmpcdk'));
+    fs.mkdirSync(this.tempDir, { recursive: true });
+
+    await shell(['node', require.resolve('npm'), 'install', `aws-cdk@${this.version}`], {
+      cwd: this.tempDir,
+    });
+
+    process.env.CDK_CLI_PATH = this.tempDir;
+    process.env.VERSION = this.version;
+    process.env.FRAMEWORK_VERSION = this.frameworkVersion ?? this.version;
+  }
+
+  public async cleanup(): Promise<void> {
+    if (this.tempDir) {
+      rimraf(this.tempDir);
+    }
+  }
+}
+
+export class ReleasePackageSource implements IPackageSource {
+  private readonly cliPath: string;
+  private readonly version: string;
+
+  constructor() {
+    this.cliPath = process.env.CDK_CLI_PATH!;
+    this.version = process.env.VERSION!;
+  }
+
+  public async makeCliAvailable() {
+    addToShellPath(path.join(this.cliPath, 'node_modules', '.bin'));
+  }
+
+  public assertJsiiPackagesAvailable() {
+  }
+
+  public async initializeDotnetPackages(currentDir: string) {
+    if (process.env.CWD_FILES_DIR) {
+      await copyDirectoryContents(process.env.CWD_FILES_DIR, currentDir);
+    }
+  }
+
+  public majorVersion() {
+    return this.version.split('.')[0] as string;
+  }
+
+  public requestedCliVersion() {
+    return this.version;
+  }
+
+  public requestedFrameworkVersion() {
+    return process.env.FRAMEWORK_VERSION!;
+  }
+
+  public requestedAlphaVersion(): string {
+    const frameworkVersion = this.requestedFrameworkVersion();
+    if (frameworkVersion.includes('-rc.')) {
+      // For a pipeline release
+      return frameworkVersion.replace(/-rc\.\d+$/, '-alpha.999');
+    } else {
+      // For a stable release
+      return `${frameworkVersion}-alpha.0`;
+    }
+  }
+}

package/lib/package-sources/repo-source.d.ts

@@ -0,0 +1,30 @@
+import { IPackageSourceSetup, IPackageSource } from './source';
+export declare class RepoPackageSourceSetup implements IPackageSourceSetup {
+    private readonly repoRoot;
+    readonly name = "repo";
+    readonly description: string;
+    constructor(repoRoot: string);
+    prepare(): Promise<void>;
+    cleanup(): Promise<void>;
+}
+export declare class RepoPackageSource implements IPackageSource {
+    private readonly repoRoot;
+    constructor();
+    makeCliAvailable(): Promise<void>;
+    assertJsiiPackagesAvailable(): void;
+    initializeDotnetPackages(): Promise<void>;
+    majorVersion(): any;
+    requestedCliVersion(): string;
+    requestedFrameworkVersion(): string;
+    requestedAlphaVersion(): string;
+}
+/**
+  * Return a { name -> directory } packages found in a Yarn monorepo
+  *
+  * Cached in YARN_MONOREPO_CACHE.
+  */
+export declare function findYarnPackages(root: string): Promise<Record<string, string>>;
+/**
+ * Find the root directory of the repo from the current directory
+ */
+export declare function autoFindRoot(): Promise<string>;

package/lib/package-sources/repo-source.js

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RepoPackageSource = exports.RepoPackageSourceSetup = void 0;
+exports.findYarnPackages = findYarnPackages;
+exports.autoFindRoot = autoFindRoot;
+const os = require("os");
+const path = require("path");
+const fs = require("fs-extra");
+const files_1 = require("../files");
+const shell_1 = require("../shell");
+class RepoPackageSourceSetup {
+    constructor(repoRoot) {
+        this.repoRoot = repoRoot;
+        this.name = 'repo';
+        this.description = `repo(${this.repoRoot})`;
+    }
+    async prepare() {
+        if (!await fs.pathExists(path.join(this.repoRoot, 'package.json')) || !await fs.pathExists(path.join(this.repoRoot, 'yarn.lock'))) {
+            throw new Error(`${this.repoRoot}: does not look like the repository root`);
+        }
+        process.env.REPO_ROOT = this.repoRoot;
+        process.env.REPO_PACKAGE_MAP = await writePackageMap(this.repoRoot);
+        (0, shell_1.addToShellPath)(path.resolve(__dirname, 'repo-tools'));
+    }
+    async cleanup() {
+    }
+}
+exports.RepoPackageSourceSetup = RepoPackageSourceSetup;
+class RepoPackageSource {
+    constructor() {
+        this.repoRoot = process.env.REPO_ROOT;
+    }
+    async makeCliAvailable() {
+        (0, shell_1.addToShellPath)(path.join(this.repoRoot, 'packages', 'aws-cdk', 'bin'));
+    }
+    assertJsiiPackagesAvailable() {
+        throw new Error('jsii client packages are not available when using REPO source');
+    }
+    async initializeDotnetPackages() {
+    }
+    majorVersion() {
+        const releaseJson = fs.readJsonSync(path.resolve(this.repoRoot, 'release.json'));
+        return releaseJson.majorVersion;
+    }
+    requestedCliVersion() {
+        return '*';
+    }
+    requestedFrameworkVersion() {
+        return '*';
+    }
+    requestedAlphaVersion() {
+        return '*';
+    }
+}
+exports.RepoPackageSource = RepoPackageSource;
+async function writePackageMap(repoRoot) {
+    const packages = await findYarnPackages(repoRoot);
+    const fileName = path.join(os.tmpdir(), 'package-map.json');
+    await fs.writeJson(fileName, packages);
+    return fileName;
+}
+/**
+ * Cache monorepo discovery results, we only want to do this once per run
+ */
+const YARN_MONOREPO_CACHE = {};
+/**
+  * Return a { name -> directory } packages found in a Yarn monorepo
+  *
+  * Cached in YARN_MONOREPO_CACHE.
+  */
+async function findYarnPackages(root) {
+    if (!(root in YARN_MONOREPO_CACHE)) {
+        const outputDataString = JSON.parse(await (0, shell_1.shell)(['yarn', 'workspaces', '--json', 'info'], {
+            captureStderr: false,
+            cwd: root,
+            show: 'error',
+        })).data;
+        const output = JSON.parse(outputDataString);
+        const ret = {};
+        for (const [k, v] of Object.entries(output)) {
+            ret[k] = path.join(root, v.location);
+        }
+        YARN_MONOREPO_CACHE[root] = ret;
+    }
+    return YARN_MONOREPO_CACHE[root];
+}
+/**
+ * Find the root directory of the repo from the current directory
+ */
+async function autoFindRoot() {
+    const found = (0, files_1.findUp)('release.json');
+    if (!found) {
+        throw new Error(`Could not determine repository root: 'release.json' not found from ${process.cwd()}`);
+    }
+    return path.dirname(found);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"repo-source.js","sourceRoot":"","sources":["repo-source.ts"],"names":[],"mappings":"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","sourcesContent":["import * as os from 'os';\nimport * as path from 'path';\nimport * as fs from 'fs-extra';\nimport { IPackageSourceSetup, IPackageSource } from './source';\nimport { findUp } from '../files';\nimport { shell, addToShellPath } from '../shell';\n\nexport class RepoPackageSourceSetup implements IPackageSourceSetup {\n  readonly name = 'repo';\n  readonly description = `repo(${this.repoRoot})`;\n\n  constructor(private readonly repoRoot: string) {\n  }\n\n  public async prepare(): Promise<void> {\n    if (!await fs.pathExists(path.join(this.repoRoot, 'package.json')) || !await fs.pathExists(path.join(this.repoRoot, 'yarn.lock'))) {\n      throw new Error(`${this.repoRoot}: does not look like the repository root`);\n    }\n\n    process.env.REPO_ROOT = this.repoRoot;\n    process.env.REPO_PACKAGE_MAP = await writePackageMap(this.repoRoot);\n    addToShellPath(path.resolve(__dirname, 'repo-tools'));\n  }\n\n  public async cleanup(): Promise<void> {\n  }\n}\n\nexport class RepoPackageSource implements IPackageSource {\n  private readonly repoRoot: string;\n\n  constructor() {\n    this.repoRoot = process.env.REPO_ROOT as string;\n  }\n\n  public async makeCliAvailable() {\n    addToShellPath(path.join(this.repoRoot, 'packages', 'aws-cdk', 'bin'));\n  }\n\n  public assertJsiiPackagesAvailable() {\n    throw new Error('jsii client packages are not available when using REPO source');\n  }\n\n  public async initializeDotnetPackages() {\n  }\n\n  public majorVersion() {\n    const releaseJson = fs.readJsonSync(path.resolve(this.repoRoot, 'release.json'));\n    return releaseJson.majorVersion;\n  }\n\n  public requestedCliVersion(): string {\n    return '*';\n  }\n\n  public requestedFrameworkVersion(): string {\n    return '*';\n  }\n\n  public requestedAlphaVersion(): string {\n    return '*';\n  }\n}\n\nasync function writePackageMap(repoRoot: string): Promise<string> {\n  const packages = await findYarnPackages(repoRoot);\n  const fileName = path.join(os.tmpdir(), 'package-map.json');\n  await fs.writeJson(fileName, packages);\n  return fileName;\n}\n\n/**\n * Cache monorepo discovery results, we only want to do this once per run\n */\nconst YARN_MONOREPO_CACHE: Record<string, any> = {};\n\n/**\n  * Return a { name -> directory } packages found in a Yarn monorepo\n  *\n  * Cached in YARN_MONOREPO_CACHE.\n  */\nexport async function findYarnPackages(root: string): Promise<Record<string, string>> {\n  if (!(root in YARN_MONOREPO_CACHE)) {\n    const outputDataString: string = JSON.parse(await shell(['yarn', 'workspaces', '--json', 'info'], {\n      captureStderr: false,\n      cwd: root,\n      show: 'error',\n    })).data;\n    const output: YarnWorkspacesOutput = JSON.parse(outputDataString);\n\n    const ret: Record<string, string> = {};\n    for (const [k, v] of Object.entries(output)) {\n      ret[k] = path.join(root, v.location);\n    }\n    YARN_MONOREPO_CACHE[root] = ret;\n  }\n  return YARN_MONOREPO_CACHE[root];\n}\n\n/**\n * Find the root directory of the repo from the current directory\n */\nexport async function autoFindRoot() {\n  const found = findUp('release.json');\n  if (!found) {\n    throw new Error(`Could not determine repository root: 'release.json' not found from ${process.cwd()}`);\n  }\n  return path.dirname(found);\n}\n\ntype YarnWorkspacesOutput = Record<string, { location: string }>;\n"]}

package/lib/package-sources/repo-source.ts

@@ -0,0 +1,111 @@
+import * as os from 'os';
+import * as path from 'path';
+import * as fs from 'fs-extra';
+import { IPackageSourceSetup, IPackageSource } from './source';
+import { findUp } from '../files';
+import { shell, addToShellPath } from '../shell';
+
+export class RepoPackageSourceSetup implements IPackageSourceSetup {
+  readonly name = 'repo';
+  readonly description = `repo(${this.repoRoot})`;
+
+  constructor(private readonly repoRoot: string) {
+  }
+
+  public async prepare(): Promise<void> {
+    if (!await fs.pathExists(path.join(this.repoRoot, 'package.json')) || !await fs.pathExists(path.join(this.repoRoot, 'yarn.lock'))) {
+      throw new Error(`${this.repoRoot}: does not look like the repository root`);
+    }
+
+    process.env.REPO_ROOT = this.repoRoot;
+    process.env.REPO_PACKAGE_MAP = await writePackageMap(this.repoRoot);
+    addToShellPath(path.resolve(__dirname, 'repo-tools'));
+  }
+
+  public async cleanup(): Promise<void> {
+  }
+}
+
+export class RepoPackageSource implements IPackageSource {
+  private readonly repoRoot: string;
+
+  constructor() {
+    this.repoRoot = process.env.REPO_ROOT as string;
+  }
+
+  public async makeCliAvailable() {
+    addToShellPath(path.join(this.repoRoot, 'packages', 'aws-cdk', 'bin'));
+  }
+
+  public assertJsiiPackagesAvailable() {
+    throw new Error('jsii client packages are not available when using REPO source');
+  }
+
+  public async initializeDotnetPackages() {
+  }
+
+  public majorVersion() {
+    const releaseJson = fs.readJsonSync(path.resolve(this.repoRoot, 'release.json'));
+    return releaseJson.majorVersion;
+  }
+
+  public requestedCliVersion(): string {
+    return '*';
+  }
+
+  public requestedFrameworkVersion(): string {
+    return '*';
+  }
+
+  public requestedAlphaVersion(): string {
+    return '*';
+  }
+}
+
+async function writePackageMap(repoRoot: string): Promise<string> {
+  const packages = await findYarnPackages(repoRoot);
+  const fileName = path.join(os.tmpdir(), 'package-map.json');
+  await fs.writeJson(fileName, packages);
+  return fileName;
+}
+
+/**
+ * Cache monorepo discovery results, we only want to do this once per run
+ */
+const YARN_MONOREPO_CACHE: Record<string, any> = {};
+
+/**
+  * Return a { name -> directory } packages found in a Yarn monorepo
+  *
+  * Cached in YARN_MONOREPO_CACHE.
+  */
+export async function findYarnPackages(root: string): Promise<Record<string, string>> {
+  if (!(root in YARN_MONOREPO_CACHE)) {
+    const outputDataString: string = JSON.parse(await shell(['yarn', 'workspaces', '--json', 'info'], {
+      captureStderr: false,
+      cwd: root,
+      show: 'error',
+    })).data;
+    const output: YarnWorkspacesOutput = JSON.parse(outputDataString);
+
+    const ret: Record<string, string> = {};
+    for (const [k, v] of Object.entries(output)) {
+      ret[k] = path.join(root, v.location);
+    }
+    YARN_MONOREPO_CACHE[root] = ret;
+  }
+  return YARN_MONOREPO_CACHE[root];
+}
+
+/**
+ * Find the root directory of the repo from the current directory
+ */
+export async function autoFindRoot() {
+  const found = findUp('release.json');
+  if (!found) {
+    throw new Error(`Could not determine repository root: 'release.json' not found from ${process.cwd()}`);
+  }
+  return path.dirname(found);
+}
+
+type YarnWorkspacesOutput = Record<string, { location: string }>;

package/lib/package-sources/repo-tools/npm

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+require('./npm.js');

package/lib/package-sources/repo-tools/npm.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/package-sources/repo-tools/npm.js

@@ -0,0 +1,43 @@
+"use strict";
+var _a, _b, _c;
+Object.defineProperty(exports, "__esModule", { value: true });
+const child_process = require("child_process");
+const fs = require("fs-extra");
+let argv = process.argv.slice(2);
+// eslint-disable-next-line no-console
+console.log('fake npm');
+if (argv[0] === 'install') {
+    if (!process.env.REPO_PACKAGE_MAP) {
+        throw new Error('REPO_PACKAGE_MAP not set');
+    }
+    const repoPackageMap = fs.readJsonSync(process.env.REPO_PACKAGE_MAP, { encoding: 'utf-8' });
+    // Replace paths in the 'package.json' in the current directory
+    if (fs.pathExistsSync('package.json')) {
+        const packageJson = fs.readJsonSync('package.json', { encoding: 'utf-8' });
+        for (const deps of [(_a = packageJson.dependencies) !== null && _a !== void 0 ? _a : {}, (_b = packageJson.devDependencies) !== null && _b !== void 0 ? _b : {}]) {
+            for (const [name, version] of Object.entries(deps)) {
+                deps[name] = (_c = repoPackageMap[name]) !== null && _c !== void 0 ? _c : version;
+            }
+        }
+        fs.writeJsonSync('package.json', packageJson, { encoding: 'utf-8' });
+    }
+    // Replace package names on the command line
+    argv = argv.map(x => { var _a; return (_a = repoPackageMap[x]) !== null && _a !== void 0 ? _a : x; });
+}
+////////////////////////////////////////////////////////////////////////
+//  Shell out to original npm
+const child = child_process.spawn('node', [require.resolve('npm'), ...argv], {
+    shell: false,
+    stdio: ['ignore', 'inherit', 'inherit'],
+});
+child.once('error', e => {
+    // eslint-disable-next-line no-console
+    console.error(e);
+    process.exitCode = 1;
+});
+child.once('close', code => {
+    if (code) {
+        process.exitCode = code;
+    }
+});
+//# sourceMappingURL=data:application/json;base64,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

package/lib/package-sources/repo-tools/npm.ts

@@ -0,0 +1,48 @@
+import * as child_process from 'child_process';
+import * as fs from 'fs-extra';
+
+let argv = process.argv.slice(2);
+
+// eslint-disable-next-line no-console
+console.log('fake npm');
+
+if (argv[0] === 'install') {
+  if (!process.env.REPO_PACKAGE_MAP) {
+    throw new Error('REPO_PACKAGE_MAP not set');
+  }
+  const repoPackageMap = fs.readJsonSync(process.env.REPO_PACKAGE_MAP, { encoding: 'utf-8' });
+
+  // Replace paths in the 'package.json' in the current directory
+  if (fs.pathExistsSync('package.json')) {
+    const packageJson = fs.readJsonSync('package.json', { encoding: 'utf-8' });
+    for (const deps of [packageJson.dependencies ?? {}, packageJson.devDependencies ?? {}]) {
+      for (const [name, version] of Object.entries(deps)) {
+        deps[name] = repoPackageMap[name] ?? version;
+      }
+    }
+    fs.writeJsonSync('package.json', packageJson, { encoding: 'utf-8' });
+  }
+
+  // Replace package names on the command line
+  argv = argv.map(x => repoPackageMap[x] ?? x);
+}
+
+////////////////////////////////////////////////////////////////////////
+//  Shell out to original npm
+
+const child = child_process.spawn('node', [require.resolve('npm'), ...argv], {
+  shell: false,
+  stdio: ['ignore', 'inherit', 'inherit'],
+});
+
+child.once('error', e => {
+  // eslint-disable-next-line no-console
+  console.error(e);
+  process.exitCode = 1;
+});
+
+child.once('close', code => {
+  if (code) {
+    process.exitCode = code;
+  }
+});