@wocker/ws 1.0.15 → 1.0.16

package/lib/AppModule.js

@@ -39,9 +39,9 @@ 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) {

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,6 +11,7 @@ export declare class PresetController {
     protected onInit(project: Project): Promise<void>;
     protected onRebuild(project: Project): Promise<void>;
     protected onBeforeStart(project: Project): Promise<void>;
+    init(): Promise<void>;
     add(name: string): Promise<void>;
     delete(name: string, confirm?: boolean): Promise<void>;
     eject(name?: 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();
@@ -149,6 +148,9 @@ let PresetController = class PresetController {
             }
         }
     }
+    async init() {
+        await this.presetService.init();
+    }
     async add(name) {
         await this.presetService.addPreset(name);
     }
@@ -182,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);
@@ -234,6 +236,12 @@ 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")),

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) {

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/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/PresetService.d.ts

@@ -1,14 +1,19 @@
-import { EnvConfig, Preset, Config, PresetProperties, AppConfigService } 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 {
     protected readonly appConfigService: AppConfigService;
-    constructor(appConfigService: AppConfigService);
+    protected readonly logService: LogService;
+    constructor(appConfigService: AppConfigService, logService: LogService);
     protected toObject(config: PresetProperties): Preset;
-    protected getList(): Promise<Config["presets"]>;
+    protected getList(): Promise<AppConfig["presets"]>;
     getImageName(preset: Preset, buildArgs?: EnvConfig): string;
+    init(): Promise<void>;
     get(name: string): Promise<Preset>;
     addPreset(name: string): Promise<void>;
     search(options?: SearchOptions): Promise<Preset[]>;

package/lib/services/PresetService.js

@@ -37,15 +37,19 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PresetService = void 0;
 const core_1 = require("@wocker/core");
+const utils_1 = require("@wocker/utils");
 const md5_1 = __importDefault(require("md5"));
 const axios_1 = __importDefault(require("axios"));
 const unzipper_1 = require("unzipper");
 const Path = __importStar(require("path"));
+const AppConfigService_1 = require("./AppConfigService");
+const LogService_1 = require("./LogService");
 const env_1 = require("../env");
 const makes_1 = require("../makes");
 let PresetService = class PresetService {
-    constructor(appConfigService) {
+    constructor(appConfigService, logService) {
         this.appConfigService = appConfigService;
+        this.logService = logService;
     }
     toObject(config) {
         const _this = this;
@@ -55,24 +59,32 @@ let PresetService = class PresetService {
             }
             async save() {
                 const { source, path, ...rest } = this.toJSON();
-                const config = await _this.appConfigService.getConfig();
+                const config = _this.appConfigService.getConfig();
                 let presetData = config.presets.find((presetData) => {
                     return presetData.name === this.name;
                 });
-                if (!makes_1.FS.existsSync(_this.appConfigService.dataPath("presets", this.name))) {
-                    makes_1.FS.mkdirSync(_this.appConfigService.dataPath("presets", this.name), {
-                        recursive: true
-                    });
+                switch (this.source) {
+                    case core_1.PRESET_SOURCE_EXTERNAL:
+                        const fs = new core_1.FileSystem(this.path);
+                        await fs.writeJSON("config.json", rest);
+                        break;
+                    case core_1.PRESET_SOURCE_GITHUB: {
+                        const fs = new core_1.FileSystem(_this.appConfigService.dataPath("presets", this.name));
+                        if (!fs.exists()) {
+                            fs.mkdir("");
+                        }
+                        await fs.writeJSON("config.json", rest);
+                        break;
+                    }
                 }
-                await makes_1.FS.writeJSON(_this.appConfigService.dataPath("presets", this.name, "config.json"), rest);
                 if (!presetData) {
-                    config.registerPreset(this.name, source);
+                    config.registerPreset(this.name, source, path);
                     await config.save();
                 }
             }
             async delete() {
                 if (this.source === core_1.PRESET_SOURCE_GITHUB) {
-                    const config = await _this.appConfigService.getConfig();
+                    const config = _this.appConfigService.getConfig();
                     await makes_1.FS.rm(_this.appConfigService.dataPath("presets", this.name), {
                         recursive: true
                     });
@@ -84,7 +96,7 @@ let PresetService = class PresetService {
     }
     async getList() {
         const dirs = await makes_1.FS.readdir(env_1.PRESETS_DIR);
-        const { presets } = await this.appConfigService.getConfig();
+        const { presets } = this.appConfigService.getConfig();
         return [
             ...dirs.map((name) => {
                 return {
@@ -93,7 +105,12 @@ let PresetService = class PresetService {
                     path: Path.join(env_1.PRESETS_DIR, name)
                 };
             }),
-            ...presets
+            ...presets.map((item) => {
+                if (item.source === core_1.PRESET_SOURCE_GITHUB) {
+                    item.path = this.appConfigService.dataPath("presets", item.name);
+                }
+                return item;
+            })
         ];
     }
     getImageName(preset, buildArgs = {}) {
@@ -117,6 +134,92 @@ let PresetService = class PresetService {
         }).join("-");
         return `ws-preset-${preset.name}:${version}`;
     }
+    async init() {
+        let preset = await this.searchOne({
+            path: this.appConfigService.pwd()
+        });
+        if (preset) {
+            throw new Error("Preset is already registered");
+        }
+        const fs = new core_1.FileSystem(this.appConfigService.pwd());
+        if (!fs.exists("config.json")) {
+            preset = this.toObject({
+                name: fs.basename(),
+                version: "1.0.0",
+                source: "external",
+                path: this.appConfigService.pwd()
+            });
+            const list = await this.getList();
+            preset.name = await (0, utils_1.promptText)({
+                message: "Preset name:",
+                required: true,
+                validate: async (value) => {
+                    if (!/^[a-z][a-z0-9-_]+$/.test(value || "")) {
+                        return "Invalid name";
+                    }
+                    const presetData = list.find((presetData) => {
+                        return presetData.name === value;
+                    });
+                    if (presetData) {
+                        return "Preset name is already taken";
+                    }
+                    return true;
+                },
+                default: preset.name
+            });
+            preset.version = await (0, utils_1.promptText)({
+                message: "Preset version:",
+                validate: (version) => {
+                    if (!/^[0-9]+\.[0.9]+\.[0-9]+$/.test(version)) {
+                        return "Invalid version";
+                    }
+                    return true;
+                },
+                default: preset.version
+            });
+            preset.type = await (0, utils_1.promptSelect)({
+                message: "Preset type:",
+                options: ["dockerfile", "image"]
+            });
+            switch (preset.type) {
+                case "dockerfile":
+                    const files = await fs.readdirFiles();
+                    const dockerfiles = files.filter((fileName) => {
+                        if (new RegExp("^(.*)\\.dockerfile$").test(fileName)) {
+                            return true;
+                        }
+                        return new RegExp("^Dockerfile(\\..*)?").test(fileName);
+                    });
+                    if (dockerfiles.length === 0) {
+                        throw new Error("No dockerfiles found");
+                    }
+                    preset.dockerfile = await (0, utils_1.promptSelect)({
+                        message: "Preset dockerfile:",
+                        options: dockerfiles
+                    });
+                    break;
+                case "image":
+                    preset.image = await (0, utils_1.promptText)({
+                        message: "Preset image:",
+                        required: true,
+                        validate(value) {
+                            if (!/^[a-z0-9]+(?:[._-][a-z0-9]+)*(?::[a-z0-9]+(?:[._-][a-z0-9]+)*)?$/.test(value)) {
+                                return "Invalid image name";
+                            }
+                            return true;
+                        }
+                    });
+                    break;
+            }
+            console.info(JSON.stringify(preset.toJSON(), null, 4));
+            const confirm = await (0, utils_1.promptConfirm)({
+                message: "Correct?"
+            });
+            if (confirm) {
+                await preset.save();
+            }
+        }
+    }
     async get(name) {
         const list = await this.getList();
         const item = list.find((item) => {
@@ -125,12 +228,6 @@ let PresetService = class PresetService {
         if (!item) {
             throw new Error(`Preset ${name} not found`);
         }
-        if (item.source === core_1.PRESET_SOURCE_GITHUB) {
-            item.path = this.appConfigService.dataPath("presets", item.name);
-        }
-        else if (item.source === core_1.PRESET_SOURCE_INTERNAL) {
-            item.path = Path.join(env_1.PRESETS_DIR, item.name);
-        }
         const config = await makes_1.FS.readJSON(item.path, "config.json");
         return this.toObject({
             ...item,
@@ -180,7 +277,7 @@ let PresetService = class PresetService {
         console.log(preset.version);
     }
     async search(options = {}) {
-        const { name, source } = options;
+        const { name, source, path } = options;
         const presets = [];
         const presetConfigs = await this.getList();
         for (const presetConfig of presetConfigs) {
@@ -190,11 +287,11 @@ let PresetService = class PresetService {
             if (source && source !== presetConfig.source) {
                 continue;
             }
+            if (path && path !== presetConfig.path) {
+                continue;
+            }
             try {
                 const fullConfig = await makes_1.FS.readJSON(presetConfig.path, "config.json");
-                if (!fullConfig.name) {
-                    console.log(presetConfig.name);
-                }
                 const preset = this.toObject({
                     ...presetConfig,
                     ...fullConfig
@@ -202,6 +299,7 @@ let PresetService = class PresetService {
                 presets.push(preset);
             }
             catch (err) {
+                this.logService.error("PresetService.search(", options, ") ->", err.message);
             }
         }
         return presets;
@@ -214,5 +312,6 @@ let PresetService = class PresetService {
 exports.PresetService = PresetService;
 exports.PresetService = PresetService = __decorate([
     (0, core_1.Injectable)(),
-    __metadata("design:paramtypes", [core_1.AppConfigService])
+    __metadata("design:paramtypes", [AppConfigService_1.AppConfigService,
+        LogService_1.LogService])
 ], PresetService);

package/lib/services/ProjectService.d.ts

@@ -1,7 +1,6 @@
 import { Project, ProjectProperties } from "@wocker/core";
 import { DockerService, AppConfigService, AppEventsService } from "../services";
 type SearchParams = Partial<{
-    id: string;
     name: string;
     path: string;
 }>;

package/lib/services/ProjectService.js

@@ -56,7 +56,7 @@ let ProjectService = class ProjectService {
     }
     async get() {
         const project = await this.searchOne({
-            path: this.appConfigService.getPWD()
+            path: this.appConfigService.pwd()
         });
         if (!project) {
             throw new Error("Project not found");
@@ -64,8 +64,13 @@ let ProjectService = class ProjectService {
         return project;
     }
     async getById(id) {
+        const config = this.appConfigService.getConfig();
+        const projectData = config.getProject(id);
         const data = await makes_1.FS.readJSON(this.appConfigService.dataPath("projects", id, "config.json"));
-        return this.fromObject(data);
+        return this.fromObject({
+            ...data,
+            path: projectData.path || projectData.src
+        });
     }
     async cdProject(name) {
         const project = await this.searchOne({
@@ -96,7 +101,7 @@ let ProjectService = class ProjectService {
                     await this.dockerService.buildImage({
                         tag: project.imageName,
                         buildArgs: project.buildArgs,
-                        context: this.appConfigService.getPWD(),
+                        context: this.appConfigService.pwd(),
                         src: project.dockerfile
                     });
                 }
@@ -116,7 +121,10 @@ let ProjectService = class ProjectService {
                 volumes: (project.volumes || []).map((volume) => {
                     const regVolume = /^([^:]+):([^:]+)(?::([^:]+))?$/;
                     const [, source, destination, options] = regVolume.exec(volume);
-                    return `${Path.join(this.appConfigService.getPWD(), source)}:${destination}` + (options ? `:${options}` : "");
+                    if (source.startsWith("/")) {
+                        return volume;
+                    }
+                    return `${Path.join(this.appConfigService.pwd(), source)}:${destination}` + (options ? `:${options}` : "");
                 }),
                 ports: project.ports || []
             });
@@ -145,27 +153,25 @@ let ProjectService = class ProjectService {
         if (!project.id) {
             project.id = project.name;
         }
-        const projectDirPath = this.appConfigService.dataPath("projects", project.id);
         const config = await this.appConfigService.getConfig();
-        const configPath = this.appConfigService.dataPath("projects", project.id, "config.json");
-        if (!makes_1.FS.existsSync(projectDirPath)) {
-            await makes_1.FS.mkdir(projectDirPath, {
-                recursive: true
-            });
+        const fs = new core_1.FileSystem(this.appConfigService.dataPath("projects", project.id));
+        if (!fs.exists()) {
+            fs.mkdir("", { recursive: true });
         }
-        config.setProject(project.id, project.path);
-        await makes_1.FS.writeJSON(configPath, project);
+        const { path, ...rest } = project.toJSON();
+        config.addProject(project.id, project.name, path);
+        await fs.writeJSON("config.json", rest);
         await config.save();
     }
     async search(params = {}) {
-        const { id, name, path } = params;
+        const { name, path } = params;
         const config = await this.appConfigService.getConfig();
         const projects = [];
         for (const projectConfig of config.projects) {
-            if (id && projectConfig.id !== id) {
+            if (name && projectConfig.name !== name) {
                 continue;
             }
-            if (path && projectConfig.src !== path) {
+            if (path && (projectConfig.path || projectConfig.src) !== path) {
                 continue;
             }
             const project = await this.getById(projectConfig.id);

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@wocker/ws",
-    "version": "1.0.15",
+    "version": "1.0.16",
     "author": "Kris Papercut <krispcut@gmail.com>",
     "description": "Docker workspace for web projects",
     "license": "MIT",
@@ -25,7 +25,7 @@
         "lint": "eslint \"**/*.{js,jsx,ts,tsx}\""
     },
     "dependencies": {
-        "@wocker/core": "^1.0.14",
+        "@wocker/core": "1.0.16",
         "@wocker/utils": "^1.0.5",
         "async-mutex": "^0.4.0",
         "axios": "^1.6.7",