Add send to cli (#222)

* Add list all sends and filter by search term

* Add get send templates

* Add AccessUrl to send responses

* Add Send to Get command

* Add missing command options to login

These options are already coded to work in the command, but commander
did not know about the options.

* Upgrade Commander to 7.0.0

This is needed to enable the subcommand chaining required by Send.

This commit also adds get send and send receive functionality. get send
will be moved to send get along with send list and any other send commands.

* Use api url for send access url

* Move send commands to send subcommands

* Use webvault access url everywhere

Production instances all have api url located at `baseUrl/api`.
Receive command will parse the webvault url and alter it to an api url.

* Move create and receive commands to send directory

* Separate program concerns

program holds authentication/general program concerns
vault.program holds commands related to the vault
send.program holds commands related to Bitwarden Send

* Fix up imports and lint items

* Add edit command

* Use browser-hrtime

* Add send examples to help text

* Clean up receive help text

* correct help text

* Add delete command

* Code review Cleanup

* Scheme on send receive help text

* PR review items

Move buffer to array buffer to jslib
delete with server
some formatting fixes

* Add remove password command

This is the simplest way to enable removing passwords without
resorting to weird type parsing of piped in Send JSONs in edit

* Default hidden to false like web

* Do not allow password updates that aren't strings or are empty

* Delete appveyor.yml.flagged-for-delete

* Correctly order imports and include tslint rule

* fix npm globbing problem

https://stackoverflow.com/a/34594501
globs work differently in package.json. Encasing the globs in
single quotes expands them in shell rather than in npm

* Remove double slash in path

* Trigger github rebuild

src/commands/send/create.command.ts

@@ -0,0 +1,112 @@
+import * as program from 'commander';
+import * as fs from 'fs';
+import * as path from 'path';
+
+import { EnvironmentService } from 'jslib/abstractions/environment.service';
+import { SendService } from 'jslib/abstractions/send.service';
+import { UserService } from 'jslib/abstractions/user.service';
+
+import { SendType } from 'jslib/enums/sendType';
+
+import { NodeUtils } from 'jslib/misc/nodeUtils';
+
+import { Response } from 'jslib/cli/models/response';
+import { StringResponse } from 'jslib/cli/models/response/stringResponse';
+
+import { SendResponse } from '../../models/response/sendResponse';
+import { SendTextResponse } from '../../models/response/sendTextResponse';
+
+import { CliUtils } from '../../utils';
+
+export class SendCreateCommand {
+    constructor(private sendService: SendService, private userService: UserService,
+        private environmentService: EnvironmentService) { }
+
+    async run(requestJson: string, options: program.OptionValues) {
+        let req: any = null;
+        if (requestJson == null || requestJson === '') {
+            requestJson = await CliUtils.readStdin();
+        }
+
+        if (requestJson == null || requestJson === '') {
+            return Response.badRequest('`requestJson` was not provided.');
+        }
+
+        try {
+            const reqJson = Buffer.from(requestJson, 'base64').toString();
+            req = SendResponse.fromJson(reqJson);
+
+            if (req == null) {
+                throw new Error('Null request');
+            }
+        } catch (e) {
+            return Response.badRequest('Error parsing the encoded request data.');
+        }
+
+        if (req.deletionDate == null || isNaN(new Date(req.deletionDate).getTime()) ||
+            new Date(req.deletionDate) <= new Date()) {
+            return Response.badRequest('Must specify a valid deletion date after the current time');
+        }
+
+        if (req.expirationDate != null && isNaN(new Date(req.expirationDate).getTime())) {
+            return Response.badRequest('Unable to parse expirationDate: ' + req.expirationDate);
+        }
+
+        return this.createSend(req, options);
+    }
+
+    private async createSend(req: SendResponse, options: program.OptionValues) {
+        const filePath = req.file?.fileName ?? options.file;
+        const text = req.text?.text ?? options.text;
+        const hidden = req.text?.hidden ?? options.hidden;
+        const password = req.password ?? options.password;
+
+        req.key = null;
+
+        switch (req.type) {
+            case SendType.File:
+                if (!(await this.userService.canAccessPremium())) {
+                    return Response.error('Premium status is required to use this feature.');
+                }
+
+                if (filePath == null) {
+                    return Response.badRequest('Must specify a file to Send either with the --file option or in the encoded json');
+                }
+
+                req.file.fileName = path.basename(filePath)
+                break;
+            case SendType.Text:
+                if (text == null) {
+                    return Response.badRequest('Must specify text content to Send either with the --text option or in the encoded json');
+                }
+                req.text = new SendTextResponse();
+                req.text.text = text;
+                req.text.hidden = hidden;
+                break;
+            default:
+                return Response.badRequest('Unknown Send type ' + SendType[req.type] + 'valid types are: file, text');
+        }
+
+        try {
+            let fileBuffer: ArrayBuffer = null;
+            if (req.type === SendType.File) {
+                fileBuffer = NodeUtils.bufferToArrayBuffer(fs.readFileSync(filePath));
+            }
+
+            const sendView = SendResponse.toView(req);
+            const [encSend, fileData] = await this.sendService.encrypt(sendView, fileBuffer, password);
+            // Add dates from template
+            encSend.deletionDate = sendView.deletionDate;
+            encSend.expirationDate = sendView.expirationDate;
+
+            await this.sendService.saveWithServer([encSend, fileData]);
+            const newSend = await this.sendService.get(encSend.id);
+            const decSend = await newSend.decrypt();
+            const res = new SendResponse(decSend, this.environmentService.getWebVaultUrl());
+            return Response.success(options.fullObject ? res :
+                new StringResponse('Send created! It can be accessed at:\n' + res.accessUrl));
+        } catch (e) {
+            return Response.error(e);
+        }
+    }
+}