mechanica 1.0.11 → 1.0.13

package/bin/bin.js

@@ -0,0 +1,37 @@
+#!/usr/bin/env node
+import buildClient from './build.js'
+import push from './push.js'
+import compile from './compile.js'
+import fs from 'fs'
+import { join } from 'path'
+
+const keys = {}
+for (let i = 0; i < process.argv.length; i++) {
+  const key = process.argv[i].slice(2)
+  if (key.includes("=")) {
+    const [ newKey, value ] = key.split("=")
+    keys[newKey] = value
+  } else {
+    keys[key] = process.argv[i+1]?.startsWith("--") === false? process.argv[i+1]: true
+  }
+}
+
+if (process.argv[2] === "build") {
+  buildClient()
+} else if (process.argv[2] === "push") {
+  try {
+    if (fs.existsSync(join(process.cwd(), ".env"))) {
+      const env = fs.readFileSync(join(process.cwd(), ".env"), "utf-8")
+      const data = Object.fromEntries(env.split("\n").map(item => item.split("=").map(str => str.trim())))
+      Object.assign(process.env, data)
+    }
+  } catch(e) {
+    console.warn("Failed to parse .env file. Use system env values")
+  }
+  push(keys.key ?? process.env.BUILDER_API_KEY, keys.host ?? process.env.BUILDER_HOST ?? "https://builder.jt3.ru", keys.folder)
+} else if (process.argv[2] === "export") {
+  compile()
+} else {
+  console.info(`Use "mechanica build" to build client files`)
+  console.info(`Use "mechanica push --apiKey=<key> --host=<host> --dir=<dir> to push your builded client files`)
+}

package/bin/build.js

@@ -0,0 +1,63 @@
+import { build, loadConfigFromFile } from 'vite'
+
+export default async () => {
+
+  const defaultConfig = await loadConfigFromFile("vite.config.ts")
+  const mechanicaPlugin = defaultConfig.config.plugins.find(item => item.name === 'mechanica')
+  if (!mechanicaPlugin) {
+    console.error("Add mechanica plugin to your vite config file")
+    return
+  }
+
+  const userOptions = mechanicaPlugin.userOptions ?? {}
+
+  console.info("Build client files...")
+  await build({
+    configFile: "vite.config.ts",
+    build: {
+      rollupOptions: {
+        output: {
+          manualChunks: id => {
+            const [ path, query ] = id.split("?")
+            if (path.endsWith("/updater.ts")) return "updater"
+            // if (query === 'dev' || path.endsWith("DevApp.vue")) return 'dev'
+            // if (path.endsWith('/entry.ts') || path.endsWith('index.html')) return 'index'
+            return 'app'
+          }
+        }
+      }
+    }
+  })
+
+  console.info("")
+  console.info("Build client SSR files...")
+
+  await build({
+    configFile: "vite.config.ts",
+    ssr: {
+      // noExternal: ['vue', 'vue-router', 'pinia']
+      // external: [ "vue", "pinia", "@vueuse/core", "compact-json-schema" ],
+      noExternal: true,
+      optimizeDeps: {
+        include: ['*']
+      }
+    },
+    // resolve: {
+    //   alias: {
+    //     // Используем ESM-версию Vue, оптимизированную для SSR
+    //     'vue/server-renderer': '../../node_modules/vue/server-renderer/index.js',
+    //     'vue': '../../node_modules/vue/dist/vue.runtime.global.js',
+    //   }
+    // },
+    build: {
+      emptyOutDir: false,
+      ssr: true,
+      rollupOptions: {
+        input: {
+          ssr: `${userOptions.entrySsr ?? './src/main.ts'}?ssr`
+        }
+      },
+    }
+  })
+}
+

package/bin/compile.js

@@ -0,0 +1,481 @@
+import fs from "node:fs";
+import { pathToFileURL } from "node:url";
+import { resolve, parse, join, relative } from "node:path";
+const defaultImageSrc = "data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSI2NCIgaGVpZ2h0PSI2NCIgZmlsbD0ibm9uZSI+PHJlY3Qgd2lkdGg9IjY0IiBoZWlnaHQ9IjY0IiBmaWxsPSIjRjJGMkYyIiByeD0iOCIvPjxwYXRoIGZpbGw9IiM2RDZENkQiIGQ9Ik00MS42IDE5LjZIMjIuNEE0LjQgNC40IDAgMCAwIDE4IDI0djE2YTQuNCA0LjQgMCAwIDAgNC40IDQuNGgxOS4yQTQuNCA0LjQgMCAwIDAgNDYgNDBWMjRhNC40IDQuNCAwIDAgMC00LjQtNC40TTIyLjQgMjJoMTkuMmEyIDIgMCAwIDEgMiAydjEzLjEwNGwtNC4zNTItNC4zNTJhMS4xMiAxLjEyIDAgMCAwLS44OTYtLjM1MiAxLjI4IDEuMjggMCAwIDAtLjg4LjQzMmwtMi4wNjQgMi40OC03LjM2LTcuMzZhMS4xMiAxLjEyIDAgMCAwLS44NDgtLjM1MiAxLjI4IDEuMjggMCAwIDAtLjg4LjQzMmwtNS45MiA3LjA1NlYyNGEyIDIgMCAwIDEgMi0ybS0yIDE4di0xLjE2OGw2Ljg4LTguMjU2IDYuNTkyIDYuNTkyLTQuMDMyIDQuOEgyMi40YTIgMiAwIDAgMS0yLTEuOTY4bTIxLjIgMmgtOC42NGw1LjUyLTYuNjI0IDUuMDQgNS4wNEExLjk3IDEuOTcgMCAwIDEgNDEuNiA0MiIvPjwvc3ZnPg==";
+const getDefaultValue = (schema) => {
+  if (schema.default) return schema.default;
+  if (schema.nullable) return null;
+  if (schema.type === "object" && schema.format === "image") {
+    return { src: defaultImageSrc, previewSrc: defaultImageSrc };
+  }
+  if (schema.type === "number" || schema.type === "integer") return 0;
+  if (schema.type === "object") {
+    if (!schema.properties) return {};
+    return Object.fromEntries(Object.entries(schema.properties).map(([key, value]) => {
+      var _a;
+      if (!((_a = schema.required) == null ? void 0 : _a.includes(key))) {
+        return [key, void 0];
+      }
+      return [key, getDefaultValue(value)];
+    }));
+  }
+  if (schema.type === "array" && schema.format === "richText") {
+    return [{ text: "" }];
+  }
+  if (schema.type === "array") return [];
+  if (schema.type === "boolean") return false;
+  return "";
+};
+const passDefaultValue = (state, schema) => {
+  if (!schema) return state;
+  if (schema.type === "object" && state) {
+    for (let key in schema.properties) {
+      if (!(key in state) && !schema.required.includes(key)) continue;
+      state[key] = passDefaultValue(state[key], schema.properties[key]);
+    }
+  }
+  return state ?? getDefaultValue(schema);
+};
+const walkTree = (blocks, callback) => {
+  for (let block of blocks) {
+    callback(block);
+    if (!block.children) continue;
+    if (Array.isArray(block.children)) {
+      walkTree(block.children, callback);
+    } else {
+      for (let value of Object.values(block.children)) {
+        walkTree(value, callback);
+      }
+    }
+  }
+};
+const walkSchema = (obj, schema, callback) => {
+  if (schema.type === "object" && schema.properties) {
+    if (!obj) {
+      return;
+    }
+    for (let [key, childSchema] of Object.entries(schema.properties)) {
+      const isRequired = schema.required.includes(key);
+      callback(obj[key], childSchema, key, obj, isRequired);
+      if (childSchema.type === "array" || childSchema.type === "object") {
+        walkSchema(obj[key], childSchema, callback);
+      }
+    }
+  }
+  if (schema.type === "array" && schema.items) {
+    for (let value of obj) {
+      callback(value, schema.items);
+      if (schema.items.type === "array" || schema.items.type === "object") {
+        walkSchema(value, schema.items, callback);
+      }
+    }
+  }
+};
+const updaterScript = 'window.__MECHANICA_STATE__ = null;\nwindow.addEventListener("message", (e) => {\n  const { type, payload } = e.data;\n  const { content, data } = payload;\n  if (type === "update:state") {\n    const state = window.__MECHANICA_STATE__;\n    if (!state) {\n      console.warn("Mechanica state not found. Updater is not available");\n    }\n    if (data) {\n      for (let [key, value] of Object.entries(data)) {\n        if (!state.data[key]) {\n          state.data[key] = {};\n        } else {\n          for (let _key in state.data[key]) {\n            if (_key in value) continue;\n            delete state.data[key][_key];\n          }\n        }\n        Object.assign(state.data[key], value);\n      }\n    }\n    state.content.value = content;\n  }\n});\n//# sourceMappingURL=updater.js.map\n';
+const getValueByPath = (data, key) => {
+  let resp = data;
+  for (let prop of key.split(".")) {
+    resp = resp[prop];
+    if (!resp) return resp;
+  }
+  return resp;
+};
+const passDataToHTML = (html, data) => {
+  let resp = "";
+  let lastIndex = 0;
+  for (let place of html.matchAll(/{{.+}}/g)) {
+    resp += html.slice(lastIndex, place.index) + (getValueByPath(data, place[0].slice(2, -2)) ?? "");
+    lastIndex = place.index + place[0].length;
+  }
+  resp += html.slice(lastIndex);
+  return resp;
+};
+const generatePage = async (options) => {
+  walkTree(options.state.content, (block) => {
+    const schema = options.blocksMap.get(block.blockId);
+    if (!schema) return;
+    passDefaultValue(block.data, schema.props);
+  });
+  const data = { ...options.projectData, ...options.state.data };
+  const finalData = Object.fromEntries(options.dataEntries.map((entry) => [entry.id, passDefaultValue(data[entry.id] ?? {}, entry.props)]));
+  const state = {
+    content: options.state.content,
+    data: finalData,
+    baseUrl: options.baseUrl,
+    query: void 0
+  };
+  if (options.queryResolver) {
+    const getQuery2 = async (key) => {
+      const resp = await options.queryResolver(key);
+      state.query = state.query ?? {};
+      state.query[key] = resp;
+      return resp;
+    };
+    globalThis.getQuery = getQuery2;
+  }
+  globalThis.location = { pathname: options.path };
+  const html = await options.render(state, options.path ?? "");
+  let index = options.index;
+  index = passDataToHTML(index, state.data);
+  const match = index.match(/(<div.*? id="app".*?>).*?<\/div>/);
+  if (match !== null) {
+    index = index.slice(0, match.index + match[1].length) + html + index.slice(match.index + match[0].length - "</div>".length);
+  }
+  let contentCode = `
+<script>
+window.state=${JSON.stringify(state)}
+<\/script>
+  `.trim();
+  if (options.isDev) {
+    contentCode += `
+<script >
+  ${updaterScript}
+<\/script>
+    `;
+  }
+  if (options.assetsUrl) {
+    index = index.replace(/\/assets\//g, options.assetsUrl);
+  }
+  index = index.replace("</body>", `${contentCode}
+</body>`);
+  return index;
+};
+async function* generateProject(options) {
+  for (let page of options.pages) {
+    page.content = page.content ?? [];
+    walkTree(page.content, (block) => {
+      const schema = options.blocksMap.get(block.blockId);
+      walkSchema(block.data, schema.props, (val, schema2, key, parent) => {
+        if (!val) return;
+        if (schema2.format === "image") {
+          if (val.src) {
+            val.src = options.onFile(val.src);
+          }
+          if (val.previewSrc) {
+            val.previewSrc = options.onFile(val.previewSrc);
+          }
+        }
+        if (schema2.format === "richText" && schema2.type === "array") {
+          for (let row of val) {
+            if (row.image) {
+              if (row.image.src) {
+                row.image.src = options.onFile(row.image.src);
+              }
+              if (row.image.previewSrc) {
+                row.image.previewSrc = options.onFile(row.image.previewSrc);
+              }
+            }
+          }
+        }
+      });
+    });
+    const assetsUrl = options.assetsUrl ?? (options.baseUrl && options.baseUrl !== "/" ? options.baseUrl + "/assets/" : void 0);
+    const html = await generatePage({ ...options, assetsUrl, state: page, path: page.path });
+    yield [html, page.path];
+  }
+}
+const getBlockName = (path) => {
+  if (!path) return void 0;
+  const str = path.split("/").at(-1);
+  return (str == null ? void 0 : str.split(".", 1)[0].replace(/([A-Z])/g, " $1").trimStart()) ?? "Unnamed block";
+};
+const aliases$1 = {};
+const registerAlias$1 = (key, item) => {
+  aliases$1[key] = item;
+};
+const baseTypes = ["string", "boolean", "number", "integer", "bigint", "object", "array"];
+const isBaseType = (key) => {
+  return baseTypes.some((item) => item === key || item + "?" === key || item + "??" === key);
+};
+const trimType = (type) => {
+  if (type.endsWith("??"))
+    return type.slice(0, -2);
+  if (type.endsWith("?"))
+    return type.slice(0, -1);
+  return type;
+};
+const parseObjectFields = (props, unfoldSchema2) => {
+  const required = [];
+  const properties = {};
+  for (let [key, value] of Object.entries(props)) {
+    if (Array.isArray(value)) {
+      required.push(key);
+    } else if (typeof value === "object") {
+      if (typeof value.type !== "string" || !value.type.endsWith("?")) {
+        required.push(key);
+      }
+    } else if (typeof value === "string") {
+      if (!value.endsWith("?")) {
+        required.push(key);
+      }
+    }
+    properties[key] = unfoldSchema2(value);
+  }
+  return {
+    properties,
+    required
+  };
+};
+const unfoldArray$1 = (schema2) => {
+  const isEnum = schema2.every((item) => typeof item === "string") && schema2.some((item) => !isBaseType(item));
+  if (isEnum) {
+    if (schema2.length === 1) {
+      return { type: "string", const: schema2[0] };
+    } else {
+      return { type: "string", enum: schema2 };
+    }
+  } else {
+    return {
+      oneOf: schema2.map((item) => unfoldSchema(item))
+    };
+  }
+};
+const unfoldSchema = (schema2) => {
+  if (typeof schema2 === "string") {
+    const trimmedType = trimType(schema2);
+    if (trimmedType in aliases$1) {
+      if (schema2.endsWith("??")) {
+        return { ...unfoldSchema(aliases$1[trimmedType]), nullable: true };
+      }
+      return unfoldSchema(aliases$1[trimmedType]);
+    }
+    if (schema2.endsWith("??")) {
+      return { type: trimmedType, nullable: true };
+    }
+    return { type: trimmedType };
+  }
+  if (Array.isArray(schema2)) {
+    return unfoldArray$1(schema2);
+  }
+  if (typeof schema2 !== "object" || schema2 === null) {
+    throw new Error(`Schema type ${schema2} is not object`);
+  }
+  if (typeof schema2.type === "string") {
+    const { items, properties, type, ...otherProps } = schema2;
+    const trimmedType = trimType(type);
+    if (trimmedType === "array" && items) {
+      return {
+        type: "array",
+        nullable: type.endsWith("??") ? true : void 0,
+        ...otherProps,
+        items: unfoldSchema(items)
+      };
+    }
+    if (trimmedType === "object" && properties) {
+      return {
+        type: "object",
+        nullable: type.endsWith("??") ? true : void 0,
+        ...otherProps,
+        ...parseObjectFields(properties, unfoldSchema)
+      };
+    }
+    return {
+      ...unfoldSchema(type),
+      ...otherProps
+    };
+  }
+  return {
+    type: "object",
+    ...parseObjectFields(schema2, unfoldSchema)
+  };
+};
+const aliases = {};
+const registerAlias = (key, item) => {
+  aliases[key] = item;
+};
+const registerAliases = (registerCallback) => {
+  const registerAlias$12 = registerCallback ?? registerAlias;
+  registerAlias$12("image", { type: "object", format: "image", properties: { src: "string", previewSrc: "string?" } });
+  registerAlias$12("file", { type: "object", format: "file", properties: { src: "string" } });
+  registerAlias$12("color", { type: "string", format: "color" });
+  registerAlias$12("smartLink", { type: "object", format: "smartLink", properties: { url: "string", title: "string", external: "boolean" } });
+  registerAlias$12("richText", {
+    type: "array",
+    format: "richText",
+    items: { type: "object", properties: { text: "string", type: "string?", styles: "object?" } }
+  });
+};
+const queryCache = /* @__PURE__ */ new Map();
+const getQuery = async (key) => {
+  if (queryCache.has(key)) {
+    return queryCache.get(key);
+  }
+  const type = key.slice(0, key.indexOf("."));
+  const value = JSON.parse(key.slice(key.indexOf(".") + 1));
+  if (type === "getPages") {
+    let pages = await getAvailablePages(value);
+    if (value.folderName) {
+      pages = pages.filter((item) => item.folderPath === value.folderName);
+    }
+    for (let page of pages) {
+      delete page.order;
+      delete page.folderPath;
+      delete page.orderAfter;
+    }
+    queryCache.set(key, pages);
+    return pages;
+  }
+  return {};
+};
+const getAvailablePages = async (options) => {
+  if (!fs.existsSync(resolve(`.mech/pages`))) {
+    return [];
+  }
+  const pages = await fs.promises.readdir(resolve(`.mech/pages`), { recursive: true });
+  const arr = [];
+  for (let _path of pages) {
+    const { name, dir } = parse(_path);
+    if (!_path.endsWith(".json")) {
+      continue;
+    }
+    const pageData = JSON.parse(await fs.promises.readFile(join(`.mech/pages`, _path), "utf-8"));
+    const path = `/${dir}/${name === "index" ? "" : name}`.replace("//", "/").replace(/\/$/, "") || "/";
+    const data = {};
+    for (let item of options.data ?? []) {
+      data[item.id] = pageData.data[item.id] ?? {};
+    }
+    arr.push({
+      path,
+      name: pageData.name ?? name,
+      folderPath: dir === "" ? null : dir,
+      order: pageData.order ?? 0,
+      orderAfter: pageData.orderAfter ?? null,
+      ...data
+    });
+  }
+  arr.sort((a, b) => {
+    if (a.folderPath === b.folderPath) {
+      if (a.orderAfter === b.path) return 1;
+      if (b.orderAfter === a.path) return -1;
+      if (a.order === b.order) {
+        return (a.orderAfter ?? a.path).localeCompare(b.orderAfter ?? b.path);
+      } else {
+        return a.order - b.order;
+      }
+    }
+    if (!a.folderPath) return -1;
+    if (!b.folderPath) return 1;
+    return a.folderPath.localeCompare(b.folderPath);
+  });
+  return arr;
+};
+const compile = async () => {
+  console.info("Build client files...");
+  registerAliases(registerAlias$1);
+  process.env.DISABLE_HTML_GENERATE = "true";
+  let baseUrl = "/";
+  let assetsUrl = void 0;
+  let uploadsUrl = "/mech-assets";
+  for (let argv of process.argv) {
+    if (argv.startsWith("--base")) {
+      baseUrl = argv.split("=")[1];
+      if (!baseUrl) {
+        return console.error(`Use --base=/path`);
+      }
+    }
+    if (argv.startsWith("--assets-dir")) {
+      assetsUrl = argv.split("=")[1];
+      if (!assetsUrl) {
+        return console.error(`Use --assets-dir=/path`);
+      }
+      if (!assetsUrl.endsWith("/")) {
+        assetsUrl = assetsUrl + "/";
+      }
+    }
+    if (argv.startsWith("--uploads-dir")) {
+      uploadsUrl = argv.split("=")[1].replace(/\/+$/, "");
+      if (!uploadsUrl) {
+        return console.error(`Use --uploads-dir=/path`);
+      }
+    }
+  }
+  let assetsPath = (assetsUrl == null ? void 0 : assetsUrl.replace(/^\.?\/+/, "").replace(/\/+$/, "")) ?? "assets";
+  fs.rmSync(`${process.cwd()}/export`, { recursive: true, force: true });
+  fs.mkdirSync(`${process.cwd()}/export`, { recursive: true });
+  fs.cpSync(`${process.cwd()}/dist/assets`, `${process.cwd()}/export/${assetsPath}`, { recursive: true });
+  const index = fs.readFileSync(`${process.cwd()}/dist/index.html`, "utf-8");
+  const pagesPath = "/.mech/pages";
+  const window = { addEventListener() {
+  }, removeEventListener() {
+  }, state: { content: [], data: {} } };
+  globalThis.window = window;
+  globalThis.document = { location: { pathname: "/", query: "" }, createElement() {
+  } };
+  globalThis.document.location.pathname = `/`;
+  const module = await import(pathToFileURL(`${process.cwd()}/dist/ssr.js`).href);
+  const blocksMap = new Map(module.blocksList.map((file) => {
+    const blockData = {
+      ...file.blockSchema,
+      id: file.blockSchema.id ?? file.__name,
+      name: file.blockSchema.name ?? getBlockName(file.__name) ?? "Unnamed block",
+      props: file.blockSchema.props ? unfoldSchema(file.blockSchema.props) : {}
+    };
+    return [blockData.id, blockData];
+  }));
+  const render = async (state, pathName) => {
+    globalThis.document.location.pathname = pathName;
+    window.state = state;
+    module.updateState(state);
+    const html = await module.render(state);
+    return html;
+  };
+  fs.rmSync(`${process.cwd()}/export/mech-assets`, { recursive: true, force: true });
+  let hasUploadFolder = false;
+  const copiedFiles = /* @__PURE__ */ new Set();
+  const onFile = (imagePath) => {
+    if (!hasUploadFolder) {
+      fs.mkdirSync(`${process.cwd()}/export${uploadsUrl}`, { recursive: true });
+      hasUploadFolder = true;
+    }
+    const path = imagePath.replace("@mechanica", ".mech");
+    const newPath = uploadsUrl + imagePath.replace("/@mechanica", "").replace("/assets", "");
+    if (!copiedFiles.has(newPath)) {
+      copiedFiles.add(newPath);
+      fs.copyFileSync(`${process.cwd()}${path}`, `${process.cwd()}/export/${newPath}`);
+    }
+    return newPath;
+  };
+  const pages = [];
+  for await (let page of fs.opendirSync(`${process.cwd()}${pagesPath}`, { recursive: true })) {
+    if (page.isDirectory()) continue;
+    let relativePath = relative(`${process.cwd()}${pagesPath}`, page.parentPath);
+    try {
+      if (relativePath) {
+        relativePath = "/" + relativePath.replace("\\\\g", "/");
+      }
+      const pageName = page.name.slice(0, -".json".length);
+      const path = `${relativePath}/${pageName === "index" ? "" : pageName}`;
+      const { data, content, title } = JSON.parse(fs.readFileSync(`${page.parentPath}/${page.name}`, "utf-8"));
+      pages.push({ data, content, title, path });
+    } catch (e) {
+      console.warn(`Unable to read ${page.parentPath}/${page.name} directory`, e);
+    }
+  }
+  const iterator = generateProject({
+    index,
+    pages,
+    dataEntries: module.dataEntries,
+    projectData: {},
+    blocksMap,
+    baseUrl,
+    assetsUrl,
+    queryResolver: getQuery,
+    render,
+    onFile
+  });
+  for await (let [html, path] of iterator) {
+    if (path != "/") {
+      const dir = join(process.cwd(), `/export/${path}/index.html`);
+      fs.mkdirSync(`${process.cwd()}/export/${path}`, { recursive: true });
+      fs.writeFileSync(dir, html);
+      console.info(`Create page ${dir}`);
+    } else {
+      const dir = join(process.cwd(), "/export/index.html");
+      fs.writeFileSync(dir, html);
+      console.info(`Create page ${dir}`);
+    }
+  }
+};
+export {
+  compile as default
+};

package/bin/push.js

@@ -0,0 +1,80 @@
+import { request as httpsRequest } from 'https'
+import { request as httpRequest } from 'http'
+import { join } from 'path'
+import fs from 'fs'
+
+export default async (apiKey, host, folder) => {
+
+  if (!apiKey) {
+    console.warn("[ERROR] apiKey is not defined. Use mechanica push --key=<key> for push client files")
+    return
+  }
+
+  const buffers = []
+  let writedSize = 0
+
+  const getFolderStructure = async (dirPath) => {
+    const files = []
+    const filePaths = await fs.promises.readdir(dirPath)
+    for (let fileName of filePaths) {
+      const path = join(dirPath, fileName)
+      const stat = fs.statSync(path)
+      if (stat.isDirectory()) {
+        const children = await getFolderStructure(path)
+        files.push({ type: "folder", name: fileName, children, mtime: stat.mtimeMs })
+      } else {
+        const file = await fs.promises.readFile(path)
+        files.push({ type: "file", name: fileName, size: stat.size, mtime: stat.mtimeMs, offset: writedSize, length: file.byteLength })
+        buffers.push(file)
+        writedSize += file.byteLength
+      }
+    }
+    return files
+  }
+
+  const structure = await getFolderStructure(join(process.cwd(), folder ?? 'dist'))
+
+  const jsonBuffer = Buffer.from(JSON.stringify(structure), 'utf-8')
+  buffers.unshift(jsonBuffer)
+
+  const controls = new Uint32Array(2)
+  controls[0] = jsonBuffer.length
+  controls[1] = writedSize
+  buffers.unshift(Buffer.from(controls.buffer))
+
+  const outputBuffer = Buffer.concat(buffers)
+
+  const url = `${host}/api/projects/push`
+  const request = url.startsWith("https")? httpsRequest: httpRequest
+  
+  const resp = await new Promise((res, rej) => {
+    const onResponse = async (response) => {
+      const buffers = [];
+      for await (const chunk of response) {
+        buffers.push(chunk);
+      }
+      const data = Buffer.concat(buffers)
+      if (response.statusCode !== 200) {
+        rej(new Error(data.toString()))
+      }
+      res(data.toString())
+    }
+
+    const clientRequest = request(url, {
+      method: "POST",
+      headers: {
+        'authorization': `Bearer ${apiKey}`,
+        'content-type': "application/octet-stream",
+        "content-length": outputBuffer.byteLength
+      }
+    }, onResponse)  
+
+    clientRequest.on("error", (err) => {
+      rej(err)
+    })
+    clientRequest.end(outputBuffer)
+
+    console.info(`Push to site ${host}...`)
+  })
+  console.info(`Project successfull pushed. ${resp}`)
+}