Codex CLI helps each sandbox ranges and approval modes. These are likely to overlap; I’ve solely examined approval modes. Basically, the advice is to make use of auto mode if the folder you’re working in has a git repository, and to make use of read-only mode if it doesn’t.
▌ Choose Approval Mode
▌
▌ 1. Learn Solely Codex can learn recordsdata and reply questions. Codex requires
▌ approval to make edits, run instructions, or entry community
▌ > 2. Auto (present) Codex can learn recordsdata, make edits, and run instructions in
▌ the workspace. Codex requires approval to work exterior the
▌ workspace or entry community
▌ 3. Full Entry Codex can learn recordsdata, make edits, and run instructions with
▌ community entry, with out approval. Train warning
My first take a look at of codex was an outdated standby: explaining the Cline repo.
martinheller@Mac cline % codex
╭───────────────────────────────────────────╮
│ >_ OpenAI Codex (v0.42.0) │
│ │
│ mannequin: gpt-5-codex /mannequin to alter │
│ listing: /Volumes/Information/repos/cline │
╰───────────────────────────────────────────╯
To get began, describe a process or strive one in every of these instructions:
/init - create an AGENTS.md file with directions for Codex
/standing - present present session configuration
/approvals - select what Codex can do with out approval
/mannequin - select what mannequin and reasoning effort to make use of
▌ clarify this repository
• I am planning to discover the repository's construction by itemizing top-level recordsdata
first earlier than deciding learn how to strategy explaining it absolutely. Because it's probably a
reasonably advanced process involving a number of elements, I will put together to create
a plan to collect an outline and examine key recordsdata like README and manifests.
For now, I will use shell instructions within the repo path to get a listing itemizing.
• Up to date Plan
└ □ Examine repository construction and key configuration recordsdata.
□ Evaluate important supply directories to grasp performance.
□ Summarize repository goal, structure, and key elements for the
person.
• Explored
└ Listing ls
Learn README.md, package deal.json
Listing src
Learn extension.ts
Listing core
Learn README.md
Listing process
Learn index.ts
Listing webview-ui
Listing webview-ui
Listing checks
Listing specs
Listing proto
Listing standalone
Listing hosts
Listing vscode
Listing companies
Listing api
Listing suppliers
Listing api
Listing suppliers
• I’m gathering key components of the system just like the extension entrypoint, front-end
webview, the controller managing duties, the duty logic, gRPC host bridging,
and companies for terminal and net. I additionally need to spotlight the Mannequin Context
Protocol integration and look into checks, particularly these utilizing the testing-
platform and playwright. This provides a transparent map of how every little thing matches
collectively and what’s lined by checks.
• Explored
└ Listing testing-platform
Learn README.md
• Up to date Plan
└ ✔ Examine repository construction and key configuration recordsdata.
□ Evaluate important supply directories to grasp performance.
□ Summarize repository goal, structure, and key elements for the
person.
• Explored
└ Learn index.ts
Listing hostbridge
Listing packages
• Up to date Plan
└ ✔ Examine repository construction and key configuration recordsdata.
✔ Evaluate important supply directories to grasp performance.
□ Summarize repository goal, structure, and key elements for the
person.
• I’m gathering key file references with approximate begin strains to obviously
clarify the repository structure. Since precise line numbers aren’t sure,
I’ll embody paths with line 1 the place applicable—like for src/extension.ts:1
and src/core/controller/index.ts:1—to lend readability and credibility with out
overcommitting to specifics. I’ll contemplate checking webview-ui/package deal.json
subsequent to substantiate React utilization earlier than citing it.
• Explored
└ Learn package deal.json
Listing mcp
Listing browser
Listing integrations
Listing terminal
Listing evals
Learn README.md
• I’m placing collectively an intensive however concise overview of the VSCode AI
assistant extension, protecting its important components like activation, core
pipeline, controllers, process engine, companies, integrations, the React webview
UI, testing, evals, proto definitions, docs, and packaging. I plan to replace
the progress monitoring proper earlier than delivering the ultimate message.
• Up to date Plan
└ ✔ Examine repository construction and key configuration recordsdata.
✔ Evaluate important supply directories to grasp performance.
✔ Summarize repository goal, structure, and key elements for the
person.
• I’m organizing the ultimate message into clear sections with bullet factors like
Overview, Runtime Structure, AI & Tooling, and subsequent steps. I’ll embody
file path references with line numbers the place potential and probably peek into
supplier recordsdata to substantiate correct referencing. This manner, the person will get a
structured, easy-to-follow abstract of the mission.
• Explored
└ Learn openrouter.ts, TerminalManager.ts, McpHub.ts, App.tsx
Listing cline
Listing host
Learn BrowserSession.ts, ui.proto, ChatView.tsx
Search set up:all in package deal.json
Search "construct in package deal.json
Learn package deal.json
• Ran python - okay+': '+v).be a part of('n')"
└ vscode:prepublish: npm run package deal
compile: npm run check-types && npm run lint && node esbuild.mjs
… +7 strains
docs:rename-file: cd docs && npm run rename
report-issue: node scripts/report-issue.js
> Overview
- Cline markets itself as a human-in-the-loop agentic coding companion for
VSCode, combining editor, terminal, browser, and MCP tooling (README.md:1).
- Extension metadata, activation triggers, command registrations, and
market packaging stay in package deal.json:1, exhibiting it targets VSCode 1.84+
and ships below Apache-2.0.
- The core structure is documented as “extension → webview → controller →
process,” providing you with the top-level psychological mannequin for a way work strikes by the
system (src/core/README.md:1).
Runtime Circulate
- Activation bootstraps the host bridge, sidebar webview, diff suppliers,
and command palette entries earlier than handing management to the controller (src/
extension.ts:1).
- The controller handles workspace discovery, auth, telemetry, MCP lifecycle,
and state sync between the extension host and webview (src/core/controller/
index.ts:1).
- Job orchestration manages API calls, context home windows, software invocations,
checkpoints, and multi-step plans whereas streaming partial responses again to
the UI (src/core/process/index.ts:1).
- Protobuf contracts outline the bi-directional messages (asks, says, software
calls, UI instructions), letting the host, webview, and exterior shoppers discuss over
gRPC (proto/cline/ui.proto:1).
AI & Software Integrations
- A wealthy supplier layer wraps dozens of mannequin backends (OpenRouter, Anthropic,
Collectively, Bedrock, and many others.) with retryable streaming assist and per-model tuning
(src/core/api/suppliers/openrouter.ts:1 and friends).
- MCP Hub hundreds user-configured servers, watches configs, and proxies software/
useful resource calls so Cline can prolong itself with exterior capabilities (src/
companies/mcp/McpHub.ts:1).
- TerminalManager reuses VSCode terminals, streams shell output by way of the brand new
shell-integration hooks, and captures outcomes for the agent’s reasoning (src/
integrations/terminal/TerminalManager.ts:1).
- BrowserSession can launch or connect to Chromium and headless browsers to
automate net flows, accumulate screenshots, and floor console logs when duties
require it (src/companies/browser/BrowserSession.ts:1).
Frontend Webview
- The webview UI is a Vite/React app with Tailwind, Storybook, and Vitest,
bundled alongside the extension and constructed by way of devoted scripts (webview-
ui/package deal.json:1).
- Suppliers wrap context, telemetry, and gRPC shoppers earlier than rendering,
enabling server-driven state hydration and announcement dealing with within the
sidebar (webview-ui/src/App.tsx:1).
- ChatView composes messaging panes, token/price analytics, fast actions, and
slash-command tooling, powered by protobuf-backed gRPC shoppers shared with the
host (webview-ui/src/elements/chat/ChatView.tsx:1).
Testing & Ops
- A CLI-based testing platform spins up gRPC adapters and harnesses to
replay scripted conversations towards the standalone server or the extension
(testing-platform/README.md:1).
- Recorded session fixtures train chat flows, slash
instructions, and multi-root workspaces, enabling regression
checks with out re-running full UI checks (checks/specs/
grpc_recorded_session_chat___can_send_messages_and_switch_between_modes.json:1
).
- The evals suite benchmarks Cline throughout standardized coding duties, diff-edit
challenges, and mannequin comparisons, with a CLI that toggles the extension into
take a look at mode on demand (evals/README.md:1).
Subsequent steps:
1. Set up dependencies with npm run set up:all (root + webview) and generate
protobuf stubs by way of npm run protos.
2. For native growth, run npm run watch (host) in a single terminal and npm run
dev:webview in one other to iterate on the extension and sidebar UI collectively.
▌ Implement {function}
⏎ ship ⇧⏎ newline ⌃T transcript ⌃C give up 56.3K tokens used 91% context l
Token utilization: whole=56,294 enter=48,978 (+ 918,272 cached) output=7,316 (reasoning 4,160)
To proceed this session, run codex resume 01999c62-84cd-7e01-ab31-dd71d07da02b.
I’ve carried out this train with a number of massive language fashions (LLMs) which were skilled on code. That is among the many greatest summaries I’ve seen to date.
