UI revamp fix backend #272
Conversation
Pull Request Review: UI Revamp Fix BackendSummaryThis PR implements a major UI overhaul for the frontend, transitioning from "vTeam" branding to "Ambient Code Platform" with significant UX improvements. The changes include 78 files with 16,084 additions and 2,208 deletions. ✅ Strengths1. Excellent Documentation
2. Following Best Practices
3. Good UX Improvements
|
Gkrumbach07
force-pushed
the
ui-revamp-fix-backend
branch
from
74ee24c to
fda262e
Compare
Code Review - PR #272: UI Revamp Fix BackendSummaryThis PR implements a major frontend UI refresh, renaming "Projects" to "Workspaces" and introducing new components and patterns. The changes span 74 files with significant additions to frontend components, backend session handling, and development tooling. Scale: +10,776 lines (primarily frontend), -2,799 lines deleted ✅ Positive FindingsExcellent Frontend Standards Adherence
Good Architecture Patterns
Backend Changes Look Safe
🚨 Critical IssuesC1: Session Detail Page Massively Exceeds Size LimitFile:
Impact:
Recommendation: Break down into smaller components: C2: Zero Test Coverage for New Frontend Code
Impact:
Recommendation: Add tests following patterns: // __tests__/create-workspace-dialog.test.tsx
import { render, screen, fireEvent } from '@testing-library/react'
import { CreateWorkspaceDialog } from '../create-workspace-dialog'
describe('CreateWorkspaceDialog', () => {
it('should auto-generate workspace name from display name', () => {
// Test name generation logic
})
it('should validate workspace name format', () => {
// Test validation
})
})
|
Comprehensive Code Review - PR #272: UI Revamp Fix BackendExecutive SummaryThis PR implements a significant frontend UI refresh along with development workflow changes. Overall code quality is strong with excellent adherence to design guidelines, but there are a few issues that should be addressed before merging. Recommendation: ✅ APPROVE with required fixes 1. Frontend Code Quality ReviewCritical Issues 🔴None identified - No blocking issues found. Major Issues 🟡Issue #1: Use of
|
Gkrumbach07
force-pushed
the
ui-revamp-fix-backend
branch
from
fda262e to
4d7297c
Compare
Code Review: UI Revamp Fix BackendI've reviewed this PR and have feedback across several areas based on the repository's CLAUDE.md standards. ✅ StrengthsType Safety: Excellent work avoiding React Query Integration: Consistent use of React Query hooks for all data operations with proper mutation handling. Component Architecture: New reusable components follow Shadcn UI patterns with good separation of concerns. UX Improvements: Loading states, proper disabled states during mutations, and toast notifications.
|
Gkrumbach07
force-pushed
the
ui-revamp-fix-backend
branch
from
4d7297c to
9c2b6f1
Compare
Update primary button colors to blue Improve workspace modal spacing Adjust display name and workspace name logic Adjust workspace modal text Move "Create Workspace" to modal
Gkrumbach07
force-pushed
the
ui-revamp-fix-backend
branch
from
9c2b6f1 to
ffb7de3
Compare
…d imports, and updating breadcrumb functionality to hide the home link.
…jectSessionDetailPage component.
- Introduced a new POST endpoint to set the active workflow for a session. - Updated the session spec to include an activeWorkflow field for dynamic workflow switching. - Enhanced the ProjectSessionDetailPage to allow users to select and submit custom workflows. - Implemented WebSocket notifications for immediate workflow updates. - Updated the ClaudeCodeAdapter to handle workflow changes and setup workflows based on user selection.
PR Review: UI Revamp Fix Backend - Comprehensive review based on CLAUDE.mdCritical Issues (Must Fix):
Important Issues: Positive Highlights: Pre-Commit Checklist: 6/11 passing - Main failures: component size and missing route files Action Items: Verdict: Strong architectural foundation with excellent React Query and Shadcn usage. Address component size and missing route files, then ready to merge. Great work on this major UI overhaul! 🚀 |
PR Review: UI Revamp Fix BackendThank you for this comprehensive UI revamp! This is a substantial change with 15,496 additions across 72 files. Here's my detailed review: ✅ Strengths1. Backend Code QualityThe new
2. Frontend Architecture
3. Type Safety
|
| Category | Status |
|---|---|
| Code Quality | 🟡 Good with issues |
| Security | 🔴 Critical issue - missing auth check |
| Tests | 🔴 No tests for new code |
| Documentation | 🟡 Needs API docs |
| Architecture | 🟢 Well structured |
Overall: This is solid architectural work, but has 2 blocking issues that must be addressed before merge:
- Missing authentication check in SelectWorkflow (security)
- Zero test coverage for new backend code (quality)
The type safety issues are highly recommended fixes to prevent runtime panics.
🚀 Next Steps
- Fix the authentication check (5 min fix)
- Replace type assertions with unstructured helpers (15 min fix)
- Add unit tests for SelectWorkflow (30-60 min)
- Re-run linting and tests
- Update PR for re-review
Happy to help with any of these! Let me know if you need code examples or have questions about the feedback.
Review completed using project standards from CLAUDE.md
Generated by Claude Code
- Introduced a new GET endpoint `/api/workflows/ootb` to list out-of-the-box workflows. - Implemented the `ListOOTBWorkflows` handler to return workflow configurations based on environment variables. - Updated `ProjectSessionDetailPage` to fetch and display OOTB workflows, allowing users to select from available options. - Enhanced the workflow selection logic to handle enabled/disabled states for better user experience. - Added new Radix UI components for improved workflow selection in the frontend.
- Added comments to clarify the management of github-app-secret.yaml, emphasizing its exclusion from automated deployment. - Introduced new image entries for vteam_backend, vteam_claude_runner, and vteam_frontend with explicit tags for better version control. - Removed redundant image entry for vteam_claude_runner to streamline the configuration.
Code Review: UI Revamp Fix BackendThis is a comprehensive PR that introduces workflow selection capabilities and significant frontend refactoring. Overall the implementation is solid, but there are several important issues to address. 🔴 Critical Issues1. Missing Authentication Check on Public Endpoint (components/backend/routes.go:25)The Security Impact: While the endpoint only returns workflow metadata (not sensitive data), it's inconsistent with the project's authentication model and could leak information about available workflows. Recommendation: // Move to authenticated group or add explicit auth middleware
projectGroup.GET("/workflows/ootb", handlers.ListOOTBWorkflows)
// OR
api.GET("/workflows/ootb", handlers.AuthMiddleware(), handlers.ListOOTBWorkflows)2. Missing User-Scoped Client Check (components/backend/handlers/sessions.go:1087)The Code: _, reqDyn := GetK8sClientsForRequest(c)
// Missing: if reqDyn == nil { return 401 }
var req types.WorkflowSelection
if err := c.ShouldBindJSON(&req); err \!= nil {Per CLAUDE.md standards (line 1337):
Fix Required: func SelectWorkflow(c *gin.Context) {
project := c.GetString("project")
sessionName := c.Param("sessionName")
reqK8s, reqDyn := GetK8sClientsForRequest(c)
// REQUIRED: Check for nil before proceeding
if reqK8s == nil || reqDyn == nil {
c.JSON(http.StatusUnauthorized, gin.H{"error": "Invalid or missing token"})
c.Abort()
return
}
var req types.WorkflowSelection
// ... rest of function
}3. Type Assertion Without Safety Check (components/backend/handlers/sessions.go:1147)Direct type assertion without checking could panic if metadata structure is unexpected: session := types.AgenticSession{
APIVersion: updated.GetAPIVersion(),
Kind: updated.GetKind(),
Metadata: updated.Object["metadata"].(map[string]interface{}), // ❌ Unsafe
}Per CLAUDE.md (line 1402):
Fix: session := types.AgenticSession{
APIVersion: updated.GetAPIVersion(),
Kind: updated.GetKind(),
}
if metadata, ok := updated.Object["metadata"].(map[string]interface{}); ok {
session.Metadata = metadata
} else {
log.Printf("Warning: Invalid metadata structure for session %s", sessionName)
session.Metadata = make(map[string]interface{})
}
|
- Deleted the static HTML prototype files, including index.html, README.md, and various project-related pages, to streamline the codebase. - Removed the ProjectSectionLayout component from the frontend, eliminating unused layout logic and associated imports. - This cleanup enhances maintainability and reduces clutter in the project structure.
Code Review: UI Revamp Fix BackendThis PR introduces workflow selection functionality and UI updates. The code is well-structured but has critical security issues that must be fixed before merging. Critical Issues1. Missing User Token Validation (components/backend/handlers/sessions.go:1084-1160) 2. Unauthenticated Public Endpoint (components/backend/routes.go:24) 3. Type Assertion Without Validation (components/backend/handlers/sessions.go:1147) High Priority Issues4. No Error Handling for Environment Variables (components/backend/handlers/sessions.go:1162-1218) 5. Frontend Type Safety Violation (components/frontend/src/app/api/workflows/ootb/route.ts) Positive Observations
Testing CoverageMissing tests for SelectWorkflow, ListOOTBWorkflows handlers, and frontend workflow selection UI. Add unit tests covering valid cases, 404s, 401s, and 400s. Must Fix Before Merge
Should Fix
Overall AssessmentGood work on the UI revamp and workflow selection feature! The code structure is solid, but the critical token validation issue must be fixed before merging. |
- Replaced `NextResponse` with the standard `Response` object for consistency in the OOTB workflows GET endpoint. - Updated error handling to return a JSON response with appropriate headers, improving API response format. - This change enhances the clarity and standardization of the API responses for better integration with frontend components.
Pull Request Review: UI Revamp Fix BackendThank you for this comprehensive PR! I've reviewed the changes based on the repository's CLAUDE.md standards. Here's my detailed feedback: ✅ Strengths
🔴 Critical Issues1. Missing Authorization on Public Endpoint (Security)Location: // Public endpoints (no auth required)
api.GET("/workflows/ootb", handlers.ListOOTBWorkflows)Issue: The Recommendation: Either:
2. Potential Type Assertion Panic (Reliability)Location: Metadata: updated.Object["metadata"].(map[string]interface{}),Issue: Direct type assertion without checking could panic if metadata is nil or wrong type. This violates the "Never Panic in Production Code" rule from CLAUDE.md. Fix: metadata, ok := updated.Object["metadata"].(map[string]interface{})
if \!ok {
log.Printf("Warning: invalid metadata format for session %s", sessionName)
c.JSON(http.StatusInternalServerError, gin.H{"error": "Invalid session format"})
return
}
session := types.AgenticSession{
APIVersion: updated.GetAPIVersion(),
Kind: updated.GetKind(),
Metadata: metadata,
}3. Inconsistent NULL Check Pattern (Code Quality)Location: spec, ok := item.Object["spec"].(map[string]interface{})
if \!ok {
spec = make(map[string]interface{})
item.Object["spec"] = spec
}Issue: While this checks the type assertion, it should use Recommended Pattern: spec, found, err := unstructured.NestedMap(item.Object, "spec")
if err \!= nil || \!found {
spec = make(map[string]interface{})
}
|
- Added logic to ensure the working directory exists before passing it to the SDK, creating the directory if it does not. - Implemented error handling for directory creation failures, falling back to the workspace root if necessary. - Improved logging for better debugging of working directory and additional directories.
Code Review - PR #272: UI Revamp Fix BackendThank you for this substantial PR! I've reviewed the changes across backend, frontend, operator, and runner components. Here's my comprehensive feedback: 🟢 StrengthsBackend Changes
CRD Updates
Frontend Improvements
🟡 Issues & ConcernsCRITICAL: Security Issue in Public EndpointLocation: // Public endpoints (no auth required)
api.GET("/workflows/ootb", handlers.ListOOTBWorkflows)Problem: This endpoint is marked as "no auth required" and placed outside the Questions:
Recommendation: // If truly public (document why):
// OOTB workflows are public metadata - no sensitive data exposed
api.GET("/workflows/ootb", handlers.ListOOTBWorkflows)
// OR if should be authenticated:
api.GET("/workflows/ootb", handlers.RequireAuthentication(), handlers.ListOOTBWorkflows)MEDIUM: Missing User Client CheckLocation: _, reqDyn := GetK8sClientsForRequest(c)Problem: The function doesn't verify that reqK8s, reqDyn := GetK8sClientsForRequest(c)
if reqK8s == nil {
c.JSON(http.StatusUnauthorized, gin.H{"error": "Invalid or missing token"})
c.Abort()
return
}Impact: Potential nil pointer dereference if token is invalid. Fix Required: Add the standard authentication check used throughout the codebase. MEDIUM: Hardcoded Default Workflow URLLocation: if specKitRepo == "" {
specKitRepo = "https://github.com/Gkrumbach07/spec-kit-template.git"
}Problems:
Recommendations:
LOW: Missing Input ValidationLocation: Issues:
Recommendations: // Validate Git URL format
if !strings.HasPrefix(req.GitUrl, "https://") && !strings.HasPrefix(req.GitUrl, "git@") {
c.JSON(http.StatusBadRequest, gin.H{"error": "Invalid git URL format"})
return
}
// Validate branch name (alphanumeric, dash, underscore, slash for nested branches)
if req.Branch != "" && !regexp.MustCompile(`^[a-zA-Z0-9/_-]+$`).MatchString(req.Branch) {
c.JSON(http.StatusBadRequest, gin.H{"error": "Invalid branch name"})
return
}
// Validate path doesn't escape intended directory
if strings.Contains(req.Path, "..") {
c.JSON(http.StatusBadRequest, gin.H{"error": "Invalid path"})
return
}LOW: Operator CRD Field AccessLocation: Concern: Ensure the operator properly handles the new Verify: // Good pattern from CLAUDE.md:
activeWorkflow, found, err := unstructured.NestedMap(spec, "activeWorkflow")
if err != nil {
log.Printf("Failed to parse activeWorkflow: %v", err)
return err
}
if found && activeWorkflow != nil {
// Process workflow
}Could not see the actual operator changes in the diff - please verify this pattern is followed. LOW: Frontend Type SafetyFiles: Multiple frontend files with heavy refactoring Concern: With 4000+ additions and major component restructuring, ensure:
Pre-commit checklist from DESIGN_GUIDELINES.md:
📋 Testing Recommendations
🔧 Additional NotesPositive Patterns Observed:
Missing/Unclear:
📝 Action ItemsMust Fix Before Merge:
Should Fix Before Merge:
Can Address in Follow-up:
🎯 Overall AssessmentThis is a substantial and well-structured PR that follows most of the established patterns from CLAUDE.md. The UI improvements are significant and the backend changes integrate cleanly with the existing architecture. However, there are 3 security/reliability concerns that should be addressed before merging:
Once these are resolved, this PR will be ready to merge. Estimated effort to fix: 30-60 minutes Great work on the major UI revamp! Let me know if you have questions about any of these recommendations. Review generated following standards from |
- Introduced state management for pending and active workflows, allowing users to select and activate workflows dynamically. - Enhanced the UI to display active workflow status and provide feedback during activation. - Updated the backend to support active workflow retrieval and session updates, including error handling and logging improvements. - Refactored workflow selection logic to accommodate custom workflows and improved user experience with alerts and loading states.
PR Review: UI Revamp Fix BackendThis PR introduces dynamic workflow activation, OOTB workflow management, and a comprehensive UI revamp with workspace-based navigation. The implementation is generally solid, but there are several important issues that need attention. 🔴 Critical Issues1. Unsafe Type Assertion in Backend (High Priority)Location: Metadata: updated.Object["metadata"].(map[string]interface{}),Issue: Direct type assertion without checking. This violates the CLAUDE.md rule:
Fix Required: metadata, found, err := unstructured.NestedMap(updated.Object, "metadata")
if !found || err != nil {
log.Printf("Failed to get metadata: %v", err)
c.JSON(http.StatusInternalServerError, gin.H{"error": "Invalid session metadata"})
return
}
session.Metadata = metadataThis pattern appears in multiple places (lines 1147, 264, 772, 915, 1007, 1070, 1353, 1564, 1704). All should be fixed. 2. Missing Authentication Check on OOTB Workflows EndpointLocation: // Public endpoints (no auth required)
api.GET("/workflows/ootb", handlers.ListOOTBWorkflows)Issue: While OOTB workflows might be considered "public" configuration, this endpoint is placed outside the authentication middleware, which is inconsistent with the rest of the API. Even read-only endpoints typically require authentication in Kubernetes-native platforms. Recommendation: Consider moving this inside 3. Directory Creation in Runner Without Error PropagationLocation: if not cwd_path_obj.exists():
logging.warning(f"Working directory does not exist, creating: {cwd_path}")
try:
cwd_path_obj.mkdir(parents=True, exist_ok=True)
logging.info(f"Created working directory: {cwd_path}")
except Exception as e:
logging.error(f"Failed to create working directory: {e}")
# Fall back to workspace root
cwd_path = self.context.workspace_path
logging.info(f"Falling back to workspace root: {cwd_path}")Issue: While the code handles the error gracefully with a fallback, this silent recovery could mask configuration issues. If a workflow directory is expected but doesn't exist, the session might behave unexpectedly. Recommendation: Consider updating session status to indicate the fallback occurred, so users are aware their workflow wasn't loaded properly.
|
- Implemented new endpoints for managing Git operations, including status retrieval, remote configuration, and synchronization for artifacts. - Enhanced the ProjectSessionDetailPage to support Git status display, remote configuration, and synchronization actions for workflow outputs. - Introduced state management for Git status and synchronization processes, improving user experience with real-time updates and feedback. - Added UI components for configuring Git remotes and synchronizing changes, ensuring seamless integration with the existing workflow management system.
Technical Review: PR #272 - UI revamp fix backendExecutive SummaryThis PR has 81 changed files with ~9k additions. While the architecture follows established patterns, there are CRITICAL type safety issues and HIGH severity security concerns that must be addressed before merging. 🚨 CRITICAL Issues1. Unsafe Type Assertions (handlers/sessions.go)Lines: 281, 789, 932, 936, 990, 1899, 2110 Direct type assertions without checking violate CLAUDE.md rules: Impact: Runtime panics if metadata is nil/wrong type 2. Missing Authorization Checks (Git endpoints)File: handlers/sessions.go (lines 3087-3544) Git operations don't validate GetK8sClientsForRequest result: Impact: Bypasses RBAC, unauthorized operations 3. Path Traversal VulnerabilityFile: handlers/content.go (lines 159-200) Insufficient path sanitization allows escaping StateBaseDir
|
Code Review: PR #272 - UI Revamp Fix BackendExecutive SummaryOverall Assessment:
See full review details below... |
🔴 Critical Issues (Must Fix)1. Type-Safe Unstructured Access Violations (Backend)Severity: HIGH - Can cause runtime panics Multiple violations of CLAUDE.md standards in Problem: Direct type assertions without checking, e.g.: spec := item.Object["spec"].(map[string]interface{})Required Fix: spec, ok := item.Object["spec"].(map[string]interface{})
if !ok {
log.Printf("Invalid spec field in session %s", sessionName)
c.JSON(http.StatusInternalServerError, gin.H{"error": "Invalid resource structure"})
return
}2. Component Size Violation (Frontend)File:
This component needs to be broken down into smaller, focused components with hooks and utility functions. 3. React Query Violations (Frontend)Severity: HIGH - Violates DESIGN_GUIDELINES.md Multiple manual |
✅ Excellent Practices FoundBackend Security (All Good!)
Frontend Best Practices
|
🎯 Action Items Before MergeMust Fix:
Should Fix:
Nice to Have:
🏆 Overall Grade
Final Recommendation: The core architecture changes are excellent with great security practices, but critical type safety issues and component size violations must be addressed before merging. 📚 References: |
Code Review: UI Revamp & Backend CleanupI've reviewed the changes in this PR (commits 93d5c01 through 658db8c). Here's my comprehensive feedback: Summary of ChangesThis PR contains 5 commits focused on:
StrengthsFrontend Excellence
Backend Quality
New Features
Critical Issues1. Component Size ViolationFile: components/frontend/src/app/projects/[name]/sessions/[sessionName]/page.tsx
Recommendation: Break down into smaller components:
2. Missing Error HandlingFile: page.tsx:166-179 Fix: Add response validation before proceeding. 3. Race Condition in Auto-ConfigurationFile: page.tsx:159-161 Recommendation: Poll the session status until repoStatus.cloneComplete or implement a WebSocket event for clone completion. Medium Priority Issues4. Type Safety in Message AdapterFile: page.tsx:691-910 Recommendation:
5. Inconsistent Loading State ManagementFile: page.tsx:143-200 Recommendation: Prefer React Query built-in state throughout. 6. Git Operations Missing ValidationFile: components/backend/git/operations.go:1297-1300 Recommendation: Check if branch exists first, then use appropriate flags. Suggestions for Improvement7. File Viewer EnhancementFile: page.tsx:2106-2137
8. Git Status PollingFile: page.tsx:491-497 9. Toast ImprovementsMultiple places show generic Repository cloning... without progress indication. Consider progress events, estimated time, and cancel ability. Code Quality NotesPositive Patterns
Minor Issues
Security ConsiderationsNo security issues found:
Testing RecommendationsThis PR lacks explicit tests. Recommend adding:
Action Items (Prioritized)Must Fix Before Merge
Should Fix
Nice to Have
Overall AssessmentQuality: 4/5 stars
Maintainability: 3/5 stars
Recommendation: Request Changes References
Great work on the features! The file viewer and auto-remote config are valuable additions. Let's just refactor that massive component before merging. |
Code Review: UI Revamp Fix BackendI've completed a thorough review of this PR based on the project's CLAUDE.md standards. Here are my findings: ✅ Positive AspectsBackend Code Quality
Frontend Improvements
|
Code Review: UI Revamp Fix BackendThis is a large PR with significant refactoring. Analysis based on repository standards: Positive AspectsCode Quality
Frontend Improvements
Critical Issues1. Frontend File Size Violation (BLOCKING)File: session detail page
Impact: Monolithic component is difficult to maintain and test. Fix Required: Split into focused components like workspace-browser.tsx, file-viewer-dialog.tsx, repository-manager.tsx, workflow-selector.tsx, git-operations-panel.tsx, branch-management.tsx 2. Race Condition: Hard-coded DelaysLine 154-165 uses 3-second setTimeout for repo operations. Issue: Fragile timing assumption may fail on slow systems. Fix: Poll backend for completion status or use WebSocket events. 3. Git Operations: Missing Error Contextoperations.go:1299 - checkout error lacks branch name in message. Fix: Include branch name in error for debugging. 4. Complex Startup Prompt Logicwrapper.py:522-538 has nested conditions that are hard to follow. Fix: Extract to separate method with clear documentation of priorities. Security Concerns1. Path Traversal RiskLine 311: fullPath construction vulnerable to ../ injection. Fix: Sanitize paths on frontend, validate on backend. 2. File Size LimitsFile viewer loads entire contents without size checks. Fix: Add 1MB limit and streaming for large files. Missing Test CoverageRequired tests:
Performance Considerations
Pre-Commit ChecklistBackend: Mostly compliant
Frontend: Non-compliant
Recommended ActionsPriority 1 (BLOCKING):
Priority 2 (HIGH): Priority 3 (MEDIUM): SummaryValuable UX improvements but violates project standards. The 2000+ line component is the main blocker. Component decomposition required before merge. Recommendation: Request changes Generated via Claude Code review |
Code Review: UI Revamp Fix BackendThank you for this comprehensive PR! This represents a significant refactoring that removes RFE workflows and consolidates functionality. Here's my detailed review: ✅ StrengthsBackend Code Quality
Frontend Code Quality
🔧 Issues & RecommendationsCritical Issues1. Path Traversal Vulnerability 🔴Location: path := filepath.Clean("/" + strings.TrimSpace(c.Query("path")))
if path == "/" || strings.Contains(path, "..") {
c.JSON(http.StatusBadRequest, gin.H{"error": "invalid path"})
return
}Issue: Fix: rawPath := strings.TrimSpace(c.Query("path"))
if strings.Contains(rawPath, "..") {
c.JSON(http.StatusBadRequest, gin.H{"error": "invalid path"})
return
}
path := filepath.Clean("/" + rawPath)
abs := filepath.Join(StateBaseDir, path)
if \!strings.HasPrefix(abs+string(os.PathSeparator), StateBaseDir+string(os.PathSeparator)) {
c.JSON(http.StatusBadRequest, gin.H{"error": "invalid path"})
return
}Apply this fix to:
2. Git Command Injection Risk 🟡Location: countOut, _ := run("git", "rev-list", "--count", "HEAD..origin/"+branch)Issue: If Fix: Validate branch names before use: func validateBranchName(branch string) error {
if strings.ContainsAny(branch, "\n\r; |&$`") {
return fmt.Errorf("invalid branch name")
}
return nil
}Apply to all functions that accept branch parameters. 3. Missing Error Handling 🟡Location: statusOut, _ := run("git", "status", "--porcelain")
countOut, _ := run("git", "rev-list", "--count", "HEAD..origin/"+branch)Issue: Errors from git commands are silently ignored, which could lead to incorrect status reporting. Fix: Log errors at minimum: statusOut, err := run("git", "status", "--porcelain")
if err \!= nil {
log.Printf("Warning: git status failed: %v", err)
}Code Quality Issues4. Duplicate Path Validation Logic 🟡Issue: Path validation is repeated across multiple handlers with slight variations. Recommendation: Extract to a helper function: // In handlers/helpers.go
func ValidateAndResolvePath(queryPath string) (string, error) {
rawPath := strings.TrimSpace(queryPath)
if rawPath == "" || strings.Contains(rawPath, "..") {
return "", fmt.Errorf("invalid path")
}
path := filepath.Clean("/" + rawPath)
abs := filepath.Join(StateBaseDir, path)
if \!strings.HasPrefix(abs+string(os.PathSeparator), StateBaseDir+string(os.PathSeparator)) {
return "", fmt.Errorf("path outside base directory")
}
return abs, nil
}5. Frontmatter Parser Limitations 🟡Location: Issue: The frontmatter parser is very basic and doesn't handle:
Recommendation: Use a proper YAML library like import "gopkg.in/yaml.v3"
func parseFrontmatter(filePath string) map[string]interface{} {
content, err := os.ReadFile(filePath)
if err \!= nil {
return map[string]interface{}{}
}
// Extract frontmatter between --- delimiters
str := string(content)
if \!strings.HasPrefix(str, "---\n") {
return map[string]interface{}{}
}
endIdx := strings.Index(str[4:], "\n---")
if endIdx == -1 {
return map[string]interface{}{}
}
frontmatter := str[4 : 4+endIdx]
result := make(map[string]interface{})
if err := yaml.Unmarshal([]byte(frontmatter), &result); err \!= nil {
log.Printf("Failed to parse frontmatter: %v", err)
return map[string]interface{}{}
}
return result
}6. Git Config Hardcoded Values 🟢Location: cmd = exec.CommandContext(ctx, "git", "config", "user.name", "Ambient Code Bot")
cmd = exec.CommandContext(ctx, "git", "config", "user.email", "bot@ambient-code.local")Recommendation: Make these configurable via environment variables or config: const (
DefaultGitUserName = "Ambient Code Bot"
DefaultGitUserEmail = "bot@ambient-code.local"
)
func InitRepo(ctx context.Context, repoDir string) error {
// ... init logic ...
userName := os.Getenv("GIT_USER_NAME")
if userName == "" {
userName = DefaultGitUserName
}
// ... same for email
}Frontend Issues7. Large Component File 🟡Location: Issue: File is 1547 lines (added) - likely exceeds the 200-line guideline from Recommendation: Break down into smaller components:
8. Missing Loading/Error States 🟢Check that all new API calls have proper loading and error handling. From the code I can see good use of React Query, but verify:
🔍 Testing CoverageBackend
Frontend
Recommendation: Add integration tests in 📊 Performance ConsiderationsGit Operations
Workspace ListingThe 🔒 Security Summary
📋 Pre-Merge Checklist
🎯 Overall AssessmentCode Quality: ⭐⭐⭐⭐☆ (4/5) This is a solid refactoring that removes complexity and consolidates features. The architecture is sound and follows established patterns well. The main concerns are:
Recommendation: Request changes for the security issues, then approve after fixes. Great work on this significant refactoring! The codebase is moving in a good direction. Let me know if you need clarification on any of the feedback. cc: @Gkrumbach07 |
…ng added and removed file indicators into distinct badges. Update UI for clearer visual feedback on changes, improving user experience during directory browsing. Remove unused state variables and imports in session detail components Add activeWorkflow parsing to session spec and clean up whitespace in ConfigureGitRemote Refactor whitespace in content handler functions and update workflow directory path structure Add Git operations for merge status, pull, push, create branch, and list remote branches in backend and frontend. Update routes and handlers to support new functionalities. fix: use HEAD refspec when pushing new branch to prevent 'src refspec does not match any' error Enhance workflow selection UI to always display selector, update labels for activating and switching workflows, and improve user feedback during activation process. Implement ambient.json configuration support for workflows, enhancing metadata retrieval with custom prompts and artifacts directory management. Update frontend to utilize project-specific GitHub tokens for fetching out-of-the-box workflows and streamline artifact path handling. Update ambient.json configuration loading to check for active workflow URL instead of workflow configuration, ensuring correct artifact directory management. Update default artifacts directory in content handler and adjust ambient.json loading logic for custom workflows to default to an empty string. Refactor merge status handling to allow merging with unrelated histories and enhance frontend to display uncommitted changes in project session details. Add repository management functionality to sessions, including endpoints for adding and removing repositories. Update frontend to support repository operations and enhance directory browsing experience. Enhance ClaudeCodeAdapter to track first run state and adjust prompt handling for mid-session restarts. Update message types for startup prompts and initial prompts to improve session management. Implement compact Git operations UI in project session details, including branch management dialog, enhanced synchronization buttons, and dropdown menu for additional options. Update repository context display and improve user feedback for branch switching and creation. Improve handling of remote URLs and branches in project session details. Ensure fallback values for undefined properties, enhance synchronization button tooltips, and refine branch selection logic for better user experience. Enhance project session detail page by adding ChevronDown icon for branch dropdown, refining layout and spacing for better UI consistency, and improving button sizes for a more compact design. Update remote URL display and synchronization button tooltip for clarity. Refactor project session detail page to improve Git status display and synchronization options. Update layout for clarity, enhance button sizes, and streamline remote URL management. Add disconnect functionality for Git remotes and refine dropdown menu interactions. Refactor project session detail page by removing redundant UI elements and updating context type descriptions. Enhance remote URL display with clearer information and improve overall layout for better user experience. Remove RFE workflow functionality from backend and frontend components, including CRD, handlers, and related API routes. Refactor main application logic to eliminate dependencies on RFE workflows, streamlining the codebase for improved maintainability. Refactor Git operations and project session detail page to improve repository management. Enhance user feedback during repository changes with loading overlays, and streamline Git command execution by removing unnecessary whitespace. Update message handling in ClaudeCodeAdapter to include new repository-related message types. Enhance project session detail page by adding file viewer functionality, allowing users to view file contents directly. Implement loading states for file content retrieval and improve repository management by auto-configuring remotes after repository addition. Update UI elements for better user experience, including replacing the refresh icon with a folder sync icon. Update prompts in session creation and project session detail pages for improved user guidance. Replace default interactive prompts with a welcoming message that encourages users to select workflows and manage their workspace. Enhance prompt handling in ClaudeCodeAdapter to prioritize startup prompts and improve session initialization logic. Refine user prompts in session creation and project session detail pages to provide clearer guidance on workspace capabilities. Update ClaudeCodeAdapter to improve handling of startup prompts and session initialization logic, ensuring a more user-friendly experience. Refactor project session detail page by removing the branch creation functionality and consolidating remote management options. Update UI elements for clarity, including renaming buttons and improving user prompts for managing branches and remotes. Enhance loading states and feedback for remote configuration actions.
Gkrumbach07
force-pushed
the
ui-revamp-fix-backend
branch
from
ed3a7c8 to
f95bbfc
Compare
Code Review: UI Revamp Fix BackendOverviewThis is a substantial PR that adds new Git operations, workflow management features, and enhances the content service layer. The changes span both backend (Go) and frontend (TypeScript/Next.js) components. ✅ Strengths
|
Code Review: UI Revamp Fix BackendThis is a major refactoring with significant architectural changes. I've identified several critical issues that need attention before merging. Critical Issues1. Security: Missing Authentication in Content Endpoints (HIGH PRIORITY)Location: components/backend/handlers/content.go All new content endpoints (ContentGitStatus, ContentGitConfigureRemote, ContentGitSync, ContentWorkflowMetadata) appear to lack authentication checks. Impact: Unauthenticated users could potentially access/modify workspace content. Recommendation:
2. Path Traversal VulnerabilityLocation: components/backend/handlers/content.go:159-171 The ".." check happens BEFORE filepath.Clean, which normalizes paths. An attacker could bypass this with encoded sequences. Fix: Apply the pattern from ContentGitPush:64 - check AFTER filepath.Join to verify final path is under StateBaseDir. 3. Command Injection Risk in Git OperationsLocation: components/backend/git/operations.go:1163-1164 User-controlled remoteUrl is passed directly to git commands without sanitization. Malicious URLs could exploit git protocol handlers. Recommendation:
High Priority Issues4. Error Handling: Silent FailuresLocation: components/backend/git/operations.go:1145-1150 Git config failures are silently ignored. If user.name/user.email aren't set and config fails, subsequent commits will fail with cryptic errors. Recommendation: Log failures at minimum 5. Race Condition in Merge Status CheckLocation: components/backend/git/operations.go:1203-1239 Multiple git commands without locking could race with concurrent operations (pull, push, sync). Recommendation: Document that callers should use application-level locking OR implement file-based locking 6. Frontend: Massive Component (1556 lines)Location: components/frontend/src/app/projects/[name]/sessions/[sessionName]/page.tsx Violates DESIGN_GUIDELINES.md Component Size Limit (max 200 lines) Recommendation: Extract to separate components:
7. Type Safety: Missing Error HandlingMultiple frontend files have promises without proper error handling (no res.ok check, no try/catch) Medium Priority Issues
Positive Observations
Pre-Merge Checklist
Overall Assessment: This PR introduces valuable functionality but has CRITICAL SECURITY ISSUES that must be resolved before merging. The architectural direction is sound, but implementation needs hardening. Please address the critical and high-priority issues, then request re-review. |
…nce by implementing inline file viewing and folder navigation. Replace file viewer dialog with inline content display, allowing users to navigate directories and view file contents directly. Update state management for improved clarity and functionality.
Code Review: UI Revamp - Session Detail EnhancementExecutive SummaryThis PR represents a major refactor that removes RFE workflow functionality and adds inline file viewing, folder navigation, Git operations, and repository management to sessions. Overall Assessment: Strong functionality but requires significant refactoring before merge due to violations of established coding standards. CRITICAL ISSUES (Must Fix Before Merge)1. Component Size Violation - SEVERELocation: Problem: The component is 2,100+ lines - more than 10x the 200-line maximum specified in Required Action: Break down into smaller, focused components (page.tsx < 100 lines, individual components < 200 lines each) Reference: See 2. Security Vulnerability: XSS Risk in File Content DisplayLocation: Problem: File content is displayed without sanitization. Malicious files could execute HTML/JavaScript. Required Fix: Add DOMPurify sanitization or use a safe syntax highlighting library 3. Race Condition: Repository Remote ConfigurationLocation: Problem: Uses fixed 3-second timeout instead of polling for actual clone completion Required Fix: Poll for completion with proper status checks instead of fixed timeout 4. Missing Type SafetyProblem: Several instances of unsafe type handling - no type guards, unsafe optional chaining, missing null checks Required Fix: Add proper type definitions and type guard functions 5. Backend: Error Handling ViolationsLocation: Problem: Errors from json.Marshal are ignored with underscore Per CLAUDE.md: "REQUIRED: Return explicit errors with context" IMPORTANT ISSUES (Should Fix)
POSITIVE OBSERVATIONS
PRE-MERGE CHECKLISTMust Fix (Blockers):
Should Fix:
RECOMMENDATIONDO NOT MERGE until items 1-5 (Critical Issues) are addressed. The component size violation and XSS vulnerability are blockers. After addressing critical issues, this is solid work that significantly enhances the session detail experience. Review conducted per: |
…lows from the codebase. Update related handlers, manifests, and scripts to streamline project management functionality. Adjust remote URL handling in Git operations and enhance user experience in frontend components. Clean up unused variables and improve documentation for clarity.
Code Review: UI Revamp Fix Backend (PR #272)I've reviewed this large PR which removes RFE workflows and adds extensive git operation capabilities. Here's my comprehensive feedback: 🎯 Overall AssessmentThis is a significant refactoring with 8,439 additions and 8,750 deletions across backend and frontend. The changes are generally well-structured, but there are several critical security concerns and best practice violations that must be addressed. 🔴 Critical Issues (Must Fix)1. Command Injection Vulnerabilities in Git OperationsLocation: The new git operation functions use user-provided input (branch names, remote URLs) directly in exec.Command without proper sanitization: // Line 1044 - branch name comes from user input
cmd = exec.CommandContext(ctx, "git", "-C", repoDir, "push", "-u", "origin", fmt.Sprintf("HEAD:%s", branchName))
// Line 1087 - remote URL comes from user input
cmd = exec.CommandContext(ctx, "git", "remote", "add", remoteName, remoteURL)
// Line 1190 - branch name in pull operation
cmd := exec.CommandContext(ctx, "git", "pull", "--allow-unrelated-histories", "origin", branch)Risk: While
Recommendation: // Add strict validation
func validateBranchName(branch string) error {
// Only allow alphanumeric, hyphens, underscores, forward slashes
matched, _ := regexp.MatchString("^[a-zA-Z0-9/_-]+$", branch)
if \!matched || strings.Contains(branch, "..") {
return fmt.Errorf("invalid branch name: %s", branch)
}
return nil
}
func validateGitURL(url string) error {
// Only allow https:// URLs for GitHub
if \!strings.HasPrefix(url, "https://github.com/") &&
\!strings.HasPrefix(url, "https://gitlab.com/") {
return fmt.Errorf("invalid git URL scheme")
}
return nil
}2. Path Traversal Vulnerability in Content HandlersLocation: The path sanitization is insufficient: repoDir := filepath.Clean(filepath.Join(StateBaseDir, body.RepoPath))
if \!strings.HasPrefix(repoDir+string(os.PathSeparator), StateBaseDir+string(os.PathSeparator)) && repoDir \!= StateBaseDir {
// reject
}Issue: The check has a logic flaw with the Recommendation: // Stricter validation
if body.RepoPath == "" || strings.Contains(body.RepoPath, "..") {
c.JSON(http.StatusBadRequest, gin.H{"error": "invalid repoPath"})
return
}
repoDir := filepath.Clean(filepath.Join(StateBaseDir, body.RepoPath))
relPath, err := filepath.Rel(StateBaseDir, repoDir)
if err \!= nil || strings.HasPrefix(relPath, "..") {
c.JSON(http.StatusBadRequest, gin.H{"error": "path traversal detected"})
return
}3. Missing Error Handling in Git OperationsLocation: cmd = exec.CommandContext(ctx, "git", "config", "user.name", "Ambient Code Bot")
cmd.Dir = repoDir
_ = cmd.Run() // Best effort - NO ERROR CHECKINGIssue: Silently ignoring errors could lead to commits without proper author attribution, which may cause issues with some Git hosting providers or compliance requirements. Recommendation: At minimum, log the error: if err := cmd.Run(); err \!= nil {
log.Printf("Warning: failed to set git user.name: %v", err)
}4. Frontend: Missing Loading/Error StatesLocation: This 1,585-line component has multiple async operations but some lack proper loading/error states:
Recommendation: Ensure all mutations show loading states and handle errors with user-friendly messages.
|
…tication in backend handlers. Update session handler to forward GitHub token for authenticated requests. Improve project session detail page with an EmptyState component for stopped or error sessions, enhancing user feedback and experience.
PR Review: UI Revamp Fix BackendComprehensive review of PR #272 based on CLAUDE.md standards. Overall AssessmentSize: 127 files (+8,467/-8,750 lines) - Large PR removing RFE functionality and adding git operations. Critical Issues (Must Fix)1. Missing Authorization in New Handlers
2. Token Security in Git Operations
3. Frontend Error Handling Missing
Important Issues (Should Fix)4. Best Effort Logging
5. Merge Status Logic
6. Context Cancellation
7. Frontend Code Duplication
Code Quality8. Magic Strings: Extract "main" default branch to constant Pre-Merge Checklist
RecommendationsMust fix before merge:
Good work following authentication patterns and avoiding panic()! Please address security concerns before merging. |
Refactors secret management to use two hardcoded Kubernetes secrets instead of one, ensuring integration keys (GIT_*, JIRA_*) remain available when Vertex AI manages ANTHROPIC_API_KEY. Architecture: - ambient-runner-secrets: ANTHROPIC_API_KEY only (ignored when Vertex enabled) - ambient-non-vertex-integrations: GIT_TOKEN, JIRA_*, custom keys (always injected) Fixes git authentication for Claude-initiated pushes by persisting token in origin remote URL after clone. This enables Claude to push to GitHub at any time during the session using standard git commands, not just via the structured end-of-session auto-push feature. 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude <noreply@anthropic.com>
…for commit messages. Implement local commit handling and update UI to reflect changes. Remove unused Git diff fetching and related code for improved clarity and performance.
PR Review: UI Revamp Fix BackendThank you for this substantial PR! I've completed a thorough review based on the repository's CLAUDE.md standards. Here are my findings: 🔴 Critical Issues1. Token Security Violation (components/backend/handlers/content.go:256)log.Printf("Injected GitHub token into remote URL")Issue: While the token itself isn't logged, the authenticated URL containing the token is then used in git operations whose output may be logged. CLAUDE.md Rule: "REQUIRED: Redact tokens in logs using custom formatters" Fix: Ensure all git command outputs that might contain the authenticated URL are sanitized before logging. 2. Path Traversal Vulnerability (components/backend/handlers/content.go:161-164, 226-228)path := filepath.Clean("/" + strings.TrimSpace(c.Query("path")))
if path == "/" || strings.Contains(path, "..") {
c.JSON(http.StatusBadRequest, gin.H{"error": "invalid path"})
return
}Issue: The check for ".." is performed AFTER Example: Fix: path := filepath.Clean("/" + strings.TrimSpace(c.Query("path")))
abs := filepath.Join(StateBaseDir, path)
// Verify the resolved path is within StateBaseDir
if \!strings.HasPrefix(abs, filepath.Clean(StateBaseDir)) {
c.JSON(http.StatusBadRequest, gin.H{"error": "invalid path"})
return
}3. Missing Authentication on Content EndpointsThe new content endpoints ( CLAUDE.md Rule: "REQUIRED: Always use GetK8sClientsForRequest(c) to get user-scoped K8s clients" Issue: If these endpoints are exposed, any authenticated user could potentially manipulate git state in any session's workspace. Fix: Add proper authentication and authorization checks, or ensure these endpoints are only accessible in CONTENT_SERVICE_MODE within the session pod's internal network.
|
Git auth
Comprehensive Code Review - PR #272: UI Revamp Fix BackendThis is an extensive PR with 106 files changed (+8,809/-8,946). I've conducted a thorough review across backend security, frontend design patterns, test coverage, and architecture. Here are my findings: 🔴 Critical Issues - Must Fix Before Merge1. Backend Type Safety Violations (HIGH SEVERITY)Impact: Can cause backend crashes on malformed Custom Resources Location: Problem: Unsafe type assertions without checking the // Line 272 - UNSAFE - will panic if metadata is not a map
Metadata: item.Object["metadata"].(map[string]interface{}),Fix Pattern (from CLAUDE.md): if metadata, ok := item.Object["metadata"].(map[string]interface{}); ok {
session.Metadata = metadata
} else {
log.Printf("Warning: session %s has invalid metadata type", item.GetName())
session.Metadata = make(map[string]interface{})
}Lines affected: 272, 732, 875, 933, 967, 1011, 1030, 1070, 1107, 1160, 1228, 1582, 1656, 1763, 1842, 1867, 1900, 1972, 2007, 2053, 2347, 2502, 2524, 2787, 2853, 3144 2. Frontend Component Size Violation (CRITICAL)Impact: Unmaintainable code, difficult debugging, violation of design guidelines Location: Issue: 2,211 lines - This is 11x over the 200-line limit specified in DESIGN_GUIDELINES.md Required Refactoring: 3. Insufficient Test Coverage (BLOCKS PRODUCTION)Impact: High risk of production failures New functionality with 0% test coverage:
Critical untested security paths:
Overall test coverage estimate: ~15% (decreased from ~25%) 🟡 High Priority - Should Fix4. Backend Error Handling IssuesLocation: _ = c.BindJSON(&body) // Error ignored completelyFix: if err := c.BindJSON(&body); err != nil {
c.JSON(http.StatusBadRequest, gin.H{"error": "invalid request body"})
return
}5. Frontend Manual Fetch Instead of React QueryLocation: Issue: Direct Fix: Move to API service layer: // In services/api/sessions.ts
export const sessionsApi = {
addRepo: (projectName, sessionName, repo) =>
apiClient.post(`/projects/${projectName}/agentic-sessions/${sessionName}/repos`, repo),
};
// In component
const addRepoMutation = useAddSessionRepo();
addRepoMutation.mutate({ projectName, sessionName, repo });6. Path Traversal Security EnhancementLocation: Issue: path := filepath.Clean("/" + strings.TrimSpace(c.Query("path")))
if path == "/" || strings.Contains(path, "..") { // This check is too lateBetter pattern: path := strings.TrimSpace(c.Query("path"))
if path == "" || path == "/" || strings.Contains(path, "..") {
c.JSON(http.StatusBadRequest, gin.H{"error": "invalid path"})
return
}
path = filepath.Clean("/" + path)
abs := filepath.Join(StateBaseDir, path)
if !strings.HasPrefix(abs+string(os.PathSeparator), StateBaseDir+string(os.PathSeparator)) {
c.JSON(http.StatusBadRequest, gin.H{"error": "path escape attempt"})
return
}7. Missing Context Timeouts for Git OperationsLocation: Issue: Git commands could hang indefinitely without timeout Fix: // In handlers
ctx, cancel := context.WithTimeout(c.Request.Context(), 30*time.Second)
defer cancel()
err := GitPullRepo(ctx, abs, body.Branch)8. Frontend Complex State ManagementLocation: Issue: 52 individual Recommendation:
|
Enables downloading individual files from the session workspace directory browser: - Added Download icon button when viewing a file inline - Dropdown menu for future sync integrations (Jira, GDrive) - Downloads use existing workspace API endpoint - User feedback via success toast notification This supports PM workflows where specs and artifacts need to be downloaded for upload to external systems. 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude <noreply@anthropic.com>
Add single file download from Directory Browser
Pull Request Review: UI Revamp Fix Backend (#272)OverviewThis is a LARGE PR (8863 additions, 8946 deletions across 100+ files) that removes RFE workflow functionality and significantly refactors both backend and frontend code. The changes appear to be a major architectural shift in session management and workspace handling. 🔴 Critical Issues (Must Fix Before Merge)1. Unsafe Type Assertions Without Checking (CLAUDE.md violation)Location: Multiple instances of direct type assertions without safety checks that will panic on failure: // Line 272, 732, 875, 933 - UNSAFE
Metadata: item.Object["metadata"].(map[string]interface{}),Problem: Violates the "Never Panic in Production Code" rule from CLAUDE.md. Required Fix: Use safe type assertions or // GOOD - Safe pattern
metadata, found, err := unstructured.NestedMap(item.Object, "metadata")
if !found || err != nil {
log.Printf("Failed to extract metadata: %v", err)
c.JSON(http.StatusInternalServerError, gin.H{"error": "Invalid resource structure"})
return
}Impact: Production crashes if Kubernetes resources have unexpected structure. 2. Path Traversal Vulnerability in Content Handlers (SECURITY CRITICAL)Location: Vulnerable Code Pattern: path := filepath.Clean("/" + strings.TrimSpace(c.Query("path")))
if path == "/" || strings.Contains(path, "..") {
c.JSON(http.StatusBadRequest, gin.H{"error": "invalid path"})
return
}Problem: Attack Vector:
Required Fix: Check BEFORE cleaning: rawPath := strings.TrimSpace(c.Query("path"))
if strings.Contains(rawPath, "..") || strings.HasPrefix(rawPath, "/") {
c.JSON(http.StatusBadRequest, gin.H{"error": "invalid path"})
return
}
path := filepath.Clean("/" + rawPath)Affected Handlers (11 total):
3. Backend Service Account Used for Resource CreationLocation: created, err := K8sClient.CoreV1().Pods(project).Create(c.Request.Context(), pod, v1.CreateOptions{})Question: Is this temp-content pod creation truly an infrastructure operation, or should it use user RBAC via Per CLAUDE.md, backend SA should only be used for:
Required: Document/justify why backend SA is appropriate here, or switch to user-scoped client. 4. Missing OwnerReference DocumentationLocation: Pattern is correct but needs comment explaining intentional omission: ownerRef := v1.OwnerReference{
APIVersion: obj.GetAPIVersion(),
Kind: obj.GetKind(),
Name: obj.GetName(),
UID: obj.GetUID(),
Controller: types.BoolPtr(true),
// BlockOwnerDeletion intentionally omitted (causes permission issues in multi-tenant)
}
|
sallyom
left a comment
sallyom
left a comment
There was a problem hiding this comment.
There will be follow-up and many breaking changes :)
Co-authored-by: Daniel-Warner-X <dan@danielwarner.net> Co-authored-by: Andy Braren <abraren@redhat.com> Co-authored-by: sallyom <somalley@redhat.com> Co-authored-by: Claude <noreply@anthropic.com>
4 participants
No description provided.