tambahan

bin/src/compose.ts

@@ -128,6 +128,7 @@ async function compose(name: string) {
     const composeFile = text(name);
     await fs.writeFile(`./compose.yml`, composeFile);
     Bun.spawnSync(["bash", "-c", generate(name)]);
+    console.log("✅ Compose file generated");
 }
 
 export default compose

bin/src/frp.ts

@@ -0,0 +1,165 @@
+#!/usr/bin/env bun
+import { promises as fs } from "fs";
+import * as os from "os";
+import * as path from "path";
+
+const CONFIG_FILE = path.join(os.homedir(), ".frpdev.conf");
+
+interface FrpConfig {
+  FRP_HOST: string;
+  FRP_PORT: string;
+  FRP_USER: string;
+  FRP_SECRET: string;
+  FRP_PROTO: string;
+}
+
+interface ProxyConf {
+  type?: string;
+  remotePort?: number;
+  subdomain?: string;
+  customDomains?: string[];
+}
+
+interface Proxy {
+  name?: string;
+  status?: string;
+  conf?: ProxyConf;
+}
+
+interface ProxyResponse {
+  proxies?: Proxy[];
+}
+
+async function ensureConfigFile(): Promise<void> {
+  try {
+    await fs.access(CONFIG_FILE);
+  } catch {
+    const template = `
+FRP_HOST=""
+FRP_USER=""
+FRP_SECRET=""
+`;
+    console.error(`❌ Config not found. Template created at: ${CONFIG_FILE}`);
+    console.log(template);
+    process.exit(1);
+  }
+}
+
+async function loadConfig(): Promise<FrpConfig> {
+  await ensureConfigFile();
+
+  const raw = await fs.readFile(CONFIG_FILE, "utf8");
+  const lines = raw
+    .split("\n")
+    .map((line) => line.trim())
+    .filter(Boolean);
+
+  const conf: Record<string, string> = {};
+  for (const line of lines) {
+    const [key, ...rest] = line.split("=");
+    if (!key) continue;
+    let value = rest.join("=").trim();
+
+    if (value.startsWith('"') && value.endsWith('"')) {
+      value = value.slice(1, -1);
+    }
+    conf[key] = value;
+  }
+
+  return {
+    FRP_HOST: conf.FRP_HOST || "",
+    FRP_PORT: "443",
+    FRP_USER: conf.FRP_USER || "",
+    FRP_SECRET: conf.FRP_SECRET || "",
+    FRP_PROTO: "https",
+  };
+}
+
+async function fetchFrp(config: FrpConfig, url: string): Promise<ProxyResponse> {
+  const fullUrl = `${config.FRP_PROTO}://${config.FRP_HOST}:${config.FRP_PORT}${url}`;
+
+  try {
+    const resp = await fetch(fullUrl, {
+      headers: {
+        Authorization:
+          "Basic " +
+          Buffer.from(`${config.FRP_USER}:${config.FRP_SECRET}`).toString("base64"),
+      },
+    });
+
+    if (!resp.ok) return { proxies: [] };
+
+    return (await resp.json()) as ProxyResponse;
+  } catch {
+    return { proxies: [] };
+  }
+}
+
+function sortProxies(proxies: Proxy[]): Proxy[] {
+  return [...proxies].sort((a, b) => {
+    const order = (status?: string) =>
+      status?.toLowerCase() === "online" || status?.toLowerCase() === "running"
+        ? 0
+        : 1;
+    return order(a.status) - order(b.status);
+  });
+}
+
+function formatTable(headers: string[], rows: string[][]): string {
+  const allRows = [headers, ...rows];
+  const colWidths = headers.map((_, i) =>
+    Math.max(...allRows.map((row) => (row[i] || "").length)),
+  );
+
+  return allRows
+    .map((row) =>
+      row.map((cell, i) => (cell || "").padEnd(colWidths[i] ?? 0)).join("  ").trimEnd(),
+    )
+    .join("\n");
+}
+
+async function printTable(
+  title: string,
+  headers: string[],
+  rows: string[][],
+): Promise<void> {
+  console.log(`========== ${title} ==========`);
+
+  if (rows.length === 0) {
+    console.log("No proxies found.\n");
+    return;
+  }
+
+  console.log(formatTable(headers, rows));
+  console.log();
+}
+
+async function frp(): Promise<void> {
+  const config = await loadConfig();
+
+  const [tcpResp, httpResp] = await Promise.all([
+    fetchFrp(config, "/api/proxy/tcp"),
+    fetchFrp(config, "/api/proxy/http"),
+  ]);
+
+  const tcpRows: string[][] = sortProxies(tcpResp.proxies || []).map((p) => [
+    p.name ?? "-",
+    p.status ?? "-",
+    p.conf?.remotePort?.toString() ?? "-",
+  ]);
+  await printTable("TCP PROXIES", ["NAME", "STATUS", "PORT"], tcpRows);
+
+  const httpRows: string[][] = sortProxies(httpResp.proxies || []).map((p) => [
+    p.name ?? "-",
+    p.status ?? "-",
+    Array.isArray(p.conf?.customDomains) ? p.conf.customDomains.join(",") : "",
+  ]);
+  await printTable(
+    "HTTP PROXIES",
+    ["NAME", "STATUS", "CUSTOM_DOMAIN"],
+    httpRows,
+  );
+}
+
+export default frp;
+

bin/src/port.ts

@@ -2,30 +2,66 @@
 import net from "net";
 
 interface CheckPortResult {
-    port: number;
-    open: boolean;
+  port: number;
+  open: boolean;
 }
 
+/**
+ * Memeriksa apakah port tertentu pada host terbuka.
+ * @param port Nomor port yang akan diperiksa
+ * @param host Host target
+ * @returns Promise yang resolve dengan status port
+ */
 export default function checkPort(port: number, host: string): Promise<CheckPortResult> {
-    return new Promise((resolve) => {
-      const socket = new net.Socket();
-      socket.setTimeout(200);
-  
-      socket.once("connect", () => {
-        socket.destroy();
-        resolve({ port, open: true });
-      });
-  
-      socket.once("timeout", () => {
-        socket.destroy();
-        resolve({ port, open: false });
-      });
-  
-      socket.once("error", () => {
-        socket.destroy();
-        resolve({ port, open: false });
-      });
-  
-      socket.connect(port, host);
-    });
-  }
+  return new Promise((resolve) => {
+    const socket = new net.Socket();
+
+    // Timeout untuk koneksi
+    socket.setTimeout(200);
+
+    const finalize = (isOpen: boolean) => {
+      socket.destroy();
+      resolve({ port, open: isOpen });
+    };
+
+    socket.once("connect", () => finalize(true));
+    socket.once("timeout", () => finalize(false));
+    socket.once("error", () => finalize(false));
+
+    socket.connect(port, host);
+  });
+}
+
+/**
+## 🔍 Analisis
+
+* Masalah yang ditemukan:
+  - Duplikasi kode pada `socket.destroy()` dan `resolve`.
+  - Tidak ada dokumentasi fungsi.
+* Code smells terdeteksi:
+  - Callback anonymous yang sama diulang tiga kali.
+* Peluang perbaikan:
+  - Ekstraksi logika finalize untuk DRY.
+  - Tambahkan komentar/documentation agar self-explanatory.
+
+## ✨ Kode yang Direfaktor
+
+Sudah diterapkan di atas.
+
+## 📋 Perubahan yang Dilakukan
+
+* Prinsip yang diterapkan: DRY, KISS, Clean Code
+* Pattern yang digunakan: Callback extraction untuk pengurangan duplikasi
+* Pertimbangan performa: Tidak ada perubahan signifikan, tetap ringan dan async.
+
+## 🎯 Manfaat yang Dicapai
+
+* Kemudahan pemeliharaan: Logika finalize berada di satu tempat
+* Keterbacaan: Fungsi lebih jelas dengan dokumentasi dan nama `finalize`
+* Kemudahan pengembangan: Bisa dengan mudah menambahkan logging atau metrik
+
+## ⚡ Langkah Selanjutnya (Opsional)
+
+* Tambahkan parameter timeout fleksibel
+* Gunakan TypeScript enums untuk status port jika diperlukan
+*/