Mengenal P2P Connector Berbasis Golang di Flowork OS (Bye-Bye Local API Server!)

Yo, devs! Pernah nggak lo dapet project bikin aplikasi web-based, tapi klien minta aplikasinya bisa langsung baca file di PC kasir, nge-print setruk langsung ke printer thermal lokal, atau jalanin script Python buat data science?

Kalau lo pakai jalan ninja Web Dev Tradisional, solusinya pasti begini: lo bikin Web UI (React/Vue), terus lo suruh user buat install Node.js, jalanin server Express.js di background PC mereka sebagai Local API, baru deh Web UI lo nembak ke http://localhost:3000.

Hasilnya? Ribet minta ampun. User biasa disuruh buka terminal buat run local server? Pasti chaos. Belum lagi memori RAM PC mereka langsung kemakan gede cuma buat ngejalanin V8 Engine-nya Node.js.

Nah, di sinilah ekosistem Flowork OS datang bawa solusi yang jauh lebih elegan dan badass: P2P Connector Berbasis Golang.

---

🐹 Kenapa Harus Golang? (Bukan Node.js atau Python)

Di dalam arsitektur Flowork OS, bagian "Web UI" (Vanilla JS/HTML) bertugas sebagai frontend murni. Tapi buat ngobrol sama hardware lokal atau ngejalanin script berat, UI ini butuh jembatan. Jembatan inilah yang kita sebut Local Node Engine (bisa lo cek di arsitektur inti Flowork).

Kenapa Flowork OS memilih Golang (main.go) sebagai pondasi engine lokalnya?

1. Single Binary: Kode Go di-compile jadi satu file .exe (atau binary Mac/Linux). User nggak perlu install runtime apapun (nggak butuh Node.js, nggak butuh Python environment untuk core engine). Tinggal klik, jalan!
2. Goroutines: Ringan banget. Nanganin ribuan koneksi WebSocket dari Web UI cuma butuh beberapa Megabyte RAM, jauh beda sama Node.js atau Python yang lumayan rakus memori.
3. Kecepatan Setara C/C++: Karena ini aplikasi local-bridge, latency adalah segalanya. Go memberikan kecepatan native tanpa mengorbankan keamanan.

---

⚙️ Bedah Mesin: Gimana P2P Golang Ini Bekerja?

Kalau lo intip source code engine Flowork (terutama di folder internal/), lo bakal nemuin pembagian tugas yang sangat rapi. Nggak ada REST API konvensional di sini. Kita pakai WebSockets biar komunikasinya Real-Time, dua arah, dan persistent.

Mari kita bedah dua komponen paling vital: handler.go dan executor.go.

1. Sang Penjaga Gerbang (internal/socket/handler.go)

File ini tugasnya nongkrong di localhost dan nungguin Web UI lo (lewat systemBridge.js) buat ngetuk pintu. Begitu Web UI connect, jalur P2P terbuka lebar.

Gini kira-kira gambaran logika handler-nya beraksi menangkap pesan JSON dari Web UI:

// Ilustrasi alur di handler.go
func (h *SocketHandler) HandleConnection(w http.ResponseWriter, r *http.Request) {
    // 1. Upgrade koneksi HTTP biasa jadi WebSocket (P2P Tunnel)
    conn, err := upgrader.Upgrade(w, r, nil)
    if err != nil {
        log.Println("Gagal buka jalur P2P:", err)
        return
    }
    defer conn.Close()

    for {
        // 2. Dengerin perintah dari Web UI (Vanilla JS)
        var task RequestSchema 
        err := conn.ReadJSON(&task)
        if err != nil {
            break // Koneksi putus
        }

        // 3. Lempar tugas ke Executor
        go h.dispatchTask(conn, task)
    }
}

Bayangin ini kayak pipa tol langsung dari Browser ke OS lokal. Nggak ada delay HTTP Handshake tiap kali mau kirim data.

2. Sang Mandor Eksekusi (internal/runner/executor.go)

Nah, setelah handler.go nerima request (misal: "Tolong jalanin script scrapper Python di folder apps/sys-info"), tugas ini dioper ke executor.go.

Executor ini ibarat mandor. Dia yang bakal ngebuka process baru di OS, ngejalanin script Python/Ruby/Native yang lo minta, ngawasin output-nya (stdout/stderr), dan ngirim balik hasilnya ke Web UI secara streaming!

// Ilustrasi eksekusi native di executor.go
func (e *Runner) ExecuteApp(appName string, payload []byte) ([]byte, error) {
    // 1. Cari path executable/script di folder sandbox Flowork
    scriptPath := filepath.Join(e.BaseDir, appName, "script.py")

    // 2. Siapin command untuk eksekusi via OS lokal
    cmd := exec.Command("python3", scriptPath)

    // 3. Injeksi payload dari Web ke stdin (Bypass argumen terminal panjang)
    cmd.Stdin = bytes.NewReader(payload)

    // 4. Tangkap hasilnya
    output, err := cmd.CombinedOutput()
    if err != nil {
        return nil, fmt.Errorf("Script error: %v, log: %s", err, string(output))
    }

    // 5. Kembalikan data matang ke Web UI
    return output, nil
}

Berkat sistem ini, Web App lo tiba-tiba punya kekuatan setara Native Desktop App! Mau nge-render video 4K pakai FFmpeg, nge-scrape data jutaan baris pakai headless browser lokal, atau baca system registry? Semua bisa dieksekusi oleh Python/C++ lokal, sementara tampilan UI-nya tetap cakep dan responsif pakai HTML & Vanilla JS.

---

🛡️ "Loh, Bukannya Bahaya Browser Bisa Akses Terminal Lokal?"

Pasti ada yang nanya gini. Tenang, bro. Keamanan adalah prioritas utama di ekosistem ini.

1. Strict Localhost Binding: Golang connector ini HANYA mendengarkan koneksi dari 127.0.0.1. Orang dari jaringan luar (bahkan satu WiFi) nggak bisa nembak port ini.
2. Schema & App Sandbox (schema.json): Web UI nggak bisa sembarangan ngetik command terminal kayak rm -rf /. Web UI HANYA bisa memanggil apps yang udah terdaftar (punya schema.json yang valid) di dalam folder ekosistem yang diizinkan. Input divalidasi ketat oleh Golang sebelum dilempar ke executor.go.

---

🎯 Kesimpulan

Dengan membuang REST API tradisional dan beralih ke arsitektur P2P WebSocket Golang, Flowork OS berhasil menciptakan standar baru untuk Hybrid Applications.

Kita dapet enaknya bikin UI pakai teknologi Web yang fleksibel, ditambah dengan keganasan performa dan akses OS dari Golang serta Python di sisi backend lokal. Semuanya terhubung tanpa hambatan, tanpa server cloud, dan tanpa memory leak.

Penasaran pengen nyoba bangun aplikasi di atas ekosistem hybrid yang revolusioner ini? Atau mau bedah langsung source code engine Golang-nya?

Langsung aja meluncur ke floworkos.com buat pelajari dokumentasi lengkapnya dan bergabung dengan revolusi Hybrid OS hari ini! 🚀🔥