బాట్‌ల కోసం సర్వర్ 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 లోకి వెళ్లే కోడ్‌లో దాన్ని పేస్ట్ చేయవద్దు. ఎర్రర్ రెస్పాన్స్ అనేది message ఫీల్డ్ ఉన్న JSON; మీ బాట్ లాగ్ చేయాల్సింది అదే.

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())