"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const tslib_1 = require("tslib");
const fs_1 = require("fs");
const debug_1 = tslib_1.__importDefault(require("debug"));
const command_exists_1 = require("command-exists");
const rimraf_1 = tslib_1.__importDefault(require("rimraf"));
const constants_1 = require("./constants");
const platforms_1 = tslib_1.__importDefault(require("./platforms"));
const certificate_authority_1 = tslib_1.__importStar(require("./certificate-authority"));
exports.uninstall = certificate_authority_1.uninstall;
const certificates_1 = tslib_1.__importDefault(require("./certificates"));
const user_interface_1 = tslib_1.__importDefault(require("./user-interface"));
const debug = debug_1.default('devcert');
/**
 * Request an SSL certificate for the given app name signed by the devcert root
 * certificate authority. If devcert has previously generated a certificate for
 * that app name on this machine, it will reuse that certificate.
 *
 * If this is the first time devcert is being run on this machine, it will
 * generate and attempt to install a root certificate authority.
 *
 * Returns a promise that resolves with { key, cert }, where `key` and `cert`
 * are Buffers with the contents of the certificate private key and certificate
 * file, respectively
 *
 * If `options.getCaBuffer` is true, return value will include the ca certificate data
 * as { ca: Buffer }
 *
 * If `options.getCaPath` is true, return value will include the ca certificate path
 * as { caPath: string }
 */
function certificateFor(domain, options = {}) {
    return tslib_1.__awaiter(this, void 0, void 0, function* () {
        if (constants_1.VALID_IP.test(domain)) {
            throw new Error('IP addresses are not supported currently');
        }
        if (!constants_1.VALID_DOMAIN.test(domain)) {
            throw new Error(`"${domain}" is not a valid domain name.`);
        }
        debug(`Certificate requested for ${domain}. Skipping certutil install: ${Boolean(options.skipCertutilInstall)}. Skipping hosts file: ${Boolean(options.skipHostsFile)}`);
        if (options.ui) {
            Object.assign(user_interface_1.default, options.ui);
        }
        if (!constants_1.isMac && !constants_1.isLinux && !constants_1.isWindows) {
            throw new Error(`Platform not supported: "${process.platform}"`);
        }
        if (!command_exists_1.sync('openssl')) {
            throw new Error('OpenSSL not found: OpenSSL is required to generate SSL certificates - make sure it is installed and available in your PATH');
        }
        let domainKeyPath = constants_1.pathForDomain(domain, `private-key.key`);
        let domainCertPath = constants_1.pathForDomain(domain, `certificate.crt`);
        if (!fs_1.existsSync(constants_1.rootCAKeyPath)) {
            debug('Root CA is not installed yet, so it must be our first run. Installing root CA ...');
            yield certificate_authority_1.default(options);
        }
        else if (options.getCaBuffer || options.getCaPath) {
            debug('Root CA is not readable, but it probably is because an earlier version of devcert locked it. Trying to fix...');
            yield certificate_authority_1.ensureCACertReadable(options);
        }
        if (!fs_1.existsSync(constants_1.pathForDomain(domain, `certificate.crt`))) {
            debug(`Can't find certificate file for ${domain}, so it must be the first request for ${domain}. Generating and caching ...`);
            yield certificates_1.default(domain);
        }
        if (!options.skipHostsFile) {
            yield platforms_1.default.addDomainToHostFileIfMissing(domain);
        }
        debug(`Returning domain certificate`);
        const ret = {
            key: fs_1.readFileSync(domainKeyPath),
            cert: fs_1.readFileSync(domainCertPath)
        };
        if (options.getCaBuffer)
            ret.ca = fs_1.readFileSync(constants_1.rootCACertPath);
        if (options.getCaPath)
            ret.caPath = constants_1.rootCACertPath;
        return ret;
    });
}
exports.certificateFor = certificateFor;
function hasCertificateFor(domain) {
    return fs_1.existsSync(constants_1.pathForDomain(domain, `certificate.crt`));
}
exports.hasCertificateFor = hasCertificateFor;
function configuredDomains() {
    return fs_1.readdirSync(constants_1.domainsDir);
}
exports.configuredDomains = configuredDomains;
function removeDomain(domain) {
    return rimraf_1.default.sync(constants_1.pathForDomain(domain));
}
exports.removeDomain = removeDomain;
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"/Users/evanbacon/Documents/GitHub/devcert/","sources":["index.ts"],"names":[],"mappings":"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","sourcesContent":["import { readFileSync as readFile, readdirSync as readdir, existsSync as exists } from 'fs';\nimport createDebug from 'debug';\nimport { sync as commandExists } from 'command-exists';\nimport rimraf from 'rimraf';\nimport {\n  isMac,\n  isLinux,\n  isWindows,\n  pathForDomain,\n  domainsDir,\n  rootCAKeyPath,\n  rootCACertPath,\n  VALID_DOMAIN,\n  VALID_IP\n} from './constants';\nimport currentPlatform from './platforms';\nimport installCertificateAuthority, { ensureCACertReadable, uninstall } from './certificate-authority';\nimport generateDomainCertificate from './certificates';\nimport UI, { UserInterface } from './user-interface';\nexport { uninstall };\n\nconst debug = createDebug('devcert');\n\nexport interface Options /* extends Partial<ICaBufferOpts & ICaPathOpts>  */{\n  /** Return the CA certificate data? */\n  getCaBuffer?: boolean;\n  /** Return the path to the CA certificate? */\n  getCaPath?: boolean;\n  /** If `certutil` is not installed already (for updating nss databases; e.g. firefox), do not attempt to install it */\n  skipCertutilInstall?: boolean,\n  /** Do not update your systems host file with the domain name of the certificate */\n  skipHostsFile?: boolean,\n  /** User interface hooks */\n  ui?: UserInterface\n}\n\ninterface ICaBuffer {\n  ca: Buffer;\n}\ninterface ICaPath {\n  caPath: string;\n}\ninterface IDomainData {\n  key: Buffer;\n  cert: Buffer;\n}\ntype IReturnCa<O extends Options> = O['getCaBuffer'] extends true ? ICaBuffer : false;\ntype IReturnCaPath<O extends Options> = O['getCaPath'] extends true ? ICaPath : false;\ntype IReturnData<O extends Options = {}> = (IDomainData) & (IReturnCa<O>) & (IReturnCaPath<O>);\n\n/**\n * Request an SSL certificate for the given app name signed by the devcert root\n * certificate authority. If devcert has previously generated a certificate for\n * that app name on this machine, it will reuse that certificate.\n *\n * If this is the first time devcert is being run on this machine, it will\n * generate and attempt to install a root certificate authority.\n *\n * Returns a promise that resolves with { key, cert }, where `key` and `cert`\n * are Buffers with the contents of the certificate private key and certificate\n * file, respectively\n * \n * If `options.getCaBuffer` is true, return value will include the ca certificate data\n * as { ca: Buffer }\n * \n * If `options.getCaPath` is true, return value will include the ca certificate path\n * as { caPath: string }\n */\nexport async function certificateFor<O extends Options>(domain: string, options: O = {} as O): Promise<IReturnData<O>> {\n  if (VALID_IP.test(domain)) {\n    throw new Error('IP addresses are not supported currently');\n  }\n  if (!VALID_DOMAIN.test(domain)) {\n    throw new Error(`\"${domain}\" is not a valid domain name.`);\n  }\n  debug(`Certificate requested for ${ domain }. Skipping certutil install: ${ Boolean(options.skipCertutilInstall) }. Skipping hosts file: ${ Boolean(options.skipHostsFile) }`);\n\n  if (options.ui) {\n    Object.assign(UI, options.ui);\n  }\n\n  if (!isMac && !isLinux && !isWindows) {\n    throw new Error(`Platform not supported: \"${ process.platform }\"`);\n  }\n\n  if (!commandExists('openssl')) {\n    throw new Error('OpenSSL not found: OpenSSL is required to generate SSL certificates - make sure it is installed and available in your PATH');\n  }\n\n  let domainKeyPath = pathForDomain(domain, `private-key.key`);\n  let domainCertPath = pathForDomain(domain, `certificate.crt`);\n\n  if (!exists(rootCAKeyPath)) {\n    debug('Root CA is not installed yet, so it must be our first run. Installing root CA ...');\n    await installCertificateAuthority(options);\n  } else if (options.getCaBuffer || options.getCaPath) {\n    debug('Root CA is not readable, but it probably is because an earlier version of devcert locked it. Trying to fix...');\n    await ensureCACertReadable(options);\n  }\n\n  if (!exists(pathForDomain(domain, `certificate.crt`))) {\n    debug(`Can't find certificate file for ${ domain }, so it must be the first request for ${ domain }. Generating and caching ...`);\n    await generateDomainCertificate(domain);\n  }\n\n  if (!options.skipHostsFile) {\n    await currentPlatform.addDomainToHostFileIfMissing(domain);\n  }\n\n  debug(`Returning domain certificate`);\n\n  const ret = {\n    key: readFile(domainKeyPath),\n    cert: readFile(domainCertPath)\n  } as IReturnData<O>;\n  if (options.getCaBuffer) (ret as ICaBuffer).ca = readFile(rootCACertPath);\n  if (options.getCaPath) (ret as ICaPath).caPath = rootCACertPath;\n\n  return ret;\n}\n\nexport function hasCertificateFor(domain: string) {\n  return exists(pathForDomain(domain, `certificate.crt`));\n}\n\nexport function configuredDomains() {\n  return readdir(domainsDir);\n}\n\nexport function removeDomain(domain: string) {\n  return rimraf.sync(pathForDomain(domain));\n}\n"]}