@wocker/ws 1.0.1

package/lib/services/ProjectService.js

@@ -0,0 +1,91 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ProjectService = void 0;
+var Path = _interopRequireWildcard(require("path"));
+var _makes = require("../makes");
+var _models = require("../models");
+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 ProjectService {
+  constructor(appConfigService, appEventsService) {
+    this.appConfigService = appConfigService;
+    this.appEventsService = appEventsService;
+  }
+  async cdProject(name) {
+    const project = await _models.Project.searchOne({
+      name
+    });
+    if (!project) {
+      throw new Error("Project not found");
+    }
+    this.appConfigService.setPWD(project.path);
+  }
+  async get() {
+    const project = await _models.Project.searchOne({
+      src: this.appConfigService.getPWD()
+    });
+    if (!project) {
+      throw new Error("Project not found");
+    }
+    return project;
+  }
+  async start() {
+    const project = await this.get();
+    if (project.type === "dockerfile") {
+      project.imageName = `project-${project.name}:develop`;
+      const images = await _makes.Docker.imageLs({
+        tag: project.imageName
+      });
+      if (images.length === 0) {
+        await _makes.Docker.imageBuild2({
+          tag: project.imageName,
+          context: this.appConfigService.getPWD(),
+          src: project.dockerfile
+        });
+      }
+    }
+    await this.appEventsService.emit("project:beforeStart", project);
+    const containerName = `${project.name}.workspace`;
+    let container = await _makes.Docker.getContainer(containerName);
+    if (!container) {
+      container = await _makes.Docker.createContainer({
+        name: containerName,
+        image: project.imageName,
+        env: {
+          ...(await this.appConfigService.getAllEnvVariables()),
+          ...(project.env || {})
+        },
+        volumes: (project.volumes || []).map(volume => {
+          const regVolume = /^([^:]+):([^:]+)(?::([^:]+))?$/;
+          const [, source, destination, options] = regVolume.exec(volume);
+          return `${Path.join(this.appConfigService.getPWD(), source)}:${destination}` + (options ? `:${options}` : "");
+        })
+      });
+    } else {
+      process.stdout.write("Container already exists\n");
+    }
+    if (container) {
+      const {
+        State: {
+          Status
+        }
+      } = await container.inspect();
+      if (Status === "created" || Status === "exited") {
+        await container.start();
+        await this.appEventsService.emit("project:start", project);
+      }
+    }
+  }
+  async stop() {
+    const project = await this.get();
+    const container = await _makes.Docker.getContainer(`${project.name}.workspace`);
+    if (container) {
+      await this.appEventsService.emit("project:stop", project);
+      await _makes.Docker.removeContainer(`${project.name}.workspace`);
+    }
+  }
+}
+exports.ProjectService = ProjectService;

package/lib/services/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./AppConfigService";
+export * from "./AppEventsService";
+export * from "./ProjectService";

package/lib/services/index.js

@@ -0,0 +1,38 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _AppConfigService = require("./AppConfigService");
+Object.keys(_AppConfigService).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _AppConfigService[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _AppConfigService[key];
+    }
+  });
+});
+var _AppEventsService = require("./AppEventsService");
+Object.keys(_AppEventsService).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _AppEventsService[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _AppEventsService[key];
+    }
+  });
+});
+var _ProjectService = require("./ProjectService");
+Object.keys(_ProjectService).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _ProjectService[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _ProjectService[key];
+    }
+  });
+});

package/lib/types/Config.d.ts

@@ -0,0 +1,11 @@
+export type Config = {
+    debug?: boolean;
+    env: {
+        [key: string]: string;
+    };
+    projects: {
+        id: string;
+        name?: string;
+        src: string;
+    }[];
+};

package/lib/types/Config.js

@@ -0,0 +1,5 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});

package/lib/types/EnvConfig.d.ts

@@ -0,0 +1,3 @@
+export type EnvConfig = {
+    [key: string]: string;
+};

package/lib/types/EnvConfig.js

@@ -0,0 +1,5 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});

package/lib/types/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./Config";
+export * from "./EnvConfig";

package/lib/types/index.js

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

package/lib/utils/buildOptions.d.ts

@@ -0,0 +1 @@
+export declare const buildOptions: (name: string, options: any) => string;

package/lib/utils/buildOptions.js

@@ -0,0 +1,12 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.buildOptions = void 0;
+const buildOptions = (name, options) => {
+  return Object.keys(options).map(key => {
+    return `--${name} ${key}=${options[key]}`;
+  }).join(" ");
+};
+exports.buildOptions = buildOptions;

package/lib/utils/demuxOutput.d.ts

@@ -0,0 +1,2 @@
+/// <reference types="node" />
+export declare const demuxOutput: (buffer: any) => Buffer;

package/lib/utils/demuxOutput.js

@@ -0,0 +1,25 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.demuxOutput = void 0;
+const demuxOutput = buffer => {
+  let nextDataLength = null,
+    output = Buffer.from([]);
+  while (buffer.length > 0) {
+    // Logger.info(buffer.length, buffer.toString("utf8"));
+
+    const header = bufferSlice(8);
+    nextDataLength = header.readUInt32BE(4);
+    const content = bufferSlice(nextDataLength);
+    output = Buffer.concat([output, content]);
+  }
+  function bufferSlice(end) {
+    const out = buffer.slice(0, end);
+    buffer = Buffer.from(buffer.slice(end, buffer.length));
+    return out;
+  }
+  return output;
+};
+exports.demuxOutput = demuxOutput;

package/lib/utils/escapeRegExp.d.ts

@@ -0,0 +1,2 @@
+declare const escapeRegExp: (string: string) => string;
+export { escapeRegExp };

package/lib/utils/escapeRegExp.js

@@ -0,0 +1,10 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.escapeRegExp = void 0;
+const escapeRegExp = string => {
+  return string.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+};
+exports.escapeRegExp = escapeRegExp;

package/lib/utils/exec.d.ts

@@ -0,0 +1,2 @@
+declare const exec: (command: any) => Promise<unknown>;
+export { exec };

package/lib/utils/exec.js

@@ -0,0 +1,44 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.exec = void 0;
+var _child_process = require("child_process");
+var _chalk = _interopRequireDefault(require("chalk"));
+var _Logger = require("../makes/Logger");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+const exec = async command => {
+  _Logger.Logger.info(` > ${command.trim().replace(/\s+/g, " ")}`);
+  return new Promise((resolve, reject) => {
+    const worker = (0, _child_process.exec)(command, {
+      maxBuffer: Infinity
+    }, (err, stdout, stderr) => {
+      if (err) {
+        return reject(err);
+      }
+      return resolve({
+        stdout,
+        stderr
+      });
+    });
+    if (worker.stdout) {
+      worker.stdout.on("data", data => {
+        process.stdout.write(data);
+      });
+    }
+    if (worker.stderr) {
+      worker.stderr.on("data", data => {
+        // process.stdout.write(chalk.red(data));
+        process.stderr.write(data);
+      });
+    }
+    worker.on("close", code => {
+      _Logger.Logger.info("close", _chalk.default.red(code));
+    });
+    worker.on("exit", code => {
+      _Logger.Logger.info("exit", _chalk.default.red(code));
+    });
+  });
+};
+exports.exec = exec;

package/lib/utils/fetch.d.ts

@@ -0,0 +1,5 @@
+type Options = {
+    method?: "GET" | "POST";
+};
+export declare const fetch: (url: string, options?: Options) => Promise<unknown>;
+export {};

package/lib/utils/fetch.js

@@ -0,0 +1,37 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.fetch = void 0;
+var https = _interopRequireWildcard(require("https"));
+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; }
+const fetch = async (url, options) => {
+  const {
+    method = "GET"
+  } = options || {};
+  const target = new URL(url);
+  const params = {
+    method,
+    protocol: target.protocol,
+    hostname: target.hostname,
+    port: target.port,
+    path: target.pathname
+  };
+  return new Promise((resolve, reject) => {
+    const req = https.request(params, res => {
+      let body = "";
+      res.on("data", data => {
+        body += data;
+      });
+      res.on("end", () => {
+        resolve(body);
+      });
+    });
+    req.on("error", reject);
+    req.end();
+  });
+};
+exports.fetch = fetch;
+class Response {}

package/lib/utils/followProgress.d.ts

@@ -0,0 +1,6 @@
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
+export declare const followProgress: (stream: NodeJS.ReadableStream) => Promise<unknown>;

package/lib/utils/followProgress.js

@@ -0,0 +1,80 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.followProgress = void 0;
+var _Logger = require("../makes/Logger");
+var _LineConvertStream = require("../makes/LineConvertStream");
+var _formatSizeUnits = require("./format-size-units");
+const followProgress = async stream => {
+  const lineStream = new _LineConvertStream.LineConvertStream(stream);
+  let line = 0;
+  const mapLines = {};
+  lineStream.on("data", chunk => {
+    const data = JSON.parse(chunk.toString());
+    const {
+      stream,
+      id,
+      status,
+      progressDetail: {
+        current,
+        total
+      } = {},
+      aux
+    } = data;
+    if (stream) {
+      process.stdout.write(`${stream}`);
+      line += stream.split("\n").length - 1;
+      // line += Math.ceil(stream.length / process.stdout.columns);
+    } else if (id) {
+      if (typeof mapLines[id] === "undefined") {
+        mapLines[id] = line;
+      }
+      const targetLine = typeof mapLines[id] !== "undefined" ? mapLines[id] : line;
+      const dy = line - targetLine;
+      if (dy > 0) {
+        process.stdout.write("\x1b[s");
+        process.stdout.write(`\x1b[${dy}A`);
+      }
+      process.stdout.write("\x1b[2K");
+      let str = `${id}: ${status}\n`;
+      if (status === "Downloading") {
+        const width = process.stdout.columns;
+        const sizeWidth = 19,
+          totalWidth = width - id.length - status.length - sizeWidth - 7,
+          currentWidth = Math.floor(totalWidth * (current / total)),
+          formatSize = `${(0, _formatSizeUnits.formatSizeUnits)(current)}/${(0, _formatSizeUnits.formatSizeUnits)(total)}`;
+        str = `${id}: ${status} [${"█".repeat(currentWidth)}${"░".repeat(totalWidth - currentWidth)}] ${formatSize}\n`;
+      }
+      process.stdout.write(str);
+      if (dy > 0) {
+        process.stdout.write("\x1b[u");
+      } else {
+        line++;
+      }
+    } else if (status) {
+      process.stdout.write(`${status}\n`);
+      line += Math.ceil(status.length / process.stdout.columns);
+    } else if (aux) {
+      const str = `auxID: ${aux.ID}`;
+      process.stdout.write(`${str}\n`);
+      line += Math.ceil(str.length / process.stdout.columns);
+    } else {
+      _Logger.Logger.warning("followProgress: unexpected data", data);
+    }
+  });
+  return new Promise((resolve, reject) => {
+    let isEnded = false;
+    const handleEnd = () => {
+      if (!isEnded) {
+        resolve(null);
+      }
+      isEnded = true;
+    };
+    lineStream.on("end", handleEnd);
+    lineStream.on("close", handleEnd);
+    lineStream.on("error", reject);
+  });
+};
+exports.followProgress = followProgress;

package/lib/utils/format-size-units.d.ts

@@ -0,0 +1 @@
+export declare const formatSizeUnits: (bytes: number) => string;

package/lib/utils/format-size-units.js

@@ -0,0 +1,19 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.formatSizeUnits = void 0;
+const formatSizeUnits = bytes => {
+  if (bytes >= 1073741824) {
+    return (bytes / 1073741824).toFixed(2) + "GB";
+  } else if (bytes >= 1048576) {
+    return (bytes / 1048576).toFixed(2) + "MB";
+  } else if (bytes >= 1024) {
+    return (bytes / 1024).toFixed(2) + "kB";
+  } else if (bytes >= 1) {
+    return bytes + "b";
+  }
+  return "0b";
+};
+exports.formatSizeUnits = formatSizeUnits;

package/lib/utils/get-config.d.ts

@@ -0,0 +1,2 @@
+import { Config } from "src/types";
+export declare const getConfig: () => Promise<Config>;

package/lib/utils/get-config.js

@@ -0,0 +1,20 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getConfig = void 0;
+var _env = require("../env");
+var _FS = require("../makes/FS");
+const getConfig = async () => {
+  return _FS.FS.readJSON(_env.MAP_PATH).catch(err => {
+    if (err.code === "ENOENT") {
+      return Promise.resolve({
+        env: {},
+        projects: []
+      });
+    }
+    throw err;
+  });
+};
+exports.getConfig = getConfig;

package/lib/utils/get-cursor-position.d.ts

@@ -0,0 +1,4 @@
+export declare const getCursorPosition: () => Promise<{
+    row?: number;
+    col?: number;
+}>;

package/lib/utils/get-cursor-position.js

@@ -0,0 +1,34 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getCursorPosition = void 0;
+// import {} from "tty";
+
+const code = '\x1b[6n';
+const getCursorPosition = async () => {
+  process.stdin.resume();
+  process.stdin.setRawMode(true);
+  const position = {};
+  await new Promise((resolve, reject) => {
+    const handleData = data => {
+      const match = /\[(\d+);(\d+)R$/.exec(data.toString());
+      if (match) {
+        const [, col, row] = match.slice(1, 3).reverse().map(Number);
+        position.row = row;
+        position.col = col;
+        resolve(undefined);
+      }
+
+      // process.stdin.setRawMode(false);
+      process.stdin.off("data", handleData);
+      process.stdin.pause();
+    };
+    process.stdin.once("data", handleData);
+    process.stdout.write(code);
+    process.stdout.emit("data", code);
+  });
+  return position;
+};
+exports.getCursorPosition = getCursorPosition;

package/lib/utils/image-build.d.ts

@@ -0,0 +1,13 @@
+type Options = {
+    tag: string;
+    buildArgs?: {
+        [key: string]: string;
+    };
+    labels?: {
+        [key: string]: string;
+    };
+    context: string;
+    src: string;
+};
+export declare const imageBuild: (options: Options) => Promise<void>;
+export {};

package/lib/utils/image-build.js

@@ -0,0 +1,34 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.imageBuild = void 0;
+var _exec = require("./exec");
+var Path = _interopRequireWildcard(require("path"));
+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; }
+const imageBuild = async options => {
+  const {
+    tag,
+    buildArgs = {},
+    labels = {},
+    context,
+    src
+  } = options;
+  const buildArgsString = Object.keys(buildArgs).map(key => {
+    return `--build-arg ${key}=${buildArgs[key]}`;
+  }).join(" ");
+  const labelsString = Object.keys(labels).map(key => {
+    return `--label ${key}=${labels[key]}`;
+  }).join(" ");
+  await (0, _exec.exec)(`
+        docker build \
+            --tag "${tag}" \
+            ${buildArgsString} \
+            ${labelsString} \
+            --file ${Path.join(context, src)} \
+            ${context}
+    `);
+};
+exports.imageBuild = imageBuild;

package/lib/utils/index.d.ts

@@ -0,0 +1,21 @@
+export * from "./buildOptions";
+export * from "./demuxOutput";
+export * from "./escapeRegExp";
+export * from "./exec";
+export * from "./fetch";
+export * from "./followProgress";
+export * from "./format-size-units";
+export * from "./get-config";
+export * from "./get-cursor-position";
+export * from "./image-build";
+export * from "./injectVariables";
+export * from "./parse-table";
+export * from "./promptConfirm";
+export * from "./promptGroup";
+export * from "./promptSelect";
+export * from "./promptText";
+export * from "./set-config";
+export * from "./spawn";
+export * from "./tty";
+export * from "./volumeFormat";
+export * from "./volumeParse";