{"owner":"goodrain","repo":"rainbond","hasSkills":true,"totalSkillsCount":5,"totalTokensCount":3623,"categories":["command-prompt","plugin-manifest","root-instruction","claude-rule"],"hasMcp":false,"mcpConfig":null,"found":[".claude/commands/add-api.md","plugins/README.md",".claude/commands/verify.md","AGENTS.md","CLAUDE.md"],"skills":{".claude/commands/add-api.md":"# 新增 Go API 端点\n\n引导开发者在 rainbond Go 后端新增一个 API 端点。\n\n## 请提供以下信息\n\n1. API 路径（例如：`/v2/tenants/{tenant_name}/apps/{app_id}/something`）\n2. HTTP 方法（GET/POST/PUT/DELETE）\n3. 功能描述\n4. 是否需要新的数据库表？\n\n## 实施步骤\n\n按以下顺序创建/修改文件：\n\n### 1. 数据模型（如需新表）\n- 文件：`db/model/` 下对应文件\n- 定义 GORM struct，包含 `TableName()` 方法\n\n### 2. DAO 层\n- 接口：`db/dao/` 下定义接口\n- 实现：`db/mysql/` 下实现接口\n- 注册：在 `db/db.go` 的 Manager 接口中添加\n\n### 3. 请求/响应结构体\n- 文件：`api/model/` 下对应文件\n- 使用 `json` tag 和 `validate` tag\n\n### 4. Handler（业务逻辑）\n- 文件：`api/handler/` 下对应文件\n- 使用 `GetXxxHandler()` 单例模式\n- 调用 DAO 层和 K8s API\n\n### 5. Controller（HTTP 处理）\n- 文件：`api/controller/` 下对应文件\n- 使用 `httputil.ValidatorRequestStructAndErrorResponse` 验证请求\n- 使用 `httputil.ReturnSuccess/ReturnBcodeError` 返回响应\n\n### 6. 路由注册\n- 文件：`api/api_routers/version2/v2Routers.go`\n- 在对应的 Router 方法中添加路由\n\n### 7. 验证\n```bash\ngo build ./...\ngo vet ./...\n```\n","plugins/README.md":"## Rainbond Plugins\n\nThis directory contains various plugin components of the Rainbond platform, which are used to expand and enhance the functionality of Rainbond.\n\n\n## License\n\nThis project follows the same license as the Rainbond main project.\n",".claude/commands/verify.md":"# 构建验证\n\n对 rainbond Go 项目执行完整的构建验证。\n\n## 执行以下检查\n\n### 1. 编译检查\n```bash\ngo build ./...\n```\n\n### 2. 静态分析\n```bash\ngo vet ./...\n```\n\n### 3. CI 检查（如有变更文件）\n```bash\nmake check\n```\n\n## 如果发现问题\n\n- 编译错误：定位错误文件和行号，分析原因并修复\n- vet 警告：根据提示修复代码问题\n- lint 问题：按照 golint 建议调整代码风格\n\n修复后重新运行所有检查，确保全部通过。\n","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":{".claude/commands/add-api.md":"# 新增 Go API 端点\n\n引导开发者在 rainbond Go 后端新增一个 API 端点。\n\n## 请提供以下信息\n\n1. API 路径（例如：`/v2/tenants/{tenant_name}/apps/{app_id}/something`）\n2. HTTP 方法（GET/POST/PUT/DELETE）\n3. 功能描述\n4. 是否需要新的数据库表？\n\n## 实施步骤\n\n按以下顺序创建/修改文件：\n\n### 1. 数据模型（如需新表）\n- 文件：`db/model/` 下对应文件\n- 定义 GORM struct，包含 `TableName()` 方法\n\n### 2. DAO 层\n- 接口：`db/dao/` 下定义接口\n- 实现：`db/mysql/` 下实现接口\n- 注册：在 `db/db.go` 的 Manager 接口中添加\n\n### 3. 请求/响应结构体\n- 文件：`api/model/` 下对应文件\n- 使用 `json` tag 和 `validate` tag\n\n### 4. Handler（业务逻辑）\n- 文件：`api/handler/` 下对应文件\n- 使用 `GetXxxHandler()` 单例模式\n- 调用 DAO 层和 K8s API\n\n### 5. Controller（HTTP 处理）\n- 文件：`api/controller/` 下对应文件\n- 使用 `httputil.ValidatorRequestStructAndErrorResponse` 验证请求\n- 使用 `httputil.ReturnSuccess/ReturnBcodeError` 返回响应\n\n### 6. 路由注册\n- 文件：`api/api_routers/version2/v2Routers.go`\n- 在对应的 Router 方法中添加路由\n\n### 7. 验证\n```bash\ngo build ./...\ngo vet ./...\n```\n","plugins/README.md":"## Rainbond Plugins\n\nThis directory contains various plugin components of the Rainbond platform, which are used to expand and enhance the functionality of Rainbond.\n\n\n## License\n\nThis project follows the same license as the Rainbond main project.\n",".claude/commands/verify.md":"# 构建验证\n\n对 rainbond Go 项目执行完整的构建验证。\n\n## 执行以下检查\n\n### 1. 编译检查\n```bash\ngo build ./...\n```\n\n### 2. 静态分析\n```bash\ngo vet ./...\n```\n\n### 3. CI 检查（如有变更文件）\n```bash\nmake check\n```\n\n## 如果发现问题\n\n- 编译错误：定位错误文件和行号，分析原因并修复\n- vet 警告：根据提示修复代码问题\n- lint 问题：按照 golint 建议调整代码风格\n\n修复后重新运行所有检查，确保全部通过。\n","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","rawUrl":"https://raw.githubusercontent.com/goodrain/rainbond/HEAD/AGENTS.md","title":"AI Agent Protocol & Instructions","category":"root-instruction","format":"markdown","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","isInternal":false,"tokens":1491,"sizeBytes":6242},{"name":"CLAUDE.md","path":"CLAUDE.md","rawUrl":"https://raw.githubusercontent.com/goodrain/rainbond/HEAD/CLAUDE.md","title":"Claude Agent Guidelines & System Prompt","category":"claude-rule","format":"markdown","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","isInternal":false,"tokens":1491,"sizeBytes":6242},{"name":"README.md","path":"plugins/README.md","rawUrl":"https://raw.githubusercontent.com/goodrain/rainbond/HEAD/plugins/README.md","title":"plugins Documentation","category":"plugin-manifest","format":"markdown","content":"## Rainbond Plugins\n\nThis directory contains various plugin components of the Rainbond platform, which are used to expand and enhance the functionality of Rainbond.\n\n\n## License\n\nThis project follows the same license as the Rainbond main project.\n","isInternal":false,"tokens":46,"sizeBytes":247},{"name":"add-api.md","path":".claude/commands/add-api.md","rawUrl":"https://raw.githubusercontent.com/goodrain/rainbond/HEAD/.claude/commands/add-api.md","title":"Command: /add-api","category":"command-prompt","format":"markdown","content":"# 新增 Go API 端点\n\n引导开发者在 rainbond Go 后端新增一个 API 端点。\n\n## 请提供以下信息\n\n1. API 路径（例如：`/v2/tenants/{tenant_name}/apps/{app_id}/something`）\n2. HTTP 方法（GET/POST/PUT/DELETE）\n3. 功能描述\n4. 是否需要新的数据库表？\n\n## 实施步骤\n\n按以下顺序创建/修改文件：\n\n### 1. 数据模型（如需新表）\n- 文件：`db/model/` 下对应文件\n- 定义 GORM struct，包含 `TableName()` 方法\n\n### 2. DAO 层\n- 接口：`db/dao/` 下定义接口\n- 实现：`db/mysql/` 下实现接口\n- 注册：在 `db/db.go` 的 Manager 接口中添加\n\n### 3. 请求/响应结构体\n- 文件：`api/model/` 下对应文件\n- 使用 `json` tag 和 `validate` tag\n\n### 4. Handler（业务逻辑）\n- 文件：`api/handler/` 下对应文件\n- 使用 `GetXxxHandler()` 单例模式\n- 调用 DAO 层和 K8s API\n\n### 5. Controller（HTTP 处理）\n- 文件：`api/controller/` 下对应文件\n- 使用 `httputil.ValidatorRequestStructAndErrorResponse` 验证请求\n- 使用 `httputil.ReturnSuccess/ReturnBcodeError` 返回响应\n\n### 6. 路由注册\n- 文件：`api/api_routers/version2/v2Routers.go`\n- 在对应的 Router 方法中添加路由\n\n### 7. 验证\n```bash\ngo build ./...\ngo vet ./...\n```\n","isInternal":false,"tokens":423,"sizeBytes":1261},{"name":"verify.md","path":".claude/commands/verify.md","rawUrl":"https://raw.githubusercontent.com/goodrain/rainbond/HEAD/.claude/commands/verify.md","title":"Command: /verify","category":"command-prompt","format":"markdown","content":"# 构建验证\n\n对 rainbond Go 项目执行完整的构建验证。\n\n## 执行以下检查\n\n### 1. 编译检查\n```bash\ngo build ./...\n```\n\n### 2. 静态分析\n```bash\ngo vet ./...\n```\n\n### 3. CI 检查（如有变更文件）\n```bash\nmake check\n```\n\n## 如果发现问题\n\n- 编译错误：定位错误文件和行号，分析原因并修复\n- vet 警告：根据提示修复代码问题\n- lint 问题：按照 golint 建议调整代码风格\n\n修复后重新运行所有检查，确保全部通过。\n","isInternal":false,"tokens":172,"sizeBytes":504}],"systemPromptSnippet":"<yakaai_skills repo=\"goodrain/rainbond\">\n<!-- File: AGENTS.md (Tokens: ~1491 | Category: root-instruction) -->\n# 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\n<!-- File: CLAUDE.md (Tokens: ~1491 | Category: claude-rule) -->\n# 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\n<!-- File: plugins/README.md (Tokens: ~46 | Category: plugin-manifest) -->\n## Rainbond Plugins\n\nThis directory contains various plugin components of the Rainbond platform, which are used to expand and enhance the functionality of Rainbond.\n\n\n## License\n\nThis project follows the same license as the Rainbond main project.\n\n<!-- File: .claude/commands/add-api.md (Tokens: ~423 | Category: command-prompt) -->\n# 新增 Go API 端点\n\n引导开发者在 rainbond Go 后端新增一个 API 端点。\n\n## 请提供以下信息\n\n1. API 路径（例如：`/v2/tenants/{tenant_name}/apps/{app_id}/something`）\n2. HTTP 方法（GET/POST/PUT/DELETE）\n3. 功能描述\n4. 是否需要新的数据库表？\n\n## 实施步骤\n\n按以下顺序创建/修改文件：\n\n### 1. 数据模型（如需新表）\n- 文件：`db/model/` 下对应文件\n- 定义 GORM struct，包含 `TableName()` 方法\n\n### 2. DAO 层\n- 接口：`db/dao/` 下定义接口\n- 实现：`db/mysql/` 下实现接口\n- 注册：在 `db/db.go` 的 Manager 接口中添加\n\n### 3. 请求/响应结构体\n- 文件：`api/model/` 下对应文件\n- 使用 `json` tag 和 `validate` tag\n\n### 4. Handler（业务逻辑）\n- 文件：`api/handler/` 下对应文件\n- 使用 `GetXxxHandler()` 单例模式\n- 调用 DAO 层和 K8s API\n\n### 5. Controller（HTTP 处理）\n- 文件：`api/controller/` 下对应文件\n- 使用 `httputil.ValidatorRequestStructAndErrorResponse` 验证请求\n- 使用 `httputil.ReturnSuccess/ReturnBcodeError` 返回响应\n\n### 6. 路由注册\n- 文件：`api/api_routers/version2/v2Routers.go`\n- 在对应的 Router 方法中添加路由\n\n### 7. 验证\n```bash\ngo build ./...\ngo vet ./...\n```\n\n<!-- File: .claude/commands/verify.md (Tokens: ~172 | Category: command-prompt) -->\n# 构建验证\n\n对 rainbond Go 项目执行完整的构建验证。\n\n## 执行以下检查\n\n### 1. 编译检查\n```bash\ngo build ./...\n```\n\n### 2. 静态分析\n```bash\ngo vet ./...\n```\n\n### 3. CI 检查（如有变更文件）\n```bash\nmake check\n```\n\n## 如果发现问题\n\n- 编译错误：定位错误文件和行号，分析原因并修复\n- vet 警告：根据提示修复代码问题\n- lint 问题：按照 golint 建议调整代码风格\n\n修复后重新运行所有检查，确保全部通过。\n</yakaai_skills>"}