@wocker/ws 1.0.21 → 1.0.23

package/lib/modules/docker/services/ModemService.js

@@ -0,0 +1,137 @@
+"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.ModemService = void 0;
+const core_1 = require("@wocker/core");
+const formatSizeUnits_1 = require("../utils/formatSizeUnits");
+const ProtoService_1 = require("./ProtoService");
+let ModemService = class ModemService extends core_1.ModemService {
+    constructor(protoService) {
+        super();
+        this.protoService = protoService;
+    }
+    get modem() {
+        if (!this._modem) {
+            const Modem = require("docker-modem");
+            this._modem = new Modem({
+                socketPath: "/var/run/docker.sock"
+            });
+        }
+        return this._modem;
+    }
+    get docker() {
+        if (!this._docker) {
+            const Docker = require("dockerode");
+            this._docker = new Docker({
+                modem: this.modem
+            });
+        }
+        return this._docker;
+    }
+    async attachStream(stream) {
+        if (process.stdin.isTTY) {
+            process.stdin.setRawMode(true);
+        }
+        process.stdin.resume();
+        process.stdin.setEncoding("utf8");
+        process.stdin.pipe(stream);
+        stream.setEncoding("utf8");
+        stream.pipe(process.stdout);
+        try {
+            await new Promise((resolve, reject) => {
+                stream.on("end", resolve);
+                stream.on("error", reject);
+            });
+        }
+        finally {
+            process.stdin.pause();
+            if (process.stdin.isTTY) {
+                process.stdin.setRawMode(false);
+            }
+            process.stdin.unpipe(stream);
+            stream.unpipe(process.stdout);
+        }
+        return stream;
+    }
+    async followProgress(stream) {
+        let isEnded = false, line = 0;
+        const mapLines = {};
+        return new Promise((resolve, reject) => {
+            const handleEnd = () => {
+                if (!isEnded) {
+                    resolve();
+                }
+                isEnded = true;
+            };
+            stream.on("data", (chunk) => {
+                const text = chunk.toString().replace(/}\s*\{/g, "},{"), items = JSON.parse(`[${text}]`);
+                for (const item of items) {
+                    if (item.id === "moby.buildkit.trace") {
+                    }
+                    if (item.stream) {
+                        process.stdout.write(`${item.stream}`);
+                        line += item.stream.split("\n").length - 1;
+                    }
+                    else if (item.id) {
+                        const { id, status, processDetail: { current, total, } = {} } = item;
+                        if (typeof mapLines[id] === "undefined") {
+                            mapLines[id] = line;
+                        }
+                        const targetLine = typeof mapLines[id] !== "undefined"
+                            ? mapLines[id]
+                            : line;
+                        const dy = line - targetLine;
+                        if (dy > 0) {
+                            process.stdout.write("\x1b[s");
+                            process.stdout.write(`\x1b[${dy}A`);
+                        }
+                        process.stdout.write("\x1b[2K");
+                        let str = `${id}: ${status}\n`;
+                        if (status === "Downloading") {
+                            const width = process.stdout.columns;
+                            const sizeWidth = 19, totalWidth = width - id.length - status.length - sizeWidth - 7, currentWidth = Math.floor(totalWidth * (current / total)), formatSize = `${(0, formatSizeUnits_1.formatSizeUnits)(current)}/${(0, formatSizeUnits_1.formatSizeUnits)(total)}`;
+                            str = `${id}: ${status} [${"█".repeat(currentWidth)}${"░".repeat(totalWidth - currentWidth)}] ${formatSize}\n`;
+                        }
+                        process.stdout.write(str);
+                        if (dy > 0) {
+                            process.stdout.write("\x1b[u");
+                        }
+                        else {
+                            line++;
+                        }
+                    }
+                    else if (typeof item.aux === "object") {
+                        const str = `auxID: ${item.aux.ID}`;
+                        process.stdout.write(`${str}\n`);
+                        line += Math.ceil(str.length / process.stdout.columns);
+                    }
+                    else if (item.status) {
+                        process.stdout.write(`${item.status}\n`);
+                        line += Math.ceil(item.status.length / process.stdout.columns);
+                    }
+                    else {
+                        console.info("Unexpected data", item);
+                    }
+                }
+            });
+            stream.on("end", handleEnd);
+            stream.on("close", handleEnd);
+            stream.on("error", (err) => {
+                reject(err);
+            });
+        });
+    }
+};
+exports.ModemService = ModemService;
+exports.ModemService = ModemService = __decorate([
+    (0, core_1.Injectable)("MODEM_SERVICE"),
+    __metadata("design:paramtypes", [ProtoService_1.ProtoService])
+], ModemService);

package/lib/modules/docker/services/ProtoService.d.ts

@@ -0,0 +1,6 @@
+import { Type, Root } from "protobufjs";
+export declare class ProtoService {
+    protected _root?: Root;
+    get root(): Root;
+    lookupType(path: string): Type;
+}

package/lib/modules/docker/services/ProtoService.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProtoService = void 0;
+const protobufjs_1 = require("protobufjs");
+const env_1 = require("../../../env");
+class ProtoService {
+    get root() {
+        if (!this._root) {
+            this._root = (0, protobufjs_1.loadSync)([
+                `${env_1.ROOT_DIR}/proto/solver/pb/ops.proto`,
+                `${env_1.ROOT_DIR}/proto/buildkit.proto`
+            ]);
+        }
+        return this._root;
+    }
+    lookupType(path) {
+        return this.root.lookupType(path);
+    }
+}
+exports.ProtoService = ProtoService;

package/lib/modules/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./docker";
+export * from "./keystore";
+export * from "./proxy";

package/lib/{plugins → modules}/index.js

@@ -14,6 +14,6 @@ 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("./elastic-search"), exports);
-__exportStar(require("./proxmox"), exports);
-__exportStar(require("./MongodbPlugin"), exports);
+__exportStar(require("./docker"), exports);
+__exportStar(require("./keystore"), exports);
+__exportStar(require("./proxy"), exports);

package/lib/modules/keystore/controllers/KeystoreController.d.ts

@@ -0,0 +1,11 @@
+import { AppConfigService } from "../../../services/AppConfigService";
+import { KeystoreService } from "../services/KeystoreService";
+export declare class KeystoreController {
+    protected readonly appConfigService: AppConfigService;
+    protected readonly keystoreService: KeystoreService;
+    constructor(appConfigService: AppConfigService, keystoreService: KeystoreService);
+    init(provider?: string): Promise<void>;
+    add(name?: string, provider?: string): Promise<void>;
+    inspect(name?: string, provider?: string): Promise<string | undefined>;
+    delete(name?: string, provider?: string): Promise<void>;
+}

package/lib/modules/keystore/controllers/KeystoreController.js

@@ -0,0 +1,106 @@
+"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);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KeystoreController = void 0;
+const core_1 = require("@wocker/core");
+const utils_1 = require("@wocker/utils");
+const AppConfigService_1 = require("../../../services/AppConfigService");
+const KeystoreService_1 = require("../services/KeystoreService");
+let KeystoreController = class KeystoreController {
+    constructor(appConfigService, keystoreService) {
+        this.appConfigService = appConfigService;
+        this.keystoreService = keystoreService;
+    }
+    async init(provider) {
+        if (!provider) {
+            provider = await (0, utils_1.promptSelect)({
+                message: "Keystore provider",
+                type: "text",
+                options: ["file", "keytar"]
+            });
+        }
+        if (!this.keystoreService.hasProvider(provider)) {
+            return;
+        }
+        this.appConfigService.config.keystore = provider;
+        this.appConfigService.save();
+    }
+    async add(name, provider) {
+        const value = await (0, utils_1.promptInput)({
+            message: "Secret value",
+            type: "password"
+        });
+        await this.keystoreService.provider(provider).set(name, value);
+    }
+    async inspect(name, provider) {
+        return this.keystoreService.provider(provider).get(name);
+    }
+    async delete(name, provider) {
+        await this.keystoreService.provider(provider).delete(name);
+    }
+};
+exports.KeystoreController = KeystoreController;
+__decorate([
+    (0, core_1.Command)("keystore:init"),
+    __param(0, (0, core_1.Option)("provider", {
+        type: "string",
+        description: "Keystore provider name"
+    })),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", Promise)
+], KeystoreController.prototype, "init", null);
+__decorate([
+    (0, core_1.Command)("secret:create [name]"),
+    (0, core_1.Description)("Adds secret value to keystore"),
+    __param(0, (0, core_1.Param)("name")),
+    __param(1, (0, core_1.Option)("provider", {
+        alias: "p",
+        type: "string",
+        description: "Provider name"
+    })),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, String]),
+    __metadata("design:returntype", Promise)
+], KeystoreController.prototype, "add", null);
+__decorate([
+    (0, core_1.Command)("secret:inspect [name]"),
+    __param(0, (0, core_1.Param)("name")),
+    __param(1, (0, core_1.Option)("provider", {
+        type: "string",
+        alias: "p"
+    })),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, String]),
+    __metadata("design:returntype", Promise)
+], KeystoreController.prototype, "inspect", null);
+__decorate([
+    (0, core_1.Command)("secret:rm [name]"),
+    (0, core_1.Description)("Removes secret value from keystore"),
+    __param(0, (0, core_1.Param)("name")),
+    __param(1, (0, core_1.Option)("provider", {
+        type: "string",
+        alias: "p",
+        description: "Provider name"
+    })),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, String]),
+    __metadata("design:returntype", Promise)
+], KeystoreController.prototype, "delete", null);
+exports.KeystoreController = KeystoreController = __decorate([
+    (0, core_1.Controller)(),
+    (0, core_1.Description)("Keystore commands"),
+    __metadata("design:paramtypes", [AppConfigService_1.AppConfigService,
+        KeystoreService_1.KeystoreService])
+], KeystoreController);

package/lib/modules/keystore/index.d.ts

@@ -0,0 +1,4 @@
+import { KeystoreService } from "./services/KeystoreService";
+export declare class KeystoreModule {
+}
+export { KeystoreService };

package/lib/{plugins/elastic-search → modules/keystore}/index.js

@@ -6,17 +6,24 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ElasticSearchPlugin = void 0;
+exports.KeystoreService = exports.KeystoreModule = void 0;
 const core_1 = require("@wocker/core");
-const ElasticSearchController_1 = require("./controllers/ElasticSearchController");
-let ElasticSearchPlugin = class ElasticSearchPlugin {
+const KeystoreController_1 = require("./controllers/KeystoreController");
+const KeystoreService_1 = require("./services/KeystoreService");
+Object.defineProperty(exports, "KeystoreService", { enumerable: true, get: function () { return KeystoreService_1.KeystoreService; } });
+let KeystoreModule = class KeystoreModule {
 };
-exports.ElasticSearchPlugin = ElasticSearchPlugin;
-exports.ElasticSearchPlugin = ElasticSearchPlugin = __decorate([
-    (0, core_1.Plugin)({
-        name: "elastic-search",
+exports.KeystoreModule = KeystoreModule;
+exports.KeystoreModule = KeystoreModule = __decorate([
+    (0, core_1.Module)({
         controllers: [
-            ElasticSearchController_1.ElasticSearchController
+            KeystoreController_1.KeystoreController
+        ],
+        providers: [
+            KeystoreService_1.KeystoreService
+        ],
+        exports: [
+            KeystoreService_1.KeystoreService
         ]
     })
-], ElasticSearchPlugin);
+], KeystoreModule);

package/lib/modules/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/modules/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/modules/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/modules/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/modules/keystore/services/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/modules/keystore/services/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/modules/keystore/types/FileKeystore.d.ts

@@ -0,0 +1,17 @@
+type Secrets = Record<string, string>;
+type Props = {
+    passwordHash?: string;
+    secrets?: Secrets;
+};
+export declare abstract class FileKeystore {
+    passwordHash?: string;
+    protected secrets: Secrets;
+    constructor(data: Props);
+    abstract save(): void;
+    get(key: string): string | undefined;
+    set(key: string, value: string): void;
+    delete(key: string): void;
+    toObject(): {};
+    toString(): string;
+}
+export {};