@wocker/ws 1.0.14 → 1.0.16

package/lib/AppModule.js

@@ -39,15 +39,15 @@ let AppModule = AppModule_1 = class AppModule {
         const appConfigService = container.getModule(AppModule_1).get(services_1.AppConfigService);
         const logService = container.getModule(AppModule_1).get(services_1.LogService);
         const pluginService = container.getModule(AppModule_1).get(services_1.PluginService);
-        const config = await appConfigService.getConfig();
+        const config = appConfigService.getConfig();
         const imports = [];
-        for (const plugin of config.plugins) {
+        for (const plugin of config.plugins || []) {
             try {
                 const { default: Plugin } = await Promise.resolve(`${plugin}`).then(s => __importStar(require(s)));
                 if (!Plugin) {
                     continue;
                 }
-                const name = Reflect.getMetadata(core_1.MODULE_METADATA.NAME, Plugin);
+                const name = Reflect.getMetadata(core_1.PLUGIN_NAME_METADATA, Plugin);
                 Reflect.defineMetadata(core_1.MODULE_METADATA.PROVIDERS, [
                     ...Reflect.getMetadata(core_1.MODULE_METADATA.PROVIDERS, Plugin) || [],
                     {

package/lib/controllers/DebugController.d.ts

@@ -4,5 +4,8 @@ export declare class DebugController {
     protected readonly logService: LogService;
     constructor(appConfigService: AppConfigService, logService: LogService);
     debug(status: string): Promise<void>;
+    setLog(level: string): Promise<void>;
+    testLog(level: string, args: string[]): Promise<void>;
     debugCompletion(): Promise<string[]>;
+    getLevels(): string[];
 }

package/lib/controllers/DebugController.js

@@ -8,6 +8,9 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 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.DebugController = void 0;
 const core_1 = require("@wocker/core");
@@ -18,27 +21,66 @@ let DebugController = class DebugController {
         this.logService = logService;
     }
     async debug(status) {
-        const config = await this.appConfigService.getConfig();
+        const config = this.appConfigService.getConfig();
         config.debug = status === "on";
         await config.save();
     }
+    async setLog(level) {
+        const validLevels = this.getLevels();
+        if (!validLevels.includes(level)) {
+            throw new Error(`Invalid log level: ${level}. Valid options are ${validLevels.join(', ')}`);
+        }
+        const config = this.appConfigService.getConfig();
+        config.logLevel = level;
+        await config.save();
+    }
+    async testLog(level, args) {
+        this.logService._log(level, ...args);
+    }
     async debugCompletion() {
         return ["on", "off"];
     }
+    getLevels() {
+        return ["debug", "info", "warn", "error"];
+    }
 };
 exports.DebugController = DebugController;
 __decorate([
+    (0, core_1.Command)("debug:<status>"),
     (0, core_1.Command)("debug <status>"),
+    __param(0, (0, core_1.Param)("status")),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [String]),
     __metadata("design:returntype", Promise)
 ], DebugController.prototype, "debug", null);
+__decorate([
+    (0, core_1.Description)("Set the log level (options: debug, log, info, warn, error)"),
+    (0, core_1.Command)("loglevel <level>"),
+    __param(0, (0, core_1.Param)("level")),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", Promise)
+], DebugController.prototype, "setLog", null);
+__decorate([
+    (0, core_1.Command)("log:<level> [...args]"),
+    __param(0, (0, core_1.Param)("level")),
+    __param(1, (0, core_1.Param)("args")),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, Array]),
+    __metadata("design:returntype", Promise)
+], DebugController.prototype, "testLog", null);
 __decorate([
     (0, core_1.Completion)("status"),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", []),
     __metadata("design:returntype", Promise)
 ], DebugController.prototype, "debugCompletion", null);
+__decorate([
+    (0, core_1.Completion)("level"),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Array)
+], DebugController.prototype, "getLevels", null);
 exports.DebugController = DebugController = __decorate([
     (0, core_1.Controller)(),
     __metadata("design:paramtypes", [services_1.AppConfigService,

package/lib/controllers/PresetController.d.ts

@@ -11,7 +11,9 @@ export declare class PresetController {
     protected onInit(project: Project): Promise<void>;
     protected onRebuild(project: Project): Promise<void>;
     protected onBeforeStart(project: Project): Promise<void>;
-    add(preset: string): Promise<void>;
+    init(): Promise<void>;
+    add(name: string): Promise<void>;
+    delete(name: string, confirm?: boolean): Promise<void>;
     eject(name?: string): Promise<void>;
     build(rebuild: boolean, presetName: string): Promise<void>;
 }

package/lib/controllers/PresetController.js

@@ -50,7 +50,6 @@ let PresetController = class PresetController {
         this.projectService = projectService;
         this.presetService = presetService;
         this.dockerService = dockerService;
-        this.appConfigService.registerProjectType("preset", "Preset");
         this.appEventsService.on("project:init", (project) => this.onInit(project));
         this.appEventsService.on("project:beforeStart", (project) => this.onBeforeStart(project));
         this.appEventsService.on("project:rebuild", (project) => this.onRebuild(project));
@@ -62,7 +61,7 @@ let PresetController = class PresetController {
         });
     }
     async onInit(project) {
-        if (project.type !== "preset") {
+        if (project.type !== core_1.PROJECT_TYPE_PRESET) {
             return;
         }
         const presets = await this.presetService.search();
@@ -115,7 +114,7 @@ let PresetController = class PresetController {
         }
     }
     async onRebuild(project) {
-        if (project.type !== "preset") {
+        if (project.type !== core_1.PROJECT_TYPE_PRESET) {
             return;
         }
         const preset = await this.presetService.get(project.preset);
@@ -130,7 +129,7 @@ let PresetController = class PresetController {
         }
     }
     async onBeforeStart(project) {
-        if (project.type !== "preset") {
+        if (project.type !== core_1.PROJECT_TYPE_PRESET) {
             return;
         }
         const preset = await this.presetService.get(project.preset);
@@ -143,13 +142,31 @@ let PresetController = class PresetController {
                         presetName: preset.name
                     },
                     buildArgs: project.buildArgs,
-                    context: Path.join(env_1.PRESETS_DIR, preset.name),
+                    context: preset.path,
                     src: preset.dockerfile
                 });
             }
         }
     }
-    async add(preset) {
+    async init() {
+        await this.presetService.init();
+    }
+    async add(name) {
+        await this.presetService.addPreset(name);
+    }
+    async delete(name, confirm) {
+        const preset = await this.presetService.get(name);
+        if (typeof confirm === "undefined" || confirm === null) {
+            confirm = await (0, utils_2.promptConfirm)({
+                message: `Delete preset ${name}?`,
+                default: false
+            });
+        }
+        if (!confirm) {
+            return;
+        }
+        console.info("Deleting...");
+        await preset.delete();
     }
     async eject(name) {
         if (name) {
@@ -167,7 +184,7 @@ let PresetController = class PresetController {
         if (!confirm) {
             return;
         }
-        const copier = new core_1.FSManager(this.appConfigService.presetPath(preset.name), this.appConfigService.getPWD());
+        const copier = new core_1.FSManager(this.appConfigService.presetPath(preset.name), this.appConfigService.pwd());
         if (preset.dockerfile) {
             if (!copier.destination.exists(preset.dockerfile)) {
                 await copier.copy(preset.dockerfile);
@@ -219,12 +236,30 @@ let PresetController = class PresetController {
     }
 };
 exports.PresetController = PresetController;
+__decorate([
+    (0, core_1.Command)("preset:init"),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], PresetController.prototype, "init", null);
 __decorate([
     (0, core_1.Command)("preset:add <preset>"),
+    __param(0, (0, core_1.Param)("preset")),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [String]),
     __metadata("design:returntype", Promise)
 ], PresetController.prototype, "add", null);
+__decorate([
+    (0, core_1.Command)("preset:delete <preset>"),
+    __param(0, (0, core_1.Param)("preset")),
+    __param(1, (0, core_1.Option)("yes", {
+        alias: "y",
+        description: "Confirm deletion"
+    })),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, Boolean]),
+    __metadata("design:returntype", Promise)
+], PresetController.prototype, "delete", null);
 __decorate([
     (0, core_1.Command)("preset:eject"),
     __param(0, (0, core_1.Option)("name", {

package/lib/controllers/ProjectController.d.ts

@@ -1,3 +1,4 @@
+import { ProjectType } from "@wocker/core";
 import { AppConfigService, AppEventsService, ProjectService, DockerService, LogService } from "../services";
 export declare class ProjectController {
     protected readonly appConfigService: AppConfigService;
@@ -8,7 +9,7 @@ export declare class ProjectController {
     constructor(appConfigService: AppConfigService, appEventsService: AppEventsService, projectService: ProjectService, dockerService: DockerService, logService: LogService);
     protected getProjectNames(): Promise<string[]>;
     getScriptNames(): Promise<string[]>;
-    init(name: string, type: string, preset: string): Promise<void>;
+    init(name: string, type: ProjectType, preset: string): Promise<void>;
     projectList(all: boolean): Promise<string>;
     start(name?: string, detach?: boolean, attach?: boolean, rebuild?: boolean, restart?: boolean): Promise<void>;
     stop(name: string): Promise<void>;

package/lib/controllers/ProjectController.js

@@ -73,13 +73,15 @@ let ProjectController = class ProjectController {
     }
     async init(name, type, preset) {
         let project = await this.projectService.searchOne({
-            path: this.appConfigService.getPWD()
+            path: this.appConfigService.pwd()
         });
+        const fs = new core_1.FileSystem(this.appConfigService.pwd());
         if (!project) {
             project = this.projectService.fromObject({
-                path: this.appConfigService.getPWD()
+                path: this.appConfigService.pwd()
             });
         }
+        project.path = this.appConfigService.pwd();
         if (name) {
             project.name = name;
         }
@@ -97,15 +99,15 @@ let ProjectController = class ProjectController {
         }
         const mapTypes = this.appConfigService.getProjectTypes();
         if (!type || !project.type || !mapTypes[project.type]) {
-            project.type = await (0, utils_1.promptSelect)({
+            project.type = (await (0, utils_1.promptSelect)({
                 message: "Project type:",
                 options: mapTypes,
                 default: project.type
-            });
+            }));
         }
         switch (project.type) {
             case core_1.PROJECT_TYPE_DOCKERFILE: {
-                const files = await makes_1.FS.readdirFiles(this.appConfigService.getPWD());
+                const files = await fs.readdirFiles();
                 const dockerfiles = files.filter((fileName) => {
                     if (new RegExp("^(.*)\\.dockerfile$").test(fileName)) {
                         return true;
@@ -113,28 +115,30 @@ let ProjectController = class ProjectController {
                     return new RegExp("^Dockerfile(\\..*)?").test(fileName);
                 });
                 project.dockerfile = await (0, utils_1.promptSelect)({
+                    message: "Dockerfile:",
                     options: dockerfiles.map((dockerfile) => {
                         return {
                             value: dockerfile
                         };
                     }),
-                    message: "Dockerfile",
                     default: project.dockerfile
                 });
                 break;
             }
             case core_1.PROJECT_TYPE_IMAGE: {
                 project.imageName = await (0, utils_1.promptText)({
-                    message: "Image Name",
+                    message: "Image name:",
+                    required: true,
                     default: project.imageName
                 });
                 break;
             }
-            default:
+            case core_1.PROJECT_TYPE_PRESET:
                 break;
+            default:
+                throw new Error("Invalid project type");
         }
         await this.appEventsService.emit("project:init", project);
-        project.path = this.appConfigService.getPWD();
         await project.save();
     }
     async projectList(all) {
@@ -161,19 +165,18 @@ let ProjectController = class ProjectController {
             await this.projectService.cdProject(name);
         }
         const project = await this.projectService.get();
-        await this.projectService.start(project, rebuild, restart);
+        await this.projectService.start(project, restart, rebuild);
         if (detach) {
             console.info(chalk_1.default.yellow("Warning: Detach option is deprecated"));
         }
         if (attach) {
             const project = await this.projectService.get();
-            const containerName = project.containerName;
-            const container = await this.dockerService.getContainer(containerName);
+            const container = await this.dockerService.getContainer(project.containerName);
             await container.resize({
                 w: process.stdout.columns,
                 h: process.stdout.rows
             });
-            await this.dockerService.attach(containerName);
+            await this.dockerService.attach(project.containerName);
         }
     }
     async stop(name) {
@@ -820,6 +823,7 @@ __decorate([
         type: "boolean",
         alias: "g"
     })),
+    __param(2, (0, core_1.Param)("configs")),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [String, Boolean, Array]),
     __metadata("design:returntype", Promise)

package/lib/controllers/ProxyController.d.ts

@@ -10,7 +10,7 @@ export declare class ProxyController {
     onProjectStart(project: Project): Promise<void>;
     onProjectStop(project: Project): Promise<void>;
     getProjectNames(): Promise<string[]>;
-    init(httpPort: number, httpsPort: number): Promise<void>;
+    init(httpPort?: number, httpsPort?: number): Promise<void>;
     start(restart?: boolean): Promise<void>;
     stop(): Promise<void>;
     logs(): Promise<void>;

package/lib/controllers/ProxyController.js

@@ -49,20 +49,20 @@ let ProxyController = class ProxyController {
     }
     async init(httpPort, httpsPort) {
         const config = await this.appConfigService.getConfig();
-        if (typeof httpPort === "undefined" || isNaN(httpPort)) {
+        if (httpPort === null || typeof httpPort === "undefined" || isNaN(httpPort)) {
             httpPort = await (0, utils_1.promptText)({
                 required: true,
                 message: "Http port:",
-                type: "int",
+                type: "number",
                 default: config.getMeta("PROXY_HTTP_PORT", "80")
             });
         }
         config.setMeta("PROXY_HTTP_PORT", httpPort.toString());
-        if (typeof httpsPort === "undefined" || isNaN(httpsPort)) {
+        if (httpsPort === null || typeof httpsPort === "undefined" || isNaN(httpsPort)) {
             httpsPort = await (0, utils_1.promptText)({
                 required: true,
                 message: "Https port:",
-                type: "int",
+                type: "number",
                 default: config.getMeta("PROXY_HTTPS_PORT", "443")
             });
         }

package/lib/env.d.ts

@@ -4,5 +4,4 @@ export declare const PRESETS_DIR: string;
 export declare const SERVICES_DIR: string;
 export declare const PLUGINS_DIR: string;
 export declare const DATA_DIR: string;
-export declare const MAP_PATH: string;
 export declare const VIRTUAL_HOST_KEY = "VIRTUAL_HOST";

package/lib/env.js

@@ -23,7 +23,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.VIRTUAL_HOST_KEY = exports.MAP_PATH = exports.DATA_DIR = exports.PLUGINS_DIR = exports.SERVICES_DIR = exports.PRESETS_DIR = exports.ROOT_DIR = exports.NODE_ENV = void 0;
+exports.VIRTUAL_HOST_KEY = exports.DATA_DIR = exports.PLUGINS_DIR = exports.SERVICES_DIR = exports.PRESETS_DIR = exports.ROOT_DIR = exports.NODE_ENV = void 0;
 const OS = __importStar(require("os"));
 const Path = __importStar(require("path"));
 exports.NODE_ENV = process.env.NODE_ENV;
@@ -32,5 +32,4 @@ exports.PRESETS_DIR = Path.join(exports.ROOT_DIR, "presets");
 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.MAP_PATH = Path.join(exports.DATA_DIR, "data.json");
 exports.VIRTUAL_HOST_KEY = "VIRTUAL_HOST";

package/lib/plugins/index.d.ts

@@ -1,4 +1,3 @@
 export * from "./ElasticSearchPlugin";
 export * from "./MongodbPlugin";
-export * from "./PageKitePlugin";
 export * from "./ProxmoxPlugin";

package/lib/plugins/index.js

@@ -16,5 +16,4 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./ElasticSearchPlugin"), exports);
 __exportStar(require("./MongodbPlugin"), exports);
-__exportStar(require("./PageKitePlugin"), exports);
 __exportStar(require("./ProxmoxPlugin"), exports);

package/lib/services/AppConfigService.d.ts

@@ -1,18 +1,18 @@
-import { Config, AppConfigService as CoreAppConfigService } from "@wocker/core";
+import { AppConfig, AppConfigService as CoreAppConfigService } from "@wocker/core";
 type TypeMap = {
     [type: string]: string;
 };
 export declare class AppConfigService extends CoreAppConfigService {
-    protected pwd: string;
+    protected _pwd: string;
     protected mapTypes: TypeMap;
     constructor();
+    setPWD(pwd: string): void;
+    getPWD(...parts: string[]): string;
+    pwd(...parts: string[]): string;
     dataPath(...parts: string[]): string;
     pluginsPath(...parts: string[]): string;
     presetPath(...parts: string[]): string;
-    getPWD(): string;
-    setPWD(pwd: string): void;
     getProjectTypes(): TypeMap;
-    registerProjectType(name: string, title?: string): void;
-    protected loadConfig(): Promise<Config>;
+    protected loadConfig(): AppConfig;
 }
 export {};

package/lib/services/AppConfigService.js

@@ -36,15 +36,24 @@ exports.AppConfigService = void 0;
 const core_1 = require("@wocker/core");
 const Path = __importStar(require("path"));
 const env_1 = require("../env");
-const makes_1 = require("../makes");
 let AppConfigService = class AppConfigService extends core_1.AppConfigService {
     constructor() {
         super();
         this.mapTypes = {
-            image: "Image",
-            dockerfile: "Dockerfile"
+            [core_1.PROJECT_TYPE_IMAGE]: "Image",
+            [core_1.PROJECT_TYPE_DOCKERFILE]: "Dockerfile",
+            [core_1.PROJECT_TYPE_PRESET]: "Preset"
         };
-        this.pwd = (process.cwd() || process.env.PWD);
+        this._pwd = (process.cwd() || process.env.PWD);
+    }
+    setPWD(pwd) {
+        this._pwd = pwd;
+    }
+    getPWD(...parts) {
+        return this.pwd(...parts);
+    }
+    pwd(...parts) {
+        return Path.join(this._pwd, ...parts);
     }
     dataPath(...parts) {
         return Path.join(env_1.DATA_DIR, ...parts);
@@ -55,37 +64,43 @@ let AppConfigService = class AppConfigService extends core_1.AppConfigService {
     presetPath(...parts) {
         return Path.join(env_1.PRESETS_DIR, ...parts);
     }
-    getPWD() {
-        return this.pwd;
-    }
-    setPWD(pwd) {
-        this.pwd = pwd;
-    }
     getProjectTypes() {
         return this.mapTypes;
     }
-    registerProjectType(name, title) {
-        this.mapTypes[name] = title || name;
-    }
-    async loadConfig() {
-        const data = makes_1.FS.existsSync(env_1.MAP_PATH)
-            ? await makes_1.FS.readJSON(env_1.MAP_PATH)
-            : {};
-        return new class extends core_1.Config {
+    loadConfig() {
+        const fs = new core_1.FileSystem(env_1.DATA_DIR);
+        let data = {};
+        if (fs.exists("wocker.config.js")) {
+            try {
+                const { config } = require(fs.path("wocker.config.js"));
+                data = config;
+            }
+            catch (err) {
+                if (fs.exists("wocker.json")) {
+                    data = fs.readJSON("wocker.json");
+                }
+            }
+        }
+        else if (fs.exists("wocker.json")) {
+            data = fs.readJSON("wocker.json");
+        }
+        else if (fs.exists("data.json")) {
+            data = fs.readJSON("data.json");
+        }
+        return new class extends core_1.AppConfig {
             constructor(data) {
                 super(data);
             }
-            addPlugin(plugin) {
-                if (!this.plugins) {
-                    this.plugins = [];
+            async save() {
+                if (!fs.exists()) {
+                    fs.mkdir("");
                 }
-                if (this.plugins.includes(plugin)) {
-                    return;
+                const json = JSON.stringify(this.toJson(), null, 4);
+                await fs.writeFile("wocker.config.js", `// Wocker config\nexports.config = ${json};`);
+                await fs.writeJSON("wocker.json", json);
+                if (fs.exists("data.json")) {
+                    await fs.rm("data.json");
                 }
-                this.plugins.push(plugin);
-            }
-            async save() {
-                await makes_1.FS.writeJSON(env_1.MAP_PATH, this.toJson());
             }
         }(data);
     }

package/lib/services/LogService.d.ts

@@ -1,7 +1,9 @@
+import { LogService as CoreLogService } from "@wocker/core";
 import { AppConfigService } from "./AppConfigService";
-export declare class LogService {
+export declare class LogService extends CoreLogService {
     protected readonly appConfigService: AppConfigService;
     constructor(appConfigService: AppConfigService);
+    debug(...data: any[]): void;
     log(...data: any[]): void;
     info(...data: any[]): void;
     warn(...data: any[]): void;

package/lib/services/LogService.js

@@ -17,11 +17,15 @@ const core_1 = require("@wocker/core");
 const format_1 = __importDefault(require("date-fns/format"));
 const makes_1 = require("../makes");
 const AppConfigService_1 = require("./AppConfigService");
-let LogService = class LogService {
+let LogService = class LogService extends core_1.LogService {
     constructor(appConfigService) {
+        super();
         this.appConfigService = appConfigService;
         makes_1.Logger.install(this);
     }
+    debug(...data) {
+        this._log("debug", ...data);
+    }
     log(...data) {
         this._log("log", ...data);
     }
@@ -35,6 +39,10 @@ let LogService = class LogService {
         this._log("error", ...data);
     }
     _log(type, ...data) {
+        const config = this.appConfigService.getConfig();
+        if (type === "debug" && !config.debug) {
+            return;
+        }
         const time = (0, format_1.default)(new Date(), "yyyy-MM-dd hh:mm:ss");
         const logPath = this.appConfigService.dataPath("ws.log");
         const logData = data.map((item) => {

package/lib/services/PluginService.js

@@ -47,7 +47,7 @@ let PluginService = class PluginService {
     async checkPlugin(pluginName) {
         try {
             const { default: Plugin } = await Promise.resolve(`${pluginName}`).then(s => __importStar(require(s)));
-            const name = Reflect.getMetadata(core_1.MODULE_METADATA.NAME, Plugin);
+            const name = Reflect.getMetadata(core_1.PLUGIN_NAME_METADATA, Plugin);
             if (!name) {
                 console.log("No name");
             }

package/lib/services/PresetService.d.ts

@@ -1,12 +1,21 @@
-import { EnvConfig, Preset } from "@wocker/core";
+import { EnvConfig, Preset, AppConfig, PresetProperties } from "@wocker/core";
+import { AppConfigService } from "./AppConfigService";
+import { LogService } from "./LogService";
 type SearchOptions = Partial<{
     name: string;
+    source: string;
+    path: string;
 }>;
 export declare class PresetService {
-    constructor();
+    protected readonly appConfigService: AppConfigService;
+    protected readonly logService: LogService;
+    constructor(appConfigService: AppConfigService, logService: LogService);
+    protected toObject(config: PresetProperties): Preset;
+    protected getList(): Promise<AppConfig["presets"]>;
     getImageName(preset: Preset, buildArgs?: EnvConfig): string;
-    save(preset: Preset): Promise<void>;
+    init(): Promise<void>;
     get(name: string): Promise<Preset>;
+    addPreset(name: string): Promise<void>;
     search(options?: SearchOptions): Promise<Preset[]>;
     searchOne(options?: SearchOptions): Promise<Preset | null>;
 }