@codiac.io/codiac-cli 1.2.216 → 1.2.219

package/lib/ops/docker-credentials-store.js

@@ -0,0 +1,238 @@
+"use strict";
+// MOVED TO ops-common
+// import * as path from "path";
+// import { inject } from 'inversify';
+// import { INTERFACES } from '@codiac.io/codiac-common';
+// import { BetterConsoleLogger } from "@codiac.io/codiac-common/better-logger"
+// import { IBetterLogger, LogLevel } from '@codiac.io/codiac-common/IBetterLogger';
+// import { CodiacError } from "@codiac.io/codiac-common/contracts";
+// import { CliExec, JsonUtils } from '@codiac.io/codiac-ops-common';
+// import { INTERFACES_CLI } from './INTERFACES_CLI';
+// import { IDockerConfig, RegistryCredentials, UsernamePassword } from './docker-config';
+// import { DOCKER_CONSTANTS } from './docker-constants';
+// /**
+//  * Credentials store:
+//  * @see https://docs.docker.com/engine/reference/commandline/cli/
+//  * @see https://docs.docker.com/engine/reference/commandline/login/#credentials-store
+//  *
+//  *  **EITHER** docker is set to store creds in the docker config  by default `$HOME/.docker/config.json`, overridden by env var `DOCKER_CONFIG` )
+//  *  
+//  *  **OR** it stores them in an external creds store, declared in the docker config as the value of the property `credsStore`.
+//  *  The value of the credsStore setting is the suffix of the creds store helper program, 
+//  *  which MUST be cenventionally named as `"docker-credential-${suffix}"`.
+//  *  these programs MUST support a `get`, `store`, and `delete` method.
+//  *  (NOTE: logging in stores em, logging out deletes them).
+//  * 
+//  *  SO:  In this case, to get the login creds for docker, we need to:
+//  * 
+//  *  a) get the path to the docker config:   `path = 'echo $DOCKER_CONFIG' || '$HOME/.docker/config.json'` 
+//  * 
+//  *  b) load the docker config:  `let config = JSON.parse(load[path to config.json])`
+//  * 
+//  *  c) check if the `credHelpers` contains the registry url youre looking for, 
+//  * 
+//  *     if not, fall back to `credsStore` property,
+//  * 
+//  *     if not, fall back to `auths` property which contains the creds for each registry
+//  * 
+//  *  d) if theres a credsStore or credHelpers, 
+//  * 
+//  *     1) Assemble the name of the binary: `let binary = 'docker-crenential-${credsStoreValue}';`
+//  * 
+//  *     2) fire the get command:  `let credsJson = spawnAndLog('${binary} get ${registry}')`
+//  * 
+//  *        NOTE:  there may be a "list" command, like there is for the "desktop" store.
+//  *        if these creds arent there we have to throw 401 (missing or invalid creds),
+//  *        and the CLI needs to recognize that missing creds error type so that it can prompt for creds.
+//  *        and it should continue to loop a prompt while receiving a 401 invalid creds response (tho its called unauthorized).
+//  *  
+//  *  Q: Shall we throw on an unauthorized response (403)?  Or prompt them for creds again?  
+//  */
+// export class DockerCredentialsStore {
+//   /** The fully qualified pathname of the docker config file that the docker runtime is using. */
+//   public static configPath: string = DockerCredentialsStore.getConfigPath();
+//   /** Factory method that determines which creds store docker is configured for 
+//    * and spins up an instance with a matching configuration.  */
+//   public static create(): DockerCredentialsStore {
+//     try {
+//       let config = this.loadDockerConfig();
+//       // TODO:  Get the logger from the CLI's IOC container.
+//       let logger = new BetterConsoleLogger();
+//       let instance = new DockerCredentialsStore(config, new CliExec(logger), logger);
+//       return instance;
+//     } catch (err) {
+//       throw err;
+//     }
+//   }
+//   /** Determines the fully qualified pathname of the docker config file that the docker runtime is using. */
+//   private static getConfigPath(): string {
+//     let homePath = (process.platform === "win32") ? process.env["HOMEPATH"]! : process.env["HOME"]!;
+//     let override = process.env[DOCKER_CONSTANTS.CONFIG_PATH_ENV_VAR_NAME];
+//     return override || path.posix.join(homePath, DOCKER_CONSTANTS.DEFAULT_CONFIG_FOLDER, DOCKER_CONSTANTS.DEFAULT_CONFIG_FILE)
+//   }
+//   private static loadDockerConfig(): IDockerConfig {
+//     try {
+//       let config = JsonUtils.deserializeJsonFile<IDockerConfig>(this.configPath);
+//       if (!config) throw new CodiacError(`Docker config file does not exist at [${this.configPath}].`)
+//       return config;
+//     } catch (err) {
+//       throw err;
+//     }
+//   }
+//   // -------------------------------------------------------------------------------------
+//   //  NOTE:  Below is a help output from running: $ docker-credential-desktop --help
+//   //         Do ALL cred helpers have these methods?  
+//   //         (the Docker docs suggest the helper interface only requires store, get, and erase).
+//   //  
+//   //    erase       Removes a set of credentials from the store
+//   //    get         Retrieves credentials from the store
+//   //    help        Help about any command
+//   //    list        Lists the credentials in the store
+//   //    move        Move credentials from one store to another
+//   //    store       Adds a set of credentials to the store
+//   //    version     Display the version of the credentials helper protocol
+//   // -------------------------------------------------------------------------------------
+//   /** Use the static factory method DockerCredentialsStore.create() instead.  */
+//   private constructor(@inject(INTERFACES_CLI.IDockerConfig) public config: IDockerConfig
+//     , @inject(CliExec) private _cliExec: CliExec
+//     , @inject(INTERFACES.IBetterLogger) private logger: IBetterLogger) {
+//   }
+//   /** Adds a set of credentials to the store. */
+//   public async store(creds: RegistryCredentials): Promise<void> {
+//     return new Promise<void>(async (resolve, reject) => {
+//       try {
+//         throw new CodiacError("store() is not implemented");
+//         // resolve();
+//       } catch (err) {
+//         reject(err);
+//       }
+//     });
+//   }
+//   private getCredsStoreNameFor(registry: string): string | undefined {
+//     let store: string | undefined;
+//     if (this.config.credHelpers && this.config.credHelpers[registry]) {
+//       store = this.config.credHelpers[registry];
+//     } else if (this.config.credsStore) {
+//       store = this.config.credsStore;
+//     }
+//     return store;
+//   }
+//   /** Retrieves credentials from the store. 
+//    * @param registry Domain name without any protocol or path.  (eg:  index.docker.io, or ourstuff.azurecr.io)
+//    */
+//   //  * @param scope scope prefix within the registry used as the prefix in the image name (eg: "letmeaskmydog" for the image "letmeaskmydog/toyhauler-base")
+//   public async tryGet(registry: string): Promise<UsernamePassword | undefined> {
+//     return new Promise<UsernamePassword | undefined>(async (resolve, reject) => {
+//       let creds: RegistryCredentials | undefined;
+//       try {
+//         let store = this.getCredsStoreNameFor(registry);
+//         if (store) {
+//           creds = await this.getFromStoreBinary(store, registry);
+//           // }
+//           // if (this.config.credHelpers && this.config.credHelpers[registry]) {
+//           //   store = this.config.credHelpers[registry];
+//           //   creds = await this.getFromStoreBinary(store, registry);
+//           // } else if (this.config.credsStore) {
+//           //   store = this.config.credsStore;
+//           //   creds = await this.getFromStoreBinary(store, registry);
+//         } else {
+//           store = DockerCredentialsStore.configPath;
+//           if (this.config.auths) {
+//             let userpass = this.config.auths[registry];
+//             if (userpass) creds = { ServerURL: registry, ...userpass }
+//           }
+//         }
+//         // if (!creds) throw new CodiacError(`No credentials exist for [${scope ? registry.concat("/", scope) : registry}] in [${store}].`);
+//         if (!creds) throw new CodiacError(`No credentials exist for [${registry}] in [${store}].`);
+//         resolve(creds);
+//       } catch (err) {
+//         this.logger.debug(`Error attempting to get creds for [${registry}].`, err);
+//         resolve(undefined);
+//       }
+//     });
+//   }
+//   /** 
+//    * @param storeName the unprefixed codename for the store (eg: "osxkeychain" or "desktop") 
+//   */
+//   private getFromStoreBinary(storeName: string, registry: string): Promise<RegistryCredentials | undefined> {
+//     return new Promise<RegistryCredentials | undefined>(async (resolve, reject) => {
+//       try {
+//         let binaryName = DOCKER_CONSTANTS.CRED_HELPER_PREFIX.concat(storeName);
+//         // NOTE:  Docker requires that the binary be in the path, so we shouldnt have to worry about the path.
+//         // ALSO:  The registry has to be passed in via STDIN, thus the echo-pipe-$1 syntax below...
+//         let cmd = `echo ${registry} | ${binaryName} get $1`
+//         // let creds = await this._cliExec.execAsyncJson<RegistryCredentials>(cmd, { cwd: process.cwd() }, LogLevel.debug, true);
+//         let json = await this._cliExec.execAsyncStdOut(cmd, { cwd: process.cwd() }, LogLevel.debug, true);
+//         if (!json || json == "") throw new CodiacError(`Credentials not found in store [${storeName}]. Response: ${json}`);
+//         let obj = JSON.parse(json);
+//         let creds = <RegistryCredentials>obj;
+//         resolve(creds);
+//       } catch (err) {
+//         reject(err);
+//       }
+//     });
+//   }
+//   /** Removes a set of credentials from the store. */
+//   public async erase(username: string, registry: string, scope?: string): Promise<void> {
+//     return new Promise<void>(async (resolve, reject) => {
+//       try {
+//         throw new CodiacError("erase() is not implemented");
+//         // resolve();
+//       } catch (err) {
+//         reject(err);
+//       }
+//     });
+//   }
+//   /** Lists the credentials in the store. */
+//   public async list(username?: string, registry?: string): Promise<RegistryCredentials[]> {
+//     return new Promise<RegistryCredentials[]>(async (resolve, reject) => {
+//       try {
+//         let creds: RegistryCredentials[] = [];
+//         // Gather up all the registries that are declared under creds helpers
+//         if (this.config.credHelpers) {
+//           for (let registryName in this.config.credHelpers) {
+//             let store = this.config.credHelpers[registryName];
+//             let helped = await this.getFromStoreBinary(store, registryName);
+//             if (helped) creds.push(helped);
+//           }
+//         }
+//         // Get all the creds in the main creds store
+//         if (this.config.credsStore) {
+//           let store = this.config.credsStore;
+//           let binaryName = DOCKER_CONSTANTS.CRED_HELPER_PREFIX.concat(store);
+//           let cmd = `${binaryName} list`;
+//           let json = await this._cliExec.execAsyncStdOut(cmd, { cwd: process.cwd() }, LogLevel.debug, true);
+//           if (json && json != "") {
+//             this.logger.trace(`${binaryName} list results`, json);
+//             let obj = JSON.parse(json);
+//             let inStore: RegistryCredentials[] = [];;
+//             for (let serverUrl in obj) {
+//               let regCreds: RegistryCredentials = { ServerURL: serverUrl, Username: obj[serverUrl], Secret: "undefined" };
+//               inStore.push(regCreds);
+//             }
+//             creds.push(...inStore);
+//           }
+//         }
+//         // Get any creds stored directly in the config file
+//         let store = DockerCredentialsStore.configPath;
+//         if (this.config.auths) {
+//           for (let registryName in this.config.auths) {
+//             let userpass = this.config.auths[registryName];
+//             if (userpass) creds.push({ ServerURL: registryName, ...userpass });
+//           }
+//         }
+//         if (registry) {
+//           creds = creds.filter(c => c.ServerURL == registry);
+//         }
+//         if (username) {
+//           creds = creds.filter(c => c.Username == username);
+//         }
+//         // TODO: select distinct by registry
+//         resolve(creds);
+//       } catch (err) {
+//         reject(err);
+//       }
+//     });
+//   }
+// }
+//# sourceMappingURL=docker-credentials-store.js.map

package/lib/ops/docker-credentials-store.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"docker-credentials-store.js","sourceRoot":"","sources":["../../src/ops/docker-credentials-store.ts"],"names":[],"mappings":"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"}

package/lib/ops/docker-registry-api-client/docker-registry-api-client.js

@@ -0,0 +1,289 @@
+"use strict";
+// COMMENTED OUT BC:  Moved to ops-common (and refactored)
+// import * as path from 'path';
+// import { ApiClientBase } from '@codiac.io/api-client-base/api-client-base';
+// import { inject } from 'inversify';
+// import * as urella from 'url';
+// import { INTERFACES, httpRestVerb } from '@codiac.io/codiac-common';
+// import { ListResult, SingleResult } from '@codiac.io/codiac-common/contracts';
+// import { CodiacError } from "@codiac.io/codiac-common/contracts";
+// import { IBetterLogger, LogLevel } from '@codiac.io/codiac-common/IBetterLogger';
+// import { CliExec } from '@codiac.io/codiac-ops-common';
+// import { ImageTagCriteria } from './entities/image-tag-criteria';
+// import { ImageTagList } from './entities/image-tag-list';
+// import { IDockerErrorResponse } from './entities/i-docker-error-response';
+// import { TokenResponse } from './entities/token-response';
+// import { DockerAuthTokenCriteria } from './entities/docker-auth-token-criteria';
+// import { Token } from './entities/token';
+// import { DockerActionPermissionsEnum } from './entities/docker-access-actions-enum';
+// import endpointsJson from './endpoints.json';
+// import { IClientForImageRegistry } from '@codiac.io/codiac-ops-common';
+// import { DockerCredentialsStore } from '@codiac.io/codiac-ops-common';
+// import { DOCKER_CONSTANTS } from '@codiac.io/codiac-ops-common';
+// import { RepositoryCriteria } from './entities/repository-criteria';
+// import { ImageRepository } from './entities/image-repository';
+// import { IDockerListResponse } from './entities/i-docker-list-response';
+// // Test "Authorization" header value
+// // letmeaskmydog:cd32d895-8074-4bbd-ba7a-3fa4bcf5f6ab   <--- The password here is an Access Token I created on docker hub in account settings/security
+// // Basic bGV0bWVhc2tteWRvZzpjZDMyZDg5NS04MDc0LTRiYmQtYmE3YS0zZmE0YmNmNWY2YWI=
+// // RECOMMENDED WORKFLOW:  ( per https://docs.docker.com/registry/spec/auth/token/ )
+// // 
+// // 1.  Try to make a request without a token
+// // 2.  if 401,
+// //   a.  Make a JWT request with the specs provided in the response (described on that page above)
+// //      1.  The queruystring will need a service, scope, and action
+// //      2.  The headers will need a basic auth header value "Authorization" = "Basic bGV0bWVhc2tteWRvZzpjZDMyZDg5NS04MDc0LTRiYmQtYmE3YS0zZmE0YmNmNWY2YWI="
+// // 3.  Run your request again with the JWT you got back  "Authorization" = "Bearer blahasdfksdfjksd..."
+// // 4.  That token is only good for that scope and actions and expires in 5 mins
+// // 5.  To refresh the token: skip the creds and use "access_type=refresh_token" and include "refresh_token=[the refresh token you got back]"
+// export class DockerRegistryApiClient extends ApiClientBase implements IClientForImageRegistry {
+//   /** 
+//    * @see https://docs.docker.com/registry/spec/api/#detail
+//    */
+//   public static readonly DOCKER_HUB_API_URL = 'https://index.docker.io/v1/';
+//   /** Why Docker makes discovery on their api so difficult is a mystery (if you have a GOOD attitude about it). 
+//    * @see https://stackoverflow.com/questions/35444178/public-docker-v2-api-endpoints
+//    */
+//   public static readonly DOCKER_HUB_OTHER_API_URL = 'https://hub.docker.com';
+//   /** Api url to use when acquiring auth tokens. */
+//   public static readonly DOCKER_HUB_AUTH_API_URL = 'https://auth.docker.io/';
+//   /** SERVICE NAME for the information being requested.  **NOT** The target url of the Docker Hub api. */
+//   public static readonly DOCKER_REGISTRY_SERVICE_NAME = "registry.docker.io";
+//   /** The identifier for this client provided to docker for recognition.
+//    * Accepted syntax is defined in [RFC6749 Appendix A.1](https://tools.ietf.org/html/rfc6749#appendix-A.1)   */
+//   public static readonly CLIENT_ID = "codiac_cli";
+//   /** The user creds provided in "bootstrap" encoded into a basic authentication token with its "Basic " prefix, 
+//    *  for use as the value of the Authorization header when requesting a scoped token. */
+//   // private static basicAuthHeaderValue: string;
+//   /** Inidicator that the bootstrap method has been run */
+//   private static bootstrapped: boolean = false;
+//   /** REQUIRED!! You MUST fire this at startup time in order to use this class.  */
+//   public static bootstrap( /* username: string, apiKey: string */): void {
+//     super.bootstrap_base(endpointsJson);
+//     // this.setBasicAuthCreds(username, apiKey);
+//     DockerRegistryApiClient.bootstrapped = true;
+//   }
+//   // private static setBasicAuthCreds(username: string, apiKey: string): void {
+//   //   this.basicAuthHeaderValue = this.buildBasicAuthenticationHeader(username, apiKey);
+//   // }  
+//   /**
+//    * @param registryDomain The server host name of the registry (eg: my.registry.io) (without any url protocol). 
+//    *              This value is the first part of a fully qualified image name, separated by a slash "/" character.   */
+//   static supports(registryDomain: string): boolean {
+//     if (registryDomain == ""
+//       || registryDomain == this.DOCKER_REGISTRY_SERVICE_NAME
+//       || registryDomain.startsWith(this.DOCKER_HUB_API_URL)  // <-- I think this one is wrong.  Really needs to be:  https://index.docker.io/v1/
+//     ) {
+//       return true;
+//     } else {
+//       return false;
+//     }
+//   }
+//   /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
+//   *   _____          _                         ___  ___               _                   
+//   *  |_   _|        | |                        |  \/  |              | |                  
+//   *    | | _ __  ___| |_ __ _ _ __   ___ ___   | .  . | ___ _ __ ___ | |__   ___ _ __ ___ 
+//   *    | || '_ \/ __| __/ _` | '_ \ / __/ _ \  | |\/| |/ _ \ '_ ` _ \| '_ \ / _ \ '__/ __|
+//   *   _| || | | \__ \ || (_| | | | | (_|  __/  | |  | |  __/ | | | | | |_) |  __/ |  \__ \
+//   *   \___/_| |_|___/\__\__,_|_| |_|\___\___|  \_|  |_/\___|_| |_| |_|_.__/ \___|_|  |___/
+//   *                                                                                   
+//   * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+//   constructor(@inject(DockerCredentialsStore) private credStore: DockerCredentialsStore, @inject(INTERFACES.ILogger) logger: IBetterLogger
+//     , apiRootUrl?: string, authToken?: string) {
+//     super(logger, apiRootUrl, authToken);
+//     if (!DockerRegistryApiClient.bootstrapped) throw new Error("Api client has not been initialized.  Please execute the static bootstrap() method during your app startup phase.");
+//     this._cliExec = new CliExec(logger);  // this wed be better of lazy-loaded cuz we arent always gonna use it.
+//     // TODO:  Load saved tokens from a user config
+//   }
+//   private _cliExec: CliExec;
+//   protected GetDefaultRootUrl(): string {
+//     return DockerRegistryApiClient.DOCKER_HUB_API_URL;
+//   }
+//   /** List of tokens that are scoped for specific image repositories and actions within them. 
+//    * In this class, this list is hydrated by ensureTokenFor(). */
+//   private tokens: { [scope: string]: Token } = {};
+//   /** Friendly syntax for assembling a call to requestToken(). */
+//   private async ensureTokenFor(scopedImageName: string, ...permissions: DockerActionPermissionsEnum[]): Promise<Token> {
+//     return new Promise<Token>(async (resolve, reject) => {
+//       try {
+//         // Lazy load the token
+//         let scope = `repository:${(scopedImageName.indexOf("/") < 0) ? "library/" : ""}${scopedImageName}:pull`
+//         if (!this.tokens[scope] || this.tokens[scope].expirationUtc < new Date(Date.now())) {
+//           let defaultIssuedAt = new Date(Date.now());
+//           let defaultTTL_ms = 60 * 1000;
+//           let tokenCriteria = {
+//             scope: scope,
+//             service: DockerRegistryApiClient.DOCKER_REGISTRY_SERVICE_NAME,
+//             client_id: DockerRegistryApiClient.CLIENT_ID,
+//             offline_token: true
+//           };
+//           let result = await this.requestToken(tokenCriteria, DockerRegistryApiClient.DOCKER_HUB_API_URL);
+//           if (result.success && result.output) {
+//             let issuedAt = (result.output.issued_at) ? new Date(result.output.issued_at) : defaultIssuedAt;
+//             let ttl_ms = (result.output.expires_in) ? result.output.expires_in * 1000 : defaultTTL_ms;
+//             let exp = new Date(issuedAt.getTime() + ttl_ms);
+//             this.tokens[scope] = new Token(result.output.token, scopedImageName, permissions, exp);
+//             // TODO:  Persist these to the client config file
+//           } else if (result.error) new CodiacError(`Error making token request for scope ${scope}:  ${result.message || ""} ${result.error.message}. ${result.output ? JSON.stringify(result.output) : ""}`, result.error);
+//           else throw new Error(`Token request for scope ${scope} failed without error.  ${result.message}.  ${result.output ? JSON.stringify(result.output) : ""}`);
+//         }
+//         resolve(this.tokens[scope]);
+//       } catch (err) {
+//         reject(err);
+//       }
+//     });
+//   }
+//   /** Makes the actual remote call to the Docker Hub Auth service acquire a token. 
+//    * This method is used internally by this class and there is no need to call it; 
+//    * it is exposed publically merely for general utility. */
+//   public async requestToken(tokenCriteria: DockerAuthTokenCriteria, tokenProviderService: string): Promise<SingleResult<TokenResponse>> {
+//     return new Promise<SingleResult<TokenResponse>>(async (resolve, reject) => {
+//       let result = new SingleResult<TokenResponse>(false);
+//       try {
+//         let ep = this.getEndpointFor<DockerAuthTokenCriteria>(DockerAuthTokenCriteria, httpRestVerb.GET);
+//         let relUrl = this.buildUrl(ep.route, tokenCriteria, true);
+//         // relUrl = path.join(DockerRegistryApiClient.DOCKER_HUB_AUTH_API_URL.replace("//", "/"), relUrl);
+//         let url = new urella.URL(relUrl, DockerRegistryApiClient.DOCKER_HUB_AUTH_API_URL).toString();
+//         let creds = await this.credStore.tryGet(tokenProviderService);  // we know we want DockerRegistryApiClient.DOCKER_HUB_API_URL
+//         if (!creds) throw new Error(`No credentials found for ${tokenProviderService}.`);
+//         let basicAuthHeaderValue = DockerRegistryApiClient.buildBasicAuthenticationHeader(creds.Username, creds.Secret);
+//         let headers = {
+//           Authorization: basicAuthHeaderValue,
+//           "Content-Type": "application/json"
+//         };
+//         let res = await this.makeHttpCall<ImageTagCriteria, ImageTagList | IDockerErrorResponse>(ep.httpMethod, url, {}, headers);
+//         if ((<IDockerErrorResponse>res).errors) {
+//           let errResponse = <IDockerErrorResponse>res;
+//           result.error = new Error(`Error from ${ep.httpMethod} ${url}: ${errResponse.errors[0].code} ${errResponse.errors[0].message}; ${JSON.stringify(errResponse.errors[0].detail)}`)
+//           result.message = result.error.message;
+//           this.logger.error(result.error.message, errResponse);
+//         } else {
+//           let tokenResponse = <TokenResponse>(<any>res)
+//           result.success = (tokenResponse && (tokenResponse.token != undefined) && (tokenResponse.token != ""));  // ugh!
+//           result.output = tokenResponse;
+//           this.logger.debug(`Token successfully acquired for scope [${tokenCriteria.scope}].`, tokenResponse);
+//         }
+//       } catch (err) {
+//         result.message = `Error requesting token of scope [${tokenCriteria.scope}] for service [${tokenCriteria.service}]: ${err.message || err.stack}.`
+//         result.error = err;
+//       } finally {
+//         resolve(result);
+//       }
+//     });
+//   }
+//   public async authenticate(registryDomain: string, secret: string, username?: string): Promise<boolean> {
+//     return new Promise<boolean>(async (resolve, reject) => {
+//       try {
+//         let success = false;
+//         let userArg = (username) ? ` -u ${username}` : ``;  // We dont use "<token>" here.  Only do that with a creds store.
+//         let workingDir = process.cwd();
+//         let loginEnv: { [key: string]: any } = { ...process.env };
+//         loginEnv.registry_pwd = secret;
+//         let cmdLogin = `echo $registry_pwd | docker login ${registryDomain} ${userArg} --password-stdin`;
+//         // this.logger.notice(`Attempting to log into image registry [${this.styler.hilite(registryDomain)}]...`);
+//         this.logger.notice(`Attempting to log into image registry [${registryDomain}]...`);
+//         let result = await this._cliExec.execAsyncStdOut(cmdLogin, { cwd: workingDir, env: loginEnv }, LogLevel.detail, true);
+//         // need to differentiate login failures (401, 403) from other types of errors
+//         success = true;
+//         resolve(success);
+//       } catch (err) {
+//         reject(err);
+//       }
+//     });
+//   }
+//   public async push(registryDomain: string, scopedImageName: string, tag: string): Promise<void> {
+//     return new Promise<void>(async (resolve, reject) => {
+//       try {
+//         let fullImageId = registryDomain ? `${registryDomain}/${scopedImageName}:${tag}` : `${scopedImageName}:${tag}`;
+//         let scope = (scopedImageName.indexOf("/") >= 0) ? scopedImageName.split("/")[0] : undefined;
+//         let store = DockerCredentialsStore.create();
+//         let creds = await store.tryGet(registryDomain);
+//         if (!creds) throw new Error(`No credentials found for ${registryDomain}.`);
+//         let userArg = (creds.Username) ? ` -u ${creds.Username}` : ``;
+//         let passArg = (creds.Secret) ? ` -p ${creds.Secret}` : ``;
+//         let cmdLogin: string;
+//         let loginEnv: { [key: string]: any } = { ...process.env };
+//         let workingDir = process.cwd();
+//         // let regToken = "8c307c0b-e0ae-4945-9567-1da692b99322";
+//         // userArg = `-u "<token>"`; // nope that only works when using a credentials store.
+//         loginEnv.registry_pwd = creds.Secret;
+//         cmdLogin = `echo $registry_pwd | docker login ${registryDomain} ${userArg} --password-stdin`;
+//         // this.logger.notice(`Logging in and pushing [${this.styler.hilite(scopedImageName)}] to registry as [${this.styler.hilite(fullImageId)}]...`);
+//         this.logger.notice(`Logging in and pushing [${scopedImageName}] to registry as [${fullImageId}]...`);
+//         let cmdLoginAndPush = cmdLogin.concat(`  &&  docker push ${fullImageId}`);
+//         await this._cliExec.spawnAndLog(cmdLoginAndPush, workingDir, loginEnv, LogLevel.detail);
+//         resolve();
+//       } catch (err) {
+//         reject(err);
+//       }
+//     });
+//   }
+//   public async tryGetImageTags(scopedImageName: string): Promise<ListResult<string>> {
+//     return new Promise<ListResult<string>>(async (resolve, reject) => {
+//       try {
+//         let result = new ListResult<string>(false);
+//         // TODO: Validate character set in image name (this shd trap any backslashes meant to be fwd slashes)
+//         let nameInCatalog = scopedImageName;
+//         let scope = (scopedImageName.indexOf("/") >= 0) ? scopedImageName.split("/")[0] : undefined;
+//         if (!scope) nameInCatalog = DOCKER_CONSTANTS.PUBLIC_LIBRARY_SCOPE.concat("/", scopedImageName);
+//         let scopedToken = await this.ensureTokenFor(nameInCatalog, DockerActionPermissionsEnum.pull);
+//         let crit = new ImageTagCriteria(nameInCatalog);
+//         let ep = this.getEndpointFor<ImageTagCriteria>(ImageTagCriteria, httpRestVerb.GET);
+//         let url = this.buildUrl(ep.route, crit);
+//         let headers = {
+//           Authorization: `Bearer ${scopedToken.token}`
+//         };
+//         let res = await this.makeHttpCall<ImageTagCriteria, ImageTagList | IDockerErrorResponse>(ep.httpMethod, url, {}, headers);
+//         if ((<IDockerErrorResponse>res).errors) {
+//           let errRsponse = <IDockerErrorResponse>res;
+//           result.error = new Error(`Error from ${ep.httpMethod} ${url}: ${errRsponse.errors[0].code} ${errRsponse.errors[0].message}; ${JSON.stringify(errRsponse.errors[0].detail)}`)
+//           this.logger.debug(result.error.message, res);
+//           // This is where we should pick up the error and trigger a token request and reattempt.
+//           this.authToken = undefined;
+//         } else {
+//           let tagResponse = <ImageTagList>res;
+//           result.success = (tagResponse.tags && tagResponse.tags.length > 0);
+//           result.output = tagResponse;
+//         }
+//         resolve(result);
+//       } catch (err) {
+//         this.logger.write(`Error attempting getImageTags(${scopedImageName}): ${err.message || err.stack}.`);
+//         reject(err);
+//       }
+//     });
+//   }
+//   /** Performs a fuxzy text search for repositories in the catalog. 
+//    * NOTE:  Used OAuth token when running this endpoint in Postman. 
+//   */
+//   public async searchRepositories(query: string, isOfficial?: boolean, pageNumber?: number): Promise<ImageRepository[]> {
+//     return new Promise<ImageRepository[]>(async (resolve, reject) => {
+//       try {
+//         // let url = `https://hub.docker.com/v2/search/repositories/?query=rabbit`
+//         let crit = new RepositoryCriteria();
+//         crit.query = query;
+//         if (isOfficial != undefined) crit.is_official = isOfficial;
+//         if (pageNumber) crit.page = pageNumber;
+//         let ep = this.getEndpointFor<RepositoryCriteria>(RepositoryCriteria, httpRestVerb.GET);
+//         let url = this.buildUrl(ep.route, crit);
+//         let headers = {
+//           // this may only take an OAuth token
+//           // Authorization: `JWT ${OAuth.token}`  
+//         };
+//         let res = await this.makeHttpCall<RepositoryCriteria, IDockerListResponse<ImageRepository> | IDockerErrorResponse>(ep.httpMethod, url, {}, headers);
+//         let output: ImageRepository[];
+//         if ((<IDockerErrorResponse>res).errors) {
+//           let errResponse = <IDockerErrorResponse>res;
+//           throw new Error(`Error from ${ep.httpMethod} ${url}: ${errResponse.errors[0].code} ${errResponse.errors[0].message}; ${JSON.stringify(errResponse.errors[0].detail)}`)
+//           // this.logger.debug(result.error.message, res);
+//         } else {
+//           let tagResponse = <IDockerListResponse<ImageRepository>>res;
+//           output = tagResponse.results;
+//         }
+//         resolve(output);
+//       } catch (err) {
+//         reject(err);
+//       }
+//     });
+//   }
+// }
+//# sourceMappingURL=docker-registry-api-client.js.map

package/lib/ops/docker-registry-api-client/docker-registry-api-client.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"docker-registry-api-client.js","sourceRoot":"","sources":["../../../src/ops/docker-registry-api-client/docker-registry-api-client.ts"],"names":[],"mappings":"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"}

package/lib/ops/docker-registry-api-client/entities/blob-sum.d.ts

@@ -0,0 +1,7 @@
+export declare class Blob {
+    blobSum: string;
+    /**
+     * @param blobSum Digest
+     */
+    constructor(blobSum: string);
+}

package/lib/ops/docker-registry-api-client/entities/blob-sum.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Blob = void 0;
+class Blob {
+    /**
+     * @param blobSum Digest
+     */
+    constructor(blobSum) {
+        this.blobSum = blobSum;
+    }
+}
+exports.Blob = Blob;
+//# sourceMappingURL=blob-sum.js.map

package/lib/ops/docker-registry-api-client/entities/blob-sum.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"blob-sum.js","sourceRoot":"","sources":["../../../../src/ops/docker-registry-api-client/entities/blob-sum.ts"],"names":[],"mappings":";;;AAEA,MAAa,IAAI;IACf;;OAEG;IACH,YAAmB,OAAe;QAAf,YAAO,GAAP,OAAO,CAAQ;IAElC,CAAC;CACF;AAPD,oBAOC"}

package/lib/ops/docker-registry-api-client/entities/docker-access-actions-enum.d.ts

@@ -0,0 +1,5 @@
+/** The names of the permissions granted in (or requested for) a token's Access Control List (ACL). */
+export declare enum DockerActionPermissionsEnum {
+    pull = "pull",
+    push = "push"
+}

package/lib/ops/docker-registry-api-client/entities/docker-access-actions-enum.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DockerActionPermissionsEnum = void 0;
+/** The names of the permissions granted in (or requested for) a token's Access Control List (ACL). */
+var DockerActionPermissionsEnum;
+(function (DockerActionPermissionsEnum) {
+    DockerActionPermissionsEnum["pull"] = "pull";
+    DockerActionPermissionsEnum["push"] = "push";
+})(DockerActionPermissionsEnum = exports.DockerActionPermissionsEnum || (exports.DockerActionPermissionsEnum = {}));
+//# sourceMappingURL=docker-access-actions-enum.js.map

package/lib/ops/docker-registry-api-client/entities/docker-access-actions-enum.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"docker-access-actions-enum.js","sourceRoot":"","sources":["../../../../src/ops/docker-registry-api-client/entities/docker-access-actions-enum.ts"],"names":[],"mappings":";;;AACA,sGAAsG;AACtG,IAAY,2BAGX;AAHD,WAAY,2BAA2B;IACrC,4CAAa,CAAA;IACb,4CAAa,CAAA;AACf,CAAC,EAHW,2BAA2B,GAA3B,mCAA2B,KAA3B,mCAA2B,QAGtC"}

package/lib/ops/docker-registry-api-client/entities/docker-auth-token-criteria.d.ts

@@ -0,0 +1,30 @@
+export declare class DockerAuthTokenCriteria {
+    service: string;
+    scope: string;
+    offline_token?: boolean | undefined;
+    client_id?: string | undefined;
+    /**
+     *
+     * @param service The name of the service which hosts the resource.  eg:  "registry.docker.io"
+     * @param scope TL;DR: Colon-delimited string in format:  "[scopeLevel]:[scopeName]:[actions]".  eg: "?scope=repository:letmeaskmydog/toyhauler-base:pull,push".
+     *        The resource in question, formatted as one of the space-delimited entries from the scope parameters
+     *        from the WWW-Authenticate header returned in an http 401 response.
+     *        This query parameter should be specified multiple times if there is more than one scope entry
+     *        from the WWW-Authenticate header.
+     *        The scope field may be empty to request a refresh token without providing any resource permissions to the returned bearer token.
+     *
+     * @param offline_token Whether to return a refresh token along with the bearer token.
+     *         A refresh token is capable of getting additional bearer tokens for the same subject with different scopes.
+     *         The refresh token does not have an expiration and should be considered completely opaque to the client.
+     * @param client_id String identifying the client. This client_id does not need to be registered with the authorization server
+     *         but should be set to a meaningful value in order to allow auditing keys created by unregistered clients.
+     *         Accepted syntax is defined in [RFC6749 Appendix A.1](https://tools.ietf.org/html/rfc6749#appendix-A.1).
+     *
+     * @see https://docs.docker.com/registry/spec/auth/token/#how-to-authenticate How to Authenticate
+     * @see https://docs.docker.com/registry/spec/auth/token/#requesting-a-token Requesting a Token
+     * @see https://docs.docker.com/registry/spec/auth/jwt/ Token Authentication Implementation
+     * @see https://tools.ietf.org/html/rfc6750#section-3 Section 3 of RFC 6750: The OAuth 2.0 Authorization Framework: Bearer Token Usage
+     * @see https://tools.ietf.org/html/rfc6749#appendix-A.1 RFC6749 Appendix A.1
+     */
+    constructor(service: string, scope: string, offline_token?: boolean | undefined, client_id?: string | undefined);
+}