@wocker/ws 1.0.1

package/lib/models/Preset.js

@@ -0,0 +1,60 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Preset = void 0;
+var Path = _interopRequireWildcard(require("path"));
+var _md = _interopRequireDefault(require("md5"));
+var _env = require("../env");
+var _makes = require("../makes");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+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 Preset {
+  constructor(data) {
+    if (data) {
+      for (const i in data) {
+        this[i] = data[i];
+      }
+    }
+  }
+  getImageArgs(project) {
+    if (!this.buildArgsOptions) {
+      return {};
+    }
+    return Object.keys(this.buildArgsOptions).reduce((buildArgs, key) => {
+      buildArgs[key] = project.buildArgs[key];
+      return buildArgs;
+    }, {});
+  }
+  getImageName(buildArgs) {
+    const rawValues = [];
+    const hashValues = [];
+    Object.keys(buildArgs).forEach(key => {
+      const {
+        [key]: {
+          hash = true
+        } = {}
+      } = this.buildArgsOptions || {};
+      const value = buildArgs[key];
+      if (hash) {
+        hashValues.push(value);
+      } else {
+        rawValues.push(value);
+      }
+    });
+    const version = [...rawValues, (0, _md.default)(hashValues.join(",")).substr(0, 6)].filter(value => {
+      return !!value;
+    }).join("-");
+    return `ws-preset-${this.name}:${version}`;
+  }
+  static async get(name) {
+    const data = await _makes.FS.readJSON(Path.join(_env.PRESETS_DIR, name, "config.json"));
+    return new Preset({
+      name,
+      ...data
+    });
+  }
+}
+exports.Preset = Preset;

package/lib/models/Project.d.ts

@@ -0,0 +1,38 @@
+import { EnvConfig } from "src/types";
+type SearchOptions = {
+    id: string;
+    name: string;
+    src: string;
+};
+export declare class Project {
+    id: string;
+    type: string;
+    name: string;
+    path: string;
+    dockerfile?: string;
+    imageName?: string;
+    buildArgs?: EnvConfig;
+    env?: EnvConfig;
+    domains?: string[];
+    volumes?: string[];
+    meta?: {
+        [key: string]: string;
+    };
+    setEnv(name: string, value: string | boolean): void;
+    getEnv(name: string, defaultValue?: string): string;
+    unsetEnv(name: string): void;
+    getMeta(name: string, defaultValue?: string): string | undefined;
+    setMeta(name: string, value: string): void;
+    volumeMount(...volumes: string[]): void;
+    getVolumeBySource(source: string): string | undefined;
+    getVolumeByDestination(destination: string): string | undefined;
+    volumeUnmount(...volumes: string[]): void;
+    static get(id: string): Promise<void>;
+    save(): Promise<void>;
+    static fromObject(data: any): Project;
+    static search(params?: Partial<SearchOptions>): Promise<Project[]>;
+    static searchOne(params?: Partial<SearchOptions>): Promise<Project | null>;
+}
+export declare const PROJECT_TYPE_DOCKERFILE = "dockerfile";
+export declare const PROJECT_TYPE_IMAGE = "image";
+export {};

package/lib/models/Project.js

@@ -0,0 +1,151 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Project = exports.PROJECT_TYPE_IMAGE = exports.PROJECT_TYPE_DOCKERFILE = void 0;
+var Path = _interopRequireWildcard(require("path"));
+var _makes = require("../makes");
+var _utils = require("../utils");
+var _env = require("../env");
+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 Project {
+  setEnv(name, value) {
+    this.env = {
+      ...(this.env || {}),
+      [name]: typeof value === "boolean" ? value ? "true" : "false" : value
+    };
+  }
+  getEnv(name, defaultValue) {
+    const {
+      [name]: value = defaultValue
+    } = this.env || {};
+    return value;
+  }
+  unsetEnv(name) {
+    if (this.env && this.env[name]) {
+      delete this.env[name];
+    }
+  }
+  getMeta(name, defaultValue) {
+    const {
+      [name]: value = defaultValue
+    } = this.meta || {};
+    return value;
+  }
+  setMeta(name, value) {
+    if (!this.meta) {
+      this.meta = {};
+    }
+    this.meta[name] = value;
+  }
+  volumeMount(...volumes) {
+    if (volumes.length === 0) {
+      return;
+    }
+    const [volume, ...restVolumes] = volumes;
+    const {
+      destination
+    } = (0, _utils.volumeParse)(volume);
+    this.volumes = [...(this.volumes || []).filter(v => {
+      return v !== this.getVolumeByDestination(destination);
+    }), volume];
+    this.volumeMount(...restVolumes);
+  }
+  getVolumeBySource(source) {
+    return (this.volumes || []).find(volume => {
+      return (0, _utils.volumeParse)(volume).source === source;
+    });
+  }
+  getVolumeByDestination(destination) {
+    return (this.volumes || []).find(volume => {
+      return (0, _utils.volumeParse)(volume).destination === destination;
+    });
+  }
+  volumeUnmount(...volumes) {
+    this.volumes = this.volumes.filter(mounted => {
+      return !volumes.includes(mounted);
+    });
+  }
+  static async get(id) {
+    //
+  }
+  async save() {
+    if (!this.name) {
+      throw new Error("Project should has a name");
+    }
+    if (!this.path) {
+      throw new Error("Project should has a path");
+    }
+    if (!this.id) {
+      this.id = this.name;
+    }
+    const projectDirPath = Path.join(_env.DATA_DIR, "projects", this.name);
+    if (!_makes.FS.existsSync(projectDirPath)) {
+      await _makes.FS.mkdir(projectDirPath);
+    }
+    const configPath = Path.join(_env.DATA_DIR, "projects", this.id, "config.json");
+    await _makes.FS.writeJSON(configPath, this);
+    const config = await (0, _utils.getConfig)();
+    await (0, _utils.setConfig)({
+      ...config,
+      projects: [...(config.projects || []).filter(project => {
+        return project.id !== this.id;
+      }).filter(project => {
+        return project.src !== this.path;
+      }), {
+        id: this.id,
+        src: this.path
+      }]
+    });
+  }
+  static fromObject(data) {
+    const project = new Project();
+    for (const i in data) {
+      project[i] = data[i];
+    }
+    return project;
+  }
+  static async search(params = {}) {
+    const {
+      id,
+      name,
+      src
+    } = params;
+    const map = await _makes.FS.readJSON(_env.MAP_PATH);
+    const mapProjects = map.projects.filter(config => {
+      if (id) {
+        return config.id === id;
+      }
+      return true;
+    }).filter(config => {
+      if (src) {
+        return config.src === src;
+      }
+      return true;
+    });
+    const projects = [];
+    for (const i in mapProjects) {
+      const projectConfig = await _makes.FS.readJSON(Path.join(_env.DATA_DIR, "projects", mapProjects[i].id, "config.json"));
+      const project = Project.fromObject({
+        ...projectConfig,
+        id: projectConfig.id
+      });
+      if (name && project.name !== name) {
+        continue;
+      }
+      projects.push(project);
+    }
+    return projects;
+  }
+  static async searchOne(params = {}) {
+    const [project] = await Project.search(params);
+    return project || null;
+  }
+}
+exports.Project = Project;
+const PROJECT_TYPE_DOCKERFILE = "dockerfile";
+exports.PROJECT_TYPE_DOCKERFILE = PROJECT_TYPE_DOCKERFILE;
+const PROJECT_TYPE_IMAGE = "image";
+exports.PROJECT_TYPE_IMAGE = PROJECT_TYPE_IMAGE;

package/lib/models/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./Preset";
+export * from "./Project";

package/lib/models/index.js

@@ -0,0 +1,27 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _Preset = require("./Preset");
+Object.keys(_Preset).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _Preset[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _Preset[key];
+    }
+  });
+});
+var _Project = require("./Project");
+Object.keys(_Project).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _Project[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _Project[key];
+    }
+  });
+});

package/lib/plugins/LocaltunnelPlugin.d.ts

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

package/lib/plugins/LocaltunnelPlugin.js

@@ -0,0 +1,273 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.LocaltunnelPlugin = void 0;
+var _axios = _interopRequireDefault(require("axios"));
+var _makes = require("../makes");
+var _utils = require("../utils");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+class LocaltunnelPlugin extends _makes.Plugin {
+  constructor(appConfigService, appEventsService, projectService) {
+    super("localtunnel");
+    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("localtunnel:init").option("name", {
+      alias: "n",
+      type: "string",
+      description: "Project name"
+    }).action(options => this.init(options));
+    cli.command("localtunnel:start").option("name", {
+      alias: "n",
+      type: "string",
+      description: "Project name"
+    }).option("detach", {
+      type: "boolean",
+      alias: "d",
+      description: "Detach"
+    }).action(options => this.start(options));
+    cli.command("localtunnel:restart").option("name", {
+      alias: "n",
+      type: "string",
+      description: "Project name"
+    }).option("detach", {
+      type: "boolean",
+      alias: "d",
+      description: "Detach"
+    }).action(options => this.restart(options));
+    cli.command("localtunnel:stop").option("name", {
+      alias: "n",
+      type: "string",
+      description: "Project name"
+    }).action(options => this.stop(options));
+    cli.command("localtunnel:build").action(() => this.build());
+    cli.command("localtunnel:rebuild").action(() => this.rebuild());
+    cli.command("localtunnel:logs").option("name", {
+      alias: "n",
+      type: "string",
+      description: "Project name"
+    }).option("detach", {
+      type: "boolean",
+      alias: "d",
+      description: "Detach"
+    }).action(options => this.logs(options));
+  }
+  async getIp() {
+    const res = await _axios.default.get("https://ipv4.icanhazip.com");
+    return res.data.replace("\n", "");
+  }
+  async onProjectStart(project) {
+    if (!project || project.getEnv("LOCALTUNNEL_ENABLE", "false") !== "true") {
+      return;
+    }
+    let container = await _makes.Docker.getContainer(`localtunnel-${project.name}`);
+    if (container) {
+      const {
+        State: {
+          Running
+        }
+      } = await container.inspect();
+      if (Running) {
+        console.info("Localtunnel is already running");
+        return;
+      } else {
+        await _makes.Docker.removeContainer(`localtunnel-${project.name}`);
+      }
+    }
+    console.info("Localtunnel starting...");
+    _makes.Logger.info(`Localtunnel start: ${project.name}`);
+    await this.build();
+    const subdomain = project.getEnv("LOCALTUNNEL_SUBDOMAIN", project.name);
+    container = await _makes.Docker.createContainer({
+      name: `localtunnel-${project.name}`,
+      image: "ws-localtunnel",
+      // tty: true,
+      restart: "always",
+      networkMode: "host",
+      cmd: ["lt", `--port=80`,
+      // `--local-host=${project.name}.workspace`,
+      `--subdomain=${subdomain}`, "--print-requests"]
+    });
+    const stream = await container.attach({
+      logs: true,
+      stream: true,
+      hijack: true,
+      stdin: true,
+      stdout: true,
+      stderr: true
+    });
+    stream.setEncoding("utf8");
+    await container.start();
+    const link = await new Promise((resolve, reject) => {
+      let res = "";
+      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(".loca.lt")) {
+            res = link;
+            stream.end();
+          }
+        }
+      });
+      stream.on("end", () => resolve(res));
+      stream.on("error", reject);
+    });
+    _makes.Logger.info(`${project.name} localtunnel forwarding: ${link}`);
+    const ip = await this.getIp();
+    console.info(`IP: ${ip}`);
+    console.info(`Forwarding: ${link}`);
+    if (project.getEnv("LOCALTUNNEL_AUTO_CONFIRM", "false") === "true") {
+      console.info("Skipping IP confirmation...");
+      const res = await _axios.default.get(link, {
+        headers: {
+          "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/80.0.3987.149 Safari/537.36"
+        },
+        validateStatus: () => true
+      });
+      const [path] = /\/continue\/[\w.]+/.exec(res.data) || [];
+      if (path) {
+        const sendData = new URLSearchParams({
+          endpoint: ip
+        });
+        const res = await _axios.default.post(`${link}${path}`, sendData.toString(), {
+          headers: {
+            "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/80.0.3987.149 Safari/537.36",
+            "Content-Type": "application/x-www-form-urlencoded; charset=UTF-8"
+          }
+        });
+        if (res.status === 200) {
+          console.info("IP confirmed");
+        }
+      }
+    }
+  }
+  async onProjectStop(project) {
+    if (!project || project.getEnv("LOCALTUNNEL_ENABLE", "false") !== "true") {
+      return;
+    }
+    console.info("Localtunnel stopping...");
+    await _makes.Docker.removeContainer(`localtunnel-${project.name}`);
+  }
+  async build() {
+    const exists = await _makes.Docker.imageExists("ws-localtunnel");
+    if (!exists) {
+      await _makes.Docker.imageBuild({
+        tag: "ws-localtunnel",
+        context: this.pluginPath(),
+        src: "./Dockerfile"
+      });
+    }
+  }
+  async rebuild() {
+    try {
+      await _makes.Docker.imageRm("ws-localtunnel");
+    } catch (err) {
+      console.info(err.message);
+    }
+    await this.build();
+  }
+  async init(options) {
+    const {
+      name
+    } = options;
+    if (name) {
+      await this.projectService.cdProject(name);
+    }
+    const project = await this.projectService.get();
+    const enabled = await (0, _utils.promptConfirm)({
+      message: "Enable localtunnel?",
+      default: project.getEnv("LOCALTUNNEL_ENABLE", "false") === "true"
+    });
+    if (enabled) {
+      const subdomain = await (0, _utils.promptText)({
+        message: "Subdomain",
+        prefix: "https://",
+        suffix: ".loca.lt",
+        default: project.getEnv("LOCALTUNNEL_SUBDOMAIN")
+      });
+      if (!subdomain) {
+        throw new Error("Subdomain can't be empty");
+      }
+      const autoConfirmIP = await (0, _utils.promptConfirm)({
+        message: "Do you want to skip the IP confirmation form automatically?",
+        default: project.getEnv("LOCALTUNNEL_AUTO_CONFIRM", "true") === "true"
+      });
+      project.setEnv("LOCALTUNNEL_ENABLE", "true");
+      project.setEnv("LOCALTUNNEL_SUBDOMAIN", subdomain);
+      project.setEnv("LOCALTUNNEL_AUTO_CONFIRM", autoConfirmIP ? "true" : "false");
+    } else {
+      project.setEnv("LOCALTUNNEL_ENABLE", "false");
+    }
+    await project.save();
+  }
+  async start(options) {
+    const {
+      name,
+      detach
+    } = options;
+    if (name) {
+      await this.projectService.cdProject(name);
+    }
+    const project = await this.projectService.get();
+    if (project.getEnv("LOCALTUNNEL_ENABLE", "false") !== "true") {
+      throw new Error(`Localtunnel is not initialized. Run "ws localtunnel:init${name ? ` -n=${name}` : ""}" first.`);
+    }
+    await this.onProjectStart(project);
+    if (!detach) {
+      await this.logs({
+        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
+      // detach
+    } = options;
+    if (name) {
+      await this.projectService.cdProject(name);
+    }
+    const project = await this.projectService.get();
+    const container = await _makes.Docker.getContainer(`localtunnel-${project.name}`);
+    const stream = await container.logs({
+      follow: true,
+      stderr: true,
+      stdout: true,
+      tail: 5
+    });
+    stream.on("data", data => {
+      process.stdout.write(data);
+    });
+    stream.on("error", data => {
+      process.stderr.write(data);
+    });
+  }
+}
+exports.LocaltunnelPlugin = LocaltunnelPlugin;

package/lib/plugins/MaildevPlugin.d.ts

@@ -0,0 +1,10 @@
+import { Cli } from "@kearisp/cli";
+import { Plugin } from "src/makes";
+declare class MaildevPlugin extends Plugin {
+    protected containerName: string;
+    constructor();
+    install(cli: Cli): void;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+}
+export { MaildevPlugin };

package/lib/plugins/MaildevPlugin.js

@@ -0,0 +1,45 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.MaildevPlugin = void 0;
+var _makes = require("../makes");
+class MaildevPlugin extends _makes.Plugin {
+  containerName = "maildev.workspace";
+  constructor() {
+    super("maildev");
+  }
+  install(cli) {
+    super.install(cli);
+    cli.command("maildev:start").action(() => this.start());
+    cli.command("maildev:stop").action(() => this.stop());
+  }
+  async start() {
+    console.log("Maildev starting...");
+    const imageName = "ws-maildev";
+    if (!(await _makes.Docker.imageExists(imageName))) {
+      await _makes.Docker.imageBuild({
+        tag: "ws-maildev",
+        buildArgs: {},
+        labels: {},
+        context: this.pluginPath(),
+        src: "./Dockerfile"
+      });
+    }
+    await _makes.Docker.containerRun({
+      name: this.containerName,
+      restart: "always",
+      env: {
+        VIRTUAL_HOST: "maildev.workspace"
+      },
+      ports: ["25:25"],
+      image: imageName
+    });
+  }
+  async stop() {
+    console.log("Maildev stopping...");
+    await _makes.Docker.removeContainer(this.containerName);
+  }
+}
+exports.MaildevPlugin = MaildevPlugin;

package/lib/plugins/MariadbPlugin.d.ts

@@ -0,0 +1,25 @@
+import { Cli } from "@kearisp/cli";
+import { Plugin } from "src/makes";
+declare class MariadbPlugin extends Plugin {
+    protected dbDir: string;
+    protected user: string;
+    protected password: string;
+    constructor();
+    install(cli: Cli): void;
+    protected getDatabases(): Promise<string[]>;
+    protected getDumpDatabases(): Promise<string[]>;
+    protected getDumpFiles(database?: string): Promise<string[]>;
+    start(): Promise<void>;
+    protected startMariadb(): Promise<void>;
+    protected startAdmin(): Promise<void>;
+    stop(): Promise<void>;
+    protected stopMariadb(): Promise<void>;
+    protected stopAdmin(): Promise<void>;
+    exec(options: any, command: string[]): Promise<void>;
+    backup(database?: string): Promise<void>;
+    deleteBackup(options: any, database?: string, filename?: string): Promise<void>;
+    restore(options: any, database?: string, filename?: string): Promise<void>;
+    dump(options: any, database?: string): Promise<void>;
+    import(options: any, database?: string): Promise<void>;
+}
+export { MariadbPlugin };