fightertunnel 1.0.5

package/README.md

@@ -0,0 +1,73 @@
+# Fightertunnel
+
+![npm version](https://img.shields.io/npm/v/fightertunnel)
+![license](https://img.shields.io/npm/l/fightertunnel)
+![build](https://img.shields.io/travis/com/FighterTunnel/tunnel)
+
+Fightertunnel is a comprehensive module for managing various types of accounts such as SSH, VMess, VLESS, Trojan, and Shadowsocks. This module provides various functions to easily and efficiently create, check, delete, and update these accounts.
+
+<img src="https://avatars.githubusercontent.com/u/118927603?v=4" alt="Fightertunnel" width="100" height="100" style="border-radius: 50%; box-shadow: 0 0 10px yellow;">
+
+## Features
+
+- **Create Account**: Create new accounts for SSH, VMess, VLESS, Trojan, and Shadowsocks.
+- **Check Account**: Check the status and details of existing accounts.
+- **Delete Account**: Remove accounts that are no longer needed.
+- **Update Account**: Update information of existing accounts.
+
+## Installation
+
+To install the Fightertunnel module, use the following command:
+
+```bash
+npm i fightertunnel
+```
+
+## Usage
+
+Here is an example of using the FighterTunnel module to create an SSH account:
+
+### SSH
+```javascript
+const { createSSH } = require('fightertunnel');
+createSSH('username', 'password', 'exp', 'limitip', (err, result) => {
+    if (err) {
+        console.error(err);
+    } else {
+        console.log(result);
+    }
+});
+```
+
+### VMESS
+```javascript
+const { createVMess } = require('fightertunnel');
+function createVMessAccount(username, expiry, quota, iplimit) {
+    createVMess(username, expiry, quota, iplimit, (err, result) => {
+        if (err) {
+            console.error('Error occurred:', err);
+        } else {
+            console.log('VMess account created successfully:', result);
+        }
+    });
+}
+createVMessAccount('user123', '1', '1', '1');
+```
+
+## Auto Script Link
+
+For more information and auto scripts, visit our GitHub repository:
+[https://github.com/FighterTunnel/tunnel](https://github.com/FighterTunnel/tunnel)
+
+## API
+
+For more information about our API, visit:
+[https://github.com/AutoFTbot/Api/](https://github.com/AutoFTbot/Api/)
+
+## Contribution
+
+We welcome contributions from anyone. Please make a pull request or open an issue for further discussion.
+
+## License
+
+This project is licensed under the MIT License.

package/check/checkSSH.js

@@ -0,0 +1,41 @@
+const { spawn } = require('child_process');
+
+const checkSSH = (callback) => {
+  const child = spawn("/bin/bash", ["-c", `apicheck ssh`], {
+    stdio: ['pipe', 'pipe', 'pipe']
+  });
+
+  child.stdin.end();
+  let output = '';
+  child.stdout.on('data', (data) => {
+    output += data.toString();
+  });
+
+  child.stderr.on('data', (data) => {
+    output += data.toString();
+  });
+
+  child.on('close', (code) => {
+    if (code !== 0) {
+      return callback(new Error('Terjadi kesalahan saat memeriksa akun'));
+    }
+
+    try {
+      const cleanedOutput = output.replace(/,\s*}/g, '}').replace(/,\s*]/g, ']');
+      const jsonResponse = JSON.parse(cleanedOutput);
+      if (jsonResponse.status === "success" && jsonResponse.data) {
+        callback(null, {
+          status: "success",
+          message: jsonResponse.data.message,
+          data: jsonResponse.data
+        });
+      } else {
+        callback(new Error('Akun SSH tidak ditemukan'));
+      }
+    } catch (error) {
+      callback(new Error('Terjadi kesalahan saat memproses output JSON'));
+    }
+  });
+};
+
+module.exports = checkSSH;

package/check/checkShadowsocks.js

@@ -0,0 +1,41 @@
+const { spawn } = require('child_process');
+
+const checkShadowsocks = (callback) => {
+  const child = spawn("/bin/bash", ["-c", `apicheck shadowsocks`], {
+    stdio: ['pipe', 'pipe', 'pipe']
+  });
+
+  child.stdin.end();
+  let output = '';
+  child.stdout.on('data', (data) => {
+    output += data.toString();
+  });
+
+  child.stderr.on('data', (data) => {
+    output += data.toString();
+  });
+
+  child.on('close', (code) => {
+    if (code !== 0) {
+      return callback(new Error('Terjadi kesalahan saat memeriksa akun'));
+    }
+
+    try {
+      const cleanedOutput = output.replace(/,\s*}/g, '}').replace(/,\s*]/g, ']');
+      const jsonResponse = JSON.parse(cleanedOutput);
+      if (jsonResponse.status === "success" && jsonResponse.data) {
+        callback(null, {
+          status: "success",
+          message: jsonResponse.data.message,
+          data: jsonResponse.data
+        });
+      } else {
+        callback(new Error('Akun Shadowsocks tidak ditemukan'));
+      }
+    } catch (error) {
+      callback(new Error('Terjadi kesalahan saat memproses output JSON'));
+    }
+  });
+};
+
+module.exports = checkShadowsocks;

package/check/checkTrojan.js

@@ -0,0 +1,41 @@
+const { spawn } = require('child_process');
+
+const checkTrojan = (callback) => {
+  const child = spawn("/bin/bash", ["-c", `apicheck trojan`], {
+    stdio: ['pipe', 'pipe', 'pipe']
+  });
+
+  child.stdin.end();
+  let output = '';
+  child.stdout.on('data', (data) => {
+    output += data.toString();
+  });
+
+  child.stderr.on('data', (data) => {
+    output += data.toString();
+  });
+
+  child.on('close', (code) => {
+    if (code !== 0) {
+      return callback(new Error('Terjadi kesalahan saat memeriksa akun'));
+    }
+
+    try {
+      const cleanedOutput = output.replace(/,\s*}/g, '}').replace(/,\s*]/g, ']');
+      const jsonResponse = JSON.parse(cleanedOutput);
+      if (jsonResponse.status === "success" && jsonResponse.data) {
+        callback(null, {
+          status: "success",
+          message: jsonResponse.data.message,
+          data: jsonResponse.data
+        });
+      } else {
+        callback(new Error('Akun Trojan tidak ditemukan'));
+      }
+    } catch (error) {
+      callback(new Error('Terjadi kesalahan saat memproses output JSON'));
+    }
+  });
+};
+
+module.exports = checkTrojan;

package/check/checkVLESS.js

@@ -0,0 +1,41 @@
+const { spawn } = require('child_process');
+
+const checkVLESS = (callback) => {
+  const child = spawn("/bin/bash", ["-c", `apicheck vless`], {
+    stdio: ['pipe', 'pipe', 'pipe']
+  });
+
+  child.stdin.end();
+  let output = '';
+  child.stdout.on('data', (data) => {
+    output += data.toString();
+  });
+
+  child.stderr.on('data', (data) => {
+    output += data.toString();
+  });
+
+  child.on('close', (code) => {
+    if (code !== 0) {
+      return callback(new Error('Terjadi kesalahan saat memeriksa akun'));
+    }
+
+    try {
+      const cleanedOutput = output.replace(/,\s*}/g, '}').replace(/,\s*]/g, ']');
+      const jsonResponse = JSON.parse(cleanedOutput);
+      if (jsonResponse.status === "success" && jsonResponse.data) {
+        callback(null, {
+          status: "success",
+          message: jsonResponse.data.message,
+          data: jsonResponse.data
+        });
+      } else {
+        callback(new Error('Akun VLESS tidak ditemukan'));
+      }
+    } catch (error) {
+      callback(new Error('Terjadi kesalahan saat memproses output JSON'));
+    }
+  });
+};
+
+module.exports = checkVLESS;

package/check/checkVMess.js

@@ -0,0 +1,41 @@
+const { spawn } = require('child_process');
+
+const checkVMess = (callback) => {
+  const child = spawn("/bin/bash", ["-c", `apicheck vmess`], {
+    stdio: ['pipe', 'pipe', 'pipe']
+  });
+
+  child.stdin.end();
+  let output = '';
+  child.stdout.on('data', (data) => {
+    output += data.toString();
+  });
+
+  child.stderr.on('data', (data) => {
+    output += data.toString();
+  });
+
+  child.on('close', (code) => {
+    if (code !== 0) {
+      return callback(new Error('Terjadi kesalahan saat memeriksa akun'));
+    }
+
+    try {
+      const cleanedOutput = output.replace(/,\s*}/g, '}').replace(/,\s*]/g, ']');
+      const jsonResponse = JSON.parse(cleanedOutput);
+      if (jsonResponse.status === "success" && jsonResponse.data) {
+        callback(null, {
+          status: "success",
+          message: jsonResponse.data.message,
+          data: jsonResponse.data
+        });
+      } else {
+        callback(new Error('Akun VMess tidak ditemukan'));
+      }
+    } catch (error) {
+      callback(new Error('Terjadi kesalahan saat memproses output JSON'));
+    }
+  });
+};
+
+module.exports = checkVMess;

package/create/createSSH.js

@@ -0,0 +1,44 @@
+const { spawn } = require('child_process');
+
+const createSSH = (user, password, exp, iplimit, callback) => {
+  if (!user || !password || !exp || !iplimit) {
+    return callback(new Error('Username, expiry, iplimit, dan password diperlukan'));
+  }
+
+  const child = spawn("/bin/bash", ["-c", `apicreate ssh ${user} ${password} ${exp} ${iplimit}`], {
+    stdio: ['pipe', 'pipe', 'pipe']
+  });
+
+  child.stdin.end();
+  let output = '';
+  child.stdout.on('data', (data) => {
+    output += data.toString();
+  });
+
+  child.stderr.on('data', (data) => {
+    output += data.toString();
+  });
+
+  child.on('close', (code) => {
+    if (code !== 0) {
+      return callback(new Error('Terjadi kesalahan saat membuat akun'));
+    }
+
+    try {
+      const jsonResponse = JSON.parse(output);
+      if (jsonResponse.status === "success") {
+        callback(null, {
+          status: "success",
+          message: "SSH account successfully created",
+          data: jsonResponse.data
+        });
+      } else {
+        callback(new Error("Gagal membuat akun SSH"));
+      }
+    } catch (err) {
+      callback(new Error("Terjadi kesalahan saat memproses hasil"));
+    }
+  });
+};
+
+module.exports = createSSH;

package/create/createShadowsocks.js

@@ -0,0 +1,44 @@
+const { spawn } = require('child_process');
+
+const createShadowsocks = (user, exp, quota, iplimit, callback) => {
+  if (!user || !exp || !quota || !iplimit) {
+    return callback(new Error('Username, expiry, quota, dan iplimit diperlukan'));
+  }
+
+  const child = spawn("/bin/bash", ["-c", `apicreate shadowsocks ${user} ${exp} ${quota} ${iplimit}`], {
+    stdio: ['pipe', 'pipe', 'pipe']
+  });
+
+  child.stdin.end();
+  let output = '';
+  child.stdout.on('data', (data) => {
+    output += data.toString();
+  });
+
+  child.stderr.on('data', (data) => {
+    output += data.toString();
+  });
+
+  child.on('close', (code) => {
+    if (code !== 0) {
+      return callback(new Error('Terjadi kesalahan saat membuat akun'));
+    }
+
+    try {
+      const jsonResponse = JSON.parse(output);
+      if (jsonResponse.status === "success") {
+        callback(null, {
+          status: "success",
+          message: "Shadowsocks account successfully created",
+          data: jsonResponse.data
+        });
+      } else {
+        callback(new Error("Gagal membuat akun Shadowsocks"));
+      }
+    } catch (err) {
+      callback(new Error("Terjadi kesalahan saat memproses hasil"));
+    }
+  });
+};
+
+module.exports = createShadowsocks;

package/create/createTrojan.js

@@ -0,0 +1,44 @@
+const { spawn } = require('child_process');
+
+const createTrojan = (user, exp, quota, iplimit, callback) => {
+  if (!user || !exp || !quota || !iplimit) {
+    return callback(new Error('Username, expiry, quota, dan iplimit diperlukan'));
+  }
+
+  const child = spawn("/bin/bash", ["-c", `apicreate trojan ${user} ${exp} ${quota} ${iplimit}`], {
+    stdio: ['pipe', 'pipe', 'pipe']
+  });
+
+  child.stdin.end();
+  let output = '';
+  child.stdout.on('data', (data) => {
+    output += data.toString();
+  });
+
+  child.stderr.on('data', (data) => {
+    output += data.toString();
+  });
+
+  child.on('close', (code) => {
+    if (code !== 0) {
+      return callback(new Error('Terjadi kesalahan saat membuat akun'));
+    }
+
+    try {
+      const jsonResponse = JSON.parse(output);
+      if (jsonResponse.status === "success") {
+        callback(null, {
+          status: "success",
+          message: "Trojan account successfully created",
+          data: jsonResponse.data
+        });
+      } else {
+        callback(new Error("Gagal membuat akun Trojan"));
+      }
+    } catch (err) {
+      callback(new Error("Terjadi kesalahan saat memproses hasil"));
+    }
+  });
+};
+
+module.exports = createTrojan;

package/create/createVLESS.js

@@ -0,0 +1,44 @@
+const { spawn } = require('child_process');
+
+const createVLESS = (user, exp, quota, iplimit, callback) => {
+  if (!user || !exp || !quota || !iplimit) {
+    return callback(new Error('Username, expiry, quota, dan iplimit diperlukan'));
+  }
+
+  const child = spawn("/bin/bash", ["-c", `apicreate vless ${user} ${exp} ${quota} ${iplimit}`], {
+    stdio: ['pipe', 'pipe', 'pipe']
+  });
+
+  child.stdin.end();
+  let output = '';
+  child.stdout.on('data', (data) => {
+    output += data.toString();
+  });
+
+  child.stderr.on('data', (data) => {
+    output += data.toString();
+  });
+
+  child.on('close', (code) => {
+    if (code !== 0) {
+      return callback(new Error('Terjadi kesalahan saat membuat akun'));
+    }
+
+    try {
+      const jsonResponse = JSON.parse(output);
+      if (jsonResponse.status === "success") {
+        callback(null, {
+          status: "success",
+          message: "VLESS account successfully created",
+          data: jsonResponse.data
+        });
+      } else {
+        callback(new Error("Gagal membuat akun VLESS"));
+      }
+    } catch (err) {
+      callback(new Error("Terjadi kesalahan saat memproses hasil"));
+    }
+  });
+};
+
+module.exports = createVLESS;

package/create/createVMess.js

@@ -0,0 +1,44 @@
+const { spawn } = require('child_process');
+
+const createVMess = (user, exp, quota, iplimit, callback) => {
+  if (!user || !exp || !quota || !iplimit) {
+    return callback(new Error('Username, expiry, quota, dan iplimit diperlukan'));
+  }
+
+  const child = spawn("/bin/bash", ["-c", `apicreate vmess ${user} ${exp} ${quota} ${iplimit}`], {
+    stdio: ['pipe', 'pipe', 'pipe']
+  });
+
+  child.stdin.end();
+  let output = '';
+  child.stdout.on('data', (data) => {
+    output += data.toString();
+  });
+
+  child.stderr.on('data', (data) => {
+    output += data.toString();
+  });
+
+  child.on('close', (code) => {
+    if (code !== 0) {
+      return callback(new Error('Terjadi kesalahan saat membuat akun'));
+    }
+
+    try {
+      const jsonResponse = JSON.parse(output);
+      if (jsonResponse.status === "success") {
+        callback(null, {
+          status: "success",
+          message: "VMess account successfully created",
+          data: jsonResponse.data
+        });
+      } else {
+        callback(new Error("Gagal membuat akun VMess"));
+      }
+    } catch (err) {
+      callback(new Error("Terjadi kesalahan saat memproses hasil"));
+    }
+  });
+};
+
+module.exports = createVMess;

package/delete/deleteSSH.js

@@ -0,0 +1,45 @@
+const { spawn } = require('child_process');
+
+const deleteSSH = (user, callback) => {
+  if (!user) {
+    return callback(new Error('Username diperlukan'));
+  }
+
+  const child = spawn("/bin/bash", ["-c", `apidelete ssh ${user}`], {
+    stdio: ['pipe', 'pipe', 'pipe']
+  });
+
+  child.stdin.end();
+  let output = '';
+  child.stdout.on('data', (data) => {
+    output += data.toString();
+  });
+
+  child.stderr.on('data', (data) => {
+    output += data.toString();
+  });
+
+  child.on('close', (code) => {
+    if (code !== 0) {
+      return callback(new Error('Terjadi kesalahan saat menghapus akun'));
+    }
+
+    try {
+      const cleanedOutput = output.replace(/,\s*}/g, '}').replace(/,\s*]/g, ']');
+      const jsonResponse = JSON.parse(cleanedOutput);
+      if (jsonResponse.status === "success" && jsonResponse.data) {
+        callback(null, {
+          status: "success",
+          message: jsonResponse.data.message,
+          data: jsonResponse.data
+        });
+      } else {
+        callback(new Error('Akun SSH tidak ditemukan'));
+      }
+    } catch (error) {
+      callback(new Error('Terjadi kesalahan saat memproses output JSON'));
+    }
+  });
+};
+
+module.exports = deleteSSH;

package/delete/deleteShadowsocks.js

@@ -0,0 +1,45 @@
+const { spawn } = require('child_process');
+
+const deleteShadowsocks = (user, callback) => {
+  if (!user) {
+    return callback(new Error('Username diperlukan'));
+  }
+
+  const child = spawn("/bin/bash", ["-c", `apidelete shadowsocks ${user}`], {
+    stdio: ['pipe', 'pipe', 'pipe']
+  });
+
+  child.stdin.end();
+  let output = '';
+  child.stdout.on('data', (data) => {
+    output += data.toString();
+  });
+
+  child.stderr.on('data', (data) => {
+    output += data.toString();
+  });
+
+  child.on('close', (code) => {
+    if (code !== 0) {
+      return callback(new Error('Terjadi kesalahan saat menghapus akun'));
+    }
+
+    try {
+      const cleanedOutput = output.replace(/,\s*}/g, '}').replace(/,\s*]/g, ']');
+      const jsonResponse = JSON.parse(cleanedOutput);
+      if (jsonResponse.status === "success" && jsonResponse.data) {
+        callback(null, {
+          status: "success",
+          message: jsonResponse.data.message,
+          data: jsonResponse.data
+        });
+      } else {
+        callback(new Error('Akun Shadowsocks tidak ditemukan'));
+      }
+    } catch (error) {
+      callback(new Error('Terjadi kesalahan saat memproses output JSON'));
+    }
+  });
+};
+
+module.exports = deleteShadowsocks;

package/delete/deleteTrojan.js

@@ -0,0 +1,45 @@
+const { spawn } = require('child_process');
+
+const deleteTrojan = (user, callback) => {
+  if (!user) {
+    return callback(new Error('Username diperlukan'));
+  }
+
+  const child = spawn("/bin/bash", ["-c", `apidelete trojan ${user}`], {
+    stdio: ['pipe', 'pipe', 'pipe']
+  });
+
+  child.stdin.end();
+  let output = '';
+  child.stdout.on('data', (data) => {
+    output += data.toString();
+  });
+
+  child.stderr.on('data', (data) => {
+    output += data.toString();
+  });
+
+  child.on('close', (code) => {
+    if (code !== 0) {
+      return callback(new Error('Terjadi kesalahan saat menghapus akun'));
+    }
+
+    try {
+      const cleanedOutput = output.replace(/,\s*}/g, '}').replace(/,\s*]/g, ']');
+      const jsonResponse = JSON.parse(cleanedOutput);
+      if (jsonResponse.status === "success" && jsonResponse.data) {
+        callback(null, {
+          status: "success",
+          message: jsonResponse.data.message,
+          data: jsonResponse.data
+        });
+      } else {
+        callback(new Error('Akun Trojan tidak ditemukan'));
+      }
+    } catch (error) {
+      callback(new Error('Terjadi kesalahan saat memproses output JSON'));
+    }
+  });
+};
+
+module.exports = deleteTrojan;

package/delete/deleteVLESS.js

@@ -0,0 +1,45 @@
+const { spawn } = require('child_process');
+
+const deleteVLESS = (user, callback) => {
+  if (!user) {
+    return callback(new Error('Username diperlukan'));
+  }
+
+  const child = spawn("/bin/bash", ["-c", `apidelete vless ${user}`], {
+    stdio: ['pipe', 'pipe', 'pipe']
+  });
+
+  child.stdin.end();
+  let output = '';
+  child.stdout.on('data', (data) => {
+    output += data.toString();
+  });
+
+  child.stderr.on('data', (data) => {
+    output += data.toString();
+  });
+
+  child.on('close', (code) => {
+    if (code !== 0) {
+      return callback(new Error('Terjadi kesalahan saat menghapus akun'));
+    }
+
+    try {
+      const cleanedOutput = output.replace(/,\s*}/g, '}').replace(/,\s*]/g, ']');
+      const jsonResponse = JSON.parse(cleanedOutput);
+      if (jsonResponse.status === "success" && jsonResponse.data) {
+        callback(null, {
+          status: "success",
+          message: jsonResponse.data.message,
+          data: jsonResponse.data
+        });
+      } else {
+        callback(new Error('Akun VLESS tidak ditemukan'));
+      }
+    } catch (error) {
+      callback(new Error('Terjadi kesalahan saat memproses output JSON'));
+    }
+  });
+};
+
+module.exports = deleteVLESS;

package/delete/deleteVMess.js

@@ -0,0 +1,45 @@
+const { spawn } = require('child_process');
+
+const deleteVMess = (user, callback) => {
+  if (!user) {
+    return callback(new Error('Username diperlukan'));
+  }
+
+  const child = spawn("/bin/bash", ["-c", `apidelete vmess ${user}`], {
+    stdio: ['pipe', 'pipe', 'pipe']
+  });
+
+  child.stdin.end();
+  let output = '';
+  child.stdout.on('data', (data) => {
+    output += data.toString();
+  });
+
+  child.stderr.on('data', (data) => {
+    output += data.toString();
+  });
+
+  child.on('close', (code) => {
+    if (code !== 0) {
+      return callback(new Error('Terjadi kesalahan saat menghapus akun'));
+    }
+
+    try {
+      const cleanedOutput = output.replace(/,\s*}/g, '}').replace(/,\s*]/g, ']');
+      const jsonResponse = JSON.parse(cleanedOutput);
+      if (jsonResponse.status === "success" && jsonResponse.data) {
+        callback(null, {
+          status: "success",
+          message: jsonResponse.data.message,
+          data: jsonResponse.data
+        });
+      } else {
+        callback(new Error('Akun VMess tidak ditemukan'));
+      }
+    } catch (error) {
+      callback(new Error('Terjadi kesalahan saat memproses output JSON'));
+    }
+  });
+};
+
+module.exports = deleteVMess;

package/index.js

@@ -0,0 +1,58 @@
+//CREATE
+const createSSH = require('./create/createSSH');
+const createVMess = require('./create/createVMess');
+const createVLESS = require('./create/createVLESS');
+const createTrojan = require('./create/createTrojan');
+const createShadowsocks = require('./create/createShadowsocks');
+//CHECK
+const checkSSH = require('./check/checkSSH');
+const checkVMess = require('./check/checkVMess');
+const checkVLESS = require('./check/checkVLESS');
+const checkTrojan = require('./check/checkTrojan');
+const checkShadowsocks = require('./check/checkShadowsocks');
+//DELETE
+const deleteSSH = require('./delete/deleteSSH');
+const deleteVMess = require('./delete/deleteVMess');
+const deleteVLESS = require('./delete/deleteVLESS');
+const deleteTrojan = require('./delete/deleteTrojan');
+const deleteShadowsocks = require('./delete/deleteShadowsocks');
+//RENEW
+const renewSSH = require('./renew/renewSSH');
+const renewVMess = require('./renew/renewVMess');
+const renewVLESS = require('./renew/renewVLESS');
+const renewTrojan = require('./renew/renewTrojan');
+const renewShadowsocks = require('./renew/renewShadowsocks');
+//TRIAL
+const trialSSH = require('./trial/trialssh');
+const trialTrojan = require('./trial/trialtrojan');
+const trialVMess = require('./trial/trialvmess');
+const trialVLess = require('./trial/trialvless');
+const trialShadowsocks = require('./trial/trialshadowsocks');
+
+module.exports = {
+  createSSH,
+  createVMess,
+  createVLESS,
+  createTrojan,
+  createShadowsocks,
+  checkSSH,
+  checkVMess,
+  checkVLESS,
+  checkTrojan,
+  checkShadowsocks,
+  deleteSSH,
+  deleteVMess,
+  deleteVLESS,
+  deleteTrojan,
+  deleteShadowsocks,
+  renewSSH,
+  renewVMess,
+  renewVLESS,
+  renewTrojan,
+  renewShadowsocks,
+  trialSSH,
+  trialTrojan,
+  trialVMess,
+  trialVLess,
+  trialShadowsocks
+};

package/package.json

@@ -0,0 +1,12 @@
+{
+    "name": "fightertunnel",
+    "version": "1.0.5",
+    "description": "A module for managing SSH, VMess, VLESS, Trojan, and Shadowsocks accounts",
+    "main": "index.js",
+    "scripts": {
+      "test": "echo \"Error: no test specified\" && exit 1"
+    },
+    "keywords": ["ssh", "vmess", "vless", "trojan", "shadowsocks"],
+    "author": "FighterTunnel",
+    "license": "ISC"
+  }

package/renew/renewSSH.js

@@ -0,0 +1,44 @@
+const { spawn } = require('child_process');
+
+const renewSSH = (user, exp, iplimit, callback) => {
+  if (!user || !exp || !iplimit) {
+    return callback(new Error('Username, expiry, dan iplimit diperlukan'));
+  }
+
+  const child = spawn("/bin/bash", ["-c", `apirenew ssh ${user} ${exp} ${iplimit}`], {
+    stdio: ['pipe', 'pipe', 'pipe']
+  });
+
+  child.stdin.end();
+  let output = '';
+  child.stdout.on('data', (data) => {
+    output += data.toString();
+  });
+
+  child.stderr.on('data', (data) => {
+    output += data.toString();
+  });
+
+  child.on('close', (code) => {
+    if (code !== 0) {
+      return callback(new Error('Terjadi kesalahan saat memperbarui akun'));
+    }
+
+    try {
+      const jsonResponse = JSON.parse(output);
+      if (jsonResponse.status === "success") {
+        callback(null, {
+          status: "success",
+          message: "Akun SSH berhasil diperbarui",
+          data: jsonResponse.data
+        });
+      } else {
+        callback(new Error('Terjadi kesalahan saat memperbarui akun'));
+      }
+    } catch (error) {
+      callback(new Error('Terjadi kesalahan saat memproses output JSON'));
+    }
+  });
+};
+
+module.exports = renewSSH;

package/renew/renewShadowsocks.js

@@ -0,0 +1,44 @@
+const { spawn } = require('child_process');
+
+const renewShadowsocks = (user, exp, quota, iplimit, callback) => {
+  if (!user || !exp || !quota || !iplimit) {
+    return callback(new Error('Username, expiry, quota, dan iplimit diperlukan'));
+  }
+
+  const child = spawn("/bin/bash", ["-c", `apirenew shadowsocks ${user} ${exp} ${quota} ${iplimit}`], {
+    stdio: ['pipe', 'pipe', 'pipe']
+  });
+
+  child.stdin.end();
+  let output = '';
+  child.stdout.on('data', (data) => {
+    output += data.toString();
+  });
+
+  child.stderr.on('data', (data) => {
+    output += data.toString();
+  });
+
+  child.on('close', (code) => {
+    if (code !== 0) {
+      return callback(new Error('Terjadi kesalahan saat memperbarui akun'));
+    }
+
+    try {
+      const jsonResponse = JSON.parse(output);
+      if (jsonResponse.status === "success") {
+        callback(null, {
+          status: "success",
+          message: "Akun Shadowsocks berhasil diperbarui",
+          data: jsonResponse.data
+        });
+      } else {
+        callback(new Error('Terjadi kesalahan saat memperbarui akun'));
+      }
+    } catch (error) {
+      callback(new Error('Terjadi kesalahan saat memproses output JSON'));
+    }
+  });
+};
+
+module.exports = renewShadowsocks;

package/renew/renewTrojan.js

@@ -0,0 +1,44 @@
+const { spawn } = require('child_process');
+
+const renewTrojan = (user, exp, quota, iplimit, callback) => {
+  if (!user || !exp || !quota || !iplimit) {
+    return callback(new Error('Username, expiry, quota, dan iplimit diperlukan'));
+  }
+
+  const child = spawn("/bin/bash", ["-c", `apirenew trojan ${user} ${exp} ${quota} ${iplimit}`], {
+    stdio: ['pipe', 'pipe', 'pipe']
+  });
+
+  child.stdin.end();
+  let output = '';
+  child.stdout.on('data', (data) => {
+    output += data.toString();
+  });
+
+  child.stderr.on('data', (data) => {
+    output += data.toString();
+  });
+
+  child.on('close', (code) => {
+    if (code !== 0) {
+      return callback(new Error('Terjadi kesalahan saat memperbarui akun'));
+    }
+
+    try {
+      const jsonResponse = JSON.parse(output);
+      if (jsonResponse.status === "success") {
+        callback(null, {
+          status: "success",
+          message: "Akun Trojan berhasil diperbarui",
+          data: jsonResponse.data
+        });
+      } else {
+        callback(new Error('Terjadi kesalahan saat memperbarui akun'));
+      }
+    } catch (error) {
+      callback(new Error('Terjadi kesalahan saat memproses output JSON'));
+    }
+  });
+};
+
+module.exports = renewTrojan;

package/renew/renewVLESS.js

@@ -0,0 +1,44 @@
+const { spawn } = require('child_process');
+
+const renewVLESS = (user, exp, quota, iplimit, callback) => {
+  if (!user || !exp || !quota || !iplimit) {
+    return callback(new Error('Username, expiry, quota, dan iplimit diperlukan'));
+  }
+
+  const child = spawn("/bin/bash", ["-c", `apirenew vless ${user} ${exp} ${quota} ${iplimit}`], {
+    stdio: ['pipe', 'pipe', 'pipe']
+  });
+
+  child.stdin.end();
+  let output = '';
+  child.stdout.on('data', (data) => {
+    output += data.toString();
+  });
+
+  child.stderr.on('data', (data) => {
+    output += data.toString();
+  });
+
+  child.on('close', (code) => {
+    if (code !== 0) {
+      return callback(new Error('Terjadi kesalahan saat memperbarui akun'));
+    }
+
+    try {
+      const jsonResponse = JSON.parse(output);
+      if (jsonResponse.status === "success") {
+        callback(null, {
+          status: "success",
+          message: "Akun VLESS berhasil diperbarui",
+          data: jsonResponse.data
+        });
+      } else {
+        callback(new Error('Terjadi kesalahan saat memperbarui akun'));
+      }
+    } catch (error) {
+      callback(new Error('Terjadi kesalahan saat memproses output JSON'));
+    }
+  });
+};
+
+module.exports = renewVLESS;

package/renew/renewVMess.js

@@ -0,0 +1,44 @@
+const { spawn } = require('child_process');
+
+const renewVMess = (user, exp, quota, iplimit, callback) => {
+  if (!user || !exp || !quota || !iplimit) {
+    return callback(new Error('Username, expiry, quota, dan iplimit diperlukan'));
+  }
+
+  const child = spawn("/bin/bash", ["-c", `apirenew vmess ${user} ${exp} ${quota} ${iplimit}`], {
+    stdio: ['pipe', 'pipe', 'pipe']
+  });
+
+  child.stdin.end();
+  let output = '';
+  child.stdout.on('data', (data) => {
+    output += data.toString();
+  });
+
+  child.stderr.on('data', (data) => {
+    output += data.toString();
+  });
+
+  child.on('close', (code) => {
+    if (code !== 0) {
+      return callback(new Error('Terjadi kesalahan saat memperbarui akun'));
+    }
+
+    try {
+      const jsonResponse = JSON.parse(output);
+      if (jsonResponse.status === "success") {
+        callback(null, {
+          status: "success",
+          message: "Akun VMess berhasil diperbarui",
+          data: jsonResponse.data
+        });
+      } else {
+        callback(new Error('Terjadi kesalahan saat memperbarui akun'));
+      }
+    } catch (error) {
+      callback(new Error('Terjadi kesalahan saat memproses output JSON'));
+    }
+  });
+};
+
+module.exports = renewVMess;

package/trial/trialshadowsocks.js

@@ -0,0 +1,44 @@
+const { exec } = require('child_process');
+
+const trialShadowsocks = (callback) => {
+    exec(`printf '%s\n' '30' | trialshadowsocks`, (error, stdout, stderr) => {
+        if (error) {
+            return callback(new Error(`Terjadi kesalahan: ${error.message}`));
+        }
+        if (stderr) {
+            return callback(new Error(`stderr: ${stderr}`));
+        }
+        const cleanOutput = stdout.replace(/\x1B\[[0-9;]*m/g, '').trim();
+        const result = parseTrialshadowsocksOutput(cleanOutput);
+        if (result) {
+            callback(null, {
+                status: "success",
+                message: "Trial shadowsocks berhasil dibuat",
+                data: formatshadowsocksLinks(result)
+            });
+        } else {
+            callback(new Error('Gagal mem-parsing output trial shadowsocks'));
+        }
+    });
+};
+const parseTrialshadowsocksOutput = (output) => {
+    const lines = output.split('\n');
+    const data = [];
+    
+    lines.forEach(line => {
+        const match = line.match(/ss:\/\/(.*)/);
+        if (match) {
+            data.push(match[0]);
+        }
+    });
+
+    return data;
+};
+const formatshadowsocksLinks = (links) => {
+    return {
+        "TLS Link": links[0],
+        "GRPC Link": links[1]
+    };
+};
+
+module.exports = trialShadowsocks;

package/trial/trialssh.js

@@ -0,0 +1,40 @@
+const { exec } = require('child_process');
+
+const trialSSH = (callback) => {
+  exec(`printf '%s\n' '30' | trialssh`, (error, stdout, stderr) => {
+    if (error) {
+      return callback(new Error(`Terjadi kesalahan: ${error.message}`));
+    }
+    if (stderr) {
+      return callback(new Error(`stderr: ${stderr}`));
+    }
+    const cleanOutput = stdout.replace(/\x1B\[[0-9;]*m/g, '').trim();
+    const result = parseTrialSSHOutput(cleanOutput);
+    if (result) {
+      callback(null, {
+        status: "success",
+        message: "Trial SSH berhasil dibuat",
+        data: result
+      });
+    } else {
+      callback(new Error('Gagal mem-parsing output trial SSH'));
+    }
+  });
+};
+const parseTrialSSHOutput = (output) => {
+  const lines = output.split('\n');
+  const data = {};
+  
+  lines.forEach(line => {
+    const parts = line.split(':');
+    if (parts.length === 2) {
+      const key = parts[0].trim();
+      const value = parts[1].trim();
+      data[key] = value;
+    }
+  });
+
+  return data;
+};
+
+module.exports = trialSSH;

package/trial/trialtrojan.js

@@ -0,0 +1,44 @@
+const { exec } = require('child_process');
+
+const trialTrojan = (callback) => {
+    exec(`printf '%s\n' '30' | trialtrojan`, (error, stdout, stderr) => {
+        if (error) {
+            return callback(new Error(`Terjadi kesalahan: ${error.message}`));
+        }
+        if (stderr) {
+            return callback(new Error(`stderr: ${stderr}`));
+        }
+        const cleanOutput = stdout.replace(/\x1B\[[0-9;]*m/g, '').trim();
+        const result = parseTrialTrojanOutput(cleanOutput);
+        if (result) {
+            callback(null, {
+                status: "success",
+                message: "Trial Trojan berhasil dibuat",
+                data: formatTrojanLinks(result)
+            });
+        } else {
+            callback(new Error('Gagal mem-parsing output trial Trojan'));
+        }
+    });
+};
+const parseTrialTrojanOutput = (output) => {
+    const lines = output.split('\n');
+    const data = [];
+    
+    lines.forEach(line => {
+        const match = line.match(/trojan:\/\/(.*)/);
+        if (match) {
+            data.push(match[0]);
+        }
+    });
+
+    return data;
+};
+const formatTrojanLinks = (links) => {
+    return {
+        "TLS Link": links[0],
+        "GRPC Link": links[1]
+    };
+};
+
+module.exports = trialTrojan;

package/trial/trialvless.js

@@ -0,0 +1,46 @@
+const { exec } = require('child_process');
+
+const trialVLess = (callback) => {
+    exec(`printf '%s\n' '30' | trialvless`, (error, stdout, stderr) => {
+        if (error) {
+            return callback(new Error(`Terjadi kesalahan: ${error.message}`));
+        }
+        if (stderr) {
+            return callback(new Error(`stderr: ${stderr}`));
+        }
+        const cleanOutput = stdout.replace(/\x1B\[[0-9;]*m/g, '').trim();
+        const result = parseTrialVLessOutput(cleanOutput);
+        if (result) {
+            callback(null, {
+                status: "success",
+                message: "Trial VLess berhasil dibuat",
+                data: formatVLessLinks(result)
+            });
+        } else {
+            callback(new Error('Gagal mem-parsing output trial VLess'));
+        }
+    });
+};
+
+const parseTrialVLessOutput = (output) => {
+    const lines = output.split('\n');
+    const data = [];
+    
+    lines.forEach(line => {
+        const match = line.match(/vless:\/\/(.*)/);
+        if (match) {
+            data.push(match[0]);
+        }
+    });
+
+    return data;
+};
+const formatVLessLinks = (links) => {
+    return {
+        "TLS Link": links[0],
+        "NTLS Link": links[1],
+        "GRPC Link": links[2]
+    };
+};
+
+module.exports = trialVLess;

package/trial/trialvmess.js

@@ -0,0 +1,46 @@
+const { exec } = require('child_process');
+
+const trialVMess = (callback) => {
+    exec(`printf '%s\n' '30' | trialvmess`, (error, stdout, stderr) => {
+        if (error) {
+            return callback(new Error(`Terjadi kesalahan: ${error.message}`));
+        }
+        if (stderr) {
+            return callback(new Error(`stderr: ${stderr}`));
+        }
+        const cleanOutput = stdout.replace(/\x1B\[[0-9;]*m/g, '').trim();
+        const result = parseTrialVMessOutput(cleanOutput);
+        if (result) {
+            callback(null, {
+                status: "success",
+                message: "Trial VMess berhasil dibuat",
+                data: formatVMessLinks(result)
+            });
+        } else {
+            callback(new Error('Gagal mem-parsing output trial VMess'));
+        }
+    });
+};
+
+const parseTrialVMessOutput = (output) => {
+    const lines = output.split('\n');
+    const data = [];
+    
+    lines.forEach(line => {
+        const match = line.match(/vmess:\/\/(.*)/);
+        if (match) {
+            data.push(match[0]);
+        }
+    });
+
+    return data;
+};
+const formatVMessLinks = (links) => {
+    return {
+        "TLS Link": links[0],
+        "NTLS Link": links[1],
+        "GRPC Link": links[2]
+    };
+};
+
+module.exports = trialVMess;