update README and Dockerfile

add command to print key(s)
allow verify and inspect commands to be provided an explicit PayID

Author: nhartner

Dockerfile

@@ -1,20 +1,21 @@
 FROM node:12-alpine
 
-ADD . / payid-utils/
+ADD . / payid-cli/
 
-RUN cd payid-utils/ &&\
+RUN cd payid-cli/ &&\
+    npm set unsafe-perm true &&\
     npm cache clean --force &&\
     npm install &&\
     npm run build && \
     npm link
 
 FROM node:12-alpine
 
-RUN mkdir /opt/payid-utils
+RUN mkdir /opt/payid-cli
 
-WORKDIR /opt/payid-utils
+WORKDIR /opt/payid-cli
 
-COPY --from=0 /payid-utils/dist  /opt/payid-utils/dist
-COPY --from=0 /payid-utils/node_modules  /opt/payid-utils/node_modules
+COPY --from=0 /payid-cli/dist  /opt/payid-cli/dist
+COPY --from=0 /payid-cli/node_modules  /opt/payid-cli/node_modules
 
-CMD ["node", "/opt/payid-utils/dist/cli.js"]
+ENTRYPOINT ["node", "/opt/payid-cli/dist/cli.js"]

README.md

@@ -2,49 +2,87 @@
 
 ![NPM version badge](https://img.shields.io/npm/v/@payid-org/payid-cli)
 
-PayID CLI for creating, fetching, signing and verifying PayIDs. Based on the Typescript PayID Utils library.
+Command-line interface for creating, fetching, signing and verifying PayIDs.
+Based on the Typescript PayID [Utils](https://github.com/payid-org/utils) library.
 
 ## Prerequisites
 
-In order to use the CLI, both [node](https://nodejs.org/en/download/) and 
-[npm](https://docs.npmjs.com/downloading-and-installing-packages-locally) must be installed first. 
+In order to use the CLI, both [node](https://nodejs.org/en/download/) and
+[npm](https://docs.npmjs.com/downloading-and-installing-packages-locally) must be installed first.
 
 ## Installation
 
-To install the PayID CLI, run the command 
+To install the PayID CLI, run the command:
+
 ```
 npm install -g @payid-org/payid-cli
 ```
 
 ## Interactive vs single command mode
 
-CLI can be run in interactive mode or as a single command mode. 
-In interactive mode, a prompt is shown where multiple commands can be run until the exit command is run.
+CLI can be run in interactive mode or non-interactive (single command) mode.
+In interactive mode, a prompt is shown where multiple commands can be run until the `exit` command is run.
+Interactive mode retains a history of commands run which can be accessed using the up arrow key. Command completion
+is available using the tab key.
+
+In non-interactive mode, a single command is run (based on supplied command line arguments) and then the CLI exits.
+No prompt is shown in this mode. This mode is useful for running commands from a script as well as chaining the results
+of multiple commands together.
 
-In single command mode, a single command is run and then the CLI exits. No prompt is shown in this mode.
-This mode is useful for running commands from a script, or from a shell where multiple commands can be
-chained together or to pipe output to another application. 
+To run the CLI in interactive mode, run `payid`.
 
-To run the CLI in interactive mode, run ```payid```.
+To run the CLI in non-interactive, run `payid <command> <arguments>`. Examples:
 
-To run the CLI in single command mode, run ```payid <command> <arguments>```. Example: 
 ```
 payid load 'nhartner$xpring.money'
 ```
-_note: when passing a PayID as an argument in single command mode, the PayID needs to be quoted 
-if run in a Linux shell (to avoid the '$' being interpolated as a variable by the Linux shell).
+
+Or to run multiple commands:
+
+```
+payid init 'my$pay.id' && payid crypto-address add btc mainnet notARealAddress && payid save
+```
+
+_Note_: when passing a PayID as an argument in non-interactive mode, the PayID needs to be escaped or quoted  
+to avoid the '\$' being interpolated as a variable by the shell.
 
 ## Commands
 
-A list of available commands can be found run running the `help` command.
+The following commands are available:
+
+```
+    help [command...]                                                  Provides help for a given command.
+    exit                                                               Exits application.
+    clear                                                              clear the terminal
+    crypto-address add <paymentNetwork> <environment> <address> [tag]  start building a new PayID
+    crypto-address remove <address>                                    remove an address from the current PayID
+    keys clear                                                         clears all loaded keys
+    keys generate                                                      generates and saves a new identity key
+    keys list                                                          lists keys that have been loaded
+    keys load <filePath>                                               load identity-key from file
+    keys print                                                         print keys that have been loaded in pem format
+    init <payid>                                                       initializes a new PayID
+    inspect [payId]                                                    Inspect signatures on the loaded PayID or from an optionally specified PayID
+    load <payId>                                                       loads a PayID from PayID server
+    show                                                               Shows the currently loaded PayID
+    sign                                                               sign the loaded PayID with the loaded signing keys
+    verify [payId]                                                     Verify the loaded PayID or an optionally specified PayID
+    save                                                               Save the currently loaded PayID
+    from-url <url>                                                     convert a URL to a PayID
+    to-url <payId>                                                     converts PayID to url
+
+```
 
 ## Use Cases
 
 ### Loading a PayID
+
 The following command can be used to load an existing PayID from a remote server:
+
 ```
 load nhartner$xpring
 ```
+
 This will fetch all the PayID address mappings for the given PayID from the remote
 server and displays the resulting JSON.
 
@@ -59,6 +97,7 @@ crypto-address add xrpl mainnet rP3t3JStqWPYd8H88WfBYh3v84qqYzbHQ6 12345
 crypto-address add btc mainnet 3M2CH71P6uZTra1PsjiEhNFB7kCENShCgt
 save
 ```
+
 The end result should be a PayID json representation being saved to the local filesystem as
 example.json.
 
@@ -72,9 +111,11 @@ To remove all loaded keys from the CLI's local storage, use the `keys clear` com
 The `keys list` command will show you all keys currently loaded into the CLI.
 
 To generate new key run:
+
 ```
 keys generate
 ```
+
 This will generate a new key and save it to a file named `identity-key.pem`. To load a previously
 created identity key, run `keys load </path/to/pem/file>`.
 
@@ -93,5 +134,18 @@ command can be used to save your PayID, with signed addresses, to file.
 
 Two commands are available to verify a PayID's verified addresses.
 
-- ```verify``` - checks if all the verified addresses have valid signatures
-- ```insepct``` - displays details information about each verified address and signatures.
+- `verify` - checks if all the verified addresses have valid signatures.
+- `inspect` - displays details information about each verified address and signatures.
+
+## Creating, Signing and Inspecting a PayID
+
+Bringing all the above commands together, we can create a PayID, add an address mapping, generate an identity key,
+sign our PayID address mapping and then inspect the final result.
+
+```
+init example$mypayid.com
+crypto-address add xrpl mainnet rP3t3JStqWPYd8H88WfBYh3v84qqYzbHQ6
+keys generate
+sign
+inspect
+```

src/cli.ts

@@ -17,6 +17,7 @@ new cmd.ClearKeysCommand(vorpal, localStorage).setup()
 new cmd.GenerateIdentityKeyCommand(vorpal, localStorage).setup()
 new cmd.ListKeysCommand(vorpal, localStorage).setup()
 new cmd.LoadIdentityKeyCommand(vorpal, localStorage).setup()
+new cmd.PrintKeysCommand(vorpal, localStorage).setup()
 new cmd.InitPayIdCommand(vorpal, localStorage).setup()
 new cmd.InspectPayIdCommand(vorpal, localStorage).setup()
 new cmd.LoadPayIdCommand(vorpal, localStorage).setup()

src/commands/Command.ts

@@ -1,4 +1,5 @@
-import { PaymentInformation } from '@payid-org/utils'
+import { convertPayIdToUrl, PaymentInformation } from '@payid-org/utils'
+import axios, { AxiosResponse } from 'axios'
 import * as Vorpal from 'vorpal'
 import { Args } from 'vorpal'
 
@@ -34,13 +35,11 @@ abstract class Command {
     // Execute the concrete action inside a try/catch wrapper
     this.vorpal.command(this.command(), this.description()).action(
       async (args: Args): Promise<void> => {
-        try {
-          await this.action(args)
-        } catch (error) {
+        await this.action(args).catch((error) => {
           // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment -- error has any type
           const { message } = error
           this.vorpal.log(message)
-        }
+        })
       },
     )
   }
@@ -71,6 +70,23 @@ abstract class Command {
     jsonBeautify(JSON.stringify(info, null, 2))
   }
 
+  /**
+   * Retrieves a PayID using the optional payId argument or else returns the PaymentInformation
+   * currently loaded in local storage.
+   *
+   * @param args - The vorpal args object.
+   * @returns PaymentInformation from args or local storage. Or error if can't be loaded.
+   */
+  protected async payIdFromArgsOrLocalStorage(
+    args: Args,
+  ): Promise<PaymentInformation> {
+    const { payId } = args
+    if (payId) {
+      return loadPayId(payId)
+    }
+    return this.getPaymentInfo()
+  }
+
   /**
    * The vorpal command.
    *
@@ -93,4 +109,37 @@ abstract class Command {
   protected abstract async action(args: Args): Promise<void>
 }
 
+/**
+ * Loads a PayID from a remote server.
+ *
+ * @param payId - The PayID to lookup.
+ * @returns A promise that resolves to the PaymentInformation for the PayID.
+ */
+export async function loadPayId(payId: string): Promise<PaymentInformation> {
+  const url = convertPayIdToUrl(payId).href
+  return axios
+    .get(url, {
+      headers: {
+        'payid-version': '1.0',
+        accept: 'application/payid+json',
+      },
+    })
+    .then((response) => {
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment -- axios response.data has an any type
+      const info: PaymentInformation = response.data
+      return info
+    })
+    .catch((error) => {
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment -- axios error has an any type
+      const {
+        response,
+        message,
+      }: { response?: AxiosResponse; message: string } = error
+      if (response) {
+        throw new Error(`Received HTTP status ${response.status} on ${url}`)
+      }
+      throw new Error(`Bad request ${url}. Error: ${message}.`)
+    })
+}
+
 export default Command

src/commands/index.ts

@@ -8,6 +8,7 @@ export { default as GenerateIdentityKeyCommand } from './key-generate'
 export { default as LoadIdentityKeyCommand } from './key-load'
 export { default as ClearKeysCommand } from './keys-clear'
 export { default as ListKeysCommand } from './keys-list'
+export { default as PrintKeysCommand } from './keys-print'
 export { default as LocalStorage } from './localstorage'
 export { default as InitPayIdCommand } from './payid-init'
 export { default as InspectPayIdCommand } from './payid-inspect'

src/commands/keys-print.ts

@@ -0,0 +1,43 @@
+import { toKey } from '@payid-org/utils'
+
+import Command from './Command'
+
+/**
+ * Prints, to console, a summary of the identity and server keys that are currently loaded in
+ * local storage and available to use for signing.
+ */
+export default class PrintKeysCommand extends Command {
+  /**
+   * @override
+   */
+  protected async action(): Promise<void> {
+    this.printKeys('identity-keys')
+  }
+
+  /**
+   * @override
+   */
+  protected command(): string {
+    return 'keys print'
+  }
+
+  /**
+   * @override
+   */
+  protected description(): string {
+    return 'print keys that have been loaded in pem format'
+  }
+
+  /**
+   * Prints the key as pem to the console.
+   *
+   * @param name - The name of the key to print.
+   */
+  private printKeys(name: string): void {
+    const keys = this.localStorage.getSigningKeys(name)
+    keys.forEach((key) => {
+      const pem = toKey(key).toPEM(true)
+      this.vorpal.log(pem)
+    })
+  }
+}

src/commands/payid-inspect.ts

@@ -29,18 +29,21 @@ export default class InspectPayIdCommand extends Command {
    * @override
    */
   protected command(): string {
-    return 'inspect'
+    return 'inspect [payId]'
   }
 
   /**
    * @override
    */
   protected description(): string {
-    return 'Inspect signatures on the loaded PayID'
+    return 'Inspect signatures on the loaded PayID or from an optionally specified PayID'
   }
 
-  protected async action(): Promise<void> {
-    const info = this.getPaymentInfo()
+  /**
+   * @override
+   */
+  protected async action(args: Vorpal.Args): Promise<void> {
+    const info = await this.payIdFromArgsOrLocalStorage(args)
     const result = this.paymentInformationInspector.inspect(info)
     this.vorpal.log(`${info.payId} ${validString(result.isVerified)}`)
     result.verifiedAddressesResults.forEach((addressResult) => {

src/commands/payid-load.ts

@@ -1,8 +1,6 @@
-import { convertPayIdToUrl, PaymentInformation } from '@payid-org/utils'
-import axios, { AxiosResponse } from 'axios'
 import * as Vorpal from 'vorpal'
 
-import Command from './Command'
+import Command, { loadPayId } from './Command'
 
 /**
  * Loads a PayID from the remote server. For example, "load test$xpring.money" will
@@ -15,40 +13,17 @@ export default class LoadPayIdCommand extends Command {
    * @override
    */
   protected async action(args: Vorpal.Args): Promise<void> {
-    const { payid } = args
-    const url = convertPayIdToUrl(payid).href
-    await axios
-      .get(url, {
-        headers: {
-          'payid-version': '1.0',
-          accept: 'application/payid+json',
-        },
-      })
-      .then((response) => {
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment -- axios response.data has an any type
-        const info: PaymentInformation = response.data
-        this.localStorage.setPaymentInfo(info)
-        this.logPaymentInfo(info)
-      })
-      .catch((error) => {
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment -- axios error has an any type
-        const {
-          response,
-          message,
-        }: { response?: AxiosResponse; message: string } = error
-        if (response) {
-          this.vorpal.log(`Received HTTP status ${response.status} on ${url}`)
-          return
-        }
-        this.vorpal.log(`Bad request ${url}. Error: ${message}.`)
-      })
+    const { payId } = args
+    const info = await loadPayId(payId)
+    this.localStorage.setPaymentInfo(info)
+    this.logPaymentInfo(info)
   }
 
   /**
    * @override
    */
   protected command(): string {
-    return 'load <payid>'
+    return 'load <payId>'
   }
 
   /**