I am building a Chrome extension where some user data (for example tab metadata or browsing-related information) must remain on the user’s device due to Chrome Web Store privacy policies. The extension is not allowed to send this data to my server.

Because of this restriction, I need to store the data locally using something like chrome.storage or IndexedDB. However, storing the data in plain text is not acceptable from a security perspective.

My current approach is to encrypt the data before storing it locally and decrypt it when needed.

For encryption I am using the Web Crypto API with AES-GCM, and deriving the key from a user password using PBKDF2.

Here is a simplified version of the encryption logic I am currently using:

const ALGO = 'AES-GCM';
const KEY_LENGTH = 256;
const IV_LENGTH = 12;


export async function deriveKey(password, salt) {
  const enc = new TextEncoder();
  const keyMaterial = await crypto.subtle.importKey(
    'raw',
    enc.encode(password),
    'PBKDF2',
    false,
    ['deriveKey']
  );
  return crypto.subtle.deriveKey(
    {
      name: 'PBKDF2',
      salt,
      iterations: 100000,
      hash: 'SHA-256'
    },
    keyMaterial,
    {
      name: ALGO,
      length: KEY_LENGTH
    },
    false,
    ['encrypt', 'decrypt']
  );
}
export async function encryptData(data, masterPassword) {
  const enc = new TextEncoder();
  const iv = crypto.getRandomValues(new Uint8Array(IV_LENGTH));
  const salt = crypto.getRandomValues(new Uint8Array(16));
  const key = await deriveKey(masterPassword, salt);
  const encryptedBuffer = await crypto.subtle.encrypt(
    { name: ALGO, iv },
    key,
    enc.encode(JSON.stringify(data))
  );
  return {
    cipher: bufferToBase64(encryptedBuffer),
    iv: bufferToBase64(iv),
    salt: bufferToBase64(salt)
  };
}
export async function decryptData(encryptedPayload, masterPassword) {
  const { cipher, iv, salt } = encryptedPayload;
  const key = await deriveKey(masterPassword, base64ToBuffer(salt));
  const decryptedBuffer = await crypto.subtle.decrypt(
    { name: ALGO, iv: base64ToBuffer(iv) },
    key,
    base64ToBuffer(cipher)
  );
  const dec = new TextDecoder();
  return JSON.parse(dec.decode(decryptedBuffer));
}
function bufferToBase64(buffer) {
  return btoa(String.fromCharCode(...new Uint8Array(buffer)));
}
function base64ToBuffer(base64) {
  return Uint8Array.from(atob(base64), c => c.charCodeAt(0));
}

const password = '1234';
const encrypted = await encryptData(plainTab, password);

My main concern is key management.

Since this is a browser extension without a backend, I cannot store a secret key on a server. At the same time, if a key is hardcoded or stored directly in the extension code, it can be extracted by inspecting the extension.

So my questions are:

1. What is the recommended approach for encrypting sensitive data locally in a Chrome extension?
2. How should the encryption key be generated and managed securely if everything runs on the client side?
3. Is deriving the key from a user-provided master password (using PBKDF2 or similar) considered a good practice in this scenario?
4. Are there established patterns used by password managers or other privacy-focused extensions for this problem?

I am trying to design something similar to how password managers encrypt vault data locally before storing it.

Environment:

• Chrome Extension (Manifest V3)
• JavaScript
• Web Crypto API
• Storage via chrome.storage or IndexedDB

Have you solved a similar problem in a Chrome extension or another client-only application? If you have any ideas, better approaches, or security recommendations, please leave a reply or reach out to me via email codeguyakash@gmail.com.

I’d love to learn from your experience.

If you’re working with Docker on Ubuntu, you might run into issues caused by old or conflicting Docker packages such as docker.io, docker-compose, or containerd.

The best solution is to completely remove old Docker installations and then install Docker using the official Docker repository.

In this guide, I’ll walk you through a clean and reliable way to remove Docker and reinstall the latest stable version on Ubuntu.

Step 1: Remove Old Docker Packages (Clean Slate)

Ubuntu often installs Docker from its default repository, which can be outdated.

First, we remove all existing Docker-related packages to avoid conflicts.

sudo apt remove $(dpkg --get-selections docker.io docker-compose docker-compose-v2 docker-doc podman-docker containerd runc | cut -f1)

This command:

• Detects installed Docker-related packages
• Removes them safely
• Ensures there are no leftover conflicting components

👉 This step is important for a fresh and stable Docker setup.

Step 2: Update System and Install Required Dependencies

Before adding Docker’s official repository, update your system and install required tools:

sudo apt update
sudo apt install ca-certificates curl

These packages allow Ubuntu to:

• Securely download files over HTTPS
• Verify Docker’s authenticity

Step 3: Add Docker’s Official GPG Key

Docker signs its packages for security.

We add Docker’s official GPG key so Ubuntu can trust the packages.

sudo install -m 0755 -d /etc/apt/keyrings
sudo curl -fsSL https://download.docker.com/linux/ubuntu/gpg -o /etc/apt/keyrings/docker.asc
sudo chmod a+r /etc/apt/keyrings/docker.asc

This ensures:

• Package integrity
• Secure installation from Docker’s servers

Step 4: Add Docker’s Official Repository

Now we tell Ubuntu where to download Docker from.

sudo tee /etc/apt/sources.list.d/docker.sources <<EOF
Types: deb
URIs: https://download.docker.com/linux/ubuntu
Suites: $(. /etc/os-release && echo "${UBUNTU_CODENAME:-$VERSION_CODENAME}")
Components: stable
Signed-By: /etc/apt/keyrings/docker.asc
EOF

Then refresh the package list:

sudo apt update

This ensures Ubuntu can now fetch the latest Docker versions.

Step 5: Install Latest Docker Packages

Install Docker and its essential components:

sudo apt install docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin

This installs:

• Docker Engine
• Docker CLI
• Container runtime
• Buildx for advanced builds
• Docker Compose v2 (recommended)

Step 6: Start and Verify Docker Service

Check Docker’s status:

sudo systemctl status docker

If it’s not running, start it manually:

sudo systemctl start docker

To verify installation:

docker --version
docker compose version

🎉 If versions show correctly, Docker is installed successfully.

Why This Method Is Recommended

• ✅ Avoids outdated Ubuntu packages
• ✅ Prevents version conflicts
• ✅ Uses Docker’s official repository
• ✅ Stable for production & CI/CD setups

This approach is ideal for:

• Backend developers
• DevOps engineers
• AWS EC2 / VPS servers
• Docker-based production environments

Ref : https://docs.docker.com/engine/install/ubuntu

Akash (codeguyakash)

If you want to deploy your Node.js backend on an EC2 instance with a fully automated CI/CD pipeline using GitHub Actions, this guide is for you.
We’ll configure EC2, install Node.js via NodeSource, setup Nginx as a reverse proxy, use PM2 for process management, and automate everything through GitHub Actions.

Let’s build a production-grade deployment pipeline!

✅ Prerequisites

• AWS EC2 instance (Ubuntu 22.04 recommended)
• Security groups opened for:
• 22 (SSH)
• 80 (HTTP)
• GitHub repository containing your Node.js backend
• Your SSH private key for deployment

◦ Step 1: Update Your EC2 Instance

SSH into your instance and update the packages:

sudo apt update && sudo apt upgrade -y

◦ Step 2: Install Node.js (Using NodeSource — Recommended)

We are not using the n module.
Install the official Node.js 20 LTS with NodeSource:

curl -fsSL https://deb.nodesource.com/setup_lts.x | sudo -E bash -
sudo apt install -y nodejs

Verify installation:

node -v
npm -v

◦ Step 3: Install and Configure Nginx

sudo apt install nginx -y

sudo systemctl start nginx
sudo systemctl enable nginx
sudo systemctl status nginx

Nginx will serve as a reverse proxy forwarding port 80 → your Node.js app on port 8000.

◦ Step 4: Create Deployment Directory

sudo mkdir -p /var/www/express-app
cd /var/www/express-app

(Optional) Give ownership to ubuntu:

sudo chown -R ubuntu:ubuntu /var/www/express-app

◦ Step 5: Configure Nginx Reverse Proxy

Create a config file:

sudo nano /etc/nginx/sites-available/express-app

Paste this:

server {
    listen 80;
    server_name YOUR_EC2_PUBLIC_IP;location / {
        proxy_pass http://localhost:8000;
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection 'upgrade';
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
        proxy_cache_bypass $http_upgrade;
        proxy_connect_timeout 60s;
        proxy_send_timeout 60s;
        proxy_read_timeout 60s;
    }
}

Enable the config:

sudo ln -s /etc/nginx/sites-available/express-app /etc/nginx/sites-enabled/
sudo rm /etc/nginx/sites-enabled/default
sudo nginx -t
sudo systemctl restart nginx

◦ Step 6: Install PM2 to Manage the App

sudo npm install -g pm2

pm2 startup

Your app will later be started via PM2 inside the GitHub Action script.

◦ Step 7: Add GitHub Secrets

In your GitHub repo:

Settings → Secrets and variables → Actions → New repository secret

Add these:

• EC2_HOST → your EC2 Public IP
• EC2_USERNAME → ubuntu
• EC2_SSH_KEY → paste entire .pem key

Example:

-----BEGIN RSA PRIVATE KEY-----
...
-----END RSA PRIVATE KEY-----

◦ Step 8: Create GitHub Actions Workflow

Create:

.github/workflows/deploy.yml

Paste the following workflow (updated with NodeSource version, no “n”):

name: Deploy to EC2

on:
  push:
    branches: [main]
  workflow_dispatch:
jobs:
  build:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - name: Setup Node.js
        uses: actions/setup-node@v4
        with:
          node-version: "20"
      - name: Install dependencies
        run: npm ci
      - name: Build TypeScript
        run: npm run build
      - name: Create deployment package
        run: |
          mkdir -p deploy
          cp -r dist deploy/
          cp -r src deploy/
          cp package*.json deploy/
          cp ecosystem.config.cjs deploy/
          [ -f .env.example ] && cp .env.example deploy/
          tar -czf deploy.tar.gz -C deploy .
      - uses: actions/upload-artifact@v4
        with:
          name: deployment-package
          path: deploy.tar.gz
          retention-days: 1
  deploy:
    needs: build
    runs-on: ubuntu-latest
    steps:
      - uses: actions/download-artifact@v4
        with:
          name: deployment-package
      - name: Deploy to EC2
        env:
          EC2_HOST: ${{ secrets.EC2_HOST }}
          EC2_USERNAME: ${{ secrets.EC2_USERNAME }}
          SSH_PRIVATE_KEY: ${{ secrets.EC2_SSH_KEY }}
        run: |
          echo "$SSH_PRIVATE_KEY" > private_key.pem
          chmod 600 private_key.pem
          scp -i private_key.pem -o StrictHostKeyChecking=no deploy.tar.gz ${EC2_USERNAME}@${EC2_HOST}:/tmp/
          ssh -i private_key.pem -o StrictHostKeyChecking=no ${EC2_USERNAME}@${EC2_HOST} << 'EOF'
            cd /var/www/express-app
            sudo chown -R $USER:$USER /var/www/express-app
            if [ -d "dist" ]; then
              timestamp=$(date +%Y%m%d_%H%M%S)
              mkdir -p backups
              tar -czf backups/backup_${timestamp}.tar.gz dist package.json ecosystem.config.cjs .env 2>/dev/null || true
              ls -t backups/backup_*.tar.gz 2>/dev/null | tail -n +6 | xargs -r rm
            fi
            tar --overwrite -xzf /tmp/deploy.tar.gz -C /var/www/express-app
            rm /tmp/deploy.tar.gz
            sudo chown -R $USER:$USER /var/www/express-app
            npm ci --omit=dev
            if [ ! -f .env ]; then
              echo "NODE_ENV=production" > .env
              echo "PORT=8000" >> .env
            fi
            mkdir -p logs
            if pm2 describe express-app > /dev/null 2>&1; then
              pm2 reload ecosystem.config.cjs --update-env
            else
              pm2 start ecosystem.config.cjs
            fi
            pm2 save
          EOF
          rm private_key.pem
      - name: Verify Deployment
        env:
          EC2_HOST: ${{ secrets.EC2_HOST }}
        run: |
          sleep 10
          response=$(curl -s -o /dev/null -w "%{http_code}" http://${EC2_HOST})
          echo "App responded with: $response"

🚀 Your CI/CD Pipeline Is Now Ready!

Every time you push to the main branch:

1. GitHub builds the app
2. Packages it
3. Uploads to EC2
4. Auto-extracts & restarts with PM2
5. Nginx serves traffic

How to Install Node.js, Deploy a React-Vite App with Nginx, and Use PM2 on Ubuntu

From creating repositories to managing issues, pull requests, releases, and even gists — GitHub CLI makes your workflow smoother, faster, and far more efficient.

In this guide, I’ll cover the most essential gh commands you’ll use daily, with clear examples for every feature. Bookmark this article — this will become your GitHub CLI cheat sheet! 💻⚡

⭐ What Is GitHub CLI?

GitHub CLI (gh) is an official command-line tool that lets you interact with GitHub without opening the browser. You can manage:

✔️ Repositories

✔️ Pull Requests

✔️ Issues

✔️ Releases

✔️ Gists

✔️ Extensions

✔️ Configuration

All directly from your command line.

🏗️ Repository Management with

gh repo

Creating and managing GitHub repositories is effortless with gh repo.

Create a new repository

gh repo create my-project --public --clone

Clone a repository

gh repo clone cli/cli

List your repositories

gh repo list --visibility public -L 50

View repository details

gh repo view OWNER/REPO --web

🔀 Pull Request Management with

gh pr

Manage pull requests like a pro — without even opening GitHub.

Create a pull request

gh pr create --title "Fix: Bug" --body "Fixed the issue"

List pull requests

gh pr list --state closed --author "@me"

Checkout a PR locally

gh pr checkout 32

Merge a PR

gh pr merge --squash --delete-branch

🐞 Issue Management with

gh issue

Creating and managing issues becomes super straightforward.

Create a new issue

gh issue create --title "Found a bug" --label "bug,help wanted"

List issues

gh issue list --assignee "@me"

View an issue

gh issue view 123 --web

✨ Gist Management with

gh gist

Need to share code snippets? Gists are perfect.

Create a new gist

gh gist create --public hello.py

List your gists

gh gist list --secret

Clone a gist

gh gist clone 5b0e0062eb8e9654adad7bb1d81cc75f

📦 Release Management with

gh release

Automate release workflows from your terminal.

Create a release

gh release create v1.2.3 --notes "bugfix release"

Download release assets

gh release download --pattern '*.deb'

List releases

gh release list --limit 10

⚙️ Configuration Management with

gh config

Tweak your GitHub CLI environment exactly how you like it.

View config

gh config list

Get a specific key

gh config get editor

Set a config key

gh config set git_protocol ssh

Clear cache

gh config clear-cache

🧩 Create Aliases with

gh alias

Aliases help you shorten long commands.

Create an alias

gh alias set pv 'pr view'

List aliases

gh alias list

🛠️ GH Extensions (gh extension)

Extensions turn GitHub CLI into a powerful plugin-based tool.

Install an extension

gh extension install owner/gh-extension

List extensions

gh extension list

Search for new extensions

gh extension search branch

🔧 Useful Flags You Should Know

Output JSON

gh pr list --json number,title

Template format

gh issue list --template '{{.title}}'

Use a specific repo

gh pr list -R cli/cli

Open in browser

gh pr view 123 -w

Use GH_TOKEN in scripts

export GH_TOKEN=your_token_here

If you’ve ever deployed a project on a free hosting service like Render, Vercel, Railway, or Glitch, you might have experienced this annoying problem:

You leave your app running… and after some time, with no incoming requests, the server goes to sleep.

That means the next time someone visits, they face a cold start — extra load time while the service spins up your app again.

For students, hobbyists, or anyone running small side projects, this can make your project feel slow and unreliable.

The Problem with Free Deployments

Free hosting services do this for a reason — to save resources. But for apps that need to stay alive (like API backends, demo projects, or Telegram/Discord bots), this “sleep mode” can break the experience.

For example:

• A bot missing messages because the server was asleep
• Your portfolio API being slow during a job interview
• Class projects failing during a live demo

The Solution: Keep Pinging Your Server

The idea is simple: send a request to your own server at fixed intervals so the hosting provider thinks it’s “in use” and doesn’t put it to sleep.

That’s exactly what my npm package keepalive-server does.

How keepalive-server Works

It’s a tiny Node.js library that pings any URL you specify at a fixed interval.

You can use it to:

• Keep your backend awake
• Ping a /health or /ping endpoint
• Run from a different server or even from the same one

Installation

npm i keepalive-server

Usage

ESM

import { ping } from 'keepalive-server';

ping(60000, 'https://your-url.com'); // ping every 60 seconds

CommonJS (dynamic import)

(async () => {
  const { ping } = await import('keepalive-server');
  ping(60000, 'https://your-url.com');
})();

API

ping(intervalMs, url, timeoutMs?)

• intervalMs → Ping interval in milliseconds (e.g., 60000 for 1 minute)
• url → Target URL to ping
• timeoutMs (optional) → Timeout per request (default: 10 seconds)

💡 Tip: Always ping a lightweight endpoint like /health instead of your main API.

Why Use This?

• Keeps your app responsive for visitors
• Lightweight — no heavy dependencies
• Works with Render, Vercel, Railway, Glitch, and similar platforms
• Simple enough to add in two lines of code

Final Thoughts

If your student project, side hustle, or demo keeps going to sleep, give keepalive-server a try.

It’s minimal, does exactly one job, and saves you from the embarrassment of saying

“Sorry, it’s loading because my server was asleep…”

You can check out the package here:
👉 https://www.npmjs.com/package/keepalive-server

Ghar ka Smart Sensor

Maan lo aapke ghar ke gate par ek smart sensor laga hai.
Is sensor ko pata hai kaun-kaun ghar ke asli members hain: mummy, papa, bhai, didi sab registered.

Ab ek din aapka dost Raju ghar pe kuch dene aata hai.

Sensor dekhta hai aur chillata hai:

“Yeh to koi outsider hai!”

Aur phir bajta hai Teeeeeennnnnnnnnn!!!
Ghar ke andar siren baje jaa raha hai.
Raju bhi shock mein… ghar wale bhi.

Yahi browser karta hai jab CORS error deta hai 😂

🧠 Samjho CORS Kya Hai?

CORS = Cross-Origin Resource Sharing

Yeh browser ka ek security rule hai. Jab aapki frontend app (e.g., localhost:5500) kisi different origin ke backend se data maangti hai (e.g., localhost:3000), tab browser kehta hai:

“Bhai, main server se poochunga pehle — tu authorized hai ya nahi!”

Agar server ne “haan bhai allow hai” waala header nahi diya, toh browser seedha error de deta hai.

🔥 Error Kaise Dikhta Hai?

Access to fetch at 'http://localhost:3000/api/data' from origin 'http://localhost:5500' has been blocked by CORS policy

Developer ka reaction:

“Yaar backend toh chal raha hai! Ye kya natak hai?”

😎 Jugaadu Developer ka Hack: Extension Lagao

Jab developer ke paas server ka control nahi hota ya time nahi hota, toh wo extension install karta hai:

CORS Unblocker
Ya koi custom Chrome extension

Extension browser ko bolta hai:

“Relax bhai, headers toh main add kar raha hoon. Sab set hai.”

Browser bolta hai:

“Oh okay! Mujhe kya, headers mil gaye. Allow kar deta hoon.”

😎 Developer:

“CORS error gaya tel lene.”

😂 Desi Analogy #2: School Wala Scene

Socho school ka gatekeeper ho.
Sab students ID card ke saath aate hain.
Ek naya ladka bina ID ke aata hai.
Gatekeeper chillata hai: “Kaun hai tu bhai?” → CORS error.

Agar uske paas fake ID card hota (extension), toh woh andar aa jaata 😅

✅ Real Solution (For Developers)

CORS ka sahi tareeka hai:
Server ko batana hota hai ki kaun origin allowed hai.

Aapko frontend ya backend dono me thoda kaam karna padega:

🔧 Option 1: Server Side (Backend Pe Fix)

Agar aap backend developer ho (Node.js + Express):

const cors = require('cors');
app.use(cors()); // This allows all origins

// Or specific origin allow:
app.use(cors({
  origin: 'http://localhost:5500'
}));

Agar aap PHP/Python/Django pe ho, toh bhi response headers me ye bhejna hoga:

Access-Control-Allow-Origin: http://localhost:5500
Access-Control-Allow-Methods: GET, POST, PUT, DELETE
Access-Control-Allow-Headers: Content-Type

🎯 Option 2: Frontend Pe kuch nahi karna padta (bas wait karo!)

CORS ka pura control server ke paas hota hai.
Frontend se sirf request jaata hai, aur browser verify karta hai server ne allow kiya ya nahi.

🔁 Alternate Temporary Fix: Extension

Agar aapke paas server ka access nahi hai, ya aap just testing kar rahe ho, toh:

✅ Use this Chrome Extension:
🔗 Allow CORS: Access-Control-Allow-Origin

Ya aap apna khud ka extension bhi bana sakte ho (jaise humne upar banaya):

• Extension browser me response headers inject karta hai
• Server se kuch lena dena nahi hota
• Production me use mat karo — sirf development/test ke liye

⚠️ Warning Time!

Extension is Jugaad, not a permanent fix!
Browser ko bewakoof banana kaafi din tak nahi chalega.

Agar app production me jaa rahi hai:

• Server pe sahi headers configure karo.
• Dev tools ke liye extension theek hai, but public users ke liye nahi.

🏁 Summary

Scenario Solution Server access hai Add CORS headers Server access nahi Use extension (dev only) Production me Headers hi lagao bhai! Browser error dikha raha Browser ka CORS siren hai

💬 One-liner Dev Quote:

“Browser ne siren bajaya, extension ne chhup kara diya, lekin asli permission toh mummy (server) hi degi!”

Deploying a React-Vite application on an Ubuntu server with Nginx and managing it using PM2 is a great way to ensure smooth performance. This guide will walk you through the process step by step.

Step 1: Install Node.js on Ubuntu

First, update the system package list and upgrade existing packages:

sudo apt update && sudo apt upgrade -y

Then, install Node.js using NodeSource:

curl -fsSL https://deb.nodesource.com/setup_20.x | sudo -E bash -
sudo apt install -y nodejs

Verify the installation:

node -v
npm -v

Step 2: Generate a Production Build for React-Vite

Navigate to your React-Vite project directory:

cd /path/to/your-react-project

Ensure dependencies are installed:

npm install

Build the project for production:

npm run build

This will generate a dist/ folder containing the optimized production files.

Step 3: Move Build Files to Nginx Root Directory

Move the dist/ folder to a directory accessible by Nginx:

sudo mv /path/to/your-react-project/dist /var/www/react-app

Set proper ownership and permissions:

sudo chown -R www-data:www-data /var/www/react-app
sudo chmod -R 755 /var/www/react-app

Step 4: Configure Nginx for React App

Create a new Nginx configuration file:

sudo nano /etc/nginx/sites-available/react-app

Paste the following configuration:

server {
    listen 80;
    server_name _;  # Use your domain or IP if available

    root /var/www/react-app;
    index index.html;
    
    location / {
        try_files $uri /index.html;
    }

    error_page 404 /index.html;

    # Backend API proxy (3000 port)
    location /api/ {
        proxy_pass http://localhost:3000/;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
    }
}

Save the file and enable the configuration:

sudo ln -s /etc/nginx/sites-available/react-app /etc/nginx/sites-enabled/

If necessary, disable the default Nginx site:

sudo rm /etc/nginx/sites-enabled/default

Test the configuration and restart Nginx:

sudo nginx -t
sudo systemctl restart nginx

If any errors occur, check logs using:

sudo journalctl -xe

Step 5: Allow Traffic Through Firewall

Ensure that HTTP traffic is allowed:

sudo ufw allow 80/tcp

Now, visit your server’s IP in a browser:

http://your_server_ip

Your React-Vite app should be live! 🚀

Step 6: Configure Nginx for a Node.js Backend (Optional)

If your React app communicates with a Node.js backend, update the Nginx configuration:

location /api/ {
    proxy_pass http://localhost:3000/;  # Adjust port as needed
    proxy_set_header Host $host;
    proxy_set_header X-Real-IP $remote_addr;
    proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
    proxy_set_header X-Forwarded-Proto $scheme;
}

Restart Nginx to apply changes:

sudo systemctl restart nginx

Step 7: Install and Configure PM2 for Process Management

PM2 ensures that your Node.js application keeps running.

Install PM2 globally:

sudo npm install -g pm2

Verify installation:

pm2 -v

Start your Node.js app with PM2:

pm2 start app.js

Manage PM2 processes:

pm2 list         # View running applications
pm2 restart app  # Restart an app
pm2 stop app     # Stop an app
pm2 delete app   # Remove an app from PM2

Enable PM2 to restart on reboot:

pm2 startup

Run the suggested command that appears, for example:

sudo env PATH=$PATH:/usr/bin pm2 startup systemd -u your-user --hp /home/your-user

Save the PM2 process list:

pm2 save

Now, even after a reboot, PM2 will ensure your application starts automatically! 🚀

Akash (codeguyakash)

In this article, we will explore how to detect USB devices in a React Native app using a custom native module written in Kotlin. This guide will walk you through the process step by step, explaining how the code works.

Introduction

React Native does not provide built-in support for USB detection, but we can achieve this functionality by integrating native Android code. By using UsbManager and BroadcastReceiver, we can listen for USB device connections and disconnections.

Step 1: Creating the USB Detection Module

We will create a custom native module in Kotlin to handle USB device detection.

UsbDetectionModule.kt

package com.youapp

import android.content.BroadcastReceiver
import android.content.Context
import android.content.Intent
import android.content.IntentFilter
import android.hardware.usb.UsbDevice
import android.hardware.usb.UsbManager
import com.facebook.react.bridge.*
import com.facebook.react.modules.core.DeviceEventManagerModule

class UsbDetectionModule(reactContext: ReactApplicationContext) :
    ReactContextBaseJavaModule(reactContext) {

    init {
        registerUsbReceiver()
    }

    override fun getName(): String {
        return "UsbDetection"
    }

    @ReactMethod
    fun getConnectedUsbDevices(promise: Promise) {
        try {
            val usbManager = reactApplicationContext.getSystemService(Context.USB_SERVICE) as UsbManager
            val devices: HashMap<String, UsbDevice> = usbManager.deviceList as HashMap<String, UsbDevice>

            val deviceNames: WritableArray = Arguments.createArray()
            for ((_, device) in devices) {
                deviceNames.pushString(device.deviceName)
            }

            promise.resolve(deviceNames)
        } catch (e: SecurityException) {
            promise.reject("USB_PERMISSION_ERROR", "USB permission is missing: ${e.message}")
        } catch (e: Exception) {
            promise.reject("USB_ERROR", "Failed to get USB devices: ${e.message}")
        }
    }

    private fun registerUsbReceiver() {
        val filter = IntentFilter().apply {
            addAction(UsbManager.ACTION_USB_DEVICE_ATTACHED)
            addAction(UsbManager.ACTION_USB_DEVICE_DETACHED)
        }
        reactApplicationContext.registerReceiver(usbReceiver, filter)
    }

    private val usbReceiver: BroadcastReceiver = object : BroadcastReceiver() {
        override fun onReceive(context: Context, intent: Intent) {
            val action = intent.action ?: return
            reactApplicationContext.getSystemService(Context.USB_SERVICE) as UsbManager
            val device: UsbDevice? = intent.getParcelableExtra(UsbManager.EXTRA_DEVICE)

            when (action) {
                UsbManager.ACTION_USB_DEVICE_ATTACHED -> {
                    if (device != null) {
                        sendEvent("USB_ATTACHED", device.deviceName)
                    }
                }
                UsbManager.ACTION_USB_DEVICE_DETACHED -> {
                    if (device != null) {
                        sendEvent("USB_DETACHED", device.deviceName)
                    }
                }
            }
        }
    }

    private fun sendEvent(eventName: String, deviceName: String) {
        reactApplicationContext
            .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
            ?.emit(eventName, deviceName)
    }
}

Step 2: Creating the USB Detection Package

We need to package the module so it can be accessed from React Native.

UsbDetectionPackage.kt

package com.youapp

import com.facebook.react.ReactPackage
import com.facebook.react.bridge.NativeModule
import com.facebook.react.bridge.ReactApplicationContext
import com.facebook.react.uimanager.ViewManager

class UsbDetectionPackage : ReactPackage {
    override fun createNativeModules(reactContext: ReactApplicationContext): List<NativeModule> {
        return listOf(UsbDetectionModule(reactContext))
    }

    override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> {
        return emptyList()
    }
}

Step 3: Registering the Package in the Main Application

We need to register our new package in MainApplication.kt.

MainApplication.kt

package com.youapp

import android.app.Application
import com.facebook.react.PackageList
import com.facebook.react.ReactApplication
import com.facebook.react.ReactHost
import com.facebook.react.ReactNativeHost
import com.facebook.react.ReactPackage
import com.facebook.react.defaults.DefaultNewArchitectureEntryPoint.load
import com.facebook.react.defaults.DefaultReactHost.getDefaultReactHost
import com.facebook.react.defaults.DefaultReactNativeHost
import com.facebook.react.soloader.OpenSourceMergedSoMapping
import com.facebook.soloader.SoLoader

class MainApplication : Application(), ReactApplication {

  override val reactNativeHost: ReactNativeHost =
      object : DefaultReactNativeHost(this) {
        override fun getPackages(): List<ReactPackage> =
            PackageList(this).packages.apply {
              add(UsbDetectionPackage()) // Register here 
            }

        override fun getJSMainModuleName(): String = "index"
        override fun getUseDeveloperSupport(): Boolean = BuildConfig.DEBUG
        override val isNewArchEnabled: Boolean = BuildConfig.IS_NEW_ARCHITECTURE_ENABLED
        override val isHermesEnabled: Boolean = BuildConfig.IS_HERMES_ENABLED
      }

  override val reactHost: ReactHost
    get() = getDefaultReactHost(applicationContext, reactNativeHost)

  override fun onCreate() {
    super.onCreate()
    SoLoader.init(this, OpenSourceMergedSoMapping)
    if (BuildConfig.IS_NEW_ARCHITECTURE_ENABLED) {
      load()
    }
  }
}

Step 4: Using the USB Detection Module in React Native

We will use the module in our React Native app.

App.tsx

import { NativeEventEmitter, NativeModules } from 'react-native';

const UsbDetection = NativeModules.UsbDetection;
const usbEmitter = new NativeEventEmitter(UsbDetection);

useEffect(() => {
  usbEmitter.addListener('USB_ATTACHED', deviceName => {
    console.log('USB Connected:', deviceName);
  });

  usbEmitter.addListener('USB_DETACHED', deviceName => {
    console.log('USB Disconnected:', deviceName);
  });

  return () => {
    usbEmitter.removeAllListeners('USB_ATTACHED');
    usbEmitter.removeAllListeners('USB_DETACHED');
  };
}, []);

Conclusion

By following these steps, you can successfully detect USB devices in your React Native application. This approach helps in real-time monitoring of USB device connections and disconnections using Kotlin and React Native.

Picture this: you’ve got a brilliant idea for a web application — maybe it’s a task tracker, a social platform, or the next big online game. But, how do you turn that idea into reality? That’s where the dynamic duo of Node.js and Express.js come to the rescue!

Setting the Stage: ‘npm init’

Every journey starts with a single step. In web development, that often means a simple command: npm init -y . Here's what happens behind the scenes:

• Node Package Manager (npm): This handy tool helps you manage all the awesome code libraries you’ll use in your project.
• The ‘init’ command: This tells npm to set up a house for your project — the package.json file. It's like the blueprint, listing your project's name, what other tools you use, and more.
• The ‘-y’ flag: This is a shortcut telling npm, “Don’t ask me questions, just use the basics!”

Example:

{
  "name": "your-folder-name",
  "version": "1.0.0",
  "description": "basic express app",
  "main": "index.js",
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1"
  },
  "keywords": [],
  "author": "Akash (codeguyakash)",
  "license": "ISC"
}

Introducing Express.js: The Streamlined Web Architect

Node.js provides the raw power for building web servers, but Express.js makes the process elegant and organized. Think of it this way:

• Node.js is the engine: It handles the technical grunt work of receiving requests and sending responses.
• Express.js is the design expert: It gives you the tools to shape routes (think of them as the roads of your application), handle different types of requests (like GET or POST), and make your app look pretty.

Building Your First Express App: A Beginner’s Blueprint

Let’s create a super simple website. Imagine we’ll call it index.js:

JavaScript

const express = require('express');
const app = express();

const port = process.env.PORT || 3000;

app.get('/', (req, res) => {
  res.send('Hello from Express!');
}); 
 
app.listen(port, () => {
  console.log(`Server listening on port ${port}`);
});

Let’s break this down:

• The Magician ‘require()’: We bring in the mighty Express.js library.
• The Application: ‘app’: We create an Express application.
• A Warm Welcome: ‘app.get(…)’: We make a route for the homepage (‘/’). When someone visits, it sends the text “Hello from Express!”.
• Ears Open: ‘app.listen()’: We tell our server to start listening on a port.

The Grand Reveal: Running Your Creation

• Save your index.js file.
• Command and Conquer: Open your terminal and run node index.js.
• Visit http://localhost:3000 in your web browser and witness your "Hello from Express!" greeting.

This is Just the Beginning

Think of this as baking your very first cookie. From here, you can:

• Craft more routes: Make different “pages” on your website.
• Upgrade with middleware: Add functions to handle logins, file uploads, and more.
• Beautiful templates: Plug in engines like EJS to make your pages dynamic.

Want to explore advanced topics like Node.js Worker Threads?

Threads in Node.js: Unlocking the Power of Parallel Processing

Express.js is a web application framework for Node.js. If Node.js is the engine of your web server, think of Express.js as a streamlined toolkit that helps you build things quickly and easily. It handles the complexities of routing (mapping URLs to actions), templating (creating dynamic HTML pages), and much more, giving you a solid foundation for your web applications.

Why Use Express.js?

1. Simplicity: Express offers a minimalist approach, giving you the freedom to structure your application the way you want.
2. Flexibility: It works seamlessly with many other Node.js modules available, letting you pick the tools that best suit your project.
3. Performance: Express.js is built on Node.js, giving you great performance and scalability for web apps.
4. Popularity: Huge community support means lots of tutorials, help, and resources to learn from.

Core Concepts

1. Routing: Express lets you define “routes” — these are patterns in URLs. For example
2. This means, that when someone visits your website’s root (‘/’), they’ll see the text “Hello from the home page!”.

app.get('/', (req, res) => {
    res.send('Hello from the home page!');
});

1. Middleware: Think of middleware as functions that modify incoming requests or outgoing responses. They’re like checkpoints along the route of your application. Common uses:

i). Logging requests

ii). Authentication (checking if a user is logged in)

iii). Parsing data from forms

1. Templating Engines: Express lets you plug in templating engines (like EJS, Pug, or Handlebars) These help you create dynamic HTML pages by filling in data on the fly.

const express = require('express');
const app = express();
const port = 3000;

// A route for the homepage
app.get('/', (req, res) => {
  res.send('Hello, Express!');
}); 

// Start listening for requests
app.listen(port, () => {
  console.log(`Example app listening at http://localhost:${port}`); 
});

Explanation

• We start by bringing in the ‘express’ module.
• The app object is our main Express application.
• We define a route for the homepage (‘/’). When someone visits this route, the function sends a text response.
• Finally, we start the server listening on port 3000.

Next Steps

This is just a taste of Express.js! To learn more, explore:

• Express.js Official Docs: The best source (https://expressjs.com/)
• Building Routes for Different Request Types (GET, POST, etc.): Shape how your application handles user interactions.
• Working with Templating Engines: Make your pages dynamic.
• Using Middleware for Common Tasks: Add functionality at different points.