@wocker/ws 1.0.18 → 1.0.19

package/lib/controllers/PresetController.js

@@ -89,7 +89,8 @@ let PresetController = class PresetController {
                     label: "Global usage",
                     value: "global"
                 }
-            ]
+            ],
+            default: project.presetMode
         });
         const preset = await this.presetService.get(project.preset);
         if (!preset) {
@@ -187,9 +188,9 @@ let PresetController = class PresetController {
     }
     async eject(name) {
         if (name) {
-            await this.projectService.cdProject(name);
+            this.projectService.cdProject(name);
         }
-        const project = await this.projectService.get();
+        const project = this.projectService.get();
         const preset = await this.presetService.get(project.preset);
         if (!preset) {
             throw new Error("Preset not found");

package/lib/controllers/ProjectController.d.ts

@@ -1,12 +1,11 @@
 import { ProjectType } from "@wocker/core";
-import { AppConfigService, AppEventsService, ProjectService, DockerService, LogService } from "../services";
+import { AppConfigService, AppEventsService, ProjectService, DockerService } from "../services";
 export declare class ProjectController {
     protected readonly appConfigService: AppConfigService;
     protected readonly appEventsService: AppEventsService;
     protected readonly projectService: ProjectService;
     protected readonly dockerService: DockerService;
-    protected readonly logService: LogService;
-    constructor(appConfigService: AppConfigService, appEventsService: AppEventsService, projectService: ProjectService, dockerService: DockerService, logService: LogService);
+    constructor(appConfigService: AppConfigService, appEventsService: AppEventsService, projectService: ProjectService, dockerService: DockerService);
     protected getProjectNames(): Promise<string[]>;
     getScriptNames(): Promise<string[]>;
     init(name: string, type: ProjectType): Promise<void>;
@@ -36,8 +35,8 @@ export declare class ProjectController {
     extraHostList(name?: string): Promise<string>;
     addExtraHost(extraHost: string, extraDomain: string, name?: string): Promise<void>;
     removeExtraHost(extraHost: string, name?: string): Promise<void>;
-    logs(name?: string, global?: boolean, detach?: boolean, follow?: boolean): Promise<void>;
+    attach(name?: string): Promise<void>;
     exec(name?: string, command?: string[]): Promise<void>;
     run(name: string, script: string, args?: string[]): Promise<void>;
-    attach(name?: string): Promise<void>;
+    logs(name?: string, global?: boolean, detach?: boolean, follow?: boolean): Promise<void>;
 }

package/lib/controllers/ProjectController.js

@@ -48,22 +48,21 @@ const async_mutex_1 = require("async-mutex");
 const makes_1 = require("../makes");
 const services_1 = require("../services");
 let ProjectController = class ProjectController {
-    constructor(appConfigService, appEventsService, projectService, dockerService, logService) {
+    constructor(appConfigService, appEventsService, projectService, dockerService) {
         this.appConfigService = appConfigService;
         this.appEventsService = appEventsService;
         this.projectService = projectService;
         this.dockerService = dockerService;
-        this.logService = logService;
     }
     async getProjectNames() {
-        const projects = await this.projectService.search();
+        const projects = this.projectService.search();
         return projects.map((project) => {
             return project.name;
         });
     }
     async getScriptNames() {
         try {
-            const project = await this.projectService.get();
+            const project = this.projectService.get();
             return Object.keys(project.scripts);
         }
         catch (err) {
@@ -71,7 +70,7 @@ let ProjectController = class ProjectController {
         }
     }
     async init(name, type) {
-        let project = await this.projectService.searchOne({
+        let project = this.projectService.searchOne({
             path: this.appConfigService.pwd()
         });
         const fs = new core_1.FileSystem(this.appConfigService.pwd());
@@ -148,7 +147,7 @@ let ProjectController = class ProjectController {
             head: ["Name", "Type", "Status"],
             colAligns: ["left", "center", "center"]
         });
-        const projects = await this.projectService.search({});
+        const projects = this.projectService.search({});
         for (const project of projects) {
             const container = await this.dockerService.getContainer(project.containerName);
             if (!container) {
@@ -163,36 +162,27 @@ let ProjectController = class ProjectController {
         return table.toString();
     }
     async start(name, detach, attach, rebuild, restart) {
-        if (name) {
-            await this.projectService.cdProject(name);
-        }
-        const project = await this.projectService.get();
+        const project = this.projectService.get(name);
         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 container = await this.dockerService.getContainer(project.containerName);
-            await container.resize({
-                w: process.stdout.columns,
-                h: process.stdout.rows
-            });
             await this.dockerService.attach(project.containerName);
         }
+        if (detach) {
+            console.info(chalk_1.default.yellow("Warning: Detach option is deprecated"));
+        }
     }
     async stop(name) {
         if (name) {
-            await this.projectService.cdProject(name);
+            this.projectService.cdProject(name);
         }
-        const project = await this.projectService.get();
+        const project = this.projectService.get();
         await this.projectService.stop(project);
     }
     async domains(name) {
         if (name) {
-            await this.projectService.cdProject(name);
+            this.projectService.cdProject(name);
         }
-        const project = await this.projectService.get();
+        const project = this.projectService.get();
         const table = new cli_table3_1.default({
             head: [chalk_1.default.yellow("Domain")]
         });
@@ -203,9 +193,9 @@ let ProjectController = class ProjectController {
     }
     async addDomain(name, addDomains) {
         if (name) {
-            await this.projectService.cdProject(name);
+            this.projectService.cdProject(name);
         }
-        const project = await this.projectService.get();
+        const project = this.projectService.get();
         for (const domain of addDomains) {
             project.addDomain(domain);
         }
@@ -213,9 +203,9 @@ let ProjectController = class ProjectController {
     }
     async setDomains(name, domains) {
         if (name) {
-            await this.projectService.cdProject(name);
+            this.projectService.cdProject(name);
         }
-        const project = await this.projectService.get();
+        const project = this.projectService.get();
         project.clearDomains();
         for (const domain of domains) {
             project.addDomain(domain);
@@ -224,9 +214,9 @@ let ProjectController = class ProjectController {
     }
     async removeDomain(name, removeDomains) {
         if (name) {
-            await this.projectService.cdProject(name);
+            this.projectService.cdProject(name);
         }
-        const project = await this.projectService.get();
+        const project = this.projectService.get();
         for (const domain of removeDomains) {
             project.removeDomain(domain);
         }
@@ -234,17 +224,17 @@ let ProjectController = class ProjectController {
     }
     async clearDomain(name) {
         if (name) {
-            await this.projectService.cdProject(name);
+            this.projectService.cdProject(name);
         }
-        const project = await this.projectService.get();
+        const project = this.projectService.get();
         project.clearDomains();
         await project.save();
     }
     async ports(name) {
         if (name) {
-            await this.projectService.cdProject(name);
+            this.projectService.cdProject(name);
         }
-        const project = await this.projectService.get();
+        const project = this.projectService.get();
         const table = new cli_table3_1.default({
             head: ["Ports"]
         });
@@ -255,25 +245,25 @@ let ProjectController = class ProjectController {
     }
     async addPort(hostPort, containerPort, name) {
         if (name) {
-            await this.projectService.cdProject(name);
+            this.projectService.cdProject(name);
         }
-        const project = await this.projectService.get();
+        const project = this.projectService.get();
         project.linkPort(parseInt(hostPort), parseInt(containerPort));
         await project.save();
     }
     async removePort(hostPort, containerPort, name) {
         if (name) {
-            await this.projectService.cdProject(name);
+            this.projectService.cdProject(name);
         }
-        const project = await this.projectService.get();
+        const project = this.projectService.get();
         project.unlinkPort(parseInt(hostPort), parseInt(containerPort));
         await project.save();
     }
     async clearPorts(name) {
         if (name) {
-            await this.projectService.cdProject(name);
+            this.projectService.cdProject(name);
         }
-        const project = await this.projectService.get();
+        const project = this.projectService.get();
         if (project.ports) {
             delete project.ports;
             await project.save();
@@ -281,11 +271,11 @@ let ProjectController = class ProjectController {
     }
     async configList(name, global) {
         if (name) {
-            await this.projectService.cdProject(name);
+            this.projectService.cdProject(name);
         }
         let env;
         if (!global) {
-            const project = await this.projectService.get();
+            const project = this.projectService.get();
             env = project.env || {};
         }
         else {
@@ -302,11 +292,11 @@ let ProjectController = class ProjectController {
     }
     async configGet(name, global, keys) {
         if (name) {
-            await this.projectService.cdProject(name);
+            this.projectService.cdProject(name);
         }
         let config = global
             ? this.appConfigService.getConfig()
-            : await this.projectService.get();
+            : this.projectService.get();
         const table = new cli_table3_1.default({
             head: ["KEY", "VALUE"]
         });
@@ -321,11 +311,11 @@ let ProjectController = class ProjectController {
     }
     async configSet(name, global, variables) {
         if (!global && name) {
-            await this.projectService.cdProject(name);
+            this.projectService.cdProject(name);
         }
         const config = global
             ? this.appConfigService.getConfig()
-            : await this.projectService.get();
+            : this.projectService.get();
         for (const variable of variables) {
             const [key, value] = variable.split("=");
             if (!value) {
@@ -336,7 +326,7 @@ let ProjectController = class ProjectController {
         }
         await config.save();
         if (!global) {
-            const project = await this.projectService.get();
+            const project = this.projectService.get();
             const container = await this.dockerService.getContainer(project.containerName);
             if (container) {
                 await this.projectService.start(project, true);
@@ -353,15 +343,15 @@ let ProjectController = class ProjectController {
             return;
         }
         if (name) {
-            await this.projectService.cdProject(name);
+            this.projectService.cdProject(name);
         }
-        const project = await this.projectService.get();
+        const project = this.projectService.get();
         for (const i in env) {
             project.unsetEnv(i);
         }
         await project.save();
         if (!global) {
-            const project = await this.projectService.get();
+            const project = this.projectService.get();
             const container = await this.dockerService.getContainer(project.containerName);
             if (container) {
                 await this.projectService.start(project, true);
@@ -370,9 +360,9 @@ let ProjectController = class ProjectController {
     }
     async buildArgsList(name) {
         if (name) {
-            await this.projectService.cdProject(name);
+            this.projectService.cdProject(name);
         }
-        const project = await this.projectService.get();
+        const project = this.projectService.get();
         const table = new cli_table3_1.default({
             head: ["KEY", "VALUE"]
         });
@@ -384,9 +374,9 @@ let ProjectController = class ProjectController {
     }
     async buildArgsGet(name, args) {
         if (name) {
-            await this.projectService.cdProject(name);
+            this.projectService.cdProject(name);
         }
-        const project = await this.projectService.get();
+        const project = this.projectService.get();
         const table = new cli_table3_1.default({
             head: ["KEY", "VALUE"]
         });
@@ -400,9 +390,9 @@ let ProjectController = class ProjectController {
     }
     async buildArgsSet(name, args) {
         if (name) {
-            await this.projectService.cdProject(name);
+            this.projectService.cdProject(name);
         }
-        const project = await this.projectService.get();
+        const project = this.projectService.get();
         const buildArgs = args.reduce((env, config) => {
             let [, key = "", value = ""] = config.split(/^([^=]+)=(.*)$/);
             key = key.trim();
@@ -422,9 +412,9 @@ let ProjectController = class ProjectController {
     }
     async buildArgsUnset(name, args) {
         if (name) {
-            await this.projectService.cdProject(name);
+            this.projectService.cdProject(name);
         }
-        const project = await this.projectService.get();
+        const project = this.projectService.get();
         const buildArgs = args.reduce((env, config) => {
             let [, key = "", value = ""] = config.split(/^([^=]+)(?:=(.*))?$/);
             key = key.trim();
@@ -444,9 +434,9 @@ let ProjectController = class ProjectController {
     }
     async volumeList(name) {
         if (name) {
-            await this.projectService.cdProject(name);
+            this.projectService.cdProject(name);
         }
-        const project = await this.projectService.get();
+        const project = this.projectService.get();
         const table = new cli_table3_1.default({
             head: ["Volume"]
         });
@@ -458,9 +448,9 @@ let ProjectController = class ProjectController {
     }
     async volumeMount(name, volumes) {
         if (name) {
-            await this.projectService.cdProject(name);
+            this.projectService.cdProject(name);
         }
-        const project = await this.projectService.get();
+        const project = this.projectService.get();
         if (Array.isArray(volumes) && volumes.length > 0) {
             project.volumeMount(...volumes);
             await project.save();
@@ -468,9 +458,9 @@ let ProjectController = class ProjectController {
     }
     async volumeUnmount(name, volumes) {
         if (name) {
-            await this.projectService.cdProject(name);
+            this.projectService.cdProject(name);
         }
-        const project = await this.projectService.get();
+        const project = this.projectService.get();
         if (Array.isArray(volumes) && volumes.length > 0) {
             project.volumeUnmount(...volumes);
             await project.save();
@@ -478,9 +468,9 @@ let ProjectController = class ProjectController {
     }
     async extraHostList(name) {
         if (name) {
-            await this.projectService.cdProject(name);
+            this.projectService.cdProject(name);
         }
-        const project = await this.projectService.get();
+        const project = this.projectService.get();
         if (!project.extraHosts) {
             return "No extra hosts found";
         }
@@ -496,20 +486,60 @@ let ProjectController = class ProjectController {
     }
     async addExtraHost(extraHost, extraDomain, name) {
         if (name) {
-            await this.projectService.cdProject(name);
+            this.projectService.cdProject(name);
         }
-        const project = await this.projectService.get();
+        const project = this.projectService.get();
         project.addExtraHost(extraHost, extraDomain);
         await project.save();
     }
     async removeExtraHost(extraHost, name) {
         if (name) {
-            await this.projectService.cdProject(name);
+            this.projectService.cdProject(name);
         }
-        const project = await this.projectService.get();
+        const project = this.projectService.get();
         project.removeExtraHost(extraHost);
         await project.save();
     }
+    async attach(name) {
+        if (name) {
+            this.projectService.cdProject(name);
+        }
+        const project = this.projectService.get();
+        await this.dockerService.attach(project.containerName);
+    }
+    async exec(name, command) {
+        if (name) {
+            this.projectService.cdProject(name);
+        }
+        const project = this.projectService.get();
+        await this.dockerService.exec(project.containerName, command, true);
+    }
+    async run(name, script, args) {
+        if (name) {
+            this.projectService.cdProject(name);
+        }
+        const project = this.projectService.get();
+        if (!project.scripts || !project.scripts[script]) {
+            throw new Error(`Script ${script} not found`);
+        }
+        const container = await this.dockerService.getContainer(project.containerName);
+        if (!container) {
+            throw new Error("The project is not started");
+        }
+        const exec = await container.exec({
+            AttachStdin: true,
+            AttachStdout: true,
+            AttachStderr: true,
+            Tty: process.stdin.isTTY,
+            Cmd: ["bash", "-i", "-c", [project.scripts[script], ...args || []].join(" ")]
+        });
+        const stream = await exec.start({
+            hijack: true,
+            stdin: true,
+            Tty: process.stdin.isTTY
+        });
+        await this.dockerService.attachStream(stream);
+    }
     async logs(name, global, detach, follow) {
         if (global) {
             const logFilepath = this.appConfigService.dataPath("ws.log");
@@ -562,30 +592,15 @@ let ProjectController = class ProjectController {
             return;
         }
         if (name) {
-            await this.projectService.cdProject(name);
+            this.projectService.cdProject(name);
         }
-        const project = await this.projectService.get();
+        const project = this.projectService.get();
         const container = await this.dockerService.getContainer(project.containerName);
         if (!container) {
             throw new Error("Project not started");
         }
         if (!detach) {
-            const stream = await container.logs({
-                stdout: true,
-                stderr: true,
-                follow: true
-            });
-            stream.on("data", (data) => {
-                try {
-                    if (data instanceof Buffer) {
-                        data = (0, utils_1.demuxOutput)(data);
-                    }
-                }
-                catch (err) {
-                    this.logService.error(err.message, err);
-                }
-                process.stdout.write(data);
-            });
+            await this.dockerService.logs(container);
         }
         else {
             let data = await container.logs({
@@ -593,57 +608,9 @@ let ProjectController = class ProjectController {
                 stderr: true,
                 follow: false
             });
-            try {
-                if (data instanceof Buffer) {
-                    data = (0, utils_1.demuxOutput)(data);
-                }
-            }
-            catch (err) {
-                this.logService.error(err.message, err);
-            }
             process.stdout.write(data);
         }
     }
-    async exec(name, command) {
-        if (name) {
-            await this.projectService.cdProject(name);
-        }
-        const project = await this.projectService.get();
-        await this.dockerService.exec(project.containerName, command);
-    }
-    async run(name, script, args) {
-        if (name) {
-            await this.projectService.cdProject(name);
-        }
-        const project = await this.projectService.get();
-        if (!project.scripts || !project.scripts[script]) {
-            throw new Error(`Script ${script} not found`);
-        }
-        const container = await this.dockerService.getContainer(project.containerName);
-        if (!container) {
-            throw new Error("The project is not started");
-        }
-        const exec = await container.exec({
-            Cmd: ["bash", "-i", "-c", [project.scripts[script], ...args || []].join(" ")],
-            AttachStdin: true,
-            AttachStdout: true,
-            AttachStderr: true,
-            Tty: process.stdin.isTTY
-        });
-        const stream = await exec.start({
-            hijack: true,
-            stdin: true,
-            Tty: process.stdin.isTTY
-        });
-        await this.dockerService.attachStream(stream);
-    }
-    async attach(name) {
-        if (name) {
-            await this.projectService.cdProject(name);
-        }
-        const project = await this.projectService.get();
-        await this.dockerService.attach(project.containerName);
-    }
 };
 exports.ProjectController = ProjectController;
 __decorate([
@@ -1019,29 +986,17 @@ __decorate([
     __metadata("design:returntype", Promise)
 ], ProjectController.prototype, "removeExtraHost", null);
 __decorate([
-    (0, core_1.Command)("logs"),
+    (0, core_1.Command)("attach"),
+    (0, core_1.Description)("Attach local standard input, output, and error streams to a running container"),
     __param(0, (0, core_1.Option)("name", {
         type: "string",
         alias: "n",
         description: "The name of the project"
     })),
-    __param(1, (0, core_1.Option)("global", {
-        type: "boolean",
-        alias: "g"
-    })),
-    __param(2, (0, core_1.Option)("detach", {
-        type: "boolean",
-        alias: "d",
-        description: "Detach"
-    })),
-    __param(3, (0, core_1.Option)("follow", {
-        type: "boolean",
-        alias: "f"
-    })),
     __metadata("design:type", Function),
-    __metadata("design:paramtypes", [String, Boolean, Boolean, Boolean]),
+    __metadata("design:paramtypes", [String]),
     __metadata("design:returntype", Promise)
-], ProjectController.prototype, "logs", null);
+], ProjectController.prototype, "attach", null);
 __decorate([
     (0, core_1.Command)("exec [...command]"),
     __param(0, (0, core_1.Option)("name", {
@@ -1067,22 +1022,33 @@ __decorate([
     __metadata("design:returntype", Promise)
 ], ProjectController.prototype, "run", null);
 __decorate([
-    (0, core_1.Command)("attach"),
-    (0, core_1.Description)("Attach local standard input, output, and error streams to a running container"),
+    (0, core_1.Command)("logs"),
     __param(0, (0, core_1.Option)("name", {
         type: "string",
         alias: "n",
         description: "The name of the project"
     })),
+    __param(1, (0, core_1.Option)("global", {
+        type: "boolean",
+        alias: "g"
+    })),
+    __param(2, (0, core_1.Option)("detach", {
+        type: "boolean",
+        alias: "d",
+        description: "Detach"
+    })),
+    __param(3, (0, core_1.Option)("follow", {
+        type: "boolean",
+        alias: "f"
+    })),
     __metadata("design:type", Function),
-    __metadata("design:paramtypes", [String]),
+    __metadata("design:paramtypes", [String, Boolean, Boolean, Boolean]),
     __metadata("design:returntype", Promise)
-], ProjectController.prototype, "attach", null);
+], ProjectController.prototype, "logs", null);
 exports.ProjectController = ProjectController = __decorate([
     (0, core_1.Controller)(),
     __metadata("design:paramtypes", [services_1.AppConfigService,
         services_1.AppEventsService,
         services_1.ProjectService,
-        services_1.DockerService,
-        services_1.LogService])
+        services_1.DockerService])
 ], ProjectController);

package/lib/controllers/ProxyController.d.ts

@@ -9,7 +9,7 @@ export declare class ProxyController {
     constructor(appConfigService: AppConfigService, appEventsService: AppEventsService, projectService: ProjectService, proxyService: ProxyService);
     onProjectStart(project: Project): Promise<void>;
     onProjectStop(project: Project): Promise<void>;
-    getProjectNames(): Promise<string[]>;
+    getProjectNames(): string[];
     init(httpPort?: number, httpsPort?: number): Promise<void>;
     start(restart?: boolean): Promise<void>;
     stop(): Promise<void>;

package/lib/controllers/ProxyController.js

@@ -43,12 +43,12 @@ let ProxyController = class ProxyController {
     }
     async onProjectStop(project) {
     }
-    async getProjectNames() {
-        const projects = await this.projectService.search();
+    getProjectNames() {
+        const projects = this.projectService.search();
         return projects.map((project) => project.name);
     }
     async init(httpPort, httpsPort) {
-        const config = await this.appConfigService.getConfig();
+        const config = this.appConfigService.getConfig();
         if (httpPort === null || typeof httpPort === "undefined" || isNaN(httpPort)) {
             httpPort = await (0, utils_1.promptText)({
                 required: true,
@@ -85,7 +85,7 @@ __decorate([
     (0, core_1.Completion)("name"),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", []),
-    __metadata("design:returntype", Promise)
+    __metadata("design:returntype", Array)
 ], ProxyController.prototype, "getProjectNames", null);
 __decorate([
     (0, core_1.Command)("proxy:init"),

package/lib/env.d.ts

@@ -1,3 +1,4 @@
+export declare const WOCKER_VERSION = "1.0.19";
 export declare const NODE_ENV: string;
 export declare const ROOT_DIR: string;
 export declare const PRESETS_DIR: string;

package/lib/env.js

@@ -23,9 +23,10 @@ var __importStar = (this && this.__importStar) || function (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 = void 0;
+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.NODE_ENV = process.env.NODE_ENV;
 exports.ROOT_DIR = Path.join(__dirname, "..");
 exports.PRESETS_DIR = Path.join(exports.ROOT_DIR, "presets");

package/lib/services/AppConfigService.d.ts

@@ -1,11 +1,14 @@
-import { AppConfig, AppConfigService as CoreAppConfigService } from "@wocker/core";
+import { AppConfig, AppConfigService as CoreAppConfigService, FileSystem } from "@wocker/core";
 type TypeMap = {
     [type: string]: string;
 };
 export declare class AppConfigService extends CoreAppConfigService {
     protected _pwd: string;
+    protected _fs?: FileSystem;
     protected readonly mapTypes: TypeMap;
     constructor();
+    get version(): string;
+    get fs(): FileSystem;
     pwd(...parts: string[]): string;
     setPWD(pwd: string): void;
     dataPath(...parts: string[]): string;

package/lib/services/AppConfigService.js

@@ -46,6 +46,15 @@ let AppConfigService = class AppConfigService extends core_1.AppConfigService {
         };
         this._pwd = (process.cwd() || process.env.PWD);
     }
+    get version() {
+        return env_1.WOCKER_VERSION;
+    }
+    get fs() {
+        if (!this._fs) {
+            this._fs = new core_1.FileSystem(env_1.DATA_DIR);
+        }
+        return this._fs;
+    }
     pwd(...parts) {
         return Path.join(this._pwd, ...parts);
     }
@@ -65,7 +74,7 @@ let AppConfigService = class AppConfigService extends core_1.AppConfigService {
         return this.mapTypes;
     }
     loadConfig() {
-        const fs = new core_1.FileSystem(env_1.DATA_DIR);
+        const fs = this.fs;
         let data = {};
         if (fs.exists("wocker.config.js")) {
             try {

package/lib/services/DockerService.d.ts

@@ -14,11 +14,11 @@ export declare class DockerService {
     removeContainer(name: string): Promise<void>;
     buildImage(params: Params.BuildImage): Promise<void>;
     imageExists(tag: string): Promise<boolean>;
-    imageRm(tag: string): Promise<void>;
+    imageRm(tag: string, force?: boolean): Promise<void>;
     imageLs(options?: Params.ImageList): Promise<Docker.ImageInfo[]>;
     pullImage(tag: string): Promise<void>;
     attach(containerOrName: string | Container): Promise<NodeJS.ReadWriteStream>;
-    logs(name: string): Promise<void>;
-    attachStream(stream: NodeJS.ReadWriteStream): Promise<void>;
+    attachStream(stream: NodeJS.ReadWriteStream): Promise<NodeJS.ReadWriteStream>;
     exec(name: string, args?: string[], tty?: boolean): Promise<import("stream").Duplex>;
+    logs(containerOrName: string | Container): Promise<NodeJS.ReadableStream>;
 }

package/lib/services/DockerService.js

@@ -14,9 +14,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DockerService = void 0;
 const core_1 = require("@wocker/core");
-const utils_1 = require("@wocker/utils");
 const dockerode_1 = __importDefault(require("dockerode"));
-const utils_2 = require("../utils");
+const utils_1 = require("../utils");
 const makes_1 = require("../makes");
 const LogService_1 = require("./LogService");
 let DockerService = class DockerService {
@@ -77,7 +76,7 @@ let DockerService = class DockerService {
             OpenStdin: true,
             StdinOnce: false,
             Entrypoint: entrypoint,
-            Tty: tty,
+            Tty: true,
             Cmd: cmd,
             Env: Object.keys(env).map((key) => {
                 const value = env[key];
@@ -183,7 +182,7 @@ let DockerService = class DockerService {
             }, {}),
             dockerfile: src
         });
-        await (0, utils_2.followProgress)(stream);
+        await (0, utils_1.followProgress)(stream);
     }
     async imageExists(tag) {
         const image = this.docker.getImage(tag);
@@ -195,13 +194,15 @@ let DockerService = class DockerService {
             return false;
         }
     }
-    async imageRm(tag) {
+    async imageRm(tag, force = false) {
         const image = this.docker.getImage(tag);
         const exists = await this.imageExists(tag);
         if (!exists) {
             return;
         }
-        await image.remove();
+        await image.remove({
+            force
+        });
     }
     async imageLs(options) {
         const { tag, reference, labels } = options || {};
@@ -209,7 +210,7 @@ let DockerService = class DockerService {
         if (reference) {
             filters.reference = [
                 ...filters.reference || [],
-                reference
+                ...reference
             ];
         }
         if (tag) {
@@ -234,7 +235,7 @@ let DockerService = class DockerService {
             return;
         }
         const stream = await this.docker.pull(tag);
-        await (0, utils_2.followProgress)(stream);
+        await (0, utils_1.followProgress)(stream);
     }
     async attach(containerOrName) {
         let container = typeof containerOrName === "string"
@@ -244,40 +245,15 @@ let DockerService = class DockerService {
             return;
         }
         const stream = await container.attach({
-            logs: true,
             stream: true,
             hijack: true,
             stdin: true,
             stdout: true,
             stderr: true,
-            detachKeys: "ctrl-c"
-        });
-        process.stdin.resume();
-        process.stdin.setEncoding("utf8");
-        process.stdin.setRawMode(true);
-        process.stdin.pipe(stream);
-        process.stdin.on("data", (data) => {
-            if (data.toString() === "\u0003") {
-                stream.end();
-                setTimeout(() => {
-                    process.exit();
-                }, 5000);
-            }
-        });
-        stream.on("data", (data) => {
-            if (data instanceof Buffer) {
-                try {
-                    data = (0, utils_1.demuxOutput)(data);
-                }
-                catch (err) {
-                    this.logService.error(err.toString(), err.stack);
-                }
-            }
-            process.stdout.write(data);
-        });
-        stream.on("end", async () => {
-            process.exit();
+            logs: true,
+            detachKeys: "ctrl-d"
         });
+        await this.attachStream(stream);
         const handleResize = () => {
             const [width, height] = process.stdout.getWindowSize();
             container.resize({
@@ -289,43 +265,26 @@ let DockerService = class DockerService {
         handleResize();
         return stream;
     }
-    async logs(name) {
-        const container = await this.getContainer(name);
-        if (!container) {
-            return;
-        }
-        const stream = await container.logs({
-            stdout: true,
-            stderr: true,
-            follow: true
-        });
-        stream.on("data", (data) => {
-            process.stdout.write((0, utils_1.demuxOutput)(data));
-        });
-    }
     async attachStream(stream) {
-        process.stdin.resume();
-        process.stdin.setEncoding("utf8");
-        process.stdin.pipe(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);
-        const end = () => {
+        const onEnd = () => {
             process.stdin.pause();
-            process.stdin.unpipe(stream);
             if (process.stdin.isTTY) {
                 process.stdin.setRawMode(false);
             }
+            process.stdin.unpipe(stream);
             stream.unpipe(process.stdout);
         };
-        await new Promise((resolve, reject) => {
-            stream.on("end", end);
-            stream.on("error", end);
-            stream.on("end", resolve);
-            stream.on("error", reject);
-        });
+        stream.on("end", onEnd);
+        stream.on("error", onEnd);
+        return stream;
     }
     async exec(name, args, tty = false) {
         const container = await this.getContainer(name);
@@ -365,6 +324,27 @@ let DockerService = class DockerService {
         }
         return stream;
     }
+    async logs(containerOrName) {
+        const container = typeof containerOrName === "string"
+            ? await this.getContainer(containerOrName)
+            : containerOrName;
+        if (!container) {
+            return;
+        }
+        const stream = await container.logs({
+            stdout: true,
+            stderr: true,
+            follow: true,
+            tail: 4
+        });
+        stream.on("data", (data) => {
+            process.stdout.write(data);
+        });
+        stream.on("error", (data) => {
+            process.stderr.write(data);
+        });
+        return stream;
+    }
 };
 exports.DockerService = DockerService;
 exports.DockerService = DockerService = __decorate([

package/lib/services/ProjectService.d.ts

@@ -10,13 +10,13 @@ declare class ProjectService {
     protected readonly dockerService: DockerService;
     constructor(appConfigService: AppConfigService, appEventsService: AppEventsService, dockerService: DockerService);
     fromObject(data: Partial<ProjectProperties>): Project;
-    get(): Promise<Project>;
-    getById(id: string): Promise<Project>;
-    cdProject(name: string): Promise<void>;
+    get(name?: string): Project;
+    getById(id: string): Project;
+    cdProject(name: string): void;
     start(project: Project, restart?: boolean, rebuild?: boolean): Promise<void>;
     stop(project: Project): Promise<void>;
     save(project: Project): Promise<void>;
-    search(params?: Partial<SearchParams>): Promise<Project[]>;
-    searchOne(params?: Partial<SearchParams>): Promise<Project | null>;
+    search(params?: Partial<SearchParams>): Project[];
+    searchOne(params?: Partial<SearchParams>): Project | null;
 }
 export { ProjectService };

package/lib/services/ProjectService.js

@@ -11,7 +11,6 @@ var __metadata = (this && this.__metadata) || function (k, v) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ProjectService = void 0;
 const core_1 = require("@wocker/core");
-const makes_1 = require("../makes");
 const services_1 = require("../services");
 let ProjectService = class ProjectService {
     constructor(appConfigService, appEventsService, dockerService) {
@@ -30,26 +29,31 @@ let ProjectService = class ProjectService {
             }
         }(data);
     }
-    async get() {
-        const project = await this.searchOne({
-            path: this.appConfigService.pwd()
-        });
+    get(name) {
+        const project = name
+            ? this.searchOne({ name })
+            : this.searchOne({
+                path: this.appConfigService.pwd()
+            });
         if (!project) {
             throw new Error("Project not found");
         }
+        if (name) {
+            this.appConfigService.setPWD(project.path);
+        }
         return project;
     }
-    async getById(id) {
+    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"));
+        const data = this.appConfigService.fs.readJSON("projects", id, "config.json");
         return this.fromObject({
             ...data,
             path: projectData.path || projectData.src
         });
     }
-    async cdProject(name) {
-        const project = await this.searchOne({
+    cdProject(name) {
+        const project = this.searchOne({
             name
         });
         if (!project) {
@@ -132,17 +136,16 @@ let ProjectService = class ProjectService {
         if (!project.id) {
             project.id = project.name;
         }
-        const config = await this.appConfigService.getConfig();
-        const fs = new core_1.FileSystem(this.appConfigService.dataPath("projects", project.id));
-        if (!fs.exists()) {
-            fs.mkdir("", { recursive: true });
+        const config = this.appConfigService.getConfig();
+        if (!this.appConfigService.fs.exists(`projects/${project.id}`)) {
+            this.appConfigService.fs.mkdir(`projects/${project.id}`, { recursive: true });
         }
         const { path, ...rest } = project.toJSON();
         config.addProject(project.id, project.name, path);
-        await fs.writeJSON("config.json", rest);
+        this.appConfigService.fs.writeJSON(`projects/${project.id}/config.json`, rest);
         await config.save();
     }
-    async search(params = {}) {
+    search(params = {}) {
         const { name, path } = params;
         const config = this.appConfigService.getConfig();
         const projects = [];
@@ -153,7 +156,7 @@ let ProjectService = class ProjectService {
             if (path && (projectConfig.path || projectConfig.src) !== path) {
                 continue;
             }
-            const project = await this.getById(projectConfig.id);
+            const project = this.getById(projectConfig.id);
             if (name && project.name !== name) {
                 continue;
             }
@@ -161,8 +164,8 @@ let ProjectService = class ProjectService {
         }
         return projects;
     }
-    async searchOne(params = {}) {
-        const [project] = await this.search(params);
+    searchOne(params = {}) {
+        const [project] = this.search(params);
         return project || null;
     }
 };

package/lib/services/ProxyService.js

@@ -20,7 +20,7 @@ let ProxyService = class ProxyService {
         this.appConfigService = appConfigService;
         this.dockerService = dockerService;
         this.containerName = "proxy.workspace";
-        this.imageName = "nginxproxy/nginx-proxy";
+        this.imageName = "nginxproxy/nginx-proxy:latest";
     }
     async init(project) {
         const appPort = await (0, utils_1.promptText)({

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@wocker/ws",
-    "version": "1.0.18",
+    "version": "1.0.19",
     "author": "Kris Papercut <krispcut@gmail.com>",
     "description": "Docker workspace for web projects",
     "license": "MIT",
@@ -21,11 +21,10 @@
         "prepare": "npm run build",
         "start": "npm run watch",
         "build": "tsc",
-        "watch": "tsc -w",
-        "lint": "eslint \"**/*.{js,jsx,ts,tsx}\""
+        "watch": "tsc -w"
     },
     "dependencies": {
-        "@wocker/core": "1.0.18",
+        "@wocker/core": "1.0.19",
         "@wocker/utils": "^1.0.7",
         "async-mutex": "^0.4.0",
         "axios": "^1.6.7",
@@ -50,12 +49,6 @@
         "@types/node": "^20.11.16",
         "@types/readable-stream": "^2.3.15",
         "@types/unzipper": "^0.10.10",
-        "@typescript-eslint/eslint-plugin": "^6.5.0",
-        "@typescript-eslint/parser": "^6.5.0",
-        "eslint": "^8.48.0",
-        "eslint-plugin-import": "^2.28.1",
-        "eslint-plugin-node": "^11.1.0",
-        "eslint-webpack-plugin": "^3.1.0",
-        "typescript": "^5.5.4"
+        "typescript": "^5.6.3"
     }
 }