Learn extra at:
Codex CLI helps each sandbox ranges and approval modes. These are inclined to overlap; I’ve solely examined approval modes. Normally, 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 outdoors 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 check of codex was an previous standby: explaining the Cline repo.
martinheller@Mac cline % codex
╭───────────────────────────────────────────╮
│ >_ OpenAI Codex (v0.42.0) │
│ │
│ mannequin: gpt-5-codex /mannequin to vary │
│ listing: /Volumes/Information/repos/cline │
╰───────────────────────────────────────────╯
To get began, describe a process or strive certainly one 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 how you can strategy explaining it absolutely. Because it's seemingly a
reasonably advanced process involving a number of parts, I am going to put together to create
a plan to assemble an summary and examine key recordsdata like README and manifests.
For now, I am going to use shell instructions within the repo path to get a listing itemizing.
• Up to date Plan
└ □ Examine repository construction and key configuration recordsdata.
□ Evaluation foremost supply directories to grasp performance.
□ Summarize repository objective, structure, and key parts for the
consumer.
• Explored
└ Record ls
Learn README.md, package deal.json
Record src
Learn extension.ts
Record core
Learn README.md
Record process
Learn index.ts
Record webview-ui
Record webview-ui
Record exams
Record specs
Record proto
Record standalone
Record hosts
Record vscode
Record providers
Record api
Record suppliers
Record api
Record 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 providers for terminal and net. I additionally need to spotlight the Mannequin Context
Protocol integration and look into exams, particularly these utilizing the testing-
platform and playwright. This offers a transparent map of how every little thing matches
collectively and what’s lined by exams.
• Explored
└ Record testing-platform
Learn README.md
• Up to date Plan
└ ✔ Examine repository construction and key configuration recordsdata.
□ Evaluation foremost supply directories to grasp performance.
□ Summarize repository objective, structure, and key parts for the
consumer.
• Explored
└ Learn index.ts
Record hostbridge
Record packages
• Up to date Plan
└ ✔ Examine repository construction and key configuration recordsdata.
✔ Evaluation foremost supply directories to grasp performance.
□ Summarize repository objective, structure, and key parts for the
consumer.
• I’m gathering key file references with approximate begin strains to obviously
clarify the repository structure. Since actual line numbers aren’t sure,
I’ll embody paths with line 1 the place acceptable—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 think about checking webview-ui/package deal.json
subsequent to substantiate React utilization earlier than citing it.
• Explored
└ Learn package deal.json
Record mcp
Record browser
Record integrations
Record terminal
Record evals
Learn README.md
• I’m placing collectively a radical however concise overview of the VSCode AI
assistant extension, protecting its foremost parts like activation, core
pipeline, controllers, process engine, providers, 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.
✔ Evaluation foremost supply directories to grasp performance.
✔ Summarize repository objective, structure, and key parts for the
consumer.
• 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 doable and presumably peek into
supplier recordsdata to substantiate correct referencing. This fashion, the consumer will get a
structured, easy-to-follow abstract of the venture.
• Explored
└ Learn openrouter.ts, TerminalManager.ts, McpHub.ts, App.tsx
Record cline
Record 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 - <<'PY'
│ import json
│ with open('package deal.json') as f:
│ … +4 strains
└ bash: can not create temp file for right here doc: Operation not permitted
• Ran node -p "Object.entries(require('./
│ package deal.json').scripts).map(([k,v])=>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, displaying it targets VSCode 1.84+
and ships beneath Apache-2.0.
- The core structure is documented as “extension → webview → controller →
process,” supplying you with the top-level psychological mannequin for a way work strikes by way of the
system (src/core/README.md:1).
Runtime Movement
- 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, device 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, device
calls, UI instructions), letting the host, webview, and exterior shoppers discuss over
gRPC (proto/cline/ui.proto:1).
AI & Instrument 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 device/
useful resource calls so Cline can prolong itself with exterior capabilities (src/
providers/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, gather screenshots, and floor console logs when duties
require it (src/providers/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/parts/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 exams (exams/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
check 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: complete=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 finished this train with a number of large language models (LLMs) which were educated on code. That is among the many greatest summaries I’ve seen to date.