Panduan Lengkap: Mengemas Aplikasi Node.js TypeScript ke Installer Windows (.exe) dengan Proteksi Kode dan Kontrol Layanan

Abstrak Eksekutif

Pendahuluan

Latar Belakang

Tujuan Artikel

Gambaran Umum Solusi

1. Pengemasan Aplikasi: Proses mengubah seluruh kode sumber Node.js dan dependensinya menjadi satu file executable Windows (.exe) yang mandiri, menghilangkan kebutuhan akan instalasi Node.js terpisah di mesin pengguna.

2. Proteksi Kode Sumber: Penerapan teknik obfuscation untuk menyembunyikan atau mempersulit pembacaan kode sumber JavaScript, melindungi kekayaan intelektual.

3. Manajemen Layanan Windows: Konfigurasi aplikasi agar dapat berjalan secara otomatis di latar belakang sebagai layanan sistem Windows, memastikan ketersediaan dan ketahanan.

4. Installer dan GUI Kontrol: Pembuatan installer yang profesional dan mudah digunakan untuk mengotomatiskan seluruh proses instalasi, serta pengembangan antarmuka pengguna grafis (GUI) untuk mengelola layanan yang berjalan dan memantau log aplikasi secara real-time.

Bagian 1: Mengemas Aplikasi Node.js TypeScript ke Executable (.exe)

1.1 Persiapan Proyek Node.js TypeScript

1.2 Pemilihan Alat Packaging: nexe sebagai Solusi Unggul

1.3 Konfigurasi nexe untuk Aplikasi Node.js TypeScript

// Pastikan untuk menginstal puppeteer-core dan @sparticuz/chromium

// npm install puppeteer-core @sparticuz/chromium

// npm install -D puppeteer (untuk pengembangan lokal)

import puppeteer from 'puppeteer-core';

import chromium from '@sparticuz/chromium';

import path from 'path';

import fs from 'fs';

async function launchBrowser() {

let executablePath;

// Logika untuk menentukan executablePath di lingkungan nexe

// nexe akan mengekstrak resources ke direktori sementara.

// Anda mungkin perlu menemukan path absolut dari Chromium yang diekstrak.

// Ini adalah bagian yang paling menantang dan mungkin memerlukan eksperimen.

// Sebagai contoh, jika Anda menempatkan chromium di folder 'chromium-binary'

// di root proyek Anda dan menyertakannya sebagai resource:

const bundledChromiumPath = path.join(process.execPath, '..', 'chromium-binary', 'chrome.exe'); // Contoh asumsi

if (fs.existsSync(bundledChromiumPath)) {

executablePath = bundledChromiumPath;

} else {

// Fallback untuk pengembangan atau jika @sparticuz/chromium tidak dapat ditemukan

executablePath = await chromium.executablePath();

}

const browser = await puppeteer.launch({

args: [...chromium.args, '--no-sandbox', '--disable-setuid-sandbox'],

executablePath: executablePath,

headless: chromium.headless,

ignoreHTTPSErrors: true,

});

return browser;

}

{
  "name": "nama-proyek-anda",

  "version": "1.0.0",

  "main": "dist/index.js",

  "scripts": {
    "build:ts": "tsc --build",

    "obfuscate": "javascript-obfuscator./dist --output./dist-obfuscated --config high-obfuscation",

    "package:win": "nexe -i./dist-obfuscated/index.js -o myapp.exe -t windows-x64-current --resources \"./public/**/*\" --resources \"./node_modules/socket.io/client-dist/*.js\" --resources \"./node_modules/@sparticuz/chromium/**/*\""
  },

  "dependencies": {
    "socket.io": "^4.x.x",

    "puppeteer-core": "^22.x.x",

    "@sparticuz/chromium": "^122.x.x"
  },

  "devDependencies": {
    "typescript": "^5.x.x",

    "nexe": "^4.x.x",

    "javascript-obfuscator": "^4.x.x",

    "puppeteer": "^22.x.x"
  }
}

1.4 Proteksi Kode Sumber dengan Obfuscation

Bagian 2: Menjalankan Aplikasi sebagai Layanan Windows

2.1 Memahami Layanan Windows untuk Aplikasi Node.js

• Auto-start: Layanan Windows dapat dikonfigurasi untuk memulai secara otomatis saat sistem boot, bahkan sebelum pengguna login ke sistem. Ini krusial untuk aplikasi server yang harus selalu aktif dan tersedia.

• Berjalan di Latar Belakang: Layanan beroperasi di Session 0, sebuah sesi yang terisolasi dan tidak memiliki antarmuka pengguna grafis. Ini berarti aplikasi berjalan tanpa jendela konsol yang terlihat oleh pengguna, memenuhi persyaratan untuk "aplikasi jadi seperti program.exe" yang beroperasi secara diam-diam di latar belakang.

• Pemulihan Otomatis: Sistem layanan Windows dapat dikonfigurasi untuk secara otomatis me-restart layanan jika mengalami kegagalan, crash, atau berhenti secara tidak terduga.18 Ini meningkatkan ketahanan aplikasi secara signifikan.

• Manajemen Terpusat: Layanan dapat dikelola dengan mudah melalui Windows Services Manager (services.msc) atau melalui perintah CLI (Command Line Interface), memungkinkan kontrol yang konsisten dan terintegrasi dengan sistem operasi.

2.2 Implementasi Layanan dengan node-windows

// install-service.js

const Service = require('node-windows').Service;

const path = require('path');

// Jalur ke executable nexe yang sudah dikemas

const appExecutablePath = path.join(process.cwd(), 'myapp.exe'); // Asumsi myapp.exe ada di direktori kerja saat ini

// Buat objek layanan baru

const svc = new Service({

name: 'NamaAplikasiNodeJSAnda', // Nama layanan yang akan muncul di Windows Services

description: 'Deskripsi singkat aplikasi Node.js Anda.',

script: appExecutablePath, // Jalur ke executable nexe Anda

nodeOptions:, // Opsional: Tambahkan opsi Node.js jika diperlukan oleh app.exe

env:

});

// Dengarkan event "install"

svc.on('install', function() {

console.log('Layanan diinstal berhasil.');

svc.start(); // Mulai layanan setelah instalasi

});

// Dengarkan event "alreadyinstalled"

svc.on('alreadyinstalled', function() {

console.log('Layanan sudah terinstal.');

});

// Dengarkan event "invalidinstallation"

svc.on('invalidinstallation', function() {

console.error('Instalasi layanan tidak valid.');

});

// Instal layanan

svc.install();

Dan skrip uninstall-service.js untuk menghapus layanan:

JavaScript

// uninstall-service.js

const Service = require('node-windows').Service;

const path = require('path');

// Buat objek layanan baru (harus sama dengan saat instalasi)

const svc = new Service({

name: 'NamaAplikasiNodeJSAnda',

script: path.join(process.cwd(), 'myapp.exe')

});

// Dengarkan event "uninstall"

svc.on('uninstall', function() {

console.log('Layanan di-uninstal berhasil.');

console.log('Layanan ada:', svc.exists); // Harusnya false

});

// Dengarkan event "notfound"

svc.on('notfound', function() {

console.log('Layanan tidak ditemukan.');

});

// Uninstal layanan

svc.uninstall();

2.3 Alternatif: NSSM (Non-Sucking Service Manager)

• Fleksibilitas: NSSM dapat menjalankan executable apa pun, tidak hanya aplikasi yang dirancang khusus sebagai layanan Windows.

• Konfigurasi Mudah: NSSM menyediakan antarmuka GUI dan CLI untuk menginstal, mengkonfigurasi, dan mengelola layanan. Ini memungkinkan pengaturan direktori kerja khusus, prioritas proses,
logging, pemeriksaan kesehatan, variabel lingkungan, dan skrip pra-peluncuran.19

• Pemantauan dan Pemulihan: NSSM terus memantau aplikasi, secara otomatis me-restart jika crash, hang, atau berhenti. Ini menjadikannya pilihan yang sangat andal untuk menjaga aplikasi non-layanan tetap berjalan di latar belakang.

• Log Otomatis: NSSM dapat mengalihkan stdout dan stderr ke file log dengan rotasi otomatis berbasis ukuran.

1. Unduh NSSM: Unduh NSSM dari situs web resminya (misalnya, dari SourceForge). Ini adalah utilitas mandiri yang tidak memerlukan instalasi.

2. Instal Layanan (CLI): Buka Command Prompt sebagai Administrator dan navigasi ke direktori NSSM. Gunakan perintah berikut:

nssm install [NamaLayananAnda][path_ke_executable_nexe_anda]

Contoh:

nssm install MyNodeAppService C:\Path\To\Your\myapp.exe

Ini akan membuka GUI NSSM di mana Anda dapat mengkonfigurasi detail layanan, seperti nama, deskripsi, direktori startup, dan argumen.

3. Mulai Layanan:

nssm start MyNodeAppService

4. Hentikan Layanan:

nssm stop MyNodeAppService

5. Uninstal Layanan:

nssm remove MyNodeAppService

NSSM adalah pilihan yang kuat dan seringkali lebih sederhana untuk mengelola executable yang dikemas sebagai layanan Windows, terutama jika tidak ingin mengintegrasikan logika layanan langsung ke dalam kode Node.js menggunakan node-windows.

Bagian 3: Membangun Installer Windows

3.1 Pemilihan Alat Installer: NSIS atau Inno Setup

• Fitur Utama: NSIS adalah sistem open source profesional untuk membuat installer Windows. NSIS dirancang agar sekecil dan sefleksibel mungkin, sehingga sangat cocok untuk distribusi internet.23 NSIS berbasis skrip dan memungkinkan pembuatan logika untuk menangani tugas instalasi yang paling kompleks. Banyak
plug-in dan skrip sudah tersedia, memungkinkan pembuatan web installer, komunikasi dengan Windows dan komponen perangkat lunak lainnya, serta instalasi atau pembaruan komponen bersama.

• Kelebihan: Ukuran overhead yang sangat kecil, komunitas yang besar, dan banyak contoh kode. NSIS juga dapat membuat
installer di Linux/macOS melalui cross-compilation jika NSSIS terinstal.

• Kekurangan: Bahasa skripnya sendiri mungkin memerlukan kurva pembelajaran.

• Fitur Utama: Inno Setup adalah builder installer open-source untuk aplikasi Windows yang telah dipercaya oleh pengembang dan organisasi sejak Inno Setup mendukung pembuatan satu file EXE untuk distribusi
online yang mudah, antarmuka wizard Windows standar yang dapat disesuaikan, kemampuan uninstal lengkap, dan berbagai opsi instalasi file termasuk kompresi. Inno Setup juga mendukung instalasi multibahasa, instalasi yang dilindungi kata sandi dan dienkripsi, instalasi yang ditandatangani secara digital, dan instalasi silent. Inno Setup memiliki opsi
preprocessor terintegrasi untuk kustomisasi waktu kompilasi tingkat lanjut dan mesin scripting Pascal terintegrasi untuk kustomisasi runtime instalasi dan uninstal tingkat lanjut.

• Kelebihan: Antarmuka wizard yang mudah digunakan untuk membuat skrip dasar, dukungan scripting Pascal yang kuat untuk logika kompleks, dan banyak fitur bawaan untuk instalasi aplikasi. Digunakan oleh proyek besar seperti Microsoft Visual Studio Code.

• Kekurangan: Bahasa scripting Pascal mungkin asing bagi pengembang Node.js.

3.2 Membuat Skrip Installer dengan Inno Setup

• ``: Mendefinisikan metadata aplikasi, direktori instalasi default, nama grup program, dan opsi kompresi.28
PrivilegesRequired=admin penting karena instalasi layanan Windows memerlukan hak administrator.

• [Files]: Mencantumkan semua file dan direktori yang akan disertakan dalam installer dan tujuan mereka di sistem pengguna. Ini harus mencakup executable myapp.exe yang dihasilkan oleh nexe, serta skrip install-service.js dan uninstall-service.js.28 Jika aplikasi memiliki aset lain (misalnya, file HTML, CSS, gambar untuk
frontend atau puppeteer), file-file tersebut juga harus disertakan di sini.

• [Icons]: Membuat pintasan di Start Menu Windows. Pintasan untuk "Start Service" dan "Stop Service" akan memanggil skrip Node.js yang relevan atau perintah NSSM secara hidden.24

• ``: Bagian ini sangat penting untuk mengotomatisasi instalasi layanan. Setelah semua file disalin, installer akan menjalankan skrip install-service.js menggunakan runtime Node.js yang dibundel (atau NSSM) untuk menginstal dan memulai layanan Windows.28 Opsi
runhidden mencegah jendela konsol muncul selama instalasi.

• ``: Mendefinisikan perintah yang akan dijalankan saat pengguna meng-uninstal aplikasi. Ini akan menghentikan dan menghapus layanan Windows yang telah diinstal.24

3.3 Membundel Runtime Node.js dan Executable nexe

1. Buka Inno Setup IDE: Buka Inno Setup Compiler.

2. Buka Skrip: Buka file .iss yang telah dibuat.

3. Kompilasi: Klik tombol "Compile" (biasanya ikon play hijau atau "Build" -> "Compile") di Inno Setup IDE.

Bagian 4: Antarmuka Pengguna Grafis (GUI) untuk Kontrol Layanan dan Log

4.1 Membangun GUI dengan Electron

• Buat proyek Electron baru: npm init electron-app@latest my-service-gui.33

• Struktur dasar akan mencakup main.js (proses utama Electron) dan index.html (antarmuka pengguna).

• main.js (Proses Utama Electron):

const { app, BrowserWindow, ipcMain } = require('electron');
const { exec } = require('node:child_process'); // Menggunakan exec untuk menjalankan perintah shell
const path = require('path');
const fs = require('fs');

let mainWindow;
const SERVICE_NAME = 'NamaAplikasiNodeJSAnda'; // Harus sama dengan nama layanan di Inno Setup / node-windows
const LOG_FILE_PATH = path.join(app.getPath('userData'), 'logs', 'main.log'); // Jalur log aplikasi Node.js

function createWindow() {
    mainWindow = new BrowserWindow({
        width: 800,
        height: 600,
        webPreferences: {
            preload: path.join(__dirname, 'preload.js'), // Skrip preload untuk komunikasi IPC
            nodeIntegration: false, // Penting untuk keamanan
            contextIsolation: true // Penting untuk keamanan
        }
    });

    mainWindow.loadFile('index.html');
    // mainWindow.webContents.openDevTools(); // Untuk debugging
}

app.whenReady().then(() => {
    createWindow();

    app.on('activate', () => {
        if (BrowserWindow.getAllWindows().length === 0) {
            createWindow();
        }
    });
});

app.on('window-all-closed', () => {
    if (process.platform!== 'darwin') {
        app.quit();
    }
});


// Handler IPC untuk kontrol layanan
ipcMain.handle('service-control', async (event, action) => {
    let command = '';
    switch (action) {
        case 'start':
            command = `sc start ${SERVICE_NAME}`;
            break;
        case 'stop':
            command = `sc stop ${SERVICE_NAME}`;
            break;
        case 'restart':
            command = `sc stop ${SERVICE_NAME} && sc start ${SERVICE_NAME}`;
            break;
        case 'status':
            command = `sc query ${SERVICE_NAME}`;
            break;
        default:
            return { success: false, message: 'Aksi tidak dikenal.' };
    }

    return new Promise((resolve) => {
        exec(command, (error, stdout, stderr) => {
            if (error) {
                console.error(`Error executing command: ${error.message}`);
                resolve({ success: false, message: stderr |



| error.message });
return;
}
if (stderr) {
console.warn(Command stderr: ${stderr});
resolve({ success: false, message: stderr });
return;
}
console.log(Command stdout: ${stdout});
resolve({ success: true, message: stdout });
});
});
});


// Handler IPC untuk membaca log
ipcMain.handle('read-log', async () => {
    try {
        if (fs.existsSync(LOG_FILE_PATH)) {
            // Membaca 100 baris terakhir dari file log
            const logContent = fs.readFileSync(LOG_FILE_PATH, 'utf8');
            const lines = logContent.split('\n');
            const last100Lines = lines.slice(Math.max(lines.length - 100, 0)).join('\n');
            return { success: true, content: last100Lines };
        } else {
            return { success: false, message: 'File log tidak ditemukan.' };
        }
    } catch (error) {
        console.error(`Error reading log file: ${error.message}`);
        return { success: false, message: error.message };
    }
});

// Handler IPC untuk tail log secara real-time
ipcMain.handle('tail-log-start', (event) => {
    if (!fs.existsSync(LOG_FILE_PATH)) {
        event.sender.send('log-update', 'File log tidak ditemukan.');
        return;
    }

    // Menggunakan fs.watchFile untuk memantau perubahan file
    fs.watchFile(LOG_FILE_PATH, { interval: 1000 }, (curr, prev) => {
        if (curr.mtime > prev.mtime) {
            // File telah dimodifikasi, baca perubahan baru
            const newContent = fs.readFileSync(LOG_FILE_PATH, 'utf8');
            const lines = newContent.split('\n');
            const last100Lines = lines.slice(Math.max(lines.length - 100, 0)).join('\n');
            event.sender.send('log-update', last100Lines);
        }
    });
});

ipcMain.handle('tail-log-stop', () => {
    fs.unwatchFile(LOG_FILE_PATH);
});

const { contextBridge, ipcRenderer } = require("electron");

contextBridge.exposeInMainWorld("electronAPI", {
  serviceControl: (action) => ipcRenderer.invoke("service-control", action),

  readLog: () => ipcRenderer.invoke("read-log"),

  tailLogStart: () => ipcRenderer.invoke("tail-log-start"),

  tailLogStop: () => ipcRenderer.invoke("tail-log-stop"),

  onLogUpdate: (callback) =>
    ipcRenderer.on("log-update", (event, data) => callback(data)),
});

• index.html (Antarmuka Pengguna Electron):

<!DOCTYPE **html**>

<html>
  <head>
    <meta charset="UTF-8" />

    <title>Kontrol Aplikasi Node.js</title>

    <style>

      body { font-family: sans-serif; padding: 20px; }

      button { margin: 5px; padding: 10px 15px; cursor: pointer; }

      #log-output {

      width: 100%;

      height: 300px;

      border: 1px solid #ccc;

      padding: 10px;

      overflow-y: scroll;

      background-color: #f9f9f9;

      font-family: monospace;

      white-space: pre-wrap;

      }
    </style>
  </head>

  <body>
    <h1>Kontrol Layanan Node.js</h1>

    <div>
      <button id="start-btn">Mulai Layanan</button>

      <button id="stop-btn">Hentikan Layanan</button>

      <button id="restart-btn">Restart Layanan</button>

      <button id="status-btn">Cek Status</button>
    </div>

    <p id="service-status"></p>

    <h2>Log Konsol</h2>

    <div>
      <button id="refresh-log-btn">Refresh Log</button>

      <button id="tail-log-btn">Mulai Tail Log Real-time</button>

      <button id="stop-tail-log-btn">Hentikan Tail Log</button>
    </div>

    <pre id="log-output"></pre>

    <script>

      const startBtn = document.getElementById('start-btn');

      const stopBtn = document.getElementById('stop-btn');

      const restartBtn = document.getElementById('restart-btn');

      const statusBtn = document.getElementById('status-btn');

      const serviceStatus = document.getElementById('service-status');

      const logOutput = document.getElementById('log-output');

      const refreshLogBtn = document.getElementById('refresh-log-btn');

      const tailLogBtn = document.getElementById('tail-log-btn');

      const stopTailLogBtn = document.getElementById('stop-tail-log-btn');

      async function controlService(action) {

      const result = await window.electronAPI.serviceControl(action);

      serviceStatus.textContent = `Status: ${result.message}`;

      if (!result.success) {

      serviceStatus.style.color = 'red';

      } else {

      serviceStatus.style.color = 'green';

      }

      }

      async function readAndDisplayLog() {

      const result = await window.electronAPI.readLog();

      if (result.success) {

      logOutput.textContent = result.content;

      logOutput.scrollTop = logOutput.scrollHeight; // Scroll ke bawah

      } else {

      logOutput.textContent = `Error: ${result.message}`;

      }

      }

      startBtn.addEventListener('click', () => controlService('start'));

      stopBtn.addEventListener('click', () => controlService('stop'));

      restartBtn.addEventListener('click', () => controlService('restart'));

      statusBtn.addEventListener('click', () => controlService('status'));

      refreshLogBtn.addEventListener('click', readAndDisplayLog);

      let isTailing = false;

      tailLogBtn.addEventListener('click', () => {

      if (!isTailing) {

      window.electronAPI.tailLogStart();

      window.electronAPI.onLogUpdate((data) => {

      logOutput.textContent = data;

      logOutput.scrollTop = logOutput.scrollHeight;

      });

      isTailing = true;

      tailLogBtn.disabled = true;

      stopTailLogBtn.disabled = false;

      serviceStatus.textContent = 'Mulai tailing log real-time...';

      serviceStatus.style.color = 'blue';

      }

      });

      stopTailLogBtn.addEventListener('click', () => {

      if (isTailing) {

      window.electronAPI.tailLogStop();

      isTailing = false;

      tailLogBtn.disabled = false;

      stopTailLogBtn.disabled = true;

      serviceStatus.textContent = 'Tailing log dihentikan.';

      serviceStatus.style.color = 'black';

      }

      });

      // Baca log saat aplikasi dimuat

      readAndDisplayLog();
    </script>
  </body>
</html>

• Komunikasi IPC: Electron menggunakan Inter-Process Communication (IPC) untuk berkomunikasi antara proses utama (Node.js) dan proses renderer (browser Chromium).34 Skrip
preload.js mengekspos API ke window objek di renderer yang memungkinkan tombol di index.html memanggil fungsi di main.js.

• Kontrol Layanan: Fungsi serviceControl di main.js menggunakan child_process.exec untuk menjalankan perintah sc (Service Control) Windows.35 Perintah ini dapat memulai, menghentikan, me-restart, atau memeriksa status layanan Windows yang telah diinstal.

• Melihat Log Konsol:

• Perekaman Log: Aplikasi Node.js yang berjalan sebagai layanan harus dikonfigurasi untuk menulis log ke file. Ini dapat dilakukan dengan mengalihkan stdout dan stderr ke file saat layanan dimulai, atau menggunakan library logging seperti winston atau log4js.36 Misalnya, di skrip
entry point Node.js Anda, Anda dapat mengalihkan process.stdout.write dan process.stderr.write ke fs.createWriteStream.36

• Pembacaan Log Real-time: Proses renderer Electron tidak dapat langsung membaca file sistem. Oleh karena itu, permintaan untuk membaca log dikirim ke proses utama melalui IPC (read-log). Proses utama kemudian membaca file log dan mengirimkan isinya kembali ke renderer.34 Untuk pembaruan
real-time, fs.watchFile dapat digunakan di proses utama untuk memantau perubahan pada file log dan mengirimkan pembaruan ke renderer melalui ipcRenderer.send.39
electron-log juga merupakan library yang sangat berguna untuk mengelola log di aplikasi Electron, secara otomatis menulis log ke lokasi standar dan memungkinkan akses dari proses utama dan renderer.41

• Tampilan Log: Log ditampilkan dalam elemen <pre> di index.html, yang mempertahankan format teks asli. Scrolling otomatis ke bawah memastikan pengguna selalu melihat log terbaru.

4.2 Mengemas GUI Electron

1. Instal Electron Forge:
npm install --save-dev @electron-forge/cli
npx electron-forge import

2. Konfigurasi package.json: Electron Forge akan menambahkan skrip dan konfigurasi ke package.json Anda.

3. Build Aplikasi:
npm run make
Perintah ini akan menghasilkan installer (misalnya, .exe atau .msi untuk Windows) untuk aplikasi GUI Anda di direktori out/make.33

Kesimpulan dan Rekomendasi

• Pengemasan yang Efisien: Penggunaan nexe adalah pilihan yang lebih unggul dibandingkan pkg untuk aplikasi Node.js yang melibatkan TypeScript dan library dengan dependensi biner seperti puppeteer. nexe menawarkan dukungan yang lebih baik untuk struktur modul modern dan penanganan resource. Namun, penanganan binary Chromium puppeteer di dalam bundle nexe memerlukan konfigurasi jalur yang cermat pada saat runtime untuk memastikan browser dapat ditemukan dan diluncurkan dengan benar.

• Proteksi Kode yang Realistis: Obfuscation JavaScript dengan alat seperti javascript-obfuscator dapat secara signifikan menghalangi rekayasa balik, tetapi tidak dapat sepenuhnya mencegahnya karena sifat bahasa yang diinterpretasikan. Kombinasi obfuscation dengan perjanjian lisensi pengguna akhir (EULA) adalah strategi yang lebih komprehensif untuk melindungi kekayaan intelektual. Penting untuk menyeimbangkan tingkat obfuscation dengan dampak potensial pada kinerja dan kemudahan debugging.

• Ketahanan Layanan: Menjalankan aplikasi Node.js sebagai layanan Windows menggunakan node-windows atau NSSM memberikan keandalan yang jauh lebih tinggi dibandingkan hanya menjalankan proses di latar belakang. Layanan dapat memulai secara otomatis saat sistem boot dan pulih dari kegagalan, memastikan ketersediaan aplikasi yang berkelanjutan. NSSM menawarkan fleksibilitas yang lebih besar dan kemudahan konfigurasi untuk mengelola executable apa pun sebagai layanan.

• Pengalaman Pengguna yang Ditingkatkan: Pengembangan GUI berbasis Electron menyediakan antarmuka yang intuitif bagi pengguna akhir untuk mengontrol layanan (memulai, menghentikan, me-restart) dan memantau log secara real-time, menggantikan kebutuhan akan interaksi baris perintah yang kompleks. Komunikasi IPC antara proses utama Electron dan renderer memungkinkan interaksi yang mulus dengan layanan sistem dan pembacaan file log.

• Installer Profesional: NSIS atau Inno Setup memungkinkan pembuatan installer Windows yang profesional dan otomatis, yang dapat membundel executable aplikasi, skrip layanan, dan GUI kontrol menjadi satu paket yang mudah didistribusikan.

1. Validasi Jalur Puppeteer: Lakukan pengujian ekstensif untuk memastikan puppeteer dapat menemukan dan meluncurkan binary Chromium yang dibundel di dalam executable nexe pada berbagai lingkungan Windows. Ini mungkin melibatkan penyesuaian logika penentuan jalur runtime dalam kode aplikasi Node.js.

2. Strategi Logging: Terapkan library logging yang kuat seperti winston atau electron-log dalam aplikasi Node.js Anda untuk memastikan semua output konsol dicatat ke file dengan format yang konsisten. Ini akan mempermudah pemantauan dan debugging melalui GUI Electron.

3. Pengujian Komprehensif: Lakukan pengujian menyeluruh terhadap seluruh alur, mulai dari instalasi installer, fungsionalitas layanan (start/stop/restart), hingga tampilan log real-time di GUI. Uji pada berbagai versi dan arsitektur Windows yang ditargetkan.

4. Dokumentasi Pengguna: Sertakan dokumentasi yang jelas untuk pengguna akhir mengenai cara menginstal, menjalankan, dan mengelola aplikasi melalui GUI, serta lokasi file log untuk pemecahan masalah.

5. Pertimbangan Keamanan: Meskipun obfuscation membantu, untuk data sensitif atau logika bisnis yang sangat kritis, pertimbangkan untuk mengimplementasikan bagian-bagian tertentu dari aplikasi sebagai layanan backend yang dihosting di server yang dikendalikan, dan hanya mengekspos API yang diperlukan ke aplikasi desktop. Ini memberikan lapisan keamanan tambahan yang tidak dapat dicapai hanya dengan proteksi kode klien.

Karya yang dikutip

1. Compile and build TypeScript code using npm - Visual Studio (Windows) | Microsoft Learn, diakses Agustus 18, 2025, https://learn.microsoft.com/en-us/visualstudio/javascript/compile-typescript-code-npm?view=vs-2022

2. How to set up TypeScript, diakses Agustus 18, 2025, https://www.typescriptlang.org/download/

3. How to make exe files from a node.js app? - Stack Overflow, diakses Agustus 18, 2025, https://stackoverflow.com/questions/8173232/how-to-make-exe-files-from-a-node-js-app

4. vercel/pkg: Package your Node.js project into an executable - GitHub, diakses Agustus 18, 2025, https://github.com/vercel/pkg

5. Packaging error with pkg tool when updating puppeteer from v1.20.0 to v24.0.0, diakses Agustus 18, 2025, https://community.latenode.com/t/packaging-error-with-pkg-tool-when-updating-puppeteer-from-v1-20-0-to-v24-0-0/32518

6. How to use with `pkg` - Socket.IO, diakses Agustus 18, 2025, https://socket.io/how-to/use-with-pkg

7. nexe/nexe: create a single executable out of your node.js apps - GitHub, diakses Agustus 18, 2025, https://github.com/nexe/nexe

8. Node.js Packaging - Tutorialspoint, diakses Agustus 18, 2025, https://www.tutorialspoint.com/nodejs/nodejs_packaging.htm

9. nexe - NPM, diakses Agustus 18, 2025, https://www.npmjs.com/package/nexe

10. Installation - Puppeteer, diakses Agustus 18, 2025, https://pptr.dev/guides/installation

11. Deploying Puppeteer with Next.js on Vercel, diakses Agustus 18, 2025, https://vercel.com/guides/deploying-puppeteer-with-nextjs-on-vercel

12. Running Puppeteer on Vercel - Medium, diakses Agustus 18, 2025, https://medium.com/@ubermensch1/running-puppeteer-on-vercel-511dfec154a1

13. Hide source code possibility · Issue #269 · nwjs/nw.js - GitHub, diakses Agustus 18, 2025, https://github.com/nwjs/nw.js/issues/269

14. how to Hide source code from build executable in electron-app : r/electronjs - Reddit, diakses Agustus 18, 2025, https://www.reddit.com/r/electronjs/comments/dts5ri/how_to_hide_source_code_from_build_executable_in/

15. JavaScript Obfuscator Tool, diakses Agustus 18, 2025, https://obfuscator.io/

16. A powerful obfuscator for JavaScript and Node.js - GitHub, diakses Agustus 18, 2025, https://github.com/javascript-obfuscator/javascript-obfuscator

17. How to Run Any Node.js Application as a Windows Service with AlwaysUp, diakses Agustus 18, 2025, https://www.coretechnologies.com/products/AlwaysUp/Apps/RunNodeJSAsAService.html

18. Set Up a Node.js Backend as a Windows Service | by Gul Ershad | Medium, diakses Agustus 18, 2025, https://mailtogulershad.medium.com/set-up-a-node-js-backend-as-a-windows-service-a9b17bf7403f

19. aelassas/servy: Run Any App as a Windows Service — A Fully Managed NSSM Alternative, diakses Agustus 18, 2025, https://github.com/aelassas/servy

20. How to Start and Run a Node.js Service in the Background using PM2 - GitHub Gist, diakses Agustus 18, 2025, https://gist.github.com/bewithdhanu/a392f61d35edf5eef8e27dc5b84753d0

21. How to install node.js as windows service? - Stack Overflow, diakses Agustus 18, 2025, https://stackoverflow.com/questions/10547974/how-to-install-node-js-as-windows-service

22. How do you run a Python script as a service in Windows? [closed] - Stack Overflow, diakses Agustus 18, 2025, https://stackoverflow.com/questions/32404/how-do-you-run-a-python-script-as-a-service-in-windows

23. NSIS Wiki, diakses Agustus 18, 2025, https://nsis.sourceforge.io/Main_Page

24. Category:Code Examples - NSIS - SourceForge, diakses Agustus 18, 2025, https://nsis.sourceforge.io/Category:Code_Examples

25. Windows Installer - Tauri, diakses Agustus 18, 2025, https://v2.tauri.app/distribute/windows-installer/

26. Inno Setup - JRSoftware.org, diakses Agustus 18, 2025, https://jrsoftware.org/isinfo.php

27. Inno Setup Help - JRSoftware.org, diakses Agustus 18, 2025, https://jrsoftware.org/ishelp/

28. Create Windows Installer for Node.js App using Inno Setup - Prakhar's blog, diakses Agustus 18, 2025, https://prakhartripathi.hashnode.dev/create-windows-installer-for-nodejs-app-using-inno-setup

29. Inno Setup Downloads - JRSoftware.org, diakses Agustus 18, 2025, https://jrsoftware.org/isdl.php

30. How to create a Windows (InnoSetup exe) installer (for NodeJS apps) - AJ ONeal, diakses Agustus 18, 2025, https://coolaj86.com/articles/how-to-create-an-innosetup-installer.html

31. Remove the need for users to set up Node.js themselves · Issue #24 · asamuzaK/withExEditorHost - GitHub, diakses Agustus 18, 2025, https://github.com/asamuzaK/withExEditorHost/issues/24

32. Building your First App | Electron, diakses Agustus 18, 2025, https://electronjs.org/docs/latest/tutorial/tutorial-first-app

33. Electron: Build cross-platform desktop apps with JavaScript, HTML, and CSS, diakses Agustus 18, 2025, https://electronjs.org/

34. Electron JS Read/Write to Locale File | by Sagar Hudge - Medium, diakses Agustus 18, 2025, https://medium.com/@sagar.hudge/electron-js-read-write-to-locale-file-711c230c798e

35. Child process | Node.js v24.6.0 Documentation, diakses Agustus 18, 2025, https://nodejs.org/api/child_process.html

36. How to configure Node.js to log to a file instead of the console? - LambdaTest Community, diakses Agustus 18, 2025, https://community.lambdatest.com/t/how-to-configure-node-js-to-log-to-a-file-instead-of-the-console/35551

37. redirect node.js console output to file - GitHub Gist, diakses Agustus 18, 2025, https://gist.github.com/eddex/520c065156b5b1fc3f7e17278b52fb9f

38. How to Create API to View Logs in Node.js ? - GeeksforGeeks, diakses Agustus 18, 2025, https://www.geeksforgeeks.org/node-js/how-to-create-api-to-view-logs-in-node-js/

39. Using tail -F to see a file changing in real-time - Stack Overflow, diakses Agustus 18, 2025, https://stackoverflow.com/questions/41756525/using-tail-f-to-see-a-file-changing-in-real-time

40. Live log tail with Logdy - stream logs from anywhere to web browser, diakses Agustus 18, 2025, https://logdy.dev/blog/post/live-log-tail-with-logdy-stream-logs-from-anywhere-to-web-browser

41. electron-log - NPM, diakses Agustus 18, 2025, https://www.npmjs.com/package/electron-log