@wocker/ws 1.0.31-beta.0 → 1.0.32-beta.0

package/lib/modules/project/controllers/ProjectController.js

@@ -284,6 +284,7 @@ let ProjectController = class ProjectController {
             project.addDomain(domain);
         }
         project.save();
+        await this.eventService.emit("project:add-domain", project, addDomains);
     }
     async setDomains(domains, name) {
         const project = this.projectService.get(name);

package/lib/modules/project/repositories/ProjectRepository.d.ts

@@ -1,10 +1,13 @@
-import { AppConfigService, AppFileSystemService, Project, ProjectRepository as CoreProjectRepository, ProjectRepositorySearchParams as SearchParams } from "@wocker/core";
+import { AppConfigService, AppFileSystemService, Project, ProjectRepository as CoreProjectRepository } from "@wocker/core";
 export declare class ProjectRepository extends CoreProjectRepository {
     protected readonly appConfigService: AppConfigService;
     protected readonly fs: AppFileSystemService;
     constructor(appConfigService: AppConfigService, fs: AppFileSystemService);
     getByName(name: string): Project;
     save(project: Project): void;
-    search(params?: SearchParams): Project[];
-    searchOne(params?: SearchParams): Project | null;
+    search(params?: ProjectRepository.SearchParams): Project[];
+    searchOne(params?: ProjectRepository.SearchParams): Project | null;
+}
+export declare namespace ProjectRepository {
+    type SearchParams = CoreProjectRepository.SearchParams;
 }

package/lib/modules/project/services/ProjectService.d.ts

@@ -1,4 +1,4 @@
-import { AppConfigService, EventService, LogService, ProcessService, Project, ProjectService as CoreProjectService, ProjectRepositorySearchParams as SearchParams } from "@wocker/core";
+import { AppConfigService, EventService, LogService, ProcessService, Project, ProjectService as CoreProjectService } from "@wocker/core";
 import { ComposeService, DockerService } from "@wocker/docker-module";
 import { PresetRepository, PresetService } from "../../preset";
 import { ProjectRepository } from "../repositories/ProjectRepository";
@@ -14,8 +14,8 @@ export declare class ProjectService extends CoreProjectService {
     protected readonly logService: LogService;
     constructor(appConfigService: AppConfigService, processService: ProcessService, eventService: EventService, dockerService: DockerService, composeService: ComposeService, projectRepository: ProjectRepository, presetService: PresetService, presetRepository: PresetRepository, logService: LogService);
     get(name?: string): Project;
-    search(params?: SearchParams): Project[];
-    searchOne(params?: SearchParams): Project | null;
+    search(params?: ProjectRepository.SearchParams): Project[];
+    searchOne(params?: ProjectRepository.SearchParams): Project | null;
     save(project: Project): void;
     start(project: Project, restart?: boolean, rebuild?: boolean, attach?: boolean): Promise<void>;
     stop(project: Project): Promise<void>;

package/lib/modules/proxy/controllers/CertController.js

@@ -48,12 +48,14 @@ let CertController = class CertController {
 exports.CertController = CertController;
 __decorate([
     (0, core_1.Command)("certs"),
+    (0, core_1.Description)("Show certs"),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", []),
     __metadata("design:returntype", Promise)
 ], CertController.prototype, "list", null);
 __decorate([
     (0, core_1.Command)("cert:generate [cert]"),
+    (0, core_1.Description)("Generate cert"),
     __param(0, (0, core_1.Param)("cert")),
     __param(1, (0, core_1.Option)("dns", {
         type: "string",
@@ -66,6 +68,7 @@ __decorate([
 ], CertController.prototype, "createCert", null);
 __decorate([
     (0, core_1.Command)("cert:use [cert]"),
+    (0, core_1.Description)("Use cert"),
     __param(0, (0, core_1.Param)("cert")),
     __param(1, (0, core_1.Option)("name", {
         type: "string",
@@ -78,6 +81,7 @@ __decorate([
 ], CertController.prototype, "use", null);
 __decorate([
     (0, core_1.Command)("cert:remove"),
+    (0, core_1.Description)("Remove cert"),
     __param(0, (0, core_1.Option)("name", {
         type: "string",
         alias: "n",
@@ -89,6 +93,7 @@ __decorate([
 ], CertController.prototype, "remove", null);
 __decorate([
     (0, core_1.Command)("cert:delete <cert>"),
+    (0, core_1.Description)("Delete cert"),
     __param(0, (0, core_1.Param)("cert")),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [String]),
@@ -109,6 +114,7 @@ __decorate([
 ], CertController.prototype, "existsOtherNames", null);
 exports.CertController = CertController = __decorate([
     (0, core_1.Controller)(),
+    (0, core_1.Description)("Cert commands"),
     __metadata("design:paramtypes", [project_1.ProjectService,
         CertService_1.CertService])
 ], CertController);

package/lib/modules/proxy/controllers/HttpAuthController.d.ts

@@ -0,0 +1,16 @@
+import { Project } from "@wocker/core";
+import { ProjectService } from "../../project";
+import { HttpAuthService } from "../services/HttpAuthService";
+import { ProxyService } from "../services/ProxyService";
+export declare class HttpAuthController {
+    protected readonly projectService: ProjectService;
+    protected readonly httpAuthService: HttpAuthService;
+    protected readonly proxyService: ProxyService;
+    constructor(projectService: ProjectService, httpAuthService: HttpAuthService, proxyService: ProxyService);
+    onAddDomain(project: Project, ...domains: string[]): Promise<void>;
+    enable(domain?: string): Promise<void>;
+    disable(domain?: string): Promise<void>;
+    add(user?: string, password?: string, global?: boolean, algorithm?: HttpAuthService.Algorithm): Promise<void>;
+    remove(user?: string): Promise<void>;
+    clear(): Promise<void>;
+}

package/lib/modules/proxy/controllers/HttpAuthController.js

@@ -0,0 +1,125 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpAuthController = void 0;
+const core_1 = require("@wocker/core");
+const utils_1 = require("@wocker/utils");
+const project_1 = require("../../project");
+const HttpAuthService_1 = require("../services/HttpAuthService");
+const ProxyService_1 = require("../services/ProxyService");
+let HttpAuthController = class HttpAuthController {
+    constructor(projectService, httpAuthService, proxyService) {
+        this.projectService = projectService;
+        this.httpAuthService = httpAuthService;
+        this.proxyService = proxyService;
+    }
+    async onAddDomain(project, ...domains) {
+        console.log("New domains:", domains);
+    }
+    async enable(domain) {
+        await this.httpAuthService.enableForProject(this.projectService.get(), domain);
+        await this.proxyService.start(true);
+    }
+    async disable(domain) {
+        await this.httpAuthService.disableForProject(this.projectService.get(), domain);
+        await this.proxyService.start(true);
+    }
+    async add(user, password, global, algorithm) {
+        if (!user) {
+            user = await (0, utils_1.promptInput)({
+                required: true,
+                message: "User",
+                type: "text"
+            });
+        }
+        if (!password) {
+            password = await (0, utils_1.promptInput)({
+                required: true,
+                message: "Password",
+                type: "password"
+            });
+        }
+        if (global) {
+            await this.httpAuthService.addForGlobal(user, password, algorithm);
+        }
+        else {
+            await this.httpAuthService.addForProject(this.projectService.get(), user, password, algorithm);
+        }
+        await this.proxyService.start(true);
+    }
+    async remove(user) {
+        await this.httpAuthService.removeForProject(this.projectService.get(), user);
+    }
+    async clear() {
+    }
+};
+exports.HttpAuthController = HttpAuthController;
+__decorate([
+    (0, core_1.Event)("project:add-domain"),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [core_1.Project, String]),
+    __metadata("design:returntype", Promise)
+], HttpAuthController.prototype, "onAddDomain", null);
+__decorate([
+    (0, core_1.Command)("http-auth:enable"),
+    __param(0, (0, core_1.Option)("domain", "d")),
+    __param(0, (0, core_1.Description)("Domain to apply authentication to.")),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", Promise)
+], HttpAuthController.prototype, "enable", null);
+__decorate([
+    (0, core_1.Command)("http-auth:disable"),
+    __param(0, (0, core_1.Option)("domain", "d")),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", Promise)
+], HttpAuthController.prototype, "disable", null);
+__decorate([
+    (0, core_1.Command)("http-auth:add-user"),
+    (0, core_1.Command)("http-auth:add-user [user]"),
+    (0, core_1.Command)("http-auth:add-user [user]:[password]"),
+    (0, core_1.Description)("Add a user for HTTP Basic Auth"),
+    __param(0, (0, core_1.Param)("user")),
+    __param(0, (0, core_1.Description)("Username for Basic Auth. If omitted, you will be prompted.")),
+    __param(1, (0, core_1.Param)("password")),
+    __param(1, (0, core_1.Description)("Password for Basic Auth. If omitted, you will be prompted.")),
+    __param(2, (0, core_1.Option)("global", "g")),
+    __param(2, (0, core_1.Description)("")),
+    __param(3, (0, core_1.Option)("algorithm", "a")),
+    __param(3, (0, core_1.Description)("Password hashing algorithm (e.g. md5, bcrypt, sha1, sha256, sha512).")),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, String, Boolean, String]),
+    __metadata("design:returntype", Promise)
+], HttpAuthController.prototype, "add", null);
+__decorate([
+    (0, core_1.Command)("http-auth:remove [user]"),
+    __param(0, (0, core_1.Param)("user")),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", Promise)
+], HttpAuthController.prototype, "remove", null);
+__decorate([
+    (0, core_1.Command)("http-auth:clear"),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], HttpAuthController.prototype, "clear", null);
+exports.HttpAuthController = HttpAuthController = __decorate([
+    (0, core_1.Controller)(),
+    (0, core_1.Description)("BasicAuth commands"),
+    __metadata("design:paramtypes", [project_1.ProjectService,
+        HttpAuthService_1.HttpAuthService,
+        ProxyService_1.ProxyService])
+], HttpAuthController);

package/lib/modules/proxy/index.js

@@ -13,8 +13,10 @@ exports.CertService = exports.ProxyService = exports.ProxyModule = void 0;
 const core_1 = require("@wocker/core");
 const docker_module_1 = __importDefault(require("@wocker/docker-module"));
 const project_1 = require("../project");
+const HttpAuthController_1 = require("./controllers/HttpAuthController");
 const CertController_1 = require("./controllers/CertController");
 const ProxyController_1 = require("./controllers/ProxyController");
+const HttpAuthService_1 = require("./services/HttpAuthService");
 const CertService_1 = require("./services/CertService");
 Object.defineProperty(exports, "CertService", { enumerable: true, get: function () { return CertService_1.CertService; } });
 const ProxyService_1 = require("./services/ProxyService");
@@ -29,10 +31,12 @@ exports.ProxyModule = ProxyModule = __decorate([
             project_1.ProjectModule
         ],
         controllers: [
+            HttpAuthController_1.HttpAuthController,
             CertController_1.CertController,
             ProxyController_1.ProxyController
         ],
         providers: [
+            HttpAuthService_1.HttpAuthService,
             ProxyService_1.ProxyService,
             CertService_1.CertService
         ],

package/lib/modules/proxy/services/CertService.d.ts

@@ -1,9 +1,6 @@
 import { Project, AppFileSystemService } from "@wocker/core";
 import { DockerService } from "@wocker/docker-module";
 import { ProxyService } from "./ProxyService";
-type CertMap = {
-    [name: string]: string[];
-};
 export declare class CertService {
     protected readonly fs: AppFileSystemService;
     protected readonly proxyService: ProxyService;
@@ -11,9 +8,13 @@ export declare class CertService {
     constructor(fs: AppFileSystemService, proxyService: ProxyService, dockerService: DockerService);
     list(): Promise<string>;
     generate(certName: string, dns: string[]): Promise<void>;
-    getCertsMap(): CertMap;
+    getCertsMap(): CertService.CertMap;
     use(project: Project, name: string): Promise<void>;
     remove(project: Project): Promise<void>;
     delete(name: string): Promise<void>;
 }
-export {};
+export declare namespace CertService {
+    type CertMap = {
+        [name: string]: string[];
+    };
+}

package/lib/modules/proxy/services/CertService.js

@@ -96,8 +96,7 @@ let CertService = class CertService {
     getCertsMap() {
         const files = this.fs.readdir("certs/projects");
         return files.reduce((res, file) => {
-            const ext = Path.extname(file);
-            const name = Path.basename(file, ext);
+            const ext = Path.extname(file), name = Path.basename(file, ext);
             if (!res[name]) {
                 res[name] = [];
             }

package/lib/modules/proxy/services/HttpAuthService.d.ts

@@ -0,0 +1,20 @@
+import { AppFileSystemService, Project, ProcessService } from "@wocker/core";
+import { DockerService } from "@wocker/docker-module";
+import { ProxyService } from "./ProxyService";
+export declare class HttpAuthService {
+    protected readonly processService: ProcessService;
+    protected readonly fs: AppFileSystemService;
+    protected readonly dockerService: DockerService;
+    protected readonly proxyService: ProxyService;
+    constructor(processService: ProcessService, fs: AppFileSystemService, dockerService: DockerService, proxyService: ProxyService);
+    add(path: string, user: string, password: string, algorithm?: HttpAuthService.Algorithm): Promise<void>;
+    addForProject(project: Project, user: string, password: string, algorithm?: HttpAuthService.Algorithm): Promise<void>;
+    addForGlobal(user: string, password: string, algorithm?: HttpAuthService.Algorithm): Promise<void>;
+    removeUser(path: string, user: string): Promise<void>;
+    removeForProject(project: Project, user: string): Promise<void>;
+    enableForProject(project: Project, domain?: string): Promise<void>;
+    disableForProject(project: Project, domain?: string): Promise<void>;
+}
+export declare namespace HttpAuthService {
+    type Algorithm = "md5" | "sha1" | "sha256" | "sha512" | "bcrypt";
+}

package/lib/modules/proxy/services/HttpAuthService.js

@@ -0,0 +1,118 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpAuthService = void 0;
+const core_1 = require("@wocker/core");
+const docker_module_1 = require("@wocker/docker-module");
+const utils_1 = require("@wocker/utils");
+const ProxyService_1 = require("./ProxyService");
+let HttpAuthService = class HttpAuthService {
+    constructor(processService, fs, dockerService, proxyService) {
+        this.processService = processService;
+        this.fs = fs;
+        this.dockerService = dockerService;
+        this.proxyService = proxyService;
+    }
+    async add(path, user, password, algorithm = "md5") {
+        const alMap = {
+            md5: "-m",
+            sha1: "-s",
+            sha256: "-2",
+            sha512: "-5",
+            bcrypt: "-B",
+        };
+        if (!(algorithm in alMap)) {
+            throw new Error(`Unsupported "${algorithm}" algorithm`);
+        }
+        if (!this.fs.exists(path)) {
+            this.fs.writeFile(path, "", {
+                mode: 0o640
+            });
+        }
+        const stream = await this.dockerService.exec("wocker-proxy", {
+            user: "nginx",
+            cmd: ["htpasswd", "-b", alMap[algorithm], `/etc/${path}`, user, password]
+        });
+        await new Promise((resolve, reject) => {
+            stream.on("data", (chunk) => {
+                this.processService.stdout.write((0, utils_1.demuxOutput)(chunk));
+            });
+            stream.on("end", resolve);
+            stream.on("error", reject);
+        });
+    }
+    async addForProject(project, user, password, algorithm = "md5") {
+        if (!this.fs.exists("nginx/htpasswd/projects")) {
+            this.fs.mkdir("nginx/htpasswd/projects", {
+                mode: 0o764
+            });
+        }
+        await this.add(`nginx/htpasswd/projects/${project.name}`, user, password, algorithm);
+    }
+    async addForGlobal(user, password, algorithm = "md5") {
+        return this.add(`nginx/htpasswd/_global`, user, password, algorithm);
+    }
+    async removeUser(path, user) {
+    }
+    async removeForProject(project, user) {
+        if (!this.fs.exists("nginx/htpasswd/projects")) {
+            return;
+        }
+        await this.removeUser(`nginx/htpasswd/projects/${project.name}`, user);
+    }
+    async enableForProject(project, domain) {
+        if (!this.fs.exists(`nginx/htpasswd/projects/${project.name}`)) {
+            throw new Error(`No htpasswd for ${project.name}`);
+        }
+        if (!domain) {
+            for (const d of project.domains) {
+                await this.enableForProject(project, d);
+            }
+            return;
+        }
+        if (!project.domains.includes(domain)) {
+            throw new Error("Domain not related to project");
+        }
+        const filePath = `nginx/htpasswd/${domain}`;
+        if (this.fs.exists(filePath)) {
+            return;
+        }
+        this.fs.symlink(`nginx/htpasswd/projects/${project.name}`, filePath, "file");
+    }
+    async disableForProject(project, domain) {
+        if (!domain) {
+            for (const d of project.domains) {
+                await this.disableForProject(project, d);
+            }
+            return;
+        }
+        const filePath = `nginx/htpasswd/${domain}`;
+        if (!this.fs.exists(filePath)) {
+            return;
+        }
+        const stat = this.fs.lstat(filePath);
+        if (!stat.isSymbolicLink()) {
+            return;
+        }
+        if (`projects/${project.name}` !== this.fs.readlink(filePath)) {
+            return;
+        }
+        this.fs.unlink(filePath);
+    }
+};
+exports.HttpAuthService = HttpAuthService;
+exports.HttpAuthService = HttpAuthService = __decorate([
+    (0, core_1.Injectable)(),
+    __metadata("design:paramtypes", [core_1.ProcessService,
+        core_1.AppFileSystemService,
+        docker_module_1.DockerService,
+        ProxyService_1.ProxyService])
+], HttpAuthService);

package/lib/modules/proxy/services/ProxyService.d.ts

@@ -1,14 +1,15 @@
-import { Project, AppConfigService, AppFileSystemService, ProxyService as CoreProxyService } from "@wocker/core";
+import { Project, AppConfigService, AppFileSystemService, ProcessService, ProxyService as CoreProxyService } from "@wocker/core";
 import { DockerService } from "@wocker/docker-module";
 export declare class ProxyService extends CoreProxyService {
     protected readonly appConfigService: AppConfigService;
+    protected readonly processService: ProcessService;
     protected readonly fs: AppFileSystemService;
     protected readonly dockerService: DockerService;
     protected containerName: string;
     protected oldContainerNames: string[];
     protected imageName: string;
     protected oldImages: string[];
-    constructor(appConfigService: AppConfigService, fs: AppFileSystemService, dockerService: DockerService);
+    constructor(appConfigService: AppConfigService, processService: ProcessService, fs: AppFileSystemService, dockerService: DockerService);
     init(project: Project): Promise<void>;
     start(restart?: boolean, rebuild?: boolean): Promise<void>;
     stop(): Promise<void>;

package/lib/modules/proxy/services/ProxyService.js

@@ -49,16 +49,18 @@ const utils_1 = require("@wocker/utils");
 const Path = __importStar(require("path"));
 const env_1 = require("../../../env");
 let ProxyService = class ProxyService extends core_1.ProxyService {
-    constructor(appConfigService, fs, dockerService) {
+    constructor(appConfigService, processService, fs, dockerService) {
         super();
         this.appConfigService = appConfigService;
+        this.processService = processService;
         this.fs = fs;
         this.dockerService = dockerService;
         this.containerName = "wocker-proxy";
         this.oldContainerNames = ["proxy.workspace"];
-        this.imageName = "wocker-proxy:1.0.1";
+        this.imageName = "wocker-proxy:1.0.2";
         this.oldImages = [
-            "wocker-proxy:1.0.0"
+            "wocker-proxy:1.0.0",
+            "wocker-proxy:1.0.1"
         ];
     }
     async init(project) {
@@ -81,7 +83,6 @@ let ProxyService = class ProxyService extends core_1.ProxyService {
             }
             console.info("Proxy starting...");
             await this.build(rebuild);
-            const fs = this.fs;
             if (!this.fs.exists("certs/ca")) {
                 this.fs.mkdir("certs/ca", {
                     recursive: true,
@@ -94,20 +95,29 @@ let ProxyService = class ProxyService extends core_1.ProxyService {
                     mode: 0o700
                 });
             }
-            if (!fs.exists("nginx/vhost.d")) {
-                fs.mkdir("nginx/vhost.d", {
+            if (!this.fs.exists("nginx/vhost.d")) {
+                this.fs.mkdir("nginx/vhost.d", {
                     recursive: true,
                     mode: 0o700
                 });
             }
-            const httpPort = this.appConfigService.getMeta("PROXY_HTTP_PORT", "80");
-            const httpsPort = this.appConfigService.getMeta("PROXY_HTTPS_PORT", "443");
-            const sshPort = this.appConfigService.getMeta("PROXY_SSH_PORT", "22");
+            if (!this.fs.exists("nginx/htpasswd")) {
+                this.fs.mkdir("nginx/htpasswd", {
+                    recursive: true,
+                    mode: 0o764
+                });
+            }
+            else {
+                this.fs.chmod("nginx/htpasswd", 0o764);
+            }
+            const httpPort = this.appConfigService.getMeta("PROXY_HTTP_PORT", "80"), httpsPort = this.appConfigService.getMeta("PROXY_HTTPS_PORT", "443"), sshPort = this.appConfigService.getMeta("PROXY_SSH_PORT", "22");
             container = await this.dockerService.createContainer({
                 name: this.containerName,
                 image: this.imageName,
                 restart: "always",
                 env: {
+                    UID: this.processService.UID,
+                    GID: this.processService.GID,
                     DEFAULT_HOST: "localhost",
                     TRUST_DOWNSTREAM_PROXY: "true"
                 },
@@ -120,9 +130,10 @@ let ProxyService = class ProxyService extends core_1.ProxyService {
                 ],
                 volumes: [
                     "/var/run/docker.sock:/tmp/docker.sock:ro",
-                    `${fs.path("certs/projects")}:/etc/nginx/certs`,
-                    `${fs.path("certs/ca")}:/etc/nginx/ca-certs`,
-                    `${fs.path("nginx/vhost.d")}:/etc/nginx/vhost.d`
+                    `${this.fs.path("certs/projects")}:/etc/nginx/certs`,
+                    `${this.fs.path("certs/ca")}:/etc/nginx/ca-certs`,
+                    `${this.fs.path("nginx/vhost.d")}:/etc/nginx/vhost.d`,
+                    `${this.fs.path("nginx/htpasswd")}:/etc/nginx/htpasswd`
                 ],
                 network: "workspace"
             });
@@ -166,6 +177,7 @@ exports.ProxyService = ProxyService;
 exports.ProxyService = ProxyService = __decorate([
     (0, core_1.Injectable)("PROXY_SERVICE"),
     __metadata("design:paramtypes", [core_1.AppConfigService,
+        core_1.ProcessService,
         core_1.AppFileSystemService,
         docker_module_1.DockerService])
 ], ProxyService);

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@wocker/ws",
     "type": "commonjs",
-    "version": "1.0.31-beta.0",
+    "version": "1.0.32-beta.0",
     "author": "Kris Papercut <krispcut@gmail.com>",
     "description": "Docker workspace for web projects",
     "license": "MIT",
@@ -35,7 +35,7 @@
         "make-coverage-badge": "make-coverage-badge"
     },
     "dependencies": {
-        "@wocker/core": "1.0.31",
+        "@wocker/core": "^1.0.32-beta.2",
         "@wocker/docker-module": "^0.0.6",
         "@wocker/utils": "^2.0.6",
         "async-mutex": "^0.4.0",
@@ -66,5 +66,16 @@
         "ts-node": "^10.9.2",
         "typescript": "^5.9.3",
         "unionfs": "^4.5.4"
+    },
+    "overrides": {
+        "@wocker/testing": {
+            "@wocker/core": "^1.0.32-beta.2"
+        },
+        "@wocker/docker-module": {
+            "@wocker/core": "^1.0.32-beta.2"
+        },
+        "@wocker/docker-mock-module": {
+            "@wocker/core": "^1.0.32-beta.2"
+        }
     }
 }

package/plugins/proxy/Dockerfile

@@ -1,14 +1,21 @@
-FROM nginxproxy/nginx-proxy:1.6.4-alpine
+FROM nginxproxy/nginx-proxy:1.10.1-alpine
 
-ARG SSH_PASSWORD=''
+ENV UID=1000 \
+    GID=1000
 
+COPY ./wocker-entrypoint.sh /app/wocker-entrypoint.sh
 COPY ./bin/wocker-create-ca /usr/local/bin/wocker-create-ca
 COPY ./bin/wocker-create-cert /usr/local/bin/wocker-create-cert
 COPY ./bin/wocker-create-domains /usr/local/bin/wocker-create-domains
 
-RUN chmod +x /usr/local/bin/wocker-create-ca && \
+RUN chmod +x /app/wocker-entrypoint.sh && \
+    chown root:root /app/wocker-entrypoint.sh && \
+    chmod +x /usr/local/bin/wocker-create-ca && \
     chmod +x /usr/local/bin/wocker-create-cert && \
-    chmod +x /usr/local/bin/wocker-create-domains
+    chmod +x /usr/local/bin/wocker-create-domains && \
+    apk add --no-cache apache2-utils shadow
+
+ARG SSH_PASSWORD=''
 
 RUN if [ -n "$SSH_PASSWORD" ]; then \
         apk update && apk add --no-cache openssh; \
@@ -21,3 +28,6 @@ RUN if [ -n "$SSH_PASSWORD" ]; then \
         ssh-keygen -A; \
         echo "sshd: /usr/sbin/sshd -D" >> /app/Procfile; \
     fi
+
+ENTRYPOINT ["/app/wocker-entrypoint.sh"]
+CMD ["forego", "start", "-r"]

package/plugins/proxy/wocker-entrypoint.sh

@@ -0,0 +1,11 @@
+#!/bin/sh
+
+set -e
+
+UID=${UID:-1000}
+GID=${GID:-1000}
+
+groupmod -g ${GID} nginx
+usermod -u ${UID} -g ${GID} nginx
+
+exec /app/docker-entrypoint.sh "$@"