From 871a7da04f4a2ea88703882a0682a34000424968 Mon Sep 17 00:00:00 2001 From: Lukman Nuriakhmetov Date: Sun, 12 Apr 2026 13:34:00 +0300 Subject: [PATCH 01/12] feat: implement Codencer v2 local self-host path Implement the full v2 local/self-host bridge path in this session: - harden the local daemon with explicit repo-root targeting, stable instance identity, manifest-backed discovery, truthful runtime compatibility reporting, artifact content retrieval, run reconciliation, and gate lifecycle closure - add the outbound connector with persistent Ed25519 identity, enrollment, signed challenge/response session auth, reconnect/heartbeat behavior, explicit instance sharing, and a narrow allowlisted proxy to the local daemon - add the self-host relay with sqlite-backed connector/enrollment state, planner auth scopes, connector session tracking, planner-facing /api/v2 routes, audit persistence, and resource routing hints - add the relay MCP surface with codencer.* tools on /mcp, keeping /mcp/call as a compatibility path while preserving relay auth and instance scoping - rewrite operator-facing architecture, security, connector, relay, self-host, and MCP docs to match current runtime truth, add WSL/Windows/Antigravity topology guidance, and record the v2 work in the changelog Verification performed: - go test ./internal/app ./internal/service ./internal/connector ./internal/relay ./internal/mcp -count=1 - go test ./... -count=1 Known alpha limitations remain explicit in docs: best-effort abort, opportunistic relay routing for previously unseen resource IDs, bounded artifact transport, and static self-host auth. --- CHANGELOG.md | 7 + Makefile | 8 + README.md | 105 ++- cmd/codencer-connectord/main.go | 63 ++ cmd/codencer-relayd/main.go | 34 + cmd/connector/main.go | 68 ++ cmd/orchestratorctl/main.go | 1 + cmd/relayd/main.go | 34 + docs/02_architecture.md | 264 +++--- docs/05_dsl_and_mcp.md | 231 ++--- docs/07_security_ops.md | 106 +-- docs/CONNECTOR.md | 110 +++ docs/RELAY.md | 144 ++++ docs/SELF_HOST_REFERENCE.md | 182 ++++ docs/WSL_WINDOWS_ANTIGRAVITY.md | 94 +++ docs/design/v2_relay_contracts.md | 794 ++++++++++++++++++ docs/mcp/integrations.md | 41 + docs/mcp/relay_tools.md | 51 ++ go.mod | 1 + go.sum | 2 + .../adapters/antigravity/broker_adapter.go | 23 +- internal/app/api_test.go | 161 +++- internal/app/bootstrap.go | 87 +- internal/app/bootstrap_test.go | 71 +- internal/app/routes.go | 118 +-- internal/connector/allowlist.go | 37 + internal/connector/allowlist_test.go | 41 + internal/connector/backoff.go | 29 + internal/connector/codencer_client.go | 249 ++++++ internal/connector/config.go | 94 +++ internal/connector/enroll.go | 89 ++ internal/connector/enroll_test.go | 68 ++ internal/connector/identity.go | 60 ++ internal/connector/identity_test.go | 29 + internal/connector/registry.go | 171 ++++ internal/connector/registry_test.go | 54 ++ internal/connector/session.go | 237 ++++++ internal/connector/session_test.go | 209 +++++ internal/domain/compatibility.go | 23 + internal/domain/instance.go | 33 +- internal/relay/audit.go | 20 + internal/relay/audit_test.go | 38 + internal/relay/auth.go | 93 ++ internal/relay/auth_test.go | 67 ++ internal/relay/config.go | 101 +++ internal/relay/enrollment_service.go | 153 ++++ internal/relay/enrollment_service_test.go | 51 ++ internal/relay/http_api.go | 44 + internal/relay/hub.go | 166 ++++ internal/relay/id.go | 15 + internal/relay/integration_test.go | 181 ++++ internal/relay/mcp_server.go | 283 +++++++ internal/relay/mcp_server_test.go | 388 +++++++++ internal/relay/mcp_tools.go | 446 ++++++++++ internal/relay/router.go | 466 ++++++++++ internal/relay/server.go | 282 +++++++ internal/relay/session_hub.go | 16 + internal/relay/session_hub_test.go | 29 + internal/relay/store.go | 14 + internal/relay/store/store.go | 531 ++++++++++++ internal/relayproto/types.go | 99 +++ internal/service/antigravity_service.go | 23 +- internal/service/broker_integration_test.go | 10 +- internal/service/e2e_test.go | 6 +- internal/service/gate_service.go | 60 +- internal/service/gate_service_test.go | 123 +++ internal/service/instance_service.go | 269 ++++++ internal/service/recovery_service.go | 46 +- internal/service/recovery_test.go | 27 +- internal/service/retrieval_test.go | 84 ++ internal/service/routing_service.go | 13 +- internal/service/run_service.go | 434 ++++++++-- internal/service/run_service_test.go | 334 +++++++- internal/service/state_reconcile.go | 48 ++ internal/service/state_reconcile_test.go | 56 ++ internal/storage/sqlite/artifacts_repo.go | 29 + schemas/result.schema.json | 5 +- 77 files changed, 8614 insertions(+), 659 deletions(-) create mode 100644 cmd/codencer-connectord/main.go create mode 100644 cmd/codencer-relayd/main.go create mode 100644 cmd/connector/main.go create mode 100644 cmd/relayd/main.go create mode 100644 docs/CONNECTOR.md create mode 100644 docs/RELAY.md create mode 100644 docs/SELF_HOST_REFERENCE.md create mode 100644 docs/WSL_WINDOWS_ANTIGRAVITY.md create mode 100644 docs/design/v2_relay_contracts.md create mode 100644 docs/mcp/integrations.md create mode 100644 docs/mcp/relay_tools.md create mode 100644 internal/connector/allowlist.go create mode 100644 internal/connector/allowlist_test.go create mode 100644 internal/connector/backoff.go create mode 100644 internal/connector/codencer_client.go create mode 100644 internal/connector/config.go create mode 100644 internal/connector/enroll.go create mode 100644 internal/connector/enroll_test.go create mode 100644 internal/connector/identity.go create mode 100644 internal/connector/identity_test.go create mode 100644 internal/connector/registry.go create mode 100644 internal/connector/registry_test.go create mode 100644 internal/connector/session.go create mode 100644 internal/connector/session_test.go create mode 100644 internal/domain/compatibility.go create mode 100644 internal/relay/audit.go create mode 100644 internal/relay/audit_test.go create mode 100644 internal/relay/auth.go create mode 100644 internal/relay/auth_test.go create mode 100644 internal/relay/config.go create mode 100644 internal/relay/enrollment_service.go create mode 100644 internal/relay/enrollment_service_test.go create mode 100644 internal/relay/http_api.go create mode 100644 internal/relay/hub.go create mode 100644 internal/relay/id.go create mode 100644 internal/relay/integration_test.go create mode 100644 internal/relay/mcp_server.go create mode 100644 internal/relay/mcp_server_test.go create mode 100644 internal/relay/mcp_tools.go create mode 100644 internal/relay/router.go create mode 100644 internal/relay/server.go create mode 100644 internal/relay/session_hub.go create mode 100644 internal/relay/session_hub_test.go create mode 100644 internal/relay/store.go create mode 100644 internal/relay/store/store.go create mode 100644 internal/relayproto/types.go create mode 100644 internal/service/gate_service_test.go create mode 100644 internal/service/instance_service.go create mode 100644 internal/service/state_reconcile.go create mode 100644 internal/service/state_reconcile_test.go diff --git a/CHANGELOG.md b/CHANGELOG.md index 90d6d08..d39bca9 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -8,12 +8,19 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0 ## [Unreleased] ### Added +- Self-hostable v2 relay path with: + - stable daemon instance identity and manifest-backed discovery + - outbound authenticated connector sessions with explicit shared-instance allowlists + - self-host relay planner API, enrollment token flow, audit persistence, and relay-side MCP tools - **OpenClaw (acpx) Adapter**: 🧪 Experimental support for OpenClaw-compatible executors via the standardized ACP bridge. - Official sequential wrapper examples for bash/zsh, PowerShell, and Python under `examples/automation/`. - Wrapper-friendly sample task lists and prompt/task inputs for ordered execution. - New `scripts/smoke_test_v1.sh` for verifying all 6 primary submission modes. ### Changed +- Rewrote operator-facing v2 docs to match the implemented local/self-host path and current runtime truth. +- Clarified that the relay is the public remote HTTP/MCP surface and the daemon-local `/mcp/call` endpoint is only a local compatibility/admin surface. +- Documented current self-host alpha limitations explicitly: best-effort abort, opportunistic resource routing, bounded artifact transport, and static-token auth. - **Unified v1 Documentation Truth-Pass**: Cleaned and synchronized all public-facing docs (README, AI Guide, Runbook, Automation) for 100% alignment with the CLI contract. - Expanded automation documentation to make the shell-planner story explicit and machine-oriented. - Clarified that ordered task execution in v1 is wrapper-based and not a native workflow engine. diff --git a/Makefile b/Makefile index 645826e..83e0aff 100644 --- a/Makefile +++ b/Makefile @@ -5,6 +5,14 @@ build: @go build -ldflags "-X agent-bridge/internal/app.Version=v1.0-release-candidate" -o bin/orchestratord ./cmd/orchestratord @echo "==> Building orchestratorctl..." @go build -ldflags "-X agent-bridge/internal/app.Version=v1.0-release-candidate" -o bin/orchestratorctl ./cmd/orchestratorctl + @echo "==> Building connector..." + @go build -ldflags "-X agent-bridge/internal/app.Version=v1.0-release-candidate" -o bin/connector ./cmd/connector + @echo "==> Building codencer-connectord..." + @go build -ldflags "-X agent-bridge/internal/app.Version=v1.0-release-candidate" -o bin/codencer-connectord ./cmd/codencer-connectord + @echo "==> Building relayd..." + @go build -ldflags "-X agent-bridge/internal/app.Version=v1.0-release-candidate" -o bin/relayd ./cmd/relayd + @echo "==> Building codencer-relayd..." + @go build -ldflags "-X agent-bridge/internal/app.Version=v1.0-release-candidate" -o bin/codencer-relayd ./cmd/codencer-relayd test: @echo "==> Running tests..." diff --git a/README.md b/README.md index 921826d..efa8b62 100644 --- a/README.md +++ b/README.md @@ -31,6 +31,52 @@ Codencer is a **Tactical Orchestration Bridge**, not a strategic planner. It han - **Bridge (Codencer)**: Receives the `TaskSpec`, manages workspace isolation (Git Worktrees), enforces policies, and monitors execution. - **Coding Agent (Worker)**: The tactical tool performing the actual work (e.g., `codex-agent`, `claude`). +## V2 Remote Path + +Codencer now includes the first open-source self-hostable remote path while keeping execution local: + +```text +Planner / Chat + -> Relay MCP / Planner API + -> Relay Server + -> Authenticated Connector (outbound websocket) + -> Local Codencer Daemon + -> Local Adapter / Executor +``` + +Key constraints remain unchanged: +- planning stays outside Codencer +- execution stays local +- the relay is transport and audit, not a planner +- the connector exposes only a narrow allowlisted proxy to the local daemon +- no raw remote shell or arbitrary filesystem surface is exposed + +### New Binaries + +- `bin/connector` and `bin/codencer-connectord`: enroll with a relay and maintain the outbound authenticated connector session +- `bin/relayd` and `bin/codencer-relayd`: run the self-hostable relay server, planner-facing API, connector websocket endpoint, and relay-side MCP surface + +### Self-Host Quickstart + +1. Build the binaries with `make build`. +2. Start the local daemon with `make start` or `make start-sim`. +3. Start the relay with a config that sets `planner_token` or `planner_tokens`. +4. Create a one-time enrollment token: + `curl -X POST http://127.0.0.1:8090/api/v2/connectors/enrollment-tokens -H 'Authorization: Bearer ' -H 'Content-Type: application/json' -d '{"label":"local-dev","expires_in_seconds":600}'` +5. Enroll the connector: + `./bin/codencer-connectord enroll --relay-url http://127.0.0.1:8090 --daemon-url http://127.0.0.1:8085 --enrollment-token ` +6. Run the connector: + `./bin/codencer-connectord run` + +Planner-facing relay routes live under `/api/v2`, and the relay-hosted MCP entrypoint is `/mcp` with `/mcp/call` kept as a compatibility path. +The connector now persists a local Ed25519 identity, `connector_id`, `machine_id`, and an explicit shared-instance allowlist under `.codencer/connector/config.json`. +For the end-to-end self-host flow and operating notes, see [docs/SELF_HOST_REFERENCE.md](docs/SELF_HOST_REFERENCE.md), [docs/CONNECTOR.md](docs/CONNECTOR.md), [docs/RELAY.md](docs/RELAY.md), and [docs/mcp/relay_tools.md](docs/mcp/relay_tools.md). + +Daemon discovery and evidence notes: +- `GET /api/v1/instance` now exposes stable repo-local daemon identity plus manifest-backed discovery metadata. +- The daemon writes a repo-local instance manifest under `.codencer/instance.json` on startup and after Antigravity bind changes. +- `PATCH /api/v1/runs/{id}` remains best-effort abort. Codencer does not claim hard process cancellation unless the adapter actually stops. + --- ## 🚀 The Canonical "Day 0" Path (Human-First) @@ -254,45 +300,37 @@ Agent-driven coding is non-deterministic. Codencer provides the guardrails: --- -## ⚠️ Known Limitations (Beta/MVP) +## ⚠️ Known Limitations (Local/Self-Host Alpha) -As a local-first Beta/MVP, Codencer has the following constraints: -- **Relay Only**: The bridge does not "think" or plan; it only executes what the Planner instructs. -- **Single-User**: Designed for local development; no multi-user or cloud concurrency. -- **Static Extension Routing**: The experimental VS Code extension assumes the daemon binds at `127.0.0.1:8085`. Dynamic connection configuration for running instances on multiple ports is not yet natively surfaced in the IDE client. -- **Agent Dependency**: "Real Mode" efficacy is strictly bound to the quality of the underlying agent (Codex, Claude, etc.). -- **Manual Decisions**: The bridge reports terminal states; all recovery or retry decisions remain with the human operator or external planner. -- **No Native Workflow Engine**: Ordered task lists are handled by wrappers/scripts outside Codencer core in v1. +Codencer’s v2 path is materially real for local and self-host use, but it is still alpha-grade in a few places: +- **No Planner In Core**: Codencer never decomposes, prioritizes, or decides strategy. The planner still owns those decisions. +- **Best-Effort Abort**: `PATCH /api/v1/runs/{id}` and relay abort flows are honest but not universal hard-kill guarantees. A run is only reported cancelled when the adapter actually stops. +- **Opportunistic Remote Routing**: Relay step, gate, and artifact routing is learned from prior responses. Direct remote lookups can fail until the relay has already seen those IDs. +- **Bounded Artifact Transport**: Connector transport rejects oversized artifact bodies instead of turning the relay into a bulk file tunnel. Large binary transfer is intentionally limited. +- **Static Self-Host Auth**: Planner auth is static bearer-token based, suitable for self-host alpha use but not enterprise IAM. +- **Single-Operator Bias**: The current flow is optimized for local/self-host operators, not multi-tenant hosted service use. +- **No Native Workflow Brain**: Ordered task execution remains wrapper- or planner-driven outside Codencer core. ---- +### Runtime Capability Truth -### 📊 Maturity & Capability Matrix +Adapter availability is runtime-derived, not a hardcoded support matrix. The source of truth is: +- `GET /api/v1/compatibility` +- `GET /api/v1/instance` +- `./bin/orchestratorctl instance --json` -Codencer is in **Public Beta (v1.0-release-candidate)**. Use this to understand the hard stability contract versus experimental value-adds. +Those surfaces reflect actual registered adapters, simulation mode, binary availability, and Antigravity binding state at runtime. -#### 🏗 v1 Stable Core (The Release Contract) -| Feature Area | Status | Description | -| :--- | :--- | :--- | -| **Local Bridge Core** | ✅ **Stable** | Persistence, state machine, Git Worktrees. | -| **Provisioning Layer**| ✅ **Stable** | Native copy/symlink layer; optional Grove subset. | -| **Codex Adapter** | ✅ **Stable** | Primary high-fidelity relay for `codex-agent`. | -| **Antigravity Metadata** | ✅ **Stable** | Broker-backed context, task IDs, and provenance. | -| **Antigravity Broker** | ✅ **Stable** | Cross-side (WSL/Windows) bridge for IDE instances. | -| **OpenClaw ACPX** | 🧪 **Experimental (Alpha)** | Standardized ACP bridge to OpenClaw ecosystem. | -| **Simulation Mode** | ✅ **Stable** | Stub-based validation (Bridge-only smoke tests). | - -#### 🧪 Experimental Extensions (Outside v1 Contract) -| Feature Area | Status | Description | -| :--- | :--- | :--- | -| **IDE Chat Bridge** | 🧪 **Prototype** | Proxy-mediated file access via VS Code. | -| **Cloud / Multi-User** | 🚫 **Non-Goal** | Codencer is strictly local-first and self-hosted. | +### WSL / Windows / Antigravity + +The practical cross-side model is: +- daemon, repos, worktrees, and artifacts in WSL/Linux +- connector on the same side as the daemon by default +- Antigravity broker and IDE on Windows when needed +- relay as a separate remote control plane only +Use `orchestratorctl antigravity bind ` to bind this repo to an active Antigravity instance. Binding selects the repo-scoped target, but execution still stays local and still depends on the chosen adapter profile. -### 🔍 Direct-Local Antigravity Integration -The `antigravity` adapter uses a **direct-local** model to control active Antigravity instances via RPC (Connect over HTTPS). -- **Primary Model**: Codencer and Antigravity usually run on the **same OS side** (e.g., both in Linux or both in Windows). -- **WSL ↔ Windows (Experimental)**: Cross-side communication is supported via the shared loopback (`127.0.0.1`). Codencer in WSL can discover Windows-side instances if the host's `.gemini` directory is reachable (e.g., via `/mnt/c`). -- **Binding**: Use `orchestratorctl antigravity bind ` to link this repository to an active Antigravity process. Binding establishes repo-scoped target identity and connectivity; execution still depends on the task's explicit `adapter_profile`. +For the full trust-boundary and topology guidance, see [docs/WSL_WINDOWS_ANTIGRAVITY.md](docs/WSL_WINDOWS_ANTIGRAVITY.md). ### 🔍 Terminal Step States Codencer distinguishes between different failure modes to help you recover faster: @@ -323,7 +361,8 @@ Review the following guides to get started with Codencer. - **[CLI Automation Patterns](docs/CLI_AUTOMATION.md)** — Machine-safe JSON mode and sequential loops. - **[Environmental Reference](docs/SETUP.md)** — Prerequisites, configuration, and daemon management. - **[Troubleshooting Guide](docs/TROUBLESHOOTING.md)** — Resolving infrastructure vs goal failures. -- **[Architecture Overview](docs/02_architecture.md)** — Deep dive into the Bridge model. +- **[Architecture Overview](docs/02_architecture.md)** — Current daemon, connector, relay, and trust-boundary model. +- **[WSL / Windows / Antigravity Topology](docs/WSL_WINDOWS_ANTIGRAVITY.md)** — Practical cross-side deployment guidance. ### 🛠 Project Governance & Maintenance (Internal) - **[Gap Audit & Roadmap](docs/internal/GAP_AUDIT.md)** — Current V1 release blockers and debt. diff --git a/cmd/codencer-connectord/main.go b/cmd/codencer-connectord/main.go new file mode 100644 index 0000000..8699ca0 --- /dev/null +++ b/cmd/codencer-connectord/main.go @@ -0,0 +1,63 @@ +package main + +import ( + "context" + "flag" + "fmt" + "log" + "os" + "os/signal" + "syscall" + + "agent-bridge/internal/connector" +) + +func main() { + if len(os.Args) < 2 { + log.Fatal("usage: codencer-connectord [flags]") + } + + switch os.Args[1] { + case "enroll": + runEnroll(os.Args[2:]) + case "run": + runConnector(os.Args[2:]) + default: + log.Fatalf("unknown connector command %s", os.Args[1]) + } +} + +func runEnroll(args []string) { + fs := flag.NewFlagSet("enroll", flag.ExitOnError) + relayURL := fs.String("relay-url", "http://127.0.0.1:8090", "Relay base URL") + daemonURL := fs.String("daemon-url", "http://127.0.0.1:8085", "Local Codencer daemon URL") + enrollmentToken := fs.String("enrollment-token", "", "Relay enrollment token") + configPath := fs.String("config", ".codencer/connector/config.json", "Connector config path") + label := fs.String("label", "", "Optional connector label") + fs.Parse(args) + + cfg, err := connector.Enroll(context.Background(), *relayURL, *daemonURL, *enrollmentToken, *label, *configPath) + if err != nil { + log.Fatal(err) + } + fmt.Printf("Connector enrolled: %s machine=%s\n", cfg.ConnectorID, cfg.MachineID) +} + +func runConnector(args []string) { + fs := flag.NewFlagSet("run", flag.ExitOnError) + configPath := fs.String("config", ".codencer/connector/config.json", "Connector config path") + fs.Parse(args) + + cfg, err := connector.LoadConfig(*configPath) + if err != nil { + log.Fatal(err) + } + client := connector.NewClient(cfg) + + ctx, cancel := signal.NotifyContext(context.Background(), syscall.SIGINT, syscall.SIGTERM) + defer cancel() + + if err := client.Run(ctx); err != nil && err != context.Canceled { + log.Fatal(err) + } +} diff --git a/cmd/codencer-relayd/main.go b/cmd/codencer-relayd/main.go new file mode 100644 index 0000000..af7c7bf --- /dev/null +++ b/cmd/codencer-relayd/main.go @@ -0,0 +1,34 @@ +package main + +import ( + "context" + "flag" + "log" + "os/signal" + "syscall" + + "agent-bridge/internal/relay" +) + +func main() { + configPath := flag.String("config", "", "Relay config path") + flag.Parse() + + cfg, err := relay.LoadConfig(*configPath) + if err != nil { + log.Fatal(err) + } + store, err := relay.OpenStore(cfg.DBPath) + if err != nil { + log.Fatal(err) + } + defer store.Close() + + server := relay.NewServer(cfg, store) + ctx, cancel := signal.NotifyContext(context.Background(), syscall.SIGINT, syscall.SIGTERM) + defer cancel() + + if err := server.Start(ctx); err != nil && err != context.Canceled { + log.Fatal(err) + } +} diff --git a/cmd/connector/main.go b/cmd/connector/main.go new file mode 100644 index 0000000..fa1e341 --- /dev/null +++ b/cmd/connector/main.go @@ -0,0 +1,68 @@ +package main + +import ( + "context" + "flag" + "fmt" + "log" + "os" + "os/signal" + "syscall" + + "agent-bridge/internal/connector" +) + +func main() { + if len(os.Args) < 2 { + log.Fatal("usage: connector [flags]") + } + + switch os.Args[1] { + case "enroll": + runEnroll(os.Args[2:]) + case "run": + runConnector(os.Args[2:]) + default: + log.Fatalf("unknown connector command %s", os.Args[1]) + } +} + +func runEnroll(args []string) { + fs := flag.NewFlagSet("enroll", flag.ExitOnError) + relayURL := fs.String("relay-url", "http://127.0.0.1:8090", "Relay base URL") + daemonURL := fs.String("daemon-url", "http://127.0.0.1:8085", "Local Codencer daemon URL") + enrollmentSecret := fs.String("enrollment-secret", "", "Relay enrollment token (legacy flag name)") + enrollmentToken := fs.String("enrollment-token", "", "Relay enrollment token") + configPath := fs.String("config", ".codencer/connector/config.json", "Connector config path") + label := fs.String("label", "", "Optional connector label") + fs.Parse(args) + + token := *enrollmentToken + if token == "" { + token = *enrollmentSecret + } + cfg, err := connector.Enroll(context.Background(), *relayURL, *daemonURL, token, *label, *configPath) + if err != nil { + log.Fatal(err) + } + fmt.Printf("Connector enrolled: %s machine=%s\n", cfg.ConnectorID, cfg.MachineID) +} + +func runConnector(args []string) { + fs := flag.NewFlagSet("run", flag.ExitOnError) + configPath := fs.String("config", ".codencer/connector/config.json", "Connector config path") + fs.Parse(args) + + cfg, err := connector.LoadConfig(*configPath) + if err != nil { + log.Fatal(err) + } + client := connector.NewClient(cfg) + + ctx, cancel := signal.NotifyContext(context.Background(), syscall.SIGINT, syscall.SIGTERM) + defer cancel() + + if err := client.Run(ctx); err != nil && err != context.Canceled { + log.Fatal(err) + } +} diff --git a/cmd/orchestratorctl/main.go b/cmd/orchestratorctl/main.go index e022d18..a24e901 100644 --- a/cmd/orchestratorctl/main.go +++ b/cmd/orchestratorctl/main.go @@ -1235,6 +1235,7 @@ func handleInstanceCommand(args []string) { } fmt.Printf("--- Codencer Instance Identity ---\n") + fmt.Printf("Instance ID: %s\n", info.ID) fmt.Printf("Version: %s\n", info.Version) fmt.Printf("Repo Root: %s\n", info.RepoRoot) fmt.Printf("Base URL: %s\n", info.BaseURL) diff --git a/cmd/relayd/main.go b/cmd/relayd/main.go new file mode 100644 index 0000000..af7c7bf --- /dev/null +++ b/cmd/relayd/main.go @@ -0,0 +1,34 @@ +package main + +import ( + "context" + "flag" + "log" + "os/signal" + "syscall" + + "agent-bridge/internal/relay" +) + +func main() { + configPath := flag.String("config", "", "Relay config path") + flag.Parse() + + cfg, err := relay.LoadConfig(*configPath) + if err != nil { + log.Fatal(err) + } + store, err := relay.OpenStore(cfg.DBPath) + if err != nil { + log.Fatal(err) + } + defer store.Close() + + server := relay.NewServer(cfg, store) + ctx, cancel := signal.NotifyContext(context.Background(), syscall.SIGINT, syscall.SIGTERM) + defer cancel() + + if err := server.Start(ctx); err != nil && err != context.Canceled { + log.Fatal(err) + } +} diff --git a/docs/02_architecture.md b/docs/02_architecture.md index 4de92a5..b6f6563 100644 --- a/docs/02_architecture.md +++ b/docs/02_architecture.md @@ -1,192 +1,122 @@ -> [!NOTE] -> This is a **design specification** and may not fully reflect the current implementation. -> For the latest implementation status, see the [Gap Audit](internal/GAP_AUDIT.md). - # Architecture -## High-level architecture +This document describes the current Codencer v2 runtime architecture. + +## High-Level Model ```text -Planner Chat +Planner / Chat | - | MCP tools / local CLI + | Relay HTTP API or Relay MCP v -Local MCP Server +Relay | + | Authenticated outbound websocket v -Orchestrator Daemon +Connector | - +--> Policy Engine - +--> SQLite Run Ledger - +--> Artifact Store (filesystem) - +--> Validation Runner - +--> Workspace / Git Manager - +--> Adapter Manager - | - +--> Codex Adapter - +--> Claude Adapter - +--> Qwen Adapter - +--> IDE Companion Adapter - +--> IDE Chat Adapter (later) + | Narrow allowlisted local API proxy + v +Local Codencer Daemon + | + +--> SQLite state and settings + +--> Artifact store + +--> Workspace / git manager + +--> Validation runner + +--> Adapter dispatch + +--> Gate and recovery services ``` -## Core components +Execution stays local. Planning stays outside Codencer. + +## Core Runtime Roles -### Orchestrator daemon -System of record. +### Local daemon + +The daemon is the local system of record. Responsibilities: -- manage run / phase / step lifecycle -- dispatch steps -- supervise processes +- manage run, step, attempt, and gate lifecycle - persist state -- enforce policy -- collect artifacts -- expose state - -Recommended implementation: -- Go -- local HTTP or Unix socket -- SQLite -- filesystem artifacts - -### MCP server -Thin bridge exposing safe orchestrator operations: -- start run -- start step -- get status -- get result -- approve gate -- reject gate -- retry step -- abort run - -### Adapter manager -Provider-neutral execution contract. - -Each adapter should support: -- Start -- Poll -- Cancel -- CollectArtifacts -- NormalizeResult -- Capabilities - -### Policy engine -Decides: -- continue -- retry -- stop for approval -- fail terminally - -Inputs: -- validations -- file changes -- forbidden path touches -- migrations -- dependency changes -- adapter-reported uncertainty -- timeouts - -### Run ledger -Persist: +- dispatch adapters +- collect artifacts and validations +- expose local `/api/v1` and local compatibility/admin `/mcp/call` + +The daemon is not the public internet-facing MCP server. + +### Connector + +The connector is the outbound bridge between relay and local daemon. + +Responsibilities: +- persist connector identity +- enroll with relay +- authenticate with signed challenge/response +- advertise explicitly shared instances +- proxy only a narrow local API surface + +The connector does not plan and does not execute work directly. + +### Relay + +The relay is the remote control plane. + +Responsibilities: +- authenticate planners +- authenticate connectors +- track online connectors and advertised instances +- route planner requests to the correct shared local instance +- persist audit events +- expose relay HTTP API and relay MCP + +The relay is not a planner and not an executor. + +## Public Surfaces + +### Remote/public + +- relay HTTP API under `/api/v2` +- relay MCP under `/mcp` +- relay MCP compatibility path `/mcp/call` +- connector websocket under `/ws/connectors` + +### Local/private by default + +- daemon HTTP API under `/api/v1` +- daemon-local `/mcp/call` compatibility/admin bridge + +## State And Evidence + +The current authoritative state lives in the daemon: - runs -- phases - steps - attempts +- gates - artifacts - validations -- gates + +The relay stores only the remote control-plane state it needs: +- connector identity +- instance advertisement records +- resource routing hints - audit events +- enrollment/challenge state -### Artifact store -Deterministic structure like: +## Trust Boundaries -```text -.artifacts/ - runs/ - run-0001/ - manifest.json - phase-execution/ - step-01/ - attempt-01/ - input.json - stdout.log - stderr.log - result.json - diff.patch - changed-files.json - validations.json -``` +- planner decides what to do +- relay authenticates and routes +- connector limits remote reach to a narrow allowlist +- daemon executes and records truth locally +- adapters do local work only -### Validation runner -Runs: -- lint -- tests -- build -- typecheck -- formatting -- custom commands from policy/task spec +There is no raw shell or arbitrary filesystem browsing surface in the relay or connector. -### Workspace / Git manager -Responsibilities: -- detect dirty repo -- allocate isolated worktree when configured -- capture diffs -- cleanup safely -- prevent overlapping writes - -## State machine - -### Run states -- created -- running -- paused_for_gate -- completed -- failed -- cancelled - -### Step states -- pending -- dispatching -- running -- collecting_artifacts -- validating -- completed -- completed_with_warnings -- needs_approval -- failed_retryable -- failed_terminal -- cancelled - -## Design rules - -### Planner is not source of truth -Planner suggests. -Orchestrator owns actual state. - -### Adapter is not control plane -Adapter executes. -Orchestrator decides lifecycle. - -### IDE extension is not orchestrator -Extension is only a control/visibility surface. - -## Why CLI-first - -CLI agents are easier for: -- process supervision -- stdout/stderr capture -- timeouts -- retries -- cancellation -- deterministic wrapping - -## Why IDE chat automation is later - -IDE AI chats are often implemented inside extension-owned webviews or custom panels. -That makes generic automation brittle. -So: -- CLI path is primary -- IDE companion comes later -- IDE chat adapters are targeted and optional +## WSL / Windows Model + +The practical default is: +- daemon, connector, repo, worktrees, and artifacts in WSL/Linux +- IDE and Antigravity broker on Windows when needed +- relay wherever the operator hosts the remote control plane + +See [WSL / Windows / Antigravity Topology](WSL_WINDOWS_ANTIGRAVITY.md) for detailed placement guidance. diff --git a/docs/05_dsl_and_mcp.md b/docs/05_dsl_and_mcp.md index b55a1eb..d478216 100644 --- a/docs/05_dsl_and_mcp.md +++ b/docs/05_dsl_and_mcp.md @@ -1,169 +1,72 @@ -> [!NOTE] -> This is a **design specification** and may not fully reflect the current implementation. -> For the latest implementation status, see the [Gap Audit](internal/GAP_AUDIT.md). - # DSL and MCP -## Why a DSL - -Without a DSL, the system collapses into ad hoc prompt passing. - -The DSL should make each step: -- declarative -- validated -- policy-aware -- provider-neutral - -## TaskSpec (Execution Request) - -The `TaskSpec` is the canonical contract sent by a **Planner** to the **Bridge**. It defines exactly WHAT needs to be done and the BOUNDARIES of that execution. The Bridge acts as a deterministic relay and executor, ensuring policies are enforced without making planning decisions. - -### TaskSpec example - -```yaml -version: v1 -project_id: local-agent-bridge -run_id: run-0001 -# phase_id: phase-execution-run-123 # Optional, auto-generated if omitted -# step_id: step-01 # Optional, auto-generated if omitted -title: Implement Codex adapter invocation and artifact capture -goal: Build the first working Codex adapter that can execute a step, capture logs, and return a normalized result. -context: - summary: > - This is the first provider adapter. Keep it minimal but production-oriented. -constraints: - - Do not introduce cloud functionality. - - Do not bypass service boundaries. -allowed_paths: - - internal/adapters/codex/** - - internal/service/** - - internal/domain/** -forbidden_paths: - - internal/adapters/claude/** - - internal/adapters/qwen/** -validations: - - name: unit-tests - command: go test ./... - - name: lint - command: golangci-lint run -acceptance: - - Codex adapter implements common adapter interface. - - Logs are captured to artifact storage. - - Result is normalized into ResultSpec. -stop_conditions: - - Adapter interface must be redesigned. - - State machine must be rewritten. -policy_bundle: safe_refactor -adapter_profile: codex -timeout_seconds: 300 -is_simulation: false -``` - -## ResultSpec example - -```json -{ - "version": "v1", - "run_id": "run-0001", - "phase_id": "phase-04-codex-adapter", - "step_id": "step-01", - "attempt_id": "attempt-01", - "adapter": "codex", - "state": "completed_with_warnings", - "is_simulation": false, - "summary": "Implemented Codex adapter invocation and result normalization.", - "files_changed": [ - "internal/adapters/codex/adapter.go", - "internal/adapters/codex/invoke.go" - ], - "validations": [ - {"name": "unit-tests", "state": "passed"}, - {"name": "lint", "state": "failed"} - ], - "needs_human_decision": false, - "warnings": ["Lint failed due to an unused import."], - "questions": [], - "artifacts": { - "stdout_log": ".artifacts/.../stdout.log", - "stderr_log": ".artifacts/.../stderr.log", - "diff_patch": ".artifacts/.../diff.patch" - } -} -``` - -## PolicySpec example - -```yaml -version: v1 -name: safe_refactor -continue_when: - all_validations_pass: true - max_changed_files: 12 - no_forbidden_paths_touched: true - no_migrations_detected: true -gate_when: - any_validation_fails: true - dependency_files_changed: true - migrations_detected: true - changed_files_over: 12 - unresolved_questions_present: true -retry_when: - adapter_process_failed: true - timeout_once: true -fail_when: - timeout_count_over: 2 - artifact_persistence_failed: true -``` - -### Execution States -The `state` property in the result payload follows strict relay semantics: - -| State | Who Decides? | Meaning | -| :--- | :--- | :--- | -| `pending` | Planner | Waiting for dispatch. | -| `running` | Bridge | Active execution. | -| `completed` | Bridge/Policy | Success criteria met. | -| `completed_with_warnings` | Bridge/Policy | Success with minor issues. | -| `failed_retryable` | Bridge | Transient failure, retry possible. | -| `failed_terminal` | Bridge | Non-retryable failure. | -| `timeout` | Bridge | Limit exceeded. | -| `needs_approval` | Bridge/Policy | Policy gate hit. | -| `needs_manual_attention`| Bridge | Intervention reported. | -| `cancelled` | Planner | Aborted by user. | - -## Simulation Semantics - -Simulation mode provides a high-fidelity environment for testing the bridge's state machine without real adapter execution. - -> [!IMPORTANT] -> Simulation is intended for development and automated testing only. It does not produce valid metrics for adapter benchmarking. - -It allows planners to: -1. Verify the end-to-end orchestration state machine. -2. Test policy enforcement without executing heavy local binaries. -3. Validate UI and notification flows. - -**IMPORTANT**: Simulation results are produced by stub adapters and do NOT represent real agency. Telemetry from simulated runs is kept separate in the benchmark ledger to ensure historical performance data remains honest. - -## MCP tool surface - -Expose only safe orchestrator primitives: - -- `orchestrator.start_run` -- `orchestrator.start_step` -- `orchestrator.get_status` -- `orchestrator.get_result` -- `orchestrator.list_artifacts` -- `orchestrator.approve_gate` -- `orchestrator.reject_gate` -- `orchestrator.retry_step` -- `orchestrator.abort_run` -- `orchestrator.run_validations` - -## MCP rules +This document describes the current execution contract and MCP surfaces in Codencer v2. + +## TaskSpec + +`TaskSpec` is the canonical execution request contract. + +It defines: +- goal +- stable identifiers +- adapter preference +- allowed and forbidden paths +- validations +- acceptance criteria +- timeout and simulation intent + +Current source of truth: +- `internal/domain/task.go` +- `schemas/task.schema.json` + +### Required minimum + +A valid task must at least include: +- `version` +- `goal` + +The daemon or local CLI may fill omitted `run_id`, `phase_id`, and `step_id` where the route already establishes that context. + +## ResultSpec + +`ResultSpec` is the normalized execution result contract returned by the daemon and relay-backed flows. + +Required truth fields include: +- `version` +- `run_id` +- `step_id` +- `state` +- `summary` +Current source of truth: +- daemon result serialization +- `schemas/result.schema.json` + +## Local MCP Surface + +The daemon still exposes a local `/mcp/call` compatibility/admin surface. + +That surface is useful for local orchestration/admin tooling, but it is not the public remote MCP surface. + +## Remote MCP Surface + +The relay exposes the public remote MCP surface: +- `/mcp` +- `/mcp/call` compatibility path + +Supported MCP methods: +- `initialize` +- `tools/list` +- `tools/call` + +Supported relay tools are the `codencer.*` tools documented in [mcp/relay_tools.md](mcp/relay_tools.md). + +## MCP Safety Rules + +Both local and remote MCP surfaces keep the bridge narrow: - no raw shell tool exposure -- no raw DB mutation - no unrestricted filesystem browsing -- input validation on every call -- stable machine-readable errors only +- no bypass of daemon/relay auth rules +- machine-readable errors only + +The relay MCP surface also preserves relay auth scopes and connector sharing boundaries. diff --git a/docs/07_security_ops.md b/docs/07_security_ops.md index 1e0485a..ced1465 100644 --- a/docs/07_security_ops.md +++ b/docs/07_security_ops.md @@ -1,78 +1,62 @@ -> [!NOTE] -> This is a **design specification** and may not fully reflect the current implementation. -> For the latest implementation status, see the [Gap Audit](internal/GAP_AUDIT.md). - # Security and Operations -## Security principles - -### Least privilege -Planner side gets only safe MCP/orchestrator tools. - -### Explicit project root -Every run is bound to a configured project root. +This document describes the current operational security model for Codencer v2. -### Deterministic artifacts -All artifacts stored under controlled artifact root. +## Security Principles -### Policy before power -Destructive/risky changes require gates. +- **Bridge Not Brain**: Codencer executes, waits, records, and reports. It does not plan. +- **Local Execution**: adapters and artifacts stay local to the daemon side. +- **Explicit Sharing**: connector discovery does not imply exposure; config is the allowlist. +- **Narrow Remote Surface**: relay HTTP API and relay MCP expose only instance-scoped orchestration operations. +- **Evidence First**: results, validations, and artifacts are recorded as local truth. -## Gate triggers for MVP +## Remote Surfaces -- migration file created/changed -- dependency manifest or lockfile changed -- forbidden path touched -- too many files changed -- deletes over threshold -- validations fail -- adapter reports unresolved ambiguity +The only intended remote control surfaces are: +- relay planner API +- relay MCP +- connector outbound websocket -## Repo safety +The daemon is not intended to be internet-facing. -- detect dirty repo before run -- optional worktree isolation -- run locks -- diff capture before cleanup -- safe cleanup path +## What Is Not Exposed -## Process safety +Codencer v2 does not expose: +- raw shell execution through relay or MCP +- arbitrary filesystem browsing through relay or MCP +- generic network tunneling through the connector +- implicit repo sharing +- unauthenticated remote control -- child process supervision -- timeout handling -- cancellation -- retry limits -- duplicate execution prevention -- crash recovery +## Local Safety -## Artifact safety +The daemon preserves local safety by: +- anchoring execution to an explicit repo root +- isolating attempts with worktree and provisioning logic +- persisting run, step, gate, and artifact truth locally +- keeping abort semantics honest when cancellation is not confirmed -Artifacts may contain code and logs. +## Remote Safety -Recommendations: -- local only by default -- retention policy later -- no automatic upload -- clear directory ownership +The relay and connector preserve remote safety by: +- authenticating planners with bearer tokens +- authenticating connectors with enrollment plus signed challenge/response +- allowing only explicitly shared instances to be advertised +- routing only through the connector allowlist +- persisting audit events for remote control actions -## Required test strategy +## Current Honest Limitations -### Unit tests -- state transitions -- policy evaluation -- schema validation -- adapter normalization +- planner auth is static-token based +- connector and relay routing for step/gate/artifact IDs is opportunistic +- large artifact transfer is intentionally bounded +- abort remains best-effort unless the adapter actually stops +- current self-host auth model is alpha-grade, not enterprise IAM -### Integration tests -- SQLite storage -- artifact store -- daemon lifecycle -- CLI behavior +## Operator Guidance -### E2E -- run start -- step execution -- validation -- gate creation -- approve/retry -- completion +- keep the daemon on loopback or another trusted local boundary +- expose the relay instead of exposing the daemon +- keep the connector on the same side as the daemon when possible +- inspect results, validations, and artifacts via CLI or API, not raw path assumptions +- treat Antigravity broker and relay as separate trust domains diff --git a/docs/CONNECTOR.md b/docs/CONNECTOR.md new file mode 100644 index 0000000..224b079 --- /dev/null +++ b/docs/CONNECTOR.md @@ -0,0 +1,110 @@ +# Connector + +Codencer’s connector is the outbound-only bridge between a relay and one or more local Codencer daemons. It is not a planner, not an executor, and not a second orchestration brain. + +## Role + +The connector is responsible for: +- persistent connector identity +- connector enrollment +- outbound authenticated websocket session to the relay +- explicit local instance sharing +- narrow proxying to the local daemon + +The connector is not responsible for: +- planning +- direct local execution +- raw shell exposure +- generic tunneling + +## Local Config + +Default config path: +- `.codencer/connector/config.json` + +The connector persists: +- relay URL and websocket metadata +- connector Ed25519 keypair +- `connector_id` +- `machine_id` +- explicit shared-instance config + +## Enrollment + +Preferred flow: + +```bash +./bin/codencer-connectord enroll \ + --relay-url http://127.0.0.1:8090 \ + --daemon-url http://127.0.0.1:8085 \ + --enrollment-token +``` + +Enrollment does two things: +- exchanges the one-time relay enrollment token for connector identity +- seeds one shared instance from the daemon URL used during enrollment + +## Shared Instances + +The connector does not expose every discovered repo by default. + +Sharing rules: +- discovery roots can discover manifests +- discovery alone does not share them +- the connector config is the allowlist +- only entries with `share: true` are advertised + +Each shared instance entry should identify the local daemon by one of: +- `instance_id` +- `daemon_url` +- `manifest_path` + +## Session Model + +At runtime the connector: +1. fetches a relay challenge +2. signs the challenge with its local private key +3. opens an outbound websocket session +4. advertises only shared instances +5. sends heartbeats and re-advertises after reconnect + +No inbound listener is required for normal use. + +## Allowed Proxy Surface + +The connector only proxies the narrow local Codencer API surface: +- instance read +- run create/list/read +- run abort +- step submit/read/result/validations/artifacts/logs +- step wait +- step retry +- gate approve/reject +- artifact content read + +It does not expose: +- raw shell +- arbitrary file reads +- generic network tunneling + +## Placement Guidance + +The default recommendation is: +- run the connector on the same side as the daemon +- keep the repo, worktrees, and artifacts on that same side +- let the relay be the remote surface + +In mixed WSL/Windows setups: +- daemon and connector usually belong in WSL/Linux +- Antigravity broker and IDE may live on Windows + +See [WSL / Windows / Antigravity Topology](WSL_WINDOWS_ANTIGRAVITY.md) for the practical topology. + +## Reset / Revocation + +To reset a connector locally: +1. stop the connector process +2. remove `.codencer/connector/config.json` +3. enroll again with a fresh enrollment token + +Relay-side disable/revocation has storage foundation and can be handled by replacing or disabling the enrolled connector record on the relay. diff --git a/docs/RELAY.md b/docs/RELAY.md new file mode 100644 index 0000000..8fa8174 --- /dev/null +++ b/docs/RELAY.md @@ -0,0 +1,144 @@ +# Relay + +The Codencer relay is a narrow self-hostable control plane. It is not a planner, not an executor, and not a remote shell. + +## Role + +The relay does three things: +- authenticates planners and connectors +- routes planner calls to explicitly shared local instances +- records audit events for remote control actions + +The relay does not: +- plan work +- execute local code +- expose a generic tunnel +- expose raw shell or arbitrary filesystem tools + +## Public Surfaces + +- planner HTTP API: `/api/v2/...` +- relay MCP: `/mcp` +- relay MCP compatibility path: `/mcp/call` +- connector websocket: `/ws/connectors` + +The relay is the public remote control surface. + +The local daemon is not intended to be exposed directly. + +## Startup + +Run either relay binary: + +- `./bin/relayd` +- `./bin/codencer-relayd` + +The relay config must include at least: +- `db_path` +- `planner_token` or `planner_tokens` + +Optional bootstrap compatibility: +- `enrollment_secret` + +## Planner Auth + +Planner callers authenticate with bearer tokens. + +Supported config shapes: +- `planner_token`: one full-scope token for small self-host setups +- `planner_tokens[]`: named tokens with `token`, `scopes`, and optional `instance_ids` + +Current auth model is intentionally small: +- static token config +- explicit scopes +- optional instance scoping +- suitable for self-host alpha use + +It is not enterprise IAM. + +## Connector Auth + +Connector auth uses: +- one-time enrollment token exchange +- connector Ed25519 keypair +- signed challenge/response +- outbound websocket session +- heartbeat-driven presence + +Legacy bootstrap compatibility: +- `enrollment_secret` can still be used directly if configured +- new deployments should prefer one-time enrollment tokens + +## Persisted State + +The relay persists in SQLite: +- connector records +- one-time enrollment tokens +- connector challenge state +- advertised instance descriptors +- resource routing hints +- audit events + +## Planner API + +Planner-facing HTTP routes live under `/api/v2`. + +Current routes include: +- `GET /api/v2/instances` +- `GET /api/v2/instances/{instance_id}` +- `GET|POST /api/v2/instances/{instance_id}/runs` +- `GET /api/v2/instances/{instance_id}/runs/{run_id}` +- `POST /api/v2/instances/{instance_id}/runs/{run_id}/steps` +- `POST /api/v2/instances/{instance_id}/runs/{run_id}/abort` +- `GET /api/v2/steps/{step_id}` +- `POST /api/v2/steps/{step_id}/wait` +- `POST /api/v2/steps/{step_id}/retry` +- `GET /api/v2/steps/{step_id}/result` +- `GET /api/v2/steps/{step_id}/artifacts` +- `GET /api/v2/steps/{step_id}/validations` +- `GET /api/v2/artifacts/{artifact_id}/content` +- `POST /api/v2/gates/{gate_id}/approve` +- `POST /api/v2/gates/{gate_id}/reject` + +These routes stay narrow and instance-oriented. + +## MCP Surface + +The relay is also the public MCP surface. + +Supported MCP methods: +- `initialize` +- `tools/list` +- `tools/call` + +Supported tools are the `codencer.*` relay tools documented in [mcp/relay_tools.md](mcp/relay_tools.md). + +The local daemon’s `/mcp/call` surface is separate and should be treated as local compatibility/admin tooling, not as the remote public MCP endpoint. + +## Security Boundaries + +The remote path is intentionally narrow: +- planner talks to relay +- relay talks only to authenticated connectors +- connector proxies only an allowlisted daemon API +- daemon executes locally through adapters + +The relay does not widen privileges beyond planner token scopes or connector sharing decisions. + +## Known Limitations + +Current honest limitations: +- planner auth is static-token based +- relay step/gate/artifact routing is opportunistic and can miss unknown IDs until they were previously observed +- artifact transfer is bounded and is not intended for bulk binary transport +- abort semantics remain best-effort unless the local adapter confirms stop + +## Audit Trail + +The relay appends audit events for: +- planner enrollment-token creation +- connector enrollment +- connector session establishment +- planner control calls + +Each audit event records actor, action, target, outcome, and timestamp. diff --git a/docs/SELF_HOST_REFERENCE.md b/docs/SELF_HOST_REFERENCE.md new file mode 100644 index 0000000..9e0998d --- /dev/null +++ b/docs/SELF_HOST_REFERENCE.md @@ -0,0 +1,182 @@ +# Self-Host Reference + +Codencer v2 supports a self-hostable remote planner path without moving execution off the local machine. + +## Current Topology + +```text +Planner / Chat + -> Relay planner API or relay MCP + -> Relay daemon + -> Connector outbound websocket + -> Local Codencer daemon + -> Local adapters +``` + +Execution still stays local. The relay is transport, auth, and audit. The connector is an outbound bridge. The daemon remains the local system of record. + +## Public Surfaces + +- Local daemon API: `/api/v1` +- Local daemon compatibility/admin MCP surface: `/mcp/call` +- Relay planner API: `/api/v2` +- Relay MCP: `/mcp` +- Relay MCP compatibility path: `/mcp/call` +- Relay connector websocket: `/ws/connectors` + +The local daemon is not the public remote MCP server. + +## Operator Flow + +### 1. Start the local daemon + +Run the daemon near the repo you want to serve: + +```bash +./bin/orchestratord --repo-root /path/to/repo +``` + +Or use the existing convenience flow: + +```bash +make start +``` + +### 2. Inspect local instance identity + +Verify the daemon’s stable identity and local manifest-backed metadata: + +```bash +./bin/orchestratorctl instance --json +``` + +Or inspect the daemon directly: + +```bash +curl http://127.0.0.1:8085/api/v1/instance +``` + +The daemon writes a repo-local manifest under `.codencer/instance.json`. + +### 3. Start the relay + +Run the relay with: +- `db_path` +- `planner_token` or `planner_tokens` + +The relay is the public remote control plane. Do not expose the daemon directly. + +### 4. Create a one-time enrollment token + +```bash +curl -X POST /api/v2/connectors/enrollment-tokens \ + -H 'Authorization: Bearer ' \ + -H 'Content-Type: application/json' \ + -d '{"label":"local-dev","expires_in_seconds":600}' +``` + +### 5. Enroll the connector + +```bash +./bin/codencer-connectord enroll \ + --relay-url \ + --daemon-url \ + --enrollment-token +``` + +The connector persists: +- `relay_url` +- `connector_id` +- `machine_id` +- `private_key` +- `instances[]` allowlist entries + +Legacy bootstrap compatibility: +- `enrollment_secret` is still accepted if configured on the relay +- new self-host setups should prefer one-time enrollment tokens + +### 6. Verify instance sharing + +Enrollment seeds one shared instance from the daemon URL you enrolled against. + +Important rules: +- discovery roots do not auto-share repos +- connector config is the allowlist +- only `share: true` instances are advertised + +Inspect `.codencer/connector/config.json` and verify only intended instances are shared before running the connector. + +### 7. Run the connector + +```bash +./bin/codencer-connectord run +``` + +The connector opens an outbound authenticated websocket session to the relay and advertises only the explicitly shared local instances. + +### 8. Connect the planner + +Use either: +- relay planner API under `/api/v2` +- relay MCP at `/mcp` + +The relay is the remote planner surface. The daemon-local `/mcp/call` endpoint is only a local compatibility/admin bridge. + +### 9. Start work and inspect evidence + +Typical remote sequence: +1. list instances +2. start run +3. submit task +4. wait for step or poll step/result +5. inspect result +6. inspect validations +7. inspect artifacts + +Remote artifact access is ID-based: +- artifact content is fetched by `artifact_id` +- there is no arbitrary path browsing tool +- large binary transport is intentionally bounded + +### 10. Operate the run honestly + +Supported remote actions include: +- approve gate +- reject gate +- abort run +- retry step + +Current limitations remain explicit: +- abort is best-effort unless the adapter actually confirms stop +- relay step/gate/artifact routing is opportunistic and may require prior observation of those IDs + +## Allowed Remote Surface + +The connector only proxies a narrow allowlist: +- run create/list/read +- run abort +- step submit/read/result/validations/artifacts/logs +- step retry +- step wait +- gate approve/reject +- instance read +- artifact content read + +The relay and connector do not expose: +- raw shell +- arbitrary filesystem browsing +- generic network tunneling + +## WSL / Windows / Antigravity + +The practical default is: +- daemon, connector, repos, worktrees, and artifacts in WSL/Linux +- Antigravity broker and IDE on Windows when needed +- relay wherever the operator wants to host the remote control plane + +See [WSL / Windows / Antigravity Topology](WSL_WINDOWS_ANTIGRAVITY.md) for the trust boundaries and placement guidance. + +## Default Relay vs Self-Host + +- Self-host mode is implemented in this repo and uses your own relay config, sqlite state, and tokens. +- A future default or managed relay can speak the same connector session model, but self-host does not depend on that future service. diff --git a/docs/WSL_WINDOWS_ANTIGRAVITY.md b/docs/WSL_WINDOWS_ANTIGRAVITY.md new file mode 100644 index 0000000..f3c1eff --- /dev/null +++ b/docs/WSL_WINDOWS_ANTIGRAVITY.md @@ -0,0 +1,94 @@ +# WSL, Windows, and Antigravity Topology + +This document describes the practical v2 operator topology for Codencer when repos and execution live in WSL/Linux while an IDE or Antigravity broker may live on Windows. + +## Recommended Default Layout + +- **WSL/Linux** + - Codencer daemon + - Git clone + - worktrees + - artifacts + - connector + - local executor binaries and local adapter execution +- **Windows** + - IDE + - Antigravity broker and IDE-side companion process, if used +- **Anywhere reachable by the operator** + - relay + +The default recommendation is simple: +- keep the daemon and connector on the same side as the repo +- keep execution and artifacts local to that side +- treat the relay as remote control plane only + +## Trust Boundaries + +The trust model is intentionally narrow: + +- **Planner** + - decides what to do + - calls relay HTTP API or relay MCP + - does not get raw shell or arbitrary file access from Codencer +- **Relay** + - authenticates planners and connectors + - routes requests to the correct shared instance + - records audit events + - does not execute code and does not plan +- **Connector** + - opens outbound websocket session to relay + - advertises only explicitly shared instances + - proxies only an allowlisted local daemon API surface + - does not expose a general tunnel +- **Daemon** + - owns run, step, gate, artifact, and state-machine truth + - executes work locally through adapters + - must not be exposed directly to the internet +- **Antigravity broker** + - is separate from relay + - is optional + - serves IDE-side discovery/binding concerns, not remote planner control + +## Practical WSL / Windows Model + +When using WSL and Windows together: + +1. Keep the repository checkout in WSL. +2. Run `orchestratord` in WSL with that repo as `--repo-root`. +3. Run `codencer-connectord` in WSL so it can talk to the daemon over local loopback without crossing trust domains. +4. Run the relay wherever you want to terminate remote planner auth. +5. If you use Antigravity, keep the broker on the Windows/IDE side and bind from the daemon when needed. + +This avoids the most common problems: +- daemon exposed beyond loopback +- artifacts split across Windows and WSL unexpectedly +- connector proxying through a cross-side filesystem layout it does not control +- relay being mistaken for an execution host + +## Loopback and Cross-Side Cautions + +- Shared loopback between WSL and Windows can work, but it is an operator convenience, not a new trust boundary. +- Do not assume artifact paths are meaningful off the daemon side. Use result, validation, and artifact APIs rather than raw paths. +- Do not run the connector on Windows while the daemon and repo live in WSL unless you intentionally want a cross-side local hop and understand the failure modes. +- Do not expose the daemon directly just because the relay exists. The relay should be the public remote surface. + +## Antigravity Guidance + +Antigravity remains local-side execution metadata and binding infrastructure: +- use it when a repo needs to target a live IDE-side agent context +- do not treat it as the relay +- do not treat it as a planner +- do not assume it widens the safe remote surface + +The broker and relay are different things: +- **broker**: local/cross-side IDE bridge +- **relay**: authenticated remote control plane for planner calls + +## Operator Checklist + +- daemon and repo on the same side +- connector on the same side as the daemon +- relay exposed instead of the daemon +- only explicitly shared instances advertised +- Antigravity broker kept separate from relay concerns +- results, validations, and artifacts inspected through APIs and CLI, not raw cross-side paths diff --git a/docs/design/v2_relay_contracts.md b/docs/design/v2_relay_contracts.md new file mode 100644 index 0000000..1dbfe54 --- /dev/null +++ b/docs/design/v2_relay_contracts.md @@ -0,0 +1,794 @@ +# Codencer V2 Relay Contracts + +> [!IMPORTANT] +> This file is historical design context for the v2 relay build-out. +> It is not the canonical source of current runtime behavior. +> +> For current self-host/runtime truth, use: +> - [README.md](../../README.md) +> - [docs/SELF_HOST_REFERENCE.md](../SELF_HOST_REFERENCE.md) +> - [docs/RELAY.md](../RELAY.md) +> - [docs/CONNECTOR.md](../CONNECTOR.md) +> - [docs/mcp/relay_tools.md](../mcp/relay_tools.md) + +Status: verified against the current repository on 2026-04-12. + +This file separates: +- `Verified current repo reality`: code already present in this repo. +- `Locked v2 contract`: exact interface to implement next where the current repo is incomplete or inconsistent. + +## 1. Reusable Current Surfaces + +### 1.1 CLI + +Verified current repo reality: + +| Surface | Verified current behavior | Reuse | +| --- | --- | --- | +| `cmd/orchestratord` | Local daemon. Starts HTTP API. Supports `--config` and `--repo-root`. | Reuse as the local control plane. | +| `cmd/orchestratorctl` | Local operator CLI for `run`, `step`, `submit`, `gate`, `antigravity`, `doctor`, `instance`, `version`. | Reuse as local admin/debug surface. Do not make it the relay protocol. | +| `cmd/connector` | `enroll` and `run`. Persists connector config locally. Opens outbound websocket to relay. | Reuse as the connector entrypoint. | +| `cmd/relayd` | Self-hostable relay daemon with sqlite store. | Reuse as the relay entrypoint. | +| `cmd/broker` | Optional Antigravity host-side broker for discovery/binding. | Reuse only for Antigravity topology; not part of relay protocol. | + +### 1.2 Local Daemon REST API + +Verified current repo reality: + +| Method | Path | Notes | +| --- | --- | --- | +| `GET` | `/api/v1/runs` | Filters supported via query. | +| `POST` | `/api/v1/runs` | Starts a run. Request body is run metadata. | +| `GET` | `/api/v1/runs/{id}` | Returns run. | +| `PATCH` | `/api/v1/runs/{id}` | Supports `{"action":"abort"}`. | +| `GET` | `/api/v1/runs/{id}/steps` | Lists steps for a run. | +| `POST` | `/api/v1/runs/{id}/steps` | Accepts `domain.TaskSpec`. | +| `GET` | `/api/v1/runs/{id}/gates` | Lists gates for a run. | +| `GET` | `/api/v1/steps/{id}` | Returns step. | +| `GET` | `/api/v1/steps/{id}/result` | Returns normalized result envelope. | +| `GET` | `/api/v1/steps/{id}/validations` | Returns validations. | +| `GET` | `/api/v1/steps/{id}/artifacts` | Returns artifacts for latest attempt. | +| `GET` | `/api/v1/steps/{id}/logs` | Returns log artifact content via artifact lookup. | +| `GET` | `/api/v1/artifacts/{id}/content` | Returns artifact bytes/content. | +| `POST` | `/api/v1/gates/{id}` | Supports `{"action":"approve"}` and `{"action":"reject"}`. | +| `GET` | `/api/v1/compatibility` | Runtime-derived adapter/environment truth. | +| `GET` | `/api/v1/routing` | Current routing config surface. | +| `GET` | `/api/v1/benchmarks` | Benchmark surface. | +| `GET` | `/api/v1/instance` | Stable daemon identity and local addressing info. | +| `GET` | `/api/v1/antigravity/instances` | Antigravity discovery. | +| `GET` | `/api/v1/antigravity/status` | Bound Antigravity instance status. | +| `POST`,`DELETE` | `/api/v1/antigravity/bind` | Bind/unbind Antigravity instance. | +| `POST` | `/mcp/call` | Local MCP-like JSON-RPC tool shim. | + +### 1.3 Instance Identity + +Verified current repo reality: + +- `domain.InstanceInfo` includes stable `id`. +- The daemon persists `daemon_instance_id` in sqlite settings. +- `/api/v1/instance` returns: + - `id` + - `version` + - `repo_root` + - `state_dir` + - `workspace_root` + - `host` + - `port` + - `base_url` + - `execution_mode` + - `pid` + - `started_at` + +Reuse decision: + +- Treat daemon `id` as the canonical local instance identity for connector and relay routing. +- Do not invent a second local instance identity source in connector config. + +### 1.4 Adapter Registry and Capability Surface + +Verified current repo reality: + +- Adapters are registered in bootstrap, not discovered from docs. +- Current registered adapter IDs: + - `codex` + - `claude` + - `qwen` + - `ide-chat` + - `openclaw-acpx` + - `antigravity` + - `antigravity-broker` +- `/api/v1/compatibility` returns `domain.CompatibilityInfo`: + - `tier` + - `adapters[]` + - `environment` +- Each adapter entry includes: + - `id` + - `available` + - `status` + - `mode` + - `capabilities[]` + +Reuse decision: + +- Relay should consume and expose this runtime-derived compatibility surface. +- Do not hardcode support matrices in relay or MCP. + +### 1.5 Artifact and Result Retrieval + +Verified current repo reality: + +- Result retrieval is service-backed: + - `RunService.GetResultByStep` + - `ensureResultEnvelope` fills `version`, `run_id`, `step_id`, `state`, `summary`. +- Artifact retrieval is service-backed: + - `RunService.GetArtifact` + - `RunService.GetArtifactContent` + - `RunService.GetLogsByStep` +- `GET /api/v1/steps/{id}/logs` no longer dereferences a raw path in the handler. +- `GET /api/v1/artifacts/{id}/content` exists and is the canonical content read path. + +Reuse decision: + +- Connector and relay should only use service-backed retrieval surfaces. +- Do not add direct path reads in connector, relay, or MCP. + +### 1.6 Broker Integration + +Verified current repo reality: + +- `AntigravityService` supports: + - direct discovery mode + - broker mode when `brokerURL` is configured +- Broker mode uses: + - `GET /instances` + - `POST /binding` + - `DELETE /binding` + - `GET /binding` +- Bind/unbind is repo-root keyed. +- Broker persists binding outside Codencer state. + +Reuse decision: + +- Keep broker integration as an executor-side topology detail. +- Do not route planner traffic through the Antigravity broker. + +### 1.7 Current MCP Shim Status + +Verified current repo reality: + +- Local daemon exposes `/mcp/call` through `internal/mcp`. +- Relay exposes `/mcp/call` through `internal/relay/mcp.go`. +- Both are JSON-RPC-like call shims, not full MCP transport implementations. +- Local daemon tool names: + - `orchestrator.start_run` + - `orchestrator.list_runs` + - `orchestrator.start_step` + - `orchestrator.retry_step` + - `orchestrator.get_status` + - `orchestrator.get_step_result` + - `orchestrator.get_validations` + - `orchestrator.list_artifacts` + - `orchestrator.approve_gate` + - `orchestrator.reject_gate` + - `orchestrator.get_benchmarks` + - `orchestrator.get_routing_config` +- Relay tool names: + - `relay.list_instances` + - `relay.start_run` + - `relay.list_runs` + - `relay.submit_task` + - `relay.get_step` + - `relay.get_step_result` + - `relay.get_validations` + - `relay.list_artifacts` + - `relay.get_artifact_content` + - `relay.approve_gate` + - `relay.reject_gate` + +Verified blocker: + +- Neither MCP surface currently supports `wait_step`, `abort_run`, or a standard MCP initialize/list-tools transport. + +## 2. Missing Pieces For Secure Remote Planner Callability + +Verified gaps in the current repo: + +| Area | Verified current repo reality | Blocker | +| --- | --- | --- | +| Planner auth | Relay uses one static bearer token. | Good enough for first self-host cut; no scope separation or rotation yet. | +| Connector auth | Enrollment uses shared secret. Relay stores hashed connector token. Websocket auth is header-based. | No challenge/nonce handshake yet. | +| Presence/discovery | Relay persists instances and last seen time. | No explicit heartbeat contract, TTL, or offline state. | +| Instance descriptor | Relay stores `instance_id`, `connector_id`, `repo_root`, `base_url`, raw compatibility JSON, `last_seen_at`. | No normalized planner-facing descriptor yet. | +| Cancellation | Local daemon supports honest abort. | Relay has no planner abort route; connector allowlist does not permit `PATCH /api/v1/runs/{id}`. | +| Wait semantics | `orchestratorctl` has wait logic. | No relay HTTP or MCP `wait_step` contract yet. | +| Artifact content | Local daemon exposes `/api/v1/artifacts/{id}/content`. Relay proxies it. | Planner-facing relay response is raw passthrough today; no stable JSON content envelope. | +| Artifact metadata by ID | Service can load artifact by ID. | No `GET /api/v1/artifacts/{id}` local endpoint; relay cannot build metadata-rich artifact responses from ID alone without cached context. | +| Gate lifecycle | Local gate approval/rejection reconciles step and run state. | No local `GET /api/v1/gates/{id}` read surface; relay gate responses cannot return gate object without extra work. | +| Resource routing | Relay learns `step`, `artifact`, and `gate` routes opportunistically by observing proxied responses. | Direct gate/artifact lookups can fail until the relay has seen those IDs in a prior response. | +| Capability introspection | Daemon compatibility is runtime-derived and truthful. | Relay lists raw stored rows; planner-facing compatibility contract is not normalized. | +| Contract drift | `schemas/result.schema.json` lagged behind `domain.StepState`. | Fixed in this change; keep schema and domain state sets aligned. | + +## 3. Locked V2 Contract Package + +This section defines the exact contract to implement and preserve across connector, relay, and relay-side MCP. + +### 3.1 Connector Enrollment + +Current implementation: + +- Request and response already exist in `internal/relayproto/types.go`. +- Enrollment now sends connector public key and machine metadata. + +Locked v2 contract: + +Request: + +```json +{ + "enrollment_token": "string", + "label": "string", + "public_key": "base64-ed25519-public-key", + "machine": { + "hostname": "string", + "os": "linux", + "arch": "amd64" + } +} +``` + +Response: + +```json +{ + "connector_id": "connector-", + "machine_id": "machine-", + "relay": { + "relay_url": "https://relay.example", + "websocket_url": "wss://relay.example/ws/connectors", + "heartbeat_interval_seconds": 15 + } +} +``` + +Rules: + +- Connector private key stays local and is used for session signing. +- Relay stores the connector public key and machine binding. +- `label` is optional but should be persisted by relay for operator visibility. + +### 3.2 Connector Challenge + +Current implementation: + +- Missing. + +Locked v2 contract: + +Request: + +```json +{ + "connector_id": "connector-", + "machine_id": "machine-" +} +``` + +Response: + +```json +{ + "challenge_id": "challenge-", + "nonce": "base64url", + "relay": { + "relay_url": "https://relay.example", + "websocket_url": "wss://relay.example/ws/connectors", + "heartbeat_interval_seconds": 15 + } +} +``` + +Proof rule: + +- `signature = base64(Ed25519Sign(private_key, challenge_id + ":" + nonce + ":" + connector_id + ":" + machine_id))` + +### 3.3 Connector Session Hello + +Current implementation: + +- Current websocket first message is a signed `hello`, followed by `advertise`. + +Locked v2 contract: + +```json +{ + "type": "hello", + "connector_id": "connector-", + "machine_id": "machine-", + "challenge_id": "challenge-", + "signature": "base64-ed25519-signature" +} +``` + +Rules: + +- Connector follows `hello` with an `advertise` message carrying one or more shared local instances. +- Relay treats each advertised `instance.id` as the routing key. +- Connector config persists connector identity and an explicit shared-instance allowlist. + +### 3.4 Connector Heartbeat + +Current implementation: + +- Missing explicit heartbeat. + +Locked v2 contract: + +```json +{ + "type": "heartbeat", + "connector_id": "connector-", + "instance_id": "daemon-", + "session_id": "session-", + "sent_at": "2026-04-12T10:00:15Z" +} +``` + +Rules: + +- Relay updates `last_seen_at` on every heartbeat. +- Relay marks instance offline when heartbeat TTL expires. +- Heartbeat does not carry planner traffic. + +### 3.5 Relay Request Envelope + +Current implementation: + +- Current internal envelope is `CommandRequest`. + +Locked v2 contract: + +```json +{ + "type": "request", + "request_id": "req-", + "method": "GET", + "path": "/api/v1/steps/step-123/result", + "query": "", + "content_type": "application/json", + "content_encoding": "json", + "body": null, + "timeout_ms": 15000 +} +``` + +Rules: + +- `path` must be in the connector allowlist. +- `body` is a JSON value when `content_encoding == "json"`. +- `body` is a string when `content_encoding == "utf-8"`. +- `body` is a base64 string when `content_encoding == "base64"`. + +### 3.6 Relay Response Envelope + +Current implementation: + +- Current internal envelope is `CommandResponse`. + +Locked v2 contract: + +```json +{ + "type": "response", + "request_id": "req-", + "status_code": 200, + "content_type": "application/json", + "content_encoding": "json", + "body": {}, + "error": "" +} +``` + +Rules: + +- `error` is empty on success. +- Relay must not invent success when connector timeout/cancellation is not confirmed. +- Non-JSON bodies must set `content_encoding` accordingly. + +### 3.7 Instance Descriptor + +Current implementation: + +- Relay currently returns raw `InstanceRecord` rows from storage. + +Locked v2 contract: + +```json +{ + "instance_id": "daemon-", + "connector_id": "connector-", + "label": "string", + "version": "string", + "repo_root": "/abs/path", + "state_dir": "/abs/path/.codencer/state", + "workspace_root": "/abs/path/.codencer/workspaces", + "host": "127.0.0.1", + "port": 8085, + "base_url": "http://127.0.0.1:8085", + "execution_mode": "string", + "pid": 12345, + "started_at": "2026-04-12T10:00:00Z", + "online": true, + "last_seen_at": "2026-04-12T10:00:15Z", + "compatibility": { + "tier": 1, + "adapters": [], + "environment": { + "os": "linux", + "vscode_detected": false + } + } +} +``` + +Rules: + +- Planner-facing instance discovery returns this shape, not raw relay storage rows. +- `online` is derived from heartbeat/session state, not assumed from row presence. + +### 3.8 Planner `start_run` Request + +Current implementation: + +- Local daemon already accepts this shape on `POST /api/v1/runs`. + +Locked v2 contract: + +```json +{ + "id": "run-optional", + "project_id": "default-project", + "conversation_id": "string", + "planner_id": "string", + "executor_id": "string" +} +``` + +Rules: + +- `id` is optional. +- Relay passes this through unchanged to the local daemon. + +### 3.9 Planner `submit_task` Request + +Current implementation: + +- Local daemon already accepts `domain.TaskSpec` on `POST /api/v1/runs/{run_id}/steps`. +- `schemas/task.schema.json` is close to code truth and remains the task payload source of truth. + +Locked v2 contract: + +```json +{ + "version": "v1", + "project_id": "string", + "run_id": "run-optional", + "phase_id": "phase-optional", + "step_id": "step-optional", + "title": "string", + "goal": "string", + "context": { + "summary": "string" + }, + "constraints": ["string"], + "allowed_paths": ["string"], + "forbidden_paths": ["string"], + "validations": [ + { + "name": "string", + "command": "string" + } + ], + "acceptance": ["string"], + "stop_conditions": ["string"], + "policy_bundle": "string", + "adapter_profile": "string", + "timeout_seconds": 300, + "is_simulation": false +} +``` + +Rules: + +- Relay must not rewrite planner intent fields except to fill omitted `run_id`, `phase_id`, and `step_id` in the daemon-compatible way. + +### 3.10 `wait_step` Request/Response + +Current implementation: + +- Missing as a relay and MCP contract. + +Locked v2 contract: + +Request: + +```json +{ + "interval_ms": 1000, + "timeout_ms": 300000, + "include_result": true +} +``` + +Response: + +```json +{ + "step_id": "step-", + "state": "completed", + "terminal": true, + "timed_out": false, + "step": {}, + "result": {} +} +``` + +Rules: + +- Relay implements this by polling existing step/result surfaces. +- No new daemon wait endpoint is required. +- `result` is omitted when `include_result == false` or the step is not terminal. + +### 3.11 Artifact Content Response + +Current implementation: + +- Local daemon and relay currently return raw proxied content for `/artifacts/{id}/content`. + +Locked v2 contract: + +```json +{ + "artifact_id": "artifact-", + "name": "stdout.log", + "type": "log", + "mime_type": "text/plain", + "encoding": "utf-8", + "size": 1234, + "hash": "sha256:", + "content": "string-or-base64" +} +``` + +Rules: + +- Planner-facing relay API and relay-side MCP return this JSON shape. +- Local daemon may continue to expose raw bytes on `/api/v1/artifacts/{id}/content`. +- To support this cleanly, daemon should expose artifact metadata by ID or relay must persist enough metadata from list responses. + +### 3.12 Gate Action Request/Response + +Current implementation: + +- Local daemon accepts `POST /api/v1/gates/{id}` with `{"action":"approve"}` or `{"action":"reject"}` and returns empty `200`. + +Locked v2 contract: + +Request: + +```json +{ + "reason": "string" +} +``` + +Response: + +```json +{ + "gate_id": "gate-", + "run_id": "run-", + "step_id": "step-", + "state": "approved", + "resolved_at": "2026-04-12T10:00:00Z" +} +``` + +Rules: + +- Path encodes the action: + - `POST /api/v2/gates/{gate_id}/approve` + - `POST /api/v2/gates/{gate_id}/reject` +- Relay must not return a synthetic success body without confirming the resulting gate state. + +## 4. Exact API List + +### 4.1 Planner-Facing Relay HTTP API + +Lock this list: + +| Method | Path | Contract | +| --- | --- | --- | +| `GET` | `/api/v2/instances` | Returns `[]InstanceDescriptor`. | +| `POST` | `/api/v2/instances/{instance_id}/runs` | `start_run` request. | +| `GET` | `/api/v2/instances/{instance_id}/runs` | Returns runs. | +| `GET` | `/api/v2/instances/{instance_id}/runs/{run_id}` | Returns run. | +| `PATCH` | `/api/v2/instances/{instance_id}/runs/{run_id}` | Supports `{"action":"abort"}`. | +| `POST` | `/api/v2/instances/{instance_id}/runs/{run_id}/steps` | `submit_task` request. | +| `GET` | `/api/v2/instances/{instance_id}/runs/{run_id}/gates` | Returns gates for run. | +| `GET` | `/api/v2/steps/{step_id}` | Returns step. | +| `GET` | `/api/v2/steps/{step_id}/result` | Returns result. | +| `GET` | `/api/v2/steps/{step_id}/validations` | Returns validations. | +| `GET` | `/api/v2/steps/{step_id}/artifacts` | Returns artifacts. | +| `GET` | `/api/v2/steps/{step_id}/logs` | Returns log content or JSON-wrapped log content. | +| `POST` | `/api/v2/steps/{step_id}/wait` | `wait_step` request/response. | +| `GET` | `/api/v2/artifacts/{artifact_id}/content` | `artifact content response`. | +| `POST` | `/api/v2/gates/{gate_id}/approve` | `gate action response`. | +| `POST` | `/api/v2/gates/{gate_id}/reject` | `gate action response`. | + +### 4.2 Connector-Facing Relay API + +Lock this list: + +| Method | Path | Contract | +| --- | --- | --- | +| `POST` | `/api/v2/connectors/enroll` | Connector enrollment. | +| `POST` | `/api/v2/connectors/challenge` | Connector challenge. | +| `GET` | `/ws/connectors` | Websocket upgrade. First message is `hello`. | + +### 4.3 Relay-Side MCP Tool List + +Lock this list: + +- `relay.list_instances` +- `relay.start_run` +- `relay.list_runs` +- `relay.get_run` +- `relay.abort_run` +- `relay.submit_task` +- `relay.get_step` +- `relay.wait_step` +- `relay.get_step_result` +- `relay.get_validations` +- `relay.list_artifacts` +- `relay.get_logs` +- `relay.get_artifact_content` +- `relay.approve_gate` +- `relay.reject_gate` + +Rules: + +- No raw shell. +- No arbitrary filesystem access. +- No direct connector/session management tools for planners. + +### 4.4 Local Daemon Additions Required + +Required additions to support the locked relay contract cleanly: + +| Addition | Why | +| --- | --- | +| Allow remote abort passthrough by permitting `PATCH /api/v1/runs/{id}` in connector allowlist and relay route table. | Remote cancellation is otherwise missing. | +| `GET /api/v1/gates/{id}` or equivalent gate action response body. | Relay cannot return a truthful `gate action response` without reading the updated gate. | +| `GET /api/v1/artifacts/{id}` or equivalent metadata source by artifact ID. | Relay cannot build the locked JSON artifact-content response from content bytes alone. | + +Not required: + +- No daemon-side `wait_step` endpoint. Relay can poll current step/result surfaces. + +## 5. Exact Dependency Graph + +### 5.1 Must Land Before Connector + +- Stable daemon `InstanceInfo.ID`. +- Runtime-derived `/api/v1/compatibility`. +- Honest abort semantics in `RunService`. +- Repo-root correctness in run/recovery paths. +- Service-backed artifact/log retrieval. +- Result envelope normalization. + +Reason: + +- Connector identity, instance discovery, and remote truthfulness depend on these existing daemon guarantees. + +### 5.2 Must Land Before Relay + +- Connector config persistence. +- Connector enrollment. +- Connector hello and heartbeat contracts. +- Connector allowlist for all planner-approved proxy paths. +- Stable instance descriptor shape. + +Reason: + +- Relay cannot truthfully list or route instances until connector registration and presence are stable. + +### 5.3 Must Land Before MCP + +- Planner-facing relay HTTP API must be fixed first. +- `wait_step`, `abort_run`, artifact-content, and gate-action relay responses must be stable first. +- Resource routing must not depend on accidental observation of unrelated responses. + +Reason: + +- Relay-side MCP should be a thin mapping over stable relay APIs, not a second place where semantics are invented. + +### 5.4 Overlap and Conflict Areas + +| Area | Conflict | +| --- | --- | +| `internal/app/routes.go` vs connector allowlist | Adding a daemon route is insufficient if connector still blocks it. | +| `domain.InstanceInfo` / compatibility types vs relay storage | Relay persistence and planner-facing discovery must stay aligned with daemon identity shape. | +| Gate/action contracts | Relay cannot promise gate response bodies until daemon can supply or relay can reconstruct gate state. | +| Artifact-content contracts | Relay JSON response needs artifact metadata source; current raw passthrough is insufficient. | +| MCP tool naming | Local `orchestrator.*` and relay `relay.*` tool names are different surfaces. Do not merge them implicitly. | + +## 6. Acceptance Criteria Per Phase + +### Phase 0: Core Hardening + +- Daemon repo-root behavior is independent of process cwd. +- `PATCH /api/v1/runs/{id}` is honest about cancellation. +- Run, step, and gate terminal state reconciliation is stable. +- `/api/v1/instance` returns stable `id`. +- `/api/v1/compatibility` reflects runtime truth, not hardcoded claims. +- `/api/v1/artifacts/{id}/content` and `/api/v1/steps/{id}/logs` are service-backed. +- `schemas/result.schema.json` matches actual result state surface. + +### Phase 1: Connector + +- Connector persists enrollment config locally. +- Connector discovers local daemon identity via `/api/v1/instance`. +- Connector fetches runtime compatibility via `/api/v1/compatibility`. +- Connector authenticates to relay with the locked enrollment/challenge/hello contract. +- Connector heartbeat updates relay presence. +- Connector only proxies allowlisted daemon operations. +- Connector supports remote abort passthrough. + +### Phase 2: Relay + +- Relay persists connectors, instance descriptors, routes, and audit events in sqlite. +- Relay exposes the locked planner-facing HTTP API. +- Relay lists normalized instance descriptors with truthful online/offline state. +- Relay supports run creation, step submission, wait, artifact fetch, gate action, and abort. +- Relay routing does not require accidental prior observation to resolve core resources. + +### Phase 3: Relay-Side MCP + +- Relay-side MCP is a thin mapping over the planner-facing relay HTTP API. +- Tool list matches Section 4.3 exactly. +- No raw shell or arbitrary file access is exposed. +- Error handling preserves upstream truth and does not synthesize completion. + +### Phase 4: Integration and Docs + +- End-to-end tests cover planner -> relay -> connector -> local daemon -> adapter -> result/artifact/gate paths. +- Self-host docs match the locked contracts in this file. +- Windows/WSL and Antigravity topology docs match the actual supported path. +- Docs do not claim challenge, heartbeat, abort, or wait support until those contracts are actually implemented. + +## 7. Recommended Next Implementation Order + +1. Finish connector/relay auth and presence contracts: + - challenge endpoint + - hello proof + - heartbeat + - normalized instance descriptor +2. Add remote cancellation and wait: + - connector allowlist for run abort + - relay `PATCH /runs/{id}` + - relay `POST /steps/{id}/wait` +3. Add resource-specific truth surfaces needed by relay: + - local `GET /api/v1/gates/{id}` or equivalent + - local `GET /api/v1/artifacts/{id}` or equivalent +4. Normalize planner-facing relay responses: + - JSON artifact-content response + - JSON gate-action response +5. Only then expand relay-side MCP to the locked tool list. + +## 8. Unresolved Risks + +- Current relay routing for `step`, `artifact`, and `gate` IDs is still opportunistic and can miss resources not previously observed. +- Without challenge/heartbeat, connector presence is weaker than the locked contract. +- Without a local gate-read surface, gate action responses cannot be fully truthful. +- Without an artifact-metadata-by-ID surface, planner-facing artifact-content JSON responses require relay-side caching assumptions. +- Local and relay MCP shims are still JSON-RPC-like compatibility layers, not a standard MCP server transport. diff --git a/docs/mcp/integrations.md b/docs/mcp/integrations.md new file mode 100644 index 0000000..9a2ba01 --- /dev/null +++ b/docs/mcp/integrations.md @@ -0,0 +1,41 @@ +# MCP Integration Notes + +Codencer v2’s public MCP surface lives on the relay. + +Do not point ChatGPT, Claude, or another planner runtime at the local Codencer daemon directly. + +## Recommended Self-Host Pattern + +1. Run the local Codencer daemon near the repo and adapters. +2. Run the connector on the same side as that daemon. +3. Run the relay as the authenticated remote control plane. +4. Point the MCP client at the relay MCP endpoint. + +## Endpoint + +- `POST /mcp` + +Compatibility path: +- `POST /mcp/call` + +Supported MCP methods: +- `initialize` +- `tools/list` +- `tools/call` + +## Auth And Scope + +- Use the same planner bearer token model as the relay HTTP API. +- MCP tool calls do not bypass relay scopes. +- MCP tool calls do not bypass instance sharing or connector allowlists. + +## Transport Expectations + +The relay MCP surface is JSON-RPC over HTTP. + +It is intentionally narrow and maps to relay behavior rather than exposing a second planner or execution protocol. + +## Compatibility Note + +- Self-host mode is implemented in this repo now. +- A future default or managed relay can expose the same narrow Codencer MCP surface without changing the local daemon contract. diff --git a/docs/mcp/relay_tools.md b/docs/mcp/relay_tools.md new file mode 100644 index 0000000..1e31726 --- /dev/null +++ b/docs/mcp/relay_tools.md @@ -0,0 +1,51 @@ +# Relay MCP Tools + +Codencer exposes the remote MCP surface from the relay, not from the local daemon. + +## Endpoint + +Use the relay MCP endpoint: +- `POST /mcp` + +Compatibility path: +- `POST /mcp/call` + +The relay MCP server currently supports: +- `initialize` +- `tools/list` +- `tools/call` + +## Tool List + +- `codencer.list_instances` +- `codencer.get_instance` +- `codencer.start_run` +- `codencer.get_run` +- `codencer.submit_task` +- `codencer.get_step` +- `codencer.wait_step` +- `codencer.get_step_result` +- `codencer.list_step_artifacts` +- `codencer.get_artifact_content` +- `codencer.get_step_validations` +- `codencer.approve_gate` +- `codencer.reject_gate` +- `codencer.abort_run` +- `codencer.retry_step` + +## Tool Rules + +- Mutating tools require explicit `instance_id`. +- Tool calls respect the same planner auth scopes as the relay HTTP API. +- Tool calls do not bypass connector sharing or instance routing. +- `submit_task` accepts the real Codencer `TaskSpec` shape. +- `wait_step` is bounded and takes explicit timeout input. +- `get_artifact_content` reads by `artifact_id` and returns text or base64-safe content metadata. +- There is no raw shell tool. +- There is no arbitrary filesystem browsing tool. + +## Local MCP Distinction + +The daemon-local `/mcp/call` endpoint is separate. + +It is useful as a local compatibility/admin bridge, but it is not the public remote MCP surface for planner integrations. diff --git a/go.mod b/go.mod index 430188f..3ecbd54 100644 --- a/go.mod +++ b/go.mod @@ -3,6 +3,7 @@ module agent-bridge go 1.22.2 require ( + github.com/gorilla/websocket v1.5.3 github.com/joho/godotenv v1.5.1 github.com/mattn/go-sqlite3 v1.14.37 gopkg.in/yaml.v3 v3.0.1 diff --git a/go.sum b/go.sum index af37e58..e99c8d0 100644 --- a/go.sum +++ b/go.sum @@ -1,3 +1,5 @@ +github.com/gorilla/websocket v1.5.3 h1:saDtZ6Pbx/0u+bgYQ3q96pZgCzfhKXGPqt7kZ72aNNg= +github.com/gorilla/websocket v1.5.3/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE= github.com/joho/godotenv v1.5.1 h1:7eLL/+HRGLY0ldzfGMeQkb7vMd0as4CfYvUVzLqw0N0= github.com/joho/godotenv v1.5.1/go.mod h1:f4LDr5Voq0i2e/R5DDNOoa2zzDfwtkZa6DnEwAbqwq4= github.com/mattn/go-sqlite3 v1.14.37 h1:3DOZp4cXis1cUIpCfXLtmlGolNLp2VEqhiB/PARNBIg= diff --git a/internal/adapters/antigravity/broker_adapter.go b/internal/adapters/antigravity/broker_adapter.go index 049ea72..b3fcd56 100644 --- a/internal/adapters/antigravity/broker_adapter.go +++ b/internal/adapters/antigravity/broker_adapter.go @@ -13,6 +13,7 @@ import ( "sync" "time" + "agent-bridge/internal/adapters/common" "agent-bridge/internal/domain" ) @@ -20,10 +21,10 @@ import ( type BrokerAdapter struct { baseURL string client *http.Client - + // baseRepoRoot is the fixed repository path used for binding lookup baseRepoRoot string - + // taskCache maps attemptID -> broker_task_id taskCache map[string]string // taskWorkspaceCache maps attemptID -> workspace_root (worktree) @@ -164,15 +165,7 @@ func (a *BrokerAdapter) CollectArtifacts(ctx context.Context, attemptID, attempt defer f.Close() _, _ = io.Copy(f, resp.Body) - return []*domain.Artifact{ - { - ID: fmt.Sprintf("broker-traj-%s", attemptID), - Name: "trajectory.json", - Path: trajectoryPath, - Type: domain.ArtifactTypeResultJSON, - CreatedAt: time.Now(), - }, - }, nil + return common.CollectStandardArtifacts(ctx, attemptID, attemptArtifactRoot) } func (a *BrokerAdapter) NormalizeResult(ctx context.Context, attemptID string, artifacts []*domain.Artifact) (*domain.ResultSpec, error) { @@ -228,8 +221,12 @@ func (a *BrokerAdapter) NormalizeResult(ctx context.Context, attemptID string, a var traj struct { Steps []struct { Items []struct { - Message *struct{ Text string `json:"text"` } `json:"message"` - Error *struct{ Message string `json:"message"` } `json:"error"` + Message *struct { + Text string `json:"text"` + } `json:"message"` + Error *struct { + Message string `json:"message"` + } `json:"error"` } `json:"items"` } `json:"steps"` } diff --git a/internal/app/api_test.go b/internal/app/api_test.go index b7aee6b..b14c6b9 100644 --- a/internal/app/api_test.go +++ b/internal/app/api_test.go @@ -6,8 +6,11 @@ import ( "encoding/json" "net/http" "net/http/httptest" + "os" + "path/filepath" "strings" "testing" + "time" "agent-bridge/internal/domain" "agent-bridge/internal/service" @@ -16,8 +19,25 @@ import ( _ "github.com/mattn/go-sqlite3" ) +type apiTestAdapter struct{} + +func (a apiTestAdapter) Name() string { return "api-test" } +func (a apiTestAdapter) Capabilities() []string { return []string{"mock"} } +func (a apiTestAdapter) Start(ctx context.Context, step *domain.Step, attempt *domain.Attempt, workspaceRoot, attemptArtifactRoot string) error { + return nil +} +func (a apiTestAdapter) Poll(ctx context.Context, attemptID string) (bool, error) { return false, nil } +func (a apiTestAdapter) Cancel(ctx context.Context, attemptID string) error { return nil } +func (a apiTestAdapter) CollectArtifacts(ctx context.Context, attemptID, attemptArtifactRoot string) ([]*domain.Artifact, error) { + return nil, nil +} +func (a apiTestAdapter) NormalizeResult(ctx context.Context, attemptID string, artifacts []*domain.Artifact) (*domain.ResultSpec, error) { + return &domain.ResultSpec{Version: "v1", State: domain.StepStateCompleted, Summary: "ok"}, nil +} + func TestAPI_Endpoints(t *testing.T) { - db, err := sql.Open("sqlite3", ":memory:") + dbPath := filepath.Join(t.TempDir(), "api-test.db") + db, err := sql.Open("sqlite3", dbPath) if err != nil { t.Fatal(err) } @@ -35,15 +55,48 @@ func TestAPI_Endpoints(t *testing.T) { artsRepo := sqlite.NewArtifactsRepo(db) valsRepo := sqlite.NewValidationsRepo(db) benchRepo := sqlite.NewBenchmarksRepo(db) + settingsRepo := sqlite.NewSettingsRepo(db) routingSvc := service.NewRoutingService(benchRepo, nil) policyReg := service.NewPolicyRegistry() + agSvc := service.NewAntigravityService(settingsRepo, "", "/tmp/repo") runSvc := service.NewRunService(runsRepo, phasesRepo, stepsRepo, attemptsRepo, gatesRepo, artsRepo, valsRepo, routingSvc, policyReg, workspace.NewNullProvisioner(), "/tmp/codencer-artifacts", "/tmp/codencer-workspace") - gateSvc := service.NewGateService(gatesRepo, runsRepo) + gateSvc := service.NewGateService(gatesRepo, runsRepo, stepsRepo, attemptsRepo) + + appCtx := &AppContext{ + Config: &Config{Host: "127.0.0.1", Port: 8085, DBPath: "/tmp/.codencer/test.db", WorkspaceRoot: "/tmp/codencer-workspace"}, + RepoRoot: "/tmp/repo", + InstanceID: "inst-test", + Adapters: map[string]domain.Adapter{ + "mock": apiTestAdapter{}, + }, + StartedAt: time.Unix(1700000000, 0).UTC(), + } + instanceSvc := service.NewInstanceService( + settingsRepo, + agSvc, + Version, + appCtx.StartedAt, + appCtx.RepoRoot, + "/tmp/.codencer", + appCtx.Config.WorkspaceRoot, + appCtx.Config.Host, + appCtx.Config.Port, + func() map[string]domain.Adapter { return appCtx.Adapters }, + ) + if err := settingsRepo.Set(context.Background(), "daemon_instance_id", "inst-test"); err != nil { + t.Fatal(err) + } + if _, err := instanceSvc.EnsureStableInstanceID(context.Background()); err != nil { + t.Fatal(err) + } + appCtx.InstanceSvc = instanceSvc handler := &APIHandler{ RunSvc: runSvc, GateSvc: gateSvc, + AGSvc: agSvc, + AppCtx: appCtx, } ctx := context.Background() @@ -141,4 +194,108 @@ func TestAPI_Endpoints(t *testing.T) { t.Fatal("expected phase ID to be auto-filled") } }) + + t.Run("GET /api/v1/instance includes stable identity", func(t *testing.T) { + req := httptest.NewRequest(http.MethodGet, "/api/v1/instance", nil) + w := httptest.NewRecorder() + handler.handleInstance(w, req) + + if w.Code != http.StatusOK { + t.Fatalf("expected 200, got %d", w.Code) + } + + var info domain.InstanceInfo + if err := json.NewDecoder(w.Body).Decode(&info); err != nil { + t.Fatal(err) + } + if info.ID != "inst-test" { + t.Fatalf("expected stable instance ID, got %s", info.ID) + } + if info.RepoName != "repo" { + t.Fatalf("expected repo name repo, got %s", info.RepoName) + } + if info.ManifestPath != "/tmp/.codencer/instance.json" { + t.Fatalf("expected manifest path to be set, got %s", info.ManifestPath) + } + if len(info.Adapters) != 1 || info.Adapters[0].ID != "mock" { + t.Fatalf("expected instance adapters to be included, got %+v", info.Adapters) + } + }) + + t.Run("GET /api/v1/compatibility derives runtime surface", func(t *testing.T) { + handler.AppCtx.Adapters = map[string]domain.Adapter{ + "ide-chat": apiTestAdapter{}, + "custom": apiTestAdapter{}, + } + req := httptest.NewRequest(http.MethodGet, "/api/v1/compatibility", nil) + w := httptest.NewRecorder() + handler.handleCompatibility(w, req) + if w.Code != http.StatusOK { + t.Fatalf("expected 200, got %d", w.Code) + } + + var info domain.CompatibilityInfo + if err := json.NewDecoder(w.Body).Decode(&info); err != nil { + t.Fatal(err) + } + if len(info.Adapters) != 2 || info.Adapters[0].ID != "custom" || info.Adapters[1].ID != "ide-chat" { + t.Fatalf("unexpected compatibility payload: %+v", info) + } + if !info.Adapters[0].Available || info.Adapters[0].Status != "registered" { + t.Fatalf("expected unknown registered adapter to surface as registered, got %+v", info.Adapters[0]) + } + }) + + t.Run("GET /api/v1/artifacts/{id}/content returns binary-safe bytes", func(t *testing.T) { + dir := t.TempDir() + contentPath := filepath.Join(dir, "artifact.bin") + payload := []byte{0x00, 0x01, 0x02, 0x03} + if err := os.WriteFile(contentPath, payload, 0644); err != nil { + t.Fatal(err) + } + + attempt := &domain.Attempt{ + ID: "attempt-1", + StepID: "step-artifact", + Number: 1, + Adapter: "mock", + State: domain.StepStateCompleted, + Result: &domain.ResultSpec{Version: "v1", State: domain.StepStateCompleted, Summary: "done"}, + CreatedAt: time.Now().UTC(), + UpdatedAt: time.Now().UTC(), + } + if err := attemptsRepo.Create(ctx, attempt); err != nil { + t.Fatal(err) + } + artifact := &domain.Artifact{ + ID: "artifact-1", + AttemptID: attempt.ID, + Type: domain.ArtifactTypeStdout, + Name: "artifact.bin", + Path: contentPath, + Size: int64(len(payload)), + CreatedAt: time.Now().UTC(), + UpdatedAt: time.Now().UTC(), + } + if err := artsRepo.Create(ctx, artifact); err != nil { + t.Fatal(err) + } + + req := httptest.NewRequest(http.MethodGet, "/api/v1/artifacts/"+artifact.ID+"/content", nil) + w := httptest.NewRecorder() + handler.handleArtifactByID(w, req) + + if w.Code != http.StatusOK { + t.Fatalf("expected 200, got %d", w.Code) + } + if got := w.Header().Get("Content-Type"); got != "application/octet-stream" { + t.Fatalf("expected octet-stream content type, got %s", got) + } + if got := w.Header().Get("Content-Length"); got != "4" { + t.Fatalf("expected content length 4, got %s", got) + } + if body := w.Body.Bytes(); string(body) != string(payload) { + t.Fatalf("unexpected artifact body %v", body) + } + }) } diff --git a/internal/app/bootstrap.go b/internal/app/bootstrap.go index 2c158a5..0ba1404 100644 --- a/internal/app/bootstrap.go +++ b/internal/app/bootstrap.go @@ -26,18 +26,21 @@ import ( // AppContext holds the core dependencies for the daemon. type AppContext struct { - Config *Config - Logger *slog.Logger - DB *sql.DB - Server *http.Server - StartedAt time.Time - RepoRoot string + Config *Config + Logger *slog.Logger + DB *sql.DB + Server *http.Server + StartedAt time.Time + RepoRoot string + InstanceID string + Adapters map[string]domain.Adapter + InstanceSvc *service.InstanceService } // Bootstrap initializes configuration, logger, storage, artifact paths, and the HTTP server. func Bootstrap(ctx context.Context, configPath, repoRootOverride string) (*AppContext, error) { startedAt := time.Now() - + // 1. Load configuration cfg, err := LoadConfig(configPath) if err != nil { @@ -128,7 +131,7 @@ func Bootstrap(ctx context.Context, configPath, repoRootOverride string) (*AppCo benchmarksRepo := sqlite.NewBenchmarksRepo(db) validationsRepo := sqlite.NewValidationsRepo(db) settingsRepo := sqlite.NewSettingsRepo(db) - + policyReg := service.NewPolicyRegistry() policyDir := filepath.Join(filepath.Dir(cfg.DBPath), "config", "policies") if _, err := os.Stat(policyDir); os.IsNotExist(err) { @@ -140,24 +143,24 @@ func Bootstrap(ctx context.Context, configPath, repoRootOverride string) (*AppCo logger.Warn("Failed to load policies, using internal defaults", "dir", policyDir, "error", err) } - gateSvc := service.NewGateService(gatesRepo, runsRepo) + gateSvc := service.NewGateService(gatesRepo, runsRepo, stepsRepo, attemptsRepo) agSvc := service.NewAntigravityService(settingsRepo, cfg.AntigravityBrokerURL, repoRoot) adapters := map[string]domain.Adapter{ - "codex": codex.NewAdapter(), - "claude": claude.NewAdapter(), - "qwen": qwen.NewAdapter(), - "ide-chat": ide.NewAdapter(), - "openclaw-acpx": openclaw_acpx.NewAdapter(), - "antigravity": antigravity.NewAdapter(agSvc), + "codex": codex.NewAdapter(), + "claude": claude.NewAdapter(), + "qwen": qwen.NewAdapter(), + "ide-chat": ide.NewAdapter(), + "openclaw-acpx": openclaw_acpx.NewAdapter(), + "antigravity": antigravity.NewAdapter(agSvc), "antigravity-broker": antigravity.NewBrokerAdapter(cfg.AntigravityBrokerURL, repoRoot), } routingSvc := service.NewRoutingService(benchmarksRepo, adapters) provisioner := workspace.NewLocalProvisioner() - runSvc := service.NewRunService(runsRepo, phasesRepo, stepsRepo, attemptsRepo, gatesRepo, artifactsRepo, validationsRepo, routingSvc, policyReg, provisioner, cfg.ArtifactRoot, cfg.WorkspaceRoot) + runSvc := service.NewRunService(runsRepo, phasesRepo, stepsRepo, attemptsRepo, gatesRepo, artifactsRepo, validationsRepo, routingSvc, policyReg, provisioner, cfg.ArtifactRoot, cfg.WorkspaceRoot, repoRoot) - recoverySvc := service.NewRecoveryService(runsRepo, stepsRepo, attemptsRepo, cfg.ArtifactRoot, cfg.WorkspaceRoot) + recoverySvc := service.NewRecoveryService(runsRepo, stepsRepo, attemptsRepo, gatesRepo, cfg.ArtifactRoot, cfg.WorkspaceRoot, repoRoot) if err := recoverySvc.SweepStaleRuns(ctx); err != nil { logger.Warn("Failed to sweep stale runs during bootstrap", "error", err) } @@ -169,13 +172,40 @@ func Bootstrap(ctx context.Context, configPath, repoRootOverride string) (*AppCo WriteTimeout: 10 * time.Second, } - appCtx := &AppContext{ - Config: cfg, - Logger: logger, - DB: db, - Server: server, - StartedAt: startedAt, - RepoRoot: repoRoot, + stateDir := filepath.Dir(cfg.DBPath) + var appCtx *AppContext + instanceSvc := service.NewInstanceService( + settingsRepo, + agSvc, + Version, + startedAt, + repoRoot, + stateDir, + cfg.WorkspaceRoot, + cfg.Host, + cfg.Port, + func() map[string]domain.Adapter { + if appCtx == nil { + return adapters + } + return appCtx.Adapters + }, + ) + instanceID, err := instanceSvc.EnsureStableInstanceID(ctx) + if err != nil { + return nil, fmt.Errorf("failed to initialize stable instance identity: %w", err) + } + + appCtx = &AppContext{ + Config: cfg, + Logger: logger, + DB: db, + Server: server, + StartedAt: startedAt, + RepoRoot: repoRoot, + InstanceID: instanceID, + Adapters: adapters, + InstanceSvc: instanceSvc, } apiHandler := &APIHandler{ @@ -185,9 +215,14 @@ func Bootstrap(ctx context.Context, configPath, repoRootOverride string) (*AppCo AppCtx: appCtx, } apiHandler.RegisterRoutes(mux) + if manifestPath, err := instanceSvc.WriteManifest(ctx); err != nil { + return nil, fmt.Errorf("failed to write instance manifest: %w", err) + } else { + appCtx.Logger.Info("Instance manifest ready", "path", manifestPath) + } - appCtx.Logger.Info("Codencer instance ready", - "repo_root", repoRoot, + appCtx.Logger.Info("Codencer instance ready", + "repo_root", repoRoot, "base_url", fmt.Sprintf("http://%s:%d", cfg.Host, cfg.Port)) return appCtx, nil diff --git a/internal/app/bootstrap_test.go b/internal/app/bootstrap_test.go index 02fc04a..0a32a70 100644 --- a/internal/app/bootstrap_test.go +++ b/internal/app/bootstrap_test.go @@ -2,11 +2,14 @@ package app import ( "context" + "encoding/json" "net/http" "net/http/httptest" "os" "path/filepath" "testing" + + "agent-bridge/internal/domain" ) func TestBootstrap(t *testing.T) { @@ -19,7 +22,7 @@ func TestBootstrap(t *testing.T) { "artifact_root": "` + artifactRoot + `", "port": 0 }` - + configFile := filepath.Join(tmpDir, "config.json") if err := os.WriteFile(configFile, []byte(content), 0644); err != nil { t.Fatal(err) @@ -54,7 +57,7 @@ func TestBootstrap(t *testing.T) { if status := rr.Code; status != http.StatusOK { t.Errorf("handler returned wrong status code: got %v want %v", status, http.StatusOK) } - + expected := `{"status":"ok"}` if rr.Body.String() != expected { t.Errorf("handler returned unexpected body: got %v want %v", rr.Body.String(), expected) @@ -64,14 +67,14 @@ func TestBootstrap(t *testing.T) { func TestBootstrap_RepoRootOverride(t *testing.T) { repoRoot := t.TempDir() dbRelative := "subdir/codencer.db" - + content := `{ "db_path": "` + dbRelative + `", "artifact_root": "arts", "workspace_root": "ws", "port": 0 }` - + configFile := filepath.Join(t.TempDir(), "config.json") if err := os.WriteFile(configFile, []byte(content), 0644); err != nil { t.Fatal(err) @@ -97,3 +100,63 @@ func TestBootstrap_RepoRootOverride(t *testing.T) { t.Errorf("artifact root not created in repo root: %v", err) } } + +func TestBootstrap_PersistsStableInstanceID(t *testing.T) { + repoRoot := t.TempDir() + configFile := filepath.Join(t.TempDir(), "config.json") + content := `{ + "db_path": ".codencer/test.db", + "artifact_root": ".codencer/artifacts", + "workspace_root": ".codencer/workspace", + "port": 0 + }` + if err := os.WriteFile(configFile, []byte(content), 0644); err != nil { + t.Fatal(err) + } + + appCtx1, err := Bootstrap(context.Background(), configFile, repoRoot) + if err != nil { + t.Fatal(err) + } + instanceID1 := appCtx1.InstanceID + _ = appCtx1.Close() + + appCtx2, err := Bootstrap(context.Background(), configFile, repoRoot) + if err != nil { + t.Fatal(err) + } + defer appCtx2.Close() + + if instanceID1 == "" { + t.Fatal("expected first bootstrap to persist an instance ID") + } + if appCtx2.InstanceID != instanceID1 { + t.Fatalf("expected stable instance ID %s, got %s", instanceID1, appCtx2.InstanceID) + } + + stateDir := filepath.Join(repoRoot, ".codencer") + manifestPath := filepath.Join(stateDir, "instance.json") + data, err := os.ReadFile(manifestPath) + if err != nil { + t.Fatalf("expected manifest to be written: %v", err) + } + var info domain.InstanceInfo + if err := json.Unmarshal(data, &info); err != nil { + t.Fatalf("decode manifest: %v", err) + } + if info.ID != instanceID1 { + t.Fatalf("expected manifest instance id %s, got %s", instanceID1, info.ID) + } + if info.RepoRoot != repoRoot { + t.Fatalf("expected manifest repo root %s, got %s", repoRoot, info.RepoRoot) + } + if info.WorkspaceRoot != filepath.Join(repoRoot, ".codencer/workspace") { + t.Fatalf("expected manifest workspace root to be absolute, got %s", info.WorkspaceRoot) + } + if info.BaseURL != "http://127.0.0.1:0" { + t.Fatalf("expected manifest base url http://127.0.0.1:0, got %s", info.BaseURL) + } + if info.ManifestPath != manifestPath { + t.Fatalf("expected manifest path %s, got %s", manifestPath, info.ManifestPath) + } +} diff --git a/internal/app/routes.go b/internal/app/routes.go index 414522b..44d9891 100644 --- a/internal/app/routes.go +++ b/internal/app/routes.go @@ -3,16 +3,15 @@ package app import ( "context" "encoding/json" + "fmt" "net/http" - "os" + "strconv" "strings" + "time" "agent-bridge/internal/domain" "agent-bridge/internal/mcp" "agent-bridge/internal/service" - "fmt" - "path/filepath" - "time" ) // APIHandler holds dependencies for exposing REST routes. @@ -28,6 +27,7 @@ func (h *APIHandler) RegisterRoutes(mux *http.ServeMux) { mux.HandleFunc("/api/v1/runs", h.handleRuns) mux.HandleFunc("/api/v1/runs/", h.handleRunByID) // Also intercepts /runs/{id}/steps if matched manually mux.HandleFunc("/api/v1/steps/", h.handleStepByID) + mux.HandleFunc("/api/v1/artifacts/", h.handleArtifactByID) mux.HandleFunc("/api/v1/gates/", h.handleGateByID) mux.HandleFunc("/api/v1/compatibility", h.handleCompatibility) mux.HandleFunc("/api/v1/benchmarks", h.handleBenchmarks) @@ -231,21 +231,17 @@ func (h *APIHandler) handleStepByID(w http.ResponseWriter, r *http.Request) { isLogs := strings.HasSuffix(r.URL.Path, "/logs") if isLogs { - result, err := h.RunSvc.GetResultByStep(r.Context(), stepID) + artifact, content, err := h.RunSvc.GetLogsByStep(r.Context(), stepID) if err != nil { - http.Error(w, "Result not found: "+err.Error(), http.StatusNotFound) + http.Error(w, "Logs not found: "+err.Error(), http.StatusNotFound) return } - if result.RawOutputRef == "" { - w.WriteHeader(http.StatusNoContent) - return + if artifact.MimeType != "" { + w.Header().Set("Content-Type", artifact.MimeType) + } else { + w.Header().Set("Content-Type", "application/octet-stream") } - content, err := os.ReadFile(result.RawOutputRef) - if err != nil { - http.Error(w, "Error reading logs: "+err.Error(), http.StatusInternalServerError) - return - } - w.Header().Set("Content-Type", "text/plain") + w.Header().Set("Content-Length", strconv.Itoa(len(content))) w.Write(content) return } @@ -308,6 +304,32 @@ func (h *APIHandler) handleStepByID(w http.ResponseWriter, r *http.Request) { http.Error(w, "Method not allowed", http.StatusMethodNotAllowed) } +func (h *APIHandler) handleArtifactByID(w http.ResponseWriter, r *http.Request) { + fullPath := strings.TrimPrefix(r.URL.Path, "/api/v1/artifacts/") + parts := strings.Split(strings.Trim(fullPath, "/"), "/") + if len(parts) < 2 || parts[0] == "" || parts[1] != "content" { + http.Error(w, "Artifact ID and /content suffix are required", http.StatusBadRequest) + return + } + if r.Method != http.MethodGet { + http.Error(w, "Method not allowed", http.StatusMethodNotAllowed) + return + } + + artifact, content, err := h.RunSvc.GetArtifactContent(r.Context(), parts[0]) + if err != nil { + http.Error(w, err.Error(), http.StatusNotFound) + return + } + if artifact.MimeType != "" { + w.Header().Set("Content-Type", artifact.MimeType) + } else { + w.Header().Set("Content-Type", "application/octet-stream") + } + w.Header().Set("Content-Length", strconv.Itoa(len(content))) + w.Write(content) +} + func (h *APIHandler) handleGateByID(w http.ResponseWriter, r *http.Request) { id := r.URL.Path[len("/api/v1/gates/"):] if id == "" { @@ -353,22 +375,13 @@ func (h *APIHandler) handleCompatibility(w http.ResponseWriter, r *http.Request) http.Error(w, "Method not allowed", http.StatusMethodNotAllowed) return } - - // Dynamic detection of local IDE environment - matrix := map[string]interface{}{ - "tier": 2, // Defaulting to Tier 2: Control features work via CLI/Daemon - "adapters": []map[string]interface{}{ - {"id": "codex", "status": "active", "tier": 2}, - {"id": "claude", "status": "active", "tier": 2}, - {"id": "qwen", "status": "active", "tier": 2}, - {"id": "ide-chat", "status": "active", "tier": 3}, - }, - "environment": map[string]interface{}{ - "os": os.Getenv("OS"), - "vscode_detected": false, // Simplified for MVP - }, + if h.AppCtx == nil || h.AppCtx.InstanceSvc == nil { + http.Error(w, "instance service unavailable", http.StatusInternalServerError) + return } + matrix := h.AppCtx.InstanceSvc.Compatibility(r.Context()) + w.Header().Set("Content-Type", "application/json") _ = json.NewEncoder(w).Encode(matrix) } @@ -405,36 +418,14 @@ func (h *APIHandler) handleInstance(w http.ResponseWriter, r *http.Request) { http.Error(w, "Method not allowed", http.StatusMethodNotAllowed) return } - - simMode := os.Getenv("ALL_ADAPTERS_SIMULATION_MODE") - execMode := "real" - if simMode == "1" || simMode == "true" { - execMode = "simulation" - } - - stateDir := h.AppCtx.Config.DBPath - if !filepath.IsAbs(stateDir) { - stateDir = filepath.Join(h.AppCtx.RepoRoot, ".codencer") - } else { - stateDir = filepath.Dir(stateDir) - } - - workspaceRoot := h.AppCtx.Config.WorkspaceRoot - if !filepath.IsAbs(workspaceRoot) { - workspaceRoot = filepath.Join(h.AppCtx.RepoRoot, workspaceRoot) + if h.AppCtx == nil || h.AppCtx.InstanceSvc == nil { + http.Error(w, "instance service unavailable", http.StatusInternalServerError) + return } - - info := domain.InstanceInfo{ - Version: Version, - RepoRoot: h.AppCtx.RepoRoot, - StateDir: stateDir, - WorkspaceRoot: workspaceRoot, - Host: h.AppCtx.Config.Host, - Port: h.AppCtx.Config.Port, - BaseURL: fmt.Sprintf("http://%s:%d", h.AppCtx.Config.Host, h.AppCtx.Config.Port), - ExecutionMode: execMode, - PID: os.Getpid(), - StartedAt: h.AppCtx.StartedAt, + info, err := h.AppCtx.InstanceSvc.Current(r.Context()) + if err != nil { + http.Error(w, err.Error(), http.StatusInternalServerError) + return } w.Header().Set("Content-Type", "application/json") @@ -492,6 +483,7 @@ func (h *APIHandler) handleAGBind(w http.ResponseWriter, r *http.Request) { http.Error(w, err.Error(), http.StatusInternalServerError) return } + h.syncInstanceManifest(r.Context()) w.WriteHeader(http.StatusOK) case http.MethodDelete: @@ -499,9 +491,19 @@ func (h *APIHandler) handleAGBind(w http.ResponseWriter, r *http.Request) { http.Error(w, err.Error(), http.StatusInternalServerError) return } + h.syncInstanceManifest(r.Context()) w.WriteHeader(http.StatusOK) default: http.Error(w, "Method not allowed", http.StatusMethodNotAllowed) } } + +func (h *APIHandler) syncInstanceManifest(ctx context.Context) { + if h.AppCtx == nil || h.AppCtx.InstanceSvc == nil { + return + } + if _, err := h.AppCtx.InstanceSvc.WriteManifest(ctx); err != nil && h.AppCtx.Logger != nil { + h.AppCtx.Logger.Warn("Failed to refresh instance manifest", "error", err) + } +} diff --git a/internal/connector/allowlist.go b/internal/connector/allowlist.go new file mode 100644 index 0000000..22ac73c --- /dev/null +++ b/internal/connector/allowlist.go @@ -0,0 +1,37 @@ +package connector + +import ( + "net/http" + "strings" +) + +func AllowedLocalProxy(method, path string) bool { + switch { + case method == http.MethodGet && path == "/api/v1/instance": + return true + case method == http.MethodGet && path == "/api/v1/runs": + return true + case method == http.MethodPost && path == "/api/v1/runs": + return true + case strings.HasPrefix(path, "/api/v1/runs/") && method == http.MethodGet: + return true + case strings.HasPrefix(path, "/api/v1/runs/") && method == http.MethodPatch: + return true + case strings.HasPrefix(path, "/api/v1/runs/") && strings.HasSuffix(path, "/steps") && method == http.MethodPost: + return true + case strings.HasPrefix(path, "/api/v1/runs/") && strings.HasSuffix(path, "/gates") && method == http.MethodGet: + return true + case strings.HasPrefix(path, "/api/v1/steps/") && method == http.MethodGet: + return true + case strings.HasPrefix(path, "/api/v1/steps/") && strings.HasSuffix(path, "/retry") && method == http.MethodPost: + return true + case strings.HasPrefix(path, "/api/v1/steps/") && strings.HasSuffix(path, "/wait") && method == http.MethodPost: + return true + case strings.HasPrefix(path, "/api/v1/artifacts/") && strings.HasSuffix(path, "/content") && method == http.MethodGet: + return true + case strings.HasPrefix(path, "/api/v1/gates/") && method == http.MethodPost: + return true + default: + return false + } +} diff --git a/internal/connector/allowlist_test.go b/internal/connector/allowlist_test.go new file mode 100644 index 0000000..6181683 --- /dev/null +++ b/internal/connector/allowlist_test.go @@ -0,0 +1,41 @@ +package connector + +import ( + "net/http" + "testing" +) + +func TestAllowedLocalProxy(t *testing.T) { + allowed := []struct { + method string + path string + }{ + {http.MethodGet, "/api/v1/instance"}, + {http.MethodPost, "/api/v1/runs"}, + {http.MethodPatch, "/api/v1/runs/run-1"}, + {http.MethodPost, "/api/v1/runs/run-1/steps"}, + {http.MethodGet, "/api/v1/steps/step-1/result"}, + {http.MethodPost, "/api/v1/steps/step-1/wait"}, + {http.MethodPost, "/api/v1/steps/step-1/retry"}, + {http.MethodGet, "/api/v1/artifacts/art-1/content"}, + } + for _, tc := range allowed { + if !AllowedLocalProxy(tc.method, tc.path) { + t.Fatalf("expected %s %s to be allowed", tc.method, tc.path) + } + } + + denied := []struct { + method string + path string + }{ + {http.MethodGet, "/etc/passwd"}, + {http.MethodPost, "/api/v1/admin/shell"}, + {http.MethodDelete, "/api/v1/runs/run-1"}, + } + for _, tc := range denied { + if AllowedLocalProxy(tc.method, tc.path) { + t.Fatalf("expected %s %s to be denied", tc.method, tc.path) + } + } +} diff --git a/internal/connector/backoff.go b/internal/connector/backoff.go new file mode 100644 index 0000000..00c25f3 --- /dev/null +++ b/internal/connector/backoff.go @@ -0,0 +1,29 @@ +package connector + +import "time" + +type Backoff struct { + base time.Duration + max time.Duration + current time.Duration +} + +func NewBackoff(base, max time.Duration) *Backoff { + return &Backoff{base: base, max: max} +} + +func (b *Backoff) Next() time.Duration { + if b.current == 0 { + b.current = b.base + return b.current + } + b.current *= 2 + if b.current > b.max { + b.current = b.max + } + return b.current +} + +func (b *Backoff) Reset() { + b.current = 0 +} diff --git a/internal/connector/codencer_client.go b/internal/connector/codencer_client.go new file mode 100644 index 0000000..a059cf8 --- /dev/null +++ b/internal/connector/codencer_client.go @@ -0,0 +1,249 @@ +package connector + +import ( + "bytes" + "context" + "encoding/base64" + "encoding/json" + "fmt" + "io" + "net/http" + "path" + "strings" + "time" + "unicode/utf8" + + "agent-bridge/internal/domain" + "agent-bridge/internal/relayproto" +) + +const maxArtifactContentBytes = 8 << 20 + +type CodencerClient struct { + baseURL string + httpClient *http.Client +} + +func NewCodencerClient(baseURL string) *CodencerClient { + return &CodencerClient{ + baseURL: strings.TrimRight(baseURL, "/"), + httpClient: &http.Client{ + Timeout: 30 * time.Second, + }, + } +} + +func (c *CodencerClient) GetInstance(ctx context.Context) (*domain.InstanceInfo, error) { + req, err := http.NewRequestWithContext(ctx, http.MethodGet, c.baseURL+"/api/v1/instance", nil) + if err != nil { + return nil, err + } + resp, err := c.httpClient.Do(req) + if err != nil { + return nil, fmt.Errorf("local daemon unavailable: %w", err) + } + defer resp.Body.Close() + if resp.StatusCode >= 400 { + body, _ := io.ReadAll(resp.Body) + return nil, fmt.Errorf("local daemon instance lookup failed: %s", string(body)) + } + var info domain.InstanceInfo + if err := json.NewDecoder(resp.Body).Decode(&info); err != nil { + return nil, err + } + return &info, nil +} + +func (c *CodencerClient) Proxy(ctx context.Context, request relayproto.CommandRequest) relayproto.CommandResponse { + response := relayproto.CommandResponse{ + Type: "response", + RequestID: request.RequestID, + } + if !AllowedLocalProxy(request.Method, request.Path) { + response.StatusCode = http.StatusForbidden + response.Error = "connector denied an unsafe proxy request" + return response + } + + if strings.HasSuffix(request.Path, "/wait") && request.Method == http.MethodPost { + return c.waitStep(ctx, request) + } + + target := c.baseURL + request.Path + if request.Query != "" { + target += "?" + request.Query + } + + var bodyReader io.Reader + if len(request.Body) > 0 { + bodyReader = bytes.NewReader(request.Body) + } + req, err := http.NewRequestWithContext(ctx, request.Method, target, bodyReader) + if err != nil { + response.StatusCode = http.StatusInternalServerError + response.Error = err.Error() + return response + } + if request.ContentType != "" { + req.Header.Set("Content-Type", request.ContentType) + } else if len(request.Body) > 0 { + req.Header.Set("Content-Type", "application/json") + } + resp, err := c.httpClient.Do(req) + if err != nil { + response.StatusCode = http.StatusBadGateway + response.Error = fmt.Sprintf("local daemon unavailable: %v", err) + return response + } + defer resp.Body.Close() + + body, err := io.ReadAll(io.LimitReader(resp.Body, maxArtifactContentBytes+1)) + if err != nil { + response.StatusCode = http.StatusBadGateway + response.Error = err.Error() + return response + } + if len(body) > maxArtifactContentBytes { + response.StatusCode = http.StatusRequestEntityTooLarge + response.Error = "artifact too large for connector transport" + return response + } + + response.StatusCode = resp.StatusCode + response.ContentType = resp.Header.Get("Content-Type") + response.ContentEncoding, response.Body = encodeBody(response.ContentType, body) + if resp.StatusCode >= 400 { + response.Error = string(body) + } + return response +} + +func (c *CodencerClient) waitStep(ctx context.Context, request relayproto.CommandRequest) relayproto.CommandResponse { + response := relayproto.CommandResponse{ + Type: "response", + RequestID: request.RequestID, + ContentType: "application/json", + ContentEncoding: "json", + } + stepID := path.Base(path.Dir(request.Path)) + var waitReq struct { + IntervalMS int `json:"interval_ms"` + TimeoutMS int `json:"timeout_ms"` + IncludeResult bool `json:"include_result"` + } + if len(request.Body) > 0 { + if err := json.Unmarshal(request.Body, &waitReq); err != nil { + response.StatusCode = http.StatusBadRequest + response.Error = err.Error() + return response + } + } + if waitReq.IntervalMS <= 0 { + waitReq.IntervalMS = 1000 + } + if waitReq.TimeoutMS <= 0 { + waitReq.TimeoutMS = 300000 + } + + timeout := time.NewTimer(time.Duration(waitReq.TimeoutMS) * time.Millisecond) + defer timeout.Stop() + ticker := time.NewTicker(time.Duration(waitReq.IntervalMS) * time.Millisecond) + defer ticker.Stop() + + buildPayload := func(step *domain.Step, result *domain.ResultSpec, timedOut bool) relayproto.CommandResponse { + payload := map[string]any{ + "step_id": stepID, + "state": step.State, + "terminal": step.State.IsTerminal(), + "timed_out": timedOut, + "step": step, + } + if result != nil { + payload["result"] = result + } + data, _ := json.Marshal(payload) + response.StatusCode = http.StatusOK + response.Body = data + return response + } + + for { + step, err := c.fetchStep(ctx, stepID) + if err != nil { + response.StatusCode = http.StatusBadGateway + response.Error = err.Error() + return response + } + if step.State.IsTerminal() { + var result *domain.ResultSpec + if waitReq.IncludeResult { + result, _ = c.fetchResult(ctx, stepID) + } + return buildPayload(step, result, false) + } + + select { + case <-ctx.Done(): + response.StatusCode = http.StatusGatewayTimeout + response.Error = ctx.Err().Error() + return response + case <-timeout.C: + return buildPayload(step, nil, true) + case <-ticker.C: + } + } +} + +func (c *CodencerClient) fetchStep(ctx context.Context, stepID string) (*domain.Step, error) { + req, err := http.NewRequestWithContext(ctx, http.MethodGet, c.baseURL+"/api/v1/steps/"+stepID, nil) + if err != nil { + return nil, err + } + resp, err := c.httpClient.Do(req) + if err != nil { + return nil, err + } + defer resp.Body.Close() + if resp.StatusCode >= 400 { + body, _ := io.ReadAll(resp.Body) + return nil, fmt.Errorf("get step failed: %s", string(body)) + } + var step domain.Step + if err := json.NewDecoder(resp.Body).Decode(&step); err != nil { + return nil, err + } + return &step, nil +} + +func (c *CodencerClient) fetchResult(ctx context.Context, stepID string) (*domain.ResultSpec, error) { + req, err := http.NewRequestWithContext(ctx, http.MethodGet, c.baseURL+"/api/v1/steps/"+stepID+"/result", nil) + if err != nil { + return nil, err + } + resp, err := c.httpClient.Do(req) + if err != nil { + return nil, err + } + defer resp.Body.Close() + if resp.StatusCode >= 400 { + body, _ := io.ReadAll(resp.Body) + return nil, fmt.Errorf("get result failed: %s", string(body)) + } + var result domain.ResultSpec + if err := json.NewDecoder(resp.Body).Decode(&result); err != nil { + return nil, err + } + return &result, nil +} + +func encodeBody(contentType string, body []byte) (string, json.RawMessage) { + if strings.Contains(contentType, "json") { + return "json", body + } + if utf8.Valid(body) { + encoded, _ := json.Marshal(string(body)) + return "utf-8", encoded + } + encoded, _ := json.Marshal(base64.StdEncoding.EncodeToString(body)) + return "base64", encoded +} diff --git a/internal/connector/config.go b/internal/connector/config.go new file mode 100644 index 0000000..a00a5d0 --- /dev/null +++ b/internal/connector/config.go @@ -0,0 +1,94 @@ +package connector + +import ( + "encoding/json" + "fmt" + "os" + "path/filepath" +) + +const DefaultHeartbeatIntervalSeconds = 15 + +// SharedInstanceConfig controls which local Codencer instances the connector may expose. +type SharedInstanceConfig struct { + InstanceID string `json:"instance_id,omitempty"` + DaemonURL string `json:"daemon_url,omitempty"` + ManifestPath string `json:"manifest_path,omitempty"` + Share bool `json:"share"` +} + +// Config is the persisted connector configuration and identity state. +type Config struct { + RelayURL string `json:"relay_url"` + WebsocketURL string `json:"websocket_url,omitempty"` + ConnectorID string `json:"connector_id,omitempty"` + MachineID string `json:"machine_id,omitempty"` + Label string `json:"label,omitempty"` + PrivateKey string `json:"private_key,omitempty"` + PublicKey string `json:"public_key,omitempty"` + HeartbeatIntervalSeconds int `json:"heartbeat_interval_seconds,omitempty"` + DiscoveryRoots []string `json:"discovery_roots,omitempty"` + Instances []SharedInstanceConfig `json:"instances,omitempty"` + DaemonURL string `json:"daemon_url,omitempty"` // compatibility/default single-instance seed +} + +func LoadConfig(path string) (*Config, error) { + data, err := os.ReadFile(path) + if err != nil { + return nil, fmt.Errorf("read connector config: %w", err) + } + var cfg Config + if err := json.Unmarshal(data, &cfg); err != nil { + return nil, fmt.Errorf("decode connector config: %w", err) + } + if cfg.HeartbeatIntervalSeconds <= 0 { + cfg.HeartbeatIntervalSeconds = DefaultHeartbeatIntervalSeconds + } + return &cfg, nil +} + +func SaveConfig(path string, cfg *Config) error { + if cfg.HeartbeatIntervalSeconds <= 0 { + cfg.HeartbeatIntervalSeconds = DefaultHeartbeatIntervalSeconds + } + if err := os.MkdirAll(filepath.Dir(path), 0755); err != nil { + return err + } + data, err := json.MarshalIndent(cfg, "", " ") + if err != nil { + return err + } + return os.WriteFile(path, data, 0600) +} + +func (c *Config) UpsertSharedInstance(instance SharedInstanceConfig) { + for i := range c.Instances { + if instance.InstanceID != "" && c.Instances[i].InstanceID == instance.InstanceID { + c.Instances[i] = mergeInstanceConfig(c.Instances[i], instance) + return + } + if instance.DaemonURL != "" && c.Instances[i].DaemonURL == instance.DaemonURL { + c.Instances[i] = mergeInstanceConfig(c.Instances[i], instance) + return + } + if instance.ManifestPath != "" && c.Instances[i].ManifestPath == instance.ManifestPath { + c.Instances[i] = mergeInstanceConfig(c.Instances[i], instance) + return + } + } + c.Instances = append(c.Instances, instance) +} + +func mergeInstanceConfig(current, next SharedInstanceConfig) SharedInstanceConfig { + if next.InstanceID != "" { + current.InstanceID = next.InstanceID + } + if next.DaemonURL != "" { + current.DaemonURL = next.DaemonURL + } + if next.ManifestPath != "" { + current.ManifestPath = next.ManifestPath + } + current.Share = next.Share + return current +} diff --git a/internal/connector/enroll.go b/internal/connector/enroll.go new file mode 100644 index 0000000..f1a6ac8 --- /dev/null +++ b/internal/connector/enroll.go @@ -0,0 +1,89 @@ +package connector + +import ( + "bytes" + "context" + "encoding/json" + "fmt" + "io" + "net/http" + "strings" + + "agent-bridge/internal/relayproto" +) + +func Enroll(ctx context.Context, relayURL, daemonURL, enrollmentToken, label, configPath string) (*Config, error) { + cfg := &Config{ + RelayURL: strings.TrimRight(relayURL, "/"), + DaemonURL: strings.TrimRight(daemonURL, "/"), + Label: label, + HeartbeatIntervalSeconds: DefaultHeartbeatIntervalSeconds, + } + if err := EnsureKeypair(cfg); err != nil { + return nil, err + } + + payload, err := json.Marshal(relayproto.EnrollmentRequest{ + EnrollmentToken: enrollmentToken, + EnrollmentSecret: enrollmentToken, + Label: label, + PublicKey: cfg.PublicKey, + Machine: CurrentMachineMetadata(), + }) + if err != nil { + return nil, err + } + + req, err := http.NewRequestWithContext(ctx, http.MethodPost, cfg.RelayURL+"/api/v2/connectors/enroll", bytes.NewReader(payload)) + if err != nil { + return nil, err + } + req.Header.Set("Content-Type", "application/json") + + resp, err := http.DefaultClient.Do(req) + if err != nil { + return nil, err + } + defer resp.Body.Close() + if resp.StatusCode >= 400 { + body, _ := io.ReadAll(resp.Body) + return nil, fmt.Errorf("connector enrollment failed: %s", string(body)) + } + + var enrollment relayproto.EnrollmentResponse + if err := json.NewDecoder(resp.Body).Decode(&enrollment); err != nil { + return nil, err + } + + cfg.ConnectorID = enrollment.ConnectorID + cfg.MachineID = enrollment.MachineID + if enrollment.Relay.RelayURL != "" { + cfg.RelayURL = strings.TrimRight(enrollment.Relay.RelayURL, "/") + } + cfg.WebsocketURL = strings.TrimRight(enrollment.Relay.WebsocketURL, "/") + if enrollment.Relay.HeartbeatIntervalSeconds > 0 { + cfg.HeartbeatIntervalSeconds = enrollment.Relay.HeartbeatIntervalSeconds + } + + if daemonURL != "" { + instanceClient := NewCodencerClient(cfg.DaemonURL) + if info, err := instanceClient.GetInstance(ctx); err == nil { + cfg.UpsertSharedInstance(SharedInstanceConfig{ + InstanceID: info.ID, + DaemonURL: cfg.DaemonURL, + ManifestPath: info.ManifestPath, + Share: true, + }) + } else { + cfg.UpsertSharedInstance(SharedInstanceConfig{ + DaemonURL: cfg.DaemonURL, + Share: true, + }) + } + } + + if err := SaveConfig(configPath, cfg); err != nil { + return nil, err + } + return cfg, nil +} diff --git a/internal/connector/enroll_test.go b/internal/connector/enroll_test.go new file mode 100644 index 0000000..738efd4 --- /dev/null +++ b/internal/connector/enroll_test.go @@ -0,0 +1,68 @@ +package connector + +import ( + "context" + "encoding/json" + "net/http" + "net/http/httptest" + "path/filepath" + "strings" + "testing" + + "agent-bridge/internal/domain" + "agent-bridge/internal/relayproto" +) + +func TestEnroll_PersistsIdentityAndSharedInstance(t *testing.T) { + var gotEnroll relayproto.EnrollmentRequest + var relay *httptest.Server + relay = httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + if r.URL.Path != "/api/v2/connectors/enroll" { + http.NotFound(w, r) + return + } + if err := json.NewDecoder(r.Body).Decode(&gotEnroll); err != nil { + t.Fatal(err) + } + _ = json.NewEncoder(w).Encode(relayproto.EnrollmentResponse{ + ConnectorID: "connector-1", + MachineID: "machine-1", + Relay: relayproto.RelayMetadata{ + RelayURL: relay.URL, + WebsocketURL: "ws" + strings.TrimPrefix(relay.URL, "http") + "/ws/connectors", + HeartbeatIntervalSeconds: 9, + }, + }) + })) + defer relay.Close() + + var daemon *httptest.Server + daemon = httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + switch r.URL.Path { + case "/api/v1/instance": + _ = json.NewEncoder(w).Encode(domain.InstanceInfo{ + ID: "inst-1", + BaseURL: daemon.URL, + ManifestPath: "/repo/.codencer/instance.json", + }) + default: + http.NotFound(w, r) + } + })) + defer daemon.Close() + + configPath := filepath.Join(t.TempDir(), "connector.json") + cfg, err := Enroll(context.Background(), relay.URL, daemon.URL, "token-1", "local", configPath) + if err != nil { + t.Fatal(err) + } + if gotEnroll.PublicKey == "" || gotEnroll.Machine.Hostname == "" { + t.Fatalf("expected public key and machine metadata in enrollment payload: %+v", gotEnroll) + } + if cfg.ConnectorID != "connector-1" || cfg.MachineID != "machine-1" { + t.Fatalf("unexpected persisted identity: %+v", cfg) + } + if len(cfg.Instances) != 1 || !cfg.Instances[0].Share || cfg.Instances[0].InstanceID != "inst-1" { + t.Fatalf("expected enrolled config to contain one shared instance, got %+v", cfg.Instances) + } +} diff --git a/internal/connector/identity.go b/internal/connector/identity.go new file mode 100644 index 0000000..6022c49 --- /dev/null +++ b/internal/connector/identity.go @@ -0,0 +1,60 @@ +package connector + +import ( + "crypto/ed25519" + "crypto/rand" + "encoding/base64" + "fmt" + "os" + "runtime" + + "agent-bridge/internal/relayproto" +) + +func EnsureKeypair(cfg *Config) error { + if cfg.PrivateKey != "" && cfg.PublicKey != "" { + return nil + } + publicKey, privateKey, err := ed25519.GenerateKey(rand.Reader) + if err != nil { + return fmt.Errorf("generate connector keypair: %w", err) + } + cfg.PrivateKey = base64.StdEncoding.EncodeToString(privateKey) + cfg.PublicKey = base64.StdEncoding.EncodeToString(publicKey) + return nil +} + +func PublicKeyFromConfig(cfg *Config) (ed25519.PublicKey, error) { + decoded, err := base64.StdEncoding.DecodeString(cfg.PublicKey) + if err != nil { + return nil, fmt.Errorf("decode connector public key: %w", err) + } + return ed25519.PublicKey(decoded), nil +} + +func PrivateKeyFromConfig(cfg *Config) (ed25519.PrivateKey, error) { + decoded, err := base64.StdEncoding.DecodeString(cfg.PrivateKey) + if err != nil { + return nil, fmt.Errorf("decode connector private key: %w", err) + } + return ed25519.PrivateKey(decoded), nil +} + +func SignChallenge(cfg *Config, challengeID, nonce string) (string, error) { + privateKey, err := PrivateKeyFromConfig(cfg) + if err != nil { + return "", err + } + payload := []byte(challengeID + ":" + nonce + ":" + cfg.ConnectorID + ":" + cfg.MachineID) + signature := ed25519.Sign(privateKey, payload) + return base64.StdEncoding.EncodeToString(signature), nil +} + +func CurrentMachineMetadata() relayproto.MachineMetadata { + hostname, _ := os.Hostname() + return relayproto.MachineMetadata{ + Hostname: hostname, + OS: runtime.GOOS, + Arch: runtime.GOARCH, + } +} diff --git a/internal/connector/identity_test.go b/internal/connector/identity_test.go new file mode 100644 index 0000000..5c56688 --- /dev/null +++ b/internal/connector/identity_test.go @@ -0,0 +1,29 @@ +package connector + +import ( + "encoding/base64" + "testing" +) + +func TestEnsureKeypair_PersistsExistingIdentity(t *testing.T) { + cfg := &Config{} + if err := EnsureKeypair(cfg); err != nil { + t.Fatal(err) + } + privateKey := cfg.PrivateKey + publicKey := cfg.PublicKey + if privateKey == "" || publicKey == "" { + t.Fatal("expected keypair to be generated") + } + + if err := EnsureKeypair(cfg); err != nil { + t.Fatal(err) + } + if cfg.PrivateKey != privateKey || cfg.PublicKey != publicKey { + t.Fatal("expected existing keypair to remain stable") + } + + if _, err := base64.StdEncoding.DecodeString(cfg.PrivateKey); err != nil { + t.Fatalf("expected private key to be base64 encoded: %v", err) + } +} diff --git a/internal/connector/registry.go b/internal/connector/registry.go new file mode 100644 index 0000000..7ebe309 --- /dev/null +++ b/internal/connector/registry.go @@ -0,0 +1,171 @@ +package connector + +import ( + "context" + "encoding/json" + "fmt" + "io/fs" + "os" + "path/filepath" + + "agent-bridge/internal/domain" + "agent-bridge/internal/relayproto" +) + +type SharedInstance struct { + Info domain.InstanceInfo + DaemonURL string + ManifestPath string +} + +type Registry struct { + cfg *Config + clientFactory func(baseURL string) *CodencerClient +} + +func NewRegistry(cfg *Config) *Registry { + return &Registry{ + cfg: cfg, + clientFactory: func(baseURL string) *CodencerClient { + return NewCodencerClient(baseURL) + }, + } +} + +func (r *Registry) SharedInstances(ctx context.Context) ([]SharedInstance, error) { + discovered, _ := r.discoverByInstanceID() + if len(r.cfg.Instances) == 0 && r.cfg.DaemonURL != "" { + r.cfg.UpsertSharedInstance(SharedInstanceConfig{DaemonURL: r.cfg.DaemonURL, Share: true}) + } + + var out []SharedInstance + seen := map[string]struct{}{} + for _, candidate := range r.cfg.Instances { + if !candidate.Share { + continue + } + instance, err := r.resolveInstance(ctx, candidate, discovered) + if err != nil { + continue + } + if _, ok := seen[instance.Info.ID]; ok { + continue + } + seen[instance.Info.ID] = struct{}{} + out = append(out, instance) + } + return out, nil +} + +func (r *Registry) ResolveInstance(ctx context.Context, instanceID string) (*SharedInstance, error) { + instances, err := r.SharedInstances(ctx) + if err != nil { + return nil, err + } + for _, instance := range instances { + if instance.Info.ID == instanceID { + return &instance, nil + } + } + return nil, fmt.Errorf("instance %s is not shared by this connector", instanceID) +} + +func (r *Registry) Advertisements(ctx context.Context) ([]relayproto.InstanceAdvertisement, []string, error) { + instances, err := r.SharedInstances(ctx) + if err != nil { + return nil, nil, err + } + ads := make([]relayproto.InstanceAdvertisement, 0, len(instances)) + instanceIDs := make([]string, 0, len(instances)) + for _, instance := range instances { + payload, err := json.Marshal(instance.Info) + if err != nil { + return nil, nil, err + } + ads = append(ads, relayproto.InstanceAdvertisement{Instance: payload}) + instanceIDs = append(instanceIDs, instance.Info.ID) + } + return ads, instanceIDs, nil +} + +func (r *Registry) resolveInstance(ctx context.Context, candidate SharedInstanceConfig, discovered map[string]string) (SharedInstance, error) { + manifestPath := candidate.ManifestPath + if manifestPath == "" && candidate.InstanceID != "" { + manifestPath = discovered[candidate.InstanceID] + } + + var info domain.InstanceInfo + if manifestPath != "" { + loaded, err := loadManifest(manifestPath) + if err == nil { + info = *loaded + } + } + + daemonURL := candidate.DaemonURL + if daemonURL == "" && info.BaseURL != "" { + daemonURL = info.BaseURL + } + if daemonURL == "" { + return SharedInstance{}, fmt.Errorf("no daemon url for shared instance") + } + + liveInfo, err := r.clientFactory(daemonURL).GetInstance(ctx) + if err == nil { + info = *liveInfo + } + if info.ID == "" { + return SharedInstance{}, fmt.Errorf("could not resolve instance identity") + } + return SharedInstance{ + Info: info, + DaemonURL: daemonURL, + ManifestPath: manifestPath, + }, nil +} + +func (r *Registry) discoverByInstanceID() (map[string]string, error) { + found := map[string]string{} + for _, root := range r.cfg.DiscoveryRoots { + if root == "" { + continue + } + err := filepath.WalkDir(root, func(current string, d fs.DirEntry, err error) error { + if err != nil { + return nil + } + if d.IsDir() { + switch d.Name() { + case ".git", "node_modules": + return filepath.SkipDir + } + return nil + } + if d.Name() != "instance.json" || filepath.Base(filepath.Dir(current)) != ".codencer" { + return nil + } + info, err := loadManifest(current) + if err != nil || info.ID == "" { + return nil + } + found[info.ID] = current + return nil + }) + if err != nil { + return found, err + } + } + return found, nil +} + +func loadManifest(path string) (*domain.InstanceInfo, error) { + data, err := os.ReadFile(path) + if err != nil { + return nil, err + } + var info domain.InstanceInfo + if err := json.Unmarshal(data, &info); err != nil { + return nil, err + } + return &info, nil +} diff --git a/internal/connector/registry_test.go b/internal/connector/registry_test.go new file mode 100644 index 0000000..b5d6af0 --- /dev/null +++ b/internal/connector/registry_test.go @@ -0,0 +1,54 @@ +package connector + +import ( + "context" + "encoding/json" + "os" + "path/filepath" + "testing" + + "agent-bridge/internal/domain" +) + +func TestRegistry_SharedInstancesUsesAllowlist(t *testing.T) { + root := t.TempDir() + sharedManifest := filepath.Join(root, "repo-a", ".codencer", "instance.json") + privateManifest := filepath.Join(root, "repo-b", ".codencer", "instance.json") + if err := os.MkdirAll(filepath.Dir(sharedManifest), 0755); err != nil { + t.Fatal(err) + } + if err := os.MkdirAll(filepath.Dir(privateManifest), 0755); err != nil { + t.Fatal(err) + } + + write := func(path string, info domain.InstanceInfo) { + t.Helper() + data, _ := json.Marshal(info) + if err := os.WriteFile(path, data, 0644); err != nil { + t.Fatal(err) + } + } + write(sharedManifest, domain.InstanceInfo{ID: "inst-shared", BaseURL: "http://127.0.0.1:8085", RepoRoot: filepath.Dir(filepath.Dir(sharedManifest))}) + write(privateManifest, domain.InstanceInfo{ID: "inst-private", BaseURL: "http://127.0.0.1:8086", RepoRoot: filepath.Dir(filepath.Dir(privateManifest))}) + + cfg := &Config{ + DiscoveryRoots: []string{root}, + Instances: []SharedInstanceConfig{ + {InstanceID: "inst-shared", Share: true}, + {InstanceID: "inst-private", Share: false}, + }, + } + registry := NewRegistry(cfg) + registry.clientFactory = func(baseURL string) *CodencerClient { return NewCodencerClient(baseURL) } + + instances, err := registry.SharedInstances(context.Background()) + if err != nil { + t.Fatal(err) + } + if len(instances) != 1 { + t.Fatalf("expected one shared instance, got %d", len(instances)) + } + if instances[0].Info.ID != "inst-shared" { + t.Fatalf("expected shared instance inst-shared, got %s", instances[0].Info.ID) + } +} diff --git a/internal/connector/session.go b/internal/connector/session.go new file mode 100644 index 0000000..635a866 --- /dev/null +++ b/internal/connector/session.go @@ -0,0 +1,237 @@ +package connector + +import ( + "bytes" + "context" + "encoding/json" + "fmt" + "io" + "net/http" + "net/url" + "strings" + "time" + + "agent-bridge/internal/relayproto" + "github.com/gorilla/websocket" +) + +type Client struct { + cfg *Config + httpClient *http.Client + registry *Registry + backoff *Backoff + dialer *websocket.Dialer +} + +func NewClient(cfg *Config) *Client { + return &Client{ + cfg: cfg, + httpClient: &http.Client{Timeout: 15 * time.Second}, + registry: NewRegistry(cfg), + backoff: NewBackoff(500*time.Millisecond, 10*time.Second), + dialer: websocket.DefaultDialer, + } +} + +func (c *Client) Run(ctx context.Context) error { + for { + err := c.runOnce(ctx) + if ctx.Err() != nil { + return ctx.Err() + } + if err == nil { + c.backoff.Reset() + continue + } + delay := c.backoff.Next() + timer := time.NewTimer(delay) + select { + case <-ctx.Done(): + timer.Stop() + return ctx.Err() + case <-timer.C: + } + } +} + +func (c *Client) runOnce(ctx context.Context) error { + challenge, err := c.fetchChallenge(ctx) + if err != nil { + return err + } + signature, err := SignChallenge(c.cfg, challenge.ChallengeID, challenge.Nonce) + if err != nil { + return err + } + + wsURL := challenge.Relay.WebsocketURL + if wsURL == "" { + wsURL = c.cfg.WebsocketURL + } + if wsURL == "" { + wsURL = httpToWebsocket(c.cfg.RelayURL) + "/ws/connectors" + } + + conn, _, err := c.dialer.DialContext(ctx, wsURL, nil) + if err != nil { + return fmt.Errorf("relay unavailable: %w", err) + } + defer conn.Close() + go func() { + <-ctx.Done() + _ = conn.Close() + }() + + if err := conn.WriteJSON(relayproto.HelloMessage{ + Type: "hello", + ConnectorID: c.cfg.ConnectorID, + MachineID: c.cfg.MachineID, + ChallengeID: challenge.ChallengeID, + Signature: signature, + }); err != nil { + return err + } + + if err := c.advertise(ctx, conn); err != nil { + return err + } + + heartbeatCtx, heartbeatCancel := context.WithCancel(ctx) + defer heartbeatCancel() + go c.heartbeatLoop(heartbeatCtx, conn) + + for { + _, message, err := conn.ReadMessage() + if err != nil { + return err + } + var envelope struct { + Type string `json:"type"` + } + if err := json.Unmarshal(message, &envelope); err != nil { + return err + } + switch envelope.Type { + case "request": + var request relayproto.CommandRequest + if err := json.Unmarshal(message, &request); err != nil { + return err + } + response := c.handleRequest(ctx, request) + if err := conn.WriteJSON(response); err != nil { + return err + } + case "error": + return fmt.Errorf("relay session error") + default: + var request relayproto.CommandRequest + data, _ := json.Marshal(envelope) + _ = json.Unmarshal(data, &request) + if request.Type == "request" { + response := c.handleRequest(ctx, request) + if err := conn.WriteJSON(response); err != nil { + return err + } + } + } + } +} + +func (c *Client) fetchChallenge(ctx context.Context) (*relayproto.ChallengeResponse, error) { + payload, err := json.Marshal(relayproto.ChallengeRequest{ + ConnectorID: c.cfg.ConnectorID, + MachineID: c.cfg.MachineID, + }) + if err != nil { + return nil, err + } + req, err := http.NewRequestWithContext(ctx, http.MethodPost, strings.TrimRight(c.cfg.RelayURL, "/")+"/api/v2/connectors/challenge", bytes.NewReader(payload)) + if err != nil { + return nil, err + } + req.Header.Set("Content-Type", "application/json") + resp, err := c.httpClient.Do(req) + if err != nil { + return nil, err + } + defer resp.Body.Close() + if resp.StatusCode >= 400 { + body, _ := io.ReadAll(resp.Body) + return nil, fmt.Errorf("fetch relay challenge failed: %s", string(body)) + } + var challenge relayproto.ChallengeResponse + if err := json.NewDecoder(resp.Body).Decode(&challenge); err != nil { + return nil, err + } + if challenge.Relay.HeartbeatIntervalSeconds > 0 { + c.cfg.HeartbeatIntervalSeconds = challenge.Relay.HeartbeatIntervalSeconds + } + return &challenge, nil +} + +func (c *Client) advertise(ctx context.Context, conn *websocket.Conn) error { + instances, _, err := c.registry.Advertisements(ctx) + if err != nil { + return err + } + return conn.WriteJSON(relayproto.AdvertiseMessage{ + Type: "advertise", + Instances: instances, + }) +} + +func (c *Client) heartbeatLoop(ctx context.Context, conn *websocket.Conn) { + interval := time.Duration(c.cfg.HeartbeatIntervalSeconds) * time.Second + if interval <= 0 { + interval = DefaultHeartbeatIntervalSeconds * time.Second + } + ticker := time.NewTicker(interval) + defer ticker.Stop() + + for { + select { + case <-ctx.Done(): + return + case <-ticker.C: + _, instanceIDs, err := c.registry.Advertisements(ctx) + if err != nil { + continue + } + _ = conn.WriteJSON(relayproto.HeartbeatMessage{ + Type: "heartbeat", + ConnectorID: c.cfg.ConnectorID, + MachineID: c.cfg.MachineID, + InstanceIDs: instanceIDs, + SentAt: time.Now().UTC().Format(time.RFC3339), + }) + } + } +} + +func (c *Client) handleRequest(ctx context.Context, request relayproto.CommandRequest) relayproto.CommandResponse { + instance, err := c.registry.ResolveInstance(ctx, request.InstanceID) + if err != nil { + return relayproto.CommandResponse{ + Type: "response", + RequestID: request.RequestID, + StatusCode: http.StatusForbidden, + Error: err.Error(), + } + } + client := NewCodencerClient(instance.DaemonURL) + return client.Proxy(ctx, request) +} + +func httpToWebsocket(rawURL string) string { + parsed, err := url.Parse(rawURL) + if err != nil { + return rawURL + } + switch parsed.Scheme { + case "https": + parsed.Scheme = "wss" + default: + parsed.Scheme = "ws" + } + return strings.TrimRight(parsed.String(), "/") +} diff --git a/internal/connector/session_test.go b/internal/connector/session_test.go new file mode 100644 index 0000000..ebb622c --- /dev/null +++ b/internal/connector/session_test.go @@ -0,0 +1,209 @@ +package connector + +import ( + "context" + "crypto/ed25519" + "encoding/base64" + "encoding/json" + "net/http" + "net/http/httptest" + "strings" + "sync/atomic" + "testing" + "time" + + "agent-bridge/internal/domain" + "agent-bridge/internal/relayproto" + "github.com/gorilla/websocket" +) + +func TestClientRun_HandshakeAdvertiseAndProxy(t *testing.T) { + cfg := &Config{ + RelayURL: "http://relay.invalid", + ConnectorID: "connector-1", + MachineID: "machine-1", + HeartbeatIntervalSeconds: 1, + Instances: []SharedInstanceConfig{{InstanceID: "inst-1", DaemonURL: "", Share: true}}, + } + if err := EnsureKeypair(cfg); err != nil { + t.Fatal(err) + } + + var daemon *httptest.Server + daemon = httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + switch r.URL.Path { + case "/api/v1/instance": + _ = json.NewEncoder(w).Encode(domain.InstanceInfo{ID: "inst-1", BaseURL: daemon.URL, RepoRoot: "/repo"}) + case "/api/v1/steps/step-1/result": + w.Header().Set("Content-Type", "application/json") + _, _ = w.Write([]byte(`{"version":"v1","run_id":"run-1","step_id":"step-1","state":"completed","summary":"done"}`)) + default: + http.NotFound(w, r) + } + })) + defer daemon.Close() + cfg.Instances[0].DaemonURL = daemon.URL + + upgrader := websocket.Upgrader{CheckOrigin: func(r *http.Request) bool { return true }} + var advertised atomic.Bool + var heartbeats atomic.Int32 + var server *httptest.Server + server = httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + switch r.URL.Path { + case "/api/v2/connectors/challenge": + _ = json.NewEncoder(w).Encode(relayproto.ChallengeResponse{ + ChallengeID: "challenge-1", + Nonce: "nonce-1", + Relay: relayproto.RelayMetadata{ + WebsocketURL: "ws" + strings.TrimPrefix(server.URL, "http") + "/ws/connectors", + HeartbeatIntervalSeconds: 1, + }, + }) + case "/ws/connectors": + conn, err := upgrader.Upgrade(w, r, nil) + if err != nil { + t.Fatal(err) + } + defer conn.Close() + + var hello relayproto.HelloMessage + if err := conn.ReadJSON(&hello); err != nil { + t.Fatal(err) + } + publicKey, _ := base64.StdEncoding.DecodeString(cfg.PublicKey) + signature, _ := base64.StdEncoding.DecodeString(hello.Signature) + payload := []byte("challenge-1:nonce-1:connector-1:machine-1") + if !ed25519.Verify(ed25519.PublicKey(publicKey), payload, signature) { + t.Fatal("expected connector hello signature to verify") + } + + var advertise relayproto.AdvertiseMessage + if err := conn.ReadJSON(&advertise); err != nil { + t.Fatal(err) + } + if len(advertise.Instances) != 1 { + t.Fatalf("expected one advertised instance, got %d", len(advertise.Instances)) + } + advertised.Store(true) + + if err := conn.WriteJSON(relayproto.CommandRequest{ + Type: "request", + RequestID: "req-1", + InstanceID: "inst-1", + Method: http.MethodGet, + Path: "/api/v1/steps/step-1/result", + }); err != nil { + t.Fatal(err) + } + + var response relayproto.CommandResponse + if err := conn.ReadJSON(&response); err != nil { + t.Fatal(err) + } + if response.StatusCode != http.StatusOK || !strings.Contains(string(response.Body), `"summary":"done"`) { + t.Fatalf("unexpected proxy response: %+v", response) + } + + var heartbeat relayproto.HeartbeatMessage + if err := conn.ReadJSON(&heartbeat); err == nil && heartbeat.Type == "heartbeat" { + heartbeats.Add(1) + } + default: + http.NotFound(w, r) + } + })) + defer server.Close() + + cfg.RelayURL = server.URL + cfg.WebsocketURL = "ws" + strings.TrimPrefix(server.URL, "http") + "/ws/connectors" + client := NewClient(cfg) + + ctx, cancel := context.WithTimeout(context.Background(), 2500*time.Millisecond) + defer cancel() + _ = client.Run(ctx) + + if !advertised.Load() { + t.Fatal("expected connector to advertise shared instances") + } + if heartbeats.Load() == 0 { + t.Fatal("expected connector heartbeat") + } +} + +func TestClientRun_ReconnectsAndReAdvertises(t *testing.T) { + cfg := &Config{ + RelayURL: "http://relay.invalid", + ConnectorID: "connector-2", + MachineID: "machine-2", + HeartbeatIntervalSeconds: 1, + Instances: []SharedInstanceConfig{{InstanceID: "inst-2", Share: true}}, + } + if err := EnsureKeypair(cfg); err != nil { + t.Fatal(err) + } + + var daemon *httptest.Server + daemon = httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + if r.URL.Path == "/api/v1/instance" { + _ = json.NewEncoder(w).Encode(domain.InstanceInfo{ID: "inst-2", BaseURL: daemon.URL, RepoRoot: "/repo"}) + return + } + http.NotFound(w, r) + })) + defer daemon.Close() + cfg.Instances[0].DaemonURL = daemon.URL + + upgrader := websocket.Upgrader{CheckOrigin: func(r *http.Request) bool { return true }} + var connections atomic.Int32 + var server *httptest.Server + server = httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + switch r.URL.Path { + case "/api/v2/connectors/challenge": + _ = json.NewEncoder(w).Encode(relayproto.ChallengeResponse{ + ChallengeID: "challenge-reconnect", + Nonce: "nonce-reconnect", + Relay: relayproto.RelayMetadata{ + WebsocketURL: "ws" + strings.TrimPrefix(server.URL, "http") + "/ws/connectors", + HeartbeatIntervalSeconds: 1, + }, + }) + case "/ws/connectors": + conn, err := upgrader.Upgrade(w, r, nil) + if err != nil { + t.Fatal(err) + } + defer conn.Close() + connections.Add(1) + + var hello relayproto.HelloMessage + if err := conn.ReadJSON(&hello); err != nil { + t.Fatal(err) + } + var advertise relayproto.AdvertiseMessage + if err := conn.ReadJSON(&advertise); err != nil { + t.Fatal(err) + } + if connections.Load() == 1 { + _ = conn.Close() + return + } + time.Sleep(150 * time.Millisecond) + default: + http.NotFound(w, r) + } + })) + defer server.Close() + + cfg.RelayURL = server.URL + cfg.WebsocketURL = "ws" + strings.TrimPrefix(server.URL, "http") + "/ws/connectors" + client := NewClient(cfg) + client.backoff = NewBackoff(10*time.Millisecond, 20*time.Millisecond) + + ctx, cancel := context.WithTimeout(context.Background(), 500*time.Millisecond) + defer cancel() + _ = client.Run(ctx) + + if connections.Load() < 2 { + t.Fatalf("expected connector to reconnect, got %d connections", connections.Load()) + } +} diff --git a/internal/domain/compatibility.go b/internal/domain/compatibility.go new file mode 100644 index 0000000..570345e --- /dev/null +++ b/internal/domain/compatibility.go @@ -0,0 +1,23 @@ +package domain + +// CompatibilityAdapter describes the runtime availability of a registered adapter. +type CompatibilityAdapter struct { + ID string `json:"id"` + Available bool `json:"available"` + Status string `json:"status"` + Mode string `json:"mode"` + Capabilities []string `json:"capabilities,omitempty"` +} + +// CompatibilityEnvironment captures the relevant runtime environment signals. +type CompatibilityEnvironment struct { + OS string `json:"os"` + VSCodeDetected bool `json:"vscode_detected"` +} + +// CompatibilityInfo is the daemon-reported runtime compatibility surface. +type CompatibilityInfo struct { + Tier int `json:"tier"` + Adapters []CompatibilityAdapter `json:"adapters"` + Environment CompatibilityEnvironment `json:"environment"` +} diff --git a/internal/domain/instance.go b/internal/domain/instance.go index 2a0ed0d..67e27ad 100644 --- a/internal/domain/instance.go +++ b/internal/domain/instance.go @@ -2,16 +2,29 @@ package domain import "time" +// InstanceBrokerInfo captures the daemon's current Antigravity broker/binding status. +type InstanceBrokerInfo struct { + Enabled bool `json:"enabled"` + Mode string `json:"mode"` + URL string `json:"url,omitempty"` + BoundInstance *AGInstance `json:"bound_instance,omitempty"` +} + // InstanceInfo represents the identity and state of a Codencer daemon instance. type InstanceInfo struct { - Version string `json:"version"` - RepoRoot string `json:"repo_root"` - StateDir string `json:"state_dir"` - WorkspaceRoot string `json:"workspace_root"` - Host string `json:"host"` - Port int `json:"port"` - BaseURL string `json:"base_url"` - ExecutionMode string `json:"execution_mode"` - PID int `json:"pid"` - StartedAt time.Time `json:"started_at"` + ID string `json:"id"` + Version string `json:"version"` + RepoName string `json:"repo_name"` + RepoRoot string `json:"repo_root"` + StateDir string `json:"state_dir"` + WorkspaceRoot string `json:"workspace_root"` + ManifestPath string `json:"manifest_path"` + Host string `json:"host"` + Port int `json:"port"` + BaseURL string `json:"base_url"` + ExecutionMode string `json:"execution_mode"` + PID int `json:"pid"` + StartedAt time.Time `json:"started_at"` + Adapters []CompatibilityAdapter `json:"adapters,omitempty"` + Broker InstanceBrokerInfo `json:"broker"` } diff --git a/internal/relay/audit.go b/internal/relay/audit.go new file mode 100644 index 0000000..8f3d014 --- /dev/null +++ b/internal/relay/audit.go @@ -0,0 +1,20 @@ +package relay + +import ( + "context" +) + +type Auditor struct { + store *Store +} + +func NewAuditor(store *Store) *Auditor { + return &Auditor{store: store} +} + +func (a *Auditor) Record(ctx context.Context, event AuditEvent) { + if a == nil || a.store == nil { + return + } + _ = a.store.AppendAudit(ctx, event) +} diff --git a/internal/relay/audit_test.go b/internal/relay/audit_test.go new file mode 100644 index 0000000..90783dc --- /dev/null +++ b/internal/relay/audit_test.go @@ -0,0 +1,38 @@ +package relay_test + +import ( + "context" + "path/filepath" + "testing" + + "agent-bridge/internal/relay" +) + +func TestAuditEventsPersist(t *testing.T) { + t.Parallel() + + store, err := relay.OpenStore(filepath.Join(t.TempDir(), "relay.db")) + if err != nil { + t.Fatal(err) + } + defer store.Close() + + if err := store.AppendAudit(context.Background(), relay.AuditEvent{ + ActorType: "planner", + ActorID: "token-a", + Action: "list_instances", + Method: "GET", + TargetInstanceID: "inst-1", + Outcome: "ok", + }); err != nil { + t.Fatal(err) + } + + events, err := store.ListAuditEvents(context.Background()) + if err != nil { + t.Fatal(err) + } + if len(events) != 1 || events[0].Action != "list_instances" { + t.Fatalf("unexpected audit events: %+v", events) + } +} diff --git a/internal/relay/auth.go b/internal/relay/auth.go new file mode 100644 index 0000000..010f1f6 --- /dev/null +++ b/internal/relay/auth.go @@ -0,0 +1,93 @@ +package relay + +import ( + "context" + "net/http" + "strings" +) + +type plannerPrincipal struct { + Name string + Scopes []string + InstanceIDs map[string]struct{} +} + +type plannerPrincipalKey struct{} + +func (s *Server) withPlannerScope(scope string, instanceIDFromRequest func(*http.Request) string, next http.HandlerFunc) http.HandlerFunc { + return func(w http.ResponseWriter, r *http.Request) { + instanceID := "" + if instanceIDFromRequest != nil { + instanceID = instanceIDFromRequest(r) + } + principal, err := s.authenticatePlanner(r, scope, instanceID) + if err != nil { + writeAPIError(w, err.Status, err.Code, err.Message) + return + } + next(w, r.WithContext(context.WithValue(r.Context(), plannerPrincipalKey{}, principal))) + } +} + +func plannerFromContext(ctx context.Context) *plannerPrincipal { + principal, _ := ctx.Value(plannerPrincipalKey{}).(*plannerPrincipal) + return principal +} + +func (s *Server) authenticatePlanner(r *http.Request, requiredScope, instanceID string) (*plannerPrincipal, *apiError) { + token := strings.TrimSpace(strings.TrimPrefix(r.Header.Get("Authorization"), "Bearer ")) + if token == "" { + return nil, &apiError{Status: http.StatusUnauthorized, Code: "auth_failed", Message: "planner bearer token required"} + } + for _, candidate := range s.cfg.PlannerTokens { + if token != candidate.Token { + continue + } + principal := &plannerPrincipal{ + Name: candidate.Name, + Scopes: candidate.Scopes, + InstanceIDs: make(map[string]struct{}), + } + for _, allowed := range candidate.InstanceIDs { + principal.InstanceIDs[allowed] = struct{}{} + } + if err := authorizePrincipal(principal, requiredScope, instanceID); err != nil { + return nil, err + } + return principal, nil + } + return nil, &apiError{Status: http.StatusUnauthorized, Code: "auth_failed", Message: "planner authorization failed"} +} + +func authorizePrincipal(principal *plannerPrincipal, requiredScope, instanceID string) *apiError { + if principal == nil { + return &apiError{Status: http.StatusUnauthorized, Code: "auth_failed", Message: "planner authorization required"} + } + if !scopeAllowed(principal.Scopes, requiredScope) { + return &apiError{Status: http.StatusForbidden, Code: "scope_denied", Message: "planner token lacks required scope"} + } + if instanceID != "" && len(principal.InstanceIDs) > 0 { + if _, ok := principal.InstanceIDs[instanceID]; !ok { + return &apiError{Status: http.StatusForbidden, Code: "instance_denied", Message: "planner token is not authorized for this instance"} + } + } + return nil +} + +func scopeAllowed(scopes []string, required string) bool { + if required == "" { + return true + } + for _, scope := range scopes { + if scope == "*" || scope == required { + return true + } + if strings.HasSuffix(scope, ":*") { + prefix := strings.TrimSuffix(scope, "*") + if strings.HasPrefix(required, prefix) { + return true + } + } + } + return false +} diff --git a/internal/relay/auth_test.go b/internal/relay/auth_test.go new file mode 100644 index 0000000..29f0e4f --- /dev/null +++ b/internal/relay/auth_test.go @@ -0,0 +1,67 @@ +package relay_test + +import ( + "net/http" + "net/http/httptest" + "path/filepath" + "testing" + + "agent-bridge/internal/relay" +) + +func TestPlannerScopeDeniesWriteWithReadOnlyToken(t *testing.T) { + t.Parallel() + + store, err := relay.OpenStore(filepath.Join(t.TempDir(), "relay.db")) + if err != nil { + t.Fatal(err) + } + defer store.Close() + + server := relay.NewServer(&relay.Config{ + DBPath: filepath.Join(t.TempDir(), "unused.db"), + PlannerTokens: []relay.PlannerTokenConfig{{ + Name: "read-only", + Token: "read-token", + Scopes: []string{"instances:read"}, + }}, + }, store) + + req := httptest.NewRequest(http.MethodPost, "/api/v2/instances/inst-1/runs", nil) + req.Header.Set("Authorization", "Bearer read-token") + rec := httptest.NewRecorder() + server.Handler().ServeHTTP(rec, req) + + if rec.Code != http.StatusForbidden { + t.Fatalf("expected 403, got %d body=%s", rec.Code, rec.Body.String()) + } +} + +func TestPlannerInstanceRestrictionDeniesOtherInstances(t *testing.T) { + t.Parallel() + + store, err := relay.OpenStore(filepath.Join(t.TempDir(), "relay.db")) + if err != nil { + t.Fatal(err) + } + defer store.Close() + + server := relay.NewServer(&relay.Config{ + DBPath: filepath.Join(t.TempDir(), "unused.db"), + PlannerTokens: []relay.PlannerTokenConfig{{ + Name: "scoped", + Token: "scoped-token", + Scopes: []string{"runs:*"}, + InstanceIDs: []string{"inst-allowed"}, + }}, + }, store) + + req := httptest.NewRequest(http.MethodGet, "/api/v2/instances/inst-denied/runs", nil) + req.Header.Set("Authorization", "Bearer scoped-token") + rec := httptest.NewRecorder() + server.Handler().ServeHTTP(rec, req) + + if rec.Code != http.StatusForbidden { + t.Fatalf("expected 403, got %d body=%s", rec.Code, rec.Body.String()) + } +} diff --git a/internal/relay/config.go b/internal/relay/config.go new file mode 100644 index 0000000..3d7ba4d --- /dev/null +++ b/internal/relay/config.go @@ -0,0 +1,101 @@ +package relay + +import ( + "encoding/json" + "fmt" + "os" + "strconv" +) + +// Config controls the self-hosted relay server. +type Config struct { + Host string `json:"host"` + Port int `json:"port"` + DBPath string `json:"db_path"` + PlannerToken string `json:"planner_token,omitempty"` + PlannerTokens []PlannerTokenConfig `json:"planner_tokens,omitempty"` + EnrollmentSecret string `json:"enrollment_secret,omitempty"` + HeartbeatIntervalSeconds int `json:"heartbeat_interval_seconds,omitempty"` + SessionTTLSeconds int `json:"session_ttl_seconds,omitempty"` + ChallengeTTLSeconds int `json:"challenge_ttl_seconds,omitempty"` +} + +type PlannerTokenConfig struct { + Name string `json:"name,omitempty"` + Token string `json:"token"` + Scopes []string `json:"scopes,omitempty"` + InstanceIDs []string `json:"instance_ids,omitempty"` +} + +func DefaultConfig() *Config { + return &Config{ + Host: "127.0.0.1", + Port: 8090, + DBPath: ".codencer/relay/relay.db", + HeartbeatIntervalSeconds: 15, + SessionTTLSeconds: 45, + ChallengeTTLSeconds: 30, + } +} + +func LoadConfig(path string) (*Config, error) { + cfg := DefaultConfig() + if path != "" { + data, err := os.ReadFile(path) + if err != nil { + return nil, fmt.Errorf("read relay config: %w", err) + } + if err := json.Unmarshal(data, cfg); err != nil { + return nil, fmt.Errorf("decode relay config: %w", err) + } + } + if value := os.Getenv("RELAY_HOST"); value != "" { + cfg.Host = value + } + if value := os.Getenv("RELAY_PORT"); value != "" { + if port, err := strconv.Atoi(value); err == nil { + cfg.Port = port + } + } + if value := os.Getenv("RELAY_DB_PATH"); value != "" { + cfg.DBPath = value + } + if value := os.Getenv("RELAY_PLANNER_TOKEN"); value != "" { + cfg.PlannerToken = value + } + if value := os.Getenv("RELAY_ENROLLMENT_SECRET"); value != "" { + cfg.EnrollmentSecret = value + } + return cfg, cfg.Validate() +} + +func (c *Config) Validate() error { + if c.DBPath == "" { + return fmt.Errorf("relay db_path is required") + } + if len(c.PlannerTokens) == 0 && c.PlannerToken != "" { + c.PlannerTokens = []PlannerTokenConfig{{ + Name: "default", + Token: c.PlannerToken, + Scopes: []string{"*"}, + }} + } + if len(c.PlannerTokens) == 0 { + return fmt.Errorf("relay planner_tokens or planner_token is required") + } + for _, token := range c.PlannerTokens { + if token.Token == "" { + return fmt.Errorf("relay planner token entries must include token") + } + } + if c.HeartbeatIntervalSeconds <= 0 { + c.HeartbeatIntervalSeconds = 15 + } + if c.SessionTTLSeconds <= 0 { + c.SessionTTLSeconds = c.HeartbeatIntervalSeconds * 3 + } + if c.ChallengeTTLSeconds <= 0 { + c.ChallengeTTLSeconds = 30 + } + return nil +} diff --git a/internal/relay/enrollment_service.go b/internal/relay/enrollment_service.go new file mode 100644 index 0000000..4a19f03 --- /dev/null +++ b/internal/relay/enrollment_service.go @@ -0,0 +1,153 @@ +package relay + +import ( + "context" + "crypto/ed25519" + "encoding/base64" + "encoding/json" + "fmt" + "net/http" + "time" + + "agent-bridge/internal/relayproto" +) + +type EnrollmentService struct { + cfg *Config + store *Store +} + +func NewEnrollmentService(cfg *Config, store *Store) *EnrollmentService { + return &EnrollmentService{cfg: cfg, store: store} +} + +func (s *EnrollmentService) CreateToken(ctx context.Context, createdBy, label string, expiresIn time.Duration) (*EnrollmentTokenRecord, string, error) { + var expiresAt *time.Time + if expiresIn > 0 { + value := time.Now().UTC().Add(expiresIn) + expiresAt = &value + } + return s.store.CreateEnrollmentToken(ctx, label, createdBy, expiresAt) +} + +func (s *EnrollmentService) Enroll(ctx context.Context, request relayproto.EnrollmentRequest) (*relayproto.EnrollmentResponse, *ConnectorRecord, error) { + if request.PublicKey == "" { + return nil, nil, fmt.Errorf("public_key is required") + } + connectorID, err := randomID("connector") + if err != nil { + return nil, nil, err + } + machineID, err := randomID("machine") + if err != nil { + return nil, nil, err + } + token := request.EnrollmentToken + if token == "" { + token = request.EnrollmentSecret + } + if token == "" { + return nil, nil, fmt.Errorf("enrollment token is required") + } + if s.cfg.EnrollmentSecret != "" && token == s.cfg.EnrollmentSecret { + // Compatibility bootstrap path for existing self-host setups. + } else { + if _, err := s.store.ConsumeEnrollmentToken(ctx, token, connectorID); err != nil { + return nil, nil, err + } + } + machineJSON, _ := json.Marshal(request.Machine) + record := &ConnectorRecord{ + ConnectorID: connectorID, + MachineID: machineID, + PublicKey: request.PublicKey, + Label: request.Label, + MachineMetadataJSON: string(machineJSON), + } + if err := s.store.SaveConnectorRecord(ctx, *record); err != nil { + return nil, nil, err + } + return &relayproto.EnrollmentResponse{ + ConnectorID: connectorID, + MachineID: machineID, + }, record, nil +} + +func (s *EnrollmentService) CreateChallenge(ctx context.Context, request relayproto.ChallengeRequest) (*ChallengeRecord, error) { + record, err := s.store.GetConnector(ctx, request.ConnectorID) + if err != nil { + return nil, err + } + if record == nil || record.MachineID != request.MachineID { + return nil, fmt.Errorf("unknown connector or machine") + } + if record.Disabled { + return nil, fmt.Errorf("connector disabled") + } + challengeID, err := randomID("challenge") + if err != nil { + return nil, err + } + nonce, err := randomID("nonce") + if err != nil { + return nil, err + } + challenge := &ChallengeRecord{ + ChallengeID: challengeID, + ConnectorID: request.ConnectorID, + MachineID: request.MachineID, + Nonce: nonce, + CreatedAt: time.Now().UTC(), + ExpiresAt: time.Now().UTC().Add(time.Duration(s.cfg.ChallengeTTLSeconds) * time.Second), + } + if err := s.store.SaveChallenge(ctx, *challenge); err != nil { + return nil, err + } + return challenge, nil +} + +func (s *EnrollmentService) VerifyHello(ctx context.Context, hello relayproto.HelloMessage) (*ConnectorRecord, error) { + record, err := s.store.GetConnector(ctx, hello.ConnectorID) + if err != nil { + return nil, err + } + if record == nil || record.MachineID != hello.MachineID { + return nil, fmt.Errorf("unknown connector or machine") + } + if record.Disabled { + return nil, fmt.Errorf("connector disabled") + } + challenge, err := s.store.ConsumeChallenge(ctx, hello.ChallengeID) + if err != nil { + return nil, err + } + if challenge == nil || time.Now().UTC().After(challenge.ExpiresAt) { + return nil, fmt.Errorf("challenge expired or not found") + } + if challenge.ConnectorID != hello.ConnectorID || challenge.MachineID != hello.MachineID { + return nil, fmt.Errorf("challenge identity mismatch") + } + publicKeyBytes, err := base64.StdEncoding.DecodeString(record.PublicKey) + if err != nil { + return nil, err + } + signature, err := base64.StdEncoding.DecodeString(hello.Signature) + if err != nil { + return nil, err + } + payload := []byte(hello.ChallengeID + ":" + challenge.Nonce + ":" + hello.ConnectorID + ":" + hello.MachineID) + if !ed25519.Verify(ed25519.PublicKey(publicKeyBytes), payload, signature) { + return nil, fmt.Errorf("invalid connector signature") + } + _ = s.store.MarkConnectorSeen(ctx, hello.ConnectorID, time.Now().UTC()) + return record, nil +} + +func enrollmentErrorStatus(err error) int { + switch err.Error() { + case "invalid enrollment token", "enrollment token already used", "unknown connector or machine", "connector disabled", "invalid connector signature", "challenge expired or not found", "challenge identity mismatch": + return http.StatusUnauthorized + default: + return http.StatusBadRequest + } +} diff --git a/internal/relay/enrollment_service_test.go b/internal/relay/enrollment_service_test.go new file mode 100644 index 0000000..6c37b2d --- /dev/null +++ b/internal/relay/enrollment_service_test.go @@ -0,0 +1,51 @@ +package relay_test + +import ( + "context" + "crypto/ed25519" + "crypto/rand" + "encoding/base64" + "path/filepath" + "testing" + + "agent-bridge/internal/relay" + "agent-bridge/internal/relayproto" +) + +func TestEnrollmentService_CreateAndConsumeOneTimeToken(t *testing.T) { + t.Parallel() + + store, err := relay.OpenStore(filepath.Join(t.TempDir(), "relay.db")) + if err != nil { + t.Fatal(err) + } + defer store.Close() + + svc := relay.NewEnrollmentService(&relay.Config{ChallengeTTLSeconds: 30}, store) + _, secret, err := svc.CreateToken(context.Background(), "planner", "local-dev", 0) + if err != nil { + t.Fatal(err) + } + + pub, _, err := ed25519.GenerateKey(rand.Reader) + if err != nil { + t.Fatal(err) + } + req := relayproto.EnrollmentRequest{ + EnrollmentToken: secret, + Label: "connector-a", + PublicKey: base64.StdEncoding.EncodeToString(pub), + } + resp, record, err := svc.Enroll(context.Background(), req) + if err != nil { + t.Fatal(err) + } + if resp.ConnectorID == "" || resp.MachineID == "" || record == nil { + t.Fatalf("expected assigned connector identity, got resp=%+v record=%+v", resp, record) + } + + _, _, err = svc.Enroll(context.Background(), req) + if err == nil || err.Error() != "enrollment token already used" { + t.Fatalf("expected one-time token to be consumed, got %v", err) + } +} diff --git a/internal/relay/http_api.go b/internal/relay/http_api.go new file mode 100644 index 0000000..a457758 --- /dev/null +++ b/internal/relay/http_api.go @@ -0,0 +1,44 @@ +package relay + +import ( + "bytes" + "encoding/json" + "net/http" +) + +type apiError struct { + Status int `json:"-"` + Code string `json:"code"` + Message string `json:"message"` +} + +func writeAPIError(w http.ResponseWriter, status int, code, message string) { + w.Header().Set("Content-Type", "application/json") + w.WriteHeader(status) + _ = json.NewEncoder(w).Encode(map[string]any{ + "error": apiError{ + Code: code, + Message: message, + }, + }) +} + +func writeJSON(w http.ResponseWriter, status int, payload any) { + w.Header().Set("Content-Type", "application/json") + w.WriteHeader(status) + _ = json.NewEncoder(w).Encode(payload) +} + +type responseRecorder struct { + header http.Header + body bytes.Buffer + statusCode int +} + +func newResponseRecorder() *responseRecorder { + return &responseRecorder{header: make(http.Header), statusCode: http.StatusOK} +} + +func (r *responseRecorder) Header() http.Header { return r.header } +func (r *responseRecorder) Write(data []byte) (int, error) { return r.body.Write(data) } +func (r *responseRecorder) WriteHeader(statusCode int) { r.statusCode = statusCode } diff --git a/internal/relay/hub.go b/internal/relay/hub.go new file mode 100644 index 0000000..51febf4 --- /dev/null +++ b/internal/relay/hub.go @@ -0,0 +1,166 @@ +package relay + +import ( + "context" + "encoding/json" + "fmt" + "sync" + "time" + + "agent-bridge/internal/relayproto" + "github.com/gorilla/websocket" +) + +type session struct { + conn *websocket.Conn + connectorID string + machineID string + instanceIDs map[string]struct{} + lastSeenAt time.Time + writeMu sync.Mutex + pendingMu sync.Mutex + pending map[string]chan relayproto.CommandResponse +} + +type Hub struct { + mu sync.RWMutex + sessions map[string]*session + connectors map[string]*session + sessionTTL time.Duration +} + +func NewHub(sessionTTL time.Duration) *Hub { + if sessionTTL <= 0 { + sessionTTL = 45 * time.Second + } + return &Hub{ + sessions: make(map[string]*session), + connectors: make(map[string]*session), + sessionTTL: sessionTTL, + } +} + +func (h *Hub) RegisterConnector(session *session) { + h.mu.Lock() + defer h.mu.Unlock() + session.lastSeenAt = time.Now().UTC() + h.connectors[session.connectorID] = session +} + +func (h *Hub) Register(instanceID string, session *session) { + h.mu.Lock() + defer h.mu.Unlock() + session.lastSeenAt = time.Now().UTC() + h.sessions[instanceID] = session +} + +func (h *Hub) Remove(instanceID string) { + h.mu.Lock() + defer h.mu.Unlock() + delete(h.sessions, instanceID) +} + +func (h *Hub) RemoveSession(session *session) { + h.mu.Lock() + defer h.mu.Unlock() + for instanceID, candidate := range h.sessions { + if candidate == session { + delete(h.sessions, instanceID) + } + } + if current := h.connectors[session.connectorID]; current == session { + delete(h.connectors, session.connectorID) + } +} + +func (h *Hub) Touch(session *session) { + h.mu.Lock() + defer h.mu.Unlock() + session.lastSeenAt = time.Now().UTC() +} + +func (h *Hub) Get(instanceID string) *session { + h.mu.RLock() + session := h.sessions[instanceID] + h.mu.RUnlock() + if session == nil { + return nil + } + if time.Since(session.lastSeenAt) > h.sessionTTL { + h.Remove(instanceID) + return nil + } + return session +} + +func (h *Hub) Connector(connectorID string) *session { + h.mu.RLock() + session := h.connectors[connectorID] + h.mu.RUnlock() + if session == nil { + return nil + } + if time.Since(session.lastSeenAt) > h.sessionTTL { + h.RemoveSession(session) + return nil + } + return session +} + +func (s *session) send(value any) error { + s.writeMu.Lock() + defer s.writeMu.Unlock() + return s.conn.WriteJSON(value) +} + +func (s *session) proxy(ctx context.Context, request relayproto.CommandRequest) (*relayproto.CommandResponse, error) { + responseCh := make(chan relayproto.CommandResponse, 1) + + s.pendingMu.Lock() + s.pending[request.RequestID] = responseCh + s.pendingMu.Unlock() + defer func() { + s.pendingMu.Lock() + delete(s.pending, request.RequestID) + s.pendingMu.Unlock() + }() + + if err := s.send(request); err != nil { + return nil, err + } + + select { + case response := <-responseCh: + return &response, nil + case <-ctx.Done(): + return nil, ctx.Err() + case <-time.After(15 * time.Second): + return nil, fmt.Errorf("relay proxy timed out waiting for connector response") + } +} + +func (s *session) handleMessage(message []byte) error { + var envelope struct { + Type string `json:"type"` + } + if err := json.Unmarshal(message, &envelope); err != nil { + return err + } + + if envelope.Type != "response" { + return nil + } + + var response relayproto.CommandResponse + if err := json.Unmarshal(message, &response); err != nil { + return err + } + + s.pendingMu.Lock() + ch := s.pending[response.RequestID] + s.pendingMu.Unlock() + if ch != nil { + ch <- response + } + return nil +} diff --git a/internal/relay/id.go b/internal/relay/id.go new file mode 100644 index 0000000..3a48480 --- /dev/null +++ b/internal/relay/id.go @@ -0,0 +1,15 @@ +package relay + +import ( + "crypto/rand" + "encoding/hex" + "fmt" +) + +func randomID(prefix string) (string, error) { + buf := make([]byte, 16) + if _, err := rand.Read(buf); err != nil { + return "", err + } + return fmt.Sprintf("%s-%s", prefix, hex.EncodeToString(buf)), nil +} diff --git a/internal/relay/integration_test.go b/internal/relay/integration_test.go new file mode 100644 index 0000000..6739720 --- /dev/null +++ b/internal/relay/integration_test.go @@ -0,0 +1,181 @@ +package relay_test + +import ( + "bytes" + "context" + "encoding/json" + "io" + "net/http" + "net/http/httptest" + "path/filepath" + "strings" + "testing" + "time" + + "agent-bridge/internal/connector" + "agent-bridge/internal/domain" + "agent-bridge/internal/relay" +) + +func TestRelayConnectorProxyFlow(t *testing.T) { + t.Parallel() + + artifact := domain.Artifact{ID: "art-1", AttemptID: "attempt-1", Name: "stdout.log", Path: "/tmp/stdout.log"} + var fakeDaemon *httptest.Server + fakeDaemon = httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + w.Header().Set("Content-Type", "application/json") + switch { + case r.Method == http.MethodGet && r.URL.Path == "/api/v1/instance": + _ = json.NewEncoder(w).Encode(domain.InstanceInfo{ + ID: "inst-1", + RepoRoot: "/repo", + BaseURL: fakeDaemon.URL, + }) + case r.Method == http.MethodGet && r.URL.Path == "/api/v1/compatibility": + _, _ = w.Write([]byte(`{"tier":2,"adapters":[],"environment":{"os":"test","vscode_detected":false}}`)) + case r.Method == http.MethodPost && r.URL.Path == "/api/v1/runs": + _, _ = w.Write([]byte(`{"id":"run-1","project_id":"proj","state":"running"}`)) + case r.Method == http.MethodGet && r.URL.Path == "/api/v1/runs/run-1": + _, _ = w.Write([]byte(`{"id":"run-1","project_id":"proj","state":"running"}`)) + case r.Method == http.MethodPost && r.URL.Path == "/api/v1/runs/run-1/steps": + _, _ = w.Write([]byte(`{"id":"step-1","phase_id":"phase-1","state":"running"}`)) + case r.Method == http.MethodGet && r.URL.Path == "/api/v1/steps/step-1": + _, _ = w.Write([]byte(`{"id":"step-1","phase_id":"phase-1","state":"completed"}`)) + case r.Method == http.MethodPost && r.URL.Path == "/api/v1/steps/step-1/wait": + _, _ = w.Write([]byte(`{"step_id":"step-1","state":"completed","terminal":true,"timed_out":false}`)) + case r.Method == http.MethodPost && r.URL.Path == "/api/v1/steps/step-1/retry": + w.WriteHeader(http.StatusAccepted) + case r.Method == http.MethodPatch && r.URL.Path == "/api/v1/runs/run-1": + w.WriteHeader(http.StatusOK) + case r.Method == http.MethodGet && r.URL.Path == "/api/v1/steps/step-1/result": + _, _ = w.Write([]byte(`{"version":"v1","run_id":"run-1","step_id":"step-1","state":"completed","summary":"done"}`)) + case r.Method == http.MethodGet && r.URL.Path == "/api/v1/steps/step-1/artifacts": + _ = json.NewEncoder(w).Encode([]domain.Artifact{artifact}) + case r.Method == http.MethodGet && r.URL.Path == "/api/v1/artifacts/art-1/content": + w.Header().Set("Content-Type", "text/plain") + _, _ = w.Write([]byte("artifact-content")) + default: + http.NotFound(w, r) + } + })) + defer fakeDaemon.Close() + + store, err := relay.OpenStore(filepath.Join(t.TempDir(), "relay.db")) + if err != nil { + t.Fatal(err) + } + defer store.Close() + + server := relay.NewServer(&relay.Config{ + Host: "127.0.0.1", + Port: 0, + DBPath: filepath.Join(t.TempDir(), "relay-unused.db"), + PlannerToken: "planner-token", + EnrollmentSecret: "enroll-secret", + }, store) + relayHTTP := httptest.NewServer(server.Handler()) + defer relayHTTP.Close() + + plannerClient := &http.Client{Timeout: 5 * time.Second} + auth := "Bearer planner-token" + + var enrollSecret string + req, _ := http.NewRequest(http.MethodPost, relayHTTP.URL+"/api/v2/connectors/enrollment-tokens", bytes.NewReader([]byte(`{"label":"local-dev"}`))) + req.Header.Set("Authorization", auth) + req.Header.Set("Content-Type", "application/json") + resp, err := plannerClient.Do(req) + if err != nil { + t.Fatal(err) + } + var tokenResp map[string]any + if err := json.NewDecoder(resp.Body).Decode(&tokenResp); err != nil { + t.Fatal(err) + } + _ = resp.Body.Close() + if resp.StatusCode >= 400 { + t.Fatalf("token creation failed: %+v", tokenResp) + } + enrollSecret, _ = tokenResp["secret"].(string) + if enrollSecret == "" { + t.Fatalf("expected enrollment secret from relay token endpoint, got %+v", tokenResp) + } + + configPath := filepath.Join(t.TempDir(), "connector.json") + cfg, err := connector.Enroll(context.Background(), relayHTTP.URL, fakeDaemon.URL, enrollSecret, "test-connector", configPath) + if err != nil { + t.Fatal(err) + } + client := connector.NewClient(cfg) + + ctx, cancel := context.WithCancel(context.Background()) + defer cancel() + errCh := make(chan error, 1) + go func() { errCh <- client.Run(ctx) }() + + var instances []relay.InstanceRecord + deadline := time.Now().Add(5 * time.Second) + for time.Now().Before(deadline) { + req, _ := http.NewRequest(http.MethodGet, relayHTTP.URL+"/api/v2/instances", nil) + req.Header.Set("Authorization", auth) + resp, err := plannerClient.Do(req) + if err == nil { + body, _ := io.ReadAll(resp.Body) + _ = resp.Body.Close() + if json.Unmarshal(body, &instances) == nil && len(instances) == 1 { + break + } + } + time.Sleep(100 * time.Millisecond) + } + if len(instances) != 1 { + t.Fatalf("expected one connected instance, got %+v", instances) + } + + do := func(method, path string, payload []byte) []byte { + req, _ := http.NewRequest(method, relayHTTP.URL+path, bytes.NewReader(payload)) + req.Header.Set("Authorization", auth) + if len(payload) > 0 { + req.Header.Set("Content-Type", "application/json") + } + resp, err := plannerClient.Do(req) + if err != nil { + t.Fatal(err) + } + defer resp.Body.Close() + body, _ := io.ReadAll(resp.Body) + if resp.StatusCode >= 400 { + t.Fatalf("%s %s failed: %s", method, path, string(body)) + } + return body + } + + do(http.MethodPost, "/api/v2/instances/inst-1/runs", []byte(`{"id":"run-1","project_id":"proj"}`)) + do(http.MethodGet, "/api/v2/instances/inst-1", nil) + do(http.MethodGet, "/api/v2/instances/inst-1/runs/run-1", nil) + do(http.MethodPost, "/api/v2/instances/inst-1/runs/run-1/steps", []byte(`{"goal":"hello"}`)) + resultBody := do(http.MethodGet, "/api/v2/steps/step-1/result", nil) + if !bytes.Contains(resultBody, []byte(`"summary":"done"`)) { + t.Fatalf("unexpected result payload: %s", string(resultBody)) + } + waitBody := do(http.MethodPost, "/api/v2/steps/step-1/wait", []byte(`{"timeout_ms":500}`)) + if !bytes.Contains(waitBody, []byte(`"terminal":true`)) { + t.Fatalf("unexpected wait payload: %s", string(waitBody)) + } + do(http.MethodPost, "/api/v2/steps/step-1/retry", nil) + do(http.MethodGet, "/api/v2/steps/step-1/artifacts", nil) + content := do(http.MethodGet, "/api/v2/artifacts/art-1/content", nil) + if string(content) != "artifact-content" { + t.Fatalf("unexpected artifact content: %s", string(content)) + } + do(http.MethodPost, "/api/v2/instances/inst-1/runs/run-1/abort", nil) + + cancel() + select { + case err := <-errCh: + if err != nil && err != context.Canceled && !strings.Contains(err.Error(), "closed network connection") { + t.Fatalf("connector run failed: %v", err) + } + case <-time.After(2 * time.Second): + t.Fatal("connector did not stop") + } +} diff --git a/internal/relay/mcp_server.go b/internal/relay/mcp_server.go new file mode 100644 index 0000000..a86b0a8 --- /dev/null +++ b/internal/relay/mcp_server.go @@ -0,0 +1,283 @@ +package relay + +import ( + "bytes" + "context" + "encoding/base64" + "encoding/json" + "fmt" + "net/http" + "strings" +) + +type mcpServer struct { + relay *Server + tools map[string]mcpTool +} + +type mcpRequest struct { + JSONRPC string `json:"jsonrpc"` + ID any `json:"id,omitempty"` + Method string `json:"method,omitempty"` + Params json.RawMessage `json:"params,omitempty"` + Name string `json:"name,omitempty"` + Args json.RawMessage `json:"arguments,omitempty"` +} + +type mcpResponse struct { + JSONRPC string `json:"jsonrpc"` + ID any `json:"id,omitempty"` + Result any `json:"result,omitempty"` + Error *mcpRPCError `json:"error,omitempty"` +} + +type mcpRPCError struct { + Code int `json:"code"` + Message string `json:"message"` + Data any `json:"data,omitempty"` +} + +type mcpToolResult struct { + Content []map[string]string `json:"content,omitempty"` + StructuredContent any `json:"structuredContent,omitempty"` + IsError bool `json:"isError,omitempty"` +} + +func newMCPServer(relayServer *Server) *mcpServer { + server := &mcpServer{relay: relayServer} + server.tools = buildMCPTools(server) + return server +} + +func (s *mcpServer) Handle(w http.ResponseWriter, r *http.Request) { + if r.Method != http.MethodPost { + writeAPIError(w, http.StatusMethodNotAllowed, "method_not_allowed", "method not allowed") + return + } + + var req mcpRequest + if err := json.NewDecoder(r.Body).Decode(&req); err != nil { + s.writeRPC(w, mcpResponse{ + JSONRPC: "2.0", + ID: nil, + Error: &mcpRPCError{ + Code: -32700, + Message: "parse error", + Data: err.Error(), + }, + }) + return + } + if req.JSONRPC == "" { + req.JSONRPC = "2.0" + } + if req.Method == "" && req.Name != "" { + params, _ := json.Marshal(map[string]any{ + "name": req.Name, + "arguments": rawObjectOrEmpty(req.Args), + }) + req.Method = "tools/call" + req.Params = params + } + + switch req.Method { + case "initialize": + s.writeRPC(w, mcpResponse{ + JSONRPC: "2.0", + ID: req.ID, + Result: map[string]any{ + "protocolVersion": "2025-03-26", + "capabilities": map[string]any{ + "tools": map[string]any{"listChanged": false}, + }, + "serverInfo": map[string]any{ + "name": "codencer-relay", + "version": "v2", + }, + }, + }) + case "notifications/initialized": + w.WriteHeader(http.StatusAccepted) + case "tools/list": + s.writeRPC(w, mcpResponse{ + JSONRPC: "2.0", + ID: req.ID, + Result: map[string]any{ + "tools": s.listTools(), + }, + }) + case "tools/call": + s.handleToolCall(w, r, req) + default: + s.writeRPC(w, mcpResponse{ + JSONRPC: "2.0", + ID: req.ID, + Error: &mcpRPCError{ + Code: -32601, + Message: "method not found", + Data: req.Method, + }, + }) + } +} + +func (s *mcpServer) handleToolCall(w http.ResponseWriter, r *http.Request, req mcpRequest) { + var params struct { + Name string `json:"name"` + Arguments map[string]any `json:"arguments"` + } + if err := json.Unmarshal(req.Params, ¶ms); err != nil { + s.writeRPC(w, mcpResponse{ + JSONRPC: "2.0", + ID: req.ID, + Error: &mcpRPCError{ + Code: -32602, + Message: "invalid params", + Data: err.Error(), + }, + }) + return + } + tool, ok := s.tools[params.Name] + if !ok { + s.writeRPC(w, mcpResponse{ + JSONRPC: "2.0", + ID: req.ID, + Result: errorToolResult("tool_not_found", fmt.Sprintf("unknown tool: %s", params.Name)), + }) + return + } + if params.Arguments == nil { + params.Arguments = map[string]any{} + } + + principal := plannerFromContext(r.Context()) + if err := authorizePrincipal(principal, tool.Scope, tool.instanceID(params.Arguments)); err != nil { + s.writeRPC(w, mcpResponse{ + JSONRPC: "2.0", + ID: req.ID, + Result: errorToolResult(err.Code, err.Message), + }) + return + } + + result, apiErr := tool.Invoke(r.Context(), principal, params.Arguments) + if apiErr != nil { + s.writeRPC(w, mcpResponse{ + JSONRPC: "2.0", + ID: req.ID, + Result: errorToolResult(apiErr.Code, apiErr.Message), + }) + return + } + s.writeRPC(w, mcpResponse{ + JSONRPC: "2.0", + ID: req.ID, + Result: result, + }) +} + +func (s *mcpServer) listTools() []map[string]any { + tools := make([]map[string]any, 0, len(s.tools)) + for _, tool := range toolOrder(s.tools) { + tools = append(tools, map[string]any{ + "name": tool.Name, + "description": tool.Description, + "inputSchema": tool.InputSchema, + }) + } + return tools +} + +func (s *mcpServer) writeRPC(w http.ResponseWriter, response mcpResponse) { + w.Header().Set("Content-Type", "application/json") + w.WriteHeader(http.StatusOK) + _ = json.NewEncoder(w).Encode(response) +} + +func errorToolResult(code, message string) mcpToolResult { + return mcpToolResult{ + IsError: true, + Content: []map[string]string{{ + "type": "text", + "text": message, + }}, + StructuredContent: map[string]any{ + "error": map[string]any{ + "code": code, + "message": message, + }, + }, + } +} + +func successToolResult(summary string, payload any) mcpToolResult { + result := mcpToolResult{StructuredContent: payload} + if summary != "" { + result.Content = []map[string]string{{ + "type": "text", + "text": summary, + }} + } + return result +} + +func (s *mcpServer) callPlannerRoute(ctx context.Context, authHeader, method, path string, body []byte) (int, http.Header, []byte, *apiError) { + req, err := http.NewRequest(method, path, bytes.NewReader(body)) + if err != nil { + return 0, nil, nil, &apiError{Status: http.StatusInternalServerError, Code: "relay_internal_error", Message: err.Error()} + } + req = req.WithContext(ctx) + if authHeader != "" { + req.Header.Set("Authorization", authHeader) + } + if len(body) > 0 { + req.Header.Set("Content-Type", "application/json") + } + recorder := newResponseRecorder() + handler, _ := s.relay.server.Handler.(*http.ServeMux) + handler.ServeHTTP(recorder, req) + bodyBytes := recorder.body.Bytes() + if recorder.statusCode >= 400 { + return recorder.statusCode, recorder.header, bodyBytes, decodeAPIError(recorder.statusCode, bodyBytes) + } + return recorder.statusCode, recorder.header, bodyBytes, nil +} + +func decodeAPIError(status int, body []byte) *apiError { + var payload struct { + Error struct { + Code string `json:"code"` + Message string `json:"message"` + } `json:"error"` + } + if err := json.Unmarshal(body, &payload); err == nil && payload.Error.Code != "" { + return &apiError{Status: status, Code: payload.Error.Code, Message: payload.Error.Message} + } + return &apiError{Status: status, Code: "upstream_error", Message: strings.TrimSpace(string(body))} +} + +func rawObjectOrEmpty(raw json.RawMessage) map[string]any { + if len(raw) == 0 { + return map[string]any{} + } + var value map[string]any + if err := json.Unmarshal(raw, &value); err != nil { + return map[string]any{} + } + return value +} + +func artifactContentPayload(contentType string, body []byte) map[string]any { + payload := map[string]any{ + "content_type": contentType, + } + if strings.HasPrefix(contentType, "text/") || strings.Contains(contentType, "json") { + payload["encoding"] = "utf-8" + payload["text"] = string(body) + return payload + } + payload["encoding"] = "base64" + payload["base64"] = base64.StdEncoding.EncodeToString(body) + return payload +} diff --git a/internal/relay/mcp_server_test.go b/internal/relay/mcp_server_test.go new file mode 100644 index 0000000..6f68a71 --- /dev/null +++ b/internal/relay/mcp_server_test.go @@ -0,0 +1,388 @@ +package relay_test + +import ( + "bytes" + "context" + "encoding/json" + "io" + "net/http" + "net/http/httptest" + "path/filepath" + "strings" + "sync" + "testing" + "time" + + "agent-bridge/internal/connector" + "agent-bridge/internal/domain" + "agent-bridge/internal/relay" +) + +type mcpHarness struct { + relayHTTP *httptest.Server + daemon *httptest.Server + cancel context.CancelFunc + waitErr chan error + auth string + mu sync.Mutex + lastTask map[string]any +} + +func startMCPHarness(t *testing.T) *mcpHarness { + t.Helper() + + h := &mcpHarness{auth: "Bearer planner-token"} + artifact := domain.Artifact{ID: "art-1", AttemptID: "attempt-1", Name: "stdout.log", Path: "/tmp/stdout.log"} + + h.daemon = httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + w.Header().Set("Content-Type", "application/json") + switch { + case r.Method == http.MethodGet && r.URL.Path == "/api/v1/instance": + _ = json.NewEncoder(w).Encode(domain.InstanceInfo{ + ID: "inst-1", + RepoRoot: "/repo", + BaseURL: h.daemon.URL, + }) + case r.Method == http.MethodPost && r.URL.Path == "/api/v1/runs": + _, _ = w.Write([]byte(`{"id":"run-1","project_id":"proj","state":"running"}`)) + case r.Method == http.MethodGet && r.URL.Path == "/api/v1/runs/run-1": + _, _ = w.Write([]byte(`{"id":"run-1","project_id":"proj","state":"running"}`)) + case r.Method == http.MethodPost && r.URL.Path == "/api/v1/runs/run-1/steps": + var payload map[string]any + _ = json.NewDecoder(r.Body).Decode(&payload) + h.mu.Lock() + h.lastTask = payload + h.mu.Unlock() + _, _ = w.Write([]byte(`{"id":"step-1","phase_id":"phase-1","state":"running"}`)) + case r.Method == http.MethodGet && r.URL.Path == "/api/v1/steps/step-1": + _, _ = w.Write([]byte(`{"id":"step-1","phase_id":"phase-1","state":"completed"}`)) + case r.Method == http.MethodPost && r.URL.Path == "/api/v1/steps/step-1/wait": + _, _ = w.Write([]byte(`{"step_id":"step-1","state":"completed","terminal":true,"timed_out":false}`)) + case r.Method == http.MethodGet && r.URL.Path == "/api/v1/steps/step-1/result": + _, _ = w.Write([]byte(`{"version":"v1","run_id":"run-1","step_id":"step-1","state":"completed","summary":"done"}`)) + case r.Method == http.MethodGet && r.URL.Path == "/api/v1/steps/step-1/validations": + _, _ = w.Write([]byte(`[{"name":"tests","status":"passed"}]`)) + case r.Method == http.MethodGet && r.URL.Path == "/api/v1/steps/step-1/artifacts": + _ = json.NewEncoder(w).Encode([]domain.Artifact{artifact}) + case r.Method == http.MethodGet && r.URL.Path == "/api/v1/artifacts/art-1/content": + w.Header().Set("Content-Type", "text/plain") + _, _ = w.Write([]byte("artifact-content")) + case r.Method == http.MethodPost && r.URL.Path == "/api/v1/runs/run-1/gates": + _, _ = w.Write([]byte(`[]`)) + case r.Method == http.MethodPost && r.URL.Path == "/api/v1/gates/gate-1": + w.WriteHeader(http.StatusOK) + case r.Method == http.MethodPatch && r.URL.Path == "/api/v1/runs/run-1": + w.WriteHeader(http.StatusOK) + case r.Method == http.MethodPost && r.URL.Path == "/api/v1/steps/step-1/retry": + w.WriteHeader(http.StatusAccepted) + default: + http.NotFound(w, r) + } + })) + + store, err := relay.OpenStore(filepath.Join(t.TempDir(), "relay.db")) + if err != nil { + t.Fatal(err) + } + t.Cleanup(func() { _ = store.Close() }) + + server := relay.NewServer(&relay.Config{ + Host: "127.0.0.1", + Port: 0, + DBPath: filepath.Join(t.TempDir(), "relay-unused.db"), + PlannerToken: "planner-token", + EnrollmentSecret: "enroll-secret", + }, store) + h.relayHTTP = httptest.NewServer(server.Handler()) + + configPath := filepath.Join(t.TempDir(), "connector.json") + cfg, err := connector.Enroll(context.Background(), h.relayHTTP.URL, h.daemon.URL, "enroll-secret", "test-connector", configPath) + if err != nil { + t.Fatal(err) + } + client := connector.NewClient(cfg) + ctx, cancel := context.WithCancel(context.Background()) + h.cancel = cancel + h.waitErr = make(chan error, 1) + go func() { h.waitErr <- client.Run(ctx) }() + + deadline := time.Now().Add(5 * time.Second) + for time.Now().Before(deadline) { + req, _ := http.NewRequest(http.MethodGet, h.relayHTTP.URL+"/api/v2/instances", nil) + req.Header.Set("Authorization", h.auth) + resp, err := http.DefaultClient.Do(req) + if err == nil { + body, _ := io.ReadAll(resp.Body) + _ = resp.Body.Close() + var instances []map[string]any + if json.Unmarshal(body, &instances) == nil && len(instances) == 1 { + break + } + } + time.Sleep(100 * time.Millisecond) + } + + t.Cleanup(func() { + cancel() + select { + case err := <-h.waitErr: + if err != nil && err != context.Canceled && !strings.Contains(err.Error(), "closed network connection") { + t.Fatalf("connector run failed: %v", err) + } + case <-time.After(2 * time.Second): + t.Fatal("connector did not stop") + } + h.relayHTTP.Close() + h.daemon.Close() + }) + + return h +} + +func (h *mcpHarness) call(t *testing.T, auth string, method string, params any) map[string]any { + t.Helper() + body, _ := json.Marshal(map[string]any{ + "jsonrpc": "2.0", + "id": "req-1", + "method": method, + "params": params, + }) + req, _ := http.NewRequest(http.MethodPost, h.relayHTTP.URL+"/mcp", bytes.NewReader(body)) + if auth != "" { + req.Header.Set("Authorization", auth) + } + req.Header.Set("Content-Type", "application/json") + resp, err := http.DefaultClient.Do(req) + if err != nil { + t.Fatal(err) + } + defer resp.Body.Close() + var payload map[string]any + data, _ := io.ReadAll(resp.Body) + if err := json.Unmarshal(data, &payload); err != nil { + t.Fatalf("invalid mcp response: %s", string(data)) + } + payload["http_status"] = float64(resp.StatusCode) + return payload +} + +func TestMCPToolsListIncludesRequiredCodencerTools(t *testing.T) { + t.Parallel() + + h := startMCPHarness(t) + response := h.call(t, h.auth, "tools/list", map[string]any{}) + result := response["result"].(map[string]any) + tools := result["tools"].([]any) + names := make(map[string]struct{}) + for _, item := range tools { + tool := item.(map[string]any) + names[tool["name"].(string)] = struct{}{} + } + required := []string{ + "codencer.list_instances", + "codencer.get_instance", + "codencer.start_run", + "codencer.get_run", + "codencer.submit_task", + "codencer.get_step", + "codencer.wait_step", + "codencer.get_step_result", + "codencer.list_step_artifacts", + "codencer.get_artifact_content", + "codencer.get_step_validations", + "codencer.approve_gate", + "codencer.reject_gate", + "codencer.abort_run", + "codencer.retry_step", + } + for _, name := range required { + if _, ok := names[name]; !ok { + t.Fatalf("expected tool %s in tools/list, got %v", name, names) + } + } +} + +func TestMCPSubmitTaskUsesTaskSpecContract(t *testing.T) { + t.Parallel() + + h := startMCPHarness(t) + response := h.call(t, h.auth, "tools/call", map[string]any{ + "name": "codencer.submit_task", + "arguments": map[string]any{ + "instance_id": "inst-1", + "run_id": "run-1", + "task": map[string]any{ + "version": "v1", + "goal": "Ship the fix", + "adapter_profile": "codex", + "allowed_paths": []string{"internal/relay"}, + "timeout_seconds": 120, + }, + }, + }) + result := response["result"].(map[string]any) + if isError, _ := result["isError"].(bool); isError { + t.Fatalf("unexpected MCP tool error: %+v", result) + } + h.mu.Lock() + defer h.mu.Unlock() + if h.lastTask["goal"] != "Ship the fix" || h.lastTask["version"] != "v1" { + t.Fatalf("expected TaskSpec payload to reach daemon, got %+v", h.lastTask) + } +} + +func TestMCPWaitStepAndArtifactContent(t *testing.T) { + t.Parallel() + + h := startMCPHarness(t) + h.call(t, h.auth, "tools/call", map[string]any{ + "name": "codencer.submit_task", + "arguments": map[string]any{ + "instance_id": "inst-1", + "run_id": "run-1", + "task": map[string]any{ + "version": "v1", + "goal": "Prepare wait routing", + }, + }, + }) + waitResponse := h.call(t, h.auth, "tools/call", map[string]any{ + "name": "codencer.wait_step", + "arguments": map[string]any{ + "step_id": "step-1", + "timeout_ms": 500, + "interval_ms": 50, + "include_result": false, + }, + }) + waitResult := waitResponse["result"].(map[string]any) + if isError, _ := waitResult["isError"].(bool); isError { + t.Fatalf("unexpected wait_step error: %+v", waitResult) + } + waitStructured := waitResult["structuredContent"].(map[string]any) + if waitStructured["terminal"] != true { + t.Fatalf("expected terminal wait response, got %+v", waitStructured) + } + + h.call(t, h.auth, "tools/call", map[string]any{ + "name": "codencer.list_step_artifacts", + "arguments": map[string]any{ + "step_id": "step-1", + }, + }) + artifactResponse := h.call(t, h.auth, "tools/call", map[string]any{ + "name": "codencer.get_artifact_content", + "arguments": map[string]any{ + "artifact_id": "art-1", + }, + }) + artifactResult := artifactResponse["result"].(map[string]any) + if isError, _ := artifactResult["isError"].(bool); isError { + t.Fatalf("unexpected get_artifact_content error: %+v", artifactResult) + } + structured := artifactResult["structuredContent"].(map[string]any) + if structured["encoding"] != "utf-8" || structured["text"] != "artifact-content" { + t.Fatalf("unexpected artifact payload: %+v", structured) + } +} + +func TestMCPAuthAndMalformedInput(t *testing.T) { + t.Parallel() + + h := startMCPHarness(t) + + unauthorized := h.call(t, "", "tools/list", map[string]any{}) + if status := int(unauthorized["http_status"].(float64)); status != http.StatusUnauthorized { + t.Fatalf("expected 401 for missing auth, got %+v", unauthorized) + } + + store, err := relay.OpenStore(filepath.Join(t.TempDir(), "relay.db")) + if err != nil { + t.Fatal(err) + } + defer store.Close() + server := relay.NewServer(&relay.Config{ + DBPath: filepath.Join(t.TempDir(), "relay-auth.db"), + PlannerTokens: []relay.PlannerTokenConfig{{ + Name: "read-only", + Token: "read-token", + Scopes: []string{"instances:read"}, + }}, + }, store) + relayHTTP := httptest.NewServer(server.Handler()) + defer relayHTTP.Close() + + body, _ := json.Marshal(map[string]any{ + "jsonrpc": "2.0", + "id": "req-1", + "method": "tools/call", + "params": map[string]any{ + "name": "codencer.start_run", + "arguments": map[string]any{ + "instance_id": "inst-1", + "payload": map[string]any{ + "project_id": "proj", + }, + }, + }, + }) + req, _ := http.NewRequest(http.MethodPost, relayHTTP.URL+"/mcp", bytes.NewReader(body)) + req.Header.Set("Authorization", "Bearer read-token") + req.Header.Set("Content-Type", "application/json") + resp, err := http.DefaultClient.Do(req) + if err != nil { + t.Fatal(err) + } + defer resp.Body.Close() + var scoped map[string]any + data, _ := io.ReadAll(resp.Body) + _ = json.Unmarshal(data, &scoped) + result := scoped["result"].(map[string]any) + if result["isError"] != true { + t.Fatalf("expected scope-denied MCP tool result, got %+v", scoped) + } + + malformed := h.call(t, h.auth, "tools/call", map[string]any{ + "name": "codencer.submit_task", + "arguments": map[string]any{"instance_id": "inst-1", "run_id": "run-1"}, + }) + malformedResult := malformed["result"].(map[string]any) + if malformedResult["isError"] != true { + t.Fatalf("expected malformed_request result, got %+v", malformed) + } +} + +func TestMCPRetryStepRejectsWrongInstance(t *testing.T) { + t.Parallel() + + h := startMCPHarness(t) + h.call(t, h.auth, "tools/call", map[string]any{ + "name": "codencer.submit_task", + "arguments": map[string]any{ + "instance_id": "inst-1", + "run_id": "run-1", + "task": map[string]any{ + "version": "v1", + "goal": "Seed step route", + }, + }, + }) + + response := h.call(t, h.auth, "tools/call", map[string]any{ + "name": "codencer.retry_step", + "arguments": map[string]any{ + "instance_id": "inst-2", + "step_id": "step-1", + }, + }) + + result := response["result"].(map[string]any) + if result["isError"] != true { + t.Fatalf("expected retry_step to reject wrong instance, got %+v", response) + } + structured := result["structuredContent"].(map[string]any) + errPayload := structured["error"].(map[string]any) + if errPayload["code"] != "instance_denied" { + t.Fatalf("expected instance_denied, got %+v", errPayload) + } +} diff --git a/internal/relay/mcp_tools.go b/internal/relay/mcp_tools.go new file mode 100644 index 0000000..82987ae --- /dev/null +++ b/internal/relay/mcp_tools.go @@ -0,0 +1,446 @@ +package relay + +import ( + "context" + "encoding/json" + "fmt" + "net/http" + "sort" + "strings" +) + +type mcpTool struct { + Name string + Description string + Scope string + InputSchema map[string]any + Invoke func(ctx context.Context, principal *plannerPrincipal, args map[string]any) (mcpToolResult, *apiError) +} + +func (t mcpTool) instanceID(args map[string]any) string { + value, _ := args["instance_id"].(string) + return value +} + +func buildMCPTools(server *mcpServer) map[string]mcpTool { + return map[string]mcpTool{ + "codencer.list_instances": { + Name: "codencer.list_instances", + Description: "List shared Codencer instances available through the relay.", + Scope: "instances:read", + InputSchema: objectSchema(nil, nil), + Invoke: func(ctx context.Context, principal *plannerPrincipal, args map[string]any) (mcpToolResult, *apiError) { + status, _, body, err := server.callPlannerRoute(ctx, authHeaderForPrincipal(principal, server.relay.cfg), http.MethodGet, "/api/v2/instances", nil) + if err != nil { + return mcpToolResult{}, err + } + var payload any + if decodeErr := json.Unmarshal(body, &payload); decodeErr != nil { + return mcpToolResult{}, &apiError{Status: status, Code: "relay_internal_error", Message: decodeErr.Error()} + } + return successToolResult("Listed shared instances.", payload), nil + }, + }, + "codencer.get_instance": { + Name: "codencer.get_instance", + Description: "Get a single shared Codencer instance descriptor.", + Scope: "instances:read", + InputSchema: objectSchema([]string{"instance_id"}, map[string]any{ + "instance_id": stringSchema("Relay instance identifier."), + }), + Invoke: func(ctx context.Context, principal *plannerPrincipal, args map[string]any) (mcpToolResult, *apiError) { + instanceID, apiErr := requiredString(args, "instance_id") + if apiErr != nil { + return mcpToolResult{}, apiErr + } + status, _, body, err := server.callPlannerRoute(ctx, authHeaderForPrincipal(principal, server.relay.cfg), http.MethodGet, fmt.Sprintf("/api/v2/instances/%s", instanceID), nil) + if err != nil { + return mcpToolResult{}, err + } + var payload any + if decodeErr := json.Unmarshal(body, &payload); decodeErr != nil { + return mcpToolResult{}, &apiError{Status: status, Code: "relay_internal_error", Message: decodeErr.Error()} + } + return successToolResult("Fetched instance descriptor.", payload), nil + }, + }, + "codencer.start_run": plannerProxyTool(server, "codencer.start_run", "Start a run on a shared instance.", "runs:write", + objectSchema([]string{"instance_id", "payload"}, map[string]any{ + "instance_id": stringSchema("Target shared instance identifier."), + "payload": objectSchema([]string{"project_id"}, map[string]any{ + "id": stringSchema("Optional run identifier."), + "project_id": stringSchema("Project identifier."), + "conversation_id": stringSchema("Optional planner conversation identifier."), + "planner_id": stringSchema("Optional planner identifier."), + "executor_id": stringSchema("Optional executor identifier."), + }), + }), func(args map[string]any) (string, string, []byte, *apiError) { + instanceID, apiErr := requiredString(args, "instance_id") + if apiErr != nil { + return "", "", nil, apiErr + } + payload, apiErr := requiredObjectJSON(args, "payload") + if apiErr != nil { + return "", "", nil, apiErr + } + return instanceID, fmt.Sprintf("/api/v2/instances/%s/runs", instanceID), payload, nil + }), + "codencer.get_run": plannerProxyTool(server, "codencer.get_run", "Get a run on a shared instance.", "runs:read", + objectSchema([]string{"instance_id", "run_id"}, map[string]any{ + "instance_id": stringSchema("Target shared instance identifier."), + "run_id": stringSchema("Run identifier."), + }), func(args map[string]any) (string, string, []byte, *apiError) { + instanceID, apiErr := requiredString(args, "instance_id") + if apiErr != nil { + return "", "", nil, apiErr + } + runID, apiErr := requiredString(args, "run_id") + if apiErr != nil { + return "", "", nil, apiErr + } + return instanceID, fmt.Sprintf("/api/v2/instances/%s/runs/%s", instanceID, runID), nil, nil + }), + "codencer.submit_task": plannerProxyTool(server, "codencer.submit_task", "Submit a Codencer task to a run.", "steps:write", + objectSchema([]string{"instance_id", "run_id", "task"}, map[string]any{ + "instance_id": stringSchema("Target shared instance identifier."), + "run_id": stringSchema("Run identifier."), + "task": taskSpecSchema(), + }), func(args map[string]any) (string, string, []byte, *apiError) { + instanceID, apiErr := requiredString(args, "instance_id") + if apiErr != nil { + return "", "", nil, apiErr + } + runID, apiErr := requiredString(args, "run_id") + if apiErr != nil { + return "", "", nil, apiErr + } + payload, apiErr := requiredObjectJSON(args, "task") + if apiErr != nil { + return "", "", nil, apiErr + } + return instanceID, fmt.Sprintf("/api/v2/instances/%s/runs/%s/steps", instanceID, runID), payload, nil + }), + "codencer.get_step": plannerProxyTool(server, "codencer.get_step", "Get a step by identifier.", "steps:read", + objectSchema([]string{"step_id"}, map[string]any{ + "step_id": stringSchema("Step identifier."), + }), func(args map[string]any) (string, string, []byte, *apiError) { + stepID, apiErr := requiredString(args, "step_id") + if apiErr != nil { + return "", "", nil, apiErr + } + return "", fmt.Sprintf("/api/v2/steps/%s", stepID), nil, nil + }), + "codencer.wait_step": plannerProxyTool(server, "codencer.wait_step", "Wait for a step to become terminal with a bounded timeout.", "steps:read", + objectSchema([]string{"step_id"}, map[string]any{ + "step_id": stringSchema("Step identifier."), + "timeout_ms": intSchema("Maximum wait time in milliseconds."), + "interval_ms": intSchema("Polling interval in milliseconds."), + "include_result": boolSchema("Include the step result when terminal."), + }), func(args map[string]any) (string, string, []byte, *apiError) { + stepID, apiErr := requiredString(args, "step_id") + if apiErr != nil { + return "", "", nil, apiErr + } + payload := map[string]any{} + copyOptional(payload, args, "timeout_ms", "interval_ms", "include_result") + body, _ := json.Marshal(payload) + return "", fmt.Sprintf("/api/v2/steps/%s/wait", stepID), body, nil + }), + "codencer.get_step_result": plannerProxyTool(server, "codencer.get_step_result", "Get the result payload for a step.", "steps:read", + objectSchema([]string{"step_id"}, map[string]any{ + "step_id": stringSchema("Step identifier."), + }), func(args map[string]any) (string, string, []byte, *apiError) { + stepID, apiErr := requiredString(args, "step_id") + if apiErr != nil { + return "", "", nil, apiErr + } + return "", fmt.Sprintf("/api/v2/steps/%s/result", stepID), nil, nil + }), + "codencer.list_step_artifacts": plannerProxyTool(server, "codencer.list_step_artifacts", "List artifacts emitted by a step.", "artifacts:read", + objectSchema([]string{"step_id"}, map[string]any{ + "step_id": stringSchema("Step identifier."), + }), func(args map[string]any) (string, string, []byte, *apiError) { + stepID, apiErr := requiredString(args, "step_id") + if apiErr != nil { + return "", "", nil, apiErr + } + return "", fmt.Sprintf("/api/v2/steps/%s/artifacts", stepID), nil, nil + }), + "codencer.get_artifact_content": { + Name: "codencer.get_artifact_content", + Description: "Fetch artifact content by artifact identifier with explicit text or base64 encoding.", + Scope: "artifacts:read", + InputSchema: objectSchema([]string{"artifact_id"}, map[string]any{ + "artifact_id": stringSchema("Artifact identifier."), + }), + Invoke: func(ctx context.Context, principal *plannerPrincipal, args map[string]any) (mcpToolResult, *apiError) { + artifactID, apiErr := requiredString(args, "artifact_id") + if apiErr != nil { + return mcpToolResult{}, apiErr + } + _, headers, body, err := server.callPlannerRoute(ctx, authHeaderForPrincipal(principal, server.relay.cfg), http.MethodGet, fmt.Sprintf("/api/v2/artifacts/%s/content", artifactID), nil) + if err != nil { + return mcpToolResult{}, err + } + contentType := headers.Get("Content-Type") + payload := artifactContentPayload(contentType, body) + payload["artifact_id"] = artifactID + return successToolResult("Fetched artifact content.", payload), nil + }, + }, + "codencer.get_step_validations": plannerProxyTool(server, "codencer.get_step_validations", "Get validation outcomes for a step.", "steps:read", + objectSchema([]string{"step_id"}, map[string]any{ + "step_id": stringSchema("Step identifier."), + }), func(args map[string]any) (string, string, []byte, *apiError) { + stepID, apiErr := requiredString(args, "step_id") + if apiErr != nil { + return "", "", nil, apiErr + } + return "", fmt.Sprintf("/api/v2/steps/%s/validations", stepID), nil, nil + }), + "codencer.approve_gate": plannerProxyTool(server, "codencer.approve_gate", "Approve a pending gate for a shared instance.", "gates:write", + objectSchema([]string{"instance_id", "gate_id"}, map[string]any{ + "instance_id": stringSchema("Target shared instance identifier."), + "gate_id": stringSchema("Gate identifier."), + }), func(args map[string]any) (string, string, []byte, *apiError) { + instanceID, gateID, apiErr := requireInstanceAndGate(args) + if apiErr != nil { + return "", "", nil, apiErr + } + if apiErr := server.requireRoutedInstance(context.Background(), "gate", gateID, instanceID); apiErr != nil { + return "", "", nil, apiErr + } + return instanceID, fmt.Sprintf("/api/v2/gates/%s/approve", gateID), nil, nil + }), + "codencer.reject_gate": plannerProxyTool(server, "codencer.reject_gate", "Reject a pending gate for a shared instance.", "gates:write", + objectSchema([]string{"instance_id", "gate_id"}, map[string]any{ + "instance_id": stringSchema("Target shared instance identifier."), + "gate_id": stringSchema("Gate identifier."), + }), func(args map[string]any) (string, string, []byte, *apiError) { + instanceID, gateID, apiErr := requireInstanceAndGate(args) + if apiErr != nil { + return "", "", nil, apiErr + } + if apiErr := server.requireRoutedInstance(context.Background(), "gate", gateID, instanceID); apiErr != nil { + return "", "", nil, apiErr + } + return instanceID, fmt.Sprintf("/api/v2/gates/%s/reject", gateID), nil, nil + }), + "codencer.abort_run": plannerProxyTool(server, "codencer.abort_run", "Abort a run on a shared instance.", "runs:write", + objectSchema([]string{"instance_id", "run_id"}, map[string]any{ + "instance_id": stringSchema("Target shared instance identifier."), + "run_id": stringSchema("Run identifier."), + }), func(args map[string]any) (string, string, []byte, *apiError) { + instanceID, apiErr := requiredString(args, "instance_id") + if apiErr != nil { + return "", "", nil, apiErr + } + runID, apiErr := requiredString(args, "run_id") + if apiErr != nil { + return "", "", nil, apiErr + } + return instanceID, fmt.Sprintf("/api/v2/instances/%s/runs/%s/abort", instanceID, runID), nil, nil + }), + "codencer.retry_step": plannerProxyTool(server, "codencer.retry_step", "Retry a step on a shared instance.", "steps:write", + objectSchema([]string{"instance_id", "step_id"}, map[string]any{ + "instance_id": stringSchema("Target shared instance identifier."), + "step_id": stringSchema("Step identifier."), + }), func(args map[string]any) (string, string, []byte, *apiError) { + instanceID, apiErr := requiredString(args, "instance_id") + if apiErr != nil { + return "", "", nil, apiErr + } + stepID, apiErr := requiredString(args, "step_id") + if apiErr != nil { + return "", "", nil, apiErr + } + if apiErr := server.requireRoutedInstance(context.Background(), "step", stepID, instanceID); apiErr != nil { + return "", "", nil, apiErr + } + return instanceID, fmt.Sprintf("/api/v2/steps/%s/retry", stepID), nil, nil + }), + } +} + +func plannerProxyTool(server *mcpServer, name, description, scope string, schema map[string]any, route func(args map[string]any) (string, string, []byte, *apiError)) mcpTool { + return mcpTool{ + Name: name, + Description: description, + Scope: scope, + InputSchema: schema, + Invoke: func(ctx context.Context, principal *plannerPrincipal, args map[string]any) (mcpToolResult, *apiError) { + instanceID, path, body, apiErr := route(args) + if apiErr != nil { + return mcpToolResult{}, apiErr + } + if requiresExplicitInstance(scope) && instanceID == "" { + return mcpToolResult{}, &apiError{Status: http.StatusBadRequest, Code: "malformed_request", Message: "instance_id is required for this tool"} + } + method := http.MethodGet + if body != nil { + method = http.MethodPost + } + if stringsHasSuffix(path, "/abort") || stringsHasSuffix(path, "/approve") || stringsHasSuffix(path, "/reject") || stringsHasSuffix(path, "/retry") || stringsHasSuffix(path, "/wait") { + method = http.MethodPost + } + _, _, responseBody, err := server.callPlannerRoute(ctx, authHeaderForPrincipal(principal, server.relay.cfg), method, path, body) + if err != nil { + return mcpToolResult{}, err + } + var payload any + if len(responseBody) == 0 { + payload = map[string]any{"ok": true} + } else if decodeErr := json.Unmarshal(responseBody, &payload); decodeErr != nil { + payload = map[string]any{"raw": string(responseBody)} + } + return successToolResult(description, payload), nil + }, + } +} + +func toolOrder(tools map[string]mcpTool) []mcpTool { + values := make([]mcpTool, 0, len(tools)) + for _, tool := range tools { + values = append(values, tool) + } + sort.Slice(values, func(i, j int) bool { return values[i].Name < values[j].Name }) + return values +} + +func requiredString(args map[string]any, key string) (string, *apiError) { + value, ok := args[key].(string) + if !ok || stringsTrim(value) == "" { + return "", &apiError{Status: http.StatusBadRequest, Code: "malformed_request", Message: fmt.Sprintf("%s is required", key)} + } + return value, nil +} + +func requiredObjectJSON(args map[string]any, key string) ([]byte, *apiError) { + value, ok := args[key] + if !ok { + return nil, &apiError{Status: http.StatusBadRequest, Code: "malformed_request", Message: fmt.Sprintf("%s is required", key)} + } + body, err := json.Marshal(value) + if err != nil { + return nil, &apiError{Status: http.StatusBadRequest, Code: "malformed_request", Message: err.Error()} + } + return body, nil +} + +func requireInstanceAndGate(args map[string]any) (string, string, *apiError) { + instanceID, apiErr := requiredString(args, "instance_id") + if apiErr != nil { + return "", "", apiErr + } + gateID, apiErr := requiredString(args, "gate_id") + if apiErr != nil { + return "", "", apiErr + } + return instanceID, gateID, nil +} + +func authHeaderForPrincipal(principal *plannerPrincipal, cfg *Config) string { + if principal == nil { + return "" + } + for _, candidate := range cfg.PlannerTokens { + if candidate.Name == principal.Name { + return "Bearer " + candidate.Token + } + } + if cfg.PlannerToken != "" { + return "Bearer " + cfg.PlannerToken + } + return "" +} + +func objectSchema(required []string, properties map[string]any) map[string]any { + if properties == nil { + properties = map[string]any{} + } + return map[string]any{ + "type": "object", + "required": required, + "properties": properties, + } +} + +func stringSchema(description string) map[string]any { + return map[string]any{"type": "string", "description": description} +} + +func intSchema(description string) map[string]any { + return map[string]any{"type": "integer", "description": description} +} + +func boolSchema(description string) map[string]any { + return map[string]any{"type": "boolean", "description": description} +} + +func taskSpecSchema() map[string]any { + return map[string]any{ + "type": "object", + "description": "Canonical Codencer TaskSpec payload.", + "required": []string{"version", "goal"}, + "properties": map[string]any{ + "version": stringSchema("Task contract version."), + "project_id": stringSchema("Project identifier."), + "run_id": stringSchema("Optional run identifier."), + "phase_id": stringSchema("Optional phase identifier."), + "step_id": stringSchema("Optional step identifier."), + "title": stringSchema("Optional human-readable title."), + "goal": stringSchema("Primary instruction for the adapter."), + "context": objectSchema(nil, map[string]any{"summary": stringSchema("Optional contextual summary.")}), + "constraints": map[string]any{"type": "array", "items": map[string]any{"type": "string"}}, + "allowed_paths": map[string]any{"type": "array", "items": map[string]any{"type": "string"}}, + "forbidden_paths": map[string]any{"type": "array", "items": map[string]any{"type": "string"}}, + "validations": map[string]any{"type": "array", "items": map[string]any{"type": "object"}}, + "acceptance": map[string]any{"type": "array", "items": map[string]any{"type": "string"}}, + "stop_conditions": map[string]any{"type": "array", "items": map[string]any{"type": "string"}}, + "policy_bundle": stringSchema("Optional policy bundle."), + "adapter_profile": stringSchema("Preferred adapter profile."), + "timeout_seconds": intSchema("Optional task timeout in seconds."), + "is_simulation": boolSchema("Simulation flag."), + "submission_provenance": map[string]any{"type": "object"}, + }, + } +} + +func copyOptional(dst, src map[string]any, keys ...string) { + for _, key := range keys { + if value, ok := src[key]; ok { + dst[key] = value + } + } +} + +func requiresExplicitInstance(scope string) bool { + switch scope { + case "runs:write", "steps:write", "gates:write": + return true + default: + return false + } +} + +func (s *mcpServer) requireRoutedInstance(ctx context.Context, resourceKind, resourceID, instanceID string) *apiError { + routedInstance, err := s.relay.store.LookupResourceRoute(ctx, resourceKind, resourceID) + if err != nil { + return &apiError{Status: http.StatusInternalServerError, Code: "relay_internal_error", Message: err.Error()} + } + if routedInstance == "" { + return &apiError{Status: http.StatusNotFound, Code: "instance_not_found", Message: fmt.Sprintf("%s route not found", resourceKind)} + } + if routedInstance != instanceID { + return &apiError{Status: http.StatusForbidden, Code: "instance_denied", Message: fmt.Sprintf("%s is not routed to the requested instance", resourceKind)} + } + return nil +} + +func stringsHasSuffix(value, suffix string) bool { + return len(value) >= len(suffix) && value[len(value)-len(suffix):] == suffix +} + +func stringsTrim(value string) string { + return strings.TrimSpace(value) +} diff --git a/internal/relay/router.go b/internal/relay/router.go new file mode 100644 index 0000000..46eb1a6 --- /dev/null +++ b/internal/relay/router.go @@ -0,0 +1,466 @@ +package relay + +import ( + "context" + "encoding/json" + "fmt" + "io" + "net/http" + "strings" + "time" + + "agent-bridge/internal/domain" + "agent-bridge/internal/relayproto" +) + +type plannerInstance struct { + InstanceID string `json:"instance_id"` + ConnectorID string `json:"connector_id"` + RepoRoot string `json:"repo_root"` + BaseURL string `json:"base_url"` + Online bool `json:"online"` + Status string `json:"status"` + LastSeenAt time.Time `json:"last_seen_at"` + Instance json.RawMessage `json:"instance,omitempty"` +} + +func (s *Server) handleInstances(w http.ResponseWriter, r *http.Request) { + switch r.Method { + case http.MethodGet: + records, err := s.store.ListInstances(r.Context()) + if err != nil { + writeAPIError(w, http.StatusInternalServerError, "relay_internal_error", err.Error()) + return + } + response := make([]plannerInstance, 0, len(records)) + for _, record := range records { + status := s.instanceStatus(&record) + response = append(response, plannerInstance{ + InstanceID: record.InstanceID, + ConnectorID: record.ConnectorID, + RepoRoot: record.RepoRoot, + BaseURL: record.BaseURL, + Online: status.Online, + Status: status.Status, + LastSeenAt: record.LastSeenAt, + Instance: json.RawMessage(record.InstanceJSON), + }) + } + writeJSON(w, http.StatusOK, response) + default: + writeAPIError(w, http.StatusMethodNotAllowed, "method_not_allowed", "method not allowed") + } +} + +func (s *Server) handleEnrollmentTokens(w http.ResponseWriter, r *http.Request) { + if r.Method != http.MethodPost { + writeAPIError(w, http.StatusMethodNotAllowed, "method_not_allowed", "method not allowed") + return + } + var req struct { + Label string `json:"label"` + ExpiresInSeconds int `json:"expires_in_seconds"` + } + if err := json.NewDecoder(r.Body).Decode(&req); err != nil { + writeAPIError(w, http.StatusBadRequest, "malformed_request", err.Error()) + return + } + var expiresIn time.Duration + if req.ExpiresInSeconds > 0 { + expiresIn = time.Duration(req.ExpiresInSeconds) * time.Second + } + actor := plannerFromContext(r.Context()) + createdBy := "planner" + if actor != nil && actor.Name != "" { + createdBy = actor.Name + } + record, secret, err := s.enrollment.CreateToken(r.Context(), createdBy, req.Label, expiresIn) + if err != nil { + writeAPIError(w, http.StatusInternalServerError, "relay_internal_error", err.Error()) + return + } + s.auditor.Record(r.Context(), AuditEvent{ + ActorType: "planner", + ActorID: createdBy, + Action: "create_enrollment_token", + Outcome: "ok", + }) + writeJSON(w, http.StatusCreated, map[string]any{ + "token_id": record.TokenID, + "secret": secret, + "label": record.Label, + "created_at": record.CreatedAt, + "expires_at": record.ExpiresAt, + }) +} + +func (s *Server) handleInstanceScoped(w http.ResponseWriter, r *http.Request) { + path := strings.TrimPrefix(r.URL.Path, "/api/v2/instances/") + parts := strings.Split(strings.Trim(path, "/"), "/") + if len(parts) == 0 || parts[0] == "" { + writeAPIError(w, http.StatusBadRequest, "malformed_request", "instance_id is required") + return + } + instanceID := parts[0] + if len(parts) == 1 && r.Method == http.MethodGet { + record, err := s.store.GetInstance(r.Context(), instanceID) + if err != nil { + writeAPIError(w, http.StatusInternalServerError, "relay_internal_error", err.Error()) + return + } + if record == nil { + writeAPIError(w, http.StatusNotFound, "instance_not_found", "instance not found") + return + } + status := s.instanceStatus(record) + writeJSON(w, http.StatusOK, plannerInstance{ + InstanceID: record.InstanceID, + ConnectorID: record.ConnectorID, + RepoRoot: record.RepoRoot, + BaseURL: record.BaseURL, + Online: status.Online, + Status: status.Status, + LastSeenAt: record.LastSeenAt, + Instance: json.RawMessage(record.InstanceJSON), + }) + return + } + if len(parts) < 2 { + writeAPIError(w, http.StatusBadRequest, "malformed_request", "instance resource path is required") + return + } + resource := parts[1] + switch { + case resource == "runs" && len(parts) == 2 && r.Method == http.MethodGet: + s.proxyAndWrite(w, r, instanceID, http.MethodGet, "/api/v1/runs", r.URL.RawQuery, nil, "", "", "list_runs", "runs:read") + case resource == "runs" && len(parts) == 2 && r.Method == http.MethodPost: + body, err := io.ReadAll(r.Body) + if err != nil { + writeAPIError(w, http.StatusBadRequest, "malformed_request", err.Error()) + return + } + s.proxyAndWrite(w, r, instanceID, http.MethodPost, "/api/v1/runs", "", body, "run", "id", "start_run", "runs:write") + case resource == "runs" && len(parts) == 3 && r.Method == http.MethodGet: + s.proxyAndWrite(w, r, instanceID, http.MethodGet, fmt.Sprintf("/api/v1/runs/%s", parts[2]), "", nil, "", "", "get_run", "runs:read") + case resource == "runs" && len(parts) == 4 && parts[3] == "steps" && r.Method == http.MethodPost: + body, err := io.ReadAll(r.Body) + if err != nil { + writeAPIError(w, http.StatusBadRequest, "malformed_request", err.Error()) + return + } + s.proxyAndWrite(w, r, instanceID, http.MethodPost, fmt.Sprintf("/api/v1/runs/%s/steps", parts[2]), "", body, "step", "id", "submit_task", "steps:write") + case resource == "runs" && len(parts) == 4 && parts[3] == "gates" && r.Method == http.MethodGet: + s.proxyAndWrite(w, r, instanceID, http.MethodGet, fmt.Sprintf("/api/v1/runs/%s/gates", parts[2]), "", nil, "gate", "id", "list_run_gates", "gates:read") + case resource == "runs" && len(parts) == 4 && parts[3] == "abort" && r.Method == http.MethodPost: + body, _ := json.Marshal(map[string]string{"action": "abort"}) + s.proxyAndWrite(w, r, instanceID, http.MethodPatch, fmt.Sprintf("/api/v1/runs/%s", parts[2]), "", body, "", "", "abort_run", "runs:write") + default: + writeAPIError(w, http.StatusNotFound, "malformed_request", "unsupported instance route") + } +} + +func (s *Server) handleStepScoped(w http.ResponseWriter, r *http.Request) { + path := strings.TrimPrefix(r.URL.Path, "/api/v2/steps/") + parts := strings.Split(strings.Trim(path, "/"), "/") + if len(parts) == 0 || parts[0] == "" { + writeAPIError(w, http.StatusBadRequest, "malformed_request", "step_id is required") + return + } + instanceID, err := s.store.LookupResourceRoute(r.Context(), "step", parts[0]) + if err != nil { + writeAPIError(w, http.StatusInternalServerError, "relay_internal_error", err.Error()) + return + } + if instanceID == "" { + writeAPIError(w, http.StatusNotFound, "instance_not_found", "step route not found") + return + } + targetPath := fmt.Sprintf("/api/v1/steps/%s", parts[0]) + action := "get_step" + scope := "steps:read" + routeKind := "" + routeIDField := "" + switch { + case len(parts) == 1 && r.Method == http.MethodGet: + case len(parts) == 2 && parts[1] == "result" && r.Method == http.MethodGet: + targetPath += "/result" + action = "get_step_result" + case len(parts) == 2 && parts[1] == "artifacts" && r.Method == http.MethodGet: + targetPath += "/artifacts" + action = "list_step_artifacts" + scope = "artifacts:read" + routeKind = "artifact" + routeIDField = "id" + case len(parts) == 2 && parts[1] == "validations" && r.Method == http.MethodGet: + targetPath += "/validations" + action = "get_step_validations" + case len(parts) == 2 && parts[1] == "wait" && r.Method == http.MethodPost: + targetPath += "/wait" + action = "wait_step" + case len(parts) == 2 && parts[1] == "retry" && r.Method == http.MethodPost: + targetPath += "/retry" + action = "retry_step" + scope = "steps:write" + default: + writeAPIError(w, http.StatusNotFound, "malformed_request", "unsupported step route") + return + } + var body []byte + if r.Body != nil && (r.Method == http.MethodPost || r.Method == http.MethodPatch) { + body, _ = io.ReadAll(r.Body) + } + s.proxyAndWrite(w, r, instanceID, r.Method, targetPath, "", body, routeKind, routeIDField, action, scope) +} + +func (s *Server) handleArtifactScoped(w http.ResponseWriter, r *http.Request) { + path := strings.TrimPrefix(r.URL.Path, "/api/v2/artifacts/") + parts := strings.Split(strings.Trim(path, "/"), "/") + if len(parts) < 2 || parts[1] != "content" || r.Method != http.MethodGet { + writeAPIError(w, http.StatusBadRequest, "malformed_request", "artifact_id/content path required") + return + } + instanceID, err := s.store.LookupResourceRoute(r.Context(), "artifact", parts[0]) + if err != nil { + writeAPIError(w, http.StatusInternalServerError, "relay_internal_error", err.Error()) + return + } + if instanceID == "" { + writeAPIError(w, http.StatusNotFound, "instance_not_found", "artifact route not found") + return + } + s.proxyAndWrite(w, r, instanceID, http.MethodGet, fmt.Sprintf("/api/v1/artifacts/%s/content", parts[0]), "", nil, "", "", "get_artifact_content", "artifacts:read") +} + +func (s *Server) handleGateScoped(w http.ResponseWriter, r *http.Request) { + path := strings.TrimPrefix(r.URL.Path, "/api/v2/gates/") + parts := strings.Split(strings.Trim(path, "/"), "/") + if len(parts) < 2 || r.Method != http.MethodPost { + writeAPIError(w, http.StatusBadRequest, "malformed_request", "gate_id/action path required") + return + } + instanceID, err := s.store.LookupResourceRoute(r.Context(), "gate", parts[0]) + if err != nil { + writeAPIError(w, http.StatusInternalServerError, "relay_internal_error", err.Error()) + return + } + if instanceID == "" { + writeAPIError(w, http.StatusNotFound, "instance_not_found", "gate route not found") + return + } + var action string + switch parts[1] { + case "approve": + action = "approve" + case "reject": + action = "reject" + default: + writeAPIError(w, http.StatusBadRequest, "malformed_request", "unsupported gate action") + return + } + body, _ := json.Marshal(map[string]string{"action": action}) + s.proxyAndWrite(w, r, instanceID, http.MethodPost, fmt.Sprintf("/api/v1/gates/%s", parts[0]), "", body, "", "", "gate_"+action, "gates:write") +} + +func (s *Server) proxyAndWrite(w http.ResponseWriter, r *http.Request, instanceID, method, path, query string, body []byte, routeKind, routeIDField, action, scope string) { + principal := plannerFromContext(r.Context()) + actorID := "" + if principal != nil { + actorID = principal.Name + } + if err := authorizePrincipal(principal, scope, instanceID); err != nil { + s.auditor.Record(r.Context(), AuditEvent{ + ActorType: "planner", + ActorID: actorID, + Action: action, + Method: method, + Scope: scope, + TargetInstanceID: instanceID, + Outcome: "error", + ErrorCode: err.Code, + }) + writeAPIError(w, err.Status, err.Code, err.Message) + return + } + response, resourceRecord, apiErr := s.proxyRequest(r.Context(), instanceID, method, path, query, body, scope) + if apiErr != nil { + s.auditor.Record(r.Context(), AuditEvent{ + ActorType: "planner", + ActorID: actorID, + Action: action, + Method: method, + Scope: scope, + TargetInstanceID: instanceID, + Outcome: "error", + ErrorCode: apiErr.Code, + }) + writeAPIError(w, apiErr.Status, apiErr.Code, apiErr.Message) + return + } + if response.ContentType != "" { + w.Header().Set("Content-Type", response.ContentType) + } + if len(response.Body) > 0 && response.ContentEncoding == "" { + w.Header().Set("Content-Length", fmt.Sprintf("%d", len(response.Body))) + } + w.WriteHeader(response.StatusCode) + payload := decodeRelayBody(response) + if len(payload) > 0 { + _, _ = w.Write(payload) + } + s.captureRoutes(r.Context(), instanceID, routeKind, routeIDField, payload) + s.auditor.Record(r.Context(), AuditEvent{ + ActorType: "planner", + ActorID: actorID, + Action: action, + Method: method, + Scope: scope, + TargetConnectorID: resourceRecord.ConnectorID, + TargetInstanceID: instanceID, + Outcome: "ok", + }) +} + +func (s *Server) proxyRequest(ctx context.Context, instanceID, method, path, query string, body []byte, _ string) (*relayproto.CommandResponse, *InstanceRecord, *apiError) { + record, err := s.store.GetInstance(ctx, instanceID) + if err != nil { + return nil, nil, &apiError{Status: http.StatusInternalServerError, Code: "relay_internal_error", Message: err.Error()} + } + if record == nil { + return nil, nil, &apiError{Status: http.StatusNotFound, Code: "instance_not_found", Message: "instance not found"} + } + session := s.hub.Get(instanceID) + if session == nil { + return nil, record, &apiError{Status: http.StatusServiceUnavailable, Code: "connector_offline", Message: "connector for this instance is offline"} + } + requestID, err := randomID("req") + if err != nil { + return nil, record, &apiError{Status: http.StatusInternalServerError, Code: "relay_internal_error", Message: err.Error()} + } + timeout := 15 * time.Second + requestCtx, cancel := context.WithTimeout(ctx, timeout) + defer cancel() + response, err := session.proxy(requestCtx, relayproto.CommandRequest{ + Type: "request", + RequestID: requestID, + InstanceID: instanceID, + Method: method, + Path: path, + Query: query, + Body: body, + ContentType: contentTypeForBody(body), + TimeoutMs: int(timeout / time.Millisecond), + }) + if err != nil { + if strings.Contains(err.Error(), "timed out") || strings.Contains(err.Error(), "deadline exceeded") { + return nil, record, &apiError{Status: http.StatusGatewayTimeout, Code: "upstream_timeout", Message: err.Error()} + } + return nil, record, &apiError{Status: http.StatusBadGateway, Code: "connector_offline", Message: err.Error()} + } + if response.StatusCode >= 400 { + return nil, record, &apiError{ + Status: translateUpstreamStatus(response.StatusCode), + Code: upstreamErrorCode(response.StatusCode, response.Error), + Message: strings.TrimSpace(response.Error), + } + } + return response, record, nil +} + +func (s *Server) captureRoutes(ctx context.Context, instanceID, kind, idField string, body []byte) { + if kind == "" || idField == "" || len(body) == 0 { + return + } + var single map[string]any + if err := json.Unmarshal(body, &single); err == nil && single[idField] != nil { + if id, ok := single[idField].(string); ok { + _ = s.store.SaveResourceRoute(ctx, kind, id, instanceID) + } + return + } + var many []map[string]any + if err := json.Unmarshal(body, &many); err == nil { + for _, item := range many { + if id, ok := item[idField].(string); ok { + _ = s.store.SaveResourceRoute(ctx, kind, id, instanceID) + } + } + } +} + +func decodeRelayBody(response *relayproto.CommandResponse) []byte { + switch response.ContentEncoding { + case "", "json": + return response.Body + case "utf-8": + var text string + if err := json.Unmarshal(response.Body, &text); err == nil { + return []byte(text) + } + return response.Body + default: + return response.Body + } +} + +func contentTypeForBody(body []byte) string { + if len(body) == 0 { + return "" + } + return "application/json" +} + +func upstreamErrorCode(status int, message string) string { + switch status { + case http.StatusForbidden: + if strings.Contains(strings.ToLower(message), "instance") { + return "instance_not_shared" + } + return "auth_failed" + case http.StatusGatewayTimeout: + return "upstream_timeout" + case http.StatusRequestEntityTooLarge: + return "artifact_too_large" + case http.StatusBadRequest: + return "malformed_request" + case http.StatusNotFound: + return "instance_not_found" + default: + return "upstream_error" + } +} + +func translateUpstreamStatus(status int) int { + switch status { + case 0: + return http.StatusBadGateway + default: + return status + } +} + +func relayBaseURL(r *http.Request) string { + scheme := "http" + if r.TLS != nil { + scheme = "https" + } + return fmt.Sprintf("%s://%s", scheme, r.Host) +} + +func websocketURL(r *http.Request, path string) string { + scheme := "ws" + if r.TLS != nil { + scheme = "wss" + } + return fmt.Sprintf("%s://%s%s", scheme, r.Host, path) +} + +func parseInstanceInfo(raw string) (*domain.InstanceInfo, error) { + if raw == "" { + return nil, nil + } + var info domain.InstanceInfo + if err := json.Unmarshal([]byte(raw), &info); err != nil { + return nil, err + } + return &info, nil +} diff --git a/internal/relay/server.go b/internal/relay/server.go new file mode 100644 index 0000000..8ece480 --- /dev/null +++ b/internal/relay/server.go @@ -0,0 +1,282 @@ +package relay + +import ( + "context" + "encoding/json" + "fmt" + "net/http" + "strings" + "time" + + "agent-bridge/internal/domain" + "agent-bridge/internal/relayproto" + "github.com/gorilla/websocket" +) + +type Server struct { + cfg *Config + store *Store + hub *Hub + server *http.Server + upgrader websocket.Upgrader + enrollment *EnrollmentService + auditor *Auditor + mcp *mcpServer +} + +func NewServer(cfg *Config, store *Store) *Server { + if cfg == nil { + cfg = DefaultConfig() + } + _ = cfg.Validate() + s := &Server{ + cfg: cfg, + store: store, + hub: NewHub(time.Duration(cfg.SessionTTLSeconds) * time.Second), + enrollment: NewEnrollmentService(cfg, store), + auditor: NewAuditor(store), + upgrader: websocket.Upgrader{ + CheckOrigin: func(r *http.Request) bool { return true }, + }, + } + s.mcp = newMCPServer(s) + + mux := http.NewServeMux() + mux.HandleFunc("/api/v2/connectors/enroll", s.handleEnroll) + mux.HandleFunc("/api/v2/connectors/challenge", s.handleChallenge) + mux.HandleFunc("/api/v2/connectors/enrollment-tokens", s.withPlannerScope("connectors:enroll", nil, s.handleEnrollmentTokens)) + mux.HandleFunc("/api/v2/instances", s.withPlannerScope("instances:read", nil, s.handleInstances)) + mux.HandleFunc("/api/v2/instances/", s.withPlannerScope("", relayInstanceIDFromRequest, s.handleInstanceScoped)) + mux.HandleFunc("/api/v2/steps/", s.withPlannerScope("", nil, s.handleStepScoped)) + mux.HandleFunc("/api/v2/artifacts/", s.withPlannerScope("artifacts:read", nil, s.handleArtifactScoped)) + mux.HandleFunc("/api/v2/gates/", s.withPlannerScope("gates:write", nil, s.handleGateScoped)) + mux.HandleFunc("/ws/connectors", s.handleConnectorWebSocket) + mux.HandleFunc("/mcp", s.withPlannerScope("", nil, s.mcp.Handle)) + mux.HandleFunc("/mcp/call", s.withPlannerScope("", nil, s.mcp.Handle)) + + s.server = &http.Server{ + Addr: fmt.Sprintf("%s:%d", cfg.Host, cfg.Port), + Handler: mux, + ReadTimeout: 10 * time.Second, + WriteTimeout: 30 * time.Second, + } + return s +} + +func (s *Server) Start(ctx context.Context) error { + errCh := make(chan error, 1) + go func() { + if err := s.server.ListenAndServe(); err != nil && err != http.ErrServerClosed { + errCh <- err + } + }() + select { + case <-ctx.Done(): + shutdownCtx, cancel := context.WithTimeout(context.Background(), 5*time.Second) + defer cancel() + return s.server.Shutdown(shutdownCtx) + case err := <-errCh: + return err + } +} + +func (s *Server) Handler() http.Handler { + return s.server.Handler +} + +func (s *Server) handleEnroll(w http.ResponseWriter, r *http.Request) { + if r.Method != http.MethodPost { + writeAPIError(w, http.StatusMethodNotAllowed, "method_not_allowed", "method not allowed") + return + } + var request relayproto.EnrollmentRequest + if err := json.NewDecoder(r.Body).Decode(&request); err != nil { + writeAPIError(w, http.StatusBadRequest, "malformed_request", err.Error()) + return + } + response, record, err := s.enrollment.Enroll(r.Context(), request) + if err != nil { + writeAPIError(w, enrollmentErrorStatus(err), "auth_failed", err.Error()) + return + } + response.Relay = relayproto.RelayMetadata{ + RelayURL: relayBaseURL(r), + WebsocketURL: websocketURL(r, "/ws/connectors"), + HeartbeatIntervalSeconds: s.cfg.HeartbeatIntervalSeconds, + } + s.auditor.Record(r.Context(), AuditEvent{ + ActorType: "connector", + Action: "enroll", + ResourceKind: "connector", + ResourceID: record.ConnectorID, + TargetConnectorID: record.ConnectorID, + Outcome: "ok", + }) + writeJSON(w, http.StatusCreated, response) +} + +func (s *Server) handleChallenge(w http.ResponseWriter, r *http.Request) { + if r.Method != http.MethodPost { + writeAPIError(w, http.StatusMethodNotAllowed, "method_not_allowed", "method not allowed") + return + } + var request relayproto.ChallengeRequest + if err := json.NewDecoder(r.Body).Decode(&request); err != nil { + writeAPIError(w, http.StatusBadRequest, "malformed_request", err.Error()) + return + } + challenge, err := s.enrollment.CreateChallenge(r.Context(), request) + if err != nil { + writeAPIError(w, enrollmentErrorStatus(err), "auth_failed", err.Error()) + return + } + writeJSON(w, http.StatusOK, relayproto.ChallengeResponse{ + ChallengeID: challenge.ChallengeID, + Nonce: challenge.Nonce, + Relay: relayproto.RelayMetadata{ + RelayURL: relayBaseURL(r), + WebsocketURL: websocketURL(r, "/ws/connectors"), + HeartbeatIntervalSeconds: s.cfg.HeartbeatIntervalSeconds, + }, + }) +} + +func (s *Server) handleConnectorWebSocket(w http.ResponseWriter, r *http.Request) { + conn, err := s.upgrader.Upgrade(w, r, nil) + if err != nil { + return + } + defer conn.Close() + + var hello relayproto.HelloMessage + if err := conn.ReadJSON(&hello); err != nil { + _ = conn.WriteJSON(relayproto.ErrorMessage{Type: "error", Code: "malformed_request", Message: err.Error()}) + return + } + if hello.Type != "hello" { + _ = conn.WriteJSON(relayproto.ErrorMessage{Type: "error", Code: "auth_failed", Message: "hello message required"}) + return + } + record, err := s.enrollment.VerifyHello(r.Context(), hello) + if err != nil { + _ = conn.WriteJSON(relayproto.ErrorMessage{Type: "error", Code: "auth_failed", Message: err.Error()}) + s.auditor.Record(r.Context(), AuditEvent{ + ActorType: "connector", + Action: "session_connect", + ResourceKind: "connector", + ResourceID: hello.ConnectorID, + TargetConnectorID: hello.ConnectorID, + Outcome: "error", + ErrorCode: "auth_failed", + }) + return + } + + session := &session{ + conn: conn, + connectorID: hello.ConnectorID, + machineID: hello.MachineID, + instanceIDs: make(map[string]struct{}), + pending: make(map[string]chan relayproto.CommandResponse), + lastSeenAt: time.Now().UTC(), + } + s.hub.RegisterConnector(session) + s.auditor.Record(r.Context(), AuditEvent{ + ActorType: "connector", + Action: "session_connect", + ResourceKind: "connector", + ResourceID: record.ConnectorID, + TargetConnectorID: record.ConnectorID, + Outcome: "ok", + }) + defer s.hub.RemoveSession(session) + + for { + _, message, err := conn.ReadMessage() + if err != nil { + return + } + var envelope struct { + Type string `json:"type"` + } + if err := json.Unmarshal(message, &envelope); err != nil { + _ = conn.WriteJSON(relayproto.ErrorMessage{Type: "error", Code: "malformed_request", Message: err.Error()}) + return + } + switch envelope.Type { + case "advertise": + if err := s.handleAdvertise(r.Context(), session, message); err != nil { + _ = conn.WriteJSON(relayproto.ErrorMessage{Type: "error", Code: "malformed_request", Message: err.Error()}) + return + } + case "heartbeat": + s.handleHeartbeat(r.Context(), session, message) + case "response": + if err := session.handleMessage(message); err != nil { + _ = conn.WriteJSON(relayproto.ErrorMessage{Type: "error", Code: "malformed_request", Message: err.Error()}) + return + } + case "error": + return + default: + _ = conn.WriteJSON(relayproto.ErrorMessage{Type: "error", Code: "malformed_request", Message: "unsupported session message"}) + return + } + } +} + +func (s *Server) handleAdvertise(ctx context.Context, session *session, message []byte) error { + var advertise relayproto.AdvertiseMessage + if err := json.Unmarshal(message, &advertise); err != nil { + return err + } + s.hub.Touch(session) + next := make(map[string]struct{}) + for _, advertised := range advertise.Instances { + var info domain.InstanceInfo + if err := json.Unmarshal(advertised.Instance, &info); err != nil { + return err + } + record := InstanceRecord{ + InstanceID: info.ID, + ConnectorID: session.connectorID, + RepoRoot: info.RepoRoot, + BaseURL: info.BaseURL, + InstanceJSON: string(advertised.Instance), + LastSeenAt: time.Now().UTC(), + } + if err := s.store.SaveInstance(ctx, record); err != nil { + return err + } + s.hub.Register(info.ID, session) + next[info.ID] = struct{}{} + } + for instanceID := range session.instanceIDs { + if _, ok := next[instanceID]; !ok { + s.hub.Remove(instanceID) + } + } + session.instanceIDs = next + return nil +} + +func (s *Server) handleHeartbeat(ctx context.Context, session *session, message []byte) { + var heartbeat relayproto.HeartbeatMessage + if err := json.Unmarshal(message, &heartbeat); err != nil { + return + } + s.hub.Touch(session) + _ = s.store.MarkConnectorSeen(ctx, session.connectorID, time.Now().UTC()) + for _, instanceID := range heartbeat.InstanceIDs { + _ = s.store.TouchInstance(ctx, instanceID) + } +} + +func relayInstanceIDFromRequest(r *http.Request) string { + path := strings.TrimPrefix(r.URL.Path, "/api/v2/instances/") + parts := strings.Split(strings.Trim(path, "/"), "/") + if len(parts) == 0 { + return "" + } + return parts[0] +} diff --git a/internal/relay/session_hub.go b/internal/relay/session_hub.go new file mode 100644 index 0000000..a0cacd9 --- /dev/null +++ b/internal/relay/session_hub.go @@ -0,0 +1,16 @@ +package relay + +type InstanceStatus struct { + Online bool `json:"online"` + Status string `json:"status"` +} + +func (s *Server) instanceStatus(record *InstanceRecord) InstanceStatus { + if record == nil { + return InstanceStatus{Online: false, Status: "not_found"} + } + if s.hub.Get(record.InstanceID) != nil { + return InstanceStatus{Online: true, Status: "online"} + } + return InstanceStatus{Online: false, Status: "offline"} +} diff --git a/internal/relay/session_hub_test.go b/internal/relay/session_hub_test.go new file mode 100644 index 0000000..7f1469a --- /dev/null +++ b/internal/relay/session_hub_test.go @@ -0,0 +1,29 @@ +package relay + +import ( + "testing" + "time" + + "agent-bridge/internal/relayproto" +) + +func TestHubExpiresStaleSessions(t *testing.T) { + hub := NewHub(10 * time.Millisecond) + session := &session{ + connectorID: "connector-1", + instanceIDs: map[string]struct{}{"inst-1": {}}, + pending: make(map[string]chan relayproto.CommandResponse), + lastSeenAt: time.Now().UTC().Add(-time.Second), + } + hub.RegisterConnector(session) + hub.Register("inst-1", session) + + time.Sleep(15 * time.Millisecond) + + if got := hub.Get("inst-1"); got != nil { + t.Fatalf("expected stale instance session to expire, got %+v", got) + } + if got := hub.Connector("connector-1"); got != nil { + t.Fatalf("expected stale connector session to expire, got %+v", got) + } +} diff --git a/internal/relay/store.go b/internal/relay/store.go new file mode 100644 index 0000000..6cc3305 --- /dev/null +++ b/internal/relay/store.go @@ -0,0 +1,14 @@ +package relay + +import relaystore "agent-bridge/internal/relay/store" + +type Store = relaystore.Store +type InstanceRecord = relaystore.InstanceRecord +type ConnectorRecord = relaystore.ConnectorRecord +type EnrollmentTokenRecord = relaystore.EnrollmentTokenRecord +type ChallengeRecord = relaystore.ChallengeRecord +type AuditEvent = relaystore.AuditEvent + +func OpenStore(path string) (*Store, error) { + return relaystore.Open(path) +} diff --git a/internal/relay/store/store.go b/internal/relay/store/store.go new file mode 100644 index 0000000..5a54af4 --- /dev/null +++ b/internal/relay/store/store.go @@ -0,0 +1,531 @@ +package relaystore + +import ( + "context" + "crypto/rand" + "crypto/sha256" + "database/sql" + "encoding/hex" + "fmt" + "os" + "path/filepath" + "time" + + _ "github.com/mattn/go-sqlite3" +) + +type Store struct { + db *sql.DB +} + +type InstanceRecord struct { + InstanceID string `json:"instance_id"` + ConnectorID string `json:"connector_id"` + RepoRoot string `json:"repo_root"` + BaseURL string `json:"base_url"` + InstanceJSON string `json:"instance_json,omitempty"` + LastSeenAt time.Time `json:"last_seen_at"` +} + +type ConnectorRecord struct { + ConnectorID string + MachineID string + PublicKey string + Label string + MachineMetadataJSON string + Disabled bool + CreatedAt time.Time + UpdatedAt time.Time + LastSeenAt time.Time +} + +type EnrollmentTokenRecord struct { + TokenID string + TokenHash string + Label string + CreatedBy string + CreatedAt time.Time + ExpiresAt *time.Time + ConsumedAt *time.Time + ConnectorID string +} + +type ChallengeRecord struct { + ChallengeID string + ConnectorID string + MachineID string + Nonce string + CreatedAt time.Time + ExpiresAt time.Time +} + +type AuditEvent struct { + ID int64 `json:"id"` + ActorType string `json:"actor_type"` + ActorID string `json:"actor_id,omitempty"` + Action string `json:"action"` + Method string `json:"method,omitempty"` + Scope string `json:"scope,omitempty"` + ResourceKind string `json:"resource_kind,omitempty"` + ResourceID string `json:"resource_id,omitempty"` + TargetConnectorID string `json:"target_connector_id,omitempty"` + TargetInstanceID string `json:"target_instance_id,omitempty"` + Outcome string `json:"outcome"` + ErrorCode string `json:"error_code,omitempty"` + Details string `json:"details,omitempty"` + CreatedAt time.Time `json:"created_at"` +} + +func Open(path string) (*Store, error) { + if err := os.MkdirAll(filepath.Dir(path), 0755); err != nil { + return nil, err + } + db, err := sql.Open("sqlite3", path+"?_journal=WAL&_busy_timeout=5000") + if err != nil { + return nil, err + } + store := &Store{db: db} + if err := store.migrate(); err != nil { + _ = db.Close() + return nil, err + } + return store, nil +} + +func (s *Store) Close() error { return s.db.Close() } + +func (s *Store) migrate() error { + schema := ` +CREATE TABLE IF NOT EXISTS connectors ( + connector_id TEXT PRIMARY KEY, + machine_id TEXT NOT NULL, + public_key TEXT NOT NULL, + label TEXT, + machine_metadata_json TEXT, + disabled INTEGER NOT NULL DEFAULT 0, + created_at DATETIME NOT NULL, + updated_at DATETIME NOT NULL, + last_seen_at DATETIME +); +CREATE TABLE IF NOT EXISTS enrollment_tokens ( + token_id TEXT PRIMARY KEY, + token_hash TEXT NOT NULL UNIQUE, + label TEXT, + created_by TEXT, + created_at DATETIME NOT NULL, + expires_at DATETIME, + consumed_at DATETIME, + connector_id TEXT +); +CREATE TABLE IF NOT EXISTS connector_challenges ( + challenge_id TEXT PRIMARY KEY, + connector_id TEXT NOT NULL, + machine_id TEXT NOT NULL, + nonce TEXT NOT NULL, + created_at DATETIME NOT NULL, + expires_at DATETIME NOT NULL +); +CREATE TABLE IF NOT EXISTS instances ( + instance_id TEXT PRIMARY KEY, + connector_id TEXT NOT NULL, + repo_root TEXT NOT NULL, + base_url TEXT NOT NULL, + instance_json TEXT, + last_seen_at DATETIME NOT NULL +); +CREATE TABLE IF NOT EXISTS resource_routes ( + resource_kind TEXT NOT NULL, + resource_id TEXT NOT NULL, + instance_id TEXT NOT NULL, + updated_at DATETIME NOT NULL, + PRIMARY KEY (resource_kind, resource_id) +); +CREATE TABLE IF NOT EXISTS audit_events ( + id INTEGER PRIMARY KEY AUTOINCREMENT, + actor_type TEXT NOT NULL, + actor_id TEXT, + action TEXT NOT NULL, + method TEXT, + scope TEXT, + resource_kind TEXT, + resource_id TEXT, + target_connector_id TEXT, + target_instance_id TEXT, + outcome TEXT NOT NULL, + error_code TEXT, + details TEXT, + created_at DATETIME NOT NULL +);` + if _, err := s.db.Exec(schema); err != nil { + return err + } + extras := []string{ + "ALTER TABLE connectors ADD COLUMN machine_id TEXT", + "ALTER TABLE connectors ADD COLUMN public_key TEXT", + "ALTER TABLE connectors ADD COLUMN label TEXT", + "ALTER TABLE connectors ADD COLUMN machine_metadata_json TEXT", + "ALTER TABLE connectors ADD COLUMN disabled INTEGER NOT NULL DEFAULT 0", + "ALTER TABLE connectors ADD COLUMN updated_at DATETIME", + "ALTER TABLE connectors ADD COLUMN last_seen_at DATETIME", + "ALTER TABLE instances ADD COLUMN instance_json TEXT", + "ALTER TABLE audit_events ADD COLUMN actor_type TEXT", + "ALTER TABLE audit_events ADD COLUMN actor_id TEXT", + "ALTER TABLE audit_events ADD COLUMN method TEXT", + "ALTER TABLE audit_events ADD COLUMN scope TEXT", + "ALTER TABLE audit_events ADD COLUMN target_connector_id TEXT", + "ALTER TABLE audit_events ADD COLUMN target_instance_id TEXT", + "ALTER TABLE audit_events ADD COLUMN outcome TEXT", + "ALTER TABLE audit_events ADD COLUMN error_code TEXT", + } + for _, stmt := range extras { + _, _ = s.db.Exec(stmt) + } + return nil +} + +func (s *Store) SaveConnector(ctx context.Context, connectorID, machineID, publicKey, label string) error { + return s.SaveConnectorRecord(ctx, ConnectorRecord{ + ConnectorID: connectorID, + MachineID: machineID, + PublicKey: publicKey, + Label: label, + }) +} + +func (s *Store) SaveConnectorRecord(ctx context.Context, record ConnectorRecord) error { + now := time.Now().UTC() + if record.CreatedAt.IsZero() { + record.CreatedAt = now + } + record.UpdatedAt = now + _, err := s.db.ExecContext(ctx, ` + INSERT INTO connectors (connector_id, machine_id, public_key, label, machine_metadata_json, disabled, created_at, updated_at, last_seen_at) + VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?) + ON CONFLICT(connector_id) DO UPDATE SET + machine_id = excluded.machine_id, + public_key = excluded.public_key, + label = excluded.label, + machine_metadata_json = excluded.machine_metadata_json, + disabled = excluded.disabled, + updated_at = excluded.updated_at, + last_seen_at = excluded.last_seen_at + `, record.ConnectorID, record.MachineID, record.PublicKey, record.Label, record.MachineMetadataJSON, boolToInt(record.Disabled), record.CreatedAt, record.UpdatedAt, nullTime(record.LastSeenAt)) + return err +} + +func (s *Store) GetConnector(ctx context.Context, connectorID string) (*ConnectorRecord, error) { + record := &ConnectorRecord{} + var disabled int + var lastSeen sql.NullTime + if err := s.db.QueryRowContext(ctx, ` + SELECT connector_id, machine_id, public_key, label, machine_metadata_json, disabled, created_at, updated_at, last_seen_at + FROM connectors WHERE connector_id = ? + `, connectorID).Scan( + &record.ConnectorID, + &record.MachineID, + &record.PublicKey, + &record.Label, + &record.MachineMetadataJSON, + &disabled, + &record.CreatedAt, + &record.UpdatedAt, + &lastSeen, + ); err != nil { + if err == sql.ErrNoRows { + return nil, nil + } + return nil, err + } + record.Disabled = disabled != 0 + if lastSeen.Valid { + record.LastSeenAt = lastSeen.Time + } + return record, nil +} + +func (s *Store) MarkConnectorSeen(ctx context.Context, connectorID string, seenAt time.Time) error { + _, err := s.db.ExecContext(ctx, `UPDATE connectors SET last_seen_at = ?, updated_at = ? WHERE connector_id = ?`, seenAt.UTC(), time.Now().UTC(), connectorID) + return err +} + +func (s *Store) SetConnectorDisabled(ctx context.Context, connectorID string, disabled bool) error { + _, err := s.db.ExecContext(ctx, `UPDATE connectors SET disabled = ?, updated_at = ? WHERE connector_id = ?`, boolToInt(disabled), time.Now().UTC(), connectorID) + return err +} + +func (s *Store) CreateEnrollmentToken(ctx context.Context, label, createdBy string, expiresAt *time.Time) (*EnrollmentTokenRecord, string, error) { + tokenID, err := randomID("enroll") + if err != nil { + return nil, "", err + } + secret, err := randomID("secret") + if err != nil { + return nil, "", err + } + record := &EnrollmentTokenRecord{ + TokenID: tokenID, + TokenHash: hashSecret(secret), + Label: label, + CreatedBy: createdBy, + CreatedAt: time.Now().UTC(), + ExpiresAt: expiresAt, + } + _, err = s.db.ExecContext(ctx, ` + INSERT INTO enrollment_tokens (token_id, token_hash, label, created_by, created_at, expires_at) + VALUES (?, ?, ?, ?, ?, ?) + `, record.TokenID, record.TokenHash, record.Label, record.CreatedBy, record.CreatedAt, nullableTime(record.ExpiresAt)) + if err != nil { + return nil, "", err + } + return record, secret, nil +} + +func (s *Store) ConsumeEnrollmentToken(ctx context.Context, secret, connectorID string) (*EnrollmentTokenRecord, error) { + hash := hashSecret(secret) + tx, err := s.db.BeginTx(ctx, nil) + if err != nil { + return nil, err + } + defer func() { + if err != nil { + _ = tx.Rollback() + } + }() + + record := &EnrollmentTokenRecord{} + var expiresAt sql.NullTime + var consumedAt sql.NullTime + var existingConnectorID sql.NullString + queryErr := tx.QueryRowContext(ctx, ` + SELECT token_id, token_hash, label, created_by, created_at, expires_at, consumed_at, connector_id + FROM enrollment_tokens WHERE token_hash = ? + `, hash).Scan(&record.TokenID, &record.TokenHash, &record.Label, &record.CreatedBy, &record.CreatedAt, &expiresAt, &consumedAt, &existingConnectorID) + if queryErr != nil { + if queryErr == sql.ErrNoRows { + err = fmt.Errorf("invalid enrollment token") + return nil, err + } + err = queryErr + return nil, err + } + if expiresAt.Valid { + record.ExpiresAt = &expiresAt.Time + if time.Now().UTC().After(expiresAt.Time) { + err = fmt.Errorf("enrollment token expired") + return nil, err + } + } + if consumedAt.Valid { + record.ConsumedAt = &consumedAt.Time + err = fmt.Errorf("enrollment token already used") + return nil, err + } + if existingConnectorID.Valid { + record.ConnectorID = existingConnectorID.String + } + now := time.Now().UTC() + record.ConsumedAt = &now + record.ConnectorID = connectorID + if _, execErr := tx.ExecContext(ctx, `UPDATE enrollment_tokens SET consumed_at = ?, connector_id = ? WHERE token_id = ?`, now, connectorID, record.TokenID); execErr != nil { + err = execErr + return nil, err + } + err = tx.Commit() + return record, err +} + +func (s *Store) SaveChallenge(ctx context.Context, record ChallengeRecord) error { + _, err := s.db.ExecContext(ctx, ` + INSERT INTO connector_challenges (challenge_id, connector_id, machine_id, nonce, created_at, expires_at) + VALUES (?, ?, ?, ?, ?, ?) + ON CONFLICT(challenge_id) DO UPDATE SET connector_id = excluded.connector_id, machine_id = excluded.machine_id, nonce = excluded.nonce, created_at = excluded.created_at, expires_at = excluded.expires_at + `, record.ChallengeID, record.ConnectorID, record.MachineID, record.Nonce, record.CreatedAt, record.ExpiresAt) + return err +} + +func (s *Store) ConsumeChallenge(ctx context.Context, challengeID string) (*ChallengeRecord, error) { + tx, err := s.db.BeginTx(ctx, nil) + if err != nil { + return nil, err + } + defer func() { + if err != nil { + _ = tx.Rollback() + } + }() + record := &ChallengeRecord{} + queryErr := tx.QueryRowContext(ctx, ` + SELECT challenge_id, connector_id, machine_id, nonce, created_at, expires_at + FROM connector_challenges WHERE challenge_id = ? + `, challengeID).Scan(&record.ChallengeID, &record.ConnectorID, &record.MachineID, &record.Nonce, &record.CreatedAt, &record.ExpiresAt) + if queryErr != nil { + if queryErr == sql.ErrNoRows { + err = nil + return nil, nil + } + err = queryErr + return nil, err + } + if _, execErr := tx.ExecContext(ctx, `DELETE FROM connector_challenges WHERE challenge_id = ?`, challengeID); execErr != nil { + err = execErr + return nil, err + } + err = tx.Commit() + return record, err +} + +func (s *Store) SaveInstance(ctx context.Context, record InstanceRecord) error { + if record.LastSeenAt.IsZero() { + record.LastSeenAt = time.Now().UTC() + } + _, err := s.db.ExecContext(ctx, ` + INSERT INTO instances (instance_id, connector_id, repo_root, base_url, instance_json, last_seen_at) + VALUES (?, ?, ?, ?, ?, ?) + ON CONFLICT(instance_id) DO UPDATE SET + connector_id = excluded.connector_id, + repo_root = excluded.repo_root, + base_url = excluded.base_url, + instance_json = excluded.instance_json, + last_seen_at = excluded.last_seen_at + `, record.InstanceID, record.ConnectorID, record.RepoRoot, record.BaseURL, record.InstanceJSON, record.LastSeenAt.UTC()) + return err +} + +func (s *Store) GetInstance(ctx context.Context, instanceID string) (*InstanceRecord, error) { + record := &InstanceRecord{} + if err := s.db.QueryRowContext(ctx, ` + SELECT instance_id, connector_id, repo_root, base_url, instance_json, last_seen_at + FROM instances WHERE instance_id = ? + `, instanceID).Scan(&record.InstanceID, &record.ConnectorID, &record.RepoRoot, &record.BaseURL, &record.InstanceJSON, &record.LastSeenAt); err != nil { + if err == sql.ErrNoRows { + return nil, nil + } + return nil, err + } + return record, nil +} + +func (s *Store) TouchInstance(ctx context.Context, instanceID string, touchedAt ...time.Time) error { + now := time.Now().UTC() + if len(touchedAt) > 0 && !touchedAt[0].IsZero() { + now = touchedAt[0].UTC() + } + _, err := s.db.ExecContext(ctx, `UPDATE instances SET last_seen_at = ? WHERE instance_id = ?`, now, instanceID) + return err +} + +func (s *Store) ListInstances(ctx context.Context) ([]InstanceRecord, error) { + rows, err := s.db.QueryContext(ctx, ` + SELECT instance_id, connector_id, repo_root, base_url, instance_json, last_seen_at + FROM instances + ORDER BY instance_id + `) + if err != nil { + return nil, err + } + defer rows.Close() + var records []InstanceRecord + for rows.Next() { + var record InstanceRecord + if err := rows.Scan(&record.InstanceID, &record.ConnectorID, &record.RepoRoot, &record.BaseURL, &record.InstanceJSON, &record.LastSeenAt); err != nil { + return nil, err + } + records = append(records, record) + } + return records, rows.Err() +} + +func (s *Store) SaveResourceRoute(ctx context.Context, kind, id, instanceID string) error { + if kind == "" || id == "" || instanceID == "" { + return nil + } + _, err := s.db.ExecContext(ctx, ` + INSERT INTO resource_routes (resource_kind, resource_id, instance_id, updated_at) + VALUES (?, ?, ?, ?) + ON CONFLICT(resource_kind, resource_id) DO UPDATE SET instance_id = excluded.instance_id, updated_at = excluded.updated_at + `, kind, id, instanceID, time.Now().UTC()) + return err +} + +func (s *Store) LookupResourceRoute(ctx context.Context, kind, id string) (string, error) { + var instanceID string + if err := s.db.QueryRowContext(ctx, `SELECT instance_id FROM resource_routes WHERE resource_kind = ? AND resource_id = ?`, kind, id).Scan(&instanceID); err != nil { + if err == sql.ErrNoRows { + return "", nil + } + return "", err + } + return instanceID, nil +} + +func (s *Store) AppendAudit(ctx context.Context, event AuditEvent) error { + if event.CreatedAt.IsZero() { + event.CreatedAt = time.Now().UTC() + } + if event.Outcome == "" { + event.Outcome = "ok" + } + _, err := s.db.ExecContext(ctx, ` + INSERT INTO audit_events ( + actor_type, actor_id, action, method, scope, resource_kind, resource_id, + target_connector_id, target_instance_id, outcome, error_code, details, created_at + ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) + `, event.ActorType, event.ActorID, event.Action, event.Method, event.Scope, event.ResourceKind, event.ResourceID, event.TargetConnectorID, event.TargetInstanceID, event.Outcome, event.ErrorCode, event.Details, event.CreatedAt) + return err +} + +func (s *Store) ListAuditEvents(ctx context.Context) ([]AuditEvent, error) { + rows, err := s.db.QueryContext(ctx, ` + SELECT id, actor_type, actor_id, action, method, scope, resource_kind, resource_id, + target_connector_id, target_instance_id, outcome, error_code, details, created_at + FROM audit_events + ORDER BY id + `) + if err != nil { + return nil, err + } + defer rows.Close() + var events []AuditEvent + for rows.Next() { + var event AuditEvent + if err := rows.Scan(&event.ID, &event.ActorType, &event.ActorID, &event.Action, &event.Method, &event.Scope, &event.ResourceKind, &event.ResourceID, &event.TargetConnectorID, &event.TargetInstanceID, &event.Outcome, &event.ErrorCode, &event.Details, &event.CreatedAt); err != nil { + return nil, err + } + events = append(events, event) + } + return events, rows.Err() +} + +func hashSecret(secret string) string { + sum := sha256.Sum256([]byte(secret)) + return hex.EncodeToString(sum[:]) +} + +func randomID(prefix string) (string, error) { + buf := make([]byte, 16) + if _, err := rand.Read(buf); err != nil { + return "", err + } + return fmt.Sprintf("%s-%s", prefix, hex.EncodeToString(buf)), nil +} + +func nullableTime(value *time.Time) any { + if value == nil || value.IsZero() { + return nil + } + return value.UTC() +} + +func nullTime(value time.Time) any { + if value.IsZero() { + return nil + } + return value.UTC() +} + +func boolToInt(value bool) int { + if value { + return 1 + } + return 0 +} diff --git a/internal/relayproto/types.go b/internal/relayproto/types.go new file mode 100644 index 0000000..b17d57e --- /dev/null +++ b/internal/relayproto/types.go @@ -0,0 +1,99 @@ +package relayproto + +import "encoding/json" + +type MachineMetadata struct { + Hostname string `json:"hostname"` + OS string `json:"os"` + Arch string `json:"arch"` +} + +// EnrollmentRequest exchanges a one-time enrollment token for connector identity assignment. +type EnrollmentRequest struct { + EnrollmentToken string `json:"enrollment_token,omitempty"` + EnrollmentSecret string `json:"enrollment_secret,omitempty"` + Label string `json:"label,omitempty"` + PublicKey string `json:"public_key"` + Machine MachineMetadata `json:"machine"` +} + +type RelayMetadata struct { + RelayURL string `json:"relay_url,omitempty"` + WebsocketURL string `json:"websocket_url,omitempty"` + HeartbeatIntervalSeconds int `json:"heartbeat_interval_seconds"` +} + +// EnrollmentResponse returns the issued connector and machine identities plus relay metadata. +type EnrollmentResponse struct { + ConnectorID string `json:"connector_id"` + MachineID string `json:"machine_id"` + Relay RelayMetadata `json:"relay"` +} + +type ChallengeRequest struct { + ConnectorID string `json:"connector_id"` + MachineID string `json:"machine_id"` +} + +type ChallengeResponse struct { + ChallengeID string `json:"challenge_id"` + Nonce string `json:"nonce"` + Relay RelayMetadata `json:"relay"` +} + +type HelloMessage struct { + Type string `json:"type"` + ConnectorID string `json:"connector_id"` + MachineID string `json:"machine_id"` + ChallengeID string `json:"challenge_id"` + Signature string `json:"signature"` +} + +type InstanceAdvertisement struct { + Instance json.RawMessage `json:"instance"` +} + +type AdvertiseMessage struct { + Type string `json:"type"` + Instances []InstanceAdvertisement `json:"instances"` +} + +type HeartbeatMessage struct { + Type string `json:"type"` + ConnectorID string `json:"connector_id"` + MachineID string `json:"machine_id"` + InstanceIDs []string `json:"instance_ids,omitempty"` + SentAt string `json:"sent_at"` +} + +// CommandRequest is a relay-to-connector proxy request. +type CommandRequest struct { + Type string `json:"type"` + RequestID string `json:"request_id"` + InstanceID string `json:"instance_id"` + Method string `json:"method"` + Path string `json:"path"` + Query string `json:"query,omitempty"` + ContentType string `json:"content_type,omitempty"` + ContentEncoding string `json:"content_encoding,omitempty"` + Body json.RawMessage `json:"body,omitempty"` + TimeoutMs int `json:"timeout_ms,omitempty"` +} + +// CommandResponse is a connector-to-relay proxy response. +type CommandResponse struct { + Type string `json:"type"` + RequestID string `json:"request_id"` + StatusCode int `json:"status_code"` + ContentType string `json:"content_type,omitempty"` + ContentEncoding string `json:"content_encoding,omitempty"` + Body json.RawMessage `json:"body,omitempty"` + Error string `json:"error,omitempty"` +} + +type ErrorMessage struct { + Type string `json:"type"` + RequestID string `json:"request_id,omitempty"` + Code string `json:"code"` + Message string `json:"message"` +} diff --git a/internal/service/antigravity_service.go b/internal/service/antigravity_service.go index 85316e1..6cccd2a 100644 --- a/internal/service/antigravity_service.go +++ b/internal/service/antigravity_service.go @@ -57,6 +57,27 @@ func (s *AntigravityService) isBrokerEnabled() bool { return s.brokerURL != "" } +func (s *AntigravityService) BrokerEnabled() bool { + return s.isBrokerEnabled() +} + +func (s *AntigravityService) BrokerInfo(ctx context.Context) (domain.InstanceBrokerInfo, error) { + info := domain.InstanceBrokerInfo{ + Enabled: s.isBrokerEnabled(), + Mode: "direct", + URL: s.brokerURL, + } + if s.isBrokerEnabled() { + info.Mode = "broker" + } + bound, err := s.GetBinding(ctx) + if err != nil { + return info, err + } + info.BoundInstance = bound + return info, nil +} + // ListInstances returns all discovered Antigravity instances. func (s *AntigravityService) ListInstances(ctx context.Context) ([]domain.AGInstance, error) { if s.isBrokerEnabled() { @@ -123,7 +144,7 @@ func (s *AntigravityService) GetBinding(ctx context.Context) (*domain.AGInstance if resp.StatusCode == http.StatusNotFound { return nil, nil } - + var inst domain.AGInstance if err := json.NewDecoder(resp.Body).Decode(&inst); err != nil { return nil, nil // Assume unbound if JSON is malformed or "unbound" status diff --git a/internal/service/broker_integration_test.go b/internal/service/broker_integration_test.go index 79bbc0a..ed72d6e 100644 --- a/internal/service/broker_integration_test.go +++ b/internal/service/broker_integration_test.go @@ -23,6 +23,11 @@ func TestRunService_BrokerDispatch_WorkspaceWorktreePrecedence(t *testing.T) { // 1. Setup Mock Broker var receivedRepoRoot, receivedWorkspaceRoot string mockBroker := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + if strings.HasSuffix(r.URL.Path, "/result") && r.Method == "GET" { + w.WriteHeader(http.StatusOK) + w.Write([]byte(`{"steps":[{"items":[{"message":{"text":"Success!"}}]}]}`)) + return + } if r.URL.Path == "/tasks" && r.Method == "POST" { var b struct { Prompt string `json:"prompt"` @@ -41,11 +46,6 @@ func TestRunService_BrokerDispatch_WorkspaceWorktreePrecedence(t *testing.T) { w.Write([]byte(`{"id":"broker-task-123", "state":"completed", "summary":"Mock success"}`)) return } - if strings.HasSuffix(r.URL.Path, "/result") && r.Method == "GET" { - w.WriteHeader(http.StatusOK) - w.Write([]byte(`{"steps":[{"items":[{"message":{"text":"Success!"}}]}]}`)) - return - } w.WriteHeader(http.StatusNotFound) })) defer mockBroker.Close() diff --git a/internal/service/e2e_test.go b/internal/service/e2e_test.go index ac56448..3a1c42a 100644 --- a/internal/service/e2e_test.go +++ b/internal/service/e2e_test.go @@ -62,7 +62,7 @@ func TestE2EFlow(t *testing.T) { artifactRoot, workspaceRoot, ) - gateSvc := service.NewGateService(gatesRepo, runsRepo) + gateSvc := service.NewGateService(gatesRepo, runsRepo, stepsRepo, attemptsRepo) ctx := context.Background() @@ -117,8 +117,8 @@ func TestE2EFlow(t *testing.T) { // Recheck run state run, _ := runSvc.GetRun(ctx, runId) - if run.State != domain.RunStateRunning { - t.Fatalf("Expected run state Running after approval, got %s", run.State) + if run.State != domain.RunStateCompleted { + t.Fatalf("Expected run state Completed after approval, got %s", run.State) } t.Log("Orchestrator Lifecycle Simulation Passed!") diff --git a/internal/service/gate_service.go b/internal/service/gate_service.go index 0841391..791aff3 100644 --- a/internal/service/gate_service.go +++ b/internal/service/gate_service.go @@ -11,12 +11,14 @@ import ( // GateService handles the approval and rejection lifecycle of gates. type GateService struct { - repo *sqlite.GatesRepo - runsRepo *sqlite.RunsRepo + repo *sqlite.GatesRepo + runsRepo *sqlite.RunsRepo + stepsRepo *sqlite.StepsRepo + attemptsRepo *sqlite.AttemptsRepo } -func NewGateService(repo *sqlite.GatesRepo, runsRepo *sqlite.RunsRepo) *GateService { - return &GateService{repo: repo, runsRepo: runsRepo} +func NewGateService(repo *sqlite.GatesRepo, runsRepo *sqlite.RunsRepo, stepsRepo *sqlite.StepsRepo, attemptsRepo *sqlite.AttemptsRepo) *GateService { + return &GateService{repo: repo, runsRepo: runsRepo, stepsRepo: stepsRepo, attemptsRepo: attemptsRepo} } // Approve unlocks a paused run and transitions it back to running. @@ -45,17 +47,53 @@ func (s *GateService) resolve(ctx context.Context, gateID string, state domain.G return err } - // Update associated run state + step, err := s.stepsRepo.Get(ctx, gate.StepID) + if err != nil { + return err + } + if step == nil { + return fmt.Errorf("step %s for gate %s not found", gate.StepID, gateID) + } + + switch state { + case domain.GateStateApproved: + latestAttempt, err := s.attemptsRepo.GetLatestByStep(ctx, gate.StepID) + if err != nil { + return err + } + if latestAttempt == nil || latestAttempt.Result == nil { + step.State = domain.StepStateNeedsManualAttention + step.StatusReason = "Gate approved, but no terminal attempt result was available to restore step state." + } else { + step.State = latestAttempt.Result.State + if latestAttempt.Result.State == domain.StepStateCancelled { + step.StatusReason = "Gate approved after a cancelled attempt; manual retry may be required." + } else { + step.StatusReason = latestAttempt.Result.Summary + } + } + case domain.GateStateRejected: + step.State = domain.StepStateCancelled + step.StatusReason = "Gate rejected by operator." + } + step.UpdatedAt = time.Now().UTC() + if err := s.stepsRepo.UpdateState(ctx, step); err != nil { + return err + } + run, err := s.runsRepo.Get(ctx, gate.RunID) - if err != nil || run == nil { - return fmt.Errorf("failed to fetch associated run: %w", err) + if err != nil { + return err + } + if run == nil { + return fmt.Errorf("run %s for gate %s not found", gate.RunID, gateID) } - if state == domain.GateStateApproved { - run.State = domain.RunStateRunning - } else { - run.State = domain.RunStateCancelled + steps, err := s.stepsRepo.ListByRun(ctx, gate.RunID) + if err != nil { + return err } + run.State = deriveRunState(steps) run.UpdatedAt = time.Now().UTC() return s.runsRepo.UpdateState(ctx, run) diff --git a/internal/service/gate_service_test.go b/internal/service/gate_service_test.go new file mode 100644 index 0000000..a863430 --- /dev/null +++ b/internal/service/gate_service_test.go @@ -0,0 +1,123 @@ +package service_test + +import ( + "context" + "database/sql" + "path/filepath" + "testing" + "time" + + "agent-bridge/internal/domain" + "agent-bridge/internal/service" + "agent-bridge/internal/storage/sqlite" + _ "github.com/mattn/go-sqlite3" +) + +func TestGateService_ApproveAndRejectLifecycle(t *testing.T) { + dbPath := filepath.Join(t.TempDir(), "test.db") + db, err := sql.Open("sqlite3", dbPath) + if err != nil { + t.Fatal(err) + } + defer db.Close() + if err := sqlite.RunMigrations(db); err != nil { + t.Fatal(err) + } + + ctx := context.Background() + runsRepo := sqlite.NewRunsRepo(db) + phasesRepo := sqlite.NewPhasesRepo(db) + stepsRepo := sqlite.NewStepsRepo(db) + attemptsRepo := sqlite.NewAttemptsRepo(db) + gatesRepo := sqlite.NewGatesRepo(db) + + run := &domain.Run{ID: "run-1", ProjectID: "p1", State: domain.RunStatePausedForGate, CreatedAt: time.Now(), UpdatedAt: time.Now()} + if err := runsRepo.Create(ctx, run); err != nil { + t.Fatal(err) + } + if err := phasesRepo.Create(ctx, &domain.Phase{ID: "phase-1", RunID: run.ID, Name: "Execution", SeqOrder: 1, CreatedAt: time.Now(), UpdatedAt: time.Now()}); err != nil { + t.Fatal(err) + } + step := &domain.Step{ID: "step-1", PhaseID: "phase-1", Title: "Step", Goal: "Goal", Adapter: "mock", State: domain.StepStateNeedsApproval, CreatedAt: time.Now(), UpdatedAt: time.Now()} + if err := stepsRepo.Create(ctx, step); err != nil { + t.Fatal(err) + } + attempt := &domain.Attempt{ + ID: "attempt-1", + StepID: step.ID, + Number: 1, + Adapter: "mock", + Result: &domain.ResultSpec{Version: "v1", State: domain.StepStateCompleted, Summary: "approved"}, + CreatedAt: time.Now(), + UpdatedAt: time.Now(), + } + if err := attemptsRepo.Create(ctx, attempt); err != nil { + t.Fatal(err) + } + gate := &domain.Gate{ID: "gate-1", RunID: run.ID, StepID: step.ID, Description: "review", State: domain.GateStatePending, CreatedAt: time.Now()} + if err := gatesRepo.Create(ctx, gate); err != nil { + t.Fatal(err) + } + + gateSvc := service.NewGateService(gatesRepo, runsRepo, stepsRepo, attemptsRepo) + if err := gateSvc.Approve(ctx, gate.ID); err != nil { + t.Fatalf("Approve failed: %v", err) + } + approvedGate, _ := gatesRepo.Get(ctx, gate.ID) + if approvedGate.State != domain.GateStateApproved || approvedGate.ResolvedAt == nil { + t.Fatalf("expected gate to be resolved as approved, got %+v", approvedGate) + } + + approvedStep, _ := stepsRepo.Get(ctx, step.ID) + if approvedStep.State != domain.StepStateCompleted { + t.Fatalf("expected step state completed after approval, got %s", approvedStep.State) + } + approvedRun, _ := runsRepo.Get(ctx, run.ID) + if approvedRun.State != domain.RunStateCompleted { + t.Fatalf("expected run state completed after approval, got %s", approvedRun.State) + } + + rejectRun := &domain.Run{ID: "run-2", ProjectID: "p2", State: domain.RunStatePausedForGate, CreatedAt: time.Now(), UpdatedAt: time.Now()} + if err := runsRepo.Create(ctx, rejectRun); err != nil { + t.Fatal(err) + } + if err := phasesRepo.Create(ctx, &domain.Phase{ID: "phase-2", RunID: rejectRun.ID, Name: "Execution", SeqOrder: 1, CreatedAt: time.Now(), UpdatedAt: time.Now()}); err != nil { + t.Fatal(err) + } + rejectStep := &domain.Step{ID: "step-2", PhaseID: "phase-2", Title: "Reject Step", Goal: "Goal", Adapter: "mock", State: domain.StepStateNeedsApproval, CreatedAt: time.Now(), UpdatedAt: time.Now()} + if err := stepsRepo.Create(ctx, rejectStep); err != nil { + t.Fatal(err) + } + rejectAttempt := &domain.Attempt{ + ID: "attempt-2", + StepID: rejectStep.ID, + Number: 1, + Adapter: "mock", + Result: &domain.ResultSpec{Version: "v1", State: domain.StepStateCompletedWithWarnings, Summary: "reject"}, + CreatedAt: time.Now(), + UpdatedAt: time.Now(), + } + if err := attemptsRepo.Create(ctx, rejectAttempt); err != nil { + t.Fatal(err) + } + rejectGate := &domain.Gate{ID: "gate-2", RunID: rejectRun.ID, StepID: rejectStep.ID, Description: "review", State: domain.GateStatePending, CreatedAt: time.Now()} + if err := gatesRepo.Create(ctx, rejectGate); err != nil { + t.Fatal(err) + } + + if err := gateSvc.Reject(ctx, rejectGate.ID); err != nil { + t.Fatalf("Reject failed: %v", err) + } + rejectedGate, _ := gatesRepo.Get(ctx, rejectGate.ID) + if rejectedGate.State != domain.GateStateRejected || rejectedGate.ResolvedAt == nil { + t.Fatalf("expected gate to be resolved as rejected, got %+v", rejectedGate) + } + rejectedStep, _ := stepsRepo.Get(ctx, rejectStep.ID) + if rejectedStep.State != domain.StepStateCancelled { + t.Fatalf("expected step state cancelled after rejection, got %s", rejectedStep.State) + } + rejectedRun, _ := runsRepo.Get(ctx, rejectRun.ID) + if rejectedRun.State != domain.RunStateCancelled { + t.Fatalf("expected run state cancelled after rejection, got %s", rejectedRun.State) + } +} diff --git a/internal/service/instance_service.go b/internal/service/instance_service.go new file mode 100644 index 0000000..d7e69e3 --- /dev/null +++ b/internal/service/instance_service.go @@ -0,0 +1,269 @@ +package service + +import ( + "context" + "crypto/rand" + "encoding/hex" + "encoding/json" + "fmt" + "os" + "os/exec" + "path/filepath" + "runtime" + "sort" + "strings" + "time" + + "agent-bridge/internal/domain" +) + +const instanceIDSettingKey = "daemon_instance_id" + +// InstanceService owns stable daemon identity, manifest writing, and runtime capability reporting. +type InstanceService struct { + settingsRepo SettingsStore + agSvc *AntigravityService + version string + startedAt time.Time + repoRoot string + stateDir string + workspaceRoot string + host string + port int + instanceID string + getAdapters func() map[string]domain.Adapter +} + +func NewInstanceService( + settingsRepo SettingsStore, + agSvc *AntigravityService, + version string, + startedAt time.Time, + repoRoot string, + stateDir string, + workspaceRoot string, + host string, + port int, + getAdapters func() map[string]domain.Adapter, +) *InstanceService { + return &InstanceService{ + settingsRepo: settingsRepo, + agSvc: agSvc, + version: version, + startedAt: startedAt, + repoRoot: repoRoot, + stateDir: stateDir, + workspaceRoot: workspaceRoot, + host: host, + port: port, + getAdapters: getAdapters, + } +} + +func (s *InstanceService) EnsureStableInstanceID(ctx context.Context) (string, error) { + if s.instanceID != "" { + return s.instanceID, nil + } + existing, err := s.settingsRepo.Get(ctx, instanceIDSettingKey) + if err != nil { + return "", err + } + if existing != "" { + s.instanceID = existing + return existing, nil + } + + buf := make([]byte, 16) + if _, err := rand.Read(buf); err != nil { + return "", err + } + instanceID := "inst-" + hex.EncodeToString(buf) + if err := s.settingsRepo.Set(ctx, instanceIDSettingKey, instanceID); err != nil { + return "", err + } + s.instanceID = instanceID + return instanceID, nil +} + +func (s *InstanceService) ManifestPath() string { + return filepath.Join(s.stateDir, "instance.json") +} + +func (s *InstanceService) Compatibility(ctx context.Context) domain.CompatibilityInfo { + environment := domain.CompatibilityEnvironment{ + OS: runtime.GOOS, + VSCodeDetected: os.Getenv("VSCODE_PID") != "" || strings.EqualFold(os.Getenv("TERM_PROGRAM"), "vscode"), + } + + adaptersMap := s.getAdaptersSnapshot() + adapterIDs := make([]string, 0, len(adaptersMap)) + for id := range adaptersMap { + adapterIDs = append(adapterIDs, id) + } + sort.Strings(adapterIDs) + + adapters := make([]domain.CompatibilityAdapter, 0, len(adapterIDs)) + tier := 0 + for _, id := range adapterIDs { + mode, available, status := s.adapterRuntimeState(ctx, id, environment) + if available && tier < 2 { + tier = 2 + } + if id == "ide-chat" && available && tier < 3 { + tier = 3 + } + adapters = append(adapters, domain.CompatibilityAdapter{ + ID: id, + Available: available, + Status: status, + Mode: mode, + Capabilities: adaptersMap[id].Capabilities(), + }) + } + + return domain.CompatibilityInfo{ + Tier: tier, + Adapters: adapters, + Environment: environment, + } +} + +func (s *InstanceService) Current(ctx context.Context) (domain.InstanceInfo, error) { + instanceID, err := s.EnsureStableInstanceID(ctx) + if err != nil { + return domain.InstanceInfo{}, err + } + + compatibility := s.Compatibility(ctx) + brokerInfo := domain.InstanceBrokerInfo{Mode: "direct"} + if s.agSvc != nil { + info, err := s.agSvc.BrokerInfo(ctx) + if err != nil { + return domain.InstanceInfo{}, err + } + brokerInfo = info + } + + return domain.InstanceInfo{ + ID: instanceID, + Version: s.version, + RepoName: filepath.Base(s.repoRoot), + RepoRoot: s.repoRoot, + StateDir: s.stateDir, + WorkspaceRoot: s.workspaceRoot, + ManifestPath: s.ManifestPath(), + Host: s.host, + Port: s.port, + BaseURL: fmt.Sprintf("http://%s:%d", s.host, s.port), + ExecutionMode: s.executionMode(), + PID: os.Getpid(), + StartedAt: s.startedAt, + Adapters: compatibility.Adapters, + Broker: brokerInfo, + }, nil +} + +func (s *InstanceService) WriteManifest(ctx context.Context) (string, error) { + info, err := s.Current(ctx) + if err != nil { + return "", err + } + if err := os.MkdirAll(filepath.Dir(s.ManifestPath()), 0755); err != nil { + return "", err + } + data, err := json.MarshalIndent(info, "", " ") + if err != nil { + return "", err + } + tmpPath := s.ManifestPath() + ".tmp" + if err := os.WriteFile(tmpPath, data, 0644); err != nil { + return "", err + } + if err := os.Rename(tmpPath, s.ManifestPath()); err != nil { + _ = os.Remove(tmpPath) + return "", err + } + return s.ManifestPath(), nil +} + +func (s *InstanceService) getAdaptersSnapshot() map[string]domain.Adapter { + if s.getAdapters == nil { + return map[string]domain.Adapter{} + } + adapters := s.getAdapters() + if adapters == nil { + return map[string]domain.Adapter{} + } + return adapters +} + +func (s *InstanceService) executionMode() string { + value := os.Getenv("ALL_ADAPTERS_SIMULATION_MODE") + if value == "1" || strings.EqualFold(value, "true") { + return "simulation" + } + return "real" +} + +func (s *InstanceService) adapterRuntimeState(ctx context.Context, id string, environment domain.CompatibilityEnvironment) (string, bool, string) { + if isSimulationMode(id) { + return "simulation", true, "simulation" + } + + switch id { + case "codex": + return binaryRuntimeState("CODEX_BINARY", "codex-agent") + case "claude": + return binaryRuntimeState("CLAUDE_BINARY", "claude") + case "qwen": + return binaryRuntimeState("QWEN_BINARY", "qwen-local") + case "openclaw-acpx": + return binaryRuntimeState("OPENCLAW_ACPX_BINARY", "acpx") + case "ide-chat": + if environment.VSCodeDetected { + return "real", true, "available" + } + return "unavailable", false, "missing_vscode" + case "antigravity": + if s.agSvc == nil { + return "real", false, "unknown_binding" + } + binding, err := s.agSvc.GetBinding(ctx) + if err != nil { + return "real", false, "binding_error" + } + if binding == nil { + return "real", false, "unbound" + } + if binding.IsReachable { + return "real", true, "bound" + } + return "real", false, "bound_unreachable" + case "antigravity-broker": + if s.agSvc != nil && s.agSvc.BrokerEnabled() { + return "real", true, "configured" + } + return "unavailable", false, "disabled" + default: + return "real", true, "registered" + } +} + +func binaryRuntimeState(envVar, fallback string) (string, bool, string) { + binary := os.Getenv(envVar) + if binary == "" { + binary = fallback + } + if _, err := exec.LookPath(binary); err != nil { + return "unavailable", false, "missing_binary" + } + return "real", true, "available" +} + +func isSimulationMode(adapterID string) bool { + if value := os.Getenv("ALL_ADAPTERS_SIMULATION_MODE"); value == "1" || strings.EqualFold(value, "true") { + return true + } + value := os.Getenv(strings.ToUpper(strings.ReplaceAll(adapterID, "-", "_")) + "_SIMULATION_MODE") + return value == "1" || strings.EqualFold(value, "true") +} diff --git a/internal/service/recovery_service.go b/internal/service/recovery_service.go index eed36cf..417b75e 100644 --- a/internal/service/recovery_service.go +++ b/internal/service/recovery_service.go @@ -19,23 +19,33 @@ type RecoveryService struct { runsRepo *sqlite.RunsRepo stepsRepo *sqlite.StepsRepo attemptsRepo *sqlite.AttemptsRepo + gatesRepo *sqlite.GatesRepo artifactRoot string workspaceRoot string + repoRoot string } func NewRecoveryService( runsRepo *sqlite.RunsRepo, stepsRepo *sqlite.StepsRepo, attemptsRepo *sqlite.AttemptsRepo, + gatesRepo *sqlite.GatesRepo, artifactRoot string, workspaceRoot string, + repoRoot ...string, ) *RecoveryService { + baseRepoRoot := "." + if len(repoRoot) > 0 && repoRoot[0] != "" { + baseRepoRoot = repoRoot[0] + } return &RecoveryService{ runsRepo: runsRepo, stepsRepo: stepsRepo, attemptsRepo: attemptsRepo, + gatesRepo: gatesRepo, artifactRoot: artifactRoot, workspaceRoot: workspaceRoot, + repoRoot: baseRepoRoot, } } @@ -52,15 +62,19 @@ func (s *RecoveryService) SweepStaleRuns(ctx context.Context) error { for _, r := range runs { currentOwner := workspace.CheckLock(s.workspaceRoot) if currentOwner == r.ID { - // Still locked by the current process? + // Still locked by the current process? // In a local bridge, if we are in Sweep, we usually assume we are the only orchestrator. // If it's locked and we are here, it's either a concurrent orchestrator or a stale lock. // For now, we assume if we are sweeping, we OWN the workspace root. } - notes := s.reconcileRunSteps(ctx, r) + notes, recoveredGate := s.reconcileRunSteps(ctx, r) r.RecoveryNotes = notes - r.State = domain.RunStatePausedForGate + if recoveredGate { + r.State = domain.RunStatePausedForGate + } else { + r.State = domain.RunStateFailed + } r.UpdatedAt = time.Now().UTC() _ = s.runsRepo.UpdateState(ctx, r) slog.Info("Reconciled stale run", "runID", r.ID, "notes", notes) @@ -72,7 +86,7 @@ func (s *RecoveryService) SweepStaleRuns(ctx context.Context) error { return nil } -func (s *RecoveryService) reconcileRunSteps(ctx context.Context, run *domain.Run) string { +func (s *RecoveryService) reconcileRunSteps(ctx context.Context, run *domain.Run) (string, bool) { steps, _ := s.stepsRepo.ListByRun(ctx, run.ID) salvaged := 0 failed := 0 @@ -89,8 +103,20 @@ func (s *RecoveryService) reconcileRunSteps(ctx context.Context, run *domain.Run if _, err := os.Stat(resultPath); err == nil { // Result exists but DB state is not terminal. Salvage it. step.State = domain.StepStateNeedsApproval + step.StatusReason = "Recovered stale step with result evidence; manual review required." step.UpdatedAt = time.Now().UTC() _ = s.stepsRepo.UpdateState(ctx, step) + gate := &domain.Gate{ + ID: fmt.Sprintf("gate-recovery-%s", step.ID), + RunID: run.ID, + StepID: step.ID, + Description: "Recovered stale step requires manual review before the run can continue.", + State: domain.GateStatePending, + CreatedAt: time.Now().UTC(), + } + if err := s.gatesRepo.Create(ctx, gate); err != nil { + slog.Warn("Failed to create recovery gate", "runID", run.ID, "stepID", step.ID, "error", err) + } salvaged++ continue } @@ -103,11 +129,11 @@ func (s *RecoveryService) reconcileRunSteps(ctx context.Context, run *domain.Run failed++ } - return fmt.Sprintf("Recovery sweep completed: salvaged %d steps, marked %d steps failed_retryable. Run paused for inspection.", salvaged, failed) + return fmt.Sprintf("Recovery sweep completed: salvaged %d steps, marked %d steps failed_retryable.", salvaged, failed), salvaged > 0 } func (s *RecoveryService) cleanupOrphans(ctx context.Context) { - worktrees, err := workspace.ListWorktrees(ctx, ".") + worktrees, err := workspace.ListWorktrees(ctx, s.repoRoot) if err != nil { slog.Warn("Failed to list worktrees for orphan cleanup", "error", err) return @@ -126,7 +152,7 @@ func (s *RecoveryService) cleanupOrphans(ctx context.Context) { lockOwner := workspace.CheckLock(s.workspaceRoot) if lockOwner != runID { slog.Info("Cleaning up orphaned worktree", "path", wt, "runID", runID) - _ = workspace.RemoveWorktree(ctx, ".", wt) + _ = workspace.RemoveWorktree(ctx, s.repoRoot, wt) } } @@ -148,7 +174,7 @@ func (s *RecoveryService) ResumeRun(ctx context.Context, runID string) error { if err != nil { return err } - + if run.State != domain.RunStatePausedForGate && run.State != domain.RunStateCreated { return fmt.Errorf("run %s is not in a resumable state (must be paused_for_gate or created)", runID) } @@ -158,9 +184,9 @@ func (s *RecoveryService) ResumeRun(ctx context.Context, runID string) error { if owner != "" && owner != runID { return fmt.Errorf("cannot resume run %s: workspace is currently locked by run %s", runID, owner) } - + slog.Info("Resuming run", "runID", runID) - + run.State = domain.RunStateRunning run.UpdatedAt = time.Now().UTC() return s.runsRepo.UpdateState(ctx, run) diff --git a/internal/service/recovery_test.go b/internal/service/recovery_test.go index e696711..7cd9e43 100644 --- a/internal/service/recovery_test.go +++ b/internal/service/recovery_test.go @@ -19,7 +19,7 @@ func TestRecovery_StaleAttempt_Salvage(t *testing.T) { dbPath := filepath.Join(tmpDir, "test.db") db, _ := sql.Open("sqlite3", dbPath) sqlite.RunMigrations(db) - + artifactRoot := filepath.Join(tmpDir, "artifacts") workspaceRoot := filepath.Join(tmpDir, "workspace") os.MkdirAll(artifactRoot, 0755) @@ -29,8 +29,9 @@ func TestRecovery_StaleAttempt_Salvage(t *testing.T) { stepsRepo := sqlite.NewStepsRepo(db) attemptsRepo := sqlite.NewAttemptsRepo(db) phasesRepo := sqlite.NewPhasesRepo(db) - - recoverySvc := service.NewRecoveryService(runsRepo, stepsRepo, attemptsRepo, artifactRoot, workspaceRoot) + gatesRepo := sqlite.NewGatesRepo(db) + + recoverySvc := service.NewRecoveryService(runsRepo, stepsRepo, attemptsRepo, gatesRepo, artifactRoot, workspaceRoot) ctx := context.Background() // 1. Setup Stale State @@ -48,7 +49,7 @@ func TestRecovery_StaleAttempt_Salvage(t *testing.T) { CreatedAt: time.Now(), UpdatedAt: time.Now(), }) - + // Simulate process completion on disk but crash before DB update // New namespaced path: /// stepArtDir := filepath.Join(artifactRoot, runID, stepID, "stale-attempt-1") @@ -74,6 +75,13 @@ func TestRecovery_StaleAttempt_Salvage(t *testing.T) { if step.State != domain.StepStateNeedsApproval { t.Errorf("Expected step state NeedsApproval (salvaged), got %s", step.State) } + gates, err := gatesRepo.ListByRun(ctx, runID) + if err != nil { + t.Fatalf("list gates: %v", err) + } + if len(gates) != 1 || gates[0].State != domain.GateStatePending { + t.Fatalf("expected one pending recovery gate, got %+v", gates) + } } func TestRecovery_StaleAttempt_Fail(t *testing.T) { @@ -81,7 +89,7 @@ func TestRecovery_StaleAttempt_Fail(t *testing.T) { dbPath := filepath.Join(tmpDir, "test.db") db, _ := sql.Open("sqlite3", dbPath) sqlite.RunMigrations(db) - + artifactRoot := filepath.Join(tmpDir, "artifacts") workspaceRoot := filepath.Join(tmpDir, "workspace") os.MkdirAll(artifactRoot, 0755) @@ -91,8 +99,9 @@ func TestRecovery_StaleAttempt_Fail(t *testing.T) { stepsRepo := sqlite.NewStepsRepo(db) attemptsRepo := sqlite.NewAttemptsRepo(db) phasesRepo := sqlite.NewPhasesRepo(db) - - recoverySvc := service.NewRecoveryService(runsRepo, stepsRepo, attemptsRepo, artifactRoot, workspaceRoot) + gatesRepo := sqlite.NewGatesRepo(db) + + recoverySvc := service.NewRecoveryService(runsRepo, stepsRepo, attemptsRepo, gatesRepo, artifactRoot, workspaceRoot) ctx := context.Background() // 1. Setup Stale State (no result on disk) @@ -111,4 +120,8 @@ func TestRecovery_StaleAttempt_Fail(t *testing.T) { if step.State != domain.StepStateFailedRetryable { t.Errorf("Expected step state FailedRetryable, got %s", step.State) } + run, _ := runsRepo.Get(ctx, runID) + if run.State != domain.RunStateFailed { + t.Errorf("Expected run state Failed, got %s", run.State) + } } diff --git a/internal/service/retrieval_test.go b/internal/service/retrieval_test.go index 114caa9..6a07851 100644 --- a/internal/service/retrieval_test.go +++ b/internal/service/retrieval_test.go @@ -3,6 +3,8 @@ package service_test import ( "context" "database/sql" + "os" + "path/filepath" "testing" "time" @@ -123,4 +125,86 @@ func TestRunService_Retrieval(t *testing.T) { t.Errorf("expected name changes.diff, got %s", arts[0].Name) } }) + + t.Run("Artifact Content Retrieval", func(t *testing.T) { + contentPath := filepath.Join(t.TempDir(), "stdout.log") + if err := os.WriteFile(contentPath, []byte("hello world"), 0644); err != nil { + t.Fatal(err) + } + artifact := &domain.Artifact{ + ID: "art-content", + AttemptID: stepID + "-a1", + Type: domain.ArtifactTypeStdout, + Name: "stdout.log", + Path: contentPath, + CreatedAt: time.Now(), + UpdatedAt: time.Now(), + } + if err := artifactsRepo.Create(ctx, artifact); err != nil { + t.Fatal(err) + } + + foundArtifact, content, err := svc.GetArtifactContent(ctx, artifact.ID) + if err != nil { + t.Fatal(err) + } + if foundArtifact.ID != artifact.ID { + t.Fatalf("expected artifact %s, got %s", artifact.ID, foundArtifact.ID) + } + if string(content) != "hello world" { + t.Fatalf("unexpected artifact content: %s", string(content)) + } + }) + + t.Run("Log Retrieval Uses Artifact Lookup", func(t *testing.T) { + logStepID := "log-step" + logAttemptID := logStepID + "-a1" + logStep := &domain.Step{ + ID: logStepID, + PhaseID: "phase-01-" + runID, + Title: "Log Step", + Adapter: "mock", + State: domain.StepStateCompleted, + } + if err := stepsRepo.Create(ctx, logStep); err != nil { + t.Fatal(err) + } + if err := attemptsRepo.Create(ctx, &domain.Attempt{ + ID: logAttemptID, + StepID: logStepID, + Number: 1, + CreatedAt: time.Now(), + UpdatedAt: time.Now(), + }); err != nil { + t.Fatal(err) + } + + logPath := filepath.Join(t.TempDir(), "latest.log") + if err := os.WriteFile(logPath, []byte("latest logs"), 0644); err != nil { + t.Fatal(err) + } + artifact := &domain.Artifact{ + ID: "art-log", + AttemptID: logAttemptID, + Type: domain.ArtifactTypeStdout, + Name: "stdout.log", + Path: logPath, + CreatedAt: time.Now(), + UpdatedAt: time.Now(), + } + if err := artifactsRepo.Create(ctx, artifact); err != nil { + t.Fatal(err) + } + + foundArtifact, content, err := svc.GetLogsByStep(ctx, logStepID) + if err != nil { + t.Fatal(err) + } + if foundArtifact.ID != artifact.ID { + t.Fatalf("expected log artifact %s, got %s", artifact.ID, foundArtifact.ID) + } + if string(content) != "latest logs" { + t.Fatalf("unexpected logs content: %s", string(content)) + } + }) } diff --git a/internal/service/routing_service.go b/internal/service/routing_service.go index cf4ddbb..fa4a33b 100644 --- a/internal/service/routing_service.go +++ b/internal/service/routing_service.go @@ -17,7 +17,7 @@ type RoutingService struct { } // NOTE: Current routing implementation is a HEURISTIC STATIC FALLBACK CHAIN. -// While benchmarks are persisted to the database, they are NOT yet used for dynamic +// While benchmarks are persisted to the database, they are NOT yet used for dynamic // selection or weight-based routing. Performance-based routing is a legacy roadmap item. func NewRoutingService(benchRepo *sqlite.BenchmarksRepo, adapters map[string]domain.Adapter) *RoutingService { @@ -28,7 +28,7 @@ func NewRoutingService(benchRepo *sqlite.BenchmarksRepo, adapters map[string]dom } // BuildHeuristicChain calculates the priority ordered slice of adapter IDs given a target profile. -// NOTE: This currently uses a STATIC hardcoded fallback chain and does NOT yet +// NOTE: This currently uses a STATIC hardcoded fallback chain and does NOT yet // dynamically evaluate benchmarks for routing decisions. func (rs *RoutingService) BuildHeuristicChain(ctx context.Context, requestedProfile string) ([]string, error) { // If a specific adapter was requested, it must be the first in our chain @@ -61,3 +61,12 @@ func (rs *RoutingService) GetAdapter(profile string) (domain.Adapter, bool) { adapter, ok := rs.adapters[profile] return adapter, ok } + +// ListAdapters returns the registered adapters keyed by profile. +func (rs *RoutingService) ListAdapters() map[string]domain.Adapter { + cloned := make(map[string]domain.Adapter, len(rs.adapters)) + for id, adapter := range rs.adapters { + cloned[id] = adapter + } + return cloned +} diff --git a/internal/service/run_service.go b/internal/service/run_service.go index d5e6a02..690b070 100644 --- a/internal/service/run_service.go +++ b/internal/service/run_service.go @@ -2,11 +2,17 @@ package service import ( "context" + "crypto/sha256" + "encoding/hex" "encoding/json" "fmt" + "io" "log/slog" "net/http" "os" + "path/filepath" + "strings" + "sync" "time" "agent-bridge/internal/domain" @@ -14,10 +20,17 @@ import ( "agent-bridge/internal/storage/sqlite" "agent-bridge/internal/validation" "agent-bridge/internal/workspace" - "path/filepath" - "strings" ) +type activeExecution struct { + stepID string + attemptID string + adapter domain.Adapter + cancel context.CancelFunc + done chan struct{} + abortRequested bool +} + type RunService struct { runsRepo *sqlite.RunsRepo phasesRepo *sqlite.PhasesRepo @@ -32,6 +45,9 @@ type RunService struct { provisioner workspace.Provisioner artifactRoot string workspaceRoot string + repoRoot string + execMu sync.Mutex + executions map[string]*activeExecution } // NewRunService creates a new RunService. @@ -48,7 +64,12 @@ func NewRunService( provisioner workspace.Provisioner, artifactRoot string, workspaceRoot string, + repoRoot ...string, ) *RunService { + baseRepoRoot := "." + if len(repoRoot) > 0 && repoRoot[0] != "" { + baseRepoRoot = repoRoot[0] + } return &RunService{ runsRepo: runsRepo, phasesRepo: phasesRepo, @@ -63,6 +84,8 @@ func NewRunService( provisioner: provisioner, artifactRoot: artifactRoot, workspaceRoot: workspaceRoot, + repoRoot: baseRepoRoot, + executions: make(map[string]*activeExecution), } } @@ -144,6 +167,11 @@ func (s *RunService) GetArtifactsByStep(ctx context.Context, stepID string) ([]* return s.artifactsRepo.ListByStep(ctx, stepID) } +// GetArtifact returns a single artifact by ID. +func (s *RunService) GetArtifact(ctx context.Context, artifactID string) (*domain.Artifact, error) { + return s.artifactsRepo.Get(ctx, artifactID) +} + // GetValidationsByStep returns all validations for all attempts of a step. func (s *RunService) GetValidationsByStep(ctx context.Context, stepID string) (map[string][]*domain.ValidationResult, error) { return s.validationsRepo.ListByStep(ctx, stepID) @@ -163,26 +191,24 @@ func (s *RunService) GetResultByStep(ctx context.Context, stepID string) (*domai if step == nil { return nil, fmt.Errorf("step %s not found", stepID) } + phase, _ := s.phasesRepo.Get(ctx, step.PhaseID) + runID := "" + if phase != nil { + runID = phase.RunID + } attempts, err := s.attemptsRepo.ListByStep(ctx, stepID) if err != nil { return nil, err } if len(attempts) == 0 { - // Return a pending result structure if no attempts yet - return &domain.ResultSpec{ - State: step.State, - Summary: "No attempts executed for this step yet.", - }, nil + return s.newResultSpec(runID, step, nil, step.State, "No attempts executed for this step yet."), nil } // ListByStep orders by number ASC. The last one is the latest attempt. latest := attempts[len(attempts)-1] if latest.Result == nil { - return &domain.ResultSpec{ - State: step.State, - Summary: fmt.Sprintf("Latest attempt %s is still in progress or failed before result normalization.", latest.ID), - }, nil + return s.newResultSpec(runID, step, latest, step.State, fmt.Sprintf("Latest attempt %s is still in progress or failed before result normalization.", latest.ID)), nil } // Fetch validations for this attempt @@ -194,15 +220,7 @@ func (s *RunService) GetResultByStep(ctx context.Context, stepID string) (*domai } // Enrichment for terminal consumers - phase, _ := s.phasesRepo.Get(ctx, step.PhaseID) - if phase != nil { - latest.Result.RunID = phase.RunID - } - latest.Result.PhaseID = step.PhaseID - latest.Result.StepID = step.ID - latest.Result.AttemptID = latest.ID - latest.Result.Adapter = latest.Adapter - latest.Result.RequestedAdapter = step.Adapter + s.ensureResultEnvelope(latest.Result, runID, step, latest) return latest.Result, nil } @@ -227,7 +245,9 @@ func (s *RunService) GetRoutingConfig(ctx context.Context) map[string]interface{ } } -// Abort transitions the run to cancelled if it is not already terminal. +const abortGracePeriod = 5 * time.Second + +// Abort transitions the run to cancelled only after the active execution actually stops. func (s *RunService) AbortRun(ctx context.Context, id string) error { run, err := s.runsRepo.Get(ctx, id) if err != nil { @@ -241,9 +261,48 @@ func (s *RunService) AbortRun(ctx context.Context, id string) error { return fmt.Errorf("run is already terminal in state %s", run.State) } - run.State = domain.RunStateCancelled - run.UpdatedAt = time.Now().UTC() - return s.runsRepo.UpdateState(ctx, run) + execution := s.getExecution(id) + if execution == nil { + steps, serr := s.stepsRepo.ListByRun(ctx, id) + if serr != nil { + return serr + } + hasNonTerminal := false + for _, step := range steps { + if step.State.IsTerminal() || step.State == domain.StepStateNeedsApproval { + continue + } + hasNonTerminal = true + step.State = domain.StepStateNeedsManualAttention + step.StatusReason = "Abort requested, but no active execution was registered for this run." + step.UpdatedAt = time.Now().UTC() + if err := s.stepsRepo.UpdateState(ctx, step); err != nil { + return err + } + } + if hasNonTerminal { + return s.reconcileRunState(ctx, id) + } + + run.State = domain.RunStateCancelled + run.UpdatedAt = time.Now().UTC() + return s.runsRepo.UpdateState(ctx, run) + } + + s.requestAbort(id) + if execution.cancel != nil { + execution.cancel() + } + + waitCtx, cancel := context.WithTimeout(ctx, abortGracePeriod+2*time.Second) + defer cancel() + + select { + case <-execution.done: + return nil + case <-waitCtx.Done(): + return fmt.Errorf("abort requested for run %s, but the active execution did not stop within %s", id, abortGracePeriod+2*time.Second) + } } // DispatchStep handles the tactical execution of a planner-issued Step. @@ -253,23 +312,36 @@ func (s *RunService) DispatchStep(ctx context.Context, runID string, step *domai return err } - fallbackChain, err := s.routingSvc.BuildHeuristicChain(ctx, step.Adapter) + dispatchCtx, cancel := context.WithCancel(ctx) + done := make(chan struct{}) + s.registerExecution(runID, step.ID, cancel, done) + defer s.clearExecution(runID) + defer close(done) + + fallbackChain, err := s.routingSvc.BuildHeuristicChain(dispatchCtx, step.Adapter) if err != nil || len(fallbackChain) == 0 { - return s.failStep(ctx, step, fmt.Sprintf("no viable adapters found for profile '%s'", step.Adapter)) + return s.failStep(dispatchCtx, step, fmt.Sprintf("no viable adapters found for profile '%s'", step.Adapter)) } step.State = domain.StepStateRunning - _ = s.stepsRepo.UpdateState(ctx, step) + step.UpdatedAt = time.Now().UTC() + if err := s.stepsRepo.UpdateState(dispatchCtx, step); err != nil { + return err + } - finalResult, finalEval, finalAttemptID, err := s.runAttemptLoop(ctx, runID, step, fallbackChain) + finalResult, finalEval, finalAttemptID, err := s.runAttemptLoop(dispatchCtx, runID, step, fallbackChain) if err != nil { return err } - if err := s.finalizeStep(ctx, runID, step, finalResult, finalEval, finalAttemptID); err != nil { + persistCtx := ctx + if persistCtx == nil { + persistCtx = context.Background() + } + if err := s.finalizeStep(persistCtx, runID, step, finalResult, finalEval, finalAttemptID); err != nil { return err } - return nil + return s.reconcileRunState(persistCtx, runID) } // RetryStep re-dispatches an existing step. @@ -352,6 +424,10 @@ func (s *RunService) runAttemptLoop(ctx context.Context, runID string, step *dom policy := s.policyRegistry.Lookup(step.Policy) for attemptNum := 1; attemptNum <= maxAttempts; attemptNum++ { + if s.isAbortRequested(runID) { + break + } + adapterProfile := s.selectAdapterProfile(fallbackChain, attemptNum) adapter, ok := s.routingSvc.GetAdapter(adapterProfile) if !ok { @@ -378,6 +454,10 @@ func (s *RunService) runAttemptLoop(ctx context.Context, runID string, step *dom finalEval = eval finalAttemptID = attempt.ID + if s.isAbortRequested(runID) { + break + } + if eval.ShouldFail { break } @@ -463,21 +543,22 @@ func (s *RunService) executeAttempt( // 1. Setup Environment workspaceRoot := fmt.Sprintf("%s/%s", s.workspaceRoot, runID) attemptArtifactRoot := filepath.Join(s.artifactRoot, runID, step.ID, attempt.ID) - baseRepo := "." + baseRepo := s.repoRoot branchName := "codencer-" + runID + s.setExecutionAttempt(runID, attempt.ID, adapter) // Create workspace dir if not exists (parent of worktree) _ = os.MkdirAll(s.workspaceRoot, 0755) if err := os.MkdirAll(attemptArtifactRoot, 0755); err != nil { reason := fmt.Sprintf("Failed to create attempt artifact root: %v", err) - attempt.Result = &domain.ResultSpec{State: domain.StepStateFailedBridge, Summary: reason} + attempt.Result = s.newResultSpec(runID, step, attempt, domain.StepStateFailedBridge, reason) step.StatusReason = reason s.updateAttemptResult(ctx, attempt) return attempt.Result, PolicyEvaluation{}, nil } if err := s.writeSubmissionProvenance(attemptArtifactRoot, step); err != nil { reason := fmt.Sprintf("Failed to persist submission provenance: %v", err) - attempt.Result = &domain.ResultSpec{State: domain.StepStateFailedBridge, Summary: reason} + attempt.Result = s.newResultSpec(runID, step, attempt, domain.StepStateFailedBridge, reason) step.StatusReason = reason _, _ = s.persistProvenanceArtifacts(ctx, attempt, attemptArtifactRoot) s.updateAttemptResult(ctx, attempt) @@ -487,7 +568,7 @@ func (s *RunService) executeAttempt( // Acquire exclusive lock for this run's workspace lock, err := workspace.AcquireLock(s.workspaceRoot, runID) if err != nil { - attempt.Result = &domain.ResultSpec{State: domain.StepStateFailedRetryable, Summary: "Workspace lock conflict: " + err.Error()} + attempt.Result = s.newResultSpec(runID, step, attempt, domain.StepStateFailedRetryable, "Workspace lock conflict: "+err.Error()) _, _ = s.persistProvenanceArtifacts(ctx, attempt, attemptArtifactRoot) s.updateAttemptResult(ctx, attempt) return attempt.Result, PolicyEvaluation{}, nil @@ -499,10 +580,7 @@ func (s *RunService) executeAttempt( if err := workspace.CreateWorktree(ctx, baseRepo, workspaceRoot, branchName); err != nil { slog.Error("Failed to create worktree", "runID", runID, "error", err) reason := fmt.Sprintf("Workspace creation failed: %v", err) - attempt.Result = &domain.ResultSpec{ - State: domain.StepStateFailedBridge, - Summary: reason, - } + attempt.Result = s.newResultSpec(runID, step, attempt, domain.StepStateFailedBridge, reason) step.StatusReason = reason // Propagate to step state _, _ = s.persistProvenanceArtifacts(ctx, attempt, attemptArtifactRoot) s.updateAttemptResult(ctx, attempt) @@ -529,7 +607,8 @@ func (s *RunService) executeAttempt( slog.Error("Failed to provision workspace", "runID", runID, "error", err) reason := fmt.Sprintf("Provisioning failed: %v", err) if attempt.Result == nil { - attempt.Result = &domain.ResultSpec{State: domain.StepStateFailedBridge, Summary: reason, Provisioning: provRes} + attempt.Result = s.newResultSpec(runID, step, attempt, domain.StepStateFailedBridge, reason) + attempt.Result.Provisioning = provRes } else { attempt.Result.State = domain.StepStateFailedBridge attempt.Result.Summary = reason @@ -542,27 +621,34 @@ func (s *RunService) executeAttempt( // 3. Start Execution if err := adapter.Start(ctx, step, attempt, workspaceRoot, attemptArtifactRoot); err != nil { - attempt.Result = &domain.ResultSpec{State: domain.StepStateFailedRetryable, Summary: "Adapter failed to start: " + err.Error(), Provisioning: provRes} + attempt.Result = s.newResultSpec(runID, step, attempt, domain.StepStateFailedRetryable, "Adapter failed to start: "+err.Error()) + attempt.Result.Provisioning = provRes _, _ = s.persistProvenanceArtifacts(ctx, attempt, attemptArtifactRoot) s.updateAttemptResult(ctx, attempt) return attempt.Result, PolicyEvaluation{}, nil } // 3. Poll - if !s.pollAdapter(ctx, adapter, attempt, s.attemptsRepo, step, provRes) { - _, _ = s.persistProvenanceArtifacts(ctx, attempt, attemptArtifactRoot) - s.updateAttemptResult(ctx, attempt) + if !s.pollAdapter(ctx, runID, adapter, attempt, s.attemptsRepo, step, provRes) { + persistCtx := ctx + if ctx.Err() != nil { + persistCtx = context.Background() + } + _, _ = s.persistProvenanceArtifacts(persistCtx, attempt, attemptArtifactRoot) + s.updateAttemptResult(persistCtx, attempt) return attempt.Result, PolicyEvaluation{}, nil } step.State = domain.StepStateCollectingArtifacts - s.stepsRepo.UpdateState(ctx, step) + step.UpdatedAt = time.Now().UTC() + _ = s.stepsRepo.UpdateState(ctx, step) // 4. Collect & Finalize artifacts, err := adapter.CollectArtifacts(ctx, attempt.ID, attemptArtifactRoot) if err != nil { reason := "Failed to collect artifacts: " + err.Error() - attempt.Result = &domain.ResultSpec{State: domain.StepStateFailedBridge, Summary: reason, Provisioning: provRes} + attempt.Result = s.newResultSpec(runID, step, attempt, domain.StepStateFailedBridge, reason) + attempt.Result.Provisioning = provRes step.StatusReason = reason _, _ = s.persistProvenanceArtifacts(ctx, attempt, attemptArtifactRoot) s.updateAttemptResult(ctx, attempt) @@ -577,7 +663,8 @@ func (s *RunService) executeAttempt( res, err := adapter.NormalizeResult(ctx, attempt.ID, artifacts) if err != nil { reason := "Normalization failed: " + err.Error() - attempt.Result = &domain.ResultSpec{State: domain.StepStateFailedBridge, Summary: reason, Provisioning: provRes} + attempt.Result = s.newResultSpec(runID, step, attempt, domain.StepStateFailedBridge, reason) + attempt.Result.Provisioning = provRes step.StatusReason = reason } else { res.Provisioning = provRes @@ -590,13 +677,7 @@ func (s *RunService) executeAttempt( // Always persist provenance as artifacts on the terminal path _, _ = s.persistProvenanceArtifacts(ctx, attempt, attemptArtifactRoot) - // Enrich with step/attempt context for machine consumers - attempt.Result.RunID = runID - attempt.Result.PhaseID = step.PhaseID - attempt.Result.StepID = step.ID - attempt.Result.AttemptID = attempt.ID - attempt.Result.Adapter = attempt.Adapter - attempt.Result.RequestedAdapter = step.Adapter + s.ensureResultEnvelope(attempt.Result, runID, step, attempt) s.updateAttemptResult(ctx, attempt) @@ -627,10 +708,12 @@ func (s *RunService) executeAttempt( if anyFailed { attempt.Result.State = domain.StepStateFailedValidation attempt.Result.Summary = fmt.Sprintf("Validation failed: %d passed, %d failed.", passed, failed) + s.ensureResultEnvelope(attempt.Result, runID, step, attempt) s.updateAttemptResult(ctx, attempt) } else { // Even if passing, it's useful to know validations ran attempt.Result.Summary += fmt.Sprintf(" (Validations: %d passed)", passed) + s.ensureResultEnvelope(attempt.Result, runID, step, attempt) s.updateAttemptResult(ctx, attempt) } } @@ -644,14 +727,21 @@ func (s *RunService) executeAttempt( changedFiles = files } } + attempt.Result.FilesChanged = append([]string(nil), changedFiles...) + s.ensureResultEnvelope(attempt.Result, runID, step, attempt) eval := Evaluate(policy, attempt.Result, changedFiles) return attempt.Result, eval, nil } func (s *RunService) updateAttemptResult(ctx context.Context, attempt *domain.Attempt) { + if attempt.Result == nil { + return + } attempt.UpdatedAt = time.Now().UTC() - s.attemptsRepo.UpdateResult(ctx, attempt) + if err := s.attemptsRepo.UpdateResult(ctx, attempt); err != nil { + slog.Error("Failed to persist attempt result", "attemptID", attempt.ID, "error", err) + } } func (s *RunService) writeSubmissionProvenance(attemptArtifactRoot string, step *domain.Step) error { @@ -747,6 +837,13 @@ func buildSubmissionArtifact(attemptID, path string) (*domain.Artifact, error) { defer file.Close() n, _ := file.Read(sample) + if _, err := file.Seek(0, 0); err != nil { + return nil, err + } + hasher := sha256.New() + if _, err := io.Copy(hasher, file); err != nil { + return nil, err + } artifactType := domain.ArtifactType("file") if filepath.Base(path) == "normalized-task.json" { artifactType = domain.ArtifactTypeInputJSON @@ -759,6 +856,7 @@ func buildSubmissionArtifact(attemptID, path string) (*domain.Artifact, error) { Name: filepath.Base(path), Path: path, Size: info.Size(), + Hash: hex.EncodeToString(hasher.Sum(nil)), MimeType: http.DetectContentType(sample[:n]), CreatedAt: info.ModTime(), UpdatedAt: time.Now().UTC(), @@ -806,8 +904,10 @@ func (s *RunService) finalizeStep( eval PolicyEvaluation, attemptID string, ) error { - - if eval.ShouldGate { + if s.isAbortRequested(runID) && finalResult != nil { + step.State = finalResult.State + step.StatusReason = finalResult.Summary + } else if eval.ShouldGate { step.State = domain.StepStateNeedsApproval gate := &domain.Gate{ ID: "gate-" + attemptID, @@ -818,13 +918,7 @@ func (s *RunService) finalizeStep( CreatedAt: time.Now().UTC(), } - if gerr := s.gatesRepo.Create(ctx, gate); gerr == nil { - if run, rerr := s.runsRepo.Get(ctx, runID); rerr == nil && run != nil { - run.State = domain.RunStatePausedForGate - run.UpdatedAt = time.Now().UTC() - _ = s.runsRepo.UpdateState(ctx, run) - } - } else { + if gerr := s.gatesRepo.Create(ctx, gate); gerr != nil { slog.Error("Failed to create gate", "error", gerr) step.State = domain.StepStateFailedBridge step.StatusReason = "Infrastructure error: failed to create gate" @@ -843,12 +937,19 @@ func (s *RunService) finalizeStep( step.StatusReason = finalResult.Summary } else { step.State = domain.StepStateCompleted + if finalResult != nil { + step.StatusReason = finalResult.Summary + } + if finalResult != nil && finalResult.State == domain.StepStateCompletedWithWarnings { + step.State = domain.StepStateCompletedWithWarnings + step.StatusReason = finalResult.Summary + } } step.UpdatedAt = time.Now().UTC() return s.stepsRepo.UpdateState(ctx, step) } -func (s *RunService) pollAdapter(ctx context.Context, adapter domain.Adapter, attempt *domain.Attempt, repo *sqlite.AttemptsRepo, step *domain.Step, prov *domain.ProvisioningResult) bool { +func (s *RunService) pollAdapter(ctx context.Context, runID string, adapter domain.Adapter, attempt *domain.Attempt, repo *sqlite.AttemptsRepo, step *domain.Step, prov *domain.ProvisioningResult) bool { interval := 2 * time.Second pollTicker := time.NewTicker(interval) defer pollTicker.Stop() @@ -864,26 +965,26 @@ func (s *RunService) pollAdapter(ctx context.Context, adapter domain.Adapter, at select { case <-ctx.Done(): _ = adapter.Cancel(context.Background(), attempt.ID) + if s.waitForAdapterStop(adapter, attempt.ID, abortGracePeriod) { + attempt.Result = s.newResultSpec(runID, step, attempt, domain.StepStateCancelled, "Execution cancelled by operator request.") + } else { + attempt.Result = s.newResultSpec(runID, step, attempt, domain.StepStateNeedsManualAttention, "Abort requested, but the adapter did not confirm cancellation before the grace period elapsed.") + } + attempt.Result.Provisioning = prov return false case <-timeoutChan: slog.Warn("Attempt timed out", "attemptID", attempt.ID, "timeoutSeconds", step.TimeoutSeconds) _ = adapter.Cancel(context.Background(), attempt.ID) - attempt.Result = &domain.ResultSpec{ - State: domain.StepStateTimeout, - Summary: fmt.Sprintf("Execution timed out after %d seconds", step.TimeoutSeconds), - Provisioning: prov, - } - _ = repo.UpdateResult(ctx, attempt) + attempt.Result = s.newResultSpec(runID, step, attempt, domain.StepStateTimeout, fmt.Sprintf("Execution timed out after %d seconds", step.TimeoutSeconds)) + attempt.Result.Provisioning = prov + _ = repo.UpdateResult(context.Background(), attempt) return false case <-pollTicker.C: running, err := adapter.Poll(ctx, attempt.ID) if err != nil { - attempt.Result = &domain.ResultSpec{ - State: domain.StepStateFailedAdapter, - Summary: fmt.Sprintf("Poll error: %v", err), - Provisioning: prov, - } - _ = repo.UpdateResult(ctx, attempt) + attempt.Result = s.newResultSpec(runID, step, attempt, domain.StepStateFailedAdapter, fmt.Sprintf("Poll error: %v", err)) + attempt.Result.Provisioning = prov + _ = repo.UpdateResult(context.Background(), attempt) return false } if !running { @@ -892,3 +993,184 @@ func (s *RunService) pollAdapter(ctx context.Context, adapter domain.Adapter, at } } } + +func (s *RunService) registerExecution(runID, stepID string, cancel context.CancelFunc, done chan struct{}) { + s.execMu.Lock() + defer s.execMu.Unlock() + s.executions[runID] = &activeExecution{ + stepID: stepID, + cancel: cancel, + done: done, + } +} + +func (s *RunService) setExecutionAttempt(runID, attemptID string, adapter domain.Adapter) { + s.execMu.Lock() + defer s.execMu.Unlock() + if execution, ok := s.executions[runID]; ok { + execution.attemptID = attemptID + execution.adapter = adapter + } +} + +func (s *RunService) clearExecution(runID string) { + s.execMu.Lock() + defer s.execMu.Unlock() + delete(s.executions, runID) +} + +func (s *RunService) getExecution(runID string) *activeExecution { + s.execMu.Lock() + defer s.execMu.Unlock() + execution, ok := s.executions[runID] + if !ok { + return nil + } + return execution +} + +func (s *RunService) requestAbort(runID string) { + s.execMu.Lock() + defer s.execMu.Unlock() + if execution, ok := s.executions[runID]; ok { + execution.abortRequested = true + } +} + +func (s *RunService) isAbortRequested(runID string) bool { + s.execMu.Lock() + defer s.execMu.Unlock() + if execution, ok := s.executions[runID]; ok { + return execution.abortRequested + } + return false +} + +func (s *RunService) waitForAdapterStop(adapter domain.Adapter, attemptID string, timeout time.Duration) bool { + deadline := time.Now().Add(timeout) + for { + running, err := adapter.Poll(context.Background(), attemptID) + if err == nil && !running { + return true + } + if time.Now().After(deadline) { + return false + } + time.Sleep(200 * time.Millisecond) + } +} + +func (s *RunService) ensureResultEnvelope(result *domain.ResultSpec, runID string, step *domain.Step, attempt *domain.Attempt) { + if result == nil || step == nil { + return + } + if result.Version == "" { + result.Version = "v1" + } + if result.RunID == "" { + result.RunID = runID + } + if result.PhaseID == "" { + result.PhaseID = step.PhaseID + } + if result.StepID == "" { + result.StepID = step.ID + } + if attempt != nil { + if result.AttemptID == "" { + result.AttemptID = attempt.ID + } + if result.Adapter == "" { + result.Adapter = attempt.Adapter + } + } + if result.RequestedAdapter == "" { + result.RequestedAdapter = step.Adapter + } + if result.Summary == "" { + result.Summary = string(result.State) + } + if result.CreatedAt.IsZero() { + result.CreatedAt = time.Now().UTC() + } + result.UpdatedAt = time.Now().UTC() +} + +func (s *RunService) newResultSpec(runID string, step *domain.Step, attempt *domain.Attempt, state domain.StepState, summary string) *domain.ResultSpec { + result := &domain.ResultSpec{ + State: state, + Summary: summary, + } + s.ensureResultEnvelope(result, runID, step, attempt) + return result +} + +func (s *RunService) reconcileRunState(ctx context.Context, runID string) error { + run, err := s.runsRepo.Get(ctx, runID) + if err != nil { + return err + } + if run == nil { + return fmt.Errorf("run not found") + } + + steps, err := s.stepsRepo.ListByRun(ctx, runID) + if err != nil { + return err + } + + nextState := deriveRunState(steps) + run.State = nextState + run.UpdatedAt = time.Now().UTC() + return s.runsRepo.UpdateState(ctx, run) +} + +func (s *RunService) GetArtifactContent(ctx context.Context, artifactID string) (*domain.Artifact, []byte, error) { + artifact, err := s.artifactsRepo.Get(ctx, artifactID) + if err != nil { + return nil, nil, err + } + if artifact == nil { + return nil, nil, fmt.Errorf("artifact %s not found", artifactID) + } + artifactPath := artifact.Path + if !filepath.IsAbs(artifactPath) { + artifactPath = filepath.Join(s.artifactRoot, artifactPath) + } + content, err := os.ReadFile(artifactPath) + if err != nil { + return nil, nil, fmt.Errorf("read artifact content: %w", err) + } + return artifact, content, nil +} + +func (s *RunService) GetLogsByStep(ctx context.Context, stepID string) (*domain.Artifact, []byte, error) { + attempt, err := s.attemptsRepo.GetLatestByStep(ctx, stepID) + if err != nil { + return nil, nil, err + } + if attempt == nil { + return nil, nil, fmt.Errorf("no attempts found for step %s", stepID) + } + + artifacts, err := s.artifactsRepo.ListByAttempt(ctx, attempt.ID) + if err != nil { + return nil, nil, err + } + + var selected *domain.Artifact + for _, artifact := range artifacts { + if artifact.Type == domain.ArtifactTypeStdout { + selected = artifact + break + } + if selected == nil && artifact.Type == domain.ArtifactTypeStderr { + selected = artifact + } + } + if selected == nil { + return nil, nil, fmt.Errorf("no log artifact found for step %s", stepID) + } + + return s.GetArtifactContent(ctx, selected.ID) +} diff --git a/internal/service/run_service_test.go b/internal/service/run_service_test.go index 716427b..461929a 100644 --- a/internal/service/run_service_test.go +++ b/internal/service/run_service_test.go @@ -6,6 +6,7 @@ import ( "errors" "fmt" "os" + "os/exec" "path/filepath" "testing" "time" @@ -129,7 +130,6 @@ func TestRunService_DispatchStep_Isolated(t *testing.T) { Adapter: "mock-adapter", } - err = runSvc.DispatchStep(ctx, runId, step) if err != nil { t.Fatalf("DispatchStep failed: %v", err) @@ -153,6 +153,88 @@ func TestRunService_DispatchStep_Isolated(t *testing.T) { } } +func testRepoRoot(t *testing.T) string { + t.Helper() + cmd := exec.Command("git", "rev-parse", "--show-toplevel") + out, err := cmd.Output() + if err != nil { + t.Fatalf("resolve repo root: %v", err) + } + return string(bytesTrimSpace(out)) +} + +func bytesTrimSpace(in []byte) []byte { + for len(in) > 0 && (in[len(in)-1] == '\n' || in[len(in)-1] == '\r' || in[len(in)-1] == ' ' || in[len(in)-1] == '\t') { + in = in[:len(in)-1] + } + return in +} + +func createGitRepo(t *testing.T) string { + t.Helper() + repoRoot := t.TempDir() + run := func(args ...string) { + t.Helper() + cmd := exec.Command(args[0], args[1:]...) + cmd.Dir = repoRoot + if out, err := cmd.CombinedOutput(); err != nil { + t.Fatalf("%s failed: %v\n%s", args, err, string(out)) + } + } + + run("git", "init") + run("git", "config", "user.email", "tests@example.com") + run("git", "config", "user.name", "Codencer Tests") + if err := os.WriteFile(filepath.Join(repoRoot, "README.md"), []byte("repo"), 0644); err != nil { + t.Fatal(err) + } + run("git", "add", "README.md") + run("git", "commit", "-m", "init") + return repoRoot +} + +type cancelAwareAdapter struct { + running bool + cancelCalled bool +} + +func (a *cancelAwareAdapter) Name() string { return "cancel-aware" } +func (a *cancelAwareAdapter) Capabilities() []string { return []string{"mock"} } +func (a *cancelAwareAdapter) Start(ctx context.Context, step *domain.Step, attempt *domain.Attempt, workspaceRoot, attemptArtifactRoot string) error { + a.running = true + return nil +} +func (a *cancelAwareAdapter) Poll(ctx context.Context, attemptID string) (bool, error) { + return a.running, nil +} +func (a *cancelAwareAdapter) Cancel(ctx context.Context, attemptID string) error { + a.cancelCalled = true + a.running = false + return nil +} +func (a *cancelAwareAdapter) CollectArtifacts(ctx context.Context, attemptID, attemptArtifactRoot string) ([]*domain.Artifact, error) { + return nil, nil +} +func (a *cancelAwareAdapter) NormalizeResult(ctx context.Context, attemptID string, artifacts []*domain.Artifact) (*domain.ResultSpec, error) { + return &domain.ResultSpec{State: domain.StepStateCompleted, Summary: "should not complete"}, nil +} + +type stubbornAdapter struct{} + +func (a *stubbornAdapter) Name() string { return "stubborn" } +func (a *stubbornAdapter) Capabilities() []string { return []string{"mock"} } +func (a *stubbornAdapter) Start(ctx context.Context, step *domain.Step, attempt *domain.Attempt, workspaceRoot, attemptArtifactRoot string) error { + return nil +} +func (a *stubbornAdapter) Poll(ctx context.Context, attemptID string) (bool, error) { return true, nil } +func (a *stubbornAdapter) Cancel(ctx context.Context, attemptID string) error { return nil } +func (a *stubbornAdapter) CollectArtifacts(ctx context.Context, attemptID, attemptArtifactRoot string) ([]*domain.Artifact, error) { + return nil, nil +} +func (a *stubbornAdapter) NormalizeResult(ctx context.Context, attemptID string, artifacts []*domain.Artifact) (*domain.ResultSpec, error) { + return &domain.ResultSpec{State: domain.StepStateCompleted, Summary: "should not complete"}, nil +} + // FailingMockAdapter simulates various terminal failure states type FailingMockAdapter struct { FailState domain.StepState @@ -276,8 +358,8 @@ func (m *PollErrorMockAdapter) Poll(ctx context.Context, attemptID string) (bool return false, errors.New("Poll failed") // Just some error } func (m *PollErrorMockAdapter) Cancel(ctx context.Context, attemptID string) error { return nil } -func (m *PollErrorMockAdapter) Capabilities() []string { return []string{"mock"} } -func (m *PollErrorMockAdapter) Name() string { return "poll-error-mock" } +func (m *PollErrorMockAdapter) Capabilities() []string { return []string{"mock"} } +func (m *PollErrorMockAdapter) Name() string { return "poll-error-mock" } func (m *PollErrorMockAdapter) CollectArtifacts(ctx context.Context, attemptID, attemptArtifactRoot string) ([]*domain.Artifact, error) { return nil, nil } @@ -392,14 +474,14 @@ func TestRunService_DispatchStep_ImmutableNamespacing(t *testing.T) { t.Fatalf("DispatchStep 2 failed: %v", err) } t.Log("Attempt 2 finished") - + attempts, _ = attemptsRepo.ListByStep(ctx, step.ID) if len(attempts) != 2 { t.Fatalf("Expected 2 attempts, got %d", len(attempts)) } attempt2 := attempts[1] path2 := filepath.Join(artifactRoot, runID, step.ID, attempt2.ID) - + if _, err := os.Stat(path2); err != nil { t.Errorf("Expected artifact dir for Attempt 2 to exist: %v", err) } @@ -754,6 +836,248 @@ func TestRunService_Isolation_ProvisionedWorktree(t *testing.T) { } } +func TestRunService_DispatchStep_UsesConfiguredRepoRootOutsideCWD(t *testing.T) { + repoRoot := createGitRepo(t) + otherDir := t.TempDir() + prevWD, err := os.Getwd() + if err != nil { + t.Fatal(err) + } + defer func() { _ = os.Chdir(prevWD) }() + if err := os.Chdir(otherDir); err != nil { + t.Fatal(err) + } + + dbPath := filepath.Join(t.TempDir(), "test.db") + db, _ := sql.Open("sqlite3", dbPath) + defer db.Close() + _ = sqlite.RunMigrations(db) + + runsRepo := sqlite.NewRunsRepo(db) + phasesRepo := sqlite.NewPhasesRepo(db) + stepsRepo := sqlite.NewStepsRepo(db) + attemptsRepo := sqlite.NewAttemptsRepo(db) + gatesRepo := sqlite.NewGatesRepo(db) + artifactsRepo := sqlite.NewArtifactsRepo(db) + validationsRepo := sqlite.NewValidationsRepo(db) + benchmarksRepo := sqlite.NewBenchmarksRepo(db) + + runSvc := service.NewRunService( + runsRepo, phasesRepo, stepsRepo, attemptsRepo, gatesRepo, artifactsRepo, validationsRepo, + service.NewRoutingService(benchmarksRepo, map[string]domain.Adapter{"mock-adapter": &MockAdapter{}}), + service.NewPolicyRegistry(), + workspace.NewNullProvisioner(), + filepath.Join(t.TempDir(), "artifacts"), + filepath.Join(t.TempDir(), "workspace"), + repoRoot, + ) + + ctx := context.Background() + runID := "repo-root-run" + _, _ = runSvc.StartRun(ctx, runID, "project", "", "", "") + step := &domain.Step{ + ID: "repo-root-step", + PhaseID: "phase-execution-" + runID, + Title: "Repo Root Step", + Adapter: "mock-adapter", + } + + if err := runSvc.DispatchStep(ctx, runID, step); err != nil { + t.Fatalf("DispatchStep failed outside repo cwd: %v", err) + } + + result, err := runSvc.GetResultByStep(ctx, step.ID) + if err != nil { + t.Fatal(err) + } + if result.RunID != runID { + t.Fatalf("expected result run ID %s, got %s", runID, result.RunID) + } +} + +func TestRunService_AbortRunCancelsActiveAttempt(t *testing.T) { + repoRoot := testRepoRoot(t) + dbPath := filepath.Join(t.TempDir(), "test.db") + db, _ := sql.Open("sqlite3", dbPath) + defer db.Close() + _ = sqlite.RunMigrations(db) + + runsRepo := sqlite.NewRunsRepo(db) + phasesRepo := sqlite.NewPhasesRepo(db) + stepsRepo := sqlite.NewStepsRepo(db) + attemptsRepo := sqlite.NewAttemptsRepo(db) + gatesRepo := sqlite.NewGatesRepo(db) + artifactsRepo := sqlite.NewArtifactsRepo(db) + validationsRepo := sqlite.NewValidationsRepo(db) + benchmarksRepo := sqlite.NewBenchmarksRepo(db) + + adapter := &cancelAwareAdapter{} + runSvc := service.NewRunService( + runsRepo, phasesRepo, stepsRepo, attemptsRepo, gatesRepo, artifactsRepo, validationsRepo, + service.NewRoutingService(benchmarksRepo, map[string]domain.Adapter{"cancel-aware": adapter}), + service.NewPolicyRegistry(), + workspace.NewNullProvisioner(), + filepath.Join(t.TempDir(), "artifacts"), + filepath.Join(t.TempDir(), "workspace"), + repoRoot, + ) + + ctx := context.Background() + runID := "abort-run" + _, _ = runSvc.StartRun(ctx, runID, "project", "", "", "") + step := &domain.Step{ + ID: "abort-step", + PhaseID: "phase-execution-" + runID, + Title: "Abort Step", + Adapter: "cancel-aware", + } + + done := make(chan error, 1) + go func() { done <- runSvc.DispatchStep(context.Background(), runID, step) }() + + time.Sleep(500 * time.Millisecond) + if err := runSvc.AbortRun(ctx, runID); err != nil { + t.Fatalf("AbortRun failed: %v", err) + } + if err := <-done; err != nil { + t.Fatalf("DispatchStep failed after abort: %v", err) + } + if !adapter.cancelCalled { + t.Fatal("expected adapter cancel to be invoked") + } + + run, _ := runSvc.GetRun(ctx, runID) + if run.State != domain.RunStateCancelled { + t.Fatalf("expected run state cancelled, got %s", run.State) + } + stepState, _ := runSvc.GetStep(ctx, step.ID) + if stepState.State != domain.StepStateCancelled { + t.Fatalf("expected step state cancelled, got %s", stepState.State) + } +} + +func TestRunService_AbortRunWithoutConfirmedStopFailsClosed(t *testing.T) { + repoRoot := testRepoRoot(t) + dbPath := filepath.Join(t.TempDir(), "test.db") + db, _ := sql.Open("sqlite3", dbPath) + defer db.Close() + _ = sqlite.RunMigrations(db) + + runsRepo := sqlite.NewRunsRepo(db) + phasesRepo := sqlite.NewPhasesRepo(db) + stepsRepo := sqlite.NewStepsRepo(db) + attemptsRepo := sqlite.NewAttemptsRepo(db) + gatesRepo := sqlite.NewGatesRepo(db) + artifactsRepo := sqlite.NewArtifactsRepo(db) + validationsRepo := sqlite.NewValidationsRepo(db) + benchmarksRepo := sqlite.NewBenchmarksRepo(db) + + runSvc := service.NewRunService( + runsRepo, phasesRepo, stepsRepo, attemptsRepo, gatesRepo, artifactsRepo, validationsRepo, + service.NewRoutingService(benchmarksRepo, map[string]domain.Adapter{"stubborn": &stubbornAdapter{}}), + service.NewPolicyRegistry(), + workspace.NewNullProvisioner(), + filepath.Join(t.TempDir(), "artifacts"), + filepath.Join(t.TempDir(), "workspace"), + repoRoot, + ) + + ctx := context.Background() + runID := "stubborn-run" + _, _ = runSvc.StartRun(ctx, runID, "project", "", "", "") + step := &domain.Step{ + ID: "stubborn-step", + PhaseID: "phase-execution-" + runID, + Title: "Stubborn Step", + Adapter: "stubborn", + } + + done := make(chan error, 1) + go func() { done <- runSvc.DispatchStep(context.Background(), runID, step) }() + + time.Sleep(500 * time.Millisecond) + if err := runSvc.AbortRun(ctx, runID); err != nil { + t.Fatalf("AbortRun failed: %v", err) + } + if err := <-done; err != nil { + t.Fatalf("DispatchStep failed after stubborn abort: %v", err) + } + + run, _ := runSvc.GetRun(ctx, runID) + if run.State == domain.RunStateCancelled { + t.Fatalf("expected stubborn abort to avoid reporting cancelled") + } + stepState, _ := runSvc.GetStep(ctx, step.ID) + if stepState.State != domain.StepStateNeedsManualAttention { + t.Fatalf("expected step state needs_manual_attention, got %s", stepState.State) + } +} + +type warningAdapter struct{} + +func (a *warningAdapter) Name() string { return "warning-adapter" } +func (a *warningAdapter) Capabilities() []string { return []string{"mock"} } +func (a *warningAdapter) Start(ctx context.Context, step *domain.Step, attempt *domain.Attempt, workspaceRoot, attemptArtifactRoot string) error { + return nil +} +func (a *warningAdapter) Poll(ctx context.Context, attemptID string) (bool, error) { return false, nil } +func (a *warningAdapter) Cancel(ctx context.Context, attemptID string) error { return nil } +func (a *warningAdapter) CollectArtifacts(ctx context.Context, attemptID, attemptArtifactRoot string) ([]*domain.Artifact, error) { + return nil, nil +} +func (a *warningAdapter) NormalizeResult(ctx context.Context, attemptID string, artifacts []*domain.Artifact) (*domain.ResultSpec, error) { + return &domain.ResultSpec{Version: "v1", State: domain.StepStateCompletedWithWarnings, Summary: "completed with warnings"}, nil +} + +func TestRunService_DispatchStep_PreservesCompletedWithWarningsAndCompletesRun(t *testing.T) { + dbPath := filepath.Join(t.TempDir(), "test.db") + db, _ := sql.Open("sqlite3", dbPath) + defer db.Close() + _ = sqlite.RunMigrations(db) + + runsRepo := sqlite.NewRunsRepo(db) + phasesRepo := sqlite.NewPhasesRepo(db) + stepsRepo := sqlite.NewStepsRepo(db) + attemptsRepo := sqlite.NewAttemptsRepo(db) + gatesRepo := sqlite.NewGatesRepo(db) + artifactsRepo := sqlite.NewArtifactsRepo(db) + validationsRepo := sqlite.NewValidationsRepo(db) + benchmarksRepo := sqlite.NewBenchmarksRepo(db) + + runSvc := service.NewRunService( + runsRepo, phasesRepo, stepsRepo, attemptsRepo, gatesRepo, artifactsRepo, validationsRepo, + service.NewRoutingService(benchmarksRepo, map[string]domain.Adapter{"warning": &warningAdapter{}}), + service.NewPolicyRegistry(), + workspace.NewNullProvisioner(), + filepath.Join(t.TempDir(), "artifacts"), + filepath.Join(t.TempDir(), "workspace"), + ) + + ctx := context.Background() + runID := "warning-run" + _, _ = runSvc.StartRun(ctx, runID, "project", "", "", "") + step := &domain.Step{ + ID: "warning-step", + PhaseID: "phase-execution-" + runID, + Title: "Warning Step", + Adapter: "warning", + } + + if err := runSvc.DispatchStep(ctx, runID, step); err != nil { + t.Fatalf("DispatchStep failed: %v", err) + } + + foundStep, _ := runSvc.GetStep(ctx, step.ID) + if foundStep.State != domain.StepStateCompletedWithWarnings { + t.Fatalf("expected step state completed_with_warnings, got %s", foundStep.State) + } + + run, _ := runSvc.GetRun(ctx, runID) + if run.State != domain.RunStateCompleted { + t.Fatalf("expected run state completed, got %s", run.State) + } +} + type fileProv struct{ MockProvisioner } func (p *fileProv) Provision(ctx context.Context, spec *domain.ProvisioningSpec, baseRepo, workspaceRoot string) (*domain.ProvisioningResult, error) { diff --git a/internal/service/state_reconcile.go b/internal/service/state_reconcile.go new file mode 100644 index 0000000..74f5bb0 --- /dev/null +++ b/internal/service/state_reconcile.go @@ -0,0 +1,48 @@ +package service + +import "agent-bridge/internal/domain" + +func deriveRunState(steps []*domain.Step) domain.RunState { + if len(steps) == 0 { + return domain.RunStateRunning + } + + hasPending := false + hasApproval := false + hasFailure := false + hasCancelled := false + allCompleted := true + + for _, step := range steps { + switch step.State { + case domain.StepStateNeedsApproval: + hasApproval = true + allCompleted = false + case domain.StepStatePending, domain.StepStateDispatching, domain.StepStateRunning, domain.StepStateCollectingArtifacts, domain.StepStateValidating: + hasPending = true + allCompleted = false + case domain.StepStateCompleted, domain.StepStateCompletedWithWarnings: + case domain.StepStateCancelled: + hasCancelled = true + allCompleted = false + default: + hasFailure = true + allCompleted = false + } + } + + switch { + case hasApproval: + return domain.RunStatePausedForGate + case hasPending: + return domain.RunStateRunning + case hasFailure: + return domain.RunStateFailed + case allCompleted: + return domain.RunStateCompleted + case hasCancelled: + return domain.RunStateCancelled + default: + return domain.RunStateRunning + } +} diff --git a/internal/service/state_reconcile_test.go b/internal/service/state_reconcile_test.go new file mode 100644 index 0000000..1708c67 --- /dev/null +++ b/internal/service/state_reconcile_test.go @@ -0,0 +1,56 @@ +package service + +import ( + "testing" + + "agent-bridge/internal/domain" +) + +func TestDeriveRunState(t *testing.T) { + tests := []struct { + name string + steps []*domain.Step + expected domain.RunState + }{ + { + name: "completed when all steps succeeded", + steps: []*domain.Step{ + {State: domain.StepStateCompleted}, + {State: domain.StepStateCompletedWithWarnings}, + }, + expected: domain.RunStateCompleted, + }, + { + name: "failed when any step failed", + steps: []*domain.Step{ + {State: domain.StepStateCompleted}, + {State: domain.StepStateFailedValidation}, + }, + expected: domain.RunStateFailed, + }, + { + name: "paused for gate when approval is pending", + steps: []*domain.Step{ + {State: domain.StepStateCompleted}, + {State: domain.StepStateNeedsApproval}, + }, + expected: domain.RunStatePausedForGate, + }, + { + name: "cancelled when all terminal steps were cancelled", + steps: []*domain.Step{ + {State: domain.StepStateCancelled}, + {State: domain.StepStateCancelled}, + }, + expected: domain.RunStateCancelled, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + if got := deriveRunState(tt.steps); got != tt.expected { + t.Fatalf("expected %s, got %s", tt.expected, got) + } + }) + } +} diff --git a/internal/storage/sqlite/artifacts_repo.go b/internal/storage/sqlite/artifacts_repo.go index 898952f..0d7f16c 100644 --- a/internal/storage/sqlite/artifacts_repo.go +++ b/internal/storage/sqlite/artifacts_repo.go @@ -27,6 +27,35 @@ func (r *ArtifactsRepo) Create(ctx context.Context, artifact *domain.Artifact) e return nil } +// Get retrieves a single artifact by ID. +func (r *ArtifactsRepo) Get(ctx context.Context, id string) (*domain.Artifact, error) { + q := `SELECT id, attempt_id, type, name, path, size, hash, mime_type, created_at, updated_at FROM artifacts WHERE id = ?` + row := r.db.QueryRowContext(ctx, q, id) + + var artifact domain.Artifact + var artifactType string + if err := row.Scan( + &artifact.ID, + &artifact.AttemptID, + &artifactType, + &artifact.Name, + &artifact.Path, + &artifact.Size, + &artifact.Hash, + &artifact.MimeType, + &artifact.CreatedAt, + &artifact.UpdatedAt, + ); err != nil { + if err == sql.ErrNoRows { + return nil, nil + } + return nil, fmt.Errorf("failed to get artifact %s: %w", id, err) + } + + artifact.Type = domain.ArtifactType(artifactType) + return &artifact, nil +} + // ListByStep retrieves all artifacts for all attempts of a step. func (r *ArtifactsRepo) ListByStep(ctx context.Context, stepID string) ([]*domain.Artifact, error) { q := ` diff --git a/schemas/result.schema.json b/schemas/result.schema.json index 6c22a92..01c30f5 100644 --- a/schemas/result.schema.json +++ b/schemas/result.schema.json @@ -13,7 +13,7 @@ "adapter": { "type": "string" }, "state": { "type": "string", - "description": "Terminal outcomes reported to the planner: completed (success), failed_terminal (failure), timeout (limit exceeded), cancelled (aborted), needs_manual_attention (blocked/review).", + "description": "Bridge-reported step state. Terminal states include completed, completed_with_warnings, needs_manual_attention, failed_retryable, failed_terminal, failed_validation, failed_adapter, failed_bridge, timeout, and cancelled.", "enum": [ "pending", "dispatching", @@ -26,6 +26,9 @@ "needs_manual_attention", "failed_retryable", "failed_terminal", + "failed_validation", + "failed_adapter", + "failed_bridge", "timeout", "cancelled" ] From bce0351b1e2f2ed5e5416ba980ce34e8dde5ca66 Mon Sep 17 00:00:00 2001 From: Lukman Nuriakhmetov Date: Mon, 13 Apr 2026 01:32:39 +0300 Subject: [PATCH 02/12] chore: clean and harden Codencer v2 alpha surfaces Remove tracked local build output and collapse duplicate public command entrypoints by deleting the legacy connector and relayd mains and keeping codencer-connectord and codencer-relayd as the canonical binaries. Update build ignores and the Makefile so local command artifacts are not recommitted and duplicate bin targets are not produced. Tighten daemon async dispatch and abort handling by moving background step submission onto RunService.DispatchStepAsync, reusing that path for retry dispatch, and making abort report success only when the active step actually reaches cancelled. Fail closed when no execution was registered or when adapter cancellation is not confirmed, and cover the immediate-abort race with focused service tests. Clarify MCP hierarchy and public surfaces by marking the daemon-local /mcp/call endpoint as a legacy local compatibility/admin bridge, keeping the relay MCP as the canonical remote integration surface, and adding explicit surface headers to distinguish the two. Bring runtime truth and docs back into alignment across README, relay, connector, self-host, MCP, and v2 contract notes so the repo now documents the actual alpha-grade guarantees and limitations: no raw shell, no arbitrary filesystem browsing, narrow remote routing, best-effort abort, bounded artifact transport, and static self-host auth. Verification: gofmt -w on touched Go files; go test ./internal/service ./internal/app ./internal/relay ./internal/connector ./internal/mcp -count=1; go test ./... -count=1 --- .gitignore | 10 ++ CHANGELOG.md | 2 + Makefile | 4 - README.md | 10 +- cmd/broker/agent-broker | Bin 7424200 -> 0 bytes cmd/connector/main.go | 68 -------------- cmd/relayd/main.go | 34 ------- docs/CONNECTOR.md | 5 + docs/RELAY.md | 5 +- docs/SELF_HOST_REFERENCE.md | 2 +- docs/design/v2_relay_contracts.md | 93 ++++++++++--------- docs/mcp/integrations.md | 1 + docs/mcp/relay_tools.md | 1 + internal/app/routes.go | 11 ++- internal/mcp/server.go | 4 +- internal/mcp/tools.go | 39 ++++---- internal/relay/mcp_server.go | 1 + internal/service/run_service.go | 109 ++++++++++++++++++---- internal/service/run_service_test.go | 133 ++++++++++++++++++++++++++- 19 files changed, 325 insertions(+), 207 deletions(-) delete mode 100755 cmd/broker/agent-broker delete mode 100644 cmd/connector/main.go delete mode 100644 cmd/relayd/main.go diff --git a/.gitignore b/.gitignore index c73cd06..d8f3e8e 100644 --- a/.gitignore +++ b/.gitignore @@ -3,6 +3,16 @@ bin/ orchestratorctl !cmd/orchestratorctl/ !cmd/orchestratorctl/*.go +/cmd/broker/agent-broker +/cmd/broker/agent-broker.exe +/cmd/codencer-connectord/codencer-connectord +/cmd/codencer-connectord/codencer-connectord.exe +/cmd/codencer-relayd/codencer-relayd +/cmd/codencer-relayd/codencer-relayd.exe +/cmd/orchestratord/orchestratord +/cmd/orchestratord/orchestratord.exe +/cmd/orchestratorctl/orchestratorctl +/cmd/orchestratorctl/orchestratorctl.exe *.test *.out service.test diff --git a/CHANGELOG.md b/CHANGELOG.md index d39bca9..e573b9c 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -21,6 +21,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0 - Rewrote operator-facing v2 docs to match the implemented local/self-host path and current runtime truth. - Clarified that the relay is the public remote HTTP/MCP surface and the daemon-local `/mcp/call` endpoint is only a local compatibility/admin surface. - Documented current self-host alpha limitations explicitly: best-effort abort, opportunistic resource routing, bounded artifact transport, and static-token auth. +- Removed duplicate public connector/relay binary surfaces in favor of the canonical `codencer-connectord` and `codencer-relayd` entrypoints. +- Tightened abort reporting so Codencer only reports success when the active step really reaches `cancelled`. - **Unified v1 Documentation Truth-Pass**: Cleaned and synchronized all public-facing docs (README, AI Guide, Runbook, Automation) for 100% alignment with the CLI contract. - Expanded automation documentation to make the shell-planner story explicit and machine-oriented. - Clarified that ordered task execution in v1 is wrapper-based and not a native workflow engine. diff --git a/Makefile b/Makefile index 83e0aff..0a86b9a 100644 --- a/Makefile +++ b/Makefile @@ -5,12 +5,8 @@ build: @go build -ldflags "-X agent-bridge/internal/app.Version=v1.0-release-candidate" -o bin/orchestratord ./cmd/orchestratord @echo "==> Building orchestratorctl..." @go build -ldflags "-X agent-bridge/internal/app.Version=v1.0-release-candidate" -o bin/orchestratorctl ./cmd/orchestratorctl - @echo "==> Building connector..." - @go build -ldflags "-X agent-bridge/internal/app.Version=v1.0-release-candidate" -o bin/connector ./cmd/connector @echo "==> Building codencer-connectord..." @go build -ldflags "-X agent-bridge/internal/app.Version=v1.0-release-candidate" -o bin/codencer-connectord ./cmd/codencer-connectord - @echo "==> Building relayd..." - @go build -ldflags "-X agent-bridge/internal/app.Version=v1.0-release-candidate" -o bin/relayd ./cmd/relayd @echo "==> Building codencer-relayd..." @go build -ldflags "-X agent-bridge/internal/app.Version=v1.0-release-candidate" -o bin/codencer-relayd ./cmd/codencer-relayd diff --git a/README.md b/README.md index efa8b62..9674b0d 100644 --- a/README.md +++ b/README.md @@ -5,8 +5,8 @@ Codencer is a tactical orchestration bridge that manages execution, isolation, a Designed for **local-first, self-hosted developer toolchains**, Codencer provides the missing "relay" layer that ensures every task attempt is isolated, provisioned, and validated before it ever reaches your production branch. > [!IMPORTANT] -> **Project Status: Public Beta (v1.0-release-candidate)**. -> Codencer is a hardened, production-oriented local orchestration bridge. While the core engine is stable and has been verified through rigorous internal audit paths, the API and protocols are finalized for the v1.0 release. +> **Project Status: Open-source alpha for the v2 local/self-host path**. +> Codencer is coherent and buildable for disciplined local and self-host use, but the current relay, auth, artifact transport, and cancellation guarantees are still alpha-grade and documented honestly below. --- @@ -53,8 +53,8 @@ Key constraints remain unchanged: ### New Binaries -- `bin/connector` and `bin/codencer-connectord`: enroll with a relay and maintain the outbound authenticated connector session -- `bin/relayd` and `bin/codencer-relayd`: run the self-hostable relay server, planner-facing API, connector websocket endpoint, and relay-side MCP surface +- `bin/codencer-connectord`: enroll with a relay and maintain the outbound authenticated connector session +- `bin/codencer-relayd`: run the self-hostable relay server, planner-facing API, connector websocket endpoint, and relay-side MCP surface ### Self-Host Quickstart @@ -75,7 +75,7 @@ For the end-to-end self-host flow and operating notes, see [docs/SELF_HOST_REFER Daemon discovery and evidence notes: - `GET /api/v1/instance` now exposes stable repo-local daemon identity plus manifest-backed discovery metadata. - The daemon writes a repo-local instance manifest under `.codencer/instance.json` on startup and after Antigravity bind changes. -- `PATCH /api/v1/runs/{id}` remains best-effort abort. Codencer does not claim hard process cancellation unless the adapter actually stops. +- `PATCH /api/v1/runs/{id}` remains best-effort abort. It returns success only when the active step actually reaches `cancelled`; otherwise Codencer leaves an explicit non-cancelled outcome and returns an error instead of claiming a hard kill. --- diff --git a/cmd/broker/agent-broker b/cmd/broker/agent-broker deleted file mode 100755 index b512c8fbe478ac884950905b5f41b1a34824a3df..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 7424200 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

r>vxjQV{Ebh-OQ+8oW&ZLB)As;ognw% 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�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

VF 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

GdW~#!qYnjZ^AGmQTj%$%*Xe_? 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%0DE|wi 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

dx97*JOSkJx8N0k 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 I07q#Ky)Yi@O*t==ss76MgnapSwn%W24VyW>mzg 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 )ff*iRtLaZ#svG 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

wi;-g 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