@wocker/ws 1.0.9 → 1.0.10

package/lib/controllers/DebugController.d.ts

@@ -1,7 +1,8 @@
-import { AppConfigService } from "../services";
+import { AppConfigService, LogService } from "../services";
 export declare class DebugController {
     protected readonly appConfigService: AppConfigService;
-    constructor(appConfigService: AppConfigService);
+    protected readonly logService: LogService;
+    constructor(appConfigService: AppConfigService, logService: LogService);
     debug(status: string): Promise<void>;
     debugCompletion(): Promise<string[]>;
 }

package/lib/controllers/DebugController.js

@@ -13,8 +13,9 @@ exports.DebugController = void 0;
 const core_1 = require("@wocker/core");
 const services_1 = require("../services");
 let DebugController = class DebugController {
-    constructor(appConfigService) {
+    constructor(appConfigService, logService) {
         this.appConfigService = appConfigService;
+        this.logService = logService;
     }
     async debug(status) {
         const config = await this.appConfigService.getConfig();
@@ -40,5 +41,6 @@ __decorate([
 ], DebugController.prototype, "debugCompletion", null);
 exports.DebugController = DebugController = __decorate([
     (0, core_1.Controller)(),
-    __metadata("design:paramtypes", [services_1.AppConfigService])
+    __metadata("design:paramtypes", [services_1.AppConfigService,
+        services_1.LogService])
 ], DebugController);

package/lib/controllers/ImageController.js

@@ -29,7 +29,7 @@ let ImageController = class ImageController {
         for (const image of images) {
             table.push([image.Id]);
         }
-        return table.toString() + "\n";
+        return table.toString();
     }
 };
 exports.ImageController = ImageController;

package/lib/controllers/PresetController.js

@@ -42,7 +42,6 @@ const utils_2 = require("@wocker/utils");
 const Path = __importStar(require("path"));
 const env_1 = require("../env");
 const utils_3 = require("../utils");
-const makes_1 = require("../makes");
 const services_1 = require("../services");
 let PresetController = class PresetController {
     constructor(appConfigService, appEventsService, projectService, presetService, dockerService) {
@@ -166,37 +165,34 @@ let PresetController = class PresetController {
         if (!confirm) {
             return;
         }
-        const source = new makes_1.FS(this.appConfigService.presetPath(preset.name));
-        const destination = new makes_1.FS(this.appConfigService.getPWD());
-        const fs = new core_1.FSManager(this.appConfigService.presetPath(preset.name), this.appConfigService.getPWD());
+        const copier = new core_1.FSManager(this.appConfigService.presetPath(preset.name), this.appConfigService.getPWD());
         if (preset.dockerfile) {
-            if (!destination.exists(preset.dockerfile)) {
-                await fs.copy(preset.dockerfile);
+            if (!copier.destination.exists(preset.dockerfile)) {
+                await copier.copy(preset.dockerfile);
             }
             project.type = "dockerfile";
             project.dockerfile = preset.dockerfile;
         }
-        const files = await source.readdirFiles("", {
+        const files = await copier.source.readdirFiles("", {
             recursive: true
         });
         for (const path of files) {
-            const stat = source.stat(path);
+            const stat = copier.source.stat(path), dir = Path.dirname(path);
             if (stat.isFile() && path === "config.json") {
                 continue;
             }
             if (stat.isFile() && path === preset.dockerfile) {
                 continue;
             }
-            if (destination.exists(path)) {
+            if (copier.destination.exists(path)) {
                 continue;
             }
-            const dir = Path.dirname(path);
-            if (!destination.exists(dir)) {
-                destination.mkdir(dir, {
+            if (!copier.destination.exists(dir)) {
+                copier.destination.mkdir(dir, {
                     recursive: true
                 });
             }
-            await fs.copy(path);
+            await copier.copy(path);
         }
         delete project.preset;
         delete project.imageName;

package/lib/controllers/ProjectController.js

@@ -144,7 +144,7 @@ let ProjectController = class ProjectController {
             const { State: { Status = "stopped" } = {} } = await container.inspect();
             table.push([project.name, project.type, Status]);
         }
-        return table.toString() + "\n";
+        return table.toString();
     }
     async start(name, detach, rebuild, restart) {
         if (name) {
@@ -203,8 +203,8 @@ let ProjectController = class ProjectController {
         if (name) {
             await this.projectService.cdProject(name);
         }
-        const containerName = `${name}.workspace`;
-        await this.dockerService.attach(containerName);
+        const project = await this.projectService.get();
+        await this.dockerService.attach(project.containerName);
     }
     async configList(name, global) {
         if (name) {
@@ -225,7 +225,7 @@ let ProjectController = class ProjectController {
         for (const i in env) {
             table.push([i, env[i]]);
         }
-        return table.toString() + "\n";
+        return table.toString();
     }
     async configGet(name, global, keys) {
         if (name) {
@@ -244,7 +244,7 @@ let ProjectController = class ProjectController {
             }
             table.push([key, value]);
         }
-        return table.toString() + "\n";
+        return table.toString();
     }
     async configSet(name, global, variables) {
         if (!global && name) {
@@ -262,6 +262,13 @@ let ProjectController = class ProjectController {
             config.setEnv(key.trim(), value.trim());
         }
         await config.save();
+        if (!global) {
+            const project = await this.projectService.get();
+            const container = await this.dockerService.getContainer(project.containerName);
+            if (container) {
+                await this.projectService.start(true);
+            }
+        }
     }
     async configUnset(name, global, configs) {
         const env = configs.reduce((env, config) => {
@@ -280,6 +287,13 @@ let ProjectController = class ProjectController {
             project.unsetEnv(i);
         }
         await project.save();
+        if (!global) {
+            const project = await this.projectService.get();
+            const container = await this.dockerService.getContainer(project.containerName);
+            if (container) {
+                await this.projectService.start(true);
+            }
+        }
     }
     async buildArgsList(name) {
         if (name) {
@@ -293,7 +307,7 @@ let ProjectController = class ProjectController {
         for (const i in buildArgs) {
             table.push([i, typeof buildArgs[i] === "string" ? buildArgs[i] : JSON.stringify(buildArgs[i])]);
         }
-        return table.toString() + "\n";
+        return table.toString();
     }
     async buildArgsGet(name, args) {
         if (name) {
@@ -310,7 +324,7 @@ let ProjectController = class ProjectController {
                 table.push([key, value]);
             }
         }
-        return table.toString() + "\n";
+        return table.toString();
     }
     async buildArgsSet(name, args) {
         if (name) {
@@ -362,7 +376,7 @@ let ProjectController = class ProjectController {
         for (const volume of volumes) {
             table.push([volume]);
         }
-        return table.toString() + "\n";
+        return table.toString();
     }
     async volumeMount(name, volumes) {
         if (name) {

package/lib/main.js

@@ -17,6 +17,7 @@ exports.app = {
             const res = await app.run(args);
             if (res) {
                 process.stdout.write(res);
+                process.stdout.write("\n");
             }
         }
         catch (err) {

package/lib/makes/FS.d.ts

@@ -2,28 +2,16 @@
 /// <reference types="node" />
 import { FS as CoreFS } from "@wocker/core";
 import * as fs from "fs";
-import { Stats, BigIntStats, PathLike, PathOrFileDescriptor, WriteFileOptions, ObjectEncodingOptions, MakeDirectoryOptions } from "fs";
+import { Stats, BigIntStats, PathLike, PathOrFileDescriptor, WriteFileOptions, MakeDirectoryOptions } from "fs";
 import { PassThrough } from "readable-stream";
-type ReaddirOptions = ObjectEncodingOptions & {
-    recursive?: boolean;
-};
 type ReaddirFilesOptions = {
     recursive?: boolean;
 };
 export declare class FS extends CoreFS {
-    protected source: string;
-    constructor(source: string);
-    path(...parts: string[]): string;
-    exists(...parts: string[]): boolean;
-    stat(...parts: string[]): fs.Stats;
-    mkdir(path: string, options?: MakeDirectoryOptions): void;
-    readdir(...parts: string[]): Promise<string[]>;
-    readdirFiles(path?: string, options?: ReaddirOptions): Promise<string[]>;
     static access(path: PathLike): Promise<any>;
     static existsSync(path: PathLike): boolean;
     static mkdir(dirPath: string, options?: MakeDirectoryOptions): Promise<void>;
     static mkdirSync(path: string, options?: MakeDirectoryOptions): string;
-    static readdir(path: PathLike): Promise<string[]>;
     static readdirFiles(path: string, options?: ReaddirFilesOptions): Promise<string[]>;
     static appendFile(path: PathOrFileDescriptor, data: any, options?: WriteFileOptions): Promise<unknown>;
     static appendFileSync(path: PathOrFileDescriptor, data: any, options?: WriteFileOptions): void;

package/lib/makes/FS.js

@@ -29,45 +29,6 @@ const fs = __importStar(require("fs"));
 const Path = __importStar(require("path"));
 const readable_stream_1 = require("readable-stream");
 class FS extends core_1.FS {
-    constructor(source) {
-        super();
-        this.source = source;
-    }
-    path(...parts) {
-        return Path.join(this.source, ...parts);
-    }
-    exists(...parts) {
-        const fullPath = this.path(...parts);
-        return FS.existsSync(fullPath);
-    }
-    stat(...parts) {
-        const fullPath = this.path(...parts);
-        return fs.statSync(fullPath);
-    }
-    mkdir(path, options) {
-        const fullPath = this.path(path);
-        fs.mkdirSync(fullPath, options);
-    }
-    async readdir(...parts) {
-        const fullPath = this.path(...parts);
-        return FS.readdir(fullPath);
-    }
-    async readdirFiles(path, options) {
-        const fullPath = this.path(path);
-        return new Promise((resolve, reject) => {
-            fs.readdir(fullPath, options, (err, files) => {
-                if (err) {
-                    reject(err);
-                    return;
-                }
-                files = files.filter((path) => {
-                    const stat = this.stat(path);
-                    return stat.isFile();
-                });
-                resolve(files);
-            });
-        });
-    }
     static async access(path) {
         return new Promise((resolve, reject) => {
             fs.access(path, (err) => {
@@ -98,18 +59,6 @@ class FS extends core_1.FS {
     static mkdirSync(path, options) {
         return fs.mkdirSync(path, options);
     }
-    static async readdir(path) {
-        return new Promise((resolve, reject) => {
-            fs.readdir(path, (err, files) => {
-                if (!err) {
-                    resolve(files);
-                }
-                else {
-                    reject(err);
-                }
-            });
-        });
-    }
     static async readdirFiles(path, options) {
         const { recursive = false } = options || {};
         if (recursive) {

package/lib/plugins/index.d.ts

@@ -2,7 +2,5 @@ export * from "./ElasticSearchPlugin";
 export * from "./LocaltunnelPlugin";
 export * from "./MaildevPlugin";
 export * from "./MongodbPlugin";
-export * from "./NgrokPlugin";
 export * from "./PageKitePlugin";
 export * from "./ProxmoxPlugin";
-export * from "./RedisPlugin";

package/lib/plugins/index.js

@@ -18,7 +18,5 @@ __exportStar(require("./ElasticSearchPlugin"), exports);
 __exportStar(require("./LocaltunnelPlugin"), exports);
 __exportStar(require("./MaildevPlugin"), exports);
 __exportStar(require("./MongodbPlugin"), exports);
-__exportStar(require("./NgrokPlugin"), exports);
 __exportStar(require("./PageKitePlugin"), exports);
 __exportStar(require("./ProxmoxPlugin"), exports);
-__exportStar(require("./RedisPlugin"), exports);

package/lib/services/DockerService.d.ts

@@ -1,7 +1,7 @@
 /// <reference types="node" />
 /// <reference types="node" />
-import Docker, { Container } from "dockerode";
 import { DockerServiceParams as Params } from "@wocker/core";
+import Docker, { Container } from "dockerode";
 import { LogService } from "./LogService";
 export declare class DockerService {
     protected readonly logService: LogService;
@@ -16,6 +16,7 @@ export declare class DockerService {
     imageLs(options?: Params.ImageList): Promise<Docker.ImageInfo[]>;
     pullImage(tag: string): Promise<void>;
     attach(name: string): Promise<void>;
+    logs(name: string): Promise<void>;
     attachStream(stream: NodeJS.ReadWriteStream): Promise<void>;
     exec(name: string, args?: string[], tty?: boolean): Promise<import("stream").Duplex>;
 }

package/lib/services/DockerService.js

@@ -13,9 +13,10 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DockerService = void 0;
-const dockerode_1 = __importDefault(require("dockerode"));
 const core_1 = require("@wocker/core");
-const utils_1 = require("../utils");
+const utils_1 = require("@wocker/utils");
+const dockerode_1 = __importDefault(require("dockerode"));
+const utils_2 = require("../utils");
 const makes_1 = require("../makes");
 const LogService_1 = require("./LogService");
 let DockerService = class DockerService {
@@ -159,7 +160,7 @@ let DockerService = class DockerService {
             }, {}),
             dockerfile: src
         });
-        await (0, utils_1.followProgress)(stream);
+        await (0, utils_2.followProgress)(stream);
     }
     async imageExists(tag) {
         const image = this.docker.getImage(tag);
@@ -209,17 +210,21 @@ let DockerService = class DockerService {
             return;
         }
         const stream = await this.docker.pull(tag);
-        await (0, utils_1.followProgress)(stream);
+        await (0, utils_2.followProgress)(stream);
     }
     async attach(name) {
         const container = await this.getContainer(name);
+        if (!container) {
+            return;
+        }
         const stream = await container.attach({
             logs: true,
             stream: true,
             hijack: true,
             stdin: true,
             stdout: true,
-            stderr: true
+            stderr: true,
+            detachKeys: "ctrl-c"
         });
         process.stdin.resume();
         process.stdin.setEncoding("utf8");
@@ -230,12 +235,8 @@ let DockerService = class DockerService {
                 process.stdin.setRawMode(false);
             }
         });
-        stream.setEncoding("utf8");
-        stream.pipe(process.stdout);
-        const [width, height] = process.stdout.getWindowSize();
-        await container.resize({
-            w: width,
-            h: height
+        stream.on("data", (data) => {
+            process.stdout.write((0, utils_1.demuxOutput)(data));
         });
         stream.on("end", async () => {
             process.exit();
@@ -247,6 +248,25 @@ let DockerService = class DockerService {
                 h: height
             });
         });
+        const [width, height] = process.stdout.getWindowSize();
+        await container.resize({
+            w: width,
+            h: height
+        });
+    }
+    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();

package/lib/services/ProjectService.js

@@ -96,10 +96,10 @@ let ProjectService = class ProjectService {
                 });
             }
         }
-        await this.appEventsService.emit("project:beforeStart", project);
         let container = await this.dockerService.getContainer(project.containerName);
         if (container && restart) {
             container = null;
+            await this.appEventsService.emit("project:stop", project);
             await this.dockerService.removeContainer(project.containerName);
         }
         if (!container) {
@@ -120,10 +120,11 @@ let ProjectService = class ProjectService {
             });
         }
         const { State: { Status } } = await container.inspect();
+        await this.appEventsService.emit("project:beforeStart", project);
         if (Status === "created" || Status === "exited") {
             await container.start();
-            await this.appEventsService.emit("project:start", project);
         }
+        await this.appEventsService.emit("project:start", project);
     }
     async stop() {
         const project = await this.get();

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@wocker/ws",
-    "version": "1.0.9",
+    "version": "1.0.10",
     "author": "Kris Papercut <krispcut@gmail.com>",
     "description": "Docker workspace for web projects",
     "license": "MIT",
@@ -26,8 +26,8 @@
     },
     "dependencies": {
         "@kearisp/cli": "^1.0.7",
-        "@wocker/core": "^1.0.9",
-        "@wocker/utils": "^1.0.3",
+        "@wocker/core": "^1.0.10",
+        "@wocker/utils": "^1.0.4",
         "async-mutex": "^0.4.0",
         "axios": "^1.6.7",
         "chalk": "^2.4.2",

package/lib/plugins/NgrokPlugin.d.ts

@@ -1,37 +0,0 @@
-import { DockerService, Project } from "@wocker/core";
-import { Cli } from "@kearisp/cli";
-import { AppEventsService, ProjectService } from "../services";
-type StartOptions = {
-    name?: string;
-    detach?: string;
-};
-type StopOptions = {
-    name?: string;
-};
-type LogsOptions = {
-    name?: string;
-};
-type AttachOptions = {
-    name?: string;
-};
-type ForwardingOptions = {
-    name?: string;
-};
-export declare class NgrokPlugin {
-    protected readonly appEventsService: AppEventsService;
-    protected readonly projectService: ProjectService;
-    protected readonly dockerService: DockerService;
-    constructor(appEventsService: AppEventsService, projectService: ProjectService, dockerService: DockerService);
-    install(cli: Cli): void;
-    init(options: any): Promise<void>;
-    getForwarding(project: Project): Promise<string | undefined>;
-    onProjectStart(project: Project): Promise<void>;
-    onProjectStop(project: Project): Promise<void>;
-    start(options: StartOptions): Promise<void>;
-    stop(options: StopOptions): Promise<void>;
-    restart(options: StartOptions): Promise<void>;
-    logs(options: LogsOptions): Promise<void>;
-    attach(options: AttachOptions): Promise<void>;
-    forwarding(options: ForwardingOptions): Promise<string>;
-}
-export {};

package/lib/plugins/NgrokPlugin.js

@@ -1,254 +0,0 @@
-"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.NgrokPlugin = void 0;
-const core_1 = require("@wocker/core");
-const utils_1 = require("@wocker/utils");
-const makes_1 = require("../makes");
-const services_1 = require("../services");
-let NgrokPlugin = class NgrokPlugin {
-    constructor(appEventsService, projectService, dockerService) {
-        this.appEventsService = appEventsService;
-        this.projectService = projectService;
-        this.dockerService = dockerService;
-    }
-    install(cli) {
-        this.appEventsService.on("project:start", (project) => this.onProjectStart(project));
-        this.appEventsService.on("project:stop", (project) => this.onProjectStop(project));
-        cli.command("ngrok:init")
-            .option("name", {
-            alias: "n",
-            type: "string",
-            description: "Project name"
-        })
-            .action((options) => this.init(options));
-        cli.command("ngrok:start")
-            .option("name", {
-            type: "string",
-            alias: "n",
-            description: "Project name"
-        })
-            .option("detach", {
-            type: "boolean",
-            alias: "d",
-            description: "Detach"
-        })
-            .action((options) => this.start(options));
-        cli.command("ngrok:stop")
-            .option("name", {
-            type: "string",
-            alias: "n",
-            description: "Project name"
-        })
-            .action((options) => this.stop(options));
-        cli.command("ngrok:restart")
-            .option("name", {
-            type: "string",
-            alias: "n",
-            description: "Project name"
-        })
-            .option("detach", {
-            type: "boolean",
-            alias: "d",
-            description: "Detach"
-        })
-            .action((options) => this.restart(options));
-        cli.command("ngrok:logs")
-            .option("name", {
-            type: "string",
-            alias: "n",
-            description: "Project name"
-        })
-            .action((options) => this.logs(options));
-        cli.command("ngrok:attach")
-            .option("name", {
-            type: "string",
-            alias: "n",
-            description: "Project name"
-        })
-            .action((options) => this.attach(options));
-        cli.command("ngrok:forwarding")
-            .option("name", {
-            type: "string",
-            alias: "n",
-            description: "Project name"
-        })
-            .action((options) => this.forwarding(options));
-    }
-    async init(options) {
-        const { name } = options;
-        if (name) {
-            await this.projectService.cdProject(name);
-        }
-        const project = await this.projectService.get();
-        const enable = await (0, utils_1.promptConfirm)({
-            message: "Enable ngrok?",
-            default: true
-        });
-        if (enable) {
-            const token = await (0, utils_1.promptText)({
-                message: "Token",
-                default: project.getEnv("NGROK_AUTHTOKEN")
-            });
-            project.setEnv("NGROK_AUTHTOKEN", token);
-            project.setEnv("NGROK_ENABLE", "true");
-        }
-        else {
-            project.setEnv("NGROK_ENABLE", "false");
-        }
-        await project.save();
-    }
-    async getForwarding(project) {
-        const container = await this.dockerService.getContainer(`ngrok-${project.name}`);
-        if (!container) {
-            throw new Error(`Ngrok for "${project.name}" not started`);
-        }
-        const { NetworkSettings: { Networks: { workspace } } } = await container.inspect();
-        const stream = await this.dockerService.exec("proxy.workspace", [
-            "curl", `http://${workspace.IPAddress}:4040/api/tunnels/command_line`
-        ], false);
-        const res = await new Promise((resolve, reject) => {
-            let res = "";
-            stream.on("data", (data) => {
-                res += (0, utils_1.demuxOutput)(data).toString();
-            });
-            stream.on("end", () => resolve(res));
-            stream.on("error", reject);
-        });
-        const tunnel = JSON.parse(res);
-        return tunnel.public_url;
-    }
-    async onProjectStart(project) {
-        if (!project || project.getEnv("NGROK_ENABLE", "false") !== "true") {
-            return;
-        }
-        const container1 = await this.dockerService.getContainer(`ngrok-${project.name}`);
-        if (container1) {
-            const { State: { Running } } = await container1.inspect();
-            if (Running) {
-                console.log("Ngrok is already running");
-                const forwarding = await this.getForwarding(project);
-                console.log(`Forwarding: ${forwarding}`);
-                return;
-            }
-            else {
-                await this.dockerService.removeContainer(`ngrok-${project.name}`);
-            }
-        }
-        console.log("Ngrok starting...");
-        makes_1.Logger.info(`Ngrok start: ${project.name}`);
-        await this.dockerService.pullImage("ngrok/ngrok:latest");
-        const container = await this.dockerService.createContainer({
-            name: `ngrok-${project.name}`,
-            image: "ngrok/ngrok:latest",
-            tty: true,
-            restart: "always",
-            env: {
-                NGROK_AUTHTOKEN: project.getEnv("NGROK_AUTHTOKEN")
-            },
-            cmd: ["http", `${project.name}.workspace:80`]
-        });
-        const stream = await container.attach({
-            logs: true,
-            stream: true,
-            hijack: true,
-            stdin: true,
-            stdout: true,
-            stderr: true
-        });
-        stream.setEncoding("utf8");
-        await container.start();
-        await container.resize({
-            w: 90,
-            h: 40
-        });
-        await new Promise((resolve, reject) => {
-            stream.on("data", (data) => {
-                const regLink = /(https?):\/\/(\w[\w.-]+[a-z]|\d+\.\d+\.\d+\.\d+)(?::(\d+))?/;
-                if (regLink.test(data.toString())) {
-                    const [link] = regLink.exec(data.toString());
-                    if (link.includes(".ngrok")) {
-                        makes_1.Logger.info(`${project.name} forwarding: ${link}`);
-                        console.log(`Forwarding: ${link}`);
-                        stream.end();
-                    }
-                }
-            });
-            stream.on("end", resolve);
-            stream.on("error", reject);
-        });
-    }
-    async onProjectStop(project) {
-        if (!project || project.getEnv("NGROK_ENABLE", "false") !== "true") {
-            return;
-        }
-        console.log("Ngrok stopping...");
-        await this.dockerService.removeContainer(`ngrok-${project.name}`);
-    }
-    async start(options) {
-        const { name, detach } = options;
-        if (name) {
-            await this.projectService.cdProject(name);
-        }
-        const project = await this.projectService.get();
-        await this.onProjectStart(project);
-        if (!detach) {
-            await this.dockerService.attach(`ngrok-${project.name}`);
-        }
-    }
-    async stop(options) {
-        const { name } = options;
-        if (name) {
-            await this.projectService.cdProject(name);
-        }
-        const project = await this.projectService.get();
-        await this.onProjectStop(project);
-    }
-    async restart(options) {
-        const { name } = options;
-        await this.stop({ name });
-        await this.start(options);
-    }
-    async logs(options) {
-        const { name } = options;
-        if (name) {
-            await this.projectService.cdProject(name);
-        }
-        const project = await this.projectService.get();
-        const container = await this.dockerService.getContainer(`ngrok-${project.name}`);
-        if (!container) {
-            throw new Error("Ngrok not started");
-        }
-    }
-    async attach(options) {
-        const { name } = options;
-        if (name) {
-            await this.projectService.cdProject(name);
-        }
-        const project = await this.projectService.get();
-        await this.dockerService.attach(`ngrok-${project.name}`);
-    }
-    async forwarding(options) {
-        const { name } = options;
-        if (name) {
-            await this.projectService.cdProject(name);
-        }
-        const project = await this.projectService.get();
-        return this.getForwarding(project);
-    }
-};
-exports.NgrokPlugin = NgrokPlugin;
-exports.NgrokPlugin = NgrokPlugin = __decorate([
-    (0, core_1.Controller)(),
-    __metadata("design:paramtypes", [services_1.AppEventsService,
-        services_1.ProjectService,
-        core_1.DockerService])
-], NgrokPlugin);

package/lib/plugins/RedisPlugin.d.ts

@@ -1,16 +0,0 @@
-import { FSManager } from "@wocker/core";
-import { Cli } from "@kearisp/cli";
-import { AppConfigService, DockerService } from "../services";
-export declare class RedisPlugin {
-    protected readonly appConfigService: AppConfigService;
-    protected readonly dockerService: DockerService;
-    protected container: string;
-    protected commander: string;
-    protected fs: FSManager;
-    constructor(appConfigService: AppConfigService, dockerService: DockerService);
-    install(cli: Cli): void;
-    up(): Promise<void>;
-    protected startCommander(): Promise<void>;
-    down(): Promise<void>;
-    protected stopCommander(): Promise<void>;
-}

package/lib/plugins/RedisPlugin.js

@@ -1,91 +0,0 @@
-"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.RedisPlugin = void 0;
-const core_1 = require("@wocker/core");
-const services_1 = require("../services");
-let RedisPlugin = class RedisPlugin {
-    constructor(appConfigService, dockerService) {
-        this.appConfigService = appConfigService;
-        this.dockerService = dockerService;
-        this.container = "redis.workspace";
-        this.commander = "redis-commander.workspace";
-        this.fs = new core_1.FSManager(this.appConfigService.pluginsPath("redis"), this.appConfigService.dataPath("plugins/redis"));
-    }
-    install(cli) {
-        cli.command("redis:start")
-            .action(() => this.up());
-        cli.command("redis:stop")
-            .action(() => this.down());
-    }
-    async up() {
-        console.log("Redis up...");
-        await this.dockerService.pullImage("redis");
-        let container = await this.dockerService.getContainer(this.container);
-        if (!container) {
-            await this.fs.mkdir("", {
-                recursive: true
-            });
-            container = await this.dockerService.createContainer({
-                name: this.container,
-                image: "redis",
-                restart: "always",
-                env: {
-                    VIRTUAL_HOST: this.container
-                },
-                volumes: [
-                    `${this.fs.path()}:/data`
-                ],
-                ports: [
-                    "6379:6379"
-                ]
-            });
-        }
-        await container.start();
-        await this.startCommander();
-    }
-    async startCommander() {
-        console.info("RedisCommander starting...");
-        let container = await this.dockerService.getContainer(this.commander);
-        if (!container) {
-            await this.dockerService.pullImage("rediscommander/redis-commander:latest");
-            container = await this.dockerService.createContainer({
-                name: this.commander,
-                image: "rediscommander/redis-commander:latest",
-                restart: "always",
-                env: {
-                    VIRTUAL_HOST: this.commander,
-                    VIRTUAL_PORT: "8081",
-                    REDIS_HOSTS: this.container
-                }
-            });
-        }
-        const { State: { Status } } = await container.inspect();
-        if (Status === "created" || Status === "exited") {
-            await container.start();
-        }
-    }
-    async down() {
-        console.log("Redis down...");
-        await this.dockerService.removeContainer(this.container);
-        await this.stopCommander();
-    }
-    async stopCommander() {
-        console.info("RedisCommander stopping...");
-        await this.dockerService.removeContainer(this.commander);
-    }
-};
-exports.RedisPlugin = RedisPlugin;
-exports.RedisPlugin = RedisPlugin = __decorate([
-    (0, core_1.Controller)(),
-    __metadata("design:paramtypes", [services_1.AppConfigService,
-        services_1.DockerService])
-], RedisPlugin);

package/plugins/ngrok/Dockerfile

@@ -1,2 +0,0 @@
-FROM ngrok/ngrok:latest
-