bitwarden-estensione-browser/src/commands/export.command.ts

import * as program from "commander";
import * as inquirer from "inquirer";

import { ExportService } from "jslib-common/abstractions/export.service";
import { KeyConnectorService } from "jslib-common/abstractions/keyConnector.service";
import { PolicyService } from "jslib-common/abstractions/policy.service";
import { UserVerificationService } from "jslib-common/abstractions/userVerification.service";

import { Response } from "jslib-node/cli/models/response";

import { PolicyType } from "jslib-common/enums/policyType";
import { VerificationType } from "jslib-common/enums/verificationType";

import { Utils } from "jslib-common/misc/utils";

import { CliUtils } from "../utils";

export class ExportCommand {
  constructor(
    private exportService: ExportService,
    private policyService: PolicyService,
    private keyConnectorService: KeyConnectorService,
    private userVerificationService: UserVerificationService
  ) {}

  async run(password: string, options: program.OptionValues): Promise<Response> {
    if (
      options.organizationid == null &&
      (await this.policyService.policyAppliesToUser(PolicyType.DisablePersonalVaultExport))
    ) {
      return Response.badRequest(
        "One or more organization policies prevents you from exporting your personal vault."
      );
    }

    const canInteract = process.env.BW_NOINTERACTION !== "true";
    if (!canInteract) {
      return Response.badRequest(
        "User verification is required. Try running this command again in interactive mode."
      );
    }

    try {
      (await this.keyConnectorService.getUsesKeyConnector())
        ? await this.verifyOTP()
        : await this.verifyMasterPassword(password);
    } catch (e) {
      return Response.badRequest(e.message);
    }

    let format = options.format;
    if (format !== "encrypted_json" && format !== "json") {
      format = "csv";
    }
    if (options.organizationid != null && !Utils.isGuid(options.organizationid)) {
      return Response.error("`" + options.organizationid + "` is not a GUID.");
    }
    let exportContent: string = null;
    try {
      exportContent =
        options.organizationid != null
          ? await this.exportService.getOrganizationExport(options.organizationid, format)
          : await this.exportService.getExport(format);
    } catch (e) {
      return Response.error(e);
    }
    return await this.saveFile(exportContent, options, format);
  }

  async saveFile(
    exportContent: string,
    options: program.OptionValues,
    format: string
  ): Promise<Response> {
    try {
      const fileName = this.getFileName(format, options.organizationid != null ? "org" : null);
      return await CliUtils.saveResultToFile(exportContent, options.output, fileName);
    } catch (e) {
      return Response.error(e.toString());
    }
  }

  private getFileName(format: string, prefix?: string) {
    if (format === "encrypted_json") {
      if (prefix == null) {
        prefix = "encrypted";
      } else {
        prefix = "encrypted_" + prefix;
      }
      format = "json";
    }
    return this.exportService.getFileName(prefix, format);
  }

  private async verifyMasterPassword(password: string) {
    if (password == null || password === "") {
      const answer: inquirer.Answers = await inquirer.createPromptModule({
        output: process.stderr,
      })({
        type: "password",
        name: "password",
        message: "Master password:",
      });
      password = answer.password;
    }

    await this.userVerificationService.verifyUser({
      type: VerificationType.MasterPassword,
      secret: password,
    });
  }

  private async verifyOTP() {
    await this.userVerificationService.requestOTP();
    const answer: inquirer.Answers = await inquirer.createPromptModule({ output: process.stderr })({
      type: "password",
      name: "otp",
      message: "A verification code has been emailed to you.\n Verification code:",
    });

    await this.userVerificationService.verifyUser({
      type: VerificationType.OTP,
      secret: answer.otp,
    });
  }
}