cplt

AI कोडिंग एजेंट्स के लिए कर्नेल-प्रवर्तित सैंडबॉक्स। cplt GitHub Copilot CLI, OpenCode, Gemini CLI, Antigravity CLI, Pi, Claude Code, goose, DeepSeek Harness, या किसी भी शेल को रैप करता है, ताकि एजेंट कोड लिख सके लेकिन क्रेडेंशियल्स चुरा न सके, main पर push न कर सके, PRs merge न कर सके, या सीक्रेट्स exfiltrate न कर सके।

macOS: sandbox-exec के माध्यम से Apple Seatbelt/SBPL
Linux: Landlock LSM + seccomp-BPF + वैकल्पिक Bubblewrap namespace isolation (kernel 5.13+, 6.7+ पर पूर्ण नेटवर्क फ़िल्टरिंग)
Windows: कोई नेटिव समर्थन नहीं। कोई Windows सैंडबॉक्स बैकएंड नहीं है। cplt को WSL2 के अंदर चलाएँ, जहाँ यह एक सामान्य Linux इंस्टॉल है और Microsoft kernel Landlock प्रदान करता है। Windows (WSL2) setup देखें।

cplt banner

cplt क्यों?

AI एजेंट्स मनमाना कोड निष्पादित करते हैं। एक समझौता किया गया एजेंट, चाहे prompt injection, supply chain attack, या दुर्भावनापूर्ण MCP server के माध्यम से, ~/.ssh पढ़ सकता है, main पर push कर सकता है, PRs merge कर सकता है, या आपका कोड exfiltrate कर सकता है, जब तक कि OS स्वयं मना न करे।

cplt आपको टीम-कॉन्फ़िगर करने योग्य नीति के साथ कर्नेल-स्तरीय प्रवर्तन देता है:

.cplt.toml में प्रति-रेपो नीति, वर्जन कंट्रोल में कमिट की गई, इसलिए यह छेड़छाड़-रहित और ऑडिट करने योग्य है
क्रेडेंशियल्स, सीक्रेट्स, और संवेदनशील फ़ाइलों के लिए डिफ़ॉल्ट रूप से अस्वीकार
कमांड-स्तरीय git और gh इंटरसेप्शन: डिफ़ॉल्ट ब्रांच पर pushes, force pushes, merges, और releases अवरुद्ध हैं, feature branches खुली रहती हैं
ऑडिट लॉग के साथ आउटबाउंड नेटवर्क फ़िल्टरिंग
कोई Docker नहीं, कोई VMs नहीं। एक बाइनरी जो लॉक-डाउन लैपटॉप पर चलती है
डेवलपर्स के लिए ज़ीरो-कॉन्फ़िग शुरुआत, जब किसी बिल्ड को वास्तव में इसकी आवश्यकता हो तो escape hatches के साथ

विस्तृत दस्तावेज़: Configuration · Proxy & domain filtering · gh command guard · git command guard · Known impacts · Security details · Security model

त्वरित शुरुआत```bash

brew install navikt/tap/cplt # macOS. On Debian or Ubuntu, see apt below cplt --shell-install # make 'copilot' run sandboxed (persistent) # --agent opencode for any other agent cplt doctor # check your environment cplt -- -p "fix the tests" # run Copilot in sandbox

अन्य एजेंट और सैंडबॉक्स कमांड:```bash
cplt --agent opencode                       # OpenCode (Copilot subscription)
cplt --agent opencode --pass-env ANTHROPIC_API_KEY  # third-party provider
cplt --agent shell                          # interactive sandboxed shell (no AI)
cplt exec -- npm install                    # sandbox any command directly
cplt exec -c "npm install && npm test"      # compound commands in sandbox
alias npm="cplt exec -- npm"               # sandboxed npm for every invocation

टीम रोलआउट```bash

1. Generate per-repo policy

cplt init --write

2. Developers approve on first run

cplt trust accept --all

3. Tune the command guards (both block by default)

cplt config set git_guard.protect_default_branch_only false # block every push, not just main cplt config set git_guard.mode warn # observe instead of blocking

## यह क्या ब्लॉक करता है

सैंडबॉक्स कर्नेल में क्रेडेंशियल्स और सीक्रेट्स तक पहुँच को ब्लॉक करता है। कमांड गार्ड्स विनाशकारी ऑपरेशन्स को ब्लॉक करते हैं। हर प्रतिबंध एजेंट पर और उसके द्वारा स्पॉन किए गए हर प्रोसेस पर लागू होता है।

| संसाधन | स्थिति | नोट्स |
| --- | --- | --- |
| प्रोजेक्ट डायरेक्टरी पढ़ें/लिखें | ✅ अनुमत | |
| प्रोजेक्ट में `.env*`, `.pem`, `.key` पढ़ें/लिखें/हटाएँ | 🔒 कर्नेल-ब्लॉक्ड | सीक्रेट एक्सफिल्ट्रेशन और विनाश को रोकता है। `--allow-env-files` ओवरराइड करता है |
| `.git/hooks`, `.git/config`, `.gitmodules` लिखें | 🔒 कर्नेल-ब्लॉक्ड (macOS), ⚠️ Linux पर आंशिक | git hooks, hooksPath रीडायरेक्ट, सबमॉड्यूल हाईजैकिंग के ज़रिए पर्सिस्टेंस को रोकता है। **Linux:** Landlock किसी अनुमत ट्री के अंदर किसी सबपाथ को डिनाई नहीं कर सकता, इसलिए Landlock-only पाथ पर ये लिखने योग्य बने रहते हैं। `bwrap` `.git/hooks` को रीड-ओनली री-बाइंड करता है लेकिन जानबूझकर `.git/config` और `.gitmodules` को लिखने योग्य छोड़ देता है, इसलिए `core.hooksPath` एक पर्सिस्टेंस रूट बना रहता है, देखें [Linux limitations](https://github.com/navikt/cplt/blob/main/docs/security.md#linux)। **हर** लिखने योग्य रूट पर लागू होता है, प्रोजेक्ट और हर `allow.write` ग्रांट पर, जिसमें एक ग्रांटेड वर्कट्री या बेयर रेपो भी शामिल है जिसके असली hooks `<root>/.git` के बाहर रहते हैं |
| `/tmp`, `/var/folders` से एक्ज़ीक्यूट करें | 🔒 कर्नेल-ब्लॉक्ड | write-then-exec को रोकता है। scratch dir TMPDIR को एक सुरक्षित लोकेशन पर रीडायरेक्ट करता है, डिफ़ॉल्ट रूप से चालू |
| PATH-resolved bin/shim डायर्स लिखें (`~/.bun/bin`, `~/.deno/bin`, `$PNPM_HOME`, mise `shims/` और पूरा `installs/`) | 🔒 कर्नेल-ब्लॉक्ड (macOS), ⚠️ Linux पर mise आंशिक | आपके अगले *अनसैंडबॉक्स्ड* कमांड द्वारा PATH के ज़रिए रिज़ॉल्व होने वाली बाइनरी को ट्रोजन करने से रोकता है। इसी कारण `~/.cargo/bin` और `~/go/bin` हमेशा से रीड-ओनली रहे हैं। cplt के अंदर `bun install -g`, `deno install`, `pnpm add -g`, `mise install`, `mise upgrade`, `mise use -g` को तोड़ता है, जानबूझकर, और एक रेपो जो किसी अनइंस्टॉल्ड टूलचेन को पिन करता है अब बूटस्ट्रैप नहीं होता। प्रोजेक्ट-लोकल इंस्टॉल्स अप्रभावित रहते हैं। **Linux:** mise के दोनों `bwrap` रीड-ओनली ओवरले पर सवार होते हैं; बाकी नेटिव रूप से टिके रहते हैं। देखें [Global tool installs](https://github.com/navikt/cplt/blob/main/docs/known-impacts.md#global-tool-installs) |
| `~/Library/Caches` से एक्ज़ीक्यूट करें | 🔒 डिफ़ॉल्ट रूप से कर्नेल-ब्लॉक्ड | बाइनरी-ड्रॉप स्टेजिंग को रोकता है। Copilot नेटिव मॉड्यूल्स को एक कार्व-आउट के ज़रिए छूट दी गई है। `--allow-cache-exec <SUBDIR>` के साथ टार्गेटेड छूट जोड़ें, जैसे `ms-playwright` |
| `.vscode/tasks.json`, `launch.json` संशोधित करें | ⚠️ अनुमत, ज्ञात जोखिम | IDE ट्रस्ट बाउंड्री। उपायों के लिए देखें [SECURITY.md](https://github.com/navikt/cplt/blob/main/SECURITY.md) |
| `~/.copilot` पढ़ें/लिखें (auth, settings) | ✅ अनुमत | `keytar.node`, `pty.node`, `computer.node` के लिए `file-map-executable` शामिल है |
| `~/.copilot/pkg` लिखें (नेटिव मॉड्यूल्स) | 🔒 कर्नेल-ब्लॉक्ड | नेटिव मॉड्यूल रिप्लेसमेंट के ज़रिए पर्सिस्टेंस को रोकता है |
| एनवायरनमेंट वेरिएबल्स | 🔒 सैनिटाइज़्ड + हार्डन्ड | केवल एक सुरक्षित allowlist पास होती है। लाइफसाइकल स्क्रिप्ट्स ब्लॉक्ड। `--pass-env VAR` एक को वापस जोड़ता है |
| `~/.config/gh/hosts.yml` + `config.yml` पढ़ें | ✅ अनुमत (रीड-ओनली) | केवल ये दो फ़ाइलें। बाकी `.config/gh` ब्लॉक्ड है |
| `~/.config/mise` पढ़ें | ✅ अनुमत (रीड-ओनली) | टूल वर्ज़न और PATH, कोई सीक्रेट नहीं |
| `~/.gitconfig`, `~/.config/git/config` पढ़ें | ✅ अनुमत (रीड-ओनली) | एक dotfiles सिमलिंक को उसके टार्गेट तक फ़ॉलो किया जाता है, इसलिए एक stowed `~/.gitconfig` काम करता है |
| `~/.git-credentials` पढ़ें | 🔒 कर्नेल-ब्लॉक्ड | `credential.helper = store` क्लीयरटेक्स्ट टोकन यहाँ रखता है। कोई `--allow-read` इसे फिर से नहीं खोलता, जैसे `~/.netrc`। **Linux:** किसी *पूर्वज* (`$HOME` स्वयं) पर एक ग्रांट इसे अब भी उजागर करता है, क्योंकि Landlock किसी अनुमत ट्री के अंदर किसी सबपाथ को डिनाई नहीं कर सकता |
| ग्लोबल git hooks पढ़ें (`core.hooksPath`) | ✅ अनुमत (रीड-ओनली, राइट-डिनाइड) | ऑटो-डिटेक्टेड। `$HOME` के अंदर गहराई ≥3 के साथ होना चाहिए। राइट्स स्पष्ट रूप से ब्लॉक्ड हैं |
| कमिट/टैग साइनिंग (`commit.gpgsign`, `tag.gpgsign`) | 🔒 अक्षम | `~/.ssh` और `~/.gnupg` में प्राइवेट कीज़ ब्लॉक्ड हैं, इसलिए एक env var ओवरराइड के ज़रिए साइनिंग अक्षम है |
| `~/Library/Application Support/Microsoft` पढ़ें | ✅ अनुमत (रीड-ओनली) | टेलीमेट्री के लिए डिवाइस ID |
| macOS Keychain एक्सेस करें | ⚠️ अनुमत (read+write) उन एजेंट्स के लिए जो वहाँ auth स्टोर करते हैं | ग्रांट को एक आइटम तक सीमित नहीं किया जा सकता, इसलिए यह हर उस keychain एंट्री तक पहुँचता है जिसे एजेंट अनलॉक कर सकता है। `sandbox.keychain_substitute` (EXPERIMENTAL, डिफ़ॉल्ट रूप से बंद) को ऑप्ट इन करें ताकि उन रन्स पर इसे हटाया जा सके जहाँ एजेंट इसके बिना ऑथेंटिकेट कर सकता है — Claude Code के लिए `CLAUDE_CODE_OAUTH_TOKEN`, Antigravity के लिए एक मौजूदा फ़ॉलबैक टोकन फ़ाइल। देखें [SECURITY.md](https://github.com/navikt/cplt/blob/main/SECURITY.md#keychain-access-is-all-or-nothing) |
| आउटबाउंड नेटवर्क (पोर्ट 443) | ✅ अनुमत | हर अन्य पोर्ट ब्लॉक्ड है। `--allow-port` के साथ अतिरिक्त जोड़ें |
| Localhost आउटबाउंड | 🔒 कर्नेल-ब्लॉक्ड (macOS), ⚠️ Linux पर पोर्ट-आधारित | लोकल सर्विस एक्सेस को रोकता है। प्रॉक्सी के लिए इनबाउंड अब भी काम करता है। **Linux:** Landlock नियम केवल पोर्ट नंबर हैं और `localhost:443` को `remote:443` से अलग नहीं बता सकते, इसलिए किसी अनुमत पोर्ट पर एक लोकल सर्विस पहुँच योग्य है और कोई localhost-विशिष्ट डिनाई नहीं है। SSRF सुरक्षा के लिए `--with-proxy` का उपयोग करें, देखें [Linux limitations](https://github.com/navikt/cplt/blob/main/docs/security.md#linux) |
| SSH agent (unix socket) | 🔒 कर्नेल-ब्लॉक्ड (macOS), ⚠️ Linux पर केवल env | git ऑपरेशन्स या होस्ट्स को SSH साइन करने से रोकता है। **Linux:** unix socket `connect()` गेटेड नहीं है, इसलिए रोका गया `SSH_AUTH_SOCK` ही एकमात्र बाधा है और एक एजेंट जो इसे स्वयं सेट करता है, लोडेड कीज़ का उपयोग कर सकता है। `bwrap` स्टॉक OpenSSH सॉकेट को `/tmp` के नीचे छिपा देता है, लेकिन `$XDG_RUNTIME_DIR` के नीचे gnome-keyring/gcr या systemd एजेंट को नहीं। देखें [Linux limitations](https://github.com/navikt/cplt/blob/main/docs/security.md#linux) |
| डेवलपर टूल्स (`~/.cargo`, `~/.gradle`, `~/.m2`, `~/.sdkman`, `~/.jenv`, `~/.pyenv`, `~/.konan`, आदि) | ✅ अनुमत (कैशेज़ के लिए read+write) | केवल वे डायर्स जो डिस्क पर मौजूद हैं। रनटाइम पर `cplt doctor` जो डिटेक्ट करता है उसके अनुसार कसा जाता है |
| रजिस्ट्री क्रेडेंशियल फ़ाइलें (`~/.m2/settings.xml`, `~/.gradle/gradle.properties`, `~/.cargo/credentials`) | 🔒 macOS पर कर्नेल-ब्लॉक्ड। Linux पर पैरेंट टूल डायर पठनीय बना रहता है | `--allow-read` के साथ ओवरराइड करें। देखें [Private registries](https://github.com/navikt/cplt/blob/main/docs/known-impacts.md#private-registries) |
| `~/.npmrc` पढ़ें | 🔒 कर्नेल-ब्लॉक्ड (दोनों प्लेटफ़ॉर्म) | `--allow-read` के साथ ओवरराइड करें। yarn 1 को तोड़ता है, देखें [yarn 1](https://github.com/navikt/cplt/blob/main/docs/known-impacts.md#yarn-1-and-unreadable-home-rc-files) |
| Go सोर्स कोड (`~/go/src`) | 🔒 कर्नेल-ब्लॉक्ड | केवल `~/go/bin` और `~/go/pkg` पठनीय हैं |
| `~/.ssh`, `~/.gnupg`, `~/.aws`, `~/.azure` पढ़ें | 🔒 कर्नेल-ब्लॉक्ड | |
| `~/.kube`, `~/.docker`, `~/.nais` पढ़ें | 🔒 कर्नेल-ब्लॉक्ड | |
| `~/.password-store`, `~/.terraform.d` पढ़ें | 🔒 कर्नेल-ब्लॉक्ड | |
| `~/.config/gcloud`, `~/.config/op` पढ़ें | 🔒 कर्नेल-ब्लॉक्ड | व्यक्तिगत फ़ाइलें `--allow-read` के साथ ओवरराइड करने योग्य हैं। देखें [Cloud credentials](https://github.com/navikt/cplt/blob/main/docs/known-impacts.md#cloud-credential-directories) |
| `~/.config/cplt`, `~/.nav-pilot` पढ़ें या लिखें | 🔒 कर्नेल-ब्लॉक्ड | टूल स्टेट जो तय करती है कि *अगला* लॉन्च क्या कर सकता है। `~/.config/cplt` एक पूरे सबट्री के रूप में अन-ओवरराइडेबल है; `~/.nav-pilot` के अंदर, एक नामित पाथ ग्रांटेबल बना रहता है ताकि एक पिन्ड agentpakke पेलोड पढ़ा जा सके |
| `~/.netrc`, `~/.pypirc`, `~/.vault-token` पढ़ें | 🔒 कर्नेल-ब्लॉक्ड | दोनों प्लेटफ़ॉर्म पर अन-ओवरराइडेबल। `allow.read` में इनमें से किसी एक को नाम देना एक स्टार्टअप एरर है |
| `~/.gem/credentials` पढ़ें | 🔒 कर्नेल-ब्लॉक्ड | दोनों प्लेटफ़ॉर्म पर अन-ओवरराइडेबल। `allow.read` में इनमें से किसी एक को नाम देना एक स्टार्टअप एरर है |
| `gh` CLI विनाशकारी ऑपरेशन्स (merge, delete, release) | 🔒 कमांड-गेटेड (डिफ़ॉल्ट रूप से चालू) | `--no-gh-guard` के साथ ऑप्ट आउट करें। देखें [gh guard](https://github.com/navikt/cplt/blob/main/docs/gh-guard.md) |
| डिफ़ॉल्ट ब्रांच पर `git push` | 🔒 कमांड-गेटेड (डिफ़ॉल्ट रूप से चालू) | `main`/`master` पर पुश को ब्लॉक करता है; फ़ीचर-ब्रांच पुश अब भी काम करते हैं। `protect_default_branch_only = false` हर पुश को ब्लॉक करता है, `git_guard.mode = "warn"` केवल चेतावनी देता है, `--no-git-guard` ऑप्ट आउट करता है |
| चाइल्ड प्रोसेस इनहेरिटेंस | ✅ सभी प्रतिबंध सबप्रोसेसेज़ पर लागू होते हैं | |

यह तालिका एक सारांश है। सैंडबॉक्स सिस्टम फ़ाइलों (SSL certs, `/etc/hosts`), टेम्प डायरेक्टरीज़ (पढ़ें और लिखें, कोई exec नहीं), और सिस्टम टूल पाथ्स (`/usr/bin`, `/opt/homebrew`) तक पहुँच की भी अनुमति देता है। पूर्ण SBPL नियमों के लिए `cplt --print-profile` चलाएँ।

पूर्ण सुरक्षा मॉडल, थ्रेट विश्लेषण, और टेस्ट रणनीति के लिए, [SECURITY.md](https://github.com/navikt/cplt/blob/main/SECURITY.md) पढ़ें।

## cplt की तुलना

### Codex CLI का सैंडबॉक्स

| क्षेत्र | cplt | Codex CLI सैंडबॉक्स |
| --- | --- | --- |
| आउटबाउंड नेटवर्क नियंत्रण | डोमेन allow/block लिस्ट्स के साथ CONNECT प्रॉक्सी | कोई डोमेन-स्तरीय फ़िल्टरिंग नहीं |
| एनवायरनमेंट हैंडलिंग | Allowlist प्लस हार्डनिंग env इंजेक्शन | अधिक बेसिक पास-थ्रू मॉडल |
| सीक्रेट फ़ाइल सुरक्षा | रेपो के अंदर `.env*`, `.pem`, `.key` जैसे डिनाई पैटर्न | मुख्य रूप से डायरेक्टरी-स्कोप्ड एक्सेस |
| रेपो पॉलिसी | एक स्पष्ट ट्रस्ट/अप्रूवल फ़्लो के साथ [`.cplt.toml`](https://github.com/navikt/cplt/blob/main/docs/configuration.md#per-repo-configuration-cplttoml) | कोई रेपो-स्तरीय पॉलिसी फ़ाइल नहीं |
| एजेंट सपोर्ट | Copilot, OpenCode, Gemini CLI, Antigravity CLI, Pi, Claude Code, goose, DeepSeek Harness, या shell | केवल Codex |

cplt हर जगह मज़बूत नहीं है। Codex CLI के पास आज Linux namespace आइसोलेशन है, और यह पहले से ही read-only और workspace-write जैसे स्पष्ट सैंडबॉक्स मोड्स उजागर करता है। cplt के पास अभी वह मोड मैट्रिक्स नहीं है।

### Docker-आधारित सैंडबॉक्स

| क्षेत्र | cplt | Docker-आधारित सैंडबॉक्स |
| --- | --- | --- |
| स्टार्टअप समय | सामान्य CLI उपयोग के लिए लगभग तत्काल | आमतौर पर धीमा कंटेनर स्टार्टअप |
| नेटवर्क नियंत्रण | प्रॉक्सी के ज़रिए प्रति-रिक्वेस्ट आउटबाउंड फ़िल्टरिंग | आमतौर पर ऑल-ऑर-नथिंग नेटवर्क एक्सेस |
| फ़ाइल नियंत्रण | प्रति-पाथ और प्रति-पैटर्न नियम | प्रति-माउंट नियंत्रण |
| होस्ट आवश्यकताएँ | सिंगल बाइनरी | Docker डेमन आवश्यक |
| कॉर्पोरेट लैपटॉप फ़िट | वहाँ काम करता है जहाँ Docker अनुपलब्ध या प्रतिबंधित है | अक्सर लोकल पॉलिसी द्वारा ब्लॉक्ड |

Docker अब भी कुछ एनवायरनमेंट्स में आपको मज़बूत आइसोलेशन देता है, ख़ासकर अगर आप एक पूरी तरह से अलग फ़ाइलसिस्टम और प्रोसेस नेमस्पेस चाहते हैं। cplt उसके बदले हल्के सेटअप और उस मशीन के साथ गहरे इंटीग्रेशन का सौदा करता है जिस पर आप पहले से डेवलप करते हैं।

### VS Code agent mode अनुमतियाँ

VS Code agent mode जैसे टूल्स मुख्य रूप से UI अनुमतियों पर निर्भर करते हैं। cplt अपने प्रतिबंधों को कर्नेल में लागू करता है, इसलिए एजेंट किसी प्रॉम्प्ट या संशोधित निर्देश के ज़रिए उनके चारों ओर से निकल नहीं सकता। यह CLI एजेंट्स और क्रेडेंशियल एक्सपोज़र के लिए सबसे अधिक मायने रखता है:

- cplt IDE के बाहर काम करता है
- एजेंट शुरू होने से पहले env vars फ़िल्टर किए जाते हैं
- संवेदनशील फ़ाइलें ब्लॉक की जा सकती हैं भले ही वे रेपो के अंदर हों
- वही प्रतिबंध चाइल्ड प्रोसेसेज़ पर लागू होते हैं

### Claude Code का सैंडबॉक्स (Anthropic Sandbox Runtime)

[Anthropic Sandbox Runtime](https://github.com/anthropic-experimental/sandbox-runtime) (`srt`) वह सैंडबॉक्सिंग लेयर है जिसका उपयोग Claude Code करता है। cplt के समान उच्च-स्तरीय दृष्टिकोण, macOS Seatbelt प्लस कर्नेल-स्तरीय Linux एन्फ़ोर्समेंट प्लस एक HTTP प्रॉक्सी, अलग इम्प्लीमेंटेशन।

| क्षेत्र | cplt | Anthropic srt |
| --- | --- | --- |
| भाषा / डिलीवरी | सिंगल Rust बाइनरी | Node.js + npm पैकेज + बाहरी deps |
| Linux बैकएंड | Landlock LSM (कोई deps नहीं, कोई namespaces नहीं) | bubblewrap (user namespaces के ज़रिए कंटेनर) |
| एनवायरनमेंट फ़िल्टरिंग | सख़्त allowlist + suffix-deny (`_TOKEN`, `_SECRET`) | पूरा पैरेंट env इनहेरिट करता है (सीक्रेट्स पास हो जाते हैं) |
| क्रेडेंशियल डायर सुरक्षा | डिफ़ॉल्ट रूप से 15+ डायर्स डिनाइड | उपयोगकर्ता को मैन्युअल रूप से कॉन्फ़िगर करना होगा |
| DNS रीबाइंडिंग सुरक्षा | ✅ पोस्ट-DNS IP को प्राइवेट रेंजेज़ के विरुद्ध जाँचा जाता है | ❌ लागू नहीं |
| नेटवर्क प्रॉक्सी | HTTP CONNECT + डोमेन allow/block | HTTP + SOCKS5 + प्रयोगात्मक TLS MITM |
| SSH git | macOS पर कर्नेल पर ब्लॉक्ड (agent socket डिनाइड); Linux पर केवल `SSH_AUTH_SOCK` रोका जाता है | SOCKS5 के ज़रिए प्रॉक्सीड |
| पैकेज मैनेजर स्क्रिप्ट्स | डिफ़ॉल्ट रूप से ब्लॉक्ड (`npm_config_ignore_scripts`) | ब्लॉक्ड नहीं |
| एजेंट सपोर्ट | Copilot, OpenCode, Gemini, Antigravity, Pi, Claude Code, goose, DSH, Shell | Claude Code |
| कॉन्फ़िग | TOML (ग्लोबल + प्रति-रेपो) | JSON (केवल ग्लोबल) + `--control-fd` लाइव अपडेट्स |
| लाइब्रेरी API | ❌ केवल बाइनरी | ✅ एम्बेडेबल TypeScript लाइब्रेरी |

cplt आउट-ऑफ़-द-बॉक्स अधिक सुरक्षित है: env फ़िल्टरिंग, क्रेडेंशियल सुरक्षा, DNS रीबाइंडिंग जाँच, लाइफसाइकल स्क्रिप्ट ब्लॉकिंग। srt अधिक लचीला है: SOCKS5, TLS इंस्पेक्शन, प्रति-रिक्वेस्ट कॉलबैक्स, लाइब्रेरी एम्बेडिंग। Linux बैकएंड का चुनाव मायने रखता है। bwrap को Ubuntu 24.04+ पर AppArmor userns प्रतिबंधों की वजह से वर्कअराउंड्स की ज़रूरत होती है, जबकि Landlock को कर्नेल 5.13 या नया चाहिए लेकिन शून्य बाहरी निर्भरताएँ हैं।

### GitHub Copilot CLI का अपना सैंडबॉक्स

Copilot CLI जून 2026 से एक लोकल सैंडबॉक्स के साथ शिप हो रहा है, जो
मानक सीट में शामिल है। यह Microsoft MXC के ज़रिए shell कमांड्स चलाता है, प्रतिबंधित
फ़ाइलसिस्टम, नेटवर्क और सिस्टम एक्सेस के साथ, macOS, Linux और Windows पर।
`/sandbox enable` इसे चालू करता है।

अगर वह आपके लिए पर्याप्त है, तो उसका उपयोग करें। इसमें कोई अतिरिक्त खर्च नहीं है, और यह Windows पर
चलता है, जो cplt नहीं करता।

यह दो चीज़ें नहीं करता।

पॉलिसी एडमिनिस्ट्रेटर के पास रहती है, रेपो के पास नहीं। एंटरप्राइज़ेज़
Intune या किसी अन्य MDM के ज़रिए सैंडबॉक्स पॉलिसी सेट करते हैं। कोड के बग़ल में कुछ नहीं बैठता,
इसलिए एक रेपो के लिए मायने रखने वाला नियम किसी कंट्रीब्यूटर तक, CI तक, या उस लैपटॉप तक
नहीं पहुँच सकता जिसे MDM मैनेज नहीं करता। cplt में पॉलिसी रेपो में
`.cplt.toml` है। रिव्यूअर्स पुल
रिक्वेस्ट में इसके बदलाव देखते हैं, और यह फ़ाइल डेवलपर के अपने कॉन्फ़िगरेशन को कस सकती है लेकिन कभी ढीला नहीं कर सकती।

यह प्रोसेस को सीमित करता है, न कि प्रोसेस उन क्रेडेंशियल्स के साथ क्या करती है जो उसके पास हैं। `/sandbox` टैब्स
फ़ाइलसिस्टम, नेटवर्क और सिस्टम
क्षमताओं को कवर करते हैं, और एक Git रेपो के अंदर एजेंट को डिफ़ॉल्ट रूप से `.git` पर पढ़ने और लिखने की अनुमति दी जाती है। एक सैंडबॉक्स्ड एजेंट के पास अब भी आपका `gh` टोकन और आपकी
पुश एक्सेस है। एक ब्रांच पुश करना, एक पुल रिक्वेस्ट मर्ज करना और एक
रेपो हटाना सभी एक अधिकृत क्लाइंट से वेल-फ़ॉर्म्ड API कॉल्स हैं, और एक
फ़ाइलसिस्टम या नेटवर्क नियम की उनके बारे में कोई राय नहीं होती। cplt इसके बजाय `git` और
`gh` को रैप करता है। एजेंट स्वतंत्र रूप से कमिट, ब्रांच और रीबेस करता है। `gh pr merge`,
`gh repo delete` और `gh release create` डिफ़ॉल्ट रूप से ब्लॉक्ड हैं। `main`/`master` पर
`git push` भी ऐसा ही है; फ़ीचर-ब्रांच पुश अब भी काम करते हैं, क्योंकि
`protect_default_branch_only` चालू है। हर पुश को ब्लॉक करने के लिए इसे `false` पर सेट करें, या
केवल चेतावनी देने के लिए `git_guard.mode = "warn"`।

दोनों को चलाना उचित है। MXC प्रोसेस को सीमित करता है। गार्ड्स तय करते हैं कि
एजेंट उन क्रेडेंशियल्स के साथ क्या कर सकता है जो उसके पास हैं।

### ईमानदार कमियाँ

- macOS के पास आज सबसे मज़बूत फ़ाइल-स्तरीय एन्फ़ोर्समेंट है। Linux कवरेज बेहतर हो रही है लेकिन समान नहीं है।
- cplt अभी सरल read-only / workspace-write / full-access पॉलिसी प्रीसेट्स प्रदान नहीं करता।
- अगर आप पूर्ण कंटेनर आइसोलेशन चाहते हैं, तो cplt Docker को बदलने की कोशिश नहीं कर रहा है।

## इंस्टॉल

### Homebrew (अनुशंसित)```bash
brew install navikt/tap/cplt

mise```bash

mise use -g 'github:navikt/cplt@'

mise आपके प्लेटफ़ॉर्म के लिए सही रिलीज़ एसेट चुनता है और इसके बिल्ड
प्रोवेनेंस अटेस्टेशन को सत्यापित करता है।

वर्शन पिन करें। हमारे वर्शन स्ट्रिंग्स तुलनीय semver नहीं हैं — उनमें
अग्रणी शून्य और दो हाइफ़न होते हैं — इसलिए `mise latest` नवीनतम की तुलना में
पुराने रिलीज़ को रिज़ॉल्व कर सकता है ([navikt/copilot#818](https://github.com/navikt/copilot/issues/818))।

### apt (Debian/Ubuntu, Linux पर अनुशंसित)

[navikt/apt](https://navikt.github.io/apt/) एक हस्ताक्षरित आर्काइव है जो
GitHub Pages पर सर्व किया जाता है, जिसमें amd64 और arm64 के लिए cplt और nav-pilot शामिल हैं:```bash
curl -fsSL https://navikt.github.io/apt/keyring/navikt-archive-keyring.gpg \
  | sudo tee /usr/share/keyrings/navikt-archive-keyring.gpg >/dev/null
echo "deb [signed-by=/usr/share/keyrings/navikt-archive-keyring.gpg] https://navikt.github.io/apt stable main" \
  | sudo tee /etc/apt/sources.list.d/navikt.list
sudo apt update && sudo apt install cplt

यह एक सादा apt रिपॉज़िटरी है जो हमारी रिलीज़ को मिरर करती है, न कि अपने स्वयं के मेंटेनर वाला डिस्ट्रिब्यूशन पैकेज। इसका पब्लिश जॉब हर घंटे चलता है और प्रत्येक टूल की नवीनतम रिलीज़ से सबसे नया .deb खींचता है, इसलिए कुछ मिनट पहले कटी रिलीज़ को उस तरीके से इंस्टॉल-योग्य होने में एक घंटे तक लग सकता है।

पैकेज बाइनरी को /usr/bin/cplt पर रखता है, और उसके बाद अपग्रेड sudo apt upgrade से होते हैं। cplt update apt इंस्टॉल को छूने से इंकार करता है और इसके बजाय sudo apt upgrade की ओर इशारा करता है: dpkg की पीठ पीछे बाइनरी को बदलना अगले apt रन द्वारा पूर्ववत कर दिया जाएगा।

आर्काइव के बिना, वही .deb एक रिलीज़ एसेट है:```bash arch=$(dpkg --print-architecture) # amd64 or arm64 gh release download --repo navikt/cplt --pattern "${arch}.deb" sudo apt install ./cplt_"${arch}".deb

### curl | bash

उन वितरणों के लिए जो Debian डेरिवेटिव नहीं हैं, और CI के लिए:```bash
curl -fsSL https://raw.githubusercontent.com/navikt/cplt/main/install.sh | bash

विकल्प:```bash

Install a specific version

curl -fsSL ... | bash -s -- --version 2026.05.05-174753-75bae5b

Install to a custom directory

curl -fsSL ... | bash -s -- --dir ~/.local/bin

Skip Homebrew (force direct download)

curl -fsSL ... | bash -s -- --no-brew

### रिलीज़ से डाउनलोड करें

अपने प्लेटफ़ॉर्म के लिए नवीनतम बिल्ड [GitHub Releases](https://github.com/navikt/cplt/releases/latest) से प्राप्त करें:```bash
# macOS, Apple Silicon (M1/M2/M3/M4)
curl -fsSL https://github.com/navikt/cplt/releases/latest/download/cplt-aarch64-apple-darwin.tar.gz | tar xz
sudo mv cplt /usr/local/bin/

# macOS, Intel
curl -fsSL https://github.com/navikt/cplt/releases/latest/download/cplt-x86_64-apple-darwin.tar.gz | tar xz
sudo mv cplt /usr/local/bin/

# Linux, x86_64
curl -fsSL https://github.com/navikt/cplt/releases/latest/download/cplt-x86_64-unknown-linux-gnu.tar.gz | tar xz
sudo mv cplt /usr/local/bin/

# Linux, ARM64
curl -fsSL https://github.com/navikt/cplt/releases/latest/download/cplt-aarch64-unknown-linux-gnu.tar.gz | tar xz
sudo mv cplt /usr/local/bin/

प्रत्येक रिलीज़ बाइनरी में एक बिल्ड प्रोवेनेंस अटेस्टेशन होता है। इसे सत्यापित करें:```bash gh attestation verify cplt -o navikt

### स्रोत से बनाएं```bash
git clone https://github.com/navikt/cplt.git && cd cplt
cargo build --release
sudo cp target/release/cplt /usr/local/bin/

या mise के साथ:```bash mise run install

`mise run install` और मैन्युअल बिल्ड cplt को `/usr/local/bin/cplt` में रखते हैं। यदि आपके पास `/opt/homebrew/bin/cplt` पर Homebrew बिल्ड भी है, तो `PATH` में `/usr/local/bin` को पहले रखें ताकि आपका डेवलपमेंट बिल्ड जीत जाए:```bash
# Check which cplt is active
which cplt

# If it shows /opt/homebrew/bin/cplt, reorder your PATH:
export PATH="/usr/local/bin:$PATH"

या फिर सीधे /usr/local/bin/cplt चलाएँ और PATH रिज़ॉल्यूशन को पूरी तरह छोड़ दें।

Windows (WSL2)

cplt का कोई Windows सैंडबॉक्स बैकएंड नहीं है। एनफोर्समेंट macOS पर Apple Seatbelt और Linux पर Landlock LSM है, इसलिए Windows पर मूल रूप से चलाने के लिए कुछ नहीं है। समर्थित रास्ता WSL2 है, जहाँ cplt एक सामान्य Linux इंस्टॉल है और सैंडबॉक्स कर्नेल-एनफोर्स्ड है। Microsoft की प्रत्येक कर्नेल शाखा CONFIG_SECURITY_LANDLOCK=y बनाती है और CONFIG_LSM में landlock को पहले सूचीबद्ध करती है (config-wsl), जो कर्नेल 5.15.57.1 से शिप किया गया है, और WSL की डिफ़ॉल्ट कर्नेल कमांड लाइन कोई lsm= ओवरराइड सेट नहीं करती है।

PowerShell में, एक बार:```powershell wsl --install # WSL2 + the default distro (now Ubuntu 26.04 LTS), then reboot wsl --install -d Ubuntu-24.04 # ...or pin an older release wsl --update # keep the Microsoft kernel current, see the ABI note below

Everything नीचे **distro के अंदर** चलता है (`wsl`, या Windows Terminal में Ubuntu profile), PowerShell में नहीं:```bash
# 1. Node. Copilot CLI requires Node 22+
#    Ubuntu 26.04 ships 22.x, so apt is enough:
sudo apt update && sudo apt install -y nodejs npm
#    Ubuntu 24.04 ships Node 18, too old. Use nvm, fnm, or NodeSource there instead.

# 2. GitHub CLI, and log in. Ubuntu's universe package works but lags
#    (2.45 on 24.04); add GitHub's apt repo if you want a current gh:
#    https://github.com/cli/cli/blob/trunk/docs/install_linux.md
sudo apt install -y gh
gh auth login

# 3. The agent, installed in the distro, never on the Windows side
npm install -g @github/copilot

# 4. cplt, from the apt archive. The default distro is Ubuntu, so this is
#    the same route as on any other Debian derivative.
curl -fsSL https://navikt.github.io/apt/keyring/navikt-archive-keyring.gpg \
  | sudo tee /usr/share/keyrings/navikt-archive-keyring.gpg >/dev/null
echo "deb [signed-by=/usr/share/keyrings/navikt-archive-keyring.gpg] https://navikt.github.io/apt stable main" \
  | sudo tee /etc/apt/sources.list.d/navikt.list
sudo apt update && sudo apt install cplt

# 5. Check the result
cplt doctor

Windows साइड पर Copilot CLI इंस्टॉल न करें। interop चालू होने पर (जो डिफ़ॉल्ट है), Windows का PATH distro के PATH में जोड़ दिया जाता है, इसलिए Windows साइड पर npm install -g @github/copilot चलाने पर वह distro के अंदर /mnt/c/Users/<user>/AppData/Roaming/npm/copilot के रूप में दिखाई देता है। यह interop के ज़रिए पहुँचा गया Windows इंस्टॉल है। यह Linux sandbox में नहीं चल सकता, और npm shim ऐसे node को exec करता है जो distro में तब तक नहीं होगा जब तक आपने वहाँ भी एक इंस्टॉल न किया हो। पहले लक्षण एक असंबंधित runtime-extraction error था। अब cplt उस समय कारण बताता है जब वह /mnt/<drive>/ के अंतर्गत किसी agent को resolve करता है और वह WSL के अंतर्गत चल रहा हो, और cplt doctor इसे पास होने के बजाय एक failing check के रूप में रिपोर्ट करता है (#188)। WSL का पता kernel-owned state से लगाया जाता है, या तो /run/WSL से या /proc/sys/kernel/osrelease और /proc/version में kernel नाम से, न कि WSL_DISTRO_NAME से, जो sudo के अंतर्गत और systemd units में अनुपस्थित रहता है और जिसे कोई भी process सेट कर सकता है। साधारण Linux बॉक्स पर को छोड़ दिया जाता है। वहाँ यह एक सामान्य mount point है।

उस check की दो सीमाएँ हैं, दोनों जानबूझकर। यह डिफ़ॉल्ट automount root पर key करता है, इसलिए यदि आपने इसे स्थानांतरित किया है (/etc/wsl.conf में [automount] root), तो Windows-साइड इंस्टॉल पहचाना नहीं जाता और आपको पुरानी, कम सहायक विफलता मिलती है जिसमें path शामिल होता है। और interop बंद करने से Windows का PATH लीक होना रुक जाता है लेकिन /mnt/c unmount नहीं होता।

Kernel और Landlock ABI. वर्तमान WSL (2.7.x और बाद के) Linux 6.18 के साथ आता है, जो Landlock ABI 7 देता है — cplt जो कुछ भी उपयोग करता है वह सब इसके अलावा unix-socket connect() right, जिसके लिए ABI 9 (kernel 7.1) चाहिए। 6.6 kernel लाइन पर अभी भी मौजूद इंस्टॉल को ABI 3 मिलता है: filesystem rules लागू होते हैं, लेकिन TCP port rules (ABI 4), ioctl restriction (ABI 5) और signal/abstract-socket scoping (ABI 6) उपलब्ध नहीं हैं, और network filtering CONNECT proxy पर वापस चला जाता है। wsl --update आपको आगे बढ़ाता है। cplt doctor kernel संस्करण और पाया गया ABI प्रिंट करता है, जो आपकी मशीन पर मायने रखने वाला check है।

.wslconfig में Landlock अक्षम न करें। [wsl2] kernelCommandLine में lsm= सूची जो landlock को छोड़ देती है, या कस्टम [wsl2] kernel= जो CONFIG_SECURITY_LANDLOCK के बिना बनाया गया है, उस kernel enforcement को हटा देता है जिस पर cplt निर्भर करता है, और cplt doctor Landlock को अनुपलब्ध रिपोर्ट करेगा।

प्रोजेक्ट को Linux filesystem में रखें। /mnt/c/Users/... के बजाय distro के अंदर ~/src/... में काम करें। Microsoft का अपना मार्गदर्शन यह है कि cross-OS file access उल्लेखनीय रूप से धीमा है, और WSL 2.9.x से /mnt/c डिफ़ॉल्ट रूप से 9p के ज़रिए serve किया जाता है (virtiofs [wsl2] virtiofs=true के ज़रिए opt-in है)। और भी महत्वपूर्ण बात, हमने सत्यापित नहीं किया है कि Landlock उस mount पर rules कैसे लागू करता है। kernel network- या FUSE-backed filesystems के लिए कोई exclusion प्रलेखित नहीं करता, केवल pipes, sockets और nsfs, और Landlock का अपना test suite 9p और FUSE को exercise करता है, इसलिए हमें उम्मीद है कि यह काम करेगा। यहाँ किसी ने इसकी पुष्टि नहीं की है। /mnt/c के अंतर्गत किसी प्रोजेक्ट को समर्थित मानने के बजाय unproven मानें।

Bubblewrap. Ubuntu 23.10+ kernel.apparmor_restrict_unprivileged_userns के ज़रिए unprivileged user namespaces को ब्लॉक करता है, जो bwrap को तोड़ देता है। वह sysctl एक Ubuntu kernel patch से आता है जो Microsoft kernel में अनुपस्थित है, इसलिए वैकल्पिक Bubblewrap layer के Ubuntu-under-WSL2 पर काम करने की उम्मीद है। यह kernel source से अनुमान है, ऐसा कुछ नहीं जो हमने चलाया हो। यदि bwrap वहाँ विफल होता है, तो कृपया #189 में बताएं। cplt का अपना seccomp filter एक सादा PR_SET_SECCOMP BPF प्रोग्राम है, जो WSL द्वारा हर process में इंस्टॉल किए गए filter के ऊपर stack होता है।

अभी तक वास्तविक WSL2 इंस्टॉल पर सत्यापित नहीं। Source से सत्यापित: Landlock Microsoft kernel पर compile किया गया है और CONFIG_LSM में पहले स्थान पर है; /mnt/<drive>/ detection, इसके द्वारा उपयोग किए जाने वाले WSL signals, और उनका error text; कि cplt doctor ऐसे agent पर विफल होता है और kernel + Landlock ABI प्रिंट करता है; 5.13+/6.7+ आवश्यकताएँ; और यह कि install.sh Linux release binary इंस्टॉल करता है। यहाँ किसी ने भी अभी तक सत्यापित नहीं किया: /mnt/c पर Landlock कैसे व्यवहार करता है, WSL2 के अंतर्गत Bubblewrap काम करता है या नहीं, आपका distro release कौन से सटीक package संस्करण भेजता है, और उपरोक्त क्रम end to end। यदि आप इसे चलाते हैं, तो कृपया #189 में रिपोर्ट करें कि वास्तव में क्या हुआ।

Shell setup (अनुशंसित)

डिफ़ॉल्ट रूप से आप cplt टाइप करके sandbox प्राप्त करते हैं। सादे copilot को भी sandboxed चलाने के लिए:```bash cplt --shell-install

यह आपके shell का पता लगाता है, alias को आपकी rc फ़ाइल में जोड़ता है, और जो किया वह प्रिंट करता है। इसे जितनी बार चाहें चलाएँ, यह डुप्लिकेट नहीं जोड़ेगा।

`--agent` चुनता है कि किस command को alias मिलेगा, और cplt जिस भी agent को लॉन्च कर सकता है वह उपलब्ध है:```bash
cplt --shell-install --agent opencode   # 'opencode' runs sandboxed
cplt --shell-install --agent claude     # and 'claude', alongside the others

हर इंस्टॉल आपकी rc फ़ाइल में जोड़ता है, वहाँ जो पहले से है उसे बदलने के बजाय, इसलिए आप जितने भी एजेंट उपयोग करते हैं उतने सैंडबॉक्स कर सकते हैं। --agent के बिना आपको copilot मिलता है, जो वही है जो यह फ़्लैग हमेशा से इंस्टॉल करता आया है।

--agent antigravity antigravity और agy दोनों के लिए aliases इंस्टॉल करता है, क्योंकि दोनों नामों में से कोई भी एक ही एजेंट शुरू करता है।

सक्रिय करने के लिए अपना shell रीस्टार्ट करें या फ़ाइल को source करें।

--agent shell के लिए कोई alias नहीं है: shadow करने के लिए कोई shell बाइनरी नहीं है। सैंडबॉक्स्ड shell के लिए cplt --agent shell टाइप करें, या एकल कमांड के लिए cplt exec -- <command>।

मैन्युअल सेटअप (विकल्प)

यदि आप --shell-install का उपयोग नहीं करना चाहते, तो पंक्ति स्वयं जोड़ें:```bash

zsh / bash

eval "$(cplt --shell-setup --agent opencode)"

fish

alias opencode 'cplt --agent opencode'

वही पैटर्न जो mise, direnv, और starship उपयोग करते हैं।
</details>

**प्रत्येक alias अपने agent को क्यों नाम देता है।** `alias opencode=cplt` वह नहीं करेगा जो देखने में लगता है। सादा `cplt` अपने agent को `--agent` से चुनता है, फिर config फ़ाइल से, फिर PATH में जो मिले उससे — और PATH detection `copilot` को प्राथमिकता देता है। `opencode` टाइप करने पर इसके बजाय Copilot sandbox हो जाएगा, और स्क्रीन पर कुछ भी यह नहीं बताएगा। alias `--agent` पास करता है ताकि जो command आप टाइप करें वही agent आपको मिले।

**symlink के बजाय alias क्यों?** cplt और Copilot CLI दोनों एक ही Homebrew bin directory (`/opt/homebrew/bin/`) में install होते हैं, और वहाँ `copilot` नाम की केवल एक फ़ाइल रह सकती है, इसलिए symlink टकराव करेगा। alias इससे बच जाता है। असली `copilot` binary PATH में ही रहता है जहाँ cplt उसे ढूँढकर wrap कर सकता है, और alias आपके command को redirect करता है।

> **नोट:** cplt nest करने से मना करता है। यदि यह पता लगाता है कि यह पहले से ही किसी sandbox के अंदर चल रहा है (`__CPLT_WRAPPED` environment variable के माध्यम से), तो यह दोबारा launch नहीं होगा। `--print-profile` और `cplt doctor` जैसे read-only subcommands मौजूदा sandbox के अंदर भी काम करते हैं।

## Usage```
cplt [OPTIONS] [-- <AGENT_ARGS>...]

zsh (macOS डिफ़ॉल्ट)	`~/.zshrc`	`eval "$(cplt --shell-setup --agent opencode)"`
bash	`~/.bashrc`	`eval "$(cplt --shell-setup --agent opencode)"`
fish	`~/.config/fish/conf.d/cplt.fish`	`alias opencode 'cplt --agent opencode'`

Flag	यह क्या करता है
`--preset strict`	पूर्ण network lockdown। सभी पाँच toggles बंद, साथ ही `gh_guard`, `git_guard`, `proxy.forced` (forced-proxy egress) और `proxy.default_allowlist` (fail-closed domain allowlist) चालू। Escape hatch: `--allow-all-domains` केवल allowlist को अक्षम करता है
`--preset standard`	वर्तमान defaults। सभी पाँच बंद, scratch dir चालू रहता है। कोई preset न देने के समान
`--preset permissive`	`allow_localhost_any`, `allow_tmp_exec`, और `allow_lifecycle_scripts` चालू करता है
`--preset full-trust`	⚠️ खतरनाक। सभी पाँच चालू करता है, साथ ही `allow_env_files` और `allow_docker` जोड़ता है

Flag	यह क्या करता है
`-d, --project-dir <DIR>`	Copilot किस directory में काम कर सकता है। डिफ़ॉल्ट रूप से वर्तमान git repo root
`--allow-read <PATH>`	Copilot को project के बाहर files पढ़ने दें, read-only। Repeatable
`--allow-write <PATH>`	Copilot को project के बाहर पढ़ने और लिखने दें। सावधानी से उपयोग करें। Repeatable। tree writable है लेकिन executable नहीं — जो tree दोनों है वह binary-drop path है, इसलिए `~/.cargo` पर एक `allow.write` `~/.cargo/bin` को चलने से भी रोकता है। जब आपको दोनों चाहिए तो एक अलग, non-overlapping tree पर `--allow-exec` का उपयोग करें
`--allow-exec <PATH>`	⚠️ खतरनाक। agent को डिफ़ॉल्ट tool directories के बाहर एक tree से binaries execute करने दें — जैसे कि एक relocated Homebrew या toolchain prefix। read और execute प्रदान करता है, कभी write नहीं। Repeatable। एक असुरक्षित root (`/`, `/tmp`, `$HOME` और उसके parents, platform system directories) के लिए और किसी भी tree के लिए जो एक writable tree से overlap करता है — project directory, एक `--allow-write` grant, एक writable tool directory जैसे `~/.cache`, एक writable agent data directory (`~/.claude`, `~/.local/share/opencode`, `~/.pi/agent` और इसी तरह के), एक worktree या bare repo का असली `.git`, या एक tree जिसे backends बिना किसी grant के writable बनाते हैं (Linux पर `/tmp` और `/dev/shm`; macOS पर `/private/tmp` और `/private/var/folders`) — अस्वीकार कर दिया जाता है: writable plus executable एक binary-drop path है, और कोई भी backend exec grant से write grant घटा नहीं सकता
`--allow-socket <PATH>`	⚠️ खतरनाक। एक Unix domain socket path की अनुमति दें, उदाहरण के लिए एक custom LSP daemon या database socket। Repeatable। दूसरे छोर पर जो भी है वह sandbox के बाहर चलता है, इसलिए इसे `docker.sock` या किसी agent socket पर इंगित करना `--allow-docker` के समान है, और एकमात्र guard यह है कि `--deny-path` overlaps अस्वीकार किए जाते हैं। Linux पर यह kernel 7.1 से नीचे कुछ नहीं करता, क्योंकि unix socket connects ABI v9 से पहले Landlock द्वारा gated नहीं हैं (Linux limitations देखें)

Category	Examples	How
Core system	`HOME`, `USER`, `PATH`, `SHELL`, `TMPDIR`, `LANG`	Explicit allowlist
Terminal	`TERM`, `COLORTERM`, `TERM_PROGRAM`	Explicit allowlist
Editor	`EDITOR`, `VISUAL`, `PAGER`	Explicit allowlist
Auth tokens	`GH_TOKEN`, `GITHUB_TOKEN`, `COPILOT_GITHUB_TOKEN`	केवल तभी pass होते हैं जब आपने उन्हें पहले से सेट किया हो। gh guard इसके बजाय एक one-time file का उपयोग करता है
Copilot config	`COPILOT_DEBUG`, `COPILOT_*`	Prefix allowlist
Language runtimes	`NODE_*`, `GOPATH`, `CARGO_HOME`, `JAVA_HOME`, `VIRTUAL_ENV`, `PYTHONPATH`	Explicit allowlist
Tool managers	`NVM_`, `FNM_`, `PYENV_`, `MISE_`, `SDKMAN_`, `COREPACK_`, `YARN_*`	Prefix allowlist
OpenTelemetry	`OTEL_EXPORTER_OTLP_ENDPOINT`, `OTEL_SERVICE_NAME`, `OTEL_RESOURCE_ATTRIBUTES`, `OTEL_*`	Prefix allowlist (`OTEL_EXPORTER_OTLP_HEADERS` opt-in auth ले जा सकता है)
XDG dirs	`XDG_CONFIG_HOME`, `XDG_DATA_HOME`, `XDG_STATE_HOME`, `XDG_CACHE_HOME`	Explicit allowlist

Flag	यह क्या करता है
`--pass-env <VAR>`	एक environment variable को agent तक pass करें। Repeatable
`--inherit-env`	⚠️ खतरनाक। पूर्ण parent environment inherit करें। केवल `NO_COLOR`, `FORCE_COLOR`, `SSH_AUTH_SOCK`, `SSH_AGENT_PID` हटाता है। केवल debugging के लिए

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

cplt

Policy presets

File access

Environment variables

Sandbox toggles

Supported runtimes

Debugging

Session flags

DeepSeek Harness समर्थन

Run DSH (must be explicit — not auto-detected)

Pass the API key, or keep it in $DSH_HOME/.env

Set DSH as your default agent

Exec मोड

Sandbox a single command

Compound commands via $SHELL -c

Pass sandbox flags as usual

Shell aliases for sandboxed tools

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

Browse and change settings interactively

Set global preferences

Set per-repo policy (committed to .cplt.toml)

Inspect

Security

Network and proxy

कमांड गार्ड

ज्ञात प्रभाव

Flag	यह क्या करता है
`--allow-lifecycle-scripts`	npm/yarn/pnpm lifecycle scripts (postinstall hooks) को चलने दें। डिफ़ॉल्ट रूप से अवरुद्ध। जब `npm install` को उनकी आवश्यकता हो तो उपयोग करें
`--allow-gpg-signing`	sandbox के अंदर GPG commit और tag signing की अनुमति दें। public keyring और GPG agent socket तक read-only access प्रदान करता है। Private keys denied रहती हैं। GPG signing देखें
`--allow-jvm-attach`	`/tmp` में JVM Attach API unix sockets की अनुमति दें। MockK inline mocking, Mockito inline agents, ByteBuddy के लिए आवश्यक। JVM Attach API देखें
`--allow-msbuild`	`/tmp` में MSBuild worker-node unix sockets की अनुमति दें। `dotnet build` के लिए आवश्यक। persistent MSBuild Server को सक्षम नहीं करता। MSBuild worker-node IPC देखें
`--no-scratch-dir`	per-session scratch directory को अक्षम करें, जो डिफ़ॉल्ट रूप से चालू है। TMPDIR redirect नहीं होगा
`--scratch-dir`	per-session scratch directory को स्पष्ट रूप से सक्षम करें। पहले से ही डिफ़ॉल्ट है, इसलिए यह config में `scratch_dir = false` को override करने के लिए है
`--brief`	🧪 प्रायोगिक। agent-facing sandbox brief को scratch dir (`CPLT_BRIEF.md`) में लिखें। डिफ़ॉल्ट रूप से बंद। config में `sandbox.brief = true` भी। अस्थिर, इसलिए यह भविष्य के release में बदल या हट सकता है
`--no-brief`	इस run के लिए sandbox brief बंद करें, config में `sandbox.brief = true` को override करते हुए। `AGENTS.md` block को भी suppress करता है, जो brief पर gated है
`--agents-md`	🧪 प्रायोगिक। `--brief` के साथ, managed cplt block को project के `AGENTS.md` में भी लिखें। डिफ़ॉल्ट रूप से बंद। config में `sandbox.agents_md = true` भी। के बिना कोई प्रभाव नहीं। अस्थिर, इसलिए यह भविष्य के release में बदल या हट सकता है

Runtime	Home dirs	Env vars / prefixes	Discovery
Node.js	`.nvm`, `.local/share/fnm`, `.local/bin`	`NODE_`, `NPM_`, `NVM_`, `FNM_`	`node`
Rust	`.cargo`, `.rustup`	`CARGO_HOME`, `RUSTUP_HOME`	`cargo`
Go	`go/bin`, `go/pkg`	`GOPATH`, `GOROOT`, `GOCACHE`, etc.	`go`
Java/Kotlin (JVM)	`.sdkman`, `.jenv`, `.gradle`, `.m2`	`JAVA_HOME`, `JAVA_TOOL_OPTIONS`, `GRADLE_`, `MAVEN_`, `SDKMAN_`, `JENV_`	`java`, `gradle`
Kotlin Native	`.konan`	none	none
Python	`.pyenv`	`VIRTUAL_ENV`, `PYTHONPATH`, `PYENV_ROOT`, `PYENV_*`	`python3`
Yarn Berry	`.yarn`	`YARN_*` (hardening `YARN_ENABLE_SCRIPTS` को override करता है)	`yarn`
pnpm	`Library/pnpm`, `.local/share/pnpm`	`PNPM_HOME`	`pnpm`
Corepack	none	`COREPACK_*`	none
mise	`.local/share/mise`,

Flag	यह क्या करता है
`--doctor`	Deprecated। इसके बजाय `cplt doctor` subcommand का उपयोग करें
`--print-profile`	generated sandbox profile (SBPL) प्रिंट करें और exit करें
`--show-denials`	macOS sandbox denial logs को real time में stream करें
`--no-validate`	startup check को छोड़ें जो सत्यापित करता है कि sandbox restrictions सक्रिय हैं
`-y, --yes`	interactive confirmation prompt को छोड़ें। configuration summary अभी भी प्रिंट होता है, auditability के लिए। आवश्यक जब stdin TTY न हो, इसलिए CI और scripts को इसकी आवश्यकता होती है
`-q, --quiet`	startup banner और non-essential messages को suppress करें। Errors और warnings अभी भी प्रिंट होते हैं। config में `sandbox.quiet = true` भी
`--no-quiet`	`sandbox.quiet = true` को override करें और startup summary फिर भी दिखाएँ
`--no-audit`	post-session change report को छोड़ें। cplt सामान्य रूप से working tree को run से पहले pinned baseline commit के विरुद्ध diff करता है और सूचीबद्ध करता है कि session ने क्या छुआ, sensitive paths को flag करते हुए। `-q` भी इसे suppress करता है
`--init-config`	`~/.config/cplt/config.toml` पर एक starter config file बनाएँ और exit करें

Flag	यह क्या करता है
`--resume[=SESSION]`	पिछला session resume करें। बिना मान का `--resume` interactively चुनता है, `--resume=NAME` name या ID से चुनता है
`--continue`	वर्तमान directory में सबसे हाल का session resume करें
`--remote`	remote control सक्षम करें, ताकि आप GitHub.com या mobile से session को monitor और steer कर सकें
`--name SESSION`	session को नाम दें ताकि `--resume=NAME` बाद में इसे खोज सके

Layer	Enforcement	Bypassable?	What it protects
1. Kernel sandbox	macOS Seatbelt / Linux Landlock+seccomp	❌ No	File access, exec, network ports
2. Network proxy	CONNECT proxy, domain filtering	❌ No (within the sandbox)	Outbound connections, exfiltration
3. Command guard	PATH-based wrapper scripts	⚠️ Soft barrier	Pushes, merges, releases, API writes

कमांड	क्रिया
`gh pr merge`, `gh repo delete`, `gh release create`	🔒 अवरुद्ध
`git push origin main`, `git push --force`	🔒 अवरुद्ध
`gh api` (अन्य रेपो में लिखना)	🔒 स्कोप-जाँचा गया
`gh pr list`, `gh issue list`, `git commit`	✅ अनुमत
`git push origin feature-branch`	✅ `protect_default_branch_only` के साथ अनुमत

cplt flag	Copilot	OpenCode	Antigravity (`agy`)	Claude Code
`--continue`	`--continue`	`--continue`	`--continue`	`--continue`
`--resume`	`--resume`	`--continue`¹	`--continue`¹	`--resume`
`--resume=ID`	`--resume=ID`	`--session ID`	`--conversation ID`	`--resume ID`
`--remote`	`--remote`	ignored	ignored	ignored
`--name NAME`	`--name NAME`	ignored	ignored	ignored