@wocker/ws 1.0.20 → 1.0.22

package/lib/controllers/ProxyController.js

@@ -18,7 +18,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ProxyController = void 0;
 const core_1 = require("@wocker/core");
 const utils_1 = require("@wocker/utils");
-const chalk_1 = __importDefault(require("chalk"));
+const yoctocolors_cjs_1 = __importDefault(require("yoctocolors-cjs"));
 const services_1 = require("../services");
 let ProxyController = class ProxyController {
     constructor(appConfigService, appEventsService, projectService, proxyService) {
@@ -35,9 +35,9 @@ let ProxyController = class ProxyController {
         if (project.domains.length === 0) {
             return;
         }
-        console.info(chalk_1.default.green("Don't forget to add these lines into hosts file:"));
+        console.info(yoctocolors_cjs_1.default.green("Don't forget to add these lines into hosts file:"));
         for (const domain of project.domains) {
-            console.info(chalk_1.default.gray(`127.0.0.1 ${domain}`));
+            console.info(yoctocolors_cjs_1.default.gray(`127.0.0.1 ${domain}`));
         }
         await this.start();
     }
@@ -47,26 +47,55 @@ let ProxyController = class ProxyController {
         const projects = this.projectService.search();
         return projects.map((project) => project.name);
     }
-    async init(httpPort, httpsPort) {
-        const config = this.appConfigService.getConfig();
+    async init(httpPort, httpsPort, sshPort, sshPassword) {
+        const config = this.appConfigService.config;
         if (httpPort === null || typeof httpPort === "undefined" || isNaN(httpPort)) {
-            httpPort = await (0, utils_1.promptText)({
+            httpPort = await (0, utils_1.promptInput)({
                 required: true,
-                message: "Http port:",
+                message: "Http port",
                 type: "number",
-                default: config.getMeta("PROXY_HTTP_PORT", "80")
+                default: parseInt(config.getMeta("PROXY_HTTP_PORT", "80"))
             });
         }
         config.setMeta("PROXY_HTTP_PORT", httpPort.toString());
         if (httpsPort === null || typeof httpsPort === "undefined" || isNaN(httpsPort)) {
-            httpsPort = await (0, utils_1.promptText)({
+            httpsPort = await (0, utils_1.promptInput)({
                 required: true,
-                message: "Https port:",
+                message: "Https port",
                 type: "number",
-                default: config.getMeta("PROXY_HTTPS_PORT", "443")
+                default: parseInt(config.getMeta("PROXY_HTTPS_PORT", "443"))
             });
         }
         config.setMeta("PROXY_HTTPS_PORT", httpsPort.toString());
+        let enableSsh = !sshPassword && !sshPort
+            ? await (0, utils_1.promptConfirm)({
+                message: "Enable ssh proxy?",
+                default: false
+            })
+            : true;
+        if (enableSsh) {
+            if (!sshPassword) {
+                sshPassword = await (0, utils_1.promptInput)({
+                    message: "SSH Password",
+                    type: "password",
+                    required: true,
+                    default: config.getMeta("PROXY_SSH_PASSWORD")
+                });
+            }
+            if (!sshPort) {
+                sshPort = await (0, utils_1.promptInput)({
+                    message: "SSH port",
+                    type: "number",
+                    default: parseInt(config.getMeta("PROXY_SSH_PORT", "22"))
+                });
+            }
+            config.setMeta("PROXY_SSH_PASSWORD", sshPassword);
+            config.setMeta("PROXY_SSH_PORT", sshPort.toString());
+        }
+        else {
+            config.unsetMeta("PROXY_SSH_PASSWORD");
+            config.unsetMeta("PROXY_SSH_PORT");
+        }
         await config.save();
     }
     async start(restart, rebuild) {
@@ -89,6 +118,7 @@ __decorate([
 ], ProxyController.prototype, "getProjectNames", null);
 __decorate([
     (0, core_1.Command)("proxy:init"),
+    (0, core_1.Description)("Initializes proxy configurations"),
     __param(0, (0, core_1.Option)("http-port", {
         type: "number",
         description: "Http port"
@@ -97,21 +127,30 @@ __decorate([
         type: "number",
         description: "Https port"
     })),
+    __param(2, (0, core_1.Option)("ssh-port", {
+        type: "number",
+        description: "SSH port"
+    })),
+    __param(3, (0, core_1.Option)("ssh-password", {
+        type: "string",
+        description: "SSH password"
+    })),
     __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Number, Number]),
+    __metadata("design:paramtypes", [Number, Number, Number, String]),
     __metadata("design:returntype", Promise)
 ], ProxyController.prototype, "init", null);
 __decorate([
     (0, core_1.Command)("proxy:start"),
+    (0, core_1.Description)("This command starts the proxy for the project. Options are available to restart or rebuild the proxy if needed."),
     __param(0, (0, core_1.Option)("restart", {
         type: "boolean",
         alias: "r",
-        description: "Restart"
+        description: "Restarts the proxy before starting it"
     })),
     __param(1, (0, core_1.Option)("rebuild", {
         type: "boolean",
         alias: "b",
-        description: "Rebuild"
+        description: "Rebuilds the proxy before starting it"
     })),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Boolean, Boolean]),
@@ -119,18 +158,21 @@ __decorate([
 ], ProxyController.prototype, "start", null);
 __decorate([
     (0, core_1.Command)("proxy:stop"),
+    (0, core_1.Description)("This command stops the currently running proxy for the project. It ensures that all proxy-related services are properly halted."),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", []),
     __metadata("design:returntype", Promise)
 ], ProxyController.prototype, "stop", null);
 __decorate([
     (0, core_1.Command)("proxy:logs"),
+    (0, core_1.Description)("Displays the proxy logs"),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", []),
     __metadata("design:returntype", Promise)
 ], ProxyController.prototype, "logs", null);
 exports.ProxyController = ProxyController = __decorate([
     (0, core_1.Controller)(),
+    (0, core_1.Description)("Proxy commands"),
     __metadata("design:paramtypes", [services_1.AppConfigService,
         services_1.AppEventsService,
         services_1.ProjectService,

package/lib/controllers/index.d.ts

@@ -1,7 +1,7 @@
 export * from "./CertController";
 export * from "./CompletionController";
 export * from "./DebugController";
-export * from "./ImageController";
+export * from "./KeystoreController";
 export * from "./PluginController";
 export * from "./PresetController";
 export * from "./ProjectController";

package/lib/controllers/index.js

@@ -17,7 +17,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./CertController"), exports);
 __exportStar(require("./CompletionController"), exports);
 __exportStar(require("./DebugController"), exports);
-__exportStar(require("./ImageController"), exports);
+__exportStar(require("./KeystoreController"), exports);
 __exportStar(require("./PluginController"), exports);
 __exportStar(require("./PresetController"), exports);
 __exportStar(require("./ProjectController"), exports);

package/lib/env.d.ts

@@ -1,4 +1,4 @@
-export declare const WOCKER_VERSION = "1.0.19";
+export declare const WOCKER_VERSION = "1.0.22";
 export declare const NODE_ENV: string;
 export declare const ROOT_DIR: string;
 export declare const PRESETS_DIR: string;
@@ -6,3 +6,4 @@ export declare const SERVICES_DIR: string;
 export declare const PLUGINS_DIR: string;
 export declare const DATA_DIR: string;
 export declare const VIRTUAL_HOST_KEY = "VIRTUAL_HOST";
+export declare const KEYTAR_SERVICE: string;

package/lib/env.js

@@ -15,18 +15,28 @@ var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (
 }) : function(o, v) {
     o["default"] = v;
 });
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.VIRTUAL_HOST_KEY = exports.DATA_DIR = exports.PLUGINS_DIR = exports.SERVICES_DIR = exports.PRESETS_DIR = exports.ROOT_DIR = exports.NODE_ENV = exports.WOCKER_VERSION = void 0;
+exports.KEYTAR_SERVICE = exports.VIRTUAL_HOST_KEY = exports.DATA_DIR = exports.PLUGINS_DIR = exports.SERVICES_DIR = exports.PRESETS_DIR = exports.ROOT_DIR = exports.NODE_ENV = exports.WOCKER_VERSION = void 0;
 const OS = __importStar(require("os"));
 const Path = __importStar(require("path"));
-exports.WOCKER_VERSION = "1.0.19";
+exports.WOCKER_VERSION = "1.0.22";
 exports.NODE_ENV = process.env.NODE_ENV;
 exports.ROOT_DIR = Path.join(__dirname, "..");
 exports.PRESETS_DIR = Path.join(exports.ROOT_DIR, "presets");
@@ -34,3 +44,4 @@ exports.SERVICES_DIR = Path.join(exports.ROOT_DIR, "services");
 exports.PLUGINS_DIR = Path.join(exports.ROOT_DIR, "plugins");
 exports.DATA_DIR = process.env.WS_DIR || Path.join(OS.homedir(), ".workspace");
 exports.VIRTUAL_HOST_KEY = "VIRTUAL_HOST";
+exports.KEYTAR_SERVICE = process.env.WOCKER_KEYTAR_SERVICE || "wocker";

package/lib/keystore/KeystoreService.d.ts

@@ -0,0 +1,12 @@
+import { KeystoreService as CoreKeystoreService, KeystoreProvider } from "@wocker/core";
+import { AppConfigService } from "../services/AppConfigService";
+export declare class KeystoreService extends CoreKeystoreService {
+    protected readonly appConfigService: AppConfigService;
+    protected providers: Map<string, KeystoreProvider>;
+    constructor(appConfigService: AppConfigService);
+    hasProvider(name: string): boolean;
+    provider(name?: string): KeystoreProvider;
+    get(keys: string | string[], byDefault?: string): Promise<string | undefined>;
+    set(key: string, value: string): Promise<void>;
+    registerProvider(name: string, provider: KeystoreProvider): void;
+}

package/lib/keystore/KeystoreService.js

@@ -0,0 +1,70 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KeystoreService = void 0;
+const core_1 = require("@wocker/core");
+const AppConfigService_1 = require("../services/AppConfigService");
+const KeytarKeystoreProvider_1 = require("./providers/KeytarKeystoreProvider");
+const FileKeystoreProvider_1 = require("./providers/FileKeystoreProvider");
+let KeystoreService = class KeystoreService extends core_1.KeystoreService {
+    constructor(appConfigService) {
+        super();
+        this.appConfigService = appConfigService;
+        this.providers = new Map();
+    }
+    hasProvider(name) {
+        return ["file", "keytar"].includes(name);
+    }
+    provider(name) {
+        if (!name) {
+            name = this.appConfigService.config.keystore;
+        }
+        if (!name) {
+            name = "file";
+        }
+        switch (name) {
+            case "file":
+                return new FileKeystoreProvider_1.FileKeystoreProvider(this.appConfigService);
+            case "keytar":
+                return new KeytarKeystoreProvider_1.KeytarKeystoreProvider();
+            default:
+                throw new Error(`Unknown keystore provider "${name}"`);
+        }
+    }
+    async get(keys, byDefault) {
+        const provider = this.provider();
+        if (Array.isArray(keys)) {
+            for (const key of keys) {
+                const value = await provider.get(key);
+                if (value) {
+                    return value;
+                }
+            }
+            return byDefault;
+        }
+        return provider.get(keys, byDefault);
+    }
+    async set(key, value) {
+        const provider = this.provider();
+        await provider.set(key, value);
+    }
+    registerProvider(name, provider) {
+        if (this.providers.has(name)) {
+            throw new Error(`Provider ${name} already registered`);
+        }
+        this.providers.set(name, provider);
+    }
+};
+exports.KeystoreService = KeystoreService;
+exports.KeystoreService = KeystoreService = __decorate([
+    (0, core_1.Injectable)("KEYSTORE_SERVICE"),
+    __metadata("design:paramtypes", [AppConfigService_1.AppConfigService])
+], KeystoreService);

package/lib/keystore/index.d.ts

@@ -0,0 +1 @@
+export * from "./KeystoreService";

package/lib/keystore/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./KeystoreService"), exports);

package/lib/keystore/providers/FileKeystoreProvider.d.ts

@@ -0,0 +1,16 @@
+import { KeystoreProvider } from "@wocker/core";
+import { AppConfigService } from "../../services/AppConfigService";
+import { FileKeystore } from "../types/FileKeystore";
+export declare class FileKeystoreProvider extends KeystoreProvider {
+    protected readonly appConfigService: AppConfigService;
+    protected password?: string;
+    protected encryptionKey?: Buffer;
+    protected _keystore?: FileKeystore;
+    constructor(appConfigService: AppConfigService);
+    protected get keystore(): FileKeystore;
+    protected get passwordHash(): string | undefined;
+    protected getEncryptionKey(): Promise<Buffer>;
+    get(key: string, defaultValue?: string): Promise<string | undefined>;
+    set(key: string, value: string): Promise<void>;
+    delete(key: string): Promise<void>;
+}

package/lib/keystore/providers/FileKeystoreProvider.js

@@ -0,0 +1,97 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileKeystoreProvider = void 0;
+const core_1 = require("@wocker/core");
+const utils_1 = require("@wocker/utils");
+const AppConfigService_1 = require("../../services/AppConfigService");
+const FileKeystore_1 = require("../types/FileKeystore");
+const utils_2 = require("../utils");
+let FileKeystoreProvider = class FileKeystoreProvider extends core_1.KeystoreProvider {
+    constructor(appConfigService) {
+        super();
+        this.appConfigService = appConfigService;
+    }
+    get keystore() {
+        if (!this._keystore) {
+            const fs = this.appConfigService.fs;
+            let data = {
+                secrets: {}
+            };
+            if (fs.exists("wocker.keystore.js")) {
+                try {
+                    data = {
+                        ...require(fs.path("wocker.keystore.js"))
+                    };
+                }
+                catch (err) {
+                }
+            }
+            this._keystore = new class extends FileKeystore_1.FileKeystore {
+                save() {
+                    if (!fs.exists()) {
+                        fs.mkdir("");
+                    }
+                    fs.writeFile("wocker.keystore.js", this.toString());
+                }
+            }(data);
+        }
+        return this._keystore;
+    }
+    get passwordHash() {
+        return this.keystore.passwordHash;
+    }
+    async getEncryptionKey() {
+        if (!this.encryptionKey) {
+            const password = await (0, utils_1.promptInput)({
+                required: true,
+                min: 6,
+                max: 32,
+                message: "Keystore password",
+                type: "password",
+                validate: async (value) => {
+                    if (typeof value !== "string" || !this.passwordHash || (0, utils_2.verifyPasswordHash)(value, this.passwordHash)) {
+                        return true;
+                    }
+                    return "Invalid password";
+                }
+            });
+            if (!this.keystore.passwordHash) {
+                this.keystore.passwordHash = (0, utils_2.createPasswordHash)(password);
+                this.keystore.save();
+            }
+            this.encryptionKey = (0, utils_2.createEncryptionKey)(password, this.keystore.passwordHash);
+        }
+        return this.encryptionKey;
+    }
+    async get(key, defaultValue) {
+        const value = this.keystore.get(key);
+        if (!value) {
+            return defaultValue;
+        }
+        const encryptionKey = await this.getEncryptionKey();
+        return (0, utils_2.decrypt)(encryptionKey, value);
+    }
+    async set(key, value) {
+        const encryptionKey = await this.getEncryptionKey();
+        this.keystore.set(key, (0, utils_2.encrypt)(encryptionKey, value));
+        this.keystore.save();
+    }
+    async delete(key) {
+        this.keystore.delete(key);
+        this.keystore.save();
+    }
+};
+exports.FileKeystoreProvider = FileKeystoreProvider;
+exports.FileKeystoreProvider = FileKeystoreProvider = __decorate([
+    (0, core_1.Injectable)(),
+    __metadata("design:paramtypes", [AppConfigService_1.AppConfigService])
+], FileKeystoreProvider);

package/lib/keystore/providers/KeytarKeystoreProvider.d.ts

@@ -0,0 +1,9 @@
+import { KeystoreProvider } from "@wocker/core";
+import { Keytar } from "../types/Keytar";
+export declare class KeytarKeystoreProvider extends KeystoreProvider {
+    protected _keytar?: any;
+    get(key: string, defaultValue?: string): Promise<string | undefined>;
+    set(key: string, value: string): Promise<void>;
+    delete(key: string): Promise<void>;
+    protected getKeytar(): Promise<Keytar>;
+}

package/lib/keystore/providers/KeytarKeystoreProvider.js

@@ -0,0 +1,74 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KeytarKeystoreProvider = void 0;
+const core_1 = require("@wocker/core");
+const env_1 = require("../../env");
+let KeytarKeystoreProvider = class KeytarKeystoreProvider extends core_1.KeystoreProvider {
+    async get(key, defaultValue) {
+        const keytar = await this.getKeytar();
+        const value = await keytar.getPassword(env_1.KEYTAR_SERVICE, key);
+        return value || defaultValue;
+    }
+    async set(key, value) {
+        const keytar = await this.getKeytar();
+        try {
+            await keytar.setPassword(env_1.KEYTAR_SERVICE, key, value);
+        }
+        catch (err) {
+            console.log(err.message);
+        }
+    }
+    async delete(key) {
+        const keytar = await this.getKeytar();
+        await keytar.deletePassword(env_1.KEYTAR_SERVICE, key);
+    }
+    async getKeytar() {
+        if (!this._keytar) {
+            this._keytar = await Promise.resolve().then(() => __importStar(require("keytar")));
+        }
+        return this._keytar;
+    }
+};
+exports.KeytarKeystoreProvider = KeytarKeystoreProvider;
+exports.KeytarKeystoreProvider = KeytarKeystoreProvider = __decorate([
+    (0, core_1.Injectable)()
+], KeytarKeystoreProvider);

package/lib/keystore/types/Encryption.d.ts

@@ -0,0 +1,9 @@
+export declare class Encryption {
+    private algorithm;
+    private keyLength;
+    private ivLength;
+    private saltLength;
+    private tagLength;
+    getEncryptionKey(keyPath: string, masterPassword: string): Promise<Buffer>;
+    private deriveKey;
+}

package/lib/keystore/types/Encryption.js

@@ -0,0 +1,81 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Encryption = void 0;
+const crypto = __importStar(require("crypto"));
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const util_1 = require("util");
+const fsReadFile = (0, util_1.promisify)(fs.readFile);
+const fsWriteFile = (0, util_1.promisify)(fs.writeFile);
+const fsMkdir = (0, util_1.promisify)(fs.mkdir);
+const fsAccess = (0, util_1.promisify)(fs.access);
+class Encryption {
+    constructor() {
+        this.algorithm = 'aes-256-gcm';
+        this.keyLength = 32;
+        this.ivLength = 16;
+        this.saltLength = 64;
+        this.tagLength = 16;
+    }
+    async getEncryptionKey(keyPath, masterPassword) {
+        try {
+            await fsAccess(path.dirname(keyPath));
+        }
+        catch (error) {
+            await fsMkdir(path.dirname(keyPath), { recursive: true });
+        }
+        let salt;
+        try {
+            salt = await fsReadFile(keyPath);
+        }
+        catch (error) {
+            salt = crypto.randomBytes(this.saltLength);
+            await fsWriteFile(keyPath, salt);
+        }
+        return this.deriveKey(masterPassword, salt);
+    }
+    async deriveKey(password, salt) {
+        return new Promise((resolve, reject) => {
+            crypto.scrypt(password, salt, this.keyLength, (err, derivedKey) => {
+                if (err)
+                    reject(err);
+                else
+                    resolve(derivedKey);
+            });
+        });
+    }
+}
+exports.Encryption = Encryption;

package/lib/keystore/types/Encryptor.d.ts

@@ -0,0 +1,10 @@
+export declare class Encryptor {
+    protected _salt: Buffer;
+    protected _hash?: string;
+    constructor(hash?: string, salt?: string);
+    get hash(): string;
+    get salt(): string;
+    setPassword(password: string): this;
+    encrypt(): void;
+    decrypt(): void;
+}