pilot-protocol/pilotprotocolओवरले नेटवर्क प्रोटोकॉल जो AI एजेंटों को स्थायी पते, प्रमाणित एन्क्रिप्टेड टनल, और UDP पर एक ट्रस्ट मॉडल प्रदान करता है। इसमें NAT ट्रैवर्सल, पीयर-टू-पीयर मैसेजिंग, और Node.js, Python, और Swift के लिए SDK शामिल हैं।
<p align="center">
<img src="https://assets.kitploit.com/production/public/readmes/13790/aca1679f7d00fe2469f0e9f72a440a9bcbe7d0448446e1d15a79f0669bdc3d18.png" alt="Pilot Protocol" width="200">
</p>
<h1 align="center">Pilot Protocol</h1>
<p align="center">
<strong>AI एजेंट्स के लिए नेटवर्क स्टैक।</strong><br>
पते। पोर्ट्स। टनल। एन्क्रिप्शन। भरोसा।
</p>
<p align="center">
<a href="https://pilotprotocol.network/docs/"><strong>Docs</strong></a>
<span> · </span>
<a href="https://github.com/pilot-protocol/docs/blob/main/SPEC.md"><strong>Wire Spec</strong></a>
<span> · </span>
<a href="https://github.com/pilot-protocol/docs/blob/main/WHITEPAPER.pdf"><strong>Whitepaper</strong></a>
<span> · </span>
<a href="https://www.ietf.org/archive/id/draft-teodor-pilot-protocol-01.html"><strong>IETF Draft</strong></a>
<span> · </span>
<a href="https://github.com/TeoSlayer/pilot-skills"><strong>Agent Skills</strong></a>
<span> · </span>
<a href="https://polo.pilotprotocol.network"><strong>Polo (Live Dashboard)</strong></a>
</p>
<br>
<p align="center">
<img src="https://img.shields.io/badge/lang-Go-00ADD8?logo=go&logoColor=white" alt="Go">
<img src="https://img.shields.io/badge/core-stdlib-brightgreen" alt="Core uses Go standard library only">
<img src="https://img.shields.io/badge/encryption-AES--256--GCM-blueviolet" alt="Encryption">
<img src="https://img.shields.io/badge/tests-1048%20pass-success" alt="Tests">
<a href="https://www.ietf.org/archive/id/draft-teodor-pilot-protocol-01.html"><img src="https://img.shields.io/badge/IETF-Internet--Draft-blue" alt="IETF Internet-Draft"></a>
<img src="https://img.shields.io/badge/license-AGPL--3.0-blue" alt="License">
</p>
---
<p align="center">
<img src="https://assets.kitploit.com/production/public/readmes/13790/290649ca3b8051e074e6f0b5f3bda2c43eeeb40e86686f8767bf9734269912cc.gif" alt="Pilot Protocol Demo — two agents: install, trust, data exchange" width="960">
</p>
इंटरनेट मनुष्यों के लिए बनाया गया था। AI एजेंट्स के पास न कोई पता है, न पहचान, और न ही उन तक पहुँचने का कोई तरीका। Pilot Protocol एक ओवरले नेटवर्क है जो एजेंट्स को वही देता है जो इंटरनेट ने डिवाइसों को दिया था: **एक स्थायी पता, प्रमाणित एन्क्रिप्टेड चैनल, और एक ट्रस्ट मॉडल** -- यह सब मानक UDP के ऊपर परतों में बना हुआ।
एजेंट्स डिस्कवरी और NAT ट्रैवर्सल के लिए एक रेंडेज़वस सेवा के साथ रजिस्टर करते हैं। एप्लिकेशन डेटा सीधे पीयर्स के बीच डायरेक्ट पाथ पर प्रवाहित होता है; जब NAT होल-पंचिंग विफल हो जाती है (जैसे सिमेट्रिक NAT), तो बीकन अभी भी एंड-टू-एंड-एन्क्रिप्टेड ट्रैफ़िक को फ़ॉलबैक के रूप में रिले करता है। यह कोई API नहीं है। यह कोई फ्रेमवर्क नहीं है। यह इन्फ्रास्ट्रक्चर है।
---
## समस्या
आज, एजेंट्स केंद्रीकृत APIs के माध्यम से बात करते हैं। हर संदेश एक प्लेटफ़ॉर्म से होकर गुज़रता है -- प्लेटफ़ॉर्म सारा ट्रैफ़िक देखता है, एक्सेस नियंत्रित करता है, और विफलता का एकल बिंदु बन जाता है।
```mermaid
graph LR
A1[Agent A] -->|HTTP API| P[Platform / Cloud]
A2[Agent B] -->|HTTP API| P
A3[Agent C] -->|HTTP API| P
style P fill:#f66,stroke:#333,color:#fff
style A1 fill:#4a9,stroke:#333,color:#fff
style A2 fill:#4a9,stroke:#333,color:#fff
style A3 fill:#4a9,stroke:#333,color:#fff
```
Pilot Protocol प्लेटफ़ॉर्म को डेटा पथ से बाहर निकाल देता है। एक हल्का **rendezvous** सेवा डिस्कवरी और NAT traversal को संभालती है, लेकिन एक बार एजेंट्स एक-दूसरे को ढूंढ लेते हैं, तो वे सीधे प्रमाणित, एन्क्रिप्टेड टनल के माध्यम से बात करते हैं:
```mermaid
graph LR
A1[Agent A<br/><small>0:0000.0000.0001</small>] <-->|Encrypted UDP Tunnel| A2[Agent B<br/><small>0:0000.0000.0002</small>]
A1 <-->|Encrypted UDP Tunnel| A3[Agent C<br/><small>0:0000.0000.0003</small>]
A2 <-->|Encrypted UDP Tunnel| A3
A1 -.->|discovery| RV[Rendezvous]
A2 -.->|discovery| RV
A3 -.->|discovery| RV
style A1 fill:#4a9,stroke:#333,color:#fff
style A2 fill:#4a9,stroke:#333,color:#fff
style A3 fill:#4a9,stroke:#333,color:#fff
style RV fill:#888,stroke:#333,color:#fff
```
## एजेंट्स को क्या मिलता है
```bash
pilotctl info # show your address, hostname, peer count
pilotctl set-hostname my-agent # claim a name other agents can resolve
pilotctl find agent-alpha # resolve a public demo peer
pilotctl ping agent-alpha # round-trip over the encrypted tunnel
pilotctl bench agent-alpha # 1 MB echo benchmark
```
एक बार जब आपके पास एक विश्वसनीय पीयर हो, तो एजेंट-टू-एजेंट मैसेजिंग पोर्ट 1001 पर डेटा एक्सचेंज सेवा का उपयोग करती है:
```bash
# Send a structured message (waits for reply by default)
pilotctl send-message other-agent --data "hello"
# Read messages delivered to your inbox
pilotctl inbox
# Read a specific message
pilotctl inbox read <id>
```
निम्न-स्तरीय कच्चे पोर्ट मैसेजिंग के लिए:
```bash
# on the sender
pilotctl send other-agent 1000 --data "hello"
# on the receiver
pilotctl recv 1000 --count 5 --timeout 30s
```
हर CLI कमांड संरचित आउटपुट के लिए `--json` का समर्थन करता है — पूर्ण सरफेस एरिया के लिए [CLI संदर्भ](https://pilotprotocol.network/docs/cli-reference) देखें।
<details>
<summary><strong>उदाहरण JSON आउटपुट</strong></summary>
```json
$ pilotctl --json info
{"status":"ok","data":{"address":"0:0000.0000.0005","node_id":5,"hostname":"my-agent","peers":3,"connections":1,"uptime_secs":3600}}
$ pilotctl --json find other-agent
{"status":"ok","data":{"hostname":"other-agent","address":"0:0000.0000.0003"}}
$ pilotctl --json recv 1000 --count 1
{"status":"ok","data":{"messages":[{"seq":0,"port":1000,"data":"hello","bytes":5}]}}
$ pilotctl --json find nonexistent
{"status":"error","code":"not_found","message":"cannot find \"nonexistent\" — hostname not found or no mutual trust","hint":"establish trust first: pilotctl handshake nonexistent \"reason\""}
```
</details>
---
## प्रोग्रामेटिक एक्सेस (SDKs)
एक बार डेमन चलने के बाद, आप CLI के बजाय SDK के माध्यम से एजेंट्स के साथ प्रोग्रामेटिक रूप से इंटरैक्ट कर सकते हैं। तीनों SDKs अपने Unix socket IPC के माध्यम से लोकल Pilot डेमन के साथ संचार करते हैं और आपकी पसंद की भाषा में पूरी एजेंट सतह — handshake, trust, send, receive, stream, और gateway — को उजागर करते हैं।
| भाषा | पैकेज | क्विकस्टार्ट |
|----------|---------|------------|
| **Node.js / TypeScript** | [`pilotprotocol` on npm](https://www.npmjs.com/package/pilotprotocol) | `npm install pilotprotocol` — देखें [sdk-node README](https://github.com/pilot-protocol/sdk-node) |
| **Python** | [`pilotprotocol` on PyPI](https://pypi.org/project/pilotprotocol/) | `pip install pilotprotocol` — देखें [sdk-python README](https://github.com/pilot-protocol/sdk-python) |
| **Swift / iOS / macOS** | [`pilotprotocol` on GitHub](https://github.com/pilot-protocol/sdk-swift) | `Package.swift` के माध्यम से जोड़ें — देखें [sdk-swift README](https://github.com/pilot-protocol/sdk-swift) |
`daemon start` के बाद एक न्यूनतम Node.js प्रथम-क्वेरी उदाहरण:
```js
import { createPilot, createAgent } from 'pilotprotocol';
const pilot = await createPilot();
const conn = await pilot.handshake('agent-alpha', 'hello');
await conn.trust();
// Send a message
await conn.send(3000, Buffer.from('ping'));
// Receive on any port
const msgs = await conn.recv(3000, { count: 1, timeout: 10 });
console.log('Received:', msgs[0].data.toString());
```
प्रत्येक SDK के पूर्ण API दस्तावेज़, स्ट्रीमिंग उदाहरण, और प्लेटफ़ॉर्म-विशिष्ट सेटअप (iOS सिम्युलेटर, PyPI एक्स्ट्रा, आदि) के लिए उसका README देखें।
## मुख्य विशेषताएँ
<table>
<tr>
<td width="50%" valign="top">
**एड्रेसिंग**
- 48-बिट वर्चुअल एड्रेस (`N:NNNN.HHHH.LLLL`)
- सुप्रसिद्ध असाइनमेंट के साथ 16-बिट पोर्ट
- होस्टनेम-आधारित डिस्कवरी
**ट्रांसपोर्ट**
- विश्वसनीय स्ट्रीम (TCP-समतुल्य)
- स्लाइडिंग विंडो, SACK, कंजेशन कंट्रोल (AIMD)
- फ़्लो कंट्रोल (विज्ञापित रिसीव विंडो)
- Nagle कोलेसिंग, ऑटो सेगमेंटेशन, ज़ीरो-विंडो प्रोबिंग
- NAT ट्रैवर्सल: STUN डिस्कवरी, होल-पंचिंग, रिले फ़ॉलबैक
</td>
<td width="50%" valign="top">
**सुरक्षा**
- प्रमाणित कुंजी एक्सचेंज (Ed25519-हस्ताक्षरित X25519 + AES-256-GCM)
- टनल सत्रों से बंधी Ed25519 पहचान कुंजियाँ
- नोड्स डिफ़ॉल्ट रूप से निजी हैं
- पारस्परिक विश्वास हैंडशेक प्रोटोकॉल (हस्ताक्षरित, रजिस्ट्री के माध्यम से रिले)
**संचालन**
- कोर प्रोटोकॉल: केवल Go मानक लाइब्रेरी
- अंतर्निहित सेवाओं के साथ एकल डेमन बाइनरी
- संरचित JSON लॉगिंग (`slog`)
- सभी स्थिति के लिए परमाणु दृढ़ता
- हॉट-स्टैंडबाय रजिस्ट्री प्रतिकृति
</td>
</tr>
</table>
---
## आर्किटेक्चर
```mermaid
graph LR
subgraph Local Machine
Agent[Your Agent] -->|commands| CLI[pilotctl]
CLI -->|Unix socket| D[Daemon]
D --- E[Echo :7]
D --- DX[Data Exchange :1001]
D --- ES[Event Stream :1002]
end
D <====>|UDP Tunnel<br/>AES-256-GCM + NAT traversal| RD
subgraph Remote Machine
RD[Remote Daemon] -->|Unix socket| RC[pilotctl]
RC -->|commands| RA[Remote Agent]
RD --- RE[Echo :7]
RD --- RDX[Data Exchange :1001]
RD --- RES[Event Stream :1002]
end
D -.->|register + discover| RV
RD -.->|register + discover| RV
subgraph Rendezvous
RV[Registry :9000<br/>Beacon :9001]
end
```
आपका एजेंट एक Unix सॉकेट पर स्थानीय **daemon** से बात करता है। daemon टनल एन्क्रिप्शन, NAT ट्रैवर्सल, पैकेट रूटिंग, कंजेशन कंट्रोल, और अंतर्निहित सेवाओं को संभालता है। daemon नोड पंजीकरण, पीयर डिस्कवरी, और NAT होल-पंचिंग के लिए एक **rendezvous** सर्वर (रजिस्ट्री + बीकन) से कनेक्शन बनाए रखता है। एक बार टनल स्थापित हो जाने के बाद, डेटा सीधे daemons के बीच प्रवाहित होता है -- rendezvous डेटा पथ में नहीं होता, सिवाय उस स्थिति के जब बीकन को सिमेट्रिक NATs के पीछे के पीयर्स के लिए ट्रैफ़िक रिले करना पड़ता है (रिले किया गया ट्रैफ़िक एंड-टू-एंड एन्क्रिप्टेड रहता है)।
एक सार्वजनिक rendezvous `34.71.57.205:9000` पर प्रदान किया गया है, या आप `rendezvous -registry-addr :9000 -beacon-addr :9001` के साथ अपना स्वयं का चला सकते हैं।
कनेक्शन लाइफसाइकल विवरण, गेटवे ब्रिजिंग, और NAT ट्रैवर्सल रणनीति के लिए, [पूर्ण दस्तावेज़ीकरण](https://pilotprotocol.network/docs/) देखें।
---
## डेमो
एक सार्वजनिक डेमो एजेंट (`agent-alpha`) नेटवर्क पर ऑटो-एक्सेप्ट सक्षम के साथ चल रहा है:
```bash
# 1. Install
curl -fsSL https://pilotprotocol.network/install.sh | sh
# 2. Start the daemon
pilotctl daemon start --hostname my-agent --email [email protected]
# 3. Request trust (auto-approved within seconds)
pilotctl handshake agent-alpha "hello"
# 4. Wait a few seconds, then verify trust
pilotctl trust
# 5. Start the gateway (maps the agent to a local IP)
sudo pilotctl extras gateway start --ports 80 0:0000.0000.0004
# 6. Open the website
curl http://10.4.0.1/
```
आप पिंग और बेंचमार्क भी कर सकते हैं:
```bash
pilotctl ping agent-alpha
pilotctl bench agent-alpha
```
---
## इंस्टॉल
```bash
curl -fsSL https://pilotprotocol.network/install.sh | sh
```
इंस्टॉल के दौरान होस्टनाम और ईमेल सेट करें:
```bash
curl -fsSL https://pilotprotocol.network/install.sh | [email protected] PILOT_HOSTNAME=my-agent sh
```
**UDP अवरुद्ध है, या बाहर निकलने का एकमात्र रास्ता HTTPS प्रॉक्सी है** (Meta Muse जैसे होस्टेड एजेंट सैंडबॉक्स, लॉक-डाउन VM)? सादा इंस्टॉल काम करता है:
```bash
curl -fsSL https://pilotprotocol.network/install.sh | sh
pilotctl daemon start
```
नए इंस्टॉल ट्रांसपोर्ट `auto` का उपयोग करते हैं: डेमन स्टार्टअप पर एक बार UDP के माध्यम से बीकन की जाँच करता है (जब UDP काम करता है तो एक राउंड ट्रिप, जब नहीं करता तो अधिकतम ~1.5s) और, जब कोई उत्तर नहीं होता है लेकिन कॉम्पैट बीकन TCP 443 पर उत्तर देता है (एक TLS अनुरोध जिसका एक लाइव बीकन `426 Upgrade Required` के साथ उत्तर देता है), तो **compat** मोड में चलता है — `registry.pilotprotocol.network:443` पर TLS के माध्यम से रजिस्ट्री, `beacon.pilotprotocol.network:443` पर WSS के माध्यम से बीकन। जब एक प्रॉक्सी कॉन्फ़िगर किया जाता है और वह उस जाँच से इनकार करता है (गलत या पुराने क्रेडेंशियल: `407`, एक `403`, या प्रॉक्सी तक पहुँचा नहीं जा सकता), तो यह प्रॉक्सी से आगे सीधे कनेक्शन पर वापस जाने के बजाय वैसे भी compat में चलता है, और रजिस्ट्री डायल तब प्रॉक्सी के उत्तर का नाम लेता है; `pilotctl daemon start` केवल "did not become ready" के बजाय संकेत के साथ डेमन की अंतिम प्रॉक्सी त्रुटि प्रिंट करता है। जब न तो कोई उत्तर देता है और न ही कोई प्रॉक्सी शामिल है (अभी तक कोई नेटवर्क नहीं, बीकन आउटेज) तो यह पहले की तरह UDP पर ही रहता है। compat मोड में डेमन `$HTTPS_PROXY` / `$ALL_PROXY` के माध्यम से टनल करता है (`$NO_PROXY` का सम्मान करते हुए), प्रॉक्सी से होस्ट नाम से `CONNECT` करने के लिए कहता है, इसलिए Pilot होस्ट के लिए ज़हरीला स्थानीय DNS मायने नहीं रखता। `pilotctl` की अपनी रजिस्ट्री कमांड (`lookup`, ऑटो-हैंडशेक जाँच, `recovery`) डेमन का अनुसरण करती हैं: जब यह compat चलाता है (या एक स्पष्ट प्रॉक्सी URL के साथ) तो प्रॉक्सी के माध्यम से, जब यह UDP चलाता है तो सीधे; कोई डेमन चल रहा न हो और कोई ट्रांसपोर्ट कॉन्फ़िगर न हो तो वे पहले प्रॉक्सी और दूसरे सीधे कनेक्शन का प्रयास करती हैं। UDP प्रोब को छोड़ने के लिए, स्पष्ट रूप से compat चुनें: `sh -s -- --transport compat`, `pilotctl config --set transport=compat`, या `pilotctl daemon start --transport compat`।
- **root, systemd या launchd की आवश्यकता नहीं।** डेमन को उस शेल से `pilotctl daemon start` के साथ शुरू करें जिसमें प्रॉक्सी वेरिएबल हों। systemd के बिना किसी कंटेनर या VM में इंस्टॉलर root के रूप में भी चलता है (होस्टेड सैंडबॉक्स में एजेंट उपयोगकर्ता); एक नियमित होस्ट पर यह अभी भी root से इनकार करता है जब तक कि `PILOT_ALLOW_ROOT=1` न हो।
- **एक कंटेनर में, डेमन को एक init प्रोसेस दें।** ऐप्स ऐसे सर्वर शुरू करते हैं जो डेमोनाइज़ होते हैं (redis, postgres); एक डेमोनाइज़्ड सर्वर PID 1 को सौंपा जाता है, और जब वह रुकता है तो वह तब तक ज़ॉम्बी (`ps` में `Z`) बना रहता है जब तक PID 1 उसे रीप नहीं करता। एक `pilot-daemon` जो स्वयं PID 1 है, ऐसा नहीं करता, इसलिए ज़ॉम्बी जमा होते रहते हैं और कंटेनर की PID सीमा के विरुद्ध गिने जाते हैं। कंटेनर को `docker run --init` के साथ चलाएँ (Compose: `init: true`), [tini](https://github.com/krallin/tini) को एंट्रीपॉइंट बनाएँ (`ENTRYPOINT ["tini", "--", "pilot-daemon"]`), या Kubernetes पर `shareProcessNamespace: true` सेट करें (ECS: `initProcessEnabled`)। डेमन स्टार्टअप पर एक चेतावनी लॉग करता है जब वह PID 1 होता है; कोई चेतावनी यह साबित नहीं करती कि सब ठीक है यदि कोई अन्य प्रोसेस जो रीपिंग के बिना है, जैसे कि एक शेल स्क्रिप्ट, PID 1 है। यह स्वयं अनाथों को रीप नहीं करता: इन-प्रोसेस ऐसा करना उन ऐप्स की एक्ज़िट स्थिति भी ले लेगा जिन्हें यह सुपरवाइज़ करता है।
- **क्रेडेंशियल के साथ प्रॉक्सी:** उन्हें `ps` से बाहर रखें — `HTTPS_PROXY` / `PILOT_PROXY` एक्सपोर्ट करें, या `pilotctl daemon start --proxy http://user:pass@host:port` (pilotctl क्रेडेंशियल के साथ एक URL डेमन को उसके वातावरण में सौंपता है, कभी उसकी कमांड लाइन पर नहीं)। एक systemd/launchd सेवा के लिए, जो आपके शेल के वेरिएबल नहीं देखती, इसे सहेजें: `pilotctl config --set proxy=http://user:pass@host:port` (config.json 0600 है)।
- **प्रॉक्सी क्रेडेंशियल जो रोटेट होते हैं** (Meta Muse हर कुछ मिनट में `HTTPS_PROXY` में क्रेडेंशियल रोटेट करता है): एक लंबे समय तक चलने वाला डेमन वही रखेगा जिनके साथ उसने शुरुआत की थी, और नए कनेक्शन `407 Proxy Authentication Required` के साथ विफल होने लगेंगे जबकि पुराने टनल बने रहेंगे ("node online, apps broken")। डेमन को एक कमांड दें जो वर्तमान प्रॉक्सी URL प्रिंट करती है — config.json में `proxy_cmd`, `$PILOT_PROXY_CMD`, `-proxy-cmd` या `pilotctl daemon start --proxy-cmd` — और यह इसे 60s बीत जाने पर और जब भी प्रॉक्सी क्रेडेंशियल को अस्वीकार करता है (एक 407, या Muse का गड़बड़ "malformed HTTP status code" उत्तर) पर फिर से चलाता है, उस कनेक्शन को ताज़ा क्रेडेंशियल के साथ एक बार पुनः प्रयास करता है (रजिस्ट्री, compat बीकन और HTTP क्लाइंट समान रूप से, common के `netproxy` रीफ्रेश के माध्यम से); किसी पुनः आरंभ की आवश्यकता नहीं। डेमन जो ऐप्स शुरू करता है वे डेमन में एक लूपबैक रिले के माध्यम से प्रॉक्सी तक पहुँचते हैं जो वर्तमान क्रेडेंशियल जोड़ता है, इसलिए वे रोटेशन के दौरान भी काम करते रहते हैं। pilotctl की अपनी रजिस्ट्री कमांड उसी कमांड का उपयोग करती हैं। एक Linux कंटेनर/VM में systemd के बिना जिसका `HTTPS_PROXY` या `https_proxy` क्रेडेंशियल रखता है, `pilotctl daemon start` डेमन को एक `PILOT_PROXY_CMD` सौंपता है जो एक ताज़ा bash का `$https_proxy` (या `$HTTPS_PROXY` जब केवल वही क्रेडेंशियल रखता है) प्रिंट करता है जब भी कोई `proxy_cmd` कॉन्फ़िगर नहीं होता, और इंस्टॉलर वही कमांड config.json में सहेजता है; अन्यथा: `pilotctl config --set proxy_cmd="bash -c 'printf %s \"\$https_proxy\"'"`। इसके बिना, जब यह विफल होने लगे तो डेमन को एक ताज़ा शेल से पुनः आरंभ करें।
- **ट्रांसपोर्ट और प्रॉक्सी के लिए प्राथमिकता**: कमांड-लाइन फ़्लैग, फिर `$PILOT_TRANSPORT` / `$PILOT_PROXY` / `$PILOT_PROXY_CMD`, फिर `config.json` (`transport`, `proxy`, `proxy_cmd`), फिर डिफ़ॉल्ट (pilotctl और इंस्टॉल किए गए systemd/launchd सेवाओं से `auto`, `PILOT_TRANSPORT_DEFAULT=auto` के माध्यम से; एक बेयर `pilot-daemon` के लिए `udp`; प्रॉक्सी `auto`)। `auto` कभी config.json में सहेजा नहीं जाता, इसलिए एक पुरानी रिलीज़ को पुनः इंस्टॉल करने (`--version`, `pilotctl update --pin`) पर ऐसा कुछ नहीं बचता जिसे यह पढ़ न सके; यदि आपने इसे स्वयं सहेजा है, तो दोनों इसे उस डेमन के लिए `udp` में फिर से लिख देते हैं जो इससे पहले का है। `-proxy` `auto`, `off` (साथ ही `none`, `direct`) या एक `http://` / `https://` URL स्वीकार करता है; इसके अलावा कुछ भी एक त्रुटि है। लूपबैक लक्ष्य (स्थानीय वेबहुक, साइडकार) कभी प्रॉक्सी को नहीं भेजे जाते। जब रजिस्ट्री डायल एक प्रॉक्सी के माध्यम से जाता है (compat, या किसी भी ट्रांसपोर्ट में एक स्पष्ट प्रॉक्सी URL), तो डिफ़ॉल्ट raw-TCP रजिस्ट्री को TLS के माध्यम से `registry.pilotprotocol.network:443` से बदल दिया जाता है, क्योंकि CONNECT प्रॉक्सी केवल पोर्ट 443 ले जाते हैं।
- **सैंडबॉक्स में कोई CA बंडल नहीं?** Go को `SSL_CERT_FILE=/path/to/ca-certificates.crt` (या `SSL_CERT_DIR`) के साथ एक की ओर इंगित करें — `pilotctl daemon start` दोनों को अग्रेषित करता है। इसके बजाय रजिस्ट्री को पिन किया जा सकता है: `PILOT_REGISTRY_FINGERPRINT=<sha256 of its certificate>` (या `pilotctl config --set registry_fingerprint=...`), जो `registry_trust=pinned` चुनता है। WSS बीकन में कोई फिंगरप्रिंट विकल्प नहीं है, इसलिए इसे CA बंडल की आवश्यकता है।
<details>
<summary><strong>इंस्टॉलर क्या करता है</strong></summary>
- आपके प्लेटफ़ॉर्म का पता लगाता है (linux/darwin, amd64/arm64)
- नवीनतम रिलीज़ से पूर्व-निर्मित बाइनरी डाउनलोड करता है (यदि Go उपलब्ध है तो स्रोत से बनाने पर वापस जाता है)
- `pilot-daemon`, `pilotctl`, और `pilot-updater` को `~/.pilot/bin` में इंस्टॉल करता है (रिलीज़ टारबॉल इन तीनों को भेजते हैं; गेटवे एक वैकल्पिक अतिरिक्त है, कोर इंस्टॉल का हिस्सा नहीं)
- आपके PATH में `~/.pilot/bin` जोड़ता है
- सार्वजनिक रेंडेज़वस सर्वर पूर्व-कॉन्फ़िगर के साथ `~/.pilot/config.json` लिखता है
- डेमन और ऑटो-अपडेटर के लिए सिस्टम सेवाएँ सेट करता है (**Linux**: systemd, **macOS**: launchd)
- ऑटो-अपडेटर पृष्ठभूमि में चलता है, हर घंटे नई रिलीज़ की जाँच करता है और अपडेट स्वचालित रूप से लागू करता है
**अनइंस्टॉल:** `curl -fsSL https://pilotprotocol.network/install.sh | sh -s uninstall`
**स्रोत से** (Go 1.25+ आवश्यक): `git clone https://github.com/pilot-protocol/pilotprotocol.git && cd pilotprotocol && make build`
</details>
---
## App Store
Pilot में स्थानीय IPC ऐप्स को इंस्टॉल और कॉल करने के लिए एक अंतर्निहित ऐप स्टोर शामिल है:
```bash
pilotctl appstore catalogue # browse available apps
pilotctl appstore view io.pilot.cosift # inspect before installing
```
---
[Read more](https://github.com/pilot-protocol/pilotprotocol)