fix(sdk): count structured read bytes in batch threshold estimate

Third and final instance of the structured-result gap. After the merge
with the batching PR, estimateOutdatedReclaimBytes still ignored
structured ToolOperationResult entries (only text/image/file), so its
pending-bytes counter stayed ~0 for real read_files results and the
128KB batch threshold never committed — batching was inert on production
transcripts (3-way sim showed fix+batch identical to no-fix).

Adds an else-if branch attributing the serialized bytes of an outdated
structured entry, mirroring replaceOutdatedReadContent.

3-way measurement (structured read-heavy, DeepSeek 10x cache pricing):
  A no rewrite (today):  40t $0.1723   120t $1.2395
  B fix + eager:         40t +28%       120t -27%
  C fix + batching:      40t -34%       120t -66%
The fix only pays off batched (B regresses short sessions by breaking
the cache every turn); combined it wins on both token volume and cache
stability.

Adds a regression test (structured stale read crosses a 2KB threshold
and commits); fails before this change.

.claude/hooks/claude-code-for-web-setup.sh

@@ -41,11 +41,11 @@ fi
 
 # Install project dependencies
 echo "Installing dependencies..."
-bun run install:all
+npm run install:all
 
 # Generate gRPC/protobuf types (required for TypeScript)
 echo "Generating proto types..."
-bun run protos
+npm run protos
 
 echo ""
 echo "Session setup complete!"

.clinerules/bun-and-node.md

@@ -1,55 +0,0 @@
-# Bun (tooling) and Node (runtime)
-
-This repo uses **bun** for package management and task running, and **Node** as
-the execution runtime. Both are correct at the same time; the distinction is the
-source of most confusion, so keep it straight before editing scripts, configs,
-docs, or comments.
-
-## Use bun for tooling
-
-- `bun install` (never `npm install` / `npm ci`)
-- `bun run <script>` (never `npm run <script>`)
-- `bunx <bin>` (never `npx <bin>`)
-- `bun <file>.ts` to run a TS entrypoint directly (no `ts-node` / `tsx`)
-- `bun esbuild.mjs` to drive the build (esbuild/vite are still the bundlers)
-- `bun run --parallel ...` for parallel tasks
-
-The root `bun.lock` is the single lockfile for the whole workspace, including
-`apps/vscode`, `webview-ui`, and `testing-platform`. There are no per-package npm
-lockfiles.
-
-## Node is the runtime — do NOT rewrite these to bun
-
-The build product runs on Node: the VS Code extension host loads
-`dist/extension.js` as CommonJS under Node, and the standalone `cline-core` is a
-Node process. The following are Node runtime/ABI references and are correct as-is:
-
-| Reference | Why it is Node |
-|-----------|----------------|
-| esbuild `platform: "node"` / `target: "node..."` | The bundle targets the Node runtime (extension host, standalone core). |
-| `TARGET_NODE_VERSION` (`scripts/package-standalone.mjs`) | Pins the Node ABI of the bundled standalone runtime (matches the JetBrains-packaged Node). |
-| `prebuild-install --target=<node version>` | Downloads native `.node` binaries for that Node ABI. |
-| `NODE_PATH=... node cline-core.js` | The standalone core is launched by Node, not bun. |
-| `node:` import specifiers (e.g. `node:fs`) | Node builtin module scheme; unrelated to tooling. |
-| `process.versions.node`, `engines.node`, `@types/node` | Runtime version probe / declared runtime / its types. |
-| `ELECTRON_RUN_AS_NODE` | VS Code/Electron runs the extension host as Node. |
-
-When a file legitimately uses both bun and node (e.g. `package-standalone.mjs`
-does `bun install` but `prebuild-install --target=<node>`), the `node` token is
-the runtime/ABI target, not tooling. If unsure, leave it.
-
-## Tests: bun vs the VS Code host
-
-A test file's runner is decided by its import:
-
-- **`import ... from "bun:test"`** → runs under `bun test` (the node-side unit
-  suites + the SDK/model-catalog suites). `scripts/run-bun-unit-tests.ts`
-  discovers these by the `bun:test` import and runs one isolated bun process per
-  file. `build-tests.js` excludes them from the integration compile so the
-  `bun:test` builtin never reaches Node.
-- **`import ... from "mocha"`** → runs under `@vscode/test-cli` in a real VS Code
-  extension host (Node). These exercise the live `vscode` API and cannot run
-  under bun.
-
-So a file imports `bun:test` XOR `mocha`. Don't add `bun:test` to a test that
-needs the real extension host.

.clinerules/debug-harness.md

@@ -1,128 +0,0 @@
-# Debug Harness
-
-HTTP-controlled debugger for the VSCode extension at `src/dev/debug-harness/server.ts`.
-
-## Quick start
-
-```bash
-# Build extension first if needed (protos + esbuild):
-bun run protos && IS_DEV=true bun esbuild.mjs
-
-# Launch (skip-build if already built):
-bun src/dev/debug-harness/server.ts --skip-build --auto-launch
-
-# In another terminal:
-curl localhost:19229/api -d '{"method":"status"}'
-```
-
-## Data Isolation
-
-The debugee runs with `CLINE_DIR=~/.cline2` by default, separate from your real `~/.cline`.
-This prevents the debugee's logout from logging out the debugger, and vice versa.
-Override with `--cline-dir /tmp/test-dir`. Check with `status()` → `clineDir`.
-
-## Browser Capture & OAuth
-
-The debugee runs with `CLINE_CAPTURE_BROWSER=1`, which intercepts `openExternal()` in
-`src/utils/env.ts`. URLs are captured instead of opening a real browser:
-
-- Logged to `$CLINE_DIR/data/debug-captured-urls.jsonl`
-- POSTed in real-time to `/captured-url` on the harness server
-- Queryable via `oauth.captured_urls`
-
-### OAuth API
-
-- **`oauth.captured_urls`** `{clear?}` — URLs the debugee tried to open
-- **`oauth.read_stored_token`** — Check auth token presence in secrets.json
-- **`oauth.simulate_callback`** `{path, code?, state?, provider?, token?}` — Build vscode:// callback URI
-- **`oauth.read_captured_urls_file`** — Read on-disk JSONL of captured URLs
-
-### OAuth testing flow
-
-For **Cline OAuth** (SDK local callback): The SDK starts a local HTTP server, the auth URL
-is captured. To complete: open the captured URL in a real browser (it redirects back to the
-SDK's callback server), OR extract the callback port and `curl http://127.0.0.1:PORT/callback?code=...`.
-
-For **MCP/Provider OAuth** (vscode:// URI): The redirect goes to a vscode:// URI.
-`oauth.simulate_callback` only *builds* the URI — it does not deliver it, and the ESM
-extension host can't `require()` the handler. To actually deliver the callback, call the
-debug-only hook via `ext.evaluate` (with `awaitPromise: true`):
-`globalThis.__clineHandleUri("vscode://saoudrizwan.claude-dev/...?code=...&state=...")`.
-It runs the same `SharedUriHandler.handleUri` as VSCode's real URI handler and exists only
-when `CLINE_CAPTURE_BROWSER` is set (the harness always sets it; never ships in prod).
-For end-to-end MCP OAuth, get a real `code` from the local MCP OAuth test server
-(`bun run dev:mcp-oauth-test-server`).
-
-## Navigating Views — Use Commands, Not Clicks
-
-Don't try to find/click small sidebar icons. Use VSCode commands via command palette.
-Registered in `src/registry.ts`:
-
-| Command | View |
-|---------|------|
-| `cline.accountButtonClicked` | Account / sign-in |
-| `cline.historyButtonClicked` | Task history |
-| `cline.settingsButtonClicked` | Settings |
-| `cline.mcpButtonClicked` | MCP servers |
-| `cline.plusButtonClicked` | New task (chat) |
-| `cline.worktreesButtonClicked` | Worktrees |
-
-```bash
-curl localhost:19229/api -d '{"method":"ui.command_palette","params":{"command":"cline.accountButtonClicked"}}'
-```
-
-## Key commands
-
-All via `POST localhost:19229/api` with `{"method":"...", "params":{...}}`:
-
-- **`launch`** / **`shutdown`** — lifecycle
-- **`ui.screenshot`** — screenshot to `/tmp/cline-debug/`; returns `{path}` — **use `read_file` on the path to examine, do NOT `open` the file** (Preview.app covers the VSCode window)
-- **`ui.open_sidebar`** — open the Cline sidebar
-- **`ext.set_breakpoint`** `{file, line, condition?}` — breakpoint by source file (sourcemap-resolved)
-- **`ext.evaluate`** `{expression, callFrameId?}` — eval in extension host
-- **`ext.resume`** / **`ext.step_over`** / **`ext.step_into`** — stepping
-- **`ext.call_stack`** — inspect when paused
-- **`web.evaluate`** `{expression}` — eval in webview
-- **`web.post_message`** `{message}` — send postMessage to extension host via exposed vsCodeApi
-- **`wait_for_pause`** `{timeout?}` — block until breakpoint hit
-- **`ui.locator`** `{role?, testId?, text?, frame?}` — Playwright locator (auto-retries on stale sidebar frame)
-- **`ui.react_input`** `{text, selector?, clear?, submit?}` — set React textarea value via `execCommand('insertText')`; works reliably across multiple tasks
-- **`ui.send_message`** `{text, images?, files?, responseType?}` — send chat message bypassing the textarea entirely (via gRPC postMessage)
-- **`ui.command_palette`** `{command}` — run VSCode command
-
-## Typical Session
-
-```bash
-# 1. Launch
-curl localhost:19229/api -d '{"method":"launch","params":{"skipBuild":true}}'
-
-# 2. Open sidebar + dismiss overlays (ALWAYS do this first)
-curl localhost:19229/api -d '{"method":"ui.open_sidebar"}'
-curl localhost:19229/api -d '{"method":"web.evaluate","params":{"expression":"document.querySelectorAll(\".sr-only\").forEach(el => el.parentElement?.click())"}}'
-
-# 3. Navigate to view
-curl localhost:19229/api -d '{"method":"ui.command_palette","params":{"command":"cline.accountButtonClicked"}}'
-
-# 4. Check captured OAuth URLs if testing auth
-curl localhost:19229/api -d '{"method":"oauth.captured_urls"}'
-
-# 5. Verify
-curl localhost:19229/api -d '{"method":"ui.screenshot"}'
-```
-
-## Caveats
-
-- **⚠️ Dismiss promotional overlays FIRST**: On fresh launches, full-screen promo overlays block the sidebar. **Dismiss immediately after `ui.open_sidebar`**, before any other interaction or screenshot. May need to run twice:
-  ```bash
-  curl localhost:19229/api -d '{"method": "ui.open_sidebar"}'
-  curl localhost:19229/api -d '{"method": "web.evaluate", "params": {"expression": "document.querySelectorAll(\".sr-only\").forEach(el => el.parentElement?.click())"}}'
-  ```
-- **Screenshots — don't open the file**: `ui.screenshot` and `ui.sidebar_screenshot` save PNGs to `/tmp/cline-debug/` and return the `{path}`. Use `read_file` on that path to examine screenshots. Running `open <path>` launches Preview.app on macOS which covers the VSCode window.
-- **Scripts count = 0 after launch**: CDP connects after extension host starts, so scripts parsed during startup aren't tracked. Breakpoints still work via sourcemap resolution.
-- **Port 9230**: Extension host inspector. If another VSCode instance uses this port, the harness will fail to connect. Kill other debug instances first.
-- **macOS only** for now (Playwright Electron launch behavior).
-- **Webview CDP**: `connect_webview` may fail depending on Electron version. `web.evaluate` still works via Playwright's `frame.evaluate()` fallback.
-- **Sourcemap paths**: esbuild outputs relative paths like `../src/extension.ts` in the sourcemap. The resolver handles this, but if a file isn't found, use `ext.source_files` to see exact paths.
-- **OAuth with fake codes**: Browser capture intercepts the URL but doesn't provide a valid auth code. For real OAuth testing, open the captured URL in a browser. For unit testing, mock the token exchange.
-
-See `src/dev/debug-harness/README.md` for full API reference.

.clinerules/general.md

@@ -13,56 +13,11 @@ This file is the secret sauce for working effectively in this codebase. It captu
 **What NOT to add:** Stuff you can figure out from reading a few files, obvious patterns, or standard practices. This file should be high-signal, not comprehensive.
 
 ## Miscellaneous
-- The whole repo (including `apps/vscode`) uses **bun** for package management and task running. Emit `bun run X` / `bun install` / `bunx <bin>` / `bun file.ts`, never npm/npx. Node remains the *runtime* (VS Code's extension host and the standalone cline-core are Node), so Node-runtime tokens are legitimate and must not be "fixed" to bun — see @.clinerules/bun-and-node.md for the keep-list vs rewrite-list.
-- Avoid provider-specific string matching / hardcoded provider branches when fixing provider/config plumbing. Prefer provider metadata, shared catalog/defaults, explicit protocol/client capabilities, or centralized normalization utilities that apply by data shape rather than `providerId === "..."`. If a provider exception seems necessary, stop and explain why instead of adding ad-hoc string matching.
-- This is a VS Code extension—check `package.json` for available scripts before trying to verify builds (e.g., `bun run compile`, not `bun run build`).
+- This is a VS Code extension—check `package.json` for available scripts before trying to verify builds (e.g., `npm run compile`, not `npm run build`).
 - When creating PRs, contributors should not create changelog-entry files. Maintainers handle release versioning and changelog curation during the release process.
 - When adding new feature flags, see this PR as a reference https://github.com/cline/cline/pull/7566
 - Additional instructions about making requests: @.clinerules/network.md
 
-## Searching the Codebase — Avoiding Build Output
-
-Several directories contain build output or generated code that produces
-noisy or unusable results with `search_files` / `grep`:
-
-| Directory | What it is | Why it's a problem |
-|-----------|-----------|-------------------|
-| `out/` | esbuild bundle output | Mirrors `src/` structure as minified JS — every search gets duplicate hits on single-line files |
-| `dist/` | Packaged extension | Entire extension bundled into one minified `extension.js` (~1 long line) |
-| `dist-standalone/` | Standalone build output | Same minification issue |
-| `src/generated/` | Generated protobuf code | Auto-generated from `proto/`; not the source of truth |
-| `src/shared/proto/` | Generated proto type defs | Auto-generated from `proto/`; not the source of truth |
-| `node_modules/` | Dependencies | Huge, not project source |
-
-### How to skip build output
-
-**`search_files`** — Point at `src/` (not the project root) and use `file_pattern`:
-```
-search_files(path="src/core", regex="myFunction", file_pattern="*.ts")
-```
-The `file_pattern` parameter is the most effective filter — e.g. `"*.ts"`,
-`"*.tsx"`, `"*.proto"`.
-
-**`grep` directly** — Exclude build dirs and restrict to source extensions:
-```bash
-grep -rn "myFunction" src/ --include="*.ts" --exclude-dir={out,dist,node_modules,generated}
-```
-
-### When you must search minified files
-
-Sometimes you need to verify what got bundled (e.g., checking if a change
-made it into the build). Minified files are typically one long line, so
-normal `grep` shows the entire file as context. Use these approaches:
-
-- **`grep -oP`** to extract just the match with limited surrounding context:
-  ```bash
-  grep -oP '.{0,40}myFunction.{0,40}' dist/extension.js
-  ```
-- **`read_file`** on files in `out/src/` — these have source maps and are
-  more readable than `dist/extension.js` (which is the fully bundled output).
-- **Source maps** — `out/src/*.js.map` and `dist/extension.js.map` can be
-  used to trace minified output back to original source locations.
-
 ## gRPC/Protobuf Communication
 The extension and webview communicate via gRPC-like protocol over VS Code message passing.
 
@@ -73,7 +28,7 @@ The extension and webview communicate via gRPC-like protocol over VS Code messag
 - Naming: Services `PascalCaseService`, RPCs `camelCase`, Messages `PascalCase`
 - For streaming responses, use `stream` keyword (see `subscribeToAuthCallback` in `account.proto`)
 
-**Run `bun run protos`** after any proto changes—generates types in:
+**Run `npm run protos`** after any proto changes—generates types in:
 - `src/shared/proto/` - Shared type definitions
 - `src/generated/grpc-js/` - Service implementations
 - `src/generated/nice-grpc/` - Promise-based clients
@@ -93,6 +48,93 @@ The extension and webview communicate via gRPC-like protocol over VS Code messag
 - `src/core/controller/task/explainChanges.ts` - Handler implementation
 - `webview-ui/src/components/chat/ChatRow.tsx` - UI rendering
 
+## Adding a New API Provider
+When adding a new provider (e.g., "openai-codex"), you must update the proto conversion layer in THREE places or the provider will silently reset to Anthropic:
+
+1. `proto/cline/models.proto` - Add to the `ApiProvider` enum (e.g., `OPENAI_CODEX = 40;`)
+2. `convertApiProviderToProto()` in `src/shared/proto-conversions/models/api-configuration-conversion.ts` - Add case mapping string to proto enum
+3. `convertProtoToApiProvider()` in the same file - Add case mapping proto enum back to string
+
+**Why this matters:** Without these, the provider string hits the `default` case and returns `ANTHROPIC`. The webview, provider list, and handler all work fine, but the state silently resets when it round-trips through proto serialization. No error is thrown.
+
+**Other files to update when adding a provider:**
+- `src/shared/api.ts` - Add to `ApiProvider` union type, define models
+- `src/shared/providers/providers.json` - Add to provider list for dropdown
+- `src/core/api/index.ts` - Register handler in `createHandlerForProvider()`
+- `webview-ui/src/components/settings/utils/providerUtils.ts` - Add cases in `getModelsForProvider()` and `normalizeApiConfiguration()`
+- `webview-ui/src/utils/validate.ts` - Add validation case
+- `webview-ui/src/components/settings/ApiOptions.tsx` - Render provider component
+
+## Responses API Providers (OpenAI Codex, OpenAI Native)
+Providers using OpenAI's Responses API require native tool calling. XML tools don't work with the Responses API.
+
+**Symptoms of broken native tool calling:**
+- Tools get called multiple times (e.g., `ask_followup_question` asks the same question twice)
+- Tool arguments get duplicated or malformed
+- The model responds but tools aren't recognized
+
+**Root causes to check:**
+1. **Provider missing from `isNextGenModelProvider()`** in `src/utils/model-utils.ts`. The native variant matchers (e.g., `native-gpt-5/config.ts`) call this function. If your provider isn't in the list, the matcher returns false and falls back to XML tools.
+
+2. **Model missing `apiFormat: ApiFormat.OPENAI_RESPONSES`** in its model info (`src/shared/api.ts`). This property signals that the model requires native tool calling. The task runner in `src/core/task/index.ts` checks this and forces `enableNativeToolCalls: true` regardless of user settings.
+
+**When adding a new Responses API provider:**
+1. Add provider to `isNextGenModelProvider()` list in `src/utils/model-utils.ts`
+2. Set `apiFormat: ApiFormat.OPENAI_RESPONSES` on all models that use the Responses API
+3. The variant matcher and task runner will handle the rest automatically
+
+## Adding Tools to System Prompt
+This is tricky—multiple prompt variants and configs. **Always search for existing similar tools first and follow their pattern.** Look at the full chain from prompt definition → variant configs → handler → UI before implementing.
+
+1. **Add to `ClineDefaultTool` enum** in `src/shared/tools.ts`
+2. **Tool definition** in `src/core/prompts/system-prompt/tools/` (create file like `generate_explanation.ts`)
+   - Define variants for each `ModelFamily` (generic, next-gen, xs, etc.)
+   - Export variants array (e.g., `export const my_tool_variants = [GENERIC, NATIVE_NEXT_GEN, XS]`)
+   - **Fallback behavior**: If a variant isn't defined for a model family, `ClineToolSet.getToolByNameWithFallback()` automatically falls back to GENERIC. So you only need to export `[GENERIC]` unless the tool needs model-specific behavior.
+3. **Register in `src/core/prompts/system-prompt/tools/init.ts`** - Import and spread into `allToolVariants`
+4. **Add to variant configs** - Each model family has its own config in `src/core/prompts/system-prompt/variants/*/config.ts`. Add your tool's enum to the `.tools()` list:
+   - `generic/config.ts`, `next-gen/config.ts`, `gpt-5/config.ts`, `native-gpt-5/config.ts`, `native-gpt-5-1/config.ts`, `native-next-gen/config.ts`, `gemini-3/config.ts`, `glm/config.ts`, `hermes/config.ts`, `xs/config.ts`
+   - **Important**: If you add to a variant's config, make sure the tool spec exports a variant for that ModelFamily (or relies on GENERIC fallback)
+5. **Create handler** in `src/core/task/tools/handlers/`
+6. **Wire up in `ToolExecutor.ts`** if needed for execution flow
+7. **Add to tool parsing** in `src/core/assistant-message/index.ts` if needed
+8. **If tool has UI feedback**: add `ClineSay` enum in proto, update `src/shared/ExtensionMessage.ts`, update `src/shared/proto-conversions/cline-message.ts`, update `webview-ui/src/components/chat/ChatRow.tsx`
+
+## Modifying System Prompt
+**Read these first:** `src/core/prompts/system-prompt/README.md`, `tools/README.md`, `__tests__/README.md`
+
+System prompt is modular: **components** (reusable sections) + **variants** (model-specific configs) + **templates** (with `{{PLACEHOLDER}}` resolution).
+
+**Key directories:**
+- `components/` - Shared sections: `rules.ts`, `capabilities.ts`, `editing_files.ts`, etc.
+- `variants/` - Model-specific: `generic/`, `next-gen/`, `xs/`, `gpt-5/`, `gemini-3/`, `hermes/`, `glm/`, etc.
+- `templates/` - Template engine and placeholder definitions
+
+**Variant tiers (ask user which to modify):**
+- **Next-gen** (Claude 4, GPT-5, Gemini 2.5): `next-gen/`, `native-next-gen/`, `native-gpt-5/`, `native-gpt-5-1/`, `gemini-3/`, `gpt-5/`
+- **Standard** (default fallback): `generic/`
+- **Local/small models**: `xs/`, `hermes/`, `glm/`
+
+**How overrides work:** Variants can override components via `componentOverrides` in their `config.ts`, or provide a custom template in `template.ts` (e.g., `next-gen/template.ts` exports `rules_template`). If no override, the shared component from `components/` is used.
+
+**Example: Adding a rule to RULES section**
+1. Check if variant overrides rules: look for `rules_template` in `variants/*/template.ts` or `componentOverrides.RULES` in `config.ts`
+2. If shared: modify `components/rules.ts`
+3. If overridden: modify that variant's template
+4. XS variant is special—has heavily condensed inline content in `template.ts`
+
+**After any changes, regenerate snapshots:**
+```bash
+UPDATE_SNAPSHOTS=true npm run test:unit
+```
+Snapshots live in `__tests__/__snapshots__/`. Tests validate across model families and context variations (browser, MCP, focus chain).
+
+## Modifying Default Slash Commands
+Three places need updates:
+- `src/core/slash-commands/index.ts` - Command definitions
+- `src/core/prompts/commands.ts` - System prompt integration
+- `webview-ui/src/utils/slash-commands.ts` - Webview autocomplete
+
 ## Adding New Global State Keys
 Adding a new key to global state requires updates in multiple places. Missing any step causes silent failures.
 
@@ -109,7 +151,7 @@ Settings plumbing gotcha: if a key is user-toggleable from settings, wire both c
 Missing one path causes a toggle to appear to change in one surface while the backend state stays unchanged.
 
 Webview toggle gotcha: settings changes must also round-trip back in state payloads.
-- Add the field to `UpdateSettingsRequest` in `proto/cline/state.proto` (for webview update requests), then run `bun run protos`
+- Add the field to `UpdateSettingsRequest` in `proto/cline/state.proto` (for webview update requests), then run `npm run protos`
 - Include the key in `Controller.getStateToPostToWebview()` (`src/core/controller/index.ts`)
 - Ensure `ExtensionState` and webview defaults include the key (`src/shared/ExtensionMessage.ts`, `webview-ui/src/context/ExtensionStateContext.tsx`)
 If this round-trip wiring is missing, the backend value can update but the toggle in webview appears stuck or reverts.
@@ -157,48 +199,3 @@ const isGenerating = explanationInfo.status === "generating" && !wasCancelled
 **See also:** `BrowserSessionRow.tsx` uses similar pattern with `isLastApiReqInterrupted` and `isLastMessageResume`.
 
 **Backend side:** When streaming is cancelled, clean up properly (close tabs, clear comments, etc.) by checking `taskState.abort` after the streaming function returns.
-
-## Debug Harness: clear inherited VSCode/Electron env vars before launching
-
-The debug harness (`apps/vscode/src/dev/debug-harness/server.ts`) launches a child
-VSCode via Playwright's `_electron.launch({ env: { ...process.env, ... } })`. If you
-run the harness from a process that was itself spawned by VSCode (e.g. the Cline
-extension host, an integrated terminal, or an agent running inside VSCode), the
-parent's VSCode/Electron env vars leak into the child and break the launch.
-
-The fatal one is **`ELECTRON_RUN_AS_NODE=1`**: it makes the child VSCode binary run
-as plain Node, so it rejects every VSCode CLI flag. Symptom:
-
-```
-.../Visual Studio Code.app/Contents/MacOS/Code: bad option: --extensionDevelopmentPath=...
-Error: Process failed to launch!   (Playwright _electron.launch)
-```
-
-This is NOT the macOS Playwright flakiness mentioned in the harness README — it's
-env inheritance. Fix: strip the inherited vars before starting the harness:
-
-```bash
-env -u ELECTRON_RUN_AS_NODE -u ELECTRON_NO_ATTACH_CONSOLE \
-    -u VSCODE_CLI -u VSCODE_CODE_CACHE_PATH -u VSCODE_CRASH_REPORTER_PROCESS_TYPE \
-    -u VSCODE_CWD -u VSCODE_ESM_ENTRYPOINT -u VSCODE_HANDLES_UNCAUGHT_ERRORS \
-    -u VSCODE_IPC_HOOK -u VSCODE_NLS_CONFIG -u VSCODE_PID -u VSCODE_L10N_BUNDLE_LOCATION \
-    bun src/dev/debug-harness/server.ts --auto-launch --skip-build
-```
-
-Check your own env with `env | grep -iE 'electron|vscode_'` first; `ELECTRON_RUN_AS_NODE=1`
-present means you must scrub before launching.
-
-Other harness notes confirmed in practice:
-- The extension host is **ESM** (`VSCODE_ESM_ENTRYPOINT`), so `ext.evaluate` has no
-  `require` and module-internal functions aren't reachable as globals. To inspect
-  internal builders (e.g. `buildBedrockProviderConfig`), set a breakpoint with
-  `ext.set_breakpoint` and read locals via `ext.evaluate` with the paused `callFrameId`
-  — don't try to `require()` the bundle.
-- `web.evaluate` wraps the expression as a single returned expression; multi-statement
-  snippets must be an IIFE `(() => { ...; return x; })()`, otherwise you get
-  `SyntaxError: Unexpected token ';'`.
-- Webview settings inputs are `vscode-text-field` web components with debounced React
-  onChange. Setting `.value` + dispatching events via `web.evaluate` is unreliable for
-  some fields; focus the inner shadow `input` then use real keystrokes (`ui.type` +
-  `ui.press Tab`, or click the dropdown option) to make the value persist.
-

.clinerules/protobuf-development.md

@@ -42,7 +42,7 @@ Here, we use the common `StringRequest` and `KeyValuePair` types.
 
 After editing a `.proto` file, regenerate the TypeScript code. From the project root, run:
 ```bash
-bun run protos
+npm run protos
 ```
 This command compiles all `.proto` files and outputs the generated code to `src/generated/` and `src/shared/`. Do not edit these generated files manually.
 

.clinerules/sdk-migration.md

@@ -1,26 +0,0 @@
-# SDK Adapter
-
-The VSCode extension runs on the Cline SDK (`@cline/core`, `@cline/llms`,
-`@cline/shared`) through an adapter layer in `apps/vscode/src/sdk/`. The
-webview still talks gRPC; the adapter translates between gRPC handlers and SDK
-calls. See `apps/vscode/src/dev/debug-harness/README.md` for the debug harness.
-
-## Conventions
-
-1. **Look up SDK APIs, don't guess.** Use `kb_search(name="sdk", query="...")`
-   before implementing against an SDK surface.
-2. **Reference the pre-SDK implementation when replacing a module.** Add a
-   `// Replaces classic src/core/... (see origin/main)` header and use
-   `kb_search(name="cline", commit="origin/main")` or
-   `git show origin/main:path` to consult the prior implementation.
-3. **Single entry point.** There is one codepath — the SDK adapter. No
-   `CLINE_SDK` env flag.
-4. **Use `{appBaseUrl}`**, never hardcode `app.cline.bot`.
-5. **Avoid `as` casts.** Use explicit conversion functions with tests. The
-   branded types in `apps/vscode/src/sdk/model-catalog/contracts.ts` exist so
-   casts are unnecessary outside parse/compute boundaries.
-
-## Debug harness
-
-- **Dismiss the Kanban/promo overlay** before any debug harness interaction.
-- **Use the command palette** to navigate tabs in the debug harness.

.clinerules/workflows/hotfix-release.md

@@ -91,7 +91,7 @@ On the main branch, create a commit that updates:
 
 3. No changelog-entry file cleanup is needed. Contributors do not create changelog-entry files in this repo.
 
-**No dependency install is needed.** A CHANGELOG + `version` bump does not change any dependency, and `bun.lock` does not pin workspace-package versions, so the lockfile stays consistent. The publish workflow runs `bun install --frozen-lockfile`, which would *fail* on an out-of-sync lock — so only run `bun install` here if you actually change dependencies (then commit the updated `bun.lock`).
+**Skip running `npm run install:all`** - release automation handles lockfile consistency as needed.
 
 Commit with message format: `v{VERSION} Release Notes (hotfix)`
 

.github/copilot-instructions.md

@@ -9,14 +9,14 @@ This is a VS Code extension. Read `.clinerules/general.md` for tribal knowledge
 - **MCP**: `src/services/mcp/McpHub.ts`.
 
 ## Build & Test (Critical — non-obvious commands)
-- **Build**: `bun run compile` — NOT `bun run build`.
-- **Watch**: `bun run watch` (extension + webview).
-- **Protos**: `bun run protos` — run **immediately** after any `.proto` change. Generates into `src/shared/proto/`, `src/generated/`.
-- **Tests**: `bun run test:unit`. After prompt/tool changes: `UPDATE_SNAPSHOTS=true bun run test:unit`.
+- **Build**: `npm run compile` — NOT `npm run build`.
+- **Watch**: `npm run watch` (extension + webview).
+- **Protos**: `npm run protos` — run **immediately** after any `.proto` change. Generates into `src/shared/proto/`, `src/generated/`.
+- **Tests**: `npm run test:unit`. After prompt/tool changes: `UPDATE_SNAPSHOTS=true npm run test:unit`.
 
 ## Protobuf RPC Workflow (4 steps)
 1. **Define** in `proto/cline/*.proto`. Naming: `PascalCaseService`, `camelCase` RPCs, `PascalCase` Messages. Use `common.proto` shared types for simple data.
-2. **Generate**: `bun run protos`.
+2. **Generate**: `npm run protos`.
 3. **Backend handler**: `src/core/controller/<domain>/`. 
 4. **Frontend call**: `UiServiceClient.myMethod(Request.create({...}))`.
 - Adding enums (e.g. `ClineSay`) → also update `src/shared/proto-conversions/cline-message.ts`.
@@ -38,7 +38,7 @@ For Responses API providers: add to `isNextGenModelProvider()` in `src/utils/mod
 4. Whitelist in `src/core/prompts/system-prompt/variants/*/config.ts` for each model family.
 5. Handler in `src/core/task/tools/handlers/`, wire in `ToolExecutor.ts`.
 6. If tool has UI: add `ClineSay` enum in proto → `ExtensionMessage.ts` → `cline-message.ts` → `ChatRow.tsx`.
-7. Regenerate snapshots: `UPDATE_SNAPSHOTS=true bun run test:unit`.
+7. Regenerate snapshots: `UPDATE_SNAPSHOTS=true npm run test:unit`.
 
 ## Modifying System Prompt
 Modular: `components/` (shared) + `variants/` (model-specific) + `templates/` (`{{PLACEHOLDER}}`). Variants override components via `componentOverrides` in `config.ts` or custom `template.ts`. XS variant is heavily condensed inline. Always regenerate snapshots after changes.

.github/pull_request_template.md

@@ -59,7 +59,7 @@ We're not looking for exhaustive documentation - just evidence that you've thoug
 <!-- Put an 'x' in all boxes that apply -->
 
 -   [ ] Changes are limited to a single feature, bugfix or chore (split larger changes into separate PRs)
--   [ ] Tests are passing (`bun test`) and code is formatted and linted (`bun run format && bun run lint`)
+-   [ ] Tests are passing (`npm test`) and code is formatted and linted (`npm run format && npm run lint`)
 -   [ ] I have reviewed [contributor guidelines](https://github.com/cline/cline/blob/main/CONTRIBUTING.md)
 
 ### Screenshots

.github/workflows/ext-vscode-publish-nightly.yml

@@ -31,9 +31,6 @@ jobs:
     if: github.repository == 'cline/cline' && (github.ref == 'refs/heads/main' || github.ref == 'refs/heads/dpc/sdk-migration-simpler-login')
     runs-on: ubuntu-latest
     environment: PublishNightly
-    # The VS Code extension's package.json and lockfiles live under apps/vscode/
-    # (the repo root has no package.json). Mirror ext-vscode-test.yml so install
-    # and publish steps run in the correct workspace.
     defaults:
       run:
         working-directory: apps/vscode
@@ -53,47 +50,21 @@ jobs:
           echo "Building sha: $GITHUB_SHA"
           git --no-pager log -1 --oneline
 
-      - name: Setup Bun
-        uses: oven-sh/setup-bun@v2
-        with:
-          bun-version: 1.3.14
-
-      # Node is still REQUIRED in the publish job (not just for install): the publish
-      # scripts run as `node ./scripts/publish-*.mjs` and shell out to `npx ovsx`.
-      # setup-bun does not provide a Node runtime, so keep setup-node here.
-      # Pinned to Node 22 because newer LTS (Node 24 / npm 11) can make vsce's
-      # `npm list` dependency detection fail with ELSPROBLEMS during packaging.
       - name: Setup Node.js
         uses: actions/setup-node@v4
         with:
+          # Keep publish environment aligned with test workflow/tooling lockfile expectations.
+          # Newer LTS (Node 24 / npm 11) can make `npm list` fail with ELSPROBLEMS during vsce packaging.
           node-version: 22
 
-      # Single root install resolves the whole bun workspace at once (replaces the
-      # per-package `npm ci` steps for apps/vscode + webview-ui).
-      - name: Install workspace dependencies
+      - name: Install extension dependencies
         working-directory: ${{ github.workspace }}
-        run: bun install --frozen-lockfile
+        run: npm --prefix apps/vscode ci --include=optional
 
-      # @cline/* are local workspace symlinks to source packages; build dist/ before
-      # packaging/publishing the extension.
-      - name: Build SDK packages
+      - name: Install webview-ui dependencies
         working-directory: ${{ github.workspace }}
-        run: bun run build:sdk
+        run: npm --prefix apps/vscode/webview-ui ci --include=optional
 
-      - name: Assert better-sqlite3 native binary present
-        run: |
-          NODE_FILE="node_modules/better-sqlite3/build/Release/better_sqlite3.node"
-          if [ ! -f "$NODE_FILE" ]; then
-            echo "ERROR: better-sqlite3 native binary missing at apps/vscode/$NODE_FILE"
-            echo "(bun trustedDependencies postinstall likely did not run)"
-            exit 1
-          fi
-          echo "Found better-sqlite3 native binary: $NODE_FILE"
-
-      # vsce is now a workspace devDependency (on node_modules/.bin), but ovsx is not
-      # vendored and the publish script invokes it via `npx ovsx`, so install ovsx
-      # globally here (npm is available via setup-node). vsce is installed globally
-      # too to preserve the script's existing PATH expectations.
       - name: Install Publishing Tools
         run: npm install -g @vscode/vsce ovsx
 
@@ -111,9 +82,7 @@ jobs:
           OTEL_EXPORTER_OTLP_PROTOCOL: ${{ secrets.OTEL_EXPORTER_OTLP_PROTOCOL }}
           OTEL_EXPORTER_OTLP_ENDPOINT: ${{ secrets.OTEL_EXPORTER_OTLP_ENDPOINT }}
           OTEL_EXPORTER_OTLP_HEADERS: ${{ secrets.OTEL_EXPORTER_OTLP_HEADERS }}
-        # The script itself runs under `node ./scripts/publish-nightly.mjs`; bun run
-        # just launches it. Node + npm (for `npx ovsx`) are provided by setup-node above.
-        run: bun run publish:marketplace:nightly
+        run: npm run publish:marketplace:nightly
 
       - name: Tag published commit
         working-directory: ${{ github.workspace }}

.github/workflows/ext-vscode-publish-stable.yml

@@ -109,48 +109,19 @@ jobs:
                   echo "tag=$TAG" >> $GITHUB_OUTPUT
                   echo "resolved_sha=$(git rev-parse HEAD)" >> $GITHUB_OUTPUT
 
-            - name: Setup Bun
-              uses: oven-sh/setup-bun@v2
-              with:
-                  bun-version: 1.3.14
-
-            # Node is still REQUIRED in the publish job (not just for install): the
-            # publish scripts run as `node scripts/publish-*.mjs`, the version step uses
-            # `node -p`, and `npx ovsx` needs npm. setup-bun does not provide a Node
-            # runtime, so keep setup-node. Pinned to Node 22 because newer LTS
-            # (Node 24 / npm 11) can make vsce's `npm list` detection fail with
-            # ELSPROBLEMS during packaging.
             - name: Setup Node.js
               uses: actions/setup-node@v4
               with:
                   node-version: 22
 
-            # Single root install resolves the whole bun workspace at once (replaces the
-            # per-package `npm install` steps for apps/vscode + webview-ui).
-            - name: Install workspace dependencies
+            - name: Install extension dependencies
               working-directory: ${{ github.workspace }}
-              run: bun install --frozen-lockfile
+              run: npm --prefix apps/vscode install --include=optional
 
-            # @cline/* are local workspace symlinks to source packages; build dist/ before
-            # packaging/publishing the extension.
-            - name: Build SDK packages
+            - name: Install webview-ui dependencies
               working-directory: ${{ github.workspace }}
-              run: bun run build:sdk
+              run: npm --prefix apps/vscode/webview-ui install --include=optional
 
-            - name: Assert better-sqlite3 native binary present
-              run: |
-                  NODE_FILE="node_modules/better-sqlite3/build/Release/better_sqlite3.node"
-                  if [ ! -f "$NODE_FILE" ]; then
-                    echo "ERROR: better-sqlite3 native binary missing at apps/vscode/$NODE_FILE"
-                    echo "(bun trustedDependencies postinstall likely did not run)"
-                    exit 1
-                  fi
-                  echo "Found better-sqlite3 native binary: $NODE_FILE"
-
-            # vsce is a workspace devDependency (on node_modules/.bin), but ovsx is not
-            # vendored and the publish script invokes it via `npx ovsx`, so install ovsx
-            # globally (npm is available via setup-node). vsce is installed globally too
-            # to preserve the script's existing PATH expectations.
             - name: Install Publishing Tools
               run: npm install -g @vscode/vsce ovsx
 
@@ -193,20 +164,14 @@ jobs:
                   node scripts/marketplace-readme.mjs swap-in
                   trap 'node scripts/marketplace-readme.mjs restore' EXIT
 
-                  # Required to generate the .vsix. --no-dependencies: the extension
-                  # is fully esbuild-bundled, and under the bun workspace the @cline/*
-                  # deps are symlinks pointing outside the package, so without this vsce
-                  # would walk them and pull the whole monorepo into the .vsix.
-                  vsce package --no-dependencies --allow-package-secrets sendgrid --out "cline-${{ steps.get_version.outputs.version }}.vsix"
+                  # Required to generate the .vsix
+                  vsce package  --allow-package-secrets sendgrid --out "cline-${{ steps.get_version.outputs.version }}.vsix"
 
-                  # These scripts run under `node scripts/publish-marketplace.mjs`;
-                  # bun run just launches them. Node + npm (for `npx ovsx`) come from
-                  # setup-node above.
                   if [ "$RELEASE_TYPE" = "pre-release" ]; then
-                    bun run publish:marketplace:prerelease
+                    npm run publish:marketplace:prerelease
                     echo "Successfully published pre-release version ${{ steps.get_version.outputs.version }} to VS Code Marketplace and Open VSX Registry"
                   else
-                    bun run publish:marketplace
+                    npm run publish:marketplace
                     echo "Successfully published release version ${{ steps.get_version.outputs.version }} to VS Code Marketplace and Open VSX Registry"
                   fi
 

.github/workflows/ext-vscode-test-e2e.yml

@@ -45,16 +45,12 @@ jobs:
                           - 'apps/vscode/assets/**'
                           - 'apps/vscode/walkthrough/**'
                           - 'apps/vscode/package.json'
-                          - 'apps/vscode/webview-ui/package.json'
-                          # Root bun lockfile is authoritative for the whole workspace (incl. apps/vscode).
-                          - 'bun.lock'
-                          # SDK source packages are local workspace symlinks (@cline/*), so SDK changes affect the build.
-                          - 'sdk/packages/**'
+                          - 'apps/vscode/package-lock.json'
                           - 'apps/vscode/buf.yaml'
                           - 'apps/vscode/tsconfig*.json'
                           - 'apps/vscode/biome.jsonc'
                           - 'apps/vscode/esbuild.mjs'
-                          - 'apps/vscode/bunfig.toml'
+                          - 'apps/vscode/.mocharc.json'
                           - 'apps/vscode/.vscode-test.mjs'
                           - 'apps/vscode/.vscodeignore'
                           - 'apps/vscode/playwright*.ts'
@@ -88,20 +84,26 @@ jobs:
                 working-directory: apps/vscode
         steps:
             - uses: actions/checkout@v4
-            - name: Setup Bun
-              uses: oven-sh/setup-bun@v2
+            - name: Setup Node.js environment
+              uses: actions/setup-node@v4
               with:
-                  bun-version: 1.3.14
+                  node-version: 22
 
-            # Cache Bun's global install cache - keyed on the authoritative root bun.lock.
-            - name: Cache Bun install cache
+            # Cache root dependencies - only reuse if package-lock.json exactly matches
+            - name: Cache root dependencies
               uses: actions/cache@v4
-              id: bun-cache
+              id: root-cache
               with:
-                  path: ~/.bun/install/cache
-                  key: ${{ runner.os }}-bun-${{ hashFiles('bun.lock') }}
-                  restore-keys: |
-                      ${{ runner.os }}-bun-
+                  path: apps/vscode/node_modules
+                  key: ${{ runner.os }}-npm-${{ hashFiles('apps/vscode/package-lock.json') }}
+
+            # Cache webview-ui dependencies - only reuse if package-lock.json exactly matches
+            - name: Cache webview-ui dependencies
+              uses: actions/cache@v4
+              id: webview-cache
+              with:
+                  path: apps/vscode/webview-ui/node_modules
+                  key: ${{ runner.os }}-npm-webview-${{ hashFiles('apps/vscode/webview-ui/package-lock.json') }}
 
             # Cache VS Code installation
             - name: Cache VS Code
@@ -122,41 +124,22 @@ jobs:
                       ~/.cache/ms-playwright
                       ~/Library/Caches/ms-playwright
                       ~/AppData/Local/ms-playwright
-                  key: playwright-browsers-${{ runner.os }}-${{ hashFiles('bun.lock') }}
+                  key: playwright-browsers-${{ runner.os }}-${{ hashFiles('apps/vscode/package-lock.json') }}
                   restore-keys: |
                       playwright-browsers-${{ runner.os }}-
 
-            # Single root install resolves the entire bun workspace at once (replaces
-            # the per-package `npm ci` steps for apps/vscode + webview-ui).
-            - name: Install workspace dependencies
+            - name: Install extension dependencies
               working-directory: ${{ github.workspace }}
-              run: bun install --frozen-lockfile
+              run: npm --prefix apps/vscode ci
               env:
                   GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
 
-            # @cline/* are local workspace symlinks to source packages; build dist/
-            # before building/packaging the extension for E2E.
-            - name: Build SDK packages
+            - name: Install webview-ui dependencies
               working-directory: ${{ github.workspace }}
-              run: bun run build:sdk
+              run: npm --prefix apps/vscode/webview-ui ci
 
-            - name: Assert better-sqlite3 native binary present
-              # Force bash: the Windows runner defaults to pwsh, which can't parse this
-              # POSIX test. Git Bash ships on GitHub's windows-latest images.
-              shell: bash
-              run: |
-                  NODE_FILE="node_modules/better-sqlite3/build/Release/better_sqlite3.node"
-                  if [ ! -f "$NODE_FILE" ]; then
-                    echo "ERROR: better-sqlite3 native binary missing at apps/vscode/$NODE_FILE"
-                    echo "(bun trustedDependencies postinstall likely did not run)"
-                    exit 1
-                  fi
-                  echo "Found better-sqlite3 native binary: $NODE_FILE"
-
-            # NOTE: vsce is no longer installed globally. @vscode/vsce is a workspace
-            # devDependency of apps/vscode (resolved into node_modules/.bin), and the
-            # `test:e2e:build` script invokes `vsce` via `bun run`, which puts the local
-            # .bin on PATH. No global install needed.
+            - name: Install vsce
+              run: npm install -g @vscode/vsce
 
             - name: Install xvfb on Linux
               if: matrix.runner == 'ubuntu'
@@ -165,11 +148,11 @@ jobs:
             # Run optimized E2E tests (eliminates redundant builds)
             - name: Run E2E tests - Linux
               if: matrix.runner == 'ubuntu'
-              run: xvfb-run -a bun run test:e2e:optimal
+              run: xvfb-run -a npm run test:e2e:optimal
 
             - name: Run E2E tests - Non-Linux
               if: matrix.runner != 'ubuntu'
-              run: bun run test:e2e:optimal
+              run: npm run test:e2e:optimal
 
             - uses: actions/upload-artifact@v4
               if: ${{ failure() }}

.github/workflows/ext-vscode-test.yml

@@ -45,16 +45,13 @@ jobs:
                           - 'apps/vscode/assets/**'
                           - 'apps/vscode/walkthrough/**'
                           - 'apps/vscode/package.json'
-                          - 'apps/vscode/webview-ui/package.json'
-                          # Root bun lockfile is authoritative for the whole workspace (incl. apps/vscode).
-                          - 'bun.lock'
-                          # SDK source packages are local workspace symlinks (@cline/*), so SDK changes affect the build.
-                          - 'sdk/packages/**'
+                          - 'apps/vscode/package-lock.json'
                           - 'apps/vscode/buf.yaml'
                           - 'apps/vscode/tsconfig*.json'
                           - 'apps/vscode/biome.jsonc'
                           - 'apps/vscode/esbuild.mjs'
-                          - 'apps/vscode/bunfig.toml'
+                          - 'apps/vscode/.mocharc.json'
+                          - 'apps/vscode/.nycrc*.json'
                           - 'apps/vscode/.vscode-test.mjs'
                           - 'apps/vscode/test-setup.js'
                           - '.github/workflows/ext-vscode-test.yml'
@@ -63,13 +60,9 @@ jobs:
                           - 'apps/vscode/proto/**'
                           - 'apps/vscode/standalone/**'
                           - 'apps/vscode/testing-platform/**'
-                          - 'apps/vscode/testing-platform/package.json'
                           - 'apps/vscode/tests/specs/**'
                           - 'apps/vscode/package.json'
-                          # Root bun lockfile is authoritative for the whole workspace (incl. apps/vscode).
-                          - 'bun.lock'
-                          # SDK source packages are local workspace symlinks (@cline/*), so SDK changes affect the build.
-                          - 'sdk/packages/**'
+                          - 'apps/vscode/package-lock.json'
                           - 'apps/vscode/buf.yaml'
                           - 'apps/vscode/tsconfig*.json'
                           - 'apps/vscode/esbuild.mjs'
@@ -89,38 +82,27 @@ jobs:
             - name: Checkout code
               uses: actions/checkout@v4
 
-            - name: Setup Bun
-              uses: oven-sh/setup-bun@v2
+            - name: Setup Node.js environment
+              uses: actions/setup-node@v4
               with:
-                  bun-version: 1.3.14
+                  node-version: 22
+                  cache: 'npm'
+                  cache-dependency-path: |
+                      apps/vscode/package-lock.json
+                      apps/vscode/webview-ui/package-lock.json
 
-            # Single root install resolves the entire bun workspace (apps/vscode,
-            # webview-ui, testing-platform and the @cline/* SDK symlinks) at once,
-            # so the previous per-package `npm ci` steps collapse into one.
-            - name: Install workspace dependencies
+            - name: Install extension dependencies
               working-directory: ${{ github.workspace }}
-              run: bun install --frozen-lockfile
+              run: npm --prefix apps/vscode ci
               env:
                   GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
 
-            # @cline/* are local workspace symlinks to source packages; their dist/
-            # output must be built before the extension can type-check/compile.
-            - name: Build SDK packages
+            - name: Install webview-ui dependencies
               working-directory: ${{ github.workspace }}
-              run: bun run build:sdk
-
-            - name: Assert better-sqlite3 native binary present
-              run: |
-                  NODE_FILE="node_modules/better-sqlite3/build/Release/better_sqlite3.node"
-                  if [ ! -f "$NODE_FILE" ]; then
-                    echo "ERROR: better-sqlite3 native binary missing at apps/vscode/$NODE_FILE"
-                    echo "(bun trustedDependencies postinstall likely did not run)"
-                    exit 1
-                  fi
-                  echo "Found better-sqlite3 native binary: $NODE_FILE"
+              run: npm --prefix apps/vscode/webview-ui ci
 
             - name: Run Quality Checks (Parallel)
-              run: bun run ci:check-all
+              run: npm run ci:check-all
 
     vscode-test:
         needs: [detect-changes, quality-checks]
@@ -141,43 +123,30 @@ jobs:
             - name: Checkout code
               uses: actions/checkout@v4
 
-            - name: Setup Bun
-              uses: oven-sh/setup-bun@v2
+            - name: Setup Node.js environment
+              uses: actions/setup-node@v4
               with:
-                  bun-version: 1.3.14
+                  node-version: 22
+                  cache: 'npm'
+                  cache-dependency-path: |
+                      apps/vscode/package-lock.json
+                      apps/vscode/webview-ui/package-lock.json
 
-            # Single root install resolves the entire bun workspace at once (replaces
-            # the per-package `npm ci` steps for apps/vscode + webview-ui).
-            - name: Install workspace dependencies
+            - name: Install extension dependencies
               working-directory: ${{ github.workspace }}
-              run: bun install --frozen-lockfile
+              run: npm --prefix apps/vscode ci
               env:
                   GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
 
-            # @cline/* are local workspace symlinks to source packages; build dist/
-            # before compiling/testing the extension.
-            - name: Build SDK packages
+            - name: Install webview-ui dependencies
               working-directory: ${{ github.workspace }}
-              run: bun run build:sdk
+              run: npm --prefix apps/vscode/webview-ui ci
 
-            - name: Assert better-sqlite3 native binary present
+            - name: Set up NPM on Windows
+              if: runner.os == 'Windows'
+              working-directory: ${{ github.workspace }}
               run: |
-                  NODE_FILE="node_modules/better-sqlite3/build/Release/better_sqlite3.node"
-                  if [ ! -f "$NODE_FILE" ]; then
-                    echo "ERROR: better-sqlite3 native binary missing at apps/vscode/$NODE_FILE"
-                    echo "(bun trustedDependencies postinstall likely did not run)"
-                    exit 1
-                  fi
-                  echo "Found better-sqlite3 native binary: $NODE_FILE"
-
-            # NOTE: The old `npm config set script-shell bash` step is intentionally
-            # removed. Scripts are now launched with `bun run`, which uses Bun's own
-            # built-in cross-platform shell rather than npm's configured script-shell,
-            # so that npm-specific Windows workaround no longer applies. Bash-dependent
-            # scripts (e.g. scripts/proto-lint.sh, standalone/runclinecore.sh) are
-            # invoked explicitly via `bash ...` from within the package scripts, and
-            # this job's `defaults.run.shell: bash` (Git Bash on Windows) still covers
-            # the workflow `run:` blocks below.
+                  npm config set script-shell "C:\\Program Files\\Git\\bin\\bash.exe"
 
             - name: Cache VS Code test runtime
               if: runner.os == 'Windows'
@@ -189,51 +158,24 @@ jobs:
             # Build the extension and tests (without redundant checks)
             - name: Build Tests and Extension
               id: build_step
-              run: bun run ci:build
+              run: npm run ci:build
 
-            - name: Vitest Suites (SDK adapter + model catalog)
-              id: vitest_tests
-              if: ${{ !cancelled() && steps.build_step.outcome == 'success' }}
-              # The vitest config sets passWithNoTests: true, so a broken glob/alias
-              # would "pass" with zero tests. Capture output and assert a non-zero
-              # test count to guard against silent skips.
-              run: |
-                  set -o pipefail
-                  bun run test:vitest 2>&1 | tee vitest-output.log
-                  # Strip ANSI color codes before matching — vitest colorizes the
-                  # "Tests  N passed" summary, so the count is not adjacent to the
-                  # "Tests" label in the raw bytes.
-                  if ! sed -r 's/\x1b\[[0-9;]*m//g' vitest-output.log | grep -Eq 'Tests[[:space:]]+[0-9]*[1-9][0-9]* (passed|failed)'; then
-                    echo "ERROR: vitest reported zero tests (possible silent skip)."
-                    exit 1
-                  fi
-
-            - name: Unit Tests (bun) - Linux
+            - name: Unit Tests with coverage - Linux
               id: unit_tests_linux
               if: ${{ !cancelled() && steps.build_step.outcome == 'success' && runner.os == 'Linux' }}
-              # The node-side unit suite (.mocharc spec set) now runs under `bun test`
-              # via scripts/run-bun-unit-tests.ts (one isolated bun process per file).
-              # The runner exits non-zero on any failure and prints a final
-              # "Files: N  Pass: P  Fail: F" summary; assert a non-zero pass count to
-              # guard against an empty glob silently "passing".
               run: |
-                  set -o pipefail
-                  bun run test:unit 2>&1 | tee unit-output.log
-                  if ! grep -Eq 'Pass:[[:space:]]+[0-9]*[1-9][0-9]*' unit-output.log; then
-                    echo "ERROR: bun unit runner reported zero passing tests (possible silent skip)."
-                    exit 1
-                  fi
+                  npx nyc --nycrc-path .nycrc.unit.json --reporter=lcov npm run test:unit
 
-            - name: Unit Tests (bun) - Non-Linux
+            - name: Unit Tests - Non-Linux
               id: unit_tests_non_linux
               if: ${{ !cancelled() && steps.build_step.outcome == 'success' && runner.os != 'Linux' }}
               run: |
-                  bun run test:unit
+                  npm run test:unit
 
             - name: Extension Integration Tests - Linux
               id: integration_tests_linux
               if: ${{ !cancelled() && steps.build_step.outcome == 'success' && runner.os == 'Linux' }}
-              run: xvfb-run -a bun run test:coverage
+              run: xvfb-run -a npm run test:coverage
 
             - name: Extension Integration Tests - Non-Linux
               id: integration_tests_non_linux
@@ -241,7 +183,7 @@ jobs:
               run: |
                   for attempt in 1 2 3; do
                     echo "Running extension integration tests (attempt ${attempt}/3)"
-                    if bun run test:integration; then
+                    if npm run test:integration; then
                       exit 0
                     fi
 
@@ -259,7 +201,7 @@ jobs:
               if: ${{ !cancelled() && steps.build_step.outcome == 'success' }}
               run: |
                   cd webview-ui
-                  bun run test:coverage
+                  npm run test:coverage
 
             - name: Save Coverage Reports
               uses: actions/upload-artifact@v4
@@ -268,6 +210,7 @@ jobs:
               with:
                   name: pr-coverage-reports
                   path: |
+                      apps/vscode/coverage-unit/lcov.info
                       apps/vscode/webview-ui/coverage/lcov.info
 
     test-platform-integration:
@@ -281,45 +224,39 @@ jobs:
             - name: Checkout code
               uses: actions/checkout@v4
 
-            - name: Setup Bun
-              uses: oven-sh/setup-bun@v2
+            - name: Setup Node.js environment
+              uses: actions/setup-node@v4
               with:
-                  bun-version: 1.3.14
+                  node-version: 22
+                  cache: 'npm'
+                  cache-dependency-path: |
+                      apps/vscode/package-lock.json
+                      apps/vscode/webview-ui/package-lock.json
+                      apps/vscode/testing-platform/package-lock.json
 
-            # Single root install resolves the whole bun workspace, including the
-            # testing-platform package, so the separate per-package `npm ci` steps
-            # (extension + webview-ui + testing-platform) collapse into one.
-            - name: Install workspace dependencies
+            - name: Install extension dependencies
               working-directory: ${{ github.workspace }}
-              run: bun install --frozen-lockfile
+              run: npm --prefix apps/vscode ci
               env:
                   GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
 
-            # @cline/* are local workspace symlinks to source packages; build dist/
-            # before compiling the standalone core.
-            - name: Build SDK packages
+            - name: Install webview-ui dependencies
               working-directory: ${{ github.workspace }}
-              run: bun run build:sdk
-
-            - name: Assert better-sqlite3 native binary present
-              run: |
-                  NODE_FILE="node_modules/better-sqlite3/build/Release/better_sqlite3.node"
-                  if [ ! -f "$NODE_FILE" ]; then
-                    echo "ERROR: better-sqlite3 native binary missing at apps/vscode/$NODE_FILE"
-                    echo "(bun trustedDependencies postinstall likely did not run)"
-                    exit 1
-                  fi
-                  echo "Found better-sqlite3 native binary: $NODE_FILE"
+              run: npm --prefix apps/vscode/webview-ui ci
 
             - name: Download ripgrep binaries
-              run: bun run download-ripgrep
+              run: npm run download-ripgrep
 
             - name: Compile Standalone
-              run: bun run compile-standalone
+              run: npm run compile-standalone
+
+            - name: Install testing platform dependencies
+              working-directory: ${{ github.workspace }}
+              run: npm --prefix apps/vscode/testing-platform ci
 
             - name: Running testing platform integration spec tests
               timeout-minutes: 7
-              run: bun run test:tp-orchestrator -- tests/specs/ --count=1 --coverage
+              run: npm run test:tp-orchestrator -- tests/specs/ --count=1 --coverage
 
             - name: Save Coverage Reports
               uses: actions/upload-artifact@v4

.gitignore

@@ -13,9 +13,6 @@ tmp
 pnpm-lock.yaml
 
 .clineignore
-.cline/enterprise
-.cline/remote-config
-**/.cline/remote-config
 .venv
 .actrc
 CLAUDE.local.md
@@ -84,4 +81,3 @@ apps/vscode/webview-ui/src/**/*.js.map
 *.db-wal
 .cline/**/managed.json
 .cline/**/bundle.json
-apps/vscode/tsconfig.test.generated.json

.husky/pre-commit

@@ -7,5 +7,4 @@ fi
 
 gitleaks git --pre-commit --redact --staged --verbose || exit 1
 
-cd apps/vscode && bunx lint-staged
-
+lint-staged

.vscode/launch.json

@@ -126,7 +126,10 @@
 				"${workspaceFolder}/apps/vscode/dist-standalone/**/*.js"
 			],
 			"preLaunchTask": "compile-standalone",
-			"runtimeExecutable": "bun",
+			"runtimeExecutable": "npx",
+			"runtimeArgs": [
+				"tsx"
+			],
 			"program": "scripts/test-standalone-core-api-server.ts",
 			"envFile": "${workspaceFolder}/apps/vscode/.env",
 			"env": {
@@ -180,7 +183,7 @@
 			"name": "Open Storybook",
 			"type": "node",
 			"request": "launch",
-			"runtimeExecutable": "bun",
+			"runtimeExecutable": "npm",
 			"runtimeArgs": [
 				"run",
 				"storybook"

.vscode/tasks.json

@@ -6,7 +6,7 @@
 		{
 			"label": "compile-standalone",
 			"type": "shell",
-			"command": "bun run compile-standalone",
+			"command": "npm run compile-standalone",
 			"group": "build",
 			"problemMatcher": [],
 			"presentation": {
@@ -19,7 +19,7 @@
 		{
 			"label": "npm: protos",
 			"type": "shell",
-			"command": "bun run protos",
+			"command": "npm run protos",
 			"problemMatcher": [],
 			"isBackground": false,
 			"presentation": {
@@ -65,7 +65,7 @@
 		},
 		{
 			"type": "shell",
-			"command": "bun run build:webview",
+			"command": "npm run build:webview",
 			"group": "build",
 			"problemMatcher": [],
 			"isBackground": true,
@@ -86,7 +86,7 @@
 		},
 		{
 			"type": "shell",
-			"command": "bun run build:webview:test",
+			"command": "npm run build:webview:test",
 			"group": "build",
 			"problemMatcher": [],
 			"isBackground": true,
@@ -108,7 +108,7 @@
 		},
 		{
 			"type": "shell",
-			"command": "bun run dev:webview",
+			"command": "npm run dev:webview",
 			"group": "build",
 			"problemMatcher": [
 				{
@@ -145,7 +145,7 @@
 		},
 		{
 			"type": "shell",
-			"command": "bun run watch:esbuild",
+			"command": "npm run watch:esbuild",
 			"group": "build",
 			"problemMatcher": {
 				"pattern": [
@@ -169,8 +169,7 @@
 			"isBackground": true,
 			"label": "npm: watch:esbuild",
 			"dependsOn": [
-				"npm: protos",
-				"build-sdk:debug"
+				"npm: protos"
 			],
 			"presentation": {
 				"group": "watch",
@@ -185,7 +184,7 @@
 		},
 		{
 			"type": "shell",
-			"command": "bun run watch:esbuild:test",
+			"command": "npm run watch:esbuild:test",
 			"group": "build",
 			"problemMatcher": {
 				"pattern": [
@@ -209,8 +208,7 @@
 			"isBackground": true,
 			"label": "npm: watch:esbuild:test",
 			"dependsOn": [
-				"npm: protos",
-				"build-sdk:debug"
+				"npm: protos"
 			],
 			"presentation": {
 				"group": "watch",
@@ -226,7 +224,7 @@
 		},
 		{
 			"type": "shell",
-			"command": "bun run watch:tsc",
+			"command": "npm run watch:tsc",
 			"group": "build",
 			"problemMatcher": "$tsc-watch",
 			"isBackground": true,
@@ -244,7 +242,7 @@
 		},
 		{
 			"type": "shell",
-			"command": "bun run watch-tests",
+			"command": "npm run watch-tests",
 			"label": "npm: watch-tests",
 			"problemMatcher": "$tsc-watch",
 			"isBackground": true,
@@ -284,7 +282,7 @@
 		},
 		{
 			"type": "shell",
-			"command": "bun run storybook",
+			"command": "npm run storybook",
 			"group": "build",
 			"problemMatcher": [],
 			"isBackground": false,
@@ -313,24 +311,6 @@
 			"options": {
 				"cwd": "${workspaceFolder}"
 			}
-		},
-		{
-			"label": "build-sdk:debug",
-			"type": "shell",
-			"command": "bun run build:sdk",
-			"problemMatcher": [
-				"$tsc"
-			],
-			"presentation": {
-				"group": "watch",
-				"reveal": "always"
-			},
-			"options": {
-				"cwd": "${workspaceFolder}",
-				"env": {
-					"CLINE_SOURCEMAPS": "1"
-				}
-			}
 		}
 	],
 	"inputs": [

CLAUDE.md

@@ -0,0 +1,2 @@
+@.clinerules/general.md
+@.clinerules/network.md

CONTRIBUTING.md

@@ -45,7 +45,7 @@ We also welcome contributions to our [documentation](https://github.com/cline/cl
 3. Install [bun](https://bun.com)
 4. Install the necessary dependencies for the extension and webview-gui:
     ```bash
-    cd apps/vscode && bun run install:all && cd ../..
+    cd apps/vscode && npm run install:all && cd ../..
     cd sdk && bun run build && cd ..
     ```
 5. Generate Protocol Buffer files (required before first build):
@@ -61,8 +61,8 @@ We also welcome contributions to our [documentation](https://github.com/cline/cl
 2. Push your branch and create a PR on GitHub. Our CI will:
    - Run tests and checks
 3. Testing
-    - Run `cd apps/vscode && bun run test` to run tests locally. 
-    - Before submitting PR, run `bun run format:fix` to format your code
+    - Run `cd apps/vscode && npm run test` to run tests locally. 
+    - Before submitting PR, run `npm run format:fix` to format your code
 
 ### Extension
 
@@ -74,12 +74,12 @@ We also welcome contributions to our [documentation](https://github.com/cline/cl
 
 2. **Local Development**
     - cd into the vscode extension, `cd apps/vscode`
-    - Run `bun run install:all` to install dependencies
-    - Run `bun run protos` to generate Protocol Buffer files (required before first build)
-    - Run `bun run test` to run tests locally
+    - Run `npm run install:all` to install dependencies
+    - Run `npm run protos` to generate Protocol Buffer files (required before first build)
+    - Run `npm run test` to run tests locally
     - Run → Start Debugging or `>Debug: Select and Start Debugging` and wait for a new VS Code instance to open
-    - **Terminal Workflow**: Use `bun run dev` (generates protos + runs watch mode) or `bun run watch` (if protos already generated)
-    - Before submitting PR, run `bun run format:fix` to format your code
+    - **Terminal Workflow**: Use `npm run dev` (generates protos + runs watch mode) or `npm run watch` (if protos already generated)
+    - Before submitting PR, run `npm run format:fix` to format your code
 
 3. **Linux-specific Setup**
     VS Code extension tests on Linux require the following system libraries:
@@ -135,8 +135,8 @@ Anyone can contribute code to Cline, but we ask that you follow these guidelines
 
 2. **Code Quality**
 
-    - Run `bun run lint` to check code style
-    - Run `bun run format` to automatically format code
+    - Run `npm run lint` to check code style
+    - Run `npm run format` to automatically format code
     - All PRs must pass CI checks which include both linting and formatting
     - Address any warnings or errors from linter before submitting
     - Follow TypeScript best practices and maintain type safety
@@ -144,7 +144,7 @@ Anyone can contribute code to Cline, but we ask that you follow these guidelines
 3. **Testing**
 
     - Add tests for new features
-    - Run `bun test` to ensure all tests pass
+    - Run `npm test` to ensure all tests pass
     - Update existing tests if your changes affect them
     - Include both unit tests and integration tests where appropriate
 
@@ -154,9 +154,9 @@ Anyone can contribute code to Cline, but we ask that you follow these guidelines
     
     - **Running E2E tests:**
       ```bash
-      bun run test:e2e        # Build and run all E2E tests
-      bun run e2e             # Run tests without rebuilding
-      bun run test:e2e -- --debug  # Run with interactive debugger
+      npm run test:e2e        # Build and run all E2E tests
+      npm run e2e             # Run tests without rebuilding
+      npm run test:e2e -- --debug  # Run with interactive debugger
       ```
     
     - **Writing E2E tests:**

apps/cli/CHANGELOG.md

@@ -1,48 +1,5 @@
 # Cline CLI Changelog
 
-## 3.0.29
-
-- Costs are now hidden for Cline free models
-- Fixed Z.ai model metadata resolution for Z.ai models accessed through the Cline provider
-- Reverted the model-name-only display change from v3.0.28; the model picker, selector, and status bar return to their previous display behavior
-
-## 3.0.28
-
-- Added a ClinePass onboarding flow with selectable ClinePass models, plus improved ClinePass error handling
-- Added hub primitive catalogs and refreshed the hub dashboard design with a dedicated customizations breakout
-- Auto-approve toggles now apply immediately when changed
-- Feature flags now resolve using your user ID on startup
-- Fixed Cline model display names so they resolve by model name
-- Truncate large tool results by default (including MCP and custom tool output) to keep requests within context budget
-- Hardened parallel tool-call guidance for faster, more reliable multi-tool execution
-
-## 3.0.27
-
-- Added a `cline skill` command to install and manage skills, matching `cline plugin install` and `cline mcp` (installs default to the Cline agent directory)
-- Added a prefilled MCP install wizard command for quicker MCP server setup
-- Improved error handling and messaging when plugin MCP OAuth authorization fails
-- The CLI now rejects unknown commands and unquoted multi-word input with a clear error instead of silently treating bad arguments as a prompt
-
-## 3.0.26
-
-- Reverted the expandable model picker sections and ClinePass models, restoring the previous model-selection UI
-
-## 3.0.25
-
-- Added ClinePass support, with selectable ClinePass models in the model picker
-- Made model picker sections expandable
-- Added MCP server support to plugins, including authorizing plugin MCP OAuth during install
-- Encouraged parallel tool calls for faster task execution
-- Capped tool output for bash commands and file reads to keep large output within context limits
-- Allowed ranged reads on large files
-- Fixed apply_patch to fail when a hunk is skipped
-- Fixed run_commands to return captured stdout on failure and handle split heredocs
-- Fixed search tools to treat zero results as success
-- Fixed disabled-reasoning handling for StepFun flash
-- Fixed history resume rendering isolation
-- Fixed the Hugging Face URL
-- Fixed Cline OAuth token formatting in provider config
-
 ## 3.0.24
 
 - Plugin commands can now submit prompts to the agent

apps/cli/README.md

@@ -163,30 +163,6 @@ cline auth --provider anthropic --apikey sk-... --modelid claude-sonnet-4-6
 cline auth --provider openai-native --apikey sk-... --modelid gpt-5 --baseurl https://api.example.com/v1
 ```
 
-### MCP servers
-
-Manage MCP servers with the interactive wizard:
-
-```sh
-cline mcp
-cline config mcp
-```
-
-Open the add-server wizard with the name, transport, and command or URL already filled in with `cline mcp install` (`cline mcp add` also works). Stdio servers use everything after `--` as the command and arguments:
-
-```sh
-cline mcp install fs -- npx -y @modelcontextprotocol/server-filesystem /tmp
-```
-
-Remote HTTP and SSE servers take a name, transport, and URL. The wizard still asks for auth details before saving:
-
-```sh
-cline mcp install ctx7 --transport http https://mcp.context7.com/mcp
-cline mcp install events --transport sse https://example.com/sse
-```
-
-Because this command opens the wizard, it requires a TTY.
-
 ### Connectors
 
 Bridge a chat surface into RPC-backed Cline sessions. Each conversation thread maps to a session with full context. Supported platforms: Telegram, Slack, Google Chat, WhatsApp, and Linear.

apps/cli/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "@cline/cli",
 	"displayName": "cline",
-	"version": "3.0.29",
+	"version": "3.0.24",
 	"description": "Autonomous coding agent CLI - capable of creating/editing files, running commands, using the browser, and more",
 	"type": "module",
 	"publishConfig": {

apps/cli/src/cli.e2e.test.ts

@@ -746,27 +746,6 @@ Break work into clear steps.`,
 		).toBe(true);
 	});
 
-	it("routes mcp install and requires a TTY for the prefilled wizard", () => {
-		const result = runCli(
-			[
-				"mcp",
-				"install",
-				"fs",
-				"--",
-				"npx",
-				"-y",
-				"@modelcontextprotocol/server-filesystem",
-				"/tmp",
-			],
-			{ env: createIsolatedEnv() },
-		);
-
-		expect(result.status).toBe(1);
-		expect(asText(result.stderr)).toContain(
-			"cline mcp install opens the MCP wizard and requires a TTY.",
-		);
-	});
-
 	it("lists available tools", () => {
 		const homeDir = mkdtempSync(path.join(os.tmpdir(), "cli-e2e-home-"));
 		const dataDir = mkdtempSync(path.join(os.tmpdir(), "cli-e2e-data-"));

apps/cli/src/commands/dashboard.test.ts

@@ -6,15 +6,6 @@ import { runDashboardCommand, waitForProcessShutdown } from "./dashboard";
 
 const ENV_KEYS = [
 	"WORKSPACE_ROOT",
-	"CLINE_DIR",
-	"CLINE_SANDBOX",
-	"CLINE_SANDBOX_DATA_DIR",
-	"CLINE_DATA_DIR",
-	"CLINE_DB_DATA_DIR",
-	"CLINE_SESSION_DATA_DIR",
-	"CLINE_TEAM_DATA_DIR",
-	"CLINE_PROVIDER_SETTINGS_PATH",
-	"CLINE_HOOKS_LOG_PATH",
 	"HOST",
 	"CLINE_HUB_DASHBOARD_PORT",
 	"PUBLIC_URL",
@@ -47,9 +38,6 @@ describe("runDashboardCommand", () => {
 		let observedEnv:
 			| {
 					workspaceRoot: string | undefined;
-					clineDir: string | undefined;
-					clineDataDir: string | undefined;
-					providerSettingsPath: string | undefined;
 					host: string | undefined;
 					port: string | undefined;
 					publicUrl: string | undefined;
@@ -62,9 +50,7 @@ describe("runDashboardCommand", () => {
 		process.env.CLINE_HUB_WEBVIEW_DIST_DIR = webviewDistDir;
 
 		const exitCode = await runDashboardCommand({
-			configDir: "/tmp/cline-config",
 			cwd: "sdk",
-			dataDir: ".cline-dashboard-data",
 			host: "127.0.0.1",
 			port: "9090",
 			publicUrl: "http://127.0.0.1:9090",
@@ -76,9 +62,6 @@ describe("runDashboardCommand", () => {
 			startServer: async () => {
 				observedEnv = {
 					workspaceRoot: process.env.WORKSPACE_ROOT,
-					clineDir: process.env.CLINE_DIR,
-					clineDataDir: process.env.CLINE_DATA_DIR,
-					providerSettingsPath: process.env.CLINE_PROVIDER_SETTINGS_PATH,
 					host: process.env.HOST,
 					port: process.env.CLINE_HUB_DASHBOARD_PORT,
 					publicUrl: process.env.PUBLIC_URL,
@@ -104,13 +87,6 @@ describe("runDashboardCommand", () => {
 		expect(exitCode).toBe(0);
 		expect(observedEnv).toEqual({
 			workspaceRoot: resolve("sdk"),
-			clineDir: "/tmp/cline-config",
-			clineDataDir: resolve("sdk", ".cline-dashboard-data"),
-			providerSettingsPath: join(
-				resolve("sdk", ".cline-dashboard-data"),
-				"settings",
-				"providers.json",
-			),
 			host: "127.0.0.1",
 			port: "9090",
 			publicUrl: "http://127.0.0.1:9090",

apps/cli/src/commands/dashboard.ts

@@ -3,7 +3,6 @@ import { arch, platform } from "node:os";
 import { dirname, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import open from "open";
-import { configureSandboxEnvironment } from "../utils/helpers";
 import { c } from "../utils/output";
 
 export interface DashboardServerHandle {
@@ -20,9 +19,7 @@ interface DashboardCommandIo {
 }
 
 export interface RunDashboardCommandOptions {
-	configDir?: string;
 	cwd?: string;
-	dataDir?: string;
 	host?: string;
 	port?: string;
 	publicUrl?: string;
@@ -39,9 +36,10 @@ const WEBVIEW_DIST_ENV = "CLINE_HUB_WEBVIEW_DIST_DIR";
 
 function setEnvValue(name: string, value: string | undefined): () => void {
 	const previous = process.env[name];
-	if (value !== undefined) {
-		process.env[name] = value;
+	if (value === undefined) {
+		return () => {};
 	}
+	process.env[name] = value;
 	return () => {
 		if (previous === undefined) {
 			delete process.env[name];
@@ -51,39 +49,21 @@ function setEnvValue(name: string, value: string | undefined): () => void {
 	};
 }
 
-const SANDBOX_ENV_KEYS = [
-	"CLINE_SANDBOX",
-	"CLINE_SANDBOX_DATA_DIR",
-	"CLINE_DATA_DIR",
-	"CLINE_DB_DATA_DIR",
-	"CLINE_SESSION_DATA_DIR",
-	"CLINE_TEAM_DATA_DIR",
-	"CLINE_PROVIDER_SETTINGS_PATH",
-	"CLINE_HOOKS_LOG_PATH",
-] as const;
-
 async function withDashboardEnvironment<T>(
 	options: RunDashboardCommandOptions,
 	fn: () => Promise<T>,
 ): Promise<T> {
-	const cwd = options.cwd ? resolve(options.cwd) : process.cwd();
 	const restore = [
-		setEnvValue("WORKSPACE_ROOT", options.cwd ? cwd : undefined),
-		setEnvValue("CLINE_DIR", options.configDir?.trim() || undefined),
+		setEnvValue(
+			"WORKSPACE_ROOT",
+			options.cwd ? resolve(options.cwd) : undefined,
+		),
 		setEnvValue("HOST", options.host),
 		setEnvValue(DASHBOARD_PORT_ENV, options.port),
 		setEnvValue("PUBLIC_URL", options.publicUrl),
 		setEnvValue("ROOM_SECRET", options.roomSecret),
 		setEnvValue(WEBVIEW_DIST_ENV, resolveDefaultWebviewDistDir()),
-		...SANDBOX_ENV_KEYS.map((key) => setEnvValue(key, undefined)),
 	];
-	if (options.dataDir || process.env.CLINE_SANDBOX?.trim() === "1") {
-		configureSandboxEnvironment({
-			enabled: true,
-			cwd,
-			explicitDir: options.dataDir,
-		});
-	}
 	try {
 		return await fn();
 	} finally {

apps/cli/src/commands/mcp.test.ts

@@ -1,145 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-import { buildMcpInstallDefaults, runMcpInstallCommand } from "./mcp";
-
-describe("mcp install command", () => {
-	it("builds stdio wizard defaults from command args", () => {
-		expect(
-			buildMcpInstallDefaults({
-				name: "fs",
-				targetArgs: [
-					"npx",
-					"-y",
-					"@modelcontextprotocol/server-filesystem",
-					"/tmp/my dir",
-				],
-			}),
-		).toEqual({
-			name: "fs",
-			type: "stdio",
-			command: 'npx -y @modelcontextprotocol/server-filesystem "/tmp/my dir"',
-		});
-	});
-
-	it("builds remote wizard defaults and normalizes http transport", () => {
-		expect(
-			buildMcpInstallDefaults({
-				name: "ctx7",
-				transport: "http",
-				targetArgs: ["https://mcp.context7.com/mcp"],
-			}),
-		).toEqual({
-			name: "ctx7",
-			type: "streamableHttp",
-			url: "https://mcp.context7.com/mcp",
-		});
-	});
-
-	it("normalizes streamable-http transport", () => {
-		expect(
-			buildMcpInstallDefaults({
-				name: "docs",
-				transport: "streamable-http",
-				targetArgs: ["https://example.com/mcp"],
-			}),
-		).toEqual({
-			name: "docs",
-			type: "streamableHttp",
-			url: "https://example.com/mcp",
-		});
-	});
-
-	it("builds SSE wizard defaults", () => {
-		expect(
-			buildMcpInstallDefaults({
-				name: "events",
-				transport: "sse",
-				targetArgs: ["https://example.com/sse"],
-			}),
-		).toEqual({
-			name: "events",
-			type: "sse",
-			url: "https://example.com/sse",
-		});
-	});
-
-	it("rejects missing stdio command and invalid remote URL", () => {
-		expect(() =>
-			buildMcpInstallDefaults({
-				name: "fs",
-			}),
-		).toThrow(/requires a command/);
-
-		expect(() =>
-			buildMcpInstallDefaults({
-				name: "bad",
-				transport: "http",
-				targetArgs: ["not-a-url"],
-			}),
-		).toThrow(/Invalid MCP server URL/);
-	});
-
-	it("rejects remote URL schemes other than http and https", () => {
-		expect(() =>
-			buildMcpInstallDefaults({
-				name: "bad",
-				transport: "http",
-				targetArgs: ["file:///etc/passwd"],
-			}),
-		).toThrow(/only http and https are supported/);
-	});
-
-	it("opens the add wizard with prefilled defaults", async () => {
-		const runWizard = vi.fn(async () => 0);
-
-		const code = await runMcpInstallCommand({
-			name: "ctx7",
-			transport: "http",
-			targetArgs: ["https://mcp.context7.com/mcp"],
-			isTty: true,
-			runWizard,
-			io: { writeErr: vi.fn() },
-		});
-
-		expect(code).toBe(0);
-		expect(runWizard).toHaveBeenCalledWith({
-			name: "ctx7",
-			type: "streamableHttp",
-			url: "https://mcp.context7.com/mcp",
-		});
-	});
-
-	it("requires a TTY because it opens the wizard", async () => {
-		const writeErr = vi.fn();
-		const runWizard = vi.fn(async () => 0);
-
-		const code = await runMcpInstallCommand({
-			name: "ctx7",
-			transport: "http",
-			targetArgs: ["https://mcp.context7.com/mcp"],
-			isTty: false,
-			runWizard,
-			io: { writeErr },
-		});
-
-		expect(code).toBe(1);
-		expect(runWizard).not.toHaveBeenCalled();
-		expect(writeErr).toHaveBeenCalledWith(
-			"cline mcp install opens the MCP wizard and requires a TTY.",
-		);
-	});
-
-	it("checks for TTY before validating install arguments", async () => {
-		const writeErr = vi.fn();
-
-		const code = await runMcpInstallCommand({
-			name: "fs",
-			isTty: false,
-			io: { writeErr },
-		});
-
-		expect(code).toBe(1);
-		expect(writeErr).toHaveBeenCalledWith(
-			"cline mcp install opens the MCP wizard and requires a TTY.",
-		);
-	});
-});

apps/cli/src/commands/mcp.ts

@@ -1,121 +0,0 @@
-import type { McpAddDefaults } from "../wizards/mcp";
-
-export interface McpCommandIo {
-	writeErr: (text: string) => void;
-}
-
-export interface McpInstallOptions {
-	name: string;
-	targetArgs?: string[];
-	transport?: string;
-	io?: McpCommandIo;
-	isTty?: boolean;
-	runWizard?: (defaults: McpAddDefaults) => Promise<number>;
-}
-
-function normalizeTransportType(
-	value: string | undefined,
-): McpAddDefaults["type"] {
-	const normalized = (value ?? "stdio").trim();
-	if (normalized === "http" || normalized === "streamable-http") {
-		return "streamableHttp";
-	}
-	if (
-		normalized === "stdio" ||
-		normalized === "sse" ||
-		normalized === "streamableHttp"
-	) {
-		return normalized;
-	}
-	throw new Error(
-		`Unsupported MCP transport "${normalized}". Expected stdio, sse, http, streamable-http, or streamableHttp.`,
-	);
-}
-
-function assertValidUrl(url: string): void {
-	let parsed: URL;
-	try {
-		parsed = new URL(url);
-	} catch {
-		throw new Error(`Invalid MCP server URL: ${url}`);
-	}
-	if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
-		throw new Error(
-			`Invalid MCP server URL: ${url} (only http and https are supported)`,
-		);
-	}
-}
-
-function quoteCommandArg(arg: string): string {
-	if (/^[^\s"'\\]+$/.test(arg)) {
-		return arg;
-	}
-	return `"${arg.replace(/(["\\])/g, "\\$1")}"`;
-}
-
-export function buildMcpInstallDefaults(options: {
-	name: string;
-	targetArgs?: string[];
-	transport?: string;
-}): McpAddDefaults {
-	const name = options.name.trim();
-	if (!name) {
-		throw new Error("MCP server name is required");
-	}
-	const type = normalizeTransportType(options.transport);
-	const targetArgs = options.targetArgs ?? [];
-	if (type === "stdio") {
-		if (targetArgs.length === 0) {
-			throw new Error(
-				"Stdio MCP install requires a command after the server name, for example: cline mcp install fs -- npx -y @modelcontextprotocol/server-filesystem /tmp",
-			);
-		}
-		return {
-			name,
-			type,
-			command: targetArgs.map(quoteCommandArg).join(" "),
-		};
-	}
-
-	if (targetArgs.length !== 1) {
-		throw new Error(
-			"Remote MCP install requires exactly one URL argument after the server name.",
-		);
-	}
-	const url = targetArgs[0]?.trim() ?? "";
-	assertValidUrl(url);
-	return {
-		name,
-		type,
-		url,
-	};
-}
-
-async function runPrefilledWizard(defaults: McpAddDefaults): Promise<number> {
-	const { runMcpWizard } = await import("../wizards/mcp");
-	return runMcpWizard({
-		initialAction: "add",
-		addDefaults: defaults,
-		exitAfterInitialAction: true,
-	});
-}
-
-export async function runMcpInstallCommand(
-	options: McpInstallOptions,
-): Promise<number> {
-	try {
-		const isTty =
-			options.isTty ?? (process.stdin.isTTY && process.stdout.isTTY);
-		if (!isTty) {
-			throw new Error(
-				"cline mcp install opens the MCP wizard and requires a TTY.",
-			);
-		}
-		const defaults = buildMcpInstallDefaults(options);
-		return await (options.runWizard ?? runPrefilledWizard)(defaults);
-	} catch (error) {
-		const message = error instanceof Error ? error.message : String(error);
-		options.io?.writeErr(message);
-		return 1;
-	}
-}

apps/cli/src/commands/plugin.test.ts

@@ -17,7 +17,6 @@ import {
 } from "@cline/shared/storage";
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 import {
-	collectPluginMcpOAuthCandidates,
 	installPlugin,
 	isOfficialPluginSlug,
 	parsePluginSource,
@@ -36,7 +35,6 @@ describe("plugin install command", () => {
 	let originalHome: string | undefined;
 	let originalClineDir: string | undefined;
 	let originalClineDataDir: string | undefined;
-	let originalMcpSettingsPath: string | undefined;
 
 	beforeEach(() => {
 		root = mkdtempSync(join(tmpdir(), "cli-plugin-install-"));
@@ -45,7 +43,6 @@ describe("plugin install command", () => {
 		originalHome = process.env.HOME;
 		originalClineDir = process.env.CLINE_DIR;
 		originalClineDataDir = process.env.CLINE_DATA_DIR;
-		originalMcpSettingsPath = process.env.CLINE_MCP_SETTINGS_PATH;
 		process.env.HOME = home;
 		process.env.CLINE_DIR = join(home, ".cline");
 		process.env.CLINE_DATA_DIR = join(home, ".cline", "data");
@@ -94,11 +91,6 @@ describe("plugin install command", () => {
 		} else {
 			process.env.CLINE_DATA_DIR = originalClineDataDir;
 		}
-		if (originalMcpSettingsPath === undefined) {
-			delete process.env.CLINE_MCP_SETTINGS_PATH;
-		} else {
-			process.env.CLINE_MCP_SETTINGS_PATH = originalMcpSettingsPath;
-		}
 		rmSync(root, { recursive: true, force: true });
 	});
 
@@ -684,341 +676,11 @@ describe("plugin install command", () => {
 			expect(code).toBe(0);
 			const parsed = JSON.parse(stdout.join("")) as { installPath: string };
 			expect(parsed.installPath).toContain(join(home, ".cline", "plugins"));
-			expect("mcpOAuthCandidates" in parsed).toBe(false);
 		} finally {
 			process.stdout.write = originalWrite;
 		}
 	});
 
-	it("does not run MCP OAuth follow-up for JSON plugin installs", async () => {
-		process.env.CLINE_MCP_SETTINGS_PATH = join(root, "mcp-settings.json");
-		const source = join(root, "json-oauth-mcp-plugin.js");
-		writeFileSync(
-			source,
-			`
-export default {
-  name: "json-oauth-mcp-plugin",
-  manifest: { capabilities: ["mcp"] },
-  setup(api) {
-    api.registerMcpServer({
-      name: "json-oauth-docs",
-      transport: { type: "streamableHttp", url: "https://example.com/mcp" },
-    })
-  },
-}
-`,
-			"utf8",
-		);
-		const stdout: string[] = [];
-		const originalWrite = process.stdout.write;
-		const authorize = vi.fn();
-		process.stdout.write = ((chunk: string | Uint8Array) => {
-			stdout.push(String(chunk));
-			return true;
-		}) as typeof process.stdout.write;
-		try {
-			const code = await runPluginInstallCommand({
-				source,
-				json: true,
-				io: {
-					writeln: () => {},
-					writeErr: () => {},
-				},
-				mcpOAuth: {
-					interactive: true,
-					selectCandidates: async (candidates) => candidates,
-					authorize,
-				},
-			});
-			expect(code).toBe(0);
-			expect(authorize).not.toHaveBeenCalled();
-			const parsed = JSON.parse(stdout.join("")) as {
-				installPath: string;
-				mcpOAuthCandidates?: unknown;
-			};
-			expect(parsed.installPath).toContain(join(home, ".cline", "plugins"));
-			expect(parsed.mcpOAuthCandidates).toBeUndefined();
-		} finally {
-			process.stdout.write = originalWrite;
-		}
-	});
-
-	it("warns when plugin MCP settings sync fails after install", async () => {
-		const source = join(root, "mcp-plugin.js");
-		writeFileSync(
-			source,
-			`
-export default {
-  name: "mcp-plugin",
-  manifest: { capabilities: ["mcp"] },
-  setup(api) {
-    api.registerMcpServer({
-      name: "mcp-plugin",
-      transport: { type: "streamableHttp", url: "https://example.com/mcp" },
-    })
-  },
-}
-`,
-			"utf8",
-		);
-		const blockedDirectory = join(root, "not-a-directory");
-		writeFileSync(blockedDirectory, "file", "utf8");
-		const originalSettingsPath = process.env.CLINE_MCP_SETTINGS_PATH;
-		process.env.CLINE_MCP_SETTINGS_PATH = join(
-			blockedDirectory,
-			"cline_mcp_settings.json",
-		);
-		const output: string[] = [];
-		try {
-			const code = await runPluginInstallCommand({
-				source,
-				io: {
-					writeln: (text = "") => output.push(text),
-					writeErr: (text) => output.push(text),
-				},
-			});
-
-			expect(code).toBe(0);
-			expect(output.join("\n")).toContain("Installed plugin from");
-			expect(output.join("\n")).toContain(
-				"Warning: failed to sync plugin MCP servers",
-			);
-			expect(output.join("\n")).toContain("mcp-plugin");
-		} finally {
-			if (originalSettingsPath === undefined) {
-				delete process.env.CLINE_MCP_SETTINGS_PATH;
-			} else {
-				process.env.CLINE_MCP_SETTINGS_PATH = originalSettingsPath;
-			}
-		}
-	});
-
-	it("detects plugin-owned remote MCP servers as OAuth candidates", async () => {
-		process.env.CLINE_MCP_SETTINGS_PATH = join(root, "mcp-settings.json");
-		const source = join(root, "oauth-mcp-plugin.js");
-		writeFileSync(
-			source,
-			`
-export default {
-  name: "oauth-mcp-plugin",
-  manifest: { capabilities: ["mcp"] },
-  setup(api) {
-    api.registerMcpServer({
-      name: "oauth-docs",
-      transport: { type: "streamableHttp", url: "https://example.com/mcp" },
-    })
-  },
-}
-`,
-			"utf8",
-		);
-
-		const result = await installPlugin({ source });
-
-		expect(result.mcpOAuthCandidates).toEqual([
-			expect.objectContaining({
-				name: "oauth-docs",
-				pluginName: "oauth-mcp-plugin",
-				transportType: "streamableHttp",
-			}),
-		]);
-	});
-
-	it("does not treat remote MCP servers with static headers as OAuth candidates", async () => {
-		process.env.CLINE_MCP_SETTINGS_PATH = join(root, "mcp-settings.json");
-		const source = join(root, "headers-mcp-plugin.js");
-		writeFileSync(
-			source,
-			`
-export default {
-  name: "headers-mcp-plugin",
-  manifest: { capabilities: ["mcp"] },
-  setup(api) {
-    api.registerMcpServer({
-      name: "headers-docs",
-      transport: {
-        type: "streamableHttp",
-        url: "https://example.com/mcp",
-        headers: { Authorization: "Bearer token" },
-      },
-    })
-  },
-}
-`,
-			"utf8",
-		);
-
-		const result = await installPlugin({ source });
-
-		expect(result.mcpOAuthCandidates).toEqual([]);
-	});
-
-	it("skips plugin MCP OAuth candidates that already have tokens", async () => {
-		const settingsPath = join(root, "mcp-settings.json");
-		process.env.CLINE_MCP_SETTINGS_PATH = settingsPath;
-		const source = join(root, "authorized-mcp-plugin.js");
-		writeFileSync(
-			source,
-			`
-export default {
-  name: "authorized-mcp-plugin",
-  manifest: { capabilities: ["mcp"] },
-  setup(api) {
-    api.registerMcpServer({
-      name: "authorized-docs",
-      transport: { type: "streamableHttp", url: "https://example.com/mcp" },
-    })
-  },
-}
-`,
-			"utf8",
-		);
-		const result = await installPlugin({ source });
-		const settings = JSON.parse(readFileSync(settingsPath, "utf8")) as {
-			mcpServers?: Record<string, { oauth?: unknown }>;
-		};
-		const server = settings.mcpServers?.["authorized-docs"];
-		if (!server) {
-			throw new Error("Expected authorized-docs MCP server to be written");
-		}
-		server.oauth = { tokens: { access_token: "oauth-token" } };
-		writeFileSync(settingsPath, JSON.stringify(settings, null, 2), "utf8");
-
-		expect(
-			collectPluginMcpOAuthCandidates({
-				pluginPaths: result.entryPaths,
-				settingsPath,
-			}),
-		).toEqual([]);
-	});
-
-	it("authorizes selected plugin MCP OAuth candidates during interactive installs", async () => {
-		process.env.CLINE_MCP_SETTINGS_PATH = join(root, "mcp-settings.json");
-		const source = join(root, "interactive-mcp-plugin.js");
-		writeFileSync(
-			source,
-			`
-export default {
-  name: "interactive-mcp-plugin",
-  manifest: { capabilities: ["mcp"] },
-  setup(api) {
-    api.registerMcpServer({
-      name: "interactive-docs",
-      transport: { type: "streamableHttp", url: "https://example.com/mcp" },
-    })
-  },
-}
-`,
-			"utf8",
-		);
-		const authorized: string[] = [];
-		const output: string[] = [];
-
-		const code = await runPluginInstallCommand({
-			source,
-			io: {
-				writeln: (text = "") => output.push(text),
-				writeErr: (text) => output.push(text),
-			},
-			mcpOAuth: {
-				interactive: true,
-				selectCandidates: async (candidates) => candidates,
-				authorize: async (candidate) => {
-					authorized.push(candidate.name);
-				},
-			},
-		});
-
-		expect(code).toBe(0);
-		expect(authorized).toEqual(["interactive-docs"]);
-		expect(output.join("\n")).toContain("Installed plugin from");
-	});
-
-	it("keeps plugin install successful when MCP OAuth authorization fails", async () => {
-		process.env.CLINE_MCP_SETTINGS_PATH = join(root, "mcp-settings.json");
-		const source = join(root, "failing-oauth-mcp-plugin.js");
-		writeFileSync(
-			source,
-			`
-export default {
-  name: "failing-oauth-mcp-plugin",
-  manifest: { capabilities: ["mcp"] },
-  setup(api) {
-    api.registerMcpServer({
-      name: "failing-docs",
-      transport: { type: "streamableHttp", url: "https://example.com/mcp" },
-    })
-  },
-}
-`,
-			"utf8",
-		);
-		const output: string[] = [];
-
-		const code = await runPluginInstallCommand({
-			source,
-			io: {
-				writeln: (text = "") => output.push(text),
-				writeErr: (text) => output.push(text),
-			},
-			mcpOAuth: {
-				interactive: true,
-				selectCandidates: async (candidates) => candidates,
-				authorize: async () => {
-					throw new Error("oauth unavailable");
-				},
-			},
-		});
-
-		expect(code).toBe(0);
-		expect(output.join("\n")).toContain(
-			"Warning: failed to authorize MCP server failing-docs: oauth unavailable",
-		);
-	});
-
-	it("prints guidance for plugin MCP OAuth candidates in non-interactive installs", async () => {
-		process.env.CLINE_MCP_SETTINGS_PATH = join(root, "mcp-settings.json");
-		const source = join(root, "non-interactive-mcp-plugin.js");
-		writeFileSync(
-			source,
-			`
-export default {
-  name: "non-interactive-mcp-plugin",
-  manifest: { capabilities: ["mcp"] },
-  setup(api) {
-    api.registerMcpServer({
-      name: "non-interactive-docs",
-      transport: { type: "streamableHttp", url: "https://example.com/mcp" },
-    })
-  },
-}
-`,
-			"utf8",
-		);
-		const output: string[] = [];
-		const authorize = vi.fn();
-
-		const code = await runPluginInstallCommand({
-			source,
-			io: {
-				writeln: (text = "") => output.push(text),
-				writeErr: (text) => output.push(text),
-			},
-			mcpOAuth: {
-				interactive: false,
-				authorize,
-			},
-		});
-
-		expect(code).toBe(0);
-		expect(authorize).not.toHaveBeenCalled();
-		expect(output.join("\n")).toContain(
-			"Plugin MCP servers may require OAuth authorization",
-		);
-		expect(output.join("\n")).toContain("non-interactive-docs");
-		expect(output.join("\n")).toContain('Run "cline mcp"');
-	});
-
 	it("prints JSON output for official plugin installs", async () => {
 		const officialPluginsRepo = await createOfficialPluginsRepo({
 			"json-plugin": {

apps/cli/src/commands/plugin.ts

@@ -21,15 +21,7 @@ import {
 	resolve,
 	sep,
 } from "node:path";
-import {
-	type McpServerRegistration,
-	type PluginMcpSettingsSyncResult,
-	type PluginUninstallOptions,
-	resolveDefaultMcpSettingsPath,
-	resolveMcpServerRegistrations,
-	syncPluginMcpServersToSettings,
-	uninstallPlugin,
-} from "@cline/core";
+import { type PluginUninstallOptions, uninstallPlugin } from "@cline/core";
 import {
 	isPluginModulePath,
 	resolveClineDir,
@@ -44,31 +36,12 @@ export interface PluginInstallOptions {
 	npmCommand?: string;
 	officialPluginsRepo?: string;
 	io?: PluginInstallIo;
-	mcpOAuth?: PluginInstallMcpOAuthOptions;
 }
 
 export interface PluginInstallResult {
 	source: string;
 	installPath: string;
 	entryPaths: string[];
-	mcpSyncFailures: PluginMcpSettingsSyncResult["failures"];
-	mcpOAuthCandidates: PluginMcpOAuthCandidate[];
-}
-
-export interface PluginMcpOAuthCandidate {
-	name: string;
-	pluginName: string;
-	pluginPath: string;
-	transportType: "sse" | "streamableHttp";
-	lastError?: string;
-}
-
-export interface PluginInstallMcpOAuthOptions {
-	interactive?: boolean;
-	selectCandidates?: (
-		candidates: PluginMcpOAuthCandidate[],
-	) => Promise<PluginMcpOAuthCandidate[]>;
-	authorize?: (candidate: PluginMcpOAuthCandidate) => Promise<void>;
 }
 
 export interface PluginInstallIo {
@@ -1032,81 +1005,6 @@ function replaceInstallPath(
 	}
 }
 
-function hasStaticHeaders(registration: McpServerRegistration): boolean {
-	const transport = registration.transport;
-	if (transport.type === "stdio") {
-		return false;
-	}
-	return (
-		transport.headers !== undefined && Object.keys(transport.headers).length > 0
-	);
-}
-
-function hasOAuthAccessToken(registration: McpServerRegistration): boolean {
-	const accessToken = registration.oauth?.tokens?.access_token;
-	return typeof accessToken === "string" && accessToken.trim().length > 0;
-}
-
-function getPluginOwner(
-	registration: McpServerRegistration,
-): { pluginName: string; pluginPath: string } | undefined {
-	const metadata = registration.metadata;
-	if (
-		!metadata ||
-		metadata.source !== "plugin" ||
-		typeof metadata.pluginName !== "string" ||
-		typeof metadata.pluginPath !== "string"
-	) {
-		return undefined;
-	}
-	return {
-		pluginName: metadata.pluginName,
-		pluginPath: metadata.pluginPath,
-	};
-}
-
-export function collectPluginMcpOAuthCandidates(input: {
-	pluginPaths: readonly string[];
-	settingsPath?: string;
-}): PluginMcpOAuthCandidate[] {
-	const pluginPaths = new Set(input.pluginPaths.map((path) => resolve(path)));
-	if (pluginPaths.size === 0) {
-		return [];
-	}
-
-	let registrations: McpServerRegistration[];
-	try {
-		registrations = resolveMcpServerRegistrations({
-			filePath: input.settingsPath ?? resolveDefaultMcpSettingsPath(),
-		});
-	} catch {
-		return [];
-	}
-
-	const candidates: PluginMcpOAuthCandidate[] = [];
-	for (const registration of registrations) {
-		const owner = getPluginOwner(registration);
-		if (!owner || !pluginPaths.has(resolve(owner.pluginPath))) {
-			continue;
-		}
-		const transportType = registration.transport.type;
-		if (transportType === "stdio") {
-			continue;
-		}
-		if (hasStaticHeaders(registration) || hasOAuthAccessToken(registration)) {
-			continue;
-		}
-		candidates.push({
-			name: registration.name,
-			pluginName: owner.pluginName,
-			pluginPath: owner.pluginPath,
-			transportType,
-			lastError: registration.oauth?.lastError,
-		});
-	}
-	return candidates.sort((left, right) => left.name.localeCompare(right.name));
-}
-
 export async function installPlugin(
 	options: PluginInstallOptions,
 ): Promise<PluginInstallResult> {
@@ -1173,161 +1071,28 @@ export async function installPlugin(
 		}
 
 		replaceInstallPath(stagingRoot, installPath, force);
-		const result = {
+		return {
 			source,
 			installPath,
 			entryPaths: entryPaths.map((entry) => resolve(installPath, entry)),
-			mcpSyncFailures: [] as PluginMcpSettingsSyncResult["failures"],
-			mcpOAuthCandidates: [] as PluginMcpOAuthCandidate[],
 		};
-		const syncResult = await syncPluginMcpServersToSettings({
-			pluginPaths: result.entryPaths,
-			cwd,
-			workspacePath: cwd,
-		});
-		result.mcpSyncFailures = syncResult.failures;
-		result.mcpOAuthCandidates = collectPluginMcpOAuthCandidates({
-			pluginPaths: result.entryPaths,
-		});
-		return result;
 	} catch (error) {
 		rmSync(stagingRoot, { recursive: true, force: true });
 		throw error;
 	}
 }
 
-function serializePluginInstallResult(
-	result: PluginInstallResult,
-): Omit<PluginInstallResult, "mcpOAuthCandidates"> {
-	return {
-		source: result.source,
-		installPath: result.installPath,
-		entryPaths: result.entryPaths,
-		mcpSyncFailures: result.mcpSyncFailures,
-	};
-}
-
-function isInteractivePluginInstall(options: PluginInstallOptions): boolean {
-	return (
-		options.mcpOAuth?.interactive ??
-		(process.stdin.isTTY && process.stdout.isTTY)
-	);
-}
-
-async function selectMcpOAuthCandidatesWithClack(
-	candidates: PluginMcpOAuthCandidate[],
-): Promise<PluginMcpOAuthCandidate[]> {
-	const p = await import("@clack/prompts");
-	const action = await p.select({
-		message: "Authorize plugin MCP servers now?",
-		options: [
-			{
-				value: "all",
-				label: "Authorize all",
-				hint: "open browser authorization for each server",
-			},
-			{
-				value: "choose",
-				label: "Choose servers",
-				hint: "select which servers to authorize",
-			},
-			{
-				value: "skip",
-				label: "Skip",
-			},
-		],
-	});
-	if (p.isCancel(action) || action === "skip") {
-		return [];
-	}
-	if (action === "all") {
-		return candidates;
-	}
-
-	const selectedNames = await p.multiselect({
-		message: "Select MCP servers to authorize",
-		options: candidates.map((candidate) => ({
-			value: candidate.name,
-			label: candidate.name,
-			hint: `${candidate.transportType} [${candidate.pluginName}]`,
-		})),
-		required: false,
-	});
-	if (p.isCancel(selectedNames) || !Array.isArray(selectedNames)) {
-		return [];
-	}
-	const selected = new Set(selectedNames);
-	return candidates.filter((candidate) => selected.has(candidate.name));
-}
-
-async function authorizeMcpOAuthCandidate(
-	candidate: PluginMcpOAuthCandidate,
-): Promise<void> {
-	const { authorizeMcpServerOAuthWithBrowser } = await import(
-		"../wizards/mcp/oauth"
-	);
-	await authorizeMcpServerOAuthWithBrowser(candidate.name, {
-		throwOnError: true,
-	});
-}
-
-async function runPluginMcpOAuthFollowup(
-	candidates: PluginMcpOAuthCandidate[],
-	options: PluginInstallOptions,
-): Promise<void> {
-	if (candidates.length === 0) {
-		return;
-	}
-
-	if (!isInteractivePluginInstall(options)) {
-		options.io?.writeln("Plugin MCP servers may require OAuth authorization:");
-		for (const candidate of candidates) {
-			options.io?.writeln(
-				`  ${candidate.name} (${candidate.transportType}, plugin: ${candidate.pluginName})`,
-			);
-		}
-		options.io?.writeln(
-			'Run "cline mcp" and choose "Authorize OAuth" to authorize them.',
-		);
-		return;
-	}
-
-	const selected =
-		options.mcpOAuth?.selectCandidates !== undefined
-			? await options.mcpOAuth.selectCandidates(candidates)
-			: await selectMcpOAuthCandidatesWithClack(candidates);
-	const authorize = options.mcpOAuth?.authorize ?? authorizeMcpOAuthCandidate;
-	for (const candidate of selected) {
-		try {
-			await authorize(candidate);
-		} catch (error) {
-			const message = error instanceof Error ? error.message : String(error);
-			options.io?.writeErr(
-				`Warning: failed to authorize MCP server ${candidate.name}: ${message}. Run "cline mcp" and choose "Authorize OAuth" to retry.`,
-			);
-		}
-	}
-}
-
 export async function runPluginInstallCommand(
 	options: PluginInstallOptions & { json?: boolean },
 ): Promise<number> {
 	try {
 		const result = await installPlugin(options);
 		if (options.json) {
-			process.stdout.write(
-				JSON.stringify(serializePluginInstallResult(result)),
-			);
+			process.stdout.write(JSON.stringify(result));
 			return 0;
 		}
 		options.io?.writeln(`Installed plugin from ${result.source}`);
 		options.io?.writeln(`  Path: ${result.installPath}`);
-		for (const failure of result.mcpSyncFailures) {
-			options.io?.writeErr(
-				`Warning: failed to sync plugin MCP servers for ${failure.pluginName ?? failure.pluginPath}: ${failure.message}`,
-			);
-		}
-		await runPluginMcpOAuthFollowup(result.mcpOAuthCandidates, options);
 		return 0;
 	} catch (error) {
 		const message = error instanceof Error ? error.message : String(error);

apps/cli/src/commands/program.ts

@@ -116,6 +116,7 @@ export function createProgram(): Command {
 			writeOut: () => {}, // suppress by default; main.ts re-enables for routing
 			writeErr: () => {},
 		})
+		.allowUnknownOption()
 		.allowExcessArguments()
 		.enablePositionalOptions()
 		.argument(

apps/cli/src/commands/skill.test.ts

@@ -1,88 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { buildSkillsArgs } from "./skill";
-
-describe("buildSkillsArgs", () => {
-	it("runs the skills package through npx with -y", () => {
-		expect(buildSkillsArgs(["list"])).toEqual(["-y", "skills@latest", "list"]);
-	});
-
-	it("injects --agent cline for install-style subcommands", () => {
-		expect(buildSkillsArgs(["install", "owner/repo"])).toEqual([
-			"-y",
-			"skills@latest",
-			"add",
-			"owner/repo",
-			"--agent",
-			"cline",
-		]);
-		expect(buildSkillsArgs(["add", "owner/repo"])).toContain("cline");
-		expect(buildSkillsArgs(["i", "owner/repo"])).toContain("cline");
-		expect(buildSkillsArgs(["update", "owner/repo"])).toContain("cline");
-	});
-
-	it("aliases uninstall to the skills remove subcommand", () => {
-		expect(buildSkillsArgs(["uninstall", "my-skill"])).toEqual([
-			"-y",
-			"skills@latest",
-			"remove",
-			"my-skill",
-			"--agent",
-			"cline",
-		]);
-	});
-
-	it("does not inject when the user already targeted an agent", () => {
-		expect(
-			buildSkillsArgs(["install", "owner/repo", "--agent", "cursor"]),
-		).not.toContain("cline");
-		expect(
-			buildSkillsArgs(["install", "owner/repo", "-a", "cursor"]),
-		).not.toContain("cline");
-		expect(
-			buildSkillsArgs(["install", "owner/repo", "--agent=cursor"]),
-		).not.toContain("cline");
-	});
-
-	it("aliases install and uninstall when agent options come before the subcommand", () => {
-		expect(
-			buildSkillsArgs(["--agent", "cursor", "install", "owner/repo"]),
-		).toEqual([
-			"-y",
-			"skills@latest",
-			"--agent",
-			"cursor",
-			"add",
-			"owner/repo",
-		]);
-		expect(
-			buildSkillsArgs(["--agent=cursor", "uninstall", "my-skill"]),
-		).toEqual(["-y", "skills@latest", "--agent=cursor", "remove", "my-skill"]);
-	});
-
-	it("does not scope non-install subcommands to cline", () => {
-		expect(buildSkillsArgs(["use", "owner/repo"])).not.toContain("--agent");
-		expect(buildSkillsArgs(["list"])).not.toContain("--agent");
-	});
-
-	it("scopes remove-style subcommands to cline", () => {
-		expect(buildSkillsArgs(["remove"])).toEqual([
-			"-y",
-			"skills@latest",
-			"remove",
-			"--agent",
-			"cline",
-		]);
-		expect(buildSkillsArgs(["rm", "my-skill"])).toContain("cline");
-		expect(buildSkillsArgs(["r", "my-skill"])).toContain("cline");
-	});
-
-	it("ignores leading flags when detecting the subcommand", () => {
-		expect(buildSkillsArgs(["--global", "install", "owner/repo"])).toContain(
-			"cline",
-		);
-	});
-
-	it("forwards an empty arg list unchanged", () => {
-		expect(buildSkillsArgs([])).toEqual(["-y", "skills@latest"]);
-	});
-});

apps/cli/src/commands/skill.ts

@@ -1,160 +0,0 @@
-import { type SpawnOptions, spawn } from "node:child_process";
-
-export interface SkillCommandIo {
-	writeln: (text?: string) => void;
-	writeErr: (text: string) => void;
-}
-
-// `cline skill` is a thin wrapper around the open skills CLI
-// (https://www.npmjs.com/package/skills). We run it through `npx` so users
-// don't need a separate global install. Pin the version here if we ever need to
-// lock behavior to a known-good release.
-const SKILLS_PACKAGE = "skills@latest";
-
-// Subcommands that write skill files into an agent's skills directory. For a
-// `cline skill` command we default these to Cline unless the user picked their
-// own agent. `use` is intentionally excluded: without --agent it prints the
-// generated prompt to stdout, whereas adding --agent would launch that agent
-// interactively instead — not what someone scoping to Cline would expect.
-const CLINE_SCOPED_SUBCOMMANDS = new Set([
-	"add",
-	"install",
-	"i",
-	"update",
-	"remove",
-	"rm",
-	"r",
-	"uninstall",
-]);
-
-const SKILLS_SUBCOMMAND_ALIASES = new Map([
-	["install", "add"],
-	["uninstall", "remove"],
-]);
-
-function hasAgentFlag(args: readonly string[]): boolean {
-	return args.some(
-		(arg) => arg === "-a" || arg === "--agent" || arg.startsWith("--agent="),
-	);
-}
-
-function optionConsumesNextValue(arg: string): boolean {
-	return arg === "-a" || arg === "--agent";
-}
-
-function findSubcommandIndex(args: readonly string[]): number {
-	for (let index = 0; index < args.length; index++) {
-		const arg = args[index];
-		if (arg.startsWith("-")) {
-			if (optionConsumesNextValue(arg)) {
-				index++;
-			}
-			continue;
-		}
-		return index;
-	}
-	return -1;
-}
-
-function findSubcommand(args: readonly string[]): string | undefined {
-	const index = findSubcommandIndex(args);
-	return index >= 0 ? args[index] : undefined;
-}
-
-function normalizeSkillsSubcommandAliases(args: string[]): void {
-	const index = findSubcommandIndex(args);
-	if (index < 0) return;
-	const alias = SKILLS_SUBCOMMAND_ALIASES.get(args[index]);
-	if (alias) {
-		args[index] = alias;
-	}
-}
-
-/**
- * Build the argument list passed to `npx`, injecting `--agent cline` for
- * install-style subcommands unless the user already targeted an agent.
- */
-export function buildSkillsArgs(userArgs: readonly string[]): string[] {
-	const args = [...userArgs];
-	const subcommand = findSubcommand(args);
-	normalizeSkillsSubcommandAliases(args);
-	if (
-		subcommand &&
-		CLINE_SCOPED_SUBCOMMANDS.has(subcommand) &&
-		!hasAgentFlag(args)
-	) {
-		args.push("--agent", "cline");
-	}
-	return ["-y", SKILLS_PACKAGE, ...args];
-}
-
-function resolveExitCode(
-	code: number | null,
-	signal: NodeJS.Signals | null,
-): number {
-	if (code !== null) {
-		return code;
-	}
-	switch (signal) {
-		case "SIGINT":
-			return 130;
-		case "SIGTERM":
-			return 143;
-		default:
-			return 1;
-	}
-}
-
-/**
- * Forward all arguments to the open skills CLI via `npx skills`.
- *
- * Returns the child process exit code, or 1 if npx is unavailable or fails to
- * spawn. stdio is inherited so the skills CLI's interactive prompts and output
- * pass straight through to the user's terminal.
- */
-export async function runSkillCommand(
-	userArgs: readonly string[],
-	io: SkillCommandIo,
-): Promise<number> {
-	const args = buildSkillsArgs(userArgs);
-	const isWindows = process.platform === "win32";
-	const options: SpawnOptions = {
-		stdio: "inherit",
-		env: process.env,
-		// Prevent a console window from flashing on Windows.
-		windowsHide: true,
-		...(isWindows ? { shell: true } : {}),
-	};
-
-	return new Promise<number>((resolve) => {
-		const child = spawn("npx", args, options);
-
-		const forward = (signal: NodeJS.Signals) => {
-			child.kill(signal);
-		};
-		const handleSigint = () => forward("SIGINT");
-		const handleSigterm = () => forward("SIGTERM");
-		process.on("SIGINT", handleSigint);
-		process.on("SIGTERM", handleSigterm);
-		const cleanup = () => {
-			process.off("SIGINT", handleSigint);
-			process.off("SIGTERM", handleSigterm);
-		};
-
-		child.once("error", (error: NodeJS.ErrnoException) => {
-			cleanup();
-			if (error.code === "ENOENT") {
-				io.writeErr(
-					'npx was not found. Install Node.js (which includes npx) to use "cline skill".',
-				);
-			} else {
-				io.writeErr(`Failed to run npx ${SKILLS_PACKAGE}: ${error.message}`);
-			}
-			resolve(1);
-		});
-		child.once("close", (code, signal) => {
-			cleanup();
-			resolve(resolveExitCode(code, signal));
-		});
-	});
-}

apps/cli/src/connectors/catalog.ts

@@ -1,2 +1,36 @@
-export type { ConnectorCatalogEntry } from "@cline/shared";
-export { CONNECTOR_CATALOG, listConnectorCatalog } from "@cline/shared";
+export type ConnectorCatalogEntry = {
+	name: string;
+	description: string;
+};
+
+export const CONNECTOR_CATALOG: ConnectorCatalogEntry[] = [
+	{
+		name: "discord",
+		description:
+			"Discord interactions and gateway bridge backed by RPC runtime sessions",
+	},
+	{
+		name: "gchat",
+		description: "Google Chat webhook bridge backed by RPC runtime sessions",
+	},
+	{
+		name: "linear",
+		description: "Linear webhook bridge backed by RPC runtime sessions",
+	},
+	{
+		name: "slack",
+		description: "Slack webhook/socket bridge backed by RPC runtime sessions",
+	},
+	{
+		name: "telegram",
+		description: "Bridge Telegram bot messages into RPC chat sessions",
+	},
+	{
+		name: "whatsapp",
+		description: "Bridge WhatsApp webhook messages into RPC chat sessions",
+	},
+];
+
+export function listConnectorCatalog(): ConnectorCatalogEntry[] {
+	return CONNECTOR_CATALOG.map((entry) => ({ ...entry }));
+}

apps/cli/src/main.test.ts

@@ -114,7 +114,6 @@ const telemetryMocks = vi.hoisted(() => ({
 }));
 const featureFlagMocks = vi.hoisted(() => ({
 	getBooleanFlagEnabled: vi.fn(() => false),
-	setCliFeatureFlagsAccountContext: vi.fn(),
 }));
 
 function forcePromptModeInput() {
@@ -180,8 +179,6 @@ vi.mock("./utils/feature-flags", () => ({
 		getBooleanFlagEnabled: featureFlagMocks.getBooleanFlagEnabled,
 	}),
 	refreshCliFeatureFlagsInBackground: vi.fn(),
-	setCliFeatureFlagsAccountContext:
-		featureFlagMocks.setCliFeatureFlagsAccountContext,
 }));
 vi.mock("./runtime/prompt", () => ({
 	resolveSystemPrompt: promptMocks.resolveSystemPrompt,
@@ -255,9 +252,6 @@ describe("runCli lightweight command dispatch", () => {
 		providerSettingsMocks.getProviderSettings.mockReset();
 		providerSettingsMocks.getProviderSettings.mockReturnValue(undefined);
 		providerSettingsMocks.saveProviderSettings.mockReset();
-		featureFlagMocks.getBooleanFlagEnabled.mockReset();
-		featureFlagMocks.getBooleanFlagEnabled.mockReturnValue(false);
-		featureFlagMocks.setCliFeatureFlagsAccountContext.mockReset();
 		kanbanMocks.launchKanban.mockReset();
 		kanbanMocks.launchKanban.mockResolvedValue(0);
 		dashboardMocks.runDashboardCommand.mockReset();
@@ -417,61 +411,6 @@ describe("runCli lightweight command dispatch", () => {
 		expect(mockState.runInteractiveImports).toBe(0);
 	});
 
-	it("rejects multiple bare positional prompt tokens", async () => {
-		const consoleError = vi
-			.spyOn(console, "error")
-			.mockImplementation(() => undefined);
-		forcePromptModeInput();
-		process.argv = ["bun", "src/index.ts", "hello", "world"];
-
-		const { runCli } = await import("./main");
-
-		await expect(runCli()).resolves.toBeUndefined();
-		expect(process.exitCode).toBe(1);
-		expect(consoleError).toHaveBeenCalledWith(
-			expect.stringContaining(
-				"Unknown command or extra arguments: hello world",
-			),
-		);
-		expect(runtimeMocks.runAgent).not.toHaveBeenCalled();
-		expect(mockState.runAgentImports).toBe(0);
-		expect(mockState.runInteractiveImports).toBe(0);
-	});
-
-	it("runs quoted positional prompt text", async () => {
-		forcePromptModeInput();
-		process.argv = ["bun", "src/index.ts", "hello world"];
-
-		const { runCli } = await import("./main");
-
-		await expect(runCli()).resolves.toBeUndefined();
-		expect(runtimeMocks.runAgent).toHaveBeenCalledTimes(1);
-		expect(runtimeMocks.runAgent).toHaveBeenCalledWith(
-			"hello world",
-			expect.any(Object),
-			expect.anything(),
-		);
-	});
-
-	it("rejects unknown root flags before loading runtime modules", async () => {
-		const consoleError = vi
-			.spyOn(console, "error")
-			.mockImplementation(() => undefined);
-		forcePromptModeInput();
-		process.argv = ["bun", "src/index.ts", "--made-up-flag"];
-
-		const { runCli } = await import("./main");
-
-		await expect(runCli()).resolves.toBeUndefined();
-		expect(process.exitCode).toBe(1);
-		expect(consoleError).toHaveBeenCalledWith(
-			expect.stringContaining("unknown option '--made-up-flag'"),
-		);
-		expect(runtimeMocks.runAgent).not.toHaveBeenCalled();
-		expect(mockState.runAgentImports).toBe(0);
-		expect(mockState.runInteractiveImports).toBe(0);
-	});
-
 	it("creates a worktree and runs prompt sessions from it", async () => {
 		forcePromptModeInput();
 		process.argv = ["bun", "src/index.ts", "--worktree", "hello"];
@@ -918,33 +857,6 @@ describe("runCli lightweight command dispatch", () => {
 		);
 	});
 
-	it("seeds feature flag identity from persisted Cline account id before checking flags", async () => {
-		const clineSettings = {
-			provider: "cline",
-			model: "anthropic/claude-sonnet-4.6",
-			auth: {
-				accountId: "acct-startup",
-				accessToken: "workos:token",
-				refreshToken: "refresh-token",
-			},
-		};
-		providerSettingsMocks.getProviderSettings.mockReturnValue(clineSettings);
-		process.argv = ["bun", "src/index.ts"];
-
-		const { runCli } = await import("./main");
-
-		await expect(runCli()).resolves.toBeUndefined();
-		expect(
-			featureFlagMocks.setCliFeatureFlagsAccountContext,
-		).toHaveBeenCalledWith({ id: "acct-startup" });
-		expect(
-			featureFlagMocks.setCliFeatureFlagsAccountContext.mock
-				.invocationCallOrder[0],
-		).toBeLessThan(
-			featureFlagMocks.getBooleanFlagEnabled.mock.invocationCallOrder[0],
-		);
-	});
-
 	it("runs kanban before loading runtime modules", async () => {
 		process.argv = ["bun", "src/index.ts", "kanban"];
 
@@ -962,10 +874,6 @@ describe("runCli lightweight command dispatch", () => {
 			"bun",
 			"src/index.ts",
 			"dashboard",
-			"--config",
-			"/tmp/cline-config",
-			"--data-dir",
-			".cline-dashboard-data",
 			"--port",
 			"9090",
 			"--no-open",
@@ -976,8 +884,6 @@ describe("runCli lightweight command dispatch", () => {
 		await expect(runCli()).resolves.toBeUndefined();
 		expect(dashboardMocks.runDashboardCommand).toHaveBeenCalledWith(
 			expect.objectContaining({
-				configDir: "/tmp/cline-config",
-				dataDir: ".cline-dashboard-data",
 				port: "9090",
 				openBrowser: false,
 				io: expect.any(Object),
@@ -1026,7 +932,7 @@ describe("runCli lightweight command dispatch", () => {
 		runtimeMocks.runAgent.mockClear();
 
 		forcePromptModeInput();
-		process.argv = ["bun", "src/index.ts", "/team find the bug"];
+		process.argv = ["bun", "src/index.ts", "/team", "find", "the", "bug"];
 
 		const { runCli } = await import("./main");
 

apps/cli/src/main.ts

@@ -22,7 +22,6 @@ import {
 import {
 	getCliFeatureFlagsService,
 	refreshCliFeatureFlagsInBackground,
-	setCliFeatureFlagsAccountContext,
 } from "./utils/feature-flags";
 import {
 	configureSandboxEnvironment,
@@ -140,7 +139,7 @@ export async function runCli(): Promise<void> {
 	// Re-enable built-in help/version output for the routing program
 	program.configureOutput({
 		writeOut: (str: string) => process.stdout.write(str),
-		writeErr: () => {},
+		writeErr: (str: string) => process.stderr.write(str),
 	});
 	// Default action handles non-subcommand args (e.g. prompt text)
 	program.action(() => {});
@@ -316,28 +315,6 @@ export async function runCli(): Promise<void> {
 				io,
 			});
 		});
-	const skillCmd = program
-		.command("skill")
-		.description("Manage Cline Skills via the open skills CLI (npx skills)")
-		.allowUnknownOption()
-		.passThroughOptions()
-		.argument("[args...]", "arguments forwarded to the skills CLI")
-		.addHelpText(
-			"after",
-			"\nForwards to the open skills CLI via npx. Examples:\n" +
-				"  cline skill add <owner/repo>       Add a skill into Cline\n" +
-				"  cline skill install <owner/repo>   Alias for add\n" +
-				"  cline skill list                   List installed skills\n" +
-				"  cline skill remove                 Remove installed skills\n" +
-				"  cline skill uninstall              Alias for remove\n" +
-				"\nadd/install and remove/uninstall default to '--agent cline' unless you pass your own --agent.\n" +
-				"Run 'npx skills --help' for the full command reference.",
-		)
-		.action(async () => {
-			const { runSkillCommand } = await import("./commands/skill");
-			ctx.exitCode = await runSkillCommand(skillCmd.args, io);
-		});
-
 	const connectCmd = program
 		.command("connect")
 		.description("Connect to an external channel")
@@ -379,7 +356,7 @@ export async function runCli(): Promise<void> {
 			}
 		});
 
-	const mcpCmd = program
+	program
 		.command("mcp")
 		.description("Manage MCP servers")
 		.action(async () => {
@@ -391,31 +368,6 @@ export async function runCli(): Promise<void> {
 				);
 			}
 		});
-	const mcpInstallCmd = mcpCmd
-		.command("install")
-		.alias("add")
-		.description("Open the MCP add wizard with server fields prefilled")
-		.argument("<name>", "MCP server name")
-		.argument(
-			"[targetArgs...]",
-			"URL for remote transports, or command and args after -- for stdio",
-		)
-		.option(
-			"--transport <transport>",
-			"stdio, sse, http, streamable-http, or streamableHttp (default: stdio)",
-		)
-		.action(async (name: string, targetArgs: string[]) => {
-			const opts = mcpInstallCmd.opts<{
-				transport?: string;
-			}>();
-			const { runMcpInstallCommand } = await import("./commands/mcp");
-			ctx.exitCode = await runMcpInstallCommand({
-				name,
-				targetArgs,
-				transport: opts.transport,
-				io,
-			});
-		});
 
 	const createDoctorRuntimeCommand = async () => {
 		const { createDoctorCommand } = await import("./commands/doctor");
@@ -596,12 +548,7 @@ export async function runCli(): Promise<void> {
 	const dashboardCmd = program
 		.command("dashboard")
 		.description("Start the Cline Hub dashboard and open it in a browser")
-		.option("--config <dir>", "configuration directory")
 		.option("-c, --cwd <path>", "Workspace root", process.cwd())
-		.option(
-			"--data-dir <dir>",
-			"Use isolated local state at <dir> instead of ~/.cline (enables sandbox mode)",
-		)
 		.option("--host <host>", "Dashboard bind host")
 		.option("--port <port>", "Dashboard HTTP/WebSocket port")
 		.option("--public-url <url>", "Public dashboard URL")
@@ -609,9 +556,7 @@ export async function runCli(): Promise<void> {
 		.option("--no-open", "Start the dashboard without opening a browser")
 		.action(async () => {
 			const opts = dashboardCmd.opts<{
-				config?: string;
 				cwd?: string;
-				dataDir?: string;
 				host?: string;
 				port?: string;
 				publicUrl?: string;
@@ -620,9 +565,7 @@ export async function runCli(): Promise<void> {
 			}>();
 			const { runDashboardCommand } = await import("./commands/dashboard");
 			ctx.exitCode = await runDashboardCommand({
-				configDir: opts.config,
 				cwd: opts.cwd,
-				dataDir: opts.dataDir,
 				host: opts.host,
 				port: opts.port,
 				publicUrl: opts.publicUrl,
@@ -671,7 +614,6 @@ export async function runCli(): Promise<void> {
 		if (err instanceof CommanderError) {
 			if (err.exitCode !== 0) {
 				writeErr(err.message);
-				process.exitCode = err.exitCode;
 				return;
 			}
 			return;
@@ -722,13 +664,6 @@ export async function runCli(): Promise<void> {
 
 	// Default flow: no subcommand matched, or fall-through from config/history.
 	let args = commanderToParsedArgs(program);
-	if (program.args.length > 1) {
-		writeErr(
-			`Unknown command or extra arguments: ${program.args.join(" ")}\nPrompt text with spaces must be quoted as a single argument, for example: cline "fix the tests". Use "cline --help" to see available commands and flags.`,
-		);
-		process.exitCode = 1;
-		return;
-	}
 
 	let resumeSessionId: string | undefined = ctx.resumeSessionId;
 	if (resumeSessionId) {
@@ -920,12 +855,6 @@ export async function runCli(): Promise<void> {
 	};
 	registerDisposable(stopUserInstructionService);
 	try {
-		const persistedClineAccountId = providerSettingsManager
-			.getProviderSettings("cline")
-			?.auth?.accountId?.trim();
-		if (persistedClineAccountId) {
-			setCliFeatureFlagsAccountContext({ id: persistedClineAccountId });
-		}
 		refreshCliFeatureFlagsInBackground();
 		const lastUsedProviderSettings =
 			providerSettingsManager.getLastUsedProviderSettings({

apps/cli/src/runtime/interactive/approvals.test.ts

@@ -61,20 +61,6 @@ describe("createInteractiveApprovalController", () => {
 		).resolves.toEqual({ approved: false, reason: "no" });
 	});
 
-	it("approves stale required-approval requests after auto-approve is enabled", async () => {
-		const controller = createInteractiveApprovalController(makeConfig(false));
-		controller.tuiToolApprover.current = async () => ({
-			approved: false,
-			reason: "stale prompt",
-		});
-
-		controller.setInteractiveAutoApprove(true);
-
-		await expect(
-			controller.requestToolApproval(makeRequest({ autoApprove: false })),
-		).resolves.toEqual({ approved: true });
-	});
-
 	it("denies approval-required requests when no TUI approver is available", async () => {
 		const controller = createInteractiveApprovalController(makeConfig(false));
 
@@ -91,7 +77,6 @@ describe("createInteractiveApprovalController", () => {
 
 		expect(controller.autoApproveAllRef.current).toBe(true);
 		expect(config.defaultToolAutoApprove).toBe(false);
-		expect(config.toolPolicies["*"]?.autoApprove).toBe(true);
-		expect(controller.resolveToolPolicy("run_commands").autoApprove).toBe(true);
+		expect(config.toolPolicies["*"]?.autoApprove).toBe(false);
 	});
 });

apps/cli/src/runtime/interactive/approvals.ts

@@ -3,7 +3,6 @@ import type { Config } from "../../utils/types";
 import {
 	applyInteractiveAutoApproveOverride,
 	cloneToolPolicies,
-	resolveInteractiveAutoApprovePolicy,
 } from "../tool-policies";
 
 export interface InteractiveRuntimeRefs {
@@ -39,10 +38,10 @@ export function createInteractiveApprovalController(config: Config) {
 	const requestToolApproval = async (
 		request: ToolApprovalRequest,
 	): Promise<ToolApprovalResult> => {
-		if (autoApproveAllRef.current) {
+		if (request.policy?.autoApprove === true) {
 			return { approved: true };
 		}
-		if (request.policy?.autoApprove === true) {
+		if (autoApproveAllRef.current && request.policy?.autoApprove !== false) {
 			return { approved: true };
 		}
 		if (refs.tuiToolApprover.current) {
@@ -55,12 +54,6 @@ export function createInteractiveApprovalController(config: Config) {
 		autoApproveAllRef,
 		setInteractiveAutoApprove,
 		requestToolApproval,
-		resolveToolPolicy: (toolName: string) =>
-			resolveInteractiveAutoApprovePolicy({
-				toolName,
-				baselinePolicies: baselineToolPolicies,
-				enabled: autoApproveAllRef.current,
-			}),
 		...refs,
 	};
 }

apps/cli/src/runtime/interactive/config-data.test.ts

@@ -1,11 +1,4 @@
-import {
-	chmod,
-	mkdir,
-	mkdtemp,
-	readFile,
-	rm,
-	writeFile,
-} from "node:fs/promises";
+import { mkdir, mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import type { UserInstructionConfigService } from "@cline/core";
@@ -50,17 +43,9 @@ describe("interactive config data loader", () => {
 	};
 
 	afterEach(async () => {
-		if (envSnapshot.CLINE_GLOBAL_SETTINGS_PATH === undefined) {
-			delete process.env.CLINE_GLOBAL_SETTINGS_PATH;
-		} else {
-			process.env.CLINE_GLOBAL_SETTINGS_PATH =
-				envSnapshot.CLINE_GLOBAL_SETTINGS_PATH;
-		}
-		if (envSnapshot.CLINE_MCP_SETTINGS_PATH === undefined) {
-			delete process.env.CLINE_MCP_SETTINGS_PATH;
-		} else {
-			process.env.CLINE_MCP_SETTINGS_PATH = envSnapshot.CLINE_MCP_SETTINGS_PATH;
-		}
+		process.env.CLINE_GLOBAL_SETTINGS_PATH =
+			envSnapshot.CLINE_GLOBAL_SETTINGS_PATH;
+		process.env.CLINE_MCP_SETTINGS_PATH = envSnapshot.CLINE_MCP_SETTINGS_PATH;
 		await Promise.all(
 			tempRoots.map((dir) => rm(dir, { recursive: true, force: true })),
 		);
@@ -91,28 +76,6 @@ describe("interactive config data loader", () => {
 		return pluginPath;
 	}
 
-	async function writeMcpSettingsPlugin(tempRoot: string): Promise<string> {
-		const pluginsDir = join(tempRoot, ".cline", "plugins");
-		await mkdir(pluginsDir, { recursive: true });
-		const pluginPath = join(pluginsDir, "settings-mcp-plugin.js");
-		await writeFile(
-			pluginPath,
-			[
-				"export default {",
-				"  name: 'settings-mcp-plugin',",
-				"  manifest: { capabilities: ['mcp'] },",
-				"  setup(api) {",
-				"    api.registerMcpServer({",
-				"      name: 'smoke',",
-				"      transport: { type: 'stdio', command: process.execPath, args: ['-e', 'process.exit(0)'] },",
-				"    });",
-				"  },",
-				"};",
-			].join("\n"),
-		);
-		return pluginPath;
-	}
-
 	it("toggles a skill item to the opposite enabled state and refreshes before reload", async () => {
 		const tempRoot = await mkdtemp(join(tmpdir(), "cli-config-data-"));
 		tempRoots.push(tempRoot);
@@ -348,70 +311,6 @@ Find installable skills.`,
 		).toBe(true);
 	});
 
-	it("loads plugin-owned MCP servers from settings", async () => {
-		const tempRoot = await mkdtemp(join(tmpdir(), "cli-config-data-"));
-		tempRoots.push(tempRoot);
-		const settingsPath = join(tempRoot, "cline_mcp_settings.json");
-		process.env.CLINE_MCP_SETTINGS_PATH = settingsPath;
-		const pluginPath = await writeMcpSettingsPlugin(tempRoot);
-		await writeFile(
-			settingsPath,
-			`${JSON.stringify(
-				{
-					mcpServers: {
-						smoke: {
-							transport: {
-								type: "stdio",
-								command: process.execPath,
-								args: ["-e", "process.exit(0)"],
-							},
-							metadata: {
-								source: "plugin",
-								pluginName: "settings-mcp-plugin",
-								pluginPath,
-							},
-						},
-					},
-				},
-				null,
-				2,
-			)}\n`,
-		);
-		const loader = createInteractiveConfigDataLoader({
-			config: createConfig(tempRoot),
-		});
-
-		const data = await loader.loadConfigData({ includePluginTools: true });
-
-		expect(
-			data.mcp.some(
-				(item) =>
-					item.name === "smoke" &&
-					item.pluginName === "settings-mcp-plugin" &&
-					item.pluginPath === pluginPath &&
-					item.kind === "mcp",
-			),
-		).toBe(true);
-	});
-
-	it("does not load plugin MCP rows directly from plugin diagnostics", async () => {
-		const tempRoot = await mkdtemp(join(tmpdir(), "cli-config-data-"));
-		tempRoots.push(tempRoot);
-		process.env.CLINE_GLOBAL_SETTINGS_PATH = join(
-			tempRoot,
-			"global-settings.json",
-		);
-		const pluginPath = await writeMcpSettingsPlugin(tempRoot);
-		const loader = createInteractiveConfigDataLoader({
-			config: createConfig(tempRoot),
-		});
-
-		const data = await loader.loadConfigData({ includePluginTools: true });
-
-		expect(data.plugins.some((item) => item.path === pluginPath)).toBe(true);
-		expect(data.mcp.some((item) => item.pluginPath === pluginPath)).toBe(false);
-	});
-
 	it("keeps failed plugins visible with their load error", async () => {
 		const tempRoot = await mkdtemp(join(tmpdir(), "cli-config-data-"));
 		tempRoots.push(tempRoot);
@@ -832,142 +731,6 @@ Review with the bundled skill.`,
 		).toBe(false);
 	});
 
-	it("disables and re-syncs plugin-owned MCP servers when toggling plugins", async () => {
-		const tempRoot = await mkdtemp(join(tmpdir(), "cli-config-data-"));
-		tempRoots.push(tempRoot);
-		const settingsPath = join(tempRoot, "cline_mcp_settings.json");
-		process.env.CLINE_GLOBAL_SETTINGS_PATH = join(
-			tempRoot,
-			"global-settings.json",
-		);
-		process.env.CLINE_MCP_SETTINGS_PATH = settingsPath;
-		const pluginPath = await writeMcpSettingsPlugin(tempRoot);
-		await writeFile(
-			settingsPath,
-			`${JSON.stringify(
-				{
-					mcpServers: {
-						smoke: {
-							transport: {
-								type: "stdio",
-								command: process.execPath,
-								args: ["-e", "process.exit(0)"],
-							},
-							oauth: {
-								tokens: {
-									access_token: "token",
-								},
-							},
-							metadata: {
-								source: "plugin",
-								pluginName: "settings-mcp-plugin",
-								pluginPath,
-							},
-						},
-					},
-				},
-				null,
-				2,
-			)}\n`,
-		);
-		const loader = createInteractiveConfigDataLoader({
-			config: createConfig(tempRoot),
-		});
-		const item: InteractiveConfigItem = {
-			id: pluginPath,
-			name: "settings-mcp-plugin",
-			path: pluginPath,
-			enabled: true,
-			source: "workspace-plugin",
-			kind: "plugin",
-		};
-
-		await loader.onToggleConfigItem(item);
-		let settings = JSON.parse(await readFile(settingsPath, "utf8")) as {
-			mcpServers?: Record<
-				string,
-				{ disabled?: boolean; oauth?: { tokens?: Record<string, string> } }
-			>;
-		};
-		expect(settings.mcpServers?.smoke?.disabled).toBe(true);
-		expect(settings.mcpServers?.smoke?.oauth?.tokens?.access_token).toBe(
-			"token",
-		);
-
-		await loader.onToggleConfigItem({ ...item, enabled: false });
-		settings = JSON.parse(await readFile(settingsPath, "utf8")) as {
-			mcpServers?: Record<
-				string,
-				{ disabled?: boolean; oauth?: { tokens?: Record<string, string> } }
-			>;
-		};
-		expect(settings.mcpServers?.smoke?.disabled).toBeUndefined();
-		expect(settings.mcpServers?.smoke?.oauth?.tokens?.access_token).toBe(
-			"token",
-		);
-	});
-
-	it.skipIf(process.platform === "win32")(
-		"does not mark plugin disabled when MCP disable write fails",
-		async () => {
-			const tempRoot = await mkdtemp(join(tmpdir(), "cli-config-data-"));
-			tempRoots.push(tempRoot);
-			const settingsPath = join(tempRoot, "cline_mcp_settings.json");
-			const globalSettingsPath = join(tempRoot, "global-settings.json");
-			process.env.CLINE_GLOBAL_SETTINGS_PATH = globalSettingsPath;
-			process.env.CLINE_MCP_SETTINGS_PATH = settingsPath;
-			const pluginPath = await writeMcpSettingsPlugin(tempRoot);
-			await writeFile(
-				settingsPath,
-				`${JSON.stringify(
-					{
-						mcpServers: {
-							smoke: {
-								transport: {
-									type: "stdio",
-									command: process.execPath,
-									args: ["-e", "process.exit(0)"],
-								},
-								metadata: {
-									source: "plugin",
-									pluginName: "settings-mcp-plugin",
-									pluginPath,
-								},
-							},
-						},
-					},
-					null,
-					2,
-				)}\n`,
-			);
-			await chmod(settingsPath, 0o444);
-			const loader = createInteractiveConfigDataLoader({
-				config: createConfig(tempRoot),
-			});
-
-			try {
-				await expect(
-					loader.onToggleConfigItem({
-						id: pluginPath,
-						name: "settings-mcp-plugin",
-						path: pluginPath,
-						enabled: true,
-						source: "workspace-plugin",
-						kind: "plugin",
-					}),
-				).rejects.toThrow();
-			} finally {
-				await chmod(settingsPath, 0o644);
-			}
-
-			await expect(readFile(globalSettingsPath, "utf8")).rejects.toThrow();
-			const settings = JSON.parse(await readFile(settingsPath, "utf8")) as {
-				mcpServers?: Record<string, { disabled?: boolean }>;
-			};
-			expect(settings.mcpServers?.smoke?.disabled).toBeUndefined();
-		},
-	);
-
 	it("surfaces MCP OAuth status and errors", async () => {
 		const tempRoot = await mkdtemp(join(tmpdir(), "cli-config-data-"));
 		tempRoots.push(tempRoot);

apps/cli/src/runtime/interactive/config-data.ts

@@ -1,9 +1,7 @@
 import {
 	createCoreSettingsService,
-	disablePluginMcpServersInSettings,
 	setDisabledPlugin,
 	setDisabledTools,
-	syncPluginMcpServersToSettings,
 	type UserInstructionConfigService,
 	uninstallPlugin,
 } from "@cline/core";
@@ -72,32 +70,7 @@ export function createInteractiveConfigDataLoader(input: {
 		}
 
 		if (item.kind === "plugin" && typeof item.enabled === "boolean") {
-			if (item.enabled) {
-				disablePluginMcpServersInSettings({ pluginPaths: [item.path] });
-				setDisabledPlugin(item.path, true);
-			} else {
-				const ownedMcpMutations = disablePluginMcpServersInSettings({
-					pluginPaths: [item.path],
-				});
-				const result = await syncPluginMcpServersToSettings({
-					pluginPaths: [item.path],
-					cwd: input.config.cwd,
-					workspacePath: workspaceRoot(),
-					providerId: input.config.providerId,
-					modelId: input.config.modelId,
-				});
-				if (ownedMcpMutations.length > 0 && result.failures.length > 0) {
-					throw new Error(
-						`Failed to sync plugin MCP servers: ${result.failures
-							.map((failure) => {
-								const plugin = failure.pluginName ?? failure.pluginPath;
-								return `${plugin}: ${failure.message}`;
-							})
-							.join("; ")}`,
-					);
-				}
-				setDisabledPlugin(item.path, false);
-			}
+			setDisabledPlugin(item.path, item.enabled);
 			return undefined;
 		}
 

apps/cli/src/runtime/interactive/session-runtime.test.ts

@@ -152,10 +152,7 @@ function deferred<T>() {
 
 function makeRuntime(
 	manager: ReturnType<typeof makeManager>,
-	options: {
-		resumeSessionId?: string;
-		resolveToolPolicy?: (toolName: string) => Config["toolPolicies"][string];
-	} = {},
+	options: { resumeSessionId?: string } = {},
 ) {
 	mockCreateCliCore.mockResolvedValue(manager);
 	const config = makeConfig();
@@ -167,8 +164,6 @@ function makeRuntime(
 		requestToolApproval: async (
 			_request: ToolApprovalRequest,
 		): Promise<ToolApprovalResult> => ({ approved: true }),
-		resolveToolPolicy:
-			options.resolveToolPolicy ?? (() => ({ autoApprove: true })),
 		askQuestionRef: { current: null },
 		resolveMistakeLimitDecision: undefined,
 		switchToActModeTool: makeSwitchToActModeTool(),
@@ -210,68 +205,6 @@ describe("createInteractiveSessionRuntime", () => {
 		expect(runtime.getActiveSessionId()).toBe("session-2");
 	});
 
-	it("adds a live interactive approval policy hook to started sessions", async () => {
-		const manager = makeManager();
-		const upstreamBeforeTool = vi.fn(async () => ({
-			input: { text: "updated" },
-		}));
-		mockCreateRuntimeHooks.mockReturnValueOnce({
-			hooks: {
-				beforeTool: upstreamBeforeTool,
-			},
-			shutdown: vi.fn(async () => {}),
-		});
-		const runtime = makeRuntime(manager, {
-			resolveToolPolicy: (toolName) => ({
-				autoApprove: toolName === "echo",
-			}),
-		});
-
-		await runtime.ensureReady();
-
-		const startInput = manager.start.mock.calls[0]?.[0] as
-			| { config?: Config }
-			| undefined;
-		const beforeTool = startInput?.config?.hooks?.beforeTool;
-		expect(beforeTool).toBeTypeOf("function");
-
-		const result = await beforeTool?.({
-			snapshot: {
-				agentId: "agent-1",
-				conversationId: "conversation-1",
-				status: "running",
-				iteration: 1,
-				messages: [],
-				pendingToolCalls: [],
-				usage: {
-					inputTokens: 0,
-					outputTokens: 0,
-					cacheReadTokens: 0,
-					cacheWriteTokens: 0,
-				},
-			},
-			tool: {
-				name: "echo",
-				description: "",
-				inputSchema: {},
-				execute: async () => "ok",
-			},
-			toolCall: {
-				type: "tool-call",
-				toolCallId: "call-1",
-				toolName: "echo",
-				input: { text: "original" },
-			},
-			input: { text: "original" },
-		});
-
-		expect(upstreamBeforeTool).toHaveBeenCalledOnce();
-		expect(result).toEqual({
-			input: { text: "updated" },
-			policy: { autoApprove: true },
-		});
-	});
-
 	it("starts fresh after resetting an initially resumed session", async () => {
 		const manager = makeManager();
 		const runtime = makeRuntime(manager, {

apps/cli/src/runtime/interactive/session-runtime.ts

@@ -1,6 +1,5 @@
 import {
 	type AgentEvent,
-	type AgentHooks,
 	type CheckpointEntry,
 	isSessionNotFoundError,
 	type PendingPromptMutationResult,
@@ -49,32 +48,6 @@ type CurrentTurnResult = Awaited<ReturnType<CliCore["send"]>>;
 type AskQuestionRef = {
 	current: ((question: string, options: string[]) => Promise<string>) | null;
 };
-type ToolPolicyResolver = (
-	toolName: string,
-) => NonNullable<Config["toolPolicies"]>[string];
-
-function withInteractiveApprovalPolicyHook(
-	hooks: AgentHooks | undefined,
-	resolveToolPolicy: ToolPolicyResolver,
-): AgentHooks {
-	return {
-		...hooks,
-		beforeTool: async (ctx) => {
-			const result = await hooks?.beforeTool?.(ctx);
-			if (result?.stop || result?.skip) {
-				return result;
-			}
-			const policy = resolveToolPolicy(ctx.toolCall.toolName);
-			return {
-				...result,
-				policy: {
-					...result?.policy,
-					autoApprove: policy.autoApprove,
-				},
-			};
-		},
-	};
-}
 
 export function createInteractiveSessionRuntime(input: {
 	config: Config;
@@ -85,7 +58,6 @@ export function createInteractiveSessionRuntime(input: {
 	requestToolApproval: (
 		request: ToolApprovalRequest,
 	) => Promise<ToolApprovalResult>;
-	resolveToolPolicy: ToolPolicyResolver;
 	askQuestionRef: AskQuestionRef;
 	resolveMistakeLimitDecision: Config["onConsecutiveMistakeLimitReached"];
 	switchToActModeTool: NonNullable<Config["extraTools"]>[number];
@@ -180,14 +152,10 @@ export function createInteractiveSessionRuntime(input: {
 		if (!runtimeHooks) {
 			throw new Error("interactive runtime hooks are unavailable");
 		}
-		const hooks = withInteractiveApprovalPolicyHook(
-			runtimeHooks.hooks,
-			input.resolveToolPolicy,
-		);
 		return buildInteractiveSessionConfig({
 			config: input.config,
 			chatCommandState: input.chatCommandState,
-			runtimeHooks: { hooks },
+			runtimeHooks,
 			onTeamEvent: input.onTeamEvent,
 			resolveMistakeLimitDecision: input.resolveMistakeLimitDecision,
 		});

apps/cli/src/runtime/run-agent.test.ts

@@ -27,41 +27,7 @@ const outputMocks = vi.hoisted(() => ({
 	c: { dim: "", reset: "" },
 }));
 
-const sessionEventsMocks = vi.hoisted(() => ({
-	listener: undefined as ((event: unknown) => void) | undefined,
-	subscribeToAgentEvents: vi.fn(
-		(_: unknown, listener: (event: unknown) => void) => {
-			sessionEventsMocks.listener = listener;
-			return () => {};
-		},
-	),
-}));
-
-const CLINE_PASS_SUBSCRIPTION_URL =
-	"https://app.cline.bot/dashboard/subscription?personal=true";
-const CLINE_PASS_SUBSCRIPTION_MESSAGE = `No access to ClinePass subscription models yet. Subscribe to ClinePass, the low cost open weights model coding plan: ${CLINE_PASS_SUBSCRIPTION_URL}`;
-const CLINE_ORG_INDIVIDUAL_INFERENCE_SUBSCRIPTION_MESSAGE =
-	"Organization accounts cannot use ClinePass subscriptions. Go to /account -> change account to switch to your personal account for ClinePass";
-
 vi.mock("@cline/core", () => ({
-	getClineOrgIndividualInferenceSubscriptionMessage: () =>
-		CLINE_ORG_INDIVIDUAL_INFERENCE_SUBSCRIPTION_MESSAGE,
-	getClinePassSubscriptionUrl: () => CLINE_PASS_SUBSCRIPTION_URL,
-	isClineNotSubscribedError: (error: unknown) =>
-		error instanceof Error && error.name === "ClineNotSubscribedError",
-	isClineNotSubscribedMessage: (text: string) =>
-		text
-			.toLowerCase()
-			.includes("the user is not subscribed to required model plan"),
-	isClineOrgIndividualInferenceSubscriptionError: (error: unknown) =>
-		error instanceof Error &&
-		error.name === "ClineOrgIndividualInferenceSubscriptionError",
-	isClineOrgIndividualInferenceSubscriptionMessage: (text: string) =>
-		text
-			.toLowerCase()
-			.includes(
-				"organization accounts cannot use individual model inference subscriptions",
-			),
 	prewarmFileIndex: vi.fn(async () => undefined),
 	SessionSource: {
 		CLI: "cli",
@@ -111,7 +77,7 @@ vi.mock("./prompt", () => ({
 }));
 
 vi.mock("./session-events", () => ({
-	subscribeToAgentEvents: sessionEventsMocks.subscribeToAgentEvents,
+	subscribeToAgentEvents: vi.fn(() => () => {}),
 }));
 
 describe("runAgent", () => {
@@ -135,9 +101,6 @@ describe("runAgent", () => {
 		outputMocks.writeln.mockReset();
 		outputMocks.emitJsonLine.mockReset();
 		outputMocks.setActiveCliSession.mockReset();
-		sessionEventsMocks.listener = undefined;
-		sessionEventsMocks.subscribeToAgentEvents.mockClear();
-		vi.unstubAllGlobals();
 	});
 
 	afterEach(() => {
@@ -548,39 +511,6 @@ describe("runAgent", () => {
 		expect(outputMocks.writeErr).toHaveBeenCalledWith("Missing API key");
 	});
 
-	it("renders ClinePass subscription errors with friendly copy when startup throws", async () => {
-		const error = new Error(CLINE_PASS_SUBSCRIPTION_MESSAGE);
-		error.name = "ClineNotSubscribedError";
-		sessionManagerMocks.start.mockRejectedValue(error);
-
-		const { runAgent } = await import("./run-agent");
-
-		await expect(
-			runAgent("test prompt", {
-				cwd: process.cwd(),
-				enableAgentTeams: false,
-				enableSpawnAgent: false,
-				enableTools: [],
-				execution: { maxConsecutiveMistakes: 3 },
-				logger: undefined,
-				mode: "yolo",
-				modelId: "premium-model",
-				outputMode: "text",
-				providerId: "cline-pass",
-				systemPrompt: "system",
-				thinking: false,
-				toolPolicies: { "*": { autoApprove: true } },
-				verbose: false,
-				workspaceRoot: process.cwd(),
-			} as never),
-		).resolves.toBeUndefined();
-
-		expect(process.exitCode).toBe(1);
-		expect(outputMocks.writeErr).toHaveBeenCalledWith(
-			CLINE_PASS_SUBSCRIPTION_MESSAGE,
-		);
-	});
-
 	it("emits JSON error lines for non-completed results", async () => {
 		const startedAt = new Date("2026-03-22T00:00:00.000Z");
 		const endedAt = new Date("2026-03-22T00:00:01.000Z");
@@ -646,63 +576,6 @@ describe("runAgent", () => {
 		);
 	});
 
-	it("renders ClinePass subscription errors with friendly copy for failed results", async () => {
-		const startedAt = new Date("2026-03-22T00:00:00.000Z");
-		const endedAt = new Date("2026-03-22T00:00:01.000Z");
-		sessionManagerMocks.start.mockResolvedValue({
-			sessionId: "session-1",
-			manifestPath: "/tmp/manifest.json",
-			messagesPath: "/tmp/messages.json",
-			manifest: { session_id: "session-1" },
-			result: {
-				text: CLINE_PASS_SUBSCRIPTION_MESSAGE,
-				usage: {
-					inputTokens: 0,
-					outputTokens: 0,
-					cacheReadTokens: 0,
-					cacheWriteTokens: 0,
-					totalCost: 0,
-				},
-				messages: [],
-				toolCalls: [],
-				iterations: 1,
-				finishReason: "error",
-				model: { id: "premium-model", provider: "cline-pass", info: {} },
-				startedAt,
-				endedAt,
-				durationMs: 1000,
-			},
-		});
-		sessionManagerMocks.getAccumulatedUsage.mockResolvedValue(undefined);
-
-		const { runAgent } = await import("./run-agent");
-
-		await expect(
-			runAgent("test prompt", {
-				cwd: process.cwd(),
-				enableAgentTeams: false,
-				enableSpawnAgent: false,
-				enableTools: [],
-				execution: { maxConsecutiveMistakes: 3 },
-				logger: undefined,
-				mode: "yolo",
-				modelId: "premium-model",
-				outputMode: "text",
-				providerId: "cline-pass",
-				systemPrompt: "system",
-				thinking: false,
-				toolPolicies: { "*": { autoApprove: true } },
-				verbose: false,
-				workspaceRoot: process.cwd(),
-			} as never),
-		).resolves.toBeUndefined();
-
-		expect(process.exitCode).toBe(1);
-		expect(outputMocks.writeErr).toHaveBeenCalledWith(
-			CLINE_PASS_SUBSCRIPTION_MESSAGE,
-		);
-	});
-
 	it("surfaces post-run bookkeeping failures after a completed result", async () => {
 		const startedAt = new Date("2026-03-22T00:00:00.000Z");
 		const endedAt = new Date("2026-03-22T00:00:01.000Z");
@@ -964,121 +837,4 @@ describe("runAgent", () => {
 			expect.stringContaining("est. cost"),
 		);
 	});
-
-	it("zeros Cline free model costs in JSON results and agent events", async () => {
-		const startedAt = new Date("2026-03-22T00:00:00.000Z");
-		const endedAt = new Date("2026-03-22T00:00:01.000Z");
-		vi.stubGlobal(
-			"fetch",
-			vi.fn(async () => {
-				return new Response(
-					JSON.stringify({
-						free: [{ id: "deepseek/deepseek-v4-flash" }],
-					}),
-					{ status: 200, headers: { "content-type": "application/json" } },
-				);
-			}),
-		);
-		sessionManagerMocks.start.mockResolvedValue({
-			sessionId: "session-1",
-			manifestPath: "/tmp/manifest.json",
-			messagesPath: "/tmp/messages.json",
-			manifest: {
-				session_id: "session-1",
-			},
-			result: {
-				text: "completed text",
-				usage: {
-					inputTokens: 1,
-					outputTokens: 1,
-					cacheReadTokens: 0,
-					cacheWriteTokens: 0,
-					totalCost: 0.25,
-				},
-				messages: [],
-				toolCalls: [],
-				iterations: 1,
-				finishReason: "completed",
-				model: {
-					id: "deepseek/deepseek-v4-flash",
-					provider: "cline",
-					info: {},
-				},
-				startedAt,
-				endedAt,
-				durationMs: 1000,
-			},
-		});
-		sessionManagerMocks.getAccumulatedUsage.mockResolvedValue({
-			usage: {
-				inputTokens: 1,
-				outputTokens: 1,
-				cacheReadTokens: 0,
-				cacheWriteTokens: 0,
-				totalCost: 0.25,
-			},
-			aggregateUsage: {
-				inputTokens: 1,
-				outputTokens: 1,
-				cacheReadTokens: 0,
-				cacheWriteTokens: 0,
-				totalCost: 0.25,
-			},
-		});
-
-		const { runAgent } = await import("./run-agent");
-		const { handleEvent } = await import("../utils/events");
-
-		await expect(
-			runAgent("test prompt", {
-				baseUrl: "https://cline.test/api/v1",
-				cwd: process.cwd(),
-				enableAgentTeams: false,
-				enableSpawnAgent: false,
-				enableTools: [],
-				execution: {
-					maxConsecutiveMistakes: 3,
-				},
-				logger: undefined,
-				mode: "yolo",
-				modelId: "deepseek/deepseek-v4-flash",
-				outputMode: "json",
-				providerId: "cline",
-				systemPrompt: "system",
-				thinking: false,
-				toolPolicies: { "*": { autoApprove: true } },
-				verbose: false,
-				workspaceRoot: process.cwd(),
-			} as never),
-		).resolves.toBeUndefined();
-
-		const runResult = outputMocks.emitJsonLine.mock.calls.find(
-			([, payload]) =>
-				(payload as { type?: string } | undefined)?.type === "run_result",
-		)?.[1] as
-			| {
-					usage?: { totalCost?: number };
-					aggregateUsage?: { totalCost?: number };
-			  }
-			| undefined;
-		expect(runResult?.usage?.totalCost).toBe(0);
-		expect(runResult?.aggregateUsage?.totalCost).toBe(0);
-
-		sessionEventsMocks.listener?.({
-			type: "usage",
-			inputTokens: 1,
-			outputTokens: 1,
-			cost: 0.25,
-			totalCost: 0.25,
-		});
-
-		expect(handleEvent).toHaveBeenLastCalledWith(
-			expect.objectContaining({
-				type: "usage",
-				cost: 0,
-				totalCost: 0,
-			}),
-			expect.any(Object),
-		);
-	});
 });

apps/cli/src/runtime/run-agent.ts

@@ -16,13 +16,7 @@ import {
 	requestToolApproval,
 	submitAndExitInTerminal,
 } from "../utils/approval";
-import { formatCliErrorMessage } from "../utils/cline-pass-errors";
 import { handleEvent, handleTeamEvent } from "../utils/events";
-import {
-	shouldZeroClineFreeModelCost,
-	zeroCliAgentEventCost,
-	zeroCliUsageCost,
-} from "../utils/free-model-cost";
 import { createRuntimeHooks } from "../utils/hooks";
 import {
 	c,
@@ -189,10 +183,8 @@ export async function runAgent(
 	let reasoningChunkCount = 0;
 	let redactedReasoningChunkCount = 0;
 	const displayedErrorMessages = new Set<string>();
-	const shouldZeroCost = await shouldZeroClineFreeModelCost(config);
 
-	const onAgentEvent = (rawEvent: AgentEvent): void => {
-		const event = zeroCliAgentEventCost(rawEvent, shouldZeroCost);
+	const onAgentEvent = (event: AgentEvent): void => {
 		if (event.type === "content_start" && event.contentType === "reasoning") {
 			reasoningChunkCount += 1;
 			if (event.redacted) {
@@ -346,14 +338,8 @@ export async function runAgent(
 		const usageSummary = await sessionManager.getAccumulatedUsage(
 			started.sessionId,
 		);
-		const aggregateUsage = zeroCliUsageCost(
-			usageSummary?.aggregateUsage,
-			shouldZeroCost,
-		);
-		const usage = zeroCliUsageCost(
-			aggregateUsage ?? usageSummary?.usage ?? result.usage,
-			shouldZeroCost,
-		);
+		const aggregateUsage = usageSummary?.aggregateUsage;
+		const usage = aggregateUsage ?? usageSummary?.usage ?? result.usage;
 
 		if (config.outputMode === "json") {
 			emitJsonLine("stdout", {
@@ -388,7 +374,7 @@ export async function runAgent(
 		}
 
 		if (result.finishReason !== "completed") {
-			const errorText = formatCliErrorMessage(result.text).trim();
+			const errorText = result.text.trim();
 			if (
 				errorText &&
 				(config.outputMode === "json" || !displayedErrorMessages.has(errorText))
@@ -409,7 +395,7 @@ export async function runAgent(
 		);
 		process.exitCode = 0;
 	} catch (err) {
-		const message = formatCliErrorMessage(err);
+		const message = err instanceof Error ? err.message : String(err);
 		logCliError(config.logger, "CLI task run failed", { error: err });
 		writeErr(message);
 		process.exitCode = 1;

apps/cli/src/runtime/run-interactive.ts

@@ -24,11 +24,6 @@ import { disableOpenTuiGraphicsProbe } from "../tui/opentui-env";
 import type { QueuedPromptItem } from "../tui/types";
 import { type ChatCommandState, chatCommandHost } from "../utils/chat-commands";
 import { applyCliCompactionMode } from "../utils/compaction-mode";
-import {
-	shouldZeroClineFreeModelCost,
-	zeroCliAgentEventCost,
-	zeroCliUsageCost,
-} from "../utils/free-model-cost";
 import {
 	prepareTerminalForPostTuiOutput,
 	writeErr,
@@ -126,7 +121,6 @@ export async function runInteractive(
 		autoApproveAllRef,
 		setInteractiveAutoApprove,
 		requestToolApproval,
-		resolveToolPolicy,
 		tuiToolApprover,
 		tuiAskQuestion,
 	} = createInteractiveApprovalController(config);
@@ -158,7 +152,6 @@ export async function runInteractive(
 		askQuestionRef: tuiAskQuestion,
 	});
 	const providerSettingsManager = new ProviderSettingsManager();
-	let zeroCurrentTurnCost = false;
 
 	const sessionRuntime = createInteractiveSessionRuntime({
 		config,
@@ -167,12 +160,11 @@ export async function runInteractive(
 		resumeSessionId,
 		chatCommandState,
 		requestToolApproval,
-		resolveToolPolicy,
 		askQuestionRef: tuiAskQuestion,
 		resolveMistakeLimitDecision,
 		switchToActModeTool,
 		onAgentEvent: (event) => {
-			uiEvents.emit("agent", zeroCliAgentEventCost(event, zeroCurrentTurnCost));
+			uiEvents.emit("agent", event);
 		},
 		onTeamEvent: (event) => {
 			uiEvents.emit("team", event);
@@ -438,7 +430,6 @@ export async function runInteractive(
 		},
 		onSubmit: async (input, mode, delivery, attachments, onCommandOutput) => {
 			let commandOutput: string | undefined;
-			let zeroTurnCost = false;
 			try {
 				await sessionRuntime.ensureReady();
 				await waitForSubmittedMode(mode);
@@ -485,8 +476,6 @@ export async function runInteractive(
 				}
 				input = chatCommandResult.input;
 				commandOutput = chatCommandResult.commandOutput;
-				zeroTurnCost = await shouldZeroClineFreeModelCost(config);
-				zeroCurrentTurnCost = zeroTurnCost;
 				const {
 					prompt: userInput,
 					userImages,
@@ -528,9 +517,8 @@ export async function runInteractive(
 				}
 				if (result.finishReason !== "completed") {
 					if (result.finishReason === "aborted" || isAbortInProgress()) {
-						const usage = zeroCliUsageCost(
-							await sessionRuntime.getAccumulatedUsage(result.usage),
-							zeroTurnCost,
+						const usage = await sessionRuntime.getAccumulatedUsage(
+							result.usage,
 						);
 						return {
 							usage,
@@ -545,10 +533,7 @@ export async function runInteractive(
 						errorText || `Turn finished with ${result.finishReason}`,
 					);
 				}
-				const usage = zeroCliUsageCost(
-					await sessionRuntime.getAccumulatedUsage(result.usage),
-					zeroTurnCost,
-				);
+				const usage = await sessionRuntime.getAccumulatedUsage(result.usage);
 				return {
 					usage,
 					currentContextSize: getCurrentContextSize(result.messages),
@@ -572,7 +557,6 @@ export async function runInteractive(
 				});
 				throw error;
 			} finally {
-				zeroCurrentTurnCost = false;
 				if (!delivery) {
 					isRunning = false;
 					clearAbortInProgress();

apps/cli/src/runtime/tool-policies.test.ts

@@ -2,7 +2,6 @@ import { describe, expect, it } from "vitest";
 import {
 	applyInteractiveAutoApproveOverride,
 	cloneToolPolicies,
-	resolveInteractiveAutoApprovePolicy,
 } from "./tool-policies";
 
 describe("tool policy helpers", () => {
@@ -54,9 +53,9 @@ describe("tool policy helpers", () => {
 		});
 	});
 
-	it("forces all baseline policies to auto-approve when toggled back on", () => {
+	it("restores the baseline policies when toggled back on", () => {
 		const baseline = {
-			"*": { autoApprove: false },
+			"*": { autoApprove: true },
 			run_commands: { autoApprove: true, enabled: true },
 			editor: { autoApprove: false, enabled: true },
 		};
@@ -73,40 +72,6 @@ describe("tool policy helpers", () => {
 			enabled: true,
 		});
 
-		expect(target).toEqual({
-			"*": { autoApprove: true },
-			run_commands: { autoApprove: true, enabled: true },
-			editor: { autoApprove: true, enabled: true },
-		});
-	});
-
-	it("resolves live per-tool policies from the interactive auto-approve state", () => {
-		const baseline = {
-			"*": { autoApprove: false },
-			read_files: { enabled: true },
-			editor: { autoApprove: false, enabled: true },
-		};
-
-		expect(
-			resolveInteractiveAutoApprovePolicy({
-				toolName: "editor",
-				baselinePolicies: baseline,
-				enabled: true,
-			}),
-		).toEqual({ autoApprove: true, enabled: true });
-		expect(
-			resolveInteractiveAutoApprovePolicy({
-				toolName: "run_commands",
-				baselinePolicies: baseline,
-				enabled: false,
-			}),
-		).toEqual({ autoApprove: false });
-		expect(
-			resolveInteractiveAutoApprovePolicy({
-				toolName: "read_files",
-				baselinePolicies: baseline,
-				enabled: false,
-			}),
-		).toEqual({ autoApprove: true, enabled: true });
+		expect(target).toEqual(baseline);
 	});
 });

apps/cli/src/runtime/tool-policies.ts

@@ -27,51 +27,21 @@ export function cloneToolPolicies(
 	);
 }
 
-export function resolveInteractiveAutoApprovePolicy(input: {
-	toolName: string;
-	baselinePolicies: Record<string, ToolPolicy>;
-	enabled: boolean;
-}): ToolPolicy {
-	const toolPolicy = input.baselinePolicies[input.toolName] ?? {};
-	const baselinePolicy = {
-		...(input.baselinePolicies["*"] ?? {}),
-		...toolPolicy,
-	};
-	return {
-		...baselinePolicy,
-		autoApprove: input.enabled
-			? true
-			: SAFE_AUTO_APPROVE_TOOLS.has(input.toolName)
-				? (toolPolicy.autoApprove ?? true)
-				: false,
-	};
-}
-
 export function applyInteractiveAutoApproveOverride(input: {
 	targetPolicies: Record<string, ToolPolicy>;
 	baselinePolicies: Record<string, ToolPolicy>;
 	enabled: boolean;
 }): void {
 	const nextPolicies: Record<string, ToolPolicy> = input.enabled
-		? Object.fromEntries(
-				Object.entries(input.baselinePolicies).map(([name, policy]) => [
-					name,
-					{
-						...policy,
-						autoApprove: true,
-					},
-				]),
-			)
+		? cloneToolPolicies(input.baselinePolicies)
 		: Object.fromEntries(
 				Object.entries(input.baselinePolicies).map(([name, policy]) => [
 					name,
 					{
 						...policy,
-						autoApprove: resolveInteractiveAutoApprovePolicy({
-							toolName: name,
-							baselinePolicies: input.baselinePolicies,
-							enabled: false,
-						}).autoApprove,
+						autoApprove: SAFE_AUTO_APPROVE_TOOLS.has(name)
+							? (policy.autoApprove ?? true)
+							: false,
 					},
 				]),
 			);
@@ -83,7 +53,9 @@ export function applyInteractiveAutoApproveOverride(input: {
 	}
 
 	const globalPolicy = clonePolicy(nextPolicies["*"]);
-	globalPolicy.autoApprove = input.enabled;
+	globalPolicy.autoApprove = input.enabled
+		? (input.baselinePolicies["*"]?.autoApprove ?? true)
+		: false;
 	nextPolicies["*"] = globalPolicy;
 
 	for (const key of Object.keys(input.targetPolicies)) {

apps/cli/src/tests/flags.test.ts

@@ -26,6 +26,7 @@ test.describe("root flag descriptions", () => {
 			"Set reasoning effort level",
 			"consecutive mistakes",
 			"Output messages as JSON",
+			"ACP",
 			"Check for updates and install if available",
 			"Run the kanban app",
 		]);

apps/cli/src/tui/cline-account.ts

@@ -210,7 +210,7 @@ async function onChangeToClinePass(config: ClineAccountConfig) {
 			organizationId: null,
 		});
 	} catch (error) {
-		config.logger?.debug("Failed to switch ClinePass to personal account", {
+		config.logger?.debug("Failed to switch Cline Pass to personal account", {
 			error,
 		});
 	}

apps/cli/src/tui/components/chat-entry.tsx

@@ -2,12 +2,6 @@ import { useTerminalDimensions } from "@opentui/react";
 import type React from "react";
 import { useState } from "react";
 import "opentui-spinner/react";
-import {
-	getClineOrgIndividualInferenceSubscriptionMessage,
-	getClinePassSubscriptionUrl,
-	isClineOrgIndividualInferenceSubscriptionErrorMessage,
-	isClinePassSubscriptionError,
-} from "../../utils/cline-pass-errors";
 import {
 	CLINE_CREDITS_DASHBOARD_URL,
 	isClineAccountCreditsErrorMessage,
@@ -296,65 +290,6 @@ function ClineCreditsErrorView(props: { defaultFg?: string }) {
 	);
 }
 
-function ClinePassSubscriptionErrorView(props: { defaultFg?: string }) {
-	const subscriptionUrl = getClinePassSubscriptionUrl();
-	return (
-		<box flexDirection="row">
-			<text fg="yellow" content="* " />
-			<box
-				flexDirection="column"
-				border
-				borderStyle="rounded"
-				borderColor="yellow"
-				paddingX={1}
-			>
-				<text fg="yellow">ClinePass subscription required</text>
-				<text
-					fg={props.defaultFg}
-					selectable
-					content="No access to ClinePass subscription models yet. Subscribe to ClinePass, the low cost open weights model coding plan."
-				/>
-				<box flexDirection="row">
-					<text fg="gray">Subscribe: </text>
-					<text fg="cyan" selectable>
-						<a href={subscriptionUrl}>Open subscription page</a>
-					</text>
-				</box>
-				<box flexDirection="row">
-					<text fg="gray">URL: </text>
-					<text fg="cyan" selectable>
-						<a href={subscriptionUrl}>{subscriptionUrl}</a>
-					</text>
-				</box>
-			</box>
-		</box>
-	);
-}
-
-function ClineOrgIndividualInferenceSubscriptionErrorView(props: {
-	defaultFg?: string;
-}) {
-	return (
-		<box flexDirection="row">
-			<text fg="yellow" content="* " />
-			<box
-				flexDirection="column"
-				border
-				borderStyle="rounded"
-				borderColor="yellow"
-				paddingX={1}
-			>
-				<text fg="yellow">Personal ClinePass required</text>
-				<text
-					fg={props.defaultFg}
-					selectable
-					content={getClineOrgIndividualInferenceSubscriptionMessage()}
-				/>
-			</box>
-		</box>
-	);
-}
-
 export function ChatEntryView(props: {
 	entry: ChatEntry;
 	accent?: string;
@@ -453,14 +388,6 @@ export function ChatEntryView(props: {
 			if (isClineAccountCreditsErrorMessage(entry.text)) {
 				return <ClineCreditsErrorView defaultFg={defaultFg} />;
 			}
-			if (isClineOrgIndividualInferenceSubscriptionErrorMessage(entry.text)) {
-				return (
-					<ClineOrgIndividualInferenceSubscriptionErrorView defaultFg={defaultFg} />
-				);
-			}
-			if (isClinePassSubscriptionError(entry.text)) {
-				return <ClinePassSubscriptionErrorView defaultFg={defaultFg} />;
-			}
 			return (
 				<box flexDirection="row">
 					<text fg="red" content="* " />

apps/cli/src/tui/components/dialogs/mcp-manager-dialog.test.ts

@@ -58,11 +58,7 @@ describe("mcp manager dialog helpers", () => {
 	};
 
 	afterEach(async () => {
-		if (envSnapshot.CLINE_MCP_SETTINGS_PATH === undefined) {
-			delete process.env.CLINE_MCP_SETTINGS_PATH;
-		} else {
-			process.env.CLINE_MCP_SETTINGS_PATH = envSnapshot.CLINE_MCP_SETTINGS_PATH;
-		}
+		process.env.CLINE_MCP_SETTINGS_PATH = envSnapshot.CLINE_MCP_SETTINGS_PATH;
 		await Promise.all(
 			tempRoots.map((directory) =>
 				rm(directory, { recursive: true, force: true }),
@@ -111,44 +107,6 @@ describe("mcp manager dialog helpers", () => {
 		).toBeUndefined();
 	});
 
-	it("does not toggle plugin-owned servers", async () => {
-		const tempRoot = await mkdtemp(join(tmpdir(), "cli-mcp-manager-"));
-		tempRoots.push(tempRoot);
-		const settingsPath = join(tempRoot, "cline_mcp_settings.json");
-		await writeFile(
-			settingsPath,
-			`${JSON.stringify(
-				{
-					mcpServers: {
-						docs: {
-							transport: {
-								type: "stdio",
-								command: "node",
-							},
-						},
-					},
-				},
-				null,
-				2,
-			)}\n`,
-		);
-
-		const result = toggleMcpServer({
-			name: "docs",
-			path: settingsPath,
-			enabled: true,
-			pluginName: "repo-docs",
-		});
-
-		expect(result.ok).toBe(false);
-		if (!result.ok) {
-			expect(result.message).toContain('managed by plugin "repo-docs"');
-		}
-		expect((await readSettings(settingsPath)).mcpServers?.docs?.disabled).toBe(
-			undefined,
-		);
-	});
-
 	it("returns a visible error message when toggling fails", async () => {
 		const tempRoot = await mkdtemp(join(tmpdir(), "cli-mcp-manager-"));
 		tempRoots.push(tempRoot);

apps/cli/src/tui/components/dialogs/mcp-manager-dialog.tsx

@@ -13,7 +13,6 @@ export interface McpEntry {
 	enabled?: boolean;
 	description?: string;
 	lastError?: string;
-	pluginName?: string;
 }
 
 export type McpServerToggleResult =
@@ -37,12 +36,6 @@ export function getMcpManagerEntryStatus(
 }
 
 export function toggleMcpServer(server: McpEntry): McpServerToggleResult {
-	if (server.pluginName) {
-		return {
-			ok: false,
-			message: `MCP server "${server.name}" is managed by plugin "${server.pluginName}". Disable the plugin to disable this server.`,
-		};
-	}
 	try {
 		const currentlyEnabled = server.enabled !== false;
 		setMcpServerDisabled({
@@ -78,7 +71,6 @@ export function McpManagerContent(
 	const settingsPath = servers[0]?.path ?? resolveDefaultMcpSettingsPath();
 	const itemCount = servers.length;
 	const selectedServer = servers[selected];
-	const hasPluginOwnedServers = servers.some((server) => server.pluginName);
 
 	useDialogKeyboard((key) => {
 		if (key.name === "escape") {
@@ -158,7 +150,6 @@ export function McpManagerContent(
 									{isSel ? "\u25b8 " : "  "}
 									{enabledIcon}
 									{srv.name}
-									{srv.pluginName ? " *" : ""}
 								</text>
 								{status && (
 									<text fg={srv.lastError ? palette.error : "gray"}>
@@ -193,12 +184,6 @@ export function McpManagerContent(
 				</box>
 			)}
 
-			{hasPluginOwnedServers && (
-				<text fg="gray" marginTop={1}>
-					* managed by plugin; disable the plugin to disable the server.
-				</text>
-			)}
-
 			<text fg="gray" marginTop={1}>
 				<em>{getMcpManagerFooterText(servers.length > 0)}</em>
 			</text>

apps/cli/src/tui/components/model-selector/model-selector.tsx

@@ -134,7 +134,6 @@ export function ModelSelectorContent(
 		currentModel: string;
 		currentProviderName: string;
 		models: ModelOption[];
-		showCustomModelId?: boolean;
 	},
 ) {
 	const {
@@ -144,7 +143,6 @@ export function ModelSelectorContent(
 		currentModel,
 		currentProviderName,
 		models,
-		showCustomModelId = true,
 	} = props;
 	const [search, setSearch] = useState("");
 	const [selected, setSelected] = useState(() => {
@@ -166,7 +164,7 @@ export function ModelSelectorContent(
 		return scored.map((r) => r.model);
 	}, [models, search]);
 
-	const optionCount = filtered.length + (showCustomModelId ? 1 : 0);
+	const optionCount = filtered.length + 1;
 	const safeSelected = Math.min(selected, Math.max(0, optionCount - 1));
 
 	useDialogKeyboard((key) => {
@@ -190,7 +188,7 @@ export function ModelSelectorContent(
 				resolve(model.key);
 				return;
 			}
-			if (showCustomModelId && safeSelected === filtered.length) {
+			if (safeSelected === filtered.length) {
 				setIsCreatingCustomModel(true);
 				setCustomModelId("");
 				setCustomModelError("");
@@ -292,7 +290,6 @@ export function ModelSelectorContent(
 				dimmed={onProvider}
 				currentModel={currentModel}
 				onSelect={resolve}
-				showCustomModelId={showCustomModelId}
 				onCreateCustomModel={() => {
 					setIsCreatingCustomModel(true);
 					setCustomModelId("");
@@ -411,7 +408,6 @@ function ModelList(props: {
 	dimmed?: boolean;
 	currentModel: string;
 	onSelect: (key: string) => void;
-	showCustomModelId: boolean;
 	onCreateCustomModel: () => void;
 }) {
 	const {
@@ -420,12 +416,11 @@ function ModelList(props: {
 		dimmed,
 		currentModel,
 		onSelect,
-		showCustomModelId,
 		onCreateCustomModel,
 	} = props;
 	const rows: ({ type: "model"; model: ModelOption } | { type: "custom" })[] = [
 		...items.map((model) => ({ type: "model" as const, model })),
-		...(showCustomModelId ? ([{ type: "custom" as const }] as const) : []),
+		{ type: "custom" as const },
 	];
 
 	if (rows.length <= MAX_VISIBLE) {

apps/cli/src/tui/components/status-bar.test.ts

@@ -57,7 +57,7 @@ describe("formatStatusBarUsageText", () => {
 				totalCost: 0.123,
 				showCost: true,
 			}),
-		).toBe("(12,345 tokens) $0.12");
+		).toBe("(12,345) $0.12");
 	});
 
 	it("omits cost when usage cost is hidden", () => {
@@ -67,6 +67,6 @@ describe("formatStatusBarUsageText", () => {
 				totalCost: 0.123,
 				showCost: false,
 			}),
-		).toBe("(12,345 tokens)");
+		).toBe("(12,345)");
 	});
 });

apps/cli/src/tui/components/status-bar.tsx

@@ -51,7 +51,7 @@ export function formatStatusBarUsageText(input: {
 	totalCost: number;
 	showCost: boolean;
 }): string {
-	const tokens = `(${input.totalTokens.toLocaleString()} tokens)`;
+	const tokens = `(${input.totalTokens.toLocaleString()})`;
 	if (!input.showCost) return tokens;
 	return `${tokens} ${formatCost(input.totalCost)}`;
 }

apps/cli/src/tui/contexts/session-context.tsx

@@ -106,9 +106,9 @@ export function SessionProvider(props: {
 	const [uiMode, setUiMode] = useState<AgentMode>(
 		config.mode === "plan" ? "plan" : "act",
 	);
-	const initialAutoApproveAll = config.toolPolicies["*"]?.autoApprove !== false;
-	const autoApproveAllRef = useRef(initialAutoApproveAll);
-	const [autoApproveAll, _setAutoApproveAll] = useState(initialAutoApproveAll);
+	const [autoApproveAll, _setAutoApproveAll] = useState(
+		config.toolPolicies["*"]?.autoApprove !== false,
+	);
 	const [compactionMode, _setCompactionMode] = useState<CliCompactionMode>(() =>
 		getCliCompactionMode(config),
 	);
@@ -192,10 +192,11 @@ export function SessionProvider(props: {
 	}, []);
 
 	const toggleAutoApprove = useCallback(() => {
-		const next = !autoApproveAllRef.current;
-		autoApproveAllRef.current = next;
-		onAutoApproveChange(next);
-		_setAutoApproveAll(next);
+		_setAutoApproveAll((prev) => {
+			const next = !prev;
+			onAutoApproveChange(next);
+			return next;
+		});
 	}, [onAutoApproveChange]);
 
 	const setCompactionMode = useCallback(

apps/cli/src/tui/hooks/use-agent-events.ts

@@ -4,7 +4,6 @@ import type {
 	PendingPromptSnapshot,
 	PendingPromptSubmittedEvent,
 } from "../../runtime/session-events";
-import { formatCliErrorMessage } from "../../utils/cline-pass-errors";
 import { resolveStatusNoticeLabel } from "../../utils/events";
 import {
 	formatToolInput,
@@ -172,10 +171,7 @@ export function useAgentEventHandlers(deps: AgentEventDeps) {
 					turnErrorReportedRef.current = true;
 					onTurnErrorReported(true);
 					if (!event.recoverable || verbose) {
-						appendEntry({
-							kind: "error",
-							text: formatCliErrorMessage(event.error),
-						});
+						appendEntry({ kind: "error", text: event.error.message });
 					}
 					break;
 				case "notice":

apps/cli/src/tui/hooks/use-mcp-manager.tsx

@@ -17,7 +17,6 @@ function toMcpEntries(items: InteractiveConfigItem[]): McpEntry[] {
 		enabled: item.enabled,
 		description: item.description,
 		lastError: item.loadError,
-		pluginName: item.pluginName,
 	}));
 }
 

apps/cli/src/tui/hooks/use-model-selector.tsx

@@ -323,7 +323,6 @@ export function useModelSelector(opts: {
 									currentModel={config.modelId}
 									currentProviderName={providerDisplayName}
 									models={modelOptions}
-									showCustomModelId={config.providerId !== "cline-pass"}
 								/>
 							),
 						});
@@ -414,7 +413,6 @@ export function useModelSelector(opts: {
 							currentModel={config.modelId}
 							currentProviderName={providerDisplayName}
 							models={modelOptions}
-							showCustomModelId={config.providerId !== "cline-pass"}
 						/>
 					),
 				});

apps/cli/src/tui/hooks/use-prompt-input-controller.ts

@@ -1,5 +1,4 @@
 import { useCallback, useLayoutEffect, useRef, useState } from "react";
-import { formatCliErrorMessage } from "../../utils/cline-pass-errors";
 import { shouldShowCliUsageCost } from "../../utils/usage-cost-display";
 import type { SlashCommandRegistry } from "../commands/slash-command-registry";
 import {
@@ -377,7 +376,7 @@ export function usePromptInputController(input: {
 				if (!turnErrorReportedRef.current) {
 					session.appendEntry({
 						kind: "error",
-						text: formatCliErrorMessage(error),
+						text: error instanceof Error ? error.message : String(error),
 					});
 				}
 			} finally {

apps/cli/src/tui/interactive-config.ts

@@ -86,7 +86,6 @@ export interface InteractiveConfigData {
 	mcp: InteractiveConfigItem[];
 	tools: InteractiveConfigItem[];
 	workflowSlashCommands: InteractiveSlashCommand[];
-	pluginDiagnosticsLoaded?: boolean;
 }
 
 export interface LoadInteractiveConfigDataOptions {
@@ -94,14 +93,12 @@ export interface LoadInteractiveConfigDataOptions {
 }
 
 export function isToggleableInteractiveConfigItem(
-	item: Pick<InteractiveConfigItem, "kind" | "source" | "pluginName">,
+	item: Pick<InteractiveConfigItem, "kind" | "source">,
 ): boolean {
-	if (item.kind === "mcp") {
-		return !item.pluginName;
-	}
 	return (
 		item.kind === "skill" ||
 		item.kind === "plugin" ||
+		item.kind === "mcp" ||
 		item.source === "builtin" ||
 		item.source === "workspace-plugin" ||
 		item.source === "global-plugin"
@@ -245,10 +242,9 @@ function readPackageName(packageJsonPath: string): string | undefined {
 	}
 }
 
-function getPluginDisplayName(filePath: string, searchRoot: string): string {
+function getPluginDisplayName(filePath: string): string {
 	let current = dirname(filePath);
-	const root = resolve(searchRoot);
-	while (isPathWithin(root, current)) {
+	for (let depth = 0; depth < 4; depth++) {
 		const packageJsonPath = join(current, "package.json");
 		if (existsSync(packageJsonPath)) {
 			const packageName = readPackageName(packageJsonPath);
@@ -388,7 +384,7 @@ export async function loadInteractiveConfigData(input: {
 			for (const filePath of discoverPluginModulePaths(directory)) {
 				plugins.push({
 					id: filePath,
-					name: getPluginDisplayName(filePath, directory),
+					name: getPluginDisplayName(filePath),
 					path: filePath,
 					enabled: !disabledPlugins.has(filePath),
 					kind: "plugin",
@@ -462,16 +458,6 @@ export async function loadInteractiveConfigData(input: {
 			for (const registration of resolveMcpServerRegistrations({
 				filePath: mcpSettingsPath,
 			})) {
-				const pluginName =
-					registration.metadata?.source === "plugin" &&
-					typeof registration.metadata.pluginName === "string"
-						? registration.metadata.pluginName
-						: undefined;
-				const pluginPath =
-					registration.metadata?.source === "plugin" &&
-					typeof registration.metadata.pluginPath === "string"
-						? registration.metadata.pluginPath
-						: undefined;
 				mcp.push({
 					id: registration.name,
 					name: registration.name,
@@ -481,8 +467,6 @@ export async function loadInteractiveConfigData(input: {
 					source: detectSource(mcpSettingsPath, input.workspaceRoot),
 					description: getMcpDescription(registration),
 					loadError: registration.oauth?.lastError,
-					pluginName,
-					pluginPath,
 				});
 			}
 		} catch {
@@ -530,7 +514,6 @@ export async function loadInteractiveConfigData(input: {
 					toolNames: [pluginTool.name],
 					configKind: "tool",
 					pluginName: pluginTool.pluginName,
-					pluginPath: pluginTool.path,
 					source: pluginTool.source,
 					description: pluginTool.description,
 				});
@@ -550,6 +533,5 @@ export async function loadInteractiveConfigData(input: {
 		mcp: toSorted(mcp.filter((item) => existsSync(item.path))),
 		tools: toSorted(tools),
 		workflowSlashCommands,
-		pluginDiagnosticsLoaded: input.includePluginTools !== false,
 	};
 }

apps/cli/src/tui/views/config-view-helpers.ts

@@ -229,15 +229,3 @@ export function getConfigFooterText({
 export function getConfigItemDisplayName(name: string): string {
 	return name;
 }
-
-export function getPluginDiagnosticsLoadingText(
-	tab: InteractiveConfigTab,
-): string | undefined {
-	if (tab === "tools") {
-		return "Loading plugin tools...";
-	}
-	if (tab === "plugins") {
-		return "Loading plugin diagnostics...";
-	}
-	return undefined;
-}

apps/cli/src/tui/views/config-view.test.ts

@@ -59,18 +59,6 @@ describe("config view helpers", () => {
 		expect(isToggleableConfigItem(createItem({ kind: "mcp" }))).toBe(true);
 	});
 
-	it("does not treat plugin MCP rows as toggleable", () => {
-		expect(
-			isToggleableConfigItem(
-				createItem({
-					kind: "mcp",
-					pluginName: "plugin",
-					source: "workspace-plugin",
-				}),
-			),
-		).toBe(false);
-	});
-
 	it("resolves Enter/Tab on a skill row to details", () => {
 		const skill = createItem({
 			kind: "skill",

apps/cli/src/tui/views/config-view.tsx

@@ -25,7 +25,6 @@ import {
 	getConfigFooterText,
 	getConfigItemDisplayName,
 	getConfigTabs,
-	getPluginDiagnosticsLoadingText,
 	isInlineConfigAction,
 	isToggleableConfigItem,
 	resolveActiveConfigItems,
@@ -199,7 +198,6 @@ function appendToolGroupRows(
 			rightLabel: `${enabledCount}/${groupItems.length} tools enabled`,
 			indent: 2,
 		});
-
 		for (const item of sortBySourceThenName(groupItems)) {
 			rows.push({
 				kind: "ext",
@@ -247,24 +245,17 @@ function appendToolRows(
 		appendExtRows(rows, builtinTools);
 	}
 
-	const pluginToolItems = items.filter((item) => item.pluginName);
-	const pluginGroups = groupToolItems(pluginToolItems);
+	const pluginGroups = groupToolItems(items.filter((item) => item.pluginName));
 	if (pluginGroups.length > 0) {
 		rows.push({ kind: "head", label: "Plugins" });
 		appendToolGroupRows(
 			rows,
 			pluginGroups,
-			getSharedToolNames(pluginToolItems),
+			getSharedToolNames(items.filter((item) => item.pluginName)),
 		);
 	}
 }
 
-function hasPluginDiagnostics(data: InteractiveConfigData): boolean {
-	return (
-		data.pluginDiagnosticsLoaded || data.tools.some((item) => item.pluginName)
-	);
-}
-
 function appendSkillRows(
 	rows: ConfigRow[],
 	items: InteractiveConfigItem[],
@@ -314,18 +305,11 @@ function withOptimisticToggle(
 		).filter(Boolean),
 	);
 	const updateItems = (items: InteractiveConfigItem[]) =>
-		items.map((candidate) => {
-			if (matchesItem(candidate)) {
-				return { ...candidate, enabled: nextEnabled };
-			}
-			if (
-				item.kind === "plugin" &&
-				(candidate.path === item.path || candidate.pluginPath === item.path)
-			) {
-				return { ...candidate, enabled: nextEnabled };
-			}
-			return candidate;
-		});
+		items.map((candidate) =>
+			matchesItem(candidate)
+				? { ...candidate, enabled: nextEnabled }
+				: candidate,
+		);
 	const updateTools = (items: InteractiveConfigItem[]) =>
 		items.map((candidate) => {
 			if (matchesItem(candidate)) {
@@ -397,7 +381,7 @@ export function ConfigPanelContent(props: ConfigPanelProps) {
 	);
 	const [configData, setConfigData] = useState(props.configData);
 	const [pluginToolsLoaded, setPluginToolsLoaded] = useState(
-		hasPluginDiagnostics(props.configData),
+		props.configData.tools.some((item) => item.pluginName),
 	);
 	const [pluginToolsLoading, setPluginToolsLoading] = useState(false);
 	const [pluginToolsError, setPluginToolsError] = useState<
@@ -481,11 +465,10 @@ export function ConfigPanelContent(props: ConfigPanelProps) {
 				});
 			} else if (activeTab === "tools") {
 				appendToolRows(r, activeItems);
-				const loadingText = getPluginDiagnosticsLoadingText(activeTab);
-				if (pluginToolsLoading && loadingText) {
+				if (pluginToolsLoading) {
 					r.push({
 						kind: "detail",
-						text: loadingText,
+						text: "Loading plugin tools...",
 					});
 				}
 				if (pluginToolsError) {
@@ -516,10 +499,9 @@ export function ConfigPanelContent(props: ConfigPanelProps) {
 					});
 				}
 				if (activeTab === "plugins" && pluginToolsLoading) {
-					const loadingText = getPluginDiagnosticsLoadingText(activeTab);
 					r.push({
 						kind: "detail",
-						text: loadingText ?? "Loading plugin diagnostics...",
+						text: "Loading plugin diagnostics...",
 					});
 				}
 				if (activeTab === "plugins" && pluginToolsError) {
@@ -567,13 +549,15 @@ export function ConfigPanelContent(props: ConfigPanelProps) {
 			});
 			if (nextData) {
 				setConfigData(nextData);
-				setPluginToolsLoaded(hasPluginDiagnostics(nextData));
+				setPluginToolsLoaded(nextData.tools.some((tool) => tool.pluginName));
 			} else if (item.kind === "plugin" && loadConfigData) {
 				const refreshedData = await loadConfigData({
 					includePluginTools: true,
 				});
 				setConfigData(refreshedData);
-				setPluginToolsLoaded(hasPluginDiagnostics(refreshedData));
+				setPluginToolsLoaded(
+					refreshedData.tools.some((tool) => tool.pluginName),
+				);
 				setPluginToolsError(undefined);
 			}
 		} catch (error) {

apps/cli/src/tui/views/onboarding/auth.test.ts

@@ -5,7 +5,6 @@ const hoisted = vi.hoisted(() => ({
 	startClineDeviceAuth: vi.fn(),
 	completeClineDeviceAuth: vi.fn(),
 	saveLocalProviderOAuthCredentials: vi.fn(),
-	identifyFeatureFlagsAccount: vi.fn(async () => {}),
 	openMock: vi.fn(() => Promise.resolve()),
 }));
 
@@ -23,10 +22,6 @@ vi.mock("@cline/shared", () => ({
 
 vi.mock("open", () => ({ default: hoisted.openMock }));
 
-vi.mock("../../../utils/feature-flags", () => ({
-	identifyFeatureFlagsAccount: hoisted.identifyFeatureFlagsAccount,
-}));
-
 import { runDeviceCodeAuthFlow, runOAuthAuthFlow } from "./auth";
 
 // Minimal stand-in for a telemetry service. The auth helpers must forward this
@@ -50,8 +45,6 @@ describe("onboarding auth telemetry forwarding", () => {
 		hoisted.startClineDeviceAuth.mockReset();
 		hoisted.completeClineDeviceAuth.mockReset();
 		hoisted.saveLocalProviderOAuthCredentials.mockReset();
-		hoisted.identifyFeatureFlagsAccount.mockReset();
-		hoisted.identifyFeatureFlagsAccount.mockResolvedValue(undefined);
 		hoisted.openMock.mockReset();
 		hoisted.openMock.mockResolvedValue(undefined);
 	});
@@ -92,7 +85,6 @@ describe("onboarding auth telemetry forwarding", () => {
 		// Identity, not deep-equal — we are validating the exact reference flows
 		// through so opt-out / common metadata stays consistent.
 		expect(telemetryArg).toBe(fakeTelemetry);
-		expect(hoisted.identifyFeatureFlagsAccount).not.toHaveBeenCalled();
 	});
 
 	it("does not pass telemetry when none is provided (back-compat)", () => {
@@ -129,8 +121,6 @@ describe("onboarding auth telemetry forwarding", () => {
 			access: "a",
 			refresh: "r",
 			expires: 0,
-			accountId: "acct-1",
-			email: "user@example.com",
 		});
 
 		runDeviceCodeAuthFlow({
@@ -156,10 +146,6 @@ describe("onboarding auth telemetry forwarding", () => {
 		// emitted by completeClineDeviceAuth, so passing telemetry to the start
 		// helper would double-emit the event.
 		expect(hoisted.startClineDeviceAuth).toHaveBeenCalledWith();
-		expect(hoisted.identifyFeatureFlagsAccount).toHaveBeenCalledWith({
-			id: "acct-1",
-			email: "user@example.com",
-		});
 		expect(hoisted.openMock).toHaveBeenCalledWith(
 			"https://verify?user_code=uc",
 			{ wait: false },

apps/cli/src/tui/views/onboarding/auth.ts

@@ -9,7 +9,6 @@ import {
 } from "@cline/core";
 import { getClineEnvironmentConfig } from "@cline/shared";
 import open from "open";
-import { identifyFeatureFlagsAccount } from "../../../utils/feature-flags";
 
 export type OnboardingOAuthProviderId = string;
 
@@ -19,10 +18,6 @@ export function isOnboardingOAuthProviderId(
 	return isOAuthProvider(providerId);
 }
 
-function isClineAccountOAuthProvider(providerId: string): boolean {
-	return providerId === "cline" || providerId === "cline-pass";
-}
-
 export function runOAuthAuthFlow(input: {
 	providerId: OnboardingOAuthProviderId;
 	providerSettingsManager: ProviderSettingsManager;
@@ -61,12 +56,6 @@ export function runOAuthAuthFlow(input: {
 				existing,
 				credentials,
 			);
-			if (isClineAccountOAuthProvider(input.providerId)) {
-				void identifyFeatureFlagsAccount({
-					id: credentials.accountId,
-					email: credentials.email,
-				}).catch(() => {});
-			}
 			input.onComplete(input.providerId);
 		})
 		.catch((err: unknown) => {
@@ -129,12 +118,6 @@ export function runDeviceCodeAuthFlow(input: {
 						existing,
 						credentials,
 					);
-					if (isClineAccountOAuthProvider(input.providerId)) {
-						void identifyFeatureFlagsAccount({
-							id: credentials.accountId,
-							email: credentials.email,
-						}).catch(() => {});
-					}
 					input.onComplete(input.providerId);
 				})
 				.catch((err: unknown) => {

apps/cli/src/tui/views/onboarding/controller.ts

@@ -9,14 +9,12 @@ import {
 	resolveProviderConfig,
 	saveLocalProviderSettings,
 } from "@cline/core";
-import { isClineProvider } from "@cline/shared";
 import { useCallback, useEffect, useMemo, useRef, useState } from "react";
 import {
 	type CodexCliStatus,
 	checkCodexCliInstalled,
 	isOpenAICodexCliProvider,
 } from "../../../utils/codex-cli";
-import { getCliFeatureFlagsService } from "../../../utils/feature-flags";
 import { getPersistedProviderApiKey } from "../../../utils/provider-auth";
 import { listLocalProviders } from "../../../utils/provider-catalog";
 import { getCliTelemetryService } from "../../../utils/telemetry";
@@ -48,13 +46,11 @@ import {
 import { FIELD_ORDER } from "./fields";
 import { useOnboardingKeyboard } from "./keyboard";
 import {
-	getMainMenuOptions,
 	type ModelEntry,
 	type OnboardingResult,
 	type OnboardingStep,
 	type ProviderEntry,
 	type ReasoningEffort,
-	shouldUseFeaturedClineModelPicker,
 	type ThinkingLevel,
 	toModelEntriesFromKnownModels,
 	toModelEntry,
@@ -75,14 +71,6 @@ export function useOnboardingController(props: OnboardingControllerProps) {
 		() => props.providerSettingsManager ?? new ProviderSettingsManager(),
 		[props.providerSettingsManager],
 	);
-	const menuOptions = useMemo(
-		() =>
-			getMainMenuOptions({
-				isClinePassEnabled:
-					getCliFeatureFlagsService().getBooleanFlagEnabled("ext-cline-pass"),
-			}),
-		[],
-	);
 	const [step, setStep] = useState<OnboardingStep>("menu");
 	const [menuSelected, setMenuSelected] = useState(0);
 	const [oauthProvider, setOauthProvider] = useState("");
@@ -165,9 +153,6 @@ export function useOnboardingController(props: OnboardingControllerProps) {
 
 	const createCustomModelItem = useCallback(
 		(_search: string, filteredItems: SearchableItem[]) => {
-			if (activeProviderId === "cline-pass") {
-				return undefined;
-			}
 			if (filteredItems.some((item) => item.key === CUSTOM_MODEL_ID_ACTION)) {
 				return undefined;
 			}
@@ -178,7 +163,7 @@ export function useOnboardingController(props: OnboardingControllerProps) {
 				searchText: "create custom model id manual entry",
 			} satisfies SearchableItem;
 		},
-		[activeProviderId],
+		[],
 	);
 
 	const modelList = useSearchableList(modelItems, createCustomModelItem);
@@ -271,7 +256,7 @@ export function useOnboardingController(props: OnboardingControllerProps) {
 			const provider = providers.find((p) => p.id === providerId);
 			setActiveProviderName(provider?.name ?? providerId);
 			setModelsDefaultId(provider?.defaultModelId ?? "");
-			if (shouldUseFeaturedClineModelPicker(providerId)) {
+			if (providerId === "cline") {
 				setClineModelSelected(0);
 				setStep("cline_model");
 			} else if (providerId === "openai-compatible") {
@@ -322,7 +307,7 @@ export function useOnboardingController(props: OnboardingControllerProps) {
 
 	const startOAuthFlow = useCallback(
 		(providerId: OnboardingOAuthProviderId) => {
-			if (isClineProvider(providerId)) {
+			if (providerId === "cline") {
 				startDeviceCodeFlow(providerId);
 				return;
 			}
@@ -626,7 +611,6 @@ export function useOnboardingController(props: OnboardingControllerProps) {
 		onExit: props.onExit,
 		oauthProvider,
 		activeProviderId,
-		menuOptions,
 		menuSelected,
 		providerList,
 		modelList,
@@ -701,7 +685,6 @@ export function useOnboardingController(props: OnboardingControllerProps) {
 		},
 		handleModelItemSelect: selectModelItem,
 		menuSelected,
-		menuOptions,
 		modelItems,
 		modelList,
 		modelsLoading,

apps/cli/src/tui/views/onboarding/keyboard.ts

@@ -3,13 +3,10 @@ import { useKeyboard } from "@opentui/react";
 import type { Dispatch, SetStateAction } from "react";
 import type { ClineModelPickerEntry } from "../../components/model-selector/cline-model-picker";
 import type { SearchableListState } from "../../components/searchable-list";
-import {
-	isOnboardingOAuthProviderId,
-	type OnboardingOAuthProviderId,
-} from "./auth";
+import type { OnboardingOAuthProviderId } from "./auth";
 import { FIELD_ORDER } from "./fields";
 import {
-	type MenuOption,
+	MAIN_MENU,
 	type OnboardingStep,
 	THINKING_LEVELS,
 	type ThinkingLevel,
@@ -20,7 +17,6 @@ export function useOnboardingKeyboard(input: {
 	onExit: () => void;
 	oauthProvider: string;
 	activeProviderId: string;
-	menuOptions: MenuOption[];
 	menuSelected: number;
 	providerList: SearchableListState;
 	modelList: SearchableListState;
@@ -137,21 +133,17 @@ export function useOnboardingKeyboard(input: {
 
 		if (input.step === "menu") {
 			if (key.name === "up") {
-				input.setMenuSelected((s) =>
-					s <= 0 ? input.menuOptions.length - 1 : s - 1,
-				);
+				input.setMenuSelected((s) => (s <= 0 ? MAIN_MENU.length - 1 : s - 1));
 				return;
 			}
 			if (key.name === "down") {
-				input.setMenuSelected((s) =>
-					s >= input.menuOptions.length - 1 ? 0 : s + 1,
-				);
+				input.setMenuSelected((s) => (s >= MAIN_MENU.length - 1 ? 0 : s + 1));
 				return;
 			}
 			if (key.name === "return") {
-				const option = input.menuOptions[input.menuSelected];
+				const option = MAIN_MENU[input.menuSelected];
 				if (!option) return;
-				if (isOnboardingOAuthProviderId(option.value)) {
+				if (option.value === "cline" || option.value === "openai-codex") {
 					input.startOAuthFlow(option.value);
 				} else {
 					input.setStep("byo_provider");

apps/cli/src/tui/views/onboarding/model.test.ts

@@ -1,30 +1,12 @@
 import { describe, expect, it } from "vitest";
 import {
-	getMainMenuOptions,
 	getOAuthProviderLabel,
-	shouldUseFeaturedClineModelPicker,
 	toModelEntriesFromKnownModels,
 	toModelEntry,
 	toProviderEntry,
 } from "./model";
 
 describe("onboarding model helpers", () => {
-	it("hides ClinePass from the main menu unless its feature flag is enabled", () => {
-		expect(
-			getMainMenuOptions().some((option) => option.value === "cline-pass"),
-		).toBe(false);
-		expect(
-			getMainMenuOptions({ isClinePassEnabled: false }).some(
-				(option) => option.value === "cline-pass",
-			),
-		).toBe(false);
-		expect(
-			getMainMenuOptions({ isClinePassEnabled: true }).some(
-				(option) => option.value === "cline-pass",
-			),
-		).toBe(true);
-	});
-
 	it("maps provider catalog entries into onboarding provider entries", () => {
 		expect(
 			toProviderEntry({
@@ -130,14 +112,7 @@ describe("onboarding model helpers", () => {
 
 	it("formats OAuth provider labels for onboarding status views", () => {
 		expect(getOAuthProviderLabel("cline")).toBe("Cline");
-		expect(getOAuthProviderLabel("cline-pass")).toBe("ClinePass");
 		expect(getOAuthProviderLabel("openai-codex")).toBe("ChatGPT");
 		expect(getOAuthProviderLabel("oca")).toBe("oca");
 	});
-
-	it("uses the featured Cline model picker only for the Cline provider", () => {
-		expect(shouldUseFeaturedClineModelPicker("cline")).toBe(true);
-		expect(shouldUseFeaturedClineModelPicker("cline-pass")).toBe(false);
-		expect(shouldUseFeaturedClineModelPicker("anthropic")).toBe(false);
-	});
 });

apps/cli/src/tui/views/onboarding/model.ts

@@ -43,12 +43,6 @@ export const MAIN_MENU: MenuOption[] = [
 		detail: "Latest models with regular free promos",
 		icon: "\u263a",
 	},
-	{
-		label: "Sign in with ClinePass",
-		value: "cline-pass",
-		detail: "Low cost subscription for everyone",
-		icon: "\u2726",
-	},
 	{
 		label: "Sign in with ChatGPT",
 		value: "openai-codex",
@@ -63,14 +57,6 @@ export const MAIN_MENU: MenuOption[] = [
 	},
 ];
 
-export function getMainMenuOptions(options?: {
-	isClinePassEnabled?: boolean;
-}): MenuOption[] {
-	return MAIN_MENU.filter(
-		(option) => option.value !== "cline-pass" || options?.isClinePassEnabled,
-	);
-}
-
 export interface OnboardingResult {
 	providerId: string;
 	modelId: string;
@@ -153,9 +139,6 @@ export function toModelEntriesFromKnownModels(
 }
 
 export function getOAuthProviderLabel(providerId: string): string {
-	if (providerId === "cline-pass") {
-		return "ClinePass";
-	}
 	if (providerId === "cline") {
 		return "Cline";
 	}
@@ -164,7 +147,3 @@ export function getOAuthProviderLabel(providerId: string): string {
 	}
 	return providerId;
 }
-
-export function shouldUseFeaturedClineModelPicker(providerId: string): boolean {
-	return providerId === "cline";
-}

apps/cli/src/tui/views/onboarding/screens.tsx

@@ -20,7 +20,7 @@ import {
 import { useTerminalBackground } from "../../hooks/use-terminal-background";
 import { getDefaultForeground, palette } from "../../palette";
 import { FIELD_ORDER } from "./fields";
-import { type MenuOption, THINKING_LEVELS } from "./model";
+import { MAIN_MENU, THINKING_LEVELS } from "./model";
 
 type MouseTrackerState = ReturnType<typeof useMouseTracker>;
 
@@ -633,7 +633,6 @@ export function OnboardingThinkingLevelScreen(props: {
 
 export function OnboardingMainMenuScreen(props: {
 	contentWidth: number;
-	menuOptions: MenuOption[];
 	menuSelected: number;
 	mouse: MouseTrackerState;
 }) {
@@ -672,7 +671,7 @@ export function OnboardingMainMenuScreen(props: {
 				marginTop={1}
 				gap={0}
 			>
-				{props.menuOptions.map((option, i) => {
+				{MAIN_MENU.map((option, i) => {
 					const isSel = i === props.menuSelected;
 					return (
 						<box

apps/cli/src/tui/views/onboarding/view.tsx

@@ -166,7 +166,6 @@ export function OnboardingView(props: OnboardingViewProps) {
 	return (
 		<OnboardingMainMenuScreen
 			contentWidth={contentWidth}
-			menuOptions={state.menuOptions}
 			menuSelected={state.menuSelected}
 			mouse={mouse}
 		/>

apps/cli/src/utils/cline-pass-errors.test.ts

@@ -1,44 +0,0 @@
-import { describe, expect, it } from "vitest";
-import {
-	formatCliErrorMessage,
-	getClineOrgIndividualInferenceSubscriptionMessage,
-	getClinePassSubscriptionUrl,
-	isClineOrgIndividualInferenceSubscriptionErrorMessage,
-	isClinePassSubscriptionError,
-} from "./cline-pass-errors";
-
-describe("cline-pass-errors", () => {
-	it("recognizes both raw and formatted ClinePass subscription messages", () => {
-		expect(
-			isClinePassSubscriptionError(
-				"the user is not subscribed to required model plan",
-			),
-		).toBe(true);
-
-		const formatted = `No access to ClinePass subscription models yet. Subscribe to ClinePass, the low cost open weights model coding plan: ${getClinePassSubscriptionUrl()}`;
-		expect(isClinePassSubscriptionError(formatted)).toBe(true);
-		expect(formatCliErrorMessage(new Error(formatted))).toBe(formatted);
-	});
-
-	it("formats the ClinePass subscription URL", () => {
-		expect(getClinePassSubscriptionUrl()).toBe(
-			"https://app.cline.bot/dashboard/subscription?personal=true",
-		);
-	});
-
-	it("recognizes and formats organization account individual subscription errors", () => {
-		const raw =
-			"403 Error 403: organization accounts cannot use individual model inference subscriptions";
-		const formatted = getClineOrgIndividualInferenceSubscriptionMessage();
-
-		expect(isClineOrgIndividualInferenceSubscriptionErrorMessage(raw)).toBe(
-			true,
-		);
-		expect(
-			isClineOrgIndividualInferenceSubscriptionErrorMessage(
-				new Error(formatted),
-			),
-		).toBe(true);
-		expect(formatCliErrorMessage(new Error(raw))).toBe(formatted);
-	});
-});

apps/cli/src/utils/cline-pass-errors.ts

@@ -1,69 +0,0 @@
-import {
-	getClineOrgIndividualInferenceSubscriptionMessage,
-	getClinePassSubscriptionUrl,
-	isClineNotSubscribedError,
-	isClineNotSubscribedMessage,
-	isClineOrgIndividualInferenceSubscriptionError,
-	isClineOrgIndividualInferenceSubscriptionMessage,
-} from "@cline/core";
-
-export {
-	getClineOrgIndividualInferenceSubscriptionMessage,
-	getClinePassSubscriptionUrl,
-};
-
-function isFormattedClinePassSubscriptionMessage(message: string): boolean {
-	const normalized = message.trim().toLowerCase();
-	return (
-		normalized.includes("no access to clinepass subscription models yet") &&
-		normalized.includes("subscribe to clinepass")
-	);
-}
-
-export function isClinePassSubscriptionError(error: unknown): boolean {
-	if (isClineNotSubscribedError(error)) {
-		return true;
-	}
-	if (error instanceof Error) {
-		return (
-			error.name === "ClineNotSubscribedError" ||
-			isClineNotSubscribedMessage(error.message) ||
-			isFormattedClinePassSubscriptionMessage(error.message)
-		);
-	}
-	return (
-		typeof error === "string" &&
-		(isClineNotSubscribedMessage(error) ||
-			isFormattedClinePassSubscriptionMessage(error))
-	);
-}
-
-export function isClineOrgIndividualInferenceSubscriptionErrorMessage(
-	error: unknown,
-): boolean {
-	if (isClineOrgIndividualInferenceSubscriptionError(error)) {
-		return true;
-	}
-	if (error instanceof Error) {
-		return (
-			error.name === "ClineOrgIndividualInferenceSubscriptionError" ||
-			isClineOrgIndividualInferenceSubscriptionMessage(error.message) ||
-			error.message === getClineOrgIndividualInferenceSubscriptionMessage()
-		);
-	}
-	return (
-		typeof error === "string" &&
-		(isClineOrgIndividualInferenceSubscriptionMessage(error) ||
-			error === getClineOrgIndividualInferenceSubscriptionMessage())
-	);
-}
-
-export function formatCliErrorMessage(error: unknown): string {
-	if (isClineOrgIndividualInferenceSubscriptionErrorMessage(error)) {
-		return getClineOrgIndividualInferenceSubscriptionMessage();
-	}
-	if (error instanceof Error) {
-		return error.message;
-	}
-	return String(error);
-}

apps/cli/src/utils/feature-flags.ts

@@ -87,29 +87,22 @@ export async function disposeCliFeatureFlagsService(): Promise<void> {
 	await current.dispose();
 }
 
-export function setCliFeatureFlagsAccountContext(account: {
-	id?: string;
-	email?: string;
-}): void {
+export async function identifyFeatureFlagsAccount(
+	account: { id?: string; email?: string },
+	logger?: BasicLogger,
+): Promise<void> {
 	const accountId = account.id?.trim();
 	cliFeatureFlagsContext = {
 		...cliFeatureFlagsContext,
 		...(accountId ? { distinctId: accountId, userId: accountId } : {}),
 		...(account.email?.trim() ? { email: account.email.trim() } : {}),
 	};
-	cliFeatureFlagsService?.setContext(getCliFeatureFlagsContext());
-}
-
-export async function identifyFeatureFlagsAccount(
-	account: { id?: string; email?: string },
-	logger?: BasicLogger,
-): Promise<void> {
-	setCliFeatureFlagsAccountContext(account);
 
 	if (!cliFeatureFlagsService) {
 		return;
 	}
 
+	cliFeatureFlagsService.setContext(getCliFeatureFlagsContext());
 	try {
 		await cliFeatureFlagsService.poll();
 	} catch (error) {

apps/cli/src/utils/free-model-cost.test.ts

@@ -1,162 +0,0 @@
-import type { AgentEvent } from "@cline/core";
-import { afterEach, describe, expect, it, vi } from "vitest";
-import {
-	clearClineFreeModelCostCache,
-	shouldZeroClineFreeModelCost,
-	zeroCliAgentEventCost,
-	zeroCliUsageCost,
-} from "./free-model-cost";
-
-afterEach(() => {
-	clearClineFreeModelCostCache();
-	vi.unstubAllGlobals();
-});
-
-describe("shouldZeroClineFreeModelCost", () => {
-	it("uses the Cline free model list", async () => {
-		const fetchMock = vi.fn(
-			async (_input: Parameters<typeof fetch>[0], _init?: RequestInit) => {
-				return new Response(
-					JSON.stringify({
-						free: [{ id: "deepseek/deepseek-v4-flash" }],
-					}),
-					{ status: 200, headers: { "content-type": "application/json" } },
-				);
-			},
-		);
-		vi.stubGlobal("fetch", fetchMock);
-
-		await expect(
-			shouldZeroClineFreeModelCost({
-				providerId: "cline",
-				modelId: "deepseek/deepseek-v4-flash",
-				baseUrl: "https://cline.test/api/v1",
-			}),
-		).resolves.toBe(true);
-
-		expect(fetchMock.mock.calls[0]?.[0]).toBe(
-			"https://cline.test/api/v1/ai/cline/recommended-models",
-		);
-	});
-
-	it("does not zero non-Cline providers", async () => {
-		const fetchMock = vi.fn();
-		vi.stubGlobal("fetch", fetchMock);
-
-		await expect(
-			shouldZeroClineFreeModelCost({
-				providerId: "openrouter",
-				modelId: "deepseek/deepseek-v4-flash",
-				baseUrl: "https://cline.test/api/v1",
-			}),
-		).resolves.toBe(false);
-		expect(fetchMock).not.toHaveBeenCalled();
-	});
-
-	it("does not match a paid model by only the final path segment", async () => {
-		vi.stubGlobal(
-			"fetch",
-			vi.fn(async () => {
-				return new Response(
-					JSON.stringify({
-						free: [{ id: "deepseek/deepseek-v4-flash" }],
-					}),
-					{ status: 200, headers: { "content-type": "application/json" } },
-				);
-			}),
-		);
-
-		await expect(
-			shouldZeroClineFreeModelCost({
-				providerId: "cline",
-				modelId: "acme/deepseek-v4-flash",
-				baseUrl: "https://cline.test/api/v1",
-			}),
-		).resolves.toBe(false);
-	});
-
-	it("retries after a failed free model list fetch", async () => {
-		const fetchMock = vi
-			.fn()
-			.mockResolvedValueOnce(new Response("unavailable", { status: 503 }))
-			.mockResolvedValueOnce(
-				new Response(
-					JSON.stringify({
-						free: [{ id: "deepseek/deepseek-v4-flash" }],
-					}),
-					{ status: 200, headers: { "content-type": "application/json" } },
-				),
-			);
-		vi.stubGlobal("fetch", fetchMock);
-
-		await expect(
-			shouldZeroClineFreeModelCost({
-				providerId: "cline",
-				modelId: "deepseek/deepseek-v4-flash",
-				baseUrl: "https://cline.test/api/v1",
-			}),
-		).resolves.toBe(false);
-		await expect(
-			shouldZeroClineFreeModelCost({
-				providerId: "cline",
-				modelId: "deepseek/deepseek-v4-flash",
-				baseUrl: "https://cline.test/api/v1",
-			}),
-		).resolves.toBe(true);
-		expect(fetchMock).toHaveBeenCalledTimes(2);
-	});
-});
-
-describe("zeroCliUsageCost", () => {
-	it("zeros total cost while preserving token usage", () => {
-		expect(
-			zeroCliUsageCost(
-				{
-					inputTokens: 10,
-					outputTokens: 5,
-					totalCost: 0.001,
-				},
-				true,
-			),
-		).toEqual({
-			inputTokens: 10,
-			outputTokens: 5,
-			totalCost: 0,
-		});
-	});
-});
-
-describe("zeroCliAgentEventCost", () => {
-	it("zeros usage event cost fields", () => {
-		const event = {
-			type: "usage",
-			inputTokens: 10,
-			outputTokens: 5,
-			cost: 0.001,
-			totalCost: 0.001,
-		} as AgentEvent;
-
-		expect(zeroCliAgentEventCost(event, true)).toMatchObject({
-			cost: 0,
-			totalCost: 0,
-		});
-	});
-
-	it("zeros done event usage cost", () => {
-		const event = {
-			type: "done",
-			reason: "completed",
-			text: "ok",
-			iterations: 1,
-			usage: {
-				inputTokens: 10,
-				outputTokens: 5,
-				totalCost: 0.001,
-			},
-		} as AgentEvent;
-
-		expect(zeroCliAgentEventCost(event, true)).toMatchObject({
-			usage: { totalCost: 0 },
-		});
-	});
-});

apps/cli/src/utils/free-model-cost.ts

@@ -1,123 +0,0 @@
-import type { AgentEvent } from "@cline/core";
-import { getClineEnvironmentConfig } from "@cline/shared";
-import type { Config } from "./types";
-
-const CLINE_RECOMMENDED_MODELS_TIMEOUT_MS = 5_000;
-const freeModelIdsByBaseUrl = new Map<
-	string,
-	Promise<readonly string[] | undefined>
->();
-
-function normalizeModelId(modelId: string | undefined): string {
-	return modelId?.trim().toLowerCase() ?? "";
-}
-
-function modelIdsMatch(selectedModelId: string, freeModelId: string): boolean {
-	const selected = normalizeModelId(selectedModelId);
-	const free = normalizeModelId(freeModelId);
-	if (!selected || !free) return false;
-	return selected === free;
-}
-
-function resolveClineRecommendedModelsUrl(baseUrl: string): string {
-	const normalizedBaseUrl = baseUrl.trim().replace(/\/+$/, "");
-	const apiBaseUrl = normalizedBaseUrl.endsWith("/api/v1")
-		? normalizedBaseUrl.slice(0, -"/api/v1".length)
-		: normalizedBaseUrl;
-	return `${apiBaseUrl}/api/v1/ai/cline/recommended-models`;
-}
-
-async function fetchClineFreeModelIds(
-	baseUrl: string,
-): Promise<readonly string[] | undefined> {
-	const controller = new AbortController();
-	const timeout = setTimeout(
-		() => controller.abort(),
-		CLINE_RECOMMENDED_MODELS_TIMEOUT_MS,
-	);
-	try {
-		const response = await fetch(resolveClineRecommendedModelsUrl(baseUrl), {
-			signal: controller.signal,
-		});
-		if (!response.ok) return undefined;
-		const json = (await response.json()) as { free?: unknown };
-		return Array.isArray(json.free)
-			? json.free
-					.map((model) =>
-						model && typeof model === "object"
-							? (model as Record<string, unknown>).id
-							: undefined,
-					)
-					.filter((id): id is string => typeof id === "string" && id.length > 0)
-			: [];
-	} catch {
-		return undefined;
-	} finally {
-		clearTimeout(timeout);
-	}
-}
-
-function getClineFreeModelIds(baseUrl: string): Promise<readonly string[]> {
-	const cacheKey = baseUrl.trim();
-	let cached = freeModelIdsByBaseUrl.get(cacheKey);
-	if (!cached) {
-		cached = fetchClineFreeModelIds(cacheKey).then((ids) => {
-			if (!ids) freeModelIdsByBaseUrl.delete(cacheKey);
-			return ids;
-		});
-		freeModelIdsByBaseUrl.set(cacheKey, cached);
-	}
-	return cached.then((ids) => ids ?? []);
-}
-
-export async function shouldZeroClineFreeModelCost(
-	config: Pick<Config, "providerId" | "modelId" | "baseUrl">,
-): Promise<boolean> {
-	if (config.providerId !== "cline") return false;
-	const modelId = normalizeModelId(config.modelId);
-	if (!modelId) return false;
-
-	const baseUrl =
-		config.baseUrl?.trim() || getClineEnvironmentConfig().apiBaseUrl;
-	const freeModelIds = await getClineFreeModelIds(baseUrl);
-	return freeModelIds.some((freeModelId) =>
-		modelIdsMatch(modelId, freeModelId),
-	);
-}
-
-export function zeroCliUsageCost<T extends { totalCost?: number } | undefined>(
-	usage: T,
-	shouldZeroCost: boolean,
-): T {
-	if (
-		!shouldZeroCost ||
-		!usage ||
-		typeof usage.totalCost !== "number" ||
-		usage.totalCost === 0
-	) {
-		return usage;
-	}
-	return { ...usage, totalCost: 0 } as T;
-}
-
-export function zeroCliAgentEventCost(
-	event: AgentEvent,
-	shouldZeroCost: boolean,
-): AgentEvent {
-	if (!shouldZeroCost) return event;
-	if (event.type === "done" && event.usage) {
-		return {
-			...event,
-			usage: zeroCliUsageCost(event.usage, true),
-		};
-	}
-	if (event.type !== "usage") return event;
-	const next = { ...event } as Record<string, unknown>;
-	if (typeof next.cost === "number") next.cost = 0;
-	if (typeof next.totalCost === "number") next.totalCost = 0;
-	return next as unknown as AgentEvent;
-}
-
-export function clearClineFreeModelCostCache(): void {
-	freeModelIdsByBaseUrl.clear();
-}

apps/cli/src/utils/provider-catalog.test.ts

@@ -20,7 +20,7 @@ vi.mock("./feature-flags", () => ({
 }));
 
 describe("listLocalProviders", () => {
-	it("passes the ClinePass feature flag into the SDK provider list", async () => {
+	it("passes the Cline Pass feature flag into the SDK provider list", async () => {
 		const { listLocalProviders } = await import("./provider-catalog");
 		const manager = {} as never;
 

apps/cli/src/wizards/connect/platforms.ts

@@ -1,16 +1,325 @@
-import {
-	CONNECTOR_PLATFORMS,
-	shouldIncludeConnectorField,
-} from "@cline/shared";
+export interface PlatformDef {
+	id: string;
+	name: string;
+	type: "polling" | "webhook" | "hybrid";
+	hint: string;
+	fields: FieldDef[];
+	security?: SecurityDef;
+}
 
-export type {
-	ConnectorFieldCondition as FieldCondition,
-	ConnectorFieldDef as FieldDef,
-	ConnectorPlatformDef as PlatformDef,
-	ConnectorSecurityDef as SecurityDef,
-	ConnectorSecurityFieldDef as SecurityFieldDef,
-} from "@cline/shared";
-export { CONNECTOR_PLATFORMS, shouldIncludeConnectorField };
+export interface FieldDef {
+	flag: string;
+	label: string;
+	placeholder?: string;
+	required?: boolean;
+	help?: string[];
+	initialValue?: string;
+	options?: Array<{ value: string; label: string; hint?: string }>;
+	includeWhen?: FieldCondition;
+}
 
-export const PLATFORMS = CONNECTOR_PLATFORMS;
-export const shouldIncludeField = shouldIncludeConnectorField;
+export type FieldCondition = {
+	flag: string;
+	equals?: string;
+	notEquals?: string;
+};
+
+export interface SecurityFieldDef {
+	key: string;
+	label: string;
+	placeholder?: string;
+	help?: string[];
+	requiredMessage: string;
+	validate?: (value: string) => string | undefined;
+}
+
+export interface SecurityDef {
+	prompt: string;
+	fields: SecurityFieldDef[];
+	buildArgs: (values: Record<string, string>) => string[];
+}
+
+export function shouldIncludeField(
+	field: FieldDef,
+	values: Record<string, string>,
+): boolean {
+	const condition = field.includeWhen;
+	if (!condition) {
+		return true;
+	}
+	const value = values[condition.flag] ?? "";
+	if (condition.equals !== undefined && value !== condition.equals) {
+		return false;
+	}
+	if (condition.notEquals !== undefined && value === condition.notEquals) {
+		return false;
+	}
+	return true;
+}
+
+function validateTelegramUserId(value: string): string | undefined {
+	return /^\d+$/.test(value)
+		? undefined
+		: "Telegram user ID must contain digits only";
+}
+
+function validateSlackTeamId(value: string): string | undefined {
+	return /^T[A-Z0-9]+$/.test(value)
+		? undefined
+		: "Slack workspace ID must start with T and contain uppercase letters or digits only";
+}
+
+function validateSlackUserId(value: string): string | undefined {
+	return /^[UW][A-Z0-9]+$/.test(value)
+		? undefined
+		: "Slack member ID must start with U or W and contain uppercase letters or digits only";
+}
+
+export const PLATFORMS: PlatformDef[] = [
+	{
+		id: "telegram",
+		name: "Telegram",
+		type: "polling",
+		hint: "Easiest to set up. No public URL needed.",
+		fields: [
+			{
+				flag: "-k",
+				label: "Bot token",
+				placeholder: "7123456789:AAH...",
+				required: true,
+				help: [
+					"Open Telegram and start a chat with @BotFather",
+					"Send /newbot and follow the prompts",
+					"BotFather gives you this after creating the bot",
+					"It looks like 7123456789:AAHxxx...",
+				],
+			},
+		],
+		security: {
+			prompt:
+				"By default, anyone who finds your bot can message it and run tasks on your machine. Restrict access to your Telegram user ID?",
+			fields: [
+				{
+					key: "userId",
+					label: "Your Telegram user ID",
+					placeholder: "123456789",
+					help: [
+						"Message @userinfobot on Telegram",
+						"It will reply with your numeric user ID",
+					],
+					requiredMessage: "User ID is required to restrict access",
+					validate: validateTelegramUserId,
+				},
+			],
+			buildArgs: ({ userId }) => ["--allowed-user-id", userId ?? ""],
+		},
+	},
+	{
+		id: "slack",
+		name: "Slack",
+		type: "hybrid",
+		hint: "Public URL for webhook mode; leave blank for socket mode.",
+		fields: [
+			{
+				flag: "--bot-token",
+				label: "Bot token",
+				placeholder: "xoxb-...",
+				required: true,
+				help: [
+					"Go to api.slack.com/apps and create a new app",
+					"Add Bot Token Scopes: chat:write, app_mentions:read, channels:history, channels:read, im:history, im:read, im:write, users:read",
+					"Install to workspace and copy the Bot Token",
+				],
+			},
+			{
+				flag: "--base-url",
+				label: "Public base URL",
+				placeholder: "leave blank for socket mode",
+				help: [
+					"Enter a publicly accessible URL for webhook mode",
+					"Leave blank to use Slack socket mode instead",
+				],
+			},
+			{
+				flag: "--signing-secret",
+				label: "Signing secret",
+				required: true,
+				help: ["Found in your app's Basic Information page"],
+				includeWhen: { flag: "--base-url", notEquals: "" },
+			},
+			{
+				flag: "--app-token",
+				label: "App-level token",
+				placeholder: "xapp-...",
+				required: true,
+				help: [
+					"Enable Socket Mode in the Slack app",
+					"Generate an app-level token with the connections:write scope",
+				],
+				includeWhen: { flag: "--base-url", equals: "" },
+			},
+		],
+		security: {
+			prompt: "Restrict which Slack users can interact with the bot?",
+			fields: [
+				{
+					key: "teamId",
+					label: "Allowed Slack workspace ID",
+					placeholder: "T01ABC123",
+					help: [
+						"Open your Slack workspace URL in a browser",
+						"The workspace ID is the segment after /client/, for example T01ABC123",
+					],
+					requiredMessage: "Workspace ID is required to restrict access",
+					validate: validateSlackTeamId,
+				},
+				{
+					key: "userId",
+					label: "Allowed Slack member ID",
+					placeholder: "U01ABC123",
+					help: [
+						"Click a user's name in Slack, then View full profile",
+						"Click ... and Copy member ID",
+					],
+					requiredMessage: "Member ID is required to restrict access",
+					validate: validateSlackUserId,
+				},
+			],
+			buildArgs: ({ teamId, userId }) => [
+				"--hook-command",
+				`jq -r ".payload.actor.participantKey" | grep -qx "slack:team:${teamId}:user:${userId}" && echo '{"action":"allow"}' || echo '{"action":"deny"}'`,
+			],
+		},
+	},
+	{
+		id: "discord",
+		name: "Discord",
+		type: "webhook",
+		hint: "Requires a Discord app and public URL.",
+		fields: [
+			{
+				flag: "--application-id",
+				label: "Application ID",
+				required: true,
+				help: [
+					"Go to discord.com/developers/applications",
+					"Create a new app, copy the Application ID",
+				],
+			},
+			{
+				flag: "--bot-token",
+				label: "Bot token",
+				required: true,
+				help: ["Go to Bot section, create a bot, copy the token"],
+			},
+			{
+				flag: "--public-key",
+				label: "Public key",
+				required: true,
+				help: ["Found in General Information of your app"],
+			},
+			{
+				flag: "--base-url",
+				label: "Public base URL",
+				placeholder: "https://example.com",
+				required: true,
+				help: [
+					"Base URL for the connector",
+					"For Discord, set the Interactions Endpoint URL to <base-url>/api/webhooks/discord",
+				],
+			},
+		],
+	},
+	{
+		id: "whatsapp",
+		name: "WhatsApp",
+		type: "webhook",
+		hint: "Requires Meta developer account and public URL.",
+		fields: [
+			{
+				flag: "--phone-number-id",
+				label: "Phone number ID",
+				required: true,
+				help: ["From your WhatsApp Business account in Meta Developer portal"],
+			},
+			{
+				flag: "--access-token",
+				label: "Access token",
+				required: true,
+				help: ["Generate a permanent token in Meta Developer portal"],
+			},
+			{
+				flag: "--app-secret",
+				label: "App secret",
+				required: true,
+				help: ["Found in App Settings > Basic"],
+			},
+			{
+				flag: "--verify-token",
+				label: "Webhook verify token",
+				placeholder: "my-verify-token",
+				required: true,
+				help: ["Any string you choose, used to verify webhook setup"],
+			},
+			{
+				flag: "--base-url",
+				label: "Public base URL",
+				placeholder: "https://example.com",
+				required: true,
+			},
+		],
+	},
+	{
+		id: "gchat",
+		name: "Google Chat",
+		type: "webhook",
+		hint: "Requires Google Cloud project and public URL.",
+		fields: [
+			{
+				flag: "--credentials-json",
+				label: "Service account credentials JSON",
+				required: true,
+				help: [
+					"Create a service account in Google Cloud Console",
+					"Download the credentials JSON file",
+					"Paste the JSON content here",
+				],
+			},
+			{
+				flag: "--base-url",
+				label: "Public base URL",
+				placeholder: "https://example.com",
+				required: true,
+			},
+		],
+	},
+	{
+		id: "linear",
+		name: "Linear",
+		type: "webhook",
+		hint: "React to Linear issues and comments.",
+		fields: [
+			{
+				flag: "--api-key",
+				label: "API key",
+				required: true,
+				help: ["Go to Linear Settings > API > Personal API keys"],
+			},
+			{
+				flag: "--webhook-secret",
+				label: "Webhook signing secret",
+				required: true,
+				help: [
+					"Go to Settings > API > Webhooks, create one",
+					"Copy the signing secret",
+				],
+			},
+			{
+				flag: "--base-url",
+				label: "Public base URL",
+				placeholder: "https://example.com",
+				required: true,
+			},
+		],
+	},
+];

apps/cli/src/wizards/mcp/index.ts

@@ -1,5 +1,6 @@
 import * as p from "@clack/prompts";
-import { authorizeMcpServerOAuthWithBrowser as authorizeOAuth } from "./oauth";
+import { authorizeMcpServerOAuth } from "@cline/core";
+import open from "open";
 import {
 	addServer,
 	clearServerOAuth,
@@ -16,6 +17,16 @@ function isCancel(value: unknown): value is symbol {
 	return p.isCancel(value);
 }
 
+function toErrorMessage(error: unknown): string {
+	if (error instanceof Error) {
+		const message = error.message.trim();
+		if (message.length > 0) {
+			return message;
+		}
+	}
+	return String(error);
+}
+
 function transportLabel(t: McpTransport): string {
 	if (t.type === "stdio") return `stdio: ${t.command}`;
 	return `${t.type}: ${t.url}`;
@@ -51,19 +62,6 @@ interface UrlServerConfig {
 	authMode: RemoteAuthMode;
 }
 
-export interface McpAddDefaults {
-	name?: string;
-	type?: McpTransport["type"];
-	command?: string;
-	url?: string;
-}
-
-export interface RunMcpWizardOptions {
-	initialAction?: "add";
-	addDefaults?: McpAddDefaults;
-	exitAfterInitialAction?: boolean;
-}
-
 export function parseStdioCommand(input: string): string[] {
 	const tokens: string[] = [];
 	let current = "";
@@ -109,15 +107,12 @@ export function parseStdioCommand(input: string): string[] {
 	return tokens;
 }
 
-async function collectStdioTransport(
-	defaultCommand?: string,
-): Promise<McpTransport | null> {
+async function collectStdioTransport(): Promise<McpTransport | null> {
 	p.log.info("Quoted arguments and escaped spaces are supported");
 
 	const command = await p.text({
 		message: "Command to run",
 		placeholder: "npx -y @modelcontextprotocol/server-filesystem",
-		initialValue: defaultCommand,
 		validate: (v) => {
 			if (!v?.trim()) return "Command is required";
 			return undefined;
@@ -157,12 +152,10 @@ async function collectStdioTransport(
 
 async function collectUrlTransport(
 	type: "sse" | "streamableHttp",
-	defaultUrl?: string,
 ): Promise<UrlServerConfig | null> {
 	const url = await p.text({
 		message: "Server URL",
 		placeholder: "https://example.com/mcp",
-		initialValue: defaultUrl,
 		validate: (v) => {
 			if (!v?.trim()) return "URL is required";
 			try {
@@ -229,11 +222,33 @@ async function collectUrlTransport(
 	};
 }
 
-async function actionAdd(defaults?: McpAddDefaults): Promise<void> {
+async function authorizeOAuth(name: string): Promise<void> {
+	p.log.info("Opening browser for MCP OAuth authorization");
+	try {
+		const result = await authorizeMcpServerOAuth({
+			serverName: name,
+			filePath: getSettingsPath(),
+			openUrl: async (url) => {
+				p.log.message(`Authorization URL: ${url}`);
+				await open(url, { wait: false });
+			},
+			onServerListening: (info) => {
+				p.log.message(`Waiting for OAuth callback at ${info.callbackUrl}`);
+			},
+		});
+		p.log.success(result.message);
+	} catch (error) {
+		p.log.error(`OAuth authorization failed: ${toErrorMessage(error)}`);
+		p.log.warn(
+			`Server "${name}" is still saved. Choose "Authorize OAuth" to retry.`,
+		);
+	}
+}
+
+async function actionAdd(): Promise<void> {
 	const name = await p.text({
 		message: "Server name",
 		placeholder: "my-mcp-server",
-		initialValue: defaults?.name,
 		validate: (v) => {
 			if (!v?.trim()) return "Name is required";
 			const existing = loadServers();
@@ -247,7 +262,6 @@ async function actionAdd(defaults?: McpAddDefaults): Promise<void> {
 
 	const type = await p.select({
 		message: "Server type",
-		initialValue: defaults?.type,
 		options: [
 			{
 				value: "stdio",
@@ -271,12 +285,9 @@ async function actionAdd(defaults?: McpAddDefaults): Promise<void> {
 	let transport: McpTransport | null;
 	let authMode: RemoteAuthMode = "none";
 	if (type === "stdio") {
-		transport = await collectStdioTransport(defaults?.command);
+		transport = await collectStdioTransport();
 	} else {
-		const config = await collectUrlTransport(
-			type as "sse" | "streamableHttp",
-			defaults?.url,
-		);
+		const config = await collectUrlTransport(type as "sse" | "streamableHttp");
 		transport = config?.transport ?? null;
 		authMode = config?.authMode ?? "none";
 	}
@@ -430,25 +441,9 @@ async function actionAuthorizeOAuth(): Promise<void> {
 	await authorizeOAuth(name);
 }
 
-export async function runMcpWizard(
-	options: RunMcpWizardOptions = {},
-): Promise<number> {
+export async function runMcpWizard(): Promise<number> {
 	p.intro("MCP Servers");
 
-	if (options.initialAction === "add") {
-		let initialActionExitCode = 0;
-		try {
-			await actionAdd(options.addDefaults);
-		} catch (err) {
-			initialActionExitCode = 1;
-			p.log.error(err instanceof Error ? err.message : String(err));
-		}
-		if (options.exitAfterInitialAction === true) {
-			p.outro("Done");
-			return initialActionExitCode;
-		}
-	}
-
 	let keepGoing = true;
 	while (keepGoing) {
 		const action = await p.select({

apps/cli/src/wizards/mcp/oauth.ts

@@ -1,45 +0,0 @@
-import * as p from "@clack/prompts";
-import {
-	authorizeMcpServerOAuth,
-	resolveDefaultMcpSettingsPath,
-} from "@cline/core";
-import open from "open";
-
-function toErrorMessage(error: unknown): string {
-	if (error instanceof Error) {
-		const message = error.message.trim();
-		if (message.length > 0) {
-			return message;
-		}
-	}
-	return String(error);
-}
-
-export async function authorizeMcpServerOAuthWithBrowser(
-	name: string,
-	options: { throwOnError?: boolean } = {},
-): Promise<void> {
-	p.log.info("Opening browser for MCP OAuth authorization");
-	try {
-		const result = await authorizeMcpServerOAuth({
-			serverName: name,
-			filePath: resolveDefaultMcpSettingsPath(),
-			openUrl: async (url) => {
-				p.log.message(`Authorization URL: ${url}`);
-				await open(url, { wait: false });
-			},
-			onServerListening: (info) => {
-				p.log.message(`Waiting for OAuth callback at ${info.callbackUrl}`);
-			},
-		});
-		p.log.success(result.message);
-	} catch (error) {
-		if (options.throwOnError === true) {
-			throw error instanceof Error ? error : new Error(toErrorMessage(error));
-		}
-		p.log.error(`OAuth authorization failed: ${toErrorMessage(error)}`);
-		p.log.warn(
-			`Server "${name}" is still saved. Choose "Authorize OAuth" to retry.`,
-		);
-	}
-}

apps/cli/src/wizards/mcp/settings.test.ts

@@ -57,17 +57,6 @@ describe("MCP wizard settings", () => {
 		expect(Object.keys(parsed.mcpServers ?? {})).toEqual(["added"]);
 	});
 
-	it("creates the settings file when adding a server to a missing path", async () => {
-		const settingsPath = await useTempSettingsPath();
-
-		addServer("added", { type: "stdio", command: "npx", args: ["server"] });
-
-		const parsed = JSON.parse(await readFile(settingsPath, "utf8")) as {
-			mcpServers?: Record<string, unknown>;
-		};
-		expect(Object.keys(parsed.mcpServers ?? {})).toEqual(["added"]);
-	});
-
 	it("parses quoted stdio command arguments", () => {
 		expect(
 			parseStdioCommand('npx -y "@scope/server name" --root "my dir"'),

apps/cli/src/wizards/mcp/settings.ts

@@ -1,9 +1,8 @@
-import { existsSync, readFileSync } from "node:fs";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname } from "node:path";
 import {
 	type McpServerOAuthState,
-	McpSettingsUpdateSkippedError,
 	resolveDefaultMcpSettingsPath,
-	updateMcpSettingsFileSync,
 } from "@cline/core";
 
 export interface McpServerEntry {
@@ -57,6 +56,28 @@ export function loadServers(): McpServerEntry[] {
 	}
 }
 
+function readRawSettings(): Record<string, unknown> {
+	const path = getSettingsPath();
+	if (!existsSync(path)) return {};
+	try {
+		const raw = readFileSync(path, "utf-8");
+		const parsed = JSON.parse(raw);
+		return parsed && typeof parsed === "object" && !Array.isArray(parsed)
+			? (parsed as Record<string, unknown>)
+			: {};
+	} catch {
+		return {};
+	}
+}
+
+function readRawServers(): Record<string, unknown> {
+	const settings = readRawSettings();
+	const servers = settings.mcpServers;
+	return servers && typeof servers === "object" && !Array.isArray(servers)
+		? { ...(servers as Record<string, unknown>) }
+		: {};
+}
+
 function getOwnServerRecord(
 	servers: Record<string, unknown>,
 	name: string,
@@ -71,85 +92,62 @@ function getOwnServerRecord(
 	return value as Record<string, unknown>;
 }
 
-/**
- * Mutate the MCP settings file through @cline/core's locked read-update-write
- * helper. The mutator must be synchronous and pure; the helper may call it more
- * than once to verify deterministic output. Throw McpSettingsUpdateSkippedError
- * for normal no-op cases instead of returning a boolean that callers can ignore.
- */
-function mutateServers(mutate: (servers: Record<string, unknown>) => void): void {
-	updateMcpSettingsFileSync(getSettingsPath(), (settings) => {
-		const serversValue = settings.mcpServers;
-		const servers = serversValue && typeof serversValue === "object" && !Array.isArray(serversValue)
-			? { ...(serversValue as Record<string, unknown>) }
-			: {};
-		mutate(servers);
-		settings.mcpServers = servers;
-	});
+function writeServers(servers: Record<string, unknown>): void {
+	const path = getSettingsPath();
+	const settings = readRawSettings();
+	mkdirSync(dirname(path), { recursive: true });
+	writeFileSync(
+		path,
+		`${JSON.stringify({ ...settings, mcpServers: servers }, null, 2)}\n`,
+	);
 }
 
 export function addServer(name: string, transport: McpTransport): void {
-	mutateServers((servers) => {
-		servers[name] = { transport };
-	});
+	const servers = readRawServers();
+	servers[name] = { transport };
+	writeServers(servers);
 }
 
 export function removeServer(name: string): boolean {
-	try {
-		mutateServers((servers) => {
-			if (!(name in servers)) {
-				throw new McpSettingsUpdateSkippedError(`MCP server not found: ${name}`);
-			}
-			delete servers[name];
-		});
-		return true;
-	} catch (error) {
-		if (error instanceof McpSettingsUpdateSkippedError) {
-			return false;
-		}
-		throw error;
-	}
+	const servers = readRawServers();
+	if (!(name in servers)) return false;
+	delete servers[name];
+	writeServers(servers);
+	return true;
 }
 
 export function updateServer(name: string, transport: McpTransport): void {
-	mutateServers((servers) => {
-		const existing =
-			servers[name] && typeof servers[name] === "object"
-				? (servers[name] as Record<string, unknown>)
-				: {};
-		servers[name] = { ...existing, transport };
-	});
+	const servers = readRawServers();
+	const existing =
+		servers[name] && typeof servers[name] === "object"
+			? (servers[name] as Record<string, unknown>)
+			: {};
+	servers[name] = { ...existing, transport };
+	writeServers(servers);
 }
 
 export function clearServerOAuth(name: string): void {
-	try {
-		mutateServers((servers) => {
-			const existing = getOwnServerRecord(servers, name);
-			if (!existing) {
-				throw new McpSettingsUpdateSkippedError(`MCP server not found: ${name}`);
-			}
-			delete existing.oauth;
-			servers[name] = existing;
-		});
-	} catch (error) {
-		if (error instanceof McpSettingsUpdateSkippedError) {
-			return;
-		}
-		throw error;
+	const servers = readRawServers();
+	const existing = getOwnServerRecord(servers, name);
+	if (!existing) {
+		return;
 	}
+	delete existing.oauth;
+	servers[name] = existing;
+	writeServers(servers);
 }
 
 export function toggleServer(name: string, disabled: boolean): void {
-	mutateServers((servers) => {
-		const existing =
-			servers[name] && typeof servers[name] === "object"
-				? (servers[name] as Record<string, unknown>)
-				: {};
-		if (disabled) {
-			existing.disabled = true;
-		} else {
-			delete existing.disabled;
-		}
-		servers[name] = existing;
-	});
+	const servers = readRawServers();
+	const existing =
+		servers[name] && typeof servers[name] === "object"
+			? (servers[name] as Record<string, unknown>)
+			: {};
+	if (disabled) {
+		existing.disabled = true;
+	} else {
+		delete existing.disabled;
+	}
+	servers[name] = existing;
+	writeServers(servers);
 }

apps/cline-hub/package.json

@@ -12,7 +12,6 @@
 		"dev": "bun run src/dev.ts",
 		"start": "bun run src/server.ts",
 		"smoke:options": "bun run src/validate-options.ts",
-		"test": "bunx vitest run --config vitest.config.ts",
 		"typecheck": "bun tsc -p tsconfig.json --noEmit"
 	},
 	"dependencies": {

apps/cline-hub/src/options.ts

@@ -1,5 +1,3 @@
-import { isIP } from "node:net";
-
 export interface ClineHubServerOptions {
 	host: string;
 	port: number;
@@ -49,9 +47,6 @@ function normalizePublicUrl(
 			`PUBLIC_URL must use http: or https:, got ${parsed.protocol}`,
 		);
 	}
-	if (shouldAddDashboardPortToPublicUrl(parsed, port)) {
-		parsed.port = String(port);
-	}
 	parsed.hash = "";
 	return parsed.toString().replace(/\/$/, "");
 }
@@ -90,26 +85,12 @@ export function resolveClineHubServerOptions(
 	};
 }
 
-function isDefaultProtocolPort(url: URL, port: number): boolean {
-	return (
-		(url.protocol === "http:" && port === 80) ||
-		(url.protocol === "https:" && port === 443)
-	);
-}
-
-function shouldAddDashboardPortToPublicUrl(url: URL, port: number): boolean {
-	if (url.port || isDefaultProtocolPort(url, port)) return false;
-	const hostname = url.hostname.replace(/^\[|\]$/g, "");
-	return hostname === "localhost" || isIP(hostname) !== 0;
-}
-
 export function buildInviteUrl(
 	publicUrl: string,
 	roomSecret: string | undefined,
 ): string {
+	if (!roomSecret) return publicUrl;
 	const url = new URL(publicUrl);
-	if (roomSecret) {
-		url.searchParams.set("roomSecret", roomSecret);
-	}
+	url.searchParams.set("roomSecret", roomSecret);
 	return url.toString();
 }

apps/cline-hub/src/server.ts

@@ -4,7 +4,6 @@ import {
 	handleToolApprovalResponse,
 	rejectOrphanedApprovals,
 } from "./server/approvals";
-import { isAuthorizedBrowserToDesktopRequest } from "./server/browser-auth";
 import {
 	browserConfig,
 	host,
@@ -15,11 +14,7 @@ import {
 	webviewDistDir,
 } from "./server/deps";
 import { handleDesktopCommand } from "./server/desktop-commands";
-import {
-	createJsonResponse,
-	isWebviewRoute,
-	WebviewAssets,
-} from "./server/http";
+import { createJsonResponse, WebviewAssets } from "./server/http";
 import {
 	attachHub,
 	detachHub,
@@ -27,7 +22,6 @@ import {
 	syncHubClientsAndSessions,
 	syncHubHealth,
 } from "./server/hub";
-import { fetchMarketplaceCatalog } from "./server/marketplace";
 import {
 	loadModels,
 	runProviderOAuthLogin,
@@ -58,33 +52,17 @@ export interface ClineHubDashboardServer {
 	stop: () => Promise<void>;
 }
 
-const PUBLIC_BROWSER_PATHS = new Set([
-	"/version",
-	"/health",
-	"/config.json",
-	"/api/marketplace/catalog",
-	"/icon.png",
-	"/icon.svg",
-	"/icon.ico",
-	"/32x32.png",
-	"/cline-logo-filled.svg",
-	"/favicon.svg",
-]);
-
-function isPublicStaticAssetPath(pathname: string): boolean {
-	return pathname.startsWith("/assets/") || PUBLIC_BROWSER_PATHS.has(pathname);
-}
-
-function isPublicBrowserRoute(_req: Request, url: URL): boolean {
-	return isWebviewRoute(url.pathname) || isPublicStaticAssetPath(url.pathname);
-}
-
 export async function startClineHubDashboardServer(): Promise<ClineHubDashboardServer> {
 	const ctx = new HubContext();
 	const assets = new WebviewAssets(webviewDistDir);
 	const syncClientsAndSessions = () => syncHubClientsAndSessions(ctx);
 	let stopped = false;
 
+	function isAuthorizedBrowserRequest(url: URL): boolean {
+		if (!roomSecret) return true;
+		return url.searchParams.get("roomSecret") === roomSecret;
+	}
+
 	await attachHub(ctx);
 	const healthInterval = setInterval(() => {
 		void (async () => {
@@ -98,21 +76,6 @@ export async function startClineHubDashboardServer(): Promise<ClineHubDashboardS
 		hostname: host,
 		async fetch(req, server) {
 			const url = new URL(req.url);
-			if (
-				!isAuthorizedBrowserToDesktopRequest(
-					req,
-					url,
-					{
-						bindHost: host,
-						port,
-						publicUrl,
-						roomSecret,
-					},
-					isPublicBrowserRoute,
-				)
-			) {
-				return createJsonResponse({ error: "unauthorized_browser" }, 403);
-			}
 			if (url.pathname === "/version") {
 				return createJsonResponse({ coreVersion: CORE_BUILD_VERSION });
 			}
@@ -121,6 +84,9 @@ export async function startClineHubDashboardServer(): Promise<ClineHubDashboardS
 				return createJsonResponse(hubStatusPayload(ctx));
 			}
 			if (url.pathname === "/browser") {
+				if (!isAuthorizedBrowserRequest(url)) {
+					return createJsonResponse({ error: "invalid_room_secret" }, 401);
+				}
 				const displayName = `Browser ${Math.random().toString(36).slice(2, 6)}`;
 				const data = {
 					socket: undefined as never,
@@ -133,21 +99,6 @@ export async function startClineHubDashboardServer(): Promise<ClineHubDashboardS
 			if (url.pathname === "/config.json") {
 				return createJsonResponse(browserConfig);
 			}
-			if (url.pathname === "/api/marketplace/catalog") {
-				try {
-					return createJsonResponse(await fetchMarketplaceCatalog());
-				} catch (error) {
-					return createJsonResponse(
-						{
-							error:
-								error instanceof Error
-									? error.message
-									: "Failed to fetch marketplace catalog",
-						},
-						502,
-					);
-				}
-			}
 			return assets.serve(url.pathname);
 		},
 		websocket: {

apps/cline-hub/src/server/browser-auth.test.ts

@@ -1,359 +0,0 @@
-import { describe, expect, it } from "vitest";
-import {
-	allowedBrowserHosts,
-	allowedBrowserOrigins,
-	isAuthorizedBrowserRequest,
-	isAuthorizedBrowserToDesktopRequest,
-	requiresBrowserRequestAuth,
-} from "./browser-auth";
-
-const defaultOptions = {
-	bindHost: "127.0.0.1",
-	port: 8787,
-	publicUrl: "http://127.0.0.1:8787",
-};
-
-const publicRoute = (_req: Request, url: URL) => url.pathname === "/public";
-
-function browserRequest(
-	origin?: string,
-	init?: Omit<RequestInit, "headers"> & {
-		headers?: Record<string, string>;
-	},
-): Request {
-	return new Request("http://127.0.0.1:8787/browser", {
-		...init,
-		headers: {
-			host: "127.0.0.1:8787",
-			...(origin === undefined ? {} : { origin }),
-			...(init?.headers ?? {}),
-		},
-	});
-}
-
-describe("allowedBrowserOrigins", () => {
-	it("allows the configured public URL origin and local aliases for local binds", () => {
-		expect([...allowedBrowserOrigins(defaultOptions)].sort()).toEqual([
-			"http://127.0.0.1:8787",
-			"http://[::1]:8787",
-			"http://localhost:8787",
-		]);
-	});
-
-	it("uses the configured public URL scheme for local aliases", () => {
-		expect(
-			[
-				...allowedBrowserOrigins({
-					...defaultOptions,
-					publicUrl: "https://127.0.0.1:8787",
-				}),
-			].sort(),
-		).toEqual([
-			"https://127.0.0.1:8787",
-			"https://[::1]:8787",
-			"https://localhost:8787",
-		]);
-	});
-
-	it("omits default protocol ports for local alias origins", () => {
-		expect(
-			[
-				...allowedBrowserOrigins({
-					bindHost: "127.0.0.1",
-					port: 80,
-					publicUrl: "http://localhost",
-				}),
-			].sort(),
-		).toEqual(["http://127.0.0.1", "http://[::1]", "http://localhost"]);
-
-		expect(
-			[
-				...allowedBrowserOrigins({
-					bindHost: "127.0.0.1",
-					port: 443,
-					publicUrl: "https://localhost",
-				}),
-			].sort(),
-		).toEqual(["https://127.0.0.1", "https://[::1]", "https://localhost"]);
-	});
-
-	it("allows the configured public URL origin and explicit bind origin for non-local binds", () => {
-		expect(
-			[
-				...allowedBrowserOrigins({
-					bindHost: "0.0.0.0",
-					port: 8787,
-					publicUrl: "https://example.ngrok-free.app",
-					roomSecret: "secret",
-				}),
-			].sort(),
-		).toEqual(["https://0.0.0.0:8787", "https://example.ngrok-free.app"]);
-	});
-});
-
-describe("allowedBrowserHosts", () => {
-	it("allows the configured public URL host and local aliases for local binds", () => {
-		expect([...allowedBrowserHosts(defaultOptions)].sort()).toEqual([
-			"127.0.0.1:8787",
-			"[::1]:8787",
-			"localhost:8787",
-		]);
-	});
-
-	it("omits default protocol ports for local alias hosts", () => {
-		expect(
-			[
-				...allowedBrowserHosts({
-					bindHost: "127.0.0.1",
-					port: 80,
-					publicUrl: "http://localhost",
-				}),
-			].sort(),
-		).toEqual(["127.0.0.1", "[::1]", "localhost"]);
-
-		expect(
-			[
-				...allowedBrowserHosts({
-					bindHost: "127.0.0.1",
-					port: 443,
-					publicUrl: "https://localhost",
-				}),
-			].sort(),
-		).toEqual(["127.0.0.1", "[::1]", "localhost"]);
-	});
-
-	it("allows the configured public URL host and explicit bind host for non-local binds", () => {
-		expect(
-			[
-				...allowedBrowserHosts({
-					bindHost: "0.0.0.0",
-					port: 8787,
-					publicUrl: "https://example.ngrok-free.app",
-					roomSecret: "secret",
-				}),
-			].sort(),
-		).toEqual(["0.0.0.0:8787", "example.ngrok-free.app"]);
-	});
-});
-
-describe("requiresBrowserRequestAuth", () => {
-	it("does not require browser auth for public GET routes", () => {
-		expect(
-			requiresBrowserRequestAuth(
-				new Request("http://127.0.0.1:8787/public"),
-				new URL("http://127.0.0.1:8787/public"),
-				publicRoute,
-			),
-		).toBe(false);
-	});
-
-	it("requires browser auth for unknown paths even when they use GET", () => {
-		expect(
-			requiresBrowserRequestAuth(
-				new Request("http://127.0.0.1:8787/future-api"),
-				new URL("http://127.0.0.1:8787/future-api"),
-				publicRoute,
-			),
-		).toBe(true);
-	});
-
-	it("requires browser auth for privileged paths even when they use GET", () => {
-		expect(
-			requiresBrowserRequestAuth(
-				new Request("http://127.0.0.1:8787/browser"),
-				new URL("http://127.0.0.1:8787/browser"),
-				publicRoute,
-			),
-		).toBe(true);
-	});
-
-	it("requires browser auth for every WebSocket upgrade path", () => {
-		expect(
-			requiresBrowserRequestAuth(
-				new Request("http://127.0.0.1:8787/future-socket", {
-					headers: { upgrade: "websocket" },
-				}),
-				new URL("http://127.0.0.1:8787/future-socket"),
-				publicRoute,
-			),
-		).toBe(true);
-	});
-
-	it("requires browser auth for every unsafe HTTP method", () => {
-		expect(
-			requiresBrowserRequestAuth(
-				new Request("http://127.0.0.1:8787/future-api", { method: "POST" }),
-				new URL("http://127.0.0.1:8787/future-api"),
-				publicRoute,
-			),
-		).toBe(true);
-	});
-});
-
-describe("isAuthorizedBrowserRequest", () => {
-	it.each([
-		"http://127.0.0.1:8787",
-		"http://localhost:8787",
-		"http://[::1]:8787",
-	])("accepts local dashboard origin %s without a room secret", (origin) => {
-		expect(
-			isAuthorizedBrowserRequest(
-				browserRequest(origin),
-				new URL("http://127.0.0.1:8787/browser"),
-				defaultOptions,
-			),
-		).toBe(true);
-	});
-
-	it.each([
-		undefined,
-		"",
-		"null",
-		"not a url",
-		"http://evil.attacker.example.com",
-		"http://127.0.0.1:9999",
-		"https://127.0.0.1:8787",
-	])("rejects untrusted origin %s", (origin) => {
-		expect(
-			isAuthorizedBrowserRequest(
-				browserRequest(origin),
-				new URL("http://127.0.0.1:8787/browser"),
-				defaultOptions,
-			),
-		).toBe(false);
-	});
-
-	it.each([
-		undefined,
-		"",
-		"evil.attacker.example.com",
-		"127.0.0.1:9999",
-		"localhost:9999",
-	])("rejects untrusted host %s", (host) => {
-		expect(
-			isAuthorizedBrowserRequest(
-				browserRequest("http://127.0.0.1:8787", {
-					headers: host === undefined ? { host: "" } : { host },
-				}),
-				new URL("http://127.0.0.1:8787/browser"),
-				defaultOptions,
-			),
-		).toBe(false);
-	});
-
-	it("allows explicit wildcard bind host and origin when a room secret is configured", () => {
-		expect(
-			isAuthorizedBrowserRequest(
-				browserRequest("http://0.0.0.0:8787", {
-					headers: { host: "0.0.0.0:8787" },
-				}),
-				new URL("http://0.0.0.0:8787/browser?roomSecret=invite-123"),
-				{
-					bindHost: "0.0.0.0",
-					port: 8787,
-					publicUrl: "http://127.0.0.1:8787",
-					roomSecret: "invite-123",
-				},
-			),
-		).toBe(true);
-	});
-
-	it("requires trusted origin, trusted host, and room secret when a room secret is configured", () => {
-		const options = { ...defaultOptions, roomSecret: "invite-123" };
-
-		expect(
-			isAuthorizedBrowserRequest(
-				browserRequest("http://127.0.0.1:8787"),
-				new URL("http://127.0.0.1:8787/browser?roomSecret=invite-123"),
-				options,
-			),
-		).toBe(true);
-		expect(
-			isAuthorizedBrowserRequest(
-				browserRequest("http://127.0.0.1:8787"),
-				new URL("http://127.0.0.1:8787/browser"),
-				options,
-			),
-		).toBe(false);
-		expect(
-			isAuthorizedBrowserRequest(
-				browserRequest("http://evil.attacker.example.com"),
-				new URL("http://127.0.0.1:8787/browser?roomSecret=invite-123"),
-				options,
-			),
-		).toBe(false);
-		expect(
-			isAuthorizedBrowserRequest(
-				browserRequest("http://127.0.0.1:8787", {
-					headers: { host: "evil.attacker.example.com" },
-				}),
-				new URL("http://127.0.0.1:8787/browser?roomSecret=invite-123"),
-				options,
-			),
-		).toBe(false);
-	});
-});
-
-describe("isAuthorizedBrowserToDesktopRequest", () => {
-	it("allows safe public GET routes without an origin", () => {
-		expect(
-			isAuthorizedBrowserToDesktopRequest(
-				new Request("http://127.0.0.1:8787/public"),
-				new URL("http://127.0.0.1:8787/public"),
-				defaultOptions,
-				publicRoute,
-			),
-		).toBe(true);
-	});
-
-	it("rejects future WebSocket paths from untrusted origins by default", () => {
-		expect(
-			isAuthorizedBrowserToDesktopRequest(
-				new Request("http://127.0.0.1:8787/future-socket", {
-					headers: {
-						host: "127.0.0.1:8787",
-						origin: "http://evil.attacker.example.com",
-						upgrade: "websocket",
-					},
-				}),
-				new URL("http://127.0.0.1:8787/future-socket"),
-				defaultOptions,
-				publicRoute,
-			),
-		).toBe(false);
-	});
-
-	it("rejects future unsafe HTTP routes from untrusted origins by default", () => {
-		expect(
-			isAuthorizedBrowserToDesktopRequest(
-				new Request("http://127.0.0.1:8787/future-api", {
-					method: "POST",
-					headers: {
-						host: "127.0.0.1:8787",
-						origin: "http://evil.attacker.example.com",
-					},
-				}),
-				new URL("http://127.0.0.1:8787/future-api"),
-				defaultOptions,
-				publicRoute,
-			),
-		).toBe(false);
-	});
-
-	it("allows future unsafe HTTP routes from trusted origins", () => {
-		expect(
-			isAuthorizedBrowserToDesktopRequest(
-				new Request("http://127.0.0.1:8787/future-api", {
-					method: "POST",
-					headers: {
-						host: "127.0.0.1:8787",
-						origin: "http://127.0.0.1:8787",
-					},
-				}),
-				new URL("http://127.0.0.1:8787/future-api"),
-				defaultOptions,
-				publicRoute,
-			),
-		).toBe(true);
-	});
-});

apps/cline-hub/src/server/browser-auth.ts

@@ -1,134 +0,0 @@
-import { isNonLocalBindHost } from "../options";
-
-export interface BrowserRequestAuthOptions {
-	bindHost: string;
-	port: number;
-	publicUrl: string;
-	roomSecret?: string;
-}
-
-const SAFE_HTTP_METHODS = new Set(["GET", "HEAD", "OPTIONS"]);
-
-export type PublicBrowserRoutePredicate = (req: Request, url: URL) => boolean;
-
-function isWebSocketUpgrade(req: Request): boolean {
-	return req.headers.get("upgrade")?.toLowerCase() === "websocket";
-}
-
-function parseOrigin(value: string | null): string | undefined {
-	const origin = parseHeader(value);
-	try {
-		return new URL(origin ?? "").origin;
-	} catch {
-		return undefined;
-	}
-}
-
-function parseHeader(value: string | null): string | undefined {
-	const host = value?.trim().toLowerCase();
-	return host || undefined;
-}
-
-function formatHostForOrigin(host: string): string {
-	return host.includes(":") && !host.startsWith("[") ? `[${host}]` : host;
-}
-
-function isDefaultProtocolPort(protocol: string, port: number): boolean {
-	return (
-		(protocol === "http:" && port === 80) ||
-		(protocol === "https:" && port === 443)
-	);
-}
-
-function originForHost(protocol: string, host: string, port: number): string {
-	return new URL(`${protocol}//${formatHostForOrigin(host)}:${port}`).origin;
-}
-
-function hostHeaderForHost(
-	protocol: string,
-	host: string,
-	port: number,
-): string {
-	const formattedHost = formatHostForOrigin(host).toLowerCase();
-	return isDefaultProtocolPort(protocol, port)
-		? formattedHost
-		: `${formattedHost}:${port}`;
-}
-
-export function allowedBrowserOrigins({
-	bindHost,
-	port,
-	publicUrl,
-}: BrowserRequestAuthOptions): Set<string> {
-	const publicUrlParts = new URL(publicUrl);
-	const origins = new Set<string>();
-	origins.add(publicUrlParts.origin);
-
-	origins.add(originForHost(publicUrlParts.protocol, bindHost, port));
-
-	if (!isNonLocalBindHost(bindHost)) {
-		for (const hostname of ["127.0.0.1", "localhost", "[::1]"]) {
-			origins.add(originForHost(publicUrlParts.protocol, hostname, port));
-		}
-	}
-
-	return origins;
-}
-
-export function allowedBrowserHosts({
-	bindHost,
-	port,
-	publicUrl,
-}: BrowserRequestAuthOptions): Set<string> {
-	const publicUrlParts = new URL(publicUrl);
-	const hosts = new Set<string>();
-	const publicHost = publicUrlParts.host.toLowerCase();
-	hosts.add(publicHost);
-
-	hosts.add(hostHeaderForHost(publicUrlParts.protocol, bindHost, port));
-
-	if (!isNonLocalBindHost(bindHost)) {
-		for (const hostname of ["127.0.0.1", "localhost", "[::1]"]) {
-			hosts.add(hostHeaderForHost(publicUrlParts.protocol, hostname, port));
-		}
-	}
-
-	return hosts;
-}
-
-export function requiresBrowserRequestAuth(
-	req: Request,
-	url: URL,
-	isPublicBrowserRoute: PublicBrowserRoutePredicate,
-): boolean {
-	if (isWebSocketUpgrade(req)) return true;
-	if (!SAFE_HTTP_METHODS.has(req.method.toUpperCase())) return true;
-	return !isPublicBrowserRoute(req, url);
-}
-
-export function isAuthorizedBrowserRequest(
-	req: Request,
-	url: URL,
-	options: BrowserRequestAuthOptions,
-): boolean {
-	const host = parseHeader(req.headers.get("host"));
-	if (!host || !allowedBrowserHosts(options).has(host)) return false;
-
-	const origin = parseOrigin(req.headers.get("origin"));
-	if (!origin || !allowedBrowserOrigins(options).has(origin)) return false;
-
-	if (!options.roomSecret) return true;
-	return url.searchParams.get("roomSecret") === options.roomSecret;
-}
-
-export function isAuthorizedBrowserToDesktopRequest(
-	req: Request,
-	url: URL,
-	options: BrowserRequestAuthOptions,
-	isPublicBrowserRoute: PublicBrowserRoutePredicate,
-): boolean {
-	return (
-		!requiresBrowserRequestAuth(req, url, isPublicBrowserRoute) ||
-		isAuthorizedBrowserRequest(req, url, options)
-	);
-}

apps/cline-hub/src/server/connectors.test.ts

@@ -1,97 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { __test__ } from "./connectors";
-
-describe("connector launch command", () => {
-	it("uses Bun conditions when launching the source CLI from Bun", () => {
-		expect(
-			__test__.buildCliConnectCommand(["telegram", "--bot-token", "token"], {
-				execPath: "/Users/test/.bun/bin/bun",
-				cliPath: "/repo/apps/cli/src/index.ts",
-				exists: () => true,
-			}),
-		).toEqual({
-			launcher: "/Users/test/.bun/bin/bun",
-			childArgs: [
-				"--conditions=development",
-				"/repo/apps/cli/src/index.ts",
-				"connect",
-				"telegram",
-				"--bot-token",
-				"token",
-			],
-		});
-	});
-
-	it("uses compiled CLI subcommands without Bun flags", () => {
-		expect(
-			__test__.buildCliConnectCommand(["telegram", "--bot-token", "token"], {
-				execPath: "/Applications/Cline/bin/cline",
-				cliPath: "/repo/apps/cli/src/index.ts",
-				exists: () => true,
-			}),
-		).toEqual({
-			launcher: "/Applications/Cline/bin/cline",
-			childArgs: ["connect", "telegram", "--bot-token", "token"],
-		});
-	});
-
-	it("uses Bun conditions when launching the source CLI from Node", () => {
-		expect(
-			__test__.buildCliConnectCommand(["telegram", "--bot-token", "token"], {
-				execPath: "/usr/local/bin/node",
-				cliPath: "/repo/apps/cli/src/index.ts",
-				exists: () => true,
-			}),
-		).toEqual({
-			launcher: "bun",
-			childArgs: [
-				"--conditions=development",
-				"/repo/apps/cli/src/index.ts",
-				"connect",
-				"telegram",
-				"--bot-token",
-				"token",
-			],
-		});
-	});
-
-	it("detects Windows Node when launching the source CLI", () => {
-		expect(
-			__test__.buildCliConnectCommand(["telegram", "--bot-token", "token"], {
-				execPath: "node.exe",
-				cliPath: "C:\\repo\\apps\\cli\\src\\index.ts",
-				exists: () => true,
-			}),
-		).toEqual({
-			launcher: "bun",
-			childArgs: [
-				"--conditions=development",
-				"C:\\repo\\apps\\cli\\src\\index.ts",
-				"connect",
-				"telegram",
-				"--bot-token",
-				"token",
-			],
-		});
-	});
-
-	it("strips terminal color codes from connector command failures", () => {
-		expect(
-			__test__.normalizeConnectorError(
-				"\u001B[31merror:\u001B[0m error: unknown option '--conditions=development'",
-				"connector start failed",
-			),
-		).toBe("unknown option '--conditions=development'");
-	});
-
-	it("turns Telegram unauthorized responses into a token validation message", () => {
-		expect(
-			__test__.normalizeConnectorError(
-				"\u001B[31merror:\u001B[0m Telegram getMe failed (401 Unauthorized): Unauthorized",
-				"connector start failed",
-			),
-		).toBe(
-			"Telegram rejected this bot token. Copy the token from @BotFather and try again.",
-		);
-	});
-});

apps/cline-hub/src/server/connectors.ts

@@ -1,8 +1,5 @@
 import { spawn } from "node:child_process";
-import { existsSync } from "node:fs";
-import { basename } from "node:path";
 import process from "node:process";
-import { withResolvedClineBuildEnv } from "@cline/shared";
 import { listConnectorCatalog } from "../../../cli/src/connectors/catalog";
 import { listActiveConnectors } from "../../../cli/src/connectors/status";
 import {
@@ -16,68 +13,6 @@ import type {
 import { cliIndexPath, workspaceRoot } from "./deps";
 import { asRecord, asString } from "./utils";
 
-type CliConnectCommand = {
-	launcher: string;
-	childArgs: string[];
-};
-
-const ANSI_ESCAPE_PATTERN = new RegExp(
-	[
-		"[\\u001B\\u009B][[\\]()#;?]*",
-		"(?:(?:(?:[a-zA-Z\\d]*(?:;[a-zA-Z\\d]*)*)?\\u0007)",
-		"|(?:(?:\\d{1,4}(?:;\\d{0,4})*)?[\\dA-PR-TZcf-nq-uy=><~]))",
-	].join(""),
-	"g",
-);
-
-function stripAnsi(value: string): string {
-	return value.replace(ANSI_ESCAPE_PATTERN, "");
-}
-
-function normalizeConnectorError(rawMessage: string, fallback: string): string {
-	const message =
-		stripAnsi(rawMessage)
-			.replace(/\r\n/g, "\n")
-			.trim()
-			.replace(/^(?:error:\s*)+/i, "")
-			.trim() || fallback;
-
-	if (
-		/^Telegram getMe failed \(401 Unauthorized\): Unauthorized$/i.test(message)
-	) {
-		return "Telegram rejected this bot token. Copy the token from @BotFather and try again.";
-	}
-
-	return message.slice(0, 2_000);
-}
-
-function buildCliConnectCommand(
-	args: string[],
-	options: {
-		execPath?: string;
-		cliPath?: string;
-		exists?: (path: string) => boolean;
-	} = {},
-): CliConnectCommand {
-	const execPath = options.execPath ?? process.execPath;
-	const cliPath = options.cliPath ?? cliIndexPath;
-	const exists = options.exists ?? existsSync;
-	const runtimeName = basename(execPath).toLowerCase();
-	const isBunRuntime = runtimeName.includes("bun");
-	const isNodeRuntime = runtimeName === "node" || runtimeName === "node.exe";
-	const useBunSourceEntrypoint =
-		(isBunRuntime || isNodeRuntime) && exists(cliPath);
-	const launcher = isBunRuntime
-		? execPath
-		: useBunSourceEntrypoint
-			? "bun"
-			: execPath;
-	const childArgs = useBunSourceEntrypoint
-		? ["--conditions=development", cliPath, "connect", ...args]
-		: ["connect", ...args];
-	return { launcher, childArgs };
-}
-
 export function connectorChannelsPayload(): WebviewConnectorChannelsResponse {
 	const supported = new Set(
 		listConnectorCatalog().map((connector) => connector.name),
@@ -120,14 +55,23 @@ async function runCliConnectCommand(args: string[]): Promise<{
 	stdout: string;
 	stderr: string;
 }> {
-	const { launcher, childArgs } = buildCliConnectCommand(args);
-	const child = spawn(launcher, childArgs, {
-		cwd: workspaceRoot,
-		env: withResolvedClineBuildEnv(process.env),
-		stdio: ["ignore", "pipe", "pipe"],
-		// Prevent a console window from flashing on Windows.
-		windowsHide: true,
-	});
+	const launcher = (process.versions as Record<string, string | undefined>).bun
+		? process.execPath
+		: "bun";
+	const child = spawn(
+		launcher,
+		["--conditions=development", cliIndexPath, "connect", ...args],
+		{
+			cwd: workspaceRoot,
+			env: {
+				...process.env,
+				CLINE_BUILD_ENV: process.env.CLINE_BUILD_ENV ?? "development",
+			},
+			stdio: ["ignore", "pipe", "pipe"],
+			// Prevent a console window from flashing on Windows.
+			windowsHide: true,
+		},
+	);
 	let stdout = "";
 	let stderr = "";
 	child.stdout?.setEncoding("utf8");
@@ -213,10 +157,9 @@ export async function startConnectorChannel(
 	const result = await runCliConnectCommand(cliArgs);
 	if (result.code !== 0) {
 		throw new Error(
-			normalizeConnectorError(
-				result.stderr || result.stdout,
-				"connector start failed",
-			),
+			(result.stderr.trim() || result.stdout.trim() || "connector start failed")
+				.trim()
+				.slice(0, 2_000),
 		);
 	}
 	await waitForConnectorState(() =>
@@ -225,11 +168,6 @@ export async function startConnectorChannel(
 	return connectorChannelsPayload();
 }
 
-export const __test__ = {
-	buildCliConnectCommand,
-	normalizeConnectorError,
-};
-
 export async function stopConnectorChannel(
 	args?: Record<string, unknown>,
 ): Promise<WebviewConnectorChannelsResponse> {
@@ -244,10 +182,9 @@ export async function stopConnectorChannel(
 	const result = await runCliConnectCommand([channel, "--stop"]);
 	if (result.code !== 0) {
 		throw new Error(
-			normalizeConnectorError(
-				result.stderr || result.stdout,
-				"connector stop failed",
-			),
+			(result.stderr.trim() || result.stdout.trim() || "connector stop failed")
+				.trim()
+				.slice(0, 2_000),
 		);
 	}
 	await waitForConnectorState(

apps/cline-hub/src/server/desktop-commands.ts

@@ -4,20 +4,15 @@ import {
 	ClineAccountService,
 	ensureCustomProvidersLoaded,
 	executeClineAccountAction,
-	formatProviderOAuthApiKey,
 	getLocalProviderModels,
-	getPersistedProviderApiKey,
-	getProviderOAuthCredentialsFromSettings,
-	getValidClineCredentials,
 	listLocalProviders,
 	loginAndSaveLocalProviderOAuthCredentials,
 	normalizeOAuthProvider,
 	type ProviderCapability,
 	type ProviderClient,
 	type ProviderProtocol,
-	type ProviderSettings,
 	readGlobalSettings,
-	saveLocalProviderOAuthCredentials,
+	resolveLocalClineAuthToken,
 	saveLocalProviderSettings,
 	setAutoUpdateEnabledGlobally,
 	setDisabledPlugin,
@@ -32,12 +27,6 @@ import {
 	stopConnectorChannel,
 } from "./connectors";
 import { providerSettingsManager, workspaceRoot } from "./deps";
-import {
-	installMarketplaceEntryForDesktopCommand,
-	listMarketplaceInstalledEntries,
-	uninstallLocalPrimitive,
-	uninstallMarketplaceEntryForDesktopCommand,
-} from "./marketplace";
 import {
 	deleteMcpServer,
 	ensureMcpSettingsFile,
@@ -63,39 +52,6 @@ const ROUTINE_SCHEDULE_COMMANDS = new Set([
 	"delete_routine_schedule",
 ]);
 
-async function resolveHubClineAccountAuthToken(input: {
-	settings?: ProviderSettings;
-	apiBaseUrl: string;
-}): Promise<string | undefined> {
-	const credentials = input.settings
-		? getProviderOAuthCredentialsFromSettings("cline", input.settings)
-		: null;
-	if (!credentials || !input.settings) {
-		return getPersistedProviderApiKey("cline", input.settings);
-	}
-
-	const nextCredentials = await getValidClineCredentials(credentials, {
-		apiBaseUrl: input.apiBaseUrl,
-	});
-	if (!nextCredentials) {
-		throw new Error(
-			"Cline account requires re-authentication. Run cline auth cline.",
-		);
-	}
-
-	if (nextCredentials !== credentials) {
-		saveLocalProviderOAuthCredentials(
-			providerSettingsManager,
-			"cline",
-			input.settings,
-			nextCredentials,
-			{ setLastUsed: false },
-		);
-	}
-
-	return formatProviderOAuthApiKey("cline", nextCredentials);
-}
-
 export async function handleDesktopCommand(
 	ctx: HubContext,
 	command: string,
@@ -172,18 +128,10 @@ export async function handleDesktopCommand(
 	}
 	if (command === "cline_account") {
 		const settings = providerSettingsManager.getProviderSettings("cline");
-		const apiBaseUrl =
-			settings?.baseUrl?.trim() || getClineEnvironmentConfig().apiBaseUrl;
-		const authToken = await resolveHubClineAccountAuthToken({
-			settings,
-			apiBaseUrl,
-		});
-		if (!authToken) {
-			throw new Error("No Cline account auth token found");
-		}
 		const accountService = new ClineAccountService({
-			apiBaseUrl,
-			getAuthToken: async () => authToken,
+			apiBaseUrl:
+				settings?.baseUrl?.trim() || getClineEnvironmentConfig().apiBaseUrl,
+			getAuthToken: async () => resolveLocalClineAuthToken(settings),
 		});
 		return await executeClineAccountAction(
 			args as ClineAccountActionRequest,
@@ -265,27 +213,6 @@ export async function handleDesktopCommand(
 	if (command === "list_user_instruction_configs") {
 		return await listUserInstructionConfigs(workspaceRoot);
 	}
-	if (command === "list_marketplace_installed_entries") {
-		return listMarketplaceInstalledEntries(
-			args,
-			await listUserInstructionConfigs(workspaceRoot),
-		);
-	}
-	if (command === "install_marketplace_entry") {
-		const result = await installMarketplaceEntryForDesktopCommand(args);
-		broadcastHubState(ctx);
-		return result;
-	}
-	if (command === "uninstall_marketplace_entry") {
-		const result = await uninstallMarketplaceEntryForDesktopCommand(args);
-		broadcastHubState(ctx);
-		return result;
-	}
-	if (command === "uninstall_local_primitive") {
-		const result = await uninstallLocalPrimitive(args, { workspaceRoot });
-		broadcastHubState(ctx);
-		return result;
-	}
 	if (command === "toggle_disabled_plugin_tool") {
 		const toolName = String(args?.name ?? "").trim();
 		if (!toolName) throw new Error("tool name is required");

apps/cline-hub/src/server/http.test.ts

@@ -1,54 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { isWebviewRoute, normalizeWebviewIndexHtml } from "./http";
-
-describe("isWebviewRoute", () => {
-	it.each([
-		"/",
-		"/chat",
-		"/sessions",
-		"/models",
-		"/customizations",
-		"/rules",
-		"/hooks",
-		"/mcp",
-		"/plugins",
-		"/skills",
-		"/agents",
-		"/tools",
-		"/marketplace",
-		"/marketplace/mcp",
-		"/marketplace/skills",
-		"/marketplace/plugins",
-		"/channels",
-		"/schedules",
-		"/settings",
-		"/settings/providers",
-	])("matches dashboard SPA route %s", (pathname) => {
-		expect(isWebviewRoute(pathname)).toBe(true);
-	});
-
-	it("does not treat nested marketplace asset requests as SPA routes", () => {
-		expect(isWebviewRoute("/marketplace/assets/index.js")).toBe(false);
-	});
-});
-
-describe("normalizeWebviewIndexHtml", () => {
-	it("rewrites relative built asset URLs so deep links can refresh", () => {
-		expect(
-			normalizeWebviewIndexHtml(
-				'<script type="module" src="./assets/index.js"></script><link href="./assets/index.css">',
-			),
-		).toBe(
-			'<script type="module" src="/assets/index.js"></script><link href="/assets/index.css">',
-		);
-	});
-
-	it("injects the persisted theme bootstrap once", () => {
-		const normalized = normalizeWebviewIndexHtml(
-			"<html><head></head><body></body></html>",
-		);
-
-		expect(normalized).toContain('id="cline-hub-theme-bootstrap"');
-		expect(normalizeWebviewIndexHtml(normalized)).toBe(normalized);
-	});
-});

apps/cline-hub/src/server/http.ts

@@ -15,25 +15,6 @@ export function createTextResponse(text: string, status = 200): Response {
 	});
 }
 
-const NO_STORE_HEADERS = {
-	"cache-control": "no-store, no-cache, must-revalidate, proxy-revalidate",
-	pragma: "no-cache",
-	expires: "0",
-};
-
-const IMMUTABLE_ASSET_CACHE = "public, max-age=31536000, immutable";
-const THEME_BOOTSTRAP_SCRIPT = `<script id="cline-hub-theme-bootstrap">
-  (() => {
-    try {
-      const theme = window.localStorage.getItem("cline-hub-theme");
-      if (theme === "dark" || theme === "light") {
-        document.documentElement.classList.toggle("dark", theme === "dark");
-        document.documentElement.dataset.clineHubTheme = theme;
-      }
-    } catch {}
-  })();
-</script>`;
-
 function contentTypeFor(path: string): string {
 	switch (extname(path)) {
 		case ".html":
@@ -55,47 +36,20 @@ function contentTypeFor(path: string): string {
 	}
 }
 
-export function isWebviewRoute(pathname: string): boolean {
+function isWebviewRoute(pathname: string): boolean {
 	return (
 		pathname === "/" ||
 		pathname === "/index.html" ||
 		pathname === "/chat" ||
-		pathname === "/sessions" ||
-		pathname === "/models" ||
-		pathname === "/customizations" ||
-		pathname === "/rules" ||
-		pathname === "/hooks" ||
-		pathname === "/mcp" ||
-		pathname === "/plugins" ||
-		pathname === "/skills" ||
-		pathname === "/agents" ||
-		pathname === "/tools" ||
-		pathname === "/marketplace" ||
-		pathname === "/marketplace/mcp" ||
-		pathname === "/marketplace/skills" ||
-		pathname === "/marketplace/plugins" ||
-		pathname === "/channels" ||
-		pathname === "/schedules" ||
 		pathname === "/settings" ||
 		pathname.startsWith("/settings/")
 	);
 }
 
-export function normalizeWebviewIndexHtml(html: string): string {
-	const normalized = html
-		.replaceAll('src="./', 'src="/')
-		.replaceAll('href="./', 'href="/');
-	if (normalized.includes('id="cline-hub-theme-bootstrap"')) {
-		return normalized;
-	}
-	return normalized.replace("<head>", `<head>\n${THEME_BOOTSTRAP_SCRIPT}`);
-}
-
 function renderDevIndexHtml(devServerUrl: string): string {
 	return `<!doctype html>
 <html lang="en">
 <head>
-  ${THEME_BOOTSTRAP_SCRIPT}
   <meta charset="UTF-8" />
   <meta name="viewport" content="width=device-width, initial-scale=1.0" />
   <script type="module">
@@ -106,7 +60,7 @@ function renderDevIndexHtml(devServerUrl: string): string {
     window.__vite_plugin_react_preamble_installed__ = true;
   </script>
   <script type="module" src="${devServerUrl}/@vite/client"></script>
-  <link rel="icon" type="image/svg+xml" href="${devServerUrl}/cline-logo-filled.svg" />
+  <link rel="icon" type="image/svg+xml" href="${devServerUrl}/favicon.svg" />
   <title>Cline Hub</title>
 </head>
 <body>
@@ -120,14 +74,6 @@ function renderDevIndexHtml(devServerUrl: string): string {
 export class WebviewAssets {
 	constructor(private readonly webviewDistDir: string) {}
 
-	private async resolveCurrentMainAssetPath(): Promise<string | undefined> {
-		const indexFile = Bun.file(join(this.webviewDistDir, "index.html"));
-		if (!(await indexFile.exists())) return undefined;
-		const html = await indexFile.text();
-		const match = html.match(/src="\.\/(assets\/index-[^"]+\.js)"/);
-		return match?.[1] ? join(this.webviewDistDir, match[1]) : undefined;
-	}
-
 	private resolveStaticPath(pathname: string): string | undefined {
 		const decoded = decodeURIComponent(pathname);
 		const requested = decoded === "/" ? "/index.html" : decoded;
@@ -143,11 +89,8 @@ export class WebviewAssets {
 	private async serveIndex(): Promise<Response> {
 		const indexFile = Bun.file(join(this.webviewDistDir, "index.html"));
 		if (await indexFile.exists()) {
-			return new Response(normalizeWebviewIndexHtml(await indexFile.text()), {
-				headers: {
-					"content-type": "text/html; charset=utf-8",
-					...NO_STORE_HEADERS,
-				},
+			return new Response(indexFile, {
+				headers: { "content-type": "text/html; charset=utf-8" },
 			});
 		}
 		return createTextResponse(
@@ -160,10 +103,7 @@ export class WebviewAssets {
 		const devServerUrl = process.env.VITE_DEV_SERVER_URL?.trim();
 		if (devServerUrl && isWebviewRoute(pathname)) {
 			return new Response(renderDevIndexHtml(devServerUrl), {
-				headers: {
-					"content-type": "text/html; charset=utf-8",
-					...NO_STORE_HEADERS,
-				},
+				headers: { "content-type": "text/html; charset=utf-8" },
 			});
 		}
 		if (isWebviewRoute(pathname)) {
@@ -172,37 +112,12 @@ export class WebviewAssets {
 
 		const filePath = this.resolveStaticPath(pathname);
 		if (!filePath) return createTextResponse("not found", 404);
-		let responsePath = filePath;
-		let file = Bun.file(responsePath);
-		if (
-			!(await file.exists()) &&
-			/^\/assets\/index-[A-Za-z0-9_-]+\.js$/.test(pathname)
-		) {
-			const currentMainAssetPath = await this.resolveCurrentMainAssetPath();
-			if (currentMainAssetPath) {
-				responsePath = currentMainAssetPath;
-				file = Bun.file(responsePath);
-			}
-		}
+		const file = Bun.file(filePath);
 		if (!(await file.exists())) {
 			return createTextResponse("not found", 404);
 		}
-		const isHashedAsset = /^\/assets\/.+-[A-Za-z0-9_-]+\.[A-Za-z0-9]+$/.test(
-			pathname,
-		);
 		return new Response(file, {
-			headers: {
-				"content-type": contentTypeFor(responsePath),
-				"cache-control": isHashedAsset
-					? IMMUTABLE_ASSET_CACHE
-					: NO_STORE_HEADERS["cache-control"],
-				...(isHashedAsset
-					? {}
-					: {
-							pragma: NO_STORE_HEADERS.pragma,
-							expires: NO_STORE_HEADERS.expires,
-						}),
-			},
+			headers: { "content-type": contentTypeFor(filePath) },
 		});
 	}
 }

apps/cline-hub/src/server/marketplace.test.ts

@@ -1,870 +0,0 @@
-import { createHash } from "node:crypto";
-import {
-	existsSync,
-	mkdirSync,
-	mkdtempSync,
-	readFileSync,
-	rmSync,
-	writeFileSync,
-} from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { afterEach, describe, expect, it, vi } from "vitest";
-import {
-	buildMarketplaceMcpInput,
-	fetchMarketplaceCatalog,
-	installMarketplaceEntry,
-	installMarketplaceEntryForDesktopCommand,
-	listMarketplaceInstalledEntries,
-	uninstallLocalPrimitive,
-	uninstallMarketplaceEntry,
-	uninstallMarketplaceEntryForDesktopCommand,
-} from "./marketplace";
-
-describe("marketplace installer", () => {
-	const originalWrapperPath = process.env.CLINE_WRAPPER_PATH;
-	const originalClineDir = process.env.CLINE_DIR;
-	const originalHome = process.env.HOME;
-	const originalMcpSettingsPath = process.env.CLINE_MCP_SETTINGS_PATH;
-
-	afterEach(() => {
-		if (originalWrapperPath === undefined) {
-			delete process.env.CLINE_WRAPPER_PATH;
-		} else {
-			process.env.CLINE_WRAPPER_PATH = originalWrapperPath;
-		}
-		if (originalClineDir === undefined) {
-			delete process.env.CLINE_DIR;
-		} else {
-			process.env.CLINE_DIR = originalClineDir;
-		}
-		if (originalHome === undefined) {
-			delete process.env.HOME;
-		} else {
-			process.env.HOME = originalHome;
-		}
-		if (originalMcpSettingsPath === undefined) {
-			delete process.env.CLINE_MCP_SETTINGS_PATH;
-		} else {
-			process.env.CLINE_MCP_SETTINGS_PATH = originalMcpSettingsPath;
-		}
-		vi.restoreAllMocks();
-	});
-
-	it("maps remote MCP catalog args to the hub MCP upsert shape", () => {
-		expect(
-			buildMarketplaceMcpInput([
-				"context7",
-				"--transport",
-				"http",
-				"https://mcp.context7.com/mcp",
-			]),
-		).toEqual({
-			name: "context7",
-			transportType: "streamableHttp",
-			url: "https://mcp.context7.com/mcp",
-			disabled: false,
-		});
-	});
-
-	it("maps stdio MCP catalog args to command and args", () => {
-		expect(
-			buildMarketplaceMcpInput(["filesystem", "npx", "-y", "server", "/tmp"]),
-		).toEqual({
-			name: "filesystem",
-			transportType: "stdio",
-			command: "npx",
-			args: ["-y", "server", "/tmp"],
-			disabled: false,
-		});
-	});
-
-	it("preserves server flags after stdio MCP command args begin", () => {
-		expect(
-			buildMarketplaceMcpInput([
-				"search",
-				"npx",
-				"-y",
-				"server",
-				"--transport",
-				"stdio",
-			]),
-		).toEqual({
-			name: "search",
-			transportType: "stdio",
-			command: "npx",
-			args: ["-y", "server", "--transport", "stdio"],
-			disabled: false,
-		});
-	});
-
-	it("runs skills globally for Cline without prompts", async () => {
-		const homeDir = mkdtempSync(join(tmpdir(), "cline-marketplace-home-"));
-		process.env.HOME = homeDir;
-		const spawnCommand = vi.fn(async () => {
-			mkdirSync(join(homeDir, ".agents", "skills", "web-design-guidelines"), {
-				recursive: true,
-			});
-			writeFileSync(
-				join(homeDir, ".agents", "skills", "web-design-guidelines", "SKILL.md"),
-				"---\nname: web-design-guidelines\n---\n",
-			);
-			return {
-				exitCode: 0,
-				stdout: "installed",
-				stderr: "",
-			};
-		});
-
-		await installMarketplaceEntry(
-			{
-				entry: {
-					id: "web-design-guidelines",
-					type: "skill",
-					name: "Web Design Guidelines",
-					install: {
-						args: [
-							"vercel-labs/agent-skills",
-							"--skill",
-							"web-design-guidelines",
-						],
-					},
-				},
-			},
-			{ spawnCommand },
-		);
-
-		expect(spawnCommand).toHaveBeenCalledWith("npx", [
-			"-y",
-			"skills@latest",
-			"add",
-			"vercel-labs/agent-skills",
-			"--skill",
-			"web-design-guidelines",
-			"-g",
-			"-a",
-			"cline",
-			"-y",
-		]);
-	});
-
-	it("skips skill install commands when the global skill already exists", async () => {
-		const homeDir = mkdtempSync(join(tmpdir(), "cline-marketplace-home-"));
-		process.env.HOME = homeDir;
-		mkdirSync(join(homeDir, ".agents", "skills", "cline-sdk"), {
-			recursive: true,
-		});
-		writeFileSync(
-			join(homeDir, ".agents", "skills", "cline-sdk", "SKILL.md"),
-			"---\nname: cline-sdk\n---\n",
-		);
-		const spawnCommand = vi.fn(async () => ({
-			exitCode: 0,
-			stdout: "",
-			stderr: "",
-		}));
-
-		await expect(
-			installMarketplaceEntry(
-				{
-					entry: {
-						id: "cline-sdk",
-						type: "skill",
-						name: "Cline SDK",
-						install: { args: ["cline/sdk-skill"] },
-					},
-				},
-				{ spawnCommand },
-			),
-		).resolves.toMatchObject({
-			status: "installed",
-			message: "Cline SDK is already installed.",
-		});
-		expect(spawnCommand).not.toHaveBeenCalled();
-	});
-
-	it("reports Cline global skills as marketplace-installed", () => {
-		const clineDir = mkdtempSync(join(tmpdir(), "cline-marketplace-cline-"));
-		process.env.CLINE_DIR = clineDir;
-		mkdirSync(join(clineDir, "skills", "cline-sdk"), {
-			recursive: true,
-		});
-		writeFileSync(
-			join(clineDir, "skills", "cline-sdk", "SKILL.md"),
-			"---\nname: cline-sdk\n---\n",
-		);
-
-		expect(
-			listMarketplaceInstalledEntries({
-				entries: [
-					{
-						id: "cline-sdk",
-						type: "skill",
-						name: "Cline SDK",
-						install: { args: ["cline/sdk-skill"] },
-					},
-				],
-			}),
-		).toEqual({ installedKeys: ["skill:cline-sdk"] });
-	});
-
-	it("accepts skill installs that create Cline global skills", async () => {
-		const homeDir = mkdtempSync(join(tmpdir(), "cline-marketplace-home-"));
-		const clineDir = join(homeDir, ".cline");
-		process.env.HOME = homeDir;
-		process.env.CLINE_DIR = clineDir;
-		const spawnCommand = vi.fn(async () => {
-			mkdirSync(join(clineDir, "skills", "cline-sdk"), {
-				recursive: true,
-			});
-			writeFileSync(
-				join(clineDir, "skills", "cline-sdk", "SKILL.md"),
-				"---\nname: cline-sdk\n---\n",
-			);
-			return {
-				exitCode: 0,
-				stdout: "installed",
-				stderr: "",
-			};
-		});
-
-		await expect(
-			installMarketplaceEntry(
-				{
-					entry: {
-						id: "cline-sdk",
-						type: "skill",
-						name: "Cline SDK",
-						install: { args: ["cline/sdk-skill"] },
-					},
-				},
-				{ spawnCommand },
-			),
-		).resolves.toMatchObject({
-			status: "installed",
-			message: "Installed Cline SDK globally for Cline.",
-		});
-	});
-
-	it("removes Cline global marketplace skills without prompts", async () => {
-		const homeDir = mkdtempSync(join(tmpdir(), "cline-marketplace-home-"));
-		process.env.HOME = homeDir;
-		const skillDir = join(homeDir, ".agents", "skills", "cline-sdk");
-		mkdirSync(skillDir, { recursive: true });
-		writeFileSync(join(skillDir, "SKILL.md"), "---\nname: cline-sdk\n---\n");
-		const spawnCommand = vi.fn(async () => {
-			rmSync(skillDir, { recursive: true, force: true });
-			return {
-				exitCode: 0,
-				stdout: "removed",
-				stderr: "",
-			};
-		});
-
-		await expect(
-			uninstallMarketplaceEntry(
-				{
-					entry: {
-						id: "cline-sdk",
-						type: "skill",
-						name: "Cline SDK",
-						install: { args: ["cline/sdk-skill"] },
-					},
-				},
-				{ spawnCommand },
-			),
-		).resolves.toMatchObject({
-			status: "uninstalled",
-			message: "Uninstalled Cline SDK.",
-		});
-		expect(spawnCommand).toHaveBeenCalledWith("npx", [
-			"-y",
-			"skills@latest",
-			"remove",
-			"cline-sdk",
-			"-g",
-			"-a",
-			"cline",
-			"-y",
-		]);
-	});
-
-	it("does not report project-local skills as marketplace-installed globals", () => {
-		const homeDir = mkdtempSync(join(tmpdir(), "cline-marketplace-home-"));
-		process.env.HOME = homeDir;
-
-		expect(
-			listMarketplaceInstalledEntries(
-				{
-					entries: [
-						{
-							id: "cline-sdk",
-							type: "skill",
-							name: "Cline SDK",
-							install: { args: ["cline/sdk-skill"] },
-						},
-					],
-				},
-				{
-					skills: [
-						{
-							id: "cline-sdk",
-							name: "cline-sdk",
-							path: "/workspace/project/.agents/skills/cline-sdk/SKILL.md",
-						},
-					],
-				},
-			),
-		).toEqual({ installedKeys: [] });
-	});
-
-	it("rejects skill installs that exit zero but report failure", async () => {
-		const homeDir = mkdtempSync(join(tmpdir(), "cline-marketplace-home-"));
-		process.env.HOME = homeDir;
-		const spawnCommand = vi.fn(async () => ({
-			exitCode: 0,
-			stdout: "Failed to install 1",
-			stderr: "",
-		}));
-
-		await expect(
-			installMarketplaceEntry(
-				{
-					entry: {
-						id: "cline-sdk",
-						type: "skill",
-						name: "Cline SDK",
-						install: { args: ["cline/sdk-skill"] },
-					},
-				},
-				{ spawnCommand },
-			),
-		).rejects.toThrow("Skill install failed");
-	});
-
-	it("redacts common secret formats from failed install output", async () => {
-		const homeDir = mkdtempSync(join(tmpdir(), "cline-marketplace-home-"));
-		process.env.HOME = homeDir;
-		const spawnCommand = vi.fn(async () => ({
-			exitCode: 1,
-			stdout:
-				"Authorization: Bearer stdout-token\napi key stdout-key\nOPENAI_API_KEY=compound-key",
-			stderr:
-				"TOKEN=stderr-token\npassword is stderr-password\nANTHROPIC_SECRET_KEY=anthropic-secret",
-		}));
-
-		let message = "";
-		try {
-			await installMarketplaceEntry(
-				{
-					entry: {
-						id: "cline-sdk",
-						type: "skill",
-						name: "Cline SDK",
-						install: { args: ["cline/sdk-skill"] },
-					},
-				},
-				{ spawnCommand },
-			);
-		} catch (error) {
-			message = error instanceof Error ? error.message : String(error);
-		}
-
-		expect(message).toContain("Authorization: [redacted]");
-		expect(message).toContain("api key [redacted]");
-		expect(message).toContain("OPENAI_API_KEY=[redacted]");
-		expect(message).toContain("TOKEN=[redacted]");
-		expect(message).toContain("password is [redacted]");
-		expect(message).toContain("ANTHROPIC_SECRET_KEY=[redacted]");
-		expect(message).not.toContain("stdout-token");
-		expect(message).not.toContain("stdout-key");
-		expect(message).not.toContain("compound-key");
-		expect(message).not.toContain("stderr-token");
-		expect(message).not.toContain("stderr-password");
-		expect(message).not.toContain("anthropic-secret");
-	});
-
-	it("rejects skill installs before spawning when the global skill directory is not writable", async () => {
-		const homeDir = mkdtempSync(join(tmpdir(), "cline-marketplace-home-"));
-		process.env.HOME = homeDir;
-		mkdirSync(join(homeDir, ".agents"), { recursive: true });
-		writeFileSync(join(homeDir, ".agents", "skills"), "");
-		const spawnCommand = vi.fn(async () => ({
-			exitCode: 0,
-			stdout: "",
-			stderr: "",
-		}));
-
-		await expect(
-			installMarketplaceEntry(
-				{
-					entry: {
-						id: "cline-sdk",
-						type: "skill",
-						name: "Cline SDK",
-						install: { args: ["cline/sdk-skill"] },
-					},
-				},
-				{ spawnCommand },
-			),
-		).rejects.toThrow(
-			"Cannot install skill globally because ~/.agents/skills is not writable",
-		);
-		expect(spawnCommand).not.toHaveBeenCalled();
-	});
-
-	it("rejects skill installs that do not create a global skill", async () => {
-		const homeDir = mkdtempSync(join(tmpdir(), "cline-marketplace-home-"));
-		process.env.HOME = homeDir;
-		const spawnCommand = vi.fn(async () => ({
-			exitCode: 0,
-			stdout: "Installation complete",
-			stderr: "",
-		}));
-
-		await expect(
-			installMarketplaceEntry(
-				{
-					entry: {
-						id: "cline-sdk",
-						type: "skill",
-						name: "Cline SDK",
-						install: { args: ["cline/sdk-skill"] },
-					},
-				},
-				{ spawnCommand },
-			),
-		).rejects.toThrow("was not found in Cline's global skills directories");
-	});
-
-	it("runs official plugin installs through the current Cline CLI", async () => {
-		process.env.CLINE_WRAPPER_PATH = "/usr/local/bin/cline";
-		const spawnCommand = vi.fn(async () => ({
-			exitCode: 0,
-			stdout: JSON.stringify({ installPath: "/tmp/plugin" }),
-			stderr: "",
-		}));
-
-		await installMarketplaceEntry(
-			{
-				entry: {
-					id: "marketplace-test-plugin",
-					type: "plugin",
-					name: "Marketplace Test Plugin",
-					install: { args: ["marketplace-test-plugin"] },
-				},
-			},
-			{ spawnCommand },
-		);
-
-		expect(spawnCommand).toHaveBeenCalledWith("/usr/local/bin/cline", [
-			"plugin",
-			"install",
-			"marketplace-test-plugin",
-			"--json",
-		]);
-	});
-
-	it("runs official plugin uninstalls through the current Cline CLI", async () => {
-		process.env.CLINE_WRAPPER_PATH = "/usr/local/bin/cline";
-		const spawnCommand = vi.fn(async () => ({
-			exitCode: 0,
-			stdout: JSON.stringify({
-				name: "goal",
-				installPath: "/tmp/plugin",
-				removedPaths: ["/tmp/plugin"],
-				entryPaths: [],
-			}),
-			stderr: "",
-		}));
-
-		await expect(
-			uninstallMarketplaceEntry(
-				{
-					entry: {
-						id: "goal",
-						type: "plugin",
-						name: "Goal",
-						install: { args: ["goal"] },
-					},
-				},
-				{ spawnCommand },
-			),
-		).resolves.toMatchObject({
-			status: "uninstalled",
-			message: "Uninstalled Goal.",
-		});
-
-		expect(spawnCommand).toHaveBeenCalledWith("/usr/local/bin/cline", [
-			"plugin",
-			"uninstall",
-			"goal",
-			"--json",
-		]);
-	});
-
-	it("resolves desktop installs from the server catalog instead of browser-sent args", async () => {
-		process.env.CLINE_WRAPPER_PATH = "/usr/local/bin/cline";
-		const spawnCommand = vi.fn(async () => ({
-			exitCode: 0,
-			stdout: JSON.stringify({ installPath: "/tmp/plugin" }),
-			stderr: "",
-		}));
-
-		await installMarketplaceEntryForDesktopCommand(
-			{
-				entry: {
-					id: "marketplace-test-plugin",
-					type: "plugin",
-					name: "Tampered",
-					install: { args: ["malicious-source"] },
-				},
-			},
-			{
-				spawnCommand,
-				loadCatalog: async () => ({
-					entries: [
-						{
-							id: "marketplace-test-plugin",
-							type: "plugin",
-							name: "Marketplace Test Plugin",
-							install: { args: ["marketplace-test-plugin"] },
-						},
-					],
-				}),
-			},
-		);
-
-		expect(spawnCommand).toHaveBeenCalledWith("/usr/local/bin/cline", [
-			"plugin",
-			"install",
-			"marketplace-test-plugin",
-			"--json",
-		]);
-	});
-
-	it("resolves desktop uninstalls from the server catalog instead of browser-sent args", async () => {
-		process.env.CLINE_WRAPPER_PATH = "/usr/local/bin/cline";
-		const spawnCommand = vi.fn(async () => ({
-			exitCode: 0,
-			stdout: JSON.stringify({
-				name: "goal",
-				installPath: "/tmp/plugin",
-				removedPaths: ["/tmp/plugin"],
-				entryPaths: [],
-			}),
-			stderr: "",
-		}));
-
-		await uninstallMarketplaceEntryForDesktopCommand(
-			{
-				entry: {
-					id: "goal",
-					type: "plugin",
-					name: "Tampered",
-					install: { args: ["malicious-source"] },
-				},
-			},
-			{
-				spawnCommand,
-				loadCatalog: async () => ({
-					entries: [
-						{
-							id: "goal",
-							type: "plugin",
-							name: "Goal",
-							install: { args: ["goal"] },
-						},
-					],
-				}),
-			},
-		);
-
-		expect(spawnCommand).toHaveBeenCalledWith("/usr/local/bin/cline", [
-			"plugin",
-			"uninstall",
-			"goal",
-			"--json",
-		]);
-	});
-
-	it("uninstalls MCP marketplace entries from Cline MCP settings", async () => {
-		const settingsPath = join(
-			mkdtempSync(join(tmpdir(), "cline-marketplace-mcp-")),
-			"cline_mcp_settings.json",
-		);
-		process.env.CLINE_MCP_SETTINGS_PATH = settingsPath;
-		writeFileSync(
-			settingsPath,
-			JSON.stringify(
-				{
-					mcpServers: {
-						context7: {
-							transport: {
-								type: "streamableHttp",
-								url: "https://mcp.context7.com/mcp",
-							},
-						},
-					},
-				},
-				null,
-				2,
-			),
-		);
-
-		await expect(
-			uninstallMarketplaceEntry({
-				entry: {
-					id: "context7",
-					type: "mcp",
-					name: "Context7",
-					install: {
-						args: [
-							"context7",
-							"--transport",
-							"http",
-							"https://mcp.context7.com/mcp",
-						],
-					},
-				},
-			}),
-		).resolves.toMatchObject({
-			status: "uninstalled",
-			message: "Uninstalled Context7.",
-		});
-		expect(
-			listMarketplaceInstalledEntries({
-				entries: [
-					{
-						id: "context7",
-						type: "mcp",
-						name: "Context7",
-						install: {
-							args: [
-								"context7",
-								"--transport",
-								"http",
-								"https://mcp.context7.com/mcp",
-							],
-						},
-					},
-				],
-			}),
-		).toEqual({ installedKeys: [] });
-	});
-
-	it("uninstalls local MCP servers by name", async () => {
-		const settingsPath = join(
-			mkdtempSync(join(tmpdir(), "cline-local-mcp-")),
-			"cline_mcp_settings.json",
-		);
-		process.env.CLINE_MCP_SETTINGS_PATH = settingsPath;
-		writeFileSync(
-			settingsPath,
-			JSON.stringify(
-				{
-					mcpServers: {
-						context7: {
-							transport: {
-								type: "streamableHttp",
-								url: "https://mcp.context7.com/mcp",
-							},
-						},
-					},
-				},
-				null,
-				2,
-			),
-		);
-
-		await expect(
-			uninstallLocalPrimitive({
-				type: "mcp",
-				id: "context7",
-				name: "context7",
-			}),
-		).resolves.toMatchObject({
-			status: "uninstalled",
-			message: "Uninstalled context7.",
-		});
-		expect(readFileSync(settingsPath, "utf8")).not.toContain("context7");
-	});
-
-	it("uninstalls local skills by removing their configured skill directory", async () => {
-		const workspaceRoot = mkdtempSync(join(tmpdir(), "cline-local-skill-"));
-		const skillDir = join(workspaceRoot, ".cline", "skills", "review");
-		mkdirSync(skillDir, { recursive: true });
-		const skillPath = join(skillDir, "SKILL.md");
-		writeFileSync(skillPath, "---\nname: review\n---\nReview changes.");
-
-		await expect(
-			uninstallLocalPrimitive(
-				{
-					type: "skill",
-					id: "review",
-					name: "Review",
-					path: skillPath,
-				},
-				{ workspaceRoot },
-			),
-		).resolves.toMatchObject({
-			status: "uninstalled",
-			message: "Uninstalled Review.",
-		});
-		expect(existsSync(skillDir)).toBe(false);
-	});
-
-	it("reports official plugin marketplace entries installed from Cline home", () => {
-		const clineDir = mkdtempSync(join(tmpdir(), "cline-marketplace-test-"));
-		process.env.CLINE_DIR = clineDir;
-		const sourceKey =
-			"official:https://github.com/cline/plugins.git#plugins/goal";
-		const hash = createHash("sha256")
-			.update(sourceKey)
-			.digest("hex")
-			.slice(0, 12);
-		mkdirSync(
-			join(clineDir, "plugins", "_installed", "official", `goal-${hash}`),
-			{
-				recursive: true,
-			},
-		);
-
-		expect(
-			listMarketplaceInstalledEntries({
-				entries: [
-					{
-						id: "goal",
-						type: "plugin",
-						name: "Goal",
-						install: { args: ["goal"] },
-					},
-				],
-			}),
-		).toEqual({ installedKeys: ["plugin:goal"] });
-	});
-
-	it("does not report plugin inventory substring matches as installed", () => {
-		process.env.CLINE_DIR = mkdtempSync(
-			join(tmpdir(), "cline-marketplace-test-"),
-		);
-
-		expect(
-			listMarketplaceInstalledEntries(
-				{
-					entries: [
-						{
-							id: "goal",
-							type: "plugin",
-							name: "Goal",
-							install: { args: ["goal"] },
-						},
-					],
-				},
-				{
-					plugins: [
-						{
-							name: "goal-helper",
-							path: "/workspace/.cline/plugins/goal-helper/index.ts",
-						},
-					],
-				},
-			),
-		).toEqual({ installedKeys: [] });
-	});
-
-	it("skips invalid marketplace entries during installed-status checks", () => {
-		const clineDir = mkdtempSync(join(tmpdir(), "cline-marketplace-test-"));
-		process.env.CLINE_DIR = clineDir;
-		const sourceKey =
-			"official:https://github.com/cline/plugins.git#plugins/goal";
-		const hash = createHash("sha256")
-			.update(sourceKey)
-			.digest("hex")
-			.slice(0, 12);
-		mkdirSync(
-			join(clineDir, "plugins", "_installed", "official", `goal-${hash}`),
-			{
-				recursive: true,
-			},
-		);
-
-		expect(
-			listMarketplaceInstalledEntries({
-				entries: [
-					{
-						id: "broken-mcp",
-						type: "mcp",
-						name: "Broken MCP",
-						install: {
-							args: [
-								"broken-mcp",
-								"--transport",
-								"ws",
-								"https://example.com/mcp",
-							],
-						},
-					},
-					{
-						id: "goal",
-						type: "plugin",
-						name: "Goal",
-						install: { args: ["goal"] },
-					},
-				],
-			}),
-		).toEqual({ installedKeys: ["plugin:goal"] });
-	});
-
-	it("rejects invalid marketplace entries before spawning commands", async () => {
-		const spawnCommand = vi.fn(async () => ({
-			exitCode: 0,
-			stdout: "",
-			stderr: "",
-		}));
-
-		await expect(
-			installMarketplaceEntry(
-				{
-					entry: {
-						id: "bad",
-						type: "skill",
-						install: { args: [] },
-					},
-				},
-				{ spawnCommand },
-			),
-		).rejects.toThrow("marketplace install args are required");
-		expect(spawnCommand).not.toHaveBeenCalled();
-	});
-
-	it("fetches the marketplace catalog through the server helper", async () => {
-		const fetchImpl = vi.fn(async () => {
-			return new Response(JSON.stringify({ version: 1, entries: [] }), {
-				headers: { "content-type": "application/json" },
-			});
-		});
-
-		await expect(fetchMarketplaceCatalog(fetchImpl)).resolves.toEqual({
-			version: 1,
-			entries: [],
-		});
-		expect(fetchImpl).toHaveBeenCalledWith(
-			"https://cline.github.io/marketplace/catalog.json",
-			{ headers: { Accept: "application/json" } },
-		);
-	});
-
-	it("surfaces marketplace catalog upstream failures", async () => {
-		const fetchImpl = vi.fn(async () => {
-			return new Response("nope", {
-				status: 503,
-				statusText: "Service Unavailable",
-			});
-		});
-
-		await expect(fetchMarketplaceCatalog(fetchImpl)).rejects.toThrow(
-			"Failed to fetch marketplace catalog: 503 Service Unavailable",
-		);
-	});
-});

apps/cline-hub/src/server/mcp.ts

@@ -1,5 +1,5 @@
-import { existsSync, readFileSync } from "node:fs";
-import { updateMcpSettingsFileSync } from "@cline/core";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname } from "node:path";
 import { resolveMcpSettingsPath } from "@cline/shared/storage";
 import type { JsonRecord } from "./types";
 
@@ -65,9 +65,9 @@ export function readMcpServersResponse(): JsonRecord {
 }
 
 export function writeMcpServersMap(servers: JsonRecord): void {
-	updateMcpSettingsFileSync(resolveMcpSettingsPath(), (settings) => {
-		settings.mcpServers = servers;
-	});
+	const path = resolveMcpSettingsPath();
+	mkdirSync(dirname(path), { recursive: true });
+	writeFileSync(path, `${JSON.stringify({ mcpServers: servers }, null, 2)}\n`);
 }
 
 export function ensureMcpSettingsFile(): string {
@@ -78,21 +78,23 @@ export function ensureMcpSettingsFile(): string {
 	return path;
 }
 
+function readServersMap(): { path: string; servers: JsonRecord } {
+	const path = ensureMcpSettingsFile();
+	const parsed = JSON.parse(readFileSync(path, "utf8")) as JsonRecord;
+	return { path, servers: (parsed.mcpServers as JsonRecord | undefined) ?? {} };
+}
+
 export function setMcpServerDisabled(
 	name: string,
 	disabled: boolean,
 ): JsonRecord {
-	// Hold the cross-process lock across read-modify-write so a concurrent writer
-	// (the extension, the CLI) cannot clobber this change.
-	updateMcpSettingsFileSync(resolveMcpSettingsPath(), (settings) => {
-		const servers = ((settings.mcpServers as JsonRecord | undefined) ?? {}) as JsonRecord;
-		const current = servers[name];
-		if (!current || typeof current !== "object") {
-			throw new Error(`unknown MCP server: ${name}`);
-		}
-		servers[name] = { ...(current as JsonRecord), disabled };
-		settings.mcpServers = servers;
-	});
+	const { servers } = readServersMap();
+	const current = servers[name];
+	if (!current || typeof current !== "object") {
+		throw new Error(`unknown MCP server: ${name}`);
+	}
+	servers[name] = { ...(current as JsonRecord), disabled };
+	writeMcpServersMap(servers);
 	return readMcpServersResponse();
 }
 
@@ -125,27 +127,19 @@ export function upsertMcpServer(input: JsonRecord): JsonRecord {
 					},
 					disabled: input.disabled === true,
 				};
-	// Hold the cross-process lock across read-modify-write so a concurrent writer
-	// cannot clobber this upsert.
-	updateMcpSettingsFileSync(resolveMcpSettingsPath(), (settings) => {
-		const servers = ((settings.mcpServers as JsonRecord | undefined) ?? {}) as JsonRecord;
-		if (previousName && previousName !== name) {
-			delete servers[previousName];
-		}
-		servers[name] = next;
-		settings.mcpServers = servers;
-	});
+	const { servers } = readServersMap();
+	if (previousName && previousName !== name) {
+		delete servers[previousName];
+	}
+	servers[name] = next;
+	writeMcpServersMap(servers);
 	return readMcpServersResponse();
 }
 
 export function deleteMcpServer(name: string): JsonRecord {
 	if (!name) throw new Error("server name is required");
-	// Hold the cross-process lock across read-modify-write so a concurrent writer
-	// cannot resurrect the deleted server from a stale snapshot.
-	updateMcpSettingsFileSync(resolveMcpSettingsPath(), (settings) => {
-		const servers = ((settings.mcpServers as JsonRecord | undefined) ?? {}) as JsonRecord;
-		delete servers[name];
-		settings.mcpServers = servers;
-	});
+	const { servers } = readServersMap();
+	delete servers[name];
+	writeMcpServersMap(servers);
 	return readMcpServersResponse();
 }

apps/cline-hub/src/server/session-mapping.ts

@@ -235,7 +235,6 @@ export function toWebviewSessionSummary(
 		providerId: session.provider,
 		model: session.model,
 		workspaceRoot: session.workspaceRoot,
-		createdAt: session.createdAt,
 		updatedAt: session.updatedAt,
 		inputTokens: session.inputTokens,
 		outputTokens: session.outputTokens,

apps/cline-hub/src/server/user-instructions.test.ts

@@ -1,70 +0,0 @@
-import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { afterEach, describe, expect, it } from "vitest";
-import { listUserInstructionConfigs } from "./user-instructions";
-
-describe("listUserInstructionConfigs", () => {
-	const tempRoots: string[] = [];
-	const envSnapshot = {
-		CLINE_GLOBAL_SETTINGS_PATH: process.env.CLINE_GLOBAL_SETTINGS_PATH,
-		CLINE_MCP_SETTINGS_PATH: process.env.CLINE_MCP_SETTINGS_PATH,
-	};
-
-	afterEach(async () => {
-		if (envSnapshot.CLINE_GLOBAL_SETTINGS_PATH === undefined) {
-			delete process.env.CLINE_GLOBAL_SETTINGS_PATH;
-		} else {
-			process.env.CLINE_GLOBAL_SETTINGS_PATH =
-				envSnapshot.CLINE_GLOBAL_SETTINGS_PATH;
-		}
-		if (envSnapshot.CLINE_MCP_SETTINGS_PATH === undefined) {
-			delete process.env.CLINE_MCP_SETTINGS_PATH;
-		} else {
-			process.env.CLINE_MCP_SETTINGS_PATH = envSnapshot.CLINE_MCP_SETTINGS_PATH;
-		}
-		await Promise.all(
-			tempRoots.map((dir) => rm(dir, { recursive: true, force: true })),
-		);
-		tempRoots.length = 0;
-	});
-
-	it("uses the package name for package-backed plugin entries", async () => {
-		const tempRoot = await mkdtemp(join(tmpdir(), "cline-hub-config-"));
-		tempRoots.push(tempRoot);
-		process.env.CLINE_GLOBAL_SETTINGS_PATH = join(tempRoot, "settings.json");
-		process.env.CLINE_MCP_SETTINGS_PATH = join(tempRoot, "mcp.json");
-		const packageDir = join(
-			tempRoot,
-			".cline",
-			"plugins",
-			"_installed",
-			"git",
-			"github.com",
-			"demo",
-			"package",
-		);
-		await mkdir(packageDir, { recursive: true });
-		const pluginPath = join(packageDir, "index.ts");
-		await writeFile(
-			join(packageDir, "package.json"),
-			JSON.stringify(
-				{
-					name: "cline-sdk-portable-agents",
-					cline: {
-						plugins: [{ paths: ["./index.ts"] }],
-					},
-				},
-				null,
-				2,
-			),
-		);
-		await writeFile(pluginPath, "export default {};\n");
-
-		const data = await listUserInstructionConfigs(tempRoot);
-		const plugins = data.plugins as Array<{ name: string; path: string }>;
-		const plugin = plugins.find((item) => item.path === pluginPath);
-
-		expect(plugin?.name).toBe("cline-sdk-portable-agents");
-	});
-});

apps/cline-hub/src/server/user-instructions.ts

@@ -1,13 +1,5 @@
 import { existsSync, readdirSync, readFileSync } from "node:fs";
-import {
-	dirname,
-	extname,
-	isAbsolute,
-	join,
-	basename as pathBasename,
-	relative,
-	resolve,
-} from "node:path";
+import { extname, join, basename as pathBasename } from "node:path";
 import {
 	createUserInstructionConfigService,
 	discoverPluginModulePaths,
@@ -25,48 +17,6 @@ function resolveAgentConfigSearchPaths(workspaceRoot?: string): string[] {
 	return resolveSharedAgentConfigSearchPaths(workspaceRoot);
 }
 
-function readPackageName(packageJsonPath: string): string | undefined {
-	try {
-		const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf8")) as {
-			name?: unknown;
-		};
-		return typeof packageJson.name === "string" && packageJson.name.trim()
-			? packageJson.name.trim()
-			: undefined;
-	} catch {
-		return undefined;
-	}
-}
-
-function isPathWithin(parentPath: string, childPath: string): boolean {
-	const relativePath = relative(resolve(parentPath), resolve(childPath));
-	return (
-		relativePath === "" ||
-		(!relativePath.startsWith("..") && !isAbsolute(relativePath))
-	);
-}
-
-function getPluginDisplayName(filePath: string, searchRoot: string): string {
-	let current = dirname(filePath);
-	const root = resolve(searchRoot);
-	while (isPathWithin(root, current)) {
-		const packageJsonPath = join(current, "package.json");
-		if (existsSync(packageJsonPath)) {
-			const packageName = readPackageName(packageJsonPath);
-			if (packageName) {
-				return packageName;
-			}
-			break;
-		}
-		const parent = resolve(current, "..");
-		if (parent === current) {
-			break;
-		}
-		current = parent;
-	}
-	return pathBasename(filePath, extname(filePath));
-}
-
 export async function listUserInstructionConfigs(
 	targetWorkspaceRoot: string,
 ): Promise<JsonRecord> {
@@ -165,7 +115,7 @@ export async function listUserInstructionConfigs(
 				for (const filePath of discoverPluginModulePaths(directory)) {
 					if (pluginsByPath.has(filePath)) continue;
 					pluginsByPath.set(filePath, {
-						name: getPluginDisplayName(filePath, directory),
+						name: pathBasename(filePath, extname(filePath)),
 						path: filePath,
 						enabled: !disabledPlugins.has(filePath),
 					});

apps/cline-hub/src/validate-options.ts

@@ -41,23 +41,6 @@ expectEqual(
 	"invite URL",
 );
 
-const tailscale = resolveClineHubServerOptions({
-	HOST: "0.0.0.0",
-	CLINE_HUB_DASHBOARD_PORT: "8787",
-	PUBLIC_URL: "http://100.82.5.118",
-	ROOM_SECRET: "invite-123",
-});
-expectEqual(
-	tailscale.publicUrl,
-	"http://100.82.5.118:8787",
-	"direct IP public URL gets dashboard port",
-);
-expectEqual(
-	buildInviteUrl(tailscale.publicUrl, tailscale.roomSecret),
-	"http://100.82.5.118:8787/?roomSecret=invite-123",
-	"invite URL for direct IP public URL",
-);
-
 expectThrows(
 	() => resolveClineHubServerOptions({ HOST: "0.0.0.0" }),
 	"non-local bind without ROOM_SECRET",

apps/cline-hub/src/webview-protocol.ts

@@ -109,7 +109,6 @@ export type WebviewSessionSummary = {
 	providerId?: string;
 	model?: string;
 	workspaceRoot?: string;
-	createdAt?: number;
 	updatedAt?: number;
 	inputTokens?: number;
 	outputTokens?: number;