did

#!/usr/bin/env node
/**
 * A Decentralized Identifier client for managing DIDs.
 *
 * Copyright (c) 2017-2019 Digital Bazaar, Inc. All rights reserved.
 */
const drivers = require('./lib');
const yargs = require('yargs');
const {join} = require('path');
const util = require('util');

const {homepage} = require(join(__dirname, 'package.json'));

// FIXME: Fix for nginx-proxied nodes for node.js 8.x.x
const tls = require('tls');
tls.DEFAULT_ECDH_CURVE = 'auto';

function _setupTypeCommand(yargs) {
  return yargs
    .option('type', {
      alias: 't',
      describe: 'DID type (method) to use',
      choices: [
        'key',
        'veres'
      ],
      default: 'veres'
    });
}

function _setupRemoteCommand(yargs) {
  return yargs
    .option('mode', {
      alias: 'm',
      describe: 'Mode of operation',
      choices: [
        'live',
        'test',
        'dev'
      ],
      default: 'test'
    })
    .option('hostname', {
      alias: 'H',
      describe: 'Ledger hostname (overrides mode/type)',
      type: 'string',
      nargs: 1
    })
    .option('auth', {
      alias: 'a',
      describe: 'Authorization DID',
      type: 'string',
      nargs: 1
    });
}

function _setupDidCommand(yargs) {
  return yargs
    .positional('did', {
      describe: 'Target DID',
      type: 'string'
    });
}

// function _setupFilenameCommand(yargs) {
//   return yargs
//     .positional('filename', {
//       describe: 'Target filename',
//       type: 'string'
//     });
// }

function _setupNotesCommand(yargs) {
  return yargs
    .option('notes', {
      describe: 'Enable automatic notes',
      type: 'boolean',
      default: true
    });
}

function _setupRegisterCommand(yargs) {
  return yargs
    .option('register', {
      alias: 'r',
      describe: 'Register a DID on the ledger',
      type: 'boolean',
      default: false
    });
}

function _setupAcceleratorCommand(yargs) {
  return yargs
    .option('accelerator', {
      alias: 'A',
      describe: 'Accelerator hostname[:port]',
      type: 'string',
      nargs: 1
    })
    .implies('accelerator', 'auth');
}

function _setupOcapCommand(yargs) {
  return yargs
    .positional('invoker', {
      describe: 'DID of the invoker',
      type: 'string'
    });
}

// add examples if tagged for a command.  "main" is main app.
function _setupExamples(yargs, cmd) {
  function example(cmds, ...rest) {
    if(cmds.includes(cmd)) {
      yargs.example(...rest);
    }
  }
  example(
    ['main'],
    '$0 COMMAND -h',
    'Show help and more examples for COMMAND');

  example(
    ['main', 'generate'],
    '$0 generate',
    'Generate a local DID');
  example(
    ['generate'],
    '$0 generate -p toomanysecrets',
    'Generate a DID with a passphrase');
  example(
    ['generate'],
    '$0 generate -m dev -k rsa -r',
    'Generate a DID and register on development ledger');
  example(
    ['main', 'generate'],
    '$0 generate --name my-did-1 --description \'My First DID!\'',
    'Generate a local DID with private notes');
  example(
    ['main', 'generate'],
    '$0 generate -k rsa -r',
    'Generate a RSA DID and register on ledger');
  example(
    ['generate'],
    '$0 generate -r -a did:example:me -A accelerator.example.org',
    'Generate a DID and register it using an accelerator');
  example(
    ['generate'],
    '$0 generate --no-import',
    'Generate a DID and output to stdout instead of importing it');
  example(
    ['generate'],
    '$0 generate --no-notes',
    'Generate a DID without creating automatic private notes');

  example(
    ['main', 'list'],
    '$0 list',
    'List pending and registered DIDs');

  example(
    ['main', 'register'],
    '$0 register -m dev <did>',
    'Register a local DID on development ledger');
  example(
    ['main', 'register'],
    '$0 register -m dev',
    'Register a DID from stdin to development ledger');
  example(
    ['register'],
    '$0 register -a did:example:me -A accelerator.example.org <did>',
    'Register local DID to ledger using an accelerator');

  example(
    ['main', 'info'],
    '$0 info did:example:1234',
    'Show DID info on ledger.');
  example(
    ['main', 'info'],
    '$0 info -L local <did>',
    'Show local DID info.');
  example(
    ['main', 'info'],
    '$0 info -f human -L both <did>',
    'Show readable DID info.');
  example(
    ['main', 'info'],
    '$0 info -f found -L both <did>',
    'Check local and ledger for DID.');
  example(
    ['main', 'info'],
    '$0 info -f found -L ledger -H host1.example.org <did>',
    'Check single ledger host for DID.');
  example(
    ['main', 'info'],
    '$0 info -f found -L all <did>',
    'Check local and all ledger hosts for DID.');

  /* FIXME: notes will be fixed post testnet v2
  example(
    ['main', 'notes'],
    '$0 notes',
    'Show all private notes for all DIDs');
  example(
    ['main', 'notes'],
    '$0 notes <did>',
    'Show all private notes for a DID');
  example(
    ['notes'],
    '$0 notes --get name',
    'Show all DIDs with a name set');
  example(
    ['notes'],
    '$0 notes <did> --clear',
    'Clear private notes for a DID');
  example(
    ['main', 'notes'],
    '$0 notes <did> --set name my-name',
    'Set private property/value pair note for a DID');
  example(
    ['notes'],
    '$0 notes <did> --add ledger veres',
    'Add private property/value pair note for a DID');
  example(
    ['notes'],
    '$0 notes <did> --get schema:url',
    'Get private property/value pair note for a DID');
  example(
    ['notes'],
    '$0 notes <did> --remove ledger veres',
    'Remove private note property for a DID');
  example(
    ['notes'],
    '$0 notes <did> --delete schema:url',
    'Delete all private note properties for a DID');
  example(
    ['main', 'notes'],
    '$0 notes --find name my-name',
    'Show all DIDs with a specific name set');
  example(
    ['notes'],
    '$0 notes did:example:1234 --name my-did-1 --description \'My DID!\'',
    'Set DID private notes with standard name and description');
*/
  example(
    ['main', 'ed25519-key-add'],
    '$0 ed25519-key-add <did> -p authentication ' +
      '--pub <publicKeyBase58> --pvt <privateKeyBase58>',
    'Add public authentication key to DID');

  example(
    ['main', 'service-add'],
    '$0 service-add <did> -f myservice -e https://example.com ' +
    '-s urn:myservicetype',
    'Add a service descriptor to a DID');
}

// setup the command line
yargs
// FIXME: output prolog help text
//.usage('$0 <command>',
//  'A program to manage Decentralized Identifiers (DIDs)')

  // accept env vars
  .env('DID_CLIENT')

  .command(['list', 'ls'],
    'List pending and registered DIDs',
    yargs => {
      _setupTypeCommand(yargs);
      _setupExamples(yargs, 'list');
    },
    argv => _runLedgerCommand('list', argv))

  .command(['remove <did>', 'rm'],
    'Remove a pending (unregistered) DID',
    yargs => {
      _setupTypeCommand(yargs);
      _setupDidCommand(yargs);
      _setupExamples(yargs, 'remove');
    },
    argv => _runLedgerCommand('remove', argv))

  .command('generate',
    'Generate a DID',
    yargs => {
      _setupTypeCommand(yargs);
      _setupRemoteCommand(yargs);
      _setupRegisterCommand(yargs);
      _setupAcceleratorCommand(yargs);
      _setupNotesCommand(yargs);
      _setupExamples(yargs, 'generate');
      yargs
        .option('keytype', {
          alias: 'k',
          describe: 'Key type',
          choices: [
            'ed25519',
            'rsa'
          ],
          default: 'ed25519'
        })
        .option('passphrase', {
          alias: 'p',
          describe: 'Passphrase',
          type: 'string',
          nargs: 1
        })
        .option('name', {
          describe: 'Set DID private name note',
          type: 'string',
          nargs: 1
        })
        .option('description', {
          describe: 'Set DID private description note',
          type: 'string',
          nargs: 1
        });
    },
    argv => _runLedgerCommand('generate', argv))

  .command('register [did]',
    'Register a DID on a ledger',
    yargs => {
      _setupTypeCommand(yargs);
      _setupDidCommand(yargs);
      _setupRemoteCommand(yargs);
      _setupAcceleratorCommand(yargs);
      _setupNotesCommand(yargs);
      _setupExamples(yargs, 'register');
    },
    argv => _runLedgerCommand('register', argv))

  .command('receive <did>',
    'Receive DID from ledger',
    yargs => {
      _setupTypeCommand(yargs);
      _setupDidCommand(yargs);
      _setupRemoteCommand(yargs);
      _setupExamples(yargs, 'receive');
    },
    argv => _runLedgerCommand('receive', argv))

/*
  .command('revoke <did>',
    'Revoke DID',
    yargs => {
      _setupLedgerCommand(yargs);
      _setupDidCommand(yargs);
      _setupRemoteCommand(yargs);
    },
    argv => _runLedgerCommand('revoke', argv))
  */

  .command(['info <did>', 'i', 'get'],
    'Show DID information',
    yargs => {
      _setupTypeCommand(yargs);
      _setupDidCommand(yargs);
      _setupRemoteCommand(yargs);
      _setupExamples(yargs, 'info');
      // yargs
      //   .option('public-key', {
      //     describe: 'Show public key #1',
      //     type: 'boolean',
      //     default: false
      //   })
      //   .option('private-key', {
      //     describe: 'Show private key #1',
      //     type: 'boolean',
      //     default: false
      //   })
      //   .option('retry', {
      //     describe: 'Retry until all found',
      //     type: 'boolean',
      //     default: false
      //   })
      //   .option('retry-show-found', {
      //     describe: 'Only show found while retrying',
      //     type: 'boolean',
      //     default: false
      //   })
      //   .option('retry-ms', {
      //     describe: 'ms to wait between retries',
      //     type: 'number',
      //     default: 1000
      //   })
      //   .option('retry-timeout-ms', {
      //     describe: 'ms before retries timeout',
      //     type: 'number',
      //     default: 30000
      //   })
      //   .option('retry-max', {
      //     describe: 'Maximum number of retries',
      //     type: 'number',
      //     default: 30
      //   })
      //   .option('retry-sim-failure', {
      //     describe: 'Percent chance of simulated ledger failure [0.0-1.0]',
      //     type: 'number',
      //     default: 0.0
      //   });
    },
    argv => _runLedgerCommand('info', argv))

  .command(['notes [did]', 'n'],
    'Manage DID private notes',
    yargs => {
      _setupTypeCommand(yargs);
      _setupDidCommand(yargs);
      _setupRemoteCommand(yargs);
      _setupExamples(yargs, 'notes');
      yargs
        .option('format', {
          alias: 'f',
          describe: 'Output format',
          choices: [
            'plain',
            'json-compact',
            'json',
          ],
          default: 'plain'
        })
        .option('all', {
          describe: 'Enable mutable operations on all DIDs',
          type: 'boolean',
          default: false,
        })
        .option('clear', {
          describe: 'Clear all properties',
          type: 'boolean',
          default: false,
        })
        .option('add', {
          describe: 'Multi-value property and value to add',
          type: 'string',
          nargs: 2
        })
        .option('remove', {
          describe: 'Multi-value property and value to remove',
          type: 'string',
          nargs: 2
        })
        .option('get', {
          describe: 'Property to get',
          type: 'string',
          nargs: 1
        })
        .option('set', {
          describe: 'Property and value to set',
          type: 'string',
          nargs: 2
        })
        .option('delete', {
          describe: 'Property to delete',
          type: 'string',
          nargs: 1
        })
        .option('find', {
          describe: 'Multi-value property name to value to find',
          type: 'string',
          nargs: 2
        });
    },
    argv => _runLedgerCommand('notes', argv))

  .command('ed25519-key-add <did>',
    'Add an ed25519 verification method to a DID',
    yargs => {
      _setupTypeCommand(yargs);
      _setupDidCommand(yargs);
      _setupRemoteCommand(yargs);
      _setupAcceleratorCommand(yargs);
      _setupRegisterCommand(yargs);
      _setupExamples(yargs, 'ed25519-key-add');
      yargs
        .option('purpose', {
          alias: 'p',
          describe: 'Proof purpose',
          choices: [
            'authentication',
            'capabilityDelegation',
            'capabilityInvocation',
          ]
        })
        .option('public', {
          alias: 'pub',
          describe: 'Base58 encoded public key material',
          type: 'string',
          nargs: 1
        })
        .option('private', {
          alias: 'pvt',
          describe: 'Base58 encoded private key material',
          type: 'string',
          nargs: 1
        })
        .demandOption(['purpose', 'public', 'private']);
    },
    argv => _runLedgerCommand('ed25519-key-add', argv))

  .command('authn-remove <did> <key>',
    'Remove an existing DID authentication key',
    yargs => {
      _setupTypeCommand(yargs);
      _setupDidCommand(yargs);
      _setupRemoteCommand(yargs);
      _setupAcceleratorCommand(yargs);
      _setupRegisterCommand(yargs);
      _setupExamples(yargs, 'authn-remove');
      yargs
        .positional('key', {
          describe: 'The key identifier to remove',
          type: 'string'
        });
    },
    argv => _runLedgerCommand('authn-remove', argv))

  .command('rotate <key-id>',
    'Rotate an existing DID key (remove it and generate a new one)',
    yargs => {
      _setupTypeCommand(yargs);
      _setupRemoteCommand(yargs);
      _setupAcceleratorCommand(yargs);
      _setupExamples(yargs, 'rotate');
      yargs
        .positional('key-id', {
          describe: 'The old key identifier to rotate out',
          type: 'string'
        });
    },
    argv => _runLedgerCommand('rotate', argv))

  // FIXME
  .command('ocap-add <did> <invoker>',
    'Add an object capability DID Document',
    yargs => {
      _setupTypeCommand(yargs);
      _setupDidCommand(yargs);
      _setupOcapCommand(yargs);
      _setupRegisterCommand(yargs);
      _setupExamples(yargs, 'ocap-add');
    },
    argv => _runLedgerCommand('ocap-add', argv))
  //.option('-d, --DID', 'The DID of the invocation target')

  // FIXME
  .command('ocap-revoke <did>',
    'Remove an object capability DID Document',
    yargs => {
      _setupTypeCommand(yargs);
      _setupDidCommand(yargs);
      //_setupOcapCommand(yargs);
      _setupRegisterCommand(yargs);
      _setupExamples(yargs, 'ocap-revoke');
    },
    argv => _runLedgerCommand('ocap-revoke', argv))
  //.option('-d, --DID', 'The DID of the object capability to revoke')

  .command('service-add <did>',
    'Add a service descriptor a DID',
    yargs => {
      _setupTypeCommand(yargs);
      _setupDidCommand(yargs);
      _setupRemoteCommand(yargs);
      // _setupAcceleratorCommand(yargs);
      // _setupRegisterCommand(yargs);
      _setupExamples(yargs, 'service-add');
      yargs
        .option('endpoint', {
          alias: 'e',
          describe: 'Service endpoint URI',
          type: 'string',
          nargs: 1,
        })
        .option('fragment', {
          alias: 'f',
          describe: 'Service identifier hash fragment',
          type: 'string',
          nargs: 1,
        })
        .option('servicetype', {
          alias: 's',
          describe: 'Service type URI',
          type: 'string',
          nargs: 1,
        })
        .demandOption(['endpoint', 'fragment', 'type']);
    },
    argv => _runLedgerCommand('service-add', argv))

  // general
  // FIXME: add per-command completion support
  .completion()
  /*
  .completion('completion', (current, argv) => {
  })
  */
  .demandCommand(1, 'Please specify a command to execute.')
  .recommendCommands()
  .strict()
  .help('h')
  .alias('h', 'help')
  .count('v')
  .describe('v', 'Increase verbosity')
  .alias('v', 'verbose')
  .describe('q', 'Quiet output')
  .boolean('q')
  .alias('q', 'quiet')
  /*
  .string('config')
  .describe('config', 'Path to config file')
  .default('config', '$HOME/.did/config.jsonld')
  */
  .epilog(`Documentation: ${homepage}`);

_setupExamples(yargs, 'main');

// parse
yargs.argv;

process.on('unhandledRejection', error => {
  console.error(util.inspect(error, {depth: null}));
});

function _runLedgerCommand(command, argv) {
  try {
    const driver = drivers[argv.type];
    if(!driver) {
      throw new Error(`"${argv.type}" DID type not supported`);
    }
    if(argv.verbose >= 1) {
      console.log(
        `Executing ${command} on ${argv.type} ledger in ${argv.mode} mode...`);
    }
    const api = driver[command];
    if(!api) {
      throw new Error(`"${command}" not implemented`);
    }
    api(argv);
  } catch(e) {
    console.error(util.inspect(e, {depth: null}));
  }
}