@wocker/ws 1.0.1

package/lib/plugins/PresetPlugin.js

@@ -0,0 +1,164 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.PresetPlugin = void 0;
+var Path = _interopRequireWildcard(require("path"));
+var _env = require("../env");
+var _makes = require("../makes");
+var _models = require("../models");
+var _utils = require("../utils");
+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 PresetPlugin extends _makes.Plugin {
+  constructor(appConfigService, appEventsService) {
+    super("preset");
+    this.appConfigService = appConfigService;
+    this.appEventsService = appEventsService;
+    this.pluginDir = Path.join(_env.ROOT_DIR, "presets");
+  }
+  install(cli) {
+    super.install(cli);
+    this.appConfigService.registerProjectType("preset", "Preset");
+    this.appEventsService.on("project:init", project => this.onInit(project));
+    this.appEventsService.on("project:rebuild", project => this.onRebuild(project));
+    this.appEventsService.on("project:beforeStart", project => this.onBeforeStart(project));
+    cli.command("preset:build <preset>").completion("preset", () => this.presets()).option("rebuild", {
+      alias: "r",
+      type: "boolean",
+      description: "Rebuild image"
+    }).action((options, preset) => this.build(options, preset));
+  }
+  async presets() {
+    return _makes.FS.readdir(this.pluginPath());
+  }
+  async onInit(project) {
+    if (project.type !== "preset") {
+      return;
+    }
+    const presetName = await (0, _utils.promptSelect)({
+      message: "Select preset",
+      options: await _makes.FS.readdir(_env.PRESETS_DIR),
+      default: project.getEnv("PRESET_NAME")
+    });
+    const preset = await _models.Preset.get(presetName);
+    project.setEnv("PRESET_NAME", presetName);
+    if (preset.buildArgsOptions) {
+      project.buildArgs = await (0, _utils.promptGroup)(project.buildArgs || {}, preset.buildArgsOptions);
+    }
+    if (preset.envOptions) {
+      project.env = await (0, _utils.promptGroup)(project.env || {}, preset.envOptions);
+    }
+    if (preset.volumeOptions) {
+      for (let volume of preset.volumeOptions) {
+        volume = (0, _utils.injectVariables)(volume, {
+          ...(project.buildArgs || {}),
+          ...(project.env || {})
+        });
+        const {
+          destination,
+          options
+        } = (0, _utils.volumeParse)(volume);
+        let projectVolume = project.getVolumeByDestination(destination);
+        const source = await (0, _utils.promptText)({
+          message: "Volume",
+          suffix: `:${destination}`,
+          default: projectVolume ? (0, _utils.volumeParse)(projectVolume).source : "./"
+        });
+        projectVolume = (0, _utils.volumeFormat)({
+          source,
+          destination,
+          options
+        });
+        project.volumeMount(projectVolume);
+      }
+    }
+    if (preset.dockerfile) {
+      project.imageName = preset.getImageName(project.buildArgs);
+    }
+  }
+  async onRebuild(project) {
+    if (project.type !== "preset") {
+      return;
+    }
+    const presetName = project.getEnv("PRESET_NAME");
+    const preset = await _models.Preset.get(presetName);
+    if (!preset) {
+      throw new Error(`Preset ${presetName} not found`);
+    }
+    const imageName = preset.getImageName(project.buildArgs || {});
+    const exists = await _makes.Docker.imageExists(imageName);
+    if (exists) {
+      console.info(`Removing image: ${imageName}`);
+      await _makes.Docker.imageRm(imageName);
+    }
+  }
+  async onBeforeStart(project) {
+    if (project.type !== "preset") {
+      return;
+    }
+    const presetName = project.getEnv("PRESET_NAME");
+    const preset = await _models.Preset.get(presetName);
+    const config = await _makes.FS.readJSON(this.pluginPath(project.getEnv("PRESET_NAME"), "config.json"));
+
+    // if(preset.volumes) {
+    //     project.volumeMount(...preset.volumes);
+    // }
+
+    // if(preset.image) {
+    //     project.imageName = config.image;
+    //
+    //     return;
+    // }
+
+    if (preset.dockerfile) {
+      project.imageName = preset.getImageName(project.buildArgs);
+      _makes.Logger.info(project.imageName);
+      if (!(await _makes.Docker.imageExists(project.imageName))) {
+        const stream = await _makes.Docker.imageBuild2({
+          tag: project.imageName,
+          context: this.pluginPath(presetName),
+          src: config.dockerfile,
+          labels: {
+            presetName
+          },
+          buildArgs: project.buildArgs
+        });
+        await (0, _utils.followProgress)(stream);
+      }
+    }
+  }
+  async build(options, presetName) {
+    const {
+      rebuild
+    } = options;
+    const preset = await _models.Preset.get(presetName);
+    const presetPath = this.pluginPath(presetName);
+    let buildArgs = {};
+    if (preset.buildArgsOptions) {
+      buildArgs = await (0, _utils.promptGroup)(buildArgs, preset.buildArgsOptions);
+    }
+    const imageName = preset.getImageName(buildArgs);
+    _makes.Logger.info("Image name:", imageName);
+    _makes.Logger.info("Build args:", buildArgs);
+    if (rebuild) {
+      const exists = await _makes.Docker.imageExists(imageName);
+      if (exists) {
+        await _makes.Docker.imageRm(imageName);
+      }
+    }
+    const stream = await _makes.Docker.imageBuild2({
+      tag: imageName,
+      context: presetPath,
+      src: preset.dockerfile,
+      labels: {
+        presetName,
+        ...buildArgs
+      },
+      buildArgs
+    });
+    await (0, _utils.followProgress)(stream);
+  }
+}
+exports.PresetPlugin = PresetPlugin;

package/lib/plugins/ProjectPlugin.d.ts

@@ -0,0 +1,12 @@
+import { Cli } from "@kearisp/cli";
+import { Plugin } from "src/makes";
+type ProjectListOptions = {
+    all?: boolean;
+};
+declare class ProjectPlugin extends Plugin {
+    constructor();
+    install(cli: Cli): void;
+    projectList(options: ProjectListOptions): Promise<string>;
+    init(): Promise<void>;
+}
+export { ProjectPlugin };

package/lib/plugins/ProjectPlugin.js

@@ -0,0 +1,54 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ProjectPlugin = void 0;
+var _cliTable = _interopRequireDefault(require("cli-table3"));
+var _makes = require("../makes");
+var _models = require("../models");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+class ProjectPlugin extends _makes.Plugin {
+  constructor() {
+    super("project");
+  }
+  install(cli) {
+    super.install(cli);
+    cli.command("ps").option("all", {
+      type: "boolean",
+      alias: "a",
+      description: "All projects"
+    }).action(options => this.projectList(options));
+  }
+  async projectList(options) {
+    const {
+      all
+    } = options;
+    const projects = await _models.Project.search();
+    const table = new _cliTable.default({
+      head: ["Name", "Type", "Status"],
+      colAligns: ["left", "center"]
+    });
+    for (const i in projects) {
+      const project = projects[i];
+      const container = await _makes.Docker.getContainer(`${project.name}.workspace`);
+      if (!container) {
+        if (all) {
+          table.push([project.name, project.type, "-"]);
+        }
+        continue;
+      }
+      const {
+        State: {
+          Status = "Stopped"
+        } = {}
+      } = await container.inspect();
+      table.push([project.name, project.type, Status]);
+    }
+    return table.toString();
+  }
+  async init() {
+    //
+  }
+}
+exports.ProjectPlugin = ProjectPlugin;

package/lib/plugins/ProxmoxPlugin.d.ts

@@ -0,0 +1,9 @@
+import { Cli } from "@kearisp/cli";
+import { Plugin } from "src/makes";
+export declare class ProxmoxPlugin extends Plugin {
+    protected configDir: string;
+    constructor();
+    install(cli: Cli): void;
+    up(): Promise<void>;
+    down(): Promise<void>;
+}

package/lib/plugins/ProxmoxPlugin.js

@@ -0,0 +1,55 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ProxmoxPlugin = void 0;
+var Path = _interopRequireWildcard(require("path"));
+var _makes = require("../makes");
+var _utils = require("../utils");
+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 ProxmoxPlugin extends _makes.Plugin {
+  constructor() {
+    super("proxmox");
+    this.configDir = Path.join(__dirname, "../../services/proxmox");
+  }
+  install(cli) {
+    super.install(cli);
+  }
+  async up() {
+    const container = await _makes.Docker.getContainer("proxmox.workspace");
+    if (container) {
+      await this.down();
+    }
+    await (0, _utils.exec)(`
+            docker build \
+                --tag "ws-proxmox" \
+                --file "${this.pluginPath("./Dockerfile")}" \
+                ${this.pluginPath()}
+        `);
+
+    // --add-host=""
+
+    await (0, _utils.exec)(`
+            docker run -d \
+                --name proxmox.workspace \
+                --network workspace \
+                -e VIRTUAL_HOST=proxmox.workspace \
+                -p 8006:8006 \
+                ws-proxmox
+        `);
+  }
+  async down() {
+    await (0, _utils.exec)("docker stop proxmox.workspace").catch(() => {
+      //
+    });
+    await (0, _utils.exec)("docker rm proxmox.workspace").catch(() => {
+      //
+    });
+    await (0, _utils.exec)("docker image rm ws-proxmox").catch(() => {
+      //
+    });
+  }
+}
+exports.ProxmoxPlugin = ProxmoxPlugin;

package/lib/plugins/ProxyPlugin.d.ts

@@ -0,0 +1,33 @@
+import { Cli } from "@kearisp/cli";
+import { Plugin } from "src/makes";
+import { Project } from "src/models";
+import { AppConfigService, AppEventsService, ProjectService } from "src/services";
+type InitOptions = {
+    "http-port"?: number;
+    "https-port"?: number;
+};
+type DomainsOptions = {
+    name?: string;
+};
+declare class ProxyPlugin extends Plugin {
+    protected appConfigService: AppConfigService;
+    protected appEventsService: AppEventsService;
+    protected projectService: ProjectService;
+    protected containerName: string;
+    constructor(appConfigService: AppConfigService, appEventsService: AppEventsService, projectService: ProjectService);
+    install(cli: Cli): void;
+    getProjectNames(): Promise<string[]>;
+    onProjectStart(project: Project): Promise<void>;
+    createNetwork(): Promise<void>;
+    init(options: InitOptions): Promise<void>;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    restart(): Promise<void>;
+    logs(): Promise<void>;
+    domainList(options: DomainsOptions): Promise<string>;
+    addDomain(options: DomainsOptions, addDomains: string[]): Promise<void>;
+    removeDomain(options: DomainsOptions, removeDomains: string[]): Promise<void>;
+    setDomains(options: DomainsOptions, domains: string[]): Promise<void>;
+    clearDomains(options: DomainsOptions): Promise<void>;
+}
+export { ProxyPlugin };

package/lib/plugins/ProxyPlugin.js

@@ -0,0 +1,257 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ProxyPlugin = void 0;
+var _chalk = _interopRequireDefault(require("chalk"));
+var _cliTable = _interopRequireDefault(require("cli-table3"));
+var _makes = require("../makes");
+var _models = require("../models");
+var _utils = require("../utils");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+class ProxyPlugin extends _makes.Plugin {
+  containerName = "proxy.workspace";
+  constructor(appConfigService, appEventsService, projectService) {
+    super("proxy");
+    this.appConfigService = appConfigService;
+    this.appEventsService = appEventsService;
+    this.projectService = projectService;
+  }
+  install(cli) {
+    super.install(cli);
+    this.appEventsService.on("project:beforeStart", project => this.onProjectStart(project));
+    cli.command("proxy:init").option("http-port", {
+      type: "number",
+      description: "Http port"
+    }).option("https-port", {
+      type: "number",
+      description: "Https port"
+    }).action(options => this.init(options));
+    cli.command("proxy:start").action(() => this.start());
+    cli.command("proxy:stop").action(() => this.stop());
+    cli.command("proxy:restart").action(() => this.restart());
+    cli.command("proxy:logs").action(() => this.logs());
+    cli.command("domains").option("name", {
+      type: "string",
+      alias: "n"
+    }).completion("name", () => this.getProjectNames()).action(options => this.domainList(options));
+    cli.command("domain:add [...domains]").option("name", {
+      type: "string",
+      alias: "n"
+    }).completion("name", () => this.getProjectNames()).action((options, domains) => this.addDomain(options, domains));
+    cli.command("domain:remove [...domains]").option("name", {
+      type: "string",
+      alias: "n"
+    }).completion("name", () => this.getProjectNames()).action((options, domains) => this.removeDomain(options, domains));
+    cli.command("domain:set [...domains]").option("name", {
+      type: "string",
+      alias: "n"
+    }).completion("name", () => this.getProjectNames()).action((options, domains) => this.setDomains(options, domains));
+    cli.command("domain:clear").option("name", {
+      type: "string",
+      alias: "n"
+    }).action(options => this.clearDomains(options));
+  }
+  async getProjectNames() {
+    const projects = await _models.Project.search();
+    return projects.map(project => {
+      return project.name;
+    });
+  }
+  async onProjectStart(project) {
+    await this.createNetwork();
+    if (!project.getEnv("VIRTUAL_HOST")) {
+      project.setEnv("VIRTUAL_HOST", `${project.name}.workspace`);
+    }
+  }
+  async createNetwork() {
+    const networks = await _makes.Docker.docker.listNetworks();
+    const workspaceNetwork = networks.find(network => network.Name === "workspace");
+    if (!workspaceNetwork) {
+      console.info("Creating \"workspace\" network.");
+      await _makes.Docker.docker.createNetwork({
+        Name: "workspace"
+      });
+    }
+  }
+  async init(options) {
+    let {
+      "http-port": httpPort,
+      "https-port": httpsPort
+    } = options;
+    _makes.Logger.log(typeof httpPort, typeof httpsPort);
+    if (typeof httpPort === "undefined" || isNaN(httpPort)) {
+      httpPort = await (0, _utils.promptText)({
+        required: true,
+        label: "Http port",
+        type: "integer",
+        default: await this.appConfigService.getEnvVariable("PROXY_HTTP_PORT", "80")
+      });
+    }
+    await this.appConfigService.setEnvVariable("PROXY_HTTP_PORT", httpPort);
+    if (typeof httpsPort === "undefined" || httpsPort === null) {
+      httpsPort = await (0, _utils.promptText)({
+        required: true,
+        label: "Https port",
+        type: "integer",
+        default: await this.appConfigService.getEnvVariable("PROXY_HTTPS_PORT", "443")
+      });
+    }
+    await this.appConfigService.setEnvVariable("PROXY_HTTPS_PORT", httpsPort);
+  }
+  async start() {
+    console.info("Proxy starting...");
+    await _makes.Docker.pullImage("nginxproxy/nginx-proxy");
+    const httpPort = await this.appConfigService.getEnvVariable("PROXY_HTTP_PORT", "80");
+    const httpsPort = await this.appConfigService.getEnvVariable("PROXY_HTTPS_PORT", "443");
+    const container = await _makes.Docker.createContainer({
+      name: this.containerName,
+      image: "nginxproxy/nginx-proxy",
+      restart: "always",
+      volumes: ["/var/run/docker.sock:/tmp/docker.sock:ro", `${this.certsPath()}:/etc/nginx/certs`],
+      ports: [`${httpPort}:${httpPort}`, `${httpsPort}:${httpsPort}`],
+      env: {
+        DEFAULT_HOST: "index.workspace",
+        HTTP_PORT: httpPort,
+        HTTPS_PORT: httpsPort
+      }
+    });
+    await container.start();
+  }
+  async stop() {
+    console.info("Proxy stopping...");
+    const container = await _makes.Docker.getContainer(this.containerName);
+    if (container) {
+      try {
+        await container.stop();
+      } catch (err) {
+        //
+      }
+      try {
+        await container.remove();
+      } catch (err) {
+        //
+      }
+    }
+  }
+  async restart() {
+    await this.stop();
+    await this.start();
+  }
+  async logs() {
+    const container = await _makes.Docker.getContainer(this.containerName);
+    if (container) {
+      const stream = await container.logs({
+        follow: true,
+        stdout: true,
+        stderr: true
+      });
+      stream.on("data", data => {
+        process.stdout.write((0, _utils.demuxOutput)(data));
+      });
+    }
+  }
+  async domainList(options) {
+    const {
+      name
+    } = options;
+    const project = await _models.Project.searchOne(name ? {
+      name
+    } : {
+      src: this.appConfigService.getPWD()
+    });
+    if (!project) {
+      throw new Error("Project not found");
+    }
+    const table = new _cliTable.default({
+      head: [_chalk.default.yellow("Domain")]
+    });
+    const domains = project.getEnv("VIRTUAL_HOST", "").split(",");
+    for (const domain of domains) {
+      table.push([domain]);
+    }
+    return table.toString();
+  }
+  async addDomain(options, addDomains) {
+    const {
+      name
+    } = options;
+    if (name) {
+      await this.projectService.cdProject(name);
+    }
+    const project = await this.projectService.get();
+    if (!project) {
+      throw new Error("Project not found");
+    }
+    let domains = project.getEnv("VIRTUAL_HOST", "").split(",").filter(domain => {
+      return !!domain;
+    });
+    domains = [...domains, ...addDomains.filter(domain => {
+      return !domains.find(existDomain => {
+        return existDomain === domain;
+      });
+    })];
+    project.setEnv("VIRTUAL_HOST", domains.join(","));
+    await project.save();
+    const container = await _makes.Docker.getContainer(`${project.name}.workspace`);
+    if (container) {
+      await this.projectService.stop();
+      await this.projectService.start();
+    }
+  }
+  async removeDomain(options, removeDomains) {
+    const {
+      name
+    } = options;
+    const project = await _models.Project.searchOne(name ? {
+      name
+    } : {
+      src: this.appConfigService.getPWD()
+    });
+    if (!project) {
+      throw new Error("Project not found");
+    }
+    let domains = project.getEnv("VIRTUAL_HOST", "").split(",").filter(domain => {
+      return !!domain;
+    });
+    domains = domains.filter(domain => {
+      return !removeDomains.find(removeDomain => {
+        return removeDomain === domain;
+      });
+    });
+    project.setEnv("VIRTUAL_HOST", domains.join(","));
+    await project.save();
+  }
+  async setDomains(options, domains) {
+    const {
+      name
+    } = options;
+    const project = await _models.Project.searchOne(name ? {
+      name
+    } : {
+      src: this.appConfigService.getPWD()
+    });
+    if (!project) {
+      throw new Error("Project not found");
+    }
+    project.setEnv("VIRTUAL_HOST", domains.join(","));
+    await project.save();
+  }
+  async clearDomains(options) {
+    const {
+      name
+    } = options;
+    const project = await _models.Project.searchOne(name ? {
+      name
+    } : {
+      src: this.appConfigService.getPWD()
+    });
+    if (!project) {
+      throw new Error("Project not found");
+    }
+    project.unsetEnv("VIRTUAL_HOST");
+    await project.save();
+  }
+}
+exports.ProxyPlugin = ProxyPlugin;

package/lib/plugins/RedisPlugin.d.ts

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

package/lib/plugins/RedisPlugin.js

@@ -0,0 +1,42 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.RedisPlugin = void 0;
+var _makes = require("../makes");
+class RedisPlugin extends _makes.Plugin {
+  container = "redis.workspace";
+  constructor() {
+    super("redis");
+  }
+  install(cli) {
+    super.install(cli);
+    cli.command("redis:start").action(() => this.up());
+    cli.command("redis:stop").action(() => this.down());
+  }
+  async up() {
+    console.log("Redis up...");
+    await _makes.Docker.pullImage("redis");
+    const container = await _makes.Docker.createContainer({
+      name: this.container,
+      restart: "always",
+      env: {
+        VIRTUAL_HOST: this.container
+      },
+      volumes: [`${this.dataPath()}:/data`],
+      ports: ["6379:6379"],
+      image: "redis"
+    });
+    await container.start();
+  }
+  async down() {
+    console.log("Redis down...");
+    const container = await _makes.Docker.getContainer(this.container);
+    await container.stop().catch(() => {
+      //
+    });
+    await container.remove();
+  }
+}
+exports.RedisPlugin = RedisPlugin;

package/lib/plugins/ServeoPlugin.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;
+    rebuild?: boolean;
+    detach?: boolean;
+};
+type StopOptions = {
+    name?: string;
+};
+type LogsOptions = {
+    name?: string;
+    detach?: boolean;
+};
+declare class ServeoPlugin 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>;
+    restart(options: StartOptions): Promise<void>;
+    build(): Promise<void>;
+    rebuild(): Promise<void>;
+    logs(options: LogsOptions): Promise<void>;
+}
+export { ServeoPlugin };