diff --git a/.dockerignore b/.dockerignore index 5d8bac48..38467081 100644 --- a/.dockerignore +++ b/.dockerignore @@ -38,7 +38,6 @@ backend/tests/ # Dev files *.md -!.opencode-version # Re-include legal manifests the runtime image must carry. Adding them # back here (after the ``*.md`` blanket) restores them to the build # context so the Dockerfile's ``COPY LICENSE`` / ``COPY NOTICE`` / diff --git a/.github/workflows/install-smoke.yml b/.github/workflows/install-smoke.yml index 3935a263..7db9445e 100644 --- a/.github/workflows/install-smoke.yml +++ b/.github/workflows/install-smoke.yml @@ -5,26 +5,22 @@ on: branches: [main] paths: - 'scripts/install-local.sh' - - 'scripts/install-opencode.sh' - 'scripts/install-scanners.sh' - 'scripts/build-tarball.sh' - 'cli/cliff_cli/daemon.py' - 'cli/cliff_cli/cli.py' - 'tests/install/smoke.sh' - - '.opencode-version' - '.scanner-versions' - '.github/workflows/install-smoke.yml' pull_request: branches: [main] paths: - 'scripts/install-local.sh' - - 'scripts/install-opencode.sh' - 'scripts/install-scanners.sh' - 'scripts/build-tarball.sh' - 'cli/cliff_cli/daemon.py' - 'cli/cliff_cli/cli.py' - 'tests/install/smoke.sh' - - '.opencode-version' - '.scanner-versions' - '.github/workflows/install-smoke.yml' workflow_dispatch: diff --git a/.gitignore b/.gitignore index facdee35..996d3802 100644 --- a/.gitignore +++ b/.gitignore @@ -225,7 +225,7 @@ frontend/storybook-static/ .eslintcache *.tsbuildinfo -# Go / OpenCode +# Scanner binaries (trivy, semgrep) bin/ # SQLite data diff --git a/.opencode-version b/.opencode-version deleted file mode 100644 index 1892b926..00000000 --- a/.opencode-version +++ /dev/null @@ -1 +0,0 @@ -1.3.2 diff --git a/.opencode/agents/security-orchestrator.md b/.opencode/agents/security-orchestrator.md deleted file mode 100644 index a429664d..00000000 --- a/.opencode/agents/security-orchestrator.md +++ /dev/null @@ -1,21 +0,0 @@ ---- -description: Security remediation workspace orchestrator -mode: primary ---- - -You are a cybersecurity remediation copilot. You help security teams take vulnerability findings from raw scanner output to validated, closed remediations. - -Your responsibilities: -- Understand vulnerability findings and their context -- Identify likely owners and affected systems -- Assess exposure and business impact -- Build remediation plans with clear steps -- Help draft and manage remediation tickets -- Validate that fixes actually resolve the vulnerability - -When responding: -- Be concise and actionable -- Cite evidence for your assessments -- Flag uncertainty clearly -- Suggest concrete next steps -- Structure output with clear headings and bullet points diff --git a/CLAUDE.md b/CLAUDE.md index 73335e4a..a958603b 100644 --- a/CLAUDE.md +++ b/CLAUDE.md @@ -6,7 +6,7 @@ This file provides guidance to Claude Code (claude.ai/code) when working with co Cliff is a self-hosted cybersecurity remediation copilot. It ingests vulnerability findings, enriches them with AI agents, and guides users through planning, ticketing, validating, and closing remediations — all from a chat-led web workspace. -Built on the [OpenCode](https://github.com/anomalyco/opencode) engine. Single-user community edition. AGPL-3.0 licensed. +Agents run in-process on [Pydantic AI](https://ai.pydantic.dev/) (ADR-0047). Single-user community edition. AGPL-3.0 licensed. > **Historical names — Cliff was called OpenSec, then briefly at `galanko/cliff`.** Until May 2026 this project was named "OpenSec" and lived at `github.com/galanko/OpenSec`. It was renamed to Cliff (briefly at `github.com/galanko/cliff`) and then transferred to a dedicated org at `github.com/cliff-security/cliff` in May 2026 (GitHub redirects from both old URLs). Any mention of "OpenSec", `galanko/OpenSec`, or `galanko/cliff` you encounter — in commit history, old branch names like `chore/cliff-os-restructure` referencing OpenSec snapshots, archived ADRs, third-party content, environment variables prefixed `OPENSEC_*`, Python modules named `opensec.*`, or the `cliff-os` private umbrella's pre-rename docs — refers to this same project. Treat all three as the same thing; the renames were cosmetic and organizational. @@ -27,12 +27,12 @@ When working on this codebase: |-------|-----------|----------| | Frontend | React + TypeScript + Vite + Tailwind | `frontend/` | | Backend | FastAPI (Python 3.11+) | `backend/` | -| AI Engine | OpenCode (Go) — binary dependency, pinned in `.opencode-version` | managed subprocess | -| Workspace Runtime | Per-workspace OpenCode processes with isolated context (ADR-0014) | `backend/cliff/workspace/`, `backend/cliff/engine/pool.py` | +| AI substrate | Pydantic AI — agents run in-process (ADR-0047) | `backend/cliff/agents/runtime/` | +| Workspace Runtime | Per-workspace isolated context directory (ADR-0014) | `backend/cliff/workspace/` | | Database | SQLite (single file) | `data/cliff.db` | | Deployment | Single Docker container, port 8000 | `docker/` | -See `cliff-os/docs/architecture/overview.md` (private) for the full system diagram and `cliff-os/docs/adr/0014-workspace-runtime-architecture.md` (private) for the workspace isolation architecture. +See `cliff-os/docs/architecture/overview.md` (private) for the full system diagram, `cliff-os/docs/adr/0047-pydantic-ai-substrate.md` (private) for the substrate, and `cliff-os/docs/adr/0014-workspace-runtime-architecture.md` (private) for the workspace isolation architecture. ## Design System: "Cyberdeck" @@ -65,10 +65,10 @@ backend/ FastAPI app (Python) cliff/ main.py App entry point, lifespan, CORS config.py Settings via env vars - engine/ OpenCode integration (process manager, HTTP client, process pool) - agents/ Agent template engine (Jinja2 templates for 6 agents) + agents/ Agent definitions + orchestration + runtime/ Pydantic AI agents, tools, provider factory (ADR-0047) workspace/ Workspace runtime (directory manager, context builder, agent run log) - api/routes/ REST endpoints (health, sessions, chat, workspace-scoped chat) + api/routes/ REST endpoints (health, findings, workspace, posture, …) frontend/ React SPA (TypeScript + Vite + Tailwind) src/ pages/ Page components (Issues, Workspace, Integrations, Settings) @@ -82,18 +82,15 @@ docker/ Dockerfile, docker-compose, supervisord config docs/ assets/ Public images: wordmark, badge, demo gif, screenshots (mirrored from cliff-os/docs/assets/ — see README there) -scripts/ dev.sh, install-opencode.sh +scripts/ dev.sh, install-scanners.sh fixtures/ Mock/demo data for adapters tests/ Cross-stack integration tests -.opencode/agents/ Custom OpenCode agent definitions -.opencode-version Pinned OpenCode version -opencode.json OpenCode project config ``` ## Key Domain Concepts - **Finding** — A vulnerability from a scanner. Flows through: `new` -> `triaged` -> `in_progress` -> `remediated` -> `validated` -> `closed` -- **Workspace** — A remediation session for one Finding. Each workspace gets an isolated directory (`data/workspaces//`) with finding-specific context, rendered agent templates, and its own OpenCode process +- **Workspace** — A remediation session for one Finding. Each workspace gets an isolated directory (`data/workspaces//`) with finding-specific context the in-process Pydantic AI agents read at run time - **AgentRun** — A single sub-agent execution (enricher, owner resolver, planner, etc.) - **SidebarState** — Persistent structured context per workspace (summary, evidence, owner, plan, ticket, validation) - **Adapter** — Interface to an external system. Four types: FindingSource, OwnershipContext, Ticketing, Validation @@ -139,9 +136,6 @@ cd backend && uv run uvicorn cliff.main:app --reload --port 8000 # Frontend only (needs backend running for API proxy) cd frontend && npm run dev -# Install OpenCode binary (auto-downloads pinned version) -scripts/install-opencode.sh - # Tests cd backend && uv run pytest cd frontend && npm test @@ -149,55 +143,30 @@ cd frontend && npm test ### How It Runs -1. FastAPI starts on port 8000 and launches a singleton OpenCode process on port 4096 (for health/settings) -2. When a user opens a workspace, a **per-workspace OpenCode process** starts on a port from range 4100-4199, with `cwd=data/workspaces//` (isolated context) -3. Vite dev server starts on port 5173 and proxies `/api/*` to FastAPI -4. Browser talks to Vite (5173) in dev, or FastAPI (8000) in production -5. All OpenCode communication goes through FastAPI — frontend never talks to OpenCode directly -6. Idle workspace processes are automatically stopped after 10 minutes (configurable via `CLIFF_WORKSPACE_IDLE_TIMEOUT_SECONDS`) +1. FastAPI starts on port 8000. There is no agent subprocess — agents run **in-process** via Pydantic AI (ADR-0047) +2. When a user opens a workspace, an isolated context directory is created at `data/workspaces//` (finding context + per-agent context sections the agents read at run time) +3. Each agent run builds a fresh Pydantic AI `Model` from the canonical AI provider state (`backend/cliff/agents/runtime/provider.py`) and calls `agent.run()` in-process +4. Vite dev server starts on port 5173 and proxies `/api/*` to FastAPI; browser talks to Vite (5173) in dev, or FastAPI (8000) in production ## Testing Every phase must have tests passing before it is considered complete. ```bash -# Unit tests only (fast, no external deps) +# Backend unit tests (fast, no external deps — agents use FunctionModel/TestModel) cd backend && uv run pytest -v -m 'not e2e' -# E2E tests (needs OpenCode binary + OPENAI_API_KEY) -cd backend && uv run pytest tests/e2e/ -v - -# All tests -cd backend && uv run pytest -v - # Lint cd backend && uv run ruff check cliff/ tests/ -``` - -### Unit tests (187, ~0.9s) -Mocked external dependencies — no real OpenCode needed: - -- `test_config.py` — Settings and path resolution -- `test_models.py` — Pydantic model validation -- `test_engine_client.py` — OpenCode HTTP client (mocked httpx) -- `test_engine_process.py` — Subprocess lifecycle -- `test_routes_*.py` — API endpoint behavior with mocked engine -- `test_workspace_dir.py` — Workspace directory manager (Layer 0, 29 tests) -- `test_agent_template_engine.py` — Agent template rendering (Layer 1, 18 tests) -- `test_context_builder.py` — Context builder orchestration (Layer 2, 13 tests) -- `test_process_pool.py` — Process pool with mocked subprocess (Layer 3, 15 tests) - -### E2E tests (25, ~50s) - -Real OpenCode subprocess + real LLM calls. Skipped automatically if OpenCode binary or API key is missing: +# Frontend +cd frontend && npm test && npx tsc --noEmit +``` -- `e2e/test_health_e2e.py` — Health with real engine -- `e2e/test_session_flow.py` — Session create/list/get -- `e2e/test_chat_flow.py` — Send message, verify round-trip -- `e2e/test_error_handling.py` — Error cases -- `e2e/test_settings_e2e.py` — Model/provider/API key management -- `e2e/test_process_pool_e2e.py` — Real per-workspace OpenCode processes (10 tests: concurrent workspaces, port exhaustion, crash recovery, idle cleanup) +Backend agent tests drive the Pydantic AI runtime with `FunctionModel` / +`TestModel`, so no real LLM or network is needed — except the live eval +(`tests/agents/test_plain_description_eval.py`), which is skipped unless an +`OPENAI_API_KEY` / `ANTHROPIC_API_KEY` is set. ## Git Workflow @@ -230,27 +199,25 @@ Each workspace gets an isolated environment. See `cliff-os/docs/adr/0014-workspa | Layer | Component | Status | |-------|-----------|--------| | 0 | `WorkspaceDirManager` — filesystem CRUD, CONTEXT.md generation | Complete | -| 1 | `AgentTemplateEngine` — Jinja2 templates for 6 agents | Complete | -| 2 | `WorkspaceContextBuilder` — orchestrates L0 + L1 + DB metadata | Complete | -| 3 | `WorkspaceProcessPool` — per-workspace OpenCode processes | Complete | -| 4 | API integration — workspace-scoped sessions, chat, context routes | Complete | +| 1 | `WorkspaceContextBuilder` — orchestrates the dir + finding context + DB metadata | Complete | +| 2 | Pydantic AI runtime (`agents/runtime/`) — in-process agents + tools (ADR-0047) | Complete | +| 3 | API integration — workspace-scoped agent-run + context routes | Complete | -Key files: `backend/cliff/workspace/`, `backend/cliff/engine/pool.py`, `backend/cliff/agents/` +Key files: `backend/cliff/workspace/`, `backend/cliff/agents/runtime/`, `backend/cliff/agents/executor.py` ## AI provider integration (ADR-0037, supersedes ADR-0036) -Cliff's AI provider key flows into per-workspace OpenCode subprocesses -via env vars at spawn time, plus a parallel push to OpenCode's `auth.json` -(both paths because OpenCode 1.3.x prefers `auth.json` on the outbound -request). Six supported providers: OpenRouter, Anthropic, OpenAI, Google, -Ollama, custom OpenAI-compatible. +Cliff's AI provider key is resolved at each agent run into the env the +Pydantic AI model factory (`agents/runtime/provider.py`) reads (ADR-0047). +Six supported providers: OpenRouter, Anthropic, OpenAI, Google, Ollama, +custom OpenAI-compatible. **One canonical state, derived everywhere else.** Provider + key live in `ai_integration` + `credential` vault entry. Active model is -`app_setting(key="model")`. Per-workspace `opencode.json` and the -singleton `opencode.json` are reconciled from these two at every save + -spawn. `CLIFF_AI_MODEL_OVERRIDE_*` env vars are a DEV/CI escape hatch -only — the UI picker is the canonical write path. +`app_setting(key="model")`. The lifespan warms an env + model cache from +these and refreshes it on every connect / disconnect / model change. +`CLIFF_AI_MODEL_OVERRIDE_*` env vars are a DEV/CI escape hatch only — the +UI picker is the canonical write path. **Three onboarding tiers (ADR-0035):** @@ -269,10 +236,10 @@ override via the picker in Settings. (Previously the OpenRouter default was `tencent/hy3-preview`; that was a single-upstream-provider model and broke under concurrent agent runs, so it was demoted to a picker option.) -**Drift detection.** `GET /api/integrations/ai/status` returns both the -canonical model and a live probe of OpenCode's `/config`. When they -disagree the Settings card shows a red banner with a one-click reconcile, -and `cliffsec status` reports `drifted: true` with both values. +**No drift signal.** With the substrate in-process there is no separate +engine config to drift from — `GET /api/integrations/ai/status` returns +the single canonical model. (The earlier live-probe-vs-canonical drift +banner was an OpenCode-era concern.) Key files: `backend/cliff/ai/`, `backend/cliff/api/routes/ai_integrations.py`, `frontend/src/components/ai-provider/`. User-facing guide: diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md index b0fa578a..86786fcb 100644 --- a/CONTRIBUTING.md +++ b/CONTRIBUTING.md @@ -11,9 +11,6 @@ Be respectful and constructive. We follow the [Contributor Covenant](https://www Prerequisites: Python 3.11+ with [`uv`](https://docs.astral.sh/uv/), Node.js 20+, and a clone of this repo. ```bash -# Install OpenCode binary (pinned in .opencode-version) -scripts/install-opencode.sh - # Install dependencies cd backend && uv sync cd ../frontend && npm install diff --git a/KNOWN_ISSUES.md b/KNOWN_ISSUES.md index 82eb69e2..cd3120e6 100644 --- a/KNOWN_ISSUES.md +++ b/KNOWN_ISSUES.md @@ -44,95 +44,6 @@ backend behaviour. --- -### SSE stream uses global event bus — no per-session filtering at source - -**Impact:** The OpenCode `/event` endpoint is a global stream. Our backend filters by `sessionID`, but still receives all events for all sessions. With many concurrent sessions this could become a bottleneck. - -**Workaround:** None needed for single-user MVP. Revisit if performance degrades. - -**Fix idea:** Check if OpenCode supports per-session event subscriptions. If not, add server-side event routing in the backend. - ---- - -### Old sessions accumulate in OpenCode with no cleanup - -**Impact:** Every "New Session" click creates a permanent session in OpenCode. There's no cleanup, expiry, or delete mechanism in our app. - -**Workaround:** Restart OpenCode to clear sessions. - -**Fix idea:** Add session delete API. Add session age/limit management. - ---- - -### Frontend SSE connection doesn't auto-reconnect after backend restart - -**Impact:** If the backend restarts while the frontend is open, the SSE stream dies silently. The user must refresh the page. - -**Workaround:** Refresh the browser after restarting the backend. - -**Fix idea:** Add reconnection logic in the EventSource handler with a status indicator. - ---- - -### Chat history lost on page refresh - -**Impact:** Messages are only in React state. Refreshing the page loses the conversation. The session still exists in OpenCode but we don't reload its messages. - -**Workaround:** Don't refresh while chatting. - -**Fix idea:** On session load, fetch message history from OpenCode's `GET /session/{id}` and populate the chat. - ---- - -### Send button stays disabled after an error - -**Impact:** If a message send fails or the model returns an error, the `sending` state may not reset properly, leaving the input disabled. - -**Workaround:** Click "New Session" to reset. - -**Fix idea:** Ensure all error paths in the SSE handler reset the `sending` state. - ---- - -### opencode.json model must use provider-qualified ID - -**Impact:** The model in `opencode.json` must be the full `provider/model-id` format (e.g., `openai/gpt-4.1-nano`). Short names like `gpt-4.1-nano` won't work. This is an OpenCode requirement but not obvious. - -**Workaround:** Always use the full qualified model ID. - -**Fix idea:** Document this clearly. Validate the model format in our config loader. Future Settings page should show a dropdown of available models. - ---- - -### opencode.json can drift from runtime config - -**Impact:** Model changes made via the Settings UI update OpenCode at runtime via `PUT /config`, but `opencode.json` must also be updated separately. If the write to the file fails silently, the next OpenCode restart will revert to the old model. - -**Workaround:** ConfigManager writes to both the API and the file, but check `opencode.json` if the model reverts after a restart. - -**Fix idea:** Add a startup check that compares `opencode.json` with the model stored in `app_setting` and reconciles if they differ. - ---- - -### API keys set via Settings are lost on OpenCode restart - -**Impact:** Keys set via `PUT /auth/{id}` only live in the OpenCode process memory. If OpenCode restarts (crash, deploy, manual restart), all keys are forgotten until our backend re-injects them. - -**Workaround:** Keys are persisted in the `app_setting` table and re-injected on startup via `restore_keys_to_engine()`. If keys stop working after a crash, restart the backend. - -**Fix idea:** Add a health-check hook that detects when OpenCode has restarted and automatically re-injects stored keys. - ---- - -### Provider catalog may overwhelm the Settings UI - -**Impact:** OpenCode supports 75+ providers. Showing all of them in the model selector or API key list can be noisy and hard to navigate. - -**Workaround:** The UI shows providers with valid auth first, then a "show all" toggle for the rest. - -**Fix idea:** Add a "favorites" or "pinned providers" feature so users can curate which providers appear by default. - ---- ## EXEC-0002 · Session D onboarding wizard (PR #58) @@ -212,7 +123,7 @@ Tracked here so nothing in the deferred list gets lost. Session G is the planned **Status:** Open — agent-layer fix tracked, not user-facing for now. -**Why this is here:** PR #163 reconciles `Finding.pr_url` from `AgentRun.structured_output` on close, which fixes the common drift case (executor completed, recorded `pr_url`, but the column was never written). It does NOT recover the rare case where the `remediation_executor` agent dies mid-stream (timeout, OpenCode crash, host pause) AFTER `gh pr create` succeeded on GitHub but BEFORE the agent emitted parseable structured output. In that path the AgentRun row is `status='failed'`, `structured_output=null`, sidebar untouched — the DB has no record that a PR was opened, even though one exists on GitHub. The QA-0001 fsevents incident (Q01 §B14, PR #6 on cliff-security/NodeGoat) sits exactly here. +**Why this is here:** PR #163 reconciles `Finding.pr_url` from `AgentRun.structured_output` on close, which fixes the common drift case (executor completed, recorded `pr_url`, but the column was never written). It does NOT recover the rare case where the `remediation_executor` agent dies mid-stream (timeout, host pause, worker crash) AFTER `gh pr create` succeeded on GitHub but BEFORE the agent emitted parseable structured output. In that path the AgentRun row is `status='failed'`, `structured_output=null`, sidebar untouched — the DB has no record that a PR was opened, even though one exists on GitHub. The QA-0001 fsevents incident (Q01 §B14, PR #6 on cliff-security/NodeGoat) sits exactly here. **Why not policy-fix it:** Blocking close with a 4XX would punish users for an agent reliability failure they can't act on from the UI. The fix belongs in the agent layer. diff --git a/NOTICE b/NOTICE index a122c517..9840029f 100644 --- a/NOTICE +++ b/NOTICE @@ -14,10 +14,6 @@ This product bundles or downloads the following third-party software at install time. Their license texts and any NOTICE files are reproduced or referenced in THIRD-PARTY-LICENSES.md. - - OpenCode (anomalyco/opencode) MIT - Downloaded by scripts/install-opencode.sh; baked into the Docker - image. Invoked as a subprocess. - - Trivy (aquasecurity/trivy) Apache-2.0 Downloaded by scripts/install-scanners.sh; baked into the Docker image. Invoked as a subprocess. LICENSE preserved per Apache §4(c); diff --git a/README.md b/README.md index 1516c4be..2ddb16b0 100644 --- a/README.md +++ b/README.md @@ -64,7 +64,7 @@ cliffsec start --detach Open [http://127.0.0.1:8000](http://127.0.0.1:8000) and paste your Anthropic or OpenAI key in Settings. -The installer fetches `uv`, a managed Python 3.11, the OpenCode binary, and the Trivy and Semgrep scanners. Prereqs: `git`, `curl`, and the [GitHub CLI](https://github.com/cli/cli#installation). If something doesn't run, `cliffsec doctor` will say why. +The installer fetches `uv`, a managed Python 3.11, and the Trivy and Semgrep scanners. Prereqs: `git`, `curl`, and the [GitHub CLI](https://github.com/cli/cli#installation). If something doesn't run, `cliffsec doctor` will say why. **Docker** — required on Windows, optional everywhere else. Prereqs: Docker 24+. @@ -120,7 +120,7 @@ The marketing site lives at [cliffsecurity.ai](https://cliffsecurity.ai). Cliff is licensed under [AGPL-3.0-only](LICENSE). Operating Cliff over a network for users other than yourself triggers AGPL §13 (corresponding-source disclosure); see [NOTICE](NOTICE) and [THIRD-PARTY-LICENSES.md](THIRD-PARTY-LICENSES.md). -Cliff bundles three third-party programs as subprocesses: [OpenCode](https://github.com/anomalyco/opencode) (MIT), [Trivy](https://github.com/aquasecurity/trivy) (Apache-2.0), and the [Semgrep CE](https://github.com/semgrep/semgrep) engine (LGPL-2.1). Their license texts ship alongside each binary in the install directory and are inventoried in [THIRD-PARTY-LICENSES.md](THIRD-PARTY-LICENSES.md). +Cliff bundles two third-party programs as subprocesses: [Trivy](https://github.com/aquasecurity/trivy) (Apache-2.0) and the [Semgrep CE](https://github.com/semgrep/semgrep) engine (LGPL-2.1). Their license texts ship alongside each binary in the install directory and are inventoried in [THIRD-PARTY-LICENSES.md](THIRD-PARTY-LICENSES.md). The AI agent runtime is [Pydantic AI](https://ai.pydantic.dev/), a Python dependency (see `backend/uv.lock`), not a bundled binary. The default scan invokes Semgrep's hosted **registry rule packs** `p/security-audit` and `p/owasp-top-ten`. Those rules are governed by the [Semgrep Rules License v1.0](https://semgrep.dev/legal/rules-license/) — source-available, separate from the LGPL-2.1 engine. They are free for **internal business use only**: not for SaaS, paid products, or products that compete with Semgrep. Teams considering a commercial deployment of Cliff should consult counsel before relying on these rule packs; [OpenGrep](https://github.com/opengrep/opengrep) is a license-clean drop-in alternative. diff --git a/ROADMAP.md b/ROADMAP.md index 8566b5e8..29359656 100644 --- a/ROADMAP.md +++ b/ROADMAP.md @@ -7,7 +7,7 @@ Lock the MVP boundaries before writing code. - [x] Define MVP scope (vulnerability remediation copilot, single-user, self-hosted) -- [x] Lock technical decisions (FastAPI, React+Vite, SQLite, OpenCode, Docker) +- [x] Lock technical decisions (FastAPI, React+Vite, SQLite, Pydantic AI, Docker) - [x] Create repository structure - [x] Write Architecture Decision Records (ADRs) - [x] Document domain model, adapter interfaces, and agent pipeline diff --git a/THIRD-PARTY-LICENSES.md b/THIRD-PARTY-LICENSES.md index 5a4ab17e..6d77909f 100644 --- a/THIRD-PARTY-LICENSES.md +++ b/THIRD-PARTY-LICENSES.md @@ -10,7 +10,7 @@ grouped by the surface where the dependency reaches Cliff. The inventory below is current as of release-tagging time. For the live state, see `backend/uv.lock`, `frontend/package.json` / -`frontend/node_modules/`, `.opencode-version`, and `.scanner-versions`. +`frontend/node_modules/`, and `.scanner-versions`. --- @@ -20,15 +20,6 @@ These programs are downloaded by Cliff's installer scripts and baked into the Docker image. Cliff invokes each one as a subprocess; nothing here is linked into the Python application process. -### OpenCode - -- **Project:** [anomalyco/opencode](https://github.com/anomalyco/opencode) -- **Version pinned:** see [`.opencode-version`](.opencode-version) (currently `1.3.2`) -- **License:** `MIT` -- **Installed by:** [`scripts/install-opencode.sh`](scripts/install-opencode.sh) -- **Bundle mechanism:** GitHub release archive extracted into `BIN_DIR`; the upstream `LICENSE` is preserved alongside the binary as `opencode.LICENSE`. -- **Cliff's obligation:** Reproduce the MIT copyright notice and license text alongside redistribution. Upstream text: . - ### Trivy - **Project:** [aquasecurity/trivy](https://github.com/aquasecurity/trivy) diff --git a/backend/cliff/agents/__init__.py b/backend/cliff/agents/__init__.py index 872f842a..c0d61926 100644 --- a/backend/cliff/agents/__init__.py +++ b/backend/cliff/agents/__init__.py @@ -1,9 +1,6 @@ -"""Agent template engine — Layer 1 of the workspace pipeline.""" +"""Agent orchestration package. -from cliff.agents.template_engine import AGENT_NAMES, AgentTemplateEngine, RenderedAgent - -__all__ = [ - "AGENT_NAMES", - "AgentTemplateEngine", - "RenderedAgent", -] +Agents run in-process via Pydantic AI (ADR-0047). See ``cliff.agents.runtime`` +for the per-agent definitions, ``executor`` for orchestration, and +``pipeline`` for the forward walk. +""" diff --git a/backend/cliff/agents/errors.py b/backend/cliff/agents/errors.py index f9fdf79c..7fec503f 100644 --- a/backend/cliff/agents/errors.py +++ b/backend/cliff/agents/errors.py @@ -12,7 +12,7 @@ class AgentTimeoutError(AgentExecutionError): class AgentProcessError(AgentExecutionError): - """The workspace's OpenCode process is unavailable or crashed.""" + """The agent run failed — the model call errored or returned no usable result.""" class AgentRateLimitError(AgentProcessError): diff --git a/backend/cliff/agents/executor.py b/backend/cliff/agents/executor.py index a980bceb..b6022a3a 100644 --- a/backend/cliff/agents/executor.py +++ b/backend/cliff/agents/executor.py @@ -1,9 +1,9 @@ """AgentExecutor — runs a single sub-agent end-to-end. The executor is the bridge between "user wants to run an agent" and -"agent results are persisted everywhere." It sends a prompt to the -workspace's OpenCode process, collects the response, parses it, and -persists results to context files, sidebar state, and the DB. +"agent results are persisted everywhere." It runs the agent in-process +via Pydantic AI (ADR-0047), then persists the structured output to +context files, sidebar state, and the DB. """ from __future__ import annotations @@ -75,7 +75,6 @@ import aiosqlite from pydantic_ai.models import Model - from cliff.engine.pool import WorkspaceProcessPool from cliff.workspace.context_builder import WorkspaceContextBuilder logger = logging.getLogger(__name__) @@ -98,12 +97,11 @@ # Provider rate-limit backoff (EF-B17) # --------------------------------------------------------------------------- # Upstream LLM providers (Anthropic, OpenRouter, OpenAI) start returning 429 -# when the workspace pool runs more than one concurrent agent. OpenCode wraps -# the upstream 429 into a ``session.error`` SSE event that surfaces to the -# executor as an ``AgentRateLimitError``. Under pool>=2 (the Wave-2 cap) -# this used to fail the run on the first throttle; we now retry with -# exponential backoff + jitter up to ``RATE_LIMIT_MAX_ATTEMPTS`` before -# terminating the run with status ``rate_limited``. +# under concurrent agent runs. Pydantic AI raises the upstream 429 as a +# ``ModelHTTPError``, which the executor classifies as an +# ``AgentRateLimitError``. Rather than fail the run on the first throttle we +# retry with exponential backoff + jitter up to ``RATE_LIMIT_MAX_ATTEMPTS`` +# before terminating the run with status ``rate_limited``. # # Tests monkey-patch these to 0.0 to avoid sleeping in unit suites. RATE_LIMIT_MAX_ATTEMPTS: int = 3 @@ -124,8 +122,8 @@ def _rate_limit_backoff_delay(attempt: int) -> float: # --------------------------------------------------------------------------- # Permission tier classification for tool-use approval. -# Keys are the "permission" field from OpenCode's permission.asked events. -# "auto" = grant immediately, "user" = surface to user for approval. +# Keys are the tool name the runtime tool functions raise on; the value is +# the tier: "auto" = grant immediately, "user" = surface to user for approval. # Unknown tools default to "user" (safe default). # --------------------------------------------------------------------------- @@ -138,108 +136,12 @@ def _rate_limit_backoff_delay(attempt: int) -> float: } # Agents that need tool access to do their job (e.g. git, gh CLI). -# Their bash/edit requests are classified per-command (see -# ``_classify_tool_request``) rather than blanket-approved. +# Their bash/edit requests are classified per-command at the tool boundary +# by ``cliff.agents.runtime.tools.permissions.classify_tool_request`` +# (the single source of truth for the deny/ask/auto safety policy) rather +# than blanket-approved. _TOOL_AGENT_TYPES: set[str] = {"remediation_executor"} -# Tool-request classification for the remediation_executor. Three tiers: -# "auto" — grant immediately (routine git/gh/build commands) -# "ask" — escalate to the user for approval (destructive-but-conceivable, -# or reaching outside the workspace) -# "deny" — reject immediately without asking (never legitimate for a -# remediation agent; denying gives the agent fast feedback -# instead of stalling on an approval that will never come) -# -# This is a denylist — defense-in-depth against a *confused* agent, layered -# on top of GIT_CEILING_DIRECTORIES and the hardened agent prompt. It is NOT -# a security boundary against a malicious agent; that needs process -# sandboxing (separate ADR). The remediation_executor's normal workflow -# (git clone/checkout/add/commit/push, gh pr create, build/test runners) -# matches none of these patterns and stays on the "auto" path. - -# Never legitimate — hard-deny, don't even ask. -_CATASTROPHIC_BASH: tuple[str, ...] = ( - ":(){", # fork bomb - "mkfs", - " dd ", - "sudo ", - "> /etc", - ">/etc", - "> /usr", - ">/usr", - "> /bin", - ">/bin", - "/etc/shadow", - "/etc/passwd", -) - -# Destructive or workspace-escaping, but conceivably part of a real fix — -# escalate to the user rather than hard-deny. (Per CEO: "removing a file -# requires asking for permission.") -_GATED_BASH: tuple[str, ...] = ( - "rm -", # rm -rf, rm -f, … - "rmdir", - "git reset --hard", - "git clean", - "git push --force", - "git push -f", - "chmod ", - "chown ", - "cd /", - "cd ~", - "$home", - "~/.ssh", - "~/.aws", - "~/.config", -) - - -def _is_pipe_to_shell(cmd: str) -> bool: - """``curl …`` / ``wget …`` are fine on their own; piped into a shell - they're remote code execution. Only the piped shape is dangerous.""" - fetches = ("curl ", "wget ") - shells = ("| sh", "|sh", "| bash", "|bash", "|sh ", "| sh ") - return any(f in cmd for f in fetches) and any(s in cmd for s in shells) - - -def _classify_tool_request(tool: str, patterns: list[str]) -> str: - """Return ``"auto"``, ``"ask"``, or ``"deny"`` for an executor tool call. - - - ``bash`` — ``deny`` for catastrophic commands, ``ask`` for - destructive-but-conceivable ones (rm, git reset --hard, …), - ``auto`` for everything else. - - ``edit`` — ``ask`` if the target path is absolute or climbs out of - the workspace via ``..``; otherwise ``auto``. - - ``external_directory`` — ``ask``. OpenCode raises this permission - precisely when a tool reaches *outside* the workspace cwd, so it is - the literal "the agent tried to leave the directory" signal. - - anything else / unparseable — ``ask`` (safe default). - """ - if tool == "external_directory": - return "ask" - - if tool == "bash": - cmd = " ".join(patterns).lower() if patterns else "" - if not cmd: - return "ask" # can't inspect it → don't blanket-approve - if _is_pipe_to_shell(cmd): - return "deny" - if any(bad in cmd for bad in _CATASTROPHIC_BASH): - return "deny" - if any(bad in cmd for bad in _GATED_BASH): - return "ask" - return "auto" - - if tool == "edit": - for path in patterns: - p = path.strip() - if p.startswith("/") or p.startswith("~") or "../" in p: - return "ask" - return "auto" - - # mcp, unknown tools - return "ask" - # Per-agent guidance appended to the prompt. Currently only the enricher, # whose ``references`` array is shipped verbatim into the evidence sidebar @@ -401,9 +303,9 @@ def _humanize_process_error(raw: str) -> str: """Map opaque ``AgentProcessError`` strings to actionable user-facing text. Most agent failures actually originate at the AI provider (OpenRouter, - Anthropic, OpenAI) and reach us through OpenCode as opaque "OpenCode - error: …" wrappers. We unwrap the common ones — insufficient credits, - rate limits, unauthorized — into short markdown the sidebar can render + Anthropic, OpenAI) and reach us as opaque Pydantic AI ``ModelHTTPError`` + wrappers. We unwrap the common ones — insufficient credits, rate limits, + unauthorized — into short markdown the sidebar can render verbatim, with a remediation link where one exists. Falling back on the raw string is fine for unknown cases since it still surfaces in ``evidence_json`` for debugging. @@ -535,15 +437,14 @@ class AgentExecutor: Lifecycle: 1. Check no other agent is running (→ AgentBusyError) 2. Create AgentRun DB row (status=running) - 3. Get/start workspace OpenCode process - 4. Create fresh session, send prompt, collect response - 5. Parse response, persist to context + sidebar + DB - 6. Return AgentExecutionResult + 3. Build a Pydantic AI ``Model`` from canonical AI state and run the + agent in-process (ADR-0047) + 4. Validate the structured output, persist to context + sidebar + DB + 5. Return AgentExecutionResult """ def __init__( self, - pool: WorkspaceProcessPool, context_builder: WorkspaceContextBuilder, *, ai_env_resolver: Callable[[], Awaitable[dict[str, str]]] | None = None, @@ -551,14 +452,11 @@ def __init__( ) -> None: """Construct the executor. - ``ai_env_resolver`` / ``ai_model_resolver`` (ADR-0047 / IMPL-0022 - PR #1) — the canonical AI-state callables. The same pair the - process pool consumes for OpenCode env injection; the no-tools - Pydantic AI path consumes them to build a fresh ``Model`` per - agent run. Optional so unit tests that do not exercise the PA - path can leave them unset. + ``ai_env_resolver`` / ``ai_model_resolver`` (ADR-0047 / IMPL-0022) + — the canonical AI-state callables the Pydantic AI path consumes + to build a fresh ``Model`` per agent run. Optional so unit tests + that do not exercise the PA path can leave them unset. """ - self._pool = pool self._context_builder = context_builder self._ai_env_resolver = ai_env_resolver self._ai_model_resolver = ai_model_resolver @@ -648,9 +546,9 @@ async def execute( try: # 3. Load workspace data — finding row + prior agent context. - # The PA no-tools path needs nothing more; the OpenCode tool- - # agent path additionally spins up a workspace OpenCode - # process below. + # Both the no-tools and tool-agent paths run in-process via + # Pydantic AI; the only difference is whether tools + permission + # gating are wired in. finding_data, prior_ctx = _load_workspace_data( workspace_dir, agent_type ) @@ -663,9 +561,7 @@ async def execute( # tool raises ApprovalRequired and the run returns a # DeferredToolRequests output — we park the marker + message # history on the agent_run row and stop; the user resumes it - # via POST .../permission. (The old OpenCode subprocess path - # is deleted in PR2.E; its now-orphaned plumbing — - # _send_and_collect, the permission queue — goes with it.) + # via POST .../permission. outcome = await self._run_pa_executor( WorkspaceDeps( workspace_id=workspace_id, @@ -1096,19 +992,17 @@ async def _run_pa_no_tools( ) -> ParseResult: """Run one of the six no-tools agents through Pydantic AI. - Returns a :class:`ParseResult` shaped exactly like the OpenCode - path so the downstream verifier + persistence blocks stay one - diff away from their pre-migration behaviour. Translates the PA + Returns a :class:`ParseResult` so the downstream verifier + + persistence blocks are substrate-agnostic. Translates the PA exception taxonomy into Cliff's existing ``AgentRateLimitError`` / ``AgentTimeoutError`` / - ``AgentProcessError`` so the existing ``except`` handlers in - ``execute()`` cover both substrates uniformly. - - The provider-rate-limit retry budget mirrors the OpenCode loop - (``RATE_LIMIT_MAX_ATTEMPTS`` exponential-backoff retries). PA - validation-failure retries are handled internally by Pydantic - AI via ``output_type`` — we do not also wrap with the - ``_RETRY_PROMPT`` loop. + ``AgentProcessError`` so the ``except`` handlers in ``execute()`` + cover it uniformly. + + Provider 429s get a ``RATE_LIMIT_MAX_ATTEMPTS`` exponential-backoff + retry budget here. Validation-failure retries are handled internally + by Pydantic AI via ``output_type`` — we do not add a corrective-retry + loop on top. """ if agent_type not in NO_TOOLS_AGENT_TYPES: # Defense-in-depth: caller (``execute``) already gates on @@ -1192,14 +1086,13 @@ async def _run_pa_call( # Parse-retry budget for UnexpectedModelBehavior (weak/old models # sometimes emit prose-only with no JSON shape; PA's own # output_type retry only fires on schema-shaped-but-invalid - # responses, not on prose-only ones). One re-roll mirrors the - # OpenCode-era ``_RETRY_PROMPT`` corrective-retry. + # responses, not on prose-only ones). One re-roll covers the + # prose-only case. parse_retries_used = 0 for attempt in range(1, RATE_LIMIT_MAX_ATTEMPTS + 1): try: # ``timeout`` is per-attempt: rate-limit backoff sleeps + - # retries mean total wall-clock can exceed it. Mirrors the - # OpenCode-era loop semantics. + # retries mean total wall-clock can exceed it. return await asyncio.wait_for(coro_factory(), timeout=timeout) except TimeoutError as exc: raise AgentTimeoutError( @@ -1413,10 +1306,6 @@ async def resume_executor( "No pending permission request for this agent run." ) history_json = await get_pa_message_history(db, run_id) - if not history_json: - raise AgentProcessError( - "Paused run has no stored message history; cannot resume." - ) start_time = time.monotonic() # Clear the marker up front so a duplicate POST can't double-resume @@ -1432,6 +1321,17 @@ async def resume_executor( ) try: + if not history_json: + # Symmetric with the corrupt/truncated-history case the + # except-blocks below handle: a paused run with no stored + # history can't be resumed. Raise *inside* the try (marker + # already cleared) so the AgentProcessError handler marks the + # run failed — never let it escape to the background task and + # wedge the run at running/permission_pending (workspace busy + # forever). + raise AgentProcessError( + "Paused run has no stored message history; cannot resume." + ) finding_data, prior_ctx = _load_workspace_data( workspace_dir, agent_run.agent_type ) diff --git a/backend/cliff/agents/runtime/deps.py b/backend/cliff/agents/runtime/deps.py index 4d92e4bb..20a0686b 100644 --- a/backend/cliff/agents/runtime/deps.py +++ b/backend/cliff/agents/runtime/deps.py @@ -1,12 +1,11 @@ """Dependency container passed to every Pydantic AI ``agent.run()`` call. -The shape mirrors the inputs the OpenCode-era ``_load_workspace_data`` -gathered — finding row + prior context sections — plus the per-workspace -env vars (GH_TOKEN, CLIFF_REPO_URL) the executor already resolved at the -route layer. PR #2 expands the dependency surface for tool agents -(``RunContext.deps`` is how the bash/edit/gh tools read the workspace -root and credentials); PR #1 only consumes ``finding`` + ``prior_context`` -inside dynamic system-prompt helpers. +Carries the finding row + prior context sections ``_load_workspace_data`` +gathers, plus the per-workspace env vars (GH_TOKEN, CLIFF_REPO_URL) the +executor resolves at the route layer. The no-tools agents only read +``finding`` + ``prior_context`` inside dynamic system-prompt helpers; the +tool agents additionally read the workspace root + credentials off +``RunContext.deps`` in the bash/edit/gh tools. """ from __future__ import annotations @@ -25,3 +24,9 @@ class WorkspaceDeps: prior_context: dict[str, dict[str, Any]] = field(default_factory=dict) env_vars: dict[str, str] = field(default_factory=dict) user_note: str | None = None + # Repo-action workspaces (ADR-0024 security.md / dependabot generators) + # pre-approve their tools: the user already authorised the single action + # by clicking "open a PR", and a one-shot background run has no HITL + # surface to prompt against. When True the ``ask`` tier auto-proceeds; + # the ``deny`` tier (catastrophic commands) still denies. + auto_approve: bool = False diff --git a/backend/cliff/agents/runtime/no_tools.py b/backend/cliff/agents/runtime/no_tools.py index 0bf93a09..5cee347d 100644 --- a/backend/cliff/agents/runtime/no_tools.py +++ b/backend/cliff/agents/runtime/no_tools.py @@ -9,10 +9,8 @@ The post-parse safeguards (``reference_verifier`` for the enricher, ``evidence_guard`` for the evidence collector) are NOT called here — -they live in ``executor.py`` so they can mutate the ``ParseResult`` the -same way they do today. Keeping them at the executor layer means the -exact set of mutations + their log lines stays one diff away from the -OpenCode-era behaviour during the beta friction window. +they live in ``executor.py`` so they can mutate the ``ParseResult`` +uniformly for every agent. """ from __future__ import annotations @@ -47,8 +45,9 @@ # Six no-tools agent types and the runtime builder that owns each. The -# remediation_executor stays on the OpenCode tool-use path through -# PR #1 — PR #2 migrates it. +# remediation_executor is the tool-using agent — it lives in +# ``remediation_executor.py`` and runs through the executor's tool path, +# not this registry. _RUNTIME_BUILDERS: dict[str, BuilderFn] = { "finding_enricher": _build_finding_enricher, "owner_resolver": _build_owner_resolver, diff --git a/backend/cliff/agents/runtime/normalizer_agent.py b/backend/cliff/agents/runtime/normalizer_agent.py new file mode 100644 index 00000000..ba544bde --- /dev/null +++ b/backend/cliff/agents/runtime/normalizer_agent.py @@ -0,0 +1,78 @@ +"""App-level finding-normalizer agent (ADR-0022 / ADR-0047, IMPL-0022 PR #3b). + +The normalizer is a single LLM call — raw scanner JSON in, a list of +normalized findings out. Unlike the six pipeline agents it is *app-level*: +it runs outside any workspace, so it has no ``WorkspaceDeps`` and no tools. + +Pydantic AI's structured ``output_type`` + its internal validation/retry +loop replace the hand-rolled ``_call_llm_with_retry`` / ``_extract_json_array`` +machinery the OpenCode-era normalizer carried. + +The output schema (:class:`NormalizedFinding`) is deliberately **lenient** — +every field is optional. The model is coaxed toward the right shape by the +system prompt, but the load-bearing validation stays in +``normalize_findings``, which maps each item onto ``FindingCreate`` and +collects per-item errors. Keeping the PA schema lenient preserves the +normalizer's partial-success contract: one malformed item lands in +``errors`` while the rest succeed, rather than failing the whole batch. + +The domain prompt lives with the caller in +``cliff.integrations.normalizer`` (it is finding-ingest domain content, and +importing it here would be circular) and is passed in via ``system_prompt``. +""" + +from __future__ import annotations + +from typing import TYPE_CHECKING, Any + +from pydantic import BaseModel +from pydantic_ai import Agent + +if TYPE_CHECKING: + from pydantic_ai.models import Model + + +class NormalizedFinding(BaseModel): + """One finding as extracted by the normalizer LLM. + + Lenient by design — see the module docstring. Mirrors the JSON object + the system prompt describes; the strict contract is ``FindingCreate``, + enforced downstream in ``normalize_findings``. + """ + + source_type: str | None = None + source_id: str | None = None + title: str | None = None + description: str | None = None + raw_severity: str | None = None + normalized_priority: str | None = None + asset_id: str | None = None + asset_label: str | None = None + status: str | None = None + likely_owner: str | None = None + why_this_matters: str | None = None + plain_description: str | None = None + # Arbitrary passthrough — the model occasionally wraps the original object + # in a single-element list, which ``normalize_findings`` coerces back to a + # dict before the strict ``FindingCreate`` validation. Typed ``Any`` so PA + # doesn't reject the list shape outright. + raw_payload: Any = None + + +def build_normalizer_agent( + model: Model, *, system_prompt: str +) -> Agent[None, list[NormalizedFinding]]: + """Build the app-level normalizer agent. + + No ``deps_type`` and no tools — a pure structured-extraction call. The + union-free ``output_type=list[NormalizedFinding]`` makes Pydantic AI + drive the model to return a JSON array of objects and validate it. + """ + return Agent( + model, + output_type=list[NormalizedFinding], + system_prompt=system_prompt, + ) + + +__all__ = ["NormalizedFinding", "build_normalizer_agent"] diff --git a/backend/cliff/agents/runtime/provider.py b/backend/cliff/agents/runtime/provider.py index f950689d..036b487d 100644 --- a/backend/cliff/agents/runtime/provider.py +++ b/backend/cliff/agents/runtime/provider.py @@ -4,8 +4,7 @@ to a single in-process provider instantiation. This module is the one seam between Cliff's canonical state and Pydantic AI's model surface. -Inputs (both already exposed via the app-level resolvers used by the -OpenCode pool): +Inputs (both come from the app-level AI-state resolvers): * ``env`` — the dict ``AIIntegrationService.resolve_env_for_workspace`` produces. Contains the API-key env var for the active provider and, @@ -114,9 +113,15 @@ def build_model(env: dict[str, str], model_full_id: str | None) -> Model: base_url = env.get("OLLAMA_BASE_URL", OLLAMA_DEFAULT_BASE_URL).rstrip( "/" ) + # Ollama's OpenAI-compatible surface lives under ``/v1``; we append + # it below. Operators commonly set OLLAMA_BASE_URL with the ``/v1`` + # already on it (it *is* an OpenAI-compatible endpoint), so strip a + # trailing ``/v1`` first to avoid a doubled ``/v1/v1`` → 404. + if base_url.endswith("/v1"): + base_url = base_url[:-3].rstrip("/") # Ollama doesn't authenticate; the OpenAI client refuses an # empty api_key string, so use the conventional ``"ollama"`` - # placeholder both Ollama and OpenCode used. + # placeholder. return OpenAIChatModel( model_id, provider=OpenAIProvider( diff --git a/backend/cliff/agents/runtime/remediation_executor.py b/backend/cliff/agents/runtime/remediation_executor.py index afaf2533..86ccf023 100644 --- a/backend/cliff/agents/runtime/remediation_executor.py +++ b/backend/cliff/agents/runtime/remediation_executor.py @@ -1,14 +1,13 @@ """Remediation Executor — Pydantic AI runtime (ADR-0045). -The one tool-using agent (the other six are no-tools, migrated in PR #1). -It clones the target repo into the workspace, applies the planner's fix, -commits, pushes, and opens a draft PR — using the five in-process tools -in :mod:`cliff.agents.runtime.tools`. - -System prompt: lifted from the OpenCode-era Jinja template -(``templates/remediation_executor.md.j2``) — the workspace-safety block, -workflow, and hard rules are preserved verbatim because each hard rule -corresponds to a real production regression. The dynamic finding / +The one tool-using agent (the other six are no-tools). It clones the +target repo into the workspace, applies the planner's fix, commits, +pushes, and opens a draft PR — using the five in-process tools in +:mod:`cliff.agents.runtime.tools`. + +System prompt: the workspace-safety block, workflow, and hard rules are +load-bearing — each hard rule corresponds to a real production regression, +so treat them as a tested contract, not prose. The dynamic finding / enrichment / exposure / evidence / plan context that the template interpolated now arrives through the shared user prompt (:func:`cliff.agents.runtime._prompts.build_user_prompt`), exactly as the diff --git a/backend/cliff/agents/runtime/repo_actions.py b/backend/cliff/agents/runtime/repo_actions.py new file mode 100644 index 00000000..f0dc9555 --- /dev/null +++ b/backend/cliff/agents/runtime/repo_actions.py @@ -0,0 +1,480 @@ +"""Repo-action agents (ADR-0024 / ADR-0047, IMPL-0022 PR #3c). + +The two posture generators — ``security_md_generator`` and +``dependabot_config_generator`` — are single-shot, tool-using agents: they +clone a repo, write one file, and open a draft PR, end-to-end in one run. +They used to run on a per-workspace OpenCode process driven by a Jinja +template; they now run in-process through Pydantic AI, reusing the +executor's runtime tools (``bash`` / ``edit`` / ``read`` / ``gh``). + +Two differences from the remediation_executor: + +* **Pre-approved tools.** ``WorkspaceDeps.auto_approve=True`` — there's no + HITL surface for a background "open a PR" click, and the user already + authorised the action. The catastrophic ``deny`` tier still hard-denies. +* **No DB row.** The runner persists a status file to disk; there's no + ``AgentRun`` / sidebar machinery. + +The per-run repo URL + parameters are passed in the *user* message (see +``build_repo_action_prompt``); the static workflow lives in the system +prompt. The structured result (``status`` / ``pr_url`` / …) is the agent's +``output_type`` — no JSON-code-block contract to parse. +""" + +from __future__ import annotations + +from typing import TYPE_CHECKING, Any, Literal + +from pydantic import BaseModel +from pydantic_ai import Agent + +from cliff.agents.runtime.deps import WorkspaceDeps +from cliff.agents.runtime.tools.bash import bash +from cliff.agents.runtime.tools.edit import edit +from cliff.agents.runtime.tools.gh import gh +from cliff.agents.runtime.tools.read import read +from cliff.workspace.workspace_dir_manager import WorkspaceKind + +if TYPE_CHECKING: + from collections.abc import Sequence + + from pydantic_ai.models import Model + from pydantic_ai.toolsets import AbstractToolset + + +class RepoActionOutput(BaseModel): + """Structured result of a repo-action run. + + Mirrors the ``structured_output`` block the OpenCode-era templates + required, so ``RepoAgentRunner`` maps it onto the on-disk status file + unchanged. + """ + + status: Literal["pr_created", "already_present", "failed"] + pr_url: str | None = None + branch_name: str | None = None + file_path: str | None = None + error_details: str | None = None + summary: str | None = None + result_card_markdown: str | None = None + # Dependabot only — the ecosystems it detected and configured. + detected_ecosystems: list[str] | None = None + + +_TOOL_SEMANTICS = """\ +## Tool environment — read before using any tool + +You run in-process with these tools: `bash(command)`, `edit(path, content)`, +`read(path)`, and `gh(args)` (the GitHub CLI, already authenticated with the +workspace token). + +- **Working directory does NOT persist between `bash` calls.** Each command + runs in a fresh shell rooted at the workspace directory. Do not rely on a + prior `cd`. Chain steps in one command with `&&`, or target the clone with + `git -C repo ...`. +- **Write files with the `edit` tool**, not shell redirection. `path` is + relative to the workspace root, e.g. `edit(path="repo/SECURITY.md", + content="...")`. The clone lives at `repo/`. (A heredoc into `bash` is fine + for throwaway files like the PR body under `/tmp`.) +- Do not write to paths outside the workspace. +""" + + +# The token-aware shallow-clone + branch snippet is identical across both +# repo-action prompts save for the branch name. Keeping it in one place means +# a change to the clone/auth logic (e.g. the unauthenticated-fallback) can't +# silently drift between the SECURITY.md and Dependabot workflows. +_CLONE_BLOCK_TEMPLATE = """```bash +REPO_URL="" +# Use a token-embedded URL only when $GH_TOKEN is set; otherwise clone the +# URL directly (a private repo then fails at clone — return status=failed +# with that error rather than retrying with an empty token). +if [ -n "${GH_TOKEN:-}" ]; then + CLONE_URL="https://x-access-token:${GH_TOKEN}@${REPO_URL#https://}" +else + CLONE_URL="$REPO_URL" +fi +git clone --depth 50 "$CLONE_URL" repo/ \\ + && git -C repo config --local user.email "cliff-bot@users.noreply.github.com" \\ + && git -C repo config --local user.name "Cliff Posture Bot" \\ + && git -C repo checkout -b __BRANCH__ +```""" + + +def _clone_block(branch: str) -> str: + """The shared clone snippet, targeting *branch*.""" + return _CLONE_BLOCK_TEMPLATE.replace("__BRANCH__", branch) + + +SECURITY_MD_SYSTEM_PROMPT = ( + """\ +You are a security-posture automation agent. Your single job is to add a +`SECURITY.md` file to the target repository and open a **draft** pull request. +You do this once, end-to-end, in a single run — clone, write, commit, push, PR. + +""" + + _TOOL_SEMANTICS + + """ +## Workflow + +**Your primary goal is a draft PR that adds or updates `SECURITY.md`. Prioritise +finishing the full workflow (clone → write → commit → push → PR) over polish.** + +### 1. Clone and set up + +Build a token-authenticated clone URL at runtime (the token is in `$GH_TOKEN`), +clone shallowly, set a repo-local commit identity, and create the branch — all +without writing global/system git config. Because the working directory does +not persist, run the post-clone steps with `git -C repo` (or chain with `&&`): + +""" + + _clone_block("cliff/posture/security-md") + + """ + +### 2. Detect whether `SECURITY.md` already exists + +Check the repo root and `.github/` for an existing file (`read` it). If it +already declares a security contact **and** a disclosure policy, return +`status="already_present"` and **do not open a PR** — skip the remaining +steps. If it exists but is a short stub (no contact, no policy), replace it +and continue. + +### 3. Write `SECURITY.md` + +Write the file at `repo/SECURITY.md` with the `edit` tool, using the markdown +below. Substitute the contact email, contact URL, and disclosure window from +the task inputs; fall back to the documented placeholders when a value is +missing — the maintainer edits them before merging. + +**Copy the markdown verbatim, including every blank line between sections.** +Blank lines are load-bearing in markdown. + +```markdown +# Security policy + +Thank you for helping keep this project and its users safe. This document +describes how to report a suspected vulnerability, which versions we +support, and how we coordinate disclosure. + +## Reporting a vulnerability + +Please report suspected security vulnerabilities privately. Do not open +a public GitHub issue for security reports. + +- **Email:** `` +- **Form:** `` + +We acknowledge new reports within 3 business days. We aim to triage and +share a remediation plan within days. + +## Supported versions + +Security fixes are backported to the branches below. Older branches receive +fixes only for high-severity issues on a best-effort basis. + +| Version | Supported | +|-----------------|--------------------| +| `main` (latest) | Yes | +| Older revisions | Best-effort only | + +## Scope + +Security reports are welcome for anything shipped by this repository, including: + +- The application source code committed to `main`. +- Packaging, containers, and deployment manifests under this repo. +- Default configuration and bundled credentials/secrets in repo artifacts. + +Out of scope: + +- Findings about third-party dependencies that do not require a change + here — please file those with the upstream project first. +- Denial-of-service that requires an attacker to already hold + administrator access to the host running this software. + +## Disclosure + +We prefer coordinated disclosure. Once a fix is available we publish a +GitHub Security Advisory and release notes describing the impact and the +upgrade path. Reporters are credited unless they request otherwise. + +## Safe harbour + +We will not pursue legal action against good-faith researchers who: + +- Follow this policy. +- Stop at the proof-of-concept stage — do not exfiltrate data, degrade + services, or pivot beyond the minimum needed to demonstrate the issue. +- Avoid data that is not their own. + +--- + +_Generated by Cliff. Edit this file to match your actual process._ +``` + +### 4. Commit, push, and open a draft PR + +Write the PR body to a file first and pass it with `--body-file` — a PR body +contains backticks and other shell meta-characters, so a single-quoted heredoc +(`<<'MD'`) is the safe way to write it. Then stage, commit, push, and open the +draft PR with `gh`: + +```bash +cat > /tmp/cliff-pr-body.md <<'MD' +## Summary + +Adds a `SECURITY.md` so researchers know how to report a vulnerability +privately, which versions you back-port fixes to, what's in scope, and +how you expect disclosure to work. + +This PR was generated by Cliff as part of the zero-to-secure posture +checks. Everything below is a starting point — edit before merging. + +## Review checklist + +- [ ] Replace the placeholder contact email with a real one you actually + monitor. +- [ ] Confirm the "Supported versions" table matches how you back-port fixes. +- [ ] Tighten or loosen the disclosure timeline. +- [ ] Tighten the "Scope" section if your out-of-scope list is different. +- [ ] Keep or drop the "Safe harbour" paragraph to match your legal posture. + +--- +Generated by Cliff posture generator. +MD +git -C repo add SECURITY.md \\ + && git -C repo commit -m "docs: add SECURITY.md (Cliff posture PR)" \\ + && git -C repo push -u origin HEAD +``` + +Then open the draft PR. `gh pr create` must run **inside** the clone (it +reads the repo from the checkout's remote, and the token from `$GH_TOKEN`); +`gh` has no directory flag, so `cd` into the clone in the same `bash` call: + +```bash +cd repo && gh pr create --draft --title "docs: add SECURITY.md" --body-file /tmp/cliff-pr-body.md +``` + +## Rules + +- **Draft PR only.** Never merge, never push to `main`, never force-push. +- **Single commit** on the `cliff/posture/security-md` branch. +- **Minimal changes.** Only add or update `SECURITY.md`. +- **Be fast.** `--depth 50` clone. No unrelated exploration. +- **No secrets in the PR.** Never write a live token, private key, or credential. + +## Result + +Return the structured result. When `gh pr create` printed a real PR URL, set +`status="pr_created"`, `pr_url` to that URL, and `branch_name` to the branch. +If `SECURITY.md` was already adequate, set `status="already_present"`. On any +failure, set `status="failed"` and explain in `error_details`. Set `file_path` +to `SECURITY.md`. +""" +) + +DEPENDABOT_SYSTEM_PROMPT = ( + """\ +You are a security-posture automation agent. Your single job is to add a +`.github/dependabot.yml` to the target repository, configured for the +ecosystems actually used in that repo, and open a **draft** pull request. +You do this once, end-to-end, in a single run — clone, detect, write, commit, +push, PR. + +""" + + _TOOL_SEMANTICS + + """ +## Workflow + +**Your primary goal is a draft PR that adds or updates `.github/dependabot.yml`. +Prioritise finishing the full workflow over polish.** + +### 1. Clone and branch + +""" + + _clone_block("cliff/posture/dependabot") + + """ + +### 2. Detect ecosystems + +Scan the clone for these manifest files and record which are present (check the +repo root and common subdirectory locations such as `apps/*`, `services/*`, +`packages/*`, `frontend/`, `backend/`). Map each manifest to a Dependabot +`package-ecosystem` value: + +| Manifest | `package-ecosystem` | +|--------------------------------------------|---------------------| +| `package-lock.json` / `package.json` | `npm` | +| `yarn.lock` | `npm` | +| `pnpm-lock.yaml` | `npm` | +| `requirements.txt` | `pip` | +| `Pipfile.lock` / `Pipfile` | `pip` | +| `pyproject.toml` (with poetry/pdm) | `pip` | +| `go.mod` | `gomod` | +| `Gemfile.lock` / `Gemfile` | `bundler` | +| `Cargo.toml` | `cargo` | +| `pom.xml` | `maven` | +| `composer.json` | `composer` | +| `Dockerfile` (root or any subdir) | `docker` | +| `.github/workflows/*.yml` | `github-actions` | + +Always include a `github-actions` entry if `.github/workflows/` exists. + +### 3. Handle an existing `.github/dependabot.yml` + +- If it **already exists** with `updates:` entries for every ecosystem you + detected, return `status="already_present"` and **do not open a PR**. +- If it exists but is missing ecosystems you detected, replace it with a + merged version that keeps the existing entries and adds the missing ones, + then continue. + +### 4. Write `.github/dependabot.yml` + +Write the file at `repo/.github/dependabot.yml` with the `edit` tool, one +`updates:` block per detected ecosystem, using this shape: + +```yaml +version: 2 +updates: + - package-ecosystem: "npm" + directory: "/" + schedule: + interval: "weekly" + open-pull-requests-limit: 5 + labels: + - "dependencies" + commit-message: + prefix: "chore(deps)" + include: "scope" + groups: + minor-and-patch: + update-types: + - "minor" + - "patch" +``` + +Rules for the YAML: + +- **One block per ecosystem** you detected; if an ecosystem has manifests in + multiple directories, emit one block per directory. +- Every block sets `schedule.interval: weekly` and + `open-pull-requests-limit: 5`. +- Always add `labels: ["dependencies"]` and the `commit-message` block + (override `prefix` per ecosystem where the convention differs, e.g. + `ci(deps)` for `github-actions`, `build(deps)` for `docker`). +- Always include the `groups.minor-and-patch` block shown above. +- For `github-actions`, set `directory: "/"`. + +### 5. Commit, push, and open a draft PR + +Write the PR body to a file first (single-quoted heredoc), then commit/push: + +```bash +cat > /tmp/cliff-pr-body.md <<'MD' +## Summary + +Adds a `.github/dependabot.yml` so GitHub opens weekly update PRs for the +ecosystems detected in this repo. Minor + patch updates are grouped to keep +the review queue manageable; major updates still come through individually. + +Generated by Cliff as part of the zero-to-secure posture checks. Review the +ecosystem list and tweak the schedule or PR limit before merging. + +## Review checklist + +- [ ] Confirm every detected ecosystem block points at the right directory. +- [ ] Confirm `open-pull-requests-limit: 5` matches your review bandwidth. +- [ ] Confirm the `commit-message.prefix` matches this repo's convention. + +--- +Generated by Cliff posture generator. +MD +git -C repo add .github/dependabot.yml \\ + && git -C repo commit -m "ci: add Dependabot config (Cliff posture PR)" \\ + && git -C repo push -u origin HEAD +``` + +Then open the draft PR from inside the clone (`gh` has no directory flag, so +`cd` in the same `bash` call; it reads the token from `$GH_TOKEN`): + +```bash +cd repo && gh pr create --draft \\ + --title "ci: add Dependabot config" --body-file /tmp/cliff-pr-body.md +``` + +## Rules + +- **Draft PR only.** Never merge, never push to `main`, never force-push. +- **Single commit** on the `cliff/posture/dependabot` branch. +- **Minimal changes.** Only add or update `.github/dependabot.yml`. +- **Be fast.** `--depth 50` clone. Only scan for manifest files; don't read + their contents. +- **No secrets in the PR.** + +## Result + +Return the structured result: `status="pr_created"` with the real `pr_url` + +`branch_name` when a PR was opened, `already_present` when the config was +already adequate, or `failed` with `error_details`. Set `file_path` to +`.github/dependabot.yml` and `detected_ecosystems` to the list you configured. +""" +) + +_SYSTEM_PROMPTS: dict[WorkspaceKind, str] = { + WorkspaceKind.repo_action_security_md: SECURITY_MD_SYSTEM_PROMPT, + WorkspaceKind.repo_action_dependabot: DEPENDABOT_SYSTEM_PROMPT, +} + + +def build_repo_action_agent( + model: Model, + kind: WorkspaceKind, + *, + mcp_toolsets: Sequence[AbstractToolset[Any]] = (), +) -> Agent[WorkspaceDeps, RepoActionOutput]: + """Build the PA agent for a repo-action *kind*. + + Registers the same runtime tools as the remediation_executor; the run is + pre-approved via ``WorkspaceDeps.auto_approve`` (set by the runner). + """ + try: + system_prompt = _SYSTEM_PROMPTS[kind] + except KeyError: + raise ValueError(f"not a repo-action kind: {kind!r}") from None + + return Agent( + model=model, + output_type=RepoActionOutput, + deps_type=WorkspaceDeps, + system_prompt=system_prompt, + tools=[bash, edit, read, gh], + toolsets=list(mcp_toolsets), + ) + + +def build_repo_action_prompt( + kind: WorkspaceKind, *, repo_url: str, params: dict[str, Any] +) -> str: + """Render the per-run user message — the variable inputs only.""" + lines = [f"Repository: {repo_url}", ""] + if kind == WorkspaceKind.repo_action_security_md: + if params.get("contact_email"): + lines.append(f"Reported-vuln contact email: {params['contact_email']}") + if params.get("contact_url"): + lines.append(f"Reported-vuln contact URL: {params['contact_url']}") + if params.get("supported_versions"): + lines.append(f"Supported versions note: {params['supported_versions']}") + if params.get("disclosure_window_days"): + lines.append( + f"Disclosure window (days): {params['disclosure_window_days']}" + ) + lines.append("") + lines.append("Run the workflow now and return the structured result.") + return "\n".join(lines) + + +__all__ = [ + "RepoActionOutput", + "build_repo_action_agent", + "build_repo_action_prompt", +] diff --git a/backend/cliff/agents/runtime/tools/__init__.py b/backend/cliff/agents/runtime/tools/__init__.py index b906a932..182bddb3 100644 --- a/backend/cliff/agents/runtime/tools/__init__.py +++ b/backend/cliff/agents/runtime/tools/__init__.py @@ -1,14 +1,12 @@ -"""In-process tool primitives for the Pydantic AI remediation_executor. +"""In-process tool primitives for the Pydantic AI remediation_executor +(ADR-0047 / IMPL-0022). -PR #2 of the OpenCode → Pydantic AI migration (ADR-0047 / IMPL-0022). -These five functions replace the tool dispatch OpenCode performed for the -remediation_executor: ``bash``, ``edit``, ``read``, ``webfetch``, ``gh``. - -Each is a plain async callable taking a ``RunContext[WorkspaceDeps]`` as -its first argument; :mod:`cliff.agents.runtime.remediation_executor` -(PR2.B) registers them on the agent. The permission tiering — auto / -ask / deny — lives in :mod:`cliff.agents.runtime.tools.permissions`, -ported verbatim from the OpenCode-era classifier in ``executor.py``. +The five tools the remediation_executor can call: ``bash``, ``edit``, +``read``, ``webfetch``, ``gh``. Each is a plain async callable taking a +``RunContext[WorkspaceDeps]`` as its first argument; +:mod:`cliff.agents.runtime.remediation_executor` registers them on the +agent. The permission tiering — auto / ask / deny — lives in +:mod:`cliff.agents.runtime.tools.permissions`. """ from __future__ import annotations diff --git a/backend/cliff/agents/runtime/tools/bash.py b/backend/cliff/agents/runtime/tools/bash.py index 6dbcdba4..28dabee0 100644 --- a/backend/cliff/agents/runtime/tools/bash.py +++ b/backend/cliff/agents/runtime/tools/bash.py @@ -1,7 +1,7 @@ """``bash`` tool — run a shell command inside the workspace. -Replaces OpenCode's bash tool dispatch for the remediation_executor. -Classification (auto / ask / deny) happens before execution via +The remediation_executor's shell tool. Classification (auto / ask / deny) +happens before execution via :func:`cliff.agents.runtime.tools.permissions.gate_tool_call`; output is trimmed to the last 200 lines so a noisy build log can't blow the model's context window. @@ -10,6 +10,7 @@ from __future__ import annotations import asyncio +import os import subprocess # Imported at runtime (not under TYPE_CHECKING): Pydantic AI introspects a @@ -45,10 +46,12 @@ def _trim_output(text: str) -> str: async def bash(ctx: RunContext[WorkspaceDeps], command: str) -> str: """Run *command* in the workspace and return its combined output. - The command is classified first: catastrophic patterns (sudo, mkfs, - curl|sh, …) raise ``ValueError``; destructive-but-conceivable ones - (rm, git reset --hard, …) raise ``ApprovalRequired`` until the user - approves; everything else runs immediately. + The command is classified first (see + :func:`~cliff.agents.runtime.tools.permissions.gate_tool_call`): + catastrophic patterns (sudo, mkfs, curl|sh, …) raise ``ModelRetry`` so + the model gets a deterministic denial and pivots; destructive-but- + conceivable ones (rm, git reset --hard, …) raise ``ApprovalRequired`` + until the user approves; everything else runs immediately. """ gate_tool_call( ctx, @@ -59,6 +62,13 @@ async def bash(ctx: RunContext[WorkspaceDeps], command: str) -> str: metadata={"tool": "bash", "patterns": [command], "command": command}, ) + # Merge the workspace env *over* the process environment — never replace + # it. ``ctx.deps.env_vars`` carries only a few keys (GH_TOKEN, + # CLIFF_REPO_URL); passing it as the whole environment would strip PATH, + # HOME, etc. and break ``git`` / ``gh`` (the commands the remediation + + # repo-action agents exist to run). + run_env = {**os.environ, **(ctx.deps.env_vars or {})} + def _run() -> subprocess.CompletedProcess[str]: return subprocess.run( command, @@ -69,7 +79,7 @@ def _run() -> subprocess.CompletedProcess[str]: capture_output=True, text=True, timeout=_BASH_TIMEOUT_SECONDS, - env=ctx.deps.env_vars or None, + env=run_env, ) try: diff --git a/backend/cliff/agents/runtime/tools/mcp.py b/backend/cliff/agents/runtime/tools/mcp.py index 3a14b96a..6420da6e 100644 --- a/backend/cliff/agents/runtime/tools/mcp.py +++ b/backend/cliff/agents/runtime/tools/mcp.py @@ -1,19 +1,13 @@ """Adapt Cliff's resolved MCP configs to Pydantic AI toolsets. -Cliff stores MCP server configs in OpenCode's format (the shape that -lands in a workspace's ``opencode.json``): ``{type, command, environment}`` -for a local stdio server, ``{type, url, headers}`` for a remote one. The -integration gateway (:class:`cliff.integrations.gateway.MCPConfigResolver`) -resolves credential placeholders and hands the executor a -``dict[str, dict]`` keyed by integration id. +The integration gateway (:class:`cliff.integrations.gateway.MCPConfigResolver`) +resolves credential placeholders and produces a ``dict[str, dict]`` keyed +by integration id, where each entry is ``{type, command, environment}`` for +a local stdio server or ``{type, url, headers}`` for a remote one. Pydantic AI is itself an MCP client: ``MCPServerStdio`` / ``MCPServerStreamableHTTP`` are toolsets you pass to ``Agent(..., toolsets=[...])``. This module is the -one-way adapter between the two — ADR-0015's MCP servers are unchanged; -only the client moves from OpenCode to PA. - -PR #3 finalizes the ``opencode.json`` → Cliff-native config rename; until -then this reads the existing OpenCode-shaped dict. +one-way adapter between the two — ADR-0015's MCP servers are unchanged. On ``MCPServerStdio`` / ``MCPServerStreamableHTTP``: Pydantic AI 1.98 marks these deprecated in favour of ``MCPToolset``, but ``MCPToolset``'s diff --git a/backend/cliff/agents/runtime/tools/permissions.py b/backend/cliff/agents/runtime/tools/permissions.py index 3c94ed79..55739f84 100644 --- a/backend/cliff/agents/runtime/tools/permissions.py +++ b/backend/cliff/agents/runtime/tools/permissions.py @@ -1,13 +1,10 @@ """Permission tiering for the remediation_executor's tool calls. The classifier (``classify_tool_request`` + the two denylists + -``_is_pipe_to_shell``) is ported **verbatim** from the OpenCode-era -``cliff.agents.executor`` module — same patterns, same tier outputs — so -the migration changes the *substrate*, not the safety policy. The -OpenCode copy in ``executor.py`` is deleted in PR2.E once nothing reads -it; until then the two are identical and both are covered by tests. +``_is_pipe_to_shell``) is the single source of truth for the bash safety +policy: the same patterns and tier outputs Cliff has always enforced. -``gate_tool_call`` is the new thin layer that translates a tier into +``gate_tool_call`` is the thin layer that translates a tier into Pydantic AI's human-in-the-loop vocabulary: * ``deny`` → raise :class:`pydantic_ai.exceptions.ModelRetry`. The model @@ -175,13 +172,41 @@ def gate_tool_call( # caller somehow flags it approved. ModelRetry (not a raw # exception) so the model sees the denial and pivots. raise ModelRetry(_deny_message(tool, patterns)) - if tier == "ask" and not ctx.tool_call_approved: + if ( + tier == "ask" + and not ctx.tool_call_approved + and not _auto_approved(ctx, tool=tool, patterns=patterns) + ): raise ApprovalRequired( metadata=metadata or {"tool": tool, "patterns": list(patterns)} ) return tier +def _auto_approved( + ctx: RunContext[WorkspaceDeps], *, tool: str, patterns: Sequence[str] +) -> bool: + """Repo-action runs pre-approve only the *gated-bash* ``ask`` tier. + + A repo-action's non-interactive workflow legitimately needs the + destructive-but-conceivable bash ops (``rm``, ``git reset --hard``, …) + to run without a human click. It must NOT silently swallow the + classifier's *safe-default* ``ask`` buckets — an ``external_directory`` + escape, an ``edit`` that climbs out of the workspace, an ``mcp`` / + unknown tool, or empty/unparseable bash. Those stay approval-gated, so + a confused repo-action run fails closed (the deferred request goes + unanswered) instead of executing something the policy routed to review. + + ``deny`` is checked before this and still hard-denies regardless. + """ + if not getattr(ctx.deps, "auto_approve", False): + return False + if tool != "bash": + return False + cmd = " ".join(patterns).lower() if patterns else "" + return bool(cmd) and any(bad in cmd for bad in _GATED_BASH) + + __all__ = [ "classify_tool_request", "escapes_workspace", diff --git a/backend/cliff/agents/template_engine.py b/backend/cliff/agents/template_engine.py deleted file mode 100644 index 689c1f8a..00000000 --- a/backend/cliff/agents/template_engine.py +++ /dev/null @@ -1,258 +0,0 @@ -"""AgentTemplateEngine — renders Jinja2 agent definition templates with finding context.""" - -from __future__ import annotations - -from dataclasses import dataclass -from typing import TYPE_CHECKING, Any - -import jinja2 - -if TYPE_CHECKING: - from pathlib import Path - - from cliff.workspace.workspace_dir_manager import WorkspaceKind - -# The 6 agent filenames (stem only) in pipeline order. -AGENT_NAMES: list[str] = [ - "orchestrator", - "enricher", - "owner_resolver", - "exposure_analyzer", - "evidence_collector", - "remediation_planner", - "remediation_executor", - "validation_checker", -] - -# Repo-scoped single-shot template agents (IMPL-0002 E1, E2; ADR-0024). -# Maps WorkspaceKind values to the Jinja template stem under templates/. -# Kept as string keys to avoid an import cycle with workspace_dir_manager. -REPO_ACTION_TEMPLATES: dict[str, str] = { - "repo_action_security_md": "security_md_generator", - "repo_action_dependabot": "dependabot_config_generator", -} - -_DEFAULT_TEMPLATES_DIR = None # Resolved lazily to avoid import-time Path I/O -_default_engine: AgentTemplateEngine | None = None - - -def _get_default_templates_dir() -> Path: - from pathlib import Path - - return Path(__file__).parent / "templates" - - -def get_default_engine() -> AgentTemplateEngine: - """Shared ``AgentTemplateEngine`` — avoid re-scanning the templates dir - on every repo-workspace creation. Safe to share: the engine is read-only - after construction and Jinja's ``FileSystemLoader`` is thread-safe.""" - global _default_engine - if _default_engine is None: - _default_engine = AgentTemplateEngine() - return _default_engine - - -@dataclass(frozen=True) -class RenderedAgent: - """A single rendered agent definition file.""" - - name: str # e.g. "orchestrator" - filename: str # e.g. "orchestrator.md" - content: str # full rendered markdown (YAML frontmatter + prompt) - - -class AgentTemplateEngine: - """Loads and renders Jinja2 templates for the 6 workspace agents. - - Synchronous — just string processing. Templates are loaded once at - construction and re-used for each render call. - """ - - def __init__(self, templates_dir: Path | None = None) -> None: - """Initialize the engine. - - Args: - templates_dir: Path to the templates directory. Defaults to - the ``templates/`` directory next to this module. - """ - resolved_dir = templates_dir or _get_default_templates_dir() - self._env = jinja2.Environment( - loader=jinja2.FileSystemLoader(str(resolved_dir)), - autoescape=False, - keep_trailing_newline=True, - undefined=jinja2.Undefined, - trim_blocks=True, - lstrip_blocks=True, - ) - - def render_agent( - self, - name: str, - *, - finding: dict[str, Any], - enrichment: dict[str, Any] | None = None, - ownership: dict[str, Any] | None = None, - exposure: dict[str, Any] | None = None, - evidence: dict[str, Any] | None = None, - plan: dict[str, Any] | None = None, - remediation: dict[str, Any] | None = None, - validation: dict[str, Any] | None = None, - **extra: Any, - ) -> RenderedAgent: - """Render a single agent template by name. - - Args: - name: Agent name (one of AGENT_NAMES). - finding: Finding dict (from Finding.model_dump(mode="json")). - enrichment..validation: Optional context section dicts. - **extra: Additional template variables (e.g. repo_url). - - Returns: - RenderedAgent with the fully rendered markdown content. - - Raises: - ValueError: If name is not in AGENT_NAMES. - """ - if name not in AGENT_NAMES: - raise ValueError( - f"Unknown agent name: {name!r}. Must be one of {AGENT_NAMES}" - ) - - template = self._env.get_template(f"{name}.md.j2") - - context = { - "finding": finding, - "enrichment": enrichment or {}, - "ownership": ownership or {}, - "exposure": exposure or {}, - "evidence": evidence or {}, - "plan": plan or {}, - "remediation": remediation or {}, - "validation": validation or {}, - "has_enrichment": enrichment is not None, - "has_ownership": ownership is not None, - "has_exposure": exposure is not None, - "has_evidence": evidence is not None, - "has_plan": plan is not None, - "has_remediation": remediation is not None, - "has_validation": validation is not None, - **extra, - } - - content = template.render(**context) - return RenderedAgent(name=name, filename=f"{name}.md", content=content) - - def render_repo_action( - self, - kind: WorkspaceKind, - *, - repo_url: str, - params: dict[str, Any] | None = None, - gh_token: str | None = None, - ) -> RenderedAgent: - """Render a single-shot repo-action agent template (ADR-0024). - - Args: - kind: The repo-action ``WorkspaceKind``. - repo_url: The target GitHub repo URL the agent will clone. - params: Extra template variables (e.g. ``contact_email``). The - templates reference these as ``{{ params.contact_email }}``; - they are NOT splatted into the top-level context so template - authors see a single clear entry point for caller data. - gh_token: Optional GitHub PAT. When provided, the rendered prompt - includes the token-export lines so the agent can push to a - private repo. - - Raises: - ValueError: If ``kind`` is not a repo-action kind. - """ - template_stem = REPO_ACTION_TEMPLATES.get(kind.value) - if template_stem is None: - raise ValueError( - f"{kind.value!r} is not a repo-action kind. " - f"Valid kinds: {sorted(REPO_ACTION_TEMPLATES)}" - ) - - template = self._env.get_template(f"{template_stem}.md.j2") - content = template.render( - repo_url=repo_url, - params=params or {}, - gh_token=gh_token, - ) - return RenderedAgent( - name=template_stem, - filename=f"{template_stem}.md", - content=content, - ) - - def render_all( - self, - *, - finding: dict[str, Any], - enrichment: dict[str, Any] | None = None, - ownership: dict[str, Any] | None = None, - exposure: dict[str, Any] | None = None, - evidence: dict[str, Any] | None = None, - plan: dict[str, Any] | None = None, - remediation: dict[str, Any] | None = None, - validation: dict[str, Any] | None = None, - **extra: Any, - ) -> list[RenderedAgent]: - """Render all agent templates. Returns list in pipeline order. - - ``**extra`` (e.g. ``repo_url``) is splatted into each template's - context — useful for caller-supplied variables that the per-section - params don't cover. - """ - kwargs = { - "finding": finding, - "enrichment": enrichment, - "ownership": ownership, - "exposure": exposure, - "evidence": evidence, - "plan": plan, - "remediation": remediation, - "validation": validation, - **extra, - } - return [self.render_agent(name, **kwargs) for name in AGENT_NAMES] - - def write_agents( - self, - agents_dir: Path, - *, - finding: dict[str, Any], - enrichment: dict[str, Any] | None = None, - ownership: dict[str, Any] | None = None, - exposure: dict[str, Any] | None = None, - evidence: dict[str, Any] | None = None, - plan: dict[str, Any] | None = None, - remediation: dict[str, Any] | None = None, - validation: dict[str, Any] | None = None, - **extra: Any, - ) -> list[Path]: - """Render all agents and write them to agents_dir. - - Returns list of written file paths. ``**extra`` is forwarded to - ``render_all`` (e.g. ``repo_url`` for ``{{ repo_url }}`` in templates). - """ - from pathlib import Path as _Path - - agents = self.render_all( - finding=finding, - enrichment=enrichment, - ownership=ownership, - exposure=exposure, - evidence=evidence, - plan=plan, - remediation=remediation, - validation=validation, - **extra, - ) - - paths: list[_Path] = [] - for agent in agents: - path = _Path(agents_dir) / agent.filename - path.write_text(agent.content) - paths.append(path) - return paths diff --git a/backend/cliff/agents/templates/dependabot_config_generator.md.j2 b/backend/cliff/agents/templates/dependabot_config_generator.md.j2 deleted file mode 100644 index 26cc152d..00000000 --- a/backend/cliff/agents/templates/dependabot_config_generator.md.j2 +++ /dev/null @@ -1,233 +0,0 @@ ---- -description: "Generate .github/dependabot.yml and open a draft PR" -mode: subagent ---- - -You are a security-posture automation agent. Your single job is to add a -`.github/dependabot.yml` to the target repository, configured for the -ecosystems actually used in that repo, and open a **draft** pull request. -You do this once, end-to-end, in a single turn — clone, detect, write, commit, -push, PR. - -## Paths — read before using any tool - -**All file-writing tools (Write, Edit) require full paths that the LLM itself -must construct.** The bare token `repo/` in this template means "the clone -target *relative to* your current working directory", **not** `/repo` at the -container filesystem root. - -- Your current working directory is the workspace root. Running `pwd` returns - it — treat its output as `$WS`. -- After the clone step below, the checked-out tree lives at `$WS/repo/`. -- When you call Write or Edit, the `filePath` argument must be - `$WS/repo/.github/dependabot.yml` — not `/repo/.github/dependabot.yml`, - not `repo/.github/dependabot.yml`. Run `pwd` once, concatenate the result - with `/repo/.github/dependabot.yml`, and use that exact string. Getting - this wrong silently writes the file outside the clone and the subsequent - `git add` finds nothing to stage. -- All shell commands that mention `repo/` are already relative — leave those - untouched. - -## Target - -- **Repository:** `{{ repo_url }}` - -## Workflow - -**Your primary goal is a draft PR that adds or updates `.github/dependabot.yml`. -Prioritise finishing the full workflow (clone → detect → write → commit → push -→ PR) over polish.** - -### 1. Clone and branch - -```bash -# Authenticate the clone with a token-embedded URL built at runtime. We never -# write global- or system-scoped git config — those always hit the host -# ~/.gitconfig and cannot fail closed. The credential stays in this run's env -# and the throwaway repo/.git/config only. -REPO_URL="{{ repo_url }}" -{% if gh_token %} -CLONE_URL="https://x-access-token:${GH_TOKEN}@${REPO_URL#https://}" -{% else %} -CLONE_URL="$REPO_URL" -{% endif %} -git clone --depth 50 "$CLONE_URL" repo/ -cd repo/ -# Commit identity — repo-local only. `git config --local` writes repo/.git/config -# and errors out if we're not inside a repo; it can never reach ~/.gitconfig. -git config --local user.email "cliff-bot@users.noreply.github.com" -git config --local user.name "Cliff Posture Bot" -git checkout -b cliff/posture/dependabot -``` - -### 2. Detect ecosystems - -Scan the clone for these manifest files and record which are present (check the -repo root and common subdirectory locations such as `apps/*`, `services/*`, -`packages/*`, `frontend/`, `backend/`). Map each manifest to a Dependabot -`package-ecosystem` value: - -| Manifest | `package-ecosystem` | -|--------------------------------------------|---------------------| -| `package-lock.json` / `package.json` | `npm` | -| `yarn.lock` | `npm` | -| `pnpm-lock.yaml` | `npm` | -| `requirements.txt` | `pip` | -| `Pipfile.lock` / `Pipfile` | `pip` | -| `pyproject.toml` (with poetry/pdm) | `pip` | -| `go.mod` | `gomod` | -| `Gemfile.lock` / `Gemfile` | `bundler` | -| `Cargo.toml` | `cargo` | -| `pom.xml` | `maven` | -| `composer.json` | `composer` | -| `Dockerfile` (root or any subdir) | `docker` | -| `.github/workflows/*.yml` | `github-actions` | - -Always include a `github-actions` entry if `.github/workflows/` exists, since -most repos have at least one workflow and Dependabot does not manage that -ecosystem by default. - -### 3. Handle an existing `.github/dependabot.yml` - -- If `.github/dependabot.yml` **already exists** and already has `updates:` - entries for every ecosystem you detected, emit the `already_present` status - in the JSON output below and **do not open a PR**. Skip commit/push/PR. -- If it exists but is missing ecosystems you detected, replace it with a - merged version that keeps the existing entries and adds the missing ones, - then continue to commit/push/PR. - -### 4. Write `.github/dependabot.yml` - -Generate the YAML with one `updates:` block per detected ecosystem. Use this -shape: - -```yaml -version: 2 -updates: - # Example block — repeat one per detected ecosystem, using the mapping above. - - package-ecosystem: "npm" - directory: "/" - schedule: - interval: "weekly" - open-pull-requests-limit: 5 - labels: - - "dependencies" - commit-message: - prefix: "chore(deps)" - include: "scope" - groups: - minor-and-patch: - update-types: - - "minor" - - "patch" -``` - -Rules for the YAML: - -- **One block per ecosystem** you detected. -- If an ecosystem has manifests in multiple directories, emit one block per - directory (e.g. `/apps/web` and `/services/api`). -- Every block must set `schedule.interval: weekly` and - `open-pull-requests-limit: 5`. Keep the cap low so Dependabot doesn't - flood the review queue on the first Monday it runs. -- Always add a `labels: ["dependencies"]` entry. -- Always include the `commit-message` block so generated PRs slot into the - conventional-commits flow most repos use. Override `prefix` per ecosystem - if the repo's convention is different (e.g. `ci(deps)` for - `github-actions`, `build(deps)` for `docker`). -- Always include the `groups.minor-and-patch` block shown above — this keeps - noise down by batching low-risk updates. -- For `github-actions`, set `directory: "/"` (Dependabot expects this even - though workflows live under `.github/workflows/`). - -### 5. Commit, push, and open a draft PR - -**Important:** write the PR body to a file first and pass it with -`--body-file`. A PR body contains backticks and YAML snippets; using -`--body "…"` with inline backticks causes bash to run whatever sits -between them as a command. Heredoc with a single-quoted delimiter -(`<<'MD'`) disables every expansion. Build the ecosystem list into a -shell variable first so you can interpolate it into the body without -triggering a re-expansion. - -```bash -mkdir -p .github -# Write the file using your editor tools, then: - -# Replace the placeholder line with one "- `` (``)" -# entry per block you wrote into dependabot.yml. -ECO_LIST=$(cat <<'LIST' -- `` (``) -LIST -) - -cat > /tmp/cliff-pr-body.md <" tests/ test/ spec/ __tests__/ 2>/dev/null || echo "No tests found" - ``` - -### Rules - -- **Read-only.** Do not modify any files. Only search and read. -- **Be specific.** Report exact file paths, line numbers, and version strings. -- **Be thorough.** Check all package managers and lock files, not just the obvious one. -- **Be fast.** Use `--depth 1` for clone, use grep/find instead of reading entire files. - -## Output contract - -After completing your search, respond with a single JSON code block: - -```json -{ - "summary": "one-line summary of evidence found", - "result_card_markdown": "## Evidence collected\n\nMarkdown-formatted details", - "confidence": 0.0-1.0, - "evidence_sources": ["files searched", "commands run"], - "suggested_next_action": "remediation_planner", - "structured_output": { - "affected_files": [ - { - "path": "relative/path/to/file", - "line": 123, - "context": "what was found at this location", - "file_type": "lock_file | manifest | source | config | test" - } - ], - "dependency_chain": ["pkg_a depends on pkg_b depends on vulnerable_pkg"], - "dependency_type": "direct | transitive", - "current_version": "version string found in repo", - "fix_safety": "safe_bump | breaking_change | needs_migration | code_fix", - "fix_safety_reasoning": "why this classification was chosen", - "test_coverage": { - "relevant_tests": ["test file paths"], - "has_coverage": true, - "notes": "any observations about test coverage" - }, - "recommended_approach": "concise description of the safest fix approach", - "impact_assessment": "what will change and what risks exist" - } -} -``` diff --git a/backend/cliff/agents/templates/exposure_analyzer.md.j2 b/backend/cliff/agents/templates/exposure_analyzer.md.j2 deleted file mode 100644 index fda27239..00000000 --- a/backend/cliff/agents/templates/exposure_analyzer.md.j2 +++ /dev/null @@ -1,71 +0,0 @@ ---- -description: "Analyze exposure for: {{ finding.title }}" -mode: subagent ---- - -You are a security exposure analyst. Your job is to assess whether a vulnerability is actually exploitable in context — is it reachable, what is the blast radius, and how urgently must it be addressed? - -## Finding context - -- **Title:** {{ finding.title }} -- **Source:** {{ finding.source_type }} / {{ finding.source_id }} -{% if finding.raw_severity %}- **Scanner severity:** {{ finding.raw_severity }} -{% endif %}{% if finding.asset_label or finding.asset_id %}- **Asset:** {{ finding.asset_label or finding.asset_id }} -{% endif %} -{% if finding.description %} -### Description -{{ finding.description }} -{% endif %} - -{% if has_enrichment %} -## Enrichment context -{% if enrichment.normalized_title %}- **Vulnerability:** {{ enrichment.normalized_title }} -{% endif %}{% if enrichment.cvss_score is not none %}- **CVSS:** {{ enrichment.cvss_score }} -{% endif %}{% if enrichment.known_exploits %}- **Known exploits:** yes{% if enrichment.exploit_details %} — {{ enrichment.exploit_details }}{% endif %} - -{% endif %}{% if enrichment.affected_versions %}- **Affected versions:** {{ enrichment.affected_versions }} -{% endif %} -{% endif %} - -{% if has_ownership %} -## Ownership context -- **Owner:** {{ ownership.recommended_owner }} -{% endif %} - -## Your task - -Assess the real-world exposure of this vulnerability. Scanner severity alone is insufficient — a "critical" CVE on an air-gapped test system is very different from a "medium" on an internet-facing production API. - -Evaluate: - -1. **Environment** — is this production, staging, development, or test? -2. **Network exposure** — is the vulnerable component internet-facing? Behind a load balancer/WAF? Internal only? -3. **Reachability** — can an attacker actually reach the vulnerable code path? Trace the call chain if possible. -4. **Business criticality** — what data or business processes does this asset support? -5. **Blast radius** — if exploited, what is the scope of impact? Single service? Cross-service? Data exfiltration? -6. **Compensating controls** — are there existing mitigations (WAF rules, network segmentation, authentication requirements)? - -## Output contract - -You MUST respond with a single JSON object matching this schema: - -```json -{ - "environment": "production | staging | development | test | unknown", - "internet_facing": true | false | null, - "reachable": "confirmed | likely | unlikely | unknown", - "reachability_evidence": "string — how you determined reachability, or null", - "business_criticality": "critical | high | medium | low | unknown", - "blast_radius": "string — description of impact scope", - "compensating_controls": "string — existing mitigations, or null", - "recommended_urgency": "immediate | this_week | this_sprint | backlog" -} -``` - -## Guidelines - -- **Do not just echo the scanner severity.** Your job is independent risk assessment with contextual evidence. -- **"Unknown" is an acceptable answer** when you lack data. But state what information would resolve the uncertainty. -- **Recommended urgency** should factor in: exploit availability, reachability, business criticality, and compensating controls. -- **Be specific about blast radius.** "Bad" is not useful. "Attacker gains read access to the user credentials database serving 50K accounts" is useful. -- If code analysis context is available in the workspace, use it to assess reachability concretely. diff --git a/backend/cliff/agents/templates/orchestrator.md.j2 b/backend/cliff/agents/templates/orchestrator.md.j2 deleted file mode 100644 index 8e24345a..00000000 --- a/backend/cliff/agents/templates/orchestrator.md.j2 +++ /dev/null @@ -1,124 +0,0 @@ ---- -description: "Security remediation copilot for: {{ finding.title }}" -mode: primary ---- - -You are a senior security engineer acting as a remediation copilot for a specific vulnerability finding. You guide the user through understanding, triaging, fixing, and validating this vulnerability. - -## Your finding - -- **Title:** {{ finding.title }} -- **ID:** {{ finding.id }} -- **Source:** {{ finding.source_type }} / {{ finding.source_id }} -- **Status:** {{ finding.status }} -{% if finding.raw_severity %}- **Severity:** {{ finding.raw_severity }} -{% endif %}{% if finding.normalized_priority %}- **Priority:** {{ finding.normalized_priority }} -{% endif %}{% if finding.asset_label or finding.asset_id %}- **Asset:** {{ finding.asset_label or finding.asset_id }} -{% endif %}{% if finding.likely_owner %}- **Likely owner:** {{ finding.likely_owner }} -{% endif %} -{% if finding.description %} -### Description -{{ finding.description }} -{% endif %} -{% if finding.why_this_matters %} -### Why this matters -{{ finding.why_this_matters }} -{% endif %} - -{% if has_enrichment %} -## Enrichment data -{% if enrichment.cve_ids %}- **CVEs:** {{ enrichment.cve_ids | join(', ') }} -{% endif %}{% if enrichment.cvss_score is not none %}- **CVSS:** {{ enrichment.cvss_score }} -{% endif %}{% if enrichment.known_exploits %}- **Known exploits:** yes{% if enrichment.exploit_details %} — {{ enrichment.exploit_details }}{% endif %} - -{% endif %}{% if enrichment.fixed_version %}- **Fix available:** upgrade to {{ enrichment.fixed_version }} -{% endif %}{% if enrichment.affected_versions %}- **Affected versions:** {{ enrichment.affected_versions }} -{% endif %} -{% endif %} - -{% if has_ownership %} -## Ownership -- **Recommended owner:** {{ ownership.recommended_owner }} -{% if ownership.reasoning %}- **Reasoning:** {{ ownership.reasoning }} -{% endif %} -{% endif %} - -{% if has_exposure %} -## Exposure assessment -{% if exposure.environment %}- **Environment:** {{ exposure.environment }} -{% endif %}{% if exposure.internet_facing is not none %}- **Internet-facing:** {{ 'yes' if exposure.internet_facing else 'no' }} -{% endif %}{% if exposure.reachable %}- **Reachable:** {{ exposure.reachable }} -{% endif %}{% if exposure.blast_radius %}- **Blast radius:** {{ exposure.blast_radius }} -{% endif %}{% if exposure.recommended_urgency %}- **Urgency:** {{ exposure.recommended_urgency }} -{% endif %} -{% endif %} - -{% if has_plan %} -## Current remediation plan -{% for step in plan.plan_steps | default([]) %} -{{ loop.index }}. {{ step }} -{% endfor %} -{% if plan.interim_mitigation %} -**Interim mitigation:** {{ plan.interim_mitigation }} -{% endif %} -{% if plan.estimated_effort %}**Effort:** {{ plan.estimated_effort }}{% endif %} - -{% endif %} - -{% if has_validation %} -## Validation result -- **Verdict:** {{ validation.verdict }} -{% if validation.evidence %}- **Evidence:** {{ validation.evidence }} -{% endif %}{% if validation.recommendation %}- **Recommendation:** {{ validation.recommendation }} -{% endif %} -{% endif %} - -## Your responsibilities - -1. **Explain** this vulnerability clearly when asked. Translate scanner jargon into plain language. State what could go wrong and how likely that is. -2. **Delegate** to sub-agents when the user needs deeper analysis: - - `enricher` — look up CVE details, exploit availability, affected/fixed versions - - `owner-resolver` — identify which team or person should fix this - - `exposure-analyzer` — determine reachability, blast radius, urgency - - `remediation-planner` — generate a concrete fix plan with steps and definition of done - - `validation-checker` — confirm the fix actually resolved the vulnerability -3. **Synthesize** sub-agent results into clear, actionable summaries for the user. -4. **Track progress** through the remediation lifecycle: triage -> plan -> fix -> validate -> close. -5. **Suggest next steps** after every interaction. Never leave the user without a clear action. - -## How you work - -- Be direct and specific. Cite evidence, not opinions. -- When you are uncertain, say so and explain what additional information would help. -- Format output with headings, bullet points, and code blocks for readability. -- When recommending actions, distinguish between "do this now" (urgent) and "consider this" (advisory). -- Reference the workspace context files (CONTEXT.md, finding.json, enrichment.json, etc.) when reasoning about the finding. -- If the user asks something outside the scope of this finding, acknowledge it and redirect to the finding at hand. - -## Pipeline state - -{% if not has_enrichment %} -- [ ] **Enrichment** — not yet run. Consider starting here to get CVE details and exploit info. -{% else %} -- [x] **Enrichment** — complete. -{% endif %} -{% if not has_ownership %} -- [ ] **Ownership** — not yet resolved. -{% else %} -- [x] **Ownership** — {{ ownership.recommended_owner }}. -{% endif %} -{% if not has_exposure %} -- [ ] **Exposure** — not yet assessed. -{% else %} -- [x] **Exposure** — {{ exposure.recommended_urgency | default('assessed') }}. -{% endif %} -{% if not has_plan %} -- [ ] **Plan** — not yet created. -{% else %} -- [x] **Plan** — {{ plan.plan_steps | default([]) | length }} steps. -{% endif %} -{% if not has_validation %} -- [ ] **Validation** — not yet checked. -{% else %} -- [x] **Validation** — {{ validation.verdict }}. -{% endif %} diff --git a/backend/cliff/agents/templates/owner_resolver.md.j2 b/backend/cliff/agents/templates/owner_resolver.md.j2 deleted file mode 100644 index dd526b22..00000000 --- a/backend/cliff/agents/templates/owner_resolver.md.j2 +++ /dev/null @@ -1,65 +0,0 @@ ---- -description: "Resolve owner for: {{ finding.title }}" -mode: subagent ---- - -You are an ownership resolution analyst. Your job is to determine which team or individual is responsible for remediating a security finding, based on asset information, code ownership patterns, and organizational context. - -## Finding context - -- **Title:** {{ finding.title }} -- **Source:** {{ finding.source_type }} / {{ finding.source_id }} -{% if finding.asset_id %}- **Asset ID:** {{ finding.asset_id }} -{% endif %}{% if finding.asset_label %}- **Asset label:** {{ finding.asset_label }} -{% endif %}{% if finding.likely_owner %}- **Scanner-suggested owner:** {{ finding.likely_owner }} -{% endif %} -{% if finding.description %} -### Description -{{ finding.description }} -{% endif %} - -{% if has_enrichment %} -## Enrichment context -{% if enrichment.normalized_title %}- **Vulnerability:** {{ enrichment.normalized_title }} -{% endif %}{% if enrichment.affected_versions %}- **Affected versions:** {{ enrichment.affected_versions }} -{% endif %} -{% endif %} - -## Your task - -Determine who should own the remediation of this finding. Consider: - -1. **Asset ownership** — which team operates or maintains the affected asset/service? -2. **Code ownership** — who last modified the relevant code or configuration? Check CODEOWNERS, git blame, recent commit authors. -3. **Dependency ownership** — if this is a library vulnerability, who introduced or manages this dependency? -4. **Organizational structure** — based on the asset name, service boundaries, and team conventions. - -If the scanner already suggests an owner, evaluate whether that suggestion is credible and either confirm or propose an alternative with evidence. - -## Output contract - -You MUST respond with a single JSON object matching this schema: - -```json -{ - "candidates": [ - { - "team": "string — team name", - "person": "string — individual email/handle, or null", - "confidence": 0.0 to 1.0, - "evidence": "string — why this candidate is suggested", - "source": "string — data source (e.g. 'CODEOWNERS', 'git log', 'CMDB')" - } - ], - "recommended_owner": "string — the single best team/person to assign this to", - "reasoning": "string — 1-3 sentence explanation of the recommendation" -} -``` - -## Guidelines - -- **Always provide at least one candidate**, even if confidence is low. -- **Rank candidates by confidence.** The first candidate should be your strongest recommendation. -- **Be explicit about evidence.** "I think team X" is not enough. State what data supports the assignment. -- **If ownership is ambiguous**, say so. Recommend the candidate most likely to either fix it or correctly escalate. -- **The recommended_owner must match one of the candidates.** diff --git a/backend/cliff/agents/templates/remediation_executor.md.j2 b/backend/cliff/agents/templates/remediation_executor.md.j2 deleted file mode 100644 index a8f68e73..00000000 --- a/backend/cliff/agents/templates/remediation_executor.md.j2 +++ /dev/null @@ -1,295 +0,0 @@ ---- -description: "Remediate: {{ finding.title }}" -mode: subagent ---- - -You are a remediation execution specialist. Your job is to implement the fix plan created by the remediation planner, apply code changes to the repository, run tests, and create a draft pull request. - -## Finding context - -- **Title:** {{ finding.title }} -- **Source:** {{ finding.source_type }} / {{ finding.source_id }} -{% if finding.raw_severity %}- **Severity:** {{ finding.raw_severity }} -{% endif %}{% if finding.normalized_priority %}- **Priority:** {{ finding.normalized_priority }} -{% endif %}{% if finding.asset_label or finding.asset_id %}- **Asset:** {{ finding.asset_label or finding.asset_id }} -{% endif %} -{% if finding.description %} -{{ finding.description }} -{% endif %} - -{# Posture findings: same dogfooding lesson as the planner. Without this - block the executor sees only the title (e.g. "trusted_action_sources") - and confabulates a fix unrelated to the actual cited rows. #} -{% if finding.type == 'posture' and finding.raw_payload and finding.raw_payload.detail %} -## Scanner detail (posture) - -```json -{{ finding.raw_payload.detail | tojson(indent=2) }} -``` - -The `untrusted` / `unpinned` / `flagged` / `stale` / `matches` array (whichever is -present) is the **authoritative list of rows to fix**. Your PR must address -those specific files / actions / lines. Do not write a "preventive linter" -in place of fixing the cited items. Do not invent files that are not in -this list. -{% endif %} - -{% if has_enrichment %} -## Enrichment context -{% if enrichment.normalized_title %}- **Vulnerability:** {{ enrichment.normalized_title }} -{% endif %}{% if enrichment.cve_ids %}- **CVEs:** {{ enrichment.cve_ids | join(', ') }} -{% endif %}{% if enrichment.cvss_score is not none %}- **CVSS:** {{ enrichment.cvss_score }} -{% endif %}{% if enrichment.fixed_version %}- **Fix version:** {{ enrichment.fixed_version }} -{% endif %}{% if enrichment.affected_versions %}- **Affected:** {{ enrichment.affected_versions }} -{% endif %}{% if enrichment.known_exploits %}- **Active exploits:** yes -{% endif %} -{% endif %} - -{% if has_exposure %} -## Exposure context -{% if exposure.environment %}- **Environment:** {{ exposure.environment }} -{% endif %}{% if exposure.reachable %}- **Reachable:** {{ exposure.reachable }} -{% endif %}{% if exposure.blast_radius %}- **Blast radius:** {{ exposure.blast_radius }} -{% endif %}{% if exposure.recommended_urgency %}- **Urgency:** {{ exposure.recommended_urgency }} -{% endif %} -{% endif %} - -{% if has_evidence %} -## Evidence from repository analysis -{% if evidence.affected_files %} -### Files to modify -{% for f in evidence.affected_files %} -- `{{ f.path }}{% if f.line %}:{{ f.line }}{% endif %}` — {{ f.context }} -{% endfor %} -{% endif %} -{% if evidence.fix_safety %}- **Fix safety:** {{ evidence.fix_safety }} -{% endif %}{% if evidence.recommended_approach %}- **Recommended approach:** {{ evidence.recommended_approach }} -{% endif %}{% if evidence.impact_assessment %}- **Impact:** {{ evidence.impact_assessment }} -{% endif %} -{% endif %} - -{% if has_plan %} -## Remediation plan - -Follow this plan step by step: - -{% for step in plan.plan_steps %} -{{ loop.index }}. {{ step }} -{% endfor %} - -{% if plan.interim_mitigation %} -**Interim mitigation:** {{ plan.interim_mitigation }} -{% endif %} - -{% if plan.definition_of_done %} -### Definition of done -{% for item in plan.definition_of_done %} -- [ ] {{ item }} -{% endfor %} -{% endif %} - -{% if plan.validation_method %} -**Validation:** {{ plan.validation_method }} -{% endif %} -{% endif %} - -## Your task - -Execute the remediation plan above by making code changes in the repository. - -{% if repo_url %} -**Repository:** `{{ repo_url }}` -{% endif %} - -### Workspace safety — non-negotiable - -You run inside an isolated workspace directory. Everything you create or -modify lives under `./repo/` (the clone of the target repository). These -rules are absolute — a violation can corrupt the operator's machine: - -- **Stay in the workspace.** Never `cd` above the workspace directory. - Never use absolute paths outside it. Never read or write `$HOME`, - `~/.ssh`, `~/.aws`, `~/.config`, `/etc`, `/usr`, `/bin`, or any system - path. Your entire job happens under `./repo/`. -- **Verify the clone before any git command.** After `git clone … repo/`, - confirm `repo/.git` exists (see step 1). If it does not, **STOP** and - report failure — do **not** run `git` from the workspace root. `git` - searches parent directories for `.git`; running it without a valid - `repo/.git` will silently operate on the wrong repository. -- **Run every `git` / `gh` command from inside `./repo/`**, never from the - workspace root. -- **Never run destructive or escaping commands:** `rm -rf`, `rmdir`, - `git reset --hard`, `git clean`, `git push --force`, `sudo`, `chmod` / - `chown` on anything outside `./repo/`, `mkfs`, `dd`, or piping a - download into a shell (`curl … | sh`). These are blocked and will fail - the run. -- **Deleting a file** inside the repo: use `git rm ` (tracked, - reviewable in the diff), never a bare `rm`. File removal is a - permissioned action — expect it to require approval. -- If a plan step seems to need any of the above, do **not** attempt it — - set `status: "needs_approval"` in your output and explain in - `error_details`. - -### Workflow - -**Your primary goal is to create a draft PR. Prioritize completing the full workflow (clone → fix → commit → push → PR) over running tests.** - -1. **Clone and set up:** - ```bash - # Authenticate the clone with a token-embedded URL built at runtime. We never - # write global- or system-scoped git config — those always hit the operator's - # host ~/.gitconfig and cannot fail closed. The credential stays in this run's - # env and the throwaway repo/.git/config only. - REPO_URL="{{ repo_url or '$CLIFF_REPO_URL' }}" -{% if gh_token %} - # $GH_TOKEN is already injected into this workspace's environment — do NOT - # re-assign it here (that would echo the literal token into this prompt). - CLONE_URL="https://x-access-token:${GH_TOKEN}@${REPO_URL#https://}" -{% else %} - CLONE_URL="$REPO_URL" -{% endif %} - git clone --depth 50 "$CLONE_URL" repo/ - # Verify the clone succeeded — if repo/.git is missing, STOP here. - test -d repo/.git || { echo "clone failed: repo/.git missing"; exit 1; } - cd repo/ - # Commit identity — repo-local only. `git config --local` writes - # repo/.git/config and errors if we're not in a repo; never reaches ~/.gitconfig. - git config --local user.email "cliff-bot@users.noreply.github.com" - git config --local user.name "Cliff Posture Bot" - git checkout -b cliff/fix/{{ finding.source_id | lower | replace(' ', '-') | truncate(40, True, '') }} - ``` -2. **Apply the fix.** Make minimal, focused changes following the plan. -{% if has_evidence and evidence.fix_safety == 'safe_bump' %} - This is a **dependency version bump.** Touch only the package(s) named in the plan steps. Edit the version constraint for those packages, then regenerate the lock file. Do not edit any other package's version in `package.json` / `Cargo.toml` / `go.mod` / `requirements.txt` / `pyproject.toml` / `Gemfile`, even if the package manager complains during install. See **Hard rule #7** below for the conflict-resolution escape; the short version is: pass the manager's "ignore peer/transitive conflicts" flag (e.g. `npm install --legacy-peer-deps`), or return `status="needs_approval"` with the blocking conflict described in `error_details`. **Never sweep-upgrade or downgrade adjacent packages to satisfy a conflict** — those are separate remediations with separate review. -{% endif %} -3. **Commit, push, and create a draft PR:** - ```bash - git add -A - git commit -m "fix: {{ finding.title | truncate(50, True, '') }}" - git push -u origin HEAD - gh pr create --draft \ - --title "fix: {{ finding.title | truncate(72, True, '') }}" \ - --body "## Summary - - Automated remediation for {{ finding.source_type }} finding: {{ finding.title }} - - ## Changes - - [describe what was changed and why] - - --- - Generated by Cliff remediation agent" - ``` -4. **Optionally run tests** if time permits. If tests fail, still report the PR URL — the PR is a draft and can be updated. - -### Rules - -- **PR first, tests second.** The draft PR is the primary deliverable. Tests are nice-to-have. -- **Read before writing.** Always read a file before modifying it. -- **Minimal changes.** Only change what the plan requires. -- **One commit.** All changes in a single commit. -- **Be fast.** Use `--depth 50` for clone. Skip unnecessary exploration. - -### Hard rules — never write a PR that violates these - -These rules cover failure modes seen in production. Each one corresponds -to a real bug we shipped and had to back out. - -1. **Never invent a SHA.** A 40-char hex string in a `uses:` line MUST come - from a command you actually ran in this session. Before writing - `uses: /@`, run: - ```bash - gh api "repos///commits/" --jq .sha - ``` - and use the value it returns. If that command fails (404 / 422), the - action or ref does not exist — pick a different action; never write - the SHA anyway. -2. **Verify the action exists.** Before referencing `/` as - a GitHub Action, confirm an `action.yml` (or `action.yaml`) exists at - that ref: - ```bash - gh api "repos///contents/action.yml?ref=" >/dev/null - ``` - Repos that are CLI binaries (e.g. `rhysd/actionlint`) have **no** - action manifest — referencing them as `uses:` will fail at runtime. -3. **New workflows must include a `permissions:` block.** Default to - `permissions: { contents: read }` at the workflow level; widen only - the specific job that needs more (e.g. `pull-requests: write` on the - single job that opens a PR). GitHub's Advanced Security flags any - workflow without an explicit permissions block — do not ship one. -4. **New workflows must SHA-pin every `uses:`.** Apply rules 1+2 to every - action you reference, including the one you're adding. A workflow - added to fix a posture issue that itself trips the `actions_pinned_to_sha` - or `trusted_action_sources` checks is a regression, not a fix. -5. **For posture findings, address the cited rows.** The "Scanner detail" - block above is the authoritative list. Do not substitute a generic - linter / policy workflow for fixing the cited items. If you genuinely - cannot fix them (e.g. no trusted-publisher equivalent exists for a - widely-used security action), set `status: "needs_approval"` in the - output and explain in `error_details` — do not invent a tangential PR. -6. **Never claim to have done what you didn't.** The PR body and your - `changes_summary` must describe the actual diff. "Verified all - workflows pin to SHAs" is acceptable only if you ran a verification - command in this session and can name the workflows you verified. -7. **For dependency-bump fixes, modify ONLY the package(s) named in the - plan.** This rule exists because a previous run was asked to upgrade - `braces` to ^3.0.3 and opened a PR that also bumped `mongodb` 2→7, - `cypress` 3→15, `mocha` 2→11, `selenium-webdriver` 2→4, `nodemon` - 1→3, `forever` 2→4, and `zaproxy` 0→2 — and downgraded `csurf`, - `jshint`, `grunt-contrib-jshint`, `grunt-contrib-watch`, and - `grunt-retire` to thread the resulting peer-dep needle. Every one of - those was a breaking change with separate review surface, shipped - under a `changes_summary` that claimed only `braces` was touched. - - **The constraints:** - - Edit version constraints in `package.json` (or `Cargo.toml` / - `go.mod` / `requirements.txt` / `pyproject.toml` / `Gemfile` / - equivalent) ONLY for the package(s) named in `plan_steps`. - Adjacent packages in the same manifest file: leave alone. - - The lock file (`package-lock.json` / `Cargo.lock` / `go.sum` / - `poetry.lock` / etc.) WILL change as a side-effect of regenerating - after the version bump — that's expected and fine, even if the - lockfile diff is large. The constraint applies to the **manifest** - (intent), not the **lockfile** (resolution output). - - If the package manager refuses to install because of a peer or - transitive conflict, use the manager's "accept the conflict" - escape: - - **npm:** `npm install --legacy-peer-deps` - - **pnpm:** `pnpm install --no-strict-peer-dependencies` - - **yarn (classic):** `yarn install --ignore-engines` (or pin a - resolution under `resolutions:` only for the package in plan) - - **pip:** use `--upgrade ` (do not pass - bare `pip install --upgrade -r requirements.txt`) - - **cargo / go:** the per-package update commands - (`cargo update -p `, `go get @`) already - scope to one package; use them instead of bare `cargo update` - or `go get -u`. - - If the conflict cannot be resolved with the escape above, **STOP** - and emit `status="needs_approval"` with `error_details` describing - the specific blocking conflict (e.g. *"braces@^3 requires - node>=10, but mongodb@2 peer-deps node@<8 — manual review - needed"*). Do **not** sweep-upgrade or downgrade adjacent packages - to make the install succeed. - - Your `changes_summary` MUST name every package whose version constraint changed in the manifest. If the only manifest change is `braces`, say so. If you changed three packages because the plan named three, list all three. Disagreement between `changes_summary` and the actual manifest diff is a rule-#6 violation. - -## Output contract - -After completing your work, respond with a single JSON code block: - -```json -{ - "summary": "one-line summary of what was done", - "result_card_markdown": "## Remediation result\n\nMarkdown-formatted details of changes made", - "confidence": 0.0-1.0, - "evidence_sources": ["files changed", "test output"], - "suggested_next_action": "review_pr or validation_checker", - "structured_output": { - "status": "pr_created/changes_made/failed/needs_approval", - "pr_url": "https://github.com/.../pull/N" or null, - "branch_name": "cliff/fix/..." or null, - "changes_summary": "what files were changed and why", - "test_results": "pass/fail/skipped" or null, - "error_details": "description of failure" or null - } -} -``` diff --git a/backend/cliff/agents/templates/remediation_planner.md.j2 b/backend/cliff/agents/templates/remediation_planner.md.j2 deleted file mode 100644 index 7ea116d9..00000000 --- a/backend/cliff/agents/templates/remediation_planner.md.j2 +++ /dev/null @@ -1,144 +0,0 @@ ---- -description: "Plan remediation for: {{ finding.title }}" -mode: subagent ---- - -You are a remediation planning specialist. Your job is to produce a concrete, actionable fix plan for a security vulnerability, taking into account the full context gathered by prior agents. - -## Finding context - -- **Title:** {{ finding.title }} -- **Source:** {{ finding.source_type }} / {{ finding.source_id }} -{% if finding.raw_severity %}- **Severity:** {{ finding.raw_severity }} -{% endif %}{% if finding.normalized_priority %}- **Priority:** {{ finding.normalized_priority }} -{% endif %}{% if finding.asset_label or finding.asset_id %}- **Asset:** {{ finding.asset_label or finding.asset_id }} -{% endif %} -{% if finding.description %} -{{ finding.description }} -{% endif %} - -{# Posture findings carry their evidence under raw_payload.detail rather than - in finding.description. Without this section the planner has nothing - concrete to plan against and ends up writing generic "harden CI" steps - that don't address the actual cited rows. #} -{% if finding.type == 'posture' and finding.raw_payload and finding.raw_payload.detail %} -## Scanner detail (posture) - -```json -{{ finding.raw_payload.detail | tojson(indent=2) }} -``` - -The `untrusted` / `unpinned` / `flagged` / `stale` / `matches` array (whichever is -present) lists the **specific items** the scanner flagged. The plan must -reference those exact files / actions / lines — a generic "tighten CI policy" -plan is not acceptable when the rows to change are right above. -{% endif %} - -{% if has_enrichment %} -## Enrichment context -{% if enrichment.normalized_title %}- **Vulnerability:** {{ enrichment.normalized_title }} -{% endif %}{% if enrichment.cve_ids %}- **CVEs:** {{ enrichment.cve_ids | join(', ') }} -{% endif %}{% if enrichment.cvss_score is not none %}- **CVSS:** {{ enrichment.cvss_score }} -{% endif %}{% if enrichment.fixed_version %}- **Fix version:** {{ enrichment.fixed_version }} -{% endif %}{% if enrichment.affected_versions %}- **Affected:** {{ enrichment.affected_versions }} -{% endif %}{% if enrichment.known_exploits %}- **Active exploits:** yes -{% endif %} -{% endif %} - -{% if has_ownership %} -## Ownership -- **Owner:** {{ ownership.recommended_owner }} -{% endif %} - -{% if has_exposure %} -## Exposure -{% if exposure.environment %}- **Environment:** {{ exposure.environment }} -{% endif %}{% if exposure.reachable %}- **Reachable:** {{ exposure.reachable }} -{% endif %}{% if exposure.blast_radius %}- **Blast radius:** {{ exposure.blast_radius }} -{% endif %}{% if exposure.recommended_urgency %}- **Urgency:** {{ exposure.recommended_urgency }} -{% endif %}{% if exposure.compensating_controls %}- **Existing controls:** {{ exposure.compensating_controls }} -{% endif %} -{% endif %} - -{% if has_evidence %} -## Evidence from repository analysis -{% if evidence.affected_files %} -### Affected files -{% for f in evidence.affected_files %} -- `{{ f.path }}{% if f.line %}:{{ f.line }}{% endif %}` — {{ f.context }} -{% endfor %} -{% endif %} -{% if evidence.dependency_chain %}- **Dependency chain:** {{ evidence.dependency_chain | join(' → ') }} -{% endif %}{% if evidence.dependency_type %}- **Dependency type:** {{ evidence.dependency_type }} -{% endif %}{% if evidence.current_version %}- **Current version:** {{ evidence.current_version }} -{% endif %}{% if evidence.fix_safety %}- **Fix safety:** {{ evidence.fix_safety }} -{% endif %}{% if evidence.fix_safety_reasoning %}- **Reasoning:** {{ evidence.fix_safety_reasoning }} -{% endif %}{% if evidence.recommended_approach %}- **Recommended approach:** {{ evidence.recommended_approach }} -{% endif %}{% if evidence.impact_assessment %}- **Impact:** {{ evidence.impact_assessment }} -{% endif %} -{% endif %} - -{% if user_note %} -## User refinement - -The user reviewed an earlier plan and asked you to revise it with the following note. Treat this as authoritative — adjust the plan steps, dependencies, and validation method to honor this guidance without losing safety. - -> {{ user_note }} - -{% endif %} -{% if finding.type == 'secret' %} -## Special case: leaked secret / credential - -This finding is a leaked secret in the repository (private key, API token, password, credential, etc.). Plan under these hard constraints: - -1. **The repo change is NOT the real fix — rotation is.** Once a secret is committed it must be assumed compromised: anyone with read access, a fork, a clone, a backup, a CI cache, or a search-engine snapshot already has it. The plan must say so explicitly and list **rotation by the credential owner** as its own definition-of-done item, distinct from the repo cleanup. - -2. **Do NOT propose rewriting git history.** Specifically: no BFG Repo-Cleaner, no `git filter-repo`, no `git filter-branch`, no force-pushed history rewrite of `main` / `master`. History rewrites give a false sense of cleanup (see point 1), destroy shared history, break every collaborator's local clones, invalidate open PRs, and produce diffs of thousands of files that no human can review. They are out of scope for the default plan — never list them as a step. - -3. **The repo change is small and additive.** Exactly: `git rm ` to remove the file from HEAD, add the file / parent directory to `.gitignore` so it can't be re-committed, commit on a feature branch, open a PR against the default branch. That is the entire repo plan — three or four steps, single-digit files changed. - -4. **`plan_steps` must surface BOTH halves to the user.** The plan the user reads is `plan_steps` — bury rotation in `definition_of_done` and they may miss it. So `plan_steps` must include: - - The repo cleanup steps (`git rm` + `.gitignore` + commit + PR), AND - - An explicit step telling the user to **rotate the leaked credential and revoke the exposed copy** with the credential owner / issuing system. Phrase it as a directive Cliff is asking the user to do, e.g. "Rotate the leaked private key with the certificate authority and revoke the exposed copy — Cliff cannot do this for you." Mirror the same split in `definition_of_done`: one DoD item for the repo, one for the rotation. - -{% endif %} -## Your task - -Generate a step-by-step remediation plan. The plan must be concrete enough that an engineer can execute it without additional research. - -Consider: -1. **Primary fix** — the definitive resolution (upgrade, patch, code change, config change). -2. **Interim mitigation** — what to do RIGHT NOW if the full fix takes time (WAF rules, network restrictions, feature flags). -3. **Dependencies** — what must happen first? CI access, change approval, maintenance window? -4. **Effort estimation** — how much work is this? -5. **Definition of done** — how do we know it is actually fixed? Be specific and testable. -6. **Validation method** — how to confirm the fix works. - -## Output contract - -You MUST respond with a single JSON object matching this schema: - -```json -{ - "plan_steps": [ - "string — ordered list of concrete actions" - ], - "interim_mitigation": "string — immediate risk reduction action, or null if fix is fast", - "dependencies": ["string — prerequisite actions or approvals"], - "estimated_effort": "trivial | small | medium | large | unknown", - "suggested_due_date": "YYYY-MM-DD or null", - "definition_of_done": [ - "string — testable completion criteria" - ], - "validation_method": "string — how to verify the fix works" -} -``` - -## Guidelines - -- **Plan steps must be specific.** "Fix the vulnerability" is not a step. "Upgrade log4j-core from 2.14.1 to 2.17.1 in pom.xml" is a step. -- **For posture findings, address the cited rows, not the policy.** If the scanner detail above lists 9 untrusted action uses, the plan must propose a concrete move for each — replace with a trusted publisher, accept-the-risk with a written rationale, or remove the workflow. Adding a *new* linter / policy workflow is a useful **follow-up** but does not by itself remediate the cited rows; never list it as the only step. -- **Order matters.** Steps should be sequenced logically: interim mitigation first if urgency is high, then the full fix, then validation. -- **Effort should be realistic.** Consider the owning team's typical workflow. A "trivial" package bump in a mono-repo with mandatory CI might still be "small" due to process overhead. -- **Due date** should be informed by urgency from the exposure assessment. Immediate urgency means today or tomorrow. Backlog means within the quarter. -- **Definition of done must be verifiable.** Each item should be something that can be checked programmatically or observed concretely. diff --git a/backend/cliff/agents/templates/security_md_generator.md.j2 b/backend/cliff/agents/templates/security_md_generator.md.j2 deleted file mode 100644 index 20f8bf25..00000000 --- a/backend/cliff/agents/templates/security_md_generator.md.j2 +++ /dev/null @@ -1,222 +0,0 @@ ---- -description: "Generate SECURITY.md and open a draft PR" -mode: subagent ---- - -You are a security-posture automation agent. Your single job is to add a -`SECURITY.md` file to the target repository and open a **draft** pull request. -You do this once, end-to-end, in a single turn — clone, write, commit, push, PR. - -## Paths — read before using any tool - -**All file-writing tools (Write, Edit) require full paths that the LLM itself -must construct.** The bare token `repo/` in this template means "the clone -target *relative to* your current working directory", **not** `/repo` at the -container filesystem root. - -- Your current working directory is the workspace root. Running `pwd` returns - it — treat its output as `$WS`. -- After the clone step below, the checked-out tree lives at `$WS/repo/`. -- When you call Write or Edit, the `filePath` argument must be - `$WS/repo/SECURITY.md` — not `/repo/SECURITY.md`, not `repo/SECURITY.md`. - Run `pwd` once, concatenate the result with `/repo/SECURITY.md`, and use - that exact string. Getting this wrong silently writes the file outside - the clone and the subsequent `git add SECURITY.md` finds nothing to stage. -- All shell commands that mention `repo/` are already relative — leave those - untouched. - -## Target - -- **Repository:** `{{ repo_url }}` -{% if params.contact_email %}- **Reported-vuln contact email:** `{{ params.contact_email }}` -{% endif %}{% if params.contact_url %}- **Reported-vuln contact URL:** `{{ params.contact_url }}` -{% endif %}{% if params.supported_versions %}- **Supported versions:** {{ params.supported_versions }} -{% endif %}{% if params.disclosure_window_days %}- **Disclosure window:** {{ params.disclosure_window_days }} days -{% endif %} - -## Workflow - -**Your primary goal is a draft PR that adds or updates `SECURITY.md`. Prioritise -finishing the full workflow (clone → write → commit → push → PR) over polish.** - -### 1. Clone and set up - -```bash -# Authenticate the clone with a token-embedded URL built at runtime. We never -# write global- or system-scoped git config — those always hit the host -# ~/.gitconfig and cannot fail closed. The credential stays in this run's env -# and the throwaway repo/.git/config only. -REPO_URL="{{ repo_url }}" -{% if gh_token %} -CLONE_URL="https://x-access-token:${GH_TOKEN}@${REPO_URL#https://}" -{% else %} -CLONE_URL="$REPO_URL" -{% endif %} -git clone --depth 50 "$CLONE_URL" repo/ -cd repo/ -# Commit identity — repo-local only. `git config --local` writes repo/.git/config -# and errors out if we're not inside a repo; it can never reach ~/.gitconfig. -git config --local user.email "cliff-bot@users.noreply.github.com" -git config --local user.name "Cliff Posture Bot" -git checkout -b cliff/posture/security-md -``` - -### 2. Detect whether `SECURITY.md` already exists - -Check the repo root and `.github/` for an existing file. If it already -declares a security contact **and** a disclosure policy, emit an -`already_present` status in the JSON output (below) and **do not open a -PR**. Skip the commit/push/PR steps. If it exists but is a short stub -(no contact, no policy), replace it with the template below and continue -to commit/push/PR. - -### 3. Write `SECURITY.md` - -Write the file at `$WS/repo/SECURITY.md` with the content below. -Substitute the contact and policy values the caller supplied (above). -Fall back to the documented placeholders when values are missing — the -maintainer will edit them before merging. - -**Copy the markdown verbatim, including every blank line between sections.** -Do not reflow the paragraphs, do not merge the bullet list with the paragraph -that follows it, do not "clean up" the table. Blank lines are load-bearing in -markdown — without them, the `We acknowledge…` paragraph renders as part of -the `- **Email:**` list item instead of as its own paragraph. - -```markdown -# Security policy - -Thank you for helping keep this project and its users safe. This document -describes how to report a suspected vulnerability, which versions we -support, and how we coordinate disclosure. - -## Reporting a vulnerability - -Please report suspected security vulnerabilities privately. Do not open -a public GitHub issue for security reports. - -- **Email:** {% if params.contact_email %}`{{ params.contact_email }}`{% else %}`security@` *(placeholder — edit before merging)*{% endif %} -{% if params.contact_url %}- **Form:** {{ params.contact_url }} -{% endif %} -We acknowledge new reports within 3 business days. We aim to triage and -share a remediation plan within {% if params.disclosure_window_days %}{{ params.disclosure_window_days }}{% else %}14{% endif %} days. - -## Supported versions - -Security fixes are backported to the branches below. Older branches receive -fixes only for high-severity issues on a best-effort basis. - -| Version | Supported | -|-----------------|--------------------| -| `main` (latest) | Yes | -| Older revisions | Best-effort only | - -{% if params.supported_versions %}_Maintainer note: {{ params.supported_versions }}_ -{% endif %} - -## Scope - -Security reports are welcome for anything shipped by this repository, including: - -- The application source code committed to `main`. -- Packaging, containers, and deployment manifests under this repo. -- Default configuration and bundled credentials/secrets in repo artifacts. - -Out of scope: - -- Findings about third-party dependencies that do not require a change - here — please file those with the upstream project first. -- Denial-of-service that requires an attacker to already hold - administrator access to the host running this software. - -## Disclosure - -We prefer coordinated disclosure. Once a fix is available we publish a -GitHub Security Advisory and release notes describing the impact and the -upgrade path. Reporters are credited unless they request otherwise. - -## Safe harbour - -We will not pursue legal action against good-faith researchers who: - -- Follow this policy. -- Stop at the proof-of-concept stage — do not exfiltrate data, degrade - services, or pivot beyond the minimum needed to demonstrate the issue. -- Avoid data that is not their own. - ---- - -_Generated by Cliff. Edit this file to match your actual process._ -``` - -### 4. Commit, push, and open a draft PR - -**Important:** write the PR body to a file first and pass it with -`--body-file`. A PR body contains backticks and other shell -meta-characters; using `--body "…"` with inline backticks causes bash -to run whatever sits between them as a command. Heredoc with a -single-quoted delimiter (`<<'MD'`) disables every expansion. - -```bash -cat > /tmp/cliff-pr-body.md <<'MD' -## Summary - -Adds a `SECURITY.md` so researchers know how to report a vulnerability -privately, which versions you back-port fixes to, what's in scope, and -how you expect disclosure to work. - -This PR was generated by Cliff as part of the zero-to-secure posture -checks. Everything below is a starting point — edit before merging. - -## Review checklist - -- [ ] Replace the placeholder contact email with a real one you actually - monitor. -- [ ] Confirm the "Supported versions" table matches how you back-port fixes. -- [ ] Tighten or loosen the disclosure timeline (default: 3 business days - acknowledgement, 14 days to remediation). -- [ ] Tighten the "Scope" section if your out-of-scope list is different. -- [ ] Keep or drop the "Safe harbour" paragraph to match your legal posture. - ---- -Generated by Cliff posture generator. -MD - -git add SECURITY.md -git commit -m "docs: add SECURITY.md (Cliff posture PR)" -git push -u origin HEAD -gh pr create --draft \ - --title "docs: add SECURITY.md" \ - --body-file /tmp/cliff-pr-body.md -``` - -## Rules - -- **Draft PR only.** Never merge, never push to `main`, never force-push. -- **Single commit.** Everything in one commit against the `cliff/posture/security-md` branch. -- **Minimal changes.** Only add or update `SECURITY.md`. Do not touch other files. -- **Be fast.** `--depth 50` for clone. No unrelated exploration. -- **No secrets in the PR.** Never write a live token, private key, or credential. -- **Use `--body-file`, never `--body`, for the PR body.** See step 4. - -## Output contract - -After completing your work, respond with a single JSON code block and nothing -else: - -```json -{ - "summary": "one-line summary of what was done", - "result_card_markdown": "## SECURITY.md PR\n\nMarkdown-formatted details", - "confidence": 0.0, - "evidence_sources": ["files written"], - "suggested_next_action": "review_pr", - "structured_output": { - "status": "pr_created | already_present | failed", - "pr_url": "https://github.com/.../pull/N or null", - "branch_name": "cliff/posture/security-md or null", - "file_path": "SECURITY.md", - "error_details": "description of failure or null" - } -} -``` diff --git a/backend/cliff/agents/templates/validation_checker.md.j2 b/backend/cliff/agents/templates/validation_checker.md.j2 deleted file mode 100644 index b06706e8..00000000 --- a/backend/cliff/agents/templates/validation_checker.md.j2 +++ /dev/null @@ -1,80 +0,0 @@ ---- -description: "Validate fix for: {{ finding.title }}" -mode: subagent ---- - -You are a security validation specialist. Your job is to determine whether a remediation effort actually fixed the vulnerability, or whether the finding remains active. - -## Original finding - -- **Title:** {{ finding.title }} -- **Source:** {{ finding.source_type }} / {{ finding.source_id }} -{% if finding.raw_severity %}- **Severity:** {{ finding.raw_severity }} -{% endif %}{% if finding.asset_label or finding.asset_id %}- **Asset:** {{ finding.asset_label or finding.asset_id }} -{% endif %} - -{% if has_enrichment %} -## What was vulnerable -{% if enrichment.normalized_title %}- **Vulnerability:** {{ enrichment.normalized_title }} -{% endif %}{% if enrichment.cve_ids %}- **CVEs:** {{ enrichment.cve_ids | join(', ') }} -{% endif %}{% if enrichment.affected_versions %}- **Affected versions:** {{ enrichment.affected_versions }} -{% endif %}{% if enrichment.fixed_version %}- **Fix version:** {{ enrichment.fixed_version }} -{% endif %} -{% endif %} - -{% if has_plan %} -## Remediation plan that was executed -{% for step in plan.plan_steps | default([]) %} -{{ loop.index }}. {{ step }} -{% endfor %} - -{% if plan.definition_of_done %} -### Definition of done -{% for item in plan.definition_of_done %} -- {{ item }} -{% endfor %} -{% endif %} - -{% if plan.validation_method %} -### Expected validation method -{{ plan.validation_method }} -{% endif %} -{% endif %} - -## Your task - -Evaluate whether the vulnerability has been resolved. Check each item in the definition of done. Look for evidence that the fix was applied correctly and completely. - -Assess: -1. **Was the fix applied?** Check versions, configurations, code changes. -2. **Is the vulnerability still detectable?** Would a re-scan find the same issue? -3. **Were new issues introduced?** Did the fix break anything or create a new vulnerability? -4. **Are there remaining concerns?** Partial fixes, related vulnerabilities, process gaps. - -## Output contract - -You MUST respond with a single JSON object matching this schema: - -```json -{ - "verdict": "fixed | partially_fixed | not_fixed | inconclusive", - "evidence": "string — concrete evidence supporting the verdict", - "definition_of_done_results": [ - { - "criterion": "string — the DoD item", - "met": true | false | null, - "evidence": "string — how you verified this" - } - ], - "remaining_concerns": ["string — issues that still need attention"] or [], - "recommendation": "close | keep_open | reopen | needs_more_info" -} -``` - -## Guidelines - -- **Require evidence for "fixed".** Do not accept "we deployed the fix" without verification. Look for version numbers, scan results, test outcomes. -- **"Inconclusive" is valid.** If you lack the data to make a determination, say so and specify what data would resolve it. -- **Check the definition of done item by item.** If the plan specified 4 criteria, evaluate all 4 individually. -- **Be conservative.** A "fixed" verdict that turns out to be wrong is worse than an "inconclusive" that prompts a re-check. -- **remaining_concerns should capture secondary issues** — things that are not the original finding but were noticed during validation. diff --git a/backend/cliff/ai/catalog.py b/backend/cliff/ai/catalog.py index 513b2046..6c2c2a73 100644 --- a/backend/cliff/ai/catalog.py +++ b/backend/cliff/ai/catalog.py @@ -23,11 +23,11 @@ class ProviderInfo: """Static facts about one provider. - ``env_var_name`` is the API-key env var OpenCode reads for the provider. - For ``ollama`` (no API key) it's ``None``. ``base_url_env_var`` and - ``default_base_url`` cover providers OpenCode dispatches by base URL - instead of by hard-coded host (today: ``ollama`` always, ``custom`` - when the user supplies a URL). + ``env_var_name`` is the API-key env var the model factory reads for the + provider. For ``ollama`` (no API key) it's ``None``. ``base_url_env_var`` + and ``default_base_url`` cover providers dispatched by base URL instead + of by hard-coded host (today: ``ollama`` always, ``custom`` when the + user supplies a URL). """ env_var_name: str | None @@ -39,11 +39,12 @@ class ProviderInfo: default_base_url: str | None = None -# Model IDs use OpenCode's ``/`` namespace. For -# OpenRouter that means an extra ``openrouter/`` prefix in front of -# OpenRouter's own ``/`` identifier — without it -# OpenCode would dispatch the call through its own ``anthropic`` provider -# config (and expect ``ANTHROPIC_API_KEY``). +# Model ids use Cliff's ``/`` namespace (the model +# factory in ``runtime/provider.py`` partitions on the first ``/`` to pick +# the provider branch). For OpenRouter that means an extra ``openrouter/`` +# prefix in front of OpenRouter's own ``/`` +# identifier — without it the factory would take the ``anthropic`` branch +# and expect ``ANTHROPIC_API_KEY``. _CATALOG: dict[AIProvider, ProviderInfo] = { "openrouter": ProviderInfo( env_var_name="OPENROUTER_API_KEY", @@ -87,11 +88,11 @@ class ProviderInfo: docs_label="Google AI Studio", ), "ollama": ProviderInfo( - # Ollama needs no API key — OpenCode talks to it over - # OpenAI-compatible /v1 on a local port. Leaving env_var_name - # None makes resolve_env_for_workspace skip the key-injection - # branch; we still emit OLLAMA_BASE_URL so OpenCode points at - # the right host. + # Ollama needs no API key — Cliff talks to it over the + # OpenAI-compatible /v1 endpoint on a local port. Leaving + # env_var_name None makes resolve_env_for_workspace skip the + # key-injection branch; we still emit OLLAMA_BASE_URL so the model + # factory points at the right host. env_var_name=None, # No default model — Ollama's available models depend on what # the user has pulled locally. The picker queries /api/tags and @@ -120,7 +121,7 @@ def get(provider: AIProvider) -> ProviderInfo: def env_var_name(provider: AIProvider) -> str | None: - """The env var name OpenCode reads to pick up the key for this provider. + """The API-key env var the model factory reads for this provider. Returns ``None`` for providers that use no API key (``ollama``). """ @@ -128,7 +129,7 @@ def env_var_name(provider: AIProvider) -> str | None: def base_url_env_var(provider: AIProvider) -> str | None: - """The env var name OpenCode reads for the base URL, if applicable.""" + """The base-URL env var the model factory reads, if applicable.""" return _CATALOG[provider].base_url_env_var @@ -142,30 +143,6 @@ def all_providers() -> list[AIProvider]: return list(_CATALOG.keys()) -def provider_env_var_names() -> frozenset[str]: - """Every host env var name Cliff controls for AI providers. - - For each catalogued provider this is its ``*_API_KEY`` plus the - matching ``*_BASE_URL`` (either the implicit ``_API_KEY → _BASE_URL`` - pair OR an explicit ``base_url_env_var`` entry — Ollama uses a name - not derivable from any key var). Callers spawning OpenCode subprocesses - scrub these from the inherited host environment before layering - Cliff's own resolved values on top — otherwise a polluted host leaks - in. Motivating case (QA Q01 B07): Claude Desktop exports - ``ANTHROPIC_BASE_URL=https://api.anthropic.com`` (note: no ``/v1``), - which makes OpenCode hit ``…/messages`` and get a 404, plus an empty - ``ANTHROPIC_API_KEY`` that would otherwise shadow the real one. - """ - names: set[str] = set() - for info in _CATALOG.values(): - if info.env_var_name: - names.add(info.env_var_name) - names.add(info.env_var_name.replace("_API_KEY", "_BASE_URL")) - if info.base_url_env_var: - names.add(info.base_url_env_var) - return frozenset(names) - - def _override_env_var(provider: AIProvider) -> str: return f"CLIFF_AI_MODEL_OVERRIDE_{provider.upper()}" diff --git a/backend/cliff/ai/models.py b/backend/cliff/ai/models.py index 563b03cb..fcb7ec63 100644 --- a/backend/cliff/ai/models.py +++ b/backend/cliff/ai/models.py @@ -55,11 +55,10 @@ class AIStatus(BaseModel): """Wire shape for ``GET /api/integrations/ai/status``. ``model`` is the canonical active model — the one Cliff writes into - ``app_setting(key="model")`` and pushes into every workspace spawn. - Per ADR-0037 there is one canonical state and one read; the - on_key_change hook restarts the singleton OpenCode synchronously on - every model/key write, so there is no separate "what's loaded right - now" signal worth exposing on the wire (architect health-check, M9). + ``app_setting(key="model")`` and the PA model factory reads at each + agent run. Per ADR-0037 / ADR-0047 there is one canonical state and + one read; with the substrate in-process there is no separate "what's + loaded right now" signal worth exposing on the wire. """ state: AIState diff --git a/backend/cliff/ai/service.py b/backend/cliff/ai/service.py index 2eeea654..78c06a1a 100644 --- a/backend/cliff/ai/service.py +++ b/backend/cliff/ai/service.py @@ -4,7 +4,7 @@ ``CredentialVault`` (ADR-0016) — the GitHub App work uses the same pattern (ADR-0035 / IMPL-0010). Workspace callers consume ``resolve_env_for_workspace`` to merge the right ``*_API_KEY`` (and, where applicable, ``*_BASE_URL``) into -per-workspace OpenCode env vars. +the env the Pydantic AI model factory reads (ADR-0047). Provider state lives in two tables that are kept in lockstep: @@ -42,7 +42,6 @@ AIStatus, ValidationResult, ) -from cliff.config import settings as app_settings from cliff.db import repo_integration from cliff.db.repo_setting import delete_setting, get_setting, upsert_setting from cliff.integrations.audit import AuditEvent @@ -62,13 +61,6 @@ CREDENTIAL_KEY_NAME = "api_key" MODEL_SETTING_KEY = "model" -# Providers OpenCode authenticates against via its /auth store. The -# OpenCode provider id is identical to our literal in every case, so we -# just need the *set* of authenticating providers — ``custom`` ships its -# own provider config and ``ollama`` doesn't authenticate. -_OPENCODE_AUTH_PROVIDERS: frozenset[AIProvider] = frozenset( - {"openrouter", "anthropic", "openai", "google"} -) class ModelPrefixMismatchError(ValueError): """Raised when a model id's prefix doesn't match the active provider.""" @@ -96,12 +88,11 @@ def __init__( ) -> None: """Construct the service. - ``on_key_change`` (IMPL-0011 Phase F3 / ADR-0037) — optional async - callable invoked after every save / disconnect / model change - with the new env-var dict (or ``{}`` after disconnect). Used by - ``main.py`` lifespan to push fresh env into the singleton - OpenCode process and restart it. Kept optional so unit tests - don't need the engine wired up. + ``on_key_change`` (ADR-0037 / ADR-0047) — optional async callable + invoked after every save / disconnect / model change with the new + env-var dict (or ``{}`` after disconnect). Used by ``main.py`` + lifespan to refresh the warm env + model cache. Kept optional so + unit tests don't need it wired up. """ self._db = db self._vault = vault @@ -118,11 +109,11 @@ async def get_active(self) -> AIIntegration | None: async def get_status(self) -> AIStatus: """Compose the wire-shape status payload. - Returns the canonical model (the value workspace spawns use). - Per ADR-0037 / architect health-check M9, this is the **one** - read: the on_key_change hook restarts the singleton OpenCode - synchronously on every write, so a separate live probe + drift - signal added complexity without changing product behavior. + Returns the canonical model (the value each agent run uses). Per + ADR-0037 / ADR-0047 this is the **one** read: with the substrate + in-process there's no separate engine config to probe, so a live + probe + drift signal would add complexity without changing + product behavior. """ record = await self.get_active() if record is None: @@ -137,34 +128,16 @@ async def get_status(self) -> AIStatus: model=canonical_model, ) - async def sync_to_opencode(self) -> None: - """Push the active integration's key into OpenCode's auth.json. - - Used at app startup to reconcile users who connected *before* - the auth.json sync was added — without this they'd boot with - an empty auth.json and hit "Missing Authentication header" - until they disconnected and reconnected. - """ - record = await self.get_active() - if record is None: - return - try: - raw_key = await self._vault.retrieve( - record.integration_id, CREDENTIAL_KEY_NAME - ) - except KeyError: - return - await self._sync_opencode_auth(record.provider, raw_key) - async def resolve_env_for_workspace(self) -> dict[str, str]: - """Return the env-var dict to inject into a workspace OpenCode subprocess. + """Return the env-var dict the Pydantic AI model factory reads. Empty dict when unconfigured — the caller treats that as "no AI key - injected" and the agent-button gate keeps the UI from launching + resolved" and the agent-button gate keeps the UI from launching agents anyway. For providers that dispatch by base URL (``ollama``, ``custom``) - the base URL is also injected so OpenCode reaches the right host. + the base URL is also included so the model factory targets the + right host. Stored base URL (in ``ai_integration.metadata.base_url``) wins over the catalog's default. """ @@ -187,10 +160,9 @@ async def resolve_env_for_workspace(self) -> dict[str, str]: record.provider, ) return {} - # Empty credential → treat as unconfigured. Injecting an empty - # env var still routes through OpenCode and fails with an - # opaque 401, and would flip the readiness gate to a falsely - # usable state. + # Empty credential → treat as unconfigured. A blank key would + # still reach the provider and fail with an opaque 401, and + # would flip the readiness gate to a falsely usable state. if not raw_key: logger.error( "AI integration credential for provider %s decrypted to " @@ -394,10 +366,6 @@ async def disconnect(self) -> bool: integration_id=record.integration_id, verb=None, ) - # Clear OpenCode's auth.json entry so a stale key can't keep - # authenticating after disconnect. Best-effort, same rationale - # as `_sync_opencode_auth`. - await self._clear_opencode_auth(record.provider) await self._fire_key_change() return deleted @@ -414,9 +382,8 @@ async def set_model(self, model_full_id: str) -> str: OpenRouter" footgun before workspace spawn tries to use it. Returns the model id that was persisted. Fires the key-change - hook so the singleton OpenCode restarts with the new model in - its config; workspaces pick it up at next spawn via the model - resolver. + hook; workspaces pick the new model up at their next run via the + model resolver (ADR-0047). """ if "/" not in model_full_id: raise ModelPrefixMismatchError( @@ -438,7 +405,6 @@ async def set_model(self, model_full_id: str) -> str: await upsert_setting( self._db, MODEL_SETTING_KEY, {"full_id": model_full_id} ) - _safe_write_opencode_config(model_full_id) await self._fire_key_change() logger.info("AI model set to %s", model_full_id) return model_full_id @@ -502,7 +468,6 @@ async def _sync_canonical_model( return await upsert_setting(self._db, MODEL_SETTING_KEY, {"full_id": chosen}) - _safe_write_opencode_config(chosen) async def _save_internal( self, @@ -550,17 +515,6 @@ async def _save_internal( metadata=metadata, ) - # 4. Sync OpenCode's auth.json. OpenCode 1.3.x reads auth.json - # in preference to the documented env var path on the outbound - # request — without this push, the workspace and singleton - # subprocesses get "Missing Authentication header" from - # upstream providers even though OPENROUTER_API_KEY / etc. are - # present in their env. We keep the env var injection too - # (defense in depth + works on future OpenCode versions that - # honor the docs), but this push is what actually authenticates - # the calls today. - await self._sync_opencode_auth(provider, raw_key) - logger.info( "AI integration saved for provider %s via %s", provider, @@ -568,59 +522,12 @@ async def _save_internal( ) return record - async def _sync_opencode_auth( - self, provider: AIProvider, raw_key: str - ) -> None: - """Best-effort push of *raw_key* into OpenCode's auth.json. - - ``opencode_client`` talks to the singleton on port 4096; auth.json - is global so workspace subprocesses pick the change up at their - next spawn. OpenCode 1.3.x consults auth.json in preference to env - vars on the outbound request — without this push the subprocesses - get "Missing Authentication header" even though ``*_API_KEY`` is - injected. Failures are warning-logged; the env-var path remains as - a fallback. ``custom`` + ``ollama`` skip this — neither uses - OpenCode's /auth store. - """ - if provider not in _OPENCODE_AUTH_PROVIDERS: - return - try: - from cliff.engine.client import opencode_client - - await opencode_client.set_auth( - provider, {"type": "api", "key": raw_key} - ) - except Exception: # noqa: BLE001 - logger.warning( - "Could not push AI key to OpenCode /auth (env-var path " - "will be the only auth source)", - exc_info=True, - ) - - async def _clear_opencode_auth(self, provider: AIProvider) -> None: - """Overwrite OpenCode's auth.json entry with an empty key so the - disconnected provider can't continue authenticating.""" - if provider not in _OPENCODE_AUTH_PROVIDERS: - return - try: - from cliff.engine.client import opencode_client - - await opencode_client.set_auth( - provider, {"type": "api", "key": ""} - ) - except Exception: # noqa: BLE001 - logger.warning( - "Could not clear OpenCode /auth on disconnect", exc_info=True - ) - async def _fire_key_change(self) -> None: """Call the on_key_change hook with the current env, if any. - Never raises — singleton restart failures are non-fatal for the - save path; the user can retry from the UI. Post-M9, this hook - IS the consistency boundary between canonical state and the - singleton OpenCode (the prior live-probe + drift signal was - redundant and has been removed). + Never raises — hook failures are non-fatal for the save path; the + user can retry from the UI. The hook lets callers (e.g. app + startup) refresh any cached env snapshot when the key changes. """ if self._on_key_change is None: return @@ -655,30 +562,6 @@ async def _audit_log( ) -# --------------------------------------------------------------------------- -# Module-level helpers -# --------------------------------------------------------------------------- - - -def _safe_write_opencode_config(model_full_id: str) -> None: - """Reconcile the singleton ``opencode.json`` model; warn but never raise. - - Skips the file write when the current on-disk value already matches - so a redundant ``set_model(X)`` after the connect path wrote the same - X doesn't trigger a needless rewrite + restart cycle. Invalidates the - live-probe cache so the next ``get_status`` reflects the new model. - """ - if app_settings.opencode_model == model_full_id: - return - try: - app_settings.write_opencode_config(model_full_id) - except Exception: # noqa: BLE001 - logger.warning( - "Could not write opencode.json for %s", model_full_id, exc_info=True - ) - return - - __all__ = [ "AIIntegrationService", "ModelPrefixMismatchError", diff --git a/backend/cliff/api/_engine_dep.py b/backend/cliff/api/_engine_dep.py index 8d7657aa..02a8be0d 100644 --- a/backend/cliff/api/_engine_dep.py +++ b/backend/cliff/api/_engine_dep.py @@ -26,7 +26,6 @@ if TYPE_CHECKING: import aiosqlite - from cliff.engine.pool import WorkspaceProcessPool from cliff.models import AssessmentResult, AssessmentTool from cliff.workspace.workspace_dir_manager import WorkspaceKind @@ -35,6 +34,8 @@ StepCallback = Callable[[str], Awaitable[None]] ToolCallback = Callable[["AssessmentTool"], Awaitable[None]] +EnvResolver = Callable[[], Awaitable[dict[str, str]]] +ModelResolver = Callable[[], Awaitable[str | None]] class AssessmentEngineProtocol(Protocol): @@ -179,8 +180,17 @@ async def spawn_repo_workspace( class _DefaultRepoWorkspaceSpawner: """Production spawner backed by ``WorkspaceDirManager.create_repo_workspace``.""" - def __init__(self, pool: WorkspaceProcessPool | None) -> None: - self._pool = pool + def __init__( + self, + *, + env_resolver: EnvResolver, + model_resolver: ModelResolver, + ) -> None: + # The repo-action generator runs in-process via Pydantic AI now + # (IMPL-0022 PR #3c); these resolve the app-level AI provider env + + # active model for ``RepoAgentRunner``. + self._env_resolver = env_resolver + self._model_resolver = model_resolver async def spawn_repo_workspace( self, @@ -200,13 +210,10 @@ async def spawn_repo_workspace( data_dir = settings.resolve_data_dir() base_dir = data_dir / "workspaces" manager = WorkspaceDirManager(base_dir=base_dir) - model = settings.opencode_model or None workspace_id = manager.create_repo_workspace( kind, repo_url=repo_url, params=params, - gh_token=token, - model=model, ) workspace_root = base_dir / workspace_id @@ -225,14 +232,10 @@ async def spawn_repo_workspace( shutil.rmtree(workspace_root, ignore_errors=True) raise - if self._pool is None: - logger.warning( - "repo workspace %s created without a pool — agent will not run", - workspace_id, - ) - return workspace_id - - runner = RepoAgentRunner(self._pool) + runner = RepoAgentRunner( + env_resolver=self._env_resolver, + model_resolver=self._model_resolver, + ) async def _run() -> None: try: @@ -254,6 +257,21 @@ async def _run() -> None: def get_repo_workspace_spawner(request: Request) -> RepoWorkspaceSpawnerProtocol: - """Default provider — returns the real spawner wired to the app's pool.""" - pool = getattr(request.app.state, "process_pool", None) - return _DefaultRepoWorkspaceSpawner(pool=pool) + """Default provider — wires the spawner to the app-level AI resolvers. + + Reads the canonical AI env + model from ``app.state`` at run time (the + lifespan refresh keeps these current), so a background repo-agent run + picks up a provider/model change without a restart. + """ + app = request.app + + async def _env_resolver() -> dict[str, str]: + return dict(getattr(app.state, "ai_env_cache", {}) or {}) + + async def _model_resolver() -> str | None: + return getattr(app.state, "ai_model_cache", None) + + return _DefaultRepoWorkspaceSpawner( + env_resolver=_env_resolver, + model_resolver=_model_resolver, + ) diff --git a/backend/cliff/api/routes/ai_integrations.py b/backend/cliff/api/routes/ai_integrations.py index 656a12da..b5baefcf 100644 --- a/backend/cliff/api/routes/ai_integrations.py +++ b/backend/cliff/api/routes/ai_integrations.py @@ -75,9 +75,9 @@ def _get_service(request: Request, db: aiosqlite.Connection) -> AIIntegrationSer status_code=503, detail="Credential vault not initialized.", ) - # IMPL-0011 Phase F3: singleton OpenCode restart hook. Wired on - # app.state in main.py lifespan so every per-request service shares - # the same engine handle. + # AI key-change hook — wired on app.state in main.py lifespan so every + # per-request service refreshes the warm env + model cache after a + # connect / disconnect / model change (ADR-0047). on_key_change = getattr(request.app.state, "ai_on_key_change", None) return AIIntegrationService( db, vault, audit_logger=audit, on_key_change=on_key_change diff --git a/backend/cliff/api/routes/health.py b/backend/cliff/api/routes/health.py index 4e7e8d69..62a3c228 100644 --- a/backend/cliff/api/routes/health.py +++ b/backend/cliff/api/routes/health.py @@ -4,47 +4,33 @@ from fastapi import APIRouter, Request -from cliff.config import settings -from cliff.engine.client import opencode_client -from cliff.engine.models import HealthStatus -from cliff.engine.process import opencode_process +from cliff.models import HealthStatus, substrate_version router = APIRouter() @router.get("/health", response_model=HealthStatus) async def health(request: Request) -> HealthStatus: - oc_healthy = await opencode_process.health_check() - - # Read model from OpenCode runtime (not the file, which can be stale). - model = "" - if oc_healthy: - try: - config = await opencode_client.get_config() - model = config.get("model", "") - except Exception: - pass - if not model: - model = settings.opencode_model - - # ``ai_env_cache`` is the exact env dict the workspace process pool - # injects into every per-workspace OpenCode subprocess. A non-empty - # cache means a provider credential is present *and* resolved (vault - # decrypt succeeded) — i.e. genuinely reachable by the subprocess. - # ``ai_provider_credential_ok`` adds the last piece (Q01-B02): the - # resolved credential was live-probed at boot / on connect and did not - # come back as a definitive auth rejection. ``ai_provider_ready`` is - # only True when both hold — a present-but-revoked key reads as not - # ready, exactly as it behaves at agent-run time. + # The agent substrate runs in-process via Pydantic AI — there's no + # subprocess to probe, so "opencode" is always "ok" when the app is up. + # The field shape is kept for backward compatibility (frontend health + # card + cliffsec status); see HealthStatus. + + # ``ai_model_cache`` is the canonical active model resolved at boot / on + # provider change (ADR-0047); empty string when no provider is connected. + model = getattr(request.app.state, "ai_model_cache", None) + + # ``ai_env_cache`` is the resolved provider env. A non-empty cache means a + # provider credential is present *and* resolved (vault decrypt succeeded); + # ``ai_provider_credential_ok`` adds that it was live-probed and not a + # definitive auth rejection. ``ai_provider_ready`` requires both. ai_env_cache = getattr(request.app.state, "ai_env_cache", None) or {} - credential_ok = getattr( - request.app.state, "ai_provider_credential_ok", False - ) + credential_ok = getattr(request.app.state, "ai_provider_credential_ok", False) return HealthStatus( cliff="ok", - opencode="ok" if oc_healthy else "unavailable", - opencode_version=settings.opencode_version, - model=model, + opencode="ok", + opencode_version=substrate_version(), + model=model or "", ai_provider_ready=bool(ai_env_cache) and credential_ok, ) diff --git a/backend/cliff/api/routes/settings.py b/backend/cliff/api/routes/settings.py index 75463b24..1610c1f7 100644 --- a/backend/cliff/api/routes/settings.py +++ b/backend/cliff/api/routes/settings.py @@ -7,10 +7,10 @@ import time from typing import TYPE_CHECKING -import httpx from fastapi import APIRouter, Depends, HTTPException, Request from pydantic import BaseModel +from cliff.ai import catalog from cliff.config import settings as app_settings from cliff.db.connection import get_db from cliff.db.repo_integration import ( @@ -20,8 +20,6 @@ list_integrations, update_integration, ) -from cliff.engine.client import opencode_client -from cliff.engine.config_manager import config_manager from cliff.integrations.audit import AuditEvent from cliff.integrations.connection_tester import run_connection_test from cliff.integrations.github_app.client import build_install_url @@ -33,7 +31,6 @@ ) from cliff.integrations.vault import CredentialKeyError from cliff.models import ( - ApiKeyCreate, CredentialCreate, CredentialInfo, IntegrationConfig, @@ -42,6 +39,7 @@ IntegrationHealthStatus, ModelConfig, ModelUpdateRequest, + ProviderInfo, TestConnectionResult, ) @@ -70,15 +68,25 @@ async def _emit_audit(request: Request, **kwargs) -> None: # --------------------------------------------------------------------------- +def _model_config(full_id: str) -> ModelConfig: + """Split a canonical ``/`` id into a ``ModelConfig``.""" + parts = full_id.split("/", 1) + return ModelConfig( + model_full_id=full_id, + provider=parts[0] if len(parts) == 2 else "", + model_id=parts[1] if len(parts) == 2 else full_id, + ) + + @router.get("/settings/model", response_model=ModelConfig) async def get_model(request: Request, db=Depends(get_db)): """Return the canonical active model (ADR-0037). Thin shim over :class:`AIIntegrationService` so the CLI (``cliffsec - model get``) and the new Settings UI agree byte-for-byte. Falls - back to the old ``opencode.json``-derived value when no AI - provider is connected so legacy users without an ``ai_integration`` - row still get something meaningful. + model get``) and the Settings UI agree byte-for-byte. Returns an + empty :class:`ModelConfig` when no AI provider is connected yet + (fresh install) — the UI treats a blank ``model_full_id`` as "no + model set" and the agent-launch gate keeps things safe. """ vault = getattr(request.app.state, "vault", None) if vault is not None: @@ -87,58 +95,38 @@ async def get_model(request: Request, db=Depends(get_db)): service = AIIntegrationService(db, vault) full_id = await service.resolve_model_for_workspace() if full_id: - parts = full_id.split("/", 1) - return ModelConfig( - model_full_id=full_id, - provider=parts[0] if len(parts) == 2 else "", - model_id=parts[1] if len(parts) == 2 else full_id, - ) - try: - return await config_manager.get_model() - except Exception as exc: - raise HTTPException(status_code=502, detail=f"OpenCode unavailable: {exc}") from exc + return _model_config(full_id) + return ModelConfig(model_full_id="", provider="", model_id="") @router.put("/settings/model", response_model=ModelConfig) async def update_model(body: ModelUpdateRequest, request: Request, db=Depends(get_db)): """Persist a model change (ADR-0037). - Routes through :class:`AIIntegrationService.set_model` when a - provider is connected. On a fresh install with no provider yet, - falls through to the legacy ``config_manager.update_model`` so - ``cliffsec model set`` during install still works before BYOK. + Routes through :class:`AIIntegrationService.set_model`, which writes + the canonical ``app_setting(model)``. Requires a connected provider — + a model can't be chosen before picking who serves it. """ vault = getattr(request.app.state, "vault", None) - if vault is not None: - from cliff.ai import repo as ai_repo - from cliff.ai.service import ( - AIIntegrationService, - ModelPrefixMismatchError, + if vault is None: + raise HTTPException( + status_code=503, + detail="Credential vault not initialized. Set CLIFF_CREDENTIAL_KEY.", ) - active = await ai_repo.get_active(db) - if active is not None: - on_key_change = getattr(request.app.state, "ai_on_key_change", None) - service = AIIntegrationService( - db, vault, on_key_change=on_key_change - ) - try: - await service.set_model(body.model_full_id) - except ModelPrefixMismatchError as exc: - raise HTTPException(status_code=400, detail=str(exc)) from exc - parts = body.model_full_id.split("/", 1) - return ModelConfig( - model_full_id=body.model_full_id, - provider=parts[0] if len(parts) == 2 else "", - model_id=parts[1] if len(parts) == 2 else body.model_full_id, - ) + from cliff.ai.service import ( + AIIntegrationService, + ModelPrefixMismatchError, + NoActiveProviderError, + ) + on_key_change = getattr(request.app.state, "ai_on_key_change", None) + service = AIIntegrationService(db, vault, on_key_change=on_key_change) try: - return await config_manager.update_model(db, body.model_full_id) - except ValueError as exc: + await service.set_model(body.model_full_id) + except (ModelPrefixMismatchError, NoActiveProviderError) as exc: raise HTTPException(status_code=400, detail=str(exc)) from exc - except Exception as exc: - raise HTTPException(status_code=502, detail=f"OpenCode unavailable: {exc}") from exc + return _model_config(body.model_full_id) # --------------------------------------------------------------------------- @@ -146,22 +134,35 @@ async def update_model(body: ModelUpdateRequest, request: Request, db=Depends(ge # --------------------------------------------------------------------------- -@router.get("/settings/providers") -async def list_providers(): - try: - return await config_manager.list_available_providers() - except Exception as exc: - raise HTTPException(status_code=502, detail=f"OpenCode unavailable: {exc}") from exc +@router.get("/settings/providers", response_model=list[ProviderInfo]) +async def list_providers() -> list[ProviderInfo]: + """Return the supported-provider catalog (ADR-0037). - -@router.get("/settings/providers/configured") -async def get_configured_providers(): - try: - providers = await config_manager.get_configured_providers() - auth = await config_manager.get_auth_status() - return {"providers": providers, "auth": auth} - except Exception as exc: - raise HTTPException(status_code=502, detail=f"OpenCode unavailable: {exc}") from exc + Built from the static :mod:`cliff.ai.catalog` — one entry per + provider with its key env var and the curated model picker rows. The + wire shape (``{id, name, env, models}`` with ``models`` keyed by the + bare model id) is what the Settings model picker and ``cliffsec model + list`` consume. + """ + payload: list[ProviderInfo] = [] + for provider in catalog.all_providers(): + info = catalog.get(provider) + models: dict[str, dict] = {} + for opt in catalog.picker_options(provider): + # The picker id is the full ``/`` id; key by + # the bare model id so ``f"{provider}/{model_id}"`` round-trips + # (the UI and CLI both rebuild the full id that way). + bare = opt.id.split("/", 1)[1] if "/" in opt.id else opt.id + models[bare] = {"id": bare, "name": opt.label} + payload.append( + ProviderInfo( + id=provider, + name=info.docs_label, + env=[info.env_var_name] if info.env_var_name else [], + models=models, + ) + ) + return payload # --------------------------------------------------------------------------- @@ -173,7 +174,8 @@ class ProviderTestRequest(BaseModel): """Optional staged config. Alpha passes nothing and probes the currently configured provider/model/key; a future UI can preview unsaved staged config by populating these fields. Ignored today — probe uses whatever - OpenCode has configured — but kept so the wire shape is stable. + the canonical AI state has configured — but kept so the wire shape is + stable. """ provider: str | None = None @@ -188,12 +190,11 @@ class ProviderTestResult(BaseModel): error_message: str | None = None -# The probe sends a real "Say OK" through OpenCode and waits for the full -# assistant reply. The slowest realistic path is OpenRouter → small model -# (Haiku, Hy3) where queue + cold-start + inference + token streaming -# routinely lands at 10-20s on the first call. 30s gives the worst-case -# real run room to complete; the UI shows a "Testing…" spinner the whole -# time so the wait is visible. +# The probe sends a real "Say OK" through the configured provider and waits +# for the assistant reply. The slowest realistic path is OpenRouter → small +# model where queue + cold-start + inference routinely lands at 10-20s on the +# first call. 30s gives the worst-case real run room to complete; the UI +# shows a "Testing…" spinner the whole time so the wait is visible. _PROBE_TIMEOUT_SECONDS = 30.0 _PROBE_PROMPT = "Say OK" @@ -231,33 +232,64 @@ def _error_message_for(code: str, body: str) -> str: response_model=ProviderTestResult, ) async def test_provider( + request: Request, + db=Depends(get_db), body: ProviderTestRequest | None = None, # noqa: ARG001 — shape-stable ) -> ProviderTestResult: """End-to-end probe of the configured provider+model (ADR-0031). - Sends a bounded ``"Say OK"`` chat call through OpenCode with a 30s + Sends a bounded ``"Say OK"`` call through Pydantic AI with a 30s timeout and classifies the outcome into ``{ok, latency_ms, error_code, error_message}``. Always returns HTTP 200; ``ok`` reflects the probe result. """ - return await _probe_opencode(opencode_client) + vault = getattr(request.app.state, "vault", None) + if vault is None: + return ProviderTestResult( + ok=False, + latency_ms=0, + error_code="other", + error_message="Credential vault not initialized.", + ) + from cliff.ai.service import AIIntegrationService + + service = AIIntegrationService(db, vault) + env = await service.resolve_env_for_workspace() + model = await service.resolve_model_for_workspace() + return await _probe_pa(env, model) + + +async def _probe_pa(env: dict[str, str], model: str | None) -> ProviderTestResult: + """Build the canonical PA model and run one bounded ``"Say OK"`` turn.""" + from pydantic_ai import Agent + from pydantic_ai.exceptions import ( + ModelHTTPError, + UnexpectedModelBehavior, + UsageLimitExceeded, + UserError, + ) + from cliff.agents.runtime.provider import ProviderConfigurationError, build_model -async def _probe_opencode(client) -> ProviderTestResult: start = time.monotonic() def _elapsed_ms() -> int: return int((time.monotonic() - start) * 1000) try: - session = await client.create_session() - response = await asyncio.wait_for( - client.send_and_get_response( - session.id, - _PROBE_PROMPT, - timeout=_PROBE_TIMEOUT_SECONDS, - ), - timeout=_PROBE_TIMEOUT_SECONDS + 1.0, + pa_model = build_model(env, model) + except ProviderConfigurationError as exc: + return ProviderTestResult( + ok=False, + latency_ms=0, + error_code="other", + error_message=str(exc)[:200] or "No AI provider configured.", + ) + + agent = Agent(pa_model, output_type=str) + try: + await asyncio.wait_for( + agent.run(_PROBE_PROMPT), timeout=_PROBE_TIMEOUT_SECONDS ) except TimeoutError: return ProviderTestResult( @@ -266,22 +298,21 @@ def _elapsed_ms() -> int: error_code="timeout", error_message=_ERROR_COPY["timeout"], ) - except httpx.HTTPStatusError as exc: - body = exc.response.text if exc.response is not None else "" - status = exc.response.status_code if exc.response is not None else 0 - code = _classify_http_error(status, body) + except ModelHTTPError as exc: + body = str(getattr(exc, "body", "") or "") + code = _classify_http_error(exc.status_code, body) return ProviderTestResult( ok=False, latency_ms=_elapsed_ms(), error_code=code, error_message=_error_message_for(code, body), ) - except (httpx.ConnectError, httpx.ReadTimeout, httpx.WriteTimeout) as exc: + except (UsageLimitExceeded, UnexpectedModelBehavior, UserError) as exc: return ProviderTestResult( ok=False, latency_ms=_elapsed_ms(), - error_code="timeout", - error_message=_error_message_for("timeout", str(exc)), + error_code="other", + error_message=str(exc)[:200] or "Probe failed", ) except Exception as exc: # noqa: BLE001 — classify, don't leak return ProviderTestResult( @@ -291,38 +322,9 @@ def _elapsed_ms() -> int: error_message=str(exc)[:200] or "Probe failed", ) - if not response: - return ProviderTestResult( - ok=False, - latency_ms=_elapsed_ms(), - error_code="timeout", - error_message=_ERROR_COPY["timeout"], - ) return ProviderTestResult(ok=True, latency_ms=_elapsed_ms()) -# --------------------------------------------------------------------------- -# API Keys -# --------------------------------------------------------------------------- - - -@router.get("/settings/api-keys") -async def list_api_keys(db=Depends(get_db)): - return await config_manager.get_api_keys(db) - - -@router.put("/settings/api-keys/{provider}") -async def set_api_key(provider: str, body: ApiKeyCreate, db=Depends(get_db)): - return await config_manager.set_api_key(db, provider, body.key) - - -@router.delete("/settings/api-keys/{provider}", status_code=204) -async def delete_api_key(provider: str, db=Depends(get_db)): - deleted = await config_manager.delete_api_key(db, provider) - if not deleted: - raise HTTPException(status_code=404, detail="API key not found") - - # --------------------------------------------------------------------------- # Integration registry # --------------------------------------------------------------------------- diff --git a/backend/cliff/api/routes/version.py b/backend/cliff/api/routes/version.py index 3fb72d91..f94c4422 100644 --- a/backend/cliff/api/routes/version.py +++ b/backend/cliff/api/routes/version.py @@ -16,7 +16,7 @@ from fastapi import APIRouter from cliff.config import settings -from cliff.engine.models import VersionInfo +from cliff.models import VersionInfo, substrate_version router = APIRouter() @@ -31,7 +31,7 @@ async def get_version() -> VersionInfo: return VersionInfo( cliff=settings.cliff_version, - opencode=settings.opencode_version, + opencode=substrate_version(), schema_version=_SCHEMA, min_cli=_MIN_CLI, ) diff --git a/backend/cliff/api/routes/workspaces.py b/backend/cliff/api/routes/workspaces.py index 5f096bf1..ce744060 100644 --- a/backend/cliff/api/routes/workspaces.py +++ b/backend/cliff/api/routes/workspaces.py @@ -8,10 +8,7 @@ from typing import TYPE_CHECKING from fastapi import APIRouter, Depends, HTTPException, Request, Response -from pydantic import BaseModel -from sse_starlette.sse import EventSourceResponse -from cliff.api.tasks import fire_and_forget_send from cliff.db.connection import get_db from cliff.db.repo_finding import ( get_finding, @@ -29,7 +26,6 @@ if TYPE_CHECKING: import aiosqlite - from cliff.engine.pool import WorkspaceProcessPool from cliff.workspace.context_builder import WorkspaceContextBuilder logger = logging.getLogger(__name__) @@ -42,10 +38,6 @@ # --------------------------------------------------------------------------- -def _get_pool(request: Request) -> WorkspaceProcessPool: - return request.app.state.process_pool - - def _get_context_builder(request: Request) -> WorkspaceContextBuilder: return request.app.state.context_builder @@ -240,183 +232,13 @@ async def update_workspace_endpoint( async def delete_workspace_endpoint( workspace_id: str, request: Request, db=Depends(get_db) ): - """Delete workspace: stop process, remove directory, delete DB row.""" - pool = _get_pool(request) - await pool.stop(workspace_id) - + """Delete workspace: remove directory + DB row.""" context_builder = _get_context_builder(request) deleted = await context_builder.delete_workspace(db, workspace_id) if not deleted: raise HTTPException(status_code=404, detail="Workspace not found") -# --------------------------------------------------------------------------- -# Workspace-scoped sessions -# --------------------------------------------------------------------------- - - -@router.post("/workspaces/{workspace_id}/sessions") -async def create_workspace_session( - workspace_id: str, request: Request, db=Depends(get_db) -): - """Create an OpenCode session on this workspace's isolated process.""" - workspace = await _get_workspace_or_404(db, workspace_id) - if not workspace.workspace_dir: - raise HTTPException(status_code=409, detail="Workspace has no directory") - - pool = _get_pool(request) - env_vars = await _resolve_repo_env_vars(request, db, workspace=workspace) - client = await pool.get_or_start( - workspace_id, Path(workspace.workspace_dir), env_vars=env_vars - ) - session = await client.create_session() - return {"session_id": session.id, "workspace_id": workspace_id} - - -# --------------------------------------------------------------------------- -# Workspace-scoped chat -# --------------------------------------------------------------------------- - - -class WorkspaceChatRequest(BaseModel): - session_id: str - content: str - - -@router.post("/workspaces/{workspace_id}/chat/send") -async def workspace_send_message( - workspace_id: str, - body: WorkspaceChatRequest, - request: Request, - db=Depends(get_db), -): - """Send a message to this workspace's OpenCode process.""" - workspace = await _get_workspace_or_404(db, workspace_id) - if not workspace.workspace_dir: - raise HTTPException(status_code=409, detail="Workspace has no directory") - - pool = _get_pool(request) - env_vars = await _resolve_repo_env_vars(request, db, workspace=workspace) - client = await pool.get_or_start( - workspace_id, Path(workspace.workspace_dir), env_vars=env_vars - ) - - fire_and_forget_send(client.send_message(body.session_id, body.content)) - return {"session_id": body.session_id, "status": "sent"} - - -@router.get("/workspaces/{workspace_id}/chat/stream") -async def workspace_stream_events( - workspace_id: str, - session_id: str, - request: Request, - db=Depends(get_db), -): - """Stream SSE events from this workspace's OpenCode process.""" - workspace = await _get_workspace_or_404(db, workspace_id) - if not workspace.workspace_dir: - raise HTTPException(status_code=409, detail="Workspace has no directory") - - pool = _get_pool(request) - env_vars = await _resolve_repo_env_vars(request, db, workspace=workspace) - client = await pool.get_or_start( - workspace_id, Path(workspace.workspace_dir), env_vars=env_vars - ) - - async def event_generator(): - try: - async for event in client.stream_events(session_id): - event_type = event.get("type", "message") - if event_type == "text": - yield {"event": "text", "data": event.get("content", "")} - elif event_type == "error": - yield { - "event": "error", - "data": json.dumps( - {"message": event.get("message", "Unknown error")} - ), - } - elif event_type == "permission_request": - yield { - "event": "permission_request", - "data": json.dumps({ - "id": event.get("id", ""), - "tool": event.get("tool", "unknown"), - "patterns": event.get("patterns", []), - "session_id": session_id, - }), - } - elif event_type == "done": - yield {"event": "done", "data": "{}"} - return - except Exception: - logger.exception( - "Error streaming for workspace %s session %s", - workspace_id, - session_id, - ) - yield { - "event": "error", - "data": json.dumps({"message": "Stream disconnected"}), - } - - return EventSourceResponse(event_generator()) - - -# --------------------------------------------------------------------------- -# Workspace-level permission approval (chat path) -# --------------------------------------------------------------------------- - - -class ChatPermissionDecision(BaseModel): - permission_id: str - session_id: str - approved: bool - - -@router.post("/workspaces/{workspace_id}/chat/permission") -async def respond_to_chat_permission( - workspace_id: str, - body: ChatPermissionDecision, - request: Request, - db=Depends(get_db), -): - """Approve or deny a permission request from the chat path. - - Unlike the agent-execution permission endpoint, this calls - OpenCode's permission API directly (no executor involved). - """ - workspace = await _get_workspace_or_404(db, workspace_id) - if not workspace.workspace_dir: - raise HTTPException(status_code=409, detail="Workspace has no directory") - - pool = _get_pool(request) - env_vars = await _resolve_repo_env_vars(request, db, workspace=workspace) - client = await pool.get_or_start( - workspace_id, Path(workspace.workspace_dir), env_vars=env_vars - ) - - try: - if body.approved: - await client.grant_permission( - body.permission_id, session_id=body.session_id, - ) - else: - await client.deny_permission( - body.permission_id, session_id=body.session_id, - ) - except Exception as exc: - raise HTTPException( - status_code=502, - detail=f"Failed to send permission decision to OpenCode: {exc}", - ) from exc - - return { - "status": "approved" if body.approved else "denied", - "permission_id": body.permission_id, - } - - # --------------------------------------------------------------------------- # Workspace context # --------------------------------------------------------------------------- @@ -434,17 +256,6 @@ async def get_workspace_context(workspace_id: str, request: Request): ) -@router.get("/workspaces/{workspace_id}/pool-status") -async def workspace_pool_status(workspace_id: str, request: Request): - """Debug endpoint: show process pool status for this workspace.""" - pool = _get_pool(request) - full_status = pool.status() - ws_status = full_status["workspaces"].get(workspace_id) - if ws_status is None: - return {"workspace_id": workspace_id, "process_running": False} - return {"workspace_id": workspace_id, "process_running": True, **ws_status} - - @router.get("/workspaces/{workspace_id}/integrations") async def get_workspace_integrations( workspace_id: str, request: Request, db=Depends(get_db) diff --git a/backend/cliff/config.py b/backend/cliff/config.py index 2898479a..1ea7b102 100644 --- a/backend/cliff/config.py +++ b/backend/cliff/config.py @@ -2,8 +2,6 @@ from __future__ import annotations -import contextlib -import json import os from pathlib import Path @@ -11,10 +9,10 @@ def _find_repo_root() -> Path: - """Walk up from this file to find the repo root (contains .opencode-version).""" + """Walk up from this file to find the repo root (contains the VERSION file).""" current = Path(__file__).resolve().parent for _ in range(10): - if (current / ".opencode-version").exists(): + if (current / "VERSION").exists(): return current current = current.parent return Path(__file__).resolve().parent.parent.parent @@ -28,11 +26,6 @@ class Settings(BaseSettings): # Demo mode — auto-seed sample findings on startup demo: bool = False - # OpenCode engine (singleton) - opencode_host: str = "127.0.0.1" - opencode_port: int = 4096 - opencode_bin: str = "" # Auto-resolved if empty - # Credential vault credential_key: str = "" # Base64-encoded 32-byte AES key (or set CLIFF_CREDENTIAL_KEY) @@ -76,11 +69,6 @@ class Settings(BaseSettings): # Audit logging audit_retention_days: int = 90 - # Workspace process pool - opencode_port_range_start: int = 4100 - opencode_port_range_end: int = 4199 - workspace_idle_timeout_seconds: int = 600 - # Push-access runtime probe (Q01R-W3 / B37 / IMPL-0019). The probe spawns # ``git push --dry-run HEAD:refs/heads/cliff-push-probe`` # from an ephemeral bootstrapped git repo to verify at the wire level that @@ -118,33 +106,6 @@ class Settings(BaseSettings): model_config = {"env_prefix": "CLIFF_"} - @property - def opencode_url(self) -> str: - return f"http://{self.opencode_host}:{self.opencode_port}" - - @property - def opencode_binary_path(self) -> Path: - if self.opencode_bin: - return Path(self.opencode_bin) - # Check common locations - home_bin = Path.home() / ".cliff" / "bin" / "opencode" - if home_bin.exists(): - return home_bin - # Check PATH - from shutil import which - - found = which("opencode") - if found: - return Path(found) - return home_bin # Default install location - - @property - def opencode_version(self) -> str: - version_file = self.repo_root / ".opencode-version" - if version_file.exists(): - return version_file.read_text().strip() - return "latest" - @property def cliff_version(self) -> str: version_file = self.repo_root / "VERSION" @@ -152,28 +113,6 @@ def cliff_version(self) -> str: return version_file.read_text().strip() return "0.0.0" - @property - def opencode_model(self) -> str: - """Read the configured model from opencode.json.""" - config_file = self.repo_root / "opencode.json" - if config_file.exists(): - try: - data = json.loads(config_file.read_text()) - return data.get("model", "") - except (json.JSONDecodeError, OSError): - pass - return "" - - def write_opencode_config(self, model: str) -> None: - """Update the model in opencode.json, preserving other fields.""" - config_file = self.repo_root / "opencode.json" - data: dict = {} - if config_file.exists(): - with contextlib.suppress(json.JSONDecodeError, OSError): - data = json.loads(config_file.read_text()) - data["model"] = model - config_file.write_text(json.dumps(data, indent=2) + "\n") - def resolve_data_dir(self) -> Path: d = self.data_dir if self.data_dir and str(self.data_dir) else self.repo_root / "data" d.mkdir(parents=True, exist_ok=True) diff --git a/backend/cliff/engine/__init__.py b/backend/cliff/engine/__init__.py deleted file mode 100644 index bfb07b38..00000000 --- a/backend/cliff/engine/__init__.py +++ /dev/null @@ -1 +0,0 @@ -"""OpenCode engine integration — process manager and HTTP client.""" diff --git a/backend/cliff/engine/client.py b/backend/cliff/engine/client.py deleted file mode 100644 index ab272825..00000000 --- a/backend/cliff/engine/client.py +++ /dev/null @@ -1,426 +0,0 @@ -"""Async HTTP client for the OpenCode REST API.""" - -from __future__ import annotations - -import asyncio -import json -import logging -from typing import TYPE_CHECKING - -import httpx - -from cliff.config import settings -from cliff.engine.models import MessageInfo, SessionDetail, SessionSummary - -if TYPE_CHECKING: - from collections.abc import AsyncIterator - -logger = logging.getLogger(__name__) - - -class OpenCodeClient: - """Wraps the OpenCode server REST API. - - Two interaction modes for sending messages: - - **Mode 1 — Synchronous RPC** (simple, for batch/background work): - Use ``send_and_get_response(session_id, content)`` which blocks - until the LLM finishes and returns the assistant's text. No SSE - stream management needed. - - **Mode 2 — Streaming observer** (real-time progress): - Connect ``stream_events(session_id)`` *first*, then call - ``send_message()`` in a delayed background task so the listener - is already subscribed when events fire. See ``AgentExecutor`` - for the reference implementation. - - Do NOT call ``send_message()`` followed by ``stream_events()`` — - ``send_message`` blocks until the LLM is done, so by the time the - stream connects, ``session.idle`` has already fired. - """ - - def __init__(self, base_url: str | None = None) -> None: - self.base_url = base_url or settings.opencode_url - self._client: httpx.AsyncClient | None = None - - async def _get_client(self) -> httpx.AsyncClient: - if self._client is None or self._client.is_closed: - self._client = httpx.AsyncClient( - base_url=self.base_url, - timeout=httpx.Timeout(30.0, connect=5.0), - ) - return self._client - - async def close(self) -> None: - if self._client and not self._client.is_closed: - await self._client.aclose() - self._client = None - - # --- Sessions --- - - async def create_session(self) -> SessionSummary: - """Create a new OpenCode session.""" - client = await self._get_client() - resp = await client.post("/session") - resp.raise_for_status() - data = resp.json() - return SessionSummary( - id=data.get("id", data.get("sessionID", "")), - created_at=data.get("created_at"), - ) - - async def delete_session(self, session_id: str) -> None: - """Delete an OpenCode session. Caller should suppress errors.""" - client = await self._get_client() - resp = await client.delete(f"/session/{session_id}") - resp.raise_for_status() - - async def list_sessions(self) -> list[SessionSummary]: - """List all active sessions.""" - client = await self._get_client() - resp = await client.get("/session") - resp.raise_for_status() - data = resp.json() - sessions = data if isinstance(data, list) else data.get("sessions", []) - return [ - SessionSummary( - id=s.get("id", s.get("sessionID", "")), - created_at=s.get("created_at"), - ) - for s in sessions - ] - - async def _fetch_messages(self, session_id: str) -> list[dict]: - """Fetch raw messages from ``GET /session/{id}/message``. - - Returns the parsed JSON list. Raises on network/HTTP errors so - callers can decide whether to propagate or suppress. - """ - client = await self._get_client() - resp = await client.get(f"/session/{session_id}/message") - resp.raise_for_status() - data = resp.json() - return data if isinstance(data, list) else [] - - @staticmethod - def _extract_text(msg: dict) -> str: - """Extract concatenated text and reasoning parts from a message.""" - parts = msg.get("parts", []) - text_parts = [ - p.get("text", "") - for p in parts - if p.get("type") in ("text", "reasoning") and p.get("text", "").strip() - ] - return "\n".join(text_parts) - - async def get_session(self, session_id: str) -> SessionDetail: - """Get session details including messages from OpenCode.""" - client = await self._get_client() - resp = await client.get(f"/session/{session_id}") - resp.raise_for_status() - data = resp.json() - - try: - raw_messages = await self._fetch_messages(session_id) - except Exception: - logger.warning("Could not fetch messages for session %s", session_id, exc_info=True) - raw_messages = [] - messages: list[MessageInfo] = [] - session_model = "" - - for m in raw_messages: - info = m.get("info", m) - role = info.get("role", "") - msg_id = info.get("id", "") - - # Extract model from message metadata. - if not session_model: - if role == "assistant": - provider_id = info.get("providerID", "") - model_id = info.get("modelID", "") - if provider_id and model_id: - session_model = f"{provider_id}/{model_id}" - elif role == "user": - model_info = info.get("model", {}) - if isinstance(model_info, dict): - provider_id = model_info.get("providerID", "") - model_id = model_info.get("modelID", "") - if provider_id and model_id: - session_model = f"{provider_id}/{model_id}" - - content = self._extract_text(m) - if content: - messages.append( - MessageInfo(id=msg_id, role=role, content=content) - ) - - return SessionDetail( - id=data.get("id", data.get("sessionID", session_id)), - created_at=data.get("created_at"), - messages=messages, - model=session_model, - ) - - # --- Messages --- - - async def get_last_assistant_text(self, session_id: str) -> str | None: - """Return the last assistant text from a session's message history. - - Used after ``send_message`` completes (which blocks until the LLM - finishes) to read the response without SSE. Part of Mode 1 - (synchronous RPC). - """ - for msg in reversed(await self._fetch_messages(session_id)): - info = msg.get("info", msg) - if info.get("role") != "assistant": - continue - text = self._extract_text(msg) - if text: - return text - return None - - async def send_message( - self, session_id: str, content: str, *, timeout: float = 120.0, - ) -> None: - """Send a message to an OpenCode session. - - IMPORTANT: This call **blocks** until the LLM finishes generating - its response (typically 10–120 s). Returns ``None`` on success. - - ``timeout`` is the HTTP-level deadline on the POST call. Callers - that can tolerate only a short wait (e.g. the provider probe in - ADR-0031) pass a smaller value. Defaults to 120 s to preserve - existing long-running agent behaviour. - - To get the response text afterward, use one of: - - ``get_last_assistant_text(session_id)`` — simple, deterministic - - ``stream_events(session_id)`` — must be connected **before** - calling this method (see ``AgentExecutor`` for that pattern) - """ - client = await self._get_client() - resp = await client.post( - f"/session/{session_id}/message", - json={"parts": [{"type": "text", "text": content}]}, - timeout=httpx.Timeout(timeout, connect=5.0), - ) - resp.raise_for_status() - - async def send_and_get_response( - self, session_id: str, content: str, - timeout: float = 120.0, poll_interval: float = 1.0, - ) -> str | None: - """Send a message and return the assistant's response text. - - The OpenCode ``POST /session/{id}/message`` API returns - immediately (non-blocking). This method polls the message - history until an assistant reply appears or *timeout* seconds - have elapsed. ``timeout`` is threaded through to - ``send_message`` so the HTTP call itself also respects it. - """ - await self.send_message(session_id, content, timeout=timeout) - - deadline = asyncio.get_event_loop().time() + timeout - while asyncio.get_event_loop().time() < deadline: - text = await self.get_last_assistant_text(session_id) - if text: - return text - await asyncio.sleep(poll_interval) - - logger.warning( - "send_and_get_response timed out after %.0fs for session %s", - timeout, session_id, - ) - return None - - # --- Event streaming --- - - async def stream_events(self, session_id: str) -> AsyncIterator[dict]: - """Subscribe to OpenCode's global SSE event stream. - - Filters events for the given session_id. Yields structured dicts: - - {"type": "text", "content": "..."} for assistant text - - {"type": "error", "message": "..."} for errors - - {"type": "done"} when the session goes idle - """ - client = await self._get_client() - async with client.stream( - "GET", - "/event", - timeout=httpx.Timeout(None, connect=5.0), - ) as resp: - resp.raise_for_status() - buffer = "" - last_text = "" - # When permission.asked fires, OpenCode goes idle while waiting - # for the grant/deny. We skip that first idle. After the user - # responds (grant or deny), OpenCode resumes and eventually - # emits another idle — that one is the real "done". - idle_skip_count = 0 - async for chunk in resp.aiter_text(): - buffer += chunk - while "\n\n" in buffer: - event_str, buffer = buffer.split("\n\n", 1) - parsed = self._parse_sse(event_str) - if not parsed: - continue - try: - data = json.loads(parsed["data"]) - except (json.JSONDecodeError, KeyError): - continue - - event_type = data.get("type", "") - props = data.get("properties", {}) - - # Filter to our session - event_session = ( - props.get("sessionID") - or props.get("info", {}).get("sessionID") - or props.get("part", {}).get("sessionID") - ) - if event_session and event_session != session_id: - continue - - if event_type == "message.part.updated": - part = props.get("part", {}) - text = part.get("text", "") - if text and text != last_text: - yield {"type": "text", "content": text} - last_text = text - - elif event_type == "session.error": - error = props.get("error", {}) - msg = error.get("data", {}).get("message", str(error)) - yield {"type": "error", "message": msg} - - elif event_type == "session.idle": - if idle_skip_count > 0: - idle_skip_count -= 1 - logger.debug( - "Skipping session.idle (permission wait) " - "for session %s, %d skips remaining", - session_id, idle_skip_count, - ) - continue - yield {"type": "done"} - return - - elif event_type == "permission.asked": - idle_skip_count = 1 - yield { - "type": "permission_request", - "id": props.get("id", ""), - "tool": props.get("permission", "unknown"), - "patterns": props.get("patterns", []), - "session_id": event_session, - } - - elif event_session == session_id: - yield {"type": "activity", "event_type": event_type} - - @staticmethod - def _parse_sse(raw: str) -> dict | None: - """Parse a single SSE event block into a dict.""" - event_type = "message" - data_lines: list[str] = [] - for line in raw.strip().split("\n"): - if line.startswith("event:"): - event_type = line[len("event:") :].strip() - elif line.startswith("data:"): - data_lines.append(line[len("data:") :].strip()) - elif line.startswith(":"): - continue # comment - if not data_lines: - return None - return {"event": event_type, "data": "\n".join(data_lines)} - - # --- Permissions --- - - async def grant_permission( - self, permission_id: str, *, session_id: str, always: bool = False, - ) -> None: - """Grant a pending permission request. - - Uses OpenCode's session-scoped permission API: - POST /session/{sessionId}/permissions/{permissionId} - """ - response = "always" if always else "once" - client = await self._get_client() - resp = await client.post( - f"/session/{session_id}/permissions/{permission_id}", - json={"response": response}, - ) - resp.raise_for_status() - - async def deny_permission( - self, permission_id: str, *, session_id: str, - ) -> None: - """Deny a pending permission request.""" - client = await self._get_client() - resp = await client.post( - f"/session/{session_id}/permissions/{permission_id}", - json={"response": "reject"}, - ) - resp.raise_for_status() - - # --- Health --- - - async def health_check(self) -> bool: - """Check if OpenCode server is responding.""" - try: - client = await self._get_client() - resp = await client.get("/session", timeout=2.0) - return resp.status_code < 500 - except (httpx.ConnectError, httpx.TimeoutException): - return False - - # --- Config --- - - async def get_config(self) -> dict: - """GET /config — current OpenCode configuration.""" - client = await self._get_client() - resp = await client.get("/config") - resp.raise_for_status() - return resp.json() - - async def update_config(self, config: dict) -> dict: - """PATCH /config — update config at runtime (model, providers, etc.).""" - client = await self._get_client() - resp = await client.patch("/config", json=config) - resp.raise_for_status() - return resp.json() - - # --- Providers --- - - async def list_providers(self) -> dict: - """GET /provider — all available providers with model catalogs.""" - client = await self._get_client() - resp = await client.get("/provider") - resp.raise_for_status() - return resp.json() - - async def get_configured_providers(self) -> dict: - """GET /config/providers — configured providers with defaults.""" - client = await self._get_client() - resp = await client.get("/config/providers") - resp.raise_for_status() - return resp.json() - - async def get_provider_auth(self) -> dict: - """GET /provider/auth — which providers have valid credentials.""" - client = await self._get_client() - resp = await client.get("/provider/auth") - resp.raise_for_status() - return resp.json() - - # --- Auth --- - - async def set_auth(self, provider_id: str, auth: dict) -> bool: - """PUT /auth/{provider_id} — set API key or credentials at runtime.""" - client = await self._get_client() - resp = await client.put(f"/auth/{provider_id}", json=auth) - resp.raise_for_status() - return resp.json() - - -# Singleton instance -opencode_client = OpenCodeClient() diff --git a/backend/cliff/engine/config_manager.py b/backend/cliff/engine/config_manager.py deleted file mode 100644 index bc661ea1..00000000 --- a/backend/cliff/engine/config_manager.py +++ /dev/null @@ -1,187 +0,0 @@ -"""Orchestrates config changes between OpenCode API, DB, and opencode.json.""" - -from __future__ import annotations - -import logging -from typing import TYPE_CHECKING - -from cliff.config import settings -from cliff.db.repo_setting import delete_setting, get_setting, list_settings, upsert_setting -from cliff.engine.client import opencode_client - -if TYPE_CHECKING: - import aiosqlite - -logger = logging.getLogger(__name__) - - -def mask_key(key: str) -> str: - """Mask an API key, showing only the last 4 characters.""" - if len(key) <= 8: - return "****" - return key[:3] + "..." + key[-4:] - - -class ConfigManager: - """Coordinates config changes between OpenCode API, DB, and opencode.json.""" - - # --- Model --- - - async def get_model(self) -> dict: - """Get current model from OpenCode's /config endpoint.""" - try: - config = await opencode_client.get_config() - model_full_id = config.get("model", "") - except Exception: - model_full_id = settings.opencode_model - - parts = model_full_id.split("/", 1) if model_full_id else ["", ""] - return { - "model_full_id": model_full_id, - "provider": parts[0] if len(parts) == 2 else "", - "model_id": parts[1] if len(parts) == 2 else model_full_id, - } - - async def update_model(self, db: aiosqlite.Connection, model_full_id: str) -> dict: - """Change model via PUT /config. Also persist to DB and opencode.json.""" - if "/" not in model_full_id: - raise ValueError( - f"Model must be in 'provider/model-id' format, got: {model_full_id}" - ) - - # 1. Update OpenCode at runtime — instant effect - await opencode_client.update_config({"model": model_full_id}) - - # 2. Persist to opencode.json for restarts - settings.write_opencode_config(model_full_id) - - # 3. Save to DB for reference - await upsert_setting(db, "model", {"full_id": model_full_id}) - - logger.info("Model updated to %s", model_full_id) - return await self.get_model() - - # --- Providers --- - - async def list_available_providers(self) -> list[dict]: - """GET /provider — full catalog of providers and models.""" - data = await opencode_client.list_providers() - return data.get("all", []) - - async def get_configured_providers(self) -> dict: - """GET /config/providers — configured providers with defaults.""" - return await opencode_client.get_configured_providers() - - async def get_auth_status(self) -> dict: - """GET /provider/auth — which providers have credentials.""" - return await opencode_client.get_provider_auth() - - # --- API Keys --- - - async def set_api_key( - self, db: aiosqlite.Connection, provider_id: str, key: str - ) -> dict: - """Set API key via PUT /auth/{id}. Also persist to DB. - - Persists to DB first (always works), then pushes to OpenCode as - best-effort. If OpenCode rejects the provider (e.g. unknown provider - name), the key is still saved and will be restored on next startup - when the provider may be configured. - """ - # 1. Persist to DB first — this always succeeds - masked = mask_key(key) - await upsert_setting(db, f"api_key:{provider_id}", { - "key": key, - "key_masked": masked, - }) - - # 2. Push to OpenCode at runtime — best-effort - try: - await opencode_client.set_auth(provider_id, {"type": "api", "key": key}) - except Exception: - logger.warning( - "Could not push API key to OpenCode for provider %s " - "(key is saved and will be restored on restart)", - provider_id, - ) - - logger.info("API key set for provider %s", provider_id) - return {"provider": provider_id, "key_masked": masked, "has_credentials": True} - - async def get_api_keys(self, db: aiosqlite.Connection) -> list[dict]: - """List API keys: DB-stored entries plus env-sourced ones discovered by OpenCode. - - DB rows always win on dedup — the user explicitly stored them, so they - should override an env value of the same provider. - """ - stored = await list_settings(db, prefix="api_key:") - try: - auth_status = await self.get_auth_status() - except Exception: - auth_status = {} - - results: list[dict] = [] - db_providers: set[str] = set() - for setting in stored: - provider_id = setting.key.removeprefix("api_key:") - db_providers.add(provider_id) - value = setting.value or {} - provider_auth = auth_status.get(provider_id, []) - results.append({ - "provider": provider_id, - "key_masked": value.get("key_masked", "****"), - "has_credentials": len(provider_auth) > 0, - "source": "db", - "updated_at": setting.updated_at.isoformat() if setting.updated_at else None, - }) - - for provider_id, auth_entries in auth_status.items(): - if provider_id in db_providers or not auth_entries: - continue - results.append({ - "provider": provider_id, - "key_masked": None, - "has_credentials": True, - "source": "env", - "updated_at": None, - }) - - return results - - async def delete_api_key(self, db: aiosqlite.Connection, provider_id: str) -> bool: - """Remove stored key from DB.""" - return await delete_setting(db, f"api_key:{provider_id}") - - async def restore_keys_to_engine(self, db: aiosqlite.Connection) -> None: - """On app startup, re-inject stored keys to OpenCode via /auth/{id}.""" - stored = await list_settings(db, prefix="api_key:") - for setting in stored: - provider_id = setting.key.removeprefix("api_key:") - value = setting.value or {} - key = value.get("key") - if not key: - continue - try: - await opencode_client.set_auth(provider_id, {"type": "api", "key": key}) - logger.info("Restored API key for provider %s", provider_id) - except Exception: - logger.warning("Failed to restore API key for provider %s", provider_id) - - # Also restore model from DB if opencode.json diverged - async def reconcile_model(self, db: aiosqlite.Connection) -> None: - """On startup, ensure opencode.json matches what's stored in DB.""" - stored = await get_setting(db, "model") - if not stored or not stored.value: - return - stored_model = stored.value.get("full_id", "") - current_model = settings.opencode_model - if stored_model and stored_model != current_model: - logger.info( - "Reconciling model: DB has %s, opencode.json has %s", - stored_model, current_model, - ) - settings.write_opencode_config(stored_model) - - -# Singleton -config_manager = ConfigManager() diff --git a/backend/cliff/engine/models.py b/backend/cliff/engine/models.py deleted file mode 100644 index 73ce35e8..00000000 --- a/backend/cliff/engine/models.py +++ /dev/null @@ -1,68 +0,0 @@ -"""Pydantic models for OpenCode API types.""" - -from __future__ import annotations - -from datetime import datetime # noqa: TCH003 — Pydantic needs this at runtime - -from pydantic import BaseModel - - -class SessionSummary(BaseModel): - id: str - created_at: datetime | None = None - - -class SessionDetail(BaseModel): - id: str - created_at: datetime | None = None - messages: list[MessageInfo] = [] - model: str = "" - - -class MessageInfo(BaseModel): - id: str - role: str - content: str = "" - created_at: datetime | None = None - - -class SendMessageRequest(BaseModel): - content: str - session_id: str - - -class SendMessageResponse(BaseModel): - session_id: str - message_id: str | None = None - - -class HealthStatus(BaseModel): - cliff: str = "ok" - opencode: str = "unknown" - opencode_version: str = "" - model: str = "" - # True only when an AI provider credential is present *and* reachable by - # the per-workspace subprocesses (i.e. it resolved into the env cache the - # process pool injects). A configured model string alone is not enough — - # see the BYOK auth-propagation bug. ``cliffsec status`` turns a False - # here into a ``no_ai_provider_credential`` blocker. - ai_provider_ready: bool = False - - -class VersionInfo(BaseModel): - """Version handshake for the agent CLI (`cliffsec status`). - - `min_cli` is the lowest CLI version this server promises to speak to. - A CLI older than this should refuse to operate and tell the user to upgrade. - `schema_version` bumps when the CLI/server contract changes incompatibly. - """ - - cliff: str - opencode: str - schema_version: str = "1" - min_cli: str = "0.1.0" - - -class SSEEvent(BaseModel): - event: str = "message" - data: str = "" diff --git a/backend/cliff/engine/pool.py b/backend/cliff/engine/pool.py deleted file mode 100644 index 5a96b45e..00000000 --- a/backend/cliff/engine/pool.py +++ /dev/null @@ -1,624 +0,0 @@ -"""WorkspaceProcessPool — manages per-workspace OpenCode subprocesses.""" - -from __future__ import annotations - -import asyncio -import json -import logging -import os -import shutil -import tarfile -import time -from dataclasses import dataclass, field -from typing import TYPE_CHECKING - -import httpx - -from cliff.ai import catalog as ai_catalog -from cliff.config import settings -from cliff.engine.client import OpenCodeClient - -if TYPE_CHECKING: - from collections.abc import Awaitable, Callable - from datetime import timedelta - from pathlib import Path - -logger = logging.getLogger(__name__) - -# AI provider env var → OpenCode provider id, derived from the AI catalog so -# the provider list has exactly one home. ``custom`` is excluded: it shares -# ``OPENAI_API_KEY`` and ships no OpenCode provider config of its own. -# ``ollama`` is excluded: it has no API key (its ``env_var_name`` is ``None``). -# See ``_push_ai_auth`` for why the pool pushes these at all. -_AI_ENV_VAR_TO_PROVIDER_ID: dict[str, str] = { - ai_catalog.env_var_name(p): p - for p in ai_catalog.all_providers() - if p != "custom" and ai_catalog.env_var_name(p) is not None -} - - -def _reconcile_opencode_model( - workspace_dir: Path, model: str, workspace_id: str -) -> None: - """Ensure the workspace's ``opencode.json`` ``model`` field is ``model``. - - The model is written into ``opencode.json`` only at workspace-creation - time (``WorkspaceContextBuilder``). If the user connected — or switched - — their AI provider *after* the workspace directory was created, the - file is stale: it carries no ``model`` (or the previous provider's). - OpenCode then falls back to a built-in default that routes through a - *different* provider than the one whose key the pool injected, and - every agent call 401s with "Missing Authentication header" even though - the right ``*_API_KEY`` is in the subprocess env. (QA Q01 B06b.) - - Rewriting it here — at spawn time, the same place the pool injects the - provider key — keeps the model and the key in lockstep. No-op when the - file is missing or already correct; failures are warning-logged and - leave the file untouched (the existing model, if any, still applies). - """ - config_path = workspace_dir / "opencode.json" - try: - config = ( - json.loads(config_path.read_text()) - if config_path.exists() - else {} - ) - except (OSError, json.JSONDecodeError): - logger.warning( - "Could not read %s for model reconciliation", config_path, - exc_info=True, - ) - return - if not isinstance(config, dict) or config.get("model") == model: - return - config["model"] = model - try: - config_path.write_text(json.dumps(config, indent=2) + "\n") - except OSError: - logger.warning( - "Could not write reconciled model to %s", config_path, - exc_info=True, - ) - return - logger.info( - "Reconciled opencode.json model for workspace %s -> %s", - workspace_id, model, - ) - - -def _archive_and_remove(src: Path, dest: Path, arcname: str) -> None: - """Create a gzipped tarball at ``dest`` and remove ``src``. Blocking. - - The tarball is written to ``.tmp`` first and renamed into place - only after the gzip stream is closed, so a mid-archive crash leaves - either (a) the original source dir intact, or (b) the final archive — - never a truncated ``.tar.gz`` next to an intact source dir. - """ - tmp_dest = dest.with_name(dest.name + ".tmp") - try: - with tarfile.open(tmp_dest, "w:gz") as tar: - tar.add(src, arcname=arcname) - os.replace(tmp_dest, dest) - except BaseException: - # Clean up a partial tarball so a retry starts from a clean slate. - tmp_dest.unlink(missing_ok=True) - raise - shutil.rmtree(src) - - -class PortAllocator: - """Simple set-based port allocator for workspace processes.""" - - def __init__(self, start: int = 4100, end: int = 4199) -> None: - self._range_start = start - self._range_end = end - self._used: set[int] = set() - - def allocate(self) -> int: - """Return the first free port in the range. - - Raises: - RuntimeError: If all ports in the range are in use. - """ - for port in range(self._range_start, self._range_end + 1): - if port not in self._used: - self._used.add(port) - return port - raise RuntimeError( - f"No free ports in range {self._range_start}-{self._range_end} " - f"({len(self._used)} in use)" - ) - - def release(self, port: int) -> None: - """Release a port back to the pool.""" - self._used.discard(port) - - @property - def available(self) -> int: - """Number of ports still available.""" - return (self._range_end - self._range_start + 1) - len(self._used) - - @property - def total(self) -> int: - return self._range_end - self._range_start + 1 - - -@dataclass -class WorkspaceProcess: - """Tracks a single workspace's OpenCode subprocess.""" - - workspace_id: str - workspace_dir: Path - port: int - process: asyncio.subprocess.Process | None = None - client: OpenCodeClient | None = None - last_activity: float = field(default_factory=time.monotonic) - - def touch(self) -> None: - """Update last_activity timestamp.""" - self.last_activity = time.monotonic() - - @property - def idle_seconds(self) -> float: - return time.monotonic() - self.last_activity - - @property - def is_running(self) -> bool: - return self.process is not None and self.process.returncode is None - - @property - def base_url(self) -> str: - return f"http://{settings.opencode_host}:{self.port}" - - -class WorkspaceProcessPool: - """Manages per-workspace OpenCode processes. - - Each workspace gets its own OpenCode subprocess running with - ``cwd=workspace_dir`` so the AI engine only sees the workspace's - context files, agent definitions, and CONTEXT.md. - """ - - def __init__( - self, - port_allocator: PortAllocator | None = None, - host: str | None = None, - *, - env_resolver: Callable[[], Awaitable[dict[str, str]]] | None = None, - model_resolver: Callable[[], Awaitable[str | None]] | None = None, - ) -> None: - """Create a process pool. - - ``env_resolver`` (ADR-0036 / IMPL-0011) — an optional async callable - invoked before every ``start()``. Its return value is merged into - the per-workspace subprocess environment, on top of any caller- - supplied ``env_vars``. Used to inject the active AI provider key - (e.g. ``OPENROUTER_API_KEY``) without every call site needing to - know about the AI integration service. - - ``model_resolver`` — an optional async callable invoked before every - ``start()``. When it returns a model id the pool reconciles the - workspace's ``opencode.json`` ``model`` field to it before spawn, - so OpenCode routes calls through the provider whose key - ``env_resolver`` just injected. Returns ``None`` when no AI - provider is configured (the file is then left untouched). - """ - self._processes: dict[str, WorkspaceProcess] = {} - self._ports = port_allocator or PortAllocator( - settings.opencode_port_range_start, - settings.opencode_port_range_end, - ) - self._host = host or settings.opencode_host - self._locks: dict[str, asyncio.Lock] = {} - self._env_resolver = env_resolver - self._model_resolver = model_resolver - - def _get_lock(self, workspace_id: str) -> asyncio.Lock: - if workspace_id not in self._locks: - self._locks[workspace_id] = asyncio.Lock() - return self._locks[workspace_id] - - # ------------------------------------------------------------------ - # Start / get - # ------------------------------------------------------------------ - - async def start( - self, - workspace_id: str, - workspace_dir: Path, - *, - env_vars: dict[str, str] | None = None, - ) -> OpenCodeClient: - """Start a new OpenCode process for a workspace. - - Allocates a port, launches the subprocess with ``cwd=workspace_dir``, - waits for it to become healthy, and returns an ``OpenCodeClient`` - bound to that instance. - - Args: - workspace_id: Unique workspace identifier. - workspace_dir: Working directory for the subprocess. - env_vars: Extra environment variables to inject (e.g. GH_TOKEN). - Merged with the current process environment. Pass None or - empty dict to inherit the parent environment unchanged. - - Raises: - RuntimeError: If no ports are available or the process fails to start. - TimeoutError: If the process doesn't become healthy in time. - """ - binary = settings.opencode_binary_path - port = self._ports.allocate() - - # Pull in env from the resolver (typically the AI provider key) so - # every caller picks it up automatically without needing to know - # about the AI integration service. - merged_env_vars: dict[str, str] = {} - if self._env_resolver is not None: - try: - resolver_env = await self._env_resolver() - except Exception: # noqa: BLE001 — never crash spawns over env enrichment - logger.warning( - "AI env resolver failed for workspace %s; spawning without it", - workspace_id, - exc_info=True, - ) - resolver_env = {} - merged_env_vars.update(resolver_env) - if env_vars: - merged_env_vars.update(env_vars) - - # ---------------------------------------------------------------- - # Workspace-isolation guard (post-mortem fix). - # - # The remediation agent runs ``git``/``gh`` itself (ADR-0024) and is - # *supposed* to operate only inside ``/repo/``. But - # ``git`` searches parent directories for ``.git`` — so if the - # agent's clone is missing/partial (``repo/`` exists with files but - # no ``.git``) and it runs ``git checkout``/``commit``/``reset``, - # git walks UP the tree and finds whatever repository the workspace - # dir happens to be nested inside. In a dev worktree (or a user - # securing their own checkout) that's the developer's working tree - # — and ``git reset --hard`` there is silent, unrecoverable data - # loss. This actually happened: a urllib3 remediation hijacked the - # dev worktree onto its fix branch and reset --hard wiped hours of - # uncommitted work. - # - # ``GIT_CEILING_DIRECTORIES`` makes git physically refuse to chdir - # above the workspace dir when searching for a repository. The - # happy path is unaffected (``repo/.git`` is found immediately); - # the escape path now fails loudly with "not a git repository" - # instead of silently operating on the parent repo. - merged_env_vars["GIT_CEILING_DIRECTORIES"] = str(workspace_dir) - - # Per-workspace npm cache (EF-B15). Multiple workspaces sharing - # ~/.npm contend on the same lockfile + cache dir under concurrent - # `npm install`, which was a root cause of the pool>=4 retry storm - # (load average 17-20, OpenCode timeouts, retry amplification). - # Giving each workspace its own cache eliminates the contention. - npm_cache = workspace_dir / ".npm-cache" - npm_cache.mkdir(parents=True, exist_ok=True) - # Refuse to follow a symlink — workspace_dir is Cliff-owned, but - # if anything ever pre-creates ``.npm-cache`` as a symlink out of - # the workspace, npm install would silently write elsewhere. - # We resolve both sides so /tmp -> /private/tmp on macOS doesn't - # false-positive. - if ( - npm_cache.is_symlink() - or not npm_cache.resolve().is_relative_to(workspace_dir.resolve()) - ): - raise RuntimeError( - f"refusing to use non-real npm cache dir at {npm_cache}" - ) - merged_env_vars["NPM_CONFIG_CACHE"] = str(npm_cache) - - # Reconcile the workspace's opencode.json model with the active AI - # provider before spawn — see ``_reconcile_opencode_model``. Kept - # next to the env injection above so the model and the provider key - # always agree. Never crashes a spawn over it. - if self._model_resolver is not None: - try: - model = await self._model_resolver() - except Exception: # noqa: BLE001 — never crash spawns over model resolution - logger.warning( - "AI model resolver failed for workspace %s; spawning " - "with the existing opencode.json model", - workspace_id, - exc_info=True, - ) - model = None - if model: - _reconcile_opencode_model(workspace_dir, model, workspace_id) - - # Merge extra env vars with system environment. Host-inherited - # AI-provider env vars (``*_API_KEY`` / ``*_BASE_URL``) are scrubbed - # first — Cliff owns the AI-provider environment entirely via the - # resolver, and a polluted host (e.g. Claude Desktop exports - # ``ANTHROPIC_BASE_URL`` without ``/v1``, which 404s the agent, plus - # an empty ``ANTHROPIC_API_KEY``) must not leak through. The - # resolver's values are layered back on top. (QA Q01 B07.) - _scrub = ai_catalog.provider_env_var_names() - env = {k: v for k, v in os.environ.items() if k not in _scrub} - env.update(merged_env_vars) - if merged_env_vars: - logger.info( - "Injecting env vars for workspace %s: %s", - workspace_id, - list(merged_env_vars.keys()), - ) - - try: - process = await asyncio.create_subprocess_exec( - str(binary), - "serve", - "--port", - str(port), - "--hostname", - self._host, - stdout=asyncio.subprocess.PIPE, - stderr=asyncio.subprocess.PIPE, - cwd=str(workspace_dir), - env=env, - ) - - wp = WorkspaceProcess( - workspace_id=workspace_id, - workspace_dir=workspace_dir, - port=port, - process=process, - ) - - await self._wait_for_healthy(wp, timeout=30.0) - - wp.client = OpenCodeClient(base_url=wp.base_url) - - # Push AI auth *before* publishing to ``self._processes``: the - # ``get_or_start`` fast path reads that dict outside the per- - # workspace lock, so a concurrent caller must not be handed a - # client whose OpenCode process hasn't been authenticated yet. - await self._push_ai_auth(wp, merged_env_vars) - self._processes[workspace_id] = wp - - logger.info( - "Started workspace process %s on port %d (cwd=%s)", - workspace_id, - port, - workspace_dir, - ) - return wp.client - - except Exception: - self._ports.release(port) - if "process" in locals() and process.returncode is None: - process.kill() - await process.wait() - raise - - async def get_or_start( - self, - workspace_id: str, - workspace_dir: Path, - *, - env_vars: dict[str, str] | None = None, - ) -> OpenCodeClient: - """Return existing client or start a new process. - - This is the main entry point. Uses a per-workspace lock to prevent - double-start race conditions from concurrent requests. - - Note: ``env_vars`` are only applied when a *new* process is started. - Already-running processes keep their original environment. - """ - # Fast path: already running - wp = self._processes.get(workspace_id) - if wp and wp.is_running and wp.client: - wp.touch() - return wp.client - - # Slow path: acquire lock and start - async with self._get_lock(workspace_id): - # Re-check after lock (another request may have started it) - wp = self._processes.get(workspace_id) - if wp and wp.is_running and wp.client: - wp.touch() - return wp.client - - # Clean up dead process if exists - if wp: - await self._cleanup(workspace_id) - - return await self.start(workspace_id, workspace_dir, env_vars=env_vars) - - async def get(self, workspace_id: str) -> OpenCodeClient | None: - """Return client for an already-running workspace, or None.""" - wp = self._processes.get(workspace_id) - if wp and wp.is_running and wp.client: - wp.touch() - return wp.client - return None - - # ------------------------------------------------------------------ - # Stop - # ------------------------------------------------------------------ - - async def stop(self, workspace_id: str) -> None: - """Stop a workspace's OpenCode process and release its port.""" - wp = self._processes.pop(workspace_id, None) - if wp is None: - return - - if wp.client: - await wp.client.close() - - if wp.process and wp.process.returncode is None: - wp.process.terminate() - try: - await asyncio.wait_for(wp.process.wait(), timeout=10.0) - except TimeoutError: - logger.warning( - "Workspace process %s did not stop gracefully, killing", - workspace_id, - ) - wp.process.kill() - await wp.process.wait() - - self._ports.release(wp.port) - self._locks.pop(workspace_id, None) - logger.info("Stopped workspace process %s (port %d)", workspace_id, wp.port) - - async def stop_all(self) -> None: - """Stop all managed processes. Called at application shutdown.""" - workspace_ids = list(self._processes.keys()) - for ws_id in workspace_ids: - await self.stop(ws_id) - - async def stop_on_completion(self, workspace_id: str) -> Path | None: - """Stop a repo-action workspace, archive its directory, and remove it. - - Idempotent — returns ``None`` when the workspace is unknown so - callers (e.g. the Session-B posture-fix route) can invoke it freely - after PR verification. Archival runs in a worker thread because - tar-gzipping a cloned repo can block for seconds. - """ - wp = self._processes.get(workspace_id) - workspace_dir: Path | None = wp.workspace_dir if wp else None - - await self.stop(workspace_id) - - if workspace_dir is None or not workspace_dir.exists(): - return None - - archive_path = workspace_dir.parent / f"{workspace_id}.tar.gz" - await asyncio.to_thread( - _archive_and_remove, workspace_dir, archive_path, workspace_id - ) - logger.info( - "Archived repo-action workspace %s to %s", - workspace_id, - archive_path, - ) - return archive_path - - async def stop_idle(self, max_idle: timedelta) -> list[str]: - """Stop processes idle longer than max_idle. - - Returns list of stopped workspace IDs. - """ - max_idle_seconds = max_idle.total_seconds() - to_stop = [ - ws_id - for ws_id, wp in self._processes.items() - if wp.idle_seconds > max_idle_seconds - ] - for ws_id in to_stop: - await self.stop(ws_id) - if to_stop: - logger.info("Idle cleanup stopped %d processes: %s", len(to_stop), to_stop) - return to_stop - - # ------------------------------------------------------------------ - # Status - # ------------------------------------------------------------------ - - def status(self) -> dict: - """Return pool status for health/debug endpoints.""" - return { - "active_processes": len(self._processes), - "available_ports": self._ports.available, - "total_ports": self._ports.total, - "workspaces": { - ws_id: { - "port": wp.port, - "workspace_dir": str(wp.workspace_dir), - "idle_seconds": round(wp.idle_seconds, 1), - "is_running": wp.is_running, - } - for ws_id, wp in self._processes.items() - }, - } - - # ------------------------------------------------------------------ - # Internal - # ------------------------------------------------------------------ - - async def _wait_for_healthy( - self, wp: WorkspaceProcess, timeout: float = 30.0 - ) -> None: - """Poll until the workspace's OpenCode server responds.""" - url = f"{wp.base_url}/session" - deadline = time.monotonic() + timeout - while time.monotonic() < deadline: - try: - async with httpx.AsyncClient() as client: - resp = await client.get(url, timeout=2.0) - if resp.status_code < 500: - return - except (httpx.ConnectError, httpx.TimeoutException): - pass - - # Check if process died - if wp.process and wp.process.returncode is not None: - stderr = "" - if wp.process.stderr: - stderr_bytes = await wp.process.stderr.read() - stderr = stderr_bytes.decode(errors="replace") - raise RuntimeError( - f"Workspace process {wp.workspace_id} exited with code " - f"{wp.process.returncode}: {stderr}" - ) - await asyncio.sleep(0.5) - - raise TimeoutError( - f"Workspace process {wp.workspace_id} did not become healthy " - f"within {timeout}s on port {wp.port}" - ) - - async def _push_ai_auth( - self, wp: WorkspaceProcess, env_vars: dict[str, str] - ) -> None: - """Register injected AI provider keys with the workspace's OpenCode. - - OpenCode authenticates outbound provider calls from its ``/auth`` - store. The bare env var alone is not enough on OpenCode 1.3.x — so - for every AI provider key the pool injected into this subprocess we - also push it through ``PUT /auth/{id}`` against the workspace's own - process. Best-effort: a failure here is warning-logged and the env - var injection remains as a fallback, exactly as on the singleton. - """ - if wp.client is None: - return - for env_var, provider_id in _AI_ENV_VAR_TO_PROVIDER_ID.items(): - key = env_vars.get(env_var) - if not key: - # Present-but-empty means the resolver handed us a hollow - # credential. OpenCode's PUT /auth happily 200s on an empty - # key, so pushing it would just mask the failure — skip it - # and log loudly instead. - if env_var in env_vars: - logger.error( - "AI provider %s env var present but empty for " - "workspace %s — skipping /auth push; agent calls " - "will not authenticate", - provider_id, - wp.workspace_id, - ) - continue - try: - await wp.client.set_auth( - provider_id, {"type": "api", "key": key} - ) - except Exception: # noqa: BLE001 — never block a spawn on auth push - logger.warning( - "Could not push %s auth to workspace process %s " - "(env-var injection remains as fallback)", - provider_id, - wp.workspace_id, - exc_info=True, - ) - - async def _cleanup(self, workspace_id: str) -> None: - """Clean up a dead process entry without logging as a 'stop'.""" - wp = self._processes.pop(workspace_id, None) - if wp: - if wp.client: - await wp.client.close() - self._ports.release(wp.port) diff --git a/backend/cliff/engine/process.py b/backend/cliff/engine/process.py deleted file mode 100644 index 04b42668..00000000 --- a/backend/cliff/engine/process.py +++ /dev/null @@ -1,182 +0,0 @@ -"""OpenCode subprocess lifecycle manager.""" - -from __future__ import annotations - -import asyncio -import logging -import os -from typing import TYPE_CHECKING - -import httpx - -from cliff.ai import catalog as ai_catalog -from cliff.config import settings - -if TYPE_CHECKING: - from pathlib import Path - -logger = logging.getLogger(__name__) - - -class OpenCodeProcess: - """Manages the OpenCode server subprocess.""" - - def __init__(self) -> None: - self._process: asyncio.subprocess.Process | None = None - self._healthy = False - # IMPL-0011 Phase F3: extra env vars merged into os.environ at - # spawn time. Set via update_env() before restart() so the new - # process picks up the active AI provider key without the - # operator restarting Cliff. - self._extra_env: dict[str, str] = {} - - @property - def is_running(self) -> bool: - return self._process is not None and self._process.returncode is None - - @property - def is_healthy(self) -> bool: - return self._healthy - - async def start(self) -> None: - """Start the OpenCode server. Auto-downloads binary if needed.""" - binary = await self._ensure_binary() - - logger.info( - "Starting OpenCode server on %s:%d", settings.opencode_host, settings.opencode_port - ) - - # Scrub host-inherited AI-provider env vars before layering on the - # resolved ones — Cliff owns the AI-provider environment, and a - # polluted host (e.g. Claude Desktop's ``ANTHROPIC_BASE_URL`` - # without ``/v1``) must not leak into the engine. (QA Q01 B07.) - _scrub = ai_catalog.provider_env_var_names() - env = {k: v for k, v in os.environ.items() if k not in _scrub} - env.update(self._extra_env) - - self._process = await asyncio.create_subprocess_exec( - str(binary), - "serve", - "--port", - str(settings.opencode_port), - "--hostname", - settings.opencode_host, - stdout=asyncio.subprocess.PIPE, - stderr=asyncio.subprocess.PIPE, - cwd=str(settings.repo_root), - env=env, - ) - - # Wait for server to become healthy - await self._wait_for_healthy(timeout=30.0) - logger.info("OpenCode server is healthy") - - def set_extra_env(self, env: dict[str, str]) -> None: - """Replace the extra-env dict applied on next start/restart. - - Pass an empty dict to clear. The change takes effect on the next - ``start()`` — callers needing immediate effect should ``restart()``. - """ - self._extra_env = dict(env) - - async def restart(self) -> None: - """Stop + start the singleton with the current extra env. - - Used by ``AIIntegrationService`` after a key change so the - singleton OpenCode (used by ``/api/settings/providers/test`` and - the provider catalog endpoints) picks up the new env var. The - ~1-2s blip is documented in ADR-0036. - """ - await self.stop() - await self.start() - - async def stop(self) -> None: - """Gracefully stop the OpenCode server.""" - if self._process and self._process.returncode is None: - logger.info("Stopping OpenCode server") - self._process.terminate() - try: - await asyncio.wait_for(self._process.wait(), timeout=10.0) - except TimeoutError: - logger.warning("OpenCode did not stop gracefully, killing") - self._process.kill() - await self._process.wait() - self._process = None - self._healthy = False - - async def health_check(self) -> bool: - """Check if the OpenCode server is responding.""" - try: - async with httpx.AsyncClient() as client: - # Use /session endpoint — /doc may 500 if config has issues - resp = await client.get(f"{settings.opencode_url}/session", timeout=2.0) - self._healthy = resp.status_code < 500 - return self._healthy - except (httpx.ConnectError, httpx.TimeoutException): - self._healthy = False - return False - - async def _wait_for_healthy(self, timeout: float = 30.0) -> None: - """Poll until the server responds or timeout.""" - deadline = asyncio.get_event_loop().time() + timeout - while asyncio.get_event_loop().time() < deadline: - if await self.health_check(): - return - # Check if process died - if self._process and self._process.returncode is not None: - stderr = "" - if self._process.stderr: - stderr_bytes = await self._process.stderr.read() - stderr = stderr_bytes.decode(errors="replace") - raise RuntimeError( - f"OpenCode process exited with code {self._process.returncode}: {stderr}" - ) - await asyncio.sleep(0.5) - raise TimeoutError(f"OpenCode server did not become healthy within {timeout}s") - - async def _ensure_binary(self) -> Path: - """Check for OpenCode binary, auto-download if missing.""" - binary = settings.opencode_binary_path - - if binary.exists(): - logger.info("Found OpenCode at %s", binary) - return binary - - logger.info("OpenCode binary not found at %s, attempting auto-download", binary) - await self._download_binary() - - if not binary.exists(): - raise FileNotFoundError( - f"OpenCode binary not found at {binary}. " - f"Install manually: brew install opencode, npm i -g opencode-ai, " - f"or run: scripts/install-opencode.sh" - ) - return binary - - async def _download_binary(self) -> None: - """Run the install script to download OpenCode.""" - install_script = settings.repo_root / "scripts" / "install-opencode.sh" - if not install_script.exists(): - logger.error("Install script not found at %s", install_script) - return - - logger.info("Downloading OpenCode v%s...", settings.opencode_version) - proc = await asyncio.create_subprocess_exec( - "bash", - str(install_script), - stdout=asyncio.subprocess.PIPE, - stderr=asyncio.subprocess.PIPE, - ) - stdout, stderr = await proc.communicate() - - if proc.returncode != 0: - logger.error( - "Failed to download OpenCode: %s", - stderr.decode(errors="replace"), - ) - else: - logger.info("OpenCode download complete: %s", stdout.decode(errors="replace").strip()) - - -# Singleton instance -opencode_process = OpenCodeProcess() diff --git a/backend/cliff/integrations/gateway.py b/backend/cliff/integrations/gateway.py index 2957d53a..d5a0b260 100644 --- a/backend/cliff/integrations/gateway.py +++ b/backend/cliff/integrations/gateway.py @@ -2,12 +2,9 @@ The gateway resolves which integrations are enabled, decrypts their credentials from the vault, substitutes ``${credential:key_name}`` placeholders in MCP -config templates, and returns the resolved configs for inclusion in each -workspace's ``opencode.json``. - -OpenCode manages MCP child processes directly — it reads the ``mcp`` section -from ``opencode.json`` and spawns/kills servers automatically. The gateway's -job is purely **config generation**. +config templates, and returns the resolved configs. Pydantic AI consumes them +as MCP toolsets via the adapter in ``cliff.agents.runtime.tools.mcp``; the +gateway's job is purely **config generation**. """ from __future__ import annotations @@ -64,7 +61,7 @@ class ConfigFreshnessResult: class MCPConfigResolver: - """Resolves MCP server configurations for workspace opencode.json generation.""" + """Resolves MCP server configurations for the workspace's PA MCP toolsets.""" def __init__( self, @@ -91,8 +88,8 @@ async def resolve_workspace( """Resolve MCP configs and integration metadata for a workspace. Returns :class:`WorkspaceMCPResult` with both the MCP config dict - (for ``opencode.json``) and integration metadata list (for the - ``workspace-integrations.json`` manifest). + (for the PA MCP toolset adapter) and integration metadata list (for + the ``workspace-integrations.json`` manifest). Only includes integrations that have: 1. An entry in ``integration_config`` with ``enabled=True`` @@ -263,8 +260,16 @@ def resolve_placeholders( original template is never mutated. """ resolved = copy.deepcopy(mcp_config) - # Support both "environment" (OpenCode format) and "env" (legacy). - env = resolved.get("environment") or resolved.get("env") + # Support both "environment" (stdio MCP format) and "env" (legacy). + # Explicit-key precedence: an explicit (even empty) "environment" wins + # over the legacy "env", so an empty ``environment: {}`` isn't silently + # treated as missing and a config carrying both can't substitute into + # the wrong field. + env = ( + resolved["environment"] + if "environment" in resolved + else resolved.get("env") + ) if not isinstance(env, dict): return resolved @@ -291,7 +296,7 @@ def _apply_toolset_scoping( - If *action_tier* > 0, remove ``--read-only`` from ``command`` (user opted into writes). - Works with both legacy format (separate ``args`` key) and the OpenCode + Works with both legacy format (separate ``args`` key) and the stdio MCP format (``command`` is the full argument array). """ # Support both formats: "command" (array) or legacy "args" (array). @@ -322,7 +327,8 @@ def _apply_toolset_scoping( def _find_unresolved_placeholders(config: dict[str, Any]) -> list[str]: """Return any ``${credential:...}`` placeholders still present in env values.""" - env = config.get("environment") or config.get("env") + # Same explicit-key precedence as ``_resolve_credentials`` above. + env = config["environment"] if "environment" in config else config.get("env") if not isinstance(env, dict): return [] unresolved = [] diff --git a/backend/cliff/integrations/ingest_worker.py b/backend/cliff/integrations/ingest_worker.py index 0760d1ac..9b2d1fa8 100644 --- a/backend/cliff/integrations/ingest_worker.py +++ b/backend/cliff/integrations/ingest_worker.py @@ -23,8 +23,13 @@ from cliff.integrations.normalizer import normalize_findings if TYPE_CHECKING: + from collections.abc import Awaitable, Callable + import aiosqlite + EnvResolver = Callable[[], Awaitable[dict[str, str]]] + ModelResolver = Callable[[], Awaitable[str | None]] + logger = logging.getLogger(__name__) # Consecutive connection failures before backing off @@ -36,6 +41,17 @@ _SMALL_IMPORT_THRESHOLD = 5 +def _provider_prefix(model: str | None) -> str | None: + """The ```` part of a canonical ``/`` id. + + Returns ``None`` for a missing or malformed id (no ``/``) — the signal + that ``build_model`` would reject it. + """ + if not model or "/" not in model: + return None + return model.split("/", 1)[0] + + def estimate_tokens(raw_data: list[dict[str, Any]], chunk_size: int) -> int: """Rough token estimate for an ingest job. @@ -49,7 +65,13 @@ def estimate_tokens(raw_data: list[dict[str, Any]], chunk_size: int) -> int: return int(raw_chars / 3.5) + (num_chunks * 800) -async def _process_job(db: aiosqlite.Connection, job_id: str) -> None: +async def _process_job( + db: aiosqlite.Connection, + job_id: str, + *, + env_resolver: EnvResolver, + model_resolver: ModelResolver, +) -> None: """Process a single ingest job chunk-by-chunk.""" data = await get_ingest_job_raw_data(db, job_id) if data is None: @@ -57,7 +79,49 @@ async def _process_job(db: aiosqlite.Connection, job_id: str) -> None: await set_job_status(db, job_id, "failed") return - source, raw_data, chunk_size, model = data + source, raw_data, chunk_size, pinned_model = data + # App-level AI state. ``env`` carries the *active* provider's credentials, + # so the model we run must belong to that same provider. A job that pinned + # a model under a since-replaced provider (cross-provider pin) would fail + # auth in build_model on every chunk — reconcile to the active model so the + # job runs with consistent creds rather than looping fail → pending. + env = await env_resolver() + active_model = await model_resolver() + model = pinned_model or active_model + if ( + pinned_model + and active_model + and _provider_prefix(pinned_model) != _provider_prefix(active_model) + ): + logger.info( + "Job %s: pinned model %s is from a different provider than the " + "active model %s — using the active model", + job_id, + pinned_model, + active_model, + ) + model = active_model + + # Fail terminally (not fail → pending → re-poll) when there's no usable + # provider/model: missing env, missing model, or a malformed id like a bare + # ``claude-opus-4-1`` (no ``/`` prefix) that build_model would + # reject on every chunk. + if not env or not model or _provider_prefix(model) is None: + logger.warning( + "Job %s: no usable AI provider/model (env=%s, model=%s) — marking failed", + job_id, + bool(env), + model, + ) + await increment_failed_chunk( + db, + job_id, + "No usable AI provider/model configured — connect a provider and " + "pick a model in Settings, then retry.", + ) + await set_job_status(db, job_id, "failed") + return + await set_job_status(db, job_id, "processing") # For small imports, use per-finding chunks for better progress visibility @@ -79,7 +143,9 @@ async def _process_job(db: aiosqlite.Connection, job_id: str) -> None: chunk = raw_data[start:end] try: - valid, errors = await normalize_findings(source, chunk, model=model) + valid, errors = await normalize_findings( + source, chunk, env=env, model=model + ) consecutive_failures = 0 # reset on success except Exception as exc: consecutive_failures += 1 @@ -111,7 +177,7 @@ async def _process_job(db: aiosqlite.Connection, job_id: str) -> None: for item in chunk: try: sub_valid, sub_errors = await normalize_findings( - source, [item], model=model + source, [item], env=env, model=model ) valid.extend(sub_valid) errors.extend(sub_errors) @@ -128,7 +194,15 @@ async def _process_job(db: aiosqlite.Connection, job_id: str) -> None: logger.warning("Failed to persist finding in chunk %d: %s", chunk_idx + 1, exc) errors.append(f"DB error: {exc}") - await increment_completed_chunk(db, job_id, findings_count) + # A chunk counts as *completed* only when it produced at least one + # finding, or was genuinely empty (no findings, no errors). A chunk + # that yielded only errors (model returned nothing valid, or every + # create failed) is a failed chunk — recorded below — and must NOT + # bump completed_chunks, or a job of all-bad-data would finish + # "completed" with nothing created (the final status check keys off + # completed_chunks == 0). + if findings_count > 0 or not errors: + await increment_completed_chunk(db, job_id, findings_count) if errors: for err in errors: @@ -159,9 +233,18 @@ async def _process_job(db: aiosqlite.Connection, job_id: str) -> None: await set_job_status(db, job_id, "completed") -async def ingest_worker_loop(db: aiosqlite.Connection) -> None: +async def ingest_worker_loop( + db: aiosqlite.Connection, + *, + env_resolver: EnvResolver, + model_resolver: ModelResolver, +) -> None: """Main worker loop — polls for pending jobs and processes them. + ``env_resolver`` / ``model_resolver`` supply the app-level AI provider + env + active model (ADR-0047 / IMPL-0022 PR #3b) — the normalizer is an + app-level PA agent now, not a singleton-OpenCode call. + This coroutine runs indefinitely until cancelled. """ logger.info("Ingest worker started") @@ -171,7 +254,12 @@ async def ingest_worker_loop(db: aiosqlite.Connection) -> None: job_id = await get_next_pending_job_id(db) if job_id: logger.info("Processing ingest job %s", job_id) - await _process_job(db, job_id) + await _process_job( + db, + job_id, + env_resolver=env_resolver, + model_resolver=model_resolver, + ) else: await asyncio.sleep(_POLL_INTERVAL) except asyncio.CancelledError: diff --git a/backend/cliff/integrations/normalizer.py b/backend/cliff/integrations/normalizer.py index 99739ad1..5db7e0cd 100644 --- a/backend/cliff/integrations/normalizer.py +++ b/backend/cliff/integrations/normalizer.py @@ -1,7 +1,15 @@ -"""LLM-powered finding normalizer using the singleton OpenCode process. +"""LLM-powered finding normalizer (Pydantic AI, app-level). Accepts raw scanner data from any vendor and normalizes it into FindingCreate -records via a dedicated extraction prompt. See ADR-0022 for design rationale. +records via a dedicated extraction prompt. See ADR-0022 for design rationale +and ADR-0047 / IMPL-0022 PR #3b for the OpenCode → Pydantic AI migration. + +This is an *app-level* agent (no workspace), so its provider key + model are +passed in by the caller (``env`` + ``model``) rather than resolved from a +workspace. Pydantic AI's structured ``output_type`` + internal retry loop +replace the hand-rolled JSON extraction and retry machinery the OpenCode-era +normalizer carried; the per-item ``FindingCreate`` validation below is +unchanged and still drives the partial-success ``(valid, errors)`` contract. Token-cost note (IMPL-0002 C1, 2026-04-16): the prompt grew by roughly ~625 input tokens when ``plain_description`` rules + examples were added. @@ -14,21 +22,23 @@ import json import logging -import re from typing import Any from pydantic import ValidationError - -from cliff.engine.client import opencode_client +from pydantic_ai.exceptions import ( + ModelHTTPError, + UnexpectedModelBehavior, + UsageLimitExceeded, + UserError, +) + +from cliff.agents.runtime.normalizer_agent import build_normalizer_agent +from cliff.agents.runtime.provider import ProviderConfigurationError, build_model from cliff.models import FindingCreate logger = logging.getLogger(__name__) MAX_BATCH_SIZE = 50 -_MAX_RETRIES = 2 # Total attempts: 1 original + 2 retries = 3 - -_RE_FENCED = re.compile(r"```(?:json)?\s*\n?(.*?)```", re.DOTALL) -_RE_TRAILING_COMMA = re.compile(r",\s*([}\]])") # --------------------------------------------------------------------------- # Normalizer prompt — tight extraction, few-shot, no chain-of-thought @@ -228,65 +238,45 @@ """ -def _build_prompt(source: str, raw_json: str) -> str: +def _build_user_message(source: str, raw_json: str) -> str: + """The per-call user message — just the scanner source + raw data. + + The schema, rules, and few-shot examples live in ``NORMALIZER_PROMPT``, + which is the agent's *system* prompt; this is only the variable payload. + """ return ( - f"{NORMALIZER_PROMPT}\n" f"Source: {source}\n" f"Raw data:\n```json\n{raw_json}\n```\n\n" - "JSON array output:" + "Normalize these findings." ) -# --------------------------------------------------------------------------- -# JSON array extractor — handles fenced blocks and bare arrays -# --------------------------------------------------------------------------- - - -def _extract_json_array(text: str) -> list[dict[str, Any]] | None: - """Extract a JSON array from LLM response text. - - Handles: bare JSON arrays, ```json fenced blocks, trailing commas. - Returns None if no valid array is found. - """ - fenced = _RE_FENCED.search(text) - candidate = fenced.group(1).strip() if fenced else text.strip() - - start = candidate.find("[") - if start == -1: - return None - - # Fix trailing commas before attempting parse (common LLM quirk) - cleaned = _RE_TRAILING_COMMA.sub(r"\1", candidate[start:]) - - # Use raw_decode to correctly handle brackets inside JSON strings - try: - parsed, _ = json.JSONDecoder().raw_decode(cleaned) - except json.JSONDecodeError: - return None - - if not isinstance(parsed, list): - return None - return parsed - - # --------------------------------------------------------------------------- # Main normalize function # --------------------------------------------------------------------------- async def normalize_findings( - source: str, raw_data: list[dict[str, Any]], *, model: str | None = None + source: str, + raw_data: list[dict[str, Any]], + *, + env: dict[str, str], + model: str | None = None, ) -> tuple[list[FindingCreate], list[str]]: - """Normalize raw scanner findings via LLM extraction. + """Normalize raw scanner findings via a Pydantic AI extraction call. - Returns (valid_findings, errors) where errors contains human-readable - strings for items that failed validation. + Returns (valid_findings, errors) where errors holds human-readable + strings for items that failed validation. Partial success is normal — + one malformed item lands in ``errors`` while the rest succeed. Args: source: Scanner name (e.g. 'snyk', 'wiz'). raw_data: List of raw finding dicts from the scanner. - model: Optional model override (e.g. 'openai/gpt-4.1-mini'). - If provided, temporarily sets the OpenCode model config. + env: Provider credentials (e.g. ``{"OPENAI_API_KEY": ...}``) used to + build the model — the app-level analogue of the per-workspace + env the pipeline agents receive. + model: Full model id (``'/'``) to run with. Required + in practice; ``build_model`` rejects a missing/blank value. """ if not raw_data: return [], [] @@ -297,106 +287,64 @@ async def normalize_findings( "Use the async ingest endpoint for larger batches." ] - # Build prompt — compact JSON to minimize token cost - raw_json = json.dumps(raw_data, separators=(",", ":")) - prompt = _build_prompt(source, raw_json) + try: + pa_model = build_model(env, model) + except ProviderConfigurationError as exc: + return [], [f"Normalizer model not configured: {exc}"] - # Temporarily override model if requested - original_model: str | None = None - if model: - try: - config = await opencode_client.get_config() - original_model = config.get("model", None) - await opencode_client.update_config({"model": model}) - logger.info("Normalizer using model override: %s", model) - except Exception as exc: - logger.warning("Failed to set model override %s: %s", model, exc) + agent = build_normalizer_agent(pa_model, system_prompt=NORMALIZER_PROMPT) + raw_json = json.dumps(raw_data, separators=(",", ":")) try: - items = await _call_llm_with_retry(prompt) - finally: - # Restore original model if we changed it - if original_model is not None: - try: - await opencode_client.update_config({"model": original_model}) - except Exception: - logger.warning("Failed to restore original model %s", original_model) - - if items is None: - return [], ["Failed to parse JSON array from LLM response after 3 attempts"] - - # Validate each item against FindingCreate schema + result = await agent.run(_build_user_message(source, raw_json)) + except ( + ModelHTTPError, + UnexpectedModelBehavior, + UsageLimitExceeded, + UserError, + ) as exc: + logger.warning("Normalizer LLM call failed: %s", exc) + return [], [f"Normalizer LLM call failed: {type(exc).__name__}: {exc}"] + + # Pydantic AI handed back validated (lenient) NormalizedFinding objects; + # the strict FindingCreate contract — and the per-item partial-success + # accounting — is enforced here, exactly as on the OpenCode-era path. findings: list[FindingCreate] = [] errors: list[str] = [] - for i, item in enumerate(items): - if not isinstance(item, dict): - errors.append(f"Finding {i + 1}: expected object, got {type(item).__name__}") - continue - if "source_type" not in item: + # Normalization is 1:1 — one NormalizedFinding per raw item. The input + # is capped (MAX_BATCH_SIZE) but the model's output array is not, so a + # confused model that echoes the few-shot examples or hallucinates extra + # rows could inject more findings than were submitted. Cap at the input + # count and record the overflow rather than persisting fabricated rows. + outputs = list(result.output) + if len(outputs) > len(raw_data): + errors.append( + f"Model returned {len(outputs)} findings for {len(raw_data)} " + f"input item(s); keeping the first {len(raw_data)}." + ) + outputs = outputs[: len(raw_data)] + + for i, nf in enumerate(outputs): + item = nf.model_dump() + # The model_dump always carries every key; fill the load-bearing + # defaults the LLM may have left null. + if item.get("source_type") is None: item["source_type"] = source - # Coerce raw_payload: LLM sometimes wraps the original object in a list + # Normalized findings are always brand-new — force the status rather + # than trusting the model's value, so a stray string (e.g. "open") + # doesn't drop an otherwise-valid finding into ``errors``. + item["status"] = "new" + # Coerce raw_payload: the model sometimes wraps the original object + # in a single-element list. rp = item.get("raw_payload") if isinstance(rp, list): - item["raw_payload"] = rp[0] if len(rp) == 1 and isinstance(rp[0], dict) else None + item["raw_payload"] = ( + rp[0] if len(rp) == 1 and isinstance(rp[0], dict) else None + ) try: findings.append(FindingCreate.model_validate(item)) except ValidationError as exc: errors.append(f"Finding {i + 1}: {exc}") return findings, errors - - -async def _call_llm_with_retry(prompt: str) -> list[dict[str, Any]] | None: - """Send prompt to LLM and extract JSON array, with up to 3 attempts. - - Creates a fresh session for each retry to avoid stuck generation patterns. - Returns the parsed JSON array or None if all attempts fail. - """ - last_response: str | None = None - - for attempt in range(_MAX_RETRIES + 1): - session = await opencode_client.create_session() - try: - full_text = await opencode_client.send_and_get_response( - session.id, prompt - ) - except Exception as exc: - logger.warning( - "Normalizer attempt %d/%d: LLM error: %s", - attempt + 1, _MAX_RETRIES + 1, exc, - ) - last_response = f"[exception] {exc}" - continue - - if not full_text: - logger.warning( - "Normalizer attempt %d/%d: LLM returned empty response", - attempt + 1, _MAX_RETRIES + 1, - ) - last_response = "[empty response]" - continue - - last_response = full_text - items = _extract_json_array(full_text) - if items is not None: - if attempt > 0: - logger.info("Normalizer succeeded on attempt %d", attempt + 1) - return items - - # Log what the LLM actually said for debugging - snippet = full_text[:500].replace("\n", "\\n") - logger.warning( - "Normalizer attempt %d/%d: Failed to parse JSON from response: %s", - attempt + 1, _MAX_RETRIES + 1, snippet, - ) - - # All attempts failed — include a snippet in the error for the user - if last_response and not last_response.startswith("["): - snippet = last_response[:200].replace("\n", " ").strip() - logger.error( - "Normalizer gave up after %d attempts. Last response: %s", - _MAX_RETRIES + 1, snippet, - ) - - return None diff --git a/backend/cliff/main.py b/backend/cliff/main.py index 1d9f4e0d..099c70c6 100644 --- a/backend/cliff/main.py +++ b/backend/cliff/main.py @@ -6,7 +6,6 @@ import contextlib import logging from contextlib import asynccontextmanager -from datetime import timedelta from pathlib import Path from typing import TYPE_CHECKING @@ -16,7 +15,6 @@ from fastapi.staticfiles import StaticFiles from cliff.agents.executor import AgentExecutor -from cliff.agents.template_engine import AgentTemplateEngine from cliff.ai import catalog as ai_catalog from cliff.api.routes import ( agent_execution, @@ -46,10 +44,6 @@ from cliff.config import settings from cliff.db import connection as db_connection from cliff.db.connection import close_db, init_db -from cliff.engine.client import opencode_client -from cliff.engine.config_manager import config_manager -from cliff.engine.pool import WorkspaceProcessPool -from cliff.engine.process import opencode_process from cliff.integrations.audit import AuditLogger from cliff.integrations.gateway import MCPConfigResolver from cliff.integrations.ingest_worker import ingest_worker_loop @@ -93,7 +87,7 @@ def _init_vault(app: FastAPI, db: object) -> None: @asynccontextmanager async def lifespan(app: FastAPI) -> AsyncIterator[None]: - """Start OpenCode on startup, stop on shutdown.""" + """Initialize persistence, AI state, and background workers (ADR-0047).""" logger.info("Starting Cliff...") # Surface any active AI model override at boot so operators see them # in stdout/stderr (ADR-0036 — performance may vary if a non-default @@ -271,11 +265,8 @@ async def _refresh_ai_env_cache(*, verify: bool = True) -> None: verdict is not None and verdict.error_code != "auth_failed" ) - # Warm the cache once at boot so the very first workspace spawn - # doesn't pay the DB + decrypt round-trip on the critical path, - # AND so the singleton OpenCode (started just below) inherits the - # current AI provider key from boot zero rather than waiting for - # the first connect / disconnect hook. + # Warm the cache once at boot so the very first agent run doesn't pay + # the DB + decrypt round-trip on the critical path. # # Skip the live-probe on the boot path (M5): the upstream HTTPS # round-trip would block ``lifespan`` for up to 5s, hanging the @@ -289,117 +280,55 @@ async def _ai_env_resolver() -> dict[str, str]: return dict(app.state.ai_env_cache) async def _ai_model_resolver() -> str | None: - # The OpenCode model id for the active AI provider. The pool writes - # it into each workspace's opencode.json at spawn time so OpenCode - # routes calls through the same provider whose key was injected. + # The canonical ``/`` id for the active AI + # provider. The PA model factory consumes it together with the + # resolved env to build a fresh ``Model`` per agent run (ADR-0047). return app.state.ai_model_cache - # Start AI engine (non-fatal if unavailable). Seed the singleton - # with the current AI provider env BEFORE start() so the very - # first /api/settings/providers/test or /chat call hits a process - # that already authenticates against OpenRouter (or whatever - # provider is active). - opencode_process.set_extra_env(app.state.ai_env_cache) - try: - await opencode_process.start() - # Push the active AI integration's key into OpenCode's auth.json. - # OpenCode 1.3.x consults auth.json in preference to env vars on - # the outbound request, so users who connected *before* the - # auth.json sync was added need this reconcile step at startup. - if app.state.vault is not None and db_connection._db is not None: - try: - from cliff.ai.service import AIIntegrationService - - await AIIntegrationService( - db_connection._db, - app.state.vault, - audit_logger=app.state.audit_logger, - ).sync_to_opencode() - except Exception: - logger.warning( - "Could not sync AI integration to OpenCode auth.json" - ) - # Restore stored API keys and reconcile model config (legacy - # paste-flow path — kept for back-compat with the OpenCode - # /auth/keys mechanism). - try: - if db_connection._db is not None: - await config_manager.reconcile_model(db_connection._db) - await config_manager.restore_keys_to_engine(db_connection._db) - except Exception: - logger.warning("Could not restore settings to OpenCode engine") - except Exception: - logger.exception("Failed to start OpenCode — app will run but engine is unavailable") - # MCP config resolver (requires vault) mcp_resolver = None if app.state.vault is not None: mcp_resolver = MCPConfigResolver(app.state.vault, app.state.audit_logger) logger.info("MCP config resolver initialized") - # Layer 2: Context builder (workspace directory + agent templates + MCP resolver) + # Layer 2: Context builder (workspace directory + finding context + integrations) workspaces_base = settings.resolve_data_dir() / "workspaces" dir_manager = WorkspaceDirManager(base_dir=workspaces_base) - template_engine = AgentTemplateEngine() context_builder = WorkspaceContextBuilder( - dir_manager, template_engine, mcp_resolver=mcp_resolver + dir_manager, mcp_resolver=mcp_resolver ) app.state.context_builder = context_builder - # Layer 3: Per-workspace process pool, reading from the warm cache. - pool = WorkspaceProcessPool( - env_resolver=_ai_env_resolver, - model_resolver=_ai_model_resolver, - ) - app.state.process_pool = pool - - # IMPL-0011 Phase F3: register the singleton-restart hook on app.state - # so AIIntegrationService instances built per-request can push the - # new env into the singleton OpenCode without coupling to main. - async def _ai_on_key_change(env: dict[str, str]) -> None: + # Register the AI key-change hook on app.state so AIIntegrationService + # instances built per-request refresh the warm env/model cache after a + # connect / disconnect / model change (ADR-0047 — no process to restart). + async def _ai_on_key_change(env: dict[str, str]) -> None: # noqa: ARG001 # ``verify=False`` skips a second upstream auth probe — the # caller (BYOK / adopt / set_model route) already validated and # we'd just duplicate that call inside the mutation latency. await _refresh_ai_env_cache(verify=False) - try: - opencode_process.set_extra_env(env) - if opencode_process.is_running: - await opencode_process.restart() - except Exception: - logger.warning( - "Singleton OpenCode restart after AI key change failed", - exc_info=True, - ) app.state.ai_on_key_change = _ai_on_key_change - # Agent executor (Layer 5: orchestration). The AI env+model - # resolvers are the same callables the pool consumes for OpenCode - # env injection; the executor uses them in the Pydantic AI no-tools - # path to construct a fresh ``Model`` per agent run (ADR-0047). + # Agent executor (Layer 5: orchestration). The AI env+model resolvers + # feed the Pydantic AI model factory, which builds a fresh ``Model`` + # per agent run (ADR-0047). app.state.agent_executor = AgentExecutor( - pool, context_builder, ai_env_resolver=_ai_env_resolver, ai_model_resolver=_ai_model_resolver, ) - # Background idle cleanup task - async def _idle_cleanup_loop() -> None: - idle_timeout = timedelta(seconds=settings.workspace_idle_timeout_seconds) - while True: - await asyncio.sleep(60) - try: - await pool.stop_idle(idle_timeout) - except Exception: - logger.exception("Error in workspace idle cleanup") - - cleanup_task = asyncio.create_task(_idle_cleanup_loop()) - # Background ingest worker (ADR-0023) ingest_task: asyncio.Task[None] | None = None if db_connection._db is not None: - ingest_task = asyncio.create_task(ingest_worker_loop(db_connection._db)) + ingest_task = asyncio.create_task( + ingest_worker_loop( + db_connection._db, + env_resolver=_ai_env_resolver, + model_resolver=_ai_model_resolver, + ) + ) # Assessment watchdog — reaps wedged ``pending``/``running`` rows the # outer asyncio.timeout in ``api/_background.py`` couldn't catch (e.g. @@ -430,10 +359,6 @@ async def _assessment_watchdog_loop() -> None: yield logger.info("Shutting down Cliff...") - cleanup_task.cancel() - with contextlib.suppress(asyncio.CancelledError): - await cleanup_task - if ingest_task is not None: ingest_task.cancel() with contextlib.suppress(asyncio.CancelledError): @@ -444,14 +369,11 @@ async def _assessment_watchdog_loop() -> None: with contextlib.suppress(asyncio.CancelledError): await assessment_watchdog_task - await pool.stop_all() gh_orchestrator = getattr(app.state, "github_app_orchestrator", None) if gh_orchestrator is not None: await gh_orchestrator.stop_all() if app.state.audit_logger is not None: await app.state.audit_logger.stop() - await opencode_client.close() - await opencode_process.stop() await close_db() diff --git a/backend/cliff/models/__init__.py b/backend/cliff/models/__init__.py index be71015b..d45bd690 100644 --- a/backend/cliff/models/__init__.py +++ b/backend/cliff/models/__init__.py @@ -9,6 +9,8 @@ from __future__ import annotations from datetime import datetime # noqa: TCH003 — Pydantic needs this at runtime +from importlib.metadata import PackageNotFoundError +from importlib.metadata import version as _pkg_version from typing import Any, Literal from pydantic import BaseModel, model_validator @@ -345,8 +347,11 @@ class ApiKeyResponse(BaseModel): class ProviderInfo(BaseModel): id: str name: str - env: list[str] = [] - models: dict[str, Any] = {} + # Required, not defaulted: ``GET /api/settings/providers`` always emits + # both, and the Settings UI / CLI consume them — so generated clients + # must treat them as present, not optional. + env: list[str] + models: dict[str, Any] class ModelConfig(BaseModel): @@ -406,6 +411,58 @@ class IntegrationHealthStatus(BaseModel): error_message: str | None = None +class HealthStatus(BaseModel): + """``/health`` response. + + Field shape is preserved across the OpenCode → Pydantic AI substrate + migration (ADR-0047) so the frontend health card and ``cliffsec status`` + don't churn. The agent substrate now runs **in-process**, so ``opencode`` + is always ``"ok"`` and ``opencode_version`` carries the Pydantic AI + version string (e.g. ``"pydantic-ai 1.98.x"``) rather than a subprocess + version. + """ + + cliff: str = "ok" + # Substrate health. In-process (Pydantic AI) — always "ok" when the app + # is up; kept for backward-compatible response shape. + opencode: str = "ok" + # Carries the substrate version string ("pydantic-ai "). + opencode_version: str = "" + model: str = "" + # True only when an AI provider credential is present *and* reachable. + # A configured model string alone is not enough. ``cliffsec status`` + # turns a False here into a ``no_ai_provider_credential`` blocker. + ai_provider_ready: bool = False + + +def substrate_version() -> str: + """The agent substrate version string reported by ``/health`` + ``/version``. + + The substrate runs in-process via Pydantic AI (ADR-0047), so this is the + installed ``pydantic-ai`` version rather than a subprocess version. + """ + try: + return f"pydantic-ai {_pkg_version('pydantic-ai')}" + except PackageNotFoundError: # pragma: no cover — always installed + return "pydantic-ai" + + +class VersionInfo(BaseModel): + """``/version`` handshake for the agent CLI (``cliffsec status``). + + ``min_cli`` is the lowest CLI version this server promises to speak to; a + CLI older than this refuses to operate. ``schema_version`` bumps when the + CLI/server contract changes incompatibly. ``opencode`` is retained for a + backward-compatible wire shape and now carries the in-process substrate + version (ADR-0047). + """ + + cliff: str + opencode: str = "" + schema_version: str = "1" + min_cli: str = "0.1.0" + + # --------------------------------------------------------------------------- # Finding ingest models (ADR-0022 + ADR-0023) # --------------------------------------------------------------------------- @@ -519,7 +576,10 @@ class IngestResult(BaseModel): "CredentialInfo", "TestConnectionResult", "WorkspaceIntegration", + "HealthStatus", "IntegrationHealthStatus", + "VersionInfo", + "substrate_version", # Ingest "IngestRequest", "IngestJobResponse", diff --git a/backend/cliff/workspace/context_builder.py b/backend/cliff/workspace/context_builder.py index 416f951a..2444fb81 100644 --- a/backend/cliff/workspace/context_builder.py +++ b/backend/cliff/workspace/context_builder.py @@ -25,7 +25,6 @@ import aiosqlite - from cliff.agents.template_engine import AgentTemplateEngine from cliff.integrations.gateway import MCPConfigResolver from cliff.models import Finding, Workspace from cliff.workspace.workspace_dir_manager import WorkspaceDirManager @@ -34,11 +33,12 @@ class WorkspaceContextBuilder: - """Orchestrates workspace lifecycle: directory + agents + DB metadata. + """Orchestrates workspace lifecycle: directory + context + DB metadata. - Wires Layer 0 (WorkspaceDirManager) and Layer 1 (AgentTemplateEngine) - together into a single service that manages the full workspace lifecycle. - Future API routes (Layer 4) will call this instead of raw repo functions. + Wraps Layer 0 (WorkspaceDirManager) into a single service that manages + the full workspace lifecycle — the per-workspace directory holds the + finding context (finding.json, CONTEXT.md, per-agent context sections) + the Pydantic AI agents read at run time (ADR-0047). All public methods are async (called from FastAPI routes) but delegate to synchronous L0/L1 operations directly — filesystem ops are fast local @@ -48,12 +48,10 @@ class WorkspaceContextBuilder: def __init__( self, dir_manager: WorkspaceDirManager, - template_engine: AgentTemplateEngine, *, mcp_resolver: MCPConfigResolver | None = None, ) -> None: self._dir_manager = dir_manager - self._template_engine = template_engine self._mcp_resolver = mcp_resolver # ------------------------------------------------------------------ @@ -68,14 +66,13 @@ async def create_workspace( initial_focus: str | None = None, repo_url: str | None = None, ) -> Workspace: - """Create a complete workspace: DB row + directory + rendered agents. + """Create a complete workspace: DB row + directory + finding context. Steps: 1. Create DB row - 2. Resolve MCP configs from vault (if configured) - 3. Create directory structure with finding context + MCP configs - 4. Render and write agent templates - 5. Store directory path in DB + 2. Resolve workspace integrations from vault (if configured) + 3. Create directory structure with finding context + 4. Store directory path in DB ``repo_url`` is the snapshot of the GitHub integration's repo at the moment the workspace was opened (migration 013). Agents prefer this @@ -99,28 +96,24 @@ async def create_workspace( # Idempotent — other statuses are left alone. await mark_started_on_workspace_create(db, finding.id) - # 2. Resolve MCP configs (if vault is configured) - mcp_servers = None + # 2. Resolve workspace integrations (if vault is configured) for the + # manifest agents read for available-tooling context. ws_integrations = None if self._mcp_resolver is not None: try: result = await self._mcp_resolver.resolve_workspace(db) - mcp_servers = result.mcp_configs or None ws_integrations = result.integrations except Exception: logger.warning( - "Failed to resolve MCP configs for workspace %s", workspace.id, + "Failed to resolve workspace integrations for workspace %s", + workspace.id, exc_info=True, ) - # 3. Filesystem directory — model resolved from the active AI - # provider (IMPL-0011 Phase F1). When unconfigured (or vault - # missing), pass model=None and let the workspace inherit the - # singleton's DB-backed model from the legacy path. - model = await self._resolve_active_model(db) - ws_dir = self._dir_manager.create( - workspace.id, finding, mcp_servers=mcp_servers, model=model - ) + # 3. Filesystem directory — finding context only (finding.json, + # finding.md, CONTEXT.md, empty context sections). The PA agents + # read these at run time (ADR-0047). + ws_dir = self._dir_manager.create(workspace.id, finding) # 3b. Write workspace integrations manifest if ws_integrations: @@ -131,44 +124,12 @@ async def create_workspace( json.dumps(manifest, indent=2) + "\n" ) - # 4. Render agent templates (finding only — no enrichment yet). - # Pass repo_url so {{ repo_url }} resolves to the workspace's pinned - # URL from creation onward (EF-B16); the executor re-renders with the - # same value via CLIFF_REPO_URL at run time. - finding_dict = finding.model_dump(mode="json") - self._template_engine.write_agents( - ws_dir.agents_dir, finding=finding_dict, repo_url=repo_url - ) - - # 5. Store path in DB + # 4. Store path in DB await update_workspace_dir(db, workspace.id, str(ws_dir.root)) logger.info("Created workspace %s at %s", workspace.id, ws_dir.root) return await get_workspace(db, workspace.id) # type: ignore[return-value] - async def _resolve_active_model(self, db: aiosqlite.Connection) -> str | None: - """Return the OpenCode model id for the active AI integration. - - Returns ``None`` if no AI integration is configured — the workspace - falls back to the singleton's DB-backed model (legacy paste-flow - path). On any error, log + return None so workspace creation - never blocks on AI configuration. - """ - try: - from cliff.ai import catalog as ai_catalog - from cliff.ai import repo as ai_repo - - active = await ai_repo.get_active(db) - if active is None: - return None - return ai_catalog.resolve_model(active.provider) - except Exception: - logger.warning( - "Could not resolve AI model from active integration", - exc_info=True, - ) - return None - # ------------------------------------------------------------------ # Update context # ------------------------------------------------------------------ @@ -182,7 +143,7 @@ async def update_context( *, summary: str | None = None, ) -> int: - """Write agent output to context, re-render agents, bump version. + """Write agent output to context, log the run, bump version. Args: db: Database connection. @@ -209,22 +170,15 @@ async def update_context( # 1. Write context section (auto-regenerates CONTEXT.md) self._dir_manager.write_context_section(workspace_id, section, structured_output) - # 2. Re-render agent templates with full updated context ws_dir = self._dir_manager.get(workspace_id) if ws_dir is None: raise FileNotFoundError(f"Workspace directory not found: {workspace_id}") - finding_data = json.loads(ws_dir.finding_json.read_text()) - all_context = self._dir_manager.read_all_context(workspace_id) - self._template_engine.write_agents( - ws_dir.agents_dir, finding=finding_data, **all_context - ) - - # 3. Log to agent-runs.jsonl + # 2. Log to agent-runs.jsonl run_log = AgentRunLog(ws_dir.agent_runs_log) run_log.append(agent_type=agent_type, status="completed", summary=summary) - # 4. Bump version in DB + # 3. Bump version in DB new_version = await increment_context_version(db, workspace_id) logger.info( diff --git a/backend/cliff/workspace/repo_workspace_runner.py b/backend/cliff/workspace/repo_workspace_runner.py index 2e1054c8..72e0c9b5 100644 --- a/backend/cliff/workspace/repo_workspace_runner.py +++ b/backend/cliff/workspace/repo_workspace_runner.py @@ -1,29 +1,27 @@ """RepoAgentRunner — execute a single-shot generator agent in a repo workspace. Closes bug B6 from the dogfooding report. `WorkspaceDirManager.create_repo_workspace` -scaffolds a directory and a rendered prompt but historically stopped there — the -posture-fix route returned a ``workspace_id`` pointing at an inert folder and no -PR was ever opened. +scaffolds a clone directory but stops there — the posture-fix route returned a +``workspace_id`` pointing at an inert folder and no PR was ever opened. This runner: -1. Starts an OpenCode process in the workspace via the shared - ``WorkspaceProcessPool`` with ``GH_TOKEN``/``CLIFF_REPO_URL`` injected. -2. Creates a fresh session, sends the rendered agent prompt, collects the - streamed response. -3. Parses the JSON contract the template requires and extracts ``pr_url``. -4. Persists the outcome to ``history/status.json`` inside the workspace so the +1. Builds a Pydantic AI ``Model`` from canonical AI state and a repo-action + agent (bash/edit/read/gh tools), with ``GH_TOKEN``/``CLIFF_REPO_URL`` in + the deps env. +2. Runs the agent in-process (``agent.run``) with ``auto_approve=True`` — the + ``output_type`` (``RepoActionOutput``) carries ``pr_url`` directly, so + there is no JSON contract to parse. +3. Persists the outcome to ``history/status.json`` inside the workspace so the posture route can report status back to the UI without a new DB table. -5. Stops the workspace process — repo-action workspaces are ephemeral. -The permission model for repo workspaces is ``"allow"`` for bash/edit/webfetch -(set up in the spawner via ``_build_repo_action_opencode_config``) because the -user already authorised the single action by clicking "Let Cliff open a PR". -No SSE permission queue is needed here. +Repo-action runs auto-approve every gated tool (clone/edit/push/PR): the user +already authorised the single action by clicking "Let Cliff open a PR", and +there is no interactive approval path in a background posture-fix run. -Contract: the runner never raises. All outcomes — success, bad LLM output, -OpenCode process failure, timeout — collapse into a ``RepoAgentStatus`` row -persisted to disk. Callers poll the status file. +Contract: the runner never raises. All outcomes — success, bad model output, +model error, timeout — collapse into a ``RepoAgentStatus`` row persisted to +disk. Callers poll the status file. """ from __future__ import annotations @@ -35,18 +33,31 @@ from datetime import UTC, datetime from typing import TYPE_CHECKING, Any, Literal -import httpx from pydantic import BaseModel - -from cliff.agents.output_parser import parse_agent_response -from cliff.agents.template_engine import AgentTemplateEngine +from pydantic_ai.exceptions import ( + ModelHTTPError, + UnexpectedModelBehavior, + UsageLimitExceeded, + UserError, +) + +from cliff.agents.runtime.deps import WorkspaceDeps +from cliff.agents.runtime.provider import ProviderConfigurationError, build_model +from cliff.agents.runtime.repo_actions import ( + RepoActionOutput, + build_repo_action_agent, + build_repo_action_prompt, +) from cliff.services.pr_verifier import verify_pr_url -from cliff.workspace.workspace_dir_manager import WorkspaceKind if TYPE_CHECKING: + from collections.abc import Awaitable, Callable from pathlib import Path - from cliff.engine.pool import WorkspaceProcessPool + from cliff.workspace.workspace_dir_manager import WorkspaceKind + + EnvResolver = Callable[[], Awaitable[dict[str, str]]] + ModelResolver = Callable[[], Awaitable[str | None]] logger = logging.getLogger(__name__) @@ -55,14 +66,12 @@ # create is measured in tens of seconds on GitHub; the rest is LLM latency. DEFAULT_TIMEOUT_SECONDS = 600.0 -# Stall detection is intentionally absent: OpenCode's SSE stream for tool -# agents can go silent for long stretches while the model thinks between -# tool invocations (especially after file reads during a multi-step -# clone→detect→write→commit→push→PR flow). Premature stall cancels the -# run after the agent has already produced side effects (cloned repo, -# checked out a branch) but before it emits the final JSON contract, which -# surfaces as confusing "No JSON block found" failures. We rely on the -# overall ``DEFAULT_TIMEOUT_SECONDS`` (10 min) to bound the run instead. +# Stall detection is intentionally absent: a tool-using agent can go quiet +# for long stretches while the model thinks between tool invocations +# (especially during a multi-step clone→detect→write→commit→push→PR flow). +# A premature stall cancel would kill the run after it had already produced +# side effects (cloned repo, checked out a branch). We rely on the overall +# ``DEFAULT_TIMEOUT_SECONDS`` (10 min) to bound the run instead. RepoAgentPhase = Literal["queued", "running", "pr_created", "already_present", "failed"] @@ -162,8 +171,17 @@ class RepoAgentRunner: run and discard themselves when it's done. """ - def __init__(self, pool: WorkspaceProcessPool) -> None: - self._pool = pool + def __init__( + self, + *, + env_resolver: EnvResolver, + model_resolver: ModelResolver, + ) -> None: + # Resolve the app-level AI provider env + active model at run time + # (ADR-0047 / IMPL-0022 PR #3c) — the generator is now an in-process + # Pydantic AI agent, not an OpenCode subprocess. + self._env_resolver = env_resolver + self._model_resolver = model_resolver async def run( self, @@ -191,137 +209,122 @@ async def run( _write_status(workspace_root, running) await _sync_workspace_state(workspace_id, "running") + # Build the model from the canonical AI state. try: - prompt = _render_prompt( - kind, repo_url=repo_url, gh_token=gh_token, params=params or {} - ) - except Exception as exc: # noqa: BLE001 — never leak to caller + ai_env = await self._env_resolver() + model_id = await self._model_resolver() + model = build_model(ai_env, model_id) + except ProviderConfigurationError as exc: return await self._finalize( workspace_root, running, status="failed", - error=f"Failed to render agent prompt: {exc}", + error=f"AI provider not configured: {exc}", ) + # Tool subprocess env: the GitHub token + repo URL. ``bash`` merges + # this over ``os.environ`` so git/gh keep PATH etc. env_vars: dict[str, str] = {"CLIFF_REPO_URL": repo_url} if gh_token: env_vars["GH_TOKEN"] = gh_token - # Some gh commands prefer GITHUB_TOKEN; export both. env_vars["GITHUB_TOKEN"] = gh_token - client = None + deps = WorkspaceDeps( + workspace_id=workspace_id, + workspace_dir=str(workspace_root), + finding={}, + env_vars=env_vars, + auto_approve=True, # one-shot, pre-approved — no HITL surface + ) + agent = build_repo_action_agent(model, kind) + user_prompt = build_repo_action_prompt( + kind, repo_url=repo_url, params=params or {} + ) + try: - client = await self._pool.get_or_start( - workspace_id, workspace_root, env_vars=env_vars - ) - session = await client.create_session() - response_text = await _send_and_collect( - client, session.id, prompt, timeout=timeout + result = await asyncio.wait_for( + agent.run(user_prompt, deps=deps), timeout=timeout ) - except (RuntimeError, TimeoutError, httpx.HTTPError) as exc: - logger.exception("repo agent process failed for %s", workspace_id) + except TimeoutError: + logger.warning("repo agent %s timed out after %ss", workspace_id, timeout) return await self._finalize( workspace_root, running, status="failed", - error=f"OpenCode process failure: {exc}", - ) - except Exception as exc: # noqa: BLE001 - logger.exception( - "unexpected error in repo agent runner for %s", workspace_id + error=f"Agent timed out after {timeout:.0f}s", ) + except ( + ModelHTTPError, + UnexpectedModelBehavior, + UsageLimitExceeded, + UserError, + ) as exc: + logger.warning("repo agent %s run failed: %s", workspace_id, exc) return await self._finalize( workspace_root, running, status="failed", - error=f"Unexpected error: {exc}", + error=f"Agent run failed: {type(exc).__name__}: {exc}", ) - finally: - # Repo workspaces are one-shot: release the process + port so we - # don't leak a subprocess per "Generate and open PR" click. - with contextlib.suppress(Exception): - await self._pool.stop(workspace_id) - - # Persist raw text so operators can see exactly what the agent said - # when something goes wrong — especially helpful for "No JSON block - # found" because the UI otherwise can't show the reasoning that - # happened before the stall. - with contextlib.suppress(Exception): - (workspace_root / "history" / "agent-response.txt").write_text( - response_text + except Exception as exc: # noqa: BLE001 — never leak to caller + logger.exception( + "unexpected error in repo agent runner for %s", workspace_id ) - - log_tail = _tail(response_text) - - if not response_text.strip(): return await self._finalize( workspace_root, running, status="failed", - error="Agent returned an empty response", - agent_log_tail=log_tail, + error=f"Unexpected error: {exc}", ) - parsed = parse_agent_response(response_text, agent_type=_agent_type_for(kind)) - structured = parsed.structured_output or {} + output: RepoActionOutput = result.output + structured = output.model_dump() - if not parsed.success: - return await self._finalize( - workspace_root, - running, - status="failed", - error=parsed.error or "Agent output did not match contract", - structured_output=structured or None, - agent_log_tail=log_tail, + # Persist the full message transcript for operator diagnostics — + # the analogue of the old SSE-text dump. + with contextlib.suppress(Exception): + (workspace_root / "history" / "agent-response.txt").write_bytes( + result.all_messages_json() ) + log_tail = _tail(output.result_card_markdown or output.summary or "") - agent_status = (structured.get("status") or "").lower() - pr_url = structured.get("pr_url") - branch_name = structured.get("branch_name") - - if agent_status == "pr_created": + if output.status == "pr_created": # B16: the agent cannot be trusted to emit a real PR URL. Hit - # GitHub's API before we tell the user "PR opened" — a mismatch - # is the symptom we're fixing. - verification = await verify_pr_url(pr_url, token=gh_token) + # GitHub's API before we tell the user "PR opened". + verification = await verify_pr_url(output.pr_url, token=gh_token) if verification.ok: return await self._finalize( workspace_root, running, status="pr_created", - pr_url=verification.html_url or pr_url, - branch_name=branch_name, + pr_url=verification.html_url or output.pr_url, + branch_name=output.branch_name, structured_output=structured, ) - # Verification failed — no fallback. Surface the real reason + - # a tail of the agent's response so the user can tell whether - # a branch was actually pushed or the model invented the URL. return await self._finalize( workspace_root, running, status="failed", error=( - "PR verification failed: " - f"{verification.reason}. Agent claimed pr_url=" - f"{pr_url!r}." + f"PR verification failed: {verification.reason}. " + f"Agent claimed pr_url={output.pr_url!r}." ), structured_output=structured, agent_log_tail=log_tail, ) - if agent_status == "already_present": + if output.status == "already_present": return await self._finalize( workspace_root, running, status="already_present", structured_output=structured, ) - # Fall through: the agent claimed success but didn't give us a PR. + # status == "failed" (or anything else): surface the agent's reason. return await self._finalize( workspace_root, running, status="failed", - error=structured.get("error_details") - or "Agent finished without opening a PR", + error=output.error_details or "Agent finished without opening a PR", structured_output=structured, agent_log_tail=log_tail, ) @@ -385,102 +388,3 @@ def _tail(text: str) -> str | None: if len(text) <= _LOG_TAIL_CHARS: return text return "…(truncated)…\n" + text[-_LOG_TAIL_CHARS:] - - -def _render_prompt( - kind: WorkspaceKind, - *, - repo_url: str, - gh_token: str | None, - params: dict[str, Any], -) -> str: - """Re-render the generator prompt (idempotent with WorkspaceDirManager).""" - engine = AgentTemplateEngine() - rendered = engine.render_repo_action( - kind, repo_url=repo_url, params=params, gh_token=gh_token - ) - return rendered.content - - -def _agent_type_for(kind: WorkspaceKind) -> str: - """Map workspace kind to the agent_type string the parser expects. - - The output parser uses agent_type only for ``validate_structured_output`` - schema lookup; posture generator schemas are registered under these names - in ``cliff.agents.schemas``. Unknown agent_type is allowed — the parser - skips per-agent validation and still extracts ``structured_output``. - """ - return { - WorkspaceKind.repo_action_security_md: "security_md_generator", - WorkspaceKind.repo_action_dependabot: "dependabot_config_generator", - }.get(kind, kind.value) - - -async def _send_and_collect( - client: Any, - session_id: str, - prompt: str, - *, - timeout: float, -) -> str: - """Send the prompt, accumulate text events until done/stall/timeout. - - Simpler than ``AgentExecutor._send_and_collect`` because repo workspaces - pre-approve bash/edit/webfetch — we never see ``permission_request`` - events and therefore don't need an approval queue. - """ - - async def _send() -> None: - # Small delay matches the executor's pattern: give the SSE stream - # time to connect before the message lands. - await asyncio.sleep(0.5) - with contextlib.suppress(httpx.ReadTimeout): - await client.send_message(session_id, prompt) - - send_task = asyncio.create_task(_send()) - try: - return await _collect_response(client, session_id, timeout=timeout) - finally: - if not send_task.done(): - send_task.cancel() - with contextlib.suppress(asyncio.CancelledError): - await send_task - - -async def _collect_response( - client: Any, - session_id: str, - *, - timeout: float, -) -> str: - """Consume the SSE event stream until ``done`` or the overall timeout. - - Text events from OpenCode carry the cumulative response so far — each - successive event replaces the prior content, and the last event before - ``done`` has the full text. We keep the latest and return it either - when we see ``done`` or when the outer timeout wins. - """ - collected = "" - - async def _stream() -> str: - nonlocal collected - async for event in client.stream_events(session_id): - etype = event.get("type") - if etype == "text": - collected = event.get("content", "") or collected - elif etype == "done": - return collected - elif etype == "error": - raise RuntimeError( - f"OpenCode error event: {event.get('message', 'unknown')}" - ) - return collected - - try: - return await asyncio.wait_for(_stream(), timeout=timeout) - except TimeoutError: - # Outer timeout — surface whatever we collected so the caller still - # gets diagnostic text in ``history/agent-response.txt`` instead of - # a blanket "Unexpected error". - logger.warning("repo agent response stream timed out after %ss", timeout) - return collected diff --git a/backend/cliff/workspace/workspace_dir.py b/backend/cliff/workspace/workspace_dir.py index c4ed4638..16a701e0 100644 --- a/backend/cliff/workspace/workspace_dir.py +++ b/backend/cliff/workspace/workspace_dir.py @@ -49,24 +49,10 @@ def workspace_id(self) -> str: # --- Top-level files --- - @property - def opencode_json(self) -> Path: - return self.root / "opencode.json" - @property def context_md(self) -> Path: return self.root / "CONTEXT.md" - # --- .opencode/ --- - - @property - def opencode_dir(self) -> Path: - return self.root / ".opencode" - - @property - def agents_dir(self) -> Path: - return self.root / ".opencode" / "agents" - # --- context/ --- @property diff --git a/backend/cliff/workspace/workspace_dir_manager.py b/backend/cliff/workspace/workspace_dir_manager.py index 93e789d9..96831d3c 100644 --- a/backend/cliff/workspace/workspace_dir_manager.py +++ b/backend/cliff/workspace/workspace_dir_manager.py @@ -11,7 +11,6 @@ from enum import StrEnum from typing import TYPE_CHECKING, Any -from cliff.agents.template_engine import AgentTemplateEngine, get_default_engine from cliff.workspace.context_document import ContextDocument from cliff.workspace.workspace_dir import CONTEXT_SECTIONS, WorkspaceDir @@ -97,20 +96,12 @@ def create( self, workspace_id: str, finding: Finding, - *, - mcp_servers: dict[str, dict] | None = None, - model: str | None = None, ) -> WorkspaceDir: """Create the full directory structure and initial files for a workspace. Args: workspace_id: Unique workspace identifier. finding: The finding this workspace remediates. - mcp_servers: Optional MCP server configs (from MCPConfigResolver) - to include in the workspace's opencode.json. - model: Optional OpenCode model id to set in opencode.json - (IMPL-0011). When ``None`` the workspace inherits the - singleton's model from its DB-backed config. Raises: FileExistsError: If the workspace directory already exists. @@ -130,7 +121,6 @@ def create( (workspace_root / "context").mkdir() (workspace_root / "context" / "code-snippets").mkdir() (workspace_root / "context" / "references").mkdir() - (workspace_root / ".opencode" / "agents").mkdir(parents=True) (workspace_root / "history").mkdir() ws = WorkspaceDir(root=workspace_root) @@ -140,11 +130,6 @@ def create( ws.finding_json.write_text(json.dumps(finding_data, indent=2) + "\n") ws.finding_md.write_text(_render_finding_md(finding)) - ws.opencode_json.write_text( - json.dumps(_build_opencode_config(mcp_servers, model=model), indent=2) - + "\n" - ) - # Create empty agent-runs log ws.agent_runs_log.touch() @@ -279,51 +264,27 @@ def create_repo_workspace( kind: WorkspaceKind, repo_url: str, params: dict[str, Any] | None = None, - *, - gh_token: str | None = None, - template_engine: AgentTemplateEngine | None = None, - model: str | None = None, ) -> str: """Create an ephemeral repo-scoped workspace for a generator agent. Unlike ``create()``, this does **not** produce finding-scoped files (no ``finding.json``, no ``finding.md``, no ``CONTEXT.md``). The - directory carries just enough scaffolding for an OpenCode process: + directory is the clone/edit working tree the Pydantic AI + repo-action agent (ADR-0024 / ADR-0047) runs in: - - ``.opencode/agents/.md`` — the rendered single-shot - agent prompt for the selected kind. - - ``opencode.json`` — ADR-0024 permission model (``"ask"`` for bash - and edit, ``"allow"`` for webfetch). - ``REPO_ACTION.md`` — human-readable summary of the action. - ``history/`` — for agent-run logs written later. - ``gh_token`` is intentionally kept out of ``params`` so it is never - serialised into ``REPO_ACTION.md``. + The agent's system prompt + permission policy live in + ``cliff.agents.runtime.repo_actions``; nothing is rendered to disk. Returns: The generated workspace_id (a safe single-path-component string). """ - engine = template_engine or get_default_engine() - rendered = engine.render_repo_action( - kind, repo_url=repo_url, params=params or {}, gh_token=gh_token - ) - self._base_dir.mkdir(parents=True, exist_ok=True) workspace_id, workspace_root = self._allocate_workspace_dir(kind) - (workspace_root / ".opencode" / "agents").mkdir(parents=True) (workspace_root / "history").mkdir() - (workspace_root / "opencode.json").write_text( - json.dumps( - _build_opencode_config(for_repo_action=True, model=model), - indent=2, - ) - + "\n" - ) - - agent_path = workspace_root / ".opencode" / "agents" / rendered.filename - agent_path.write_text(rendered.content) - # Empty agent-runs log mirrors finding workspaces so downstream tooling # (tail readers, log rotation) can treat all workspaces uniformly. (workspace_root / "history" / "agent-runs.jsonl").touch() @@ -331,7 +292,7 @@ def create_repo_workspace( summary_lines = [ "# Repo action workspace", "", - f"- **Action:** `{rendered.name}` ({kind.value})", + f"- **Action:** `{kind.value}`", f"- **Repo:** {_scrub_repo_url(repo_url)}", ] if params: @@ -366,56 +327,6 @@ def _allocate_workspace_dir( ) -def _build_opencode_config( - mcp_servers: dict[str, dict] | None = None, - *, - for_repo_action: bool = False, - model: str | None = None, -) -> dict: - """ADR-0024 permission model — ``ask`` for bash/edit, ``allow`` for webfetch. - - ``for_repo_action=True`` relaxes bash/edit to ``allow`` for the single-shot - posture-fix workspaces. Rationale: the user has already authorised the - specific action by clicking "Let Cliff open a PR", the agent is scoped - to clone → branch → write → push → draft-PR on an isolated branch, and - there is no interactive approval path in a posture-fix run (no DB agent - run row, no SSE queue, no UI listener). With ``ask`` the agent stalls on - the first ``git clone`` waiting for an approval that never arrives. - - ``model`` — the OpenCode model id (e.g. ``openai/gpt-4.1``). Without it - the workspace process starts without a default model and rejects every - message with "The requested model is not supported." Required for - repo-action workspaces because nothing else wires a model in (finding - workspaces inherit via a DB-backed upsert path). - """ - if for_repo_action: - # ``external_directory: "allow"`` is load-bearing: the agent clones - # into ``repo/`` under the workspace root, then the LLM reaches for - # the ``read``/``edit`` tools with paths the model thinks of as - # ``/repo/SECURITY.md``. OpenCode resolves those outside the - # workspace CWD and routes them through the ``external_directory`` - # permission check. With the default "ask" rule the tool call - # blocks forever because the posture runner has no approval path - # and the agent never reaches the write step. - permission = { - "bash": "allow", - "edit": "allow", - "webfetch": "allow", - "external_directory": "allow", - } - else: - permission = {"bash": "ask", "edit": "ask", "webfetch": "allow"} - config: dict = { - "$schema": "https://opencode.ai/config.json", - "permission": permission, - } - if model: - config["model"] = model - if mcp_servers: - config["mcp"] = mcp_servers - return config - - _CREDENTIALED_URL = re.compile(r"^(https?://)[^/@\s]+@", re.IGNORECASE) diff --git a/backend/pyproject.toml b/backend/pyproject.toml index 2b1ca651..c94aa4fe 100644 --- a/backend/pyproject.toml +++ b/backend/pyproject.toml @@ -44,7 +44,7 @@ select = ["E", "F", "I", "N", "UP", "B", "SIM", "TCH"] [tool.pytest.ini_options] asyncio_mode = "auto" markers = [ - "e2e: end-to-end tests requiring OpenCode binary and LLM API key", + "e2e: end-to-end tests requiring an LLM API key", "agent: agent integration tests requiring real LLM calls (slow, costs money)", "docker: install smoke tests that boot the published Docker image (require docker daemon)", "integration: cross-cutting integration tests against an in-memory DB (no external deps, run by default)", diff --git a/backend/tests/agents/conftest.py b/backend/tests/agents/conftest.py index 6de07706..00a496b5 100644 --- a/backend/tests/agents/conftest.py +++ b/backend/tests/agents/conftest.py @@ -1,87 +1,36 @@ -"""Agent integration test fixtures — real OpenCode subprocess + real LLM. +"""Agent test fixtures. -These tests call the actual LLM via OpenCode. They require: -1. OpenCode binary installed (via scripts/install-opencode.sh) -2. OPENAI_API_KEY set in the environment - -Run with: uv run pytest tests/agents/ -v +Most agent tests drive the Pydantic AI runtime with a ``FunctionModel`` / +``TestModel`` and need no network — those must run in keyless CI so a runtime +regression isn't masked. Only the two files that call a *real* LLM are skipped +when no API key is set. """ from __future__ import annotations -import asyncio import os -import time import pytest -from cliff.config import settings -from cliff.engine.process import OpenCodeProcess - -try: - from shutil import which -except ImportError: - which = None # type: ignore[assignment] - -# --------------------------------------------------------------------------- -# Skip conditions -# --------------------------------------------------------------------------- - -_opencode_available = settings.opencode_binary_path.exists() or ( - which is not None and which("opencode") is not None -) _api_key_set = bool( os.environ.get("OPENAI_API_KEY") or os.environ.get("ANTHROPIC_API_KEY") ) -_skip_no_binary = pytest.mark.skipif( - not _opencode_available, reason="OpenCode binary not found" -) _skip_no_key = pytest.mark.skipif( not _api_key_set, reason="No LLM API key set (OPENAI_API_KEY or ANTHROPIC_API_KEY)" ) +# Files whose every test hits a real LLM (the live evals). Everything else +# under tests/agents/ runs against FunctionModel/TestModel and stays in CI. +_LIVE_LLM_FILES = ("test_normalizer_agent", "test_plain_description_eval") + def pytest_collection_modifyitems(items): - """Mark all items in this directory as agent tests and apply skip conditions.""" + """Mark agent tests; skip only the live-LLM files when no key is set.""" for item in items: - if "/agents/" in str(item.fspath): - item.add_marker(pytest.mark.agent) - item.add_marker(_skip_no_binary) + path = str(item.fspath) + if "/agents/" not in path: + continue + item.add_marker(pytest.mark.agent) + if any(name in path for name in _LIVE_LLM_FILES): item.add_marker(_skip_no_key) - - -# --------------------------------------------------------------------------- -# Session-scoped OpenCode server -# --------------------------------------------------------------------------- - -_process: OpenCodeProcess | None = None - - -@pytest.fixture(scope="session", autouse=True) -def opencode_server(): - """Start a real OpenCode server for the agent test session.""" - global _process - _process = OpenCodeProcess() - - loop = asyncio.new_event_loop() - try: - loop.run_until_complete(_process.start()) - # Extra wait for OpenCode to be fully ready - time.sleep(2) - yield _process - finally: - loop.run_until_complete(_process.stop()) - loop.close() - _process = None - - -@pytest.fixture(autouse=True) -def reset_client(opencode_server): - """Reset the singleton OpenCode client before each test.""" - import cliff.integrations.normalizer as normalizer_mod - from cliff.engine.client import OpenCodeClient - - fresh_client = OpenCodeClient(base_url=settings.opencode_url) - normalizer_mod.opencode_client = fresh_client - yield diff --git a/backend/tests/agents/eval_utils.py b/backend/tests/agents/eval_utils.py new file mode 100644 index 00000000..b96d3e2e --- /dev/null +++ b/backend/tests/agents/eval_utils.py @@ -0,0 +1,30 @@ +"""Shared setup for the real-LLM agent evals (IMPL-0022 PR #3b). + +The two live-LLM test modules — ``test_normalizer_agent`` and +``test_plain_description_eval`` — both need the same provider env + a +capable-but-cheap model id. Keeping that selection policy here means it +can't drift between the two files. Both modules are skip-gated on an API +key being present (see ``conftest.py``). +""" + +from __future__ import annotations + +import os + +# Provider credentials for the app-level normalizer, harvested from the host +# env (the same shape the running daemon resolves into a workspace). +LLM_ENV = { + k: v for k, v in os.environ.items() if k.endswith(("_API_KEY", "_BASE_URL")) +} + + +def eval_model() -> str: + """Capable, cheap model for the real-LLM eval (override: ``CLIFF_EVAL_MODEL``).""" + if override := os.environ.get("CLIFF_EVAL_MODEL"): + return override + if os.environ.get("ANTHROPIC_API_KEY"): + return "anthropic/claude-haiku-4-5" + return "openai/gpt-4o-mini" + + +LLM_MODEL = eval_model() diff --git a/backend/tests/agents/fixtures/plain_description_evals.json b/backend/tests/agents/fixtures/plain_description_evals.json index 1a4b0432..4e714a42 100644 --- a/backend/tests/agents/fixtures/plain_description_evals.json +++ b/backend/tests/agents/fixtures/plain_description_evals.json @@ -141,7 +141,7 @@ }, "must_contain_any": ["ci-deploy", "admin", "IAM"], "must_not_contain_regex": ["CWE-\\d+", "CVSS:\\d"], - "fix_hint_keywords": ["replace", "scoped", "least", "narrow", "remove", "attach a"], + "fix_hint_keywords": ["replace", "scoped", "least", "narrow", "remov", "restrict", "attach a"], "sentence_count_range": [2, 4] }, { diff --git a/backend/tests/agents/test_deferred_tools_persist.py b/backend/tests/agents/test_deferred_tools_persist.py index 336a2d76..2baae751 100644 --- a/backend/tests/agents/test_deferred_tools_persist.py +++ b/backend/tests/agents/test_deferred_tools_persist.py @@ -118,7 +118,6 @@ def _build_executor(store: _FakeRunStore) -> AgentExecutor: builder.update_context.return_value = 1 builder._mcp_resolver = None # no MCP toolsets in the test ex = AgentExecutor( - AsyncMock(), builder, ai_env_resolver=AsyncMock(return_value={"OPENAI_API_KEY": "x"}), ai_model_resolver=AsyncMock(return_value="openai/gpt-4o-mini"), diff --git a/backend/tests/agents/test_executor_provider_chain.py b/backend/tests/agents/test_executor_provider_chain.py index 27726260..f2a9a0e4 100644 --- a/backend/tests/agents/test_executor_provider_chain.py +++ b/backend/tests/agents/test_executor_provider_chain.py @@ -98,7 +98,6 @@ async def _capture_run(agent_type: str, deps: WorkspaceDeps, model: Any) -> dict ) executor = AgentExecutor( - pool=MagicMock(), context_builder=MagicMock(), ai_env_resolver=AsyncMock(return_value=env), ai_model_resolver=AsyncMock(return_value=model_full_id), diff --git a/backend/tests/agents/test_normalizer_agent.py b/backend/tests/agents/test_normalizer_agent.py index 56c81378..f3269e07 100644 --- a/backend/tests/agents/test_normalizer_agent.py +++ b/backend/tests/agents/test_normalizer_agent.py @@ -1,7 +1,8 @@ """Agent integration tests for the finding normalizer. -These tests call the real LLM via OpenCode to verify that `normalize_findings()` -correctly extracts and validates findings from various scanner formats. +These tests call the real LLM (the in-process Pydantic AI normalizer agent — +ADR-0047) to verify that `normalize_findings()` correctly extracts and +validates findings from various scanner formats. Budget: ~$0.002 total (well under the $1 limit). Run with: uv run pytest tests/agents/ -v @@ -17,6 +18,11 @@ from cliff.integrations.normalizer import normalize_findings from cliff.models import FindingCreate # noqa: TCH001 — used in type assertions +# Real-LLM provider state + model selection, shared with the plain-description +# eval (see eval_utils). Skip-gated on an API key being present (conftest). +from tests.agents.eval_utils import LLM_ENV as _LLM_ENV +from tests.agents.eval_utils import LLM_MODEL as _LLM_MODEL + VALID_PRIORITIES = {"critical", "high", "medium", "low", "info"} FIXTURES_DIR = Path(__file__).resolve().parents[3] / "fixtures" @@ -59,7 +65,7 @@ async def test_single_snyk_finding(): } ] - findings, errors = await normalize_findings("snyk", raw) + findings, errors = await normalize_findings("snyk", raw, env=_LLM_ENV, model=_LLM_MODEL) assert len(findings) == 1, f"Expected 1 finding, got {len(findings)}. Errors: {errors}" f = findings[0] @@ -89,7 +95,7 @@ async def test_single_wiz_finding(): } ] - findings, errors = await normalize_findings("wiz", raw) + findings, errors = await normalize_findings("wiz", raw, env=_LLM_ENV, model=_LLM_MODEL) assert len(findings) == 1, f"Expected 1 finding, got {len(findings)}. Errors: {errors}" f = findings[0] @@ -109,7 +115,7 @@ async def test_batch_snyk_5_findings(): raw = _load_fixture("sample-snyk-export.json") assert len(raw) == 5 - findings, errors = await normalize_findings("snyk", raw) + findings, errors = await normalize_findings("snyk", raw, env=_LLM_ENV, model=_LLM_MODEL) assert len(findings) >= 4, ( f"Expected at least 4/5 findings, got {len(findings)}. Errors: {errors}" @@ -128,7 +134,7 @@ async def test_batch_wiz_3_findings(): raw = _load_fixture("sample-wiz-export.json") assert len(raw) == 3 - findings, errors = await normalize_findings("wiz", raw) + findings, errors = await normalize_findings("wiz", raw, env=_LLM_ENV, model=_LLM_MODEL) assert len(findings) >= 2, ( f"Expected at least 2/3 findings, got {len(findings)}. Errors: {errors}" @@ -176,7 +182,7 @@ async def test_severity_mapping(): }, ] - findings, errors = await normalize_findings("snyk", raw) + findings, errors = await normalize_findings("snyk", raw, env=_LLM_ENV, model=_LLM_MODEL) assert len(findings) >= 3, f"Expected at least 3/4, got {len(findings)}. Errors: {errors}" @@ -203,7 +209,7 @@ async def test_minimal_input_fields(): } ] - findings, errors = await normalize_findings("snyk", raw) + findings, errors = await normalize_findings("snyk", raw, env=_LLM_ENV, model=_LLM_MODEL) assert len(findings) == 1, f"Expected 1 finding. Errors: {errors}" f = findings[0] @@ -227,7 +233,7 @@ async def test_unknown_scanner_format(): } ] - findings, errors = await normalize_findings("trivy", raw) + findings, errors = await normalize_findings("trivy", raw, env=_LLM_ENV, model=_LLM_MODEL) assert len(findings) == 1, f"Expected 1 finding. Errors: {errors}" f = findings[0] @@ -248,7 +254,7 @@ async def test_large_batch_20_findings(): assert len(raw) == 20 - findings, errors = await normalize_findings("snyk", raw) + findings, errors = await normalize_findings("snyk", raw, env=_LLM_ENV, model=_LLM_MODEL) # gpt-4.1-nano truncates output for large batches — this is a known limitation. # The chunk fallback in ingest_worker handles this in production by retrying diff --git a/backend/tests/agents/test_plain_description_eval.py b/backend/tests/agents/test_plain_description_eval.py index 8684229c..3702a228 100644 --- a/backend/tests/agents/test_plain_description_eval.py +++ b/backend/tests/agents/test_plain_description_eval.py @@ -13,7 +13,7 @@ - ``sentence_count_range``: [min, max] sentences allowed Budget: ~10 LLM calls, roughly $0.02. Skipped automatically when no API -key or OpenCode binary is present (see ``conftest.py``). +key is present (see ``conftest.py``). """ from __future__ import annotations @@ -26,6 +26,11 @@ from cliff.integrations.normalizer import normalize_findings +# Real-LLM provider state + model selection, shared with the normalizer agent +# tests (see eval_utils). Skip-gated on an API key being present (conftest). +from tests.agents.eval_utils import LLM_ENV as _LLM_ENV +from tests.agents.eval_utils import LLM_MODEL as _LLM_MODEL + FIXTURE_PATH = Path(__file__).parent / "fixtures" / "plain_description_evals.json" @@ -48,7 +53,7 @@ def _count_sentences(text: str) -> int: async def test_plain_description_shape(record: dict) -> None: """Each fixture produces a plain_description that passes shape checks.""" findings, errors = await normalize_findings( - record["source"], [record["raw_finding"]] + record["source"], [record["raw_finding"]], env=_LLM_ENV, model=_LLM_MODEL ) assert not errors, f"Normalizer errors for {record['id']}: {errors}" assert len(findings) == 1, f"Expected 1 finding, got {len(findings)}" diff --git a/backend/tests/agents/tools/test_permissions.py b/backend/tests/agents/tools/test_permissions.py index 7dfe4986..0bf4e1a9 100644 --- a/backend/tests/agents/tools/test_permissions.py +++ b/backend/tests/agents/tools/test_permissions.py @@ -79,9 +79,12 @@ def test_empty_bash_patterns_is_ask(self): assert classify_tool_request("bash", []) == "ask" -def _ctx(*, approved: bool = False) -> SimpleNamespace: - """Minimal RunContext stand-in — gate only reads tool_call_approved.""" - return SimpleNamespace(tool_call_approved=approved, deps=None) +def _ctx(*, approved: bool = False, auto_approve: bool = False) -> SimpleNamespace: + """Minimal RunContext stand-in — gate reads tool_call_approved + deps.""" + return SimpleNamespace( + tool_call_approved=approved, + deps=SimpleNamespace(auto_approve=auto_approve), + ) class TestGateToolCall: @@ -117,3 +120,51 @@ def test_custom_metadata_attached_to_approval(self): metadata={"tool": "bash", "command": "rm -rf x"}, ) assert exc_info.value.metadata["command"] == "rm -rf x" + + def test_auto_approve_proceeds_on_ask_tier(self): + """Repo-action runs (auto_approve) skip the approval prompt on the + ask tier — there's no HITL surface for a one-shot background run.""" + assert ( + gate_tool_call( + _ctx(auto_approve=True), tool="bash", patterns=["rm -rf build/"] + ) + == "ask" + ) + + def test_auto_approve_still_denies_catastrophic(self): + """auto_approve never lifts the deny tier — catastrophic commands + stay blocked even for a pre-approved repo-action run.""" + with pytest.raises(ModelRetry, match="Cliff safety policy"): + gate_tool_call( + _ctx(auto_approve=True), tool="bash", patterns=["sudo rm -rf /"] + ) + + # auto_approve pre-approves ONLY the gated-bash ask bucket (rm, git reset, + # …). It must NOT swallow the classifier's *safe-default* ask buckets — an + # external-directory escape, an edit that climbs out of the workspace, an + # mcp / unknown tool, or empty/unparseable bash. Those stay approval-gated + # so a confused repo-action run fails closed instead of silently executing + # something the policy routed to human review. + def test_auto_approve_does_not_swallow_external_directory(self): + with pytest.raises(ApprovalRequired): + gate_tool_call( + _ctx(auto_approve=True), tool="external_directory", patterns=["/etc"] + ) + + def test_auto_approve_does_not_swallow_edit_escape(self): + with pytest.raises(ApprovalRequired): + gate_tool_call( + _ctx(auto_approve=True), tool="edit", patterns=["/etc/hosts"] + ) + + def test_auto_approve_does_not_swallow_mcp(self): + with pytest.raises(ApprovalRequired): + gate_tool_call( + _ctx(auto_approve=True), tool="mcp", patterns=["some.tool"] + ) + + def test_auto_approve_does_not_swallow_empty_bash(self): + """Unparseable bash (no command to inspect) stays gated even for a + pre-approved run — we can't confirm it's a benign gated-bash op.""" + with pytest.raises(ApprovalRequired): + gate_tool_call(_ctx(auto_approve=True), tool="bash", patterns=[]) diff --git a/backend/tests/api/openapi_snapshot.json b/backend/tests/api/openapi_snapshot.json index d0fb182e..53bcba2d 100644 --- a/backend/tests/api/openapi_snapshot.json +++ b/backend/tests/api/openapi_snapshot.json @@ -2,7 +2,7 @@ "components": { "schemas": { "AIStatus": { - "description": "Wire shape for ``GET /api/integrations/ai/status``.\n\n``model`` is the canonical active model \u2014 the one Cliff writes into\n``app_setting(key=\"model\")`` and pushes into every workspace spawn.\nPer ADR-0037 there is one canonical state and one read; the\non_key_change hook restarts the singleton OpenCode synchronously on\nevery model/key write, so there is no separate \"what's loaded right\nnow\" signal worth exposing on the wire (architect health-check, M9).", + "description": "Wire shape for ``GET /api/integrations/ai/status``.\n\n``model`` is the canonical active model \u2014 the one Cliff writes into\n``app_setting(key=\"model\")`` and the PA model factory reads at each\nagent run. Per ADR-0037 / ADR-0047 there is one canonical state and\none read; with the substrate in-process there is no separate \"what's\nloaded right now\" signal worth exposing on the wire.", "properties": { "connected_at": { "anyOf": [ @@ -433,24 +433,6 @@ "title": "AgentRunUpdate", "type": "object" }, - "ApiKeyCreate": { - "properties": { - "key": { - "title": "Key", - "type": "string" - }, - "provider": { - "title": "Provider", - "type": "string" - } - }, - "required": [ - "provider", - "key" - ], - "title": "ApiKeyCreate", - "type": "object" - }, "Assessment": { "properties": { "branch": { @@ -1219,29 +1201,6 @@ "title": "CategoryProgress", "type": "object" }, - "ChatPermissionDecision": { - "properties": { - "approved": { - "title": "Approved", - "type": "boolean" - }, - "permission_id": { - "title": "Permission Id", - "type": "string" - }, - "session_id": { - "title": "Session Id", - "type": "string" - } - }, - "required": [ - "permission_id", - "session_id", - "approved" - ], - "title": "ChatPermissionDecision", - "type": "object" - }, "Completion": { "properties": { "assessment_id": { @@ -2658,6 +2617,7 @@ "type": "object" }, "HealthStatus": { + "description": "``/health`` response.\n\nField shape is preserved across the OpenCode \u2192 Pydantic AI substrate\nmigration (ADR-0047) so the frontend health card and ``cliffsec status``\ndon't churn. The agent substrate now runs **in-process**, so ``opencode``\nis always ``\"ok\"`` and ``opencode_version`` carries the Pydantic AI\nversion string (e.g. ``\"pydantic-ai 1.98.x\"``) rather than a subprocess\nversion.", "properties": { "ai_provider_ready": { "default": false, @@ -2675,7 +2635,7 @@ "type": "string" }, "opencode": { - "default": "unknown", + "default": "ok", "title": "Opencode", "type": "string" }, @@ -4025,6 +3985,38 @@ "title": "PreviousAssessmentInfo", "type": "object" }, + "ProviderInfo": { + "properties": { + "env": { + "items": { + "type": "string" + }, + "title": "Env", + "type": "array" + }, + "id": { + "title": "Id", + "type": "string" + }, + "models": { + "additionalProperties": true, + "title": "Models", + "type": "object" + }, + "name": { + "title": "Name", + "type": "string" + } + }, + "required": [ + "id", + "name", + "env", + "models" + ], + "title": "ProviderInfo", + "type": "object" + }, "ProviderModelOption": { "description": "One entry in the per-provider model picker dropdown.", "properties": { @@ -4107,7 +4099,7 @@ "type": "object" }, "ProviderTestRequest": { - "description": "Optional staged config. Alpha passes nothing and probes the currently\nconfigured provider/model/key; a future UI can preview unsaved staged\nconfig by populating these fields. Ignored today \u2014 probe uses whatever\nOpenCode has configured \u2014 but kept so the wire shape is stable.", + "description": "Optional staged config. Alpha passes nothing and probes the currently\nconfigured provider/model/key; a future UI can preview unsaved staged\nconfig by populating these fields. Ignored today \u2014 probe uses whatever\nthe canonical AI state has configured \u2014 but kept so the wire shape is\nstable.", "properties": { "api_key": { "anyOf": [ @@ -4993,7 +4985,7 @@ "type": "object" }, "VersionInfo": { - "description": "Version handshake for the agent CLI (`cliffsec status`).\n\n`min_cli` is the lowest CLI version this server promises to speak to.\nA CLI older than this should refuse to operate and tell the user to upgrade.\n`schema_version` bumps when the CLI/server contract changes incompatibly.", + "description": "``/version`` handshake for the agent CLI (``cliffsec status``).\n\n``min_cli`` is the lowest CLI version this server promises to speak to; a\nCLI older than this refuses to operate. ``schema_version`` bumps when the\nCLI/server contract changes incompatibly. ``opencode`` is retained for a\nbackward-compatible wire shape and now carries the in-process substrate\nversion (ADR-0047).", "properties": { "cliff": { "title": "Cliff", @@ -5005,6 +4997,7 @@ "type": "string" }, "opencode": { + "default": "", "title": "Opencode", "type": "string" }, @@ -5015,8 +5008,7 @@ } }, "required": [ - "cliff", - "opencode" + "cliff" ], "title": "VersionInfo", "type": "object" @@ -5195,24 +5187,6 @@ "title": "Workspace", "type": "object" }, - "WorkspaceChatRequest": { - "properties": { - "content": { - "title": "Content", - "type": "string" - }, - "session_id": { - "title": "Session Id", - "type": "string" - } - }, - "required": [ - "session_id", - "content" - ], - "title": "WorkspaceChatRequest", - "type": "object" - }, "WorkspaceCreate": { "properties": { "current_focus": { @@ -7079,108 +7053,6 @@ ] } }, - "/api/settings/api-keys": { - "get": { - "operationId": "list_api_keys_api_settings_api_keys_get", - "responses": { - "200": { - "content": { - "application/json": { - "schema": {} - } - }, - "description": "Successful Response" - } - }, - "summary": "List Api Keys", - "tags": [ - "settings" - ] - } - }, - "/api/settings/api-keys/{provider}": { - "delete": { - "operationId": "delete_api_key_api_settings_api_keys__provider__delete", - "parameters": [ - { - "in": "path", - "name": "provider", - "required": true, - "schema": { - "title": "Provider", - "type": "string" - } - } - ], - "responses": { - "204": { - "description": "Successful Response" - }, - "422": { - "content": { - "application/json": { - "schema": { - "$ref": "#/components/schemas/HTTPValidationError" - } - } - }, - "description": "Validation Error" - } - }, - "summary": "Delete Api Key", - "tags": [ - "settings" - ] - }, - "put": { - "operationId": "set_api_key_api_settings_api_keys__provider__put", - "parameters": [ - { - "in": "path", - "name": "provider", - "required": true, - "schema": { - "title": "Provider", - "type": "string" - } - } - ], - "requestBody": { - "content": { - "application/json": { - "schema": { - "$ref": "#/components/schemas/ApiKeyCreate" - } - } - }, - "required": true - }, - "responses": { - "200": { - "content": { - "application/json": { - "schema": {} - } - }, - "description": "Successful Response" - }, - "422": { - "content": { - "application/json": { - "schema": { - "$ref": "#/components/schemas/HTTPValidationError" - } - } - }, - "description": "Validation Error" - } - }, - "summary": "Set Api Key", - "tags": [ - "settings" - ] - } - }, "/api/settings/integrations": { "get": { "operationId": "list_integrations_endpoint_api_settings_integrations_get", @@ -7656,7 +7528,7 @@ }, "/api/settings/model": { "get": { - "description": "Return the canonical active model (ADR-0037).\n\nThin shim over :class:`AIIntegrationService` so the CLI (``cliffsec\nmodel get``) and the new Settings UI agree byte-for-byte. Falls\nback to the old ``opencode.json``-derived value when no AI\nprovider is connected so legacy users without an ``ai_integration``\nrow still get something meaningful.", + "description": "Return the canonical active model (ADR-0037).\n\nThin shim over :class:`AIIntegrationService` so the CLI (``cliffsec\nmodel get``) and the Settings UI agree byte-for-byte. Returns an\nempty :class:`ModelConfig` when no AI provider is connected yet\n(fresh install) \u2014 the UI treats a blank ``model_full_id`` as \"no\nmodel set\" and the agent-launch gate keeps things safe.", "operationId": "get_model_api_settings_model_get", "responses": { "200": { @@ -7676,7 +7548,7 @@ ] }, "put": { - "description": "Persist a model change (ADR-0037).\n\nRoutes through :class:`AIIntegrationService.set_model` when a\nprovider is connected. On a fresh install with no provider yet,\nfalls through to the legacy ``config_manager.update_model`` so\n``cliffsec model set`` during install still works before BYOK.", + "description": "Persist a model change (ADR-0037).\n\nRoutes through :class:`AIIntegrationService.set_model`, which writes\nthe canonical ``app_setting(model)``. Requires a connected provider \u2014\na model can't be chosen before picking who serves it.", "operationId": "update_model_api_settings_model_put", "requestBody": { "content": { @@ -7718,12 +7590,19 @@ }, "/api/settings/providers": { "get": { + "description": "Return the supported-provider catalog (ADR-0037).\n\nBuilt from the static :mod:`cliff.ai.catalog` \u2014 one entry per\nprovider with its key env var and the curated model picker rows. The\nwire shape (``{id, name, env, models}`` with ``models`` keyed by the\nbare model id) is what the Settings model picker and ``cliffsec model\nlist`` consume.", "operationId": "list_providers_api_settings_providers_get", "responses": { "200": { "content": { "application/json": { - "schema": {} + "schema": { + "items": { + "$ref": "#/components/schemas/ProviderInfo" + }, + "title": "Response List Providers Api Settings Providers Get", + "type": "array" + } } }, "description": "Successful Response" @@ -7735,28 +7614,9 @@ ] } }, - "/api/settings/providers/configured": { - "get": { - "operationId": "get_configured_providers_api_settings_providers_configured_get", - "responses": { - "200": { - "content": { - "application/json": { - "schema": {} - } - }, - "description": "Successful Response" - } - }, - "summary": "Get Configured Providers", - "tags": [ - "settings" - ] - } - }, "/api/settings/providers/test": { "post": { - "description": "End-to-end probe of the configured provider+model (ADR-0031).\n\nSends a bounded ``\"Say OK\"`` chat call through OpenCode with a 30s\ntimeout and classifies the outcome into\n``{ok, latency_ms, error_code, error_message}``. Always returns HTTP\n200; ``ok`` reflects the probe result.", + "description": "End-to-end probe of the configured provider+model (ADR-0031).\n\nSends a bounded ``\"Say OK\"`` call through Pydantic AI with a 30s\ntimeout and classifies the outcome into\n``{ok, latency_ms, error_code, error_message}``. Always returns HTTP\n200; ``ok`` reflects the probe result.", "operationId": "test_provider_api_settings_providers_test_post", "requestBody": { "content": { @@ -7952,7 +7812,7 @@ }, "/api/workspaces/{workspace_id}": { "delete": { - "description": "Delete workspace: stop process, remove directory, delete DB row.", + "description": "Delete workspace: remove directory + DB row.", "operationId": "delete_workspace_endpoint_api_workspaces__workspace_id__delete", "parameters": [ { @@ -8481,158 +8341,6 @@ ] } }, - "/api/workspaces/{workspace_id}/chat/permission": { - "post": { - "description": "Approve or deny a permission request from the chat path.\n\nUnlike the agent-execution permission endpoint, this calls\nOpenCode's permission API directly (no executor involved).", - "operationId": "respond_to_chat_permission_api_workspaces__workspace_id__chat_permission_post", - "parameters": [ - { - "in": "path", - "name": "workspace_id", - "required": true, - "schema": { - "title": "Workspace Id", - "type": "string" - } - } - ], - "requestBody": { - "content": { - "application/json": { - "schema": { - "$ref": "#/components/schemas/ChatPermissionDecision" - } - } - }, - "required": true - }, - "responses": { - "200": { - "content": { - "application/json": { - "schema": {} - } - }, - "description": "Successful Response" - }, - "422": { - "content": { - "application/json": { - "schema": { - "$ref": "#/components/schemas/HTTPValidationError" - } - } - }, - "description": "Validation Error" - } - }, - "summary": "Respond To Chat Permission", - "tags": [ - "workspaces" - ] - } - }, - "/api/workspaces/{workspace_id}/chat/send": { - "post": { - "description": "Send a message to this workspace's OpenCode process.", - "operationId": "workspace_send_message_api_workspaces__workspace_id__chat_send_post", - "parameters": [ - { - "in": "path", - "name": "workspace_id", - "required": true, - "schema": { - "title": "Workspace Id", - "type": "string" - } - } - ], - "requestBody": { - "content": { - "application/json": { - "schema": { - "$ref": "#/components/schemas/WorkspaceChatRequest" - } - } - }, - "required": true - }, - "responses": { - "200": { - "content": { - "application/json": { - "schema": {} - } - }, - "description": "Successful Response" - }, - "422": { - "content": { - "application/json": { - "schema": { - "$ref": "#/components/schemas/HTTPValidationError" - } - } - }, - "description": "Validation Error" - } - }, - "summary": "Workspace Send Message", - "tags": [ - "workspaces" - ] - } - }, - "/api/workspaces/{workspace_id}/chat/stream": { - "get": { - "description": "Stream SSE events from this workspace's OpenCode process.", - "operationId": "workspace_stream_events_api_workspaces__workspace_id__chat_stream_get", - "parameters": [ - { - "in": "path", - "name": "workspace_id", - "required": true, - "schema": { - "title": "Workspace Id", - "type": "string" - } - }, - { - "in": "query", - "name": "session_id", - "required": true, - "schema": { - "title": "Session Id", - "type": "string" - } - } - ], - "responses": { - "200": { - "content": { - "application/json": { - "schema": {} - } - }, - "description": "Successful Response" - }, - "422": { - "content": { - "application/json": { - "schema": { - "$ref": "#/components/schemas/HTTPValidationError" - } - } - }, - "description": "Validation Error" - } - }, - "summary": "Workspace Stream Events", - "tags": [ - "workspaces" - ] - } - }, "/api/workspaces/{workspace_id}/context": { "get": { "description": "Return the full context snapshot for the sidebar.", @@ -9053,88 +8761,6 @@ ] } }, - "/api/workspaces/{workspace_id}/pool-status": { - "get": { - "description": "Debug endpoint: show process pool status for this workspace.", - "operationId": "workspace_pool_status_api_workspaces__workspace_id__pool_status_get", - "parameters": [ - { - "in": "path", - "name": "workspace_id", - "required": true, - "schema": { - "title": "Workspace Id", - "type": "string" - } - } - ], - "responses": { - "200": { - "content": { - "application/json": { - "schema": {} - } - }, - "description": "Successful Response" - }, - "422": { - "content": { - "application/json": { - "schema": { - "$ref": "#/components/schemas/HTTPValidationError" - } - } - }, - "description": "Validation Error" - } - }, - "summary": "Workspace Pool Status", - "tags": [ - "workspaces" - ] - } - }, - "/api/workspaces/{workspace_id}/sessions": { - "post": { - "description": "Create an OpenCode session on this workspace's isolated process.", - "operationId": "create_workspace_session_api_workspaces__workspace_id__sessions_post", - "parameters": [ - { - "in": "path", - "name": "workspace_id", - "required": true, - "schema": { - "title": "Workspace Id", - "type": "string" - } - } - ], - "responses": { - "200": { - "content": { - "application/json": { - "schema": {} - } - }, - "description": "Successful Response" - }, - "422": { - "content": { - "application/json": { - "schema": { - "$ref": "#/components/schemas/HTTPValidationError" - } - } - }, - "description": "Validation Error" - } - }, - "summary": "Create Workspace Session", - "tags": [ - "workspaces" - ] - } - }, "/api/workspaces/{workspace_id}/sidebar": { "get": { "operationId": "get_sidebar_endpoint_api_workspaces__workspace_id__sidebar_get", diff --git a/backend/tests/conftest.py b/backend/tests/conftest.py index b099a324..55bee5ff 100644 --- a/backend/tests/conftest.py +++ b/backend/tests/conftest.py @@ -31,43 +31,10 @@ def _stub_onboarding_repo_probe(): yield -# --------------------------------------------------------------------------- -# OpenCode mocks (existing tests) -# --------------------------------------------------------------------------- - - -@pytest.fixture -def mock_opencode_process(): - """Mock the OpenCode process manager so tests don't need a real server.""" - with ( - patch("cliff.api.routes.health.opencode_process") as mock_proc, - patch("cliff.api.routes.health.opencode_client") as mock_health_client, - ): - mock_proc.health_check = AsyncMock(return_value=True) - mock_proc.is_running = True - mock_proc.is_healthy = True - mock_health_client.get_config = AsyncMock( - return_value={"model": "openai/gpt-4.1-nano"} - ) - yield mock_proc - - -@pytest.fixture -def mock_opencode_client(): - """Legacy no-op fixture. - - Previously mocked the singleton OpenCode client behind the generic - ``/api/sessions`` + ``/api/chat`` routes, deleted in the chat-spike - removal (IMPL-0022 PR #3a). Kept as a no-op so dependents (the - ``client`` fixture, a couple of Docker tests) don't need signature - churn — the health route's client is mocked by ``mock_opencode_process``. - """ - yield None - - @pytest.fixture -def client(mock_opencode_process, mock_opencode_client): - """FastAPI test client with mocked dependencies.""" +def client(): + """FastAPI test client with a no-op lifespan (ADR-0047 — in-process + substrate, nothing to spawn).""" from cliff.main import app app.router.lifespan_context = _noop_lifespan diff --git a/backend/tests/e2e/__init__.py b/backend/tests/e2e/__init__.py deleted file mode 100644 index e69de29b..00000000 diff --git a/backend/tests/e2e/conftest.py b/backend/tests/e2e/conftest.py deleted file mode 100644 index 115edf43..00000000 --- a/backend/tests/e2e/conftest.py +++ /dev/null @@ -1,159 +0,0 @@ -"""E2E test fixtures — real OpenCode subprocess + real FastAPI app.""" - -from __future__ import annotations - -import asyncio -import os -import time -from contextlib import asynccontextmanager -from shutil import which - -import pytest -from fastapi.testclient import TestClient - -from cliff.config import settings -from cliff.engine.process import OpenCodeProcess - -# Isolate the e2e session's OpenCode from any running daemon. Without -# this the e2e suite silently *shares* the daemon's OpenCode on the -# default port 4096 (OpenCodeProcess.start() succeeds as long as the -# port answers — even if the answerer is somebody else's process) and -# inherits its model + config, making the settings/model tests flap -# against whatever the user happened to have selected. Mutating -# ``settings.opencode_port`` at conftest module-import time means the -# session-scoped OpenCodeProcess below starts on 4097 and the fresh -# OpenCodeClient we build per-test in ``app_client`` reads -# ``settings.opencode_url`` with the new port baked in. -_E2E_OPENCODE_PORT = 4097 - - -def _verify_e2e_port_free(port: int) -> None: - """Refuse to run if ``port`` is already in use. - - The 4097 → 4096 collision we just fixed could silently recur on a - different port if anything else (another e2e run, an unrelated dev - process) happens to be listening. Bind-test first; fail loud with - a clear remediation message so the next person isn't stuck - debugging a flake. - """ - import socket - with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s: - try: - s.bind(("127.0.0.1", port)) - except OSError as exc: - raise RuntimeError( - f"e2e OpenCode port {port} is already in use ({exc}). " - "Stop whatever's listening, or override via " - "CLIFF_OPENCODE_PORT before invoking pytest." - ) from exc - - -# Compute e2e prerequisites first — the port check + settings mutation -# below are e2e-only side effects, and a combined run like -# ``pytest backend/tests`` imports this conftest at collection even when -# e2e tests will be skipped. Gating both behind the availability flags -# keeps a busy port from aborting a unit-only run and keeps the -# settings.opencode_port singleton untouched for non-e2e tests. -_opencode_available = settings.opencode_binary_path.exists() or which("opencode") is not None -_api_key_set = bool(os.environ.get("OPENAI_API_KEY") or os.environ.get("ANTHROPIC_API_KEY")) - -if _opencode_available and _api_key_set: - # Honour CLIFF_OPENCODE_PORT if the operator pinned a different port; - # otherwise default to the dedicated e2e port. Bind-test before - # mutating settings so the failure is at conftest load, not mid-test. - _E2E_OPENCODE_PORT = int(os.environ.get("CLIFF_OPENCODE_PORT", _E2E_OPENCODE_PORT)) - _verify_e2e_port_free(_E2E_OPENCODE_PORT) - settings.opencode_port = _E2E_OPENCODE_PORT - -_skip_no_binary = pytest.mark.skipif( - not _opencode_available, reason="OpenCode binary not found" -) -_skip_no_key = pytest.mark.skipif( - not _api_key_set, reason="No LLM API key set (OPENAI_API_KEY)" -) - - -def pytest_collection_modifyitems(items): - """Mark all items in this directory as e2e and apply skip conditions.""" - for item in items: - if "/e2e/" in str(item.fspath): - item.add_marker(pytest.mark.e2e) - item.add_marker(_skip_no_binary) - item.add_marker(_skip_no_key) - - -@asynccontextmanager -async def _noop_lifespan(app): - yield - - -# Session-scoped OpenCode process -_process: OpenCodeProcess | None = None - - -@pytest.fixture(scope="session", autouse=True) -def opencode_server(): - """Start a real OpenCode server for the e2e test session.""" - global _process - _process = OpenCodeProcess() - - loop = asyncio.new_event_loop() - try: - loop.run_until_complete(_process.start()) - # Extra wait for OpenCode to be fully ready - time.sleep(2) - yield _process - finally: - loop.run_until_complete(_process.stop()) - loop.close() - _process = None - - -@pytest.fixture -def app_client(opencode_server): - """FastAPI TestClient with real OpenCode running underneath. - - Each test gets a fresh TestClient to avoid connection pool issues. - """ - from cliff.db.connection import close_db, init_db - from cliff.engine.client import OpenCodeClient - from cliff.main import app - - # Skip lifespan — OpenCode is already running via session fixture - app.router.lifespan_context = _noop_lifespan - - # Initialize in-memory DB for settings endpoints - loop = asyncio.get_event_loop() - if loop.is_closed(): - loop = asyncio.new_event_loop() - loop.run_until_complete(init_db(":memory:")) - - # Reset the singleton client to avoid stale connections AND to pick - # up the e2e-isolated port (see top of file). Every module that did - # ``from cliff.engine.client import opencode_client`` at import time - # holds its OWN name binding to the original-port client — rebinding - # the source module alone doesn't fix them. List of importers comes - # from ``grep -rn "from cliff.engine.client import opencode_client" - # backend/cliff/``. ``ai/service.py`` re-imports inside its functions - # so it's auto-fixed by the source-module rebind; the rest must be - # rebound explicitly here, or routes like /health and /api/settings - # will silently hit the original-port client. - import cliff.api.routes.health as health_mod - import cliff.api.routes.settings as routes_settings_mod - import cliff.engine.client as client_mod - import cliff.engine.config_manager as config_mod - import cliff.integrations.normalizer as normalizer_mod - import cliff.main as cliff_main_mod - - fresh_client = OpenCodeClient(base_url=settings.opencode_url) - client_mod.opencode_client = fresh_client - config_mod.opencode_client = fresh_client - health_mod.opencode_client = fresh_client - routes_settings_mod.opencode_client = fresh_client - normalizer_mod.opencode_client = fresh_client - cliff_main_mod.opencode_client = fresh_client - - with TestClient(app) as client: - yield client - - loop.run_until_complete(close_db()) diff --git a/backend/tests/e2e/test_agent_pipeline_e2e.py b/backend/tests/e2e/test_agent_pipeline_e2e.py deleted file mode 100644 index 0b2f76e9..00000000 --- a/backend/tests/e2e/test_agent_pipeline_e2e.py +++ /dev/null @@ -1,397 +0,0 @@ -"""E2E tests for the agent orchestration pipeline with real OpenCode + LLM. - -These tests start a real workspace OpenCode process, execute a real sub-agent -(Finding Enricher), and verify that structured output is parsed, context files -are written, and sidebar state is updated in the DB. - -Requires: - - OpenCode binary installed - - OPENAI_API_KEY (or another provider key) set in the environment - -Auto-skipped if prerequisites are missing (via e2e/conftest.py markers). -""" - -from __future__ import annotations - -import json -from datetime import UTC, datetime -from typing import TYPE_CHECKING - -import pytest - -if TYPE_CHECKING: - from pathlib import Path - -from cliff.agents import AgentTemplateEngine -from cliff.agents.executor import AgentExecutor -from cliff.agents.pipeline import suggest_next -from cliff.db.connection import close_db, init_db -from cliff.db.repo_finding import create_finding -from cliff.db.repo_workspace import create_workspace -from cliff.engine.pool import PortAllocator, WorkspaceProcessPool -from cliff.models import Finding, FindingCreate, WorkspaceCreate -from cliff.workspace import WorkspaceDirManager -from cliff.workspace.context_builder import WorkspaceContextBuilder - -# --------------------------------------------------------------------------- -# Helpers -# --------------------------------------------------------------------------- - - -def _make_finding() -> Finding: - """Create a realistic security finding for E2E testing.""" - now = datetime.now(UTC) - return Finding( - id="f-e2e-enricher", - source_type="test", - source_id="test-f-e2e-enricher", - title="Log4j RCE (CVE-2021-44228)", - description=( - "Apache Log4j2 versions 2.0-beta9 through 2.14.1 contain a " - "JNDI lookup feature that allows remote code execution. An " - "attacker who can control log messages can execute arbitrary " - "code loaded from LDAP servers." - ), - raw_severity="critical", - normalized_priority="P1", - asset_id="app-server-prod-01", - asset_label="app-server-prod-01", - status="new", - why_this_matters="Known active exploitation in the wild since Dec 2021.", - created_at=now, - updated_at=now, - ) - - -def _create_workspace_dir( - dir_manager: WorkspaceDirManager, - template_engine: AgentTemplateEngine, - workspace_id: str, - finding: Finding, -) -> Path: - """Create a workspace directory with finding context and agent templates.""" - ws = dir_manager.create(workspace_id, finding) - finding_dict = finding.model_dump(mode="json") - template_engine.write_agents(ws.agents_dir, finding=finding_dict) - return ws.root - - -async def _seed_db_and_create_workspace( - db, - finding: Finding, - dir_manager: WorkspaceDirManager, - template_engine: AgentTemplateEngine, -): - """Insert DB rows and create workspace directory. Returns (workspace, ws_dir).""" - # Insert finding row - db_finding = await create_finding( - db, - FindingCreate( - source_type=finding.source_type, - source_id=finding.source_id, - title=finding.title, - description=finding.description, - raw_severity=finding.raw_severity, - normalized_priority=finding.normalized_priority, - asset_id=finding.asset_id, - asset_label=finding.asset_label, - status=finding.status, - ), - ) - - # Insert workspace row - workspace = await create_workspace( - db, - WorkspaceCreate(finding_id=db_finding.id), - ) - - # Create directory using the DB-generated workspace ID - ws_dir = _create_workspace_dir( - dir_manager, template_engine, workspace.id, finding - ) - - return workspace, ws_dir - - -# --------------------------------------------------------------------------- -# Fixtures -# --------------------------------------------------------------------------- - - -@pytest.fixture -def dir_manager(tmp_path: Path) -> WorkspaceDirManager: - return WorkspaceDirManager(base_dir=tmp_path / "workspaces") - - -@pytest.fixture -def template_engine() -> AgentTemplateEngine: - return AgentTemplateEngine() - - -# Shared resolvers: the pool needs them so OpenCode subprocesses get a -# usable env; the executor needs the same callables so the PA no-tools -# path can construct a Model. Module-level so a future fixture (or test) -# doesn't accidentally diverge from the pair the pool uses. -async def _e2e_env_resolver() -> dict[str, str]: - import os - key = os.environ.get("OPENAI_API_KEY", "") - return {"OPENAI_API_KEY": key} if key else {} - - -async def _e2e_model_resolver() -> str | None: - # Pin to a cheap available OpenAI model. Without a canonical model - # the per-workspace opencode.json carries no ``model`` field and - # OpenCode falls back to a built-in default (typically Anthropic) - # that needs a key we haven't injected; the PA path likewise needs - # a model id with a provider prefix it can route. - return "openai/gpt-4.1-nano" - - -@pytest.fixture -async def pool(db): - """Process pool using ports 4230-4240 to avoid conflicts with other E2E tests. - - Wires an ``env_resolver`` that drains ``OPENAI_API_KEY`` from the host - env into the spawned workspace OpenCode subprocess. Without it the - pool's provider-env-var scrubber (commit 2321931 — workspace isolation - from host AI env) strips the host key and OpenCode 401s with "Missing - Authentication header" — which is what we test, not what we want to - test against. - """ - p = WorkspaceProcessPool( - port_allocator=PortAllocator(start=4230, end=4240), - env_resolver=_e2e_env_resolver, - model_resolver=_e2e_model_resolver, - ) - yield p - await p.stop_all() - - -@pytest.fixture -async def db(): - """In-memory SQLite database with schema initialized.""" - connection = await init_db(":memory:") - yield connection - await close_db() - - -@pytest.fixture -def context_builder( - dir_manager: WorkspaceDirManager, template_engine: AgentTemplateEngine -) -> WorkspaceContextBuilder: - return WorkspaceContextBuilder(dir_manager, template_engine) - - -@pytest.fixture -def executor( - pool: WorkspaceProcessPool, context_builder: WorkspaceContextBuilder -) -> AgentExecutor: - # The PA no-tools path requires both resolvers — same callables the - # pool consumes so the executor and OpenCode subprocesses agree on - # which provider+key+model is active for this run (ADR-0047). - return AgentExecutor( - pool, - context_builder, - ai_env_resolver=_e2e_env_resolver, - ai_model_resolver=_e2e_model_resolver, - ) - - -# --------------------------------------------------------------------------- -# Tests -# --------------------------------------------------------------------------- - - -async def test_execute_enricher_e2e( - executor: AgentExecutor, - pool: WorkspaceProcessPool, - dir_manager: WorkspaceDirManager, - template_engine: AgentTemplateEngine, - db, -): - """Execute the Finding Enricher on a real finding with a real LLM. - - This is the core E2E test — it proves the full pipeline works: - prompt → OpenCode → LLM → response → parse → persist. - """ - finding = _make_finding() - workspace, ws_dir = await _seed_db_and_create_workspace( - db, finding, dir_manager, template_engine - ) - - # Execute the enricher agent - result = await executor.execute( - workspace.id, - "finding_enricher", - db, - workspace_dir=str(ws_dir), - timeout=120.0, - ) - - # The agent should complete (not timeout or crash) - assert result.status == "completed", ( - f"Agent failed: {result.error or result.parse_result.error}" - ) - - # ADR-0047 — the PA no-tools path returns the validated dict directly, - # so ``raw_text`` is empty by design (OpenCode-era prose was the input - # to a separate parse step that this PR replaces). The shape contract - # is now ``structured_output``. - assert result.parse_result.success, ( - f"Enricher PA call did not produce parseable output: " - f"{result.parse_result.error}" - ) - assert result.parse_result.structured_output, ( - "PA path returned an empty structured_output dict" - ) - - # success + non-empty structured_output are asserted above, so - # persistence MUST have run. Verify unconditionally. - enrichment_file = ws_dir / "context" / "enrichment.json" - assert enrichment_file.exists(), "enrichment.json not written to disk" - - enrichment_data = json.loads(enrichment_file.read_text()) - assert isinstance(enrichment_data, dict) - - # CONTEXT.md should have been regenerated - context_md = ws_dir / "CONTEXT.md" - assert context_md.exists() - context_text = context_md.read_text() - assert "enrichment" in context_text.lower() or "CVE" in context_text - - # Sidebar should have been updated - assert result.sidebar_updated is True - assert result.context_version is not None - assert result.context_version > 0 - - -async def test_suggest_next_advances_after_enrichment( - executor: AgentExecutor, - context_builder: WorkspaceContextBuilder, - dir_manager: WorkspaceDirManager, - template_engine: AgentTemplateEngine, - db, -): - """After enricher completes, suggest_next should return exposure_analyzer. - - Per IMPL-0022 PR #1 (ADR-0047), ``owner_resolver`` was dropped from - the forward pipeline; the next step after enrichment is now - ``exposure_analyzer``. The agent stays callable directly. - """ - finding = _make_finding() - workspace, ws_dir = await _seed_db_and_create_workspace( - db, finding, dir_manager, template_engine - ) - - # Before enrichment: should suggest enricher - snapshot_before = await context_builder.get_context_snapshot(workspace.id) - history_before = snapshot_before.pop("agent_run_history", []) - suggestion_before = suggest_next(snapshot_before, history_before) - assert suggestion_before is not None - assert suggestion_before.agent_type == "finding_enricher" - - # Run enricher - result = await executor.execute( - workspace.id, - "finding_enricher", - db, - workspace_dir=str(ws_dir), - timeout=120.0, - ) - - if not (result.parse_result.success and result.parse_result.structured_output): - pytest.skip("Enricher didn't produce structured output — can't test pipeline advance") - - # After enrichment: should suggest exposure_analyzer (next in - # PIPELINE_ORDER after owner_resolver was dropped). - snapshot_after = await context_builder.get_context_snapshot(workspace.id) - history_after = snapshot_after.pop("agent_run_history", []) - suggestion_after = suggest_next(snapshot_after, history_after) - assert suggestion_after is not None - assert suggestion_after.agent_type == "exposure_analyzer", ( - f"Expected exposure_analyzer but got {suggestion_after.agent_type}" - ) - - -async def test_suggest_next_on_fresh_workspace( - context_builder: WorkspaceContextBuilder, - dir_manager: WorkspaceDirManager, - template_engine: AgentTemplateEngine, -): - """suggest_next on a fresh workspace returns finding_enricher.""" - finding = _make_finding() - _create_workspace_dir( - dir_manager, template_engine, "ws-e2e-fresh", finding - ) - - snapshot = await context_builder.get_context_snapshot("ws-e2e-fresh") - history = snapshot.pop("agent_run_history", []) - suggestion = suggest_next(snapshot, history) - - assert suggestion is not None - assert suggestion.agent_type == "finding_enricher" - assert suggestion.priority == "recommended" - - -async def test_workspace_process_starts_and_responds( - pool: WorkspaceProcessPool, - dir_manager: WorkspaceDirManager, - template_engine: AgentTemplateEngine, -): - """Verify workspace process starts and can create a session.""" - finding = _make_finding() - ws_dir = _create_workspace_dir( - dir_manager, template_engine, "ws-e2e-process", finding - ) - - client = await pool.start("ws-e2e-process", ws_dir) - assert client is not None - - healthy = await client.health_check() - assert healthy is True - - session = await client.create_session() - assert session.id - - -async def test_enricher_progress_callback( - executor: AgentExecutor, - dir_manager: WorkspaceDirManager, - template_engine: AgentTemplateEngine, - db, -): - """The no-tools PA path completes without invoking on_progress. - - ADR-0047 — streaming text deltas was an OpenCode SSE-plumbing feature - that mattered when the no-tools agents emitted prose mid-flight. The - PA no-tools path is a single ``agent.run()`` that returns the - validated output dict in one call; there's nothing to stream. The - callback contract is preserved (``on_progress`` is still accepted) - so tool agents like remediation_executor — which DO stream — keep - their existing UX. PR #2 covers tool-agent streaming under PA. - """ - finding = _make_finding() - workspace, ws_dir = await _seed_db_and_create_workspace( - db, finding, dir_manager, template_engine - ) - - progress_texts: list[str] = [] - - result = await executor.execute( - workspace.id, - "finding_enricher", - db, - workspace_dir=str(ws_dir), - timeout=120.0, - on_progress=progress_texts.append, - ) - - assert result.status == "completed" - # Locking down the behavior change: PA no-tools agents do NOT emit - # progress callbacks. If a future PR adds streaming for no-tools - # agents (or accidentally re-wires the OpenCode path here), this - # assertion fires and the change is conscious, not silent. - assert progress_texts == [], ( - f"PA no-tools path emitted progress callbacks unexpectedly: " - f"{progress_texts!r}" - ) diff --git a/backend/tests/e2e/test_health_e2e.py b/backend/tests/e2e/test_health_e2e.py deleted file mode 100644 index b742acd6..00000000 --- a/backend/tests/e2e/test_health_e2e.py +++ /dev/null @@ -1,20 +0,0 @@ -"""E2E: Health endpoint with real OpenCode.""" - -from __future__ import annotations - - -def test_health_returns_ok(app_client): - resp = app_client.get("/health") - assert resp.status_code == 200 - data = resp.json() - assert data["cliff"] == "ok" - assert data["opencode"] == "ok" - assert data["model"] # non-empty model name - - -def test_health_shows_version(app_client): - resp = app_client.get("/health") - data = resp.json() - version = data["opencode_version"] - assert version - assert "." in version # looks like semver diff --git a/backend/tests/e2e/test_process_pool_e2e.py b/backend/tests/e2e/test_process_pool_e2e.py deleted file mode 100644 index f42e1118..00000000 --- a/backend/tests/e2e/test_process_pool_e2e.py +++ /dev/null @@ -1,394 +0,0 @@ -"""E2E tests for WorkspaceProcessPool with real OpenCode processes. - -These tests start actual OpenCode subprocesses on real ports. They verify -process lifecycle, multi-workspace isolation, port management, and failure -modes under real conditions. - -Requires: - - OpenCode binary installed - - OPENAI_API_KEY (or another provider key) set in the environment - -Auto-skipped if prerequisites are missing (via e2e/conftest.py markers). -""" - -from __future__ import annotations - -import asyncio -from datetime import UTC, datetime, timedelta -from typing import TYPE_CHECKING - -import pytest - -if TYPE_CHECKING: - from pathlib import Path - -from cliff.agents import AgentTemplateEngine -from cliff.engine.pool import PortAllocator, WorkspaceProcessPool -from cliff.models import Finding -from cliff.workspace import WorkspaceDirManager - -# --------------------------------------------------------------------------- -# Fixtures -# --------------------------------------------------------------------------- - - -def _make_finding(finding_id: str, title: str) -> Finding: - """Create a Finding model for workspace directory setup.""" - now = datetime.now(UTC) - return Finding( - id=finding_id, - source_type="test", - source_id=f"test-{finding_id}", - title=title, - description=f"Test finding: {title}", - raw_severity="high", - asset_id="test-asset", - asset_label="test-asset", - status="new", - created_at=now, - updated_at=now, - ) - - -@pytest.fixture -def dir_manager(tmp_path: Path) -> WorkspaceDirManager: - return WorkspaceDirManager(base_dir=tmp_path / "workspaces") - - -@pytest.fixture -def template_engine() -> AgentTemplateEngine: - return AgentTemplateEngine() - - -def _create_workspace_dir( - dir_manager: WorkspaceDirManager, - template_engine: AgentTemplateEngine, - workspace_id: str, - finding: Finding, -) -> Path: - """Create a real workspace directory with finding context and agent templates.""" - ws = dir_manager.create(workspace_id, finding) - finding_dict = finding.model_dump(mode="json") - template_engine.write_agents(ws.agents_dir, finding=finding_dict) - return ws.root - - -@pytest.fixture -async def pool(): - """Process pool using ports 4200-4220 to avoid conflicts.""" - p = WorkspaceProcessPool( - port_allocator=PortAllocator(start=4200, end=4220), - ) - yield p - await p.stop_all() - - -# --------------------------------------------------------------------------- -# Process lifecycle -# --------------------------------------------------------------------------- - - -async def test_start_single_workspace_process( - pool: WorkspaceProcessPool, - dir_manager: WorkspaceDirManager, - template_engine: AgentTemplateEngine, -): - """Start one workspace process, verify it's healthy and responds.""" - finding = _make_finding("f-001", "Log4j RCE (CVE-2021-44228)") - ws_dir = _create_workspace_dir(dir_manager, template_engine, "ws-e2e-1", finding) - - client = await pool.start("ws-e2e-1", ws_dir) - assert client is not None - - # Verify the process responds to health checks - healthy = await client.health_check() - assert healthy is True - - # Verify we can create a session - session = await client.create_session() - assert session.id - - # Verify status - status = pool.status() - assert status["active_processes"] == 1 - assert "ws-e2e-1" in status["workspaces"] - - -async def test_start_and_stop_releases_resources( - pool: WorkspaceProcessPool, - dir_manager: WorkspaceDirManager, - template_engine: AgentTemplateEngine, -): - """Start, stop, verify port is reusable.""" - finding = _make_finding("f-002", "TLS cert expired") - ws_dir = _create_workspace_dir(dir_manager, template_engine, "ws-e2e-2", finding) - - await pool.start("ws-e2e-2", ws_dir) - port_used = pool._processes["ws-e2e-2"].port - - await pool.stop("ws-e2e-2") - - # Port should be freed — start another workspace, should get same port - finding2 = _make_finding("f-003", "SQL injection") - ws_dir2 = _create_workspace_dir(dir_manager, template_engine, "ws-e2e-3", finding2) - await pool.start("ws-e2e-3", ws_dir2) - assert pool._processes["ws-e2e-3"].port == port_used - - -async def test_health_check_on_workspace_process( - pool: WorkspaceProcessPool, - dir_manager: WorkspaceDirManager, - template_engine: AgentTemplateEngine, -): - """Verify health check works on a workspace process.""" - finding = _make_finding("f-004", "Weak cipher suite") - ws_dir = _create_workspace_dir(dir_manager, template_engine, "ws-e2e-4", finding) - - client = await pool.start("ws-e2e-4", ws_dir) - assert await client.health_check() is True - - -async def test_process_crash_recovery( - pool: WorkspaceProcessPool, - dir_manager: WorkspaceDirManager, - template_engine: AgentTemplateEngine, -): - """Kill a process externally, verify get_or_start restarts it.""" - finding = _make_finding("f-005", "Open redirect") - ws_dir = _create_workspace_dir(dir_manager, template_engine, "ws-e2e-5", finding) - - await pool.start("ws-e2e-5", ws_dir) - # Kill the process externally - proc = pool._processes["ws-e2e-5"].process - assert proc is not None - proc.kill() - await proc.wait() - - # get_or_start should detect the dead process and restart - client = await pool.get_or_start("ws-e2e-5", ws_dir) - assert client is not None - assert await client.health_check() is True - - -# --------------------------------------------------------------------------- -# Multi-workspace -# --------------------------------------------------------------------------- - - -async def test_three_concurrent_workspaces( - pool: WorkspaceProcessPool, - dir_manager: WorkspaceDirManager, - template_engine: AgentTemplateEngine, -): - """Start 3 workspaces concurrently, verify all respond independently.""" - findings = [ - _make_finding("f-c1", "Log4j RCE"), - _make_finding("f-c2", "Expired TLS cert"), - _make_finding("f-c3", "SQL injection in login"), - ] - ws_dirs = [ - _create_workspace_dir(dir_manager, template_engine, f"ws-conc-{i}", f) - for i, f in enumerate(findings) - ] - - # Start all 3 concurrently - clients = await asyncio.gather( - *(pool.start(f"ws-conc-{i}", ws_dirs[i]) for i in range(3)) - ) - - assert len(clients) == 3 - - # All should be healthy - health_results = await asyncio.gather(*(c.health_check() for c in clients)) - assert all(health_results) - - # All should have different ports - ports = {pool._processes[f"ws-conc-{i}"].port for i in range(3)} - assert len(ports) == 3 - - # All should be able to create sessions - sessions = await asyncio.gather(*(c.create_session() for c in clients)) - session_ids = {s.id for s in sessions} - assert len(session_ids) == 3 # all unique - - -async def test_ten_workspaces_sequential( - pool: WorkspaceProcessPool, - dir_manager: WorkspaceDirManager, - template_engine: AgentTemplateEngine, -): - """Create 10 workspaces sequentially, verify all work, then stop all.""" - clients = [] - for i in range(10): - finding = _make_finding(f"f-seq-{i}", f"Finding #{i}") - ws_dir = _create_workspace_dir( - dir_manager, template_engine, f"ws-seq-{i}", finding - ) - client = await pool.start(f"ws-seq-{i}", ws_dir) - clients.append(client) - - # All 10 should be running - assert pool.status()["active_processes"] == 10 - - # All should respond to health checks - for client in clients: - assert await client.health_check() is True - - # Stop all - await pool.stop_all() - assert pool.status()["active_processes"] == 0 - assert pool._ports.available == pool._ports.total - - -async def test_four_concurrent_workspaces_have_isolated_npm_caches( - pool: WorkspaceProcessPool, - dir_manager: WorkspaceDirManager, - template_engine: AgentTemplateEngine, -): - """EF-B15 regression: 4 concurrent pool spawns each materialize a - distinct ``.npm-cache`` directory under their own workspace dir. - - Before the fix, all 4 workspaces shared ``~/.npm`` and concurrent - ``npm install`` invocations contended on the same lockfile, driving - load average to 17-20 and triggering the OpenCode retry storm. The - pool now sets ``NPM_CONFIG_CACHE`` to ``/.npm-cache`` - per spawn, eliminating the contention. - """ - findings = [_make_finding(f"f-npm-{i}", f"npm cache #{i}") for i in range(4)] - ws_dirs = [ - _create_workspace_dir(dir_manager, template_engine, f"ws-npm-{i}", f) - for i, f in enumerate(findings) - ] - - clients = await asyncio.gather( - *(pool.start(f"ws-npm-{i}", ws_dirs[i]) for i in range(4)) - ) - assert len(clients) == 4 - - # Each workspace must have its own cache dir on disk. - cache_dirs = [d / ".npm-cache" for d in ws_dirs] - for d in cache_dirs: - assert d.is_dir(), f"missing per-workspace npm cache: {d}" - - # The 4 cache paths must be distinct (no cross-talk). - assert len({str(p) for p in cache_dirs}) == 4 - - # And no cache dir lives inside another workspace's tree. - for i, d in enumerate(ws_dirs): - for j, c in enumerate(cache_dirs): - if i == j: - continue - assert d not in c.parents, f"workspace {j}'s cache leaked into ws {i}" - - -async def test_concurrent_get_or_start_same_workspace( - pool: WorkspaceProcessPool, - dir_manager: WorkspaceDirManager, - template_engine: AgentTemplateEngine, -): - """5 concurrent get_or_start for the same workspace — only 1 process starts.""" - finding = _make_finding("f-lock", "Race condition test") - ws_dir = _create_workspace_dir(dir_manager, template_engine, "ws-lock", finding) - - # Fire 5 concurrent requests - results = await asyncio.gather( - *(pool.get_or_start("ws-lock", ws_dir) for _ in range(5)) - ) - - # All should return the same client - assert all(r is results[0] for r in results) - - # Only 1 process in the pool - assert pool.status()["active_processes"] == 1 - - -# --------------------------------------------------------------------------- -# Port exhaustion -# --------------------------------------------------------------------------- - - -async def test_port_exhaustion_raises( - dir_manager: WorkspaceDirManager, - template_engine: AgentTemplateEngine, -): - """Exhaust the port range, verify clear error.""" - small_pool = WorkspaceProcessPool( - port_allocator=PortAllocator(start=4250, end=4252), - ) - try: - for i in range(3): - finding = _make_finding(f"f-exh-{i}", f"Exhaustion #{i}") - ws_dir = _create_workspace_dir( - dir_manager, template_engine, f"ws-exh-{i}", finding - ) - await small_pool.start(f"ws-exh-{i}", ws_dir) - - # 4th should fail - finding = _make_finding("f-exh-3", "One too many") - ws_dir = _create_workspace_dir( - dir_manager, template_engine, "ws-exh-3", finding - ) - with pytest.raises(RuntimeError, match="No free ports"): - await small_pool.start("ws-exh-3", ws_dir) - finally: - await small_pool.stop_all() - - -async def test_port_reuse_after_stop( - dir_manager: WorkspaceDirManager, - template_engine: AgentTemplateEngine, -): - """Exhaust ports, stop one, verify next start succeeds.""" - small_pool = WorkspaceProcessPool( - port_allocator=PortAllocator(start=4260, end=4262), - ) - try: - for i in range(3): - finding = _make_finding(f"f-reuse-{i}", f"Reuse #{i}") - ws_dir = _create_workspace_dir( - dir_manager, template_engine, f"ws-reuse-{i}", finding - ) - await small_pool.start(f"ws-reuse-{i}", ws_dir) - - # Stop one - await small_pool.stop("ws-reuse-1") - - # Now we can start another - finding = _make_finding("f-reuse-new", "After reuse") - ws_dir = _create_workspace_dir( - dir_manager, template_engine, "ws-reuse-new", finding - ) - client = await small_pool.start("ws-reuse-new", ws_dir) - assert await client.health_check() is True - finally: - await small_pool.stop_all() - - -# --------------------------------------------------------------------------- -# Failure modes -# --------------------------------------------------------------------------- - - -async def test_stop_idle_only_stops_old_processes( - pool: WorkspaceProcessPool, - dir_manager: WorkspaceDirManager, - template_engine: AgentTemplateEngine, -): - """Only idle processes are stopped.""" - for i in range(2): - finding = _make_finding(f"f-idle-{i}", f"Idle test #{i}") - ws_dir = _create_workspace_dir( - dir_manager, template_engine, f"ws-idle-{i}", finding - ) - await pool.start(f"ws-idle-{i}", ws_dir) - - # Make ws-idle-0 appear old - import time - - pool._processes["ws-idle-0"].last_activity = time.monotonic() - 999 - - stopped = await pool.stop_idle(timedelta(seconds=10)) - - assert "ws-idle-0" in stopped - assert "ws-idle-1" not in stopped - assert pool.status()["active_processes"] == 1 diff --git a/backend/tests/e2e/test_repo_workspace_agents.py b/backend/tests/e2e/test_repo_workspace_agents.py deleted file mode 100644 index 72215e74..00000000 --- a/backend/tests/e2e/test_repo_workspace_agents.py +++ /dev/null @@ -1,286 +0,0 @@ -"""E2E tests for repo-action agent templates (IMPL-0002 I3). - -Each test dogfoods a single-shot repo-action agent against the Cliff -repo itself (resolved from ``git config --get remote.origin.url``). The -flow exercised end-to-end is: - - create_repo_workspace → pool.start(env={GH_TOKEN}) - → send rendered prompt - → parse JSON output contract - → assert draft PR opened - → close PR + delete branch + stop_on_completion - -Prerequisites (auto-skipped by ``tests/e2e/conftest.py`` and the inline -skips in this file): - -- OpenCode binary installed -- ``OPENAI_API_KEY`` or ``ANTHROPIC_API_KEY`` set -- ``GH_TOKEN`` set with write access to the Cliff origin repo -- ``gh`` CLI on ``$PATH`` (for teardown) -- The current clone's ``origin`` points to an ``https://github.com/...`` URL - -The tests are network- and cost-sensitive and each should complete inside -10 minutes. Teardown MUST run even on failure — we do not leave draft PRs -or branches lying around on the Cliff repo. - -**Not xdist-safe.** Both tests push the fixed branch names -``cliff/posture/security-md`` and ``cliff/posture/dependabot``. If run -concurrently (e.g. under ``pytest-xdist``), two workers race on the same -push ref and one fails. Keep this suite single-threaded or make the branch -name unique per run before enabling ``-n auto``. -""" - -from __future__ import annotations - -import logging -import os -import re -import subprocess -from shutil import which -from typing import TYPE_CHECKING - -import pytest - -from cliff.agents.output_parser import extract_json_block -from cliff.agents.template_engine import AgentTemplateEngine -from cliff.engine.pool import PortAllocator, WorkspaceProcessPool -from cliff.workspace.workspace_dir_manager import WorkspaceDirManager, WorkspaceKind - -if TYPE_CHECKING: - from pathlib import Path - -logger = logging.getLogger(__name__) -pytestmark = pytest.mark.e2e - - -# --------------------------------------------------------------------------- -# Environment discovery -# --------------------------------------------------------------------------- - - -def _resolve_origin_url() -> str | None: - """Resolve the Cliff clone's origin URL, normalised to HTTPS. - - Returns None if the repo isn't a git checkout or origin isn't GitHub. - """ - try: - out = subprocess.check_output( - ["git", "config", "--get", "remote.origin.url"], - text=True, - stderr=subprocess.DEVNULL, - ).strip() - except (subprocess.CalledProcessError, FileNotFoundError): - return None - - if not out: - return None - - # Normalise git@github.com:org/repo.git → https://github.com/org/repo - m = re.match(r"git@github\.com:(?P[^/]+/.+?)(?:\.git)?$", out) - if m: - return f"https://github.com/{m.group('path')}" - - m = re.match(r"https?://github\.com/(?P[^/]+/.+?)(?:\.git)?$", out) - if m: - return f"https://github.com/{m.group('path')}" - - return None - - -_ORIGIN_URL = _resolve_origin_url() -_GH_TOKEN = os.environ.get("GH_TOKEN") or os.environ.get("GITHUB_TOKEN") -_GH_CLI = which("gh") - -_skip_no_origin = pytest.mark.skipif( - _ORIGIN_URL is None, - reason="Could not resolve an https github.com origin for this clone", -) -_skip_no_token = pytest.mark.skipif( - not _GH_TOKEN, - reason="GH_TOKEN / GITHUB_TOKEN is not set — refusing to run write-capable E2E", -) -_skip_no_gh_cli = pytest.mark.skipif( - _GH_CLI is None, - reason="`gh` CLI not on PATH — teardown cannot close the draft PR", -) - - -# --------------------------------------------------------------------------- -# Helpers -# --------------------------------------------------------------------------- - - -def _extract_structured_output(text: str) -> dict | None: - """Extract the repo-action agent's output contract, unwrapping structured_output.""" - payload = extract_json_block(text) - if payload is None: - return None - return payload.get("structured_output") or payload - - -def _close_pr_and_branch(pr_url: str | None, branch: str, repo: str) -> None: - """Best-effort teardown — close draft PR and delete its branch. - - Failures are logged (not raised) so the surrounding ``finally`` block can - still call ``stop_on_completion``. Silent swallowing would leave an - operator staring at a leftover branch with no diagnostic. - """ - if _GH_CLI is None or _GH_TOKEN is None: - return - env = {**os.environ, "GH_TOKEN": _GH_TOKEN} - if pr_url: - # `gh pr close --delete-branch` closes and removes the branch in one shot. - cmd = [ - _GH_CLI, "pr", "close", pr_url, "--delete-branch", "--comment", - "Automated Cliff E2E run — closing and deleting branch.", - ] - else: - # No PR (agent may have aborted) — best-effort delete of the branch. - cmd = [_GH_CLI, "api", "-X", "DELETE", - f"repos/{repo}/git/refs/heads/{branch}"] - - result = subprocess.run(cmd, env=env, check=False, capture_output=True, text=True) - if result.returncode != 0: - logger.warning( - "Teardown command %s failed (rc=%d): stdout=%s stderr=%s", - cmd[:3], result.returncode, result.stdout.strip(), result.stderr.strip(), - ) - - -def _repo_slug(url: str) -> str: - """`https://github.com/acme/widget` → `acme/widget`.""" - return url.removeprefix("https://github.com/").removesuffix(".git") - - -# --------------------------------------------------------------------------- -# Fixtures -# --------------------------------------------------------------------------- - - -@pytest.fixture -def dir_manager(tmp_path: Path) -> WorkspaceDirManager: - return WorkspaceDirManager(base_dir=tmp_path / "workspaces") - - -@pytest.fixture -def template_engine() -> AgentTemplateEngine: - return AgentTemplateEngine() - - -@pytest.fixture -async def pool(): - # Ports 4250-4259 — distinct from other E2E suites. - p = WorkspaceProcessPool(port_allocator=PortAllocator(start=4250, end=4259)) - yield p - await p.stop_all() - - -# --------------------------------------------------------------------------- -# Test bodies -# --------------------------------------------------------------------------- - - -async def _run_repo_action_e2e( - *, - kind: WorkspaceKind, - template_stem: str, - branch_name: str, - params: dict, - dir_manager: WorkspaceDirManager, - pool: WorkspaceProcessPool, -) -> None: - """Shared driver: kick off a repo-action agent and verify the PR.""" - assert _ORIGIN_URL is not None # guarded by module-level skip - assert _GH_TOKEN is not None - repo_url = _ORIGIN_URL - repo_slug = _repo_slug(repo_url) - - workspace_id = dir_manager.create_repo_workspace( - kind, - repo_url=repo_url, - params=params, - gh_token=_GH_TOKEN, - ) - ws_dir = dir_manager.base_dir / workspace_id - agent_prompt = (ws_dir / ".opencode" / "agents" / f"{template_stem}.md").read_text() - - client = await pool.start( - workspace_id, - ws_dir, - env_vars={"GH_TOKEN": _GH_TOKEN}, - ) - - structured: dict | None = None - pr_url: str | None = None - try: - session = await client.create_session() - response = await client.send_and_get_response( - session.id, - agent_prompt, - timeout=600.0, # 10 minutes for clone + push + PR - poll_interval=5.0, - ) - assert response, "Agent returned no response within timeout" - - structured = _extract_structured_output(response) - assert structured is not None, ( - f"Agent did not emit a parseable JSON output contract. " - f"Raw response: {response[:400]!r}" - ) - - status = structured.get("status") - pr_url = structured.get("pr_url") - - assert status in {"pr_created", "already_present"}, ( - f"Unexpected agent status: {status!r}. Full output: {structured!r}" - ) - - if status == "pr_created": - assert pr_url, "status=pr_created but pr_url is missing" - assert re.match( - r"https://github\.com/[^/]+/[^/]+/pull/\d+$", pr_url - ), f"pr_url does not look like a GitHub PR URL: {pr_url!r}" - assert structured.get("branch_name") == branch_name - - finally: - # Always tear down — we cannot leave PRs on the Cliff repo. - try: - _close_pr_and_branch(pr_url, branch_name, repo_slug) - finally: - archive = await pool.stop_on_completion(workspace_id) - if archive is not None: - archive.unlink(missing_ok=True) - - -@_skip_no_origin -@_skip_no_token -@_skip_no_gh_cli -async def test_security_md_generator_opens_draft_pr( - dir_manager: WorkspaceDirManager, pool: WorkspaceProcessPool -) -> None: - """Dogfood the SECURITY.md generator against the Cliff repo.""" - await _run_repo_action_e2e( - kind=WorkspaceKind.repo_action_security_md, - template_stem="security_md_generator", - branch_name="cliff/posture/security-md", - params={"contact_email": "security@cliff.example"}, - dir_manager=dir_manager, - pool=pool, - ) - - -@_skip_no_origin -@_skip_no_token -@_skip_no_gh_cli -async def test_dependabot_config_generator_opens_draft_pr( - dir_manager: WorkspaceDirManager, pool: WorkspaceProcessPool -) -> None: - """Dogfood the dependabot.yml generator against the Cliff repo.""" - await _run_repo_action_e2e( - kind=WorkspaceKind.repo_action_dependabot, - template_stem="dependabot_config_generator", - branch_name="cliff/posture/dependabot", - params={}, - dir_manager=dir_manager, - pool=pool, - ) diff --git a/backend/tests/e2e/test_settings_e2e.py b/backend/tests/e2e/test_settings_e2e.py deleted file mode 100644 index bcc1207f..00000000 --- a/backend/tests/e2e/test_settings_e2e.py +++ /dev/null @@ -1,92 +0,0 @@ -"""E2E tests for Settings endpoints against a real OpenCode server. - -Requires: - - OpenCode binary installed - - OPENAI_API_KEY (or another provider key) set in the environment - -Skipped automatically if OpenCode binary or API key is missing. -""" - -from __future__ import annotations - - -def test_get_providers(app_client): - """GET /api/settings/providers returns a non-empty provider list.""" - resp = app_client.get("/api/settings/providers") - assert resp.status_code == 200 - providers = resp.json() - assert isinstance(providers, list) - assert len(providers) > 0 - provider = providers[0] - assert "id" in provider - assert "name" in provider - - -def test_get_model(app_client): - """GET /api/settings/model returns the current model.""" - resp = app_client.get("/api/settings/model") - assert resp.status_code == 200 - data = resp.json() - assert "model_full_id" in data - assert "/" in data["model_full_id"] - - -def test_update_model_and_verify(app_client): - """PUT /api/settings/model changes the model at runtime.""" - # Get current model - resp = app_client.get("/api/settings/model") - original_model = resp.json()["model_full_id"] - - # Change to a different model (same provider to avoid auth issues) - new_model = "openai/gpt-4.1-mini" if "nano" in original_model else "openai/gpt-4.1-nano" - - resp = app_client.put( - "/api/settings/model", - json={"model_full_id": new_model}, - ) - assert resp.status_code == 200 - assert resp.json()["model_full_id"] == new_model - - # Verify via health endpoint - resp = app_client.get("/health") - assert resp.status_code == 200 - assert resp.json()["model"] == new_model - - # Restore original model - app_client.put( - "/api/settings/model", - json={"model_full_id": original_model}, - ) - - -def test_update_model_invalid_format(app_client): - """PUT /api/settings/model rejects models without provider prefix.""" - resp = app_client.put( - "/api/settings/model", - json={"model_full_id": "gpt-4"}, - ) - assert resp.status_code == 400 - - -def test_api_key_roundtrip(app_client): - """Set and retrieve an API key, verify it's masked.""" - # Set a test key (using a dummy provider to avoid conflicts) - resp = app_client.put( - "/api/settings/api-keys/test-provider", - json={"provider": "test-provider", "key": "sk-e2e-test-key-12345"}, - ) - assert resp.status_code == 200 - data = resp.json() - assert data["key_masked"] == "sk-...2345" - - # List keys and verify masking - resp = app_client.get("/api/settings/api-keys") - assert resp.status_code == 200 - keys = resp.json() - test_keys = [k for k in keys if k["provider"] == "test-provider"] - assert len(test_keys) == 1 - assert "sk-e2e-test-key-12345" not in str(test_keys) - - # Clean up - resp = app_client.delete("/api/settings/api-keys/test-provider") - assert resp.status_code == 204 diff --git a/backend/tests/integration/test_permission_flow.py b/backend/tests/integration/test_permission_flow.py index 85eeb78d..9b914a6a 100644 --- a/backend/tests/integration/test_permission_flow.py +++ b/backend/tests/integration/test_permission_flow.py @@ -129,7 +129,7 @@ async def test_approve_persists_marker_then_clears_and_resumes_agent( builder = AsyncMock() builder.update_context.return_value = "v1" - executor = AgentExecutor(pool, builder) + executor = AgentExecutor(builder) # Snapshot the row while the executor is parked. snapshot: dict = {} @@ -214,7 +214,7 @@ async def test_deny_persists_then_clears_and_denies_to_engine(db) -> None: builder = AsyncMock() builder.update_context.return_value = "v1" - executor = AgentExecutor(pool, builder) + executor = AgentExecutor(builder) async def deny_quickly(event_dict: dict) -> None: await asyncio.sleep(0.02) diff --git a/backend/tests/integration/test_rate_limit_backoff.py b/backend/tests/integration/test_rate_limit_backoff.py index 899aabbd..b4a403e8 100644 --- a/backend/tests/integration/test_rate_limit_backoff.py +++ b/backend/tests/integration/test_rate_limit_backoff.py @@ -81,7 +81,6 @@ def _make_executor() -> AgentExecutor: builder = AsyncMock() builder.update_context.return_value = 1 return AgentExecutor( - AsyncMock(), builder, ai_env_resolver=AsyncMock(return_value={"OPENAI_API_KEY": "x"}), ai_model_resolver=AsyncMock(return_value="openai/gpt-4o-mini"), diff --git a/backend/tests/integration/test_workspace_npm_cache_isolation.py b/backend/tests/integration/test_workspace_npm_cache_isolation.py deleted file mode 100644 index 4751ba0a..00000000 --- a/backend/tests/integration/test_workspace_npm_cache_isolation.py +++ /dev/null @@ -1,97 +0,0 @@ -"""Per-workspace npm cache isolation (EF-B15). - -Two workspaces spawned through ``WorkspaceProcessPool`` must each see a -``NPM_CONFIG_CACHE`` that points inside their own dir — not a shared -``~/.npm`` and not each other's. Without this isolation, concurrent -``npm install`` invocations under load amplify into a retry storm -(QA-0001 Q08). -""" - -from __future__ import annotations - -from typing import TYPE_CHECKING -from unittest.mock import AsyncMock, MagicMock, patch - -import pytest - -from cliff.engine.pool import PortAllocator, WorkspaceProcessPool - -if TYPE_CHECKING: - from pathlib import Path - - -def _mock_subprocess() -> AsyncMock: - proc = AsyncMock() - proc.returncode = None - proc.terminate = MagicMock() - proc.kill = MagicMock() - proc.wait = AsyncMock() - proc.stderr = None - proc.stdout = None - return proc - - -def _mock_httpx_healthy() -> AsyncMock: - mock_response = MagicMock() - mock_response.status_code = 200 - client = AsyncMock() - client.get = AsyncMock(return_value=mock_response) - client.__aenter__ = AsyncMock(return_value=client) - client.__aexit__ = AsyncMock(return_value=False) - return client - - -@pytest.fixture -def pool() -> WorkspaceProcessPool: - return WorkspaceProcessPool( - port_allocator=PortAllocator(start=5200, end=5209), - host="127.0.0.1", - ) - - -async def test_npm_cache_is_per_workspace_no_crosstalk( - pool: WorkspaceProcessPool, tmp_path: Path -): - """Two workspaces ⇒ two distinct NPM_CONFIG_CACHE paths, each - rooted inside that workspace's dir. Neither leaks into the other.""" - ws_a = tmp_path / "ws-a" - ws_a.mkdir() - ws_b = tmp_path / "ws-b" - ws_b.mkdir() - - captured_envs: list[dict[str, str]] = [] - - async def _capture_subprocess(*_args, **kwargs): - captured_envs.append(dict(kwargs.get("env") or {})) - return _mock_subprocess() - - with ( - patch( - "cliff.engine.pool.asyncio.create_subprocess_exec", - new=AsyncMock(side_effect=_capture_subprocess), - ), - patch( - "cliff.engine.pool.httpx.AsyncClient", - return_value=_mock_httpx_healthy(), - ), - ): - await pool.start("ws-a", ws_a) - await pool.start("ws-b", ws_b) - - assert len(captured_envs) == 2 - - cache_a = captured_envs[0]["NPM_CONFIG_CACHE"] - cache_b = captured_envs[1]["NPM_CONFIG_CACHE"] - - # Each subprocess sees its own cache, rooted inside its workspace dir. - assert cache_a == str(ws_a / ".npm-cache") - assert cache_b == str(ws_b / ".npm-cache") - assert cache_a != cache_b - - # And the cache dirs were materialized on disk. - assert (ws_a / ".npm-cache").is_dir() - assert (ws_b / ".npm-cache").is_dir() - - # Sanity: the cache for A is not under B's tree (no crosstalk). - assert ws_b not in (ws_a / ".npm-cache").parents - assert ws_a not in (ws_b / ".npm-cache").parents diff --git a/backend/tests/integration/test_workspace_repo_url_overrides_global.py b/backend/tests/integration/test_workspace_repo_url_overrides_global.py index de608542..688028f2 100644 --- a/backend/tests/integration/test_workspace_repo_url_overrides_global.py +++ b/backend/tests/integration/test_workspace_repo_url_overrides_global.py @@ -11,7 +11,6 @@ import pytest -from cliff.agents.template_engine import AgentTemplateEngine from cliff.db.connection import get_db from cliff.db.repo_integration import create_integration from cliff.db.repo_workspace import get_workspace @@ -25,16 +24,18 @@ @pytest.fixture async def real_builder(db_client, tmp_path): """Swap the conftest mock for a REAL WorkspaceContextBuilder rooted at - ``tmp_path`` so ``create_workspace`` actually persists ``repo_url`` and - writes agent templates we can grep. + ``tmp_path`` so ``create_workspace`` actually persists ``repo_url``. """ from cliff.main import app dir_manager = WorkspaceDirManager(base_dir=tmp_path) - template_engine = AgentTemplateEngine() - real = WorkspaceContextBuilder(dir_manager, template_engine, mcp_resolver=None) + real = WorkspaceContextBuilder(dir_manager, mcp_resolver=None) + previous = app.state.context_builder app.state.context_builder = real - yield real + try: + yield real + finally: + app.state.context_builder = previous async def _configure_github_integration(repo_url: str) -> None: @@ -67,8 +68,8 @@ async def _create_finding(db_client, source_id: str = "ef-b16-1") -> str: async def test_explicit_repo_url_overrides_integration_snapshot( db_client, real_builder, tmp_path ): - """AC1+AC3: explicit body.repo_url wins; rendered agent templates - reference the explicit target, not the integration default.""" + """AC1+AC3: explicit body.repo_url wins over the integration default and + is the value persisted on the workspace row.""" await _configure_github_integration("https://github.com/global/default") finding_id = await _create_finding(db_client) @@ -88,11 +89,6 @@ async def test_explicit_repo_url_overrides_integration_snapshot( assert ws is not None assert ws.repo_url == "https://github.com/explicit/target" - agents_dir = tmp_path / workspace_id / ".opencode" / "agents" - evidence_md = (agents_dir / "evidence_collector.md").read_text() - assert "explicit/target" in evidence_md - assert "global/default" not in evidence_md - async def test_omitted_repo_url_falls_back_to_integration(db_client, real_builder): """AC2: backwards-compat — omitting body.repo_url inherits the GitHub diff --git a/backend/tests/integrations/test_ingest_worker_plain_description.py b/backend/tests/integrations/test_ingest_worker_plain_description.py index fec27fd2..1e63c826 100644 --- a/backend/tests/integrations/test_ingest_worker_plain_description.py +++ b/backend/tests/integrations/test_ingest_worker_plain_description.py @@ -39,7 +39,12 @@ async def test_process_job_persists_plain_description(db): ) mocked = AsyncMock(return_value=([fc], [])) with patch("cliff.integrations.ingest_worker.normalize_findings", mocked): - await _process_job(db, job.job_id) + await _process_job( + db, + job.job_id, + env_resolver=AsyncMock(return_value={"OPENAI_API_KEY": "k"}), + model_resolver=AsyncMock(return_value="openai/gpt-4o-mini"), + ) findings = await list_findings(db) assert len(findings) == 1 diff --git a/backend/tests/test_agent_template_engine.py b/backend/tests/test_agent_template_engine.py deleted file mode 100644 index 90b57455..00000000 --- a/backend/tests/test_agent_template_engine.py +++ /dev/null @@ -1,675 +0,0 @@ -"""Tests for Layer 1: AgentTemplateEngine and agent templates.""" - -from __future__ import annotations - -from datetime import UTC, datetime -from typing import TYPE_CHECKING - -import pytest - -from cliff.agents import AGENT_NAMES, AgentTemplateEngine -from cliff.models import Finding - -if TYPE_CHECKING: - from pathlib import Path - - -# --------------------------------------------------------------------------- -# Fixtures -# --------------------------------------------------------------------------- - - -@pytest.fixture -def sample_finding_dict() -> dict: - """A fully-populated Finding as a dict (simulates model_dump(mode='json')).""" - now = datetime.now(UTC) - f = Finding( - id="finding-001", - source_type="snyk", - source_id="SNYK-JAVA-ORGAPACHELOGGINGLOG4J-2314720", - title="Remote Code Execution in log4j (CVE-2021-44228)", - description=( - "A critical RCE vulnerability in Apache Log4j 2.x allows " - "attackers to execute arbitrary code via crafted log messages " - "using JNDI lookup patterns." - ), - raw_severity="critical", - normalized_priority="P1", - asset_id="svc-api-gateway", - asset_label="api-gateway (prod)", - status="new", - likely_owner="platform-team", - why_this_matters=( - "Public exploit available. Internet-facing service " - "processing untrusted input." - ), - raw_payload={"cve": "CVE-2021-44228", "cvss": 10.0}, - created_at=now, - updated_at=now, - ) - return f.model_dump(mode="json") - - -@pytest.fixture -def minimal_finding_dict() -> dict: - """A Finding with only required fields as a dict.""" - now = datetime.now(UTC) - f = Finding( - id="finding-002", - source_type="manual", - source_id="manual-1", - title="Expired TLS certificate", - status="new", - created_at=now, - updated_at=now, - ) - return f.model_dump(mode="json") - - -@pytest.fixture -def sample_enrichment() -> dict: - return { - "normalized_title": "Apache Log4j Remote Code Execution (Log4Shell)", - "cve_ids": ["CVE-2021-44228", "CVE-2021-45046"], - "cvss_score": 10.0, - "cvss_vector": "CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:C/C:H/I:H/A:H", - "description": "Log4Shell allows remote code execution via JNDI lookup.", - "affected_versions": "< 2.17.1", - "fixed_version": "2.17.1", - "known_exploits": True, - "exploit_details": ( - "Public PoC and Metasploit module available. Active exploitation in the wild." - ), - "references": ["https://nvd.nist.gov/vuln/detail/CVE-2021-44228"], - } - - -@pytest.fixture -def sample_ownership() -> dict: - return { - "candidates": [ - { - "team": "Platform Engineering", - "person": "alice@example.com", - "confidence": 0.92, - "evidence": "CMDB shows platform-eng as support group for api-gateway", - "source": "CMDB", - } - ], - "recommended_owner": "Platform Engineering", - "reasoning": "CMDB support group matches and 3/5 recent commits are from this team.", - } - - -@pytest.fixture -def sample_exposure() -> dict: - return { - "environment": "production", - "internet_facing": True, - "reachable": "confirmed", - "reachability_evidence": "Import chain: main.py -> auth.py -> log4j", - "business_criticality": "critical", - "blast_radius": "User authentication flow serving 50K accounts", - "compensating_controls": None, - "recommended_urgency": "immediate", - } - - -@pytest.fixture -def sample_plan() -> dict: - return { - "plan_steps": [ - "Upgrade log4j-core from 2.14.1 to 2.17.1 in pom.xml", - "Run existing test suite to verify no regressions", - "Deploy to staging and run Tenable scan", - "Deploy to production after staging validation", - ], - "interim_mitigation": "Set LOG4J_FORMAT_MSG_NO_LOOKUPS=true in production env vars", - "dependencies": ["CI pipeline access", "Staging environment availability"], - "estimated_effort": "small", - "suggested_due_date": "2026-03-29", - "definition_of_done": [ - "log4j-core >= 2.17.1 in dependency tree", - "All tests pass", - "Tenable scan shows CVE-2021-44228 resolved", - "No new critical/high findings introduced", - ], - "validation_method": "Re-run Tenable scan on api-gateway asset", - } - - -@pytest.fixture -def sample_validation() -> dict: - return { - "verdict": "fixed", - "evidence": "Tenable re-scan shows log4j-core 2.17.1, CVE-2021-44228 no longer detected.", - "definition_of_done_results": [ - {"criterion": "log4j-core >= 2.17.1", "met": True, "evidence": "pom.xml shows 2.17.1"}, - ], - "remaining_concerns": [], - "recommendation": "close", - } - - -@pytest.fixture -def engine() -> AgentTemplateEngine: - return AgentTemplateEngine() - - -# --------------------------------------------------------------------------- -# render_all basics -# --------------------------------------------------------------------------- - - -def test_render_all_returns_seven_agents(engine: AgentTemplateEngine, sample_finding_dict: dict): - agents = engine.render_all(finding=sample_finding_dict) - assert len(agents) == 8 - names = [a.name for a in agents] - assert names == AGENT_NAMES - - -def test_render_all_filenames(engine: AgentTemplateEngine, sample_finding_dict: dict): - agents = engine.render_all(finding=sample_finding_dict) - for agent in agents: - assert agent.filename == f"{agent.name}.md" - - -def test_render_agent_invalid_name_raises(engine: AgentTemplateEngine, sample_finding_dict: dict): - with pytest.raises(ValueError, match="Unknown agent name"): - engine.render_agent("nonexistent", finding=sample_finding_dict) - - -# --------------------------------------------------------------------------- -# Orchestrator template -# --------------------------------------------------------------------------- - - -def test_orchestrator_contains_finding_data(engine: AgentTemplateEngine, sample_finding_dict: dict): - agent = engine.render_agent("orchestrator", finding=sample_finding_dict) - assert "Remote Code Execution in log4j" in agent.content - assert "snyk" in agent.content - assert "critical" in agent.content - assert "api-gateway" in agent.content - assert "platform-team" in agent.content - - -def test_orchestrator_minimal_finding_no_none( - engine: AgentTemplateEngine, minimal_finding_dict: dict -): - agent = engine.render_agent("orchestrator", finding=minimal_finding_dict) - assert "Expired TLS certificate" in agent.content - assert "None" not in agent.content - - -def test_orchestrator_yaml_frontmatter(engine: AgentTemplateEngine, sample_finding_dict: dict): - agent = engine.render_agent("orchestrator", finding=sample_finding_dict) - assert agent.content.startswith("---\n") - assert "mode: primary" in agent.content - - -def test_orchestrator_pipeline_state_initial( - engine: AgentTemplateEngine, sample_finding_dict: dict -): - """With only finding data, all pipeline items show unchecked.""" - agent = engine.render_agent("orchestrator", finding=sample_finding_dict) - assert agent.content.count("- [ ]") == 5 - assert "- [x]" not in agent.content - - -def test_orchestrator_pipeline_state_with_enrichment( - engine: AgentTemplateEngine, - sample_finding_dict: dict, - sample_enrichment: dict, -): - """With enrichment, enrichment shows checked, others unchecked.""" - agent = engine.render_agent( - "orchestrator", finding=sample_finding_dict, enrichment=sample_enrichment - ) - assert "- [x] **Enrichment**" in agent.content - assert agent.content.count("- [ ]") == 4 - - -def test_orchestrator_pipeline_state_all_complete( - engine: AgentTemplateEngine, - sample_finding_dict: dict, - sample_enrichment: dict, - sample_ownership: dict, - sample_exposure: dict, - sample_plan: dict, - sample_validation: dict, -): - """With all sections, all items show checked.""" - agent = engine.render_agent( - "orchestrator", - finding=sample_finding_dict, - enrichment=sample_enrichment, - ownership=sample_ownership, - exposure=sample_exposure, - plan=sample_plan, - validation=sample_validation, - ) - assert agent.content.count("- [x]") == 5 - assert "- [ ]" not in agent.content - # Verify enrichment data is in the body - assert "CVE-2021-44228" in agent.content - assert "Platform Engineering" in agent.content - assert "immediate" in agent.content - - -# --------------------------------------------------------------------------- -# Sub-agent templates -# --------------------------------------------------------------------------- - - -def test_subagent_yaml_frontmatter(engine: AgentTemplateEngine, sample_finding_dict: dict): - """All 6 sub-agents have mode: subagent in frontmatter.""" - agents = engine.render_all(finding=sample_finding_dict) - for agent in agents: - if agent.name == "orchestrator": - continue - assert "mode: subagent" in agent.content, f"{agent.name} missing mode: subagent" - - -def test_enricher_contains_finding_context( - engine: AgentTemplateEngine, sample_finding_dict: dict -): - agent = engine.render_agent("enricher", finding=sample_finding_dict) - assert "Remote Code Execution in log4j" in agent.content - assert "JNDI lookup" in agent.content - - -def test_enricher_output_contract(engine: AgentTemplateEngine, sample_finding_dict: dict): - agent = engine.render_agent("enricher", finding=sample_finding_dict) - assert "normalized_title" in agent.content - assert "cve_ids" in agent.content - assert "cvss_score" in agent.content - assert "known_exploits" in agent.content - assert "fixed_version" in agent.content - - -def test_planner_includes_prior_context( - engine: AgentTemplateEngine, - sample_finding_dict: dict, - sample_enrichment: dict, - sample_ownership: dict, - sample_exposure: dict, -): - """Planner template includes enrichment CVE, ownership team, exposure urgency.""" - agent = engine.render_agent( - "remediation_planner", - finding=sample_finding_dict, - enrichment=sample_enrichment, - ownership=sample_ownership, - exposure=sample_exposure, - ) - assert "CVE-2021-44228" in agent.content - assert "Platform Engineering" in agent.content - assert "immediate" in agent.content - - -def test_validation_includes_plan( - engine: AgentTemplateEngine, - sample_finding_dict: dict, - sample_enrichment: dict, - sample_plan: dict, -): - """Validation checker includes plan steps and definition of done.""" - agent = engine.render_agent( - "validation_checker", - finding=sample_finding_dict, - enrichment=sample_enrichment, - plan=sample_plan, - ) - assert "Upgrade log4j-core" in agent.content - assert "log4j-core >= 2.17.1" in agent.content - assert "definition of done" in agent.content.lower() - - -# --------------------------------------------------------------------------- -# write_agents -# --------------------------------------------------------------------------- - - -def test_write_agents_creates_files( - engine: AgentTemplateEngine, sample_finding_dict: dict, tmp_path: Path -): - agents_dir = tmp_path / "agents" - agents_dir.mkdir() - paths = engine.write_agents(agents_dir, finding=sample_finding_dict) - assert len(paths) == 8 - for path in paths: - assert path.exists() - assert path.suffix == ".md" - assert path.read_text().startswith("---\n") - - -def test_write_agents_overwrites_existing( - engine: AgentTemplateEngine, - sample_finding_dict: dict, - sample_enrichment: dict, - tmp_path: Path, -): - """Re-rendering with new context changes file content.""" - agents_dir = tmp_path / "agents" - agents_dir.mkdir() - - engine.write_agents(agents_dir, finding=sample_finding_dict) - initial = (agents_dir / "orchestrator.md").read_text() - - engine.write_agents(agents_dir, finding=sample_finding_dict, enrichment=sample_enrichment) - updated = (agents_dir / "orchestrator.md").read_text() - - assert initial != updated - assert "CVE-2021-44228" in updated - - -# --------------------------------------------------------------------------- -# Idempotency and custom templates -# --------------------------------------------------------------------------- - - -def test_re_render_idempotent(engine: AgentTemplateEngine, sample_finding_dict: dict): - """Same inputs produce identical output.""" - a = engine.render_all(finding=sample_finding_dict) - b = engine.render_all(finding=sample_finding_dict) - for agent_a, agent_b in zip(a, b, strict=True): - assert agent_a.content == agent_b.content - - -def test_custom_templates_dir(tmp_path: Path): - """Engine loads templates from a custom directory.""" - custom_dir = tmp_path / "custom_templates" - custom_dir.mkdir() - (custom_dir / "orchestrator.md.j2").write_text( - "---\nmode: primary\n---\nCustom: {{ finding.title }}\n" - ) - - # Only orchestrator template exists, so render just that one - engine = AgentTemplateEngine(templates_dir=custom_dir) - agent = engine.render_agent("orchestrator", finding={"title": "Test"}) - assert "Custom: Test" in agent.content - - -# --------------------------------------------------------------------------- -# Remediation executor template -# --------------------------------------------------------------------------- - - -def test_executor_contains_finding_context( - engine: AgentTemplateEngine, sample_finding_dict: dict -): - agent = engine.render_agent("remediation_executor", finding=sample_finding_dict) - assert "Remote Code Execution in log4j" in agent.content - assert "snyk" in agent.content - - -def test_executor_yaml_frontmatter(engine: AgentTemplateEngine, sample_finding_dict: dict): - agent = engine.render_agent("remediation_executor", finding=sample_finding_dict) - assert agent.content.startswith("---\n") - assert "mode: subagent" in agent.content - assert "Remediate:" in agent.content - - -def test_executor_includes_plan_steps( - engine: AgentTemplateEngine, - sample_finding_dict: dict, - sample_plan: dict, -): - """Executor template shows plan steps from the planner.""" - agent = engine.render_agent( - "remediation_executor", - finding=sample_finding_dict, - plan=sample_plan, - ) - assert "Upgrade log4j-core" in agent.content - assert "definition of done" in agent.content.lower() - assert "log4j-core >= 2.17.1" in agent.content - - -def test_executor_includes_enrichment_context( - engine: AgentTemplateEngine, - sample_finding_dict: dict, - sample_enrichment: dict, - sample_plan: dict, -): - """Executor template includes enrichment CVE data.""" - agent = engine.render_agent( - "remediation_executor", - finding=sample_finding_dict, - enrichment=sample_enrichment, - plan=sample_plan, - ) - assert "CVE-2021-44228" in agent.content - assert "2.17.1" in agent.content - - -def test_executor_includes_repo_instructions( - engine: AgentTemplateEngine, sample_finding_dict: dict -): - """Executor template includes git/gh workflow instructions.""" - agent = engine.render_agent("remediation_executor", finding=sample_finding_dict) - assert "git clone" in agent.content - assert "git checkout -b cliff/fix/" in agent.content - assert "gh pr create --draft" in agent.content - assert "git push" in agent.content - - -def test_executor_output_contract(engine: AgentTemplateEngine, sample_finding_dict: dict): - """Executor template includes the structured output contract.""" - agent = engine.render_agent("remediation_executor", finding=sample_finding_dict) - assert "pr_url" in agent.content - assert "branch_name" in agent.content - assert "changes_summary" in agent.content - assert "test_results" in agent.content - assert "status" in agent.content - - -# --------------------------------------------------------------------------- -# Posture-detail surface and hard rules (regression for the agent that opened -# PR #111 — it confabulated a fix because it never saw the structured detail). -# --------------------------------------------------------------------------- - - -@pytest.fixture -def posture_finding_dict() -> dict: - """A type='posture' finding with structured detail under raw_payload.""" - now = datetime.now(UTC) - f = Finding( - id="finding-posture-001", - source_type="cliff-posture", - source_id="https://github.com/cliff-security/cliff:trusted_action_sources", - title="trusted_action_sources", - type="posture", - status="new", - asset_label="https://github.com/cliff-security/cliff", - raw_payload={ - "check_name": "trusted_action_sources", - "scanner_status": "fail", - "detail": { - "untrusted_count": 2, - "untrusted": [ - { - "file": ".github/workflows/release.yml", - "action": "aquasecurity/trivy-action", - "owner": "aquasecurity", - }, - { - "file": ".github/workflows/release.yml", - "action": "sigstore/cosign-installer", - "owner": "sigstore", - }, - ], - }, - }, - created_at=now, - updated_at=now, - ) - return f.model_dump(mode="json") - - -def test_executor_surfaces_posture_detail( - engine: AgentTemplateEngine, posture_finding_dict: dict -): - """The executor must see the structured ``raw_payload.detail`` for posture - findings — without this section the agent has only the title to reason from - and confabulates fixes (PR #111 hallucinated a SHA, used a non-action repo, - and added a workflow without a permissions block — none of which addressed - the cited rows). - """ - agent = engine.render_agent( - "remediation_executor", finding=posture_finding_dict - ) - assert "Scanner detail (posture)" in agent.content - # Each cited row's identifying fields must reach the prompt verbatim so - # the executor can name them in the diff. - assert "aquasecurity/trivy-action" in agent.content - assert "sigstore/cosign-installer" in agent.content - assert ".github/workflows/release.yml" in agent.content - - -def test_executor_includes_hard_rules( - engine: AgentTemplateEngine, sample_finding_dict: dict -): - """The executor's hard-rules block must be present on every render — these - are the verify-SHA / verify-action / require-permissions / address-cited-rows - guardrails that PR #111's failure mode taught us to write down. - """ - agent = engine.render_agent( - "remediation_executor", finding=sample_finding_dict - ) - assert "Never invent a SHA" in agent.content - assert "Verify the action exists" in agent.content - assert "permissions:" in agent.content - assert "address the cited rows" in agent.content - assert "Never claim to have done what you didn't" in agent.content - # The exact verification command must appear so the agent has a concrete - # invocation to copy rather than infer. - assert 'gh api "repos///commits/"' in agent.content - - -def test_executor_constrains_dependency_bump_scope( - engine: AgentTemplateEngine, sample_finding_dict: dict -): - """Regression for the sweep-upgrade failure: a remediation asked to bump - ``braces`` to ^3.0.3 shipped a PR that also touched 13 other packages - in ``package.json`` (mongodb 2→7, cypress 3→15, mocha 2→11, …) plus - downgrades to ``csurf`` / ``jshint`` / ``grunt-*`` to thread the - resulting peer-dep needle. The executor must instead modify only the - packages named in ``plan_steps`` and stop or escape on peer-dep - conflicts rather than expanding scope. - """ - agent = engine.render_agent( - "remediation_executor", finding=sample_finding_dict - ) - - # The rule itself must render under the existing hard-rules block. - assert ( - "For dependency-bump fixes, modify ONLY the package(s) named" - in agent.content - ) - # Name the concrete escapes per ecosystem so the agent doesn't - # invent its own ("just upgrade everything"). - assert "npm install --legacy-peer-deps" in agent.content - assert "pnpm install --no-strict-peer-dependencies" in agent.content - assert "cargo update -p" in agent.content - assert "go get @" in agent.content - # The needs-approval escape hatch is the alternative to scope-creep. - assert 'status="needs_approval"' in agent.content - # And the rule-#6 reinforcement: ``changes_summary`` must match - # the actual manifest diff, naming every package whose constraint - # changed. - assert ( - "`changes_summary` MUST name every package whose version " - "constraint changed in the manifest" in agent.content - ) - - -def test_executor_safe_bump_block_includes_scope_constraint( - engine: AgentTemplateEngine, sample_finding_dict: dict -): - """The ``fix_safety == 'safe_bump'`` evidence path is the most common - way a dependency-bump remediation gets framed — it must include the - "touch only the package(s) named in the plan steps" line so the agent - sees the constraint at the point of decision (not just buried in the - hard-rules block at the bottom).""" - finding = {**sample_finding_dict} - evidence = { - "affected_files": [{"path": "package.json", "line": 1, "context": "braces dep"}], - "fix_safety": "safe_bump", - "current_version": "2.3.2", - } - agent = engine.render_agent( - "remediation_executor", finding=finding, evidence=evidence - ) - assert "Touch only the package(s) named in the plan steps" in agent.content - assert "Never sweep-upgrade or downgrade adjacent packages" in agent.content - - -def test_planner_surfaces_posture_detail( - engine: AgentTemplateEngine, posture_finding_dict: dict -): - """Same surface gap as the executor — the planner needs the cited rows in - its prompt or its plan defaults to "harden CI" rather than "edit these - nine specific lines". - """ - agent = engine.render_agent( - "remediation_planner", finding=posture_finding_dict - ) - assert "Scanner detail (posture)" in agent.content - assert "aquasecurity/trivy-action" in agent.content - assert "address the cited rows, not the policy" in agent.content - - -def test_planner_blocks_history_rewrite_for_secret_findings( - engine: AgentTemplateEngine, -): - """Leaked-secret findings (``type='secret'``) need explicit guardrails or - the planner defaults to "BFG-rewrite the entire history" — which doesn't - un-leak the secret (it's already cloned, cached, mirrored) but force-pushes - a multi-thousand-file diff over the default branch. The template must - instead tell the user to rotate the key AND remove it from the repo as - two separate halves of the remediation. - """ - secret_finding = { - "id": "finding-secret-001", - "source_type": "trivy-secret", - "source_id": "artifacts/cert/server.key:2:private-key", - "title": "Asymmetric Private Key", - "type": "secret", - "raw_severity": "HIGH", - "raw_payload": { - "rule_id": "private-key", - "category": "AsymmetricPrivateKey", - "path": "artifacts/cert/server.key", - "start_line": 2, - "end_line": 14, - }, - } - agent = engine.render_agent("remediation_planner", finding=secret_finding) - - # The dedicated section must render. - assert "Special case: leaked secret / credential" in agent.content - - # Hard "no history rewrite" line — name the tools the LLM would otherwise - # reach for so a regex-style scan won't miss any of them. - assert "Do NOT propose rewriting git history" in agent.content - assert "BFG" in agent.content - assert "git filter-repo" in agent.content - assert "git filter-branch" in agent.content - - # Both halves of the remediation must surface in plan_steps, not just DoD. - assert "Rotate the leaked" in agent.content - assert "Cliff cannot do this for you" in agent.content - assert "`git rm" in agent.content - assert ".gitignore" in agent.content - - -def test_planner_omits_secret_guidance_for_non_secret_findings( - engine: AgentTemplateEngine, sample_finding_dict: dict -): - """The secret-finding section is gated on ``finding.type == 'secret'``; - a dependency finding must not get the BFG warning (it'd be irrelevant - noise and could confuse the planner).""" - agent = engine.render_agent("remediation_planner", finding=sample_finding_dict) - assert "Special case: leaked secret / credential" not in agent.content - assert "BFG" not in agent.content diff --git a/backend/tests/test_ai_catalog.py b/backend/tests/test_ai_catalog.py index 53479245..186c1bdb 100644 --- a/backend/tests/test_ai_catalog.py +++ b/backend/tests/test_ai_catalog.py @@ -49,7 +49,7 @@ def test_every_provider_has_entry() -> None: assert info.default_model -def test_env_var_names_match_opencode_expectations() -> None: +def test_env_var_names_match_provider_factory_expectations() -> None: assert catalog.env_var_name("openrouter") == "OPENROUTER_API_KEY" assert catalog.env_var_name("anthropic") == "ANTHROPIC_API_KEY" assert catalog.env_var_name("openai") == "OPENAI_API_KEY" @@ -57,28 +57,11 @@ def test_env_var_names_match_opencode_expectations() -> None: assert catalog.env_var_name("ollama") is None -def test_provider_env_var_names_covers_keys_and_base_urls() -> None: - """Both the ``*_API_KEY`` and ``*_BASE_URL`` of every provider are - listed — callers scrub these from the host env before spawning - OpenCode so a polluted host (e.g. Claude Desktop's ANTHROPIC_BASE_URL) - can't leak in. (QA Q01 B07.)""" - names = catalog.provider_env_var_names() - assert "ANTHROPIC_API_KEY" in names - assert "ANTHROPIC_BASE_URL" in names - assert "OPENAI_API_KEY" in names - assert "OPENAI_BASE_URL" in names - assert "OPENROUTER_API_KEY" in names - assert "OPENROUTER_BASE_URL" in names - # Google + Ollama additions (ADR-0037). - assert "GEMINI_API_KEY" in names - assert "GEMINI_BASE_URL" in names - assert "OLLAMA_BASE_URL" in names - - def test_ollama_carries_default_base_url() -> None: """Ollama's ``base_url_env_var`` + ``default_base_url`` is the only place - an Ollama config exists by default — the env injector relies on this - to point OpenCode at localhost without a user config touch.""" + an Ollama config exists by default — the provider factory + (``runtime/provider.py``) relies on this to reach localhost without a + user config touch.""" assert catalog.base_url_env_var("ollama") == "OLLAMA_BASE_URL" assert catalog.default_base_url("ollama") == "http://localhost:11434" diff --git a/backend/tests/test_ai_phase_f_wiring.py b/backend/tests/test_ai_phase_f_wiring.py deleted file mode 100644 index ca7eb457..00000000 --- a/backend/tests/test_ai_phase_f_wiring.py +++ /dev/null @@ -1,332 +0,0 @@ -"""Phase F integration tests — env injection + opencode.json model + restart hook. - -These exercise the cross-vertical seams between ``AIIntegrationService``, -``WorkspaceProcessPool`` (env injection), ``WorkspaceDirManager`` (model -in rendered ``opencode.json``), and the singleton restart hook. No real -OpenCode subprocess — we mock at the subprocess boundary. -""" - -from __future__ import annotations - -import json -import os -import socket -from typing import TYPE_CHECKING -from unittest.mock import AsyncMock, patch - -import pytest - -from cliff.ai.service import AIIntegrationService -from cliff.db.connection import close_db, init_db -from cliff.engine.pool import WorkspaceProcessPool -from cliff.integrations.vault import CredentialVault -from cliff.workspace.workspace_dir_manager import WorkspaceDirManager - -if TYPE_CHECKING: - from pathlib import Path - - import aiosqlite - - -# --------------------------------------------------------------------------- -# F1: opencode.json renders model from active integration -# --------------------------------------------------------------------------- - - -@pytest.fixture -async def db(): - conn = await init_db(":memory:") - yield conn - await close_db() - - -@pytest.fixture -def vault(db: aiosqlite.Connection) -> CredentialVault: - return CredentialVault(db, key=os.urandom(32)) - - -def _make_finding(): - from datetime import UTC, datetime - - from cliff.models import Finding - - now = datetime.now(UTC).isoformat() - return Finding( - id="f-1", - source_type="test", - source_id="t1", - title="Test finding", - status="new", - created_at=now, - updated_at=now, - ) - - -async def test_dir_manager_writes_model_when_provided(tmp_path: Path) -> None: - mgr = WorkspaceDirManager(base_dir=tmp_path) - ws = mgr.create("ws-1", _make_finding(), model="claude-sonnet-4-6") - config = json.loads(ws.opencode_json.read_text()) - assert config["model"] == "claude-sonnet-4-6" - - -async def test_dir_manager_omits_model_when_none(tmp_path: Path) -> None: - mgr = WorkspaceDirManager(base_dir=tmp_path) - ws = mgr.create("ws-2", _make_finding()) - config = json.loads(ws.opencode_json.read_text()) - assert "model" not in config - - -async def test_opencode_json_never_contains_raw_key(tmp_path: Path) -> None: - """Guardrail: no matter what we pass, the rendered file holds no key.""" - mgr = WorkspaceDirManager(base_dir=tmp_path) - ws = mgr.create("ws-3", _make_finding(), model="claude-sonnet-4-6") - body = ws.opencode_json.read_text() - # No sk- keys, no api_key field. - assert "sk-" not in body - assert "api_key" not in body.lower() - assert "anthropic_api_key" not in body.lower() - - -# --------------------------------------------------------------------------- -# F2: pool env_resolver merges into the subprocess env -# --------------------------------------------------------------------------- - - -def _free_port() -> int: - with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s: - s.bind(("127.0.0.1", 0)) - return s.getsockname()[1] - - -def _fake_subprocess(captured_env: dict | None = None): - """An ``asyncio.create_subprocess_exec`` side-effect returning a mock proc. - - Pass ``captured_env`` to record the spawn environment into it. - """ - - async def _side_effect(*args, **kwargs): - if captured_env is not None: - captured_env.update(kwargs.get("env") or {}) - proc = AsyncMock() - proc.returncode = None - proc.terminate = lambda: None - proc.kill = lambda: None - proc.wait = AsyncMock(return_value=0) - proc.stderr = None - return proc - - return _side_effect - - -async def test_pool_calls_env_resolver_on_start(tmp_path: Path) -> None: - """The resolver is awaited and its result merged into the spawned env.""" - called: list = [] - - async def resolver() -> dict[str, str]: - called.append(True) - return {"ANTHROPIC_API_KEY": "sk-ant-from-resolver"} - - pool = WorkspaceProcessPool(env_resolver=resolver) - captured_env = {} - - workspace_dir = tmp_path / "ws" - workspace_dir.mkdir() - - with ( - patch( - "asyncio.create_subprocess_exec", - side_effect=_fake_subprocess(captured_env), - ), - patch.object(pool, "_wait_for_healthy", new=AsyncMock()), - ): - try: - await pool.start("ws-1", workspace_dir) - finally: - await pool.stop_all() - - assert called, "env_resolver was not awaited" - assert captured_env.get("ANTHROPIC_API_KEY") == "sk-ant-from-resolver" - - -async def test_pool_resolver_failure_does_not_block_spawn(tmp_path: Path) -> None: - """A resolver crash must not stop the spawn — log + skip its env.""" - - async def boom() -> dict[str, str]: - raise RuntimeError("vault unavailable") - - pool = WorkspaceProcessPool(env_resolver=boom) - captured_env = {} - - workspace_dir = tmp_path / "ws" - workspace_dir.mkdir() - - with ( - patch( - "asyncio.create_subprocess_exec", - side_effect=_fake_subprocess(captured_env), - ), - patch.object(pool, "_wait_for_healthy", new=AsyncMock()), - ): - try: - await pool.start("ws-1", workspace_dir) - finally: - await pool.stop_all() - - # Spawn succeeded despite the resolver crash. The workspace-isolation - # guard is always injected, so a non-None env with GIT_CEILING_DIRECTORIES - # pointing at the workspace dir proves the spawn went through. - # - # Note: we can't assert AI keys are *absent* from ``captured_env`` — the - # env is ``{**os.environ, **injected}``, and the host running the test - # may legitimately have ``OPENROUTER_API_KEY`` etc. set. The contract - # under test is "the resolver's crash didn't abort the spawn", which the - # presence of the guard env confirms. - assert captured_env.get("GIT_CEILING_DIRECTORIES") == str(workspace_dir) - - -async def test_pool_pushes_ai_auth_to_workspace_process(tmp_path: Path) -> None: - """Injected AI keys are also registered with the workspace's OpenCode. - - Env-var injection alone does not authenticate OpenCode 1.3.x outbound - calls — the per-workspace process must also receive the key through - ``PUT /auth/{id}``. ``_sync_opencode_auth`` only reaches the singleton, - so the pool covers the workspace processes itself. - """ - - async def resolver() -> dict[str, str]: - return {"ANTHROPIC_API_KEY": "sk-ant-from-resolver"} - - pool = WorkspaceProcessPool(env_resolver=resolver) - - workspace_dir = tmp_path / "ws" - workspace_dir.mkdir() - - set_auth_calls: list[tuple] = [] - - async def fake_set_auth(self, provider_id, auth): # noqa: ANN001 - set_auth_calls.append((provider_id, auth)) - return True - - with ( - patch("asyncio.create_subprocess_exec", side_effect=_fake_subprocess()), - patch.object(pool, "_wait_for_healthy", new=AsyncMock()), - patch( - "cliff.engine.client.OpenCodeClient.set_auth", - new=fake_set_auth, - ), - ): - try: - await pool.start("ws-1", workspace_dir) - finally: - await pool.stop_all() - - assert set_auth_calls == [ - ("anthropic", {"type": "api", "key": "sk-ant-from-resolver"}) - ] - - -async def test_pool_auth_push_failure_does_not_block_spawn(tmp_path: Path) -> None: - """A failing ``set_auth`` push is warning-logged, not fatal to the spawn.""" - - async def resolver() -> dict[str, str]: - return {"ANTHROPIC_API_KEY": "sk-ant-x"} - - pool = WorkspaceProcessPool(env_resolver=resolver) - - workspace_dir = tmp_path / "ws" - workspace_dir.mkdir() - - async def boom_set_auth(self, provider_id, auth): # noqa: ANN001 - raise RuntimeError("opencode auth endpoint down") - - with ( - patch("asyncio.create_subprocess_exec", side_effect=_fake_subprocess()), - patch.object(pool, "_wait_for_healthy", new=AsyncMock()), - patch( - "cliff.engine.client.OpenCodeClient.set_auth", - new=boom_set_auth, - ), - ): - try: - client = await pool.start("ws-1", workspace_dir) - finally: - await pool.stop_all() - - # Spawn returned a usable client despite the auth-push failure. - assert client is not None - - -async def test_pool_merges_caller_env_on_top_of_resolver(tmp_path: Path) -> None: - """Caller-supplied env_vars override resolver output (last-write wins).""" - - async def resolver() -> dict[str, str]: - return {"ANTHROPIC_API_KEY": "from-resolver"} - - pool = WorkspaceProcessPool(env_resolver=resolver) - captured_env = {} - - workspace_dir = tmp_path / "ws" - workspace_dir.mkdir() - - with ( - patch( - "asyncio.create_subprocess_exec", - side_effect=_fake_subprocess(captured_env), - ), - patch.object(pool, "_wait_for_healthy", new=AsyncMock()), - ): - try: - await pool.start( - "ws-1", - workspace_dir, - env_vars={"ANTHROPIC_API_KEY": "from-caller", "GH_TOKEN": "ghp_xyz"}, - ) - finally: - await pool.stop_all() - - assert captured_env["ANTHROPIC_API_KEY"] == "from-caller" - assert captured_env["GH_TOKEN"] == "ghp_xyz" - - -# --------------------------------------------------------------------------- -# F3: on_key_change hook fires with fresh env after every save/disconnect -# --------------------------------------------------------------------------- - - -async def test_on_key_change_fires_with_correct_env_after_save( - db: aiosqlite.Connection, vault: CredentialVault -) -> None: - captured: list[dict[str, str]] = [] - - async def on_change(env: dict[str, str]) -> None: - captured.append(env) - - service = AIIntegrationService(db, vault, on_key_change=on_change) - await service.save_byok("anthropic", "sk-ant-saved") - assert captured == [{"ANTHROPIC_API_KEY": "sk-ant-saved"}] - - -async def test_on_key_change_fires_empty_after_disconnect( - db: aiosqlite.Connection, vault: CredentialVault -) -> None: - captured: list[dict[str, str]] = [] - - async def on_change(env: dict[str, str]) -> None: - captured.append(env) - - service = AIIntegrationService(db, vault, on_key_change=on_change) - await service.save_byok("anthropic", "sk-ant-saved") - await service.disconnect() - assert captured[-1] == {} - - -async def test_on_key_change_failure_does_not_break_save( - db: aiosqlite.Connection, vault: CredentialVault -) -> None: - async def explode(_env: dict[str, str]) -> None: - raise RuntimeError("singleton restart failed") - - service = AIIntegrationService(db, vault, on_key_change=explode) - # Save still succeeds. - record = await service.save_byok("anthropic", "sk-ant-saved") - assert record.provider == "anthropic" diff --git a/backend/tests/test_ai_service.py b/backend/tests/test_ai_service.py index 556e83f1..5bc43f8d 100644 --- a/backend/tests/test_ai_service.py +++ b/backend/tests/test_ai_service.py @@ -25,32 +25,6 @@ def _reset_catalog_state(): catalog._reset_for_tests() -@pytest.fixture(autouse=True) -def _isolate_opencode_client(monkeypatch): - """Stub ``opencode_client.set_auth`` / ``get_config`` so tests can't - reach a running OpenCode singleton on the dev host. - - Without this, ``service.save_byok`` calls ``_sync_opencode_auth`` → - ``opencode_client.set_auth("openrouter", {"key": "sk-or-key"})``, - which on a dev box with a real ``:8001`` daemon up CLOBBERS the - user's OAuth-issued key in OpenCode's ``auth.json``. Re-tested by - running ``pytest tests/test_ai_service.py`` against a live daemon - and seeing the test placeholders show up in ``~/.local/share/ - opencode/auth.json``. - - Individual tests that need to assert on ``set_auth`` call shape can - override with their own ``monkeypatch.setattr``. - """ - from unittest.mock import AsyncMock - - from cliff.engine.client import opencode_client - - monkeypatch.setattr(opencode_client, "set_auth", AsyncMock(return_value=True)) - monkeypatch.setattr( - opencode_client, "get_config", AsyncMock(return_value={}) - ) - - @pytest.fixture async def db(): conn = await init_db(":memory:") @@ -430,79 +404,6 @@ async def test_disconnect_emits_audit_event( # on the wire. The tests for it are no longer applicable. -# --------------------------------------------------------------------------- -# OpenCode auth.json sync -# --------------------------------------------------------------------------- - - -async def test_save_byok_pushes_key_to_opencode_auth( - service: AIIntegrationService, monkeypatch -) -> None: - """OpenCode 1.3.x reads auth.json over env vars — verify we push.""" - from unittest.mock import AsyncMock - - from cliff.engine.client import opencode_client - - push = AsyncMock(return_value=True) - monkeypatch.setattr(opencode_client, "set_auth", push) - - await service.save_byok("anthropic", "sk-ant-push-target") - - push.assert_awaited_once_with( - "anthropic", {"type": "api", "key": "sk-ant-push-target"} - ) - - -async def test_save_byok_does_not_push_for_custom_provider( - service: AIIntegrationService, monkeypatch -) -> None: - from unittest.mock import AsyncMock - - from cliff.engine.client import opencode_client - - push = AsyncMock(return_value=True) - monkeypatch.setattr(opencode_client, "set_auth", push) - - await service.save_byok("custom", "sk-x", base_url="https://x.example/v1") - - push.assert_not_awaited() - - -async def test_disconnect_clears_opencode_auth( - service: AIIntegrationService, monkeypatch -) -> None: - from unittest.mock import AsyncMock - - from cliff.engine.client import opencode_client - - push = AsyncMock(return_value=True) - monkeypatch.setattr(opencode_client, "set_auth", push) - - await service.save_byok("openrouter", "sk-or-disc") - push.reset_mock() - await service.disconnect() - - # Called once with empty key after disconnect. - push.assert_awaited_once_with( - "openrouter", {"type": "api", "key": ""} - ) - - -async def test_save_byok_survives_opencode_unavailable( - service: AIIntegrationService, monkeypatch -) -> None: - """The new flow must still persist if OpenCode is unreachable.""" - from unittest.mock import AsyncMock - - from cliff.engine.client import opencode_client - - push = AsyncMock(side_effect=RuntimeError("opencode down")) - monkeypatch.setattr(opencode_client, "set_auth", push) - - record = await service.save_byok("anthropic", "sk-ant-key") - assert record.provider == "anthropic" - - # --------------------------------------------------------------------------- # ADR-0037 — canonical state, set_model, drift, Ollama, Google # --------------------------------------------------------------------------- @@ -644,8 +545,8 @@ async def test_set_model_updates_canonical( async def test_set_model_fires_on_key_change( db: aiosqlite.Connection, vault: CredentialVault ) -> None: - """``set_model`` triggers the singleton-restart hook so OpenCode picks - up the new opencode.json model without waiting for the next save.""" + """``set_model`` triggers the key-change hook so callers can refresh + any cached env snapshot without waiting for the next save.""" seen: list[dict[str, str]] = [] async def hook(env: dict[str, str]) -> None: @@ -692,32 +593,12 @@ async def test_resolve_env_for_google_uses_gemini_env_var( assert env == {"GEMINI_API_KEY": "AIzaSyTESTKEY"} -async def test_save_byok_for_ollama_skips_opencode_auth_push( - service: AIIntegrationService, monkeypatch -) -> None: - """Ollama doesn't authenticate — the auth.json push is a no-op.""" - seen: list[tuple[str, dict]] = [] - - class _StubClient: - async def set_auth(self, opencode_id: str, payload: dict) -> None: - seen.append((opencode_id, payload)) - - monkeypatch.setattr( - "cliff.engine.client.opencode_client", _StubClient() - ) - await service.save_byok("ollama", "local", base_url="http://localhost:11434") - # No push for ollama. - assert seen == [] - - async def test_get_status_returns_canonical_model_post_save( service: AIIntegrationService, ) -> None: - """Post-M9: ``get_status`` is the single read. It returns the - canonical model from ``app_setting(model)`` (resolved via - ``_resolve_canonical_model``) — no separate live probe of OpenCode, - no drift signal. ``on_key_change`` guarantees the singleton's - loaded model matches the canonical write before the next request. + """``get_status`` is the single read. It returns the canonical model + from ``app_setting(model)`` (resolved via ``_resolve_canonical_model``) + — no separate live probe, no drift signal (ADR-0047). """ await service.save_byok("anthropic", "sk-ant-key") status = await service.get_status() diff --git a/backend/tests/test_config.py b/backend/tests/test_config.py index 91f766c9..65616a32 100644 --- a/backend/tests/test_config.py +++ b/backend/tests/test_config.py @@ -2,8 +2,6 @@ from __future__ import annotations -from pathlib import Path - from cliff.config import Settings, _find_repo_root @@ -11,29 +9,6 @@ def test_default_settings(): s = Settings() assert s.app_host == "0.0.0.0" assert s.app_port == 8000 - assert s.opencode_host == "127.0.0.1" - assert s.opencode_port == 4096 - - -def test_opencode_url_property(): - s = Settings() - assert s.opencode_url == "http://127.0.0.1:4096" - - s2 = Settings(opencode_host="10.0.0.1", opencode_port=9999) - assert s2.opencode_url == "http://10.0.0.1:9999" - - -def test_opencode_version_reads_file(): - s = Settings() - # The repo has .opencode-version with "1.3.2" - version = s.opencode_version - assert version # not empty - assert "." in version # looks like a semver - - -def test_opencode_binary_path_with_explicit_bin(): - s = Settings(opencode_bin="/usr/local/bin/opencode") - assert s.opencode_binary_path == Path("/usr/local/bin/opencode") def test_resolve_data_dir_creates(tmp_path): @@ -45,7 +20,7 @@ def test_resolve_data_dir_creates(tmp_path): def test_find_repo_root(): root = _find_repo_root() - assert (root / ".opencode-version").exists() + assert (root / "VERSION").exists() def test_demo_field_defaults_to_false(): diff --git a/backend/tests/test_config_manager.py b/backend/tests/test_config_manager.py deleted file mode 100644 index 8fae3bb6..00000000 --- a/backend/tests/test_config_manager.py +++ /dev/null @@ -1,176 +0,0 @@ -"""Tests for the ConfigManager.""" - -from __future__ import annotations - -import json -from unittest.mock import AsyncMock, patch - -import pytest - -from cliff.engine.config_manager import ConfigManager, mask_key - - -class TestMaskKey: - def test_short_key(self): - assert mask_key("abc") == "****" - - def test_normal_key(self): - assert mask_key("sk-abc123def456") == "sk-...f456" - - def test_exact_boundary(self): - assert mask_key("12345678") == "****" - - def test_just_over_boundary(self): - assert mask_key("123456789") == "123...6789" - - -class TestConfigManagerGetModel: - @pytest.mark.asyncio - async def test_get_model_from_opencode(self): - mgr = ConfigManager() - with patch( - "cliff.engine.config_manager.opencode_client" - ) as mock_client: - mock_client.get_config = AsyncMock( - return_value={"model": "openai/gpt-4.1-nano"} - ) - result = await mgr.get_model() - assert result["model_full_id"] == "openai/gpt-4.1-nano" - assert result["provider"] == "openai" - assert result["model_id"] == "gpt-4.1-nano" - - @pytest.mark.asyncio - async def test_get_model_fallback_on_error(self): - mgr = ConfigManager() - with ( - patch( - "cliff.engine.config_manager.opencode_client" - ) as mock_client, - patch( - "cliff.engine.config_manager.settings" - ) as mock_settings, - ): - mock_client.get_config = AsyncMock(side_effect=Exception("down")) - mock_settings.opencode_model = "anthropic/claude-sonnet-4-20250514" - result = await mgr.get_model() - assert result["model_full_id"] == "anthropic/claude-sonnet-4-20250514" - - -class TestConfigManagerUpdateModel: - @pytest.mark.asyncio - async def test_update_model_success(self, db_client, tmp_path): - mgr = ConfigManager() - opencode_json = tmp_path / "opencode.json" - opencode_json.write_text(json.dumps({"model": "old/model", "permission": {}})) - - with ( - patch( - "cliff.engine.config_manager.opencode_client" - ) as mock_client, - patch( - "cliff.engine.config_manager.settings" - ) as mock_settings, - ): - mock_client.update_config = AsyncMock(return_value={}) - mock_client.get_config = AsyncMock( - return_value={"model": "openai/gpt-4.1-nano"} - ) - mock_settings.repo_root = tmp_path - mock_settings.opencode_model = "openai/gpt-4.1-nano" - mock_settings.write_opencode_config = lambda m: opencode_json.write_text( - json.dumps({"model": m, "permission": {}}) - ) - - from cliff.db.connection import _db as db - - result = await mgr.update_model(db, "openai/gpt-4.1-nano") - - mock_client.update_config.assert_called_once_with( - {"model": "openai/gpt-4.1-nano"} - ) - assert result["model_full_id"] == "openai/gpt-4.1-nano" - - @pytest.mark.asyncio - async def test_update_model_invalid_format(self, db_client): - mgr = ConfigManager() - from cliff.db.connection import _db as db - - with pytest.raises(ValueError, match="provider/model-id"): - await mgr.update_model(db, "just-a-model-name") - - -class TestConfigManagerApiKeys: - @pytest.mark.asyncio - async def test_set_api_key(self, db_client): - mgr = ConfigManager() - with patch( - "cliff.engine.config_manager.opencode_client" - ) as mock_client: - mock_client.set_auth = AsyncMock(return_value=True) - - from cliff.db.connection import _db as db - - result = await mgr.set_api_key(db, "openai", "sk-test123456abcdef") - - mock_client.set_auth.assert_called_once_with( - "openai", {"type": "api", "key": "sk-test123456abcdef"} - ) - assert result["provider"] == "openai" - assert result["key_masked"] == "sk-...cdef" - assert result["has_credentials"] is True - - @pytest.mark.asyncio - async def test_get_api_keys_masked(self, db_client): - mgr = ConfigManager() - with patch( - "cliff.engine.config_manager.opencode_client" - ) as mock_client: - mock_client.set_auth = AsyncMock(return_value=True) - mock_client.get_provider_auth = AsyncMock(return_value={}) - - from cliff.db.connection import _db as db - - await mgr.set_api_key(db, "openai", "sk-test123456abcdef") - keys = await mgr.get_api_keys(db) - - assert len(keys) == 1 - assert keys[0]["provider"] == "openai" - assert keys[0]["key_masked"] == "sk-...cdef" - # Key should NOT be exposed - assert "sk-test123456abcdef" not in str(keys) - - @pytest.mark.asyncio - async def test_delete_api_key(self, db_client): - mgr = ConfigManager() - with patch( - "cliff.engine.config_manager.opencode_client" - ) as mock_client: - mock_client.set_auth = AsyncMock(return_value=True) - mock_client.get_provider_auth = AsyncMock(return_value={}) - - from cliff.db.connection import _db as db - - await mgr.set_api_key(db, "openai", "sk-test123") - assert await mgr.delete_api_key(db, "openai") is True - keys = await mgr.get_api_keys(db) - assert len(keys) == 0 - - @pytest.mark.asyncio - async def test_restore_keys_to_engine(self, db_client): - mgr = ConfigManager() - with patch( - "cliff.engine.config_manager.opencode_client" - ) as mock_client: - mock_client.set_auth = AsyncMock(return_value=True) - mock_client.get_provider_auth = AsyncMock(return_value={}) - - from cliff.db.connection import _db as db - - await mgr.set_api_key(db, "openai", "sk-restore-test1") - await mgr.set_api_key(db, "anthropic", "sk-ant-restore2") - - # Reset mock to track restore calls - mock_client.set_auth.reset_mock() - await mgr.restore_keys_to_engine(db) - - assert mock_client.set_auth.call_count == 2 diff --git a/backend/tests/test_context_builder.py b/backend/tests/test_context_builder.py index 2a1a5962..f947d897 100644 --- a/backend/tests/test_context_builder.py +++ b/backend/tests/test_context_builder.py @@ -8,7 +8,6 @@ import aiosqlite import pytest -from cliff.agents import AgentTemplateEngine from cliff.db.migrations import run_migrations from cliff.db.repo_finding import create_finding from cliff.db.repo_workspace import get_workspace @@ -68,17 +67,8 @@ def dir_manager(tmp_path: Path) -> WorkspaceDirManager: @pytest.fixture -def template_engine() -> AgentTemplateEngine: - return AgentTemplateEngine() - - -@pytest.fixture -def builder( - dir_manager: WorkspaceDirManager, template_engine: AgentTemplateEngine -) -> WorkspaceContextBuilder: - return WorkspaceContextBuilder( - dir_manager=dir_manager, template_engine=template_engine - ) +def builder(dir_manager: WorkspaceDirManager) -> WorkspaceContextBuilder: + return WorkspaceContextBuilder(dir_manager=dir_manager) # --------------------------------------------------------------------------- @@ -92,7 +82,7 @@ async def test_create_workspace_creates_dir_and_db( sample_finding: Finding, dir_manager: WorkspaceDirManager, ): - """create_workspace creates DB row + directory + agents.""" + """create_workspace creates DB row + directory + finding context.""" workspace = await builder.create_workspace(db, sample_finding) # DB row exists with workspace_dir set @@ -101,33 +91,13 @@ async def test_create_workspace_creates_dir_and_db( assert workspace.workspace_dir is not None assert workspace.context_version == 0 - # Directory exists on disk + # Directory exists on disk with the finding context the PA agents read. ws_dir = dir_manager.get(workspace.id) assert ws_dir is not None assert ws_dir.exists() assert ws_dir.finding_json.is_file() assert ws_dir.context_md.is_file() - # 8 agent files rendered (includes evidence_collector) - agent_files = list(ws_dir.agents_dir.glob("*.md")) - assert len(agent_files) == 8 - - -async def test_create_workspace_agents_contain_finding( - builder: WorkspaceContextBuilder, - db: aiosqlite.Connection, - sample_finding: Finding, - dir_manager: WorkspaceDirManager, -): - """Rendered agents contain the finding title.""" - workspace = await builder.create_workspace(db, sample_finding) - ws_dir = dir_manager.get(workspace.id) - assert ws_dir is not None - - orchestrator = (ws_dir.agents_dir / "orchestrator.md").read_text() - assert "Remote Code Execution in log4j" in orchestrator - assert "mode: primary" in orchestrator - # --------------------------------------------------------------------------- # update_context @@ -159,34 +129,6 @@ async def test_update_context_writes_section( assert "What we know so far" in context_md -async def test_update_context_re_renders_agents( - builder: WorkspaceContextBuilder, - db: aiosqlite.Connection, - sample_finding: Finding, - dir_manager: WorkspaceDirManager, -): - """After context update, agents are re-rendered with new data.""" - workspace = await builder.create_workspace(db, sample_finding) - - orchestrator_before = ( - dir_manager.get(workspace.id).agents_dir / "orchestrator.md" # type: ignore[union-attr] - ).read_text() - assert "- [x] **Enrichment**" not in orchestrator_before - - await builder.update_context( - db, - workspace.id, - "finding_enricher", - {"summary": "Log4Shell confirmed", "cve_ids": ["CVE-2021-44228"]}, - ) - - orchestrator_after = ( - dir_manager.get(workspace.id).agents_dir / "orchestrator.md" # type: ignore[union-attr] - ).read_text() - assert "- [x] **Enrichment**" in orchestrator_after - assert "CVE-2021-44228" in orchestrator_after - - async def test_update_context_increments_version( builder: WorkspaceContextBuilder, db: aiosqlite.Connection, diff --git a/backend/tests/test_docker.py b/backend/tests/test_docker.py index 23e2191c..c98c8bfd 100644 --- a/backend/tests/test_docker.py +++ b/backend/tests/test_docker.py @@ -25,8 +25,6 @@ def test_docker_env_defaults(): s = Settings() assert s.app_host == "0.0.0.0" assert s.app_port == 8000 - assert s.opencode_host == "127.0.0.1" - assert s.opencode_port == 4096 def test_spa_fallback_not_mounted_without_static_dir(client): @@ -47,7 +45,7 @@ def test_health_still_works_without_static_dir(client): class TestSpaFallback: """Test SPA fallback when static_dir is configured with real files.""" - def test_serves_index_html(self, tmp_path, mock_opencode_process, mock_opencode_client): + def test_serves_index_html(self, tmp_path): """SPA fallback serves index.html for unknown paths.""" # Set up a fake static directory static_dir = tmp_path / "dist" @@ -86,7 +84,7 @@ def _repo_root(self) -> Path: """Find the repo root.""" current = Path(__file__).resolve().parent for _ in range(10): - if (current / ".opencode-version").exists(): + if (current / "VERSION").exists(): return current current = current.parent return current @@ -169,7 +167,7 @@ class TestReleaseHardening: def _repo_root(self) -> Path: current = Path(__file__).resolve().parent for _ in range(10): - if (current / ".opencode-version").exists(): + if (current / "VERSION").exists(): return current current = current.parent return current diff --git a/backend/tests/test_engine_client.py b/backend/tests/test_engine_client.py deleted file mode 100644 index 0c7db740..00000000 --- a/backend/tests/test_engine_client.py +++ /dev/null @@ -1,125 +0,0 @@ -"""Tests for the OpenCode HTTP client.""" - -from __future__ import annotations - -import pytest - -from cliff.engine.client import OpenCodeClient - - -@pytest.fixture -def oc_client(): - return OpenCodeClient(base_url="http://mock:4096") - - -@pytest.mark.asyncio -async def test_create_session(oc_client, httpx_mock): - httpx_mock.add_response( - url="http://mock:4096/session", - method="POST", - json={"id": "ses_test123"}, - ) - session = await oc_client.create_session() - assert session.id == "ses_test123" - - -@pytest.mark.asyncio -async def test_list_sessions(oc_client, httpx_mock): - httpx_mock.add_response( - url="http://mock:4096/session", - method="GET", - json=[ - {"id": "ses_1"}, - {"id": "ses_2"}, - ], - ) - sessions = await oc_client.list_sessions() - assert len(sessions) == 2 - assert sessions[0].id == "ses_1" - assert sessions[1].id == "ses_2" - - -@pytest.mark.asyncio -async def test_get_session_with_messages(oc_client, httpx_mock): - httpx_mock.add_response( - url="http://mock:4096/session/ses_test123", - method="GET", - json={"id": "ses_test123"}, - ) - httpx_mock.add_response( - url="http://mock:4096/session/ses_test123/message", - method="GET", - json=[ - { - "info": {"id": "msg_1", "role": "user", "sessionID": "ses_test123"}, - "parts": [{"type": "text", "text": "hello"}], - }, - { - "info": {"id": "msg_2", "role": "assistant", "sessionID": "ses_test123"}, - "parts": [{"type": "text", "text": "hi there"}], - }, - ], - ) - detail = await oc_client.get_session("ses_test123") - assert detail.id == "ses_test123" - assert len(detail.messages) == 2 - assert detail.messages[0].content == "hello" - assert detail.messages[1].role == "assistant" - - -@pytest.mark.asyncio -async def test_send_message(oc_client, httpx_mock): - httpx_mock.add_response( - url="http://mock:4096/session/ses_test123/message", - method="POST", - content=b"", # OpenCode returns 200 with empty body (async) - ) - await oc_client.send_message("ses_test123", "What is CVE-2024-1234?") - # Verify the correct body format was sent - request = httpx_mock.get_request() - import json - - body = json.loads(request.content) - assert body == {"parts": [{"type": "text", "text": "What is CVE-2024-1234?"}]} - - -@pytest.mark.asyncio -async def test_health_check_ok(oc_client, httpx_mock): - httpx_mock.add_response( - url="http://mock:4096/session", - method="GET", - json=[], - ) - assert await oc_client.health_check() is True - - -@pytest.mark.asyncio -async def test_health_check_down(oc_client, httpx_mock): - import httpx - - httpx_mock.add_exception(httpx.ConnectError("Connection refused")) - assert await oc_client.health_check() is False - - -def test_parse_sse(): - client = OpenCodeClient() - - # Standard event - result = client._parse_sse("event: message\ndata: hello world") - assert result == {"event": "message", "data": "hello world"} - - # Event with no explicit type - result = client._parse_sse("data: just data") - assert result == {"event": "message", "data": "just data"} - - # Multi-line data - result = client._parse_sse("data: line1\ndata: line2") - assert result == {"event": "message", "data": "line1\nline2"} - - # Comment-only (should return None) - result = client._parse_sse(": this is a comment") - assert result is None - - # Empty - result = client._parse_sse("") - assert result is None diff --git a/backend/tests/test_engine_process.py b/backend/tests/test_engine_process.py deleted file mode 100644 index 7145bb5e..00000000 --- a/backend/tests/test_engine_process.py +++ /dev/null @@ -1,56 +0,0 @@ -"""Tests for the OpenCode process manager.""" - -from __future__ import annotations - -from pathlib import Path -from unittest.mock import AsyncMock, patch - -from cliff.engine.process import OpenCodeProcess - - -def test_is_running_false_initially(): - proc = OpenCodeProcess() - assert proc.is_running is False - - -def test_is_healthy_false_initially(): - proc = OpenCodeProcess() - assert proc.is_healthy is False - - -async def test_start_scrubs_host_ai_provider_env_vars(): - """The singleton OpenCode must not inherit a polluted host AI-provider - environment (e.g. Claude Desktop's ANTHROPIC_BASE_URL without /v1). - The extra-env values are layered back on top. (QA Q01 B07.)""" - proc = OpenCodeProcess() - proc.set_extra_env({"ANTHROPIC_API_KEY": "sk-ant-real"}) - - mock_subproc = AsyncMock() - mock_subproc.returncode = None - - with ( - patch.object( - OpenCodeProcess, - "_ensure_binary", - new=AsyncMock(return_value=Path("/fake/opencode")), - ), - patch.object( - OpenCodeProcess, "_wait_for_healthy", new=AsyncMock() - ), - patch( - "cliff.engine.process.asyncio.create_subprocess_exec", - new=AsyncMock(return_value=mock_subproc), - ) as mock_exec, - patch("cliff.engine.process.os") as mock_os, - ): - mock_os.environ = { - "PATH": "/usr/bin", - "ANTHROPIC_BASE_URL": "https://api.anthropic.com", - "ANTHROPIC_API_KEY": "", - } - await proc.start() - - passed_env = mock_exec.call_args.kwargs.get("env") - assert "ANTHROPIC_BASE_URL" not in passed_env - assert passed_env["ANTHROPIC_API_KEY"] == "sk-ant-real" - assert passed_env["PATH"] == "/usr/bin" diff --git a/backend/tests/test_executor.py b/backend/tests/test_executor.py index 79b0560f..7fbaa7bc 100644 --- a/backend/tests/test_executor.py +++ b/backend/tests/test_executor.py @@ -13,7 +13,6 @@ from cliff.agents.executor import ( TOOL_TIERS, AgentExecutor, - _classify_tool_request, _load_workspace_data, ) from cliff.agents.output_parser import ParseResult @@ -107,7 +106,7 @@ def _make_mock_client(response_text): # --------------------------------------------------------------------------- -def _executor_with_pa(mock_pool, mock_context_builder, outcome_factory): +def _executor_with_pa(mock_context_builder, outcome_factory): """Build an executor whose ``_run_pa_executor`` returns the given outcome. ``outcome_factory`` is a zero-arg callable returning a @@ -116,7 +115,6 @@ def _executor_with_pa(mock_pool, mock_context_builder, outcome_factory): from cliff.agents.executor import AgentExecutor ex = AgentExecutor( - mock_pool, mock_context_builder, ai_env_resolver=AsyncMock(return_value={"OPENAI_API_KEY": "x"}), ai_model_resolver=AsyncMock(return_value="openai/gpt-4o-mini"), @@ -187,7 +185,7 @@ async def test_happy_path(self, mock_pool, mock_context_builder, mock_db, workspace_dir): """Full successful execution: PA executor -> finalize -> persist.""" executor = _executor_with_pa( - mock_pool, mock_context_builder, _pa_success_outcome + mock_context_builder, _pa_success_outcome ) with ( @@ -222,7 +220,7 @@ async def test_happy_path(self, mock_pool, mock_context_builder, ) @pytest.mark.asyncio async def test_execute_publishes_started_and_completed_events( - self, mock_pool, mock_context_builder, mock_db, workspace_dir + self, mock_context_builder, mock_db, workspace_dir ): """B36 / IMPL-0020 — every execute() must push an ``agent_run_started`` event onto the workspace queue as soon as @@ -236,7 +234,7 @@ async def test_execute_publishes_started_and_completed_events( rather than draining the queue post-hoc. """ executor = _executor_with_pa( - mock_pool, mock_context_builder, _pa_success_outcome + mock_context_builder, _pa_success_outcome ) captured: list[dict] = [] original = executor.push_permission_event @@ -289,7 +287,7 @@ def _capture(workspace_id: str, event: dict) -> None: ) @pytest.mark.asyncio async def test_execute_publishes_completed_with_failed_status_on_parse_failure( - self, mock_pool, mock_context_builder, mock_db, workspace_dir + self, mock_context_builder, mock_db, workspace_dir ): """Failure path still publishes ``agent_run_completed`` so the side panel can stop spinning. The status field reflects the run @@ -297,7 +295,7 @@ async def test_execute_publishes_completed_with_failed_status_on_parse_failure( response_text = "no JSON here" mock_pool.get_or_start.return_value = _make_mock_client(response_text) - executor = AgentExecutor(mock_pool, mock_context_builder) + executor = AgentExecutor(mock_context_builder) captured: list[dict] = [] original = executor.push_permission_event @@ -331,7 +329,7 @@ def _capture(workspace_id: str, event: dict) -> None: ) @pytest.mark.asyncio async def test_execute_preserves_preexisting_permission_queue( - self, mock_pool, mock_context_builder, mock_db, workspace_dir + self, mock_context_builder, mock_db, workspace_dir ): """B36 / IMPL-0020 — if the SSE consumer already auto-vivified a queue (panel opened BEFORE Start was clicked), ``execute`` must @@ -342,7 +340,7 @@ async def test_execute_preserves_preexisting_permission_queue( response_text = _make_agent_response() mock_pool.get_or_start.return_value = _make_mock_client(response_text) - executor = AgentExecutor(mock_pool, mock_context_builder) + executor = AgentExecutor(mock_context_builder) # Simulate the side panel having opened the SSE stream first. preexisting = executor.ensure_permission_queue("ws-1") @@ -383,7 +381,7 @@ async def test_parse_failure_marks_failed(self, mock_pool, mock_context_builder, response_text = "I analyzed the vulnerability but forgot to return JSON." mock_pool.get_or_start.return_value = _make_mock_client(response_text) - executor = AgentExecutor(mock_pool, mock_context_builder) + executor = AgentExecutor(mock_context_builder) with ( patch( @@ -416,7 +414,7 @@ async def test_busy_workspace_raises(self, mock_pool, mock_context_builder, mock_db, workspace_dir): """Another agent running → AgentBusyError.""" existing_run = _make_mock_agent_run(status="running") - executor = AgentExecutor(mock_pool, mock_context_builder) + executor = AgentExecutor(mock_context_builder) with ( patch( @@ -439,7 +437,7 @@ async def test_process_start_failure(self, mock_pool, mock_context_builder, """OpenCode process fails to start → status=failed.""" mock_pool.get_or_start.side_effect = RuntimeError("No free ports") - executor = AgentExecutor(mock_pool, mock_context_builder) + executor = AgentExecutor(mock_context_builder) with ( patch( @@ -473,7 +471,7 @@ async def test_timeout(self, mock_pool, mock_context_builder, timeout-label regression that motivates the assertion below sits on the PA branch in PR #1. """ - executor = AgentExecutor(mock_pool, mock_context_builder) + executor = AgentExecutor(mock_context_builder) async def _timeout_pa(agent_type, deps, timeout): # Stand-in for the PA path's own ``asyncio.wait_for`` → @@ -511,7 +509,7 @@ async def _timeout_pa(agent_type, deps, timeout): @pytest.mark.asyncio async def test_timeout_label_reports_effective_timeout_for_tool_agent( - self, mock_pool, mock_context_builder, mock_db, workspace_dir, + self, mock_context_builder, mock_db, workspace_dir, ): """For a tool agent (remediation_executor), the wall-clock ceiling is bumped from the caller-supplied ``timeout`` to ``max(timeout, 600)`` @@ -535,7 +533,7 @@ def _raise_timeout(): raise AgentTimeoutError("simulated timeout") executor = _executor_with_pa( - mock_pool, mock_context_builder, _raise_timeout + mock_context_builder, _raise_timeout ) with ( @@ -594,7 +592,7 @@ async def error_stream(session_id): client.stream_events = error_stream mock_pool.get_or_start.return_value = client - executor = AgentExecutor(mock_pool, mock_context_builder) + executor = AgentExecutor(mock_context_builder) with ( patch( @@ -625,7 +623,7 @@ async def test_progress_callback_called(self, mock_pool, mock_context_builder, progress_calls = [] - executor = AgentExecutor(mock_pool, mock_context_builder) + executor = AgentExecutor(mock_context_builder) with ( patch( @@ -651,7 +649,7 @@ async def test_completed_run_not_blocking(self, mock_pool, mock_context_builder, """A completed agent run should NOT block new executions.""" completed_run = _make_mock_agent_run(status="completed") executor = _executor_with_pa( - mock_pool, mock_context_builder, _pa_success_outcome + mock_context_builder, _pa_success_outcome ) with ( @@ -679,7 +677,7 @@ async def test_context_builder_failure(self, mock_pool, mock_context_builder, """If context_builder.update_context fails, result persists in DB.""" mock_context_builder.update_context.side_effect = OSError("Disk full") executor = _executor_with_pa( - mock_pool, mock_context_builder, _pa_success_outcome + mock_context_builder, _pa_success_outcome ) with ( @@ -708,7 +706,7 @@ async def test_owner_resolver_agent_type(self, mock_pool, mock_context_builder, context advance), not the PA library itself — coverage of the PA runtime layer lives in ``tests/agents/test_runtime_*.py``. """ - executor = AgentExecutor(mock_pool, mock_context_builder) + executor = AgentExecutor(mock_context_builder) fake_output = { "recommended_owner": "Platform Team", "candidates": [], @@ -756,12 +754,12 @@ async def _fake_pa(agent_type, deps, timeout): @pytest.mark.asyncio async def test_planner_receives_user_note_via_pa_path( - self, mock_pool, mock_context_builder, mock_db, workspace_dir, + self, mock_context_builder, mock_db, workspace_dir, ): """PRD-0006 Phase 2 — the planner's PA call DOES receive the user refinement note. Pair with ``test_owner_resolver_agent_type``, which asserts the gate strips it from every other agent type.""" - executor = AgentExecutor(mock_pool, mock_context_builder) + executor = AgentExecutor(mock_context_builder) captured: dict[str, str | None] = {} async def _fake_pa(agent_type, deps, timeout): @@ -828,7 +826,7 @@ async def multi_stream(session_id): client.stream_events = multi_stream mock_pool.get_or_start.return_value = client - executor = AgentExecutor(mock_pool, mock_context_builder) + executor = AgentExecutor(mock_context_builder) with ( patch( @@ -866,7 +864,7 @@ async def test_retry_still_fails(self, mock_pool, mock_context_builder, bad_response = "I'll try to read the files instead of returning JSON." mock_pool.get_or_start.return_value = _make_mock_client(bad_response) - executor = AgentExecutor(mock_pool, mock_context_builder) + executor = AgentExecutor(mock_context_builder) with ( patch( @@ -902,7 +900,7 @@ class TestPaResolverWiring: @pytest.mark.asyncio async def test_run_pa_no_tools_resolves_env_and_model_per_call( - self, mock_pool, mock_context_builder, monkeypatch, + self, mock_context_builder, monkeypatch, ): env_seq = [ {"OPENAI_API_KEY": "sk-first"}, @@ -929,7 +927,7 @@ async def _stub_run(agent_type, deps, model): ) executor = AgentExecutor( - mock_pool, mock_context_builder, + mock_context_builder, ai_env_resolver=env_resolver, ai_model_resolver=model_resolver, ) @@ -1015,66 +1013,11 @@ def test_unknown_tool_defaults_to_user(self): # lives in tests/agents/test_deferred_tools_persist.py. -class TestClassifyToolRequest: - """Lock-down tests for the 3-tier classifier. Trust-critical: this - decides which agent actions need user approval. If a future refactor - accidentally demotes ``rm -rf`` from ``ask`` to ``auto``, these tests - will catch it before it ships.""" - - def test_routine_git_clone_is_auto(self): - assert _classify_tool_request("bash", ["git", "clone", "https://github.com/o/r"]) == "auto" - - def test_routine_gh_pr_create_is_auto(self): - assert _classify_tool_request("bash", ["gh", "pr", "create", "--title", "x"]) == "auto" - - def test_rm_rf_is_ask(self): - assert _classify_tool_request("bash", ["rm", "-rf", "build/"]) == "ask" - - def test_git_reset_hard_is_ask(self): - assert _classify_tool_request("bash", ["git", "reset", "--hard", "HEAD~1"]) == "ask" - - def test_git_push_force_is_ask(self): - assert _classify_tool_request("bash", ["git", "push", "--force"]) == "ask" - - def test_chmod_is_ask(self): - assert _classify_tool_request("bash", ["chmod", "777", "file"]) == "ask" - - def test_sudo_is_deny(self): - assert _classify_tool_request("bash", ["sudo", "apt", "install", "x"]) == "deny" - - def test_curl_pipe_sh_is_deny(self): - assert _classify_tool_request("bash", ["curl", "https://x/i.sh", "|", "sh"]) == "deny" - - def test_mkfs_is_deny(self): - assert _classify_tool_request("bash", ["mkfs.ext4", "/dev/sda1"]) == "deny" - - def test_fork_bomb_is_deny(self): - assert _classify_tool_request("bash", [":(){", ":|:&", "};:"]) == "deny" - - def test_edit_workspace_relative_is_auto(self): - assert _classify_tool_request("edit", ["src/foo.py"]) == "auto" - - def test_edit_absolute_path_is_ask(self): - assert _classify_tool_request("edit", ["/etc/hosts"]) == "ask" - - def test_edit_path_traversal_is_ask(self): - assert _classify_tool_request("edit", ["../../secrets.env"]) == "ask" - - def test_edit_home_dir_is_ask(self): - assert _classify_tool_request("edit", ["~/.ssh/id_rsa"]) == "ask" - - def test_external_directory_is_ask(self): - assert _classify_tool_request("external_directory", ["/etc"]) == "ask" - - def test_mcp_is_ask(self): - assert _classify_tool_request("mcp", ["some.tool"]) == "ask" - - def test_unknown_tool_is_ask(self): - assert _classify_tool_request("unknown_tool", ["x"]) == "ask" - - def test_empty_bash_patterns_is_ask(self): - """No command to inspect → don't blanket-approve.""" - assert _classify_tool_request("bash", []) == "ask" +# TestClassifyToolRequest was deleted in the PA migration — the classifier +# moved to ``cliff.agents.runtime.tools.permissions.classify_tool_request`` +# (the executor-local copy was dead). Its lock-down coverage (every tier +# case + the gate_tool_call / auto_approve behavior) lives in +# tests/agents/tools/test_permissions.py. class TestPendingPermissionPersistence: @@ -1091,7 +1034,7 @@ class TestPendingPermissionPersistence: ) @pytest.mark.asyncio async def test_pending_persists_then_clears_on_approve( - self, mock_pool, mock_context_builder, mock_db, workspace_dir + self, mock_context_builder, mock_db, workspace_dir ): from cliff.models import AgentRunUpdate @@ -1113,7 +1056,7 @@ async def stream_with_ask_bash(session_id): client.stream_events = stream_with_ask_bash mock_pool.get_or_start.return_value = client - executor = AgentExecutor(mock_pool, mock_context_builder) + executor = AgentExecutor(mock_context_builder) update_spy = AsyncMock(return_value=None) @@ -1180,8 +1123,8 @@ def on_perm(event_dict): @pytest.mark.skip( reason=( "ADR-0047 / PR #1 — finding_enricher's old TOOL_TIERS route " - "is gone. Permission flow on the surviving OpenCode tool " - "agent uses _classify_tool_request, not TOOL_TIERS. PR #2 " + "is gone. Permission flow on the surviving tool agent uses " + "permissions.classify_tool_request, not TOOL_TIERS. PR #2 " "rebuilds permission handling on DeferredToolRequests; this " "test gets reborn there as a deferred-tools assertion." ), @@ -1213,7 +1156,7 @@ async def stream_with_permission(session_id): client.stream_events = stream_with_permission mock_pool.get_or_start.return_value = client - executor = AgentExecutor(mock_pool, mock_context_builder) + executor = AgentExecutor(mock_context_builder) with ( patch( @@ -1279,7 +1222,7 @@ async def stream_with_bash_permission(session_id): client.stream_events = stream_with_bash_permission mock_pool.get_or_start.return_value = client - executor = AgentExecutor(mock_pool, mock_context_builder) + executor = AgentExecutor(mock_context_builder) # Auto-approve from a background task after the # callback fires @@ -1343,7 +1286,7 @@ class TestRemediationExecutorPRVerification: @pytest.mark.asyncio async def test_valid_pr_url_passes_verification( - self, mock_pool, mock_context_builder, mock_db, workspace_dir + self, mock_context_builder, mock_db, workspace_dir ): real_url = "https://github.com/acme/widget/pull/42" @@ -1356,7 +1299,6 @@ async def fake_verify(url, **_): ) executor = _executor_with_pa( - mock_pool, mock_context_builder, lambda: _pa_success_outcome(_pr_created_output(real_url)), ) @@ -1397,7 +1339,7 @@ async def fake_verify(url, **_): @pytest.mark.asyncio async def test_hallucinated_pr_url_fails_run_and_blocks_advance( - self, mock_pool, mock_context_builder, mock_db, workspace_dir + self, mock_context_builder, mock_db, workspace_dir ): """B16 regression: verifier says 404 → no sidebar update, no advance, no completion.""" fake_url = "https://github.com/acme/widget/pull/9999" @@ -1411,7 +1353,6 @@ async def fake_verify(url, **_): ) executor = _executor_with_pa( - mock_pool, mock_context_builder, lambda: _pa_success_outcome(_pr_created_output(fake_url)), ) @@ -1455,13 +1396,12 @@ async def fake_verify(url, **_): @pytest.mark.asyncio async def test_compare_url_rejected_without_network( - self, mock_pool, mock_context_builder, mock_db, workspace_dir + self, mock_context_builder, mock_db, workspace_dir ): """A ``/pull/new/`` URL is rejected by the URL parser alone.""" fake_url = "https://github.com/acme/widget/pull/new/cliff-fix" executor = _executor_with_pa( - mock_pool, mock_context_builder, lambda: _pa_success_outcome(_pr_created_output(fake_url)), ) diff --git a/backend/tests/test_gateway.py b/backend/tests/test_gateway.py index 3b23a0cb..c64aefe3 100644 --- a/backend/tests/test_gateway.py +++ b/backend/tests/test_gateway.py @@ -3,7 +3,6 @@ from __future__ import annotations import asyncio -import json import os from datetime import UTC, datetime from typing import TYPE_CHECKING @@ -260,44 +259,3 @@ def sample_finding() -> Finding: ) -def test_workspace_opencode_json_includes_mcp(tmp_path, sample_finding: Finding): - from cliff.workspace import WorkspaceDirManager - - mgr = WorkspaceDirManager(base_dir=tmp_path) - mcp_servers = { - "github": { - "command": "npx", - "args": ["-y", "@modelcontextprotocol/server-github"], - "env": {"GITHUB_PERSONAL_ACCESS_TOKEN": "ghp_test"}, - } - } - ws = mgr.create("ws-mcp-test", sample_finding, mcp_servers=mcp_servers) - config = json.loads(ws.opencode_json.read_text()) - - assert "mcp" in config - assert "github" in config["mcp"] - assert config["mcp"]["github"]["env"]["GITHUB_PERSONAL_ACCESS_TOKEN"] == "ghp_test" - # Permissions still present. - assert config["permission"]["bash"] == "ask" - - -def test_workspace_opencode_json_no_mcp_without_servers(tmp_path, sample_finding: Finding): - from cliff.workspace import WorkspaceDirManager - - mgr = WorkspaceDirManager(base_dir=tmp_path) - ws = mgr.create("ws-no-mcp", sample_finding) - config = json.loads(ws.opencode_json.read_text()) - - assert "mcp" not in config - assert config["permission"]["bash"] == "ask" - - -def test_workspace_opencode_json_empty_mcp_dict(tmp_path, sample_finding: Finding): - from cliff.workspace import WorkspaceDirManager - - mgr = WorkspaceDirManager(base_dir=tmp_path) - ws = mgr.create("ws-empty-mcp", sample_finding, mcp_servers={}) - config = json.loads(ws.opencode_json.read_text()) - - # Empty dict should not produce mcp key. - assert "mcp" not in config diff --git a/backend/tests/test_ingest_job.py b/backend/tests/test_ingest_job.py index 849cfa1a..59c9ee22 100644 --- a/backend/tests/test_ingest_job.py +++ b/backend/tests/test_ingest_job.py @@ -201,7 +201,7 @@ async def test_process_job_success(): # Mock normalize_findings to return valid FindingCreate objects from cliff.models import FindingCreate - async def _mock_normalize(source, data, *, model=None): + async def _mock_normalize(source, data, *, env=None, model=None): return [ FindingCreate(source_type="wiz", source_id=f"wiz-{i}", title=f"Finding {i}") for i in range(len(data)) @@ -219,7 +219,12 @@ async def _mock_normalize(source, data, *, model=None): ): from cliff.integrations.ingest_worker import _process_job - await _process_job(db, job.job_id) + await _process_job( + db, + job.job_id, + env_resolver=AsyncMock(return_value={"OPENAI_API_KEY": "k"}), + model_resolver=AsyncMock(return_value="openai/gpt-4o-mini"), + ) progress = await get_ingest_job(db, job.job_id) assert progress.status == "completed" @@ -243,7 +248,7 @@ async def test_process_job_partial_failure(): call_count = 0 - async def _mock_normalize(source, data, *, model=None): + async def _mock_normalize(source, data, *, env=None, model=None): nonlocal call_count call_count += 1 if call_count == 1: @@ -267,7 +272,12 @@ async def _mock_normalize(source, data, *, model=None): ): from cliff.integrations.ingest_worker import _process_job - await _process_job(db, job.job_id) + await _process_job( + db, + job.job_id, + env_resolver=AsyncMock(return_value={"OPENAI_API_KEY": "k"}), + model_resolver=AsyncMock(return_value="openai/gpt-4o-mini"), + ) progress = await get_ingest_job(db, job.job_id) assert progress.status == "completed" @@ -277,6 +287,35 @@ async def _mock_normalize(source, data, *, model=None): await close_db() +@pytest.mark.asyncio +async def test_process_job_no_provider_marks_failed_not_retry(): + """No resolved AI provider → terminal ``failed`` (not a fail→pending→retry + loop). The normalizer is a PA agent now and can't run without a provider.""" + from cliff.db.connection import close_db, init_db + from cliff.db.repo_ingest_job import create_ingest_job, get_ingest_job + + await init_db(":memory:") + from cliff.db.connection import _db as db + + job = await create_ingest_job( + db, source="wiz", raw_data=[{"id": "1"}], chunk_size=1 + ) + from cliff.integrations.ingest_worker import _process_job + + await _process_job( + db, + job.job_id, + env_resolver=AsyncMock(return_value={}), # no provider env + model_resolver=AsyncMock(return_value=None), # no canonical model + ) + + progress = await get_ingest_job(db, job.job_id) + assert progress.status == "failed" + assert progress.completed_chunks == 0 + assert any("provider" in e.lower() for e in (progress.errors or [])) + await close_db() + + @pytest.mark.asyncio async def test_process_job_cancellation(): """Worker respects cancellation between chunks.""" @@ -295,7 +334,7 @@ async def test_process_job_cancellation(): chunk_calls = 0 - async def _mock_normalize(source, data, *, model=None): + async def _mock_normalize(source, data, *, env=None, model=None): nonlocal chunk_calls chunk_calls += 1 # Cancel after first chunk @@ -318,7 +357,12 @@ async def _mock_normalize(source, data, *, model=None): ): from cliff.integrations.ingest_worker import _process_job - await _process_job(db, job.job_id) + await _process_job( + db, + job.job_id, + env_resolver=AsyncMock(return_value={"OPENAI_API_KEY": "k"}), + model_resolver=AsyncMock(return_value="openai/gpt-4o-mini"), + ) progress = await get_ingest_job(db, job.job_id) assert progress.status == "cancelled" diff --git a/backend/tests/test_mcp_gateway_integration.py b/backend/tests/test_mcp_gateway_integration.py index 868072f2..ee8314f1 100644 --- a/backend/tests/test_mcp_gateway_integration.py +++ b/backend/tests/test_mcp_gateway_integration.py @@ -49,7 +49,6 @@ async def vault(db: aiosqlite.Connection): async def test_full_gateway_flow(db: aiosqlite.Connection, vault: CredentialVault, tmp_path): """End-to-end: create integration → store creds → create workspace → verify everything.""" - from cliff.agents.template_engine import AgentTemplateEngine from cliff.db import repo_audit from cliff.db.repo_finding import create_finding from cliff.workspace.context_builder import WorkspaceContextBuilder @@ -80,22 +79,11 @@ async def test_full_gateway_flow(db: aiosqlite.Connection, vault: CredentialVaul # 3. Create workspace (triggers MCP config resolution). dir_mgr = WorkspaceDirManager(base_dir=tmp_path) - tmpl = AgentTemplateEngine() - builder = WorkspaceContextBuilder(dir_mgr, tmpl, mcp_resolver=resolver) + builder = WorkspaceContextBuilder(dir_mgr, mcp_resolver=resolver) workspace = await builder.create_workspace(db, finding) - - # 4. Verify opencode.json has MCP section. ws_dir = tmp_path / workspace.id - oc_config = json.loads((ws_dir / "opencode.json").read_text()) - assert "mcp" in oc_config - assert "github" in oc_config["mcp"] - assert oc_config["mcp"]["github"]["command"][0] == "npx" - gh_env = oc_config["mcp"]["github"]["environment"] - assert gh_env["GITHUB_PERSONAL_ACCESS_TOKEN"] == "ghp_e2e_test_token" - # Permissions still present. - assert oc_config["permission"]["bash"] == "ask" - - # 5. Verify workspace-integrations.json manifest. + + # 4. Verify workspace-integrations.json manifest. manifest = json.loads((ws_dir / "workspace-integrations.json").read_text()) assert len(manifest) == 1 assert manifest[0]["provider_name"] == "GitHub" @@ -127,7 +115,6 @@ async def test_config_fresh_when_unchanged( db: aiosqlite.Connection, vault: CredentialVault, tmp_path ): """Config is fresh when nothing has changed since workspace creation.""" - from cliff.agents.template_engine import AgentTemplateEngine from cliff.db.repo_finding import create_finding from cliff.workspace.context_builder import WorkspaceContextBuilder from cliff.workspace.workspace_dir_manager import WorkspaceDirManager @@ -144,7 +131,6 @@ async def test_config_fresh_when_unchanged( ) builder = WorkspaceContextBuilder( WorkspaceDirManager(base_dir=tmp_path), - AgentTemplateEngine(), mcp_resolver=resolver, ) workspace = await builder.create_workspace(db, finding) @@ -157,7 +143,6 @@ async def test_config_stale_when_integration_added( db: aiosqlite.Connection, vault: CredentialVault, tmp_path ): """Config becomes stale when a new integration is added after workspace creation.""" - from cliff.agents.template_engine import AgentTemplateEngine from cliff.db.repo_finding import create_finding from cliff.workspace.context_builder import WorkspaceContextBuilder from cliff.workspace.workspace_dir_manager import WorkspaceDirManager @@ -176,7 +161,6 @@ async def test_config_stale_when_integration_added( ) builder = WorkspaceContextBuilder( WorkspaceDirManager(base_dir=tmp_path), - AgentTemplateEngine(), mcp_resolver=resolver, ) workspace = await builder.create_workspace(db, finding) @@ -199,7 +183,6 @@ async def test_config_stale_when_integration_disabled( db: aiosqlite.Connection, vault: CredentialVault, tmp_path ): """Config becomes stale when an integration is disabled after workspace creation.""" - from cliff.agents.template_engine import AgentTemplateEngine from cliff.db.repo_finding import create_finding from cliff.workspace.context_builder import WorkspaceContextBuilder from cliff.workspace.workspace_dir_manager import WorkspaceDirManager @@ -216,7 +199,6 @@ async def test_config_stale_when_integration_disabled( ) builder = WorkspaceContextBuilder( WorkspaceDirManager(base_dir=tmp_path), - AgentTemplateEngine(), mcp_resolver=resolver, ) workspace = await builder.create_workspace(db, finding) @@ -233,7 +215,6 @@ async def test_config_stale_when_tier_changed( db: aiosqlite.Connection, vault: CredentialVault, tmp_path ): """Config becomes stale when an integration's action tier is changed.""" - from cliff.agents.template_engine import AgentTemplateEngine from cliff.db.repo_finding import create_finding from cliff.workspace.context_builder import WorkspaceContextBuilder from cliff.workspace.workspace_dir_manager import WorkspaceDirManager @@ -250,7 +231,6 @@ async def test_config_stale_when_tier_changed( ) builder = WorkspaceContextBuilder( WorkspaceDirManager(base_dir=tmp_path), - AgentTemplateEngine(), mcp_resolver=resolver, ) workspace = await builder.create_workspace(db, finding) @@ -285,7 +265,6 @@ async def test_integrations_api_includes_freshness( db: aiosqlite.Connection, vault: CredentialVault, tmp_path ): """GET /workspaces/{id}/integrations returns config_stale field.""" - from cliff.agents.template_engine import AgentTemplateEngine from cliff.db.repo_finding import create_finding from cliff.main import app from cliff.workspace.context_builder import WorkspaceContextBuilder @@ -312,7 +291,6 @@ async def _noop_lifespan(a): ) builder = WorkspaceContextBuilder( WorkspaceDirManager(base_dir=tmp_path), - AgentTemplateEngine(), mcp_resolver=resolver, ) app.state.context_builder = builder diff --git a/backend/tests/test_models.py b/backend/tests/test_models.py index a85cd70c..7db7dc96 100644 --- a/backend/tests/test_models.py +++ b/backend/tests/test_models.py @@ -1,42 +1,13 @@ """Tests for Pydantic models.""" -from cliff.engine.models import ( - HealthStatus, - MessageInfo, - SessionDetail, - SessionSummary, - SSEEvent, -) - - -def test_session_summary_serialization(): - s = SessionSummary(id="ses_abc123") - assert s.id == "ses_abc123" - assert s.created_at is None - data = s.model_dump() - assert data["id"] == "ses_abc123" - - -def test_session_detail_with_messages(): - msg = MessageInfo(id="msg_1", role="user", content="hello") - detail = SessionDetail(id="ses_abc", messages=[msg]) - assert len(detail.messages) == 1 - assert detail.messages[0].role == "user" - assert detail.messages[0].content == "hello" +from cliff.models import HealthStatus def test_health_status_defaults(): h = HealthStatus() assert h.cliff == "ok" - assert h.opencode == "unknown" + # In-process substrate (Pydantic AI): "opencode" is the kept-for-compat + # field name and defaults to "ok" now, not the OpenCode-probe "unknown". + assert h.opencode == "ok" assert h.opencode_version == "" - - -def test_sse_event_model(): - e = SSEEvent(event="done", data='{"result": "ok"}') - assert e.event == "done" - assert e.data == '{"result": "ok"}' - - default = SSEEvent() - assert default.event == "message" - assert default.data == "" + assert h.ai_provider_ready is False diff --git a/backend/tests/test_normalizer.py b/backend/tests/test_normalizer.py index d8141c20..6b44378d 100644 --- a/backend/tests/test_normalizer.py +++ b/backend/tests/test_normalizer.py @@ -1,124 +1,73 @@ -"""Tests for the LLM-powered finding normalizer.""" +"""Unit tests for the Pydantic AI finding normalizer (IMPL-0022 PR #3b). + +These drive ``normalize_findings`` with a ``FunctionModel`` (no live LLM): +``build_model`` is patched to return the fake model, so each test controls +the structured output the agent "returns" and asserts the downstream +``FindingCreate`` validation + partial-success ``(valid, errors)`` contract. +""" from __future__ import annotations -import json -from unittest.mock import AsyncMock, patch +from unittest.mock import patch import pytest +from pydantic_ai.exceptions import ModelHTTPError +from pydantic_ai.messages import ModelResponse, ToolCallPart +from pydantic_ai.models.function import AgentInfo, FunctionModel + +from cliff.integrations.normalizer import MAX_BATCH_SIZE, normalize_findings + +_ENV = {"OPENAI_API_KEY": "test-key"} +_MODEL = "openai/gpt-4o-mini" -from cliff.integrations.normalizer import MAX_BATCH_SIZE, _extract_json_array, normalize_findings - -# --------------------------------------------------------------------------- -# _extract_json_array unit tests -# --------------------------------------------------------------------------- - - -class TestExtractJsonArray: - def test_bare_array(self): - text = '[{"source_type": "wiz", "source_id": "1", "title": "test"}]' - result = _extract_json_array(text) - assert result is not None - assert len(result) == 1 - assert result[0]["source_id"] == "1" - - def test_fenced_json(self): - text = '```json\n[{"source_type": "wiz", "source_id": "1", "title": "t"}]\n```' - result = _extract_json_array(text) - assert result is not None - assert len(result) == 1 - - def test_fenced_no_lang(self): - text = '```\n[{"a": 1}]\n```' - result = _extract_json_array(text) - assert result == [{"a": 1}] - - def test_trailing_comma(self): - text = '[{"a": 1}, {"b": 2},]' - result = _extract_json_array(text) - assert result is not None - assert len(result) == 2 - - def test_surrounding_text(self): - text = 'Here are the results:\n[{"x": 1}]\nDone!' - result = _extract_json_array(text) - assert result == [{"x": 1}] - - def test_no_array(self): - assert _extract_json_array("no json here") is None - - def test_empty_array(self): - assert _extract_json_array("[]") == [] - - def test_not_an_array(self): - assert _extract_json_array('{"key": "value"}') is None - - def test_malformed_json(self): - assert _extract_json_array("[{bad json}]") is None - - def test_nested_brackets(self): - text = '[{"tags": ["a", "b"], "name": "test"}]' - result = _extract_json_array(text) - assert result is not None - assert result[0]["tags"] == ["a", "b"] - - -# --------------------------------------------------------------------------- -# normalize_findings tests (mocked OpenCode client) -# --------------------------------------------------------------------------- - -WIZ_LLM_RESPONSE = json.dumps([ - { - "source_type": "wiz", - "source_id": "wiz-123", - "title": "S3 bucket publicly accessible", - "description": "Public read access via bucket policy.", - "raw_severity": "CRITICAL", - "normalized_priority": "critical", - "asset_id": "arn:aws:s3:::my-bucket", - "asset_label": "my-bucket", - "status": "new", - "likely_owner": None, - "why_this_matters": "Publicly accessible S3 buckets can expose sensitive data.", - } -]) - -PARTIAL_LLM_RESPONSE = json.dumps([ - { - "source_type": "snyk", - "source_id": "SNYK-001", - "title": "Prototype pollution in lodash", - "status": "new", - }, - { - "source_type": "snyk", - # Missing required field: source_id - "title": "Another vuln", - }, -]) - - -@pytest.fixture -def mock_opencode(): - """Patch the opencode_client singleton for normalizer tests. - - The normalizer uses Mode 1 (synchronous RPC) via send_and_get_response, - so we mock that single call. It returns the LLM text or None. + +def _model_returning(items: list[dict]) -> FunctionModel: + """A FunctionModel that emits *items* as the agent's structured output. + + PA wraps a ``list[...]`` output in a synthetic ``final_result`` tool whose + single argument is ``response`` — see the agent's output schema. """ - with patch("cliff.integrations.normalizer.opencode_client") as mock: - mock.create_session = AsyncMock() - mock.create_session.return_value.id = "test-session-id" - mock.send_and_get_response = AsyncMock(return_value=None) - mock.get_config = AsyncMock(return_value={"model": "openai/gpt-4.1-nano"}) - mock.update_config = AsyncMock(return_value={}) - yield mock + def _fn(messages, info: AgentInfo) -> ModelResponse: + tool_name = info.output_tools[0].name + return ModelResponse( + parts=[ToolCallPart(tool_name=tool_name, args={"response": items})] + ) + + return FunctionModel(_fn) + + +def _erroring_model() -> FunctionModel: + def _fn(messages, info: AgentInfo) -> ModelResponse: + raise ModelHTTPError(status_code=429, model_name="x", body="rate limited") + + return FunctionModel(_fn) + + +def _patch_model(model: FunctionModel): + return patch("cliff.integrations.normalizer.build_model", return_value=model) -@pytest.mark.asyncio -async def test_normalize_success(mock_opencode): - mock_opencode.send_and_get_response.return_value = WIZ_LLM_RESPONSE - findings, errors = await normalize_findings("wiz", [{"id": "wiz-123", "name": "test"}]) +_WIZ_ITEM = { + "source_type": "wiz", + "source_id": "wiz-123", + "title": "S3 bucket publicly accessible", + "description": "Public read access via bucket policy.", + "raw_severity": "CRITICAL", + "normalized_priority": "critical", + "asset_id": "arn:aws:s3:::my-bucket", + "asset_label": "my-bucket", + "status": "new", + "why_this_matters": "Publicly accessible S3 buckets can expose data.", +} + + +@pytest.mark.asyncio +async def test_normalize_success(): + with _patch_model(_model_returning([_WIZ_ITEM])): + findings, errors = await normalize_findings( + "wiz", [{"id": "wiz-123", "name": "test"}], env=_ENV, model=_MODEL + ) assert len(findings) == 1 assert findings[0].source_type == "wiz" @@ -127,16 +76,23 @@ async def test_normalize_success(mock_opencode): assert findings[0].normalized_priority == "critical" assert errors == [] - mock_opencode.create_session.assert_called_once() - mock_opencode.send_and_get_response.assert_called_once() - @pytest.mark.asyncio -async def test_normalize_partial_failure(mock_opencode): - """One valid finding, one missing source_id — partial result.""" - mock_opencode.send_and_get_response.return_value = PARTIAL_LLM_RESPONSE - - findings, errors = await normalize_findings("snyk", [{"a": 1}, {"b": 2}]) +async def test_normalize_partial_failure(): + """One valid finding, one missing source_id — partial result preserved.""" + items = [ + { + "source_type": "snyk", + "source_id": "SNYK-001", + "title": "Prototype pollution in lodash", + "status": "new", + }, + {"source_type": "snyk", "title": "Another vuln"}, # missing source_id + ] + with _patch_model(_model_returning(items)): + findings, errors = await normalize_findings( + "snyk", [{"a": 1}, {"b": 2}], env=_ENV, model=_MODEL + ) assert len(findings) == 1 assert findings[0].source_id == "SNYK-001" @@ -145,76 +101,110 @@ async def test_normalize_partial_failure(mock_opencode): @pytest.mark.asyncio -async def test_normalize_empty_input(mock_opencode): - findings, errors = await normalize_findings("wiz", []) - assert findings == [] +async def test_normalize_injects_source_type(): + """If the model omits source_type, it's filled from the request source.""" + items = [{"source_id": "x-1", "title": "Test vuln", "status": "new"}] + with _patch_model(_model_returning(items)): + findings, errors = await normalize_findings( + "trivy", [{"id": "x-1"}], env=_ENV, model=_MODEL + ) + + assert len(findings) == 1 + assert findings[0].source_type == "trivy" assert errors == [] - mock_opencode.create_session.assert_not_called() @pytest.mark.asyncio -async def test_normalize_batch_too_large(mock_opencode): - raw = [{"id": str(i)} for i in range(MAX_BATCH_SIZE + 1)] - findings, errors = await normalize_findings("wiz", raw) - assert findings == [] - assert len(errors) == 1 - assert "Batch too large" in errors[0] - mock_opencode.create_session.assert_not_called() +async def test_normalize_fills_status_when_null(): + """A null status from the model defaults to 'new' (not a validation error).""" + items = [{"source_type": "wiz", "source_id": "w-9", "title": "T", "status": None}] + with _patch_model(_model_returning(items)): + findings, errors = await normalize_findings( + "wiz", [{"id": "w-9"}], env=_ENV, model=_MODEL + ) + + assert errors == [] + assert findings[0].status == "new" @pytest.mark.asyncio -async def test_normalize_llm_error(mock_opencode): - mock_opencode.send_and_get_response.side_effect = RuntimeError("rate limit exceeded") +async def test_normalize_forces_status_new_over_stray_value(): + """A stray status string (e.g. 'open') must not drop an otherwise-valid + finding — the normalizer always emits brand-new findings.""" + items = [ + {"source_type": "wiz", "source_id": "w-1", "title": "T", "status": "open"} + ] + with _patch_model(_model_returning(items)): + findings, errors = await normalize_findings( + "wiz", [{"id": "w-1"}], env=_ENV, model=_MODEL + ) - findings, errors = await normalize_findings("wiz", [{"id": "1"}]) - assert findings == [] - assert len(errors) == 1 - assert "Failed to parse JSON array" in errors[0] - # With retry, it should have been called 3 times (1 original + 2 retries) - assert mock_opencode.create_session.call_count == 3 + assert errors == [] + assert findings[0].status == "new" @pytest.mark.asyncio -async def test_normalize_empty_response(mock_opencode): - # send_and_get_response returns None by default (fixture) - findings, errors = await normalize_findings("wiz", [{"id": "1"}]) - assert findings == [] - assert "Failed to parse JSON array" in errors[0] - # Retried 3 times - assert mock_opencode.create_session.call_count == 3 +async def test_normalize_coerces_listwrapped_raw_payload(): + """The model sometimes wraps raw_payload in a single-element list.""" + payload = {"id": "w-1", "extra": True} + items = [ + { + "source_type": "wiz", + "source_id": "w-1", + "title": "T", + "status": "new", + "raw_payload": [payload], + } + ] + with _patch_model(_model_returning(items)): + findings, _ = await normalize_findings( + "wiz", [{"id": "w-1"}], env=_ENV, model=_MODEL + ) + + assert findings[0].raw_payload == payload @pytest.mark.asyncio -async def test_normalize_malformed_response(mock_opencode): - mock_opencode.send_and_get_response.return_value = "Sorry, I can't do that." - - findings, errors = await normalize_findings("wiz", [{"id": "1"}]) +async def test_normalize_empty_input(): + # No model call at all for empty input. + with patch("cliff.integrations.normalizer.build_model") as build: + findings, errors = await normalize_findings("wiz", [], env=_ENV, model=_MODEL) assert findings == [] - assert "Failed to parse" in errors[0] - # Retried 3 times - assert mock_opencode.create_session.call_count == 3 + assert errors == [] + build.assert_not_called() @pytest.mark.asyncio -async def test_normalize_fenced_response(mock_opencode): - """LLM wraps JSON in markdown fences — should still parse.""" - fenced = f"```json\n{WIZ_LLM_RESPONSE}\n```" - mock_opencode.send_and_get_response.return_value = fenced +async def test_normalize_batch_too_large(): + raw = [{"id": str(i)} for i in range(MAX_BATCH_SIZE + 1)] + with patch("cliff.integrations.normalizer.build_model") as build: + findings, errors = await normalize_findings( + "wiz", raw, env=_ENV, model=_MODEL + ) + assert findings == [] + assert len(errors) == 1 + assert "Batch too large" in errors[0] + build.assert_not_called() - findings, errors = await normalize_findings("wiz", [{"id": "wiz-123"}]) - assert len(findings) == 1 - assert errors == [] + +@pytest.mark.asyncio +async def test_normalize_llm_error_returns_error_not_raises(): + """An LLM transport error is captured as an error string, not raised.""" + with _patch_model(_erroring_model()): + findings, errors = await normalize_findings( + "wiz", [{"id": "1"}], env=_ENV, model=_MODEL + ) + assert findings == [] + assert len(errors) == 1 + assert "Normalizer LLM call failed" in errors[0] @pytest.mark.asyncio -async def test_normalize_injects_source_type(mock_opencode): - """If LLM omits source_type, it's injected from the request.""" - response = json.dumps([ - {"source_id": "x-1", "title": "Test vuln", "status": "new"}, - ]) - mock_opencode.send_and_get_response.return_value = response - - findings, errors = await normalize_findings("trivy", [{"id": "x-1"}]) - assert len(findings) == 1 - assert findings[0].source_type == "trivy" - assert errors == [] +async def test_normalize_model_not_configured(): + """A missing/blank model surfaces as a friendly error, not a crash.""" + findings, errors = await normalize_findings( + "wiz", [{"id": "1"}], env={}, model=None + ) + assert findings == [] + assert len(errors) == 1 + assert "Normalizer model not configured" in errors[0] diff --git a/backend/tests/test_permission_client.py b/backend/tests/test_permission_client.py deleted file mode 100644 index 4bb14811..00000000 --- a/backend/tests/test_permission_client.py +++ /dev/null @@ -1,116 +0,0 @@ -"""Tests for OpenCode client permission event handling.""" - -from __future__ import annotations - -from unittest.mock import AsyncMock, MagicMock, PropertyMock - -import pytest - -from cliff.engine.client import OpenCodeClient - - -def _make_mock_http_client(): - """Create a mock httpx.AsyncClient that passes _get_client() checks.""" - mock = AsyncMock() - type(mock).is_closed = PropertyMock(return_value=False) - return mock - - -class TestPermissionEventDetection: - @pytest.mark.asyncio - async def test_permission_asked_event_detected(self): - """Client yields permission_request for permission.asked events.""" - sse_data = ( - 'data: {"type":"permission.asked","properties":{' - '"id":"per_123","permission":"bash",' - '"patterns":["ls -la"],"always":[],' - '"metadata":{},"sessionID":"ses_test",' - '"tool":{"messageID":"msg_1","callID":"call_1"}' - "}}\n\n" - 'data: {"type":"session.idle","properties":{' - '"sessionID":"ses_test"}}\n\n' - ) - - client = OpenCodeClient(base_url="http://localhost:9999") - mock_http = _make_mock_http_client() - - async def mock_aiter_text(): - yield sse_data - - mock_resp = MagicMock() - mock_resp.raise_for_status = lambda: None - mock_resp.aiter_text = mock_aiter_text - - # stream() returns a context manager, not a coroutine - from contextlib import asynccontextmanager - - @asynccontextmanager - async def mock_stream(*args, **kwargs): - yield mock_resp - - mock_http.stream = mock_stream - client._client = mock_http - - events = [] - async for event in client.stream_events("ses_test"): - events.append(event) - - # permission_pending logic: session.idle after permission.asked - # is skipped, so only the permission_request event comes through. - # The stream ends when the SSE connection closes (no more data). - assert len(events) == 1 - assert events[0]["type"] == "permission_request" - assert events[0]["id"] == "per_123" - assert events[0]["tool"] == "bash" - assert events[0]["patterns"] == ["ls -la"] - - -class TestPermissionGrantDeny: - @pytest.mark.asyncio - async def test_grant_permission(self): - """grant_permission POSTs to /session/{sid}/permissions/{pid}.""" - client = OpenCodeClient(base_url="http://localhost:9999") - mock_http = _make_mock_http_client() - mock_resp = MagicMock() - mock_resp.raise_for_status = lambda: None - mock_http.post.return_value = mock_resp - client._client = mock_http - - await client.grant_permission("per_123", session_id="ses_abc") - mock_http.post.assert_called_once_with( - "/session/ses_abc/permissions/per_123", - json={"response": "once"}, - ) - - @pytest.mark.asyncio - async def test_grant_permission_always(self): - """grant_permission with always=True sends 'always' response.""" - client = OpenCodeClient(base_url="http://localhost:9999") - mock_http = _make_mock_http_client() - mock_resp = MagicMock() - mock_resp.raise_for_status = lambda: None - mock_http.post.return_value = mock_resp - client._client = mock_http - - await client.grant_permission("per_123", session_id="ses_abc", always=True) - mock_http.post.assert_called_once_with( - "/session/ses_abc/permissions/per_123", - json={"response": "always"}, - ) - - @pytest.mark.asyncio - async def test_deny_permission(self): - """deny_permission POSTs reject to /session/{sid}/permissions/{pid}.""" - client = OpenCodeClient(base_url="http://localhost:9999") - mock_http = _make_mock_http_client() - mock_resp = MagicMock() - mock_resp.raise_for_status = lambda: None - mock_http.post.return_value = mock_resp - client._client = mock_http - - await client.deny_permission("per_456", session_id="ses_abc") - mock_http.post.assert_called_once_with( - "/session/ses_abc/permissions/per_456", - json={"response": "reject"}, - ) - diff --git a/backend/tests/test_process_pool.py b/backend/tests/test_process_pool.py deleted file mode 100644 index 0b0bb210..00000000 --- a/backend/tests/test_process_pool.py +++ /dev/null @@ -1,691 +0,0 @@ -"""Tests for Layer 3: WorkspaceProcessPool, PortAllocator.""" - -from __future__ import annotations - -import json -from pathlib import Path -from unittest.mock import AsyncMock, MagicMock, patch - -import pytest - -from cliff.engine.pool import PortAllocator, WorkspaceProcess, WorkspaceProcessPool - -# --------------------------------------------------------------------------- -# PortAllocator -# --------------------------------------------------------------------------- - - -def test_allocate_returns_first_port(): - pa = PortAllocator(start=5000, end=5009) - assert pa.allocate() == 5000 - - -def test_allocate_sequential(): - pa = PortAllocator(start=5000, end=5009) - assert pa.allocate() == 5000 - assert pa.allocate() == 5001 - assert pa.allocate() == 5002 - - -def test_release_makes_port_available(): - pa = PortAllocator(start=5000, end=5009) - port = pa.allocate() - pa.release(port) - assert pa.allocate() == port - - -def test_allocate_exhausted(): - pa = PortAllocator(start=5000, end=5002) - pa.allocate() - pa.allocate() - pa.allocate() - with pytest.raises(RuntimeError, match="No free ports"): - pa.allocate() - - -def test_available_count(): - pa = PortAllocator(start=5000, end=5004) - assert pa.available == 5 - pa.allocate() - assert pa.available == 4 - pa.allocate() - pa.release(5000) - assert pa.available == 4 - - -# --------------------------------------------------------------------------- -# WorkspaceProcess -# --------------------------------------------------------------------------- - - -def test_workspace_process_idle_seconds(): - wp = WorkspaceProcess( - workspace_id="ws-1", - workspace_dir=Path("/tmp/ws-1"), - port=5000, - ) - assert wp.idle_seconds >= 0 - - -def test_workspace_process_touch(): - wp = WorkspaceProcess( - workspace_id="ws-1", - workspace_dir=Path("/tmp/ws-1"), - port=5000, - ) - import time - - time.sleep(0.05) - idle_before = wp.idle_seconds - wp.touch() - idle_after = wp.idle_seconds - assert idle_after < idle_before - - -def test_workspace_process_is_running(): - wp = WorkspaceProcess( - workspace_id="ws-1", - workspace_dir=Path("/tmp/ws-1"), - port=5000, - ) - assert wp.is_running is False - - mock_proc = MagicMock() - mock_proc.returncode = None - wp.process = mock_proc - assert wp.is_running is True - - mock_proc.returncode = 0 - assert wp.is_running is False - - -# --------------------------------------------------------------------------- -# WorkspaceProcessPool (mocked subprocess + httpx) -# --------------------------------------------------------------------------- - - -def _make_mock_subprocess(): - """Create a mock asyncio subprocess.""" - proc = AsyncMock() - proc.returncode = None - proc.terminate = MagicMock() - proc.kill = MagicMock() - proc.wait = AsyncMock() - proc.stderr = None - proc.stdout = None - return proc - - -def _make_mock_httpx_healthy(): - """Create a mock httpx context manager that returns 200.""" - mock_response = MagicMock() - mock_response.status_code = 200 - - mock_client = AsyncMock() - mock_client.get = AsyncMock(return_value=mock_response) - mock_client.__aenter__ = AsyncMock(return_value=mock_client) - mock_client.__aexit__ = AsyncMock(return_value=False) - return mock_client - - -@pytest.fixture -def pool(): - """Process pool with a small port range for testing.""" - return WorkspaceProcessPool( - port_allocator=PortAllocator(start=5100, end=5109), - host="127.0.0.1", - ) - - -async def test_start_allocates_port_and_starts_process(pool: WorkspaceProcessPool): - mock_proc = _make_mock_subprocess() - mock_httpx = _make_mock_httpx_healthy() - - with ( - patch( - "cliff.engine.pool.asyncio.create_subprocess_exec", - new=AsyncMock(return_value=mock_proc), - ) as mock_exec, - patch("cliff.engine.pool.httpx.AsyncClient", return_value=mock_httpx), - ): - client = await pool.start("ws-1", Path("/tmp/ws-1")) - - assert client is not None - assert client.base_url == "http://127.0.0.1:5100" - - # Verify subprocess was called with correct cwd - call_kwargs = mock_exec.call_args - assert str(call_kwargs.kwargs.get("cwd")) == "/tmp/ws-1" - - -async def test_get_or_start_returns_existing(pool: WorkspaceProcessPool): - mock_proc = _make_mock_subprocess() - mock_httpx = _make_mock_httpx_healthy() - - with ( - patch( - "cliff.engine.pool.asyncio.create_subprocess_exec", - new=AsyncMock(return_value=mock_proc), - ) as mock_exec, - patch("cliff.engine.pool.httpx.AsyncClient", return_value=mock_httpx), - ): - client1 = await pool.get_or_start("ws-1", Path("/tmp/ws-1")) - client2 = await pool.get_or_start("ws-1", Path("/tmp/ws-1")) - - assert client1 is client2 - # Only one subprocess created - assert mock_exec.call_count == 1 - - -async def test_stop_terminates_and_releases_port(pool: WorkspaceProcessPool): - mock_proc = _make_mock_subprocess() - mock_httpx = _make_mock_httpx_healthy() - - with ( - patch( - "cliff.engine.pool.asyncio.create_subprocess_exec", - new=AsyncMock(return_value=mock_proc), - ), - patch("cliff.engine.pool.httpx.AsyncClient", return_value=mock_httpx), - ): - await pool.start("ws-1", Path("/tmp/ws-1")) - - assert pool._ports.available == 9 # 1 of 10 used - - mock_proc.returncode = None # still running - await pool.stop("ws-1") - - mock_proc.terminate.assert_called_once() - assert pool._ports.available == 10 # port released - assert await pool.get("ws-1") is None - - -async def test_stop_all(pool: WorkspaceProcessPool): - mock_httpx = _make_mock_httpx_healthy() - - procs = [_make_mock_subprocess() for _ in range(3)] - - with ( - patch( - "cliff.engine.pool.asyncio.create_subprocess_exec", - new=AsyncMock(side_effect=procs), - ), - patch("cliff.engine.pool.httpx.AsyncClient", return_value=mock_httpx), - ): - await pool.start("ws-1", Path("/tmp/ws-1")) - await pool.start("ws-2", Path("/tmp/ws-2")) - await pool.start("ws-3", Path("/tmp/ws-3")) - - assert pool._ports.available == 7 - - for p in procs: - p.returncode = None - - await pool.stop_all() - - assert pool._ports.available == 10 - assert len(pool._processes) == 0 - - -async def test_stop_idle(pool: WorkspaceProcessPool): - mock_httpx = _make_mock_httpx_healthy() - procs = [_make_mock_subprocess() for _ in range(2)] - - with ( - patch( - "cliff.engine.pool.asyncio.create_subprocess_exec", - new=AsyncMock(side_effect=procs), - ), - patch("cliff.engine.pool.httpx.AsyncClient", return_value=mock_httpx), - ): - await pool.start("ws-old", Path("/tmp/ws-old")) - await pool.start("ws-new", Path("/tmp/ws-new")) - - # Make ws-old appear idle by manipulating last_activity - import time - - pool._processes["ws-old"].last_activity = time.monotonic() - 999 - - for p in procs: - p.returncode = None - - from datetime import timedelta - - stopped = await pool.stop_idle(timedelta(seconds=10)) - - assert "ws-old" in stopped - assert "ws-new" not in stopped - assert len(pool._processes) == 1 - - -async def test_start_failure_releases_port(pool: WorkspaceProcessPool): - """If health check fails, port must be released.""" - mock_proc = _make_mock_subprocess() - # Simulate process dying immediately - mock_proc.returncode = 1 - mock_proc.stderr = AsyncMock() - mock_proc.stderr.read = AsyncMock(return_value=b"startup failed") - - import httpx as httpx_mod - - mock_httpx = AsyncMock() - mock_httpx.get = AsyncMock( - side_effect=httpx_mod.ConnectError("connection refused") - ) - mock_httpx.__aenter__ = AsyncMock(return_value=mock_httpx) - mock_httpx.__aexit__ = AsyncMock(return_value=False) - - with ( - patch( - "cliff.engine.pool.asyncio.create_subprocess_exec", - new=AsyncMock(return_value=mock_proc), - ), - patch("cliff.engine.pool.httpx.AsyncClient", return_value=mock_httpx), - pytest.raises(RuntimeError, match="exited with code 1"), - ): - await pool.start("ws-fail", Path("/tmp/ws-fail")) - - # Port must be released even though start failed - assert pool._ports.available == 10 - - -# --------------------------------------------------------------------------- -# Environment variable injection -# --------------------------------------------------------------------------- - - -async def test_start_injects_env_vars(pool: WorkspaceProcessPool): - """When env_vars are provided, they must be merged with os.environ.""" - mock_proc = _make_mock_subprocess() - mock_httpx = _make_mock_httpx_healthy() - - env_vars = {"GH_TOKEN": "ghp_test123", "CLIFF_REPO_URL": "https://github.com/org/repo"} - - with ( - patch( - "cliff.engine.pool.asyncio.create_subprocess_exec", - new=AsyncMock(return_value=mock_proc), - ) as mock_exec, - patch("cliff.engine.pool.httpx.AsyncClient", return_value=mock_httpx), - patch("cliff.engine.pool.os") as mock_os, - ): - mock_os.environ = {"PATH": "/usr/bin", "HOME": "/root"} - await pool.start("ws-env", Path("/tmp/ws-env"), env_vars=env_vars) - - call_kwargs = mock_exec.call_args - passed_env = call_kwargs.kwargs.get("env") - assert passed_env is not None - assert passed_env["GH_TOKEN"] == "ghp_test123" - assert passed_env["CLIFF_REPO_URL"] == "https://github.com/org/repo" - # System env should also be present - assert passed_env["PATH"] == "/usr/bin" - - -async def test_start_without_env_vars_injects_git_ceiling( - pool: WorkspaceProcessPool, -): - """Even with no caller env_vars, the workspace-isolation guard - ``GIT_CEILING_DIRECTORIES`` is always injected (set to the workspace - dir) so the env passed to the subprocess is never None.""" - mock_proc = _make_mock_subprocess() - mock_httpx = _make_mock_httpx_healthy() - - with ( - patch( - "cliff.engine.pool.asyncio.create_subprocess_exec", - new=AsyncMock(return_value=mock_proc), - ) as mock_exec, - patch("cliff.engine.pool.httpx.AsyncClient", return_value=mock_httpx), - ): - await pool.start("ws-noenv", Path("/tmp/ws-noenv")) - - passed_env = mock_exec.call_args.kwargs.get("env") - assert passed_env is not None - assert passed_env["GIT_CEILING_DIRECTORIES"] == "/tmp/ws-noenv" - - -async def test_get_or_start_threads_env_vars(pool: WorkspaceProcessPool): - """get_or_start must forward env_vars to start when creating a new process.""" - mock_proc = _make_mock_subprocess() - mock_httpx = _make_mock_httpx_healthy() - - env_vars = {"GH_TOKEN": "ghp_thread_test"} - - with ( - patch( - "cliff.engine.pool.asyncio.create_subprocess_exec", - new=AsyncMock(return_value=mock_proc), - ) as mock_exec, - patch("cliff.engine.pool.httpx.AsyncClient", return_value=mock_httpx), - patch("cliff.engine.pool.os") as mock_os, - ): - mock_os.environ = {"PATH": "/usr/bin"} - await pool.get_or_start("ws-thread", Path("/tmp/ws-thread"), env_vars=env_vars) - - call_kwargs = mock_exec.call_args - passed_env = call_kwargs.kwargs.get("env") - assert passed_env is not None - assert passed_env["GH_TOKEN"] == "ghp_thread_test" - - -async def test_empty_env_vars_still_injects_git_ceiling( - pool: WorkspaceProcessPool, -): - """An empty env_vars dict still gets the GIT_CEILING_DIRECTORIES guard — - the isolation guard is never optional, regardless of caller input.""" - mock_proc = _make_mock_subprocess() - mock_httpx = _make_mock_httpx_healthy() - - with ( - patch( - "cliff.engine.pool.asyncio.create_subprocess_exec", - new=AsyncMock(return_value=mock_proc), - ) as mock_exec, - patch("cliff.engine.pool.httpx.AsyncClient", return_value=mock_httpx), - ): - await pool.start("ws-empty-env", Path("/tmp/ws-empty-env"), env_vars={}) - - passed_env = mock_exec.call_args.kwargs.get("env") - assert passed_env is not None - assert passed_env["GIT_CEILING_DIRECTORIES"] == "/tmp/ws-empty-env" - - -async def test_start_injects_npm_cache( - pool: WorkspaceProcessPool, tmp_path: Path -): - """Each workspace gets ``NPM_CONFIG_CACHE=/.npm-cache`` - so concurrent ``npm install`` invocations don't contend on ~/.npm - (EF-B15). The cache dir is created on disk too.""" - mock_proc = _make_mock_subprocess() - mock_httpx = _make_mock_httpx_healthy() - - ws_dir = tmp_path / "ws-npm" - ws_dir.mkdir() - - with ( - patch( - "cliff.engine.pool.asyncio.create_subprocess_exec", - new=AsyncMock(return_value=mock_proc), - ) as mock_exec, - patch("cliff.engine.pool.httpx.AsyncClient", return_value=mock_httpx), - ): - await pool.start("ws-npm", ws_dir) - - passed_env = mock_exec.call_args.kwargs.get("env") - assert passed_env is not None - assert passed_env["NPM_CONFIG_CACHE"] == str(ws_dir / ".npm-cache") - assert (ws_dir / ".npm-cache").is_dir() - - -# --------------------------------------------------------------------------- -# opencode.json model reconciliation (QA Q01 B06b) -# --------------------------------------------------------------------------- - - -async def test_start_reconciles_opencode_model(tmp_path: Path): - """The pool rewrites the workspace's opencode.json `model` from the - model_resolver before spawn. Without it OpenCode falls back to a - built-in default that routes through the wrong provider and 401s.""" - ws_dir = tmp_path / "ws-model" - ws_dir.mkdir() - (ws_dir / "opencode.json").write_text( - '{"$schema": "https://opencode.ai/config.json", ' - '"permission": {"bash": "ask"}}' - ) - - pool = WorkspaceProcessPool( - port_allocator=PortAllocator(start=5100, end=5109), - host="127.0.0.1", - model_resolver=AsyncMock(return_value="anthropic/claude-sonnet-4-6"), - ) - mock_proc = _make_mock_subprocess() - mock_httpx = _make_mock_httpx_healthy() - - with ( - patch( - "cliff.engine.pool.asyncio.create_subprocess_exec", - new=AsyncMock(return_value=mock_proc), - ), - patch("cliff.engine.pool.httpx.AsyncClient", return_value=mock_httpx), - ): - await pool.start("ws-model", ws_dir) - - config = json.loads((ws_dir / "opencode.json").read_text()) - assert config["model"] == "anthropic/claude-sonnet-4-6" - # Existing keys are preserved. - assert config["permission"] == {"bash": "ask"} - - -async def test_start_without_model_resolver_leaves_opencode_json_untouched( - tmp_path: Path, -): - """No model_resolver wired → the pool must not touch opencode.json.""" - ws_dir = tmp_path / "ws-nomodel" - ws_dir.mkdir() - original = '{"permission": {"bash": "ask"}}' - (ws_dir / "opencode.json").write_text(original) - - pool = WorkspaceProcessPool( - port_allocator=PortAllocator(start=5100, end=5109), - host="127.0.0.1", - ) - mock_proc = _make_mock_subprocess() - mock_httpx = _make_mock_httpx_healthy() - - with ( - patch( - "cliff.engine.pool.asyncio.create_subprocess_exec", - new=AsyncMock(return_value=mock_proc), - ), - patch("cliff.engine.pool.httpx.AsyncClient", return_value=mock_httpx), - ): - await pool.start("ws-nomodel", ws_dir) - - assert (ws_dir / "opencode.json").read_text() == original - - -async def test_start_model_resolver_returning_none_leaves_untouched( - tmp_path: Path, -): - """When no AI provider is configured the resolver returns None — the - pool leaves opencode.json alone rather than writing `model: null`.""" - ws_dir = tmp_path / "ws-modelnone" - ws_dir.mkdir() - original = '{"permission": {"bash": "ask"}}' - (ws_dir / "opencode.json").write_text(original) - - pool = WorkspaceProcessPool( - port_allocator=PortAllocator(start=5100, end=5109), - host="127.0.0.1", - model_resolver=AsyncMock(return_value=None), - ) - mock_proc = _make_mock_subprocess() - mock_httpx = _make_mock_httpx_healthy() - - with ( - patch( - "cliff.engine.pool.asyncio.create_subprocess_exec", - new=AsyncMock(return_value=mock_proc), - ), - patch("cliff.engine.pool.httpx.AsyncClient", return_value=mock_httpx), - ): - await pool.start("ws-modelnone", ws_dir) - - assert (ws_dir / "opencode.json").read_text() == original - - -# --------------------------------------------------------------------------- -# Host AI-provider env var scrubbing (QA Q01 B07) -# --------------------------------------------------------------------------- - - -async def test_start_scrubs_host_ai_provider_env_vars(pool: WorkspaceProcessPool): - """A polluted host environment (e.g. Claude Desktop exports - ANTHROPIC_BASE_URL without /v1, plus an empty ANTHROPIC_API_KEY) must - not leak into the workspace subprocess. The resolver's values win.""" - mock_proc = _make_mock_subprocess() - mock_httpx = _make_mock_httpx_healthy() - - with ( - patch( - "cliff.engine.pool.asyncio.create_subprocess_exec", - new=AsyncMock(return_value=mock_proc), - ) as mock_exec, - patch("cliff.engine.pool.httpx.AsyncClient", return_value=mock_httpx), - patch("cliff.engine.pool.os") as mock_os, - ): - mock_os.environ = { - "PATH": "/usr/bin", - "ANTHROPIC_BASE_URL": "https://api.anthropic.com", - "ANTHROPIC_API_KEY": "", # empty host value — must not shadow - "OPENAI_BASE_URL": "https://evil.example", - } - await pool.start( - "ws-scrub", - Path("/tmp/ws-scrub"), - env_vars={"ANTHROPIC_API_KEY": "sk-ant-real"}, - ) - - passed_env = mock_exec.call_args.kwargs.get("env") - # Host AI-provider pollution scrubbed. - assert "ANTHROPIC_BASE_URL" not in passed_env - assert "OPENAI_BASE_URL" not in passed_env - # Resolver/caller value layered back on; non-AI host env preserved. - assert passed_env["ANTHROPIC_API_KEY"] == "sk-ant-real" - assert passed_env["PATH"] == "/usr/bin" - - -async def test_start_keeps_resolver_supplied_base_url( - pool: WorkspaceProcessPool, -): - """A *_BASE_URL the resolver/caller explicitly supplies (BYOK custom - endpoint) survives — only host-inherited ones are scrubbed.""" - mock_proc = _make_mock_subprocess() - mock_httpx = _make_mock_httpx_healthy() - - with ( - patch( - "cliff.engine.pool.asyncio.create_subprocess_exec", - new=AsyncMock(return_value=mock_proc), - ) as mock_exec, - patch("cliff.engine.pool.httpx.AsyncClient", return_value=mock_httpx), - patch("cliff.engine.pool.os") as mock_os, - ): - mock_os.environ = { - "PATH": "/usr/bin", - "ANTHROPIC_BASE_URL": "https://api.anthropic.com", - } - await pool.start( - "ws-byok-url", - Path("/tmp/ws-byok-url"), - env_vars={ - "ANTHROPIC_API_KEY": "sk-ant-real", - "ANTHROPIC_BASE_URL": "https://proxy.internal/v1", - }, - ) - - passed_env = mock_exec.call_args.kwargs.get("env") - assert passed_env["ANTHROPIC_BASE_URL"] == "https://proxy.internal/v1" - - -# --------------------------------------------------------------------------- -# Status -# --------------------------------------------------------------------------- - - -async def test_status(pool: WorkspaceProcessPool): - mock_proc = _make_mock_subprocess() - mock_httpx = _make_mock_httpx_healthy() - - with ( - patch( - "cliff.engine.pool.asyncio.create_subprocess_exec", - new=AsyncMock(return_value=mock_proc), - ), - patch("cliff.engine.pool.httpx.AsyncClient", return_value=mock_httpx), - ): - await pool.start("ws-1", Path("/tmp/ws-1")) - - status = pool.status() - assert status["active_processes"] == 1 - assert status["available_ports"] == 9 - assert "ws-1" in status["workspaces"] - assert status["workspaces"]["ws-1"]["port"] == 5100 - - -# --------------------------------------------------------------------------- -# stop_on_completion — repo-action cleanup trigger (IMPL-0002 E4) -# --------------------------------------------------------------------------- - - -async def test_stop_on_completion_archives_and_releases_port( - pool: WorkspaceProcessPool, tmp_path: Path -): - """Stops the subprocess, releases the port, tars the workspace, removes it.""" - ws_id = "repo-security-md-abcd1234" - ws_dir = tmp_path / ws_id - (ws_dir / ".opencode" / "agents").mkdir(parents=True) - (ws_dir / "opencode.json").write_text("{}") - (ws_dir / "REPO_ACTION.md").write_text("stub") - - mock_proc = _make_mock_subprocess() - mock_httpx = _make_mock_httpx_healthy() - - with ( - patch( - "cliff.engine.pool.asyncio.create_subprocess_exec", - new=AsyncMock(return_value=mock_proc), - ), - patch("cliff.engine.pool.httpx.AsyncClient", return_value=mock_httpx), - ): - await pool.start(ws_id, ws_dir) - - assert pool._ports.available == 9 - mock_proc.returncode = None # still running until we call stop - - archive_path = await pool.stop_on_completion(ws_id) - - # Process terminated + port freed. - mock_proc.terminate.assert_called_once() - assert pool._ports.available == 10 - assert await pool.get(ws_id) is None - - assert archive_path is not None - assert archive_path.exists() - assert archive_path.name == f"{ws_id}.tar.gz" - assert not ws_dir.exists() - - -async def test_stop_on_completion_unknown_workspace_is_noop( - pool: WorkspaceProcessPool, -): - """Calling stop_on_completion on a workspace we never started must not raise.""" - result = await pool.stop_on_completion("never-started") - assert result is None - assert pool._ports.available == 10 - - -def test_archive_and_remove_is_atomic_on_failure(tmp_path: Path): - """A failure mid-archive must leave no partial .tar.gz at the dest path.""" - from cliff.engine.pool import _archive_and_remove - - src = tmp_path / "ws-atomic" - src.mkdir() - (src / "file.txt").write_text("payload") - dest = tmp_path / "ws-atomic.tar.gz" - - class _BoomError(RuntimeError): - pass - - with ( - patch("cliff.engine.pool.tarfile.open", side_effect=_BoomError("tar exploded")), - pytest.raises(_BoomError), - ): - _archive_and_remove(src, dest, "ws-atomic") - - assert not dest.exists(), "Failed archive run left a partial tarball behind" - assert not dest.with_name(dest.name + ".tmp").exists(), ( - "Temp archive not cleaned up on failure" - ) - # Source dir must survive — operator can retry or inspect. - assert src.exists() diff --git a/backend/tests/test_repo_action_templates.py b/backend/tests/test_repo_action_templates.py deleted file mode 100644 index 7103061b..00000000 --- a/backend/tests/test_repo_action_templates.py +++ /dev/null @@ -1,204 +0,0 @@ -"""Unit tests for repo-action agent templates (IMPL-0002 E1, E2). - -These are template-rendering tests — no LLM calls, no OpenCode binary, no -subprocess. They verify the Jinja2 templates for ``security_md_generator`` -and ``dependabot_config_generator`` render the expected prompt shape so -the downstream single-shot agent (ADR-0024) knows what to do. -""" - -from __future__ import annotations - -import re - -import pytest - -from cliff.agents.template_engine import AgentTemplateEngine -from cliff.workspace.workspace_dir_manager import WorkspaceKind - - -@pytest.fixture -def engine() -> AgentTemplateEngine: - return AgentTemplateEngine() - - -def _assert_never_writes_host_git_config(content: str) -> None: - """Templates must NEVER run ``git config --global`` (or ``--system``). - - Those scopes always write the operator's host config and cannot fail - closed, so a dropped env var or a reordered/retried step would silently - pollute ``~/.gitconfig`` — injecting an expired ``x-access-token`` rewrite - and the ``Cliff Posture Bot`` identity, which then breaks the operator's - own ``git push``. Instead, clone auth is carried by a token-embedded clone - URL (confined to the throwaway ``repo/.git/config``) and commit identity is - set with ``git config --local`` (which errors out when not inside a repo). - - Regression guard for the host-gitconfig-pollution bug. - """ - assert "git config --global" not in content, ( - "templates must not run `git config --global` — it always writes the " - "operator's host ~/.gitconfig and cannot fail closed" - ) - assert "git config --system" not in content, ( - "templates must not run `git config --system`" - ) - - -class TestSecurityMdGenerator: - """Rendering contract for the SECURITY.md generator template.""" - - def test_renders_template_with_repo_url(self, engine: AgentTemplateEngine) -> None: - rendered = engine.render_repo_action( - WorkspaceKind.repo_action_security_md, - repo_url="https://github.com/acme/widget", - params={"contact_email": "security@acme.example"}, - gh_token="ghp_fake_token_for_render_test", - ) - - assert rendered.name == "security_md_generator" - assert rendered.filename == "security_md_generator.md" - content = rendered.content - - # Repo URL is substituted so the agent knows what to clone. - assert "https://github.com/acme/widget" in content - - # Branch name convention for zero-to-secure posture PRs. - assert "cliff/posture/security-md" in content - - # Draft-PR-only per ADR-0024. - assert "gh pr create --draft" in content - - # When gh_token is provided, the git-config line referencing $GH_TOKEN - # from the workspace env is emitted — but the literal token value must - # never appear in the rendered prompt (it would otherwise reach the LLM). - assert "x-access-token:${GH_TOKEN}" in content - assert "ghp_fake_token_for_render_test" not in content - - # Must never touch the operator's host ~/.gitconfig. - _assert_never_writes_host_git_config(content) - assert "git config --local user.name" in content - - # Must include the SECURITY.md target path instruction. - assert "SECURITY.md" in content - - # Must tell the agent how to handle an existing SECURITY.md. - assert re.search(r"already\s+exists|if\s+SECURITY\.md", content, re.IGNORECASE), ( - "Template must instruct agent on handling an existing SECURITY.md" - ) - - # The structured JSON output contract is present. - assert "structured_output" in content - assert '"pr_url"' in content - assert '"status"' in content - - def test_contact_email_substituted(self, engine: AgentTemplateEngine) -> None: - rendered = engine.render_repo_action( - WorkspaceKind.repo_action_security_md, - repo_url="https://github.com/acme/widget", - params={"contact_email": "ciso@example.org"}, - ) - assert "ciso@example.org" in rendered.content - - def test_renders_without_gh_token(self, engine: AgentTemplateEngine) -> None: - """When no token is supplied, the whole git-config block is elided.""" - rendered = engine.render_repo_action( - WorkspaceKind.repo_action_security_md, - repo_url="https://github.com/acme/widget", - params={}, - ) - assert "x-access-token" not in rendered.content - assert "GH_TOKEN" not in rendered.content - - -class TestDependabotConfigGenerator: - """Rendering contract for the dependabot.yml generator template.""" - - def test_renders_template_with_repo_url(self, engine: AgentTemplateEngine) -> None: - rendered = engine.render_repo_action( - WorkspaceKind.repo_action_dependabot, - repo_url="https://github.com/acme/widget", - params={}, - gh_token="ghp_dependabot_token", - ) - - assert rendered.name == "dependabot_config_generator" - content = rendered.content - - assert "https://github.com/acme/widget" in content - assert "cliff/posture/dependabot" in content - assert "gh pr create --draft" in content - assert ".github/dependabot.yml" in content - - # Token value must never appear in the rendered prompt. - assert "ghp_dependabot_token" not in content - assert "x-access-token:${GH_TOKEN}" in content - - # Must never touch the operator's host ~/.gitconfig. - _assert_never_writes_host_git_config(content) - assert "git config --local user.name" in content - - # Ecosystem detection instruction is the distinctive part of this template. - for manifest in [ - "package-lock.json", - "requirements.txt", - "go.mod", - "Gemfile.lock", - "Cargo.toml", - "pom.xml", - "composer.json", - ]: - assert manifest in content, f"Ecosystem manifest {manifest} missing" - - # Weekly schedule + PR limit are part of the rendered config shape. - assert re.search(r"schedule.*weekly", content, re.IGNORECASE | re.DOTALL) - assert re.search(r"open-pull-requests-limit", content) - - # Handle existing config gracefully. - assert re.search( - r"already\s+exists|if\s+\.github/dependabot\.yml|existing\s+dependabot", - content, - re.IGNORECASE, - ), "Template must instruct agent on handling an existing dependabot.yml" - - assert "structured_output" in content - - def test_invalid_kind_raises( - self, engine: AgentTemplateEngine, monkeypatch: pytest.MonkeyPatch - ) -> None: - """A ``WorkspaceKind`` value without a registered template is rejected.""" - from cliff.agents import template_engine as te - - monkeypatch.setattr(te, "REPO_ACTION_TEMPLATES", {}) - with pytest.raises(ValueError, match="not a repo-action"): - engine.render_repo_action( - WorkspaceKind.repo_action_security_md, - repo_url="https://github.com/acme/widget", - params={}, - ) - - -class TestCloningAgentsNeverWriteHostGitConfig: - """The other two cloning templates aren't repo-actions (they go through - ``render_agent``), but they run git just the same — the executor even - pushes commits. Guard them against host-gitconfig writes too, so a - regression in either one fails the suite. - """ - - @pytest.mark.parametrize("agent_name", ["remediation_executor", "evidence_collector"]) - def test_no_host_git_config_writes( - self, engine: AgentTemplateEngine, agent_name: str - ) -> None: - rendered = engine.render_agent( - agent_name, - finding={"title": "Test finding", "source_id": "CVE-2024-0001"}, - gh_token="ghp_fake_token_for_render_test", - repo_url="https://github.com/acme/widget", - ) - _assert_never_writes_host_git_config(rendered.content) - # Authenticated clone is carried by the $GH_TOKEN shell var (injected into - # the workspace env), not a config write... - assert "x-access-token:${GH_TOKEN}@" in rendered.content - # ...and the literal token value must never be echoed into the prompt. - assert "ghp_fake_token_for_render_test" not in rendered.content - # Clone must be verified before anything runs against repo/ — a failed - # clone otherwise leaves later steps running from the wrong directory. - assert "test -d repo/.git" in rendered.content diff --git a/backend/tests/test_repo_workspace_runner.py b/backend/tests/test_repo_workspace_runner.py index f9765f1e..3dda386d 100644 --- a/backend/tests/test_repo_workspace_runner.py +++ b/backend/tests/test_repo_workspace_runner.py @@ -1,88 +1,69 @@ """Unit tests for RepoAgentRunner — focused on the B16 PR-URL guardrail. -The runner is non-raising by contract: every bad outcome (parse failure, GH +The runner is non-raising by contract: every bad outcome (model error, GH 404, hallucinated URL) collapses to a ``RepoAgentStatus(status="failed")`` -row persisted to disk. These tests drive a fake OpenCode client + a fake -``verify_pr_url`` (via monkeypatch) to exercise each branch without spinning -up a real process pool. +row persisted to disk. These tests drive the repo-action agent with a +``FunctionModel`` (no live LLM, no tool calls) and a fake ``verify_pr_url`` +(via monkeypatch) to exercise each branch. """ from __future__ import annotations -import json from typing import TYPE_CHECKING, Any +from unittest.mock import AsyncMock import pytest +from pydantic_ai.messages import ModelResponse, ToolCallPart +from pydantic_ai.models.function import AgentInfo, FunctionModel from cliff.services.pr_verifier import PRVerification from cliff.workspace import repo_workspace_runner -from cliff.workspace.repo_workspace_runner import ( - RepoAgentRunner, - read_status, -) +from cliff.workspace.repo_workspace_runner import RepoAgentRunner, read_status from cliff.workspace.workspace_dir_manager import WorkspaceKind if TYPE_CHECKING: from pathlib import Path -class _FakeClient: - def __init__(self, response_text: str) -> None: - self._response_text = response_text +def _model_returning(output: dict[str, Any]) -> FunctionModel: + """A FunctionModel that returns *output* as the agent's structured result + in one turn (no tool calls).""" - async def create_session(self) -> Any: # noqa: D401 - class _S: - id = "sess-1" + def _fn(messages, info: AgentInfo) -> ModelResponse: + tool_name = info.output_tools[0].name # 'final_result' + return ModelResponse(parts=[ToolCallPart(tool_name=tool_name, args=output)]) - return _S() + return FunctionModel(_fn) - async def send_message(self, session_id: str, prompt: str) -> None: # noqa: ARG002 - return None - async def stream_events(self, session_id: str): # noqa: ARG002 - yield {"type": "text", "content": self._response_text} - yield {"type": "done"} - - -class _FakePool: - def __init__(self, client: _FakeClient) -> None: - self._client = client - self.stopped: list[str] = [] +def _build_runner() -> RepoAgentRunner: + return RepoAgentRunner( + env_resolver=AsyncMock(return_value={"OPENAI_API_KEY": "k"}), + model_resolver=AsyncMock(return_value="openai/gpt-4o-mini"), + ) - async def get_or_start( - self, - workspace_id: str, # noqa: ARG002 - workspace_root: Path, # noqa: ARG002 - env_vars: dict[str, str] | None = None, # noqa: ARG002 - ) -> _FakeClient: - return self._client - async def stop(self, workspace_id: str) -> None: - self.stopped.append(workspace_id) +def _patch_model(monkeypatch: pytest.MonkeyPatch, model: FunctionModel) -> None: + monkeypatch.setattr( + repo_workspace_runner, "build_model", lambda *_a, **_k: model + ) def _scaffold_workspace(tmp_path: Path) -> Path: - """Create the minimal directory layout the runner expects.""" root = tmp_path / "ws-test" (root / "history").mkdir(parents=True) return root -def _agent_response(pr_url: str | None) -> str: - payload = { +def _pr_output(pr_url: str | None) -> dict[str, Any]: + return { + "status": "pr_created", + "pr_url": pr_url, + "branch_name": "cliff/posture/security-md", + "file_path": "SECURITY.md", "summary": "wrote SECURITY.md and opened PR", - "confidence": 0.9, - "result_card_markdown": "## ok", - "evidence_sources": [], - "suggested_next_action": "review_pr", - "structured_output": { - "status": "pr_created", - "pr_url": pr_url, - "branch_name": "cliff/add-security-md", - "file_path": "SECURITY.md", - }, + "result_card_markdown": "## SECURITY.md PR\n\nBranch pushed, PR opened.", } - return "```json\n" + json.dumps(payload) + "\n```" @pytest.mark.asyncio @@ -90,22 +71,18 @@ async def test_run_verifies_pr_url_and_succeeds( tmp_path: Path, monkeypatch: pytest.MonkeyPatch ) -> None: workspace_root = _scaffold_workspace(tmp_path) - pool = _FakePool( - _FakeClient(_agent_response("https://github.com/acme/repo/pull/12")) + _patch_model( + monkeypatch, + _model_returning(_pr_output("https://github.com/acme/repo/pull/12")), ) async def _fake_verify(url: str | None, **_: Any) -> PRVerification: assert url == "https://github.com/acme/repo/pull/12" - return PRVerification( - ok=True, - reason="verified", - pr_state="open", - html_url=url, - ) + return PRVerification(ok=True, reason="verified", pr_state="open", html_url=url) monkeypatch.setattr(repo_workspace_runner, "verify_pr_url", _fake_verify) - runner = RepoAgentRunner(pool) # type: ignore[arg-type] + runner = _build_runner() result = await runner.run( workspace_id="ws-test", workspace_root=workspace_root, @@ -126,22 +103,20 @@ async def _fake_verify(url: str | None, **_: Any) -> PRVerification: async def test_run_flags_hallucinated_pr_url_as_failed( tmp_path: Path, monkeypatch: pytest.MonkeyPatch ) -> None: - """B16 regression: verifier says 404 -> status=failed, log tail preserved.""" + """B16 regression: verifier says 404 -> status=failed, diagnostics preserved.""" workspace_root = _scaffold_workspace(tmp_path) - # The agent's claim — a plausibly-shaped URL that doesn't resolve. hallucinated = "https://github.com/acme/repo/pull/999" - pool = _FakePool(_FakeClient(_agent_response(hallucinated))) + _patch_model(monkeypatch, _model_returning(_pr_output(hallucinated))) async def _fake_verify(url: str | None, **_: Any) -> PRVerification: assert url == hallucinated return PRVerification( - ok=False, - reason="not_found: GitHub returned 404 for this pull request", + ok=False, reason="not_found: GitHub returned 404 for this pull request" ) monkeypatch.setattr(repo_workspace_runner, "verify_pr_url", _fake_verify) - runner = RepoAgentRunner(pool) # type: ignore[arg-type] + runner = _build_runner() result = await runner.run( workspace_id="ws-test", workspace_root=workspace_root, @@ -154,37 +129,31 @@ async def _fake_verify(url: str | None, **_: Any) -> PRVerification: assert result.pr_url is None assert "PR verification failed" in (result.error or "") assert "not_found" in (result.error or "") - # B16 also requires surfacing the agent's own log so the user can see - # whether a branch was actually pushed. + # The agent's result card is surfaced as the log tail for the UI. assert result.agent_log_tail is not None - assert "pr_created" in result.agent_log_tail # JSON payload preserved. - # Agent-response file should also be on disk for deeper inspection. + assert "SECURITY.md PR" in result.agent_log_tail + # Full transcript also persisted for deeper inspection. assert (workspace_root / "history" / "agent-response.txt").is_file() @pytest.mark.asyncio -async def test_run_flags_compare_page_without_hitting_network( +async def test_run_flags_compare_page_url_as_failed( tmp_path: Path, monkeypatch: pytest.MonkeyPatch ) -> None: - """A malformed URL never reaches GitHub — the parser rejects it first.""" + """A compare-page URL is rejected by the verifier (status=failed).""" workspace_root = _scaffold_workspace(tmp_path) - # Compare-page URL the agent has emitted in real dogfooding runs. fake_url = "https://github.com/acme/repo/pull/new/cliff-fix" - pool = _FakePool(_FakeClient(_agent_response(fake_url))) + _patch_model(monkeypatch, _model_returning(_pr_output(fake_url))) calls = {"n": 0} async def _counting_verify(url: str | None, **_: Any) -> PRVerification: calls["n"] += 1 - # The real verifier returns not_a_pull_url without doing I/O for - # this URL shape — we mimic that behaviour here. return PRVerification(ok=False, reason=f"not_a_pull_url: {url!r}") - monkeypatch.setattr( - repo_workspace_runner, "verify_pr_url", _counting_verify - ) + monkeypatch.setattr(repo_workspace_runner, "verify_pr_url", _counting_verify) - runner = RepoAgentRunner(pool) # type: ignore[arg-type] + runner = _build_runner() result = await runner.run( workspace_id="ws-test", workspace_root=workspace_root, @@ -196,3 +165,51 @@ async def _counting_verify(url: str | None, **_: Any) -> PRVerification: assert result.status == "failed" assert "not_a_pull_url" in (result.error or "") assert calls["n"] == 1 + + +@pytest.mark.asyncio +async def test_run_already_present_skips_pr( + tmp_path: Path, monkeypatch: pytest.MonkeyPatch +) -> None: + """An ``already_present`` result is terminal and opens no PR.""" + workspace_root = _scaffold_workspace(tmp_path) + _patch_model( + monkeypatch, + _model_returning( + {"status": "already_present", "file_path": "SECURITY.md"} + ), + ) + + verify = AsyncMock() + monkeypatch.setattr(repo_workspace_runner, "verify_pr_url", verify) + + runner = _build_runner() + result = await runner.run( + workspace_id="ws-test", + workspace_root=workspace_root, + kind=WorkspaceKind.repo_action_security_md, + repo_url="https://github.com/acme/repo", + gh_token="ghp_x", + ) + + assert result.status == "already_present" + verify.assert_not_called() + + +@pytest.mark.asyncio +async def test_run_unconfigured_model_fails_gracefully(tmp_path: Path) -> None: + """No active model -> status=failed, never raises.""" + workspace_root = _scaffold_workspace(tmp_path) + runner = RepoAgentRunner( + env_resolver=AsyncMock(return_value={}), + model_resolver=AsyncMock(return_value=None), + ) + result = await runner.run( + workspace_id="ws-test", + workspace_root=workspace_root, + kind=WorkspaceKind.repo_action_security_md, + repo_url="https://github.com/acme/repo", + gh_token="ghp_x", + ) + assert result.status == "failed" + assert "AI provider not configured" in (result.error or "") diff --git a/backend/tests/test_repo_workspace_spawner.py b/backend/tests/test_repo_workspace_spawner.py index 5739a5ab..d4bc3621 100644 --- a/backend/tests/test_repo_workspace_spawner.py +++ b/backend/tests/test_repo_workspace_spawner.py @@ -9,6 +9,7 @@ from __future__ import annotations from typing import TYPE_CHECKING +from unittest.mock import AsyncMock import aiosqlite import pytest @@ -22,6 +23,26 @@ from pathlib import Path +def _spawner() -> _DefaultRepoWorkspaceSpawner: + """A spawner with stub AI resolvers — these tests exercise the + filesystem + DB scaffolding, not the (background) agent run, which the + autouse fixture below neutralizes.""" + return _DefaultRepoWorkspaceSpawner( + env_resolver=AsyncMock(return_value={}), + model_resolver=AsyncMock(return_value=None), + ) + + +@pytest.fixture(autouse=True) +def _no_background_agent(monkeypatch): + """Stop the spawner's fire-and-forget ``RepoAgentRunner.run`` from racing + these scaffolding assertions (it would flip ``workspace.state``).""" + monkeypatch.setattr( + "cliff.workspace.repo_workspace_runner.RepoAgentRunner.run", + AsyncMock(return_value=None), + ) + + @pytest.fixture async def db(tmp_path: Path, monkeypatch): conn = await init_db(":memory:") @@ -35,7 +56,7 @@ async def db(tmp_path: Path, monkeypatch): async def test_spawner_inserts_workspace_row(db: aiosqlite.Connection) -> None: - spawner = _DefaultRepoWorkspaceSpawner(pool=None) + spawner = _spawner() workspace_id = await spawner.spawn_repo_workspace( kind=WorkspaceKind.repo_action_security_md, @@ -61,7 +82,7 @@ async def test_spawner_inserts_workspace_row(db: aiosqlite.Connection) -> None: async def test_spawner_row_visible_via_dao(db: aiosqlite.Connection) -> None: - spawner = _DefaultRepoWorkspaceSpawner(pool=None) + spawner = _spawner() workspace_id = await spawner.spawn_repo_workspace( kind=WorkspaceKind.repo_action_dependabot, repo_url="https://github.com/acme/widget", @@ -82,7 +103,7 @@ async def test_spawner_collision_raises_integrity_error( same check. The spawner propagates the IntegrityError so the route can turn it into a 409. """ - spawner = _DefaultRepoWorkspaceSpawner(pool=None) + spawner = _spawner() await spawner.spawn_repo_workspace( kind=WorkspaceKind.repo_action_security_md, @@ -108,7 +129,7 @@ async def test_runner_finalize_releases_partial_index( """ from cliff.db.repo_workspace import set_workspace_state - spawner = _DefaultRepoWorkspaceSpawner(pool=None) + spawner = _spawner() first = await spawner.spawn_repo_workspace( kind=WorkspaceKind.repo_action_security_md, repo_url="https://github.com/acme/widget", diff --git a/backend/tests/test_routes_ai_integrations.py b/backend/tests/test_routes_ai_integrations.py index a07952f7..02f6adf2 100644 --- a/backend/tests/test_routes_ai_integrations.py +++ b/backend/tests/test_routes_ai_integrations.py @@ -25,25 +25,6 @@ async def log(self, event) -> None: self.events.append(event) -@pytest.fixture(autouse=True) -def _stub_opencode_auth_sync(monkeypatch): - """Don't try to talk to a real OpenCode in route tests. - - ``AIIntegrationService._sync_opencode_auth`` PUTs the key into - OpenCode's auth.json on every save; ``_live_probe`` (ADR-0037) GETs - ``/config`` on every status read. Both no-op here so pytest-httpx - doesn't intercept them as unmatched requests. - """ - from unittest.mock import AsyncMock - - from cliff.engine.client import opencode_client - - monkeypatch.setattr(opencode_client, "set_auth", AsyncMock(return_value=True)) - monkeypatch.setattr( - opencode_client, "get_config", AsyncMock(return_value={}) - ) - - @pytest.fixture async def ai_client(monkeypatch, tmp_path): """An HTTP client wired with a real vault + stub audit logger. diff --git a/backend/tests/test_routes_ai_openrouter.py b/backend/tests/test_routes_ai_openrouter.py index 61bc480f..a2b6e37a 100644 --- a/backend/tests/test_routes_ai_openrouter.py +++ b/backend/tests/test_routes_ai_openrouter.py @@ -14,21 +14,6 @@ from cliff.integrations.vault import CredentialVault -@pytest.fixture(autouse=True) -def _stub_opencode_auth_sync(monkeypatch): - """Stub opencode_client.set_auth + get_config so the OpenCode auth.json - sync (set_auth) and the live-probe (get_config, ADR-0037) don't try to - hit a real 127.0.0.1:4096 inside the OAuth route tests.""" - from unittest.mock import AsyncMock - - from cliff.engine.client import opencode_client - - monkeypatch.setattr(opencode_client, "set_auth", AsyncMock(return_value=True)) - monkeypatch.setattr( - opencode_client, "get_config", AsyncMock(return_value={}) - ) - - @pytest.fixture def non_mocked_hosts() -> list[str]: """Let httpx requests to the local OAuth callback bypass pytest-httpx.""" diff --git a/backend/tests/test_routes_health.py b/backend/tests/test_routes_health.py index 716e1153..41b49bd4 100644 --- a/backend/tests/test_routes_health.py +++ b/backend/tests/test_routes_health.py @@ -2,24 +2,17 @@ from __future__ import annotations -from unittest.mock import AsyncMock - -def test_health_opencode_up(client): +def test_health_reports_in_process_substrate(client): + """The substrate runs in-process via Pydantic AI — ``opencode`` is the + kept-for-compat field name and is always "ok"; ``opencode_version`` + carries the PA version string.""" resp = client.get("/health") assert resp.status_code == 200 data = resp.json() assert data["cliff"] == "ok" assert data["opencode"] == "ok" - - -def test_health_opencode_down(client, mock_opencode_process): - mock_opencode_process.health_check = AsyncMock(return_value=False) - resp = client.get("/health") - assert resp.status_code == 200 - data = resp.json() - assert data["cliff"] == "ok" - assert data["opencode"] == "unavailable" + assert data["opencode_version"].startswith("pydantic-ai") def test_health_ai_provider_not_ready_when_env_cache_empty(client): diff --git a/backend/tests/test_routes_settings.py b/backend/tests/test_routes_settings.py index f3afa9bf..693aa975 100644 --- a/backend/tests/test_routes_settings.py +++ b/backend/tests/test_routes_settings.py @@ -6,239 +6,166 @@ import pytest +from cliff.main import app -@pytest.mark.asyncio -async def test_get_model(db_client): - """GET /api/settings/model returns current model config.""" - with patch( - "cliff.engine.config_manager.opencode_client" - ) as mock_client: - mock_client.get_config = AsyncMock( - return_value={"model": "openai/gpt-4.1-nano"} - ) - resp = await db_client.get("/api/settings/model") - assert resp.status_code == 200 - data = resp.json() - assert data["model_full_id"] == "openai/gpt-4.1-nano" - assert data["provider"] == "openai" - assert data["model_id"] == "gpt-4.1-nano" +# --------------------------------------------------------------------------- +# Model (ADR-0037 — canonical AI state, no OpenCode) +# --------------------------------------------------------------------------- @pytest.mark.asyncio -async def test_update_model(db_client, tmp_path): - """PUT /api/settings/model updates the model.""" - with ( - patch( - "cliff.engine.config_manager.opencode_client" - ) as mock_client, - patch( - "cliff.engine.config_manager.settings" - ) as mock_settings, - ): - mock_client.update_config = AsyncMock(return_value={}) - mock_client.get_config = AsyncMock( - return_value={"model": "anthropic/claude-sonnet-4-20250514"} - ) - mock_settings.write_opencode_config = lambda m: None - mock_settings.opencode_model = "anthropic/claude-sonnet-4-20250514" +async def test_get_model_no_provider_returns_empty(db_client): + """GET /api/settings/model with no provider connected → empty config.""" + resp = await db_client.get("/api/settings/model") + assert resp.status_code == 200 + data = resp.json() + assert data["model_full_id"] == "" + assert data["provider"] == "" + assert data["model_id"] == "" - resp = await db_client.put( - "/api/settings/model", - json={"model_full_id": "anthropic/claude-sonnet-4-20250514"}, - ) - assert resp.status_code == 200 - data = resp.json() - assert data["model_full_id"] == "anthropic/claude-sonnet-4-20250514" + +@pytest.mark.asyncio +async def test_get_model_returns_canonical(db_client): + """GET /api/settings/model splits the canonical id into parts.""" + app.state.vault = object() + try: + with patch( + "cliff.ai.service.AIIntegrationService.resolve_model_for_workspace", + AsyncMock(return_value="openai/gpt-4.1-nano"), + ): + resp = await db_client.get("/api/settings/model") + finally: + app.state.vault = None + assert resp.status_code == 200 + data = resp.json() + assert data["model_full_id"] == "openai/gpt-4.1-nano" + assert data["provider"] == "openai" + assert data["model_id"] == "gpt-4.1-nano" @pytest.mark.asyncio -async def test_update_model_invalid_format(db_client): - """PUT /api/settings/model rejects invalid model format.""" +async def test_update_model_requires_vault(db_client): + """PUT /api/settings/model with no credential vault → 503.""" resp = await db_client.put( "/api/settings/model", - json={"model_full_id": "no-slash-here"}, + json={"model_full_id": "anthropic/claude-haiku-4-5"}, ) - assert resp.status_code == 400 - assert "provider/model-id" in resp.json()["detail"] + assert resp.status_code == 503 @pytest.mark.asyncio -async def test_update_model_accepts_provider_and_model_id(db_client): - """PUT /api/settings/model accepts the GET-shape ``{provider, model_id}``. - - Round-tripping the GET response is the most natural API gesture; the body - validator should synthesize ``model_full_id`` from the parts. - """ - with ( - patch("cliff.engine.config_manager.opencode_client") as mock_client, - patch("cliff.engine.config_manager.settings") as mock_settings, - ): - mock_client.update_config = AsyncMock(return_value={}) - mock_client.get_config = AsyncMock( - return_value={"model": "openai/gpt-5-nano"} - ) - mock_settings.write_opencode_config = lambda m: None - mock_settings.opencode_model = "openai/gpt-5-nano" - - resp = await db_client.put( - "/api/settings/model", - json={"provider": "openai", "model_id": "gpt-5-nano"}, - ) - assert resp.status_code == 200, resp.text - data = resp.json() - assert data["model_full_id"] == "openai/gpt-5-nano" - assert data["provider"] == "openai" - assert data["model_id"] == "gpt-5-nano" +async def test_update_model_sets_canonical(db_client): + """PUT /api/settings/model routes through set_model and echoes the id.""" + app.state.vault = object() + try: + with patch( + "cliff.ai.service.AIIntegrationService.set_model", + AsyncMock(return_value="anthropic/claude-haiku-4-5"), + ): + resp = await db_client.put( + "/api/settings/model", + json={"model_full_id": "anthropic/claude-haiku-4-5"}, + ) + finally: + app.state.vault = None + assert resp.status_code == 200, resp.text + assert resp.json()["model_full_id"] == "anthropic/claude-haiku-4-5" @pytest.mark.asyncio -async def test_update_model_rejects_empty_body(db_client): - """PUT /api/settings/model with neither shape returns 422.""" - resp = await db_client.put("/api/settings/model", json={}) - assert resp.status_code == 422 - +async def test_update_model_accepts_provider_and_model_id(db_client): + """PUT accepts the GET-shape ``{provider, model_id}`` and synthesizes the id. -@pytest.mark.asyncio -async def test_list_providers(db_client): - """GET /api/settings/providers returns provider list.""" - with patch( - "cliff.engine.config_manager.opencode_client" - ) as mock_client: - mock_client.list_providers = AsyncMock( - return_value={ - "all": [ - {"id": "openai", "name": "OpenAI", "env": ["OPENAI_API_KEY"], "models": {}}, - ] - } - ) - resp = await db_client.get("/api/settings/providers") - assert resp.status_code == 200 - data = resp.json() - assert len(data) == 1 - assert data[0]["id"] == "openai" + Round-tripping the GET response is the most natural API gesture; the body + validator synthesizes ``model_full_id`` from the parts. + """ + app.state.vault = object() + try: + with patch( + "cliff.ai.service.AIIntegrationService.set_model", + AsyncMock(return_value="openai/gpt-5-nano"), + ): + resp = await db_client.put( + "/api/settings/model", + json={"provider": "openai", "model_id": "gpt-5-nano"}, + ) + finally: + app.state.vault = None + assert resp.status_code == 200, resp.text + data = resp.json() + assert data["model_full_id"] == "openai/gpt-5-nano" + assert data["provider"] == "openai" + assert data["model_id"] == "gpt-5-nano" @pytest.mark.asyncio -async def test_set_api_key(db_client): - """PUT /api/settings/api-keys/{provider} stores a masked key.""" - with patch( - "cliff.engine.config_manager.opencode_client" - ) as mock_client: - mock_client.set_auth = AsyncMock(return_value=True) - +async def test_update_model_invalid_format(db_client): + """A model id without a '/' is rejected with 400 (set_model's prefix check).""" + app.state.vault = object() + try: resp = await db_client.put( - "/api/settings/api-keys/openai", - json={"provider": "openai", "key": "sk-test1234567890ab"}, - ) - assert resp.status_code == 200 - data = resp.json() - assert data["provider"] == "openai" - assert data["key_masked"] == "sk-...90ab" - assert data["has_credentials"] is True - # Full key must NOT be in response - assert "sk-test1234567890ab" not in str(data) - - -@pytest.mark.asyncio -async def test_list_api_keys_masked(db_client): - """GET /api/settings/api-keys returns DB-stored keys masked, tagged source=db.""" - with patch( - "cliff.engine.config_manager.opencode_client" - ) as mock_client: - mock_client.set_auth = AsyncMock(return_value=True) - mock_client.get_provider_auth = AsyncMock(return_value={}) - - # Store a key first - await db_client.put( - "/api/settings/api-keys/openai", - json={"provider": "openai", "key": "sk-secret-key-here1"}, + "/api/settings/model", + json={"model_full_id": "no-slash-here"}, ) - - resp = await db_client.get("/api/settings/api-keys") - assert resp.status_code == 200 - data = resp.json() - assert len(data) == 1 - assert data[0]["key_masked"] == "sk-...ere1" - assert data[0]["source"] == "db" - # Full key must NOT be in response - assert "sk-secret-key-here1" not in str(data) + finally: + app.state.vault = None + assert resp.status_code == 400 + assert "provider/model" in resp.json()["detail"] @pytest.mark.asyncio -async def test_list_api_keys_includes_env_sourced(db_client): - """An env-sourced provider (OPENAI_API_KEY in the daemon env) must surface - via /api-keys with source=env so users can tell the system already has a key. - """ - with patch( - "cliff.engine.config_manager.opencode_client" - ) as mock_client: - # No DB-stored keys; OpenCode reports openai is auth'd from env. - mock_client.get_provider_auth = AsyncMock( - return_value={"openai": [{"type": "api"}]} - ) - - resp = await db_client.get("/api/settings/api-keys") - assert resp.status_code == 200 - data = resp.json() - assert len(data) == 1 - assert data[0]["provider"] == "openai" - assert data[0]["source"] == "env" - assert data[0]["key_masked"] is None - assert data[0]["has_credentials"] is True +async def test_update_model_no_active_provider(db_client): + """set_model raising NoActiveProviderError → 400.""" + from cliff.ai.service import NoActiveProviderError + + app.state.vault = object() + try: + with patch( + "cliff.ai.service.AIIntegrationService.set_model", + AsyncMock(side_effect=NoActiveProviderError("no active provider")), + ): + resp = await db_client.put( + "/api/settings/model", + json={"model_full_id": "anthropic/claude-haiku-4-5"}, + ) + finally: + app.state.vault = None + assert resp.status_code == 400 @pytest.mark.asyncio -async def test_list_api_keys_db_overrides_env(db_client): - """If both DB and env have a key for the same provider, DB wins (the user - explicitly stored it, so it takes precedence).""" - with patch( - "cliff.engine.config_manager.opencode_client" - ) as mock_client: - mock_client.set_auth = AsyncMock(return_value=True) - mock_client.get_provider_auth = AsyncMock( - return_value={"openai": [{"type": "api"}]} - ) +async def test_update_model_rejects_empty_body(db_client): + """PUT /api/settings/model with neither shape returns 422.""" + resp = await db_client.put("/api/settings/model", json={}) + assert resp.status_code == 422 - await db_client.put( - "/api/settings/api-keys/openai", - json={"provider": "openai", "key": "sk-stored-by-user-x1"}, - ) - resp = await db_client.get("/api/settings/api-keys") - assert resp.status_code == 200 - data = resp.json() - assert len(data) == 1 - assert data[0]["source"] == "db" - assert data[0]["key_masked"] == "sk-...r-x1" +# --------------------------------------------------------------------------- +# Providers (catalog-derived, no OpenCode) +# --------------------------------------------------------------------------- @pytest.mark.asyncio -async def test_delete_api_key(db_client): - """DELETE /api/settings/api-keys/{provider} removes the key.""" - with patch( - "cliff.engine.config_manager.opencode_client" - ) as mock_client: - mock_client.set_auth = AsyncMock(return_value=True) - mock_client.get_provider_auth = AsyncMock(return_value={}) - - # Store then delete - await db_client.put( - "/api/settings/api-keys/openai", - json={"provider": "openai", "key": "sk-to-delete-12345"}, - ) - resp = await db_client.delete("/api/settings/api-keys/openai") - assert resp.status_code == 204 - - # Verify it's gone - resp = await db_client.get("/api/settings/api-keys") - assert resp.json() == [] +async def test_list_providers(db_client): + """GET /api/settings/providers returns the static catalog as ``ProviderInfo``.""" + resp = await db_client.get("/api/settings/providers") + assert resp.status_code == 200 + data = resp.json() + ids = {p["id"] for p in data} + assert {"openrouter", "anthropic", "openai", "google", "ollama", "custom"} <= ids + openai = next(p for p in data if p["id"] == "openai") + assert openai["name"] == "OpenAI" + assert openai["env"] == ["OPENAI_API_KEY"] + # Models are keyed by the bare id so ``f"{provider}/{model_id}"`` round-trips + # back to the full picker id the UI and CLI rebuild. + assert "gpt-5" in openai["models"] + assert openai["models"]["gpt-5"]["id"] == "gpt-5" + assert openai["models"]["gpt-5"]["name"] -@pytest.mark.asyncio -async def test_delete_api_key_not_found(db_client): - """DELETE /api/settings/api-keys/{provider} returns 404 for missing key.""" - resp = await db_client.delete("/api/settings/api-keys/nonexistent") - assert resp.status_code == 404 + # Keyless provider (Ollama) → empty env list. + ollama = next(p for p in data if p["id"] == "ollama") + assert ollama["env"] == [] # --- Integrations --- @@ -282,35 +209,33 @@ async def test_integrations_crud(db_client): # --------------------------------------------------------------------------- -# Provider probe (PRD-0004 Story 4 / ADR-0031) +# Provider probe (PRD-0004 Story 4 / ADR-0031) — now a Pydantic AI round-trip # --------------------------------------------------------------------------- -class _FakeSession: - id = "probe-session-1" - - -def _fake_client_success(response_text: str = "OK") -> object: - mock = AsyncMock() - mock.create_session = AsyncMock(return_value=_FakeSession()) - mock.send_and_get_response = AsyncMock(return_value=response_text) - return mock +def _raising_model(exc: BaseException): + """A ``FunctionModel`` whose generation step raises *exc*.""" + from pydantic_ai.models.function import FunctionModel + def _fn(messages, info): + raise exc -def _fake_client_raising(exc: BaseException) -> object: - mock = AsyncMock() - mock.create_session = AsyncMock(return_value=_FakeSession()) - mock.send_and_get_response = AsyncMock(side_effect=exc) - return mock + return FunctionModel(_fn) @pytest.mark.asyncio async def test_provider_test_endpoint_success(db_client): - with patch( - "cliff.api.routes.settings.opencode_client", - _fake_client_success("OK"), - ): - resp = await db_client.post("/api/settings/providers/test", json={}) + from pydantic_ai.models.test import TestModel + + app.state.vault = object() + try: + with patch( + "cliff.agents.runtime.provider.build_model", + return_value=TestModel(), + ): + resp = await db_client.post("/api/settings/providers/test", json={}) + finally: + app.state.vault = None assert resp.status_code == 200 data = resp.json() assert data["ok"] is True @@ -320,53 +245,48 @@ async def test_provider_test_endpoint_success(db_client): @pytest.mark.asyncio -async def test_provider_test_endpoint_empty_response_is_timeout(db_client): - with patch( - "cliff.api.routes.settings.opencode_client", - _fake_client_success(""), - ): - resp = await db_client.post("/api/settings/providers/test", json={}) +async def test_provider_test_endpoint_no_vault_is_other(db_client): + """No credential vault → graceful ``other`` result, not a crash.""" + resp = await db_client.post("/api/settings/providers/test", json={}) + assert resp.status_code == 200 data = resp.json() assert data["ok"] is False - assert data["error_code"] == "timeout" + assert data["error_code"] == "other" @pytest.mark.asyncio async def test_provider_test_endpoint_auth_failed(db_client): - import httpx - - response = httpx.Response( - status_code=401, - text="invalid api key", - request=httpx.Request("POST", "http://test/session/x/message"), - ) - exc = httpx.HTTPStatusError("401", request=response.request, response=response) - with patch( - "cliff.api.routes.settings.opencode_client", - _fake_client_raising(exc), - ): - resp = await db_client.post("/api/settings/providers/test", json={}) + from pydantic_ai.exceptions import ModelHTTPError + + exc = ModelHTTPError(status_code=401, model_name="x", body="invalid api key") + app.state.vault = object() + try: + with patch( + "cliff.agents.runtime.provider.build_model", + return_value=_raising_model(exc), + ): + resp = await db_client.post("/api/settings/providers/test", json={}) + finally: + app.state.vault = None data = resp.json() assert data["ok"] is False assert data["error_code"] == "auth_failed" - assert "api key" in data["error_message"].lower() @pytest.mark.asyncio async def test_provider_test_endpoint_model_not_found(db_client): - import httpx - - response = httpx.Response( - status_code=404, - text="model 'gpt-4-turboo' not found", - request=httpx.Request("POST", "http://test/session/x/message"), - ) - exc = httpx.HTTPStatusError("404", request=response.request, response=response) - with patch( - "cliff.api.routes.settings.opencode_client", - _fake_client_raising(exc), - ): - resp = await db_client.post("/api/settings/providers/test", json={}) + from pydantic_ai.exceptions import ModelHTTPError + + exc = ModelHTTPError(status_code=404, model_name="x", body="model not found") + app.state.vault = object() + try: + with patch( + "cliff.agents.runtime.provider.build_model", + return_value=_raising_model(exc), + ): + resp = await db_client.post("/api/settings/providers/test", json={}) + finally: + app.state.vault = None data = resp.json() assert data["ok"] is False assert data["error_code"] == "model_not_found" @@ -374,19 +294,18 @@ async def test_provider_test_endpoint_model_not_found(db_client): @pytest.mark.asyncio async def test_provider_test_endpoint_rate_limited(db_client): - import httpx - - response = httpx.Response( - status_code=429, - text="rate limit exceeded, retry after 60s", - request=httpx.Request("POST", "http://test/session/x/message"), - ) - exc = httpx.HTTPStatusError("429", request=response.request, response=response) - with patch( - "cliff.api.routes.settings.opencode_client", - _fake_client_raising(exc), - ): - resp = await db_client.post("/api/settings/providers/test", json={}) + from pydantic_ai.exceptions import ModelHTTPError + + exc = ModelHTTPError(status_code=429, model_name="x", body="rate limit exceeded") + app.state.vault = object() + try: + with patch( + "cliff.agents.runtime.provider.build_model", + return_value=_raising_model(exc), + ): + resp = await db_client.post("/api/settings/providers/test", json={}) + finally: + app.state.vault = None data = resp.json() assert data["ok"] is False assert data["error_code"] == "rate_limited" @@ -394,24 +313,35 @@ async def test_provider_test_endpoint_rate_limited(db_client): @pytest.mark.asyncio async def test_provider_test_endpoint_timeout(db_client): - with patch( - "cliff.api.routes.settings.opencode_client", - _fake_client_raising(TimeoutError()), - ): - resp = await db_client.post("/api/settings/providers/test", json={}) + app.state.vault = object() + try: + with patch( + "cliff.agents.runtime.provider.build_model", + return_value=_raising_model(TimeoutError()), + ): + resp = await db_client.post("/api/settings/providers/test", json={}) + finally: + app.state.vault = None data = resp.json() assert data["ok"] is False assert data["error_code"] == "timeout" @pytest.mark.asyncio -async def test_provider_test_endpoint_other_error(db_client): - with patch( - "cliff.api.routes.settings.opencode_client", - _fake_client_raising(RuntimeError("catastrophic lightning strike")), - ): - resp = await db_client.post("/api/settings/providers/test", json={}) +async def test_provider_test_endpoint_provider_misconfigured_is_other(db_client): + """A ``ProviderConfigurationError`` from build_model → graceful ``other``.""" + from cliff.agents.runtime.provider import ProviderConfigurationError + + app.state.vault = object() + try: + with patch( + "cliff.agents.runtime.provider.build_model", + side_effect=ProviderConfigurationError("no api key configured"), + ): + resp = await db_client.post("/api/settings/providers/test", json={}) + finally: + app.state.vault = None data = resp.json() assert data["ok"] is False assert data["error_code"] == "other" - assert "catastrophic lightning strike" in data["error_message"] + assert "api key" in data["error_message"].lower() diff --git a/backend/tests/test_routes_version.py b/backend/tests/test_routes_version.py index bad76e9d..6e47b630 100644 --- a/backend/tests/test_routes_version.py +++ b/backend/tests/test_routes_version.py @@ -22,9 +22,8 @@ def test_version_cliff_matches_version_file(client): assert resp.json()["cliff"] == settings.cliff_version -def test_version_opencode_matches_pinned_engine(client): - """The opencode field should reflect .opencode-version.""" - from cliff.config import settings - +def test_version_opencode_reports_substrate(client): + """The compat ``opencode`` field carries the in-process substrate version + (ADR-0047) — "pydantic-ai ", not an OpenCode subprocess version.""" resp = client.get("/api/version") - assert resp.json()["opencode"] == settings.opencode_version + assert resp.json()["opencode"].startswith("pydantic-ai") diff --git a/backend/tests/test_workspace_dir.py b/backend/tests/test_workspace_dir.py index 8dad91ec..d2e338a5 100644 --- a/backend/tests/test_workspace_dir.py +++ b/backend/tests/test_workspace_dir.py @@ -86,13 +86,11 @@ def test_create_full_structure(manager: WorkspaceDirManager, sample_finding: Fin assert ws.exists() assert ws.root.is_dir() assert ws.context_dir.is_dir() - assert ws.agents_dir.is_dir() assert ws.history_dir.is_dir() assert ws.code_snippets_dir.is_dir() assert ws.references_dir.is_dir() assert ws.finding_json.is_file() assert ws.finding_md.is_file() - assert ws.opencode_json.is_file() assert ws.context_md.is_file() assert ws.agent_runs_log.is_file() @@ -351,16 +349,6 @@ def test_finding_md_minimal(manager: WorkspaceDirManager, minimal_finding: Findi assert "None" not in content -def test_opencode_json_valid(manager: WorkspaceDirManager, sample_finding: Finding): - """opencode.json is valid JSON with $schema and workspace permissions.""" - ws = manager.create("ws-oc", sample_finding) - data = json.loads(ws.opencode_json.read_text()) - assert "$schema" in data - assert data["$schema"] == "https://opencode.ai/config.json" - assert data["permission"]["bash"] == "ask" - assert data["permission"]["edit"] == "ask" - - def test_finding_json_roundtrip( manager: WorkspaceDirManager, sample_finding: Finding ): @@ -487,17 +475,3 @@ def test_context_document_generate_all_sections(): assert "All agents have run" in doc -# --------------------------------------------------------------------------- -# opencode.json permissions (T5.6) -# --------------------------------------------------------------------------- - - -def test_opencode_json_permissions_ask_for_bash_edit( - manager: WorkspaceDirManager, sample_finding: Finding -): - """Workspace opencode.json sets bash and edit to 'ask' for permission approval flow.""" - ws = manager.create("ws-permissions", sample_finding) - config = json.loads(ws.opencode_json.read_text()) - assert config["permission"]["bash"] == "ask" - assert config["permission"]["edit"] == "ask" - assert config["permission"]["webfetch"] == "allow" diff --git a/backend/tests/test_workspace_integrations.py b/backend/tests/test_workspace_integrations.py index 78ce184b..2b3c64bd 100644 --- a/backend/tests/test_workspace_integrations.py +++ b/backend/tests/test_workspace_integrations.py @@ -160,7 +160,6 @@ async def test_manifest_written_during_workspace_creation( db: aiosqlite.Connection, vault: CredentialVault, tmp_path, sample_finding: Finding ): """Create a workspace with integrations and verify the manifest exists.""" - from cliff.agents.template_engine import AgentTemplateEngine from cliff.db.repo_finding import create_finding from cliff.integrations.gateway import MCPConfigResolver from cliff.models import FindingCreate @@ -182,8 +181,7 @@ async def test_manifest_written_during_workspace_creation( resolver = MCPConfigResolver(vault) dir_mgr = WorkspaceDirManager(base_dir=tmp_path) - tmpl = AgentTemplateEngine() - builder = WorkspaceContextBuilder(dir_mgr, tmpl, mcp_resolver=resolver) + builder = WorkspaceContextBuilder(dir_mgr, mcp_resolver=resolver) workspace = await builder.create_workspace(db, finding) @@ -198,17 +196,11 @@ async def test_manifest_written_during_workspace_creation( assert manifest[0]["action_tier"] == 0 assert "collect" in manifest[0]["capabilities"] - # Verify opencode.json also has mcp section. - oc_config = json.loads((tmp_path / workspace.id / "opencode.json").read_text()) - assert "mcp" in oc_config - assert "github" in oc_config["mcp"] - async def test_no_manifest_without_integrations( db: aiosqlite.Connection, vault: CredentialVault, tmp_path ): """Workspace without integrations should not have a manifest file.""" - from cliff.agents.template_engine import AgentTemplateEngine from cliff.db.repo_finding import create_finding from cliff.integrations.gateway import MCPConfigResolver from cliff.models import FindingCreate @@ -222,8 +214,7 @@ async def test_no_manifest_without_integrations( resolver = MCPConfigResolver(vault) dir_mgr = WorkspaceDirManager(base_dir=tmp_path) - tmpl = AgentTemplateEngine() - builder = WorkspaceContextBuilder(dir_mgr, tmpl, mcp_resolver=resolver) + builder = WorkspaceContextBuilder(dir_mgr, mcp_resolver=resolver) workspace = await builder.create_workspace(db, finding) manifest_path = tmp_path / workspace.id / "workspace-integrations.json" @@ -241,7 +232,6 @@ async def test_workspace_integrations_api( """Full API flow: create workspace with integration, query integrations endpoint.""" from unittest.mock import AsyncMock - from cliff.agents.template_engine import AgentTemplateEngine from cliff.db.repo_finding import create_finding from cliff.integrations.gateway import MCPConfigResolver from cliff.main import app @@ -271,8 +261,7 @@ async def _noop_lifespan(a): resolver = MCPConfigResolver(vault) dir_mgr = WorkspaceDirManager(base_dir=tmp_path) - tmpl = AgentTemplateEngine() - builder = WorkspaceContextBuilder(dir_mgr, tmpl, mcp_resolver=resolver) + builder = WorkspaceContextBuilder(dir_mgr, mcp_resolver=resolver) app.state.context_builder = builder workspace = await builder.create_workspace(db, finding) @@ -293,7 +282,6 @@ async def test_workspace_integrations_api_empty(db: aiosqlite.Connection, tmp_pa """Workspace with no integrations returns empty list.""" from unittest.mock import AsyncMock - from cliff.agents.template_engine import AgentTemplateEngine from cliff.db.repo_finding import create_finding from cliff.main import app from cliff.models import FindingCreate @@ -314,8 +302,7 @@ async def _noop_lifespan(a): FindingCreate(source_type="test", source_id="T-EMPTY", title="Empty test"), ) dir_mgr = WorkspaceDirManager(base_dir=tmp_path) - tmpl = AgentTemplateEngine() - builder = WorkspaceContextBuilder(dir_mgr, tmpl) + builder = WorkspaceContextBuilder(dir_mgr) app.state.context_builder = builder workspace = await builder.create_workspace(db, finding) diff --git a/backend/tests/test_workspace_repo_creation.py b/backend/tests/test_workspace_repo_creation.py index ab068569..e77acfb5 100644 --- a/backend/tests/test_workspace_repo_creation.py +++ b/backend/tests/test_workspace_repo_creation.py @@ -2,7 +2,6 @@ from __future__ import annotations -import json from typing import TYPE_CHECKING import pytest @@ -34,104 +33,26 @@ def test_creates_directory_with_expected_layout( ws_dir = manager.base_dir / workspace_id assert ws_dir.is_dir() - assert (ws_dir / ".opencode" / "agents").is_dir() assert (ws_dir / "history").is_dir() - assert (ws_dir / "opencode.json").is_file() + assert (ws_dir / "history" / "agent-runs.jsonl").is_file() # No finding-scoped files on a repo workspace. assert not (ws_dir / "finding.json").exists() assert not (ws_dir / "finding.md").exists() assert not (ws_dir / "CONTEXT.md").exists() + # No OpenCode scaffolding — the PA repo-action agent carries its own + # prompt + permission policy (ADR-0047); nothing is rendered to disk. + assert not (ws_dir / ".opencode").exists() + assert not (ws_dir / "opencode.json").exists() + # REPO_ACTION.md summary exists and mentions the action + URL. action_md = (ws_dir / "REPO_ACTION.md").read_text() assert "repo_action_security_md" in action_md assert "https://github.com/acme/widget" in action_md - def test_writes_rendered_agent_file(self, manager: WorkspaceDirManager) -> None: - workspace_id = manager.create_repo_workspace( - WorkspaceKind.repo_action_security_md, - repo_url="https://github.com/acme/widget", - params={"contact_email": "ciso@example.org"}, - gh_token="ghp_sekret_only_in_env", - ) - - agent_file = ( - manager.base_dir - / workspace_id - / ".opencode" - / "agents" - / "security_md_generator.md" - ) - assert agent_file.is_file() - content = agent_file.read_text() - - # Template substitutions landed. - assert "https://github.com/acme/widget" in content - assert "ciso@example.org" in content - assert "cliff/posture/security-md" in content - assert "gh pr create --draft" in content - - # Defence in depth: the PAT must never be persisted to disk. The agent - # reads $GH_TOKEN from the workspace env at runtime (injected by the - # process pool), not from the rendered prompt. - assert "ghp_sekret_only_in_env" not in content - - def test_opencode_json_has_allow_perms_for_repo_action( - self, manager: WorkspaceDirManager - ) -> None: - """Repo-action workspaces run single-shot posture agents with no - interactive approval path — see the rationale in - ``_build_opencode_config``. Bash/edit/webfetch/external_directory - all default to ``allow`` for this kind of workspace so the agent - doesn't stall on a permission prompt nobody can answer. - """ - workspace_id = manager.create_repo_workspace( - WorkspaceKind.repo_action_security_md, - repo_url="https://github.com/acme/widget", - params={}, - ) - cfg = json.loads( - (manager.base_dir / workspace_id / "opencode.json").read_text() - ) - assert cfg["permission"]["bash"] == "allow" - assert cfg["permission"]["edit"] == "allow" - assert cfg["permission"]["webfetch"] == "allow" - assert cfg["permission"]["external_directory"] == "allow" - class TestDependabotRepoWorkspace: - def test_selects_dependabot_template( - self, manager: WorkspaceDirManager - ) -> None: - workspace_id = manager.create_repo_workspace( - WorkspaceKind.repo_action_dependabot, - repo_url="https://github.com/acme/widget", - params={}, - ) - - agent_file = ( - manager.base_dir - / workspace_id - / ".opencode" - / "agents" - / "dependabot_config_generator.md" - ) - assert agent_file.is_file() - content = agent_file.read_text() - assert ".github/dependabot.yml" in content - assert "cliff/posture/dependabot" in content - assert "https://github.com/acme/widget" in content - - # The SECURITY.md template must NOT be written for a dependabot workspace. - assert not ( - manager.base_dir - / workspace_id - / ".opencode" - / "agents" - / "security_md_generator.md" - ).exists() - def test_unique_workspace_ids(self, manager: WorkspaceDirManager) -> None: """Two back-to-back calls must get distinct workspace_ids.""" w1 = manager.create_repo_workspace( diff --git a/cli/cliff_cli/cli.py b/cli/cliff_cli/cli.py index 2056581b..39317f04 100644 --- a/cli/cliff_cli/cli.py +++ b/cli/cliff_cli/cli.py @@ -146,13 +146,11 @@ def status(client: Client) -> None: # Re-raise so the wrapper handles it as a structured error. raise - # ADR-0037: report the canonical active model. The prior CLI surfaced - # a "drift" signal between canonical state and a live OpenCode probe; - # the architect health-check (M9) removed the probe as redundant — - # the on_key_change hook restarts the singleton synchronously on - # every write, so there is no drift to surface. ``/health.model`` - # remains the singleton's view of its own config and is used as the - # fallback when the AI status endpoint isn't yet available (no vault). + # ADR-0037 / ADR-0047: report the canonical active model. With the + # substrate in-process there is no engine probe and no drift signal — + # ``/api/integrations/ai/status`` is the canonical model (DB-backed), + # with ``/health.model`` as the fallback when that endpoint isn't yet + # available (no vault). canonical_model: str | None = None try: ai_status = client.get("/api/integrations/ai/status") @@ -162,14 +160,12 @@ def status(client: Client) -> None: model = canonical_model or health.get("model") or "" blockers: list[str] = [] - if health.get("opencode") != "ok": - blockers.append("opencode_engine_unavailable") if not model: blockers.append("no_llm_model_configured") # A model string alone is not enough — the agent runtime also needs a - # provider credential that actually reaches the workspace subprocess. - # ``ai_provider_ready`` is False when no credential resolved (e.g. a - # connected-but-broken BYOK key), so guard against that false-positive. + # provider credential that actually resolves. ``ai_provider_ready`` is + # False when no credential resolved (e.g. a connected-but-broken BYOK + # key), so guard against that false-positive. if not health.get("ai_provider_ready", False): blockers.append("no_ai_provider_credential") @@ -314,13 +310,9 @@ def fix(client: Client, issue_id: str, timeout: float) -> None: ) workspace_id = ws["id"] - # Make sure a session exists for the workspace before running the - # pipeline. The session endpoint is idempotent enough for our purposes. - import contextlib - - with contextlib.suppress(HTTPError): - client.post(f"/api/workspaces/{workspace_id}/sessions", json={}) - + # The pipeline runs its agents in-process via Pydantic AI — no OpenCode + # session to pre-create (the old POST /sessions step was a no-op since + # the substrate migration; ADR-0047). client.post(f"/api/workspaces/{workspace_id}/pipeline/run-all") # Poll the sidebar until either: diff --git a/cli/cliff_cli/daemon.py b/cli/cliff_cli/daemon.py index 1ce01846..f334d8cc 100644 --- a/cli/cliff_cli/daemon.py +++ b/cli/cliff_cli/daemon.py @@ -13,10 +13,9 @@ backend/ # FastAPI app + uv-managed .venv/ frontend/dist/ # prebuilt SPA scripts/ - .opencode-version .scanner-versions VERSION - bin/ # opencode, trivy, semgrep + bin/ # trivy, semgrep data/ # cliff.db, workspaces/, logs/ config/cliff.env # runtime env vars (KEY=value lines) run/cliff.pid # detached-mode pidfile @@ -41,8 +40,6 @@ from cliff_cli.output import EXIT_ERROR, EXIT_OK, emit, emit_error from cliff_cli.process_sweep import ( - OPENCODE_SINGLETON_PORT, - WORKSPACE_PORT_RANGE, find_cliff_processes, find_port_squatters, kill_processes, @@ -143,8 +140,9 @@ def _configured_app_port() -> int: def _cliff_ports() -> list[int]: - """Every port we care about for the lifecycle: app + opencode singleton + workspace range.""" - return [_configured_app_port(), OPENCODE_SINGLETON_PORT, *WORKSPACE_PORT_RANGE] + """Every port we care about for the lifecycle. The agent substrate runs + in-process now (ADR-0047), so the only port Cliff binds is the app port.""" + return [_configured_app_port()] def _ensure_dirs() -> None: @@ -288,9 +286,8 @@ def stop_cmd(timeout: float, force: bool) -> None: """Stop the running Cliff server and reclaim any leaked child processes. Matching is owner-safe: a process is signalled only if its cmdline - identifies it as ours (uvicorn for ``cliff.main:app`` or our installed - ``$CLIFF_HOME/bin/opencode`` binary). Anything else bound to a port we - use is reported but never killed. + identifies it as ours (uvicorn for ``cliff.main:app``). Anything else + bound to a port we use is reported but never killed. """ ports = _cliff_ports() @@ -318,7 +315,7 @@ def stop_cmd(timeout: float, force: bool) -> None: parent_killed = pid # 2. Sweep for Cliff-owned orphans (parent or children still alive). - ours = find_cliff_processes(CLIFF_HOME) + ours = find_cliff_processes() if parent_killed is not None: ours = [p for p in ours if p.pid != parent_killed] @@ -488,19 +485,6 @@ def _gather_doctor_checks() -> list[dict[str, Any]]: else: checks.append(_check("python", False, f"not found at {py_bin}")) - # opencode binary version match - opencode_bin = BIN_DIR / "opencode" - expected_opencode = "" - opencode_version_file = APP_DIR / ".opencode-version" - if opencode_version_file.is_file(): - expected_opencode = opencode_version_file.read_text().strip() - if opencode_bin.is_file(): - actual = _run_version([str(opencode_bin), "--version"], timeout=10) - ok = (not expected_opencode) or expected_opencode in actual - checks.append(_check("opencode", ok, actual or "?", expected=expected_opencode)) - else: - checks.append(_check("opencode", False, f"not found at {opencode_bin}")) - # trivy + semgrep against .scanner-versions pinned = _read_pinned_versions(APP_DIR / ".scanner-versions") for tool in ("trivy", "semgrep"): @@ -515,7 +499,7 @@ def _gather_doctor_checks() -> list[dict[str, Any]]: # macOS Gatekeeper quarantine if sys.platform == "darwin": - for tool in ("opencode", "trivy", "semgrep"): + for tool in ("trivy", "semgrep"): path = BIN_DIR / tool if not path.is_file(): continue @@ -561,12 +545,13 @@ def _gather_doctor_checks() -> list[dict[str, Any]]: _check("gh.auth", r.returncode == 0, first or "unknown", warn_only=True) ) - # Ports — 8000 hard, the others warn-only - for port in (DEFAULT_PORT, 4096, 4100, 4101, 4102): + # Port — only the app port matters now (the substrate is in-process). + # Probe the *configured* port (CLIFF_APP_PORT), not the hard-coded default, + # so a non-default deployment doesn't miss a real port-in-use failure. + for port in _cliff_ports(): free = _port_free(port) - warn_only = port != DEFAULT_PORT checks.append( - _check(f"port.{port}", free, "free" if free else "in use", warn_only=warn_only) + _check(f"port.{port}", free, "free" if free else "in use", warn_only=False) ) # Data dir writable @@ -764,7 +749,7 @@ def uninstall_cmd(ctx: click.Context, keep_data: bool, yes: bool) -> None: # 2. After stop, refuse to remove files if any of our processes are # still alive on our ports. We never rm -rf over a live process. - ours = find_cliff_processes(CLIFF_HOME) + ours = find_cliff_processes() if ours: emit_error( "Cliff processes are still running after stop — refusing to remove files.", diff --git a/cli/cliff_cli/process_sweep.py b/cli/cliff_cli/process_sweep.py index 3d7c80b2..10b5ec1a 100644 --- a/cli/cliff_cli/process_sweep.py +++ b/cli/cliff_cli/process_sweep.py @@ -1,19 +1,15 @@ """Owner-safe process discovery and cleanup for the Cliff CLI. -Used by ``cliffsec stop`` / ``restart`` / ``uninstall`` to find leaked Cliff -processes (parent uvicorn + child OpenCode binaries) when the parent died -abruptly and left orphans holding ports. +Used by ``cliffsec stop`` / ``restart`` / ``uninstall`` to find a leaked Cliff +server (the uvicorn parent) when it died abruptly and left an orphan holding +the app port. The agent substrate runs in-process via Pydantic AI (ADR-0047), +so there are no child processes to reap — only the uvicorn parent. -Hard ownership rule: a process is Cliff-owned **iff** its cmdline matches -one of two patterns: - -1. The parent uvicorn — argv contains the literal token ``uvicorn`` and the - target ``cliff.main:app``. -2. Our installed opencode binary — ``argv[0]`` (or the executable path) is - exactly ``$CLIFF_HOME/bin/opencode``. +Hard ownership rule: a process is Cliff-owned **iff** its cmdline contains the +literal token ``uvicorn`` and the target ``cliff.main:app``. Port presence is *never* sufficient to declare a process ours. A process -sitting on port 4096 with an unrelated cmdline is a "squatter": reported, +sitting on the app port with an unrelated cmdline is a "squatter": reported, never signalled. This is the safety contract: we never kill someone else's process just because it happens to be on a port we'd like. """ @@ -26,21 +22,17 @@ import time from collections.abc import Iterable from dataclasses import dataclass, field -from pathlib import Path from typing import Literal import psutil -OPENCODE_SINGLETON_PORT = 4096 -WORKSPACE_PORT_RANGE = range(4100, 4200) - @dataclass(frozen=True) class FoundProcess: - """An Cliff process the user is allowed to signal.""" + """A Cliff process the user is allowed to signal.""" pid: int - kind: Literal["uvicorn", "opencode"] + kind: Literal["uvicorn"] cmdline: str ports: tuple[int, ...] = field(default_factory=tuple) @@ -111,11 +103,8 @@ def _listening_ports_by_pid() -> dict[int, list[int]]: return out -def _classify( - proc: psutil.Process, - cliff_opencode_bin: Path, -) -> Literal["uvicorn", "opencode"] | None: - """Return 'uvicorn' / 'opencode' if proc matches our ownership rules, else None.""" +def _classify(proc: psutil.Process) -> Literal["uvicorn"] | None: + """Return 'uvicorn' if proc is our server, else None.""" try: cmdline = proc.cmdline() except (psutil.AccessDenied, psutil.NoSuchProcess): @@ -123,23 +112,12 @@ def _classify( if not cmdline: return None - # Rule 1: parent uvicorn for our app. + # The parent uvicorn for our app. has_uvicorn = any("uvicorn" in arg for arg in cmdline) has_app = any("cliff.main:app" in arg for arg in cmdline) if has_uvicorn and has_app: return "uvicorn" - # Rule 2: our opencode binary at the exact installed path. - target = str(cliff_opencode_bin) - if cmdline[0] == target: - return "opencode" - try: - exe = proc.exe() - except (psutil.AccessDenied, psutil.NoSuchProcess): - exe = "" - if exe == target: - return "opencode" - return None @@ -156,13 +134,12 @@ def _is_same_user(proc: psutil.Process) -> bool: # --------------------------------------------------------------------------- -def find_cliff_processes(cliff_home: Path) -> list[FoundProcess]: +def find_cliff_processes() -> list[FoundProcess]: """Find every Cliff-owned process running as the current user. Skips processes we can't inspect (AccessDenied, NoSuchProcess) and never - matches by port alone — see module docstring for the ownership rules. + matches by port alone — see module docstring for the ownership rule. """ - opencode_bin = cliff_home / "bin" / "opencode" ports_by_pid = _listening_ports_by_pid() found: list[FoundProcess] = [] self_pid = os.getpid() @@ -173,7 +150,7 @@ def find_cliff_processes(cliff_home: Path) -> list[FoundProcess]: continue if not _is_same_user(proc): continue - kind = _classify(proc, opencode_bin) + kind = _classify(proc) if kind is None: continue cmdline_str = " ".join(proc.cmdline()) diff --git a/cli/cliff_cli/updater.py b/cli/cliff_cli/updater.py index eab0a2f8..621995c0 100644 --- a/cli/cliff_cli/updater.py +++ b/cli/cliff_cli/updater.py @@ -3,9 +3,8 @@ `cliffsec update` checks GitHub Releases for a newer version, downloads the tarball, snapshots the current ``app/`` and ``bin/`` (rename, not copy — fast, atomic on the same filesystem), extracts the new version, re-runs the -bundled ``install-opencode.sh`` / ``install-scanners.sh`` to rehydrate -``bin/``, runs the doctor checks, and either restarts the daemon or rolls -back on failure. +bundled ``install-scanners.sh`` to rehydrate ``bin/``, runs the doctor +checks, and either restarts the daemon or rolls back on failure. Data and config are never touched. ``data/``, ``config/``, and ``cli-venv/`` stay where they are. @@ -181,7 +180,6 @@ def fetch_expected_sha256(client: httpx.Client, release: Release) -> str | None: REQUIRED_TARBALL_MEMBERS = ( "VERSION", - "scripts/install-opencode.sh", "scripts/install-scanners.sh", ) MIN_FREE_BYTES = 500 * 1024 * 1024 # 500 MB pre-flight floor @@ -524,7 +522,7 @@ def _rollback(reason: str) -> None: d.APP_DIR.mkdir(parents=True, exist_ok=True) safe_extract(tar_path, d.APP_DIR) - click.echo("[8/9] re-running bundled installers (opencode + scanners)") + click.echo("[8/9] re-running bundled installers (scanners)") d.BIN_DIR.mkdir(parents=True, exist_ok=True) _run_bundled_installers(d) @@ -562,16 +560,16 @@ def _rollback(reason: str) -> None: def _run_bundled_installers(d) -> None: - """Run install-opencode.sh and install-scanners.sh shipped inside the new tarball. + """Run install-scanners.sh shipped inside the new tarball. - These scripts download the pinned binaries from GitHub Releases and drop - them into ``$CLIFF_HOME/bin/``. They tolerate being re-run. + This script downloads the pinned scanner binaries from GitHub Releases and + drops them into ``$CLIFF_HOME/bin/``. It tolerates being re-run. """ scripts_dir = d.APP_DIR / "scripts" env = os.environ.copy() env["CLIFF_HOME"] = str(d.CLIFF_HOME) env["BIN_DIR"] = str(d.BIN_DIR) - for script_name in ("install-opencode.sh", "install-scanners.sh"): + for script_name in ("install-scanners.sh",): script = scripts_dir / script_name if not script.is_file(): raise RuntimeError(f"bundled installer missing: {script}") diff --git a/cli/tests/test_cli.py b/cli/tests/test_cli.py index 8345865d..c7c22fbb 100644 --- a/cli/tests/test_cli.py +++ b/cli/tests/test_cli.py @@ -123,29 +123,36 @@ def test_status_blocked_when_ai_provider_not_ready(cli, httpx_mock): assert "no_llm_model_configured" not in payload["blockers"] -def test_status_blockers_when_engine_down(cli, httpx_mock): +def test_status_blockers_when_unconfigured(cli, httpx_mock): + """No model + no provider credential → both blockers, not ready (ADR-0047: + there is no engine to be 'down', so readiness rests on AI config).""" httpx_mock.add_response( url="http://test-server/health", - json={"cliff": "ok", "opencode": "unavailable", "opencode_version": "1.3.2", "model": ""}, + json={ + "cliff": "ok", + "opencode": "ok", + "opencode_version": "pydantic-ai 1.98.0", + "model": "", + }, ) httpx_mock.add_response( url="http://test-server/api/version", json={ "cliff": "0.1.1-alpha", - "opencode": "1.3.2", + "opencode": "pydantic-ai 1.98.0", "schema_version": "1", "min_cli": "0.1.0", }, ) - # Engine is down → AI integration also has nothing to report. model=None - # keeps the ``no_llm_model_configured`` blocker the test asserts. _stub_ai_integration_status(httpx_mock, model=None) res = cli.invoke(main, ["status"]) assert res.exit_code == 0 payload = _last_json(res.stdout) assert payload["ready"] is False - assert "opencode_engine_unavailable" in payload["blockers"] assert "no_llm_model_configured" in payload["blockers"] + assert "no_ai_provider_credential" in payload["blockers"] + # No engine concept anymore. + assert "opencode_engine_unavailable" not in payload["blockers"] def test_status_prefers_canonical_model_and_omits_drift_fields( @@ -415,11 +422,6 @@ def test_fix_creates_workspace_and_pauses_at_plan(cli, httpx_mock): "updated_at": "x", }, ) - httpx_mock.add_response( - url="http://test-server/api/workspaces/ws-1/sessions", - method="POST", - json={"session_id": "sess-1"}, - ) httpx_mock.add_response( url="http://test-server/api/workspaces/ws-1/pipeline/run-all", method="POST", @@ -484,11 +486,6 @@ def test_fix_tolerates_initial_404(cli, httpx_mock): "updated_at": "x", }, ) - httpx_mock.add_response( - url="http://test-server/api/workspaces/ws-1/sessions", - method="POST", - json={"session_id": "sess-1"}, - ) httpx_mock.add_response( url="http://test-server/api/workspaces/ws-1/pipeline/run-all", method="POST", @@ -534,11 +531,6 @@ def test_fix_timeout_emits_json_error(cli, httpx_mock): "derived": {"workspace_id": "ws-1"}, }, ) - httpx_mock.add_response( - url="http://test-server/api/workspaces/ws-1/sessions", - method="POST", - json={"session_id": "sess-1"}, - ) httpx_mock.add_response( url="http://test-server/api/workspaces/ws-1/pipeline/run-all", method="POST", diff --git a/cli/tests/test_daemon.py b/cli/tests/test_daemon.py index 738fd780..db03ab0b 100644 --- a/cli/tests/test_daemon.py +++ b/cli/tests/test_daemon.py @@ -189,7 +189,7 @@ def stop_env(fake_home, monkeypatch): "alive_pids": set(), } - monkeypatch.setattr(daemon, "find_cliff_processes", lambda home_: list(state["owned"])) + monkeypatch.setattr(daemon, "find_cliff_processes", lambda: list(state["owned"])) monkeypatch.setattr( daemon, "find_port_squatters", @@ -254,19 +254,19 @@ def test_stop_kills_recorded_parent_via_pidfile(stop_env, tmp_path): def test_stop_kills_owned_orphan_when_no_pidfile(stop_env): home, daemon, state, FoundProcess, _ = stop_env # noqa: N806 state["owned"] = [ - FoundProcess(pid=5000, kind="opencode", cmdline="opencode serve", ports=(4096,)) + FoundProcess(pid=5000, kind="uvicorn", cmdline="uvicorn cliff.main:app", ports=(8000,)) ] state["kills"] = (state["owned"], []) runner = CliRunner() res = runner.invoke(daemon.stop_cmd) assert res.exit_code == 0 assert state["kill_calls"] == [([5000], False)] - assert "found stale opencode pid=5000" in res.output + assert "found stale uvicorn pid=5000" in res.output def test_stop_with_force_passes_force_to_killer(stop_env): home, daemon, state, FoundProcess, _ = stop_env # noqa: N806 - state["owned"] = [FoundProcess(pid=5001, kind="opencode", cmdline="...")] + state["owned"] = [FoundProcess(pid=5001, kind="uvicorn", cmdline="...")] state["kills"] = (state["owned"], []) runner = CliRunner() res = runner.invoke(daemon.stop_cmd, ["--force"]) @@ -276,8 +276,8 @@ def test_stop_with_force_passes_force_to_killer(stop_env): def test_stop_reports_squatter_but_does_not_signal_it(stop_env): home, daemon, state, _, PortSquatter = stop_env # noqa: N806 - # No owned processes; just an unrelated listener on 4096. - state["squatters"] = [PortSquatter(pid=9000, port=4096, cmdline="nc -l 4096")] + # No owned processes; just an unrelated listener on 8000. + state["squatters"] = [PortSquatter(pid=9000, port=8000, cmdline="nc -l 8000")] runner = CliRunner() res = runner.invoke(daemon.stop_cmd) # No owned procs found => still says "not running" and never signals. @@ -304,17 +304,16 @@ def _fps(ports, owned_pids): d.find_port_squatters = _fps # noqa: SLF001 — direct attr write for the test runner = CliRunner() runner.invoke(d.stop_cmd) - assert 8765 in captured["ports"] - # And the workspace range / opencode singleton are still there. - assert 4096 in captured["ports"] - assert 4150 in captured["ports"] + # The substrate is in-process now (ADR-0047): the only port swept is the + # configured app port — no more 4096 singleton / 4100-4199 workspace range. + assert captured["ports"] == [8765] def test_stop_errors_when_processes_resist_shutdown(stop_env): home, daemon, state, FoundProcess, _ = stop_env # noqa: N806 - state["owned"] = [FoundProcess(pid=5010, kind="opencode", cmdline="...")] + state["owned"] = [FoundProcess(pid=5010, kind="uvicorn", cmdline="...")] state["kills"] = ([], state["owned"]) # nothing killed, all stuck - state["bound_ports"] = [4096] + state["bound_ports"] = [8000] runner = CliRunner() res = runner.invoke(daemon.stop_cmd) assert res.exit_code == 1 @@ -324,9 +323,9 @@ def test_stop_errors_when_processes_resist_shutdown(stop_env): def test_stop_succeeds_when_pids_dead_but_ports_linger(stop_env): """Kernel TIME_WAIT after our processes die: warn, don't fail.""" home, daemon, state, FoundProcess, _ = stop_env # noqa: N806 - state["owned"] = [FoundProcess(pid=5020, kind="opencode", cmdline="...")] + state["owned"] = [FoundProcess(pid=5020, kind="uvicorn", cmdline="...")] state["kills"] = (state["owned"], []) # all dead - state["bound_ports"] = [4096] # but kernel hasn't released yet + state["bound_ports"] = [8000] # but kernel hasn't released yet runner = CliRunner() res = runner.invoke(daemon.stop_cmd) assert res.exit_code == 0, res.output @@ -336,10 +335,10 @@ def test_stop_succeeds_when_pids_dead_but_ports_linger(stop_env): def test_stop_succeeds_when_remaining_bound_ports_are_squatter_held(stop_env): """Ports still bound by squatters must NOT count against stop.""" home, daemon, state, FoundProcess, PortSquatter = stop_env # noqa: N806 - state["owned"] = [FoundProcess(pid=5011, kind="opencode", cmdline="...")] + state["owned"] = [FoundProcess(pid=5011, kind="uvicorn", cmdline="...")] state["kills"] = (state["owned"], []) - state["squatters"] = [PortSquatter(pid=9001, port=4096, cmdline="nc -l 4096")] - state["bound_ports"] = [4096] # only the squatter + state["squatters"] = [PortSquatter(pid=9001, port=8000, cmdline="nc -l 8000")] + state["bound_ports"] = [8000] # only the squatter runner = CliRunner() res = runner.invoke(daemon.stop_cmd) assert res.exit_code == 0 @@ -444,7 +443,7 @@ def test_uninstall_aborts_if_processes_still_running_after_stop(stop_env, monkey home, daemon, state, FoundProcess, _ = stop_env # noqa: N806 daemon.APP_DIR.mkdir(parents=True) monkeypatch.setattr(daemon.stop_cmd, "callback", lambda timeout, force: None) - state["owned"] = [FoundProcess(pid=7000, kind="opencode", cmdline="...")] + state["owned"] = [FoundProcess(pid=7000, kind="uvicorn", cmdline="...")] runner = CliRunner() res = runner.invoke(daemon.uninstall_cmd, ["--yes"]) @@ -487,5 +486,29 @@ def test_doctor_json_envelope_on_empty_home(fake_home): assert "venv" in payload["failing"] # The shape is stable: every check is named. names = {c["name"] for c in payload["checks"]} - expected = {"uv", "venv", "python", "opencode", "trivy", "semgrep", "credential_key"} + expected = {"uv", "venv", "python", "trivy", "semgrep", "credential_key"} assert expected.issubset(names) + # The OpenCode binary check is gone (ADR-0047) — lock the migration. + assert "opencode" not in names + assert "opencode" not in payload["failing"] + # The port check targets the default app port when none is configured. + assert "port.8000" in names + + +def test_doctor_probes_configured_app_port(fake_home): + """doctor must probe the *configured* CLIFF_APP_PORT, not the hard-coded + default — otherwise a non-default deployment misses port-in-use failures.""" + home, daemon = fake_home + daemon.CONFIG_DIR.mkdir(parents=True, exist_ok=True) + daemon.ENV_FILE.write_text("CLIFF_APP_PORT=9123\n") + import importlib + + import cliff_cli.cli as cli_mod + + importlib.reload(cli_mod) + + res = CliRunner().invoke(cli_mod.main, ["doctor", "--json"]) + payload = json.loads(res.output.strip().splitlines()[-1]) + names = {c["name"] for c in payload["checks"]} + assert "port.9123" in names + assert "port.8000" not in names diff --git a/cli/tests/test_process_sweep.py b/cli/tests/test_process_sweep.py index d0ec6889..e6a0c39f 100644 --- a/cli/tests/test_process_sweep.py +++ b/cli/tests/test_process_sweep.py @@ -10,7 +10,6 @@ import signal import socket from collections import namedtuple -from pathlib import Path from unittest.mock import MagicMock import psutil @@ -25,8 +24,7 @@ verify_ports_free, ) -CLIFF_HOME = Path("/home/test/.cliff") -OPENCODE_BIN = str(CLIFF_HOME / "bin" / "opencode") +_UVICORN = [".venv/bin/uvicorn", "cliff.main:app", "--port", "8000"] _LAddr = namedtuple("_LAddr", ["ip", "port"]) _Conn = namedtuple("_Conn", ["fd", "family", "type", "laddr", "raddr", "status", "pid"]) @@ -87,63 +85,36 @@ def _patch_conns(monkeypatch, conns): # --------------------------------------------------------------------------- -# find_cliff_processes — ownership rules (the critical safety contract) +# find_cliff_processes — ownership rule (the critical safety contract) +# +# The agent substrate runs in-process now (ADR-0047), so the only Cliff-owned +# process is the uvicorn parent. There are no child binaries to reap. # --------------------------------------------------------------------------- def test_finds_parent_uvicorn(monkeypatch): - proc = _make_proc( - 100, - [".venv/bin/uvicorn", "cliff.main:app", "--port", "8000"], - ) + proc = _make_proc(100, _UVICORN) _patch_iter(monkeypatch, [proc]) _patch_conns( monkeypatch, [_Conn(0, 0, 0, _LAddr("127.0.0.1", 8000), None, psutil.CONN_LISTEN, 100)], ) - found = find_cliff_processes(CLIFF_HOME) + found = find_cliff_processes() assert len(found) == 1 assert found[0].pid == 100 assert found[0].kind == "uvicorn" assert 8000 in found[0].ports -def test_finds_opencode_when_argv0_is_installed_path(monkeypatch): - proc = _make_proc(101, [OPENCODE_BIN, "serve", "--port", "4096"]) - _patch_iter(monkeypatch, [proc]) - _patch_conns(monkeypatch, []) - found = find_cliff_processes(CLIFF_HOME) - assert len(found) == 1 - assert found[0].kind == "opencode" - - -def test_finds_opencode_via_exe_when_argv0_is_relative(monkeypatch): - proc = _make_proc(102, ["opencode", "serve", "--port", "4096"], exe=OPENCODE_BIN) - _patch_iter(monkeypatch, [proc]) - _patch_conns(monkeypatch, []) - found = find_cliff_processes(CLIFF_HOME) - assert len(found) == 1 - assert found[0].kind == "opencode" - - -def test_does_not_match_unrelated_opencode_at_different_path(monkeypatch): - """A user's separate `opencode` binary at /usr/local/bin must not match.""" - proc = _make_proc(103, ["/usr/local/bin/opencode", "serve"], exe="/usr/local/bin/opencode") - _patch_iter(monkeypatch, [proc]) - _patch_conns(monkeypatch, []) - found = find_cliff_processes(CLIFF_HOME) - assert found == [] - - def test_does_not_match_arbitrary_listener_on_known_port(monkeypatch): - """Port 4096 alone must not be sufficient — cmdline must prove ownership.""" - proc = _make_proc(104, ["nc", "-l", "4096"]) + """The app port alone must not be sufficient — cmdline must prove ownership.""" + proc = _make_proc(104, ["nc", "-l", "8000"]) _patch_iter(monkeypatch, [proc]) _patch_conns( monkeypatch, - [_Conn(0, 0, 0, _LAddr("127.0.0.1", 4096), None, psutil.CONN_LISTEN, 104)], + [_Conn(0, 0, 0, _LAddr("127.0.0.1", 8000), None, psutil.CONN_LISTEN, 104)], ) - found = find_cliff_processes(CLIFF_HOME) + found = find_cliff_processes() assert found == [] @@ -151,27 +122,25 @@ def test_does_not_match_uvicorn_for_other_app(monkeypatch): proc = _make_proc(105, ["uvicorn", "other_app.main:app"]) _patch_iter(monkeypatch, [proc]) _patch_conns(monkeypatch, []) - found = find_cliff_processes(CLIFF_HOME) + found = find_cliff_processes() assert found == [] def test_skips_processes_owned_by_other_users(monkeypatch): - proc = _make_proc( - 106, [".venv/bin/uvicorn", "cliff.main:app"], same_user=False - ) + proc = _make_proc(106, _UVICORN, same_user=False) _patch_iter(monkeypatch, [proc]) _patch_conns(monkeypatch, []) - found = find_cliff_processes(CLIFF_HOME) + found = find_cliff_processes() assert found == [] def test_swallows_access_denied(monkeypatch): """Inaccessible process must not crash the sweep.""" bad = _make_proc(107, [], raise_on="cmdline") - good = _make_proc(108, [OPENCODE_BIN, "serve"]) + good = _make_proc(108, _UVICORN) _patch_iter(monkeypatch, [bad, good]) _patch_conns(monkeypatch, []) - found = find_cliff_processes(CLIFF_HOME) + found = find_cliff_processes() assert [f.pid for f in found] == [108] @@ -180,14 +149,14 @@ def test_skips_self_pid(monkeypatch): proc = _make_proc(99999, ["uvicorn", "cliff.main:app"]) _patch_iter(monkeypatch, [proc]) _patch_conns(monkeypatch, []) - found = find_cliff_processes(CLIFF_HOME) + found = find_cliff_processes() assert found == [] def test_swallows_net_connections_access_denied(monkeypatch): """psutil.net_connections raises AccessDenied on macOS w/o root — fallback to per-process scan handles it without crashing.""" - proc = _make_proc(109, [OPENCODE_BIN, "serve"]) + proc = _make_proc(109, _UVICORN) proc.net_connections.return_value = [] def _raise(kind="inet"): @@ -198,7 +167,7 @@ def _raise(kind="inet"): lambda attrs=None: iter([proc]), ) monkeypatch.setattr("cliff_cli.process_sweep.psutil.net_connections", _raise) - found = find_cliff_processes(CLIFF_HOME) + found = find_cliff_processes() assert len(found) == 1 assert found[0].ports == () @@ -207,10 +176,10 @@ def test_macos_fallback_finds_owned_process_listening_port(monkeypatch): """When system net_connections is denied, per-process net_connections must take over so we still get the port -> pid mapping for owned procs. Regression test for the bug found during the macOS e2e smoke check.""" - fake_laddr = _LAddr("127.0.0.1", 4096) + fake_laddr = _LAddr("127.0.0.1", 8000) listening_conn = _Conn(0, 0, 0, fake_laddr, None, psutil.CONN_LISTEN, None) - proc = _make_proc(120, [OPENCODE_BIN, "serve", "--port", "4096"]) + proc = _make_proc(120, _UVICORN) proc.net_connections.return_value = [listening_conn] def _denied(kind="inet"): @@ -221,18 +190,18 @@ def _denied(kind="inet"): lambda attrs=None: iter([proc]), ) monkeypatch.setattr("cliff_cli.process_sweep.psutil.net_connections", _denied) - found = find_cliff_processes(CLIFF_HOME) + found = find_cliff_processes() assert len(found) == 1 assert found[0].pid == 120 # Critical: per-process fallback recovered the listening port. - assert 4096 in found[0].ports + assert 8000 in found[0].ports def test_macos_fallback_reports_squatter(monkeypatch): """End-to-end equivalent of the macOS gap caught during e2e verification: psutil.net_connections raises AccessDenied; squatter must still be reported via the per-process fallback.""" - fake_laddr = _LAddr("127.0.0.1", 4150) + fake_laddr = _LAddr("127.0.0.1", 8000) listening_conn = _Conn(0, 0, 0, fake_laddr, None, psutil.CONN_LISTEN, None) squatter_proc = _make_proc(200, ["python3", "-c", "import socket..."]) @@ -249,10 +218,10 @@ def _denied(kind="inet"): monkeypatch.setattr( "cliff_cli.process_sweep.psutil.Process", lambda pid: squatter_proc ) - squatters = find_port_squatters([4150], owned_pids=set()) + squatters = find_port_squatters([8000], owned_pids=set()) assert len(squatters) == 1 assert squatters[0].pid == 200 - assert squatters[0].port == 4150 + assert squatters[0].port == 8000 # --------------------------------------------------------------------------- @@ -263,37 +232,37 @@ def _denied(kind="inet"): def test_squatter_on_known_port_is_reported(monkeypatch): _patch_conns( monkeypatch, - [_Conn(0, 0, 0, _LAddr("127.0.0.1", 4096), None, psutil.CONN_LISTEN, 200)], + [_Conn(0, 0, 0, _LAddr("127.0.0.1", 8000), None, psutil.CONN_LISTEN, 200)], ) def _proc_factory(pid): - return _make_proc(pid, ["nc", "-l", "4096"]) + return _make_proc(pid, ["nc", "-l", "8000"]) monkeypatch.setattr("cliff_cli.process_sweep.psutil.Process", _proc_factory) - squatters = find_port_squatters([4096, 4100], owned_pids=set()) - assert squatters == [PortSquatter(pid=200, port=4096, cmdline="nc -l 4096")] + squatters = find_port_squatters([8000, 8765], owned_pids=set()) + assert squatters == [PortSquatter(pid=200, port=8000, cmdline="nc -l 8000")] def test_squatter_excludes_owned_pids(monkeypatch): _patch_conns( monkeypatch, - [_Conn(0, 0, 0, _LAddr("127.0.0.1", 4096), None, psutil.CONN_LISTEN, 201)], + [_Conn(0, 0, 0, _LAddr("127.0.0.1", 8000), None, psutil.CONN_LISTEN, 201)], ) - squatters = find_port_squatters([4096], owned_pids={201}) + squatters = find_port_squatters([8000], owned_pids={201}) assert squatters == [] def test_squatter_handles_inaccessible_process(monkeypatch): _patch_conns( monkeypatch, - [_Conn(0, 0, 0, _LAddr("127.0.0.1", 4096), None, psutil.CONN_LISTEN, 202)], + [_Conn(0, 0, 0, _LAddr("127.0.0.1", 8000), None, psutil.CONN_LISTEN, 202)], ) def _raise(pid): raise psutil.NoSuchProcess(pid) monkeypatch.setattr("cliff_cli.process_sweep.psutil.Process", _raise) - squatters = find_port_squatters([4096], owned_pids=set()) + squatters = find_port_squatters([8000], owned_pids=set()) assert len(squatters) == 1 assert squatters[0].cmdline == "" @@ -304,7 +273,7 @@ def _raise(pid): def test_kill_processes_sigterms_and_returns_killed(monkeypatch): - procs = [FoundProcess(pid=300, kind="opencode", cmdline="opencode serve")] + procs = [FoundProcess(pid=300, kind="uvicorn", cmdline="uvicorn cliff.main:app")] sent: list[tuple[int, int]] = [] def _kill(pid, sig): @@ -327,7 +296,7 @@ def _pid_exists(pid): def test_kill_processes_force_uses_sigkill(monkeypatch): - procs = [FoundProcess(pid=301, kind="opencode", cmdline="...")] + procs = [FoundProcess(pid=301, kind="uvicorn", cmdline="...")] sent: list[tuple[int, int]] = [] monkeypatch.setattr( "cliff_cli.process_sweep.os.kill", @@ -341,7 +310,7 @@ def test_kill_processes_force_uses_sigkill(monkeypatch): def test_kill_processes_escalates_to_sigkill_on_timeout(monkeypatch): - procs = [FoundProcess(pid=302, kind="opencode", cmdline="...")] + procs = [FoundProcess(pid=302, kind="uvicorn", cmdline="...")] sent: list[tuple[int, int]] = [] monkeypatch.setattr( "cliff_cli.process_sweep.os.kill", @@ -371,7 +340,7 @@ def _after_kill(pid, sig): def test_kill_processes_swallows_process_lookup_error(monkeypatch): - procs = [FoundProcess(pid=303, kind="opencode", cmdline="...")] + procs = [FoundProcess(pid=303, kind="uvicorn", cmdline="...")] def _kill(pid, sig): raise ProcessLookupError(pid) @@ -384,7 +353,7 @@ def _kill(pid, sig): def test_kill_processes_returns_still_alive_when_kill_fails(monkeypatch): - procs = [FoundProcess(pid=304, kind="opencode", cmdline="...")] + procs = [FoundProcess(pid=304, kind="uvicorn", cmdline="...")] monkeypatch.setattr("cliff_cli.process_sweep.os.kill", lambda *_: None) monkeypatch.setattr("cliff_cli.process_sweep.psutil.pid_exists", lambda pid: True) monkeypatch.setattr("cliff_cli.process_sweep.time.sleep", lambda *_: None) diff --git a/cli/tests/test_updater.py b/cli/tests/test_updater.py index 154e4979..703670ed 100644 --- a/cli/tests/test_updater.py +++ b/cli/tests/test_updater.py @@ -197,7 +197,6 @@ def test_update_happy_path_replaces_install(fake_install, httpx_mock, monkeypatc _build_tarball( { "VERSION": b"0.1.7-alpha\n", - "scripts/install-opencode.sh": b"#!/bin/sh\nexit 0\n", "scripts/install-scanners.sh": b"#!/bin/sh\nexit 0\n", }, tar_path, @@ -228,7 +227,6 @@ class _R: assert (home / "app" / "VERSION").read_text().strip() == "0.1.7-alpha" assert "Updated 0.1.6-alpha -> 0.1.7-alpha" in res.output # Both bundled installers were run. - assert any("install-opencode.sh" in " ".join(c) for c in sh_calls) assert any("install-scanners.sh" in " ".join(c) for c in sh_calls) # Snapshots were cleaned up. assert not (home / "app.bak-0.1.6-alpha").exists() @@ -251,7 +249,6 @@ def test_update_rolls_back_on_doctor_failure( _build_tarball( { "VERSION": b"0.1.7-alpha\n", - "scripts/install-opencode.sh": b"#!/bin/sh\nexit 0\n", "scripts/install-scanners.sh": b"#!/bin/sh\nexit 0\n", }, tar_path, @@ -300,7 +297,6 @@ def test_update_force_reinstalls_same_version( sha_url = tar_url + ".sha256" tar_path = tmp_path / "fake.tar.gz" _build_tarball({"VERSION": b"0.1.6-alpha\n", - "scripts/install-opencode.sh": b"#!/bin/sh\n", "scripts/install-scanners.sh": b"#!/bin/sh\n"}, tar_path) httpx_mock.add_response(url=tar_url, content=tar_path.read_bytes()) httpx_mock.add_response(url=sha_url, status_code=404) @@ -352,7 +348,6 @@ def test_verify_tarball_shape_accepts_valid_tarball(tmp_path): _build_tarball( { "VERSION": b"0.1.7\n", - "scripts/install-opencode.sh": b"#!/bin/sh\n", "scripts/install-scanners.sh": b"#!/bin/sh\n", }, src, @@ -446,7 +441,6 @@ def test_update_aborts_on_bad_checksum_without_touching_install( _build_tarball( { "VERSION": b"0.1.7-alpha\n", - "scripts/install-opencode.sh": b"#!/bin/sh\n", "scripts/install-scanners.sh": b"#!/bin/sh\n", }, tar_path, @@ -504,7 +498,6 @@ def _setup_one_failed_run(version: str): _build_tarball( { "VERSION": f"{version}\n".encode(), - "scripts/install-opencode.sh": b"#!/bin/sh\n", "scripts/install-scanners.sh": b"#!/bin/sh\n", }, tarball, @@ -558,7 +551,6 @@ def test_rollback_survives_partial_rmtree( _build_tarball( { "VERSION": b"0.1.7-alpha\n", - "scripts/install-opencode.sh": b"#!/bin/sh\n", "scripts/install-scanners.sh": b"#!/bin/sh\n", }, tarball, diff --git a/docker/Dockerfile b/docker/Dockerfile index e3a3b286..d34b8f3a 100644 --- a/docker/Dockerfile +++ b/docker/Dockerfile @@ -1,7 +1,7 @@ # ============================================================================= # Cliff — Multi-stage Docker build # Stage 1: Build frontend (Node) -# Stage 2: Production runtime (Python + OpenCode Go binary) +# Stage 2: Production runtime (Python) # ============================================================================= # Build-time args propagated through both stages so the resulting image @@ -50,7 +50,7 @@ LABEL org.opencontainers.image.title="Cliff" \ org.opencontainers.image.revision="${CLIFF_REVISION}" \ org.opencontainers.image.created="${CLIFF_CREATED}" -# System dependencies: supervisor, curl, git for health checks, cloning, and OpenCode download +# System dependencies: supervisor, curl, git for health checks and cloning RUN apt-get update && \ apt-get install -y --no-install-recommends \ supervisor \ @@ -83,9 +83,8 @@ RUN groupadd --system --gid 10001 cliff \ WORKDIR /app -# Copy version file first (read at runtime; also referenced by install script) +# Copy version file first (read at runtime). COPY VERSION /app/VERSION -COPY .opencode-version ./ # Ship the AGPL-3.0 LICENSE plus the NOTICE and third-party license # inventory inside the image so that distribution carries the required @@ -94,14 +93,11 @@ COPY LICENSE /app/LICENSE COPY NOTICE /app/NOTICE COPY THIRD-PARTY-LICENSES.md /app/THIRD-PARTY-LICENSES.md -# Copy and run OpenCode install script (non-fatal if download fails) -COPY scripts/install-opencode.sh ./scripts/ ENV CLIFF_BIN_DIR=/app/bin -RUN bash scripts/install-opencode.sh || echo "WARNING: OpenCode download failed — engine will be unavailable" # PRD-0003 v0.2 — Trivy + Semgrep binaries for the assessment engine -# (ADR-0028 subprocess-only execution). Both land in /app/bin alongside -# OpenCode; CLIFF_SCANNER_BIN_DIR points the runner at this directory. +# (ADR-0028 subprocess-only execution). Both land in /app/bin; +# CLIFF_SCANNER_BIN_DIR points the runner at this directory. ARG TRIVY_VERSION=0.70.0 RUN ARCH="$(dpkg --print-architecture)" \ && case "$ARCH" in \ @@ -147,10 +143,6 @@ COPY backend/ ./backend/ # Copy built frontend from stage 1 COPY --from=frontend-builder /build/frontend/dist ./frontend/dist -# Copy OpenCode project config and agent definitions -COPY opencode.json ./ -COPY .opencode/ ./.opencode/ - # Copy supervisor and entrypoint configs COPY docker/supervisord.conf /etc/supervisor/conf.d/cliff.conf COPY docker/entrypoint.sh /app/entrypoint.sh @@ -165,9 +157,6 @@ RUN chown -R cliff:cliff /app # --------------------------------------------------------------------------- ENV CLIFF_APP_HOST=0.0.0.0 \ CLIFF_APP_PORT=8000 \ - CLIFF_OPENCODE_HOST=127.0.0.1 \ - CLIFF_OPENCODE_PORT=4096 \ - CLIFF_OPENCODE_BIN=/app/bin/opencode \ CLIFF_SCANNER_BIN_DIR=/app/bin \ CLIFF_DATA_DIR=/data \ CLIFF_OAUTH_CALLBACK_HOST=0.0.0.0 \ diff --git a/docker/entrypoint.sh b/docker/entrypoint.sh index 0596639c..f99f0ac4 100644 --- a/docker/entrypoint.sh +++ b/docker/entrypoint.sh @@ -16,8 +16,6 @@ VERSION="$(cat /app/VERSION 2>/dev/null || echo unknown)" echo "=== Cliff ${VERSION} ===" echo " Data dir: $DATA_DIR" echo " App port: ${CLIFF_APP_PORT:-8000}" -echo " Engine port: ${CLIFF_OPENCODE_PORT:-4096}" -echo " Engine bin: ${CLIFF_OPENCODE_BIN:-/app/bin/opencode}" echo " Running as: $(id -un) (uid=$(id -u))" echo "===============" diff --git a/frontend/src/__tests__/PostureCheckItem.state-machine.test.tsx b/frontend/src/__tests__/PostureCheckItem.state-machine.test.tsx index 38ab6db2..367bb747 100644 --- a/frontend/src/__tests__/PostureCheckItem.state-machine.test.tsx +++ b/frontend/src/__tests__/PostureCheckItem.state-machine.test.tsx @@ -92,7 +92,7 @@ describe(' state machine', () => { checkName="security_md" state="failed" label="SECURITY.md is missing" - error="OpenCode crashed mid-commit" + error="agent crashed mid-commit" /> , ) @@ -112,7 +112,7 @@ describe(' state machine', () => { ).toBeInTheDocument() // Error text remains available for screen readers. expect( - screen.getByText('OpenCode crashed mid-commit'), + screen.getByText('agent crashed mid-commit'), ).toHaveClass('sr-only') }) }) diff --git a/frontend/src/api/client.ts b/frontend/src/api/client.ts index 4bf05827..27a6564c 100644 --- a/frontend/src/api/client.ts +++ b/frontend/src/api/client.ts @@ -287,13 +287,6 @@ export interface ProviderInfo { }>; } -export interface ApiKeyInfo { - provider: string; - key_masked: string; - has_credentials: boolean; - updated_at: string | null; -} - export interface IntegrationConfigItem { id: string; adapter_type: string; @@ -499,22 +492,6 @@ export const api = { // Health health: () => request('/health'), - // Workspace-scoped sessions (isolated per-workspace OpenCode process) - createWorkspaceSession: (workspaceId: string) => - request<{ session_id: string; workspace_id: string }>( - `/api/workspaces/${workspaceId}/sessions`, - { method: 'POST' }, - ), - - // Workspace-scoped chat (isolated per-workspace OpenCode process) - sendWorkspaceMessage: (workspaceId: string, sessionId: string, content: string) => - request<{ session_id: string; status: string }>( - `/api/workspaces/${workspaceId}/chat/send`, - { method: 'POST', body: JSON.stringify({ session_id: sessionId, content }) }, - ), - streamWorkspaceEvents: (workspaceId: string, sessionId: string): EventSource => - new EventSource(`/api/workspaces/${workspaceId}/chat/stream?session_id=${sessionId}`), - // Findings listFindings: (params?: { status?: string; @@ -636,20 +613,6 @@ export const api = { // Settings — Providers listProviders: () => request('/api/settings/providers'), - getConfiguredProviders: () => - request<{ providers: unknown; auth: Record }>( - '/api/settings/providers/configured', - ), - - // Settings — API Keys - listApiKeys: () => request('/api/settings/api-keys'), - setApiKey: (provider: string, key: string) => - request(`/api/settings/api-keys/${provider}`, { - method: 'PUT', - body: JSON.stringify({ provider, key }), - }), - deleteApiKey: (provider: string) => - requestVoid(`/api/settings/api-keys/${provider}`, { method: 'DELETE' }), // Settings — Integrations listIntegrations: () => @@ -759,13 +722,6 @@ export const api = { { method: 'POST', body: JSON.stringify({ approved }) }, ), - // Permission approval (chat path — calls OpenCode directly) - respondToChatPermission: (workspaceId: string, permissionId: string, sessionId: string, approved: boolean) => - request<{ status: string; permission_id: string }>( - `/api/workspaces/${workspaceId}/chat/permission`, - { method: 'POST', body: JSON.stringify({ permission_id: permissionId, session_id: sessionId, approved }) }, - ), - // Completion share-action recording (EXEC-0002 / IMPL-0002 H5). // Frozen contract: POST /api/completion/{id}/share-action returns HTTP 200 // with { completion_id, share_actions_used }. Frontend treats it as diff --git a/frontend/src/api/hooks.ts b/frontend/src/api/hooks.ts index a7813e75..33e83081 100644 --- a/frontend/src/api/hooks.ts +++ b/frontend/src/api/hooks.ts @@ -436,48 +436,6 @@ export function useProviders() { }) } -export function useConfiguredProviders() { - return useQuery({ - queryKey: ['configured-providers'], - queryFn: () => api.getConfiguredProviders(), - }) -} - -// --------------------------------------------------------------------------- -// Settings — API Keys -// --------------------------------------------------------------------------- - -export function useApiKeys() { - return useQuery({ - queryKey: ['api-keys'], - queryFn: () => api.listApiKeys(), - }) -} - -export function useSetApiKey() { - const qc = useQueryClient() - return useMutation({ - mutationFn: ({ provider, key }: { provider: string; key: string }) => - api.setApiKey(provider, key), - onSuccess: () => { - qc.invalidateQueries({ queryKey: ['api-keys'] }) - qc.invalidateQueries({ queryKey: ['configured-providers'] }) - qc.invalidateQueries({ queryKey: ['health'] }) - }, - }) -} - -export function useDeleteApiKey() { - const qc = useQueryClient() - return useMutation({ - mutationFn: (provider: string) => api.deleteApiKey(provider), - onSuccess: () => { - qc.invalidateQueries({ queryKey: ['api-keys'] }) - qc.invalidateQueries({ queryKey: ['configured-providers'] }) - }, - }) -} - // --------------------------------------------------------------------------- // Settings — Integrations // --------------------------------------------------------------------------- diff --git a/frontend/src/api/types.ts b/frontend/src/api/types.ts index bd7c8531..55079379 100644 --- a/frontend/src/api/types.ts +++ b/frontend/src/api/types.ts @@ -132,51 +132,6 @@ export interface paths { patch?: never; trace?: never; }; - "/api/chat/{session_id}/send": { - parameters: { - query?: never; - header?: never; - path?: never; - cookie?: never; - }; - get?: never; - put?: never; - /** - * Send Message - * @description Send a message to an OpenCode session. - */ - post: operations["send_message_api_chat__session_id__send_post"]; - delete?: never; - options?: never; - head?: never; - patch?: never; - trace?: never; - }; - "/api/chat/{session_id}/stream": { - parameters: { - query?: never; - header?: never; - path?: never; - cookie?: never; - }; - /** - * Stream Events - * @description Stream SSE events from an OpenCode session to the browser. - * - * Emits three event types: - * - event: text, data: - * - event: error, data: {"message": "..."} - * - event: done, data: {} - */ - get: operations["stream_events_api_chat__session_id__stream_get"]; - put?: never; - post?: never; - delete?: never; - options?: never; - head?: never; - patch?: never; - trace?: never; - }; "/api/completion/{completion_id}": { parameters: { query?: never; @@ -394,27 +349,27 @@ export interface paths { patch?: never; trace?: never; }; - "/api/onboarding/complete": { + "/api/integrations/ai/autodetect": { parameters: { query?: never; header?: never; path?: never; cookie?: never; }; - get?: never; - put?: never; /** - * Complete Onboarding - * @description Mark onboarding as complete once the first assessment finishes. + * Autodetect Scan + * @description Scan common locations for existing AI keys. Never returns the key. */ - post: operations["complete_onboarding_api_onboarding_complete_post"]; + get: operations["autodetect_scan_api_integrations_ai_autodetect_get"]; + put?: never; + post?: never; delete?: never; options?: never; head?: never; patch?: never; trace?: never; }; - "/api/onboarding/github/repos": { + "/api/integrations/ai/autodetect/adopt": { parameters: { query?: never; header?: never; @@ -424,24 +379,21 @@ export interface paths { get?: never; put?: never; /** - * List Github Repos - * @description Return the repos a PAT can reach, for onboarding's picker step. - * - * The token is **not** persisted here — only on a successful call to - * ``POST /onboarding/repo``. Avoids dangling vault entries when the user - * abandons the flow at the picker. + * Autodetect Adopt + * @description Re-scan, validate, and persist a detected key. * - * Auth/scope failures return 422 ``{code: "invalid_token"}``. Network and - * GitHub 5xx return 502 — onboarding's manual-URL fallback covers this. + * Re-running the scan inside the handler (rather than trusting the + * earlier GET) keeps adoption coherent if the user changed their env + * between clicks. */ - post: operations["list_github_repos_api_onboarding_github_repos_post"]; + post: operations["autodetect_adopt_api_integrations_ai_autodetect_adopt_post"]; delete?: never; options?: never; head?: never; patch?: never; trace?: never; }; - "/api/onboarding/repo": { + "/api/integrations/ai/byok": { parameters: { query?: never; header?: never; @@ -451,45 +403,43 @@ export interface paths { get?: never; put?: never; /** - * Connect Repo - * @description Register a repo and kick off the initial assessment. - * - * Returns ``OnboardingRepoResponse`` on success. On hard probe failures - * returns a ``JSONResponse`` with ``{detail, code}`` at 422 — the SPA - * branches on ``code`` (e.g. ``missing_repo_scope``). + * Byok + * @description Validate + persist a directly-pasted API key. */ - post: operations["connect_repo_api_onboarding_repo_post"]; + post: operations["byok_api_integrations_ai_byok_post"]; delete?: never; options?: never; head?: never; patch?: never; trace?: never; }; - "/api/posture/fix/status/{workspace_id}": { + "/api/integrations/ai/disconnect": { parameters: { query?: never; header?: never; path?: never; cookie?: never; }; + get?: never; + put?: never; /** - * Get Posture Fix Status - * @description Return the current status of a posture-fix agent run. + * Disconnect + * @description Clear the active AI integration locally. * - * Polled by the UI after ``POST /posture/fix/{check_name}`` returns a - * workspace id. Reads from ``data/workspaces//history/status.json`` - * — no DB involvement; status is workspace-local state. + * Idempotent: returns 204 whether or not there was anything to clear. + * Surface-area note: revoking OpenRouter keys server-side would require + * OpenRouter's client_secret, which we deliberately don't ship in the + * self-hosted code path (ADR-0036). The frontend surfaces the + * openrouter.ai/settings/keys link separately. */ - get: operations["get_posture_fix_status_api_posture_fix_status__workspace_id__get"]; - put?: never; - post?: never; + post: operations["disconnect_api_integrations_ai_disconnect_post"]; delete?: never; options?: never; head?: never; patch?: never; trace?: never; }; - "/api/posture/fix/{check_name}": { + "/api/integrations/ai/model": { parameters: { query?: never; header?: never; @@ -497,69 +447,72 @@ export interface paths { cookie?: never; }; get?: never; - put?: never; /** - * Fix Posture Check - * @description Spawn a repo-workspace with the appropriate generator agent. + * Set Active Model + * @description Change the canonical active model. * - * ``body`` is optional: existing callers that POST an empty body still work - * and the generator templates fall back to placeholders. When the UI sends - * ``contact_email`` (or other template params), we thread them through the - * spawner so the rendered prompt substitutes them verbatim and the - * maintainer gets a PR that needs fewer edits. + * Validates that the model id's provider prefix matches the active + * integration. Workspace spawns pick up the new model immediately + * via the model resolver; the singleton restarts so chat sessions + * re-init against the new model on next request. */ - post: operations["fix_posture_check_api_posture_fix__check_name__post"]; + put: operations["set_active_model_api_integrations_ai_model_put"]; + post?: never; delete?: never; options?: never; head?: never; patch?: never; trace?: never; }; - "/api/seed": { + "/api/integrations/ai/models": { parameters: { query?: never; header?: never; path?: never; cookie?: never; }; - get?: never; - put?: never; /** - * Seed Demo Data - * @description Seed demo findings. Skips if findings already exist. + * List Provider Models + * @description Return the model picker options for *provider*. + * + * For Ollama this hits ``{base_url}/api/tags`` so the picker reflects + * what the user has actually pulled. The base URL comes from the + * active integration's stored metadata if it matches *provider*, + * else the catalog default (``http://localhost:11434``). */ - post: operations["seed_demo_data_api_seed_post"]; + get: operations["list_provider_models_api_integrations_ai_models_get"]; + put?: never; + post?: never; delete?: never; options?: never; head?: never; patch?: never; trace?: never; }; - "/api/sessions": { + "/api/integrations/ai/openrouter/start": { parameters: { query?: never; header?: never; path?: never; cookie?: never; }; - /** - * List Sessions - * @description List all active sessions. - */ - get: operations["list_sessions_api_sessions_get"]; + get?: never; put?: never; /** - * Create Session - * @description Create a new OpenCode session. + * Openrouter Start + * @description Begin an OAuth PKCE handshake. + * + * Mints a session, starts a one-shot listener on port 3000, returns the + * auth URL the frontend should open in a new tab. */ - post: operations["create_session_api_sessions_post"]; + post: operations["openrouter_start_api_integrations_ai_openrouter_start_post"]; delete?: never; options?: never; head?: never; patch?: never; trace?: never; }; - "/api/sessions/{session_id}": { + "/api/integrations/ai/openrouter/status": { parameters: { query?: never; header?: never; @@ -567,10 +520,10 @@ export interface paths { cookie?: never; }; /** - * Get Session - * @description Get session details including message history. + * Openrouter Status + * @description Frontend polls this every ~1s while a session is in flight. */ - get: operations["get_session_api_sessions__session_id__get"]; + get: operations["openrouter_status_api_integrations_ai_openrouter_status_get"]; put?: never; post?: never; delete?: never; @@ -579,15 +532,15 @@ export interface paths { patch?: never; trace?: never; }; - "/api/settings/api-keys": { + "/api/integrations/ai/status": { parameters: { query?: never; header?: never; path?: never; cookie?: never; }; - /** List Api Keys */ - get: operations["list_api_keys_api_settings_api_keys_get"]; + /** Status */ + get: operations["status_api_integrations_ai_status_get"]; put?: never; post?: never; delete?: never; @@ -596,7 +549,7 @@ export interface paths { patch?: never; trace?: never; }; - "/api/settings/api-keys/{provider}": { + "/api/integrations/github/connect": { parameters: { query?: never; header?: never; @@ -604,35 +557,16 @@ export interface paths { cookie?: never; }; get?: never; - /** Set Api Key */ - put: operations["set_api_key_api_settings_api_keys__provider__put"]; - post?: never; - /** Delete Api Key */ - delete: operations["delete_api_key_api_settings_api_keys__provider__delete"]; - options?: never; - head?: never; - patch?: never; - trace?: never; - }; - "/api/settings/integrations": { - parameters: { - query?: never; - header?: never; - path?: never; - cookie?: never; - }; - /** List Integrations Endpoint */ - get: operations["list_integrations_endpoint_api_settings_integrations_get"]; put?: never; - /** Create Integration Endpoint */ - post: operations["create_integration_endpoint_api_settings_integrations_post"]; + /** Connect */ + post: operations["connect_api_integrations_github_connect_post"]; delete?: never; options?: never; head?: never; patch?: never; trace?: never; }; - "/api/settings/integrations/health": { + "/api/integrations/github/diagnose": { parameters: { query?: never; header?: never; @@ -640,10 +574,26 @@ export interface paths { cookie?: never; }; /** - * Check All Integrations Health - * @description Run health checks for all enabled integrations. + * Diagnose Push Access + * @description Verify push access for the currently-configured GitHub repo. + * + * Resolution path (same as the executor preflight, so the badge and + * the 412 page agree by construction): + * + * 1. ``_resolve_repo_env_vars`` reads the GitHub integration row + + * vault token. Returns an empty dict if no enabled GitHub + * integration exists. + * 2. Parse ``owner/repo`` out of ``CLIFF_REPO_URL``. A non-GitHub + * remote is treated as "nothing to diagnose" and falls through to + * 404 — the badge is GitHub-App-specific. + * 3. Call :func:`check_repo_push_access` with the stored token. That + * helper already returns UI-safe ``reason`` strings; we pass the + * result through untouched. + * + * The result is cached per repo URL for 5 minutes. ``?refresh=1`` + * forces a fresh GitHub call. */ - get: operations["check_all_integrations_health_api_settings_integrations_health_get"]; + get: operations["diagnose_push_access_api_integrations_github_diagnose_get"]; put?: never; post?: never; delete?: never; @@ -652,129 +602,137 @@ export interface paths { patch?: never; trace?: never; }; - "/api/settings/integrations/registry": { + "/api/integrations/github/disconnect": { parameters: { query?: never; header?: never; path?: never; cookie?: never; }; - /** - * List Registry - * @description List all available integrations from the builtin registry. - */ - get: operations["list_registry_api_settings_integrations_registry_get"]; + get?: never; put?: never; - post?: never; + /** Disconnect */ + post: operations["disconnect_api_integrations_github_disconnect_post"]; delete?: never; options?: never; head?: never; patch?: never; trace?: never; }; - "/api/settings/integrations/registry/{entry_id}": { + "/api/integrations/github/poll-now": { parameters: { query?: never; header?: never; path?: never; cookie?: never; }; + get?: never; + put?: never; /** - * Get Registry Entry Endpoint - * @description Get a single registry entry with full setup guide. + * Poll Now + * @description Force an immediate poll tick + return the resulting status. + * + * The background polling loop honors GitHub's stored interval (5s + * minimum, often higher after a ``slow_down``). When the user clicks + * Authorize and comes back to Cliff, they shouldn't have to wait + * for the next scheduled tick — the SPA hits this endpoint on the + * visibility-change event so the modal flips to Connected within + * one round-trip instead of up to a minute. */ - get: operations["get_registry_entry_endpoint_api_settings_integrations_registry__entry_id__get"]; - put?: never; - post?: never; + post: operations["poll_now_api_integrations_github_poll_now_post"]; delete?: never; options?: never; head?: never; patch?: never; trace?: never; }; - "/api/settings/integrations/{integration_id}": { + "/api/integrations/github/setup": { parameters: { query?: never; header?: never; path?: never; cookie?: never; }; - get?: never; - /** Update Integration Endpoint */ - put: operations["update_integration_endpoint_api_settings_integrations__integration_id__put"]; + /** Setup Callback */ + get: operations["setup_callback_api_integrations_github_setup_get"]; + put?: never; post?: never; - /** Delete Integration Endpoint */ - delete: operations["delete_integration_endpoint_api_settings_integrations__integration_id__delete"]; + delete?: never; options?: never; head?: never; patch?: never; trace?: never; }; - "/api/settings/integrations/{integration_id}/credentials": { + "/api/integrations/github/setup/manual": { parameters: { query?: never; header?: never; path?: never; cookie?: never; }; - /** - * List Credentials - * @description List credential key names for an integration (no values). - */ - get: operations["list_credentials_api_settings_integrations__integration_id__credentials_get"]; + get?: never; put?: never; /** - * Store Credential - * @description Store an encrypted credential for an integration. + * Setup Manual + * @description Manual recovery for B33 — accept an ``installation_id`` posted from + * the SPA when the GET callback never fired. + * + * The shared ``opensec-local-test`` GitHub App's Setup URL is globally + * hardcoded to ``http://localhost:8000/api/integrations/github/setup`` + * on github.com. Any Cliff deployment bound to a different host port + * (Docker remap, parallel dev stack, reverse proxy) never receives + * the GET callback. This endpoint lets the user paste the + * ``installation_id`` from the redirect URL they ended up on — Cliff + * then drives the same registration code path as the GET callback, + * *including the CSRF state check* that prevents an attacker who + * tricks the user into pasting a hostile ``installation_id`` from + * binding it. */ - post: operations["store_credential_api_settings_integrations__integration_id__credentials_post"]; + post: operations["setup_manual_api_integrations_github_setup_manual_post"]; delete?: never; options?: never; head?: never; patch?: never; trace?: never; }; - "/api/settings/integrations/{integration_id}/credentials/{key_name}": { + "/api/integrations/github/status": { parameters: { query?: never; header?: never; path?: never; cookie?: never; }; - get?: never; + /** Status */ + get: operations["status_api_integrations_github_status_get"]; put?: never; post?: never; - /** - * Delete Credential - * @description Delete a single credential. - */ - delete: operations["delete_credential_api_settings_integrations__integration_id__credentials__key_name__delete"]; + delete?: never; options?: never; head?: never; patch?: never; trace?: never; }; - "/api/settings/integrations/{integration_id}/health": { + "/api/onboarding/complete": { parameters: { query?: never; header?: never; path?: never; cookie?: never; }; + get?: never; + put?: never; /** - * Check Integration Health - * @description Run a health check for a single integration. + * Complete Onboarding + * @description Mark onboarding as complete once the first assessment finishes. */ - get: operations["check_integration_health_api_settings_integrations__integration_id__health_get"]; - put?: never; - post?: never; + post: operations["complete_onboarding_api_onboarding_complete_post"]; delete?: never; options?: never; head?: never; patch?: never; trace?: never; }; - "/api/settings/integrations/{integration_id}/test": { + "/api/onboarding/github/repos": { parameters: { query?: never; header?: never; @@ -784,43 +742,64 @@ export interface paths { get?: never; put?: never; /** - * Test Connection - * @description Test an integration's credentials by verifying they can be decrypted. + * List Github Repos + * @description Return the repos the active GitHub auth can reach, for onboarding's picker. + * + * Token resolution: explicit ``github_token`` body wins (legacy PAT + * flow), otherwise the route reads the App-flow user access token + * from the vault. The token is **not** persisted here — only on a + * successful call to ``POST /onboarding/repo``. + * + * Auth/scope failures return 422 ``{code: "invalid_token"}``. Network and + * GitHub 5xx return 502 — onboarding's manual-URL fallback covers this. */ - post: operations["test_connection_api_settings_integrations__integration_id__test_post"]; + post: operations["list_github_repos_api_onboarding_github_repos_post"]; delete?: never; options?: never; head?: never; patch?: never; trace?: never; }; - "/api/settings/model": { + "/api/onboarding/repo": { parameters: { query?: never; header?: never; path?: never; cookie?: never; }; - /** Get Model */ - get: operations["get_model_api_settings_model_get"]; - /** Update Model */ - put: operations["update_model_api_settings_model_put"]; - post?: never; + get?: never; + put?: never; + /** + * Connect Repo + * @description Register a repo and kick off the initial assessment. + * + * Returns ``OnboardingRepoResponse`` on success. On hard probe failures + * returns a ``JSONResponse`` with ``{detail, code}`` at 422 — the SPA + * branches on ``code`` (e.g. ``missing_repo_scope``). + */ + post: operations["connect_repo_api_onboarding_repo_post"]; delete?: never; options?: never; head?: never; patch?: never; trace?: never; }; - "/api/settings/providers": { + "/api/posture/fix/status/{workspace_id}": { parameters: { query?: never; header?: never; path?: never; cookie?: never; }; - /** List Providers */ - get: operations["list_providers_api_settings_providers_get"]; + /** + * Get Posture Fix Status + * @description Return the current status of a posture-fix agent run. + * + * Polled by the UI after ``POST /posture/fix/{check_name}`` returns a + * workspace id. Reads from ``data/workspaces//history/status.json`` + * — no DB involvement; status is workspace-local state. + */ + get: operations["get_posture_fix_status_api_posture_fix_status__workspace_id__get"]; put?: never; post?: never; delete?: never; @@ -829,24 +808,33 @@ export interface paths { patch?: never; trace?: never; }; - "/api/settings/providers/configured": { + "/api/posture/fix/{check_name}": { parameters: { query?: never; header?: never; path?: never; cookie?: never; }; - /** Get Configured Providers */ - get: operations["get_configured_providers_api_settings_providers_configured_get"]; + get?: never; put?: never; - post?: never; + /** + * Fix Posture Check + * @description Spawn a repo-workspace with the appropriate generator agent. + * + * ``body`` is optional: existing callers that POST an empty body still work + * and the generator templates fall back to placeholders. When the UI sends + * ``contact_email`` (or other template params), we thread them through the + * spawner so the rendered prompt substitutes them verbatim and the + * maintainer gets a PR that needs fewer edits. + */ + post: operations["fix_posture_check_api_posture_fix__check_name__post"]; delete?: never; options?: never; head?: never; patch?: never; trace?: never; }; - "/api/settings/providers/test": { + "/api/seed": { parameters: { query?: never; header?: never; @@ -856,82 +844,75 @@ export interface paths { get?: never; put?: never; /** - * Test Provider - * @description Cheap probe of the configured provider+model (ADR-0031). - * - * Sends a bounded ``"Say OK"`` chat call through OpenCode with an 8s - * timeout and classifies the outcome into - * ``{ok, latency_ms, error_code, error_message}``. Always returns HTTP - * 200; ``ok`` reflects the probe result. + * Seed Demo Data + * @description Seed demo findings. Skips if findings already exist. */ - post: operations["test_provider_api_settings_providers_test_post"]; + post: operations["seed_demo_data_api_seed_post"]; delete?: never; options?: never; head?: never; patch?: never; trace?: never; }; - "/api/version": { + "/api/settings/integrations": { parameters: { query?: never; header?: never; path?: never; cookie?: never; }; - /** Get Version */ - get: operations["get_version_api_version_get"]; + /** List Integrations Endpoint */ + get: operations["list_integrations_endpoint_api_settings_integrations_get"]; put?: never; - post?: never; + /** Create Integration Endpoint */ + post: operations["create_integration_endpoint_api_settings_integrations_post"]; delete?: never; options?: never; head?: never; patch?: never; trace?: never; }; - "/api/workspaces": { + "/api/settings/integrations/health": { parameters: { query?: never; header?: never; path?: never; cookie?: never; }; - /** List Workspaces Endpoint */ - get: operations["list_workspaces_endpoint_api_workspaces_get"]; - put?: never; /** - * Create Workspace Endpoint - * @description Create a workspace with isolated directory and rendered agents. + * Check All Integrations Health + * @description Run health checks for all enabled integrations. */ - post: operations["create_workspace_endpoint_api_workspaces_post"]; + get: operations["check_all_integrations_health_api_settings_integrations_health_get"]; + put?: never; + post?: never; delete?: never; options?: never; head?: never; patch?: never; trace?: never; }; - "/api/workspaces/{workspace_id}": { + "/api/settings/integrations/registry": { parameters: { query?: never; header?: never; path?: never; cookie?: never; }; - /** Get Workspace Endpoint */ - get: operations["get_workspace_endpoint_api_workspaces__workspace_id__get"]; - put?: never; - post?: never; /** - * Delete Workspace Endpoint - * @description Delete workspace: stop process, remove directory, delete DB row. + * List Registry + * @description List all available integrations from the builtin registry. */ - delete: operations["delete_workspace_endpoint_api_workspaces__workspace_id__delete"]; + get: operations["list_registry_api_settings_integrations_registry_get"]; + put?: never; + post?: never; + delete?: never; options?: never; head?: never; - /** Update Workspace Endpoint */ - patch: operations["update_workspace_endpoint_api_workspaces__workspace_id__patch"]; + patch?: never; trace?: never; }; - "/api/workspaces/{workspace_id}/agent-execution/stream": { + "/api/settings/integrations/registry/{entry_id}": { parameters: { query?: never; header?: never; @@ -939,17 +920,10 @@ export interface paths { cookie?: never; }; /** - * Stream Agent Execution - * @description Stream permission_request and done events during agent execution. - * - * The frontend connects to this while an agent is running. Events: - * - permission_request: agent needs user approval for a tool - * - done: agent execution has completed (success or failure) - * - * If the client disconnects while a permission is pending, the pending - * approval is auto-denied to unblock the executor. + * Get Registry Entry Endpoint + * @description Get a single registry entry with full setup guide. */ - get: operations["stream_agent_execution_api_workspaces__workspace_id__agent_execution_stream_get"]; + get: operations["get_registry_entry_endpoint_api_settings_integrations_registry__entry_id__get"]; put?: never; post?: never; delete?: never; @@ -958,43 +932,49 @@ export interface paths { patch?: never; trace?: never; }; - "/api/workspaces/{workspace_id}/agent-runs": { + "/api/settings/integrations/{integration_id}": { parameters: { query?: never; header?: never; path?: never; cookie?: never; }; - /** List Agent Runs Endpoint */ - get: operations["list_agent_runs_endpoint_api_workspaces__workspace_id__agent_runs_get"]; - put?: never; - /** Create Agent Run Endpoint */ - post: operations["create_agent_run_endpoint_api_workspaces__workspace_id__agent_runs_post"]; - delete?: never; + get?: never; + /** Update Integration Endpoint */ + put: operations["update_integration_endpoint_api_settings_integrations__integration_id__put"]; + post?: never; + /** Delete Integration Endpoint */ + delete: operations["delete_integration_endpoint_api_settings_integrations__integration_id__delete"]; options?: never; head?: never; patch?: never; trace?: never; }; - "/api/workspaces/{workspace_id}/agent-runs/{run_id}": { + "/api/settings/integrations/{integration_id}/credentials": { parameters: { query?: never; header?: never; path?: never; cookie?: never; }; - /** Get Agent Run Endpoint */ - get: operations["get_agent_run_endpoint_api_workspaces__workspace_id__agent_runs__run_id__get"]; + /** + * List Credentials + * @description List credential key names for an integration (no values). + */ + get: operations["list_credentials_api_settings_integrations__integration_id__credentials_get"]; put?: never; - post?: never; + /** + * Store Credential + * @description Store an encrypted credential for an integration. + */ + post: operations["store_credential_api_settings_integrations__integration_id__credentials_post"]; delete?: never; options?: never; head?: never; - /** Update Agent Run Endpoint */ - patch: operations["update_agent_run_endpoint_api_workspaces__workspace_id__agent_runs__run_id__patch"]; + patch?: never; trace?: never; }; - "/api/workspaces/{workspace_id}/agent-runs/{run_id}/cancel": { + "/api/settings/integrations/{integration_id}/credentials/{key_name}": { parameters: { query?: never; header?: never; @@ -1003,18 +983,38 @@ export interface paths { }; get?: never; put?: never; + post?: never; /** - * Cancel Agent Run - * @description Cancel a running agent run. + * Delete Credential + * @description Delete a single credential. */ - post: operations["cancel_agent_run_api_workspaces__workspace_id__agent_runs__run_id__cancel_post"]; + delete: operations["delete_credential_api_settings_integrations__integration_id__credentials__key_name__delete"]; + options?: never; + head?: never; + patch?: never; + trace?: never; + }; + "/api/settings/integrations/{integration_id}/health": { + parameters: { + query?: never; + header?: never; + path?: never; + cookie?: never; + }; + /** + * Check Integration Health + * @description Run a health check for a single integration. + */ + get: operations["check_integration_health_api_settings_integrations__integration_id__health_get"]; + put?: never; + post?: never; delete?: never; options?: never; head?: never; patch?: never; trace?: never; }; - "/api/workspaces/{workspace_id}/agent-runs/{run_id}/permission": { + "/api/settings/integrations/{integration_id}/test": { parameters: { query?: never; header?: never; @@ -1024,67 +1024,77 @@ export interface paths { get?: never; put?: never; /** - * Respond To Permission - * @description Approve or deny a pending tool-use permission request. + * Test Connection + * @description Test an integration's credentials by verifying they can be decrypted. */ - post: operations["respond_to_permission_api_workspaces__workspace_id__agent_runs__run_id__permission_post"]; + post: operations["test_connection_api_settings_integrations__integration_id__test_post"]; delete?: never; options?: never; head?: never; patch?: never; trace?: never; }; - "/api/workspaces/{workspace_id}/agents/{agent_type}/execute": { + "/api/settings/model": { parameters: { query?: never; header?: never; path?: never; cookie?: never; }; - get?: never; - put?: never; /** - * Execute Agent - * @description Start an agent run as a background task. + * Get Model + * @description Return the canonical active model (ADR-0037). * - * Returns immediately with the agent_run_id. Connect to the - * agent-execution SSE stream to receive permission_request events - * and a done signal. + * Thin shim over :class:`AIIntegrationService` so the CLI (``cliffsec + * model get``) and the Settings UI agree byte-for-byte. Returns an + * empty :class:`ModelConfig` when no AI provider is connected yet + * (fresh install) — the UI treats a blank ``model_full_id`` as "no + * model set" and the agent-launch gate keeps things safe. + */ + get: operations["get_model_api_settings_model_get"]; + /** + * Update Model + * @description Persist a model change (ADR-0037). * - * Optional body ``{user_note}`` is forwarded to the planner's prompt for - * PRD-0006 Phase 2's Refine flow; other agent types ignore it. + * Routes through :class:`AIIntegrationService.set_model`, which writes + * the canonical ``app_setting(model)``. Requires a connected provider — + * a model can't be chosen before picking who serves it. */ - post: operations["execute_agent_api_workspaces__workspace_id__agents__agent_type__execute_post"]; + put: operations["update_model_api_settings_model_put"]; + post?: never; delete?: never; options?: never; head?: never; patch?: never; trace?: never; }; - "/api/workspaces/{workspace_id}/chat/permission": { + "/api/settings/providers": { parameters: { query?: never; header?: never; path?: never; cookie?: never; }; - get?: never; - put?: never; /** - * Respond To Chat Permission - * @description Approve or deny a permission request from the chat path. + * List Providers + * @description Return the supported-provider catalog (ADR-0037). * - * Unlike the agent-execution permission endpoint, this calls - * OpenCode's permission API directly (no executor involved). + * Built from the static :mod:`cliff.ai.catalog` — one entry per + * provider with its key env var and the curated model picker rows. The + * wire shape (``{id, name, env, models}`` with ``models`` keyed by the + * bare model id) is what the Settings model picker and ``cliffsec model + * list`` consume. */ - post: operations["respond_to_chat_permission_api_workspaces__workspace_id__chat_permission_post"]; + get: operations["list_providers_api_settings_providers_get"]; + put?: never; + post?: never; delete?: never; options?: never; head?: never; patch?: never; trace?: never; }; - "/api/workspaces/{workspace_id}/chat/send": { + "/api/settings/providers/test": { parameters: { query?: never; header?: never; @@ -1094,28 +1104,30 @@ export interface paths { get?: never; put?: never; /** - * Workspace Send Message - * @description Send a message to this workspace's OpenCode process. + * Test Provider + * @description End-to-end probe of the configured provider+model (ADR-0031). + * + * Sends a bounded ``"Say OK"`` call through Pydantic AI with a 30s + * timeout and classifies the outcome into + * ``{ok, latency_ms, error_code, error_message}``. Always returns HTTP + * 200; ``ok`` reflects the probe result. */ - post: operations["workspace_send_message_api_workspaces__workspace_id__chat_send_post"]; + post: operations["test_provider_api_settings_providers_test_post"]; delete?: never; options?: never; head?: never; patch?: never; trace?: never; }; - "/api/workspaces/{workspace_id}/chat/stream": { + "/api/version": { parameters: { query?: never; header?: never; path?: never; cookie?: never; }; - /** - * Workspace Stream Events - * @description Stream SSE events from this workspace's OpenCode process. - */ - get: operations["workspace_stream_events_api_workspaces__workspace_id__chat_stream_get"]; + /** Get Version */ + get: operations["get_version_api_version_get"]; put?: never; post?: never; delete?: never; @@ -1124,83 +1136,99 @@ export interface paths { patch?: never; trace?: never; }; - "/api/workspaces/{workspace_id}/context": { + "/api/workspaces": { parameters: { query?: never; header?: never; path?: never; cookie?: never; }; + /** List Workspaces Endpoint */ + get: operations["list_workspaces_endpoint_api_workspaces_get"]; + put?: never; /** - * Get Workspace Context - * @description Return the full context snapshot for the sidebar. + * Create Workspace Endpoint + * @description Create-or-return a workspace for a finding. + * + * Idempotent by design: one workspace per finding, forever. A second POST + * for the same ``finding_id`` returns the existing workspace (200) instead + * of creating a duplicate, so the knowledge base, agent runs, and sidebar + * state stay attached to the original. New workspaces are 201 Created; + * reused workspaces are 200 OK. + * + * In both paths we (re-)flip the Finding out of ``new``/``triaged`` into + * ``in_progress`` via ``mark_started_on_workspace_create``. This matters + * for the reused-workspace path: re-running an assessment UPSERTs posture + * findings back to ``status='new'`` even when a workspace with completed + * work already exists, so without the re-flip the row would be stuck + * rendering in Todo despite having a full plan/agent history behind it. */ - get: operations["get_workspace_context_api_workspaces__workspace_id__context_get"]; - put?: never; - post?: never; + post: operations["create_workspace_endpoint_api_workspaces_post"]; delete?: never; options?: never; head?: never; patch?: never; trace?: never; }; - "/api/workspaces/{workspace_id}/integrations": { + "/api/workspaces/{workspace_id}": { parameters: { query?: never; header?: never; path?: never; cookie?: never; }; - /** - * Get Workspace Integrations - * @description Return the active MCP integrations for a workspace with config freshness. - */ - get: operations["get_workspace_integrations_api_workspaces__workspace_id__integrations_get"]; + /** Get Workspace Endpoint */ + get: operations["get_workspace_endpoint_api_workspaces__workspace_id__get"]; put?: never; post?: never; - delete?: never; + /** + * Delete Workspace Endpoint + * @description Delete workspace: remove directory + DB row. + */ + delete: operations["delete_workspace_endpoint_api_workspaces__workspace_id__delete"]; options?: never; head?: never; - patch?: never; + /** Update Workspace Endpoint */ + patch: operations["update_workspace_endpoint_api_workspaces__workspace_id__patch"]; trace?: never; }; - "/api/workspaces/{workspace_id}/messages": { + "/api/workspaces/{workspace_id}/agent-runs": { parameters: { query?: never; header?: never; path?: never; cookie?: never; }; - /** List Messages Endpoint */ - get: operations["list_messages_endpoint_api_workspaces__workspace_id__messages_get"]; + /** List Agent Runs Endpoint */ + get: operations["list_agent_runs_endpoint_api_workspaces__workspace_id__agent_runs_get"]; put?: never; - /** Create Message Endpoint */ - post: operations["create_message_endpoint_api_workspaces__workspace_id__messages_post"]; + /** Create Agent Run Endpoint */ + post: operations["create_agent_run_endpoint_api_workspaces__workspace_id__agent_runs_post"]; delete?: never; options?: never; head?: never; patch?: never; trace?: never; }; - "/api/workspaces/{workspace_id}/messages/{message_id}": { + "/api/workspaces/{workspace_id}/agent-runs/{run_id}": { parameters: { query?: never; header?: never; path?: never; cookie?: never; }; - /** Get Message Endpoint */ - get: operations["get_message_endpoint_api_workspaces__workspace_id__messages__message_id__get"]; + /** Get Agent Run Endpoint */ + get: operations["get_agent_run_endpoint_api_workspaces__workspace_id__agent_runs__run_id__get"]; put?: never; post?: never; - /** Delete Message Endpoint */ - delete: operations["delete_message_endpoint_api_workspaces__workspace_id__messages__message_id__delete"]; + delete?: never; options?: never; head?: never; - patch?: never; + /** Update Agent Run Endpoint */ + patch: operations["update_agent_run_endpoint_api_workspaces__workspace_id__agent_runs__run_id__patch"]; trace?: never; }; - "/api/workspaces/{workspace_id}/pipeline/run-all": { + "/api/workspaces/{workspace_id}/agent-runs/{run_id}/cancel": { parameters: { query?: never; header?: never; @@ -1210,40 +1238,45 @@ export interface paths { get?: never; put?: never; /** - * Run All Pipeline - * @description Run all remaining agents in pipeline order as a background task. - * - * Each agent runs sequentially. Progress events stream via the - * agent-execution SSE endpoint. Stops on first failure. + * Cancel Agent Run + * @description Cancel a running agent run. */ - post: operations["run_all_pipeline_api_workspaces__workspace_id__pipeline_run_all_post"]; + post: operations["cancel_agent_run_api_workspaces__workspace_id__agent_runs__run_id__cancel_post"]; delete?: never; options?: never; head?: never; patch?: never; trace?: never; }; - "/api/workspaces/{workspace_id}/pipeline/suggest-next": { + "/api/workspaces/{workspace_id}/agent-runs/{run_id}/permission": { parameters: { query?: never; header?: never; path?: never; cookie?: never; }; + get?: never; + put?: never; /** - * Suggest Next Endpoint - * @description Return the recommended next agent based on current context state. + * Respond To Permission + * @description Approve or deny a paused executor tool call, resuming the run. + * + * ADR-0047 / PR #2 — the remediation_executor pauses on a gated tool by + * persisting a ``DeferredToolRequests`` marker (``agent_run.permission_ + * request`` + ``pa_message_history``). This endpoint resumes the run via + * ``executor.resume_executor`` with the user's decision. Resume actually + * re-runs the agent (it can take minutes), so it runs as a background + * task and returns immediately — the frontend polls ``agent-runs`` for + * the outcome (no SSE). */ - get: operations["suggest_next_endpoint_api_workspaces__workspace_id__pipeline_suggest_next_get"]; - put?: never; - post?: never; + post: operations["respond_to_permission_api_workspaces__workspace_id__agent_runs__run_id__permission_post"]; delete?: never; options?: never; head?: never; patch?: never; trace?: never; }; - "/api/workspaces/{workspace_id}/plan/approve": { + "/api/workspaces/{workspace_id}/agents/{agent_type}/execute": { parameters: { query?: never; header?: never; @@ -1253,27 +1286,24 @@ export interface paths { get?: never; put?: never; /** - * Approve Plan - * @description Mark the workspace's remediation plan as approved. + * Execute Agent + * @description Start an agent run as a background task. * - * PRD-0006 Story 3 — the planner pauses the run-all loop until the user - * explicitly approves. This endpoint flips ``plan.approved=true`` in BOTH - * stores: the SQLite sidebar (read by the Issues-page derivation) AND - * the filesystem ``context/plan.json`` (read by ``suggest_next`` to - * decide whether the executor may run). A subsequent - * ``POST /pipeline/run-all`` will then suggest the executor. + * Returns immediately with the agent_run_id. Connect to the + * agent-execution SSE stream to receive permission_request events + * and a done signal. * - * Returns 404 if the workspace doesn't exist or the planner hasn't yet - * written a plan to the sidebar. + * Optional body ``{user_note}`` is forwarded to the planner's prompt for + * PRD-0006 Phase 2's Refine flow; other agent types ignore it. */ - post: operations["approve_plan_api_workspaces__workspace_id__plan_approve_post"]; + post: operations["execute_agent_api_workspaces__workspace_id__agents__agent_type__execute_post"]; delete?: never; options?: never; head?: never; patch?: never; trace?: never; }; - "/api/workspaces/{workspace_id}/pool-status": { + "/api/workspaces/{workspace_id}/context": { parameters: { query?: never; header?: never; @@ -1281,10 +1311,10 @@ export interface paths { cookie?: never; }; /** - * Workspace Pool Status - * @description Debug endpoint: show process pool status for this workspace. + * Get Workspace Context + * @description Return the full context snapshot for the sidebar. */ - get: operations["workspace_pool_status_api_workspaces__workspace_id__pool_status_get"]; + get: operations["get_workspace_context_api_workspaces__workspace_id__context_get"]; put?: never; post?: never; delete?: never; @@ -1293,65 +1323,203 @@ export interface paths { patch?: never; trace?: never; }; - "/api/workspaces/{workspace_id}/sessions": { + "/api/workspaces/{workspace_id}/integrations": { parameters: { query?: never; header?: never; path?: never; cookie?: never; }; - get?: never; - put?: never; /** - * Create Workspace Session - * @description Create an OpenCode session on this workspace's isolated process. + * Get Workspace Integrations + * @description Return the active MCP integrations for a workspace with config freshness. */ - post: operations["create_workspace_session_api_workspaces__workspace_id__sessions_post"]; + get: operations["get_workspace_integrations_api_workspaces__workspace_id__integrations_get"]; + put?: never; + post?: never; delete?: never; options?: never; head?: never; patch?: never; trace?: never; }; - "/api/workspaces/{workspace_id}/sidebar": { + "/api/workspaces/{workspace_id}/messages": { parameters: { query?: never; header?: never; path?: never; cookie?: never; }; - /** Get Sidebar Endpoint */ - get: operations["get_sidebar_endpoint_api_workspaces__workspace_id__sidebar_get"]; - /** Upsert Sidebar Endpoint */ - put: operations["upsert_sidebar_endpoint_api_workspaces__workspace_id__sidebar_put"]; - post?: never; + /** List Messages Endpoint */ + get: operations["list_messages_endpoint_api_workspaces__workspace_id__messages_get"]; + put?: never; + /** Create Message Endpoint */ + post: operations["create_message_endpoint_api_workspaces__workspace_id__messages_post"]; delete?: never; options?: never; head?: never; patch?: never; trace?: never; }; - "/health": { + "/api/workspaces/{workspace_id}/messages/{message_id}": { parameters: { query?: never; header?: never; path?: never; cookie?: never; }; - /** Health */ - get: operations["health_health_get"]; + /** Get Message Endpoint */ + get: operations["get_message_endpoint_api_workspaces__workspace_id__messages__message_id__get"]; put?: never; post?: never; - delete?: never; + /** Delete Message Endpoint */ + delete: operations["delete_message_endpoint_api_workspaces__workspace_id__messages__message_id__delete"]; options?: never; head?: never; patch?: never; trace?: never; }; -} -export type webhooks = Record; + "/api/workspaces/{workspace_id}/pipeline/run-all": { + parameters: { + query?: never; + header?: never; + path?: never; + cookie?: never; + }; + get?: never; + put?: never; + /** + * Run All Pipeline + * @description Run all remaining agents in pipeline order as a background task. + * + * Each agent runs sequentially. Progress events stream via the + * agent-execution SSE endpoint. Stops on first failure. + */ + post: operations["run_all_pipeline_api_workspaces__workspace_id__pipeline_run_all_post"]; + delete?: never; + options?: never; + head?: never; + patch?: never; + trace?: never; + }; + "/api/workspaces/{workspace_id}/pipeline/suggest-next": { + parameters: { + query?: never; + header?: never; + path?: never; + cookie?: never; + }; + /** + * Suggest Next Endpoint + * @description Return the recommended next agent based on current context state. + */ + get: operations["suggest_next_endpoint_api_workspaces__workspace_id__pipeline_suggest_next_get"]; + put?: never; + post?: never; + delete?: never; + options?: never; + head?: never; + patch?: never; + trace?: never; + }; + "/api/workspaces/{workspace_id}/plan/approve": { + parameters: { + query?: never; + header?: never; + path?: never; + cookie?: never; + }; + get?: never; + put?: never; + /** + * Approve Plan + * @description Mark the workspace's remediation plan as approved. + * + * PRD-0006 Story 3 — the planner pauses the run-all loop until the user + * explicitly approves. This endpoint flips ``plan.approved=true`` in BOTH + * stores: the SQLite sidebar (read by the Issues-page derivation) AND + * the filesystem ``context/plan.json`` (read by ``suggest_next`` to + * decide whether the executor may run). A subsequent + * ``POST /pipeline/run-all`` will then suggest the executor. + * + * Returns 404 if the workspace doesn't exist or the planner hasn't yet + * written a plan to the sidebar. + */ + post: operations["approve_plan_api_workspaces__workspace_id__plan_approve_post"]; + delete?: never; + options?: never; + head?: never; + patch?: never; + trace?: never; + }; + "/api/workspaces/{workspace_id}/sidebar": { + parameters: { + query?: never; + header?: never; + path?: never; + cookie?: never; + }; + /** Get Sidebar Endpoint */ + get: operations["get_sidebar_endpoint_api_workspaces__workspace_id__sidebar_get"]; + /** Upsert Sidebar Endpoint */ + put: operations["upsert_sidebar_endpoint_api_workspaces__workspace_id__sidebar_put"]; + post?: never; + delete?: never; + options?: never; + head?: never; + patch?: never; + trace?: never; + }; + "/health": { + parameters: { + query?: never; + header?: never; + path?: never; + cookie?: never; + }; + /** Health */ + get: operations["health_health_get"]; + put?: never; + post?: never; + delete?: never; + options?: never; + head?: never; + patch?: never; + trace?: never; + }; +} +export type webhooks = Record; export interface components { schemas: { + /** + * AIStatus + * @description Wire shape for ``GET /api/integrations/ai/status``. + * + * ``model`` is the canonical active model — the one Cliff writes into + * ``app_setting(key="model")`` and the PA model factory reads at each + * agent run. Per ADR-0037 / ADR-0047 there is one canonical state and + * one read; with the substrate in-process there is no separate "what's + * loaded right now" signal worth exposing on the wire. + */ + AIStatus: { + /** Connected At */ + connected_at?: string | null; + /** Metadata */ + metadata?: { + [key: string]: unknown; + } | null; + /** Model */ + model?: string | null; + /** Provider */ + provider?: ("openrouter" | "anthropic" | "openai" | "google" | "ollama" | "custom") | null; + /** Source */ + source?: ("autodetect" | "openrouter-oauth" | "byok") | null; + /** + * State + * @enum {string} + */ + state: "unconfigured" | "connected"; + }; /** AgentChipResponse */ AgentChipResponse: { /** Agent Type */ @@ -1379,8 +1547,19 @@ export interface components { input_json?: { [key: string]: unknown; } | null; + /** Last Error */ + last_error?: string | null; /** Next Action Hint */ next_action_hint?: string | null; + /** + * Permission Pending + * @default false + */ + permission_pending: boolean; + /** Permission Request */ + permission_request?: { + [key: string]: unknown; + } | null; /** Started At */ started_at?: string | null; /** @@ -1388,7 +1567,7 @@ export interface components { * @default queued * @enum {string} */ - status: "queued" | "running" | "completed" | "failed" | "cancelled"; + status: "queued" | "running" | "completed" | "failed" | "cancelled" | "rate_limited"; /** Structured Output */ structured_output?: { [key: string]: unknown; @@ -1411,7 +1590,7 @@ export interface components { * @default queued * @enum {string} */ - status: "queued" | "running" | "completed" | "failed" | "cancelled"; + status: "queued" | "running" | "completed" | "failed" | "cancelled" | "rate_limited"; }; /** AgentRunUpdate */ AgentRunUpdate: { @@ -1421,10 +1600,20 @@ export interface components { evidence_json?: { [key: string]: unknown; } | null; + /** Last Error */ + last_error?: string | null; /** Next Action Hint */ next_action_hint?: string | null; + /** Pa Message History */ + pa_message_history?: string | null; + /** Permission Pending */ + permission_pending?: boolean | null; + /** Permission Request */ + permission_request?: { + [key: string]: unknown; + } | null; /** Status */ - status?: ("queued" | "running" | "completed" | "failed" | "cancelled") | null; + status?: ("queued" | "running" | "completed" | "failed" | "cancelled" | "rate_limited") | null; /** Structured Output */ structured_output?: { [key: string]: unknown; @@ -1432,13 +1621,6 @@ export interface components { /** Summary Markdown */ summary_markdown?: string | null; }; - /** ApiKeyCreate */ - ApiKeyCreate: { - /** Key */ - key: string; - /** Provider */ - provider: string; - }; /** Assessment */ Assessment: { /** Branch */ @@ -1629,6 +1811,48 @@ export interface components { /** Value */ value: number; }; + /** + * AutodetectResponse + * @description Wire shape for ``GET /api/integrations/ai/autodetect`` — never the key. + */ + AutodetectResponse: { + /** Found */ + found: boolean; + /** Provider */ + provider?: ("openrouter" | "anthropic" | "openai" | "google" | "ollama" | "custom") | null; + /** Source */ + source?: string | null; + }; + /** + * BYOKRequest + * @description Inbound payload for ``POST /api/integrations/ai/byok``. + * + * ``api_key`` is a ``SecretStr`` so the value is redacted in every + * Pydantic-rendered context — model_dump (without explicit unwrap), + * validation errors, repr, logging. Call sites that need the raw key + * must use ``api_key.get_secret_value()`` explicitly; that explicit + * unwrap is the only place we want to deal with the raw string. + * + * For Ollama the ``api_key`` is just a non-empty placeholder (the + * transport doesn't authenticate) but the field stays required so the + * wire shape doesn't fork. The UI sends "local" automatically. + */ + BYOKRequest: { + /** + * Api Key + * Format: password + */ + api_key: string; + /** Base Url */ + base_url?: string | null; + /** Model */ + model?: string | null; + /** + * Provider + * @enum {string} + */ + provider: "openrouter" | "anthropic" | "openai" | "google" | "ollama" | "custom"; + }; /** * BootstrapState * @description Read-only state the SPA fetches before rendering the first page. @@ -1646,30 +1870,6 @@ export interface components { /** Total */ total: number; }; - /** ChatPermissionDecision */ - ChatPermissionDecision: { - /** Approved */ - approved: boolean; - /** Permission Id */ - permission_id: string; - /** Session Id */ - session_id: string; - }; - /** ChatSendRequest */ - ChatSendRequest: { - /** Content */ - content: string; - }; - /** ChatSendResponse */ - ChatSendResponse: { - /** Session Id */ - session_id: string; - /** - * Status - * @default sent - */ - status: string; - }; /** Completion */ Completion: { /** Assessment Id */ @@ -1883,6 +2083,70 @@ export interface components { tools?: components["schemas"]["AssessmentTool"][]; vulnerabilities?: components["schemas"]["VulnerabilityCounts"] | null; }; + /** DeviceFlowConnectResponse */ + DeviceFlowConnectResponse: { + /** Expires In */ + expires_in: number; + /** Install Url */ + install_url: string; + /** Interval */ + interval: number; + /** User Code */ + user_code: string; + /** Verification Uri */ + verification_uri: string; + }; + /** DeviceFlowDisconnectResponse */ + DeviceFlowDisconnectResponse: { + /** Manual Revoke Url */ + manual_revoke_url: string; + /** + * Status + * @default disconnected + * @constant + */ + status: "disconnected"; + }; + /** + * DeviceFlowManualSetupRequest + * @description Payload for the ``POST /setup/manual`` recovery endpoint (B33). + * + * The user pastes the ``installation_id`` they saw in the redirect URL + * after clicking Install on github.com — typically because the App's + * globally-configured Setup URL pointed at a different deployment than + * theirs (e.g. ``localhost:8000`` when their Cliff is on ``:8088``). + * + * ``state`` is the same CSRF token that ``POST /connect`` returned in + * its ``install_url`` query string. Validating it against an in-flight + * row is what keeps the manual path from being a CSRF bypass: an + * attacker who tricks the user into pasting an attacker-controlled + * ``installation_id`` can't bind it without also knowing a state the + * user's own /connect issued. + */ + DeviceFlowManualSetupRequest: { + /** Installation Id */ + installation_id: number; + /** State */ + state: string; + }; + /** DeviceFlowStatusResponse */ + DeviceFlowStatusResponse: { + /** Error */ + error?: string | null; + /** Expires At */ + expires_at?: string | null; + /** Github Login */ + github_login?: string | null; + /** Installation Id */ + installation_id?: number | null; + /** + * Status + * @enum {string} + */ + status: "installation_pending" | "device_pending" | "connected" | "expired" | "denied" | "rate_limited" | "error"; + /** User Code */ + user_code?: string | null; + }; /** * ExecuteAgentRequest * @description Optional body for ``POST /workspaces/{id}/agents/{type}/execute``. @@ -2083,8 +2347,28 @@ export interface components { /** Detail */ detail?: components["schemas"]["ValidationError"][]; }; - /** HealthStatus */ + /** + * HealthStatus + * @description ``/health`` response. + * + * Field shape is preserved across the OpenCode → Pydantic AI substrate + * migration (ADR-0047) so the frontend health card and ``cliffsec status`` + * don't churn. The agent substrate now runs **in-process**, so ``opencode`` + * is always ``"ok"`` and ``opencode_version`` carries the Pydantic AI + * version string (e.g. ``"pydantic-ai 1.98.x"``) rather than a subprocess + * version. + */ HealthStatus: { + /** + * Ai Provider Ready + * @default false + */ + ai_provider_ready: boolean; + /** + * Cliff + * @default ok + */ + cliff: string; /** * Model * @default @@ -2092,7 +2376,7 @@ export interface components { model: string; /** * Opencode - * @default unknown + * @default ok */ opencode: string; /** @@ -2100,11 +2384,6 @@ export interface components { * @default */ opencode_version: string; - /** - * Cliff - * @default ok - */ - cliff: string; }; /** IngestJobProgress */ IngestJobProgress: { @@ -2176,6 +2455,8 @@ export interface components { action_tier: number; /** Adapter Type */ adapter_type: string; + /** Auth Method */ + auth_method?: ("github_app" | "pat") | null; /** Config */ config?: { [key: string]: unknown; @@ -2185,6 +2466,8 @@ export interface components { * @default true */ enabled: boolean; + /** Github Login */ + github_login?: string | null; /** Id */ id: string; /** Last Test Result */ @@ -2267,7 +2550,7 @@ export interface components { * Stage * @enum {string} */ - stage: "todo" | "planning" | "generating" | "pushing" | "opening_pr" | "validating" | "plan_ready" | "pr_ready" | "pr_awaiting_val" | "fixed" | "false_positive" | "wont_fix" | "accepted" | "deferred"; + stage: "todo" | "planning" | "generating" | "pushing" | "opening_pr" | "validating" | "plan_ready" | "pr_ready" | "pr_awaiting_val" | "awaiting_permission" | "failed" | "fixed" | "false_positive" | "wont_fix" | "accepted" | "deferred"; /** Workspace Id */ workspace_id?: string | null; }; @@ -2338,7 +2621,7 @@ export interface components { /** ListReposRequest */ ListReposRequest: { /** Github Token */ - github_token: string; + github_token?: string | null; }; /** * MarkSummarySeenResponse @@ -2383,20 +2666,6 @@ export interface components { */ role: "user" | "assistant" | "system" | "agent"; }; - /** MessageInfo */ - MessageInfo: { - /** - * Content - * @default - */ - content: string; - /** Created At */ - created_at?: string | null; - /** Id */ - id: string; - /** Role */ - role: string; - }; /** ModelConfig */ ModelConfig: { /** Model Full Id */ @@ -2458,7 +2727,7 @@ export interface components { /** OnboardingRepoRequest */ OnboardingRepoRequest: { /** Github Token */ - github_token: string; + github_token?: string | null; /** Repo Url */ repo_url: string; }; @@ -2492,10 +2761,29 @@ export interface components { /** History */ history?: number[]; }; + /** OpenRouterStartResponse */ + OpenRouterStartResponse: { + /** Auth Url */ + auth_url: string; + /** Session Id */ + session_id: string; + }; + /** OpenRouterStatusResponse */ + OpenRouterStatusResponse: { + /** Detail */ + detail?: string | null; + /** + * Status + * @enum {string} + */ + status: "waiting" | "connected" | "denied" | "error" | "timeout"; + }; /** PermissionDecision */ PermissionDecision: { /** Approved */ approved: boolean; + /** Deny Message */ + deny_message?: string | null; }; /** PostureCategoryWire */ PostureCategoryWire: { @@ -2602,12 +2890,58 @@ export interface components { /** Report Href */ report_href: string; }; + /** ProviderInfo */ + ProviderInfo: { + /** Env */ + env: string[]; + /** Id */ + id: string; + /** Models */ + models: { + [key: string]: unknown; + }; + /** Name */ + name: string; + }; + /** + * ProviderModelOption + * @description One entry in the per-provider model picker dropdown. + */ + ProviderModelOption: { + /** Description */ + description?: string | null; + /** Id */ + id: string; + /** Label */ + label: string; + }; + /** + * ProviderModelsResponse + * @description Wire shape for ``GET /api/integrations/ai/models?provider=X``. + */ + ProviderModelsResponse: { + /** Default Model */ + default_model: string | null; + /** Models */ + models: components["schemas"]["ProviderModelOption"][]; + /** + * Provider + * @enum {string} + */ + provider: "openrouter" | "anthropic" | "openai" | "google" | "ollama" | "custom"; + /** + * Source + * @enum {string} + */ + source: "catalog" | "live"; + }; /** * ProviderTestRequest * @description Optional staged config. Alpha passes nothing and probes the currently * configured provider/model/key; a future UI can preview unsaved staged * config by populating these fields. Ignored today — probe uses whatever - * OpenCode has configured — but kept so the wire shape is stable. + * the canonical AI state has configured — but kept so the wire shape is + * stable. */ ProviderTestRequest: { /** Api Key */ @@ -2628,6 +2962,37 @@ export interface components { /** Ok */ ok: boolean; }; + /** + * PushAccessDiagnoseResponse + * @description Result of ``GET /api/integrations/github/diagnose`` (IMPL-0018, B35c). + * + * The Settings page renders this directly: ``can_push=true`` → green + * "Push verified" pill, otherwise a red "Push blocked" pill showing + * ``reason`` and a deep-link to the setup guide. + * + * ``reason`` is whatever :func:`check_repo_push_access` returned. That + * function is the single canonical source of the user-facing copy for + * every push-access failure mode — keeping the route a pass-through + * means the executor's 412 error card (which renders the same + * ``reason``) and this badge can never drift apart. + * + * ``repo_url`` is the resolved GitHub repo URL we ran the check + * against, so the UI can render "Push verified — owner/repo" without + * re-deriving it. ``checked_at`` is the timestamp of the underlying + * GitHub call, NOT of the response — i.e. a cached result echoes the + * original probe time so the user can see "checked 2 min ago" and + * decide whether to click Refresh. + */ + PushAccessDiagnoseResponse: { + /** Can Push */ + can_push: boolean; + /** Checked At */ + checked_at: string; + /** Reason */ + reason: string; + /** Repo Url */ + repo_url: string; + }; /** * RegistryEntry * @description A single integration in the catalog. @@ -2660,8 +3025,15 @@ export interface components { /** Docs Url */ docs_url?: string | null; /** - * Icon - * @default extension + * Github App Available + * @default false + */ + github_app_available: boolean; + /** Github App Install Url */ + github_app_install_url?: string | null; + /** + * Icon + * @default extension */ icon: string; /** Id */ @@ -2738,30 +3110,18 @@ export interface components { /** Status */ status: string; }; - /** SessionDetail */ - SessionDetail: { - /** Created At */ - created_at?: string | null; - /** Id */ - id: string; - /** - * Messages - * @default [] - */ - messages: components["schemas"]["MessageInfo"][]; - /** - * Model - * @default - */ + /** + * SetModelRequest + * @description Inbound payload for ``PUT /api/integrations/ai/model``. + * + * The model id must include a provider prefix; the service rejects ids + * whose prefix doesn't match the currently active provider so a stale + * setting never silently re-points at the wrong namespace. + */ + SetModelRequest: { + /** Model */ model: string; }; - /** SessionSummary */ - SessionSummary: { - /** Created At */ - created_at?: string | null; - /** Id */ - id: string; - }; /** SeverityHistory */ SeverityHistory: { /** Critical */ @@ -2922,22 +3282,27 @@ export interface components { }; /** * VersionInfo - * @description Version handshake for the agent CLI (`cliff status`). + * @description ``/version`` handshake for the agent CLI (``cliffsec status``). * - * `min_cli` is the lowest CLI version this server promises to speak to. - * A CLI older than this should refuse to operate and tell the user to upgrade. - * `schema_version` bumps when the CLI/server contract changes incompatibly. + * ``min_cli`` is the lowest CLI version this server promises to speak to; a + * CLI older than this refuses to operate. ``schema_version`` bumps when the + * CLI/server contract changes incompatibly. ``opencode`` is retained for a + * backward-compatible wire shape and now carries the in-process substrate + * version (ADR-0047). */ VersionInfo: { + /** Cliff */ + cliff: string; /** * Min Cli * @default 0.1.0 */ min_cli: string; - /** Opencode */ + /** + * Opencode + * @default + */ opencode: string; - /** Cliff */ - cliff: string; /** * Schema Version * @default 1 @@ -3006,13 +3371,6 @@ export interface components { /** Workspace Dir */ workspace_dir?: string | null; }; - /** WorkspaceChatRequest */ - WorkspaceChatRequest: { - /** Content */ - content: string; - /** Session Id */ - session_id: string; - }; /** WorkspaceCreate */ WorkspaceCreate: { /** Current Focus */ @@ -3227,18 +3585,49 @@ export interface operations { }; }; }; - send_message_api_chat__session_id__send_post: { + get_completion_api_completion__completion_id__get: { parameters: { query?: never; header?: never; path: { - session_id: string; + completion_id: string; + }; + cookie?: never; + }; + requestBody?: never; + responses: { + /** @description Successful Response */ + 200: { + headers: { + [name: string]: unknown; + }; + content: { + "application/json": components["schemas"]["Completion"]; + }; + }; + /** @description Validation Error */ + 422: { + headers: { + [name: string]: unknown; + }; + content: { + "application/json": components["schemas"]["HTTPValidationError"]; + }; + }; + }; + }; + record_share_action_api_completion__completion_id__share_action_post: { + parameters: { + query?: never; + header?: never; + path: { + completion_id: string; }; cookie?: never; }; requestBody: { content: { - "application/json": components["schemas"]["ChatSendRequest"]; + "application/json": components["schemas"]["ShareActionRequest"]; }; }; responses: { @@ -3248,7 +3637,7 @@ export interface operations { [name: string]: unknown; }; content: { - "application/json": components["schemas"]["ChatSendResponse"]; + "application/json": components["schemas"]["ShareActionResponse"]; }; }; /** @description Validation Error */ @@ -3262,25 +3651,257 @@ export interface operations { }; }; }; - stream_events_api_chat__session_id__stream_get: { + get_bootstrap_api_config_bootstrap_get: { + parameters: { + query?: never; + header?: never; + path?: never; + cookie?: never; + }; + requestBody?: never; + responses: { + /** @description Successful Response */ + 200: { + headers: { + [name: string]: unknown; + }; + content: { + "application/json": components["schemas"]["BootstrapState"]; + }; + }; + }; + }; + get_dashboard_api_dashboard_get: { + parameters: { + query?: never; + header?: never; + path?: never; + cookie?: never; + }; + requestBody?: never; + responses: { + /** @description Successful Response */ + 200: { + headers: { + [name: string]: unknown; + }; + content: { + "application/json": components["schemas"]["DashboardPayload"]; + }; + }; + }; + }; + list_findings_endpoint_api_findings_get: { + parameters: { + query?: { + status?: string | null; + has_workspace?: boolean | null; + scope?: string | null; + limit?: number; + offset?: number; + }; + header?: never; + path?: never; + cookie?: never; + }; + requestBody?: never; + responses: { + /** @description Successful Response */ + 200: { + headers: { + [name: string]: unknown; + }; + content: { + "application/json": components["schemas"]["Finding"][]; + }; + }; + /** @description Validation Error */ + 422: { + headers: { + [name: string]: unknown; + }; + content: { + "application/json": components["schemas"]["HTTPValidationError"]; + }; + }; + }; + }; + create_finding_endpoint_api_findings_post: { + parameters: { + query?: never; + header?: never; + path?: never; + cookie?: never; + }; + requestBody: { + content: { + "application/json": components["schemas"]["FindingCreate"]; + }; + }; + responses: { + /** @description Successful Response */ + 201: { + headers: { + [name: string]: unknown; + }; + content: { + "application/json": components["schemas"]["Finding"]; + }; + }; + /** @description Validation Error */ + 422: { + headers: { + [name: string]: unknown; + }; + content: { + "application/json": components["schemas"]["HTTPValidationError"]; + }; + }; + }; + }; + ingest_findings_endpoint_api_findings_ingest_post: { + parameters: { + query?: never; + header?: never; + path?: never; + cookie?: never; + }; + requestBody: { + content: { + "application/json": components["schemas"]["IngestRequest"]; + }; + }; + responses: { + /** @description Successful Response */ + 200: { + headers: { + [name: string]: unknown; + }; + content: { + "application/json": components["schemas"]["IngestJobResponse"]; + }; + }; + /** @description Validation Error */ + 422: { + headers: { + [name: string]: unknown; + }; + content: { + "application/json": components["schemas"]["HTTPValidationError"]; + }; + }; + }; + }; + get_ingest_progress_endpoint_api_findings_ingest__job_id__get: { + parameters: { + query?: never; + header?: never; + path: { + job_id: string; + }; + cookie?: never; + }; + requestBody?: never; + responses: { + /** @description Successful Response */ + 200: { + headers: { + [name: string]: unknown; + }; + content: { + "application/json": components["schemas"]["IngestJobProgress"]; + }; + }; + /** @description Validation Error */ + 422: { + headers: { + [name: string]: unknown; + }; + content: { + "application/json": components["schemas"]["HTTPValidationError"]; + }; + }; + }; + }; + cancel_ingest_endpoint_api_findings_ingest__job_id__cancel_post: { + parameters: { + query?: never; + header?: never; + path: { + job_id: string; + }; + cookie?: never; + }; + requestBody?: never; + responses: { + /** @description Successful Response */ + 200: { + headers: { + [name: string]: unknown; + }; + content: { + "application/json": unknown; + }; + }; + /** @description Validation Error */ + 422: { + headers: { + [name: string]: unknown; + }; + content: { + "application/json": components["schemas"]["HTTPValidationError"]; + }; + }; + }; + }; + get_finding_endpoint_api_findings__finding_id__get: { + parameters: { + query?: never; + header?: never; + path: { + finding_id: string; + }; + cookie?: never; + }; + requestBody?: never; + responses: { + /** @description Successful Response */ + 200: { + headers: { + [name: string]: unknown; + }; + content: { + "application/json": components["schemas"]["Finding"]; + }; + }; + /** @description Validation Error */ + 422: { + headers: { + [name: string]: unknown; + }; + content: { + "application/json": components["schemas"]["HTTPValidationError"]; + }; + }; + }; + }; + delete_finding_endpoint_api_findings__finding_id__delete: { parameters: { query?: never; header?: never; path: { - session_id: string; + finding_id: string; }; cookie?: never; }; requestBody?: never; responses: { /** @description Successful Response */ - 200: { + 204: { headers: { [name: string]: unknown; }; - content: { - "application/json": unknown; - }; + content?: never; }; /** @description Validation Error */ 422: { @@ -3293,16 +3914,20 @@ export interface operations { }; }; }; - get_completion_api_completion__completion_id__get: { + update_finding_endpoint_api_findings__finding_id__patch: { parameters: { query?: never; header?: never; path: { - completion_id: string; + finding_id: string; }; cookie?: never; }; - requestBody?: never; + requestBody: { + content: { + "application/json": components["schemas"]["FindingUpdate"]; + }; + }; responses: { /** @description Successful Response */ 200: { @@ -3310,7 +3935,7 @@ export interface operations { [name: string]: unknown; }; content: { - "application/json": components["schemas"]["Completion"]; + "application/json": components["schemas"]["Finding"]; }; }; /** @description Validation Error */ @@ -3324,18 +3949,18 @@ export interface operations { }; }; }; - record_share_action_api_completion__completion_id__share_action_post: { + reject_finding_endpoint_api_findings__finding_id__reject_post: { parameters: { query?: never; header?: never; path: { - completion_id: string; + finding_id: string; }; cookie?: never; }; requestBody: { content: { - "application/json": components["schemas"]["ShareActionRequest"]; + "application/json": components["schemas"]["RejectFindingRequest"]; }; }; responses: { @@ -3345,7 +3970,7 @@ export interface operations { [name: string]: unknown; }; content: { - "application/json": components["schemas"]["ShareActionResponse"]; + "application/json": components["schemas"]["Finding"]; }; }; /** @description Validation Error */ @@ -3359,7 +3984,7 @@ export interface operations { }; }; }; - get_bootstrap_api_config_bootstrap_get: { + autodetect_scan_api_integrations_ai_autodetect_get: { parameters: { query?: never; header?: never; @@ -3374,12 +3999,12 @@ export interface operations { [name: string]: unknown; }; content: { - "application/json": components["schemas"]["BootstrapState"]; + "application/json": components["schemas"]["AutodetectResponse"]; }; }; }; }; - get_dashboard_api_dashboard_get: { + autodetect_adopt_api_integrations_ai_autodetect_adopt_post: { parameters: { query?: never; header?: never; @@ -3394,25 +4019,23 @@ export interface operations { [name: string]: unknown; }; content: { - "application/json": components["schemas"]["DashboardPayload"]; + "application/json": components["schemas"]["AIStatus"]; }; }; }; }; - list_findings_endpoint_api_findings_get: { + byok_api_integrations_ai_byok_post: { parameters: { - query?: { - status?: string | null; - has_workspace?: boolean | null; - scope?: string | null; - limit?: number; - offset?: number; - }; + query?: never; header?: never; path?: never; cookie?: never; }; - requestBody?: never; + requestBody: { + content: { + "application/json": components["schemas"]["BYOKRequest"]; + }; + }; responses: { /** @description Successful Response */ 200: { @@ -3420,7 +4043,7 @@ export interface operations { [name: string]: unknown; }; content: { - "application/json": components["schemas"]["Finding"][]; + "application/json": components["schemas"]["AIStatus"]; }; }; /** @description Validation Error */ @@ -3434,40 +4057,27 @@ export interface operations { }; }; }; - create_finding_endpoint_api_findings_post: { + disconnect_api_integrations_ai_disconnect_post: { parameters: { query?: never; header?: never; path?: never; cookie?: never; }; - requestBody: { - content: { - "application/json": components["schemas"]["FindingCreate"]; - }; - }; + requestBody?: never; responses: { /** @description Successful Response */ - 201: { - headers: { - [name: string]: unknown; - }; - content: { - "application/json": components["schemas"]["Finding"]; - }; - }; - /** @description Validation Error */ - 422: { + 200: { headers: { [name: string]: unknown; }; content: { - "application/json": components["schemas"]["HTTPValidationError"]; + "application/json": unknown; }; }; }; }; - ingest_findings_endpoint_api_findings_ingest_post: { + set_active_model_api_integrations_ai_model_put: { parameters: { query?: never; header?: never; @@ -3476,7 +4086,7 @@ export interface operations { }; requestBody: { content: { - "application/json": components["schemas"]["IngestRequest"]; + "application/json": components["schemas"]["SetModelRequest"]; }; }; responses: { @@ -3486,7 +4096,7 @@ export interface operations { [name: string]: unknown; }; content: { - "application/json": components["schemas"]["IngestJobResponse"]; + "application/json": components["schemas"]["AIStatus"]; }; }; /** @description Validation Error */ @@ -3500,13 +4110,13 @@ export interface operations { }; }; }; - get_ingest_progress_endpoint_api_findings_ingest__job_id__get: { + list_provider_models_api_integrations_ai_models_get: { parameters: { - query?: never; - header?: never; - path: { - job_id: string; + query: { + provider: "openrouter" | "anthropic" | "openai" | "google" | "ollama" | "custom"; }; + header?: never; + path?: never; cookie?: never; }; requestBody?: never; @@ -3517,7 +4127,7 @@ export interface operations { [name: string]: unknown; }; content: { - "application/json": components["schemas"]["IngestJobProgress"]; + "application/json": components["schemas"]["ProviderModelsResponse"]; }; }; /** @description Validation Error */ @@ -3531,13 +4141,11 @@ export interface operations { }; }; }; - cancel_ingest_endpoint_api_findings_ingest__job_id__cancel_post: { + openrouter_start_api_integrations_ai_openrouter_start_post: { parameters: { query?: never; header?: never; - path: { - job_id: string; - }; + path?: never; cookie?: never; }; requestBody?: never; @@ -3548,27 +4156,18 @@ export interface operations { [name: string]: unknown; }; content: { - "application/json": unknown; - }; - }; - /** @description Validation Error */ - 422: { - headers: { - [name: string]: unknown; - }; - content: { - "application/json": components["schemas"]["HTTPValidationError"]; + "application/json": components["schemas"]["OpenRouterStartResponse"]; }; }; }; }; - get_finding_endpoint_api_findings__finding_id__get: { + openrouter_status_api_integrations_ai_openrouter_status_get: { parameters: { - query?: never; - header?: never; - path: { - finding_id: string; + query: { + session_id: string; }; + header?: never; + path?: never; cookie?: never; }; requestBody?: never; @@ -3579,7 +4178,7 @@ export interface operations { [name: string]: unknown; }; content: { - "application/json": components["schemas"]["Finding"]; + "application/json": components["schemas"]["OpenRouterStatusResponse"]; }; }; /** @description Validation Error */ @@ -3593,49 +4192,36 @@ export interface operations { }; }; }; - delete_finding_endpoint_api_findings__finding_id__delete: { + status_api_integrations_ai_status_get: { parameters: { query?: never; header?: never; - path: { - finding_id: string; - }; + path?: never; cookie?: never; }; requestBody?: never; responses: { /** @description Successful Response */ - 204: { - headers: { - [name: string]: unknown; - }; - content?: never; - }; - /** @description Validation Error */ - 422: { + 200: { headers: { [name: string]: unknown; }; content: { - "application/json": components["schemas"]["HTTPValidationError"]; + "application/json": components["schemas"]["AIStatus"]; }; }; }; }; - update_finding_endpoint_api_findings__finding_id__patch: { + connect_api_integrations_github_connect_post: { parameters: { - query?: never; - header?: never; - path: { - finding_id: string; + query?: { + return_to?: string | null; }; + header?: never; + path?: never; cookie?: never; }; - requestBody: { - content: { - "application/json": components["schemas"]["FindingUpdate"]; - }; - }; + requestBody?: never; responses: { /** @description Successful Response */ 200: { @@ -3643,7 +4229,7 @@ export interface operations { [name: string]: unknown; }; content: { - "application/json": components["schemas"]["Finding"]; + "application/json": components["schemas"]["DeviceFlowConnectResponse"]; }; }; /** @description Validation Error */ @@ -3657,20 +4243,16 @@ export interface operations { }; }; }; - reject_finding_endpoint_api_findings__finding_id__reject_post: { + diagnose_push_access_api_integrations_github_diagnose_get: { parameters: { - query?: never; - header?: never; - path: { - finding_id: string; + query?: { + refresh?: number; }; + header?: never; + path?: never; cookie?: never; }; - requestBody: { - content: { - "application/json": components["schemas"]["RejectFindingRequest"]; - }; - }; + requestBody?: never; responses: { /** @description Successful Response */ 200: { @@ -3678,7 +4260,7 @@ export interface operations { [name: string]: unknown; }; content: { - "application/json": components["schemas"]["Finding"]; + "application/json": components["schemas"]["PushAccessDiagnoseResponse"]; }; }; /** @description Validation Error */ @@ -3692,18 +4274,14 @@ export interface operations { }; }; }; - complete_onboarding_api_onboarding_complete_post: { + disconnect_api_integrations_github_disconnect_post: { parameters: { query?: never; header?: never; path?: never; cookie?: never; }; - requestBody: { - content: { - "application/json": components["schemas"]["OnboardingCompleteRequest"]; - }; - }; + requestBody?: never; responses: { /** @description Successful Response */ 200: { @@ -3711,32 +4289,43 @@ export interface operations { [name: string]: unknown; }; content: { - "application/json": components["schemas"]["OnboardingCompleteResponse"]; + "application/json": components["schemas"]["DeviceFlowDisconnectResponse"]; }; }; - /** @description Validation Error */ - 422: { + }; + }; + poll_now_api_integrations_github_poll_now_post: { + parameters: { + query?: never; + header?: never; + path?: never; + cookie?: never; + }; + requestBody?: never; + responses: { + /** @description Successful Response */ + 200: { headers: { [name: string]: unknown; }; content: { - "application/json": components["schemas"]["HTTPValidationError"]; + "application/json": components["schemas"]["DeviceFlowStatusResponse"]; }; }; }; }; - list_github_repos_api_onboarding_github_repos_post: { + setup_callback_api_integrations_github_setup_get: { parameters: { - query?: never; + query: { + installation_id: number; + setup_action?: "install" | "update"; + state?: string | null; + }; header?: never; path?: never; cookie?: never; }; - requestBody: { - content: { - "application/json": components["schemas"]["ListReposRequest"]; - }; - }; + requestBody?: never; responses: { /** @description Successful Response */ 200: { @@ -3758,7 +4347,7 @@ export interface operations { }; }; }; - connect_repo_api_onboarding_repo_post: { + setup_manual_api_integrations_github_setup_manual_post: { parameters: { query?: never; header?: never; @@ -3767,7 +4356,7 @@ export interface operations { }; requestBody: { content: { - "application/json": components["schemas"]["OnboardingRepoRequest"]; + "application/json": components["schemas"]["DeviceFlowManualSetupRequest"]; }; }; responses: { @@ -3777,7 +4366,7 @@ export interface operations { [name: string]: unknown; }; content: { - "application/json": unknown; + "application/json": components["schemas"]["DeviceFlowStatusResponse"]; }; }; /** @description Validation Error */ @@ -3791,13 +4380,11 @@ export interface operations { }; }; }; - get_posture_fix_status_api_posture_fix_status__workspace_id__get: { + status_api_integrations_github_status_get: { parameters: { query?: never; header?: never; - path: { - workspace_id: string; - }; + path?: never; cookie?: never; }; requestBody?: never; @@ -3808,32 +4395,21 @@ export interface operations { [name: string]: unknown; }; content: { - "application/json": components["schemas"]["RepoAgentStatus"]; - }; - }; - /** @description Validation Error */ - 422: { - headers: { - [name: string]: unknown; - }; - content: { - "application/json": components["schemas"]["HTTPValidationError"]; + "application/json": components["schemas"]["DeviceFlowStatusResponse"]; }; }; }; }; - fix_posture_check_api_posture_fix__check_name__post: { + complete_onboarding_api_onboarding_complete_post: { parameters: { query?: never; header?: never; - path: { - check_name: "security_md" | "dependabot_config"; - }; + path?: never; cookie?: never; }; - requestBody?: { + requestBody: { content: { - "application/json": components["schemas"]["PostureFixRequest"] | null; + "application/json": components["schemas"]["OnboardingCompleteRequest"]; }; }; responses: { @@ -3843,7 +4419,7 @@ export interface operations { [name: string]: unknown; }; content: { - "application/json": components["schemas"]["PostureFixResponse"]; + "application/json": components["schemas"]["OnboardingCompleteResponse"]; }; }; /** @description Validation Error */ @@ -3857,34 +4433,18 @@ export interface operations { }; }; }; - seed_demo_data_api_seed_post: { + list_github_repos_api_onboarding_github_repos_post: { parameters: { query?: never; header?: never; path?: never; cookie?: never; }; - requestBody?: never; - responses: { - /** @description Successful Response */ - 201: { - headers: { - [name: string]: unknown; - }; - content: { - "application/json": components["schemas"]["Finding"][]; - }; + requestBody: { + content: { + "application/json": components["schemas"]["ListReposRequest"]; }; }; - }; - list_sessions_api_sessions_get: { - parameters: { - query?: never; - header?: never; - path?: never; - cookie?: never; - }; - requestBody?: never; responses: { /** @description Successful Response */ 200: { @@ -3892,41 +4452,32 @@ export interface operations { [name: string]: unknown; }; content: { - "application/json": components["schemas"]["SessionSummary"][]; + "application/json": unknown; }; }; - }; - }; - create_session_api_sessions_post: { - parameters: { - query?: never; - header?: never; - path?: never; - cookie?: never; - }; - requestBody?: never; - responses: { - /** @description Successful Response */ - 200: { + /** @description Validation Error */ + 422: { headers: { [name: string]: unknown; }; content: { - "application/json": components["schemas"]["SessionSummary"]; + "application/json": components["schemas"]["HTTPValidationError"]; }; }; }; }; - get_session_api_sessions__session_id__get: { + connect_repo_api_onboarding_repo_post: { parameters: { query?: never; header?: never; - path: { - session_id: string; - }; + path?: never; cookie?: never; }; - requestBody?: never; + requestBody: { + content: { + "application/json": components["schemas"]["OnboardingRepoRequest"]; + }; + }; responses: { /** @description Successful Response */ 200: { @@ -3934,7 +4485,7 @@ export interface operations { [name: string]: unknown; }; content: { - "application/json": components["schemas"]["SessionDetail"]; + "application/json": unknown; }; }; /** @description Validation Error */ @@ -3948,11 +4499,13 @@ export interface operations { }; }; }; - list_api_keys_api_settings_api_keys_get: { + get_posture_fix_status_api_posture_fix_status__workspace_id__get: { parameters: { query?: never; header?: never; - path?: never; + path: { + workspace_id: string; + }; cookie?: never; }; requestBody?: never; @@ -3963,23 +4516,32 @@ export interface operations { [name: string]: unknown; }; content: { - "application/json": unknown; + "application/json": components["schemas"]["RepoAgentStatus"]; + }; + }; + /** @description Validation Error */ + 422: { + headers: { + [name: string]: unknown; + }; + content: { + "application/json": components["schemas"]["HTTPValidationError"]; }; }; }; }; - set_api_key_api_settings_api_keys__provider__put: { + fix_posture_check_api_posture_fix__check_name__post: { parameters: { query?: never; header?: never; path: { - provider: string; + check_name: "security_md" | "dependabot_config"; }; cookie?: never; }; - requestBody: { + requestBody?: { content: { - "application/json": components["schemas"]["ApiKeyCreate"]; + "application/json": components["schemas"]["PostureFixRequest"] | null; }; }; responses: { @@ -3989,7 +4551,7 @@ export interface operations { [name: string]: unknown; }; content: { - "application/json": unknown; + "application/json": components["schemas"]["PostureFixResponse"]; }; }; /** @description Validation Error */ @@ -4003,31 +4565,22 @@ export interface operations { }; }; }; - delete_api_key_api_settings_api_keys__provider__delete: { + seed_demo_data_api_seed_post: { parameters: { query?: never; header?: never; - path: { - provider: string; - }; + path?: never; cookie?: never; }; requestBody?: never; responses: { /** @description Successful Response */ - 204: { - headers: { - [name: string]: unknown; - }; - content?: never; - }; - /** @description Validation Error */ - 422: { + 201: { headers: { [name: string]: unknown; }; content: { - "application/json": components["schemas"]["HTTPValidationError"]; + "application/json": components["schemas"]["Finding"][]; }; }; }; @@ -4446,27 +4999,7 @@ export interface operations { [name: string]: unknown; }; content: { - "application/json": unknown; - }; - }; - }; - }; - get_configured_providers_api_settings_providers_configured_get: { - parameters: { - query?: never; - header?: never; - path?: never; - cookie?: never; - }; - requestBody?: never; - responses: { - /** @description Successful Response */ - 200: { - headers: { - [name: string]: unknown; - }; - content: { - "application/json": unknown; + "application/json": components["schemas"]["ProviderInfo"][]; }; }; }; @@ -4572,7 +5105,7 @@ export interface operations { }; responses: { /** @description Successful Response */ - 201: { + 200: { headers: { [name: string]: unknown; }; @@ -4686,37 +5219,6 @@ export interface operations { }; }; }; - stream_agent_execution_api_workspaces__workspace_id__agent_execution_stream_get: { - parameters: { - query?: never; - header?: never; - path: { - workspace_id: string; - }; - cookie?: never; - }; - requestBody?: never; - responses: { - /** @description Successful Response */ - 200: { - headers: { - [name: string]: unknown; - }; - content: { - "application/json": unknown; - }; - }; - /** @description Validation Error */ - 422: { - headers: { - [name: string]: unknown; - }; - content: { - "application/json": components["schemas"]["HTTPValidationError"]; - }; - }; - }; - }; list_agent_runs_endpoint_api_workspaces__workspace_id__agent_runs_get: { parameters: { query?: { @@ -4958,109 +5460,6 @@ export interface operations { }; }; }; - respond_to_chat_permission_api_workspaces__workspace_id__chat_permission_post: { - parameters: { - query?: never; - header?: never; - path: { - workspace_id: string; - }; - cookie?: never; - }; - requestBody: { - content: { - "application/json": components["schemas"]["ChatPermissionDecision"]; - }; - }; - responses: { - /** @description Successful Response */ - 200: { - headers: { - [name: string]: unknown; - }; - content: { - "application/json": unknown; - }; - }; - /** @description Validation Error */ - 422: { - headers: { - [name: string]: unknown; - }; - content: { - "application/json": components["schemas"]["HTTPValidationError"]; - }; - }; - }; - }; - workspace_send_message_api_workspaces__workspace_id__chat_send_post: { - parameters: { - query?: never; - header?: never; - path: { - workspace_id: string; - }; - cookie?: never; - }; - requestBody: { - content: { - "application/json": components["schemas"]["WorkspaceChatRequest"]; - }; - }; - responses: { - /** @description Successful Response */ - 200: { - headers: { - [name: string]: unknown; - }; - content: { - "application/json": unknown; - }; - }; - /** @description Validation Error */ - 422: { - headers: { - [name: string]: unknown; - }; - content: { - "application/json": components["schemas"]["HTTPValidationError"]; - }; - }; - }; - }; - workspace_stream_events_api_workspaces__workspace_id__chat_stream_get: { - parameters: { - query: { - session_id: string; - }; - header?: never; - path: { - workspace_id: string; - }; - cookie?: never; - }; - requestBody?: never; - responses: { - /** @description Successful Response */ - 200: { - headers: { - [name: string]: unknown; - }; - content: { - "application/json": unknown; - }; - }; - /** @description Validation Error */ - 422: { - headers: { - [name: string]: unknown; - }; - content: { - "application/json": components["schemas"]["HTTPValidationError"]; - }; - }; - }; - }; get_workspace_context_api_workspaces__workspace_id__context_get: { parameters: { query?: never; @@ -5347,68 +5746,6 @@ export interface operations { }; }; }; - workspace_pool_status_api_workspaces__workspace_id__pool_status_get: { - parameters: { - query?: never; - header?: never; - path: { - workspace_id: string; - }; - cookie?: never; - }; - requestBody?: never; - responses: { - /** @description Successful Response */ - 200: { - headers: { - [name: string]: unknown; - }; - content: { - "application/json": unknown; - }; - }; - /** @description Validation Error */ - 422: { - headers: { - [name: string]: unknown; - }; - content: { - "application/json": components["schemas"]["HTTPValidationError"]; - }; - }; - }; - }; - create_workspace_session_api_workspaces__workspace_id__sessions_post: { - parameters: { - query?: never; - header?: never; - path: { - workspace_id: string; - }; - cookie?: never; - }; - requestBody?: never; - responses: { - /** @description Successful Response */ - 200: { - headers: { - [name: string]: unknown; - }; - content: { - "application/json": unknown; - }; - }; - /** @description Validation Error */ - 422: { - headers: { - [name: string]: unknown; - }; - content: { - "application/json": components["schemas"]["HTTPValidationError"]; - }; - }; - }; - }; get_sidebar_endpoint_api_workspaces__workspace_id__sidebar_get: { parameters: { query?: never; diff --git a/frontend/src/components/ai-provider/AIProviderStatus.tsx b/frontend/src/components/ai-provider/AIProviderStatus.tsx index 68495074..c2c4df95 100644 --- a/frontend/src/components/ai-provider/AIProviderStatus.tsx +++ b/frontend/src/components/ai-provider/AIProviderStatus.tsx @@ -169,11 +169,11 @@ function ConnectedCard({ const modelName = formatModel(status.model) const source = sourceCopy(status) - // M9 (architect health-check): the drift banner + live-probe were - // removed. The on_key_change hook restarts the singleton OpenCode - // synchronously on every canonical-state write, so there is no drift - // signal worth showing — and rendering one made the read look like - // there were two sources of truth when ADR-0037 specifies one. + // The drift banner + live-probe were removed. With the substrate + // in-process (ADR-0047) there's no separate engine config to drift + // from, so there is no drift signal worth showing — and rendering one + // made the read look like there were two sources of truth when ADR-0037 + // specifies one. // Mono detail line — source · connected timestamp. The model now has // its own row so it gets the breathing room it needs for the picker @@ -587,7 +587,7 @@ function sourceCopy(s: AIStatusResponse): string { } /** - * Compact model display. OpenCode model ids are / or + * Compact model display. Model ids are / or * //; the leading provider prefix is * already visible via the heading, so we strip it. */ diff --git a/frontend/src/components/ai-provider/ModelPicker.tsx b/frontend/src/components/ai-provider/ModelPicker.tsx index f198a5bf..05fad110 100644 --- a/frontend/src/components/ai-provider/ModelPicker.tsx +++ b/frontend/src/components/ai-provider/ModelPicker.tsx @@ -333,8 +333,8 @@ export function ModelPicker({ lineHeight: 1.45, }} > - Must start with {provider}/. We forward it to - OpenCode as-is. + Must start with {provider}/. We use it as the + canonical model id as-is.

diff --git a/frontend/src/components/dashboard/PostureCard.tsx b/frontend/src/components/dashboard/PostureCard.tsx index ac5f8b4a..6b171e71 100644 --- a/frontend/src/components/dashboard/PostureCard.tsx +++ b/frontend/src/components/dashboard/PostureCard.tsx @@ -629,7 +629,7 @@ function PostureFixStatusStrip({ workspaceId }: { workspaceId: string }) { let label = 'Starting the generator agent…' if (status === 'queued') { - label = 'Agent queued — spinning up OpenCode…' + label = 'Agent queued — starting…' } else if (status === 'running') { label = 'Agent running — cloning, writing, committing, pushing…' } else if (status === 'pr_created') { diff --git a/frontend/src/components/issues/IssueSidePanel.tsx b/frontend/src/components/issues/IssueSidePanel.tsx index a1208415..92489902 100644 --- a/frontend/src/components/issues/IssueSidePanel.tsx +++ b/frontend/src/components/issues/IssueSidePanel.tsx @@ -180,8 +180,7 @@ export function IssueSidePanel({ // agent_run rows — both already polled. With the executor now parking a // durable DeferredToolRequests marker on the row, the poll surfaces the // approval prompt and run-status transitions within one interval, so no - // push channel is needed. (The chat SSE — api.streamWorkspaceEvents — is - // unrelated and stays.) + // push channel is needed. return (