@wocker/ws 1.0.9 → 1.0.11

package/lib/plugins/PageKitePlugin.js

@@ -23,38 +23,6 @@ let PageKitePlugin = class PageKitePlugin {
     pluginPath(...parts) {
         return this.appConfigService.pluginsPath("pagekite", ...parts);
     }
-    install(cli) {
-        this.appEventsService.on("project:start", (project) => this.onProjectStart(project));
-        this.appEventsService.on("project:stop", (project) => this.onProjectStop(project));
-        cli.command("pagekite:init")
-            .action((options) => this.init(options));
-        cli.command("pagekite:start")
-            .option("name", {
-            type: "string",
-            alias: "n",
-            description: "Project name"
-        })
-            .option("restart", {
-            type: "boolean",
-            alias: "r",
-            description: "Restart"
-        })
-            .action((options) => this.start(options));
-        cli.command("pagekite:stop")
-            .option("name", {
-            type: "string",
-            alias: "n",
-            description: "Project name"
-        })
-            .action((options) => this.stop(options));
-        cli.command("pagekite:build")
-            .option("rebuild", {
-            type: "boolean",
-            alias: "r",
-            description: "Rebuild"
-        })
-            .action((options) => this.build(options));
-    }
     async onProjectStart(project) {
         if (!project || project.getEnv("PAGEKITE_ENABLE", "false") !== "true") {
             return;

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/PresetService.js

@@ -44,14 +44,14 @@ let PresetService = class PresetService {
     }
     async get(name) {
         const config = await makes_1.FS.readJSON(env_1.PRESETS_DIR, name, "config.json");
+        const _this = this;
         return new class extends core_1.Preset {
-            constructor(presetService, data) {
+            constructor(data) {
                 super(data);
-                this.presetService = presetService;
             }
             async save() {
             }
-        }(this, {
+        }({
             name,
             ...config
         });
@@ -64,11 +64,7 @@ let PresetService = class PresetService {
             if (name && name !== dir) {
                 continue;
             }
-            const config = await makes_1.FS.readJSON(env_1.PRESETS_DIR, dir, "config.json");
-            const preset = new core_1.Preset({
-                name: dir,
-                ...config
-            });
+            const preset = await this.get(dir);
             presets.push(preset);
         }
         return presets;

package/lib/services/ProjectService.js

@@ -100,6 +100,7 @@ let ProjectService = class ProjectService {
         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) {
@@ -122,8 +123,8 @@ let ProjectService = class ProjectService {
         const { State: { Status } } = await container.inspect();
         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,9 +1,14 @@
 {
     "name": "@wocker/ws",
-    "version": "1.0.9",
+    "version": "1.0.11",
     "author": "Kris Papercut <krispcut@gmail.com>",
     "description": "Docker workspace for web projects",
     "license": "MIT",
+    "main": "lib/index.js",
+    "types": "lib/index.d.ts",
+    "bin": {
+        "ws": "./bin/ws.js"
+    },
     "homepage": "https://kearisp.github.io/wocker",
     "repository": {
         "type": "git",
@@ -12,11 +17,6 @@
     "bugs": {
         "url": "https://github.com/kearisp/wocker-ws/issues"
     },
-    "main": "lib/index.js",
-    "types": "lib/index.d.ts",
-    "bin": {
-        "ws": "./bin/ws.js"
-    },
     "scripts": {
         "prepare": "npm run build",
         "start": "npm run watch",
@@ -25,9 +25,8 @@
         "lint": "eslint \"**/*.{js,jsx,ts,tsx}\""
     },
     "dependencies": {
-        "@kearisp/cli": "^1.0.7",
-        "@wocker/core": "^1.0.9",
-        "@wocker/utils": "^1.0.3",
+        "@wocker/core": "^1.0.11",
+        "@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
-