fc9aabcda0
The agent's workspace tracker is now split per-repository for multi-repo
task roots. Each repo gets its own tracker that polls git independently
and stamps its repository name onto every emitted event. The Changes
panel aggregates files from every repo and groups them under per-repo
headers using the file-tree machinery from Phase 6.
Backend (agentctl):
- GitStatusUpdate / FileListUpdate gain a RepositoryName field. Empty
for single-repo workspaces (legacy clients see no change).
- WorkspaceTracker carries repositoryName and stamps it onto every
emitted status/file-list. Two constructors: NewWorkspaceTracker for
the legacy single-repo path (with the bare-root fallback) and
NewWorkspaceTrackerForRepo for explicit per-repo trackers.
- Manager scans direct child directories for git repos at construction.
When 2+ repos are found, builds one tracker per repo subdir on top of
the root tracker (which stays bound to the bare task root and emits
nothing useful). Single-repo workspaces are unchanged.
- Manager.SubscribeWorkspaceStream / UnsubscribeWorkspaceStream fan out
one client subscription across the root + all per-repo trackers via
AttachWorkspaceStreamSubscriber / DetachWorkspaceStreamSubscriber on
the tracker. The WS handler switched from the single-tracker subscribe
to the manager fan-out.
- Tests cover: per-repo trackers spawn for multi-repo task roots,
single-repo doesn't, both repos emit GitStatusUpdates tagged with
RepositoryName.
Frontend:
- GitStatusEntry / GitStatusData carry repository_name (optional).
- session-runtime gitStatus.byEnvironmentRepo new map keyed by env id
then repository name; setGitStatus routes per-repo updates into it
while still updating the legacy byEnvironmentId for single-repo
consumers. clearGitStatus drops both maps.
- migrateEnvKeyedData migrates the new per-repo map alongside the
existing keys when sessionId resolves to an environmentId.
- WS git-status handler forwards repository_name from event.status.
- New useSessionGitStatusByRepo hook returns sorted [{repo, status}]
pairs for the active session.
- task-changes-panel mergeReviewFiles iterates statusByRepo when
available, stamping repository_name onto every uncommitted file so
the Changes panel groups them under per-repo headers (using the
ReviewFile.repository_name plumbing from Phase 6).
- Tests: per-repo routing, no overwrite on sibling repo update,
legacy single-repo fallback, clear-on-cleanup.
Verified: pnpm exec vitest run 623/623, eslint --max-warnings 0 clean,
tsc --noEmit clean, make test (backend) clean, make lint 0 issues.
Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
768 lines
24 KiB
Go
768 lines
24 KiB
Go
package process
|
|
|
|
import (
|
|
"context"
|
|
"crypto/sha256"
|
|
"encoding/base64"
|
|
"encoding/hex"
|
|
"errors"
|
|
"fmt"
|
|
"io"
|
|
"io/fs"
|
|
"os"
|
|
"os/exec"
|
|
"path/filepath"
|
|
"sort"
|
|
"strconv"
|
|
"strings"
|
|
"time"
|
|
"unicode/utf8"
|
|
|
|
"github.com/kandev/kandev/internal/agentctl/types"
|
|
"go.uber.org/zap"
|
|
)
|
|
|
|
const (
|
|
// ResolutionApplied indicates the diff was applied normally via git apply.
|
|
ResolutionApplied = "applied"
|
|
// ResolutionOverwritten indicates the file was overwritten with desired content.
|
|
ResolutionOverwritten = "overwritten"
|
|
)
|
|
|
|
const maxFileSize = 10 * 1024 * 1024 // 10MB
|
|
|
|
// updateFiles updates the file listing
|
|
func (wt *WorkspaceTracker) updateFiles(ctx context.Context) {
|
|
files, err := wt.getFileList(ctx)
|
|
if err != nil {
|
|
wt.logger.Debug("failed to get file list", zap.Error(err))
|
|
return
|
|
}
|
|
|
|
wt.mu.Lock()
|
|
wt.currentFiles = files
|
|
wt.mu.Unlock()
|
|
}
|
|
|
|
// getFileList retrieves the list of files in the workspace
|
|
func (wt *WorkspaceTracker) getFileList(ctx context.Context) (types.FileListUpdate, error) {
|
|
update := types.FileListUpdate{
|
|
Timestamp: time.Now(),
|
|
RepositoryName: wt.repositoryName,
|
|
Files: []types.FileEntry{},
|
|
}
|
|
|
|
// Use git ls-files to get tracked files AND untracked files (excluding ignored)
|
|
// --cached: include tracked files
|
|
// --others: include untracked files
|
|
// --exclude-standard: respect .gitignore
|
|
cmd := exec.CommandContext(ctx, "git", "ls-files", "--cached", "--others", "--exclude-standard")
|
|
cmd.Dir = wt.workDir
|
|
out, err := cmd.Output()
|
|
if err != nil {
|
|
return update, err
|
|
}
|
|
|
|
lines := strings.Split(string(out), "\n")
|
|
for _, line := range lines {
|
|
line = strings.TrimSpace(line)
|
|
if line == "" {
|
|
continue
|
|
}
|
|
update.Files = append(update.Files, types.FileEntry{
|
|
Path: line,
|
|
IsDir: false,
|
|
})
|
|
}
|
|
|
|
return update, nil
|
|
}
|
|
|
|
// GetFileTree returns the file tree for a given path and depth
|
|
func (wt *WorkspaceTracker) GetFileTree(reqPath string, depth int) (*types.FileTreeNode, error) {
|
|
// Resolve the full path with path traversal protection
|
|
safePath := filepath.Join(wt.workDir, filepath.Clean(reqPath))
|
|
cleanWorkDir := filepath.Clean(wt.workDir)
|
|
if !strings.HasPrefix(safePath, cleanWorkDir+string(os.PathSeparator)) && safePath != cleanWorkDir {
|
|
return nil, fmt.Errorf("path traversal detected")
|
|
}
|
|
|
|
// Check if path exists
|
|
info, err := os.Stat(safePath)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("path not found: %w", err)
|
|
}
|
|
|
|
// Build the tree
|
|
node, err := wt.buildFileTreeNode(safePath, reqPath, info, depth, 0)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return node, nil
|
|
}
|
|
|
|
// buildFileTreeNode recursively builds a file tree node
|
|
func (wt *WorkspaceTracker) buildFileTreeNode(safePath, relPath string, info os.FileInfo, maxDepth, currentDepth int) (*types.FileTreeNode, error) {
|
|
node := &types.FileTreeNode{
|
|
Name: info.Name(),
|
|
Path: relPath,
|
|
IsDir: info.IsDir(),
|
|
Size: info.Size(),
|
|
}
|
|
|
|
// If it's a file or we've reached max depth, return
|
|
if !info.IsDir() || (maxDepth > 0 && currentDepth >= maxDepth) {
|
|
return node, nil
|
|
}
|
|
|
|
// Read directory contents
|
|
entries, err := os.ReadDir(safePath)
|
|
if err != nil {
|
|
return node, nil // Return node without children on error
|
|
}
|
|
|
|
// Build children
|
|
node.Children = make([]*types.FileTreeNode, 0, len(entries))
|
|
for _, entry := range entries {
|
|
// Skip specific directories that should be ignored
|
|
name := entry.Name()
|
|
if name == ".git" || name == "node_modules" || name == ".next" || name == "dist" || name == "build" {
|
|
continue
|
|
}
|
|
|
|
childFullPath := filepath.Join(safePath, name)
|
|
childRelPath := filepath.Join(relPath, name)
|
|
|
|
isSymlink := entry.Type()&os.ModeSymlink != 0
|
|
var childInfo os.FileInfo
|
|
if isSymlink {
|
|
// Follow symlink to get target's info (IsDir, Size).
|
|
// os.Stat returns ELOOP for circular symlinks, which we skip.
|
|
childInfo, err = os.Stat(childFullPath)
|
|
} else {
|
|
childInfo, err = entry.Info()
|
|
}
|
|
if err != nil {
|
|
continue
|
|
}
|
|
|
|
childNode, err := wt.buildFileTreeNode(childFullPath, childRelPath, childInfo, maxDepth, currentDepth+1)
|
|
if err != nil {
|
|
continue
|
|
}
|
|
childNode.IsSymlink = isSymlink
|
|
|
|
node.Children = append(node.Children, childNode)
|
|
}
|
|
|
|
return node, nil
|
|
}
|
|
|
|
// resolvedWorkDir returns the workspace directory with symlinks resolved.
|
|
func (wt *WorkspaceTracker) resolvedWorkDir() string {
|
|
resolved, err := filepath.EvalSymlinks(filepath.Clean(wt.workDir))
|
|
if err != nil {
|
|
return filepath.Clean(wt.workDir)
|
|
}
|
|
return resolved
|
|
}
|
|
|
|
// resolveSafePath resolves reqPath to an absolute path within workDir,
|
|
// rejecting any path traversal attempts. The returned path is always
|
|
// constructed as filepath.Join(resolvedWorkDir, validatedRelPath) so that
|
|
// static analysis tools (CodeQL) can verify it stays within the workspace.
|
|
func (wt *WorkspaceTracker) resolveSafePath(reqPath string) (string, error) {
|
|
cleanWorkDir := filepath.Clean(wt.workDir)
|
|
cleanReqPath := filepath.Clean(reqPath)
|
|
|
|
// Resolve workspace directory symlinks first so that all constructed
|
|
// paths share the same canonical prefix (e.g. /private/var on macOS
|
|
// where /var is a symlink).
|
|
realWorkDir, err := filepath.EvalSymlinks(cleanWorkDir)
|
|
if err != nil {
|
|
realWorkDir = cleanWorkDir
|
|
}
|
|
|
|
var safePath string
|
|
if filepath.IsAbs(cleanReqPath) {
|
|
safePath = cleanReqPath
|
|
} else {
|
|
safePath = filepath.Join(realWorkDir, cleanReqPath)
|
|
}
|
|
|
|
// Resolve symlinks to prevent bypassing validation.
|
|
// When the path doesn't exist yet, walk up until we find an existing
|
|
// ancestor so symlinks (e.g. /tmp -> /private/tmp on macOS) are resolved
|
|
// consistently with realWorkDir below. Only fall back for not-found errors;
|
|
// propagate permission denied, symlink loops, etc.
|
|
realPath, err := filepath.EvalSymlinks(safePath)
|
|
if err != nil {
|
|
if !errors.Is(err, fs.ErrNotExist) {
|
|
return "", fmt.Errorf("failed to resolve path: %w", err)
|
|
}
|
|
realPath, err = resolveNonExistentPath(safePath)
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
}
|
|
|
|
// Check that the real path is within the workspace
|
|
relPath, err := filepath.Rel(realWorkDir, realPath)
|
|
if err != nil {
|
|
return "", fmt.Errorf("invalid path: %w", err)
|
|
}
|
|
|
|
// Ensure the relative path doesn't escape the workspace
|
|
if strings.HasPrefix(relPath, ".."+string(os.PathSeparator)) || relPath == ".." {
|
|
return "", fmt.Errorf("path traversal detected: %s", reqPath)
|
|
}
|
|
|
|
// Reconstruct the absolute path from the trusted workspace root and the
|
|
// validated relative path. This ensures the returned path is provably
|
|
// inside the workspace, satisfying static-analysis taint checks.
|
|
return filepath.Join(realWorkDir, relPath), nil
|
|
}
|
|
|
|
// resolveNonExistentPath walks up from path until it finds an existing
|
|
// ancestor, resolves its symlinks, then reattaches the non-existent tail.
|
|
// This ensures paths under symlinked directories (e.g. /tmp on macOS)
|
|
// resolve consistently even when the target doesn't exist yet.
|
|
// Returns an error if an ancestor fails with something other than ErrNotExist
|
|
// (e.g. permission denied, symlink loop).
|
|
func resolveNonExistentPath(path string) (string, error) {
|
|
current := path
|
|
var tail []string
|
|
for {
|
|
resolved, err := filepath.EvalSymlinks(current)
|
|
if err == nil {
|
|
for i := len(tail) - 1; i >= 0; i-- {
|
|
resolved = filepath.Join(resolved, tail[i])
|
|
}
|
|
return resolved, nil
|
|
}
|
|
if !errors.Is(err, fs.ErrNotExist) {
|
|
return "", fmt.Errorf("failed to resolve ancestor %q: %w", current, err)
|
|
}
|
|
parent := filepath.Dir(current)
|
|
if parent == current {
|
|
return "", fmt.Errorf("no existing ancestor for %q: %w", path, err)
|
|
}
|
|
tail = append(tail, filepath.Base(current))
|
|
current = parent
|
|
}
|
|
}
|
|
|
|
// GetFileContent returns the content of a file.
|
|
// If the file is not valid UTF-8, it is base64-encoded and isBinary is true.
|
|
// If the file is a symlink, resolvedPath contains the target path relative to the workspace root.
|
|
func (wt *WorkspaceTracker) GetFileContent(reqPath string) (string, int64, bool, string, error) {
|
|
safePath, err := wt.resolveSafePath(reqPath)
|
|
if err != nil {
|
|
return "", 0, false, "", err
|
|
}
|
|
|
|
// Check if the original path is a symlink and compute the resolved relative path.
|
|
resolvedPath := wt.resolveSymlinkRelPath(reqPath)
|
|
|
|
// Check if file exists and is a regular file
|
|
info, err := os.Stat(safePath)
|
|
if err != nil {
|
|
return "", 0, false, "", fmt.Errorf("file not found: %w", err)
|
|
}
|
|
|
|
if info.IsDir() {
|
|
return "", 0, false, "", fmt.Errorf("path is a directory, not a file")
|
|
}
|
|
|
|
// Check file size
|
|
if info.Size() > maxFileSize {
|
|
return "", info.Size(), false, "", fmt.Errorf("file too large (max 10MB)")
|
|
}
|
|
|
|
// Read file content
|
|
file, err := os.Open(safePath)
|
|
if err != nil {
|
|
return "", 0, false, "", fmt.Errorf("failed to open file: %w", err)
|
|
}
|
|
defer func() {
|
|
_ = file.Close()
|
|
}()
|
|
|
|
content, err := io.ReadAll(file)
|
|
if err != nil {
|
|
return "", 0, false, "", fmt.Errorf("failed to read file: %w", err)
|
|
}
|
|
|
|
// Detect binary: if content is not valid UTF-8, base64-encode it
|
|
if !utf8.Valid(content) {
|
|
encoded := base64.StdEncoding.EncodeToString(content)
|
|
return encoded, info.Size(), true, resolvedPath, nil
|
|
}
|
|
|
|
return string(content), info.Size(), false, resolvedPath, nil
|
|
}
|
|
|
|
// resolveSymlinkRelPath checks if reqPath is a symlink and returns the resolved
|
|
// target path relative to the workspace root. Returns "" if not a symlink.
|
|
func (wt *WorkspaceTracker) resolveSymlinkRelPath(reqPath string) string {
|
|
cleanReqPath := filepath.Clean(reqPath)
|
|
if strings.Contains(cleanReqPath, "..") || filepath.IsAbs(cleanReqPath) {
|
|
return ""
|
|
}
|
|
unresolvedPath := filepath.Join(wt.workDir, cleanReqPath)
|
|
info, err := os.Lstat(unresolvedPath)
|
|
if err != nil || info.Mode()&os.ModeSymlink == 0 {
|
|
return ""
|
|
}
|
|
// Resolve the symlink target
|
|
realTarget, err := filepath.EvalSymlinks(unresolvedPath)
|
|
if err != nil {
|
|
return ""
|
|
}
|
|
realWorkDir, _ := filepath.EvalSymlinks(filepath.Clean(wt.workDir))
|
|
if realWorkDir == "" {
|
|
realWorkDir = filepath.Clean(wt.workDir)
|
|
}
|
|
rel, err := filepath.Rel(realWorkDir, realTarget)
|
|
if err != nil {
|
|
return ""
|
|
}
|
|
return rel
|
|
}
|
|
|
|
// ApplyFileDiff applies a unified diff to a file with conflict detection.
|
|
// Uses git apply for reliable, battle-tested patch application.
|
|
// For symlinked files, resolves to the real path and rewrites the diff header
|
|
// so that git apply operates on the actual file.
|
|
// When desiredContent is provided and the diff cannot be applied (hash conflict),
|
|
// the file is overwritten with the desired content as a fallback.
|
|
// Returns the new hash and a resolution string ("applied" or "overwritten").
|
|
func (wt *WorkspaceTracker) ApplyFileDiff(reqPath, unifiedDiff, originalHash string, desiredContent *string) (string, string, error) {
|
|
safePath, err := wt.resolveSafePath(reqPath)
|
|
if err != nil {
|
|
return "", "", err
|
|
}
|
|
|
|
cleanWorkDir := filepath.Clean(wt.workDir)
|
|
|
|
// Read current file content
|
|
currentContent, _, _, _, err := wt.GetFileContent(reqPath)
|
|
if err != nil {
|
|
return "", "", fmt.Errorf("failed to read current file: %w", err)
|
|
}
|
|
|
|
// Calculate hash of current content for conflict detection
|
|
currentHash := calculateSHA256(currentContent)
|
|
if originalHash != "" && currentHash != originalHash {
|
|
if desiredContent != nil {
|
|
return wt.writeDesiredContent(safePath, cleanWorkDir, reqPath, *desiredContent, currentHash)
|
|
}
|
|
return "", "", fmt.Errorf("conflict detected: file has been modified (expected hash %s, got %s)", originalHash, currentHash)
|
|
}
|
|
|
|
// If the file is a symlink, resolve to the real path and rewrite the diff header.
|
|
// git apply cannot patch through symlinks — it needs the real file path.
|
|
applyPath, unifiedDiff := wt.resolveSymlinkForDiff(reqPath, safePath, cleanWorkDir, unifiedDiff)
|
|
|
|
// Write diff to a temporary patch file
|
|
patchFile := filepath.Join(wt.workDir, ".kandev-patch.tmp")
|
|
err = os.WriteFile(patchFile, []byte(unifiedDiff), 0o644)
|
|
if err != nil {
|
|
return "", "", fmt.Errorf("failed to write patch file: %w", err)
|
|
}
|
|
defer func() {
|
|
_ = os.Remove(patchFile) // Best effort cleanup
|
|
}()
|
|
|
|
// Use git apply to apply the patch directly to the file
|
|
cmd := exec.Command("git", "apply", "-p0", "--unidiff-zero", "--whitespace=nowarn", patchFile)
|
|
cmd.Dir = wt.workDir
|
|
|
|
output, err := cmd.CombinedOutput()
|
|
if err != nil {
|
|
if desiredContent != nil {
|
|
return wt.writeDesiredContent(safePath, cleanWorkDir, reqPath, *desiredContent, currentHash)
|
|
}
|
|
return "", "", fmt.Errorf("git apply failed: %w\nOutput: %s", err, string(output))
|
|
}
|
|
|
|
// Read the updated content (use the real file path for symlinks)
|
|
readPath := filepath.Join(cleanWorkDir, applyPath)
|
|
updatedContent, err := os.ReadFile(readPath)
|
|
if err != nil {
|
|
return "", "", fmt.Errorf("failed to read updated file: %w", err)
|
|
}
|
|
|
|
// Calculate new hash
|
|
newHash := calculateSHA256(string(updatedContent))
|
|
|
|
// Notify with the original relative path (not the resolved symlink target)
|
|
relPath := strings.TrimPrefix(safePath, cleanWorkDir+string(os.PathSeparator))
|
|
wt.notifyFileChange(relPath, types.FileOpWrite)
|
|
|
|
wt.logger.Debug("applied file diff using git apply",
|
|
zap.String("path", relPath),
|
|
zap.String("old_hash", currentHash),
|
|
zap.String("new_hash", newHash),
|
|
)
|
|
|
|
return newHash, ResolutionApplied, nil
|
|
}
|
|
|
|
// resolveSymlinkForDiff checks if reqPath is a symlink and, if so, rewrites the diff
|
|
// paths to target the real file. Returns the path to use for git apply and the
|
|
// (possibly rewritten) diff.
|
|
func (wt *WorkspaceTracker) resolveSymlinkForDiff(
|
|
reqPath, safePath, cleanWorkDir, unifiedDiff string,
|
|
) (string, string) {
|
|
cleanReqPath := filepath.Clean(reqPath)
|
|
if strings.Contains(cleanReqPath, "..") || filepath.IsAbs(cleanReqPath) {
|
|
return reqPath, unifiedDiff
|
|
}
|
|
unresolvedPath := filepath.Join(wt.workDir, cleanReqPath)
|
|
info, lErr := os.Lstat(unresolvedPath)
|
|
if lErr != nil || info.Mode()&os.ModeSymlink == 0 {
|
|
return reqPath, unifiedDiff
|
|
}
|
|
// File is a symlink. safePath already points to the real target.
|
|
realWorkDir, _ := filepath.EvalSymlinks(cleanWorkDir)
|
|
if realWorkDir == "" {
|
|
realWorkDir = cleanWorkDir
|
|
}
|
|
realRel, relErr := filepath.Rel(realWorkDir, safePath)
|
|
if relErr != nil {
|
|
return reqPath, unifiedDiff
|
|
}
|
|
return realRel, rewriteDiffPaths(unifiedDiff, reqPath, realRel)
|
|
}
|
|
|
|
// writeDesiredContent writes the desired content directly to the file as a fallback
|
|
// when the diff cannot be applied. Returns the new hash and "overwritten" resolution.
|
|
func (wt *WorkspaceTracker) writeDesiredContent(
|
|
safePath, cleanWorkDir, reqPath, desiredContent, oldHash string,
|
|
) (string, string, error) {
|
|
if err := os.WriteFile(safePath, []byte(desiredContent), 0o644); err != nil {
|
|
return "", "", fmt.Errorf("failed to write desired content: %w", err)
|
|
}
|
|
|
|
newHash := calculateSHA256(desiredContent)
|
|
relPath := strings.TrimPrefix(safePath, cleanWorkDir+string(os.PathSeparator))
|
|
wt.notifyFileChange(relPath, types.FileOpWrite)
|
|
|
|
wt.logger.Warn("overwrote file with desired content (conflict fallback)",
|
|
zap.String("path", reqPath),
|
|
zap.String("old_hash", oldHash),
|
|
zap.String("new_hash", newHash),
|
|
)
|
|
|
|
return newHash, ResolutionOverwritten, nil
|
|
}
|
|
|
|
// rewriteDiffPaths replaces file paths in unified diff headers.
|
|
// Handles both "--- a/old" / "+++ b/new" (with strip prefix) and
|
|
// "--- old" / "+++ new" (p0 mode) formats.
|
|
func rewriteDiffPaths(diff, oldPath, newPath string) string {
|
|
lines := strings.Split(diff, "\n")
|
|
for i, line := range lines {
|
|
if strings.HasPrefix(line, "--- ") {
|
|
lines[i] = replaceDiffPath(line, "--- ", oldPath, newPath)
|
|
} else if strings.HasPrefix(line, "+++ ") {
|
|
lines[i] = replaceDiffPath(line, "+++ ", oldPath, newPath)
|
|
}
|
|
}
|
|
return strings.Join(lines, "\n")
|
|
}
|
|
|
|
// replaceDiffPath replaces oldPath with newPath in a diff header line.
|
|
func replaceDiffPath(line, prefix, oldPath, newPath string) string {
|
|
rest := line[len(prefix):]
|
|
// Handle "--- a/path" or "--- path" formats
|
|
cleaned := strings.TrimPrefix(rest, "a/")
|
|
cleaned = strings.TrimPrefix(cleaned, "b/")
|
|
if cleaned == oldPath || filepath.Clean(cleaned) == filepath.Clean(oldPath) {
|
|
return prefix + newPath
|
|
}
|
|
return line
|
|
}
|
|
|
|
// CreateFile creates a new file in the workspace
|
|
func (wt *WorkspaceTracker) CreateFile(reqPath string) error {
|
|
safePath, err := wt.resolveSafePath(reqPath)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
// Create intermediate directories
|
|
dir := filepath.Dir(safePath)
|
|
if err := os.MkdirAll(dir, 0o755); err != nil {
|
|
return fmt.Errorf("failed to create directories: %w", err)
|
|
}
|
|
|
|
// Atomically create the file, failing if it already exists
|
|
f, err := os.OpenFile(safePath, os.O_CREATE|os.O_EXCL|os.O_WRONLY, 0o644)
|
|
if err != nil {
|
|
if os.IsExist(err) {
|
|
return fmt.Errorf("file already exists: %s", reqPath)
|
|
}
|
|
return fmt.Errorf("failed to create file: %w", err)
|
|
}
|
|
_ = f.Close()
|
|
|
|
// Notify with the relative path
|
|
cleanWorkDir := filepath.Clean(wt.workDir)
|
|
relPath := strings.TrimPrefix(safePath, cleanWorkDir+string(os.PathSeparator))
|
|
wt.notifyFileChange(relPath, types.FileOpCreate)
|
|
|
|
return nil
|
|
}
|
|
|
|
// DeleteFile deletes a file or directory from the workspace.
|
|
func (wt *WorkspaceTracker) DeleteFile(reqPath string) error {
|
|
safePath, err := wt.resolveSafePath(reqPath)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
cleanWorkDir := wt.resolvedWorkDir()
|
|
if safePath == cleanWorkDir {
|
|
return fmt.Errorf("cannot delete workspace root")
|
|
}
|
|
if err := wt.validateWorkspacePaths(safePath); err != nil {
|
|
return err
|
|
}
|
|
|
|
// Check if file exists
|
|
info, err := os.Stat(safePath)
|
|
if err != nil {
|
|
if os.IsNotExist(err) {
|
|
return fmt.Errorf("file does not exist: %s", reqPath)
|
|
}
|
|
return fmt.Errorf("failed to stat file: %w", err)
|
|
}
|
|
|
|
if info.IsDir() {
|
|
if err := os.RemoveAll(safePath); err != nil {
|
|
return fmt.Errorf("failed to delete directory: %w", err)
|
|
}
|
|
} else {
|
|
if err := os.Remove(safePath); err != nil {
|
|
return fmt.Errorf("failed to delete file: %w", err)
|
|
}
|
|
}
|
|
|
|
relPath := strings.TrimPrefix(safePath, cleanWorkDir+string(os.PathSeparator))
|
|
wt.notifyFileChange(relPath, types.FileOpRemove)
|
|
|
|
return nil
|
|
}
|
|
|
|
// RenameFile renames/moves a file or directory in the workspace.
|
|
func (wt *WorkspaceTracker) RenameFile(oldPath, newPath string) error {
|
|
if oldPath == "" || newPath == "" {
|
|
return fmt.Errorf("old_path and new_path are required")
|
|
}
|
|
|
|
oldSafePath, err := wt.resolveSafePath(oldPath)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
newSafePath, err := wt.resolveSafePath(newPath)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
if err := wt.validateWorkspacePaths(oldSafePath, newSafePath); err != nil {
|
|
return err
|
|
}
|
|
if oldSafePath == newSafePath {
|
|
return nil
|
|
}
|
|
|
|
if err := validateSourceExists(oldSafePath, oldPath); err != nil {
|
|
return err
|
|
}
|
|
if err := validateTargetAvailable(newSafePath, newPath); err != nil {
|
|
return err
|
|
}
|
|
|
|
parentDir := filepath.Dir(newSafePath)
|
|
if err := os.MkdirAll(parentDir, 0o755); err != nil {
|
|
return fmt.Errorf("failed to create target parent directories: %w", err)
|
|
}
|
|
|
|
if err := os.Rename(oldSafePath, newSafePath); err != nil {
|
|
return fmt.Errorf("failed to rename path: %w", err)
|
|
}
|
|
|
|
cleanWorkDir := wt.resolvedWorkDir()
|
|
oldRelPath := strings.TrimPrefix(oldSafePath, cleanWorkDir+string(os.PathSeparator))
|
|
newRelPath := strings.TrimPrefix(newSafePath, cleanWorkDir+string(os.PathSeparator))
|
|
wt.notifyFileChange(oldRelPath, types.FileOpRename)
|
|
if newRelPath != oldRelPath {
|
|
wt.notifyFileChange(newRelPath, types.FileOpRename)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// validateWorkspacePaths checks that all provided paths are strictly inside the workspace.
|
|
func (wt *WorkspaceTracker) validateWorkspacePaths(paths ...string) error {
|
|
cleanWorkDir := wt.resolvedWorkDir()
|
|
workDirPrefix := cleanWorkDir + string(os.PathSeparator)
|
|
for _, p := range paths {
|
|
if !strings.HasPrefix(p, workDirPrefix) {
|
|
return fmt.Errorf("path outside workspace")
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func validateSourceExists(safePath, reqPath string) error {
|
|
_, err := os.Stat(safePath)
|
|
if err == nil {
|
|
return nil
|
|
}
|
|
if os.IsNotExist(err) {
|
|
return fmt.Errorf("path does not exist: %s", reqPath)
|
|
}
|
|
return fmt.Errorf("failed to stat path: %w", err)
|
|
}
|
|
|
|
func validateTargetAvailable(safePath, reqPath string) error {
|
|
_, err := os.Stat(safePath)
|
|
if err == nil {
|
|
return fmt.Errorf("target already exists: %s", reqPath)
|
|
}
|
|
if os.IsNotExist(err) {
|
|
return nil
|
|
}
|
|
return fmt.Errorf("failed to stat target: %w", err)
|
|
}
|
|
|
|
// calculateSHA256 calculates the SHA256 hash of a string
|
|
func calculateSHA256(content string) string {
|
|
hash := sha256.Sum256([]byte(content))
|
|
return hex.EncodeToString(hash[:])
|
|
}
|
|
|
|
// scoredMatch holds a file path and its match score for sorting
|
|
type scoredMatch struct {
|
|
path string
|
|
score int
|
|
}
|
|
|
|
// GetFileContentAtRef returns the content of a file at a specific git ref (branch, commit, HEAD, etc).
|
|
// If the file is not valid UTF-8, it is base64-encoded and isBinary is true.
|
|
func (wt *WorkspaceTracker) GetFileContentAtRef(ctx context.Context, reqPath string, ref string) (string, int64, bool, error) {
|
|
// Validate path to prevent directory traversal
|
|
cleanPath := filepath.Clean(reqPath)
|
|
if strings.HasPrefix(cleanPath, "..") || filepath.IsAbs(cleanPath) {
|
|
return "", 0, false, fmt.Errorf("invalid path: path traversal detected")
|
|
}
|
|
|
|
// Use git show to get the file content at the specified ref
|
|
// Format: git show <ref>:<path>
|
|
gitRef := fmt.Sprintf("%s:%s", ref, cleanPath)
|
|
|
|
// Preflight: check blob size before materializing content to avoid memory spikes.
|
|
// Use CombinedOutput to capture stderr for error detection (git writes errors to stderr).
|
|
// Set LC_ALL=C to ensure English error messages for reliable parsing.
|
|
sizeCmd := exec.CommandContext(ctx, "git", "cat-file", "-s", gitRef)
|
|
sizeCmd.Dir = wt.workDir
|
|
sizeCmd.Env = append(os.Environ(), "LC_ALL=C")
|
|
sizeOut, err := sizeCmd.CombinedOutput()
|
|
if err != nil {
|
|
output := string(sizeOut)
|
|
if strings.Contains(output, "does not exist") ||
|
|
strings.Contains(output, "Not a valid object") ||
|
|
strings.Contains(output, "fatal: path") ||
|
|
strings.Contains(output, "fatal: not a valid") {
|
|
return "", 0, false, fmt.Errorf("file not found at ref %s: %s", ref, cleanPath)
|
|
}
|
|
return "", 0, false, fmt.Errorf("failed to stat file at ref: %w", err)
|
|
}
|
|
blobSize, err := strconv.ParseInt(strings.TrimSpace(string(sizeOut)), 10, 64)
|
|
if err != nil {
|
|
return "", 0, false, fmt.Errorf("failed to parse file size at ref: %w", err)
|
|
}
|
|
if blobSize > maxFileSize {
|
|
return "", blobSize, false, fmt.Errorf("file too large (max 10MB)")
|
|
}
|
|
|
|
cmd := exec.CommandContext(ctx, "git", "show", gitRef)
|
|
cmd.Dir = wt.workDir
|
|
|
|
content, err := cmd.Output()
|
|
if err != nil {
|
|
return "", 0, false, fmt.Errorf("failed to get file at ref: %w", err)
|
|
}
|
|
|
|
size := int64(len(content))
|
|
|
|
// Detect binary: if content is not valid UTF-8, base64-encode it
|
|
if !utf8.Valid(content) {
|
|
encoded := base64.StdEncoding.EncodeToString(content)
|
|
return encoded, size, true, nil
|
|
}
|
|
|
|
return string(content), size, false, nil
|
|
}
|
|
|
|
// SearchFiles searches for files matching the query string.
|
|
// It uses fuzzy matching with scoring based on how well the query matches.
|
|
func (wt *WorkspaceTracker) SearchFiles(query string, limit int) []string {
|
|
if query == "" {
|
|
return []string{}
|
|
}
|
|
if limit <= 0 {
|
|
limit = 20
|
|
}
|
|
|
|
query = strings.ToLower(query)
|
|
var matches []scoredMatch
|
|
|
|
wt.mu.RLock()
|
|
files := wt.currentFiles.Files
|
|
wt.mu.RUnlock()
|
|
|
|
for _, file := range files {
|
|
path := file.Path
|
|
lowerPath := strings.ToLower(path)
|
|
name := filepath.Base(lowerPath)
|
|
|
|
score := 0
|
|
switch {
|
|
case name == query:
|
|
score = 100 // Exact filename match
|
|
case strings.HasPrefix(name, query):
|
|
score = 75 // Filename starts with query
|
|
case strings.Contains(name, query):
|
|
score = 50 // Filename contains query
|
|
case strings.Contains(lowerPath, query):
|
|
score = 25 // Path contains query
|
|
}
|
|
|
|
if score > 0 {
|
|
matches = append(matches, scoredMatch{path: path, score: score})
|
|
}
|
|
}
|
|
|
|
// Sort by score descending
|
|
sort.Slice(matches, func(i, j int) bool {
|
|
if matches[i].score != matches[j].score {
|
|
return matches[i].score > matches[j].score
|
|
}
|
|
// Secondary sort by path length (shorter paths first)
|
|
return len(matches[i].path) < len(matches[j].path)
|
|
})
|
|
|
|
// Return top limit results
|
|
result := make([]string, 0, limit)
|
|
for i := 0; i < len(matches) && i < limit; i++ {
|
|
result = append(result, matches[i].path)
|
|
}
|
|
|
|
return result
|
|
}
|