Jinsi ya kujiendeshea sandboxd kwenye VPS yako

sandboxd ni nini, na unapata nini kwa kujiendeshea mwenyewe

Ili kujiendeshea sandboxd unahitaji seva moja ya Linux yenye Docker na jina la domain. Unatuma prompt, wakala wa uandishi wa code anajenga programu halisi ndani ya container iliyotengwa, na programu hiyo inaanza kufanya kazi kwenye URL yake ya preview. Wajenzi wa programu kutoka kwenye prompt ndiyo kundi linalovuma zaidi la huduma za hosted mwaka 2026, na sandboxd ndiyo inayoweza kuendeshwa kwenye VPS yako, chini ya leseni ya MIT, huku code iliyozalishwa ikihifadhiwa kwenye diski yako mwenyewe.

Muundo wake ni mdogo kwa makusudi. Control plane ya Go inaendesha Docker, Traefik v3 inaelekeza kila hostname ya preview, SQLite inahifadhi hali ya mfumo, na kila programu inaendeshwa ndani ya container moja. Hakuna Kubernetes wala seva tofauti ya database, ndiyo maana mashine yenye 2 vCPU inaweza kuiendesha.

Vitu vinne vinabeba mfumo mzima. App ni mradi wa kudumu, unaohifadhi jina lake, metadata ya git, na siri zake (secrets). Sandbox ni Docker container ambayo programu hiyo inaendeshwa ndani yake, na app moja inaelekeza kwenye sandbox moja kwa wakati mmoja. Workspace ni faili za programu, ambazo hukaa kwenye host na kubaki hata baada ya container kusimama. Task ni prompt moja inayopewa wakala ndani ya sandbox. Kusimamisha sandbox huacha kumbukumbu (memory) na kuhifadhi faili. Kuifuta sandbox huondoa container, na programu inaweza kuanzisha nyingine mpya.

Je, sandboxd inatofautiana vipi na Dify na OpenHands?

Zana hizi tatu huchanganywa kwa sababu zote huendesha LLM (large language model) kwenye seva yako, lakini kile zinachozalisha ni tofauti. Dify hujenga programu za LLM: violesura vya gumzo, njia za utafutaji (retrieval pipelines), na mifumo ya kazi (workflows) inayopiga simu kwa modeli kila wakati mtumiaji anapozitumia. Modeli ni sehemu ya bidhaa iliyokamilika. OpenHands hufanya kazi kwenye hazina (repository) uliyonayo tayari: unaielekeza kwenye msimbo (code) wako nayo husoma faili, huendesha amri, na kupendekeza mabadiliko. sandboxd huanza bila kitu chochote. Hutengeneza mradi kutoka kwa kiolezo (preset), huujenga ndani ya kontena jipya, na kukupa URL ya kuutazama. Kinachotoka ni programu ya kawaida ya React au FastAPI ambayo haihitaji modeli ili kuendesha.

Kwa hiyo, chagua kulingana na kile unachotaka mwishoni. sandboxd ni kwa ajili ya kuanza kutoka kwa sentensi na kuhifadhi msimbo baada ya hapo. Nyingine mbili ni kwa ajili ya wakati ambapo hazina au bidhaa inayotumia modeli ipo tayari.

Tofauti nyingine ni umri, na ndiyo inayopaswa kuzingatiwa kabla ya kujenga kitu chochote cha maana juu yake.

[
  {
    "tool": "sandboxd",
    "github_stars": "875",
    "forks": "50"
  },
  {
    "tool": "OpenHands",
    "github_stars": "83,091",
    "forks": "10,711"
  },
  {
    "tool": "Dify",
    "github_stars": "151,320",
    "forks": "23,886"
  }
]

sandboxd ina 875 stars dhidi ya 83,091 kwa OpenHands na 151,320 kwa Dify. Hazina hiyo ilianzishwa tarehe 3 Juni 2026, hivyo ina umri wa miezi miwili kufikia Agosti 2026, wakati OpenHands ilianza Machi 2024 na Dify Aprili 2023. Toleo la v0.1.0 lilishushwa tarehe 6 Juni 2026 na v0.3.6 tarehe 1 Agosti 2026. Mradi huu unajiita beta na unasema matoleo ya 0.x yanaweza kuvunja utangamano (compatibility). Soma namba hizo kama hatari ya utegemezi (dependency risk) badala ya hukumu ya ubora: mradi wa miezi miwili umekuwa na miezi miwili ya watu wengine kugundua hitilafu zake.

Mahitaji ya seva, na kinachoharibika wakati rasilimali hazitoshi

Mradi unasema 2 vCPU na 4 GB ya RAM inatosha kuanza. Hiyo ni sahihi kwa ajili ya control plane pamoja na sandbox moja ndogo, lakini haitoshi kwa watu wawili wanaojenga kwa wakati mmoja. Gawanya kumbukumbu katika sehemu. Traefik na Go control plane ni ndogo. Kila sandbox inayofanya kazi inashikilia toolchain kamili ya Node au Python, na kilele chake ni npm install ikifuatiwa na production build. Panga 8 GB kwa seva itakayoweka programu chache zikiwa hai, na chukulia swap kama wavu wa usalama badala ya uwezo wa ziada, kwa sababu build inayotumia swap inachukua dakika badala ya sekunde.

Wakati kumbukumbu inapoisha unapata hitilafu mbili tofauti, na hazifanani hata kidogo. Ndani ya sandbox, container inafika kwenye kikomo kigumu cha --memory kilichowekwa na sandboxd na kernel inaua mchakato mkubwa zaidi, kwa hivyo build inakufa bila ujumbe wowote muhimu kutoka kwa agent. docker ps -a inaonyesha exit code 137 kwa container hiyo na docker inspect juu yake inaripoti "OOMKilled": true. Build ya Node inayokufa kwa njia hii mara nyingi huchapisha JavaScript heap out of memory kwanza.

Hitilafu ya pili hutokea kwenye host. sandboxd inaendesha pressure reaper inayozima sandbox wakati kumbukumbu ya host inapopungua, kwa hivyo kwenye seva ndogo sandbox inaweza kutoweka wakati unatazama preview yake. Faili ziko salama na ombi linalofuata kwenye URL ya preview huiamsha, lakini kazi iliyokuwa ikiendelea wakati container inazima haitaendelea.

Disk ni tatizo la kimya zaidi. Kila programu huweka workspace yake kwenye host, na mradi wa JavaScript hubeba mti wa node_modules wenye mamia ya megabytes. Programu kumi ni gigabytes kadhaa za dependencies kabla ya kuhesabu images. Anza na 40 GB na uifuatilie:

docker system df
sudo du -sh /var/lib/sandboxed/workspaces

Saraka ya data chaguo-msingi ni /var/lib/sandboxed, iliyoandikwa na e ya ziada. Kuandika /var/lib/sandboxd kutakupa saraka tupu na dakika tano za kuchanganyikiwa.

Kusakinisha toleo maalum la sandboxd

Docker Engine pamoja na Compose plugin, na vilevile git, lazima viwe kwenye seva kwanza. Kusakinisha Docker kwenye VPS inaelezea sehemu hiyo.

docker compose version
git --version

Vyote viwili lazima vitoe toleo. docker: 'compose' is not a docker command inamaanisha unatumia binary ya zamani ya pekee ya docker-compose, na kisakinishi kinatarajia plugin ya v2.

Kisakinishi ni hati ya shell inayopakuliwa kupitia mtandao, kwa hivyo isome kabla ya kuiendesha, na uweke toleo maalum (pin).

curl -fsSL https://raw.githubusercontent.com/tastyeffectco/sandboxd/v0.3.6/install.sh -o install-sandboxd.sh
less install-sandboxd.sh
SANDBOXD_REF=v0.3.6 bash install-sandboxd.sh

SANDBOXD_REF ni git ref ambayo kisakinishi huichagua kwenye $HOME/.sandboxd/src, na chaguo-msingi ni main. Kuiacha bila kuwekewa thamani inamaanisha usakinishaji wako utakuwa ni chochote kilichounganishwa (merged) asubuhi hiyo, jambo ambalo ni muhimu kwa mradi uliotoa releases sita mnamo Julai 2026 pekee. Iweke toleo maalum, kisha uifanyie upgrade kwa makusudi baada ya kusoma changelog.

Hati hiyo hufanya clone ya source, hujenga images, huanzisha stack kwa kutumia docker compose up -d, na kuchapisha URL ya console na API token mwishoni. Hifadhi token hiyo mahali salama. Ni kitambulisho cha API inayoendesha Docker kama root.

curl http://127.0.0.1:9090/healthz

Hiyo huchapisha ok wakati control plane inapokuwa tayari. Ikiwa haichapishi chochote, stack haikuanza: endesha docker compose ps kutoka ~/.sandboxd/src ili kuona ni huduma ipi imezimika, kisha docker compose logs sandboxd ili kuona sababu.

Kufikia console kwenye seva ya mbali

Console hutolewa kupitia Traefik kwenye HTTP_PORT, ambayo ni 80 kwa chaguomsingi, katika hostname http://console.localhost. Traefik hufanya routing kulingana na hostname, kwa hivyo kuweka anwani ya IP ya seva yako kwenye kivinjari hakulingani na sheria yoyote na hurejesha 404. Hadi utakapoweka domain halisi, forward port na uweke hostname:

ssh -L 8080:127.0.0.1:80 you@your-vps

Kisha fungua http://console.localhost:8080 kwenye laptop yako. Kwenye Linux na macOS jina lolote linaloishia na .localhost hutatuliwa kuwa 127.0.0.1, kwa hivyo ombi hupitia kwenye tunnel likiwa na header sahihi ya Host. Weka nenosiri la console wakati wa ziara ya kwanza.

Ipe wakala modeli

Mawakala wawili wa uandishi wa msimbo husafirishwa ndani ya base image: OpenCode na Claude Code. SANDBOXD_DEFAULT_AGENT huamua ni yupi anayetekeleza kazi ambayo haijataja wakala, na chaguo-msingi ni opencode. Bila ufunguo wowote kuunganishwa, kazi hutekelezwa kwenye modeli za bure zisizohitaji ufunguo za OpenCode Zen, kwa hivyo build yako ya kwanza haigharimu chochote na unaweza kujaribu mzunguko mzima kabla ya kutumia pesa yoyote.

Unganisha ufunguo wako mwenyewe unapotaka modeli yenye nguvu zaidi. Funguo huenda kwenye control plane, kamwe haziingii kwenye sandbox: huhifadhiwa zikiwa zimesimbwa chini ya data directory na kuingizwa kwenye mtandao na credential proxy, kwa hivyo wakala wala msimbo anaouandika hauwezi kuzisoma.

export API=http://127.0.0.1:9090
export SANDBOXD_TOKEN=sk_...                       # printed by the installer
export AUTH="Authorization: Bearer $SANDBOXD_TOKEN"

curl -s -XPOST $API/v1/agents/claude-code/api-key -H "$AUTH" \
  -H 'content-type: application/json' \
  -d '{"api_key":"sk-ant-..."}'

Console hufanya vivyo hivyo chini ya Settings, AI Agents, ikijumuisha mchakato wa OAuth unaoongozwa ikiwa unataka kutumia usajili wa Claude badala ya API key. Modeli chaguo-msingi kwa kila wakala hupatikana kwenye paneli hiyo hiyo, na kazi moja inaweza kuibatilisha.

Jenga programu moja ndogo kuanzia mwanzo hadi mwisho

Unda programu hiyo, anzisha sandbox yake, kisha tuma ombi. Vitambulisho (ids) vitarudi kama JSON, na mwongozo wa kuanza (quickstart) huvivuta kwa kutumia sed ili usihitaji kuwa na jq iliyosakinishwa.

APP=$(curl -s -XPOST $API/v1/apps -H "$AUTH" \
  -H 'content-type: application/json' \
  -d '{"name":"todo","runtime_preset":"react-vite"}' \
  | sed -E 's/.*"id":"([^"]+)".*/\1/')

SB=$(curl -s -XPOST $API/v1/apps/$APP/sandbox -H "$AUTH" \
  -H 'content-type: application/json' -d '{"ports":[3000]}' \
  | sed -E 's/.*"id":"([^"]+)".*/\1/')

echo "app=$APP sandbox=$SB"

Vigezo vyote viwili lazima viwe na kitambulisho. $SB tupu inamaanisha kuwa sandbox haikuwahi kuanza, na sababu ya kawaida ni picha ya msingi (base image) bado inajengwa au seva haina kumbukumbu (memory) ya kutosha. 401 badala ya kitambulisho inamaanisha kuwa bearer token si sahihi.

curl -s -XPOST $API/v1/sandboxes/$SB/tasks -H "$AUTH" \
  -H 'content-type: application/json' \
  -d '{"prompt":"Add a todo list with a text input, an add button, and a delete button on each row. Keep the list in localStorage.","agent":"opencode"}'

Jibu hubeba kitambulisho cha kazi (task id). GET /v1/sandboxes/$SB/tasks/<task id> hurejesha matokeo yake, na njia ya /events kwenye kazi hiyo hiyo ni mkondo wa moja kwa moja wa SSE (server sent events) wa kile ambacho wakala (agent) anafanya. Dashibodi huonyesha mkondo uleule kama gumzo.

Programu hiyo inapatikana katika http://s-<sandbox id>-3000.preview.localhost, ambapo 3000 ni port uliyoiomba. Ikiwa sandbox ilikuwa imelala, ombi la kwanza hufika kwenye catch-all ya Traefik, sandboxd huanzisha kontena, husubiri port ijibu, na kuonyesha ukurasa mfupi wa kupasha moto ambao hujirefreshi na kuingia kwenye programu yako. Hakiki (preview) inayokwama kwenye ukurasa huo inamaanisha kuwa mchakato uliopo ndani hausikilizi kwenye port iliyotangazwa katika sandbox.yaml ya programu.

Weka hakikisho kwenye domain halisi yenye HTTPS

Kila sandbox hupata hostname yake, kwa hivyo rekodi moja ya wildcard DNS inatosha kwa zote. Elekeza *.preview.yourdomain.com kwenye anwani ya IP ya seva kwa kutumia rekodi ya A. Kisha weka vigezo vya hakikisho katika .env ndani ya ~/.sandboxd/src:

PREVIEW_DOMAIN=yourdomain.com
PREVIEW_ENTRYPOINT=websecure
PREVIEW_TLS=true
SANDBOXD_API_AUTH_DISABLED=false

Traefik inahitaji sehemu inayolingana: wezesha entrypoint ya websecure katika traefik/traefik.yml na uongeze certificate resolver. Tumia changamoto ya DNS-01, kwa sababu cheti kimoja cha wildcard kitafunika kila hostname ya hakikisho. Kwa HTTP-01, kila sandbox mpya ingehitaji utoaji wake wa cheti, na mchana wenye shughuli nyingi za ujenzi utagonga moja kwa moja vikomo vya viwango vya Let's Encrypt. Vyeti vya wildcard kupitia changamoto ya DNS-01 inashughulikia upande wa DNS wa jambo hilo.

cd ~/.sandboxd/src
docker compose up -d

URL za hakikisho huwa https://s-<id>-3000.preview.yourdomain.com. Fungua 80 na 443 kwenye firewall na uache 9090 ikiwa imefungwa kwa ulimwengu: angalia kanuni za msingi za ufw firewall. Kumbuka kuwa mtu yeyote anayeweza kukisia hostname ya hakikisho anaweza kupakia programu, kwa hivyo chukulia hakikisho kama kitu cha umma.

Msimbo unaozalishwa huhifadhiwa wapi, na ninaweza kuusafirisha?

Kwenye seva pangishi, uko chini ya saraka ya data. Kila nafasi ya kazi (workspace) ni saraka ya kawaida iliyopo /var/lib/sandboxed/workspaces/<id>/, ambayo imewekwa (bind mounted) ndani ya kontena, na faili za programu zinakaa kwenye /home/sandbox/workspace/app ndani ya sandbox. Hali ya mfumo wa udhibiti (control plane) ni faili moja ya SQLite iliyopo state/sandboxd.db, na vitambulisho vya wakala vilivyosimbwa viko kwenye agent-auth/. Hakuna kitu kinachofichwa ndani ya tabaka la kontena, kwa hivyo nakala rudufu ni kunakili saraka hiyo pamoja na faili ya hifadhidata. nakala rudufu za restic kwenye VPS hushughulikia yote mawili.

sudo ls /var/lib/sandboxed/workspaces
sudo du -sh /var/lib/sandboxed/workspaces/*

Usafirishaji wa Git umejengwa ndani badala ya kuongezwa baadaye. API hutoa hali (status) na tofauti (diff) kwa ajili ya kusoma, kisha commit na push:

curl -s $API/v1/apps/$APP/git/status -H "$AUTH"

curl -s -XPOST $API/v1/apps/$APP/git/commit -H "$AUTH" \
  -H 'content-type: application/json' \
  -d '{"message":"todo list, first pass"}'

curl -s -XPOST $API/v1/apps/$APP/git/push -H "$AUTH" \
  -H 'content-type: application/json' -d '{"branch":"main"}'

Remote ya faragha inahitaji token ya ufikiaji binafsi (personal access token), inayowekwa mara moja kwenye konsoi chini ya Settings, Git credentials. Inahifadhiwa ikiwa imesimbwa na inabaki nje ya sandbox, kwa hivyo wakala hawezi kuisoma au kufanya push bila idhini yako. Fanya push mapema na mara kwa mara. Hadi utakapofanya hivyo, saraka ya nafasi ya kazi ndiyo nakala pekee ya msimbo, na DELETE /v1/apps/<id> huifuta bila nafasi ya kuirejesha.

Gharama ya build katika model tokens ni kiasi gani?

sandboxd haipimi matumizi yako, kwa hivyo namba inayohusika inapatikana katika console ya mtoa huduma wako. Model za OpenCode Zen za bure hazigharimu chochote, lakini ni polepole na dhaifu kuliko model ya kulipia, jambo linalosababisha raundi nyingi za marekebisho kwa chochote kinachozidi programu ndogo ya majaribio.

Umbo la bili hufuata jinsi loop ya wakala inavyofanya kazi. Kila zamu hutuma tena muktadha (context) unaohitajika, kwa hivyo gharama hufuata idadi ya zamu, si idadi ya programu. Prompt moja inayofanikiwa ni ya bei nafuu. Raundi kumi na tano za "sasa rekebisha nafasi" dhidi ya mradi wenye faili hamsini si ya bei nafuu, kwa sababu maudhui ya faili husafiri kila wakati. Input na output tokens zina bei tofauti, na gharama ya wakala wa coding kwa kila session inatoa kiwango halisi. Weka kikomo cha matumizi (hard spend limit) kwa mtoa huduma kabla ya kukabidhi funguo kwa loop inayofanya kazi bila kusimamiwa.

Kusafisha sandboxes zilizopitwa na wakati

Idle reaper husimamisha sandbox yoyote ambayo imekuwa bila shughuli zaidi ya SANDBOXD_IDLE_THRESHOLD_SECONDS, ambayo kwa kawaida ni sekunde 2100, au dakika 35. Hii hurejesha RAM na kuhifadhi faili, na ombi linalofuata kwenye preview URL huamsha container hiyo. Ipunguze kwenye seva ndogo, kwa sababu dakika 35 za container zisizo na shughuli ni dakika 35 za kumbukumbu ambazo huwezi kuzitumia.

Kusimamisha si kufuta, na hapa ndipo diski hujaa kimyakimya. Sandbox iliyosimamishwa bado inamiliki workspace yake na container yake. Kuondoa sandbox huku ukihifadhi app ni DELETE kwenye sandbox, ambayo huondoa container na workspace pamoja nayo. Kuondoa app hufuta kila kitu, kabisa.

curl -s -XPOST $API/v1/sandboxes/$SB/stop -H "$AUTH"     # frees RAM, keeps files
curl -s -XDELETE $API/v1/sandboxes/$SB -H "$AUTH"        # container and workspace gone
curl -s -XDELETE $API/v1/apps/$APP -H "$AUTH"            # app and everything under it

Baada ya majuma machache ya majaribio, docker system df itaonyesha nafasi zaidi ya image inayoweza kurejeshwa kuliko unavyotarajia, kwa sababu kila app iliyopakua toolchain yake yenyewe iliacha layers nyuma. docker image prune husafisha zile ambazo hazijatumiwa. Angalia GET /v1/apps kwanza, kwa sababu image inayorejelewa bado na sandbox iliyolala si takataka.

Mipaka ya container inakupa nini na nini haikupi

Kila sandbox huendeshwa kama mtumiaji asiye na upendeleo (unprivileged user) akiwa na mfumo wa faili wa root wa kusoma pekee (read-only), uwezo wote wa Linux (capabilities) ukiwa umeondolewa, no-new-privileges ikiwa imewekwa, pamoja na ukomo wa kumbukumbu na idadi ya michakato (process limit). Mradi huu uko wazi kuhusu mipaka yake: container ya Linux inayoshiriki kernel ni mpaka thabiti wa utengano (isolation) lakini ni mpaka dhaifu wa kiusalama. Hitilafu katika kernel inamaanisha seva mwenyeji (host) imevamiwa.

Ukweli mbili unahitaji hatua za kuchukuliwa. Utoaji wa trafiki ya mtandao (egress) kutoka kwenye sandbox uko wazi katika toleo la self-hosted, hivyo msimbo unaozalishwa unaweza kufikia Internet, mtandao wako wa ndani, na sehemu za metadata za cloud. Mfumo mdogo wa nftables egress upo kwenye source code lakini umezimwa wakati wa compilation katika toleo la Docker Compose linaloweza kubebeka, jambo linalomaanisha kuwa vikwazo lazima vitoke kwenye firewall ya seva yako mwenyeji. Na API ya control plane kimsingi ni root ya seva mwenyeji, kwa sababu inaendesha Docker socket. Inajifunga kwenye 127.0.0.1:9090 kwa chaguo-msingi, SANDBOXD_API_AUTH_DISABLED lazima ibaki false, na haipaswi kamwe kuchapishwa kwenye Internet.

Ikiwa unapanga kuruhusu watu wengine kutuma prompts kwenye box yako, mtindo huo ni dhaifu sana peke yake. Mradi huu unapendekeza gVisor pamoja na SANDBOXD_RUNTIME=runsc, ambayo huweka kernel ya userspace kati ya sandbox na seva mwenyeji, na hupunguza kasi kwa takriban mara 1.7 hadi 4 kwa kazi zinazotumia syscall nyingi. Jibu thabiti zaidi ni mashine moja kwa kila mtumiaji (tenant), ambayo ni hoja sawa na kuendesha coding agents kwenye VM inayoweza kufutwa.

Je, unapaswa kujenga mradi wenye umri wa miezi miwili?

Kwa seva ya kibinafsi ya majaribio, ndiyo, kwa tahadhari za kawaida: pini SANDBOXD_REF, hifadhi nakala ya /var/lib/sandboxed, na tuma kila programu unayojali kwenye git remote. Kwa chochote kinachotumiwa na mteja, subiri toleo la 1.0 au tenga bajeti kwa ajili ya hitilafu, kwa sababu watunzaji wanasema wazi kuwa toleo la 0.x linaweza kubadilika wakati wowote. Watunzaji pia wanauza huduma ya usakinishaji uliosimamiwa kwa dola 79 kwa mwezi kufikia Agosti 2026, jambo ambalo ni muhimu kulijua unapopima kama mradi una sababu ya kuendelea kuwepo.

Sababu ya hatari hii kukubalika ni matokeo yake. sandboxd inazalisha programu ya kawaida katika git repository ya kawaida, kwa hivyo mradi ukikwama, unahifadhi msimbo wako na kupoteza tu kanga (wrapper). Hiyo ni nafasi nzuri zaidi kuliko kutumia huduma ya ujenzi iliyopangishwa (hosted builder) inayomiliki mradi wako. Kwa mtazamo mpana zaidi wa kile kinachostahili nafasi kwenye seva yako mwaka huu, angalia nini kinastahili kujiendeshea mwenyewe mwaka 2026.

FAQ

Je, ni sifa gani za chini za seva kwa ajili ya sandboxd?

Mradi huu unaeleza kuwa 2 vCPU na 4 GB ya RAM inatosha kuanza, ambayo inashughulikia control plane, Traefik na sandbox moja ndogo. Tumia 8 GB na 40 GB ya diski ikiwa unataka programu kadhaa ziwe hai kwa wakati mmoja, kwa sababu kila sandbox inayofanya kazi inabeba Node au Python toolchain kamili na kila workspace inatunza mti wake wa dependency kwenye diski. Wakati seva inapoishiwa rasilimali, pressure reaper ya sandboxd husimamisha sandbox ili kuachia kumbukumbu, na build inayozidi kikomo cha kumbukumbu cha container yake huawa na kernel: docker ps -a inaonyesha exit code 137 kwa ajili hiyo.

Je, sandboxd inatofautianaje na Dify au OpenHands?

Zinazalisha matokeo tofauti. Dify hujenga programu zinazoita model wakati wa runtime, kama vile interface za chat na retrieval pipelines. OpenHands huhariri repository uliyonayo tayari, ikikimbiza amri na kupendekeza mabadiliko kwenye code iliyopo. sandboxd hutengeneza mradi mpya kabisa kutoka kwa prompt, huujenga ndani ya container yake yenyewe, na kuuhudumia kwenye preview URL, na matokeo yake ni programu ya kawaida ya wavuti ambayo haihitaji model ili kufanya kazi.

Je, code inayotengenezwa na agent inakaa wapi hasa?

Kwenye filesystem ya seva, si ndani ya container image. Kila programu hupata saraka katika /var/lib/sandboxed/workspaces/<id>/ ambayo huwekwa (bind mount) ndani ya sandbox yake, na faili hizo huonekana katika /home/sandbox/workspace/app ndani yake. Hali ya control plane ni faili moja ya SQLite chini ya state/ katika saraka hiyo hiyo ya data. Unaweza kufanya commit na push kwenye git remote kutoka kwenye tab ya Git ya console au kupitia endpoints za /v1/apps/<id>/git/commit na /git/push, na token kwa ajili ya remotes za faragha huhifadhiwa kwa njia fiche na control plane badala ya kupewa sandbox.

Je, ni salama kuweka sandboxd kwenye Internet?

Weka preview URLs na console hadharani, kamwe usifanye hivyo kwa control plane API. API hiyo huendesha Docker kwenye seva, kwa hivyo ni sawa na root, na kwa sababu hiyo hufungwa kwenye 127.0.0.1:9090 kwa chaguo-msingi. Sandbox pia zina network egress iliyo wazi katika toleo la self-hosted, ikimaanisha kuwa code inayotengenezwa na agent inaweza kufikia mtandao wako wa ndani na cloud metadata endpoints, kwa hivyo ongeza sheria za firewall ya seva ikiwa sandbox ina majirani wanaostahili kulindwa. Kwa prompts kutoka kwa watu usiowaamini, endesha seva moja kwa kila mtumiaji badala ya kutegemea mpaka wa container.