बॉट के लिए सर्वर API

पैनल जो कुछ भी करता है, वह सब आप अपने कोड से कर सकते हैं: तय समय पर सर्वर शुरू करें, Discord में स्टेटस दिखाएँ, बॉट से कमांड भेजें।

की

API किसी भी पेड प्लान पर उपलब्ध है — उसी जगह जहाँ फ़ाइलें, SFTP और टीम एक्सेस हैं। फ़्री प्लान पर की जारी नहीं होती: की वही शेयर्ड एक्सेस है, बस बॉट के लिए।

सेक्शन “Players and access” → “API keys” → “Issue”। देखें कि की को क्या करने की अनुमति है — अनुमतियाँ शेयर्ड एक्सेस जैसी ही होती हैं।

की एक बार दिखाई जाती है: हम सिर्फ़ उसका फ़िंगरप्रिंट रखते हैं। अगर वह खो जाए, तो नई जारी करें और पुरानी रद्द करें।

की Authorization: Bearer mhk_live_... हेडर में भेजी जाती है।

मेथड्स

बेस URL — https://millida.net/v2/hosting/api.

उदाहरण: सर्वर शुरू करें और उसके ऑनलाइन होने का इंतज़ार करें

KEY="mhk_live_xxx"
API="https://millida.net/v2/hosting/api"

curl -sX POST "$API/start" -H "Authorization: Bearer $KEY"

until curl -s "$API/status" -H "Authorization: Bearer $KEY" | grep -q RUNNING; do
  sleep 5
done
echo "server online"

बैकअप बैकग्राउंड में बनते हैं

POST /backups तुरंत {"id":"..."} लौटाता है, जबकि आर्काइव खुद नोड पर बनता है: कई गीगाबाइट की वर्ल्ड में कई मिनट लगते हैं। GET /backups में status फ़ील्ड से तैयारी जाँचें: pending — अभी बन रहा है, ready — स्टोरेज में सेव है (तभी असली sizeMb दिखता है), failed — बन नहीं पाया।

ID=$(curl -sX POST "$API/backups" -H "Authorization: Bearer $KEY" | jq -r .id)

until curl -s "$API/backups" -H "Authorization: Bearer $KEY" \
  | jq -e --arg id "$ID" '.[] | select(.id==$id) | select(.status=="ready")' >/dev/null; do
  sleep 15
done
echo "backup ready"

जब तक एक बैकअप चल रहा हो, उसी सर्वर पर दूसरा नहीं बना सकते — नोड एक बार में एक ही बनाता है।

लाइव कंसोल

GET /console Server-Sent Events स्ट्रीम लौटाता है: हर लाइन data: प्रीफ़िक्स के साथ आती है। WebSocket की ज़रूरत नहीं — SSE किसी भी प्रॉक्सी से निकल जाता है।

जो आपको पता होना चाहिए

• की की हर कार्रवाई लॉग होती है सर्वर लॉग में “API key N” लेखक के साथ। जब सर्वर इंसान और बॉट दोनों चला रहे हों, तब यही काम आता है।
• रेट लिमिट हर की पर गिनी जाती है, एड्रेस पर नहीं: IP बदलने से लिमिट बायपास नहीं होती, और ऑफ़िस नेटवर्क पर मौजूद पड़ोसी उसे खर्च नहीं करता। सामान्य ऑटोमेशन के लिए यह काफ़ी उदार है, लेकिन हर सेकंड स्टेटस पोल करने पर लिमिट लग जाएगी — हर 10–15 सेकंड में एक बार काफ़ी है। कंसोल स्ट्रीम मिनट में दस बार तक खोली जा सकती है: हर मैसेज के लिए नई कनेक्शन खोलने के बजाय एक ही रखें।
• की तुरंत काम करना बंद कर देती है अगर सर्वर सस्पेंड हो जाए या प्लान पेड न रहे। इसके लिए उसे मैन्युअली रद्द करने की ज़रूरत नहीं।
• हर सर्वर पर पाँच तक की। जो न चाहिए उन्हें रद्द करें।

एंटी-बॉट प्रोटेक्शन

GET /antibot सेटिंग्स दो फ़ील्ड में लौटाता है। config — सर्वर की अपनी सेटिंग्स; जब तक वे न हों, यह null रहता है और सर्वर डिफ़ॉल्ट से प्रोटेक्टेड रहता है (default फ़ील्ड)। effective हमेशा मौजूद रहता है: ये वे सेटिंग्स हैं जो अभी लागू हैं या पहली एडिट के बाद सर्वर के साथ लागू होंगी — वैल्यू इन्हीं से पढ़ें।

PUT /antibot सिर्फ़ वे फ़ील्ड लेता है जिन्हें आप बदलना चाहते हैं:

curl -sX PUT "$API/antibot" -H "Authorization: Bearer $KEY"   -H 'Content-Type: application/json'   -d '{"preset":"balanced"}'

लेवल (preset): off, under_attack, balanced, aggressive, custom। लेवल खुद चेक वैल्यू में बदल जाता है, इसलिए मैन्युअल कॉन्फ़िगरेशन के लिए custom चुनें और चेक भेजें: checkCaptcha, checkPhysics, checkKeepAlive, checkTeleport, checkBrand, checkPing, checkTransfer, checkClientSettings — हर एक off, under_attack या always। एड्रेस लिस्ट (vpnMode, datacenterMode, torMode) — off, log या block। जियो फ़िल्टर — geoMode (off, allow, deny) और geoCountries (देश कोड, जैसे ["RU","BY"])।

फ़ॉरवर्डिंग सीक्रेट API से जारी या बदला नहीं जाता: यह सिर्फ़ ओनर को पैनल में दिखता है।

कॉन्फ़िग सेटिंग्स

GET /files/config?path=server.properties पार्स की गई फ़ाइल लौटाता है — हर एंट्री के साथ उसका टाइप, मौजूदा वैल्यू और “रीस्टार्ट ज़रूरी” फ़्लैग:

{
  "path": "server.properties",
  "format": "properties",
  "options": [
    { "key": "pvp", "type": "boolean", "value": "true", "owner": "sync", "requiresRestart": false },
    { "key": "difficulty", "type": "select", "value": "normal", "values": ["peaceful", "easy", "normal", "hard"], "owner": "sync", "requiresRestart": false },
    { "key": "server-port", "type": "integer", "value": "25565", "owner": "platform", "requiresRestart": true }
  ]
}

owner बताता है कि एंट्री के साथ क्या किया जा सकता है: platform — वैल्यू होस्टिंग सेट करती है, एडिट रिजेक्ट होते हैं; sync — एंट्री पैनल और फ़ाइल दोनों में है; file — इसके बारे में सिर्फ़ फ़ाइल को पता है।

लिखने पर सिर्फ़ वही की बदलती हैं जो आप भेजते हैं; फ़ाइल में बाकी सब वैसा ही रहता है:

curl -sX POST "$API/files/config" -H "Authorization: Bearer $KEY"   -H 'Content-Type: application/json'   -d '{"path":"server.properties","values":{"pvp":"false","difficulty":"hard"}}'

फ़ॉर्म .properties, .yml/.yaml और .toml पढ़ता है — उन प्लगिन कॉन्फ़िग सहित जिनके बारे में पैनल को कुछ पता नहीं: फ़ील्ड का टाइप वैल्यू से तय होता है। नेस्टेड की डॉट से लिखी जाती हैं: settings.bungeecord, advanced.compression-threshold.

पूरी फ़ाइल अब भी GET/PUT /files/content?path= से उपलब्ध है — दोनों रास्ते एक ही जगह लिखते हैं।

Node.js और Python में तैयार क्लाइंट

नीचे एक मिनिमल क्लाइंट दिया गया है: यह स्टेटस चेक करता है, सर्वर शुरू करता है और चैट में लिखता है। की MILLIDA_KEY एनवायरनमेंट वेरिएबल से आती है — इसे ऐसे कोड में न डालें जो git में चला जाए। एरर रिस्पॉन्स एक JSON होता है जिसमें message फ़ील्ड होती है; आपके बॉट को यही लॉग करना चाहिए।

Node.js 18+ (बिल्ट-इन fetch):

const API = 'https://millida.net/v2/hosting/api';
const KEY = process.env.MILLIDA_KEY;

async function call(method, path, body) {
  const res = await fetch(`${API}${path}`, {
    method,
    headers: { Authorization: `Bearer ${KEY}`, 'Content-Type': 'application/json' },
    body: body ? JSON.stringify(body) : undefined,
  });
  if (!res.ok) throw new Error(`${method} ${path}: ${res.status} ${await res.text()}`);
  return res.status === 204 ? null : res.json();
}

const status = await call('GET', '/status');
if (status.status !== 'RUNNING') await call('POST', '/start');
await call('POST', '/command', { command: 'say Hello from the bot' });

Python 3, requests लाइब्रेरी के साथ, और लाइव कंसोल पढ़ने के लिए:

import os
import requests

API = "https://millida.net/v2/hosting/api"
session = requests.Session()
session.headers["Authorization"] = f"Bearer {os.environ['MILLIDA_KEY']}"

def call(method, path, body=None):
    res = session.request(method, API + path, json=body, timeout=15)
    res.raise_for_status()
    return res.json() if res.content else None

status = call("GET", "/status")
if status["status"] != "RUNNING":
    call("POST", "/start")
call("POST", "/command", {"command": "say Hello from the bot"})

with session.get(API + "/console", stream=True, timeout=None) as stream:
    for line in stream.iter_lines(decode_unicode=True):
        if line and line.startswith("data:"):
            print(line[5:].strip())