@bprotsyk/aso-core 2.0.11 → 2.0.12

package/lib/utils/server-util.d.ts

@@ -8,10 +8,22 @@ export declare class ServerUtil {
     ssh?: NodeSSH;
     constructor(ssh?: NodeSSH);
     exec(command: string, options?: any): Promise<string>;
+    generateSSHKey(): Promise<string>;
+    createDirectories(): Promise<void>;
+    installGit(): Promise<void>;
+    addBitbucketToKnownHosts(): Promise<void>;
+    cloneRepository(repoName: string, targetPath: string): Promise<void>;
+    installNginx(): Promise<void>;
     isNginxActive(): Promise<boolean>;
     isMongoActive(): Promise<boolean>;
     mongoInstallCommand: string;
     domainNginxConfigExists(host: string): Promise<boolean>;
+    domainNginxCertsExist(host: string): Promise<boolean>;
     isCerbotActive(): Promise<boolean>;
     setupCertbot(): Promise<boolean>;
+    setupSSL(email: string, host: string): Promise<void>;
+    refresh(): Promise<boolean>;
+    deployLandingPage(host: string, username: string, password: string, remotePath: string, files: any): Promise<void>;
+    generateNginxConfig(domain: string, rootPath: string): Promise<string>;
+    serverConect(IP: string): Promise<string>;
 }

package/lib/utils/server-util.js

@@ -1,9 +1,16 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ServerUtil = exports.PORT = exports.HOST = exports.PASSWORD = exports.IP = void 0;
-const ChildProcess = require('child_process');
-const { promisify } = require('util');
-const execPromise = promisify(ChildProcess.exec);
+const node_ssh_1 = require("node-ssh");
+const child_process_1 = __importDefault(require("child_process"));
+const ssh2_sftp_client_1 = __importDefault(require("ssh2-sftp-client"));
+const fs_1 = __importDefault(require("fs"));
+const mustache_1 = __importDefault(require("mustache"));
+const { promisify } = require("util");
+const execPromise = promisify(child_process_1.default.exec);
 exports.IP = "185.123.53.227";
 exports.PASSWORD = "xUA3oOX06Kfc9m12rZ";
 exports.HOST = "cg-main-server.com";
@@ -27,10 +34,49 @@ class ServerUtil {
             });
         }
     }
+    // SSH
+    async generateSSHKey() {
+        await this.exec(`ssh-keygen -t rsa -N '' -f ~/.ssh/id_rsa <<< n`);
+        let sshFingerprint = await this.exec(`cat ~/.ssh/id_rsa.pub`);
+        return sshFingerprint;
+    }
+    // create Directories in /Var
+    async createDirectories() {
+        await this.exec(`mkdir -p /var/www/ai`);
+    }
+    // install git
+    async installGit() {
+        await this.exec(`apt-get update; apt-get install -y git`);
+    }
+    // add ssh to bitbucket
+    async addBitbucketToKnownHosts() {
+        await this.exec(`ssh-keyscan bitbucket.org >> ~/.ssh/known_hosts`);
+    }
+    // clone bitbucket Repository
+    async cloneRepository(repoName, targetPath) {
+        let gitResponse = await this.exec(`git clone git@bitbucket.org:bprtsk/${repoName}.git`, { cwd: targetPath });
+        if (gitResponse.includes(`Please make sure you have the correct access rights`)) {
+            throw new Error(`No access to the remote repository!`);
+        }
+    }
+    // не знаю чи треба але  додав ?
+    // async checkoutBranch(branch: string, repoPath: string): Promise<void> {
+    //     await this.exec(`git checkout -b ${branch}; git branch --set-upstream-to=origin/${branch} ${branch}; git reset --hard origin/${branch};`, { cwd: repoPath });
+    // }
+    // не знаю чи треба але  додав ?
+    //   async installJava(): Promise<void> {
+    //     await this.exec(`apt-get update; apt-get install -y default-jre default-jdk`);
+    // }
+    // install Nginx
+    async installNginx() {
+        await this.exec(`apt-get update; apt-get install -y nginx`);
+        await this.exec(`systemctl enable nginx`);
+        await this.exec(`systemctl start nginx`);
+    }
     // Nginx
     async isNginxActive() {
         try {
-            let result = await this.exec('systemctl status nginx');
+            let result = await this.exec("systemctl status nginx");
             if (result.includes("Active: active"))
                 return true;
         }
@@ -42,7 +88,7 @@ class ServerUtil {
     // Mongo
     async isMongoActive() {
         try {
-            let result = await this.exec('systemctl status mongod');
+            let result = await this.exec("systemctl status mongod");
             if (result.includes("Active: active"))
                 return true;
         }
@@ -65,7 +111,7 @@ class ServerUtil {
         systemctl enable mongod.service;
         systemctl start mongod;
     `;
-    // Domains
+    // checking if nginx configuration exists
     async domainNginxConfigExists(host) {
         try {
             let result = await this.exec(`ls ${this.DOMAIN_HOME}/${host}.nginx.ssl.conf`);
@@ -77,12 +123,22 @@ class ServerUtil {
         }
         return true;
     }
-    // async domainNginxCertsExist(host: string): Promise<boolean> {
-    // }
+    // checking if the ssl certificate exists
+    async domainNginxCertsExist(host) {
+        try {
+            let result = await this.exec(`ls /etc/letsencrypt/live/${host}`);
+            if (result.includes("No such file or directory"))
+                return false;
+        }
+        catch (e) {
+            console.error(e);
+        }
+        return true;
+    }
     // Certbot CRON
     async isCerbotActive() {
         try {
-            let result = await this.exec('which certbot');
+            let result = await this.exec("which certbot");
             if (result.includes("/usr/bin/certbot"))
                 return true;
         }
@@ -91,21 +147,60 @@ class ServerUtil {
         }
         return false;
     }
+    // install certbot
     async setupCertbot() {
         await this.exec(`apt-get install -y certbot python3-certbot-nginx;`);
         return true;
     }
+    // creating a SSL certificate
+    async setupSSL(email, host) {
+        let certbotResponse = await this.exec(`certbot --non-interactive --agree-tos --nginx -m "${email}" -d "${host}"`);
+        if (certbotResponse.includes(`Some challenges have failed.`)) {
+            throw new Error("Certbot encountered an error");
+        }
+        await this.exec(`echo "0 12 * * * /usr/bin/certbot renew --quiet" | crontab -`);
+    }
+    // Git
+    async refresh() {
+        await this.exec(`git stash; rm-rf built; git pull`);
+        return true;
+    }
+    async deployLandingPage(host, username, password, remotePath, files) {
+        let sftp = new ssh2_sftp_client_1.default();
+        try {
+            //connection to the server via sftp
+            await sftp.connect({ host, username, password });
+            // Завантажити файли на сервер
+            for (const file of files) {
+                await sftp.put(Buffer.from(file.content, "base64"), `${remotePath}/${file.name}`);
+            }
+        }
+        finally {
+            sftp.end();
+        }
+    }
+    async generateNginxConfig(domain, rootPath) {
+        const template = fs_1.default.readFileSync("templates/nginx-template.conf", "utf8");
+        const config = mustache_1.default.render(template, { domain, rootPath });
+        return config;
+    }
+    async serverConect(IP) {
+        if (!this.ssh) {
+            this.ssh = new node_ssh_1.NodeSSH();
+        }
+        try {
+            await this.ssh.connect({
+                host: '46.246.98.201',
+                port: exports.PORT,
+                username: 'root',
+                password: 'A0a693E4CrK6tdvSlE',
+            });
+            return `Successfully connected to ${IP}`;
+        }
+        catch (error) {
+            console.error(`Failed to connect to ${IP}:`, error);
+            return `Failed to connect to ${IP}`;
+        }
+    }
 }
 exports.ServerUtil = ServerUtil;
-// (async () => {
-//     const ssh = new NodeSSH()
-//     await ssh.connect({
-// 		host: IP,
-// 		port: PORT,
-// 		username: `root`,
-// 		password: PASSWORD
-// 	})
-//     let util = new ServerUtil(ssh)
-//     console.log(`Nginx is active: ${await util.isNginxActive()}`)
-//     process.exit(0)
-// })()

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bprotsyk/aso-core",
-  "version": "2.0.11",
+  "version": "2.0.12",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
   "scripts": {
@@ -30,17 +30,21 @@
     "axios": "^1.4.0",
     "module-alias": "^2.2.2",
     "mongoose": "^6.8.3",
+    "mustache": "^4.2.0",
     "node-ssh": "^13.2.0",
     "react": "^18.3.1",
     "react-dom": "^18.3.1",
     "replace-in-file": "^7.0.1",
     "sleep-promise": "^9.1.0",
+    "ssh2-sftp-client": "^11.0.0",
     "styled-components": "^5.3.9"
   },
   "devDependencies": {
+    "@types/mustache": "^4.2.5",
     "@types/node": "^20.14.12",
     "@types/react": "^18.2.14",
     "@types/react-dom": "^18.3.0",
+    "@types/ssh2-sftp-client": "^9.0.4",
     "typedoc": "^0.23.28",
     "typescript": "^4.9.5"
   }

package/src/utils/server-util.ts

@@ -1,56 +1,120 @@
 import { NodeSSH } from "node-ssh";
-const ChildProcess = require('child_process')
-const { promisify } = require('util');
-const execPromise = promisify(ChildProcess.exec)
-
-export let IP = "185.123.53.227"
-export let PASSWORD = "xUA3oOX06Kfc9m12rZ"
-export let HOST = "cg-main-server.com"
-export let PORT = 56777
+import ChildProcess from "child_process";
+import Client from "ssh2-sftp-client";
+import fs from "fs";
+import mustache from "mustache";
+const { promisify } = require("util");
+const execPromise = promisify(ChildProcess.exec);
+
+export let IP = "185.123.53.227";
+export let PASSWORD = "xUA3oOX06Kfc9m12rZ";
+export let HOST = "cg-main-server.com";
+export let PORT = 56777;
 
 export class ServerUtil {
-    DOMAIN_HOME = "/etc/nginx/sites-enabled"
+  DOMAIN_HOME = "/etc/nginx/sites-enabled";
+
+  ssh?: NodeSSH;
+
+  constructor(ssh?: NodeSSH) {
+    this.ssh = ssh;
+  }
+
+  // Выконує команду або по SSH або локально, повертаючи текст незалежно від результату (помилка чи успіх)
+  async exec(command: string, options?: any): Promise<string> {
+    if (this.ssh) {
+      return (await this.ssh.execCommand(command, options)).stdout;
+    } else {
+      return await new Promise<string>((resolve) => {
+        execPromise(command, (err: string, stdout: string) => {
+          resolve(stdout);
+        });
+      });
+    }
+  }
+
+  // SSH
+  async generateSSHKey(): Promise<string> {
+    await this.exec(`ssh-keygen -t rsa -N '' -f ~/.ssh/id_rsa <<< n`);
+    let sshFingerprint = await this.exec(`cat ~/.ssh/id_rsa.pub`);
+    return sshFingerprint;
+  }
+
+  // create Directories in /Var
+  async createDirectories(): Promise<void> {
+    await this.exec(`mkdir -p /var/www/ai`);
+  }
+
+  // install git
+  async installGit(): Promise<void> {
+    await this.exec(`apt-get update; apt-get install -y git`);
+  }
+
+  // add ssh to bitbucket
+  async addBitbucketToKnownHosts(): Promise<void> {
+    await this.exec(`ssh-keyscan bitbucket.org >> ~/.ssh/known_hosts`);
+  }
+
+  // clone bitbucket Repository
+  async cloneRepository(repoName: string, targetPath: string): Promise<void> {
+    let gitResponse = await this.exec(
+      `git clone git@bitbucket.org:bprtsk/${repoName}.git`,
+      { cwd: targetPath }
+    );
+    if (
+      gitResponse.includes(
+        `Please make sure you have the correct access rights`
+      )
+    ) {
+      throw new Error(`No access to the remote repository!`);
+    }
+  }
 
-    ssh?: NodeSSH
+  // не знаю чи треба але  додав ?
 
-    constructor(ssh?: NodeSSH) {
-        this.ssh = ssh
-    }
+  // async checkoutBranch(branch: string, repoPath: string): Promise<void> {
+  //     await this.exec(`git checkout -b ${branch}; git branch --set-upstream-to=origin/${branch} ${branch}; git reset --hard origin/${branch};`, { cwd: repoPath });
+  // }
 
-    // Выконує команду або по SSH або локально, повертаючи текст незалежно від результату (помилка чи успіх)
-    async exec(command: string, options?: any): Promise<string> {
-        if (this.ssh) {
-            return (await this.ssh.execCommand(command, options)).stdout
-        } else {
-            return await new Promise<string>((resolve) => {
-                execPromise(command, (err: string, stdout: string) => {
-                    resolve(stdout)
-                });
-            });
-        }
-    }
+  // не знаю чи треба але  додав ?
 
-    // Nginx
-    async isNginxActive(): Promise<boolean> {
-        try {
-            let result = await this.exec('systemctl status nginx')
-            if (result.includes("Active: active")) return true
-        } catch (e) { console.error(e) }
+  //   async installJava(): Promise<void> {
+  //     await this.exec(`apt-get update; apt-get install -y default-jre default-jdk`);
+  // }
 
-        return false
+  // install Nginx
+
+  async installNginx(): Promise<void> {
+    await this.exec(`apt-get update; apt-get install -y nginx`);
+    await this.exec(`systemctl enable nginx`);
+    await this.exec(`systemctl start nginx`);
+  }
+
+  // Nginx
+  async isNginxActive(): Promise<boolean> {
+    try {
+      let result = await this.exec("systemctl status nginx");
+      if (result.includes("Active: active")) return true;
+    } catch (e) {
+      console.error(e);
     }
 
-    // Mongo
-    async isMongoActive(): Promise<boolean> {
-        try {
-            let result = await this.exec('systemctl status mongod')
-            if (result.includes("Active: active")) return true
-        } catch (e) { console.error(e) }
+    return false;
+  }
 
-        return false
+  // Mongo
+  async isMongoActive(): Promise<boolean> {
+    try {
+      let result = await this.exec("systemctl status mongod");
+      if (result.includes("Active: active")) return true;
+    } catch (e) {
+      console.error(e);
     }
 
-    mongoInstallCommand = `
+    return false;
+  }
+
+  mongoInstallCommand = `
         echo "deb http://security.ubuntu.com/ubuntu focal-security main" | tee /etc/apt/sources.list.d/focal-security.list;
         apt-get update;
         apt-get install libssl1.1;
@@ -63,61 +127,126 @@ export class ServerUtil {
         apt-get install -y mongodb-org;
         systemctl enable mongod.service;
         systemctl start mongod;
-    `
-
-
-
-    // Domains
-
-    async domainNginxConfigExists(host: string): Promise<boolean> {
-        try {
-            let result = await this.exec(`ls ${this.DOMAIN_HOME}/${host}.nginx.ssl.conf`)
-            if (result.includes("No such file or directory")) return false
-        } catch (e) { console.error(e) }
-
-        return true
+    `;
+
+  // checking if nginx configuration exists
+  async domainNginxConfigExists(host: string): Promise<boolean> {
+    try {
+      let result = await this.exec(
+        `ls ${this.DOMAIN_HOME}/${host}.nginx.ssl.conf`
+      );
+      if (result.includes("No such file or directory")) return false;
+    } catch (e) {
+      console.error(e);
     }
 
-    // async domainNginxCertsExist(host: string): Promise<boolean> {
+    return true;
+  }
 
-    // }
-
-    // Certbot CRON
-    async isCerbotActive(): Promise<boolean> {
-        try {
-            let result = await this.exec('which certbot')
-            if (result.includes("/usr/bin/certbot")) return true
-        } catch (e) { console.error(e) }
+   // checking if the ssl certificate exists
+  async domainNginxCertsExist(host: string): Promise<boolean> {
+    try {
+      let result = await this.exec(`ls /etc/letsencrypt/live/${host}`);
+      if (result.includes("No such file or directory")) return false;
+    } catch (e) {
+      console.error(e);
+    }
+    return true;
+  }
+
+  // Certbot CRON
+  async isCerbotActive(): Promise<boolean> {
+    try {
+      let result = await this.exec("which certbot");
+      if (result.includes("/usr/bin/certbot")) return true;
+    } catch (e) {
+      console.error(e);
+    }
 
-        return false
+    return false;
+  }
+
+  // install certbot
+  async setupCertbot(): Promise<boolean> {
+    await this.exec(`apt-get install -y certbot python3-certbot-nginx;`);
+
+    return true;
+  }
+  // creating a SSL certificate
+  async setupSSL(email: string, host: string): Promise<void> {
+    let certbotResponse = await this.exec(
+      `certbot --non-interactive --agree-tos --nginx -m "${email}" -d "${host}"`
+    );
+    if (certbotResponse.includes(`Some challenges have failed.`)) {
+      throw new Error("Certbot encountered an error");
+    }
+    await this.exec(
+      `echo "0 12 * * * /usr/bin/certbot renew --quiet" | crontab -`
+    );
+  }
+
+  // Git
+  async refresh(): Promise<boolean> {
+    await this.exec(`git stash; rm-rf built; git pull`);
+
+    return true;
+  }
+
+
+
+  async deployLandingPage(
+    host: string,
+    username: string,
+    password: string,
+    remotePath: string,
+    files: any
+  ): Promise<void> {
+    let sftp = new Client();
+    try {
+        //connection to the server via sftp
+      await sftp.connect({ host, username, password });
+
+      // Завантажити файли на сервер
+      for (const file of files) {
+        await sftp.put(
+          Buffer.from(file.content, "base64"),
+          `${remotePath}/${file.name}`
+        );
+      }
+    } finally {
+      sftp.end();
     }
+  }
 
-    async setupCertbot(): Promise<boolean> {
-        await this.exec(`apt-get install -y certbot python3-certbot-nginx;`)
+  async generateNginxConfig(domain: string, rootPath: string): Promise<string> {
+    const template = fs.readFileSync("templates/nginx-template.conf", "utf8");
+    const config = mustache.render(template, { domain, rootPath });
+    return config;
+  }
 
-        return true
+  async serverConect(IP: string): Promise<string> {
+    if (!this.ssh) {
+      this.ssh = new NodeSSH();
     }
 
-    // Git 
-    // async refresh(): Promise<boolean> {
-    //     // git stash; rm-rf built; git pull
-    // }
+    try {
+      await this.ssh.connect({
+        host: '46.246.98.201',
+        port: PORT, 
+        username: 'root',
+        password: 'A0a693E4CrK6tdvSlE',
+      });
+
+      return `Successfully connected to ${IP}`;
+    } catch (error) {
+      console.error(`Failed to connect to ${IP}:`, error);
+      return `Failed to connect to ${IP}`;
+    }
+  }
+  
 }
 
 
-// (async () => {
-//     const ssh = new NodeSSH()
-
-//     await ssh.connect({
-// 		host: IP,
-// 		port: PORT,
-// 		username: `root`,
-// 		password: PASSWORD
-// 	})
 
-//     let util = new ServerUtil(ssh)
 
-//     console.log(`Nginx is active: ${await util.isNginxActive()}`)
 
-//     process.exit(0)
-// })()