Superserve Sandbox MCP

आधिकारिक

सुपरसर्व द्वारा होस्ट किए गए एजेंटों के लिए सुरक्षित वर्चुअल मशीनें

superserve.ai पर देखें

Superserve Sandbox MCP के साथ आप क्या कर सकते हैं?

  • सैंडबॉक्स बनाएं और चलाएं — अपने असिस्टेंट से सैंडबॉक्स शुरू करने और python --version जैसे कमांड चलाने के लिए कहें, sandbox_create और sandbox_exec का उपयोग करके।
  • सैंडबॉक्स में फ़ाइलें प्रबंधित करें — अपने असिस्टेंट से सैंडबॉक्स के अंदर फ़ाइलें पढ़ने, लिखने या सूचीबद्ध करने के लिए कहें, sandbox_files_read, sandbox_files_write और sandbox_files_list के साथ।
  • नेटवर्क एक्सेस नियंत्रित करें — आउटबाउंड गंतव्यों को अनुमति देने या ब्लॉक करने के लिए sandbox_create या sandbox_update पर ईग्रेस नियम कॉन्फ़िगर करें, फिर sandbox_network_log के साथ ट्रैफ़िक का ऑडिट करें।
  • पूर्वावलोकन URL प्रकाशित करें — अपने असिस्टेंट से sandbox_preview_url कॉल करके चल रही सेवा को सार्वजनिक या समाप्त होने वाला निजी लिंक प्राप्त करने के लिए कहें।
  • GUI डेस्कटॉप चलाएं — ब्राउज़र स्वचालन कार्यों के लिए डेस्कटॉप सैंडबॉक्स में स्क्रीनशॉट, क्लिक, टाइप या स्क्रॉल करने हेतु sandbox_computer का उपयोग करें।
  • सैंडबॉक्स जीवनचक्र प्रबंधित करें — sandbox_pause, sandbox_resume और sandbox_kill के साथ सैंडबॉक्स को रोकें, फिर से शुरू करें या स्थायी रूप से हटाएं।

दस्तावेज़

MCP सर्वर

किसी भी MCP क्लाइंट से Superserve सैंडबॉक्स बनाएं, चलाएं और प्रबंधित करें।

क्या आप चाहते हैं कि कोई एजेंट खुद सैंडबॉक्स बनाए? यह MCP सर्वर ऐसा करता है।

Superserve MCP सर्वर (@superserve/mcp) सैंडबॉक्स प्रिमिटिव को Model Context Protocol टूल के रूप में उजागर करता है, ताकि कोई भी MCP-सक्षम क्लाइंट — Claude, Cursor, VS Code, Windsurf, Codex — सैंडबॉक्स बना सके, कमांड चला सके, फ़ाइलें पढ़ और लिख सके, टेम्पलेट बना सके, सीक्रेट ब्रोकर कर सके, और एक अलग Firecracker microVM में नेटवर्क एक्सेस नियंत्रित कर सके।

इसे दो तरीकों से चलाएं: स्थानीय रूप से stdio पर npx के माध्यम से, या होस्टेड एंडपॉइंट https://mcp.superserve.ai के खिलाफ बिना किसी स्थानीय इंस्टॉल के। दोनों आपकी SUPERSERVE_API_KEY से प्रमाणित होते हैं और प्रति कॉल ID द्वारा सैंडबॉक्स को लक्षित करते हैं। यह TypeScript SDK पर एक पतला रैपर है, इसलिए प्रति-सैंडबॉक्स डेटा-प्लेन टोकन मॉडल तक कभी नहीं पहुंचता।

त्वरित आरंभ

सर्वर को अपने क्लाइंट में जोड़ें (देखें इंस्टॉल), फिर एजेंट से कहें "एक सैंडबॉक्स बनाएं और उसमें python --version चलाएं।" एजेंट sandbox_create, फिर sandbox_exec कॉल करता है, और परिणाम रिपोर्ट करता है — आपकी ओर से कोई कोड नहीं।

आपको एक Superserve API कुंजी चाहिए — इसे API कुंजी पृष्ठ पर बनाएं। कोई वैश्विक इंस्टॉल नहीं है; npx पहले उपयोग पर सर्वर लाता है।

इंस्टॉल

नोट

सर्वर के env में SUPERSERVE_API_KEY सेट करें — MCP क्लाइंट इसे आपके शेल से इनहेरिट नहीं करते। जहां आपका क्लाइंट समर्थन करता है, वहां कच्ची कुंजी चिपकाने के बजाय सीक्रेट-इनपुट प्रॉम्प्ट पसंद करें (नीचे VS Code देखें)।

```bash theme={"theme":{"light":"github-light","dark":"vitesse-dark"}} claude mcp add superserve \ --env SUPERSERVE_API_KEY=ss_live_xxxxxxxxxxxxxxxx \ -- npx -y @superserve/mcp ``` `claude_desktop_config.json` में जोड़ें (macOS: `~/Library/Application Support/Claude/`): 
```json theme={"theme":{"light":"github-light","dark":"vitesse-dark"}}
{
  "mcpServers": {
    "superserve": {
      "command": "npx",
      "args": ["-y", "@superserve/mcp"],
      "env": { "SUPERSERVE_API_KEY": "ss_live_xxxxxxxxxxxxxxxx" }
    }
  }
}
```
`.cursor/mcp.json` (प्रोजेक्ट) या `~/.cursor/mcp.json` (वैश्विक) में जोड़ें: 
```json theme={"theme":{"light":"github-light","dark":"vitesse-dark"}}
{
  "mcpServers": {
    "superserve": {
      "command": "npx",
      "args": ["-y", "@superserve/mcp"],
      "env": { "SUPERSERVE_API_KEY": "ss_live_xxxxxxxxxxxxxxxx" }
    }
  }
}
```
`.vscode/mcp.json` में जोड़ें। `inputs` ब्लॉक कुंजी को सादे पाठ में संग्रहीत करने के बजाय उसके लिए प्रॉम्प्ट करता है: 
```json theme={"theme":{"light":"github-light","dark":"vitesse-dark"}}
{
  "inputs": [
    {
      "id": "superserve-key",
      "type": "promptString",
      "description": "Superserve API key",
      "password": true
    }
  ],
  "servers": {
    "superserve": {
      "type": "stdio",
      "command": "npx",
      "args": ["-y", "@superserve/mcp"],
      "env": { "SUPERSERVE_API_KEY": "${input:superserve-key}" }
    }
  }
}
```
`~/.codeium/windsurf/mcp_config.json` में जोड़ें: 
```json theme={"theme":{"light":"github-light","dark":"vitesse-dark"}}
{
  "mcpServers": {
    "superserve": {
      "command": "npx",
      "args": ["-y", "@superserve/mcp"],
      "env": { "SUPERSERVE_API_KEY": "ss_live_xxxxxxxxxxxxxxxx" }
    }
  }
}
```
`~/.codex/config.toml` में जोड़ें। `env_vars` आपके वातावरण से `SUPERSERVE_API_KEY` अग्रेषित करता है, इसलिए कच्ची कुंजी कॉन्फ़िगरेशन फ़ाइल में संग्रहीत नहीं होती (पहले इसे अपने शेल में निर्यात करें)। Codex क्रॉस-टूल वर्कफ़्लो मार्गदर्शन के लिए सर्वर का `instructions` भी पढ़ता है। 
```toml theme={"theme":{"light":"github-light","dark":"vitesse-dark"}}
[mcp_servers.superserve]
command = "npx"
args = ["-y", "@superserve/mcp"]
env_vars = ["SUPERSERVE_API_KEY"]
```

[होस्टेड](#hosted-remote) एंडपॉइंट के लिए, `bearer_token_env_var = "SUPERSERVE_API_KEY"` के साथ `url = "https://mcp.superserve.ai"` का उपयोग करें।

होस्टेड (रिमोट)

क्या आप स्थानीय रूप से कुछ भी नहीं चलाना चाहते? https://mcp.superserve.ai पर होस्टेड एंडपॉइंट Streamable HTTP बोलता है — कोई npx नहीं, कोई Node नहीं। अपनी Superserve API कुंजी को बियरर टोकन के रूप में भेजें। एंडपॉइंट स्टेटलेस और खाता-स्कोप्ड है (आपकी कुंजी पहले से ही आपकी टीम से मैप होती है), और प्रति-सैंडबॉक्स डेटा-प्लेन टोकन कभी सर्वर नहीं छोड़ता।

नोट

बियरर प्रमाणीकरण किसी भी क्लाइंट में काम करता है जो आपको अनुरोध हेडर सेट करने देता है — Claude Code, Cursor, VS Code, और Anthropic Messages API कनेक्टर। Claude.ai, Claude Desktop का कस्टम कनेक्टर UI, और ChatGPT डेवलपर मोड स्थिर-बियरर / कस्टम-हेडर फ़ील्ड प्रदान नहीं करते (वे OAuth की उम्मीद करते हैं), जिसे होस्टेड एंडपॉइंट अभी तक समर्थन नहीं करता — वहां स्थानीय इंस्टॉल का उपयोग करें।

```bash theme={"theme":{"light":"github-light","dark":"vitesse-dark"}} claude mcp add --transport http superserve https://mcp.superserve.ai \ --header "Authorization: Bearer ss_live_xxxxxxxxxxxxxxxx" ``` `.cursor/mcp.json` (प्रोजेक्ट) या `~/.cursor/mcp.json` (वैश्विक) में जोड़ें: 
```json theme={"theme":{"light":"github-light","dark":"vitesse-dark"}}
{
  "mcpServers": {
    "superserve": {
      "url": "https://mcp.superserve.ai",
      "headers": { "Authorization": "Bearer ss_live_xxxxxxxxxxxxxxxx" }
    }
  }
}
```
`.vscode/mcp.json` में जोड़ें। `inputs` ब्लॉक कुंजी को सादे पाठ में संग्रहीत करने के बजाय उसके लिए प्रॉम्प्ट करता है: 
```json theme={"theme":{"light":"github-light","dark":"vitesse-dark"}}
{
  "inputs": [
    {
      "id": "superserve-key",
      "type": "promptString",
      "description": "Superserve API key",
      "password": true
    }
  ],
  "servers": {
    "superserve": {
      "type": "http",
      "url": "https://mcp.superserve.ai",
      "headers": { "Authorization": "Bearer ${input:superserve-key}" }
    }
  }
}
```
इसे [Anthropic Messages API](https://docs.anthropic.com/en/docs/agents-and-tools/mcp-connector) अनुरोध में कनेक्टर के रूप में पास करें: 
```json theme={"theme":{"light":"github-light","dark":"vitesse-dark"}}
{
  "mcp_servers": [
    {
      "type": "url",
      "name": "superserve",
      "url": "https://mcp.superserve.ai",
      "authorization_token": "ss_live_xxxxxxxxxxxxxxxx"
    }
  ]
}
```

स्थानीय सर्वर के समान टूल और व्यवहार — एकमात्र अंतर परिवहन है और यह कि कुंजी env वर के बजाय बियरर हेडर के रूप में यात्रा करती है।

टूल

टूलयह क्या करता है
sandbox_createएक नया सैंडबॉक्स बनाएं; इसका id लौटाता है। secrets, ईग्रेस नियम, और preview_access स्वीकार करता है।
sandbox_updateमेटाडेटा, ईग्रेस नियम, लाइफसाइकिल विंडो, या preview_access बदलें।
sandbox_listअपने सैंडबॉक्स सूचीबद्ध करें (सक्रिय और रोके गए), मेटाडेटा द्वारा फ़िल्टर करने योग्य।
sandbox_infoएक सैंडबॉक्स की स्थिति, संसाधन, मेटाडेटा, नेटवर्क नियम, और सीक्रेट बाइंडिंग प्राप्त करें। केवल-पढ़ने के लिए।
sandbox_execएक शेल कमांड चलाएं; stdout, stderr, निकास कोड लौटाता है। रोके गए सैंडबॉक्स को स्वचालित रूप से फिर से शुरू करता है।
sandbox_files_readएक फ़ाइल पढ़ें (UTF-8 पाठ, या बाइनरी के लिए base64)।
sandbox_files_writeएक फ़ाइल बनाएं या अधिलेखित करें। मूल निर्देशिकाएं स्वचालित रूप से बनाई जाती हैं।
sandbox_files_listएक निर्देशिका की प्रविष्टियां सूचीबद्ध करें (नाम, प्रकार, आकार, संशोधन समय)।
sandbox_files_download_dirएक निर्देशिका को base64 ZIP के रूप में डाउनलोड करें (सिमलिंक छोड़े गए)। 10 MiB पर सीमित; बड़ा → SDK/CLI।
sandbox_pauseएक सैंडबॉक्स रोकें; स्थिति संरक्षित है।
sandbox_resumeरोके गए सैंडबॉक्स को फिर से शुरू करें (आमतौर पर अनावश्यक — exec स्वचालित रूप से फिर से शुरू करता है)।
sandbox_killएक सैंडबॉक्स को स्थायी रूप से हटाएं।
sandbox_preview_urlएक पोर्ट प्रकाशित करें और एक स्वच्छ सार्वजनिक URL या एक समाप्त होने वाला निजी हस्ताक्षरित URL लौटाएं।
sandbox_network_logएक सैंडबॉक्स के आउटबाउंड कनेक्शन (होस्ट, निर्णय, बाइट्स) को फिर से शुरू किए बिना ऑडिट करें।
sandbox_computerGUI डेस्कटॉप सैंडबॉक्स चलाएं: स्क्रीनशॉट, माउस, कीबोर्ड, स्क्रॉल, आकार बदलें, व्यूअर URL। प्रति कॉल एक क्रिया।
sandbox_template_listउन टेम्पलेट्स (बेस इमेज) को सूचीबद्ध करें जिनसे आपकी टीम लॉन्च कर सकती है।
sandbox_template_createविशिष्ट vCPU/मेमोरी/डिस्क आकार या पूर्व-स्थापित सॉफ़्टवेयर के साथ एक कस्टम टेम्पलेट बनाएं (async — तैयार के लिए पोल करें)।
secret_listबाइंड करने योग्य टीम सीक्रेट सूचीबद्ध करें (केवल मेटाडेटा — कभी मान नहीं)।
sandbox_attach_secretएक संग्रहीत सीक्रेट को env var के तहत चल रहे सैंडबॉक्स से बाइंड करें।
sandbox_detach_secretएक सैंडबॉक्स से सीक्रेट बाइंडिंग हटाएं।

अधिकांश टूल sandbox_id लेते हैं; अपवाद हैं sandbox_create, sandbox_list, sandbox_template_list, sandbox_template_create, और secret_list। ID प्राप्त करने के लिए उनमें से एक से शुरू करें, फिर इसे बाद के कॉल में थ्रेड करें। केवल-पढ़ने के टूल (sandbox_list, sandbox_info, sandbox_files_read, sandbox_files_list, sandbox_files_download_dir, sandbox_network_log, sandbox_template_list, secret_list) एनोटेट हैं ताकि क्लाइंट पुष्टिकरण प्रॉम्प्ट छोड़ सकें; sandbox_preview_url एक आइडेम्पोटेंट लेखन है क्योंकि यह अनुरोधित पोर्ट प्रकाशित करता है, और sandbox_kill विनाशकारी एनोटेट है।

उदाहरण

"एक सैंडबॉक्स स्पिन करें, एक Python स्क्रिप्ट लिखें जो पहले प्राइम प्रिंट करती है, और इसे चलाएं" के लिए एक विशिष्ट एजेंट प्रवाह:

sandbox_create       { name: "primes" }
                       → { id: "a1b2c3…", name: "primes", status: "active" }

sandbox_files_write  { sandbox_id: "a1b2c3…", path: "/app/primes.py", content: "…" }
                       → { path: "/app/primes.py", bytes: 142 }

sandbox_exec         { sandbox_id: "a1b2c3…", command: "python /app/primes.py" }
                       → { exit_code: 0, stdout: "2 3 5 7 11 13 17 19 23 29", stderr: "" }

जब यह समाप्त हो जाता है, तो एजेंट sandbox_pause (स्थिति संरक्षित, रखने के लिए सस्ता) या sandbox_kill (स्थायी) कर सकता है।

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

चरआवश्यकविवरण
SUPERSERVE_API_KEYहाँआपकी Superserve API कुंजी (ss_live_ से शुरू होती है)।
SUPERSERVE_BASE_URLनहींनियंत्रण-प्लेन URL ओवरराइड करें (डिफ़ॉल्ट https://api.superserve.ai है)।

व्यवहार और सीमाएं

  • स्वचालित फिर से शुरू। sandbox_exec और फ़ाइल टूल पारदर्शी रूप से रोके गए सैंडबॉक्स को फिर से शुरू करते हैं, इसलिए एजेंटों को पहले sandbox_resume कॉल करने की आवश्यकता नहीं है। sandbox_resume केवल एक सैंडबॉक्स को स्पष्ट रूप से गर्म करने के लिए मौजूद है।
  • संदर्भ के लिए आउटपुट सीमित है। sandbox_exec stdout और stderr को प्रत्येक 32 KiB तक छोटा करता है — एक छोटा परिणाम truncated: true सेट करता है और मूल बाइट लंबाई रिपोर्ट करता है। sandbox_files_read 1 MiB से बड़ी फ़ाइलों को अस्वीकार करता है (यह आंशिक सामग्री नहीं लौटाता); त्रुटि आपको sandbox_exec के साथ एक स्लाइस पढ़ने के लिए कहती है (जैसे head -c) या SDK/CLI के साथ पूरी फ़ाइल डाउनलोड करें। sandbox_files_write इनलाइन सामग्री 8 MiB पर सीमित है।
  • डिफ़ॉल्ट कमांड टाइमआउट 60s है, 10 मिनट पर सीमित। इसे प्रति कॉल timeout_ms के साथ ओवरराइड करें।
  • ईग्रेस नियंत्रणीय है। allow_out (डोमेन पैटर्न, IP, या CIDR) अनुमत गंतव्य जोड़ता है; deny_out (IP या CIDR, कोई डोमेन नहीं) उन्हें ब्लॉक करता है। allow_out अकेले एक सैंडबॉक्स को लॉक नहीं करता — एक सख्त अनुमतिसूची के लिए, इसे deny_out: ["0.0.0.0/0"] (सभी अस्वीकार करें, फिर सूचीबद्ध गंतव्यों की अनुमति दें) के साथ जोड़ें। यदि अनुमतिसूची में डोमेन नियम हैं या वर्कलोड होस्टनाम हल करता है, तो सैंडबॉक्स के DNS रिज़ॉल्वर, 1.1.1.1/32 और 8.8.8.8/32 की भी अनुमति दें, क्योंकि सभी-अस्वीकार DNS को भी ब्लॉक करता है; उन्हें केवल-IP अनुमतिसूची से बाहर रखें, जहां एक अनुमत रिज़ॉल्वर केवल एक अतिरिक्त आउटबाउंड चैनल है। इन्हें sandbox_create या sandbox_update पर सेट करें, और sandbox_network_log के साथ ऑडिट करें कि एक सैंडबॉक्स वास्तव में क्या पहुंचा।
  • त्रुटियां कार्रवाई योग्य हैं। एक असफल टूल कॉल एक छोटा संदेश लौटाता है जो एजेंट को बताता है कि आगे क्या करना है — जैसे "सैंडबॉक्स कोटा पहुंच गया। एक सैंडबॉक्स रोकें या मारें, या बाद में पुनः प्रयास करें।" — कच्चे स्टैक ट्रेस के बजाय, ताकि एजेंट स्वयं सुधार कर सके।

सीक्रेट, टेम्पलेट, और पोर्ट

सीक्रेट। क्रेडेंशियल को सादे पाठ env_vars के रूप में पास न करें। इसके बजाय:

  1. सीक्रेट को TypeScript SDK (Secret.create()) या कंसोल के साथ एक बार बनाएं — कच्चा मान कभी एजेंट या MCP सर्वर के माध्यम से यात्रा नहीं करता, इसलिए सीक्रेट निर्माण जानबूझकर एक MCP टूल नहीं है।
  2. secret_list के साथ बाइंड करने योग्य सीक्रेट खोजें (केवल मेटाडेटा — मान कभी प्लेटफ़ॉर्म नहीं छोड़ते)।
  3. निर्माण पर बाइंड करें — sandbox_create पर secrets: { ANTHROPIC_API_KEY: "anthropic-prod" } — या बाद में sandbox_attach_secret / sandbox_detach_secret के साथ।

सैंडबॉक्स एक प्रॉक्सी टोकन देखता है; प्लेटफ़ॉर्म केवल सीक्रेट के अनुमत होस्टों के लिए आउटबाउंड अनुरोधों के लिए वास्तविक क्रेडेंशियल स्वैप करता है।

टेम्पलेट। एक सैंडबॉक्स अपने vCPU/मेमोरी/डिस्क को अपने टेम्पलेट से विरासत में लेता है और sandbox_create समय पर उन्हें ओवरराइड नहीं कर सकता। एक विशिष्ट आकार (जैसे, 4 vCPU सैंडबॉक्स) या पूर्व-स्थापित सॉफ़्टवेयर प्राप्त करने के लिए, sandbox_template_create के साथ एक टेम्पलेट बनाएं, फिर sandbox_template_list को पोल करें जब तक कि इसका status ready न हो, इसे from_template के रूप में पास करने से पहले।

पोर्ट। नए MCP सैंडबॉक्स नए प्रकाशित पोर्ट के लिए डिफ़ॉल्ट एक्सेस के रूप में public का उपयोग करते हैं; केवल स्पष्ट रूप से प्रकाशित पोर्ट पहुंच योग्य हैं। भविष्य के पोर्ट के लिए डिफ़ॉल्ट बदलने के लिए sandbox_create (या sandbox_update) को preview_access: "private" पास करें। मौजूदा पोर्ट अपना स्वयं का मोड बनाए रखते हैं। सर्वर को sandbox_exec के साथ शुरू करें, फिर sandbox_preview_url कॉल करें; टूल आइडेम्पोटेंट रूप से उस एक पोर्ट को प्रकाशित करता है और लौटाए गए पोर्ट मोड का उपयोग करके या तो एक स्वच्छ सार्वजनिक URL या एक समाप्त होने वाला निजी हस्ताक्षरित URL लौटाता है। निजी लिंक डिफ़ॉल्ट रूप से एक घंटे के होते हैं; expires_in_seconds को 1 से 604800 सेकंड के मान पर सेट करें। देखें पूर्वावलोकन URL।

कंप्यूटर उपयोग

sandbox_computer एक डेस्कटॉप टेम्पलेट जैसे superserve/desktop से बनाए गए सैंडबॉक्स में GUI डेस्कटॉप चलाता है। यह प्रति कॉल एक action लेता है जो कंप्यूटर-उपयोग मॉडल उत्सर्जित करते हैं: screenshot, left_click, right_click, middle_click, double_click, triple_click, left_click_drag, left_mouse_down, left_mouse_up, mouse_move, key, type, scroll, wait, resize, और stream_url। पॉइंटर क्रियाएं स्क्रीन पिक्सल में coordinate: [x, y] लेती हैं (मूल ऊपर-बाएं); key और type text लेते हैं; scroll scroll_direction और एक वैकल्पिक scroll_amount लेता है।

sandbox_create    { name: "browser", from_template: "superserve/desktop" }
sandbox_computer  { sandbox_id: "a1b2c3…", action: "left_click", coordinate: [640, 32] }
                    → text "left_click done (1280x800)" + image/png
sandbox_computer  { sandbox_id: "a1b2c3…", action: "type", text: "https://example.com" }
sandbox_computer  { sandbox_id: "a1b2c3…", action: "key", text: "Return" }

इनपुट क्रियाएं परिणाम का एक ताज़ा स्क्रीनशॉट लौटाती हैं, इसलिए मॉडल का कार्य-फिर-देखो मोड़ एक टूल कॉल है; कई क्रियाओं को लगातार भेजते समय screenshot_after: false पास करें। wait सैंडबॉक्स से अनुरोध के बिना duration_ms (10 सेकंड पर सीमित) के लिए रुकता है। stream_url सैंडबॉक्स की पूर्वावलोकन नीति के तहत डेस्कटॉप के लिए एक लाइव ब्राउज़र व्यूअर लौटाता है।

यदि कोई इनपुट क्रिया विफल हो जाती है, तो इनपुट पहले ही वितरित किया जा सकता है। टूल ऐसा कहता है और एजेंट को इसे दोहराने से पहले स्क्रीनशॉट लेने के लिए कहता है। अंतर्निहित SDK सतह के लिए डेस्कटॉप गाइड देखें।

अभी तक MCP सतह में नहीं

MCP सर्वर सामान्य एजेंट लूप को कवर करता है; ऊपर दी गई तालिका पूर्ण v1 टूल सेट है। कुछ SDK क्षमताएँ अभी तक उजागर नहीं हुई हैं — इनके लिए सीधे TypeScript SDK का उपयोग करें:

  • सीक्रेट निर्माण — Secret.create() (MCP सर्वर केवल मौजूदा सीक्रेट को बाइंड करता है)।
  • स्ट्रीमिंग और इंटरैक्टिव कमांड — स्ट्रीमिंग run() कॉलबैक और commands.spawn (stdin, सिग्नल, लंबे समय तक चलने वाली प्रक्रियाएँ)।
  • बड़े या स्ट्रीमिंग ट्रांसफर — डायरेक्टरी डाउनलोड sandbox_files_download_dir के माध्यम से 10 MiB तक समर्थित है; उससे आगे (और आर्काइव/स्ट्रीमिंग अपलोड या 1 MiB रीड / 8 MiB इनलाइन-राइट सीमा से अधिक एकल फ़ाइलों के लिए), SDK/CLI का उपयोग करें (files.downloadDir, स्ट्रीमिंग अपलोड)।
  • बिलिंग और प्रदाता खोज — उपयोग डेटा और सीक्रेट-प्रदाता सेटअप के लिए Provider.list()।

इन्हें अनुवर्ती कार्यों के रूप में ट्रैक किया जाता है।

यह कैसे काम करता है

सर्वर TypeScript SDK को रैप करता है और केवल आपका कंट्रोल-प्लेन SUPERSERVE_API_KEY रखता है। प्रत्येक टूल कॉल आईडी द्वारा लक्षित सैंडबॉक्स से जुड़ता है; SDK प्रति-सैंडबॉक्स डेटा-प्लेन एक्सेस टोकन को आंतरिक रूप से प्रबंधित करता है और रिज़्यूम पर इसे घुमाता है, इसलिए यह कभी भी मॉडल को उजागर नहीं होता या टूल आउटपुट में वापस नहीं आता। टूल स्टेटलेस हैं — कोई छिपा हुआ "वर्तमान सैंडबॉक्स" नहीं है — जो मल्टी-टर्न और समानांतर टूल कॉल में व्यवहार को पूर्वानुमानित रखता है।

समस्या निवारण

  • टूल दिखाई नहीं देते, या सर्वर शुरू नहीं होता। API कुंजी लगभग हमेशा कारण होती है — MCP क्लाइंट आपके शेल से पर्यावरण चर विरासत में नहीं लेते। सर्वर के env ब्लॉक में SUPERSERVE_API_KEY सेट करें (देखें इंस्टॉल), न कि केवल अपने टर्मिनल में।
  • Authentication failed। कुंजी गायब या अमान्य है। प्रोडक्शन कुंजियाँ ss_live_ से शुरू होती हैं; API कुंजी पृष्ठ पर एक बनाएँ।
  • पहली कॉल धीमी है। npx पहले उपयोग पर पैकेज डाउनलोड करता है और इसे कैश करता है; बाद के स्टार्ट तेज़ होते हैं।
  • Node 18+ आवश्यक है। स्थानीय सर्वर npx के माध्यम से Node पर चलता है। (होस्टेड एंडपॉइंट में कोई स्थानीय रनटाइम आवश्यकता नहीं है।)
  • होस्टेड एंडपॉइंट से 401 Unauthorized। बियरर टोकन गायब है या मान्य ss_live_ कुंजी नहीं है। इसे Authorization: Bearer ss_live_… के रूप में भेजें (देखें होस्टेड)।

संबंधित

सैंडबॉक्स को पॉज़, रिज़्यूम और डिलीट करें। Exec, स्ट्रीमिंग, cwd, env और टाइमआउट। सैंडबॉक्स को उजागर किए बिना प्रदाता कुंजियाँ ब्रोकर करें। वह लाइब्रेरी जिसे MCP सर्वर रैप करता है।

यह दस्तावेज़ Mintlify पर बनाया और होस्ट किया गया है, जो एक डेवलपर दस्तावेज़ीकरण प्लेटफ़ॉर्म है।