1> ## Documentation Index

2> Fetch the complete documentation index at: https://code.claude.com/docs/llms.txt

3> Use this file to discover all available pages before exploring further.

4 

5# Sandboxing

6 

7> Pelajari bagaimana alat bash sandboxed Claude Code menyediakan isolasi filesystem dan jaringan untuk eksekusi agen yang lebih aman dan mandiri.

8 

9## Ikhtisar

10 

11Claude Code menampilkan sandboxing asli untuk menyediakan lingkungan yang lebih aman untuk eksekusi agen sambil mengurangi kebutuhan akan prompt izin yang konstan. Alih-alih meminta izin untuk setiap perintah bash, sandboxing menciptakan batas yang ditentukan di awal di mana Claude Code dapat bekerja lebih bebas dengan risiko yang berkurang.

12 

13Alat bash sandboxed menggunakan primitif tingkat OS untuk memberlakukan isolasi filesystem dan jaringan.

14 

15## Mengapa sandboxing penting

16 

17Keamanan berbasis izin tradisional memerlukan persetujuan pengguna yang konstan untuk perintah bash. Meskipun ini memberikan kontrol, hal ini dapat menyebabkan:

18 

19* **Kelelahan persetujuan**: Berulang kali mengklik "setujui" dapat menyebabkan pengguna kurang memperhatikan apa yang mereka setujui

20* **Produktivitas berkurang**: Gangguan konstan memperlambat alur kerja pengembangan

21* **Otonomi terbatas**: Claude Code tidak dapat bekerja seefisien mungkin saat menunggu persetujuan

22 

23Sandboxing mengatasi tantangan ini dengan:

24 

251. **Mendefinisikan batas yang jelas**: Tentukan dengan tepat direktori dan host jaringan mana yang dapat diakses Claude Code

262. **Mengurangi prompt izin**: Perintah aman dalam sandbox tidak memerlukan persetujuan

273. **Mempertahankan keamanan**: Upaya untuk mengakses sumber daya di luar sandbox memicu notifikasi segera

284. **Memungkinkan otonomi**: Claude Code dapat berjalan lebih independen dalam batas yang ditentukan

29 

30<Warning>

31 Sandboxing yang efektif memerlukan **baik** isolasi filesystem maupun jaringan. Tanpa isolasi jaringan, agen yang dikompromikan dapat mengeksfiltrasikan file sensitif seperti kunci SSH. Tanpa isolasi filesystem, agen yang dikompromikan dapat memasang pintu belakang pada sumber daya sistem untuk mendapatkan akses jaringan. Saat mengonfigurasi sandboxing, penting untuk memastikan bahwa pengaturan yang dikonfigurasi tidak menciptakan bypass dalam sistem ini.

32</Warning>

33 

34## Cara kerjanya

35 

36### Isolasi filesystem

37 

38Alat bash sandboxed membatasi akses sistem file ke direktori tertentu:

39 

40* **Perilaku penulisan default**: Akses baca dan tulis ke direktori kerja saat ini dan subdirektorinya

41* **Perilaku pembacaan default**: Akses baca ke seluruh komputer, kecuali direktori tertentu yang ditolak

42* **Akses terblokir**: Tidak dapat memodifikasi file di luar direktori kerja saat ini tanpa izin eksplisit

43* **Dapat dikonfigurasi**: Tentukan jalur yang diizinkan dan ditolak khusus melalui pengaturan

44 

45Anda dapat memberikan akses tulis ke jalur tambahan menggunakan `sandbox.filesystem.allowWrite` dalam pengaturan Anda. Pembatasan ini diberlakukan pada tingkat OS (Seatbelt di macOS, bubblewrap di Linux), sehingga berlaku untuk semua perintah subprocess, termasuk alat seperti `kubectl`, `terraform`, dan `npm`, bukan hanya alat file Claude.

46 

47### Isolasi jaringan

48 

49Akses jaringan dikendalikan melalui server proxy yang berjalan di luar sandbox:

50 

51* **Pembatasan domain**: Hanya domain yang disetujui yang dapat diakses

52* **Konfirmasi pengguna**: Permintaan domain baru memicu prompt izin (kecuali [`allowManagedDomainsOnly`](/id/settings#sandbox-settings) diaktifkan, yang secara otomatis memblokir domain yang tidak diizinkan)

53* **Dukungan proxy khusus**: Pengguna tingkat lanjut dapat menerapkan aturan khusus pada lalu lintas keluar

54* **Cakupan komprehensif**: Pembatasan berlaku untuk semua skrip, program, dan subprocess yang dihasilkan oleh perintah

55 

56### Penegakan tingkat OS

57 

58Alat bash sandboxed memanfaatkan primitif keamanan sistem operasi:

59 

60* **macOS**: Menggunakan Seatbelt untuk penegakan sandbox

61* **Linux**: Menggunakan [bubblewrap](https://github.com/containers/bubblewrap) untuk isolasi

62* **WSL2**: Menggunakan bubblewrap, sama seperti Linux

63 

64WSL1 tidak didukung karena bubblewrap memerlukan fitur kernel yang hanya tersedia di WSL2.

65 

66Pembatasan tingkat OS ini memastikan bahwa semua proses anak yang dihasilkan oleh perintah Claude Code mewarisi batas keamanan yang sama.

67 

68## Memulai

69 

70### Prasyarat

71 

72Di **macOS**, sandboxing bekerja langsung menggunakan kerangka Seatbelt bawaan.

73 

74Di **Linux dan WSL2**, instal paket yang diperlukan terlebih dahulu:

75 

76<Tabs>

77 <Tab title="Ubuntu/Debian">

78 ```bash theme={null}

79 sudo apt-get install bubblewrap socat

80 ```

81 </Tab>

82 

83 <Tab title="Fedora">

84 ```bash theme={null}

85 sudo dnf install bubblewrap socat

86 ```

87 </Tab>

88</Tabs>

89 

90WSL1 tidak mendukung sandboxing karena kurangnya primitif namespace Linux yang diperlukan. Jika Anda melihat `Sandboxing requires WSL2`, tingkatkan distribusi Anda ke WSL2 atau jalankan Claude Code tanpa sandboxing.

91 

92Di WSL2, perintah sandboxed tidak dapat meluncurkan binari Windows seperti `cmd.exe`, `powershell.exe`, atau apa pun di bawah `/mnt/c/`. WSL menyerahkan ini ke host Windows melalui soket Unix, yang sandbox blokir. Jika perintah perlu memanggil binari Windows, tambahkan ke [`excludedCommands`](/id/settings#sandbox-settings) sehingga berjalan di luar sandbox.

93 

94### Aktifkan sandboxing

95 

96Anda dapat mengaktifkan sandboxing dengan menjalankan perintah `/sandbox`:

97 

98```text theme={null}

99/sandbox

100```

101 

102Ini membuka menu di mana Anda dapat memilih antara mode sandbox. Jika dependensi yang diperlukan hilang (seperti `bubblewrap` atau `socat` di Linux), menu menampilkan instruksi instalasi untuk platform Anda.

103 

104Secara default, jika sandbox tidak dapat dimulai (dependensi yang hilang atau platform yang tidak didukung), Claude Code menampilkan peringatan dan menjalankan perintah tanpa sandboxing. Untuk menjadikan ini kegagalan keras sebagai gantinya, atur [`sandbox.failIfUnavailable`](/id/settings#sandbox-settings) ke `true`. Ini dimaksudkan untuk penyebaran terkelola yang memerlukan sandboxing sebagai gerbang keamanan.

105 

106### Mode sandbox

107 

108Claude Code menawarkan dua mode sandbox:

109 

110**Mode izin otomatis**: Perintah Bash akan mencoba berjalan di dalam sandbox dan secara otomatis diizinkan tanpa memerlukan izin. Perintah yang tidak dapat di-sandbox (seperti yang memerlukan akses jaringan ke host yang tidak diizinkan) kembali ke alur izin reguler. Aturan penolakan eksplisit selalu dihormati, dan perintah `rm` atau `rmdir` yang menargetkan `/`, direktori home Anda, atau jalur sistem kritis lainnya masih memicu permintaan izin. Aturan Ask hanya berlaku untuk perintah yang kembali ke alur izin reguler.

111 

112**Mode izin reguler**: Semua perintah bash melalui alur izin standar, bahkan saat di-sandbox. Ini memberikan lebih banyak kontrol tetapi memerlukan lebih banyak persetujuan.

113 

114Di kedua mode, sandbox memberlakukan pembatasan filesystem dan jaringan yang sama. Perbedaannya hanya dalam apakah perintah sandboxed disetujui secara otomatis atau memerlukan izin eksplisit.

115 

116<Info>

117 Mode izin otomatis bekerja secara independen dari pengaturan mode izin Anda. Bahkan jika Anda tidak dalam mode "terima edit", perintah bash sandboxed akan berjalan secara otomatis saat izin otomatis diaktifkan. Ini berarti perintah bash yang memodifikasi file dalam batas sandbox akan dieksekusi tanpa meminta, bahkan ketika alat edit file biasanya memerlukan persetujuan.

118</Info>

119 

120### Konfigurasi sandboxing

121 

122Sesuaikan perilaku sandbox melalui file `settings.json` Anda. Lihat [Settings](/id/settings#sandbox-settings) untuk referensi konfigurasi lengkap.

123 

124#### Memberikan akses tulis subprocess ke jalur tertentu

125 

126Secara default, perintah sandboxed hanya dapat menulis ke direktori kerja saat ini. Jika perintah subprocess seperti `kubectl`, `terraform`, atau `npm` perlu menulis di luar direktori proyek, gunakan `sandbox.filesystem.allowWrite` untuk memberikan akses ke jalur tertentu:

127 

128```json theme={null}

129{

130 "sandbox": {

131 "enabled": true,

132 "filesystem": {

133 "allowWrite": ["~/.kube", "/tmp/build"]

134 }

135 }

136}

137```

138 

139Jalur ini diberlakukan pada tingkat OS, sehingga semua perintah yang berjalan di dalam sandbox, termasuk proses anak mereka, menghormatinya. Ini adalah pendekatan yang direkomendasikan ketika alat memerlukan akses tulis ke lokasi tertentu, daripada mengecualikan alat dari sandbox sepenuhnya dengan `excludedCommands`.

140 

141Ketika `allowWrite` (atau `denyWrite`/`denyRead`/`allowRead`) didefinisikan dalam beberapa [cakupan pengaturan](/id/settings#settings-precedence), array **digabungkan**, artinya jalur dari setiap cakupan digabungkan, bukan diganti. Misalnya, jika pengaturan terkelola memungkinkan penulisan ke `/opt/company-tools` dan pengguna menambahkan `~/.kube` dalam pengaturan pribadi mereka, kedua jalur disertakan dalam konfigurasi sandbox akhir. Ini berarti pengguna dan proyek dapat memperluas daftar tanpa menduplikasi atau menimpa jalur yang ditetapkan oleh cakupan prioritas lebih tinggi.

142 

143Awalan jalur mengontrol bagaimana jalur diselesaikan:

144 

145| Awalan | Arti | Contoh |

146| :--------------------- | :-------------------------------------------------------------------------------------------------- | :------------------------------------------------------------------------------- |

147| `/` | Jalur absolut dari akar filesystem | `/tmp/build` tetap `/tmp/build` |

148| `~/` | Relatif terhadap direktori home | `~/.kube` menjadi `$HOME/.kube` |

149| `./` atau tanpa awalan | Relatif terhadap akar proyek untuk pengaturan proyek, atau ke `~/.claude` untuk pengaturan pengguna | `./output` dalam `.claude/settings.json` diselesaikan ke `<project-root>/output` |

150 

151Awalan `//path` yang lebih lama untuk jalur absolut masih berfungsi. Jika Anda sebelumnya menggunakan `/path` tunggal mengharapkan resolusi relatif proyek, beralih ke `./path`. Sintaks ini berbeda dari [aturan izin Read dan Edit](/id/permissions#read-and-edit), yang menggunakan `//path` untuk absolut dan `/path` untuk relatif proyek. Jalur filesystem sandbox menggunakan konvensi standar: `/tmp/build` adalah jalur absolut.

152 

153Anda juga dapat menolak akses tulis atau baca menggunakan `sandbox.filesystem.denyWrite` dan `sandbox.filesystem.denyRead`. Ini digabungkan dengan jalur apa pun dari aturan izin `Edit(...)` dan `Read(...)`. Untuk mengizinkan kembali pembacaan jalur tertentu dalam wilayah yang ditolak, gunakan `sandbox.filesystem.allowRead`, yang mengambil alih `denyRead`. Ketika `allowManagedReadPathsOnly` diaktifkan dalam pengaturan terkelola, hanya entri `allowRead` terkelola yang dihormati; entri `allowRead` pengguna, proyek, dan lokal diabaikan. `denyRead` masih digabungkan dari semua sumber.

154 

155Misalnya, untuk memblokir pembacaan dari seluruh direktori home sambil tetap memungkinkan pembacaan dari proyek saat ini, tambahkan ini ke `.claude/settings.json` proyek Anda:

156 

157```json theme={null}

158{

159 "sandbox": {

160 "enabled": true,

161 "filesystem": {

162 "denyRead": ["~/"],

163 "allowRead": ["."]

164 }

165 }

166}

167```

168 

169`.` dalam `allowRead` diselesaikan ke akar proyek karena konfigurasi ini berada dalam pengaturan proyek. Jika Anda menempatkan konfigurasi yang sama dalam `~/.claude/settings.json`, `.` akan diselesaikan ke `~/.claude` sebagai gantinya, dan file proyek akan tetap diblokir oleh aturan `denyRead`.

170 

171<Tip>

172 Tidak semua perintah kompatibel dengan sandboxing langsung. Beberapa catatan yang mungkin membantu Anda memanfaatkan sandbox sebaik-baiknya:

173 

174 * Banyak alat CLI memerlukan akses ke host tertentu. Saat Anda menggunakan alat ini, mereka akan meminta izin untuk mengakses host tertentu. Memberikan izin akan memungkinkan mereka mengakses host ini sekarang dan di masa depan, memungkinkan mereka untuk dieksekusi dengan aman di dalam sandbox.

175 * `watchman` tidak kompatibel dengan berjalan di sandbox. Jika Anda menjalankan `jest`, pertimbangkan menggunakan `jest --no-watchman`

176 * `docker` tidak kompatibel dengan berjalan di sandbox. Pertimbangkan untuk menentukan `docker *` dalam `excludedCommands` untuk memaksanya berjalan di luar sandbox.

177</Tip>

178 

179<Note>

180 Claude Code mencakup mekanisme pintu keluar yang disengaja yang memungkinkan perintah berjalan di luar sandbox saat diperlukan. Ketika perintah gagal karena pembatasan sandbox (seperti masalah konektivitas jaringan atau alat yang tidak kompatibel), Claude diminta untuk menganalisis kegagalan dan dapat mencoba kembali perintah dengan parameter `dangerouslyDisableSandbox`. Perintah yang menggunakan parameter ini melalui alur izin Claude Code normal yang memerlukan izin pengguna untuk dieksekusi. Ini memungkinkan Claude Code menangani kasus tepi di mana alat tertentu atau operasi jaringan tidak dapat berfungsi dalam batasan sandbox.

181 

182 Anda dapat menonaktifkan pintu keluar ini dengan mengatur `"allowUnsandboxedCommands": false` dalam [pengaturan sandbox](/id/settings#sandbox-settings) Anda. Saat dinonaktifkan, parameter `dangerouslyDisableSandbox` sepenuhnya diabaikan dan semua perintah harus berjalan sandboxed atau secara eksplisit terdaftar dalam `excludedCommands`.

183</Note>

184 

185## Manfaat keamanan

186 

187### Perlindungan terhadap prompt injection

188 

189Bahkan jika penyerang berhasil memanipulasi perilaku Claude Code melalui prompt injection, sandbox memastikan sistem Anda tetap aman:

190 

191**Perlindungan filesystem:**

192 

193* Tidak dapat memodifikasi file konfigurasi kritis seperti `~/.bashrc`

194* Tidak dapat memodifikasi file tingkat sistem di `/bin/`

195* Tidak dapat membaca file yang ditolak dalam [pengaturan izin Claude](/id/permissions#manage-permissions) Anda

196 

197**Perlindungan jaringan:**

198 

199* Tidak dapat mengeksfiltrasikan data ke server yang dikendalikan penyerang

200* Tidak dapat mengunduh skrip berbahaya dari domain yang tidak sah

201* Tidak dapat melakukan panggilan API yang tidak terduga ke layanan yang tidak disetujui

202* Tidak dapat menghubungi domain apa pun yang tidak secara eksplisit diizinkan

203 

204**Pemantauan dan kontrol:**

205 

206* Semua upaya akses di luar sandbox diblokir pada tingkat OS

207* Anda menerima notifikasi segera ketika batas diuji

208* Anda dapat memilih untuk menolak, mengizinkan sekali, atau secara permanen memperbarui konfigurasi Anda

209 

210### Permukaan serangan berkurang

211 

212Sandboxing membatasi potensi kerusakan dari:

213 

214* **Dependensi berbahaya**: Paket NPM atau dependensi lain dengan kode berbahaya

215* **Skrip yang dikompromikan**: Skrip build atau alat dengan kerentanan keamanan

216* **Rekayasa sosial**: Serangan yang menipu pengguna untuk menjalankan perintah berbahaya

217* **Prompt injection**: Serangan yang menipu Claude untuk menjalankan perintah berbahaya

218 

219### Operasi transparan

220 

221Ketika Claude Code mencoba mengakses sumber daya jaringan di luar sandbox:

222 

2231. Operasi diblokir pada tingkat OS

2242. Anda menerima notifikasi segera

2253. Anda dapat memilih untuk:

226 * Menolak permintaan

227 * Mengizinkan sekali

228 * Memperbarui konfigurasi sandbox Anda untuk secara permanen mengizinkannya

229 

230## Keterbatasan Keamanan

231 

232* Keterbatasan Sandboxing Jaringan: Sistem penyaringan jaringan beroperasi dengan membatasi domain yang diizinkan untuk terhubung oleh proses. Ini tidak sebaliknya memeriksa lalu lintas yang melewati proxy dan pengguna bertanggung jawab untuk memastikan mereka hanya mengizinkan domain tepercaya dalam kebijakan mereka.

233 

234<Warning>

235 Pengguna harus menyadari potensi risiko yang datang dari mengizinkan domain luas seperti `github.com` yang mungkin memungkinkan eksfiltrasi data. Juga, dalam beberapa kasus mungkin dapat membypass penyaringan jaringan melalui [domain fronting](https://en.wikipedia.org/wiki/Domain_fronting).

236</Warning>

237 

238* Eskalasi Privilege melalui Unix Sockets: Konfigurasi `allowUnixSockets` dapat secara tidak sengaja memberikan akses ke layanan sistem yang kuat yang dapat menyebabkan bypass sandbox. Misalnya, jika digunakan untuk memungkinkan akses ke `/var/run/docker.sock` ini akan secara efektif memberikan akses ke sistem host melalui eksploitasi soket docker. Pengguna didorong untuk mempertimbangkan dengan hati-hati soket unix apa pun yang mereka izinkan melalui sandbox.

239* Eskalasi Izin Filesystem: Izin penulisan filesystem yang terlalu luas dapat memungkinkan serangan eskalasi privilege. Mengizinkan penulisan ke direktori yang berisi executable dalam `$PATH`, direktori konfigurasi sistem, atau file konfigurasi shell pengguna (`.bashrc`, `.zshrc`) dapat menyebabkan eksekusi kode dalam konteks keamanan yang berbeda ketika pengguna lain atau proses sistem mengakses file ini.

240* Kekuatan Sandbox Linux: Implementasi Linux menyediakan isolasi filesystem dan jaringan yang kuat tetapi mencakup mode `enableWeakerNestedSandbox` yang memungkinkannya bekerja di dalam lingkungan Docker tanpa namespace istimewa. Opsi ini secara konsiderabel melemahkan keamanan dan hanya boleh digunakan dalam kasus di mana isolasi tambahan sebaliknya diberlakukan.

241 

242## Bagaimana sandboxing berhubungan dengan izin

243 

244Sandboxing dan [izin](/id/permissions) adalah lapisan keamanan komplementer yang bekerja bersama:

245 

246* **Izin** mengontrol alat mana yang dapat digunakan Claude Code dan dievaluasi sebelum alat apa pun berjalan. Mereka berlaku untuk semua alat: Bash, Read, Edit, WebFetch, MCP, dan lainnya.

247* **Sandboxing** menyediakan penegakan tingkat OS yang membatasi apa yang dapat diakses perintah Bash pada tingkat filesystem dan jaringan. Ini hanya berlaku untuk perintah Bash dan proses anak mereka.

248 

249Pembatasan filesystem dan jaringan dikonfigurasi melalui pengaturan sandbox dan aturan izin:

250 

251* Gunakan `sandbox.filesystem.allowWrite` untuk memberikan akses tulis subprocess ke jalur di luar direktori kerja

252* Gunakan `sandbox.filesystem.denyWrite` dan `sandbox.filesystem.denyRead` untuk memblokir akses subprocess ke jalur tertentu

253* Gunakan `sandbox.filesystem.allowRead` untuk mengizinkan kembali pembacaan jalur tertentu dalam wilayah yang ditolak

254* Gunakan aturan tolak `Read` dan `Edit` untuk memblokir akses ke file atau direktori tertentu

255* Gunakan aturan izin/tolak `WebFetch` untuk mengontrol akses domain

256* Gunakan `allowedDomains` sandbox untuk mengontrol domain mana yang dapat dijangkau perintah Bash

257* Gunakan `deniedDomains` sandbox untuk memblokir domain tertentu bahkan ketika wildcard `allowedDomains` yang lebih luas akan sebaliknya mengizinkannya

258 

259Jalur dari pengaturan `sandbox.filesystem` dan aturan izin digabungkan bersama ke dalam konfigurasi sandbox akhir.

260 

261[Repositori](https://github.com/anthropics/claude-code/tree/main/examples/settings) ini mencakup konfigurasi pengaturan pemula untuk skenario penyebaran umum, termasuk contoh khusus sandbox. Gunakan ini sebagai titik awal dan sesuaikan dengan kebutuhan Anda.

262 

263## Penggunaan lanjutan

264 

265### Konfigurasi proxy khusus

266 

267Untuk organisasi yang memerlukan keamanan jaringan lanjutan, Anda dapat menerapkan proxy khusus untuk:

268 

269* Mendekripsi dan memeriksa lalu lintas HTTPS

270* Menerapkan aturan penyaringan khusus

271* Mencatat semua permintaan jaringan

272* Mengintegrasikan dengan infrastruktur keamanan yang ada

273 

274```json theme={null}

275{

276 "sandbox": {

277 "network": {

278 "httpProxyPort": 8080,

279 "socksProxyPort": 8081

280 }

281 }

282}

283```

284 

285### Integrasi dengan alat keamanan yang ada

286 

287Alat bash sandboxed bekerja bersama dengan:

288 

289* **Aturan izin**: Gabungkan dengan [pengaturan izin](/id/permissions) untuk pertahanan berlapis

290* **Kontainer pengembangan**: Gunakan dengan [devcontainers](/id/devcontainer) untuk isolasi tambahan

291* **Kebijakan perusahaan**: Terapkan konfigurasi sandbox melalui [pengaturan terkelola](/id/settings#settings-precedence)

292 

293## Praktik terbaik

294 

2951. **Mulai ketat**: Mulai dengan izin minimal dan perluas sesuai kebutuhan

2962. **Pantau log**: Tinjau upaya pelanggaran sandbox untuk memahami kebutuhan Claude Code

2973. **Gunakan konfigurasi khusus lingkungan**: Aturan sandbox berbeda untuk konteks pengembangan vs. produksi

2984. **Gabungkan dengan izin**: Gunakan sandboxing bersama dengan kebijakan IAM untuk keamanan komprehensif

2995. **Konfigurasi uji**: Verifikasi pengaturan sandbox Anda tidak memblokir alur kerja yang sah

300 

301## Sumber terbuka

302 

303Runtime sandbox tersedia sebagai paket npm sumber terbuka untuk digunakan dalam proyek agen Anda sendiri. Ini memungkinkan komunitas agen AI yang lebih luas untuk membangun sistem otonom yang lebih aman dan lebih aman. Ini juga dapat digunakan untuk sandbox program lain yang mungkin ingin Anda jalankan. Misalnya, untuk sandbox server MCP Anda dapat menjalankan:

304 

305```bash theme={null}

306npx @anthropic-ai/sandbox-runtime <command-to-sandbox>

307```

308 

309Untuk detail implementasi dan kode sumber, kunjungi [repositori GitHub](https://github.com/anthropic-experimental/sandbox-runtime).

310 

311## Keterbatasan

312 

313* **Overhead kinerja**: Minimal, tetapi beberapa operasi filesystem mungkin sedikit lebih lambat

314* **Kompatibilitas**: Beberapa alat yang memerlukan pola akses sistem tertentu mungkin memerlukan penyesuaian konfigurasi, atau bahkan mungkin perlu dijalankan di luar sandbox

315* **Dukungan platform**: Mendukung macOS, Linux, dan WSL2. WSL1 tidak didukung. Dukungan Windows asli sedang direncanakan.

316 

317## Apa yang sandboxing tidak mencakup

318 

319Sandbox mengisolasi subprocess Bash. Alat lain beroperasi di bawah batas yang berbeda:

320 

321* **Alat file bawaan**: Read, Edit, dan Write menggunakan sistem izin secara langsung daripada berjalan melalui sandbox. Lihat [izin](/id/permissions).

322* **Penggunaan komputer di Desktop**: ketika Claude membuka aplikasi dan mengontrol layar Anda di macOS, itu berjalan di desktop aktual Anda daripada di lingkungan terisolasi. Prompt izin per-aplikasi membatasi setiap aplikasi. Lihat [penggunaan komputer](/id/desktop#let-claude-use-your-computer).

323 

324## Lihat juga

325 

326* [Security](/id/security) - Fitur keamanan komprehensif dan praktik terbaik

327* [Permissions](/id/permissions) - Konfigurasi izin dan kontrol akses

328* [Settings](/id/settings) - Referensi konfigurasi lengkap

329* [CLI reference](/id/cli-reference) - Opsi baris perintah