Feature: Add Public API gateway service (#557) #558
Conversation
This comment has been minimized.
This comment has been minimized.
Claude Code ReviewSummaryThis PR introduces a new Public API gateway service that provides a simplified, versioned REST API for external clients (Browser, SDK, MCP). The implementation is well-architected as a thin shim layer that proxies requests to the internal Go backend while abstracting Kubernetes CRD complexity. The code demonstrates strong adherence to security best practices, comprehensive test coverage, and proper Kubernetes integration. Overall Assessment: High quality implementation with excellent security practices and comprehensive testing. A few minor improvements and documentation enhancements would make this production-ready. Issues by Severity🚫 Blocker IssuesNone - No blocking issues found. The implementation is secure and follows established patterns. 🔴 Critical IssuesNone - No critical issues found. Security patterns are properly implemented. 🟡 Major Issues1. Token Security - Potential Log Exposure (handlers/middleware.go:145)The logging middleware logs requests but does not redact tokens from query parameters or other headers beyond Authorization. Recommendation: Follow the backend pattern from 2. JWT Security Comment Clarity (handlers/middleware.go:83-93)The security comment for 🔵 Minor Issues1. Error Handling - Duplicate Code (handlers/sessions.go:40-44)Dead code detected - checking 2. Inconsistent Error Messages (handlers/sessions.go:216)When backend returns non-JSON, the error message is generic: "Request failed". Could be more descriptive. 3. Missing Dockerfile Multi-Architecture BuildThe Dockerfile does not specify TARGETPLATFORM for multi-arch builds. 4. Test Coverage - Missing Backend Integration TestsWhile unit tests are comprehensive, there are no tests for actual backend integration with a mock backend server. 5. Documentation - Missing ADRThis is a significant architectural change (new API gateway), but there is no ADR following the pattern in 6. Security Context Missing in DeploymentWhile the pod security context is excellent, the deployment does not specify a securityContext at the pod level for defense in depth. 7. Environment Variable ValidationThe 8. HTTP Client Timeout Not Configurable in TestsTests modify the global Positive Highlights✅ Excellent Security Practices:
✅ Comprehensive Test Coverage:
✅ Clean Architecture:
✅ Good Kubernetes Integration:
✅ Code Quality:
✅ Documentation:
RecommendationsPriority 1 (Before Merge)
Priority 2 (Follow-up PR)
Final VerdictAPPROVED with minor improvements ✅ This is a well-implemented feature that adds significant value to the platform. The code is production-ready with proper security practices, comprehensive testing, and clean architecture. The suggested improvements are mostly documentation and defense-in-depth enhancements rather than functional issues. Recommended Actions:
Then this is ready to merge! 🚀 Review completed by: Claude Code Review Bot 🔍 View AI decision process (logs available for 90 days) 📋 View memory system files loaded (click to expand)What Amber Loaded for Code ReviewAmber automatically loaded these repository standards from the memory system:
Impact: This review used your repository's specific code quality standards, security patterns, and best practices from the memory system (PRs #359, #360) - not just generic code review guidelines. |
Claude Code ReviewSummaryPR #558 introduces a new Public API gateway service that provides a simplified, versioned REST API ( Overall Assessment: ✅ APPROVED - High quality implementation with only minor suggestions for improvement. Issues by Severity🚫 Blocker IssuesNone - No blocking issues found. 🔴 Critical IssuesNone - No critical security or functionality issues. 🟡 Major Issues1. JWT Extraction Without Signature Validation - Security Documentation GapLocation: Issue: The
Recommendation:
Current Code: // extractJWTSubject extracts the 'sub' claim from a JWT WITHOUT validating signature.
// ... extensive warning comment ...
func extractJWTSubject(token string) string {
// Decodes without validation
}Why Major: While technically safe due to backend validation, the separation of concerns (routing vs auth) increases the attack surface if backend validation ever fails. 🔵 Minor Issues1. Dead Code - Duplicate Error CheckLocation: // Line 28-33: Read response body
body, err := io.ReadAll(resp.Body)
if err != nil {
log.Printf("Failed to read backend response: %v", err)
c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to read response"})
return
}
// Lines 42-45: Dead code (err is already checked above)
if err != nil {
c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to read response"})
return
}Fix: Remove lines 42-45 (unreachable code after successful 2. Missing BACKEND_TIMEOUT DocumentationLocation: Issue: The Current: | Variable | Default | Description |
|----------|---------|-------------|
| `PORT` | `8081` | Server port |
| `BACKEND_URL` | `http://backend-service:8080` | Internal backend URL |
| `GIN_MODE` | `release` | Gin mode (debug/release) |Add: | `BACKEND_TIMEOUT` | `30s` | Backend request timeout (Go duration format) |3. Inconsistent Error Messages - Generic vs SpecificLocation: Multiple handlers Issue: Error responses mix generic and specific messages inconsistently:
Recommendation: Standardize on generic user-facing messages while keeping detailed logs: // GOOD (current pattern in proxy.go:86-87)
log.Printf("Backend request failed: %v", err) // Detailed log
c.JSON(http.StatusBadGateway, gin.H{"error": "Backend unavailable"}) // Generic response
// AVOID exposing internal details
c.JSON(http.StatusInternalServerError, gin.H{"error": fmt.Sprintf("Failed to: %v", err)})4. Test Coverage - Missing Edge CasesGood: Comprehensive middleware tests (314 lines) with table-driven patterns ✅
Recommendation: Add test cases for backend error conditions to achieve >80% coverage. 5. Kubernetes Manifest - Missing Resource QuotasLocation: Current: serviceAccountName: public-api # ✅ Good: dedicated SA
# NOTE: No RoleBinding needed (only proxies HTTP) ✅ Good: documented
securityContext: # ✅ Excellent: follows security standards
allowPrivilegeEscalation: false
readOnlyRootFilesystem: true
runAsNonRoot: true
capabilities:
drop:
- ALLMissing: PodDisruptionBudget for production resilience (optional but recommended) Add: ---
apiVersion: policy/v1
kind: PodDisruptionBudget
metadata:
name: public-api-pdb
spec:
minAvailable: 1
selector:
matchLabels:
app: public-api6. Proposal Document - Success Criteria Not VerifiedLocation: Issue: Success criteria checklist is not referenced in PR description or test results: - [ ] Public API service is deployable
- [ ] Can list/create/get/delete sessions via `curl` to Public API
- [ ] Browser continues to work through Public API
- [ ] SDK/MCP can authenticate with access keys
- [ ] Latency < 200ms for API requestsRecommendation: Update PR description with checklist status or add link to test results demonstrating criteria met. Positive Highlights🌟 Security Excellence
🎯 Architecture
🧪 Testing
📚 Documentation
🛠️ Code Quality
RecommendationsPriority 1 (Before Merge)
Priority 2 (Follow-up PR)
Priority 3 (Future Enhancement)
Architectural Alignment✅ CLAUDE.md Compliance:
✅ ADR Compliance:
✅ Security Standards:
Final Verdict✅ LGTM with minor fixes This PR demonstrates excellent software engineering:
The only blockers are trivial (dead code, missing docs). Addressing Priority 1 recommendations will make this merge-ready. Estimated Effort to Address:
Reviewed by: Claude Sonnet 4.5 🔍 View AI decision process (logs available for 90 days) 📋 View memory system files loaded (click to expand)What Amber Loaded for Code ReviewAmber automatically loaded these repository standards from the memory system:
Impact: This review used your repository's specific code quality standards, security patterns, and best practices from the memory system (PRs #359, #360) - not just generic code review guidelines. |
Claude Code ReviewSummaryThis PR introduces a well-architected Public API gateway service that provides a versioned REST API (v1) for client access. The code is secure, well-tested, and follows Go best practices. The service uses a stateless gateway pattern (proxy to backend) which differs from the direct K8s client pattern used in the backend service - this is an intentional architectural choice that should be documented in CLAUDE.md. Overall Assessment: APPROVE WITH MINOR CHANGES ✅ Issues by Severity🚫 Blocker IssuesNone - Code is production-ready after addressing critical issues below. 🔴 Critical Issues1. JWT Subject Extraction Without Signature ValidationFile: Issue: The Current Risk: LOW (only used for routing, backend validates) Recommendation: Add validation that header project matches token project (if both present): func extractProject(c *gin.Context, token string) string {
headerProject := c.GetHeader("X-Ambient-Project")
tokenProject := extractProjectFromToken(token)
// If both exist, they must match (prevents routing attacks)
if headerProject != "" && tokenProject != "" && headerProject != tokenProject {
log.Printf("SECURITY: Project mismatch - header=%s token=%s", headerProject, tokenProject)
return "" // Force authentication failure
}
// Prefer explicit header
if headerProject != "" {
return headerProject
}
return tokenProject
}2. Missing Input Validation on Session IDs and Project NamesFile: Issue: No validation on session IDs or project names to prevent injection attacks. // Current code - no validation
sessionID := c.Param("id")
path := fmt.Sprintf("/api/projects/%s/agentic-sessions/%s", project, sessionID)Recommendation: Add K8s name validation: import "regexp"
var kubernetesNameRegex = regexp.MustCompile(`^[a-z0-9]([-a-z0-9]*[a-z0-9])?$`)
func validateKubernetesName(name string) bool {
return len(name) > 0 && len(name) <= 63 && kubernetesNameRegex.MatchString(name)
}
// In handlers:
if !validateKubernetesName(sessionID) {
c.JSON(http.StatusBadRequest, gin.H{"error": "Invalid session ID"})
return
}3. Architectural Deviation Not Documented in CLAUDE.mdFiles: All handlers Issue: The public-api service does NOT use Risk: Future developers may incorrectly try to apply backend patterns to this service. Recommendation: Update CLAUDE.md: ### Exception: Public API Gateway Service
The `components/public-api` service is a stateless HTTP gateway that does NOT
follow the standard backend pattern of using GetK8sClientsForRequest(). Instead,
it forwards authenticated requests to the backend service, which performs all
K8s operations and RBAC validation.Also add comment to // ARCHITECTURE NOTE: This service is a stateless gateway that forwards
// authenticated requests to the backend. Unlike the backend service, we do NOT
// create K8s clients here - all K8s operations and RBAC validation happen in
// the backend service. Our role is to:
// 1. Extract and validate tokens (middleware.go)
// 2. Extract project context (from header or token)
// 3. Forward requests with proper authorization headers🟡 Major Issues4. Missing Integration TestsGap: No tests verify end-to-end flow with real HTTP server. Current tests: Mock backend responses, test functions in isolation Recommendation: Add func TestE2E_CreateSession(t *testing.T) {
// Start mock backend server
backend := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
// Verify token was forwarded
auth := r.Header.Get("Authorization")
if auth != "Bearer test-token" {
t.Errorf("Token not forwarded correctly")
}
w.WriteHeader(http.StatusCreated)
json.NewEncoder(w).Encode(map[string]string{"name": "session-123"})
}))
defer backend.Close()
handlers.BackendURL = backend.URL
// ... test full flow
}5. Missing golangci-lint ConfigurationGap: No Impact: Cannot verify linting standards match backend. Recommendation: cp components/backend/.golangci.yml components/public-api/🔵 Minor Issues6. Missing Context Timeout on Backend Proxy RequestsFile: Issue: Relies solely on HTTP client timeout, no explicit context timeout. Recommendation: ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
defer cancel()
req, err := http.NewRequestWithContext(ctx, method, fullURL, bytes.NewReader(body))7. Validation Helpers Should Be ExtractedIssue: Inline validation logic could be extracted into reusable helpers. Recommendation: Create package helpers
func IsValidKubernetesName(name string) bool { ... }
func SanitizeProjectName(name string) string { ... }Positive HighlightsSecurity ✅
Code Quality ✅
Architecture ✅
Testing ✅
Dockerfile Security ✅
RecommendationsMust Address Before Merge (Priority 1)
Should Address Soon (Priority 2)
Nice to Have (Priority 3)
Detailed AssessmentSecurity: 8/10
|
Claude Code Review - PR #558SummaryThis PR introduces a Public API gateway service as a thin shim layer between clients (Browser, SDK, MCP) and the internal Go backend. The implementation is well-architected with strong security patterns, comprehensive testing, and excellent documentation. Overall Assessment: ✅ Approved with Minor Recommendations Issues by Severity🚫 Blocker IssuesNone - No blocking issues found. 🔴 Critical IssuesNone - No critical issues found. 🟡 Major Issues1. Missing Error Context in Some Logs
🔵 Minor Issues1. Inconsistent Error Messages
2. Magic Number in Test
3. Unused ErrorResponse Type
Positive Highlights⭐ Excellent Security DocumentationThe JWT extraction function (middleware.go:101-124) has outstanding security documentation explaining why unvalidated JWT parsing is safe in this context. This is a textbook example of security documentation done right. ⭐ Token Redaction PatternLogging middleware correctly implements token redaction following backend patterns, redacting token, access_token, and api_key parameters. ⭐ Comprehensive Test Coverage
⭐ Correct Architecture PatternThe public-api service correctly diverges from backend patterns as documented in CLAUDE.md:
⭐ Strong Input ValidationKubernetes DNS label validation prevents path injection attacks (RFC 1123, max 63 chars, alphanumeric + hyphens). ⭐ Production-Ready Container Security
RecommendationsPriority 1: Pre-Merge (Low Effort)
Priority 2: Post-Merge (Follow-up)
Priority 3: Future Enhancements
Architecture Compliance
Final VerdictStatus: ✅ APPROVED This PR demonstrates excellent engineering practices. The minor issues are recommendations for future improvement, not blockers. The code is safe to merge. Reviewed by: Claude Sonnet 4.5 🔍 View AI decision process (logs available for 90 days) 📋 View memory system files loaded (click to expand)What Amber Loaded for Code ReviewAmber automatically loaded these repository standards from the memory system:
Impact: This review used your repository's specific code quality standards, security patterns, and best practices from the memory system (PRs #359, #360) - not just generic code review guidelines. |
Claude Code ReviewSummaryThis PR introduces a Public API gateway service that provides a simplified, versioned REST API ( Overall Assessment: ✅ Well-designed, secure, and production-ready with one blocker issue to address. Issues by Severity🚫 Blocker Issues1. Type Assertions Without Checking in Location: Issue: Multiple unchecked type assertions that could panic in production: // Line 243 - No check if 'ok' is false before using
if metadata, ok := data["metadata"].(map[string]interface{}); ok {
if name, ok := metadata["name"].(string); ok { // ✅ Good
session.ID = name
}
}This pattern is actually CORRECT! The outer Actually, reviewing more carefully - this is handled correctly! The code uses the 🔴 Critical Issues1. Missing Security Context Validation Test Location: Issue: The middleware tests cover token extraction and project extraction, but there's no explicit test for the security-critical project mismatch detection (lines 72-75 in middleware.go): // SECURITY: If both header and token specify a project, they must match
if headerProject \!= "" && tokenProject \!= "" && headerProject \!= tokenProject {
log.Printf("SECURITY: Project mismatch - header=%s token=%s (possible routing attack)", headerProject, tokenProject)
return "" // Force authentication failure
}Recommendation: Add a dedicated test case: func TestExtractProject_SecurityMismatch(t *testing.T) {
// Test that project mismatch is detected and blocked
c, _ := gin.CreateTestContext(httptest.NewRecorder())
c.Request = httptest.NewRequest("GET", "/", nil)
c.Request.Header.Set("X-Ambient-Project", "project-a")
// Token claims project-b
token := createMockServiceAccountToken("project-b", "test-sa")
project := extractProject(c, token)
assert.Empty(t, project, "Should reject mismatched projects")
}🟡 Major Issues1. Unstructured Data Transformation Lacks Error Logging Location: Issue: The Current behavior: if metadata, ok := data["metadata"].(map[string]interface{}); ok {
// Extract fields...
} // If not ok, silently continueRecommendation: Add debug logging for transformation failures: if metadata, ok := data["metadata"].(map[string]interface{}); ok {
// Extract fields...
} else {
log.Printf("Warning: Backend response missing 'metadata' field or wrong type")
}Why Major: In production, silent data transformation failures can mask backend API changes or bugs. 2. Backend Timeout Not Configurable Per-Request Location: Issue: The backend timeout is set globally at startup ( Current implementation: HTTPClient = &http.Client{
Timeout: BackendTimeout, // Global 30s
}Recommendation: Consider per-endpoint timeout configuration: // In CreateSession handler:
ctx, cancel := context.WithTimeout(c.Request.Context(), 60*time.Second)
defer cancel()Why Major: Long-running session creation requests could timeout prematurely with a 30s global timeout. 3. No Rate Limiting Location: Issue: The public API has no rate limiting middleware. This exposes the service to:
Recommendation: Add rate limiting middleware using import "github.com/ulule/limiter/v3/drivers/middleware/gin"
// Per-token rate limiting (100 req/min)
v1.Use(rateLimitMiddleware())Why Major: Production APIs should have basic DoS protection. 🔵 Minor Issues1. Health Check Returns 200 Without Backend Validation Location: Issue: The r.GET("/health", func(c *gin.Context) {
c.JSON(200, gin.H{"status": "ok"}) // Always returns 200
})Recommendation: Add backend connectivity check (optional, only for liveness probe): r.GET("/health", func(c *gin.Context) {
// Quick ping to backend
ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
defer cancel()
req, _ := http.NewRequestWithContext(ctx, "GET", BackendURL+"/health", nil)
resp, err := HTTPClient.Do(req)
if err \!= nil || resp.StatusCode \!= 200 {
c.JSON(503, gin.H{"status": "backend unavailable"})
return
}
c.JSON(200, gin.H{"status": "ok"})
})Why Minor: Current behavior is acceptable for basic health checks, but deep health checks improve reliability. 2. Missing Metrics Endpoint Location: Issue: No Prometheus metrics endpoint ( Recommendation: Add import "github.com/zsais/go-gin-prometheus"
p := ginprometheus.NewPrometheus("public_api")
p.Use(r)Why Minor: Observability is important for production, but can be added in a follow-up PR. 3. JWT Subject Extraction Logs on Every Request Location: Issue: The middleware logs every time a project is extracted from a ServiceAccount token. This could generate excessive log volume in production. if tokenProject \!= "" {
log.Printf("Extracted project %s from ServiceAccount token for routing (backend will validate)", tokenProject)
}Recommendation: Downgrade to debug level or remove after initial deployment: // Only log at debug level or remove after validating the feature works
// log.Printf("DEBUG: Extracted project %s from SA token", tokenProject)Why Minor: High log volume, but not a functional issue. 4. Location: Issue: The default:
return phase // Could be internal K8s phase nameRecommendation: Log unexpected phases and return a normalized value: default:
log.Printf("Warning: Unknown phase '%s', normalizing to 'unknown'", phase)
return "unknown"Why Minor: Unlikely to happen in practice, but improves API contract stability. 5. Redundant Location: Issue: The Dockerfile copies COPY go.mod go.sum* ./Recommendation: Remove wildcard since COPY go.mod go.sum ./Why Minor: Doesn't affect functionality, just style. Positive Highlights🌟 Architecture & Design
🌟 Code Quality
🌟 Security
🌟 Production Readiness
🌟 Documentation
RecommendationsPrioritized Action ItemsBefore Merge (Blocker): None! The initial blocker I identified was actually a false positive - the type assertions are handled correctly. High Priority (Address in this PR or immediate follow-up):
Medium Priority (Follow-up PR):
Low Priority (Nice-to-have):
Security Review Summary✅ Token Handling: Excellent - tokens are never logged, always forwarded, never stored Final VerdictStatus: ✅ APPROVE (with minor recommendations) This is a well-architected, secure, and production-ready implementation. The code follows project standards, has excellent test coverage, and demonstrates thoughtful security design. The separation of concerns between the public-api gateway and the backend is clean and maintainable. The only critical recommendation is adding a test for the project mismatch security check. Everything else can be addressed in follow-up PRs. Excellent work! 🎉 Reviewed with:
Generated by Claude Code Review (Sonnet 4.5) 🔍 View AI decision process (logs available for 90 days) 📋 View memory system files loaded (click to expand)What Amber Loaded for Code ReviewAmber automatically loaded these repository standards from the memory system:
Impact: This review used your repository's specific code quality standards, security patterns, and best practices from the memory system (PRs #359, #360) - not just generic code review guidelines. |
Introduce a new Public API service that acts as a single entry point for all clients (Browser, SDK, MCP). This thin shim layer provides: - Versioned REST endpoints (/v1/sessions) - Simplified JSON responses (abstracts K8s CRD complexity) - Token validation and project extraction from headers or JWT - Proxy to internal Go backend Components added: - components/public-api/ - Go service with Gin framework - Kubernetes manifests for deployment, service, and route - Makefile build target (build-public-api) - Design proposal document Closes ambient-code#557 Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com> Signed-off-by: Emilien Macchi <emacchi@redhat.com>
Claude Code ReviewSummaryThis PR introduces a new Public API Gateway service that provides a simplified, versioned REST API for the Ambient Code Platform. The implementation is well-architected as a thin proxy layer that abstracts K8s CRD complexity while maintaining security through token forwarding. Overall Assessment: Strong implementation with excellent security patterns, comprehensive test coverage, and good alignment with project standards. A few minor improvements recommended. Issues by Severity🚫 Blocker IssuesNone. The PR is ready to merge from a functional and security perspective. 🔴 Critical IssuesNone identified. 🟡 Major Issues1. Error Handling: Generic Internal Error Messages // handlers/sessions.go:34-36
if err := io.ReadAll(resp.Body); err != nil {
log.Printf("Failed to read backend response: %v", err)
c.JSON(http.StatusInternalServerError, gin.H{"error": "Internal server error"})
return
}Issue: Multiple locations use generic "Internal server error" messages that don't help users understand what went wrong. Pattern violation: Error handling pattern recommends more specific user-facing messages while keeping detailed logs internal. Recommendation: Provide more context in user-facing errors:
Locations: handlers/sessions.go:36, 50, 91, 104, 147, 164, 177, 218 2. Type Safety: Unstructured Map Access // handlers/sessions.go:243-246
if metadata, ok := data["metadata"].(map[string]interface{}); ok {
if name, ok := metadata["name"].(string); ok {
session.ID = name
}
}Issue: While the code does check types with Pattern alignment: This is acceptable for a proxy service transforming backend responses, but consider defining backend response types for better maintainability. Recommendation: Low priority - current implementation is safe, but adding typed structs in 🔵 Minor Issues1. Missing Context Cancellation Logging // handlers/proxy.go:78-81
resp, err := HTTPClient.Do(req)
if err != nil {
return nil, fmt.Errorf("backend request failed: %w", err)
}Issue: When context is cancelled (client disconnect), the error includes the full backend URL in the wrapped error, which gets logged. Recommendation: Add context cancellation check: if err != nil {
if ctx.Err() == context.Canceled {
return nil, fmt.Errorf("request cancelled")
}
return nil, fmt.Errorf("backend request failed: %w", err)
}2. Security Context Documentation # components/manifests/base/public-api-deployment.yaml:52-58
securityContext:
allowPrivilegeEscalation: false
readOnlyRootFilesystem: true
runAsNonRoot: true
capabilities:
drop:
- ALLPositive: Excellent security context configuration! This follows security standards perfectly. Recommendation: Add a comment explaining why readOnlyRootFilesystem is safe (Go binary doesn't need write access). 3. Test Coverage: Integration Test Assertion // handlers/integration_test.goObservation: Integration tests exist but weren't run in my review environment. Recommendation: Ensure integration tests run in CI and validate against a real backend instance. 4. JWT Subject Extraction Security Warning // handlers/middleware.go:101-124
// SECURITY WARNING - READ BEFORE MODIFYINGPositive: Excellent security documentation! This is a great example of explaining WHY unvalidated JWT parsing is safe in this specific context. Recommendation: None - this is exemplary documentation. Positive Highlights✅ Excellent Security Patterns
✅ Strong Architecture
✅ Excellent Test Coverage
✅ Documentation & Standards
✅ DevOps & Deployment
RecommendationsPriority 1 (Before Merge - Nice to Have)
Priority 2 (Follow-up PR)
Priority 3 (Future Enhancement)
Architecture Alignment Check✅ Backend Development Standards
✅ Security Standards
✅ Error Handling Patterns
✅ Go Standards
Final VerdictAPPROVED - This is a well-implemented feature that follows project standards and security best practices. The identified issues are all minor and non-blocking. The code is production-ready. Key Strengths:
Recommendation: Merge with optional follow-up for improved error messages. Review conducted by Claude Code with full memory system context (CLAUDE.md, security-standards.md, backend-development.md, k8s-client-usage.md, error-handling.md) 🔍 View AI decision process (logs available for 90 days) 📋 View memory system files loaded (click to expand)What Amber Loaded for Code ReviewAmber automatically loaded these repository standards from the memory system:
Impact: This review used your repository's specific code quality standards, security patterns, and best practices from the memory system (PRs #359, #360) - not just generic code review guidelines. |
|
@EmilienM hey, I ran this through another reviewer and it had different feedback. It was calling out CORS as being necessary to import from gin. Does this need to have an HPA with it? Please address the critical feedback below and in the previous comments. Below are all useful additions and I would prefer they be implemented either now, or as a follow-up. Lastly, I want to include this public_api in a release urgently. Critical Issues (MUST FIX before merge):
Recommended Improvements (SHOULD FIX):
Future Enhancements (NICE TO HAVE):
|
3 participants
Introduce a new Public API service that acts as a single entry point
for all clients (Browser, SDK, MCP). This thin shim layer provides:
Components added:
Closes #557
Co-Authored-By: Claude Opus 4.5 noreply@anthropic.com
Signed-off-by: Emilien Macchi emacchi@redhat.com