{"owner":"goodrain","repo":"rainbond","hasSkills":true,"hasMcp":false,"mcpConfig":null,"found":["AGENTS.md","CLAUDE.md"],"skills":{"AGENTS.md":"# Rainbond — Go Core Services\n\n## Overview\n\nRainbond is a cloud-native application management platform. This repository contains the Go backend services that interface directly with Kubernetes. It is called by `rainbond-console` (Django) via HTTP REST APIs.\n\n- Language: Go 1.23\n- Module: `github.com/goodrain/rainbond`\n- Router: go-chi/chi\n- ORM: jinzhu/gorm (v1)\n- Logging: sirupsen/logrus\n- Vendor: dependencies vendored in `vendor/`\n\n## Binary Components\n\nEntry points in `cmd/`:\n\n| Binary | Description |\n|--------|-------------|\n| `cmd/api` | REST API server (the main service called by console) |\n| `cmd/builder` | Source code build and image build service |\n| `cmd/worker` | Application runtime management, Kubernetes operator |\n| `cmd/mq` | Message queue service for async tasks |\n| `cmd/grctl` | CLI tool for cluster management |\n| `cmd/init-probe` | Init container health probe |\n\n## Key Directories\n\n```\napi/\n  api_routers/version2/  — chi route registration (v2Routers.go)\n  controller/            — HTTP handlers (request parsing, response writing)\n  handler/               — Business logic layer\n  model/                 — API request/response structs\n  middleware/             — Auth, tenant context, CORS\n  proxy/                 — Reverse proxy utilities\ndb/\n  model/                 — GORM model definitions (database schema)\n  dao/                   — Data access objects (CRUD operations)\n  mysql/                 — MySQL-specific DAO implementations\nbuilder/                 — Build system (source code, Docker, slug)\nworker/                  — Kubernetes controller/operator logic\npkg/\n  apis/rainbond/v1alpha1/ — CRD type definitions\n  component/             — Shared components (k8s client, storage)\nutil/\n  http/                  — HTTP response helpers (ReturnSuccess, ReturnError, ReturnBcodeError)\n```\n\n## Architecture: Request Flow\n\n```\nHTTP Request → chi Router → Middleware → Controller → Handler → DAO → Database\n                                                        ↓\n                                                   Kubernetes API\n```\n\n- Controllers: parse HTTP request, validate input, call handler, write response\n- Handlers: business logic, orchestrate DAO calls and K8s operations\n- DAOs: database CRUD via GORM\n\n## Adding a New API Endpoint\n\n1. Define request/response structs in `api/model/`\n2. Add GORM model in `db/model/` if new table needed\n3. Add DAO interface in `db/dao/` and implementation in `db/mysql/`\n4. Implement business logic in `api/handler/`\n5. Add controller method in `api/controller/`\n6. Register route in `api/api_routers/version2/v2Routers.go`\n\n## Code Patterns\n\n### Controller Pattern\n```go\nfunc (t *TenantStruct) CreateSomething(w http.ResponseWriter, r *http.Request) {\n    var req model.CreateSomethingRequest\n    if !httputil.ValidatorRequestStructAndErrorResponse(r, w, &req, nil) {\n        return\n    }\n    // Extract context values\n    tenantID := r.Context().Value(ctxutil.ContextKey(\"tenant_id\")).(string)\n\n    result, err := handler.GetSomethingHandler().Create(tenantID, &req)\n    if err != nil {\n        httputil.ReturnBcodeError(r, w, err)\n        return\n    }\n    httputil.ReturnSuccess(r, w, result)\n}\n```\n\n### Handler Singleton Pattern\n```go\n// In handler package, handlers are accessed via GetXxxHandler() functions\nhandler.GetAppHandler().ExportApp(&tr)\nhandler.GetApplicationHandler().AddConfigGroup(appID, &configReq)\n```\n\n### DAO Access Pattern\n```go\ndb.GetManager().AppDao().AddModel(app)\ndb.GetManager().TenantServiceDao().GetServiceByID(serviceID)\n```\n\n## Cross-Repository Relationship\n\n- This repo is called by `rainbond-console` via `www/apiclient/regionapi.py` (RegionInvokeApi)\n- API base path: `/v2/tenants/{tenant_name}/...`\n- Console sends requests with region token in Authorization header\n\n## Build & Verify\n\n```bash\ngo build ./...          # Compile all packages\ngo vet ./...            # Static analysis\nmake check              # CI lint check (golint on changed files) + test manifest validation\nmake test-manifest-check # Validate test-manifest.json against capability_id markers\nmake build              # Build binaries via localbuild.sh\n```\n\n## Test Manifest (CI-enforced)\n\n`test-manifest.json` is a registry of behavior-guarding tests. Any test annotated\nwith a `capability_id` comment is a \"managed\" test and MUST have a matching entry\nin the manifest, otherwise CI fails.\n\n- Marker: `// capability_id: rainbond.<area>.<behavior>` (Go) or\n  `# capability_id: ...` (Python), placed directly above the test function.\n- Enforced by `scripts/validate_test_manifest.py`, invoked from `make check` and\n  `make test-manifest-check`. Runs in CI as the **Check test manifest** step in\n  `.github/workflows/pr-ci-build.yml` and `release-v6.yml`.\n- `test-manifest.md` is the human-readable table — **auto-generated, never edit by hand**.\n\n### Registering a managed test\n\nDo NOT hand-edit `test-manifest.json`. Use the manager — it inserts in sorted order\nand regenerates `test-manifest.md`:\n\n```bash\npython3 scripts/manage_test_manifest.py add rainbond.<area>.<behavior> \\\n  --title \"Short English summary\" \\\n  --interface-type workflow \\\n  --interface \"builder/sources.buildKitTomlContent\" \\\n  --code-path builder/sources/image.go \\\n  --test builder/sources/buildkit_toml_test.go::TestBuildKitTomlContent \\\n  --test-type regression\n```\n\n- `interface_type`: one of `service_method | view_endpoint | handler_method |\n  dao_method | package_function | workflow | other` (internal funcs/methods use `workflow`).\n- `test_type`: one of `unit | regression | characterization | integration`.\n- Repeat `--code-path` / `--test` for multiple values; `--status` defaults to `active`.\n- Other subcommands: `list`, `show <id>`, `render` (rebuild the `.md`), `prune <id>`.\n\n## Coding Conventions\n\n- Use `logrus` for all logging (not `log` or `fmt.Println`)\n- Use `httputil.ReturnSuccess/ReturnError/ReturnBcodeError` for HTTP responses\n- Use `chi.URLParam(r, \"param\")` for path parameters\n- Use `r.Context().Value(ctxutil.ContextKey(\"key\"))` for middleware-injected values\n- Run `goimports` before committing\n- Error codes defined in `api/util/bcode/`\n- Commit messages in English, Conventional Commits format\n","CLAUDE.md":"# Rainbond — Go Core Services\n\n## Overview\n\nRainbond is a cloud-native application management platform. This repository contains the Go backend services that interface directly with Kubernetes. It is called by `rainbond-console` (Django) via HTTP REST APIs.\n\n- Language: Go 1.23\n- Module: `github.com/goodrain/rainbond`\n- Router: go-chi/chi\n- ORM: jinzhu/gorm (v1)\n- Logging: sirupsen/logrus\n- Vendor: dependencies vendored in `vendor/`\n\n## Binary Components\n\nEntry points in `cmd/`:\n\n| Binary | Description |\n|--------|-------------|\n| `cmd/api` | REST API server (the main service called by console) |\n| `cmd/builder` | Source code build and image build service |\n| `cmd/worker` | Application runtime management, Kubernetes operator |\n| `cmd/mq` | Message queue service for async tasks |\n| `cmd/grctl` | CLI tool for cluster management |\n| `cmd/init-probe` | Init container health probe |\n\n## Key Directories\n\n```\napi/\n  api_routers/version2/  — chi route registration (v2Routers.go)\n  controller/            — HTTP handlers (request parsing, response writing)\n  handler/               — Business logic layer\n  model/                 — API request/response structs\n  middleware/             — Auth, tenant context, CORS\n  proxy/                 — Reverse proxy utilities\ndb/\n  model/                 — GORM model definitions (database schema)\n  dao/                   — Data access objects (CRUD operations)\n  mysql/                 — MySQL-specific DAO implementations\nbuilder/                 — Build system (source code, Docker, slug)\nworker/                  — Kubernetes controller/operator logic\npkg/\n  apis/rainbond/v1alpha1/ — CRD type definitions\n  component/             — Shared components (k8s client, storage)\nutil/\n  http/                  — HTTP response helpers (ReturnSuccess, ReturnError, ReturnBcodeError)\n```\n\n## Architecture: Request Flow\n\n```\nHTTP Request → chi Router → Middleware → Controller → Handler → DAO → Database\n                                                        ↓\n                                                   Kubernetes API\n```\n\n- Controllers: parse HTTP request, validate input, call handler, write response\n- Handlers: business logic, orchestrate DAO calls and K8s operations\n- DAOs: database CRUD via GORM\n\n## Adding a New API Endpoint\n\n1. Define request/response structs in `api/model/`\n2. Add GORM model in `db/model/` if new table needed\n3. Add DAO interface in `db/dao/` and implementation in `db/mysql/`\n4. Implement business logic in `api/handler/`\n5. Add controller method in `api/controller/`\n6. Register route in `api/api_routers/version2/v2Routers.go`\n\n## Code Patterns\n\n### Controller Pattern\n```go\nfunc (t *TenantStruct) CreateSomething(w http.ResponseWriter, r *http.Request) {\n    var req model.CreateSomethingRequest\n    if !httputil.ValidatorRequestStructAndErrorResponse(r, w, &req, nil) {\n        return\n    }\n    // Extract context values\n    tenantID := r.Context().Value(ctxutil.ContextKey(\"tenant_id\")).(string)\n\n    result, err := handler.GetSomethingHandler().Create(tenantID, &req)\n    if err != nil {\n        httputil.ReturnBcodeError(r, w, err)\n        return\n    }\n    httputil.ReturnSuccess(r, w, result)\n}\n```\n\n### Handler Singleton Pattern\n```go\n// In handler package, handlers are accessed via GetXxxHandler() functions\nhandler.GetAppHandler().ExportApp(&tr)\nhandler.GetApplicationHandler().AddConfigGroup(appID, &configReq)\n```\n\n### DAO Access Pattern\n```go\ndb.GetManager().AppDao().AddModel(app)\ndb.GetManager().TenantServiceDao().GetServiceByID(serviceID)\n```\n\n## Cross-Repository Relationship\n\n- This repo is called by `rainbond-console` via `www/apiclient/regionapi.py` (RegionInvokeApi)\n- API base path: `/v2/tenants/{tenant_name}/...`\n- Console sends requests with region token in Authorization header\n\n## Build & Verify\n\n```bash\ngo build ./...          # Compile all packages\ngo vet ./...            # Static analysis\nmake check              # CI lint check (golint on changed files) + test manifest validation\nmake test-manifest-check # Validate test-manifest.json against capability_id markers\nmake build              # Build binaries via localbuild.sh\n```\n\n## Test Manifest (CI-enforced)\n\n`test-manifest.json` is a registry of behavior-guarding tests. Any test annotated\nwith a `capability_id` comment is a \"managed\" test and MUST have a matching entry\nin the manifest, otherwise CI fails.\n\n- Marker: `// capability_id: rainbond.<area>.<behavior>` (Go) or\n  `# capability_id: ...` (Python), placed directly above the test function.\n- Enforced by `scripts/validate_test_manifest.py`, invoked from `make check` and\n  `make test-manifest-check`. Runs in CI as the **Check test manifest** step in\n  `.github/workflows/pr-ci-build.yml` and `release-v6.yml`.\n- `test-manifest.md` is the human-readable table — **auto-generated, never edit by hand**.\n\n### Registering a managed test\n\nDo NOT hand-edit `test-manifest.json`. Use the manager — it inserts in sorted order\nand regenerates `test-manifest.md`:\n\n```bash\npython3 scripts/manage_test_manifest.py add rainbond.<area>.<behavior> \\\n  --title \"Short English summary\" \\\n  --interface-type workflow \\\n  --interface \"builder/sources.buildKitTomlContent\" \\\n  --code-path builder/sources/image.go \\\n  --test builder/sources/buildkit_toml_test.go::TestBuildKitTomlContent \\\n  --test-type regression\n```\n\n- `interface_type`: one of `service_method | view_endpoint | handler_method |\n  dao_method | package_function | workflow | other` (internal funcs/methods use `workflow`).\n- `test_type`: one of `unit | regression | characterization | integration`.\n- Repeat `--code-path` / `--test` for multiple values; `--status` defaults to `active`.\n- Other subcommands: `list`, `show <id>`, `render` (rebuild the `.md`), `prune <id>`.\n\n## Coding Conventions\n\n- Use `logrus` for all logging (not `log` or `fmt.Println`)\n- Use `httputil.ReturnSuccess/ReturnError/ReturnBcodeError` for HTTP responses\n- Use `chi.URLParam(r, \"param\")` for path parameters\n- Use `r.Context().Value(ctxutil.ContextKey(\"key\"))` for middleware-injected values\n- Run `goimports` before committing\n- Error codes defined in `api/util/bcode/`\n- Commit messages in English, Conventional Commits format\n"},"files":{"AGENTS.md":"# Rainbond — Go Core Services\n\n## Overview\n\nRainbond is a cloud-native application management platform. This repository contains the Go backend services that interface directly with Kubernetes. It is called by `rainbond-console` (Django) via HTTP REST APIs.\n\n- Language: Go 1.23\n- Module: `github.com/goodrain/rainbond`\n- Router: go-chi/chi\n- ORM: jinzhu/gorm (v1)\n- Logging: sirupsen/logrus\n- Vendor: dependencies vendored in `vendor/`\n\n## Binary Components\n\nEntry points in `cmd/`:\n\n| Binary | Description |\n|--------|-------------|\n| `cmd/api` | REST API server (the main service called by console) |\n| `cmd/builder` | Source code build and image build service |\n| `cmd/worker` | Application runtime management, Kubernetes operator |\n| `cmd/mq` | Message queue service for async tasks |\n| `cmd/grctl` | CLI tool for cluster management |\n| `cmd/init-probe` | Init container health probe |\n\n## Key Directories\n\n```\napi/\n  api_routers/version2/  — chi route registration (v2Routers.go)\n  controller/            — HTTP handlers (request parsing, response writing)\n  handler/               — Business logic layer\n  model/                 — API request/response structs\n  middleware/             — Auth, tenant context, CORS\n  proxy/                 — Reverse proxy utilities\ndb/\n  model/                 — GORM model definitions (database schema)\n  dao/                   — Data access objects (CRUD operations)\n  mysql/                 — MySQL-specific DAO implementations\nbuilder/                 — Build system (source code, Docker, slug)\nworker/                  — Kubernetes controller/operator logic\npkg/\n  apis/rainbond/v1alpha1/ — CRD type definitions\n  component/             — Shared components (k8s client, storage)\nutil/\n  http/                  — HTTP response helpers (ReturnSuccess, ReturnError, ReturnBcodeError)\n```\n\n## Architecture: Request Flow\n\n```\nHTTP Request → chi Router → Middleware → Controller → Handler → DAO → Database\n                                                        ↓\n                                                   Kubernetes API\n```\n\n- Controllers: parse HTTP request, validate input, call handler, write response\n- Handlers: business logic, orchestrate DAO calls and K8s operations\n- DAOs: database CRUD via GORM\n\n## Adding a New API Endpoint\n\n1. Define request/response structs in `api/model/`\n2. Add GORM model in `db/model/` if new table needed\n3. Add DAO interface in `db/dao/` and implementation in `db/mysql/`\n4. Implement business logic in `api/handler/`\n5. Add controller method in `api/controller/`\n6. Register route in `api/api_routers/version2/v2Routers.go`\n\n## Code Patterns\n\n### Controller Pattern\n```go\nfunc (t *TenantStruct) CreateSomething(w http.ResponseWriter, r *http.Request) {\n    var req model.CreateSomethingRequest\n    if !httputil.ValidatorRequestStructAndErrorResponse(r, w, &req, nil) {\n        return\n    }\n    // Extract context values\n    tenantID := r.Context().Value(ctxutil.ContextKey(\"tenant_id\")).(string)\n\n    result, err := handler.GetSomethingHandler().Create(tenantID, &req)\n    if err != nil {\n        httputil.ReturnBcodeError(r, w, err)\n        return\n    }\n    httputil.ReturnSuccess(r, w, result)\n}\n```\n\n### Handler Singleton Pattern\n```go\n// In handler package, handlers are accessed via GetXxxHandler() functions\nhandler.GetAppHandler().ExportApp(&tr)\nhandler.GetApplicationHandler().AddConfigGroup(appID, &configReq)\n```\n\n### DAO Access Pattern\n```go\ndb.GetManager().AppDao().AddModel(app)\ndb.GetManager().TenantServiceDao().GetServiceByID(serviceID)\n```\n\n## Cross-Repository Relationship\n\n- This repo is called by `rainbond-console` via `www/apiclient/regionapi.py` (RegionInvokeApi)\n- API base path: `/v2/tenants/{tenant_name}/...`\n- Console sends requests with region token in Authorization header\n\n## Build & Verify\n\n```bash\ngo build ./...          # Compile all packages\ngo vet ./...            # Static analysis\nmake check              # CI lint check (golint on changed files) + test manifest validation\nmake test-manifest-check # Validate test-manifest.json against capability_id markers\nmake build              # Build binaries via localbuild.sh\n```\n\n## Test Manifest (CI-enforced)\n\n`test-manifest.json` is a registry of behavior-guarding tests. Any test annotated\nwith a `capability_id` comment is a \"managed\" test and MUST have a matching entry\nin the manifest, otherwise CI fails.\n\n- Marker: `// capability_id: rainbond.<area>.<behavior>` (Go) or\n  `# capability_id: ...` (Python), placed directly above the test function.\n- Enforced by `scripts/validate_test_manifest.py`, invoked from `make check` and\n  `make test-manifest-check`. Runs in CI as the **Check test manifest** step in\n  `.github/workflows/pr-ci-build.yml` and `release-v6.yml`.\n- `test-manifest.md` is the human-readable table — **auto-generated, never edit by hand**.\n\n### Registering a managed test\n\nDo NOT hand-edit `test-manifest.json`. Use the manager — it inserts in sorted order\nand regenerates `test-manifest.md`:\n\n```bash\npython3 scripts/manage_test_manifest.py add rainbond.<area>.<behavior> \\\n  --title \"Short English summary\" \\\n  --interface-type workflow \\\n  --interface \"builder/sources.buildKitTomlContent\" \\\n  --code-path builder/sources/image.go \\\n  --test builder/sources/buildkit_toml_test.go::TestBuildKitTomlContent \\\n  --test-type regression\n```\n\n- `interface_type`: one of `service_method | view_endpoint | handler_method |\n  dao_method | package_function | workflow | other` (internal funcs/methods use `workflow`).\n- `test_type`: one of `unit | regression | characterization | integration`.\n- Repeat `--code-path` / `--test` for multiple values; `--status` defaults to `active`.\n- Other subcommands: `list`, `show <id>`, `render` (rebuild the `.md`), `prune <id>`.\n\n## Coding Conventions\n\n- Use `logrus` for all logging (not `log` or `fmt.Println`)\n- Use `httputil.ReturnSuccess/ReturnError/ReturnBcodeError` for HTTP responses\n- Use `chi.URLParam(r, \"param\")` for path parameters\n- Use `r.Context().Value(ctxutil.ContextKey(\"key\"))` for middleware-injected values\n- Run `goimports` before committing\n- Error codes defined in `api/util/bcode/`\n- Commit messages in English, Conventional Commits format\n","CLAUDE.md":"# Rainbond — Go Core Services\n\n## Overview\n\nRainbond is a cloud-native application management platform. This repository contains the Go backend services that interface directly with Kubernetes. It is called by `rainbond-console` (Django) via HTTP REST APIs.\n\n- Language: Go 1.23\n- Module: `github.com/goodrain/rainbond`\n- Router: go-chi/chi\n- ORM: jinzhu/gorm (v1)\n- Logging: sirupsen/logrus\n- Vendor: dependencies vendored in `vendor/`\n\n## Binary Components\n\nEntry points in `cmd/`:\n\n| Binary | Description |\n|--------|-------------|\n| `cmd/api` | REST API server (the main service called by console) |\n| `cmd/builder` | Source code build and image build service |\n| `cmd/worker` | Application runtime management, Kubernetes operator |\n| `cmd/mq` | Message queue service for async tasks |\n| `cmd/grctl` | CLI tool for cluster management |\n| `cmd/init-probe` | Init container health probe |\n\n## Key Directories\n\n```\napi/\n  api_routers/version2/  — chi route registration (v2Routers.go)\n  controller/            — HTTP handlers (request parsing, response writing)\n  handler/               — Business logic layer\n  model/                 — API request/response structs\n  middleware/             — Auth, tenant context, CORS\n  proxy/                 — Reverse proxy utilities\ndb/\n  model/                 — GORM model definitions (database schema)\n  dao/                   — Data access objects (CRUD operations)\n  mysql/                 — MySQL-specific DAO implementations\nbuilder/                 — Build system (source code, Docker, slug)\nworker/                  — Kubernetes controller/operator logic\npkg/\n  apis/rainbond/v1alpha1/ — CRD type definitions\n  component/             — Shared components (k8s client, storage)\nutil/\n  http/                  — HTTP response helpers (ReturnSuccess, ReturnError, ReturnBcodeError)\n```\n\n## Architecture: Request Flow\n\n```\nHTTP Request → chi Router → Middleware → Controller → Handler → DAO → Database\n                                                        ↓\n                                                   Kubernetes API\n```\n\n- Controllers: parse HTTP request, validate input, call handler, write response\n- Handlers: business logic, orchestrate DAO calls and K8s operations\n- DAOs: database CRUD via GORM\n\n## Adding a New API Endpoint\n\n1. Define request/response structs in `api/model/`\n2. Add GORM model in `db/model/` if new table needed\n3. Add DAO interface in `db/dao/` and implementation in `db/mysql/`\n4. Implement business logic in `api/handler/`\n5. Add controller method in `api/controller/`\n6. Register route in `api/api_routers/version2/v2Routers.go`\n\n## Code Patterns\n\n### Controller Pattern\n```go\nfunc (t *TenantStruct) CreateSomething(w http.ResponseWriter, r *http.Request) {\n    var req model.CreateSomethingRequest\n    if !httputil.ValidatorRequestStructAndErrorResponse(r, w, &req, nil) {\n        return\n    }\n    // Extract context values\n    tenantID := r.Context().Value(ctxutil.ContextKey(\"tenant_id\")).(string)\n\n    result, err := handler.GetSomethingHandler().Create(tenantID, &req)\n    if err != nil {\n        httputil.ReturnBcodeError(r, w, err)\n        return\n    }\n    httputil.ReturnSuccess(r, w, result)\n}\n```\n\n### Handler Singleton Pattern\n```go\n// In handler package, handlers are accessed via GetXxxHandler() functions\nhandler.GetAppHandler().ExportApp(&tr)\nhandler.GetApplicationHandler().AddConfigGroup(appID, &configReq)\n```\n\n### DAO Access Pattern\n```go\ndb.GetManager().AppDao().AddModel(app)\ndb.GetManager().TenantServiceDao().GetServiceByID(serviceID)\n```\n\n## Cross-Repository Relationship\n\n- This repo is called by `rainbond-console` via `www/apiclient/regionapi.py` (RegionInvokeApi)\n- API base path: `/v2/tenants/{tenant_name}/...`\n- Console sends requests with region token in Authorization header\n\n## Build & Verify\n\n```bash\ngo build ./...          # Compile all packages\ngo vet ./...            # Static analysis\nmake check              # CI lint check (golint on changed files) + test manifest validation\nmake test-manifest-check # Validate test-manifest.json against capability_id markers\nmake build              # Build binaries via localbuild.sh\n```\n\n## Test Manifest (CI-enforced)\n\n`test-manifest.json` is a registry of behavior-guarding tests. Any test annotated\nwith a `capability_id` comment is a \"managed\" test and MUST have a matching entry\nin the manifest, otherwise CI fails.\n\n- Marker: `// capability_id: rainbond.<area>.<behavior>` (Go) or\n  `# capability_id: ...` (Python), placed directly above the test function.\n- Enforced by `scripts/validate_test_manifest.py`, invoked from `make check` and\n  `make test-manifest-check`. Runs in CI as the **Check test manifest** step in\n  `.github/workflows/pr-ci-build.yml` and `release-v6.yml`.\n- `test-manifest.md` is the human-readable table — **auto-generated, never edit by hand**.\n\n### Registering a managed test\n\nDo NOT hand-edit `test-manifest.json`. Use the manager — it inserts in sorted order\nand regenerates `test-manifest.md`:\n\n```bash\npython3 scripts/manage_test_manifest.py add rainbond.<area>.<behavior> \\\n  --title \"Short English summary\" \\\n  --interface-type workflow \\\n  --interface \"builder/sources.buildKitTomlContent\" \\\n  --code-path builder/sources/image.go \\\n  --test builder/sources/buildkit_toml_test.go::TestBuildKitTomlContent \\\n  --test-type regression\n```\n\n- `interface_type`: one of `service_method | view_endpoint | handler_method |\n  dao_method | package_function | workflow | other` (internal funcs/methods use `workflow`).\n- `test_type`: one of `unit | regression | characterization | integration`.\n- Repeat `--code-path` / `--test` for multiple values; `--status` defaults to `active`.\n- Other subcommands: `list`, `show <id>`, `render` (rebuild the `.md`), `prune <id>`.\n\n## Coding Conventions\n\n- Use `logrus` for all logging (not `log` or `fmt.Println`)\n- Use `httputil.ReturnSuccess/ReturnError/ReturnBcodeError` for HTTP responses\n- Use `chi.URLParam(r, \"param\")` for path parameters\n- Use `r.Context().Value(ctxutil.ContextKey(\"key\"))` for middleware-injected values\n- Run `goimports` before committing\n- Error codes defined in `api/util/bcode/`\n- Commit messages in English, Conventional Commits format\n"},"items":[{"name":"AGENTS.md","path":"AGENTS.md","title":"AGENTS.md","content":"# Rainbond — Go Core Services\n\n## Overview\n\nRainbond is a cloud-native application management platform. This repository contains the Go backend services that interface directly with Kubernetes. It is called by `rainbond-console` (Django) via HTTP REST APIs.\n\n- Language: Go 1.23\n- Module: `github.com/goodrain/rainbond`\n- Router: go-chi/chi\n- ORM: jinzhu/gorm (v1)\n- Logging: sirupsen/logrus\n- Vendor: dependencies vendored in `vendor/`\n\n## Binary Components\n\nEntry points in `cmd/`:\n\n| Binary | Description |\n|--------|-------------|\n| `cmd/api` | REST API server (the main service called by console) |\n| `cmd/builder` | Source code build and image build service |\n| `cmd/worker` | Application runtime management, Kubernetes operator |\n| `cmd/mq` | Message queue service for async tasks |\n| `cmd/grctl` | CLI tool for cluster management |\n| `cmd/init-probe` | Init container health probe |\n\n## Key Directories\n\n```\napi/\n  api_routers/version2/  — chi route registration (v2Routers.go)\n  controller/            — HTTP handlers (request parsing, response writing)\n  handler/               — Business logic layer\n  model/                 — API request/response structs\n  middleware/             — Auth, tenant context, CORS\n  proxy/                 — Reverse proxy utilities\ndb/\n  model/                 — GORM model definitions (database schema)\n  dao/                   — Data access objects (CRUD operations)\n  mysql/                 — MySQL-specific DAO implementations\nbuilder/                 — Build system (source code, Docker, slug)\nworker/                  — Kubernetes controller/operator logic\npkg/\n  apis/rainbond/v1alpha1/ — CRD type definitions\n  component/             — Shared components (k8s client, storage)\nutil/\n  http/                  — HTTP response helpers (ReturnSuccess, ReturnError, ReturnBcodeError)\n```\n\n## Architecture: Request Flow\n\n```\nHTTP Request → chi Router → Middleware → Controller → Handler → DAO → Database\n                                                        ↓\n                                                   Kubernetes API\n```\n\n- Controllers: parse HTTP request, validate input, call handler, write response\n- Handlers: business logic, orchestrate DAO calls and K8s operations\n- DAOs: database CRUD via GORM\n\n## Adding a New API Endpoint\n\n1. Define request/response structs in `api/model/`\n2. Add GORM model in `db/model/` if new table needed\n3. Add DAO interface in `db/dao/` and implementation in `db/mysql/`\n4. Implement business logic in `api/handler/`\n5. Add controller method in `api/controller/`\n6. Register route in `api/api_routers/version2/v2Routers.go`\n\n## Code Patterns\n\n### Controller Pattern\n```go\nfunc (t *TenantStruct) CreateSomething(w http.ResponseWriter, r *http.Request) {\n    var req model.CreateSomethingRequest\n    if !httputil.ValidatorRequestStructAndErrorResponse(r, w, &req, nil) {\n        return\n    }\n    // Extract context values\n    tenantID := r.Context().Value(ctxutil.ContextKey(\"tenant_id\")).(string)\n\n    result, err := handler.GetSomethingHandler().Create(tenantID, &req)\n    if err != nil {\n        httputil.ReturnBcodeError(r, w, err)\n        return\n    }\n    httputil.ReturnSuccess(r, w, result)\n}\n```\n\n### Handler Singleton Pattern\n```go\n// In handler package, handlers are accessed via GetXxxHandler() functions\nhandler.GetAppHandler().ExportApp(&tr)\nhandler.GetApplicationHandler().AddConfigGroup(appID, &configReq)\n```\n\n### DAO Access Pattern\n```go\ndb.GetManager().AppDao().AddModel(app)\ndb.GetManager().TenantServiceDao().GetServiceByID(serviceID)\n```\n\n## Cross-Repository Relationship\n\n- This repo is called by `rainbond-console` via `www/apiclient/regionapi.py` (RegionInvokeApi)\n- API base path: `/v2/tenants/{tenant_name}/...`\n- Console sends requests with region token in Authorization header\n\n## Build & Verify\n\n```bash\ngo build ./...          # Compile all packages\ngo vet ./...            # Static analysis\nmake check              # CI lint check (golint on changed files) + test manifest validation\nmake test-manifest-check # Validate test-manifest.json against capability_id markers\nmake build              # Build binaries via localbuild.sh\n```\n\n## Test Manifest (CI-enforced)\n\n`test-manifest.json` is a registry of behavior-guarding tests. Any test annotated\nwith a `capability_id` comment is a \"managed\" test and MUST have a matching entry\nin the manifest, otherwise CI fails.\n\n- Marker: `// capability_id: rainbond.<area>.<behavior>` (Go) or\n  `# capability_id: ...` (Python), placed directly above the test function.\n- Enforced by `scripts/validate_test_manifest.py`, invoked from `make check` and\n  `make test-manifest-check`. Runs in CI as the **Check test manifest** step in\n  `.github/workflows/pr-ci-build.yml` and `release-v6.yml`.\n- `test-manifest.md` is the human-readable table — **auto-generated, never edit by hand**.\n\n### Registering a managed test\n\nDo NOT hand-edit `test-manifest.json`. Use the manager — it inserts in sorted order\nand regenerates `test-manifest.md`:\n\n```bash\npython3 scripts/manage_test_manifest.py add rainbond.<area>.<behavior> \\\n  --title \"Short English summary\" \\\n  --interface-type workflow \\\n  --interface \"builder/sources.buildKitTomlContent\" \\\n  --code-path builder/sources/image.go \\\n  --test builder/sources/buildkit_toml_test.go::TestBuildKitTomlContent \\\n  --test-type regression\n```\n\n- `interface_type`: one of `service_method | view_endpoint | handler_method |\n  dao_method | package_function | workflow | other` (internal funcs/methods use `workflow`).\n- `test_type`: one of `unit | regression | characterization | integration`.\n- Repeat `--code-path` / `--test` for multiple values; `--status` defaults to `active`.\n- Other subcommands: `list`, `show <id>`, `render` (rebuild the `.md`), `prune <id>`.\n\n## Coding Conventions\n\n- Use `logrus` for all logging (not `log` or `fmt.Println`)\n- Use `httputil.ReturnSuccess/ReturnError/ReturnBcodeError` for HTTP responses\n- Use `chi.URLParam(r, \"param\")` for path parameters\n- Use `r.Context().Value(ctxutil.ContextKey(\"key\"))` for middleware-injected values\n- Run `goimports` before committing\n- Error codes defined in `api/util/bcode/`\n- Commit messages in English, Conventional Commits format\n","category":"root","tokens":1549},{"name":"CLAUDE.md","path":"CLAUDE.md","title":"CLAUDE.md","content":"# Rainbond — Go Core Services\n\n## Overview\n\nRainbond is a cloud-native application management platform. This repository contains the Go backend services that interface directly with Kubernetes. It is called by `rainbond-console` (Django) via HTTP REST APIs.\n\n- Language: Go 1.23\n- Module: `github.com/goodrain/rainbond`\n- Router: go-chi/chi\n- ORM: jinzhu/gorm (v1)\n- Logging: sirupsen/logrus\n- Vendor: dependencies vendored in `vendor/`\n\n## Binary Components\n\nEntry points in `cmd/`:\n\n| Binary | Description |\n|--------|-------------|\n| `cmd/api` | REST API server (the main service called by console) |\n| `cmd/builder` | Source code build and image build service |\n| `cmd/worker` | Application runtime management, Kubernetes operator |\n| `cmd/mq` | Message queue service for async tasks |\n| `cmd/grctl` | CLI tool for cluster management |\n| `cmd/init-probe` | Init container health probe |\n\n## Key Directories\n\n```\napi/\n  api_routers/version2/  — chi route registration (v2Routers.go)\n  controller/            — HTTP handlers (request parsing, response writing)\n  handler/               — Business logic layer\n  model/                 — API request/response structs\n  middleware/             — Auth, tenant context, CORS\n  proxy/                 — Reverse proxy utilities\ndb/\n  model/                 — GORM model definitions (database schema)\n  dao/                   — Data access objects (CRUD operations)\n  mysql/                 — MySQL-specific DAO implementations\nbuilder/                 — Build system (source code, Docker, slug)\nworker/                  — Kubernetes controller/operator logic\npkg/\n  apis/rainbond/v1alpha1/ — CRD type definitions\n  component/             — Shared components (k8s client, storage)\nutil/\n  http/                  — HTTP response helpers (ReturnSuccess, ReturnError, ReturnBcodeError)\n```\n\n## Architecture: Request Flow\n\n```\nHTTP Request → chi Router → Middleware → Controller → Handler → DAO → Database\n                                                        ↓\n                                                   Kubernetes API\n```\n\n- Controllers: parse HTTP request, validate input, call handler, write response\n- Handlers: business logic, orchestrate DAO calls and K8s operations\n- DAOs: database CRUD via GORM\n\n## Adding a New API Endpoint\n\n1. Define request/response structs in `api/model/`\n2. Add GORM model in `db/model/` if new table needed\n3. Add DAO interface in `db/dao/` and implementation in `db/mysql/`\n4. Implement business logic in `api/handler/`\n5. Add controller method in `api/controller/`\n6. Register route in `api/api_routers/version2/v2Routers.go`\n\n## Code Patterns\n\n### Controller Pattern\n```go\nfunc (t *TenantStruct) CreateSomething(w http.ResponseWriter, r *http.Request) {\n    var req model.CreateSomethingRequest\n    if !httputil.ValidatorRequestStructAndErrorResponse(r, w, &req, nil) {\n        return\n    }\n    // Extract context values\n    tenantID := r.Context().Value(ctxutil.ContextKey(\"tenant_id\")).(string)\n\n    result, err := handler.GetSomethingHandler().Create(tenantID, &req)\n    if err != nil {\n        httputil.ReturnBcodeError(r, w, err)\n        return\n    }\n    httputil.ReturnSuccess(r, w, result)\n}\n```\n\n### Handler Singleton Pattern\n```go\n// In handler package, handlers are accessed via GetXxxHandler() functions\nhandler.GetAppHandler().ExportApp(&tr)\nhandler.GetApplicationHandler().AddConfigGroup(appID, &configReq)\n```\n\n### DAO Access Pattern\n```go\ndb.GetManager().AppDao().AddModel(app)\ndb.GetManager().TenantServiceDao().GetServiceByID(serviceID)\n```\n\n## Cross-Repository Relationship\n\n- This repo is called by `rainbond-console` via `www/apiclient/regionapi.py` (RegionInvokeApi)\n- API base path: `/v2/tenants/{tenant_name}/...`\n- Console sends requests with region token in Authorization header\n\n## Build & Verify\n\n```bash\ngo build ./...          # Compile all packages\ngo vet ./...            # Static analysis\nmake check              # CI lint check (golint on changed files) + test manifest validation\nmake test-manifest-check # Validate test-manifest.json against capability_id markers\nmake build              # Build binaries via localbuild.sh\n```\n\n## Test Manifest (CI-enforced)\n\n`test-manifest.json` is a registry of behavior-guarding tests. Any test annotated\nwith a `capability_id` comment is a \"managed\" test and MUST have a matching entry\nin the manifest, otherwise CI fails.\n\n- Marker: `// capability_id: rainbond.<area>.<behavior>` (Go) or\n  `# capability_id: ...` (Python), placed directly above the test function.\n- Enforced by `scripts/validate_test_manifest.py`, invoked from `make check` and\n  `make test-manifest-check`. Runs in CI as the **Check test manifest** step in\n  `.github/workflows/pr-ci-build.yml` and `release-v6.yml`.\n- `test-manifest.md` is the human-readable table — **auto-generated, never edit by hand**.\n\n### Registering a managed test\n\nDo NOT hand-edit `test-manifest.json`. Use the manager — it inserts in sorted order\nand regenerates `test-manifest.md`:\n\n```bash\npython3 scripts/manage_test_manifest.py add rainbond.<area>.<behavior> \\\n  --title \"Short English summary\" \\\n  --interface-type workflow \\\n  --interface \"builder/sources.buildKitTomlContent\" \\\n  --code-path builder/sources/image.go \\\n  --test builder/sources/buildkit_toml_test.go::TestBuildKitTomlContent \\\n  --test-type regression\n```\n\n- `interface_type`: one of `service_method | view_endpoint | handler_method |\n  dao_method | package_function | workflow | other` (internal funcs/methods use `workflow`).\n- `test_type`: one of `unit | regression | characterization | integration`.\n- Repeat `--code-path` / `--test` for multiple values; `--status` defaults to `active`.\n- Other subcommands: `list`, `show <id>`, `render` (rebuild the `.md`), `prune <id>`.\n\n## Coding Conventions\n\n- Use `logrus` for all logging (not `log` or `fmt.Println`)\n- Use `httputil.ReturnSuccess/ReturnError/ReturnBcodeError` for HTTP responses\n- Use `chi.URLParam(r, \"param\")` for path parameters\n- Use `r.Context().Value(ctxutil.ContextKey(\"key\"))` for middleware-injected values\n- Run `goimports` before committing\n- Error codes defined in `api/util/bcode/`\n- Commit messages in English, Conventional Commits format\n","category":"root","tokens":1549}]}