jsii-release 0.2.674 → 0.2.676

package/lib/codeartifact/codeartifact-repo.js

@@ -0,0 +1,299 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CodeArtifactRepo = void 0;
+const client_codeartifact_1 = require("@aws-sdk/client-codeartifact");
+const sleep_1 = require("../help/sleep");
+const COLLECT_BY_TAG = 'collect-by';
+const REPO_LIFETIME_MS = 24 * 3600 * 1000; // One day
+/**
+ * A CodeArtifact repository
+ */
+class CodeArtifactRepo {
+    /**
+     * Create a CodeArtifact repo with a random name
+     */
+    static async createRandom(options = {}) {
+        const qualifier = Math.random().toString(36).replace(/[^a-z0-9]+/g, '');
+        const repo = new CodeArtifactRepo(`test-${qualifier}`, options);
+        await repo.create();
+        return repo;
+    }
+    /**
+     * Create a CodeArtifact repository with a given name
+     */
+    static async createWithName(name, options = {}) {
+        const repo = new CodeArtifactRepo(name, options);
+        await repo.create();
+        return repo;
+    }
+    /**
+     * Reference an existing CodeArtifact repository
+     */
+    static existing(repositoryName, options = {}) {
+        return new CodeArtifactRepo(repositoryName, options);
+    }
+    /**
+     * Garbage collect repositories
+     */
+    static async gc(options = {}) {
+        var _a, _b;
+        if (!await CodeArtifactRepo.existing('*dummy*').domainExists()) {
+            return;
+        }
+        const codeArtifact = new client_codeartifact_1.CodeartifactClient({
+            credentials: options.credentials,
+        });
+        let nextToken;
+        do {
+            const page = await retryThrottled(() => codeArtifact.send(new client_codeartifact_1.ListRepositoriesCommand({ nextToken })));
+            for (const repo of (_a = page.repositories) !== null && _a !== void 0 ? _a : []) {
+                const tags = await retryThrottled(() => codeArtifact.send(new client_codeartifact_1.ListTagsForResourceCommand({ resourceArn: repo.arn })));
+                const collectable = (_b = tags === null || tags === void 0 ? void 0 : tags.tags) === null || _b === void 0 ? void 0 : _b.find(t => t.key === COLLECT_BY_TAG && Number(t.value) < Date.now());
+                if (collectable) {
+                    // eslint-disable-next-line no-console
+                    console.error('Deleting', repo.name);
+                    await retryThrottled(() => codeArtifact.send(new client_codeartifact_1.DeleteRepositoryCommand({
+                        domain: repo.domainName,
+                        repository: repo.name,
+                    })));
+                }
+            }
+            nextToken = page.nextToken;
+        } while (nextToken);
+    }
+    constructor(repositoryName, options = {}) {
+        this.repositoryName = repositoryName;
+        this.npmUpstream = 'npm-upstream';
+        this.pypiUpstream = 'pypi-upstream';
+        this.nugetUpstream = 'nuget-upstream';
+        this.mavenUpstream = 'maven-upstream';
+        this.domain = CodeArtifactRepo.DEFAULT_DOMAIN;
+        this.codeArtifact = new client_codeartifact_1.CodeartifactClient({ credentials: options.credentials });
+    }
+    /**
+     * Create the repository
+     */
+    async create() {
+        await this.ensureDomain();
+        await this.ensureUpstreams();
+        await this.ensureRepository(this.repositoryName, {
+            description: 'Testing repository',
+            upstreams: [
+                this.npmUpstream,
+                this.pypiUpstream,
+                this.nugetUpstream,
+                this.mavenUpstream,
+            ],
+            tags: {
+                [COLLECT_BY_TAG]: `${Date.now() + REPO_LIFETIME_MS}`,
+            },
+        });
+    }
+    /**
+     * Absorb old login information
+     */
+    setLoginInformation(loginInfo) {
+        if (loginInfo.repositoryName !== this.repositoryName) {
+            throw new Error(`This login info seems to be for a different repo. '${this.repositoryName}' != '${loginInfo.repositoryName}'`);
+        }
+        this._loginInformation = loginInfo;
+    }
+    async login() {
+        var _a, _b;
+        if (this._loginInformation) {
+            return this._loginInformation;
+        }
+        const durationSeconds = 12 * 3600;
+        const authToken = await this.send(new client_codeartifact_1.GetAuthorizationTokenCommand({ domain: this.domain, durationSeconds }));
+        this._loginInformation = {
+            // eslint-disable-next-line max-len
+            authToken: authToken.authorizationToken,
+            expirationTimeMs: (_b = (_a = authToken.expiration) === null || _a === void 0 ? void 0 : _a.getTime()) !== null && _b !== void 0 ? _b : (Date.now() + durationSeconds * 1000),
+            repositoryName: this.repositoryName,
+            npmEndpoint: (await this.send(new client_codeartifact_1.GetRepositoryEndpointCommand({ domain: this.domain, repository: this.repositoryName, format: 'npm' }))).repositoryEndpoint,
+            mavenEndpoint: (await this.send(new client_codeartifact_1.GetRepositoryEndpointCommand({ domain: this.domain, repository: this.repositoryName, format: 'maven' }))).repositoryEndpoint,
+            nugetEndpoint: (await this.send(new client_codeartifact_1.GetRepositoryEndpointCommand({ domain: this.domain, repository: this.repositoryName, format: 'nuget' }))).repositoryEndpoint,
+            pypiEndpoint: (await this.send(new client_codeartifact_1.GetRepositoryEndpointCommand({ domain: this.domain, repository: this.repositoryName, format: 'pypi' }))).repositoryEndpoint,
+        };
+        return this._loginInformation;
+    }
+    async delete() {
+        try {
+            await this.send(new client_codeartifact_1.DeleteRepositoryCommand({
+                domain: this.domain,
+                repository: this.repositoryName,
+            }));
+            // eslint-disable-next-line no-console
+            console.error('Deleted', this.repositoryName);
+        }
+        catch (e) {
+            if (!isResourceNotFoundException(e)) {
+                throw e;
+            }
+            // Okay
+        }
+    }
+    /**
+     * List all packages and mark them as "allow upstream versions".
+     *
+     * If we don't do this and we publish `foo@2.3.4-rc.0`, then we can't
+     * download `foo@2.3.0` anymore because by default CodeArtifact will
+     * block different versions from the same package.
+     */
+    async markAllUpstreamAllow() {
+        for await (const pkg of this.listPackages({ upstream: 'BLOCK' })) {
+            await this.send(new client_codeartifact_1.PutPackageOriginConfigurationCommand({
+                domain: this.domain,
+                repository: this.repositoryName,
+                format: pkg.format,
+                package: pkg.package,
+                namespace: pkg.namespace,
+                restrictions: {
+                    publish: 'ALLOW',
+                    upstream: 'ALLOW',
+                },
+            }));
+        }
+    }
+    async ensureDomain() {
+        if (await this.domainExists()) {
+            return;
+        }
+        await this.send(new client_codeartifact_1.CreateDomainCommand({
+            domain: this.domain,
+            tags: [{ key: 'testing', value: 'true' }],
+        }));
+    }
+    async ensureUpstreams() {
+        await this.ensureRepository(this.npmUpstream, {
+            description: 'The upstream repository for NPM',
+            external: 'public:npmjs',
+        });
+        await this.ensureRepository(this.mavenUpstream, {
+            description: 'The upstream repository for Maven',
+            external: 'public:maven-central',
+        });
+        await this.ensureRepository(this.nugetUpstream, {
+            description: 'The upstream repository for NuGet',
+            external: 'public:nuget-org',
+        });
+        await this.ensureRepository(this.pypiUpstream, {
+            description: 'The upstream repository for PyPI',
+            external: 'public:pypi',
+        });
+    }
+    async ensureRepository(name, options) {
+        var _a;
+        if (await this.repositoryExists(name)) {
+            return;
+        }
+        await this.send(new client_codeartifact_1.CreateRepositoryCommand({
+            domain: this.domain,
+            repository: name,
+            description: options === null || options === void 0 ? void 0 : options.description,
+            upstreams: (_a = options === null || options === void 0 ? void 0 : options.upstreams) === null || _a === void 0 ? void 0 : _a.map(repositoryName => ({ repositoryName })),
+            tags: (options === null || options === void 0 ? void 0 : options.tags) ? Object.entries(options.tags).map(([key, value]) => ({ key, value })) : undefined,
+        }));
+        if (options === null || options === void 0 ? void 0 : options.external) {
+            const externalConnection = options.external;
+            await retry(() => this.send(new client_codeartifact_1.AssociateExternalConnectionCommand({
+                domain: this.domain,
+                repository: name,
+                externalConnection,
+            })));
+        }
+    }
+    async domainExists() {
+        try {
+            await this.send(new client_codeartifact_1.DescribeDomainCommand({ domain: this.domain }));
+            return true;
+        }
+        catch (e) {
+            if (!isResourceNotFoundException(e)) {
+                throw e;
+            }
+            return false;
+        }
+    }
+    async repositoryExists(name) {
+        try {
+            await this.send(new client_codeartifact_1.DescribeRepositoryCommand({ domain: this.domain, repository: name }));
+            return true;
+        }
+        catch (e) {
+            if (!isResourceNotFoundException(e)) {
+                throw e;
+            }
+            return false;
+        }
+    }
+    async *listPackages(filter = {}) {
+        var _a;
+        let response = await this.send(new client_codeartifact_1.ListPackagesCommand({
+            domain: this.domain,
+            repository: this.repositoryName,
+            ...filter,
+        }));
+        while (true) {
+            for (const p of (_a = response.packages) !== null && _a !== void 0 ? _a : []) {
+                yield p;
+            }
+            if (!response.nextToken) {
+                break;
+            }
+            response = await this.send(new client_codeartifact_1.ListPackagesCommand({
+                domain: this.domain,
+                repository: this.repositoryName,
+                ...filter,
+                nextToken: response.nextToken,
+            }));
+        }
+    }
+    // eslint-disable-next-line max-len
+    send(command) {
+        return retryThrottled(() => this.codeArtifact.send(command));
+    }
+}
+exports.CodeArtifactRepo = CodeArtifactRepo;
+CodeArtifactRepo.DEFAULT_DOMAIN = 'publib-ca';
+async function retry(block) {
+    let attempts = 3;
+    while (true) {
+        try {
+            return await block();
+        }
+        catch (e) {
+            if (attempts-- === 0) {
+                throw e;
+            }
+            // eslint-disable-next-line no-console
+            console.debug(e.message);
+            await (0, sleep_1.sleep)(500);
+        }
+    }
+}
+async function retryThrottled(block) {
+    let time = 100;
+    let attempts = 15;
+    while (true) {
+        try {
+            return await block();
+        }
+        catch (e) {
+            // eslint-disable-next-line no-console
+            console.debug(e.message);
+            if (e.code !== 'ThrottlingException') {
+                throw e;
+            }
+            if (attempts-- === 0) {
+                throw e;
+            }
+            await (0, sleep_1.sleep)(Math.floor(Math.random() * time));
+            time *= 2;
+        }
+    }
+}
+function isResourceNotFoundException(x) {
+    return x instanceof client_codeartifact_1.ResourceNotFoundException;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"codeartifact-repo.js","sourceRoot":"","sources":["../../src/codeartifact/codeartifact-repo.ts"],"names":[],"mappings":";;;AAAA,sEAAgc;AAEhc,yCAAsC;AAEtC,MAAM,cAAc,GAAG,YAAY,CAAC;AACpC,MAAM,gBAAgB,GAAG,EAAE,GAAG,IAAI,GAAG,IAAI,CAAC,CAAC,UAAU;AAMrD;;GAEG;AACH,MAAa,gBAAgB;IAG3B;;OAEG;IACI,MAAM,CAAC,KAAK,CAAC,YAAY,CAAC,UAAmC,EAAE;QACpE,MAAM,SAAS,GAAG,IAAI,CAAC,MAAM,EAAE,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC,OAAO,CAAC,aAAa,EAAE,EAAE,CAAC,CAAC;QAExE,MAAM,IAAI,GAAG,IAAI,gBAAgB,CAAC,QAAQ,SAAS,EAAE,EAAE,OAAO,CAAC,CAAC;QAChE,MAAM,IAAI,CAAC,MAAM,EAAE,CAAC;QACpB,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;OAEG;IACI,MAAM,CAAC,KAAK,CAAC,cAAc,CAAC,IAAY,EAAE,UAAmC,EAAE;QACpF,MAAM,IAAI,GAAG,IAAI,gBAAgB,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC;QACjD,MAAM,IAAI,CAAC,MAAM,EAAE,CAAC;QACpB,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;OAEG;IACI,MAAM,CAAC,QAAQ,CAAC,cAAsB,EAAE,UAAmC,EAAE;QAClF,OAAO,IAAI,gBAAgB,CAAC,cAAc,EAAE,OAAO,CAAC,CAAC;IACvD,CAAC;IAED;;OAEG;IACI,MAAM,CAAC,KAAK,CAAC,EAAE,CAAC,UAAmC,EAAE;;QAC1D,IAAI,CAAC,MAAM,gBAAgB,CAAC,QAAQ,CAAC,SAAS,CAAC,CAAC,YAAY,EAAE,EAAE;YAC9D,OAAO;SACR;QAED,MAAM,YAAY,GAAG,IAAI,wCAAkB,CAAC;YAC1C,WAAW,EAAE,OAAO,CAAC,WAAW;SACjC,CAAC,CAAC;QAEH,IAAI,SAA6B,CAAC;QAClC,GAAG;YACD,MAAM,IAAI,GAAG,MAAM,cAAc,CAAC,GAAG,EAAE,CAAC,YAAY,CAAC,IAAI,CAAC,IAAI,6CAAuB,CAAC,EAAE,SAAS,EAAE,CAAC,CAAC,CAAC,CAAC;YAEvG,KAAK,MAAM,IAAI,IAAI,MAAA,IAAI,CAAC,YAAY,mCAAI,EAAE,EAAE;gBAC1C,MAAM,IAAI,GAAG,MAAM,cAAc,CAAC,GAAG,EAAE,CAAC,YAAY,CAAC,IAAI,CAAC,IAAI,gDAA0B,CAAC,EAAE,WAAW,EAAE,IAAI,CAAC,GAAI,EAAE,CAAC,CAAC,CAAC,CAAC;gBACvH,MAAM,WAAW,GAAG,MAAA,IAAI,aAAJ,IAAI,uBAAJ,IAAI,CAAE,IAAI,0CAAE,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,GAAG,KAAK,cAAc,IAAI,MAAM,CAAC,CAAC,CAAC,KAAK,CAAC,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC,CAAC;gBACpG,IAAI,WAAW,EAAE;oBACf,sCAAsC;oBACtC,OAAO,CAAC,KAAK,CAAC,UAAU,EAAE,IAAI,CAAC,IAAI,CAAC,CAAC;oBACrC,MAAM,cAAc,CAAC,GAAG,EAAE,CAAC,YAAY,CAAC,IAAI,CAAC,IAAI,6CAAuB,CAAC;wBACvE,MAAM,EAAE,IAAI,CAAC,UAAW;wBACxB,UAAU,EAAE,IAAI,CAAC,IAAK;qBACvB,CAAC,CAAC,CAAC,CAAC;iBACN;aACF;YAED,SAAS,GAAG,IAAI,CAAC,SAAS,CAAC;SAC5B,QAAQ,SAAS,EAAE;IACtB,CAAC;IAYD,YACkB,cAAsB,EACtC,UAAmC,EAAE;QADrB,mBAAc,GAAd,cAAc,CAAQ;QAXxB,gBAAW,GAAG,cAAc,CAAC;QAC7B,iBAAY,GAAG,eAAe,CAAC;QAC/B,kBAAa,GAAG,gBAAgB,CAAC;QACjC,kBAAa,GAAG,gBAAgB,CAAC;QACjC,WAAM,GAAG,gBAAgB,CAAC,cAAc,CAAC;QAUvD,IAAI,CAAC,YAAY,GAAG,IAAI,wCAAkB,CAAC,EAAE,WAAW,EAAE,OAAO,CAAC,WAAW,EAAE,CAAC,CAAC;IACnF,CAAC;IAED;;OAEG;IACI,KAAK,CAAC,MAAM;QACjB,MAAM,IAAI,CAAC,YAAY,EAAE,CAAC;QAC1B,MAAM,IAAI,CAAC,eAAe,EAAE,CAAC;QAE7B,MAAM,IAAI,CAAC,gBAAgB,CAAC,IAAI,CAAC,cAAc,EAAE;YAC/C,WAAW,EAAE,oBAAoB;YACjC,SAAS,EAAE;gBACT,IAAI,CAAC,WAAW;gBAChB,IAAI,CAAC,YAAY;gBACjB,IAAI,CAAC,aAAa;gBAClB,IAAI,CAAC,aAAa;aACnB;YACD,IAAI,EAAE;gBACJ,CAAC,cAAc,CAAC,EAAE,GAAG,IAAI,CAAC,GAAG,EAAE,GAAG,gBAAgB,EAAE;aACrD;SACF,CAAC,CAAC;IACL,CAAC;IAED;;OAEG;IACI,mBAAmB,CAAC,SAA2B;QACpD,IAAI,SAAS,CAAC,cAAc,KAAK,IAAI,CAAC,cAAc,EAAE;YACpD,MAAM,IAAI,KAAK,CAAC,sDAAsD,IAAI,CAAC,cAAc,SAAS,SAAS,CAAC,cAAc,GAAG,CAAC,CAAC;SAChI;QACD,IAAI,CAAC,iBAAiB,GAAG,SAAS,CAAC;IACrC,CAAC;IAEM,KAAK,CAAC,KAAK;;QAChB,IAAI,IAAI,CAAC,iBAAiB,EAAE;YAC1B,OAAO,IAAI,CAAC,iBAAiB,CAAC;SAC/B;QAED,MAAM,eAAe,GAAG,EAAE,GAAG,IAAI,CAAC;QAClC,MAAM,SAAS,GAAG,MAAM,IAAI,CAAC,IAAI,CAAC,IAAI,kDAA4B,CAAC,EAAE,MAAM,EAAE,IAAI,CAAC,MAAM,EAAE,eAAe,EAAE,CAAC,CAAC,CAAC;QAE9G,IAAI,CAAC,iBAAiB,GAAG;YACvB,mCAAmC;YACnC,SAAS,EAAE,SAAS,CAAC,kBAAmB;YACxC,gBAAgB,EAAE,MAAA,MAAA,SAAS,CAAC,UAAU,0CAAE,OAAO,EAAE,mCAAI,CAAC,IAAI,CAAC,GAAG,EAAE,GAAG,eAAe,GAAG,IAAI,CAAC;YAC1F,cAAc,EAAE,IAAI,CAAC,cAAc;YACnC,WAAW,EAAE,CAAC,MAAM,IAAI,CAAC,IAAI,CAAC,IAAI,kDAA4B,CAAC,EAAE,MAAM,EAAE,IAAI,CAAC,MAAM,EAAE,UAAU,EAAE,IAAI,CAAC,cAAc,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,CAAC,CAAC,CAAC,kBAAmB;YAC7J,aAAa,EAAE,CAAC,MAAM,IAAI,CAAC,IAAI,CAAC,IAAI,kDAA4B,CAAC,EAAE,MAAM,EAAE,IAAI,CAAC,MAAM,EAAE,UAAU,EAAE,IAAI,CAAC,cAAc,EAAE,MAAM,EAAE,OAAO,EAAE,CAAC,CAAC,CAAC,CAAC,kBAAmB;YACjK,aAAa,EAAE,CAAC,MAAM,IAAI,CAAC,IAAI,CAAC,IAAI,kDAA4B,CAAC,EAAE,MAAM,EAAE,IAAI,CAAC,MAAM,EAAE,UAAU,EAAE,IAAI,CAAC,cAAc,EAAE,MAAM,EAAE,OAAO,EAAE,CAAC,CAAC,CAAC,CAAC,kBAAmB;YACjK,YAAY,EAAE,CAAC,MAAM,IAAI,CAAC,IAAI,CAAC,IAAI,kDAA4B,CAAC,EAAE,MAAM,EAAE,IAAI,CAAC,MAAM,EAAE,UAAU,EAAE,IAAI,CAAC,cAAc,EAAE,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC,CAAC,CAAC,kBAAmB;SAChK,CAAC;QACF,OAAO,IAAI,CAAC,iBAAiB,CAAC;IAChC,CAAC;IAEM,KAAK,CAAC,MAAM;QACjB,IAAI;YACF,MAAM,IAAI,CAAC,IAAI,CAAC,IAAI,6CAAuB,CAAC;gBAC1C,MAAM,EAAE,IAAI,CAAC,MAAM;gBACnB,UAAU,EAAE,IAAI,CAAC,cAAc;aAChC,CAAC,CAAC,CAAC;YAEJ,sCAAsC;YACtC,OAAO,CAAC,KAAK,CAAC,SAAS,EAAE,IAAI,CAAC,cAAc,CAAC,CAAC;SAC/C;QAAC,OAAO,CAAM,EAAE;YACf,IAAI,CAAC,2BAA2B,CAAC,CAAC,CAAC,EAAE;gBAAE,MAAM,CAAC,CAAC;aAAE;YACjD,OAAO;SACR;IACH,CAAC;IAED;;;;;;OAMG;IACI,KAAK,CAAC,oBAAoB;QAC/B,IAAI,KAAK,EAAE,MAAM,GAAG,IAAI,IAAI,CAAC,YAAY,CAAC,EAAE,QAAQ,EAAE,OAAO,EAAE,CAAC,EAAE;YAChE,MAAM,IAAI,CAAC,IAAI,CAAC,IAAI,0DAAoC,CAAC;gBACvD,MAAM,EAAE,IAAI,CAAC,MAAM;gBACnB,UAAU,EAAE,IAAI,CAAC,cAAc;gBAE/B,MAAM,EAAE,GAAG,CAAC,MAAO;gBACnB,OAAO,EAAE,GAAG,CAAC,OAAQ;gBACrB,SAAS,EAAE,GAAG,CAAC,SAAU;gBACzB,YAAY,EAAE;oBACZ,OAAO,EAAE,OAAO;oBAChB,QAAQ,EAAE,OAAO;iBAClB;aACF,CAAC,CAAC,CAAC;SACL;IACH,CAAC;IAEO,KAAK,CAAC,YAAY;QACxB,IAAI,MAAM,IAAI,CAAC,YAAY,EAAE,EAAE;YAAE,OAAO;SAAE;QAC1C,MAAM,IAAI,CAAC,IAAI,CAAC,IAAI,yCAAmB,CAAC;YACtC,MAAM,EAAE,IAAI,CAAC,MAAM;YACnB,IAAI,EAAE,CAAC,EAAE,GAAG,EAAE,SAAS,EAAE,KAAK,EAAE,MAAM,EAAE,CAAC;SAC1C,CAAC,CAAC,CAAC;IACN,CAAC;IAEO,KAAK,CAAC,eAAe;QAC3B,MAAM,IAAI,CAAC,gBAAgB,CAAC,IAAI,CAAC,WAAW,EAAE;YAC5C,WAAW,EAAE,iCAAiC;YAC9C,QAAQ,EAAE,cAAc;SACzB,CAAC,CAAC;QACH,MAAM,IAAI,CAAC,gBAAgB,CAAC,IAAI,CAAC,aAAa,EAAE;YAC9C,WAAW,EAAE,mCAAmC;YAChD,QAAQ,EAAE,sBAAsB;SACjC,CAAC,CAAC;QACH,MAAM,IAAI,CAAC,gBAAgB,CAAC,IAAI,CAAC,aAAa,EAAE;YAC9C,WAAW,EAAE,mCAAmC;YAChD,QAAQ,EAAE,kBAAkB;SAC7B,CAAC,CAAC;QACH,MAAM,IAAI,CAAC,gBAAgB,CAAC,IAAI,CAAC,YAAY,EAAE;YAC7C,WAAW,EAAE,kCAAkC;YAC/C,QAAQ,EAAE,aAAa;SACxB,CAAC,CAAC;IACL,CAAC;IAEO,KAAK,CAAC,gBAAgB,CAAC,IAAY,EAAE,OAK5C;;QACC,IAAI,MAAM,IAAI,CAAC,gBAAgB,CAAC,IAAI,CAAC,EAAE;YAAE,OAAO;SAAE;QAElD,MAAM,IAAI,CAAC,IAAI,CAAC,IAAI,6CAAuB,CAAC;YAC1C,MAAM,EAAE,IAAI,CAAC,MAAM;YACnB,UAAU,EAAE,IAAI;YAChB,WAAW,EAAE,OAAO,aAAP,OAAO,uBAAP,OAAO,CAAE,WAAW;YACjC,SAAS,EAAE,MAAA,OAAO,aAAP,OAAO,uBAAP,OAAO,CAAE,SAAS,0CAAE,GAAG,CAAC,cAAc,CAAC,EAAE,CAAC,CAAC,EAAE,cAAc,EAAE,CAAC,CAAC;YAC1E,IAAI,EAAE,CAAA,OAAO,aAAP,OAAO,uBAAP,OAAO,CAAE,IAAI,EAAC,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,EAAE,KAAK,CAAC,EAAE,EAAE,CAAC,CAAC,EAAE,GAAG,EAAE,KAAK,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,SAAS;SACvG,CAAC,CAAC,CAAC;QAEJ,IAAI,OAAO,aAAP,OAAO,uBAAP,OAAO,CAAE,QAAQ,EAAE;YACrB,MAAM,kBAAkB,GAAG,OAAO,CAAC,QAAQ,CAAC;YAC5C,MAAM,KAAK,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,wDAAkC,CAAC;gBACjE,MAAM,EAAE,IAAI,CAAC,MAAM;gBACnB,UAAU,EAAE,IAAI;gBAChB,kBAAkB;aACnB,CAAC,CAAC,CAAC,CAAC;SACN;IACH,CAAC;IAEO,KAAK,CAAC,YAAY;QACxB,IAAI;YACF,MAAM,IAAI,CAAC,IAAI,CAAC,IAAI,2CAAqB,CAAC,EAAE,MAAM,EAAE,IAAI,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC;YACpE,OAAO,IAAI,CAAC;SACb;QAAC,OAAO,CAAM,EAAE;YACf,IAAI,CAAC,2BAA2B,CAAC,CAAC,CAAC,EAAE;gBAAE,MAAM,CAAC,CAAC;aAAE;YACjD,OAAO,KAAK,CAAC;SACd;IACH,CAAC;IAEO,KAAK,CAAC,gBAAgB,CAAC,IAAY;QACzC,IAAI;YACF,MAAM,IAAI,CAAC,IAAI,CAAC,IAAI,+CAAyB,CAAC,EAAE,MAAM,EAAE,IAAI,CAAC,MAAM,EAAE,UAAU,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC;YAC1F,OAAO,IAAI,CAAC;SACb;QAAC,OAAO,CAAM,EAAE;YACf,IAAI,CAAC,2BAA2B,CAAC,CAAC,CAAC,EAAE;gBAAE,MAAM,CAAC,CAAC;aAAE;YACjD,OAAO,KAAK,CAAC;SACd;IACH,CAAC;IAEO,KAAK,CAAA,CAAE,YAAY,CAAC,SAAwE,EAAE;;QACpG,IAAI,QAAQ,GAAG,MAAM,IAAI,CAAC,IAAI,CAAC,IAAI,yCAAmB,CAAC;YACrD,MAAM,EAAE,IAAI,CAAC,MAAM;YACnB,UAAU,EAAE,IAAI,CAAC,cAAc;YAC/B,GAAG,MAAM;SACV,CAAC,CAAC,CAAC;QAEJ,OAAO,IAAI,EAAE;YACX,KAAK,MAAM,CAAC,IAAI,MAAA,QAAQ,CAAC,QAAQ,mCAAI,EAAE,EAAE;gBACvC,MAAM,CAAC,CAAC;aACT;YAED,IAAI,CAAC,QAAQ,CAAC,SAAS,EAAE;gBACvB,MAAM;aACP;YAED,QAAQ,GAAG,MAAM,IAAI,CAAC,IAAI,CAAC,IAAI,yCAAmB,CAAC;gBACjD,MAAM,EAAE,IAAI,CAAC,MAAM;gBACnB,UAAU,EAAE,IAAI,CAAC,cAAc;gBAC/B,GAAG,MAAM;gBACT,SAAS,EAAE,QAAQ,CAAC,SAAS;aAC9B,CAAC,CAAC,CAAC;SACL;IACH,CAAC;IAED,mCAAmC;IAC3B,IAAI,CAAkI,OAAuE;QACnN,OAAO,cAAc,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,OAAc,CAAC,CAAC,CAAC;IACtE,CAAC;;AAhRH,4CAiRC;AAhRwB,+BAAc,GAAG,WAAW,CAAC;AAkRtD,KAAK,UAAU,KAAK,CAAI,KAAuB;IAC7C,IAAI,QAAQ,GAAG,CAAC,CAAC;IACjB,OAAO,IAAI,EAAE;QACX,IAAI;YACF,OAAO,MAAM,KAAK,EAAE,CAAC;SACtB;QAAC,OAAO,CAAM,EAAE;YACf,IAAI,QAAQ,EAAE,KAAK,CAAC,EAAE;gBAAE,MAAM,CAAC,CAAC;aAAE;YAClC,sCAAsC;YACtC,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC;YACzB,MAAM,IAAA,aAAK,EAAC,GAAG,CAAC,CAAC;SAClB;KACF;AACH,CAAC;AAED,KAAK,UAAU,cAAc,CAAI,KAAuB;IACtD,IAAI,IAAI,GAAG,GAAG,CAAC;IACf,IAAI,QAAQ,GAAG,EAAE,CAAC;IAClB,OAAO,IAAI,EAAE;QACX,IAAI;YACF,OAAO,MAAM,KAAK,EAAE,CAAC;SACtB;QAAC,OAAO,CAAM,EAAE;YACf,sCAAsC;YACtC,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC;YACzB,IAAI,CAAC,CAAC,IAAI,KAAK,qBAAqB,EAAE;gBAAE,MAAM,CAAC,CAAC;aAAE;YAClD,IAAI,QAAQ,EAAE,KAAK,CAAC,EAAE;gBAAE,MAAM,CAAC,CAAC;aAAE;YAClC,MAAM,IAAA,aAAK,EAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,MAAM,EAAE,GAAG,IAAI,CAAC,CAAC,CAAC;YAC9C,IAAI,IAAI,CAAC,CAAC;SACX;KACF;AACH,CAAC;AAYD,SAAS,2BAA2B,CAAC,CAAM;IACzC,OAAO,CAAC,YAAY,+CAAyB,CAAC;AAChD,CAAC","sourcesContent":["import { AssociateExternalConnectionCommand, CodeartifactClient, CreateDomainCommand, CreateRepositoryCommand, DeleteRepositoryCommand, DescribeDomainCommand, DescribeRepositoryCommand, GetAuthorizationTokenCommand, GetRepositoryEndpointCommand, ListPackagesCommand, ListPackagesCommandInput, ListRepositoriesCommand, ListTagsForResourceCommand, PutPackageOriginConfigurationCommand, ResourceNotFoundException } from '@aws-sdk/client-codeartifact';\nimport { AwsCredentialIdentityProvider, Command, MetadataBearer } from '@aws-sdk/types';\nimport { sleep } from '../help/sleep';\n\nconst COLLECT_BY_TAG = 'collect-by';\nconst REPO_LIFETIME_MS = 24 * 3600 * 1000; // One day\n\nexport interface CodeArtifactRepoOptions {\n  readonly credentials?: AwsCredentialIdentityProvider;\n}\n\n/**\n * A CodeArtifact repository\n */\nexport class CodeArtifactRepo {\n  public static readonly DEFAULT_DOMAIN = 'publib-ca';\n\n  /**\n   * Create a CodeArtifact repo with a random name\n   */\n  public static async createRandom(options: CodeArtifactRepoOptions = {}) {\n    const qualifier = Math.random().toString(36).replace(/[^a-z0-9]+/g, '');\n\n    const repo = new CodeArtifactRepo(`test-${qualifier}`, options);\n    await repo.create();\n    return repo;\n  }\n\n  /**\n   * Create a CodeArtifact repository with a given name\n   */\n  public static async createWithName(name: string, options: CodeArtifactRepoOptions = {}) {\n    const repo = new CodeArtifactRepo(name, options);\n    await repo.create();\n    return repo;\n  }\n\n  /**\n   * Reference an existing CodeArtifact repository\n   */\n  public static existing(repositoryName: string, options: CodeArtifactRepoOptions = {}) {\n    return new CodeArtifactRepo(repositoryName, options);\n  }\n\n  /**\n   * Garbage collect repositories\n   */\n  public static async gc(options: CodeArtifactRepoOptions = {}) {\n    if (!await CodeArtifactRepo.existing('*dummy*').domainExists()) {\n      return;\n    }\n\n    const codeArtifact = new CodeartifactClient({\n      credentials: options.credentials,\n    });\n\n    let nextToken: string | undefined;\n    do {\n      const page = await retryThrottled(() => codeArtifact.send(new ListRepositoriesCommand({ nextToken })));\n\n      for (const repo of page.repositories ?? []) {\n        const tags = await retryThrottled(() => codeArtifact.send(new ListTagsForResourceCommand({ resourceArn: repo.arn! })));\n        const collectable = tags?.tags?.find(t => t.key === COLLECT_BY_TAG && Number(t.value) < Date.now());\n        if (collectable) {\n          // eslint-disable-next-line no-console\n          console.error('Deleting', repo.name);\n          await retryThrottled(() => codeArtifact.send(new DeleteRepositoryCommand({\n            domain: repo.domainName!,\n            repository: repo.name!,\n          })));\n        }\n      }\n\n      nextToken = page.nextToken;\n    } while (nextToken);\n  }\n\n  public readonly npmUpstream = 'npm-upstream';\n  public readonly pypiUpstream = 'pypi-upstream';\n  public readonly nugetUpstream = 'nuget-upstream';\n  public readonly mavenUpstream = 'maven-upstream';\n  public readonly domain = CodeArtifactRepo.DEFAULT_DOMAIN;\n\n  private readonly codeArtifact;\n\n  private _loginInformation: LoginInformation | undefined;\n\n  private constructor(\n    public readonly repositoryName: string,\n    options: CodeArtifactRepoOptions = {},\n  ) {\n    this.codeArtifact = new CodeartifactClient({ credentials: options.credentials });\n  }\n\n  /**\n   * Create the repository\n   */\n  public async create() {\n    await this.ensureDomain();\n    await this.ensureUpstreams();\n\n    await this.ensureRepository(this.repositoryName, {\n      description: 'Testing repository',\n      upstreams: [\n        this.npmUpstream,\n        this.pypiUpstream,\n        this.nugetUpstream,\n        this.mavenUpstream,\n      ],\n      tags: {\n        [COLLECT_BY_TAG]: `${Date.now() + REPO_LIFETIME_MS}`,\n      },\n    });\n  }\n\n  /**\n   * Absorb old login information\n   */\n  public setLoginInformation(loginInfo: LoginInformation) {\n    if (loginInfo.repositoryName !== this.repositoryName) {\n      throw new Error(`This login info seems to be for a different repo. '${this.repositoryName}' != '${loginInfo.repositoryName}'`);\n    }\n    this._loginInformation = loginInfo;\n  }\n\n  public async login(): Promise<LoginInformation> {\n    if (this._loginInformation) {\n      return this._loginInformation;\n    }\n\n    const durationSeconds = 12 * 3600;\n    const authToken = await this.send(new GetAuthorizationTokenCommand({ domain: this.domain, durationSeconds }));\n\n    this._loginInformation = {\n      // eslint-disable-next-line max-len\n      authToken: authToken.authorizationToken!,\n      expirationTimeMs: authToken.expiration?.getTime() ?? (Date.now() + durationSeconds * 1000),\n      repositoryName: this.repositoryName,\n      npmEndpoint: (await this.send(new GetRepositoryEndpointCommand({ domain: this.domain, repository: this.repositoryName, format: 'npm' }))).repositoryEndpoint!,\n      mavenEndpoint: (await this.send(new GetRepositoryEndpointCommand({ domain: this.domain, repository: this.repositoryName, format: 'maven' }))).repositoryEndpoint!,\n      nugetEndpoint: (await this.send(new GetRepositoryEndpointCommand({ domain: this.domain, repository: this.repositoryName, format: 'nuget' }))).repositoryEndpoint!,\n      pypiEndpoint: (await this.send(new GetRepositoryEndpointCommand({ domain: this.domain, repository: this.repositoryName, format: 'pypi' }))).repositoryEndpoint!,\n    };\n    return this._loginInformation;\n  }\n\n  public async delete() {\n    try {\n      await this.send(new DeleteRepositoryCommand({\n        domain: this.domain,\n        repository: this.repositoryName,\n      }));\n\n      // eslint-disable-next-line no-console\n      console.error('Deleted', this.repositoryName);\n    } catch (e: any) {\n      if (!isResourceNotFoundException(e)) { throw e; }\n      // Okay\n    }\n  }\n\n  /**\n   * List all packages and mark them as \"allow upstream versions\".\n   *\n   * If we don't do this and we publish `foo@2.3.4-rc.0`, then we can't\n   * download `foo@2.3.0` anymore because by default CodeArtifact will\n   * block different versions from the same package.\n   */\n  public async markAllUpstreamAllow() {\n    for await (const pkg of this.listPackages({ upstream: 'BLOCK' })) {\n      await this.send(new PutPackageOriginConfigurationCommand({\n        domain: this.domain,\n        repository: this.repositoryName,\n\n        format: pkg.format!,\n        package: pkg.package!,\n        namespace: pkg.namespace!,\n        restrictions: {\n          publish: 'ALLOW',\n          upstream: 'ALLOW',\n        },\n      }));\n    }\n  }\n\n  private async ensureDomain() {\n    if (await this.domainExists()) { return; }\n    await this.send(new CreateDomainCommand({\n      domain: this.domain,\n      tags: [{ key: 'testing', value: 'true' }],\n    }));\n  }\n\n  private async ensureUpstreams() {\n    await this.ensureRepository(this.npmUpstream, {\n      description: 'The upstream repository for NPM',\n      external: 'public:npmjs',\n    });\n    await this.ensureRepository(this.mavenUpstream, {\n      description: 'The upstream repository for Maven',\n      external: 'public:maven-central',\n    });\n    await this.ensureRepository(this.nugetUpstream, {\n      description: 'The upstream repository for NuGet',\n      external: 'public:nuget-org',\n    });\n    await this.ensureRepository(this.pypiUpstream, {\n      description: 'The upstream repository for PyPI',\n      external: 'public:pypi',\n    });\n  }\n\n  private async ensureRepository(name: string, options?: {\n    readonly description?: string;\n    readonly external?: string;\n    readonly upstreams?: string[];\n    readonly tags?: Record<string, string>;\n  }) {\n    if (await this.repositoryExists(name)) { return; }\n\n    await this.send(new CreateRepositoryCommand({\n      domain: this.domain,\n      repository: name,\n      description: options?.description,\n      upstreams: options?.upstreams?.map(repositoryName => ({ repositoryName })),\n      tags: options?.tags ? Object.entries(options.tags).map(([key, value]) => ({ key, value })) : undefined,\n    }));\n\n    if (options?.external) {\n      const externalConnection = options.external;\n      await retry(() => this.send(new AssociateExternalConnectionCommand({\n        domain: this.domain,\n        repository: name,\n        externalConnection,\n      })));\n    }\n  }\n\n  private async domainExists() {\n    try {\n      await this.send(new DescribeDomainCommand({ domain: this.domain }));\n      return true;\n    } catch (e: any) {\n      if (!isResourceNotFoundException(e)) { throw e; }\n      return false;\n    }\n  }\n\n  private async repositoryExists(name: string) {\n    try {\n      await this.send(new DescribeRepositoryCommand({ domain: this.domain, repository: name }));\n      return true;\n    } catch (e: any) {\n      if (!isResourceNotFoundException(e)) { throw e; }\n      return false;\n    }\n  }\n\n  private async* listPackages(filter: Pick<ListPackagesCommandInput, 'upstream'|'publish'|'format'> = {}) {\n    let response = await this.send(new ListPackagesCommand({\n      domain: this.domain,\n      repository: this.repositoryName,\n      ...filter,\n    }));\n\n    while (true) {\n      for (const p of response.packages ?? []) {\n        yield p;\n      }\n\n      if (!response.nextToken) {\n        break;\n      }\n\n      response = await this.send(new ListPackagesCommand({\n        domain: this.domain,\n        repository: this.repositoryName,\n        ...filter,\n        nextToken: response.nextToken,\n      }));\n    }\n  }\n\n  // eslint-disable-next-line max-len\n  private send<ClientInput extends object, InputType extends ClientInput, ClientOutput extends MetadataBearer, OutputType extends ClientOutput>(command: Command<ClientInput, InputType, ClientOutput, OutputType, any>): Promise<OutputType> {\n    return retryThrottled(() => this.codeArtifact.send(command as any));\n  }\n}\n\nasync function retry<A>(block: () => Promise<A>) {\n  let attempts = 3;\n  while (true) {\n    try {\n      return await block();\n    } catch (e: any) {\n      if (attempts-- === 0) { throw e; }\n      // eslint-disable-next-line no-console\n      console.debug(e.message);\n      await sleep(500);\n    }\n  }\n}\n\nasync function retryThrottled<A>(block: () => Promise<A>) {\n  let time = 100;\n  let attempts = 15;\n  while (true) {\n    try {\n      return await block();\n    } catch (e: any) {\n      // eslint-disable-next-line no-console\n      console.debug(e.message);\n      if (e.code !== 'ThrottlingException') { throw e; }\n      if (attempts-- === 0) { throw e; }\n      await sleep(Math.floor(Math.random() * time));\n      time *= 2;\n    }\n  }\n}\n\nexport interface LoginInformation {\n  readonly authToken: string;\n  readonly expirationTimeMs: number;\n  readonly repositoryName: string;\n  readonly npmEndpoint: string;\n  readonly mavenEndpoint: string;\n  readonly nugetEndpoint: string;\n  readonly pypiEndpoint: string;\n}\n\nfunction isResourceNotFoundException(x: any): x is ResourceNotFoundException {\n  return x instanceof ResourceNotFoundException;\n}"]}

package/lib/codeartifact/display.d.ts

@@ -0,0 +1 @@
+export declare function header(caption: string): void;

package/lib/codeartifact/display.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.header = void 0;
+function header(caption) {
+    console.log('');
+    console.log('/'.repeat(70));
+    console.log(`//  ${caption}`);
+    console.log('');
+}
+exports.header = header;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGlzcGxheS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9jb2RlYXJ0aWZhY3QvZGlzcGxheS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFBQSxTQUFnQixNQUFNLENBQUMsT0FBZTtJQUNwQyxPQUFPLENBQUMsR0FBRyxDQUFDLEVBQUUsQ0FBQyxDQUFDO0lBQ2hCLE9BQU8sQ0FBQyxHQUFHLENBQUMsR0FBRyxDQUFDLE1BQU0sQ0FBQyxFQUFFLENBQUMsQ0FBQyxDQUFDO0lBQzVCLE9BQU8sQ0FBQyxHQUFHLENBQUMsT0FBTyxPQUFPLEVBQUUsQ0FBQyxDQUFDO0lBQzlCLE9BQU8sQ0FBQyxHQUFHLENBQUMsRUFBRSxDQUFDLENBQUM7QUFDbEIsQ0FBQztBQUxELHdCQUtDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGZ1bmN0aW9uIGhlYWRlcihjYXB0aW9uOiBzdHJpbmcpIHtcbiAgY29uc29sZS5sb2coJycpO1xuICBjb25zb2xlLmxvZygnLycucmVwZWF0KDcwKSk7XG4gIGNvbnNvbGUubG9nKGAvLyAgJHtjYXB0aW9ufWApO1xuICBjb25zb2xlLmxvZygnJyk7XG59Il19

package/lib/codeartifact/files.d.ts

@@ -0,0 +1,15 @@
+export declare function rmFile(filename: string): Promise<void>;
+export declare function addToFile(filename: string, line: string): Promise<void>;
+export declare function writeFile(filename: string, contents: string): Promise<void>;
+export declare function copyDirectoryContents(dir: string, target: string): Promise<void>;
+export declare function findUp(name: string, directory?: string): string | undefined;
+/**
+ * Docker-safe home directory
+ */
+export declare function homeDir(): string;
+export declare function loadLines(filename: string): Promise<string[]>;
+export declare function writeLines(filename: string, lines: string[]): Promise<void>;
+/**
+ * Update a spaceless ini file in place
+ */
+export declare function updateIniKey(lines: string[], key: string, value: string): void;

package/lib/codeartifact/files.js

@@ -0,0 +1,104 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updateIniKey = exports.writeLines = exports.loadLines = exports.homeDir = exports.findUp = exports.copyDirectoryContents = exports.writeFile = exports.addToFile = exports.rmFile = void 0;
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs-extra"));
+async function rmFile(filename) {
+    if (await fs.pathExists(filename)) {
+        await fs.unlink(filename);
+    }
+}
+exports.rmFile = rmFile;
+async function addToFile(filename, line) {
+    let contents = await fs.pathExists(filename) ? await fs.readFile(filename, { encoding: 'utf-8' }) : '';
+    if (!contents.endsWith('\n')) {
+        contents += '\n';
+    }
+    contents += line + '\n';
+    await writeFile(filename, contents);
+}
+exports.addToFile = addToFile;
+async function writeFile(filename, contents) {
+    await fs.mkdirp(path.dirname(filename));
+    await fs.writeFile(filename, contents, { encoding: 'utf-8' });
+}
+exports.writeFile = writeFile;
+async function copyDirectoryContents(dir, target) {
+    for (const file of await fs.readdir(path.join(dir))) {
+        await fs.copyFile(path.join(dir, file), path.join(target, file));
+    }
+}
+exports.copyDirectoryContents = copyDirectoryContents;
+function findUp(name, directory = process.cwd()) {
+    const absoluteDirectory = path.resolve(directory);
+    const file = path.join(directory, name);
+    if (fs.existsSync(file)) {
+        return file;
+    }
+    const { root } = path.parse(absoluteDirectory);
+    if (absoluteDirectory == root) {
+        return undefined;
+    }
+    return findUp(name, path.dirname(absoluteDirectory));
+}
+exports.findUp = findUp;
+/**
+ * Docker-safe home directory
+ */
+function homeDir() {
+    var _a;
+    return (_a = os.userInfo().homedir) !== null && _a !== void 0 ? _a : os.homedir();
+}
+exports.homeDir = homeDir;
+async function loadLines(filename) {
+    return await fs.pathExists(filename) ? (await fs.readFile(filename, { encoding: 'utf-8' })).trim().split('\n') : [];
+}
+exports.loadLines = loadLines;
+async function writeLines(filename, lines) {
+    // Must end in a newline or our bash script won't read it properly
+    await fs.writeFile(filename, lines.join('\n') + '\n', { encoding: 'utf-8' });
+}
+exports.writeLines = writeLines;
+/**
+ * Update a spaceless ini file in place
+ */
+function updateIniKey(lines, key, value) {
+    const prefix = `${key}=`;
+    let found = false;
+    for (let i = 0; i < lines.length; i++) {
+        if (lines[i].startsWith(prefix)) {
+            lines[i] = prefix + value;
+            found = true;
+            break;
+        }
+    }
+    if (!found) {
+        lines.push(prefix + value);
+    }
+}
+exports.updateIniKey = updateIniKey;
+//# sourceMappingURL=data:application/json;base64,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

package/lib/codeartifact/shell.d.ts

@@ -0,0 +1,51 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import * as child_process from 'child_process';
+/**
+ * A shell command that does what you want
+ *
+ * Is platform-aware, handles errors nicely.
+ */
+export declare function shell(command: string | string[], options?: ShellOptions): Promise<string>;
+export interface ShellOptions extends child_process.SpawnOptions {
+    /**
+     * Properties to add to 'env'
+     */
+    readonly modEnv?: Record<string, string>;
+    /**
+     * Don't fail when exiting with an error
+     *
+     * @default false
+     */
+    readonly allowErrExit?: boolean;
+    /**
+     * Whether to capture stderr
+     *
+     * @default true
+     */
+    readonly captureStderr?: boolean;
+    /**
+     * Pass output here
+     *
+     * @default stdout unless quiet=true
+     */
+    readonly output?: NodeJS.WritableStream;
+    /**
+     * Only return stderr. For example, this is used to validate
+     * that when CI=true, all logs are sent to stdout.
+     *
+     * @default false
+     */
+    readonly onlyStderr?: boolean;
+    /**
+     * Don't log to stdout
+     *
+     * @default always
+     */
+    readonly show?: 'always' | 'never' | 'error';
+}
+/**
+ * rm -rf reimplementation, don't want to depend on an NPM package for this
+ */
+export declare function rimraf(fsPath: string): void;
+export declare function addToShellPath(x: string): void;