OpenAI

18 Novemba 2026

Uhandisi

Ndani ya sandbox ya Codex

Jinsi Codex inavyoendesha amri kwenye kompyuta yako kwa mipaka unayodhibiti.

Na Michael Bolin, Mwanachama wa Timu ya Kiufundi

Katika OpenAI, tunatumia mbinu ya ulinzi wa tabaka nyingi⁠(fungua katika dirisha jipya) kuwalinda mawakala. Ingawa uwekezaji wetu katika mafunzo na ulinganishaji ni msingi wa juhudi hizi, pia tunaweka vipengele katika mazingira yetu ya uendeshaji wa mawakala, Codex⁠(fungua katika dirisha jipya), ili kutoa ulinzi wa ziada. Kwa kuwa mojawapo ya mambo ambayo Codex hufanya mara nyingi (na yanayoweza kuwa hatari) ni kuendesha amri kwenye kompyuta yako, tulijenga sandbox ya Codex ili Codex ifanye kazi katika mazingira yako yaliyopo ndani ya mipaka ya mfumo wa faili na mtandao unayodhibiti.

Sandbox⁠(fungua katika dirisha jipya) ⁠(fungua katika dirisha jipya)huweka mipaka kwa kile ambacho programu inaweza kufikia inapoendeshwa. Kwa kazi ya kupanga picha, unaweza kusanidi sandbox ya Codex ili amri zisome na kubadilisha faili katika ~/Pictures huku ukizuia ufikiaji wa mtandao ili kuzuia upakiaji. Kwa ukaguzi wa msimbo, unaweza kuruhusu ufikiaji wa nyaraka za mtandaoni huku ukiweka faili za msimbo chanzo ziwe za kusoma pekee. Watumiaji husanidi sandbox ya Codex kupitia ⁠(fungua katika dirisha jipya)wasifu wa ruhusa⁠(fungua katika dirisha jipya), unaofafanua vikwazo vya mfumo wa faili na mtandao kwa kipindi cha Codex.

Katika makala haya, tutaanza na sababu za kuchagua mipangilio chaguomsingi ya sandbox ya Codex na athari zake, kisha tutaeleza muundo wa sandbox na jinsi mazingira ya uendeshaji yanavyoitumia kuendesha amri. Tutaonyesha jinsi watumiaji wa mwisho na mashirika wanavyoweza kurekebisha ruhusa zake kulingana na mahitaji yao, na jinsi wasanidi programu wanavyoweza kutumia sandbox hiyo katika zana zao wenyewe. Hatimaye, tutachunguza jinsi vikwazo hivi vinavyotekelezwa kwenye macOS, Linux na Windows.

Kuchagua mipaka ya sandbox

Katika Codex, tunalenga kuweka mipangilio chaguomsingi ya tahadhari kwa sandbox ambayo bado inaruhusu kazi yenye manufaa kufanywa. Kwa mfano, uhifadhi wa Git ukiwa mzizi wa eneo la kazi, wasifu wa ruhusa uliojengewa ndani wa :workspace:

  • Huruhusu kuandika ndani ya eneo la kazi, huku ukiweka saraka kama .git na .codex ziwe za kusoma pekee. Hii huwezesha Codex kuhariri msimbo chanzo bila kuomba ruhusa kwa kila badiliko, huku ikizuia mabadiliko ya moja kwa moja kwa .codex/config.toml au hook za Git chini ya .git/hooks.

  • Huruhusu usomaji mpana wa mfumo wa faili, kulingana na ruhusa zilizopo za mtumiaji katika mfumo wa uendeshaji. Vikusanyaji, mazingira ya utekelezaji na zana za kujenga programu hutegemea SDK, maktaba na usanidi ulio nje ya uhifadhi. Kuruhusu usomaji ndani ya eneo la kazi pekee kungevuruga mitiririko mingi ya kawaida ya kazi. Upande wa pili ni kwamba faili nyeti mahali pengine kwenye kompyuta zinaweza pia kubaki zikisomeka (kama vile faili za usanidi zenye funguo za API).

  • Huzima ufikiaji wa mtandao. Hii huzuia upakiaji wa moja kwa moja kwa huduma za nje, ikijumuisha majaribio ya kuvuja kwa data ambayo amri inaweza kusoma. Pia huzuia shughuli halali kama vile kupakua vitegemezi, zinazohitaji ufikiaji wa ziada.

Vikwazo hivi huzuia aina nyingi za tabia mbaya, lakini vitendo vyenye madhara bado vinawezekana. Kwa mfano, wakala anaweza kuingiza msimbo hasidi katika kifurushi kilichosakinishwa kwenye kompyuta kama vile node_modules/prettier. Badiliko hilo huenda lisionekane katika git status kwa sababu mara nyingi Git hupuuza node_modules. Ikiwa kihariri cha mtumiaji kinaendesha nakala hiyo ya Prettier wakati wa kuhifadhi, kuhifadhi faili tu kunaweza kutekeleza msimbo hasidi nje ya sandbox ya Codex. Ndiyo maana tunatumia mbinu ya ulinzi wa tabaka nyingi: sandbox huwekea mipaka kile ambacho amri zinaweza kufikia, huku mafunzo na ulinganishaji ukisaidia muundo kutumia ufikiaji huo kulingana na nia ya mtumiaji.

Kwa mwongozo wa kurekebisha ruhusa za sandbox na kuzichanganya na ulinzi mwingine katika mazingira ya shirika, angalia mwongozo wa vitendo wa usalama wa Codex⁠(fungua katika dirisha jipya).

Kubuni sandbox

Mashine pepe na kontena⁠(fungua katika dirisha jipya) ni njia mbili maarufu za kuweka programu kwenye sandbox, lakini tunatumia mbinu tofauti kwa sandbox ya Codex. Badala ya kuhamishia ukokotoaji kwenye mazingira tofauti ili kuutenga, Codex hutumia vipengele vya sandbox vya kila jukwaa kuweka mipaka kwa amri zinazoendeshwa katika mazingira yaliyopo ya mtumiaji.

Kwa wasanidi wengi, kompyuta yao ndogo ni mazingira ya kutengeneza programu yaliyoundwa kulingana na mahitaji yao, ambayo wanaweza kubadilisha wakati wowote wapendapo. Kuunda upya mazingira hayo ndani ya kontena la Docker kunaweza kuhitaji juhudi, na baadhi ya mitiririko ya kazi bado hutegemea zana zinazoendeshwa kwenye kompyuta mwenyeji.

Kwa mfano, fikiria kutumia Codex kutengeneza programu ya iOS kwenye Mac. Ukiamua kutenga Codex kwa kuiendesha ndani ya Docker, Codex haitaweza kuendesha mnyororo wa zana za kujenga programu za iOS unaojumuisha programu tekelezi asilia za Mac, wala kuzindua kiigaji cha iPhone ili kuendesha msimbo. Mtiririko wa kazi unaotegemea Docker unaweza kukabidhi ujenzi wa programu na shughuli za kiigaji kwa Mac mwenyeji, lakini shughuli hizo zingeendeshwa nje ya sandbox ya kontena na zingehitaji vikwazo vyake zenyewe. Kwa Codex, tunapendelea kurahisisha mambo kwa kuwekeza sana katika sandbox mahususi kwa kila mfumo wa uendeshaji ili Codex iendeshwe katika mazingira yanayofaa zaidi kwa kazi iliyopo.

Mazingira ya uendeshaji hutoa mbinu hizi za sandbox mahususi kwa kila mfumo kupitia API ya pamoja kwenye macOS, Windows na Linux. API hii hupokea amri na wasifu wa ruhusa. Wasifu wa ruhusa ukiruhusu ufikiaji wenye mipaka wa mtandao, kiitishaji lazima kitoe proksi ya mtandao ya kutekeleza mipaka hiyo:

Python

1
# This is a simplified version of the actual API.
2
def spawn_command_under_sandbox(
3
program_and_args: list[str],
4
cwd: Path,
5
env: dict[str, str],
6
permission_profile: PermissionProfile,
7
network_proxy: NetworkProxy | None,
8
) -> Child:

Chaguo hili la kukokotoa huanzisha mchakato ndani ya sandbox na kurudisha kishikio cha Child ambacho mazingira ya uendeshaji yanaweza kutumia kusubiri mchakato ukamilike. Kila mchakato tanzu hurithi vikwazo vya sandbox vya mzazi wake, hivyo vikwazo hivyo hutumika katika mti mzima wa michakato ulioanzishwa na amri, hata kwa michakato tanzu inayoendelea baada ya mchakato wa awali kumalizika.

Mchoro ufuatao unaonyesha jinsi sehemu hizi zinavyoungana, kuanzia usanidi hadi kuendesha amri ndani ya sandbox. Sehemu zinazofuata zinaeleza kila hatua.

Mchoro wa mtiririko: usanidi na mahitaji yanayosimamiwa hufafanua wasifu wa ruhusa wa kipindi; mazingira ya uendeshaji ya Codex huzindua amri chini ya vikwazo vya sandbox mahususi kwa kila jukwaa kwenye macOS, Linux au Windows. Michakato tanzu hurithi vikwazo hivyo, na proksi ya hiari ya mtandao hutekeleza sheria za vikoa.

Jinsi mazingira ya uendeshaji yanavyotumia sandbox

Kama ilivyoelezwa katika Kufafanua Mzunguko wa Wakala wa Codex, mazingira ya uendeshaji ya Codex yana jukumu la kutekeleza miito ya zana inayozalishwa na muundo. Kwa kazi za uandishi wa msimbo, zana inayotumiwa zaidi ni zana ya shell, ambayo huendesha amri kama ambavyo mtumiaji angefanya katika shell shirikishi kama Bash. Hapa tutachunguza zana ya shell ⁠(fungua katika dirisha jipya)exec_command⁠(fungua katika dirisha jipya) ya dokezo moja⁠(fungua katika dirisha jipya) ili kuonyesha jinsi mazingira ya uendeshaji yanavyotumia sandbox kufikia ulinzi unaotakiwa.

Hili ni toleo lililorahisishwa la jinsi mwito wa zana ya
exec_command ungetekelezwa na mazingira ya uendeshaji ya Codex bila sandbox:

Python

1
# Illustrative implementation of the exec_command tool call.
2

3
class ExecCommandToolCall:
4
cmd: str
5
workdir: str | None = None
6
shell: str | None = None
7
login: bool = True
8
timeout_ms: int = 10_000
9

10

11
def perform_exec_command(tool_call: ExecCommandToolCall):
12
program_and_args = [
13
tool_call.shell or os.environ.get("SHELL") or "/bin/sh",
14
"-lc" if tool_call.login else "-c",
15
tool_call.cmd,
16
]
17
child = subprocess.Popen(
18
program_and_args,
19
# workdir defaults to the turn's cwd, assumed here to be the process cwd.
20
cwd=Path(tool_call.workdir or ".").absolute(),
21
stdout=subprocess.PIPE,
22
stderr=subprocess.STDOUT,
23
)
24
output, exit_code = collect_output(child, timeout_ms=tool_call.timeout_ms)
25
return {"output": output, "exit_code": exit_code}

Ili kuweka amri kwenye sandbox, mazingira ya uendeshaji hubadilisha mwito wa subprocess.Popen() na kuweka spawn_command_under_sandbox(). Mazingira ya uendeshaji hutoa wasifu wa ruhusa na, inapohitajika, proksi ya mtandao:

Python

1
# Honoring the exec_command tool call while enforcing sandbox constraints.
2

3
def perform_exec_command_with_sandboxing(
4
tool_call: ExecCommandToolCall,
5
permission_profile: PermissionProfile,
6
network_proxy: NetworkProxy | None,
7
):
8
# ...build program_and_args as in the previous example...
9
child = spawn_command_under_sandbox(
10
program_and_args=program_and_args,
11
cwd=Path(tool_call.workdir or ".").absolute(),
12
env=os.environ.copy(),
13
permission_profile=permission_profile,
14
network_proxy=network_proxy,
15
)
16
output, exit_code = collect_output(child, timeout_ms=tool_call.timeout_ms)
17
return {"output": output, "exit_code": exit_code}

Zana ya exec_command pia huruhusu muundo kuomba ruhusa tofauti kwa amri moja, lakini mazingira ya uendeshaji huamua kama yakubali ombi hilo:

Python

1
class ExecCommandToolCall:
2
# ...command-related fields...
3

4
# Per-command sandbox override. Defaults to "use_default".
5
sandbox_permissions: Literal[
6
"use_default",
7
"with_additional_permissions",
8
"require_escalated",
9
] = "use_default"
10

11
# User-facing approval question; only for "require_escalated".
12
justification: str | None = None
13

14
# Expand network or filesystem access; only for "with_additional_permissions".
15
# AdditionalPermissions supports fine-grained options.
16
additional_permissions: AdditionalPermissions | None = None

use_default inapobainishwa, mazingira ya uendeshaji hutumia usanidi chaguomsingi wa sandbox kwa zamu hiyo. with_additional_permissions huomba ufikiaji uliopanuliwa ndani ya sandbox, huku require_escalated ikiomba utekelezaji nje yake. Mazingira ya uendeshaji hutathmini ombi kulingana na mapendeleo ya mtumiaji kabla ya kutekeleza amri. (Kwa mfano, Codex inaweza kumwomba mtumiaji idhini moja kwa moja, au kuelekeza ombi kwa ukaguzi wa kiotomatiki⁠(fungua katika dirisha jipya).) Utekelezaji ukiidhinishwa, Codex itapitisha permission_profile na network_proxy zinazofaa kwa perform_exec_command_with_sandboxing() pamoja na hoja za amri kutoka kwa ExecCommandToolCall ya awali.

Zana ya shell ndiyo mtumiaji mkuu wa spawn_command_under_sandbox(), na mazingira ya uendeshaji pia hutumia tena miundombinu yake ya sandbox kwa shughuli kama kusoma na kubadilisha faili za ndani. Matumizi haya ya kurudia hayako ndani ya mazingira ya uendeshaji pekee: amri ya codex sandbox hukuwezesha kujumuisha utekelezaji wa amri ndani ya sandbox katika zana zako mwenyewe, kama tutakavyoona baadaye. Sasa, tutaangalia jinsi wasifu wa ruhusa unavyofafanuliwa.

Kusanidi sandbox

Wasifu wa ruhusa wenye jina hukuwezesha kutumia tena vikwazo vilevile vya mfumo wa faili na mtandao katika miradi tofauti. Unaweza kufafanua wasifu wako mwenyewe chini ya [permissions] katika config.toml. Kwa mfano, yafuatayo yanafafanua wasifu uitwao dev ambao hupanua⁠(fungua katika dirisha jipya) wasifu uliojengewa ndani wa :workspace:

TOML

1
# Use the dev profile by default.
2
default_permissions = "dev"
3

4
[permissions.dev]
5
# This is displayed when /permissions is run in the Codex CLI.
6
description = "Development with extra read-only protections."
7

8
# A profile can be derived from an existing profile.
9
# Profiles starting with ":" are provided by Codex.
10
extends = ":workspace"
11

12
[permissions.dev.filesystem]
13
"~/build-cache" = "write"
14

15
[permissions.dev.filesystem.":workspace_roots"]
16
".devcontainer" = "read"
17
".vscode" = "read"
18
"**/*.env" = "deny"
19
"secrets" = "deny"

Wasifu wa dev huongeza ruhusa ya kuandika kwenye ~/build-cache na kuweka vikwazo vya ziada kwa faili zilizo katika eneo la kazi. Maingizo ya mfumo wa faili yanaweza kutoa ufikiaji wa kusoma pekee (read), wa kusoma na kuandika (write), au kuzuia ufikiaji kabisa (deny).

Jedwali la :workspace_roots hukuwezesha kufafanua sheria za njia zinazohusiana na mizizi ya eneo la kazi la mradi. Kwa chaguomsingi, Codex CLI hutumia saraka yake ya kazi kama mzizi wake pekee wa eneo la kazi, huku programu ya ChatGPT ya kompyuta ikitumia folda za msimbo chanzo za mradi. Codex hutumia kila sheria kwa kila mzizi, hivyo ingizo la .vscode katika dev hufanya saraka ya .vscode iwe ya kusoma pekee chini ya kila mzizi.

Pamoja na sheria zake yenyewe, dev hurithi ulinzi ufuatao kutoka kwa :workspace:

TOML

1
[permissions.":workspace".filesystem.":workspace_roots"]
2
".agents" = "read"
3
".aws" = "read"
4
".codex" = "read"
5
".git" = "read"

Ruhusa za mtandao

Kwa ujumla, kuna chaguo tatu za kusanidi mtandao kwa sandbox katika Codex:

  • Kuzima ufikiaji wote wa mtandao (chaguomsingi kwa wasifu wa :workspace)

  • Kuwasha ufikiaji kamili wa moja kwa moja wa mtandao (chaguomsingi kwa wasifu wa :danger-full-access)

  • Kuruhusu ufikiaji wa mtandao kupitia proksi pekee, ambayo huamua cha kupitisha kulingana na wasifu wa ruhusa


Ili kuipa
dev ufikiaji wa moja kwa moja wa mtandao, weka permissions.dev.network.enabled = true katika ngazi ya juu ya config.toml. Hii hutoa ufikiaji kamili wa mtandao wakati proksi ya mtandao imezimwa.

Ili kuiruhusu dev kufikia kundi fulani tu la vikoa, washa proksi ya mtandao na usanidi sheria zake za vikoa:

TOML

1
[permissions.dev.network]
2
enabled = true
3

4
[permissions.dev.network.domains]
5
"*.openai.com" = "allow"
6
# Allow requests to local services by hostname or by IPv4/IPv6 loopback address.
7
"localhost" = "allow"
8
"127.0.0.1" = "allow"
9
"::1" = "allow"
10
"evil.example" = "deny"
11

12
[features]
13
# If neither local config nor managed requirements enable the proxy,
14
# this profile allows direct network access; domain rules are not enforced.
15
network_proxy = true

Sheria za vikoa zinaweza kutumia majina kamili na michoro yenye vibadala, huku sheria za kukataa zilizobainishwa wazi zikitangulia sheria za kuruhusu. Maombi kwa vikoa vingine yanahitaji idhini au huzuiwa, kama ilivyoelezwa katika Proksi ya mtandao hapa chini.

Kupanga usanidi kwa tabaka na kutekeleza mipaka

Watumiaji binafsi wanaweza kusanidi chaguomsingi zinazotumika katika miradi yote na kuzibadilisha kwa mradi fulani unaoaminika. Wasimamizi wa mashirika wanaweza pia kutaka kusanidi chaguomsingi za watumiaji wao na kuweka mipaka ya mipangilio ambayo watumiaji hao wanaweza kubadilisha. Codex huwezesha yote mawili kupitia usanidi wa tabaka na mahitaji yanayosimamiwa.

Kama ilivyoelezwa katika Kipaumbele cha usanidi,⁠(fungua katika dirisha jipya) Codex huunganisha mipangilio kutoka kwa faili nyingi za config.toml. Majedwali huunganishwa hadi kwenye ngazi zote za ndani, huku chanzo chenye kipaumbele cha juu kikishinda thamani zinapokinzana. Safu hubadilishwa nzima.

Ndiyo maana wasifu wa ruhusa hutumia majedwali kwa njia za mfumo wa faili na vikoa vya mtandao. Timu inaweza kuongeza au kubatilisha maingizo binafsi katika usanidi wake na kurithi kiotomatiki mabadiliko kwa maingizo mengine yote katika usanidi wa msingi wa shirika:

TOML

1
[permissions.dev.filesystem.":workspace_roots"]
2
".idea" = "read"
3

4
[permissions.dev.network.domains]
5
"example.com" = "allow"

Wasimamizi pia wanaweza kutoa mahitaji yanayosimamiwa⁠(fungua katika dirisha jipya) kupitia requirements.toml ili kuweka mipaka kwa chaguo za usanidi za watumiaji. Mahitaji haya yanaweza kutoka kwa vyanzo vingi, ikijumuisha faili za mfumo na sera inayotolewa kupitia wingu. Matumizi ya kawaida ni kubainisha allowed_permission_profiles ili kuweka mipaka ya wasifu wa ruhusa ambao mtumiaji wa shirika anaweza kuchagua. Kwa mfano, msimamizi anaweza kubainisha mahitaji haya ya wingu:

TOML

1
default_permissions = ":read-only"
2

3
[allowed_permission_profiles]
4
":read-only" = true
5
":danger-full-access" = false

Mahitaji ya wingu yangetangulia faili ya mahitaji ya mfumo katika /etc/codex/requirements.toml, hivyo ingizo katika faili hiyo haliwezi kubatilisha ":danger-full-access" = false iliyowekwa wazi hapo juu. Kuacha :workspace bila kubainishwa huruhusu tabaka jingine la mahitaji kutoa ingizo hilo. Wasifu wenye maingizo ya false au usio na maingizo kwenye jedwali la mwisho lililounganishwa haupatikani.

Utenganishaji huu huwezesha mashirika kutekeleza mipaka huku watumiaji wakirekebisha usanidi wao ndani ya mipaka hiyo. Wasifu wa ruhusa unaopatikana unaweza kutumiwa na mazingira ya uendeshaji au kutumika moja kwa moja kwa amri, kama tutakavyoona sasa.

Kutumia amri ya codex sandbox

Codex CLI hutoa amri ya sandbox ili kurahisisha kuendesha amri yoyote chini ya wasifu wa ruhusa uliofafanuliwa katika usanidi wa Codex. Hii hutumiwa mara nyingi kujaribu wasifu, kuhakikisha kuwa sandbox inazuia tabia iliyokusudiwa kuzuia.

Kwa mfano, amri ifuatayo inajaribu kusanidi VS Code ili iendeshe kipangiliaji hasidi cha msimbo kiotomatiki wakati wa kuhifadhi. Tukichukulia kuwa .vscode tayari ipo, wasifu wa dev uliofafanuliwa hapo juu unapaswa kuzuia uandishi huu kwa sababu saraka hiyo ni ya kusoma pekee (codex sandbox huchukulia cwd kuwa mzizi wa eneo la kazi kwa chaguomsingi):

Bash

1
codex sandbox --permission-profile dev -- \
2
bash -c 'cat > .vscode/settings.json' <<'JSON'
3
{
4
"prettier.prettierPath": "./node_modules/evil-prettier",
5
"[typescript]": {
6
"editor.defaultFormatter": "esbenp.prettier-vscode",
7
"editor.formatOnSave": true
8
}
9
}
10
JSON

Kwa kweli, kwenye macOS hii hushindwa kwa ujumbe huu:

Maandishi ya Kawaida

1
bash: .vscode/settings.json: Operation not permitted

Amri ya codex sandbox hufanya mbinu ya sandbox ya Codex ipatikane bila kutegemea kipindi cha wakala. Unaweza kutumia lugha hiyo hiyo ya usanidi na utekelezaji mahususi kwa kila jukwaa kuweka mipaka kwa amri zinazozinduliwa na zana zako mwenyewe.

Mfano: kuweka seva ya MCP kwenye sandbox

Kwa seva ya MCP ya stdio iliyosanidiwa katika config.toml, mazingira ya uendeshaji ya Codex hayajaribu kuweka amri inayotumika kuanzisha seva kwenye sandbox. Codex haiwezi kubaini kwa uhakika ni faili au huduma zipi za mtandao ambazo seva hiyo inahitaji, hivyo kutumia wasifu chaguomsingi wa sandbox kunaweza kuvuruga usanidi ambao vinginevyo ungefanya kazi vizuri.

Kwa mfano, njia ya kawaida ya kusanidi seva ya MCP ya @modelcontextprotocol/server-memory⁠(fungua katika dirisha jipya) ili itumiwe na Codex ni hii:

TOML

1
[mcp_servers.memory]
2
command = "npx"
3
args = [
4
"-y",
5
"@modelcontextprotocol/server-memory@1.0.0"
6
]
7

8
[mcp_servers.memory.env]
9
MEMORY_FILE_PATH = "~/mcp-data/memory.jsonl"

Kwa kuwa amri hii ya npx huendeshwa bila sandbox, inaweza kuandika faili na kutuma maombi ya mtandao kwa ruhusa sawa na mtumiaji anayeendesha Codex, jambo linalotoa ruhusa nyingi kupita kiasi. Ili kuibana, tunaweza kufafanua wasifu wa ruhusa uitwao memory-mcp kisha kuendesha amri ya awali ya npx kupitia codex sandbox --permission-profile memory-mcp ili kuweka mipaka ya mahali seva inaweza kuandika na kuizuia kufikia mtandao:

TOML

1
[permissions.memory-mcp.filesystem]
2
# Allow broad reads for Node.js/npm dependencies and configuration.
3
":root" = "read"
4
"~/.npm" = "write"
5
"~/mcp-data" = "write"
6

7
[permissions.memory-mcp.network]
8
enabled = false
9

10
[mcp_servers.memory]
11
command = "codex"
12
args = [
13
"sandbox",
14
"--permission-profile",
15
"memory-mcp",
16
"--",
17
"npx",
18
"--offline",
19
"@modelcontextprotocol/server-memory@1.0.0"
20
]
21

22
[mcp_servers.memory.env]
23
MEMORY_FILE_PATH = "~/mcp-data/memory.jsonl"

Kabla ya kuanzisha seva, unda saraka yake ya data na uweke kifurushi cha toleo lililobainishwa kwenye akiba ya npm. Hii huwezesha npx --offline kuzindua seva chini ya wasifu unaozima ufikiaji wa mtandao:

Bash

1
# The sandbox can write to this folder, but it cannot create it.
2
mkdir -p ~/mcp-data
3

4
# Installing the MCP server requires network access.
5
npx -y --package=@modelcontextprotocol/server-memory@1.0.0 -c true

Kifurushi kikiwekwa kwenye akiba, Codex inaweza kuanzisha seva ya kumbukumbu bila ufikiaji wa mtandao, huku uandishi ukiruhusiwa kwenye akiba ya npm na saraka ya data ya seva pekee.

Utekelezaji wa sandbox ya Codex

Utekelezaji wa sandbox hubadilisha wasifu wa ruhusa kuwa vikwazo vinavyotekelezwa na mfumo wa uendeshaji. Mifumo yote mitatu mikuu ya uendeshaji hutumia mantiki ileile ya msingi ya kushughulikia maombi na sera ya proksi ya mtandao, lakini usanidi wa proksi na uunganishaji wake na sandbox ni mahususi kwa kila mfumo. Tutachunguza kwanza proksi ya pamoja, kisha utekelezaji wa macOS, Linux na Windows.

Proksi ya mtandao

Ili kutekeleza vikwazo vya mtandao vya wasifu wa ruhusa, mazingira ya uendeshaji huanzisha proksi ya mtandao na kusanidi sandbox iruhusu miunganisho kwa proksi hiyo huku ikizuia miunganisho ya moja kwa moja kwa seva za nje. Proksi hukagua kila ombi dhidi ya sheria za vikoa za wasifu ili kuamua kama ilipitishie mbele.

Katika uhifadhi wa Codex, proksi ya mtandao imetekelezwa katika kifurushi cha codex-network-proxy⁠(fungua katika dirisha jipya), ambacho mazingira ya uendeshaji hutumia kama maktaba, ingawa pia kinaweza kujengwa kama CLI inayojitegemea⁠(fungua katika dirisha jipya). Inapowashwa, codex-network-proxy huanzisha proksi ya HTTP na proksi ya SOCKS5 kwa chaguomsingi. Anwani hizi za proksi hupitishwa kwa mchakato ulioanzishwa na sandbox kupitia vigezo vya mazingira. Pamoja na kuingiza vigezo vya kawaida vya mazingira kama HTTP_PROXY, HTTPS_PROXY na ALL_PROXY, pia huingizwa vigezo kadhaa maarufu vya mazingira mahususi kwa programu⁠(fungua katika dirisha jipya) (kama vile PIP_PROXY). Ni kweli kwamba si programu zote zinazofuata vigezo hivi vya mazingira. Programu ikijaribu kuunganisha moja kwa moja kwa seva ya nje, vikwazo vya sandbox vya mfumo wa uendeshaji huizuia, kama ilivyoelezwa katika sehemu mahususi za kila jukwaa hapa chini.

Proksi ya mtandao ina jukumu la kutekeleza vikwazo vya mtandao vilivyofafanuliwa katika wasifu wa ruhusa. Kwa mfano, wasifu wa dev ulioonyeshwa awali huruhusu maombi kwa *.openai.com na hukataa wazi maombi kwa evil.example. Ombi likilenga kikoa kisicholingana na sheria ya kuruhusu au kukataa, proksi inaweza kusitisha ombi hilo kwa muda huku ikilikabidhi kwa mazingira ya uendeshaji kwa idhini. Kama ilivyo katika mfano wa amri ya shell, Codex inaweza kumwomba mtumiaji idhini moja kwa moja, au kuelekeza ombi kwa ukaguzi wa kiotomatiki⁠(fungua katika dirisha jipya). Baada ya kupokea uamuzi, proksi huruhusu ombi kuendelea au hulikataa kwa jibu la hitilafu.

Mpangilio huu ni muhimu kwa sababu hata utafutaji wa DNS unaweza kuvuja taarifa iliyosimbwa ndani ya jina la seva. Kwa hiyo, proksi hutafuta anwani ya jina la seva lililoombwa baada tu ya kubaini kuwa limeruhusiwa au limeidhinishwa. Kumbuka kwamba sheria pana za vibadala au ufikiaji wa huduma za DNS bado zinaweza kuruhusu uvujishaji wa data kupitia DNS.

macOS

Kwenye macOS, Codex hutumia Seatbelt⁠(fungua katika dirisha jipya), mbinu ya sandbox ya Apple inayotekelezwa na kiini cha mfumo. Sera za Seatbelt huandikwa kwa Sandbox Profile Language (SBPL), lugha inayotegemea Scheme ya kueleza vikwazo vya sandbox. Codex huita Seatbelt kupitia amri ya /usr/bin/sandbox-exec ya macOS. Kama codex sandbox, hupokea chaguo zinazoeleza sandbox zikifuatiwa na amri ya kuendesha:

Bash

1
sandbox-exec -p PROFILE [-Dkey=value]* -- PROG ARGS...

PROFILE ni mfuatano wa maandishi ya SBPL wenye maingizo yanayosanidi sandbox. Kwa mfano, kipande kifuatacho cha SBPL hufanya /dev/null na /dev/zero ziweze kusomwa na kuandikwa chini ya sera ya sandbox:

Scheme

1
(allow file-read* file-test-existence file-write-data
2
(literal "/dev/null")
3
(literal "/dev/zero"))

Proksi ya mtandao inapowashwa kama sehemu ya mwito wa sandbox, sheria kama zifuatazo huingizwa katika wasifu ili kuruhusu miunganisho kwa milango inayofaa ya ndani pekee:

Scheme

1
; local HTTP proxy launched by Codex
2
(allow network-outbound (remote ip "localhost:3128"))
3

4
; local SOCKS proxy launched by Codex
5
(allow network-outbound (remote ip "localhost:8081"))


Wasifu wa msingi wa Codex huanza na
(deny default), hivyo miunganisho ya kutoka hubaki imezuiwa isipokuwa iruhusiwe wazi.

Hatimaye, SBPL inaweza kuwa na vishikilia nafasi kwa kutumia (param):

Scheme

1
; Pass -DWRITABLE_ROOT_0=/path/to/dir to specify a folder that cannot be removed.
2
(deny file-write-unlink
3
(require-all
4
(literal (param "WRITABLE_ROOT_0"))
5
(vnode-type DIRECTORY)))

ambavyo hujazwa na chaguo za -Dkey=value zinazopitishwa kwa sandbox-exec.

Ili kutekeleza API yake ya sandbox, Codex huunda orodha ya hoja⁠(fungua katika dirisha jipya) za sandbox-exec ikianzia kwa sera ya msingi⁠(fungua katika dirisha jipya), kisha hutumia permission_profile na muktadha mwingine kuirekebisha ili kutoa wasifu kamili wa Seatbelt. Wasifu unaopatikana na hoja za -D zinazoambatana nao husanidi vikwazo vinavyotekelezwa na Seatbelt, huku proksi ya mtandao ikitekeleza sheria za ziada za mtandao. Orodha kamili ya hoja ikiwa imeundwa, kuita sandbox-exec ni rahisi.

Kuunda SBPL sahihi ni changamoto kwa sababu Apple haitoi nyaraka za lugha hiyo kwa matumizi ya wahusika wengine. Kwa kweli, man sandbox-exec husema The sandbox-exec command is DEPRECATED (kama ilivyo pia kwa chaguo za kukokotoa la maktaba la sandbox_init() lililoelezwa kupitia man 3 sandbox_init). Licha ya onyo hilo la kuacha kutumika, macOS bado huja na wasifu wa Seatbelt katika /usr/share/sandbox, na programu za wahusika wengine, ikiwemo Google Chrome na Chromium⁠(fungua katika dirisha jipya), zinaendelea kutegemea Seatbelt. Kwa hiyo, tunapanga kuendelea kutumia Seatbelt kwa siku zijazo tunazoweza kutabiri.

Linux

Ili kuunda sandbox kwenye Linux, Codex hutumia mchanganyiko wa bubblewrap⁠(fungua katika dirisha jipya) (bwrap), zana ya mstari wa amri ya kuunda mazingira yaliyotengwa, na seccomp-bpf⁠(fungua katika dirisha jipya), mbinu ya kiini cha Linux ya kuchuja miito ya mfumo. Programu saidizi ya ndani iitwayo codex-linux-sandbox huratibu usanidi. Kama sandbox-exec kwenye macOS, hupokea usanidi wa sandbox ukifuatiwa na amri ya kuendesha:

Bash

1
codex-linux-sandbox SANDBOX_ARGS... -- PROG ARGS...

Utengaji wa mfumo wa faili au uelekezaji kupitia proksi unapohitajika, codex-linux-sandbox huita bwrap kuunda mazingira ya awali ya sandbox. Kisha bwrap huzindua codex-linux-sandbox --apply-seccomp-then-exec ndani yake. Mwito huu wa pili hutumia seccomp-bpf kuweka vikwazo vya ziada kabla ya kuendesha amri ya mtumiaji.

Ili kuunda mazingira hayo ya awali ya sandbox, Codex hutumia bubblewrap kuunda mwonekano wa mfumo wa faili katika nafasi tofauti ya majina ya viambatisho vya mfumo wa faili, unaoakisi sheria za mfumo wa faili za wasifu wa ruhusa. Kwa kuwa hii ni sehemu ya msingi ya utekelezaji wa sandbox, Codex hujumuisha nakala yake ya bwrap iwapo mtumiaji hajasakinisha yake, lakini hupendelea usakinishaji unaooana wa ⁠(fungua katika dirisha jipya)bwrap⁠(fungua katika dirisha jipya) unaopatikana kwenye PATH, ukiwepo. Tumeona kwamba baadhi ya matoleo ya Linux huzima ufikiaji wa nafasi za majina za watumiaji kwa chaguomsingi⁠(fungua katika dirisha jipya), lakini hutoa ruhusa maalum kwa bwrap ya mfumo.

Pia, kama sandbox-exec, bwrap hupokea usanidi wa sandbox ukifuatiwa na amri ya kuendesha ndani ya sandbox. Badala ya kutumia lugha maalum ya usanidi kama SBPL, bwrap hutumia bendera mahususi kwa usanidi. Codex hutumia chaguo zifuatazo kuunda mwonekano wa mfumo wa faili:

  • --bind kubainisha faili au saraka inayoweza kuandikwa

  • --ro-bind kubainisha faili au saraka ya kusoma pekee

  • --perms 000 --tmpfs DIR --remount-ro DIR kukataa ufikiaji wa DIR

  • --perms 000 --ro-bind-data FD FILE kukataa ufikiaji wa FILE (ambapo FD ni kitambulishi cha faili iliyofunguliwa cha /dev/null)

Ili kutumia michoro ya glob ya kukataa kupitia chaguo hizi, Codex huipanua kuwa njia halisi kabla ya kuzindua kila amri. Njia mpya zinazolingana haziongezwi kiotomatiki kwenye vikwazo vya sandbox vya amri hiyo.

Codex pia hubainisha chaguo kama --unshare-ipc na --unshare-pid ili kuzuia sandbox kufikia aina nyingine za rasilimali za kompyuta mwenyeji, hivyo bubblewrap huathiri zaidi ya mwonekano wa faili pekee.

Inapotumia bubblewrap, Codex hupitisha --unshare-net kila mtandao unapozimwa au miunganisho inapolazimika kupitia proksi ya mtandao, na hivyo kuunda nafasi mpya ya majina ya mtandao kwa sandbox. Kisha tunatumia seccomp-bpf kuweka vikwazo vya ziada kwa miito ya mfumo ya mtandao na familia za soketi zinazopatikana kwa amri.


Hasa, tunatumia
kifurushi cha seccompiler⁠(fungua katika dirisha jipya) kukusanya programu ya BPF wakati wa utekelezaji kulingana na vichujio vinavyotakiwa⁠(fungua katika dirisha jipya) na kuitumia kwa mchakato wa kuzindua ndani ya sandbox ili vikwazo virithiwe na mti mzima wa michakato. Kwa hiyo, bwrap haiendeshi amri ya mtumiaji, bali huendesha kizinduzi cha codex-linux-sandbox chenye hoja zake za usanidi zikifuatiwa na amri ya mtumiaji:

Bash

1
bwrap BWRAP_ARGS... -- \
2
codex-linux-sandbox --apply-seccomp-then-exec CODEX_LINUX_SANDBOX_ARGS... -- \
3
PROG ARGS...

Ili kutumia vichujio vya seccomp bila ruhusa za juu, kizinduzi huwasha bendera ya no_new_privs ya Linux⁠(fungua katika dirisha jipya). Bendera hii hurithiwa na michakato tanzu na kuizuia kupata ruhusa za ziada inapotekeleza programu nyingine, kama vile programu tekelezi ya setuid.

Vichujio vya seccomp hutegemea usanidi wa mtandao. Ufikiaji wa mtandao unapozimwa, tunazuia miito kadhaa ya mfumo inayohusiana na mtandao, kama vile connect(2) na bind(2). Hata hivyo, proksi ya mtandao inapowashwa ndani ya sandbox, tunaruhusu soketi za IP ili kisikilizaji cha TCP kilichoundwa na codex-linux-sandbox kifikiwe, lakini kwa chaguomsingi tunazuia uundaji wa soketi huru za kikoa cha Unix, kwani zinaweza kuwezesha ufikiaji usiokusudiwa wa rasilimali za kompyuta mwenyeji.

Kuunganisha kwa proksi ya mtandao

Usanidi wa sandbox unapohitaji proksi ya mtandao, mazingira ya uendeshaji ya Codex huunda proksi moja inayoweza kutumika tena katika miito mingi ya codex-linux-sandbox ndani ya mnyororo uleule wa mazungumzo ya Codex. Kila sandbox inahitaji njia ya kufikia proksi hiyo ya pamoja kutoka kwenye nafasi yake iliyotengwa ya majina ya mtandao. Codex hutoa kisikilizaji cha TCP cha loopback ndani ya nafasi hiyo ya majina na kuweka mchakato nje ya sandbox wa kukubali miunganisho yake na kuipitisha kwa proksi.

Michoro ifuatayo inaonyesha mpangilio huu kwa mwisho mmoja wa proksi, huku mchoro wa mwisho ukionyesha muunganisho mmoja unaoupitia. Kabla ya kuzindua bubblewrap, codex-linux-sandbox huunda jozi ya soketi za Unix kuwa njia ya udhibiti na kujigawa kuwa michakato miwili. Mchakato tanzu huendesha run_host_bridge() na kusubiri kupokea kitambulishi cha faili cha kisikilizaji kupitia njia hiyo:

Mchoro wa mazingira ya uendeshaji ya Codex yakianzisha codex-linux-sandbox, ambayo hujigawa kuunda mchakato wa kupitisha data uliounganishwa kupitia njia ya udhibiti ya soketi ya Unix.

Katika mfano huu, mchakato mzazi hutumia exec kubadilisha programu yake iliyo kwenye kumbukumbu na kuweka bwrap. Hii husanidi sandbox na kuzindua codex-linux-sandbox --apply-seccomp-then-exec ndani yake, huku ikipitisha FD ya njia ya udhibiti:

Mchoro unaoonyesha bwrap ikiunda nafasi ya majina ya mtandao ya sandbox na kuzindua codex-linux-sandbox ndani yake, pamoja na njia ya udhibiti ya soketi ya Unix inayounganisha na mchakato wa kupitisha data ulio nje ya sandbox.

Ndani ya nafasi ya majina ya mtandao ya sandbox, mwito wa pili wa codex-linux-sandbox huunda kisikilizaji cha TCP cha loopback na kupitisha kitambulishi chake cha faili kupitia soketi. Kisikilizaji hubaki kimehusishwa na nafasi ya majina ya mtandao ya sandbox. Hii huwezesha mchakato tanzu uliobaki nje ya sandbox kukubali miunganisho kutoka kwa programu zilizo ndani ya sandbox huku ukifungua miunganisho yake ya kwenda kwa proksi katika nafasi ya majina ya mtandao ya kompyuta mwenyeji. Baada ya kukabidhi, michakato yote miwili hufunga vitambulishi vyake vya njia ya udhibiti, na mchakato ulio ndani ya sandbox hufunga nakala yake ya kisikilizaji.

Kisikilizaji cha TCP kikiwa tayari, mchakato ndani ya sandbox huweka thamani inayofaa ya HTTP_PROXY⁠(fungua katika dirisha jipya) na vigezo vingine husika vya mazingira ili vielekeze kwenye kisikilizaji hicho. Kisha hutumia seccomp kabla ya kujigawa kuwa michakato miwili na kutekeleza amri ya mtumiaji:

Mchoro unaoonyesha programu iliyo ndani ya sandbox ikiunganishwa na kisikilizaji cha TCP cha loopback, huku mchakato wa kupitisha data wa codex-linux-sandbox ulio nje ukielekeza trafiki kwa proksi ya mtandao ya Codex.

Mchakato ulio nje ya sandbox huacha kisikilizaji kikiwa wazi. Kwa kila muunganisho unaokubaliwa, hufungua muunganisho kwa proksi iliyosanidiwa na kupitisha data pande zote mbili.

Utaratibu huu wa ziada huipa amri nafasi yake yenyewe ya majina ya mtandao, ikijumuisha kiolesura tofauti cha loopback. Kwenye macOS, Seatbelt huruhusu amri kuunganishwa moja kwa moja na milango iliyobainishwa kwenye kiolesura cha loopback cha kompyuta mwenyeji. Kwenye Linux, amri huunganishwa badala yake na kisikilizaji ndani ya nafasi yake iliyotengwa ya majina, na mchakato ulio nje ya sandbox hupitisha miunganisho hiyo kwa proksi iliyosanidiwa. Kukabidhi kitambulishi huwezesha muunganisho huu bila kuipa amri ufikiaji wa nafasi ya majina ya mtandao ya kompyuta mwenyeji.

Windows

Mapema mwaka huu, tulitekeleza na kuandika kuhusu juhudi zetu za kuweka sandbox kwenye Windows. Tangu wakati huo, Microsoft imetoa maktaba inayoitwa MXC pamoja na vipengele vipya vya kutenga michakato ndani ya mfumo wa uendeshaji wa Windows. Kwa sasa tunabadilisha sandbox yetu iliyopo na kuweka inayotumia maktaba ya MXC.

MXC ni nini?

MXC (Microsoft eXecution Container) ni mfumo wa kutekeleza msimbo ndani ya sandbox⁠(fungua katika dirisha jipya) kutoka Microsoft unaotumia mifumo kadhaa ya nyuma ya utengaji kwenye Windows, Linux na macOS. Codex inaweza kutumia sandbox inayotegemea MXC kwenye vifaa vya Windows vinavyooana nayo, ikitumia utengaji wa michakato uliojengwa ndani ya mfumo kuweka mipaka kwa amri ndani ya mazingira yaliyopo ya mtumiaji.

Tunahama kwenda MXC ili kuboresha usalama na urahisi wa matumizi huku tukitatua mapungufu kadhaa ya sandbox yetu ya sasa ya Windows:

  • Hitaji la ruhusa za juu/za msimamizi ili kusanidi sandbox

  • Ukaguzi na uwekaji wa ACL unaotumia rasilimali nyingi au unaochukua muda

  • Hali ya usanidi wa sandbox inayobaki kwenye kompyuta mwenyeji, ikijumuisha

    • ACL

    • Sheria za ngome

    • Watumiaji wa sandbox

    • Faili za safu ya udhibiti

MXC hutoa kielezo cha usanidi wa JSON⁠(fungua katika dirisha jipya). Codex hutumia MXC SDK⁠(fungua katika dirisha jipya) kuunda ombi la utekelezaji linalofuata kielezo hicho na lenye amri, saraka ya kazi, mazingira na ruhusa. Ruhusa hizo zinahusu ufikiaji wa mfumo wa faili na mtandao, pamoja na rasilimali za Windows kama vile eneo-kazi na ubao wa kunakili.

Kubadilisha sera kuwa mwito wa MXC

Codex hutumia mipangilio isiyobadilika kwa vidhibiti kadhaa ili kusawazisha uoanifu na usalama. Inaruhusu usomaji wa sajili na kudumisha ufikiaji wa Win32k na eneo-kazi ambao PowerShell inahitaji wakati wa kuanza. Ufikiaji wa ubao wa kunakili, uingizaji wa matukio ya kuingiza data, na vidhibiti vya eneo-kazi na mipangilio ya mfumo vimezimwa. Hatimaye, MXC inazuiwa kutumia ubadilishaji wa ruhusa za mfumo wa faili wa kompyuta mwenyeji kama njia mbadala.

Codex hubadilisha sheria za mfumo wa faili na mtandao za wasifu wa ruhusa kuwa usanidi wa MXC. Tukitumia wasifu wa awali wa dev, na kuchukulia kuwa:

  • C:\, D:\ na Z:\ ndizo hifadhi pekee za ndani za kompyuta.

  • Mzizi wa eneo la kazi na saraka ya kazi ni C:\work\demo.

  • Saraka ya nyumbani ya mtumiaji ni D:\Users\dev, hivyo ~/build-cache huelekeza kwenye D:\Users\dev\build-cache.

  • Mchoro wa glob wa kukataa unalingana na C:\work\demo\config\dev.env na C:\work\demo\config\prod.env pekee.

Mipangilio husika ya MXC ingejumuisha:

JSON

1
{
2
...
3
"filesystem": {
4
"readwritePaths": [
5
"C:\\work\\demo",
6
"D:\\Users\\dev\\build-cache",
7
...
8
],
9
"readonlyPaths": [
10
"C:\\",
11
"D:\\",
12
"Z:\\",
13
"C:\\work\\demo\\.agents",
14
"C:\\work\\demo\\.aws",
15
"C:\\work\\demo\\.codex",
16
"C:\\work\\demo\\.devcontainer",
17
"C:\\work\\demo\\.git",
18
"C:\\work\\demo\\.vscode",
19
...
20
],
21
"deniedPaths": [
22
"C:\\work\\demo\\config\\dev.env",
23
"C:\\work\\demo\\config\\prod.env",
24
"C:\\work\\demo\\secrets"
25
]
26
},
27
"network": {
28
"egress": {
29
"default": "deny",
30
"allow": [{
31
"to": [
32
{"cidr": "127.0.0.0/8"},
33
{"cidr": "::1/128"}
34
]
35
}]
36
},
37
"ingress": {
38
"default": "deny",
39
"hostLoopback": "allow"
40
}
41
},
42
...
43
}

Ufikiaji wa mizizi ya hifadhi

Sera ya mfumo wa faili ya MXC hukataa ufikiaji kwa chaguomsingi. Kwa hiyo, Codex huongeza ruhusa za kusoma pekee kwa mizizi ya hifadhi za ndani ili kuwezesha usomaji mpana unaoruhusiwa na wasifu huu. Ruhusa hizi hutumika hadi kwenye ngazi zote za chini, kulingana na ruhusa zilizopo za mtumiaji katika mfumo wa uendeshaji.

Kuna tofauti moja: ruhusa za kuandika kwenye mizizi ya hifadhi hazitumiki hadi kwenye ngazi zote za chini, hivyo Codex huzipanua kujumuisha faili na saraka zilizopo moja kwa moja chini ya mzizi wa hifadhi.

Ruhusa zinazokinzana

Njia mahususi zaidi hutangulia ruhusa za ngazi za juu, hivyo C:\work\demo inaweza kuruhusu kuandika chini ya C:\ ya kusoma pekee, huku C:\work\demo\.git ikibaki ya kusoma pekee.

Njia zilizoandikwa kwa namna tofauti au majina mbadala ya symlink/junction zikirejelea njia ileile, MXC hutumia ruhusa kali zaidi: kukataa hutangulia kusoma pekee, ambako hutangulia kusoma na kuandika.

Michoro ya glob ya kukataa

MXC hupokea njia halisi za kukataa pekee, hivyo Codex hupanua michoro ya glob ya kukataa kuwa faili na saraka zinazolingana kabla ya kuzindua. Njia mpya zinazolingana na glob haziongezwi kiotomatiki wakati amri inaendeshwa.

Ufikiaji wa mtandao

Sheria za vikoa kama vile *.openai.com hutekelezwa na proksi ya pamoja ya mtandao ya Codex iliyoelezwa awali. Codex huendesha proksi hiyo nje ya sandbox na kupitisha anwani zake kwa amri kupitia vigezo vilevile vya kawaida vya mazingira vya *_PROXY vilivyotajwa awali. MXC huzuia miunganisho ya moja kwa moja ya nje huku ikiruhusu miunganisho ya loopback ya kompyuta mwenyeji, ikijumuisha ufikiaji wa proksi. Huduma nyingine za ndani bado zinaweza kufikiwa.

Kwenye macOS, Linux na Windows, mazingira ya uendeshaji hutumia API ileile ya sandbox kuzindua amri chini ya wasifu wa ruhusa. Utekelezaji mahususi kwa kila jukwaa hushughulikia usanidi unaohitajika kuweka vikwazo hivyo.

Kujenga kwa msingi wa sandbox ya Codex

Kuandika na kutekeleza msimbo huwapa mawakala njia inayobadilika kulingana na mahitaji ya kutatua matatizo zaidi ya utengenezaji wa programu. Sandbox ya Codex huwawezesha kutumia uwezo huo katika mazingira yaliyopo ya mtumiaji yenye mipaka iliyo wazi ya ufikiaji wa mfumo wa faili na mtandao. Ni kipengele cha msingi kinachoweza kutumiwa tena ndani ya mazingira ya uendeshaji, na amri ya codex sandbox hukifanya kipatikane kwa zana unazojijengea.

Mawakala wanapochukua kazi zaidi, tunataka kufanya matumizi ya sandbox yawe rahisi kwa zana na mazingira mengi zaidi. Hii inamaanisha kurahisisha usanidi wa ruhusa na kutumia ulinzi bora wa mifumo ya uendeshaji unapopatikana. Lengo letu ni kupanua uwezo wa mawakala huku watu wakiendelea kudhibiti kile ambacho mawakala hao wanaweza kufikia.

Mwandishi

OpenAI

Shukrani

Shukrani za pekee kwa David Wiesen, Charlie Weems, Viyat Bhalodia na Fotis Chantzis kwa kuchangia makala haya.