Neko Master Logo
Neko Master

अपने नेटवर्क ट्रैफ़िक को स्पष्ट रूप से देखें।
रीयल-टाइम मॉनिटरिंग · ट्रैफ़िक ऑडिटिंग · मल्टी-गेटवे समर्थन

English | 中文

[!IMPORTANT] अस्वीकरण

यह प्रोजेक्ट स्थानीय गेटवे वातावरण के लिए एक ट्रैफ़िक विश्लेषण और विज़ुअलाइज़ेशन टूल है।

यह कोई नेटवर्क एक्सेस सेवा, प्रॉक्सी सब्सक्रिप्शन, या क्रॉस-नेटवर्क कनेक्टिविटी प्रदान नहीं करता है। सभी डेटा उपयोगकर्ता के अपने नेटवर्क वातावरण से एकत्र किया जाता है।

यह प्रोजेक्ट MIT लाइसेंस के अंतर्गत ओपन-सोर्स है। इस सॉफ़्टवेयर के उपयोग से होने वाले किसी भी परिणाम की ज़िम्मेदारी हम नहीं लेते हैं। कृपया लागू कानूनों और विनियमों का पालन करते हुए इसका उपयोग करें।

नाम के बारे में

Neko (ねこ) का जापानी में अर्थ बिल्ली है। उच्चारण /ˈneɪkoʊ/ (NEH-ko)।

एक बिल्ली की तरह, Neko Master नेटवर्क ट्रैफ़िक को शांत और सटीक रूप से देखता है। यह आधुनिक गेटवे वातावरण के लिए डिज़ाइन किया गया एक हल्का एनालिटिक्स डैशबोर्ड है।

✨ विशेषताएँ

🚀 त्वरित शुरुआत

विकल्प 1: Docker Compose (अनुशंसित)

रिपॉज़िटरी का अंतर्निहित docker-compose.yml डिफ़ॉल्ट रूप से 3000/3001/3002 मैप करता है। नीचे दिए गए परिदृश्य A/B सामान्य परिनियोजन के लिए न्यूनतम टेम्पलेट हैं।

परिदृश्य A: न्यूनतम परिनियोजन (केवल 3000 एक्सपोज़ करें)```yaml

services: neko-master: image: foru17/neko-master:latest container_name: neko-master restart: unless-stopped ports: - "3000:3000" # Web UI volumes: - ./data:/app/data # Local MMDB (optional, files should be downloaded into ./geoip) - ./geoip:/app/data/geoip:ro environment: - NODE_ENV=production - DB_PATH=/app/data/stats.db - COOKIE_SECRET=${COOKIE_SECRET}

> `.env` में अनुशंसित (`docker-compose.yml` के समान निर्देशिका में):
> `COOKIE_SECRET=<कम से कम 32-बाइट यादृच्छिक स्ट्रिंग>` (`openssl rand -hex 32` से जनरेट करें)

> यह मोड पूरी तरह से अपग्रेड-संगत है और बिना किसी अतिरिक्त कॉन्फ़िगरेशन के काम करता है।
> यदि WS रूटेड नहीं है, तो ऐप स्वचालित रूप से HTTP पोलिंग पर वापस आ जाता है।

#### परिदृश्य B: रीयल-टाइम WebSocket (रिवर्स प्रॉक्सी के साथ अनुशंसित)```yaml
services:
  neko-master:
    image: foru17/neko-master:latest
    container_name: neko-master
    restart: unless-stopped
    ports:
      - "3000:3000" # Web UI
      - "3002:3002" # WebSocket (for Nginx / Tunnel forwarding)
    volumes:
      - ./data:/app/data
      # Local MMDB (optional, files should be downloaded into ./geoip)
      - ./geoip:/app/data/geoip:ro
    environment:
      - NODE_ENV=production
      - DB_PATH=/app/data/stats.db
      - COOKIE_SECRET=${COOKIE_SECRET}

फिर चलाएँ:```bash docker compose up -d

शुरू करने के लिए <http://localhost:3000> खोलें।

यदि आप रिपॉज़िटरी की अंतर्निहित Compose फ़ाइल (डिफ़ॉल्ट `3000/3001/3002`) का उपयोग करते हैं, तो वही कमांड चलाएँ।

### विकल्प 2: Docker Run```bash
# Generate a fixed cookie secret first (for session persistence)
export COOKIE_SECRET="$(openssl rand -hex 32)"

उदाहरण

# Scan a single target
scanner scan --target example.com

# Scan multiple targets from a file
scanner scan --input targets.txt --output results.json

# Use a custom configuration file
scanner scan --config /path/to/config.yaml

# Run with verbose output
scanner scan --target example.com --verbose

कॉन्फ़िगरेशन

The scanner can be configured using a YAML configuration file:

# scanner configuration
server:
  url: "http://localhost:8080"
  timeout: 30

scan:
  threads: 10
  timeout: 60
  retries: 3

output:
  format: "json"
  directory: "./results"

API उपयोग

import requests

# Initialize the client
client = requests.Session()
client.headers.update({"Authorization": "Bearer YOUR_TOKEN"})

# Start a scan
response = client.post(
    "http://localhost:8080/api/v1/scan",
    json={"target": "example.com"}
)

# Get scan results
scan_id = response.json()["id"]
results = client.get(f"http://localhost:8080/api/v1/scan/{scan_id}")
print(results.json())

योगदान

We welcome contributions from the community. Please follow these steps:

Fork the repository
Create a feature branch (git checkout -b feature/amazing-feature)
Commit your changes (git commit -m 'Add amazing feature')
Push to the branch (git push origin feature/amazing-feature)
Open a Pull Request

Please make sure to update tests as appropriate.

लाइसेंस

This project is licensed under the MIT License - see the LICENSE file for details.

आभार

ProjectDiscovery - For their amazing tools
OWASP - For security guidelines
All contributors who have helped shape this project

संपर्क

Issues: GitHub Issues
Discussions: GitHub Discussions
Twitter: @example

नोट: This tool is intended for authorized security testing only. Always ensure you have permission before scanning any target.```bash

Minimal (only 3000)

docker run -d
--name neko-master
-p 3000:3000
-v $(pwd)/data:/app/data
-e COOKIE_SECRET="$COOKIE_SECRET"
--restart unless-stopped
foru17/neko-master:latest

Real-time WS (with reverse proxy)

docker run -d
--name neko-master
-p 3000:3000
-p 3002:3002
-v $(pwd)/data:/app/data
-e COOKIE_SECRET="$COOKIE_SECRET"
--restart unless-stopped
foru17/neko-master:latest

<http://localhost:3000> खोलकर शुरू करें।

> फ्रंटएंड डिफ़ॉल्ट रूप से same-origin `/api` का उपयोग करता है, इसलिए पोर्ट 3001 आमतौर पर बाहरी रूप से आवश्यक नहीं होता है।
> रीयल-टाइम WS के लिए, आपके रिवर्स प्रॉक्सी/टनल को पोर्ट `3002` तक पहुँचने में सक्षम होना चाहिए। यदि नहीं, तो ऐप ~5s HTTP पोलिंग पर वापस चला जाता है।

> `docker run` के लिए, बाहरी पोर्ट को सीधे `-p` मैपिंग का उपयोग करके बदलें।
> केवल तभी जब आप सीधे WS एक्सेस (कोई रिवर्स प्रॉक्सी नहीं) का उपयोग करते हैं और बाहरी WS पोर्ट `3002` नहीं है, तो `-e WS_EXTERNAL_PORT=<external-ws-port>` भी पास करें।
>
> लोकल MMDB लुकअप मोड (वैकल्पिक): `-v $(pwd)/geoip:/app/data/geoip:ro` माउंट करें,
> फिर `Settings -> Preferences -> IP Lookup Source` में स्रोत को Local पर स्विच करें।

### विकल्प 3: वन-क्लिक स्क्रिप्ट

स्वचालित रूप से पोर्ट विरोधों का पता लगाता है और सब कुछ कॉन्फ़िगर करता है:```bash
# Using curl
curl -fsSL https://raw.githubusercontent.com/foru17/neko-master/main/setup.sh | bash

# Or using wget
wget -qO- https://raw.githubusercontent.com/foru17/neko-master/main/setup.sh | bash

स्क्रिप्ट स्वचालित रूप से:

✅ docker-compose.yml डाउनलोड करेगी
✅ जाँच करेगी कि डिफ़ॉल्ट पोर्ट (3000/3001/3002) उपयोग में हैं या नहीं
✅ उपलब्ध वैकल्पिक पोर्ट सुझाएगी
✅ कॉन्फ़िगरेशन फ़ाइल बनाएगी और सेवा शुरू करेगी

विकल्प 4: स्रोत कोड```bash

1. Clone the repository

git clone https://github.com/foru17/neko-master.git cd neko-master

2. Install dependencies

pnpm install

3. Prepare collector env (source mode reads apps/collector/.env)

cp apps/collector/.env.example apps/collector/.env

4. Start development services

pnpm dev

<http://localhost:3000> खोलकर कॉन्फ़िगर करें।

> सोर्स मोड में: कलेक्टर डिफ़ॉल्ट रूप से `3001/3002` पर सुनता है, वेब डिफ़ॉल्ट रूप से `3000` पर सुनता है।
> यदि आपने `API_PORT` बदला है (3001 नहीं), तो तदनुसार `API_URL` सेट करें (उदाहरण के लिए `API_URL=http://localhost:4001`) ताकि वेब `/api` रीराइट सही API को लक्षित करे।
> `apps/collector/.env.local` का `apps/collector/.env` पर प्राथमिकता होती है।

## 🤖 एजेंट डिप्लॉयमेंट

एजेंट मोड का उपयोग तब करें जब आप एक केंद्रीकृत Neko Master सेवा और स्थानीय गेटवे डेटा एकत्र करने वाले कई रिमोट डिवाइस (OpenWrt, Linux, macOS) चाहते हैं। एजेंट गेटवे के पास चलता है, डेटा खींचता है, और पैनल को रिपोर्ट करता है — पैनल कभी भी सीधे गेटवे से कनेक्ट नहीं होता।

समर्थित गेटवे प्रकार: **Clash / Mihomo** (WebSocket रीयल-टाइम) और **Surge v5+** (HTTP पोलिंग)।

### त्वरित इंस्टॉल (UI-जनित कमांड)

1. डैशबोर्ड में, `Settings → Backends` पर जाएं, एक `Agent` बैकएंड जोड़ें, गेटवे प्रकार चुनें
2. **"View Agent Script"** पर क्लिक करें और एक-पंक्ति वाला इंस्टॉल कमांड कॉपी करें, फिर इसे लक्ष्य होस्ट पर चलाएं:```bash
# Clash / Mihomo gateway example
curl -fsSL https://raw.githubusercontent.com/foru17/neko-master/main/apps/agent/install.sh \
  | env NEKO_SERVER='http://your-panel:3000' \
        NEKO_BACKEND_ID='1' \
        NEKO_BACKEND_TOKEN='ag_xxx' \
        NEKO_GATEWAY_TYPE='clash' \
        NEKO_GATEWAY_URL='http://127.0.0.1:9090' \
        sh

# Surge gateway example
curl -fsSL https://raw.githubusercontent.com/foru17/neko-master/main/apps/agent/install.sh \
  | env NEKO_SERVER='http://your-panel:3000' \
        NEKO_BACKEND_ID='2' \
        NEKO_BACKEND_TOKEN='ag_yyy' \
        NEKO_GATEWAY_TYPE='surge' \
        NEKO_GATEWAY_URL='http://127.0.0.1:9091' \
        sh

इंस्टॉल के बाद, nekoagent के साथ इंस्टेंस प्रबंधित करें:```bash nekoagent list # list all instances nekoagent status # check running state nekoagent logs # tail live logs nekoagent restart # restart nekoagent upgrade # global upgrade (CLI + binary)

> स्क्रिप्ट पहले से मौजूद इंस्टॉलेशन को स्वतः पहचान लेती है — यदि `neko-agent` पहले से मौजूद है, तो यह बिना दोबारा डाउनलोड किए केवल नया इंस्टेंस जोड़ती है।
> एक ही होस्ट पर कई इंस्टेंस चल सकते हैं (अलग-अलग `NEKO_INSTANCE_NAME`), प्रत्येक अलग गेटवे की ओर इंगित करता है।

### Agent दस्तावेज़ीकरण

- [अवलोकन](https://github.com/foru17/neko-master/blob/main/docs/agent/overview.en.md): आर्किटेक्चर, Direct बनाम Agent तुलना, सुरक्षा मॉडल
- [क्विक स्टार्ट](https://github.com/foru17/neko-master/blob/main/docs/agent/quick-start.en.md): UI से चल रहे एजेंट तक एंड-टू-एंड सेटअप
- [इंस्टॉल गाइड](https://github.com/foru17/neko-master/blob/main/docs/agent/install.en.md): इंस्टॉल विधियाँ, systemd / launchd ऑटोस्टार्ट
- [कॉन्फ़िगरेशन](https://github.com/foru17/neko-master/blob/main/docs/agent/config.en.md): पूर्ण फ्लैग और env वेरिएबल संदर्भ
- [रिलीज़ फ़्लो](https://github.com/foru17/neko-master/blob/main/docs/agent/release.en.md): वर्ज़निंग और संगतता नीति
- [समस्या निवारण](https://github.com/foru17/neko-master/blob/main/docs/agent/troubleshooting.en.md): सामान्य त्रुटियाँ और समाधान

## 📖 पहला उपयोग

![पहला उपयोग](https://assets.kitploit.com/production/public/readmes/55481/574559c63ee5ba0aa6edfe15b7b451eeb203754122a3fa5c422f8342d2437879/55102606ffce9740febe5ee0afcdeb22ab67516f8219f7cf8dd6d0798ede4f45-display-v1.webp)

### Clash / Mihomo कनेक्ट करें

1. <http://localhost:3000> खोलें
2. पहली विज़िट पर **Gateway Configuration** डायलॉग दिखाई देगा
3. अपने नेटवर्क गेटवे (जैसे, OpenClash) का कनेक्शन विवरण भरें:
   - **Name**: कस्टम नाम (जैसे, "Home Gateway")
   - **Type**: `Clash / Mihomo` चुनें
   - **Host**: गेटवे बैकएंड पता (जैसे, `192.168.101.1`)
   - **Port**: गेटवे बैकएंड पोर्ट (जैसे, `9090`)
   - **Token**: यदि Secret कॉन्फ़िगर है तो भरें, अन्यथा खाली छोड़ें
4. सहेजने के लिए "Add Backend" पर क्लिक करें
5. सिस्टम स्वतः ट्रैफ़िक डेटा एकत्र और विश्लेषण करना शुरू कर देगा

> 💡 **गेटवे पता प्राप्त करें**: अपने गेटवे कंट्रोल पैनल (जैसे, OpenClash) पर जाएँ → "External Control" सक्षम करें → API पता कॉपी करें

### Surge कनेक्ट करें

![Surge HTTP API कॉन्फ़िगरेशन](https://assets.kitploit.com/production/public/readmes/55481/9cc7414a5acad5b6c3f5fadccd072b50f0b552b305ff5003024a3d1304bb9ec4/bae0f4f4debf30de5fdf5331b6befad02135ba827c5812c1e4fdf33614c3aede-display-v1.webp)

Neko Master पूर्ण रूल चेन विज़ुअलाइज़ेशन और ट्रैफ़िक विश्लेषण के लिए Surge गेटवे से कनेक्ट करने का समर्थन करता है।

#### 1. Surge HTTP API सक्षम करें

अपने Surge कॉन्फ़िगरेशन में HTTP रिमोट API सक्षम करें:```ini
[General]
http-api = 127.0.0.1:9091
http-api-tls = false
http-api-web-dashboard = true

Surge के ग्राफिकल इंटरफ़ेस के माध्यम से कॉन्फ़िगर करें:

HTTP Remote API: Settings → General → HTTP Remote API
Port: डिफ़ॉल्ट 9091
Authentication: बेहतर सुरक्षा के लिए पासवर्ड सेट करने की सलाह दी जाती है

2. Neko Master में Surge बैकएंड जोड़ें

Neko Master सेटिंग्स डायलॉग खोलें
"Add Backend" पर क्लिक करें
कनेक्शन जानकारी भरें:
- Name: कस्टम नाम (जैसे, "Surge Home")
- Type: Surge चुनें
- Host: वह IP पता जहाँ Surge चल रहा है (जैसे, 192.168.1.1 या 127.0.0.1)
- Port: HTTP API पोर्ट (डिफ़ॉल्ट 9091)
- Token: HTTP API पासवर्ड (यदि कॉन्फ़िगर किया गया हो)
कॉन्फ़िगरेशन सत्यापित करने के लिए "Test Connection" पर क्लिक करें
कॉन्फ़िगरेशन सहेजें

💡 नोट: Surge डेटा प्राप्त करने के लिए HTTP पोलिंग का उपयोग करता है (Clash के WebSocket रीयल-टाइम स्ट्रीम की तुलना में), जिसमें डेटा रीफ़्रेश विलंब लगभग 2 सेकंड होता है।

🔧 पोर्ट कॉन्फ्लिक्ट समाधान

यदि आपको "port already in use" त्रुटि दिखाई देती है, तो यहाँ समाधान दिए गए हैं:

समाधान 1: .env फ़ाइल का उपयोग करें

docker-compose.yml के समान निर्देशिका में एक .env फ़ाइल बनाएँ:```env WEB_EXTERNAL_PORT=8080 # Change Web UI port API_EXTERNAL_PORT=8081 # Change API port WS_EXTERNAL_PORT=8082 # Change WebSocket external port (only for direct access) COOKIE_SECRET=your-long-random-secret # Strongly recommended to keep fixed

फिर पुनः आरंभ करें:```bash
docker compose down
docker compose up -d

अब http://localhost:8080 पर पहुँचें

समाधान 2: सीधे docker-compose.yml को संशोधित करें```yaml

ports:

"8080:3000" # External 8080 → Internal 3000
"8082:3002" # External 8082 → Internal 3002 (for proxy/tunnel WS forwarding)

> नोट: यदि आप सीधे WS एक्सेस (कोई रिवर्स प्रॉक्सी नहीं) का उपयोग करते हैं और बाहरी WS पोर्ट `3002` नहीं है, तो `WS_EXTERNAL_PORT=<external-ws-port>` सेट करें।

### समाधान 3: वन-क्लिक स्क्रिप्ट का उपयोग करें```bash
curl -fsSL https://raw.githubusercontent.com/foru17/neko-master/main/setup.sh | bash

स्क्रिप्ट स्वचालित रूप से उपलब्ध पोर्ट का पता लगाएगी और सुझाव देगी।

🐳 Docker कॉन्फ़िगरेशन

पोर्ट

पर्यावरण चर (परिनियोजन)

उन्नत ट्यूनिंग चर (वैकल्पिक)

API / WS रिज़ॉल्यूशन प्राथमिकता

API क्लाइंट बेस: runtime-config.API_URL → NEXT_PUBLIC_API_URL → same-origin /api
/api सर्वर-साइड रीराइट लक्ष्य: API_URL (डिफ़ॉल्ट http://localhost:3001, Next.js रीराइट्स में लागू)
WS URL: runtime-config.WS_URL → NEXT_PUBLIC_WS_URL → स्वतः उम्मीदवार (जब runtime-config.WS_PORT सेट हो, तो सीधे पोर्ट को प्राथमिकता दी जाती है; अन्यथा /_cm_ws पहले आज़माया जाता है)
WS पोर्ट: runtime-config.WS_PORT (WS_EXTERNAL_PORT से) → NEXT_PUBLIC_WS_PORT → 3002

उत्पादन पर्यावरण बेसलाइन (अनुशंसित)```env

NODE_ENV=production DB_PATH=/app/data/stats.db COOKIE_SECRET=<at least 32-byte random string>

Optional: default to local MMDB lookup

GEOIP_LOOKUP_PROVIDER=local

Keep false in normal operation

FORCE_ACCESS_CONTROL_OFF=false

`COOKIE_SECRET` जनरेट करने के लिए `openssl rand -hex 32` का उपयोग करें।

अतिरिक्त सिफारिशें:

1. डेटा और सीक्रेट के नुकसान से बचने के लिए पर्सिस्टेंट स्टोरेज माउंट करें (उदाहरण के लिए `./data:/app/data`)।
2. यदि डायरेक्ट WS एक्सेस का उपयोग कर रहे हैं और एक्सटर्नल WS पोर्ट `3002` नहीं है, तो तदनुसार `WS_EXTERNAL_PORT` सेट करें।
3. यदि सोर्स डिप्लॉयमेंट में API पोर्ट/एड्रेस बदलता है, तो `API_URL` को भी अपडेट करें।
4. लोकल MMDB लुकअप के लिए, `./geoip:/app/data/geoip:ro` माउंट करें और `Settings -> Preferences -> IP Lookup Source` में सोर्स स्विच करें।
5. MMDB फ़ाइलें बड़ी होती हैं और इमेज में बंडल नहीं की जाती हैं। उन्हें डाउनलोड करें और निश्चित नामों के साथ `./geoip` में रखें:
   `GeoLite2-City.mmdb`, `GeoLite2-ASN.mmdb` (आवश्यक), और `GeoLite2-Country.mmdb` (वैकल्पिक)।
   अनुशंसित सोर्स: <https://github.com/P3TERX/GeoLite.mmdb>.

> उन्नत Agent विवरण (इंस्टॉल, कॉन्फ़िग, रिलीज़, संगतता) `docs/agent/*` के अंतर्गत बनाए रखे जाते हैं।

## 🗄️ ClickHouse (वैकल्पिक)

SQLite Neko Master का डिफ़ॉल्ट स्टोरेज इंजन है और अधिकांश उपयोगकर्ताओं के लिए अच्छी तरह काम करता है।
ClickHouse को सक्षम करने पर विचार करें यदि आपको आवश्यकता हो:

- बहुत बड़े डेटासेट (सैकड़ों हज़ारों डोमेन/IP एंट्रीज़)
- लंबी समय अवधि (≥ 7 दिन) पर तेज़ एग्रीगेशन क्वेरीज़
- ऐतिहासिक आँकड़ों को कॉन्फ़िगरेशन/मेटाडेटा स्टोरेज से अलग करना

> ClickHouse पूरी तरह से वैकल्पिक है। ClickHouse सक्षम हो या न हो, SQLite कॉन्फ़िगरेशन और मेटाडेटा स्टोर के रूप में बना रहता है।

### आर्किटेक्चर अवलोकन

जब ClickHouse सक्षम होता है, तो सिस्टम **ड्यूल-राइट मोड** में प्रवेश करता है:```
BatchBuffer.flush()
    │
    ├──→ SQLite (config / metadata, always written)
    └──→ ClickHouse (stats traffic data, dual-write)
           └── Buffer tables → SummingMergeTree async merge

Read source को STATS_QUERY_SOURCE द्वारा नियंत्रित किया जाता है (डिफ़ॉल्ट: sqlite)।

ClickHouse सक्षम करना (Docker)

चरण 1: ClickHouse कंटेनर प्रारंभ करें

रिपॉज़िटरी की अंतर्निहित docker-compose.yml में पहले से ही एक ClickHouse सेवा शामिल है, जिसे profiles: [clickhouse] द्वारा नियंत्रित किया जाता है ताकि यह डिफ़ॉल्ट रूप से प्रारंभ न हो। रिपॉज़िटरी रूट से, चलाएँ:```bash docker compose --profile clickhouse up -d

> ClickHouse डेटा `./data/clickhouse` में सहेजा जाता है, जो मुख्य ऐप डेटा निर्देशिका से अलग है।

यदि आप एक **कस्टम `docker-compose.yml`** का उपयोग करते हैं (जैसे ऊपर Scenario A/B), तो ClickHouse
सेवा ब्लॉक को मैन्युअल रूप से जोड़ें:```yaml
services:
  neko-master:
    # ... your existing config ...
    environment:
      # append to existing environment section:
      - CH_ENABLED=${CH_ENABLED:-0}
      - CH_HOST=${CH_HOST:-clickhouse}
      - CH_PORT=${CH_PORT:-8123}
      - CH_DATABASE=${CH_DATABASE:-neko_master}
      - CH_USER=${CH_USER:-neko}
      - CH_PASSWORD=${CH_PASSWORD:-neko_master}
      - CH_WRITE_ENABLED=${CH_WRITE_ENABLED:-0}
      - STATS_QUERY_SOURCE=${STATS_QUERY_SOURCE:-sqlite}
    networks:
      - neko-master-network

  clickhouse:
    image: clickhouse/clickhouse-server:24.8
    container_name: neko-master-clickhouse
    restart: unless-stopped
    profiles: ["clickhouse"]
    ports:
      - "${CH_EXTERNAL_HTTP_PORT:-8123}:8123"
      - "${CH_EXTERNAL_NATIVE_PORT:-9000}:9000"
    volumes:
      - ./data/clickhouse:/var/lib/clickhouse
    environment:
      - CLICKHOUSE_DB=${CH_DATABASE:-neko_master}
      - CLICKHOUSE_USER=${CH_USER:-neko}
      - CLICKHOUSE_PASSWORD=${CH_PASSWORD:-neko_master}
      - CLICKHOUSE_DEFAULT_ACCESS_MANAGEMENT=1
    networks:
      - neko-master-network
    healthcheck:
      test: ["CMD-SHELL", "wget -q --spider http://127.0.0.1:8123/ping || exit 1"]
      interval: 30s
      timeout: 10s
      retries: 3
      start_period: 40s

networks:
  neko-master-network:
    driver: bridge

चरण 2: पर्यावरण चर कॉन्फ़िगर करें

अपने .env में जोड़ें (docker-compose.yml के समान निर्देशिका में):```env

Enable ClickHouse connection

CH_ENABLED=1

Enable dual-write

CH_WRITE_ENABLED=1

Read source: sqlite (default) / auto (smart routing) / clickhouse (force)

STATS_QUERY_SOURCE=auto

ClickHouse connection (defaults match docker-compose.yml, no change needed)

CH_HOST=clickhouse CH_PORT=8123 CH_DATABASE=neko_master CH_USER=neko CH_PASSWORD=neko_master

पुनः आरंभ करें:```bash
docker compose --profile clickhouse up -d

ClickHouse पर्यावरण चर

स्वास्थ्य और फ़ॉलबैक: CH_UNHEALTHY_THRESHOLD लगातार राइट विफलताओं के बाद, सिस्टम स्वतः ClickHouse को अस्वस्थ चिह्नित करता है और SQLite राइट्स फिर से शुरू करता है—भले ही CH_ONLY_MODE=1 हो। ClickHouse के रिकवर होने पर, इसे फिर से स्वस्थ चिह्नित किया जाता है और लॉग किया जाता है।

मौजूदा उपयोगकर्ताओं के लिए माइग्रेशन गाइड

SQLite-only संस्करण से अपग्रेड कर रहे हैं? आपका डेटा सुरक्षित है। SQLite फ़ाइल (./data/stats.db) पूरी तरह से संरक्षित है। यहाँ अनुशंसित क्रमिक माइग्रेशन पथ है:

चरण 1: ड्यूअल-राइट (अवलोकन अवधि, अनुशंसित प्रारंभिक बिंदु)```env

CH_ENABLED=1 CH_WRITE_ENABLED=1 STATS_QUERY_SOURCE=sqlite # Keep reading from SQLite while CH accumulates data

`[ClickHouse Writer]` लॉग शुरू करें और देखें ताकि सफल लेखन की पुष्टि हो सके।

#### चरण 2: पढ़ने का स्रोत बदलें```env
STATS_QUERY_SOURCE=auto        # Smart routing: recent data from CH, historical from SQLite
# or
STATS_QUERY_SOURCE=clickhouse  # Force all reads to ClickHouse

चरण 3 (वैकल्पिक): ऐतिहासिक डेटा माइग्रेट करें

ऐतिहासिक SQLite आँकड़ों को ClickHouse में स्थानांतरित करने के लिए:```bash

Standard migration (truncate CH then re-import, with consistency check)

./scripts/ch-migrate-docker.sh

Append mode (keep existing CH data, incremental import)

./scripts/ch-migrate-docker.sh --append

Specific time window

./scripts/ch-migrate-docker.sh --from 2026-02-01T00:00:00Z --to 2026-02-20T00:00:00Z

#### चरण 4 (वैकल्पिक): केवल-CH मोड

एक बार ClickHouse स्थिर रूप से चलने लगे, तो SQLite स्टैट्स राइट्स बंद कर दें:```env
CH_ONLY_MODE=1

CH_ONLY_MODE=1 के साथ भी, यदि ClickHouse अस्वस्थ हो जाता है तो सिस्टम स्वचालित रूप से SQLite लेखन पर वापस आ जाता है—कोई डेटा हानि नहीं।

केवल SQLite पर वापस लौटना

आप हमेशा पूरी तरह से रोल बैक कर सकते हैं:```env CH_ENABLED=0 CH_WRITE_ENABLED=0 CH_ONLY_MODE=0 STATS_QUERY_SOURCE=sqlite

Restart करें और सब कुछ शुद्ध SQLite मोड में वापस आ जाता है। ऐतिहासिक डेटा बरकरार रहता है।

---

## 🌐 रिवर्स प्रॉक्सी और टनल

अनुशंसित दृष्टिकोण: Web और WS को एक ही डोमेन के अंतर्गत रखें, पथ रूटिंग के साथ:
`/` → `3000`, `/_cm_ws` → `3002`।

### Nginx मानक उदाहरण```nginx
server {
  listen 443 ssl http2;
  server_name neko.example.com;

  location / {
    proxy_pass http://<neko-master-host>:3000;
    proxy_http_version 1.1;
    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;
  }

  location ^~ /_cm_ws {
    proxy_pass http://<neko-master-host>:3002;
    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-Forwarded-For $proxy_add_x_forwarded_for;
    proxy_set_header X-Forwarded-Proto $scheme;
    proxy_read_timeout 86400;
    proxy_send_timeout 86400;
    proxy_buffering off;
  }
}

वैकल्पिक env ओवरराइड:```env

Not required by default (already /_cm_ws)

NEXT_PUBLIC_WS_URL=/custom_ws

### Cloudflare Tunnel मानक उदाहरण

`~/.cloudflared/config.yml`:```yaml
tunnel: <your-tunnel-name-or-id>
credentials-file: /path/to/<credentials>.json

ingress:
  - hostname: neko.example.com
    path: /_cm_ws*
    service: http://localhost:3002
  - hostname: neko.example.com
    path: /*
    service: http://localhost:3000
  - service: http_status:404

चलाएँ:```bash cloudflared tunnel --config ~/.cloudflared/config.yml run

Zero Trust डैशबोर्ड-प्रबंधित रूट्स (टोकन मोड) के लिए, वही दो रूट्स कॉन्फ़िगर करें और `/_cm_ws*` को `/*` के ऊपर रखें।

### मुख्य नोट्स

1. WS पाथ के रूप में `ws` (बिना लीडिंग स्लैश) का उपयोग न करें; यह ओवरमैच कर सकता है और `/_next/static/...` → `426 Upgrade Required` का कारण बन सकता है
2. WS रूट कैच-ऑल `/*` के ऊपर होना चाहिए
3. `NEXT_PUBLIC_WS_URL` डिफ़ॉल्ट रूप से वैकल्पिक है; यदि कस्टमाइज़ किया गया हो, तो बदलावों के बाद फ्रंटएंड/कंटेनर को रीस्टार्ट करें
4. केवल `3000` को मैप करना अभी भी काम करता है, लेकिन HTTP पोलिंग (~5s) पर फ़ॉलबैक करता है, जिसमें रीयल-टाइम रिस्पॉन्सिवनेस कम होती है
5. `beacon.min.js` विफलताएँ (Cloudflare एनालिटिक्स स्क्रिप्ट) आमतौर पर ऐप API/WS डेटा फ़्लो से असंबंधित होती हैं
6. अधिकांश सेटअप्स में अतिरिक्त `/api` रिवर्स-प्रॉक्सी नियम की आवश्यकता नहीं होती; फ्रंटएंड समान-ओरिजिन `/api` का उपयोग करता है और ऐप `3001` पर आंतरिक फ़ॉरवर्डिंग संभालता है

> नोट: `/_next/static/... 426 Upgrade Required` **गलत कॉन्फ़िगर किए गए रिवर्स प्रॉक्सी / टनल** सेटअप्स में आम है; यह बिना प्रॉक्सी के सीधे लोकल एक्सेस में असामान्य है।

### मल्टी-आर्किटेक्चर समर्थन

Docker इमेजेज़ `linux/amd64` और `linux/arm64` दोनों का समर्थन करती हैं।

### डेटा पर्सिस्टेंस

डेटा कंटेनर के अंदर `/app/data` में संग्रहीत होता है। डेटा हानि रोकने के लिए इसे होस्ट पर माउंट करें:```yaml
volumes:
  - ./data:/app/data

नवीनतम में अद्यतन करें```bash

Pull the latest image and restart

docker compose pull docker compose up -d

## 🔐 प्रमाणीकरण और सुरक्षा

Neko Master डैशबोर्ड डेटा की सुरक्षा के लिए एक्सेस प्रमाणीकरण का समर्थन करता है।

### उत्पादन सुरक्षा आधारभूत

1. एक निश्चित `COOKIE_SECRET` सेट करें (अन्यथा पुनः आरंभ के बाद सत्र अमान्य हो सकते हैं)।
2. सामान्य संचालन में `FORCE_ACCESS_CONTROL_OFF=true` सक्षम न रखें।
3. `SHOWCASE_SITE_MODE=true` का उपयोग केवल सार्वजनिक डेमो वातावरण के लिए करें (राइट ऑपरेशन प्रतिबंधित हैं)।

उदाहरण:```env
COOKIE_SECRET=<at least 32-byte random string>
# FORCE_ACCESS_CONTROL_OFF=false
# SHOWCASE_SITE_MODE=false

प्रमाणीकरण सक्षम / अक्षम करें

डैशबोर्ड खोलें और निचले-बाएँ साइडबार में "Settings" पर क्लिक करें।
"Security" टैब पर जाएँ।
एक्सेस नियंत्रण सक्षम/अक्षम करें और अपना टोकन सेट करें।

टोकन भूल गए (आपातकालीन रीसेट)

यदि आप टोकन भूल गए हैं, तो आपातकालीन मोड में प्रवेश करने के लिए अस्थायी रूप से FORCE_ACCESS_CONTROL_OFF=true सेट करें।

Docker Compose

docker-compose.yml में जोड़ें: ```yaml environment:
- FORCE_ACCESS_CONTROL_OFF=true
पुनः आरंभ करें: ```bash docker compose up -d
डैशबोर्ड खोलें और "Settings -> Security" में टोकन रीसेट करें।
रीसेट के तुरंत बाद इस env var को हटा दें, फिर दोबारा रीस्टार्ट करें।

Docker CLI

कंटेनर को रोकें और हटाएँ: ```bash docker stop neko-master docker rm neko-master
आपातकालीन फ़्लैग के साथ पुनः चलाएँ: ```bash docker run -d
--name neko-master
-p 3000:3000
-v $(pwd)/data:/app/data
-e FORCE_ACCESS_CONTROL_OFF=true
foru17/neko-master:latest
टोकन रीसेट करें, फिर इस फ़्लैग को हटाएँ और सामान्य रूप से पुनः आरंभ करें।

❓ सामान्य प्रश्न

प्रश्न: क्या मैं केवल `3000:3000` एक्सपोज़ करके सामान्य रूप से चला सकता हूँ?

उत्तर: हाँ। मुख्य सुविधाएँ अभी भी काम करती हैं। यदि WS रूटेड नहीं है, तो ऐप स्वचालित रूप से HTTP पोलिंग पर वापस चला जाता है। पूर्ण रीयलटाइम अनुभव के लिए, /_cm_ws को 3002 पर रूट करें।

प्रश्न: पोर्ट परिवर्तन के बाद पोर्ट संघर्ष या पहुँच से बाहर?

उत्तर: .env बनाएँ/अपडेट करें (docker-compose.yml के समान निर्देशिका में):```env WEB_EXTERNAL_PORT=8080 API_EXTERNAL_PORT=8081 WS_EXTERNAL_PORT=8082

फिर पुनः आरंभ करें:```bash
docker compose down
docker compose up -d

प्रश्न: पुनः आरंभ के बाद लॉगिन/सत्र क्यों गायब हो जाता है?

उत्तर: आमतौर पर इसलिए क्योंकि COOKIE_SECRET निश्चित नहीं है या डेटा निर्देशिका स्थायी नहीं की गई है।

एक निश्चित COOKIE_SECRET सेट करें
./data:/app/data माउंट करें

प्रश्न: स्थानीय MMDB लुकअप के लिए कौन सी फ़ाइलें आवश्यक हैं?

उत्तर: अपनी प्रोजेक्ट निर्देशिका में ./geoip बनाएं (docker-compose.yml के समान स्तर पर अनुशंसित), फिर रखें:

GeoLite2-City.mmdb (आवश्यक)
GeoLite2-ASN.mmdb (आवश्यक)
GeoLite2-Country.mmdb (वैकल्पिक)

अनुशंसित स्रोत: https://github.com/P3TERX/GeoLite.mmdb। कंटेनर के अंदर, निश्चित लुकअप पथ /app/data/geoip है, इसलिए रखें: ./geoip:/app/data/geoip:ro। बाद में अपडेट करने के लिए, बस होस्ट ./geoip में फ़ाइलें बदलें।

प्रश्न: OpenClash / गेटवे से कनेक्ट करने में विफल?

उत्तर: जांचें:

गेटवे की ओर से बाहरी नियंत्रण सक्षम है
होस्ट/पोर्ट सही है
टोकन/सीक्रेट सही है (यदि कॉन्फ़िगर किया गया हो)
कंटेनर नेटवर्क गेटवे तक पहुंच सकता है

प्रश्न: डेटा का बैकअप और पुनर्स्थापना कैसे करें?

उत्तर: पहले बैकअप लें:```bash cp -r ./data ./data-backup-$(date +%Y%m%d)

पुनर्स्थापित करें:```bash
docker compose down
cp -r ./data-backup-YYYYMMDD/. ./data/
docker compose up -d

🏗️ आर्किटेक्चर गाइड

यदि आप सिस्टम डिज़ाइन की गहराई को जल्दी से समझना चाहते हैं, तो इस क्रम में पढ़ें:

सिस्टम आर्किटेक्चर डायग्राम: एंड-टू-एंड लेयरिंग और मॉड्यूल जिम्मेदारियाँ → docs/architecture.en.md
डेटा फ़्लो: Clash / Surge कलेक्शन पाइपलाइन और एग्रीगेशन
डेटा मॉडल और स्टोरेज: SQLite स्कीमा, ClickHouse Buffer टेबल्स, रिटेंशन पॉलिसी
रीयलटाइम चैनल डिज़ाइन: RealtimeStore मर्ज रणनीति और WS पुश
ClickHouse मॉड्यूल: ड्यूअल-राइट आर्किटेक्चर, हेल्थ फ़ॉलबैक, रीड रूटिंग

पूर्ण डॉक्यूमेंटेशन इंडेक्स: docs/README.md

यह डॉक्यूमेंटेशन कलेक्शन, एग्रीगेशन, कैशिंग, रीयलटाइम पुश, और मल्टी-बैकएंड प्रबंधन के मुख्य डिज़ाइन को कवर करता है।

🤝 फ़ीडबैक और समस्याएँ

यह प्रोजेक्ट GitHub Issue Templates (Bug / Feature / Support) का उपयोग करता है।

कृपया कम से कम निम्नलिखित शामिल करें:

डिप्लॉयमेंट विधि (Compose / Docker Run / Source)
वर्शन जानकारी (image tag या commit)
मुख्य env vars (मास्क किए गए, जैसे COOKIE_SECRET=***)
पुनरुत्पादन चरण और अपेक्षित बनाम वास्तविक व्यवहार
मुख्य लॉग (docker logs, ब्राउज़र कंसोल, नेटवर्क त्रुटियाँ)

📁 प्रोजेक्ट संरचना```

neko-master/ ├── docker-compose.yml # Docker Compose config ├── Dockerfile # Docker image build ├── setup.sh # One-click setup script ├── docker-start.sh # Docker container startup script ├── start.sh # Source code dev startup script ├── docs/ # Documentation (see docs/README.md) │ ├── README.md # Documentation index (English default) │ ├── README.zh.md # Documentation index (Chinese) │ ├── README.en.md # Documentation index (English mirror) │ ├── architecture.md # System architecture (Chinese) │ ├── architecture.en.md # System architecture (English) │ ├── release-checklist.md │ ├── agent/ # Agent docs (bilingual) │ │ ├── overview.md / overview.en.md │ │ ├── quick-start.md / quick-start.en.md │ │ ├── install.md / install.en.md │ │ ├── config.md / config.en.md │ │ ├── release.md / release.en.md │ │ └── troubleshooting.md / troubleshooting.en.md │ ├── research/ # Research reports │ └── dev/ # Internal development docs ├── assets/ # Screenshots and icons ├── apps/ │ ├── collector/ # Data collection service (Node.js + WebSocket) │ ├── agent/ # Agent daemon (Go) │ └── web/ # Next.js frontend app └── packages/ └── shared/ # Shared types and utilities

## 🛠️ टेक स्टैक

- **फ्रंटएंड**: [Next.js 16](https://nextjs.org/) + [React 19](https://react.dev/) + [TypeScript](https://www.typescriptlang.org/)
- **स्टाइलिंग**: [Tailwind CSS](https://tailwindcss.com/) + [shadcn/ui](https://ui.shadcn.com/)
- **चार्ट्स**: [Recharts](https://recharts.org/)
- **i18n**: [next-intl](https://next-intl-docs.vercel.app/)
- **बैकएंड**: [Node.js](https://nodejs.org/) + [Fastify](https://www.fastify.io/) + WebSocket
- **डेटाबेस**: [SQLite](https://www.sqlite.org/) ([better-sqlite3](https://github.com/WiseLibs/better-sqlite3)) + [ClickHouse](https://clickhouse.com/) (वैकल्पिक)
- **बिल्ड**: [pnpm](https://pnpm.io/) + [Turborepo](https://turbo.build/)

## 🤝 योगदान

योगदान का स्वागत है!

- 🐛 [बग सबमिट करें](https://github.com/foru17/neko-master/issues/new)
- 💡 [फीचर का अनुरोध करें](https://github.com/foru17/neko-master/issues/new)
- 🔧 [कोड योगदान करें](https://github.com/foru17/neko-master/pulls)

PR खोलने से पहले, [CONTRIBUTING.md](https://github.com/foru17/neko-master/blob/main/CONTRIBUTING.md) पढ़ें (वर्कफ़्लो, चेक, i18n/डार्क-मोड आवश्यकताएँ)।

**AI कोडिंग टूल के साथ डेवलप कर रहे हैं?** (Claude Code, Copilot, Cursor, Codex, ...) इसे [AGENTS.md](https://github.com/foru17/neko-master/blob/main/AGENTS.md) पर इंगित करें — कन्वेंशन, मुख्य कॉन्ट्रैक्ट्स, और प्रोजेक्ट मैप — साथ ही [`.claude/skills/`](https://github.com/foru17/neko-master/blob/main/.claude/skills) में टास्क-विशिष्ट वर्कफ़्लो गाइड्स। Claude Code दोनों को स्वचालित रूप से उठा लेता है।

## 📄 लाइसेंस

[MIT](https://github.com/foru17/neko-master/blob/main/LICENSE) © [foru17](https://github.com/foru17)

---

## ⭐ स्टार हिस्ट्री

[![Star History Chart](https://api.star-history.com/svg?repos=foru17/neko-master&type=date&legend=top-left)](https://www.star-history.com/#foru17/neko-master&type=date&legend=top-left)

---

<p align="center">
  <sub>Made with ❤️ by <a href="https://github.com/foru17">@foru17</a></sub><br>
  <sub>If this project helps you, please consider giving it a ⭐</sub>
</p>

📊 रीयल-टाइम मॉनिटरिंग	मिलीसेकंड लेटेंसी के साथ WebSocket रीयल-टाइम संग्रह
📈 ट्रेंड विश्लेषण	बहु-आयामी ट्रैफ़िक ट्रेंड: 30min / 1h / 24h
🌐 डोमेन विश्लेषण	प्रति डोमेन ट्रैफ़िक, संबंधित IP, और कनेक्शन संख्या देखें
🗺️ IP विश्लेषण	ASN, भू-स्थान, और संबंधित डोमेन प्रदर्शन
🚀 प्रॉक्सी आँकड़े	प्रति प्रॉक्सी नोड ट्रैफ़िक वितरण और कनेक्शन संख्या
📱 PWA समर्थन	नेटिव अनुभव के लिए डेस्कटॉप ऐप के रूप में इंस्टॉल करें
🌙 डार्क मोड	लाइट / डार्क / सिस्टम थीम समर्थन
🌍 i18n समर्थन	अंग्रेज़ी / चीनी निर्बाध स्विचिंग
🔄 मल्टी-बैकएंड	एक साथ कई OpenClash बैकएंड इंस्टेंस की निगरानी करें

`WEB_PORT`	`3000`	Web लिसन पोर्ट (कंटेनर के अंदर)	आमतौर पर अपरिवर्तित
`API_PORT`	`3001`	API लिसन पोर्ट (कंटेनर के अंदर)	आमतौर पर अपरिवर्तित
`COLLECTOR_WS_PORT`	`3002`	WS लिसन पोर्ट (कंटेनर के अंदर)	आमतौर पर अपरिवर्तित
`DB_PATH`	`/app/data/stats.db`	SQLite डेटा पथ	कस्टम डेटा पथ
`WEB_EXTERNAL_PORT`	`3000`	`docker-compose.yml` में बाहरी web पोर्ट मैपिंग	बाहरी web पोर्ट बदला गया
`API_EXTERNAL_PORT`	`3001`	`docker-compose.yml` में बाहरी API पोर्ट मैपिंग	सीधे बाहरी API एक्सेस की आवश्यकता
`WS_EXTERNAL_PORT`	`3002`	`docker-compose.yml` में बाहरी WS पोर्ट मैपिंग; सीधे WS पोर्ट अनुमान के लिए भी उपयोग किया जाता है	प्रॉक्सी के बिना सीधे WS एक्सेस और बाहरी WS पोर्ट बदला गया
`NEXT_PUBLIC_API_URL`	खाली	फ्रंटएंड API बेस URL को ओवरराइड करें (जैसे `https://api.example.com`)	API same-origin `/api` नहीं है
`NEXT_PUBLIC_WS_URL`	खाली	फ्रंटएंड WS URL को ओवरराइड करें (पूर्ण URL या `/custom_ws`)	कस्टम WS पथ/डोमेन
`NEXT_PUBLIC_WS_PORT`	`3002`	WS सीधे-कनेक्शन फ़ॉलबैक पोर्ट (केवल बिल्ड-टाइम — Docker रनटाइम पर इसे सेट करने का कोई प्रभाव नहीं पड़ता; इसके बजाय `WS_EXTERNAL_PORT` का उपयोग करें)	केवल कस्टम सोर्स बिल्ड के लिए
`API_URL`	`http://localhost:3001`	Next.js `/api` रीराइट लक्ष्य (मुख्यतः सोर्स/कस्टम बिल्ड)	API लिसन पता बदला गया
`COOKIE_SECRET`	स्वतः-जनित	कुकी साइनिंग सीक्रेट; यदि इसे निश्चित नहीं किया गया, तो डेटा डिर निरंतर न रहने पर पुनःआरंभ के बाद सत्र अमान्य हो सकते हैं	उत्पादन में दृढ़ता से अनुशंसित
`GEOIP_LOOKUP_PROVIDER`	`online`	IP भू-स्थान स्रोत (`online` / `local`)	डिफ़ॉल्ट रूप से स्थानीय MMDB लुकअप
`GEOIP_ONLINE_API_URL`	`https://api.ipinfo.es/ipinfo`	ऑनलाइन IP भू-स्थान API एंडपॉइंट (`ipinfo.my` प्रतिक्रिया स्कीमा के साथ संगत होना चाहिए)	केवल तब सेट करें जब आप एक संगत एंडपॉइंट परिनियोजित करते हैं
`FORCE_ACCESS_CONTROL_OFF`	`false`	एक्सेस नियंत्रण को बाध्यकारी रूप से अक्षम करें (आपातकालीन रिकवरी)	केवल तब अस्थायी उपयोग जब टोकन खो गया हो
`SHOWCASE_SITE_MODE`	`false`	रीड-ओनली शोकेस मोड (संवेदनशील लेखन संचालन को अवरुद्ध करता है)	केवल सार्वजनिक डेमो साइटों के लिए

`FLUSH_INTERVAL_MS`	`30000`	कलेक्टर लेखन के लिए बफ़र फ्लश अंतराल
`FLUSH_MAX_BUFFER_SIZE`	`5000`	जल्दी फ्लश से पहले अधिकतम बफ़र प्रविष्टियाँ
`REALTIME_MAX_MINUTES`	`180`	रीयलटाइम इन-मेमोरी विंडो आकार (मिनट)
`REALTIME_RANGE_END_TOLERANCE_MS`	`120000`	रेंज क्वेरी के लिए अंत-समय सहनशीलता
`SURGE_POLICY_SYNC_INTERVAL_MS`	`600000`	सर्ज नीति सिंक अंतराल
`DB_RANGE_QUERY_CACHE_TTL_MS`	`8000`	रेंज-क्वेरी कैश TTL
`DB_HISTORICAL_QUERY_CACHE_TTL_MS`	`300000`	ऐतिहासिक-क्वेरी कैश TTL
`DB_RANGE_QUERY_CACHE_MAX_ENTRIES`	`1024`	अधिकतम रेंज-क्वेरी कैश प्रविष्टियाँ
`DB_RANGE_QUERY_CACHE_DISABLED`	खाली	रेंज-क्वेरी कैश अक्षम करने के लिए `1` सेट करें
`DEBUG_SURGE`	`false`	सर्ज कलेक्टर डीबग लॉग सक्षम करें (`true`)

`CH_ENABLED`	`0`	ClickHouse कनेक्शन सक्षम करें (`1` सक्षम करने के लिए)
`CH_WRITE_ENABLED`	`0`	ड्यूअल-राइट सक्षम करें (`CH_ENABLED=1` आवश्यक)
`CH_ONLY_MODE`	`0`	जब CH स्वस्थ हो, तो SQLite स्टैट्स राइट्स छोड़ें (CH-only मोड)
`CH_HOST`	`clickhouse`	ClickHouse होस्ट पता
`CH_PORT`	`8123`	ClickHouse HTTP पोर्ट
`CH_DATABASE`	`neko_master`	डेटाबेस नाम
`CH_USER`	`neko`	उपयोगकर्ता नाम
`CH_PASSWORD`	`neko_master`	पासवर्ड
`CH_SECURE`	`0`	HTTPS कनेक्शन का उपयोग करें
`CH_REQUIRED`	`0`	यदि CH उपलब्ध न हो तो शुरू करने से इंकार करें
`CH_AUTO_CREATE_TABLES`	`1`	पहली बार शुरू करने पर टेबल्स स्वतः बनाएं
`CH_WRITE_MAX_PENDING_BATCHES`	`200`	अधिकतम लंबित राइट बैच
`CH_UNHEALTHY_THRESHOLD`	`5`	अस्वस्थ चिह्नित करने से पहले लगातार विफलताएं (स्वतः-फ़ॉलबैक से SQLite)
`STATS_QUERY_SOURCE`	`sqlite`	स्रोत पढ़ें: `sqlite` / `auto` / `clickhouse`
`CH_COMPARE_ENABLED`	`0`	SQLite ↔ ClickHouse संगतता जांच सक्षम करें
`CH_EXTERNAL_HTTP_PORT`	`8123`	ClickHouse HTTP बाहरी पोर्ट (Compose मैपिंग)
`CH_EXTERNAL_NATIVE_PORT`	`9000`	ClickHouse Native बाहरी पोर्ट (Compose मैपिंग)

3000	Web UI	✅	फ्रंटएंड प्रवेश बिंदु
3001	API	वैकल्पिक	फ्रंटएंड डिफ़ॉल्ट रूप से same-origin `/api` का उपयोग करता है; आमतौर पर सार्वजनिक एक्सपोज़र की आवश्यकता नहीं होती (डिफ़ॉल्ट Compose इसे मैप करता है)
3002	WebSocket	वैकल्पिक	रीयल-टाइम पुश एंडपॉइंट; केवल रिवर्स प्रॉक्सी/टनल फ़ॉरवर्डिंग के लिए अनुशंसित (डिफ़ॉल्ट Compose इसे मैप करता है)

neko-master

सबसे लोकप्रिय