@wocker/ws 1.0.21 → 1.0.23

package/lib/modules/keystore/types/FileKeystore.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileKeystore = void 0;
+class FileKeystore {
+    constructor(data) {
+        const { passwordHash, secrets = {} } = data;
+        this.passwordHash = passwordHash;
+        this.secrets = secrets;
+    }
+    get(key) {
+        if (!(key in this.secrets)) {
+            return undefined;
+        }
+        return this.secrets[key];
+    }
+    set(key, value) {
+        this.secrets[key] = value;
+    }
+    delete(key) {
+        if (!(key in this.secrets)) {
+            return;
+        }
+        delete this.secrets[key];
+    }
+    toObject() {
+        return {};
+    }
+    toString() {
+        const secrets = JSON.stringify(this.secrets, null, 4);
+        return `// Wocker keystore\nexports.passwordHash = "${this.passwordHash}";\nexports.secrets = ${secrets};\n`;
+    }
+}
+exports.FileKeystore = FileKeystore;

package/lib/modules/keystore/types/Keytar.d.ts

@@ -0,0 +1,8 @@
+import type { getPassword, setPassword, deletePassword, findPassword, findCredentials } from "keytar";
+export type Keytar = {
+    getPassword: typeof getPassword;
+    setPassword: typeof setPassword;
+    deletePassword: typeof deletePassword;
+    findPassword: typeof findPassword;
+    findCredentials: typeof findCredentials;
+};

package/lib/modules/keystore/types/Keytar.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/modules/keystore/utils/createEncryptionKey.d.ts

@@ -0,0 +1 @@
+export declare const createEncryptionKey: (password: string, passwordHash: string) => Buffer<ArrayBufferLike>;

package/lib/modules/keystore/utils/createEncryptionKey.js

@@ -0,0 +1,46 @@
+"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.createEncryptionKey = void 0;
+const crypto = __importStar(require("crypto"));
+const verifyPasswordHash_1 = require("./verifyPasswordHash");
+const createEncryptionKey = (password, passwordHash) => {
+    if (!(0, verifyPasswordHash_1.verifyPasswordHash)(password, passwordHash)) {
+        throw new Error("Invalid password provided");
+    }
+    const [, saltValue] = passwordHash.split(":"), salt = Buffer.from(saltValue, "hex");
+    return crypto.scryptSync(password, salt, 32);
+};
+exports.createEncryptionKey = createEncryptionKey;

package/lib/modules/keystore/utils/createPasswordHash.d.ts

@@ -0,0 +1 @@
+export declare const createPasswordHash: (password: string, salt?: string) => string;

package/lib/modules/keystore/utils/createPasswordHash.js

@@ -0,0 +1,20 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createPasswordHash = void 0;
+const crypto_1 = __importDefault(require("crypto"));
+const createPasswordHash = (password, salt) => {
+    const saltBuffer = salt
+        ? Buffer.from(salt, "hex")
+        : crypto_1.default.randomBytes(16);
+    if (!salt) {
+        salt = saltBuffer.toString("hex");
+    }
+    const hash = crypto_1.default.createHmac("sha256", saltBuffer)
+        .update(password)
+        .digest("hex");
+    return `${hash}:${salt}`;
+};
+exports.createPasswordHash = createPasswordHash;

package/lib/modules/keystore/utils/decrypt.d.ts

@@ -0,0 +1 @@
+export declare const decrypt: (encryptedKey: Buffer, encryptedValue: string) => string;

package/lib/modules/keystore/utils/decrypt.js

@@ -0,0 +1,15 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decrypt = void 0;
+const crypto_1 = __importDefault(require("crypto"));
+const decrypt = (encryptedKey, encryptedValue) => {
+    const buffer = Buffer.from(encryptedValue, "base64"), iv = buffer.subarray(0, 12), authTag = buffer.subarray(12, 28), encrypted = buffer.subarray(28).toString("base64"), decipher = crypto_1.default.createDecipheriv("aes-256-gcm", encryptedKey, iv);
+    decipher.setAuthTag(authTag);
+    let decrypted = decipher.update(encrypted, "base64", "utf8");
+    decrypted += decipher.final("utf8");
+    return decrypted;
+};
+exports.decrypt = decrypt;

package/lib/modules/keystore/utils/encrypt.d.ts

@@ -0,0 +1 @@
+export declare const encrypt: (encryptedKey: Buffer, value: string) => string;

package/lib/modules/keystore/utils/encrypt.js

@@ -0,0 +1,19 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.encrypt = void 0;
+const crypto_1 = __importDefault(require("crypto"));
+const encrypt = (encryptedKey, value) => {
+    const iv = crypto_1.default.randomBytes(12), cipher = crypto_1.default.createCipheriv("aes-256-gcm", encryptedKey, iv);
+    let encrypted = cipher.update(value, "utf8", "base64");
+    encrypted += cipher.final("base64");
+    const authTag = cipher.getAuthTag();
+    return Buffer.concat([
+        iv,
+        authTag,
+        Buffer.from(encrypted, "base64")
+    ]).toString("base64");
+};
+exports.encrypt = encrypt;

package/lib/modules/keystore/utils/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./createEncryptionKey";
+export * from "./createPasswordHash";
+export * from "./decrypt";
+export * from "./encrypt";
+export * from "./verifyPasswordHash";

package/lib/{services → modules/keystore/utils}/index.js

@@ -14,13 +14,8 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./AppConfigService"), exports);
-__exportStar(require("./AppEventsService"), exports);
-__exportStar(require("./CertService"), exports);
-__exportStar(require("./DockerService"), exports);
-__exportStar(require("./LogService"), exports);
-__exportStar(require("./NpmService"), exports);
-__exportStar(require("./PluginService"), exports);
-__exportStar(require("./PresetService"), exports);
-__exportStar(require("./ProjectService"), exports);
-__exportStar(require("./ProxyService"), exports);
+__exportStar(require("./createEncryptionKey"), exports);
+__exportStar(require("./createPasswordHash"), exports);
+__exportStar(require("./decrypt"), exports);
+__exportStar(require("./encrypt"), exports);
+__exportStar(require("./verifyPasswordHash"), exports);

package/lib/modules/keystore/utils/verifyPasswordHash.d.ts

@@ -0,0 +1 @@
+export declare const verifyPasswordHash: (password: string, passwordHash: string) => boolean;

package/lib/modules/keystore/utils/verifyPasswordHash.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.verifyPasswordHash = void 0;
+const createPasswordHash_1 = require("./createPasswordHash");
+const verifyPasswordHash = (password, passwordHash) => {
+    const [, salt = ""] = (passwordHash || "").split(":");
+    return passwordHash === (0, createPasswordHash_1.createPasswordHash)(password, salt);
+};
+exports.verifyPasswordHash = verifyPasswordHash;

package/lib/{controllers → modules/proxy/controllers}/CertController.d.ts

@@ -1,4 +1,5 @@
-import { ProjectService, CertService } from "../services";
+import { CertService } from "../services/CertService";
+import { ProjectService } from "../../../services/ProjectService";
 export declare class CertController {
     protected readonly projectService: ProjectService;
     protected readonly certService: CertService;

package/lib/{controllers → modules/proxy/controllers}/CertController.js

@@ -14,7 +14,8 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CertController = void 0;
 const core_1 = require("@wocker/core");
-const services_1 = require("../services");
+const CertService_1 = require("../services/CertService");
+const ProjectService_1 = require("../../../services/ProjectService");
 let CertController = class CertController {
     constructor(projectService, certService) {
         this.projectService = projectService;
@@ -108,6 +109,6 @@ __decorate([
 ], CertController.prototype, "existsOtherNames", null);
 exports.CertController = CertController = __decorate([
     (0, core_1.Controller)(),
-    __metadata("design:paramtypes", [services_1.ProjectService,
-        services_1.CertService])
+    __metadata("design:paramtypes", [ProjectService_1.ProjectService,
+        CertService_1.CertService])
 ], CertController);

package/lib/{controllers → modules/proxy/controllers}/ProxyController.d.ts

@@ -1,5 +1,8 @@
 import { Project } from "@wocker/core";
-import { AppConfigService, AppEventsService, ProjectService, ProxyService } from "../services";
+import { AppConfigService } from "../../../services/AppConfigService";
+import { AppEventsService } from "../../../services/AppEventsService";
+import { ProjectService } from "../../../services/ProjectService";
+import { ProxyService } from "../services/ProxyService";
 export declare class ProxyController {
     protected readonly appConfigService: AppConfigService;
     protected readonly appEventsService: AppEventsService;

package/lib/{controllers → modules/proxy/controllers}/ProxyController.js

@@ -18,8 +18,11 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ProxyController = void 0;
 const core_1 = require("@wocker/core");
 const utils_1 = require("@wocker/utils");
-const chalk_1 = __importDefault(require("chalk"));
-const services_1 = require("../services");
+const yoctocolors_cjs_1 = __importDefault(require("yoctocolors-cjs"));
+const AppConfigService_1 = require("../../../services/AppConfigService");
+const AppEventsService_1 = require("../../../services/AppEventsService");
+const ProjectService_1 = require("../../../services/ProjectService");
+const ProxyService_1 = require("../services/ProxyService");
 let ProxyController = class ProxyController {
     constructor(appConfigService, appEventsService, projectService, proxyService) {
         this.appConfigService = appConfigService;
@@ -35,9 +38,9 @@ let ProxyController = class ProxyController {
         if (project.domains.length === 0) {
             return;
         }
-        console.info(chalk_1.default.green("Don't forget to add these lines into hosts file:"));
+        console.info(yoctocolors_cjs_1.default.green("Don't forget to add these lines into hosts file:"));
         for (const domain of project.domains) {
-            console.info(chalk_1.default.gray(`127.0.0.1 ${domain}`));
+            console.info(yoctocolors_cjs_1.default.gray(`127.0.0.1 ${domain}`));
         }
         await this.start();
     }
@@ -48,47 +51,47 @@ let ProxyController = class ProxyController {
         return projects.map((project) => project.name);
     }
     async init(httpPort, httpsPort, sshPort, sshPassword) {
-        const config = this.appConfigService.getConfig();
+        const config = this.appConfigService.config;
         if (httpPort === null || typeof httpPort === "undefined" || isNaN(httpPort)) {
-            httpPort = await (0, utils_1.promptText)({
+            httpPort = await (0, utils_1.promptInput)({
                 required: true,
-                message: "Http port:",
+                message: "Http port",
                 type: "number",
-                default: config.getMeta("PROXY_HTTP_PORT", "80")
+                default: parseInt(config.getMeta("PROXY_HTTP_PORT", "80"))
             });
         }
         config.setMeta("PROXY_HTTP_PORT", httpPort.toString());
         if (httpsPort === null || typeof httpsPort === "undefined" || isNaN(httpsPort)) {
-            httpsPort = await (0, utils_1.promptText)({
+            httpsPort = await (0, utils_1.promptInput)({
                 required: true,
-                message: "Https port:",
+                message: "Https port",
                 type: "number",
-                default: config.getMeta("PROXY_HTTPS_PORT", "443")
+                default: parseInt(config.getMeta("PROXY_HTTPS_PORT", "443"))
             });
         }
         config.setMeta("PROXY_HTTPS_PORT", httpsPort.toString());
-        let enableSsh = false;
-        if (!sshPassword && !sshPort) {
-            enableSsh = await (0, utils_1.promptConfirm)({
+        let enableSsh = !sshPassword && !sshPort
+            ? await (0, utils_1.promptConfirm)({
                 message: "Enable ssh proxy?",
                 default: false
-            });
-        }
-        if (enableSsh && !sshPassword) {
-            sshPassword = await (0, utils_1.promptText)({
-                message: "SSH Password:",
-                type: "string",
-                default: config.getMeta("PROXY_SSH_PASSWORD")
-            });
-        }
-        if (enableSsh && !sshPort) {
-            sshPort = await (0, utils_1.promptText)({
-                message: "SSH port:",
-                type: "number",
-                default: config.getMeta("PROXY_SSH_PORT", "22")
-            });
-        }
+            })
+            : true;
         if (enableSsh) {
+            if (!sshPassword) {
+                sshPassword = await (0, utils_1.promptInput)({
+                    message: "SSH Password",
+                    type: "password",
+                    required: true,
+                    default: config.getMeta("PROXY_SSH_PASSWORD")
+                });
+            }
+            if (!sshPort) {
+                sshPort = await (0, utils_1.promptInput)({
+                    message: "SSH port",
+                    type: "number",
+                    default: parseInt(config.getMeta("PROXY_SSH_PORT", "22"))
+                });
+            }
             config.setMeta("PROXY_SSH_PASSWORD", sshPassword);
             config.setMeta("PROXY_SSH_PORT", sshPort.toString());
         }
@@ -96,7 +99,7 @@ let ProxyController = class ProxyController {
             config.unsetMeta("PROXY_SSH_PASSWORD");
             config.unsetMeta("PROXY_SSH_PORT");
         }
-        await config.save();
+        this.appConfigService.save();
     }
     async start(restart, rebuild) {
         await this.proxyService.start(restart, rebuild);
@@ -118,6 +121,7 @@ __decorate([
 ], ProxyController.prototype, "getProjectNames", null);
 __decorate([
     (0, core_1.Command)("proxy:init"),
+    (0, core_1.Description)("Initializes proxy configurations"),
     __param(0, (0, core_1.Option)("http-port", {
         type: "number",
         description: "Http port"
@@ -131,6 +135,7 @@ __decorate([
         description: "SSH port"
     })),
     __param(3, (0, core_1.Option)("ssh-password", {
+        type: "string",
         description: "SSH password"
     })),
     __metadata("design:type", Function),
@@ -139,15 +144,16 @@ __decorate([
 ], ProxyController.prototype, "init", null);
 __decorate([
     (0, core_1.Command)("proxy:start"),
+    (0, core_1.Description)("This command starts the proxy for the project. Options are available to restart or rebuild the proxy if needed."),
     __param(0, (0, core_1.Option)("restart", {
         type: "boolean",
         alias: "r",
-        description: "Restart"
+        description: "Restarts the proxy before starting it"
     })),
     __param(1, (0, core_1.Option)("rebuild", {
         type: "boolean",
         alias: "b",
-        description: "Rebuild"
+        description: "Rebuilds the proxy before starting it"
     })),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Boolean, Boolean]),
@@ -155,20 +161,23 @@ __decorate([
 ], ProxyController.prototype, "start", null);
 __decorate([
     (0, core_1.Command)("proxy:stop"),
+    (0, core_1.Description)("This command stops the currently running proxy for the project. It ensures that all proxy-related services are properly halted."),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", []),
     __metadata("design:returntype", Promise)
 ], ProxyController.prototype, "stop", null);
 __decorate([
     (0, core_1.Command)("proxy:logs"),
+    (0, core_1.Description)("Displays the proxy logs"),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", []),
     __metadata("design:returntype", Promise)
 ], ProxyController.prototype, "logs", null);
 exports.ProxyController = ProxyController = __decorate([
     (0, core_1.Controller)(),
-    __metadata("design:paramtypes", [services_1.AppConfigService,
-        services_1.AppEventsService,
-        services_1.ProjectService,
-        services_1.ProxyService])
+    (0, core_1.Description)("Proxy commands"),
+    __metadata("design:paramtypes", [AppConfigService_1.AppConfigService,
+        AppEventsService_1.AppEventsService,
+        ProjectService_1.ProjectService,
+        ProxyService_1.ProxyService])
 ], ProxyController);

package/lib/modules/proxy/index.d.ts

@@ -0,0 +1,5 @@
+import { CertService } from "./services/CertService";
+import { ProxyService } from "./services/ProxyService";
+export declare class ProxyModule {
+}
+export { ProxyService, CertService };

package/lib/modules/proxy/index.js

@@ -0,0 +1,39 @@
+"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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CertService = exports.ProxyService = exports.ProxyModule = void 0;
+const core_1 = require("@wocker/core");
+const docker_1 = require("../docker");
+const CertController_1 = require("./controllers/CertController");
+const ProxyController_1 = require("./controllers/ProxyController");
+const CertService_1 = require("./services/CertService");
+Object.defineProperty(exports, "CertService", { enumerable: true, get: function () { return CertService_1.CertService; } });
+const ProxyService_1 = require("./services/ProxyService");
+Object.defineProperty(exports, "ProxyService", { enumerable: true, get: function () { return ProxyService_1.ProxyService; } });
+let ProxyModule = class ProxyModule {
+};
+exports.ProxyModule = ProxyModule;
+exports.ProxyModule = ProxyModule = __decorate([
+    (0, core_1.Module)({
+        imports: [
+            docker_1.DockerModule
+        ],
+        controllers: [
+            CertController_1.CertController,
+            ProxyController_1.ProxyController
+        ],
+        providers: [
+            ProxyService_1.ProxyService,
+            CertService_1.CertService
+        ],
+        exports: [
+            ProxyService_1.ProxyService,
+            CertService_1.CertService
+        ]
+    })
+], ProxyModule);

package/lib/{services → modules/proxy/services}/CertService.d.ts

@@ -1,6 +1,6 @@
 import { Project } from "@wocker/core";
-import { AppConfigService } from "./AppConfigService";
-import { DockerService } from "./DockerService";
+import { DockerService } from "../../docker";
+import { AppConfigService } from "../../../services/AppConfigService";
 import { ProxyService } from "./ProxyService";
 type CertMap = {
     [name: string]: string[];
@@ -12,7 +12,7 @@ export declare class CertService {
     constructor(appConfigService: AppConfigService, proxyService: ProxyService, dockerService: DockerService);
     list(): Promise<string>;
     generate(certName: string, dns: string[]): Promise<void>;
-    getCertsMap(): Promise<CertMap>;
+    getCertsMap(): CertMap;
     use(project: Project, name: string): Promise<void>;
     remove(project: Project): Promise<void>;
     delete(name: string): Promise<void>;

package/lib/{services → modules/proxy/services}/CertService.js

@@ -49,8 +49,8 @@ exports.CertService = void 0;
 const core_1 = require("@wocker/core");
 const Path = __importStar(require("path"));
 const cli_table3_1 = __importDefault(require("cli-table3"));
-const AppConfigService_1 = require("./AppConfigService");
-const DockerService_1 = require("./DockerService");
+const docker_1 = require("../../docker");
+const AppConfigService_1 = require("../../../services/AppConfigService");
 const ProxyService_1 = require("./ProxyService");
 let CertService = class CertService {
     constructor(appConfigService, proxyService, dockerService) {
@@ -62,7 +62,7 @@ let CertService = class CertService {
         const table = new cli_table3_1.default({
             head: ["Name"]
         });
-        const certMap = await this.getCertsMap();
+        const certMap = this.getCertsMap();
         for (const name in certMap) {
             table.push([name]);
         }
@@ -93,8 +93,8 @@ let CertService = class CertService {
             cmd: ["wocker-create-cert", certName]
         });
     }
-    async getCertsMap() {
-        const files = await this.appConfigService.fs.readdir("certs/projects");
+    getCertsMap() {
+        const files = this.appConfigService.fs.readdir("certs/projects");
         return files.reduce((res, file) => {
             const ext = Path.extname(file);
             const name = Path.basename(file, ext);
@@ -106,7 +106,7 @@ let CertService = class CertService {
         }, {});
     }
     async use(project, name) {
-        const certs = await this.getCertsMap();
+        const certs = this.getCertsMap();
         if (!name) {
             name = project.domains.find((domain) => domain in certs);
         }
@@ -121,23 +121,23 @@ let CertService = class CertService {
             throw new Error(`${name}.key file missing`);
         }
         project.setEnv("CERT_NAME", name);
-        await project.save();
+        project.save();
     }
     async remove(project) {
         if (!project.hasEnv("CERT_NAME")) {
             return;
         }
         project.unsetEnv("CERT_NAME");
-        await project.save();
+        project.save();
     }
     async delete(name) {
-        const certs = await this.getCertsMap();
+        const certs = this.getCertsMap();
         if (!(name in certs)) {
             console.warn(`Cert ${name} not found`);
             return;
         }
         for (const ext of certs[name]) {
-            await this.appConfigService.fs.rm(`certs/projects/${name}${ext}`);
+            this.appConfigService.fs.rm(`certs/projects/${name}${ext}`);
         }
         console.info(`Cert ${name} deleted`);
     }
@@ -147,5 +147,5 @@ exports.CertService = CertService = __decorate([
     (0, core_1.Injectable)(),
     __metadata("design:paramtypes", [AppConfigService_1.AppConfigService,
         ProxyService_1.ProxyService,
-        DockerService_1.DockerService])
+        docker_1.DockerService])
 ], CertService);

package/lib/{services → modules/proxy/services}/ProxyService.d.ts

@@ -1,6 +1,6 @@
 import { Project, ProxyService as CoreProxyService } from "@wocker/core";
-import { AppConfigService } from "./AppConfigService";
-import { DockerService } from "./DockerService";
+import { AppConfigService } from "../../../services/AppConfigService";
+import { DockerService } from "../../docker";
 export declare class ProxyService extends CoreProxyService {
     protected readonly appConfigService: AppConfigService;
     protected readonly dockerService: DockerService;

package/lib/{services → modules/proxy/services}/ProxyService.js

@@ -46,9 +46,9 @@ exports.ProxyService = void 0;
 const core_1 = require("@wocker/core");
 const utils_1 = require("@wocker/utils");
 const Path = __importStar(require("path"));
-const env_1 = require("../env");
-const AppConfigService_1 = require("./AppConfigService");
-const DockerService_1 = require("./DockerService");
+const env_1 = require("../../../env");
+const AppConfigService_1 = require("../../../services/AppConfigService");
+const docker_1 = require("../../docker");
 let ProxyService = class ProxyService extends core_1.ProxyService {
     constructor(appConfigService, dockerService) {
         super();
@@ -61,13 +61,13 @@ let ProxyService = class ProxyService extends core_1.ProxyService {
         ];
     }
     async init(project) {
-        const appPort = await (0, utils_1.promptText)({
-            message: "App port:",
+        const appPort = await (0, utils_1.promptInput)({
+            message: "App port",
             type: "number",
-            default: project.getEnv("VIRTUAL_PORT", "80")
+            default: parseInt(project.getEnv("VIRTUAL_PORT", "80"))
         });
-        project.setEnv("VIRTUAL_PORT", appPort);
-        await project.save();
+        project.setEnv("VIRTUAL_PORT", appPort.toString());
+        project.save();
     }
     async start(restart, rebuild) {
         if (restart || rebuild) {
@@ -77,6 +77,7 @@ let ProxyService = class ProxyService extends core_1.ProxyService {
         if (!container) {
             console.info("Proxy starting...");
             await this.build(rebuild);
+            const fs = this.appConfigService.fs;
             if (!this.appConfigService.fs.exists("certs/ca")) {
                 this.appConfigService.fs.mkdir("certs/ca", {
                     recursive: true,
@@ -89,7 +90,13 @@ let ProxyService = class ProxyService extends core_1.ProxyService {
                     mode: 0o700
                 });
             }
-            const config = this.appConfigService.getConfig();
+            if (!fs.exists("nginx/vhost.d")) {
+                fs.mkdir("nginx/vhost.d", {
+                    recursive: true,
+                    mode: 0o700
+                });
+            }
+            const config = this.appConfigService.config;
             const httpPort = config.getMeta("PROXY_HTTP_PORT", "80");
             const httpsPort = config.getMeta("PROXY_HTTPS_PORT", "443");
             const sshPort = config.getMeta("PROXY_SSH_PORT", "22");
@@ -110,8 +117,9 @@ let ProxyService = class ProxyService extends core_1.ProxyService {
                 ],
                 volumes: [
                     "/var/run/docker.sock:/tmp/docker.sock:ro",
-                    `${this.appConfigService.fs.path("certs/projects")}:/etc/nginx/certs`,
-                    `${this.appConfigService.fs.path("certs/ca")}:/etc/nginx/ca-certs`
+                    `${fs.path("certs/projects")}:/etc/nginx/certs`,
+                    `${fs.path("certs/ca")}:/etc/nginx/ca-certs`,
+                    `${fs.path("nginx/vhost.d")}:/etc/nginx/vhost.d`
                 ],
                 network: "workspace"
             });
@@ -137,7 +145,7 @@ let ProxyService = class ProxyService extends core_1.ProxyService {
         for (const oldImage of this.oldImages) {
             await this.dockerService.imageRm(oldImage);
         }
-        const config = this.appConfigService.getConfig();
+        const config = this.appConfigService.config;
         await this.dockerService.buildImage({
             tag: this.imageName,
             context: Path.join(env_1.PLUGINS_DIR, "proxy"),
@@ -155,5 +163,5 @@ exports.ProxyService = ProxyService;
 exports.ProxyService = ProxyService = __decorate([
     (0, core_1.Injectable)("PROXY_SERVICE"),
     __metadata("design:paramtypes", [AppConfigService_1.AppConfigService,
-        DockerService_1.DockerService])
+        docker_1.DockerService])
 ], ProxyService);