fix

dist/cert.classes.cert.d.ts

@@ -1,44 +1,37 @@
 /// <reference types="q" />
-import * as plugins from "./cert.plugins";
+import * as q from 'q';
+import { Stringmap, Objectmap } from 'lik';
+import { Certificate } from './cert.classes.certificate';
+import { Letsencrypt, TLeEnv } from './cert.classes.letsencrypt';
 export interface ICertConstructorOptions {
     cfEmail: string;
     cfKey: string;
-    sslDir?: string;
+    sslDirPath?: string;
     gitOriginRepo?: string;
-    testMode?: boolean;
+    leEnv?: TLeEnv;
 }
 export declare class Cert {
-    private _cfEmail;
-    private _cfKey;
-    private _sslDir;
-    private _gitOriginRepo;
-    private _testMode;
-    domainCertRequestMap: plugins.lik.Stringmap;
-    certificatesPresent: Certificate[];
-    certificatesValid: Certificate[];
+    domainStringRequestMap: Stringmap;
+    certificateMap: Objectmap<Certificate>;
+    letsencrypt: Letsencrypt;
+    private _challengeHandler;
+    private _certRepo;
     /**
      * Constructor for Cert object
      */
     constructor(optionsArg: ICertConstructorOptions);
     /**
-     * Pulls already requested certificates from git origin
+     * adds a Certificate for a given domain
      */
-    sslGitOriginPull: () => void;
-    /**
-     * Pushes all new requested certificates to git origin
-     */
-    sslGitOriginAddCommitPush: () => void;
-    /**
-     * gets a ssl cert for a given domain
-     */
-    getDomainCert(domainNameArg: string, optionsArg?: {
+    addCertificate(domainNameArg: string, optionsArg?: {
         force: boolean;
-    }): plugins.q.Promise<{}>;
+    }): q.Promise<{}>;
+    /**
+     * cleans up old certificates
+     */
     cleanOldCertificates(): void;
-}
-export declare class Certificate {
-    domainName: string;
-    creationDate: Date;
-    expiryDate: Date;
-    constructor();
+    /**
+     * executes the current batch of jobs
+     */
+    deploy(): void;
 }

dist/cert.classes.cert.helpers.d.ts

@@ -1,19 +0,0 @@
-/// <reference types="q" />
-import * as plugins from "./cert.plugins";
-/**
- * schedule a retry of certificate request
- */
-export declare let scheduleRetry: (domainArg: string, certClassArg: any) => plugins.q.Promise<{}>;
-/**
- * check if a given domainCert is still valid
- */
-export declare let checkDomainsStillValid: (domainNameArg: string, sslDirArg: string) => boolean;
-export interface certConfig {
-    domainName: string;
-    created: number;
-    expires: number;
-}
-/**
- * update a ssl directory
- */
-export declare let updateSslDirSync: (sslDirArg: string, domainNameArg: string) => void;

dist/cert.classes.cert.helpers.js

@@ -1,59 +0,0 @@
-"use strict";
-const plugins = require("./cert.plugins");
-const paths = require("./cert.paths");
-/**
- * schedule a retry of certificate request
- */
-exports.scheduleRetry = (domainArg, certClassArg) => {
-    let done = plugins.q.defer();
-    setTimeout(() => {
-        certClassArg.getDomainCert(domainArg)
-            .then(done.resolve);
-    }, 60000);
-    return done.promise;
-};
-/**
- * check if a given domainCert is still valid
- */
-exports.checkDomainsStillValid = (domainNameArg, sslDirArg) => {
-    let domainConfigPath = plugins.path.join(sslDirArg, domainNameArg, "config.json");
-    if (plugins.smartfile.fs.fileExistsSync(domainConfigPath)) {
-        let domainConfig = plugins.smartfile.fs.toObjectSync(domainConfigPath, "json");
-        if (Date.now() >= ((domainConfig.expires - 604800) * 1000)) {
-            return false;
-        }
-        else {
-            return true;
-        }
-    }
-    else {
-        return false;
-    }
-};
-;
-/**
- * update a ssl directory
- */
-exports.updateSslDirSync = (sslDirArg, domainNameArg) => {
-    plugins.smartfile.fs.ensureDirSync(sslDirArg);
-    let domainCertFolder = plugins.path.join(paths.certDir, domainNameArg);
-    if (plugins.smartfile.fs.listFoldersSync(paths.certDir).indexOf(domainNameArg) != -1) {
-        plugins.smartfile.fs.copySync(plugins.path.join(domainCertFolder, "fullchain.pem"), plugins.path.join(sslDirArg, domainNameArg, "fullchain.pem"));
-        plugins.smartfile.fs.copySync(plugins.path.join(domainCertFolder, "privkey.pem"), plugins.path.join(sslDirArg, domainNameArg, "privkey.pem"));
-        // create cert config
-        let certRegex = /.*\-([0-9]*)\.pem/;
-        let certFileNameWithTime = plugins.smartfile.fs.listFilesSync(domainCertFolder, certRegex)[0];
-        let certTime = parseInt(certRegex.exec(certFileNameWithTime)[1]);
-        let certConfig = {
-            domainName: domainNameArg,
-            created: certTime,
-            expires: certTime + 7776000
-        };
-        plugins.smartfile.memory.toFsSync(JSON.stringify(certConfig), plugins.path.join(sslDirArg, domainNameArg, "config.json"));
-    }
-    ;
-};
-let updateGitOrigin = (syncDirectionArg) => {
-};
-updateGitOrigin(0 /* toOrigin */);
-//# sourceMappingURL=data:application/json;base64,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

dist/cert.classes.certificate.d.ts

@@ -0,0 +1,48 @@
+/// <reference types="q" />
+import * as q from 'q';
+import * as plugins from './cert.plugins';
+import { Cert } from './cert.classes.cert';
+export interface ICertificateFsConfig {
+    domainName: string;
+    creationTime: number;
+    expiryTime: number;
+}
+export interface ICertificateConstructorOptions {
+    domainName: string;
+    certInstance: Cert;
+}
+export declare type TCertificateStatus = 'unregistered' | 'valid' | 'expiring' | 'expired';
+export declare class Certificate {
+    domainName: string;
+    certInstance: Cert;
+    domainData: plugins.smartstring.Domain;
+    creationDate: Date;
+    expiryDate: Date;
+    publicKey: string;
+    privKey: string;
+    /**
+     * run when creating a new instance of Certificate
+     */
+    constructor(optionsArg: ICertificateConstructorOptions);
+    /**
+     * the status of the Certificate
+     */
+    readonly status: TCertificateStatus;
+    readonly sameZoneRequesting: boolean;
+    /**
+     * schedule a retry of certificate request
+     */
+    scheduleRetry(): q.Promise<{}>;
+    /**
+     * renew certificate if needed
+     */
+    renew(force?: boolean): q.Promise<{}>;
+    /**
+     * syncFs syncs the certificate with disk
+     */
+    syncFs(): void;
+    /**
+     * deletes the certificate
+     */
+    delete(): void;
+}

dist/cert.classes.certificate.js

@@ -0,0 +1,103 @@
+"use strict";
+const q = require("q");
+const plugins = require("./cert.plugins");
+class Certificate {
+    /**
+     * run when creating a new instance of Certificate
+     */
+    constructor(optionsArg) {
+        this.creationDate = null;
+        this.expiryDate = null;
+        this.publicKey = null;
+        this.privKey = null;
+        this.domainName = optionsArg.domainName;
+        this.domainData = new plugins.smartstring.Domain(this.domainName);
+        this.certInstance = optionsArg.certInstance;
+    }
+    /**
+     * the status of the Certificate
+     */
+    get status() {
+        let validTimeRemaining = 0;
+        if (this.creationDate !== null && this.expiryDate !== null) {
+            validTimeRemaining = this.expiryDate.getTime() - Date.now();
+        }
+        let MonthMilliseconds = 2629746000;
+        if (this.publicKey === null || this.privKey === null) {
+            return 'unregistered';
+        }
+        else if (validTimeRemaining >= MonthMilliseconds) {
+            return 'valid';
+        }
+        else if (validTimeRemaining < MonthMilliseconds && validTimeRemaining >= 0) {
+            return 'expiring';
+        }
+        else {
+            return 'expired';
+        }
+    }
+    get sameZoneRequesting() {
+        return this.certInstance.domainStringRequestMap.checkMinimatch('*' + this.domainData.zoneName);
+    }
+    /**
+     * schedule a retry of certificate request
+     */
+    scheduleRetry() {
+        let done = plugins.q.defer();
+        setTimeout(() => {
+            this.renew()
+                .then(done.resolve);
+        }, 60000);
+        return done.promise;
+    }
+    /**
+     * renew certificate if needed
+     */
+    renew(force = false) {
+        let done = q.defer();
+        if (this.status === 'valid') {
+            plugins.beautylog.log('Certificate still valid for more than 1 month, so it is not renewed now');
+            done.resolve();
+        }
+        else if (this.status === 'expiring' || this.status === 'expired' || this.status === 'unregistered') {
+            plugins.beautylog.info('Certificate not valid currently, going to renew now!');
+            if (this.sameZoneRequesting) {
+                this.certInstance.domainStringRequestMap.registerUntilTrue(() => {
+                    return !this.sameZoneRequesting;
+                }, () => {
+                    this.renew().then(done.resolve);
+                });
+            }
+            else {
+                this.certInstance.letsencrypt.registerDomain(this.domainName)
+                    .then(() => {
+                    return this.syncFs();
+                })
+                    .then(() => {
+                    done.resolve();
+                }).catch((err) => { console.log(err); });
+            }
+        }
+        else {
+            throw Error(`weird status for certificate with domain name ${this.domainName}`);
+        }
+        done.resolve();
+        return done.promise;
+    }
+    /**
+     * syncFs syncs the certificate with disk
+     */
+    syncFs() {
+        let configJsonMemory = {
+            domainName: this.domainName,
+            creationTime: this.creationDate.getTime(),
+            expiryTime: this.expiryDate.getTime()
+        };
+    }
+    /**
+     * deletes the certificate
+     */
+    delete() { }
+}
+exports.Certificate = Certificate;
+//# sourceMappingURL=data:application/json;base64,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

dist/cert.classes.certrepo.d.ts

@@ -0,0 +1,26 @@
+/// <reference types="q" />
+import * as q from 'q';
+import { Cert } from './cert.classes.cert';
+export interface ICertRepoConstructorOptions {
+    sslDirPath: string;
+    gitOriginRepo: string;
+    certInstance: Cert;
+}
+export declare class CertRepo {
+    private _sslDirPath;
+    private _gitOriginRepo;
+    private _certInstance;
+    constructor(optionsArg: ICertRepoConstructorOptions);
+    /**
+     * syncs an objectmap of Certificates with repo
+     */
+    syncFs(): q.Promise<{}>;
+    /**
+     * Pulls already requested certificates from git origin
+     */
+    sslGitOriginPull: () => void;
+    /**
+     * Pushes all new requested certificates to git origin
+     */
+    sslGitOriginAddCommitPush: () => void;
+}

dist/cert.classes.certrepo.js

@@ -0,0 +1,49 @@
+"use strict";
+const q = require("q");
+const plugins = require("./cert.plugins");
+const paths = require("./cert.paths");
+class CertRepo {
+    constructor(optionsArg) {
+        /**
+         * Pulls already requested certificates from git origin
+         */
+        this.sslGitOriginPull = () => {
+            if (this._gitOriginRepo) {
+                plugins.smartgit.pull(this._sslDirPath, 'origin', 'master');
+            }
+        };
+        /**
+         * Pushes all new requested certificates to git origin
+         */
+        this.sslGitOriginAddCommitPush = () => {
+            if (this._gitOriginRepo) {
+                plugins.smartgit.add.addAll(this._sslDirPath);
+                plugins.smartgit.commit(this._sslDirPath, 'added new SSL certificates and deleted obsolete ones.');
+                plugins.smartgit.push(this._sslDirPath, 'origin', 'master');
+            }
+        };
+        this._sslDirPath = optionsArg.sslDirPath;
+        this._gitOriginRepo = optionsArg.gitOriginRepo;
+        this._certInstance = optionsArg.certInstance;
+        // setup sslDir
+        if (!this._sslDirPath) {
+            this._sslDirPath = paths.defaultSslDir;
+        }
+        // setup Git
+        if (this._gitOriginRepo) {
+            plugins.smartgit.init(this._sslDirPath);
+            plugins.smartgit.remote.add(this._sslDirPath, 'origin', this._gitOriginRepo);
+            this.sslGitOriginPull();
+        }
+    }
+    /**
+     * syncs an objectmap of Certificates with repo
+     */
+    syncFs() {
+        let done = q.defer();
+        done.resolve();
+        return done.promise;
+    }
+}
+exports.CertRepo = CertRepo;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2VydC5jbGFzc2VzLmNlcnRyZXBvLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHMvY2VydC5jbGFzc2VzLmNlcnRyZXBvLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7QUFBQSx1QkFBc0I7QUFFdEIsMENBQXlDO0FBQ3pDLHNDQUFxQztBQVdyQztJQUlJLFlBQVksVUFBdUM7UUEyQm5EOztXQUVHO1FBQ0gscUJBQWdCLEdBQUc7WUFDZixFQUFFLENBQUMsQ0FBQyxJQUFJLENBQUMsY0FBYyxDQUFDLENBQUMsQ0FBQztnQkFDdEIsT0FBTyxDQUFDLFFBQVEsQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLFdBQVcsRUFBRSxRQUFRLEVBQUUsUUFBUSxDQUFDLENBQUE7WUFDL0QsQ0FBQztRQUNMLENBQUMsQ0FBQTtRQUVEOztXQUVHO1FBQ0gsOEJBQXlCLEdBQUc7WUFDeEIsRUFBRSxDQUFDLENBQUMsSUFBSSxDQUFDLGNBQWMsQ0FBQyxDQUFDLENBQUM7Z0JBQ3RCLE9BQU8sQ0FBQyxRQUFRLENBQUMsR0FBRyxDQUFDLE1BQU0sQ0FBQyxJQUFJLENBQUMsV0FBVyxDQUFDLENBQUE7Z0JBQzdDLE9BQU8sQ0FBQyxRQUFRLENBQUMsTUFBTSxDQUFDLElBQUksQ0FBQyxXQUFXLEVBQUUsdURBQXVELENBQUMsQ0FBQTtnQkFDbEcsT0FBTyxDQUFDLFFBQVEsQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLFdBQVcsRUFBRSxRQUFRLEVBQUUsUUFBUSxDQUFDLENBQUE7WUFDL0QsQ0FBQztRQUNMLENBQUMsQ0FBQTtRQTVDRyxJQUFJLENBQUMsV0FBVyxHQUFHLFVBQVUsQ0FBQyxVQUFVLENBQUE7UUFDeEMsSUFBSSxDQUFDLGNBQWMsR0FBRyxVQUFVLENBQUMsYUFBYSxDQUFBO1FBQzlDLElBQUksQ0FBQyxhQUFhLEdBQUcsVUFBVSxDQUFDLFlBQVksQ0FBQTtRQUU1QyxlQUFlO1FBQ2YsRUFBRSxDQUFDLENBQUMsQ0FBQyxJQUFJLENBQUMsV0FBVyxDQUFDLENBQUEsQ0FBQztZQUNuQixJQUFJLENBQUMsV0FBVyxHQUFHLEtBQUssQ0FBQyxhQUFhLENBQUE7UUFDMUMsQ0FBQztRQUVELFlBQVk7UUFDWixFQUFFLENBQUMsQ0FBQyxJQUFJLENBQUMsY0FBYyxDQUFDLENBQUMsQ0FBQztZQUN0QixPQUFPLENBQUMsUUFBUSxDQUFDLElBQUksQ0FBQyxJQUFJLENBQUMsV0FBVyxDQUFDLENBQUE7WUFDdkMsT0FBTyxDQUFDLFFBQVEsQ0FBQyxNQUFNLENBQUMsR0FBRyxDQUFDLElBQUksQ0FBQyxXQUFXLEVBQUUsUUFBUSxFQUFFLElBQUksQ0FBQyxjQUFjLENBQUMsQ0FBQTtZQUM1RSxJQUFJLENBQUMsZ0JBQWdCLEVBQUUsQ0FBQTtRQUMzQixDQUFDO0lBQ0wsQ0FBQztJQUVEOztPQUVHO0lBQ0gsTUFBTTtRQUNGLElBQUksSUFBSSxHQUFHLENBQUMsQ0FBQyxLQUFLLEVBQUUsQ0FBQTtRQUNwQixJQUFJLENBQUMsT0FBTyxFQUFFLENBQUE7UUFDZCxNQUFNLENBQUMsSUFBSSxDQUFDLE9BQU8sQ0FBQTtJQUN2QixDQUFDO0NBcUJKO0FBbERELDRCQWtEQyJ9

dist/cert.classes.challengehandler.d.ts

@@ -0,0 +1,20 @@
+/// <reference types="q" />
+export interface IChallengehandlerConstructorOptions {
+    cfEmail: string;
+    cfKey: string;
+}
+/**
+ * class ChallengeHandler handles challenges
+ */
+export declare class ChallengeHandler {
+    private _cfInstance;
+    constructor(optionsArg: IChallengehandlerConstructorOptions);
+    /**
+     * set a challenge
+     */
+    setChallenge(domainNameArg: string, challengeArg: string): Q.Promise<{}>;
+    /**
+     * cleans a challenge
+     */
+    cleanChallenge(domainNameArg: any): Q.Promise<{}>;
+}

dist/cert.classes.challengehandler.js

@@ -0,0 +1,75 @@
+"use strict";
+const plugins = require("./cert.plugins");
+/**
+ * class ChallengeHandler handles challenges
+ */
+class ChallengeHandler {
+    constructor(optionsArg) {
+        this._cfInstance = new plugins.cflare.CflareAccount();
+        this._cfInstance.auth({
+            email: optionsArg.cfEmail,
+            key: optionsArg.cfKey
+        });
+    }
+    /**
+     * set a challenge
+     */
+    setChallenge(domainNameArg, challengeArg) {
+        let done = plugins.q.defer();
+        plugins.beautylog.log('setting challenge for ' + domainNameArg);
+        this._cfInstance.createRecord(prefixName(domainNameArg), 'TXT', challengeArg).then(() => {
+            plugins.beautylog.ok('Challenge has been set!');
+            plugins.beautylog.info('We need to cool down to let DNS propagate to edge locations!');
+            cooldown().then(() => {
+                done.resolve();
+            });
+        });
+        return done.promise;
+    }
+    /**
+     * cleans a challenge
+     */
+    cleanChallenge(domainNameArg) {
+        let done = plugins.q.defer();
+        plugins.beautylog.log('cleaning challenge for ' + domainNameArg);
+        this._cfInstance.removeRecord(prefixName(domainNameArg), 'TXT');
+        cooldown().then(() => {
+            done.resolve();
+        });
+        return done.promise;
+    }
+}
+exports.ChallengeHandler = ChallengeHandler;
+/**
+ * cooldown timer for letting DNS settle before answering the challengerequest
+ */
+let cooldown = () => {
+    let done = plugins.q.defer();
+    let cooldowntime = 60000;
+    let passedTime = 0;
+    plugins.beautylog.log('Cooling down! ' + (cooldowntime / 1000).toString() + ' seconds left');
+    let coolDownCounter = () => {
+        setTimeout(() => {
+            if (cooldowntime <= passedTime) {
+                plugins.beautylog.ok('Cooled down!');
+                done.resolve();
+            }
+            else {
+                passedTime = passedTime + 5000;
+                plugins.beautylog.log('Cooling down! '
+                    + ((cooldowntime - passedTime) / 1000).toString()
+                    + ' seconds left');
+                coolDownCounter();
+            }
+        }, 5000);
+    };
+    coolDownCounter();
+    return done.promise;
+};
+/**
+ * prefix a domain name to make sure it complies with letsencrypt
+ */
+let prefixName = (domainNameArg) => {
+    return '_acme-challenge.' + domainNameArg;
+};
+//# sourceMappingURL=data:application/json;base64,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

dist/cert.classes.letsencrypt.d.ts

@@ -0,0 +1,27 @@
+/// <reference types="q" />
+import * as q from 'q';
+import { ChallengeHandler } from './cert.classes.challengehandler';
+export declare type TLeEnv = 'production' | 'staging';
+export interface ILetsencryptConstructorOptions {
+    leEnv: TLeEnv;
+    challengeHandler: ChallengeHandler;
+    sslDir: string;
+}
+export declare class Letsencrypt {
+    leEnv: TLeEnv;
+    challengeHandler: ChallengeHandler;
+    sslDir: string;
+    private _leInstance;
+    private _leServerUrl;
+    constructor(optionsArg: ILetsencryptConstructorOptions);
+    /**
+     * register a domain
+     */
+    registerDomain(domainNameArg: string): q.Promise<{}>;
+    private _leCopyToDestination(domainNameArg);
+    /**
+     * translates to the format expected by letsencrypt node implementation
+     */
+    private _leChallengeHandler();
+    private _leAgree(opts, agreeCb);
+}

dist/cert.classes.letsencrypt.js

@@ -0,0 +1,114 @@
+"use strict";
+const q = require("q");
+let letsencrypt = require('letsencrypt');
+const plugins = require("./cert.plugins");
+const paths = require("./cert.paths");
+class Letsencrypt {
+    constructor(optionsArg) {
+        // determine leEnv
+        this.leEnv = optionsArg.leEnv;
+        this.challengeHandler = optionsArg.challengeHandler;
+        this.sslDir = optionsArg.sslDir;
+        // set letsencrypt environment
+        if (this.leEnv === 'production') {
+            this._leServerUrl = letsencrypt.productionServerUrl;
+        }
+        else if (this.leEnv === 'staging') {
+            this._leServerUrl = letsencrypt.stagingServerUrl;
+        }
+        // create leInstance
+        this._leInstance = letsencrypt.create({
+            server: this._leServerUrl,
+            challenges: { 'dns-01': this._leChallengeHandler() },
+            challengeType: 'dns-01',
+            configDir: paths.leConfigDir,
+            privkeyPath: ':configDir/live/:hostname/privkey.pem',
+            fullchainPath: ':configDir/live/:hostname/fullchain.pem',
+            certPath: ':config/live/:hostname/cert.pem',
+            chainPath: ':config/live/:hostname/chain.pem',
+            agreeToTerms: this._leAgree,
+            debug: true
+        });
+    }
+    /**
+     * register a domain
+     */
+    registerDomain(domainNameArg) {
+        plugins.beautylog.log(`trying to register domain ${domainNameArg}`);
+        let done = q.defer();
+        console.log('test');
+        this._leInstance.register({
+            domains: [domainNameArg],
+            email: 'domains@lossless.org',
+            agreeTos: true,
+            rsaKeySize: 2048,
+            challengeType: 'dns-01'
+        }).then((results) => {
+            plugins.beautylog.success(`Got certificates for ${domainNameArg}`);
+            this._leCopyToDestination(domainNameArg).then(done.resolve);
+        }, (err) => {
+            console.error('[Error]: node-letsencrypt/examples/standalone');
+            console.error(err.stack);
+            done.resolve();
+        }).catch(err => { console.log(err); });
+        return done.promise;
+    }
+    // --------------------------------------------
+    // Translate for official letsencrypt stuff
+    // --------------------------------------------
+    _leCopyToDestination(domainNameArg) {
+        let done = q.defer();
+        return done.promise;
+    }
+    /**
+     * translates to the format expected by letsencrypt node implementation
+     */
+    _leChallengeHandler() {
+        return {
+            getOptions: (...args) => {
+                return {
+                    debug: true
+                };
+            },
+            set: (args, domain, challenge, keyAuthorization, cb) => {
+                let keyAuthDigest = require('crypto')
+                    .createHash('sha256').update(keyAuthorization || '')
+                    .digest('base64')
+                    .replace(/\+/g, '-')
+                    .replace(/\//g, '_')
+                    .replace(/=+$/g, '');
+                this.challengeHandler.setChallenge(domain, keyAuthDigest)
+                    .then(() => {
+                    cb();
+                });
+            },
+            get: (defaults, domain, challenge, cb) => {
+                console.log(defaults);
+                console.log(domain);
+                console.log(challenge);
+                cb();
+            },
+            remove: (args, domain, challenge, cb) => {
+                this.challengeHandler.cleanChallenge(domain)
+                    .then(() => {
+                    cb();
+                });
+            },
+            loopback: (args, domain, challenge, cb) => {
+                console.log(args);
+                console.log(domain);
+                console.log(challenge);
+                cb();
+            },
+            test: (defaults, domain, challenge, cb) => {
+                cb();
+            }
+        };
+    }
+    _leAgree(opts, agreeCb) {
+        // opts = { email, domains, tosUrl } 
+        agreeCb(null, opts.tosUrl);
+    }
+}
+exports.Letsencrypt = Letsencrypt;
+//# sourceMappingURL=data:application/json;base64,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

dist/cert.hook.js

@@ -1,68 +0,0 @@
-#!/usr/bin/env node
-"use strict";
-const plugins = require("./cert.plugins");
-const paths = require("./cert.paths");
-let smartcli = new plugins.smartcli.Smartcli();
-let config = plugins.smartfile.fs.toObjectSync(paths.config);
-let cflare = new plugins.cflare.CflareAccount();
-cflare.auth({
-    email: config.cfEmail,
-    key: config.cfKey
-});
-let setChallenge = (domainNameArg, challengeArg) => {
-    let done = plugins.q.defer();
-    plugins.beautylog.log("setting challenge for " + domainNameArg);
-    cflare.createRecord(prefixName(domainNameArg), "TXT", challengeArg).then(() => {
-        plugins.beautylog.ok("Challenge has been set!");
-        plugins.beautylog.info("We need to cool down to let DNS propagate to edge locations!");
-        cooldown().then(() => {
-            done.resolve();
-        });
-    });
-    return done.promise;
-};
-let cleanChallenge = (domainNameArg) => {
-    let done = plugins.q.defer();
-    plugins.beautylog.log("cleaning challenge for " + domainNameArg);
-    cflare.removeRecord(prefixName(domainNameArg), "TXT");
-    cooldown().then(() => {
-        done.resolve();
-    });
-    return done.promise;
-};
-let cooldown = () => {
-    let done = plugins.q.defer();
-    let cooldowntime = 60000;
-    let passedTime = 0;
-    plugins.beautylog.log("Cooling down! " + (cooldowntime / 1000).toString() + " seconds left");
-    let coolDownCounter = () => {
-        setTimeout(() => {
-            if (cooldowntime <= passedTime) {
-                plugins.beautylog.ok("Cooled down!");
-                done.resolve();
-            }
-            else {
-                passedTime = passedTime + 5000;
-                plugins.beautylog.log("Cooling down! " + ((cooldowntime - passedTime) / 1000).toString() + " seconds left");
-                coolDownCounter();
-            }
-        }, 5000);
-    };
-    coolDownCounter();
-    return done.promise;
-};
-let prefixName = (domainNameArg) => {
-    return "_acme-challenge." + domainNameArg;
-};
-smartcli.addCommand({
-    commandName: "deploy_challenge"
-}).then((argv) => {
-    setChallenge(argv._[1], argv._[3]);
-});
-smartcli.addCommand({
-    commandName: "clean_challenge"
-}).then((argv) => {
-    cleanChallenge(argv._[1]);
-});
-smartcli.startParse();
-//# sourceMappingURL=data:application/json;base64,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

dist/cert.paths.d.ts

@@ -1,8 +1,4 @@
-export declare let certDir: string;
-export declare let defaultSslDir: string;
+export declare let projectDir: string;
 export declare let assetDir: string;
-export declare let accountsDir: string;
-export declare let certHook: string;
-export declare let config: string;
-export declare let leShConfig: string;
-export declare let letsencryptSh: string;
+export declare let defaultSslDir: string;
+export declare let leConfigDir: string;

dist/cert.paths.js

@@ -1,13 +1,10 @@
 "use strict";
 const plugins = require("./cert.plugins");
-//dirs
-exports.certDir = plugins.path.join(__dirname, "assets/certs");
-exports.defaultSslDir = plugins.path.join(__dirname, "assets/defaultSslDir");
-exports.assetDir = plugins.path.join(__dirname, "assets/");
-exports.accountsDir = plugins.path.join(__dirname, "assets/accounts/");
-// files
-exports.certHook = plugins.path.join(__dirname, "cert.hook.js");
-exports.config = plugins.path.join(__dirname, "assets/config.json");
-exports.leShConfig = plugins.path.join(__dirname, "assets/leshconfig.json");
-exports.letsencryptSh = plugins.path.join(__dirname, "assets/letsencrypt.sh");
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2VydC5wYXRocy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzL2NlcnQucGF0aHMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUFBLDBDQUEwQztBQUUxQyxNQUFNO0FBQ0ssUUFBQSxPQUFPLEdBQUcsT0FBTyxDQUFDLElBQUksQ0FBQyxJQUFJLENBQUMsU0FBUyxFQUFDLGNBQWMsQ0FBQyxDQUFDO0FBQ3RELFFBQUEsYUFBYSxHQUFHLE9BQU8sQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLFNBQVMsRUFBQyxzQkFBc0IsQ0FBQyxDQUFDO0FBQ3BFLFFBQUEsUUFBUSxHQUFHLE9BQU8sQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLFNBQVMsRUFBQyxTQUFTLENBQUMsQ0FBQztBQUNsRCxRQUFBLFdBQVcsR0FBRyxPQUFPLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQyxTQUFTLEVBQUMsa0JBQWtCLENBQUMsQ0FBQztBQUV6RSxRQUFRO0FBQ0csUUFBQSxRQUFRLEdBQUcsT0FBTyxDQUFDLElBQUksQ0FBQyxJQUFJLENBQUMsU0FBUyxFQUFDLGNBQWMsQ0FBQyxDQUFDO0FBQ3ZELFFBQUEsTUFBTSxHQUFHLE9BQU8sQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLFNBQVMsRUFBQyxvQkFBb0IsQ0FBQyxDQUFDO0FBQzNELFFBQUEsVUFBVSxHQUFHLE9BQU8sQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLFNBQVMsRUFBQyx3QkFBd0IsQ0FBQyxDQUFDO0FBQ25FLFFBQUEsYUFBYSxHQUFHLE9BQU8sQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLFNBQVMsRUFBQyx1QkFBdUIsQ0FBQyxDQUFDIn0=
+// dirs
+exports.projectDir = plugins.path.join(__dirname, '../');
+exports.assetDir = plugins.path.join(exports.projectDir, 'assets');
+exports.defaultSslDir = plugins.path.join(exports.assetDir, 'defaultSslDir');
+exports.leConfigDir = plugins.path.join(exports.assetDir, 'letsencrypt');
+plugins.smartfile.fs.ensureDirSync(exports.leConfigDir);
+plugins.smartfile.fs.ensureDirSync(exports.defaultSslDir);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2VydC5wYXRocy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzL2NlcnQucGF0aHMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUFBLDBDQUF5QztBQUV6QyxPQUFPO0FBQ0ksUUFBQSxVQUFVLEdBQUcsT0FBTyxDQUFDLElBQUksQ0FBQyxJQUFJLENBQUMsU0FBUyxFQUFDLEtBQUssQ0FBQyxDQUFBO0FBQy9DLFFBQUEsUUFBUSxHQUFHLE9BQU8sQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLGtCQUFVLEVBQUMsUUFBUSxDQUFDLENBQUE7QUFDakQsUUFBQSxhQUFhLEdBQUcsT0FBTyxDQUFDLElBQUksQ0FBQyxJQUFJLENBQUMsZ0JBQVEsRUFBQyxlQUFlLENBQUMsQ0FBQTtBQUMzRCxRQUFBLFdBQVcsR0FBRyxPQUFPLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQyxnQkFBUSxFQUFDLGFBQWEsQ0FBQyxDQUFBO0FBQ2xFLE9BQU8sQ0FBQyxTQUFTLENBQUMsRUFBRSxDQUFDLGFBQWEsQ0FBQyxtQkFBVyxDQUFDLENBQUE7QUFDL0MsT0FBTyxDQUFDLFNBQVMsQ0FBQyxFQUFFLENBQUMsYUFBYSxDQUFDLHFCQUFhLENBQUMsQ0FBQSJ9

dist/cert.plugins.d.ts

@@ -1,12 +1,13 @@
-import "typings-global";
-export import beautylog = require("beautylog");
-export import cflare = require("cflare");
-export declare let fs: any;
-export import lik = require("lik");
-export import path = require("path");
-export import q = require("q");
-export import shelljs = require("shelljs");
-export import smartcli = require("smartcli");
-export import smartfile = require("smartfile");
-export import smartgit = require("smartgit");
-export import smartstring = require("smartstring");
+import 'typings-global';
+import * as beautylog from 'beautylog';
+import * as cflare from 'cflare';
+declare let fs: any;
+import * as lik from 'lik';
+import * as path from 'path';
+import * as q from 'q';
+import * as shelljs from 'shelljs';
+import * as smartcli from 'smartcli';
+import * as smartfile from 'smartfile';
+import * as smartgit from 'smartgit';
+import * as smartstring from 'smartstring';
+export { beautylog, cflare, fs, lik, path, q, shelljs, smartcli, smartfile, smartgit, smartstring };

dist/cert.plugins.js

@@ -1,14 +1,25 @@
 "use strict";
 require("typings-global");
-exports.beautylog = require("beautylog");
-exports.cflare = require("cflare");
-exports.fs = require("fs-extra");
-exports.lik = require("lik");
-exports.path = require("path");
-exports.q = require("q");
-exports.shelljs = require("shelljs");
-exports.smartcli = require("smartcli");
-exports.smartfile = require("smartfile");
-exports.smartgit = require("smartgit");
-exports.smartstring = require("smartstring");
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2VydC5wbHVnaW5zLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHMvY2VydC5wbHVnaW5zLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7QUFBQSwwQkFBd0I7QUFDeEIseUNBQStDO0FBQy9DLG1DQUF5QztBQUM5QixRQUFBLEVBQUUsR0FBRyxPQUFPLENBQUMsVUFBVSxDQUFDLENBQUM7QUFDcEMsNkJBQW1DO0FBQ25DLCtCQUFxQztBQUNyQyx5QkFBK0I7QUFDL0IscUNBQTJDO0FBQzNDLHVDQUE2QztBQUM3Qyx5Q0FBK0M7QUFDL0MsdUNBQTZDO0FBQzdDLDZDQUFtRCJ9
+const beautylog = require("beautylog");
+exports.beautylog = beautylog;
+const cflare = require("cflare");
+exports.cflare = cflare;
+let fs = require('fs-extra');
+exports.fs = fs;
+const lik = require("lik");
+exports.lik = lik;
+const path = require("path");
+exports.path = path;
+const q = require("q");
+exports.q = q;
+const shelljs = require("shelljs");
+exports.shelljs = shelljs;
+const smartcli = require("smartcli");
+exports.smartcli = smartcli;
+const smartfile = require("smartfile");
+exports.smartfile = smartfile;
+const smartgit = require("smartgit");
+exports.smartgit = smartgit;
+const smartstring = require("smartstring");
+exports.smartstring = smartstring;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2VydC5wbHVnaW5zLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHMvY2VydC5wbHVnaW5zLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7QUFBQSwwQkFBdUI7QUFDdkIsdUNBQXNDO0FBYWxDLG9CQWJRLFNBQVMsQ0FhUjtBQVpiLGlDQUFnQztBQWE1QixpQkFiUSxNQUFNLENBYVI7QUFaVixJQUFJLEVBQUUsR0FBRyxPQUFPLENBQUMsVUFBVSxDQUFDLENBQUE7QUFheEIsYUFiQSxFQUFFLENBYUE7QUFaTiwyQkFBMEI7QUFhdEIsY0FiUSxHQUFHLENBYVI7QUFaUCw2QkFBNEI7QUFheEIsZUFiUSxJQUFJLENBYVI7QUFaUix1QkFBc0I7QUFhbEIsWUFiUSxDQUFDLENBYVI7QUFaTCxtQ0FBa0M7QUFhOUIsa0JBYlEsT0FBTyxDQWFSO0FBWlgscUNBQW9DO0FBYWhDLG1CQWJRLFFBQVEsQ0FhUjtBQVpaLHVDQUFzQztBQWFsQyxvQkFiUSxTQUFTLENBYVI7QUFaYixxQ0FBb0M7QUFhaEMsbUJBYlEsUUFBUSxDQWFSO0FBWlosMkNBQTBDO0FBYXRDLHNCQWJRLFdBQVcsQ0FhUiJ9

dist/index.d.ts

@@ -1 +1 @@
-export * from "./cert.classes.cert";
+export * from './cert.classes.cert';

dist/index.js

@@ -3,4 +3,4 @@ function __export(m) {
     for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
 }
 __export(require("./cert.classes.cert"));
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7O0FBR0EseUNBQW9DIn0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7O0FBQUEseUNBQW1DIn0=

dist/install.d.ts

@@ -1,3 +0,0 @@
-/// <reference types="q" />
-import * as plugins from "./cert.plugins";
-export declare let startInstall: () => plugins.q.Promise<{}>;

dist/install.js

@@ -1,19 +0,0 @@
-"use strict";
-const plugins = require("./cert.plugins");
-const paths = require("./cert.paths");
-exports.startInstall = () => {
-    let done = plugins.q.defer();
-    plugins.beautylog.info("installing letsencrypt.sh locally...");
-    plugins.fs.ensureDir(plugins.path.join(__dirname, "assets/"));
-    plugins.smartfile.remote.toFs("https://raw.githubusercontent.com/lukas2511/letsencrypt.sh/master/letsencrypt.sh", paths.letsencryptSh).then(() => {
-        plugins.beautylog.success("Done!");
-        done.resolve();
-    });
-    return done.promise;
-};
-let smartcli = new plugins.smartcli.Smartcli();
-smartcli.addCommand({
-    commandName: "install"
-}).then(exports.startInstall);
-smartcli.startParse();
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5zdGFsbC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzL2luc3RhbGwudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUFBLDBDQUEwQztBQUMxQyxzQ0FBc0M7QUFFM0IsUUFBQSxZQUFZLEdBQUc7SUFDdEIsSUFBSSxJQUFJLEdBQUcsT0FBTyxDQUFDLENBQUMsQ0FBQyxLQUFLLEVBQUUsQ0FBQztJQUM3QixPQUFPLENBQUMsU0FBUyxDQUFDLElBQUksQ0FBQyxzQ0FBc0MsQ0FBQyxDQUFDO0lBRS9ELE9BQU8sQ0FBQyxFQUFFLENBQUMsU0FBUyxDQUFDLE9BQU8sQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLFNBQVMsRUFBRSxTQUFTLENBQUMsQ0FBQyxDQUFDO0lBQzlELE9BQU8sQ0FBQyxTQUFTLENBQUMsTUFBTSxDQUFDLElBQUksQ0FDekIsa0ZBQWtGLEVBQ2xGLEtBQUssQ0FBQyxhQUFhLENBQ3RCLENBQUMsSUFBSSxDQUFDO1FBQ0gsT0FBTyxDQUFDLFNBQVMsQ0FBQyxPQUFPLENBQUMsT0FBTyxDQUFDLENBQUM7UUFDbkMsSUFBSSxDQUFDLE9BQU8sRUFBRSxDQUFDO0lBQ25CLENBQUMsQ0FBQyxDQUFDO0lBQ0gsTUFBTSxDQUFDLElBQUksQ0FBQyxPQUFPLENBQUM7QUFDeEIsQ0FBQyxDQUFDO0FBRUYsSUFBSSxRQUFRLEdBQUcsSUFBSSxPQUFPLENBQUMsUUFBUSxDQUFDLFFBQVEsRUFBRSxDQUFDO0FBQy9DLFFBQVEsQ0FBQyxVQUFVLENBQUM7SUFDaEIsV0FBVyxFQUFDLFNBQVM7Q0FDeEIsQ0FBQyxDQUFDLElBQUksQ0FBQyxvQkFBWSxDQUFDLENBQUM7QUFDdEIsUUFBUSxDQUFDLFVBQVUsRUFBRSxDQUFDIn0=