@wocker/ws 1.0.31 → 1.1.0

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

@@ -0,0 +1,137 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpAuthService = void 0;
+const core_1 = require("@wocker/core");
+const docker_module_1 = require("@wocker/docker-module");
+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 users(path) {
+        await this.dockerService.exec("wocker-proxy", {
+            tty: true,
+            user: "nginx",
+            cmd: ["cut", "-d:", "-f1", `/etc/${path}`]
+        });
+    }
+    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
+            });
+        }
+        await this.dockerService.exec("wocker-proxy", {
+            user: "nginx",
+            cmd: ["htpasswd", "-b", alMap[algorithm], `/etc/${path}`, user, password],
+            tty: true
+        });
+    }
+    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) {
+        await this.dockerService.exec("wocker-proxy", {
+            cmd: ["htpasswd", "-D", `/etc/${path}`, user],
+            user: "nginx",
+            tty: true
+        });
+    }
+    async usersForProject(project) {
+        if (!this.fs.exists("nginx/htpasswd/projects")) {
+            return;
+        }
+        await this.users(`nginx/htpasswd/projects/${project.name}`);
+    }
+    async removeForProject(project, user) {
+        if (!this.fs.exists("nginx/htpasswd/projects")) {
+            return;
+        }
+        await this.removeUser(`nginx/htpasswd/projects/${project.name}`, user);
+    }
+    async clearForProject(project) {
+        const filePath = `nginx/htpasswd/projects/${project.name}`;
+        if (this.fs.exists(filePath)) {
+            this.fs.writeFile(filePath, "", {
+                mode: 0o640
+            });
+        }
+    }
+    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, AppService, 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 appService: AppService;
+    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(appService: AppService, 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

@@ -45,24 +45,26 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ProxyService = void 0;
 const core_1 = require("@wocker/core");
 const docker_module_1 = require("@wocker/docker-module");
-const utils_1 = require("@wocker/utils");
+const prompts_1 = require("@wocker/prompts");
 const Path = __importStar(require("path"));
 const env_1 = require("../../../env");
 let ProxyService = class ProxyService extends core_1.ProxyService {
-    constructor(appConfigService, fs, dockerService) {
+    constructor(appService, processService, fs, dockerService) {
         super();
-        this.appConfigService = appConfigService;
+        this.appService = appService;
+        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) {
-        const appPort = await (0, utils_1.promptInput)({
+        const appPort = await (0, prompts_1.promptInput)({
             message: "App port",
             type: "number",
             default: parseInt(project.getEnv("VIRTUAL_PORT", "80"))
@@ -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,35 +95,45 @@ 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.appService.getMeta("PROXY_HTTP_PORT", "80"), httpsPort = this.appService.getMeta("PROXY_HTTPS_PORT", "443"), sshPort = this.appService.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"
                 },
                 ports: [
                     `${httpPort}:80`,
                     `${httpsPort}:443`,
-                    ...this.appConfigService.getMeta("PROXY_SSH_PASSWORD") ? [
+                    ...this.appService.getMeta("PROXY_SSH_PASSWORD") ? [
                         `${sshPort}:22`
                     ] : []
                 ],
                 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"
             });
@@ -150,9 +161,9 @@ let ProxyService = class ProxyService extends core_1.ProxyService {
         }
         await this.dockerService.buildImage({
             tag: this.imageName,
-            version: this.appConfigService.isExperimentalEnabled("buildKit") ? "2" : "1",
+            version: this.appService.isExperimentalEnabled("buildKit") ? "2" : "1",
             buildArgs: {
-                SSH_PASSWORD: this.appConfigService.getMeta("PROXY_SSH_PASSWORD")
+                SSH_PASSWORD: this.appService.getMeta("PROXY_SSH_PASSWORD")
             },
             context: Path.join(env_1.PLUGINS_DIR, "proxy"),
             dockerfile: "./Dockerfile"
@@ -165,7 +176,8 @@ let ProxyService = class ProxyService extends core_1.ProxyService {
 exports.ProxyService = ProxyService;
 exports.ProxyService = ProxyService = __decorate([
     (0, core_1.Injectable)("PROXY_SERVICE"),
-    __metadata("design:paramtypes", [core_1.AppConfigService,
+    __metadata("design:paramtypes", [core_1.AppService,
+        core_1.ProcessService,
         core_1.AppFileSystemService,
         docker_module_1.DockerService])
 ], ProxyService);

package/lib/utils/index.d.ts

@@ -1,6 +1,5 @@
 export * from "./escapeRegExp";
 export * from "./exec";
 export * from "./get-cursor-position";
-export * from "./injectVariables";
 export * from "./parse-table";
 export * from "./spawn";

package/lib/utils/index.js

@@ -17,6 +17,5 @@ Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./escapeRegExp"), exports);
 __exportStar(require("./exec"), exports);
 __exportStar(require("./get-cursor-position"), exports);
-__exportStar(require("./injectVariables"), exports);
 __exportStar(require("./parse-table"), exports);
 __exportStar(require("./spawn"), exports);

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@wocker/ws",
     "type": "commonjs",
-    "version": "1.0.31",
+    "version": "1.1.0",
     "author": "Kris Papercut <krispcut@gmail.com>",
     "description": "Docker workspace for web projects",
     "license": "MIT",
@@ -35,29 +35,21 @@
         "make-coverage-badge": "make-coverage-badge"
     },
     "dependencies": {
-        "@wocker/core": "1.0.31",
-        "@wocker/docker-module": "^0.0.6",
+        "@wocker/core": "1.1.0",
+        "@wocker/docker-module": "^1.0.0",
+        "@wocker/prompts": "^1.0.0",
         "@wocker/utils": "^2.0.6",
         "async-mutex": "^0.4.0",
-        "axios": "^1.6.7",
-        "child_process": "^1.0.2",
         "cli-table3": "^0.6.2",
-        "docker-compose": "^1.2.0",
-        "dockerode": "^4.0.2",
         "keytar": "^7.9.0",
-        "md5": "^2.3.0",
-        "protobufjs": "^7.5.1",
         "unzipper": "^0.12.3",
         "yoctocolors-cjs": "^2.1.2"
     },
     "devDependencies": {
-        "@types/dockerode": "^3.3.23",
         "@types/jest": "^30.0.0",
-        "@types/md5": "^2.3.2",
-        "@types/mute-stream": "^0.0.4",
         "@types/node": "^24.5.2",
         "@types/unzipper": "^0.10.10",
-        "@wocker/docker-mock-module": "^0.0.3",
+        "@wocker/docker-mock-module": "^1.0.0",
         "@wocker/testing": "^1.0.4",
         "jest": "^30.1.3",
         "make-coverage-badge": "^1.2.0",

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 "$@"

package/lib/makes/Http.d.ts

@@ -1,18 +0,0 @@
-import { AxiosHeaders, AxiosResponse } from "axios";
-type HttpMethod = "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
-export declare class Http {
-    readonly method: HttpMethod;
-    readonly url: string;
-    body?: any;
-    protected headers: AxiosHeaders;
-    private constructor();
-    withHeader(name: string, value: string): Http;
-    withBody(body: any): Http;
-    send(path: string): Promise<AxiosResponse>;
-    static get(url: string): Http;
-    static post(url: string): Http;
-    static put(url: string): Http;
-    static patch(url: string): Http;
-    static delete(url: string): Http;
-}
-export {};

package/lib/makes/Http.js

@@ -1,82 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Http = void 0;
-const axios_1 = __importStar(require("axios"));
-class Http {
-    constructor(method = "GET", url, body) {
-        this.method = method;
-        this.url = url;
-        this.body = body;
-        this.headers = new axios_1.AxiosHeaders();
-    }
-    withHeader(name, value) {
-        this.headers.set(name, value);
-        return this;
-    }
-    withBody(body) {
-        this.body = body;
-        return this;
-    }
-    async send(path) {
-        return axios_1.default.create({
-            method: this.method,
-            baseURL: this.url,
-            headers: this.headers.toJSON(),
-            validateStatus() {
-                return true;
-            }
-        }).request({
-            url: path,
-            data: this.body
-        });
-    }
-    static get(url) {
-        return new Http("GET", url);
-    }
-    static post(url) {
-        return new Http("POST", url);
-    }
-    static put(url) {
-        return new Http("PUT", url);
-    }
-    static patch(url) {
-        return new Http("PATCH", url);
-    }
-    static delete(url) {
-        return new Http("DELETE", url);
-    }
-}
-exports.Http = Http;

package/lib/makes/Version.d.ts

@@ -1,22 +0,0 @@
-type VersionData = {
-    major: number;
-    minor: number;
-    patch: number;
-    tag?: string;
-    build?: number;
-};
-export declare class Version {
-    static readonly REGEXP: RegExp;
-    protected static cache: Map<string, Version>;
-    readonly major: number;
-    readonly minor: number;
-    readonly patch: number;
-    readonly tag?: string;
-    readonly build?: number;
-    constructor(data: VersionData);
-    parts(): number[];
-    compare(version: string | Version): number;
-    static valid(version: string): boolean;
-    static parse(version: string): Version;
-}
-export {};

package/lib/makes/Version.js

@@ -1,59 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Version = void 0;
-class Version {
-    constructor(data) {
-        Object.assign(this, data);
-    }
-    parts() {
-        return [
-            this.major,
-            this.minor,
-            this.patch,
-            this.build ?? 0
-        ];
-    }
-    compare(version) {
-        if (typeof version === "string") {
-            version = Version.parse(version);
-        }
-        const a = this.parts(), b = version.parts();
-        for (let i = 0; i < Math.max(a.length, b.length); i++) {
-            if (i === 3) {
-                if (this.tag && !version.tag)
-                    return -1;
-                else if (!this.tag && version.tag)
-                    return 1;
-                else if (this.tag !== version.tag)
-                    return this.tag < version.tag ? -1 : 1;
-            }
-            const diff = (a[i] ?? 0) - (b[i] ?? 0);
-            if (diff !== 0) {
-                return diff > 0 ? 1 : -1;
-            }
-        }
-        return 0;
-    }
-    static valid(version) {
-        return Version.REGEXP.test(version);
-    }
-    static parse(version) {
-        if (!Version.cache.has(version)) {
-            if (!Version.REGEXP.test(version)) {
-                throw new RangeError("Invalid version format");
-            }
-            const [, major, minor, patch, tag, build] = Version.REGEXP.exec(version) || [];
-            Version.cache.set(version, new Version({
-                major: parseInt(major),
-                minor: parseInt(minor),
-                patch: parseInt(patch),
-                tag,
-                build: build ? parseInt(build) : undefined
-            }));
-        }
-        return Version.cache.get(version);
-    }
-}
-exports.Version = Version;
-Version.REGEXP = /^v?(\d+)\.(\d+)\.(\d+)(?:-([a-zA-Z]+(?:-[a-zA-Z0-9]+)*)(?:\.(\d+))?)?/;
-Version.cache = new Map();

package/lib/makes/VersionRange.d.ts

@@ -1,6 +0,0 @@
-import { VersionRule } from "./VersionRule";
-export declare class VersionRange {
-    protected rules: VersionRule[][];
-    constructor(rules: VersionRule[][]);
-    static parse(range: string): VersionRange;
-}

package/lib/makes/VersionRange.js

@@ -1,18 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.VersionRange = void 0;
-const VersionRule_1 = require("./VersionRule");
-class VersionRange {
-    constructor(rules) {
-        this.rules = rules;
-    }
-    static parse(range) {
-        const rules = range.split("||").map((range) => {
-            return range.split(" ").map((rule) => {
-                return VersionRule_1.VersionRule.parse(rule);
-            });
-        });
-        return new VersionRange(rules);
-    }
-}
-exports.VersionRange = VersionRange;

package/lib/makes/VersionRule.d.ts

@@ -1,24 +0,0 @@
-import { Version } from "./Version";
-type VersionRuleData = {
-    prefix?: string;
-    major?: number;
-    minor?: number;
-    patch?: number;
-    tag?: string;
-    build?: number;
-};
-export declare class VersionRule {
-    static readonly REGEXP: RegExp;
-    protected static map: Map<string, VersionRule>;
-    readonly prefix?: string;
-    readonly major?: number;
-    readonly minor?: number;
-    readonly patch?: number;
-    readonly tag?: string;
-    readonly build?: number;
-    constructor(data: VersionRuleData);
-    get version(): Version;
-    match(version: string | Version, withTag?: boolean): boolean;
-    static parse(rule: string): VersionRule;
-}
-export {};