@wocker/ws 1.0.1

package/lib/plugins/NgrokPlugin.js

@@ -0,0 +1,248 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.NgrokPlugin = void 0;
+var _makes = require("../makes");
+var _utils = require("../utils");
+class NgrokPlugin extends _makes.Plugin {
+  constructor(appEventsService, projectService) {
+    super("ngrok");
+    this.appEventsService = appEventsService;
+    this.projectService = projectService;
+  }
+  install(cli) {
+    super.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.promptConfirm)({
+      message: "Enable ngrok?",
+      default: true
+    });
+    if (enable) {
+      const token = await (0, _utils.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 _makes.Docker.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 _makes.Docker.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.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 _makes.Docker.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 _makes.Docker.removeContainer(`ngrok-${project.name}`);
+      }
+    }
+    console.log("Ngrok starting...");
+    _makes.Logger.info(`Ngrok start: ${project.name}`);
+    await _makes.Docker.pullImage("ngrok/ngrok:latest");
+    const container = await _makes.Docker.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.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 _makes.Docker.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 _makes.Docker.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 _makes.Docker.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 _makes.Docker.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;

package/lib/plugins/PageKitePlugin.d.ts

@@ -0,0 +1,31 @@
+import { Cli } from "@kearisp/cli";
+import { Plugin } from "src/makes";
+import { Project } from "src/models";
+import { AppConfigService, AppEventsService, ProjectService } from "src/services";
+type InitOptions = {};
+type StartOptions = {
+    name?: string;
+    detach?: boolean;
+    restart?: boolean;
+    rebuild?: boolean;
+};
+type StopOptions = {
+    name?: string;
+};
+type BuildOptions = {
+    rebuild?: boolean;
+};
+declare class PageKitePlugin extends Plugin {
+    protected appConfigService: AppConfigService;
+    protected appEventsService: AppEventsService;
+    protected projectService: ProjectService;
+    constructor(appConfigService: AppConfigService, appEventsService: AppEventsService, projectService: ProjectService);
+    install(cli: Cli): void;
+    onProjectStart(project: Project): Promise<void>;
+    onProjectStop(project: Project): Promise<void>;
+    init(options: InitOptions): Promise<void>;
+    start(options: StartOptions): Promise<void>;
+    stop(options: StopOptions): Promise<void>;
+    build(options?: BuildOptions): Promise<void>;
+}
+export { PageKitePlugin };

package/lib/plugins/PageKitePlugin.js

@@ -0,0 +1,158 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.PageKitePlugin = void 0;
+var _makes = require("../makes");
+var _utils = require("../utils");
+class PageKitePlugin extends _makes.Plugin {
+  constructor(appConfigService, appEventsService, projectService) {
+    super("pagekite");
+    this.appConfigService = appConfigService;
+    this.appEventsService = appEventsService;
+    this.projectService = projectService;
+  }
+  install(cli) {
+    super.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;
+    }
+    console.info("Pagekite starting...");
+    await this.build();
+    let container = await _makes.Docker.getContainer(`pagekite-${project.name}`);
+    if (container) {
+      const {
+        State: {
+          Running
+        }
+      } = await container.inspect();
+      if (Running) {
+        console.info("Pagekite is already running");
+        return;
+      } else {
+        await _makes.Docker.removeContainer(`pagekite-${project.name}`);
+      }
+    }
+    const subdomain = project.getEnv("PAGEKITE_SUBDOMAIN");
+    container = await _makes.Docker.createContainer({
+      name: `pagekite-${project.name}`,
+      image: "ws-pagekite",
+      tty: true,
+      restart: "always",
+      cmd: ["python", "pagekite.py", `${project.name}.workspace:80`, `${subdomain}.pagekite.me`]
+    });
+    await container.start();
+    await container.resize({
+      w: process.stdout.columns,
+      h: process.stdout.rows
+    });
+    const stream = await container.attach({
+      stream: true,
+      stdin: true,
+      stdout: true,
+      stderr: true,
+      hijack: true,
+      logs: true
+    });
+    stream.on("data", data => {
+      if (/Kites are flying and all is well\./.test(data.toString())) {
+        stream.end();
+      }
+    });
+    await _makes.Docker.attachStream(stream);
+  }
+  async onProjectStop(project) {
+    if (!project || project.getEnv("PAGEKITE_ENABLE", "false") !== "true") {
+      return;
+    }
+    console.info("Pagekite stopping...");
+    await _makes.Docker.removeContainer(`pagekite-${project.name}`);
+  }
+  async init(options) {
+    const project = await this.projectService.get();
+    const enabled = await (0, _utils.promptConfirm)({
+      message: "Enable pagekite",
+      default: project.getEnv("PAGEKITE_ENABLE", "true") === "true"
+    });
+    if (enabled) {
+      project.setEnv("PAGEKITE_ENABLE", "true");
+      const subdomain = await (0, _utils.promptText)({
+        message: "Subdomain",
+        prefix: "https://",
+        suffix: ".pagekite.me",
+        default: project.getEnv("PAGEKITE_SUBDOMAIN", project.name)
+      });
+      project.setEnv("PAGEKITE_SUBDOMAIN", subdomain);
+    } else {
+      project.setEnv("PAGEKITE_ENABLE", "false");
+    }
+    await project.save();
+  }
+  async start(options) {
+    const {
+      name,
+      restart
+    } = options;
+    if (name) {
+      await this.projectService.cdProject(name);
+    }
+    const project = await this.projectService.get();
+    if (restart) {
+      await _makes.Docker.removeContainer(`pagekite-${project.name}`);
+    }
+    await this.onProjectStart(project);
+  }
+  async stop(options) {
+    const {
+      name
+    } = options;
+    if (name) {
+      await this.projectService.cdProject(name);
+    }
+    const project = await this.projectService.get();
+    await this.onProjectStop(project);
+  }
+  async build(options = {}) {
+    const {
+      rebuild
+    } = options;
+    const exists = await _makes.Docker.imageExists("ws-pagekite");
+    if (rebuild) {
+      await _makes.Docker.removeContainer("ws-pagekite");
+    }
+    if (!exists || rebuild) {
+      const stream = await _makes.Docker.imageBuild2({
+        tag: "ws-pagekite",
+        context: this.pluginPath(),
+        src: "./Dockerfile"
+      });
+      await (0, _utils.followProgress)(stream);
+    }
+  }
+}
+exports.PageKitePlugin = PageKitePlugin;

package/lib/plugins/PostgresPlugin.d.ts

@@ -0,0 +1,16 @@
+import { Cli } from "@kearisp/cli";
+import { Plugin } from "src/makes";
+declare class PostgresPlugin extends Plugin {
+    protected container: string;
+    protected adminContainer: string;
+    constructor();
+    install(cli: Cli): void;
+    start(): Promise<void>;
+    protected startDB(): Promise<void>;
+    protected startAdmin(): Promise<void>;
+    stop(): Promise<void>;
+    protected stopDB(): Promise<void>;
+    protected stopAdmin(): Promise<void>;
+    restart(): Promise<void>;
+}
+export { PostgresPlugin };

package/lib/plugins/PostgresPlugin.js

@@ -0,0 +1,94 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.PostgresPlugin = void 0;
+var Path = _interopRequireWildcard(require("path"));
+var _env = require("../env");
+var _makes = require("../makes");
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+class PostgresPlugin extends _makes.Plugin {
+  container = "postgres.workspace";
+  adminContainer = "dbadmin-postgres.workspace";
+  constructor() {
+    super("postgres");
+    this.dataDir = Path.join(_env.DATA_DIR, "db/postgres");
+  }
+  install(cli) {
+    super.install(cli);
+    cli.command("postgres:start").action(() => this.start());
+    cli.command("postgres:stop").action(() => this.stop());
+    cli.command("postgres:restart").action(() => this.restart());
+  }
+  async start() {
+    await this.startDB();
+    await this.startAdmin();
+  }
+  async startDB() {
+    console.log("Postgres starting...");
+    await _makes.Docker.pullImage("postgres:latest");
+    const container = await _makes.Docker.createContainer({
+      name: this.container,
+      restart: "always",
+      image: "postgres:latest",
+      volumes: [`${this.dataPath()}:/var/lib/postgresql/data`],
+      ports: ["5432:5432"],
+      env: {
+        POSTGRES_USER: "root",
+        POSTGRES_PASSWORD: "toor"
+      }
+    });
+    await container.start();
+  }
+  async startAdmin() {
+    console.log("Postgres Admin starting...");
+    await _makes.Docker.pullImage("dpage/pgadmin4:latest");
+    const container = await _makes.Docker.createContainer({
+      name: this.adminContainer,
+      restart: "always",
+      links: [`${this.container}:postgres`],
+      env: {
+        PGADMIN_DEFAULT_EMAIL: "postgres@workspace.com.ua",
+        PGADMIN_DEFAULT_PASSWORD: "toor",
+        VIRTUAL_HOST: this.adminContainer
+      },
+      image: "dpage/pgadmin4:latest"
+    });
+    await container.start();
+  }
+  async stop() {
+    await this.stopDB();
+    await this.stopAdmin();
+  }
+  async stopDB() {
+    console.log("Postgres stopping...");
+    const container = await _makes.Docker.getContainer(this.container);
+    if (container) {
+      try {
+        await container.stop();
+        await container.remove();
+      } catch (err) {
+        _makes.Logger.error(err.message);
+      }
+    }
+  }
+  async stopAdmin() {
+    console.log("Stopping postgres admin...");
+    const container = await _makes.Docker.getContainer(this.adminContainer);
+    if (container) {
+      try {
+        await container.stop();
+        await container.remove();
+      } catch (err) {
+        _makes.Logger.error(err.message);
+      }
+    }
+  }
+  async restart() {
+    await this.stop();
+    await this.start();
+  }
+}
+exports.PostgresPlugin = PostgresPlugin;

package/lib/plugins/PresetPlugin.d.ts

@@ -0,0 +1,19 @@
+import { Cli } from "@kearisp/cli";
+import { Plugin } from "src/makes";
+import { Project } from "src/models";
+import { AppConfigService, AppEventsService } from "src/services";
+type BuildOptions = {
+    rebuild?: boolean;
+};
+declare class PresetPlugin extends Plugin {
+    protected appConfigService: AppConfigService;
+    protected appEventsService: AppEventsService;
+    constructor(appConfigService: AppConfigService, appEventsService: AppEventsService);
+    install(cli: Cli): void;
+    presets(): Promise<string[]>;
+    protected onInit(project: Project): Promise<void>;
+    protected onRebuild(project: Project): Promise<void>;
+    protected onBeforeStart(project: Project): Promise<void>;
+    build(options: BuildOptions, presetName: string): Promise<void>;
+}
+export { PresetPlugin };