You've already forked agentic-coding-workflow
109 lines
3.0 KiB
Go
109 lines
3.0 KiB
Go
package handlers
|
|
|
|
import (
|
|
"context"
|
|
"encoding/json"
|
|
"errors"
|
|
"fmt"
|
|
"io/fs"
|
|
"os"
|
|
"path/filepath"
|
|
"strings"
|
|
)
|
|
|
|
// FsReadHandler handles fs/read_text_file (spec §5.4).
|
|
type FsReadHandler struct{}
|
|
|
|
// NewFsReadHandler constructs an FsReadHandler.
|
|
func NewFsReadHandler() *FsReadHandler { return &FsReadHandler{} }
|
|
|
|
// fsReadParams is the ACP-protocol input for fs/read_text_file.
|
|
type fsReadParams struct {
|
|
SessionID string `json:"sessionId"`
|
|
Path string `json:"path"`
|
|
Line *int `json:"line,omitempty"`
|
|
Limit *int `json:"limit,omitempty"`
|
|
}
|
|
|
|
type fsReadResult struct {
|
|
Content string `json:"content"`
|
|
}
|
|
|
|
// Handle reads a file inside sess.CwdPath, returning content (with optional
|
|
// line/limit slicing). Returns FsError for path-escape or read failure.
|
|
func (h *FsReadHandler) Handle(_ context.Context, sess SessionContext, paramsJSON json.RawMessage) FsResult {
|
|
var p fsReadParams
|
|
if err := json.Unmarshal(paramsJSON, &p); err != nil {
|
|
return FsResult{Err: &FsError{Code: -32602, Message: "invalid params: " + err.Error()}}
|
|
}
|
|
abs, err := resolveSafePath(sess.CwdPath, p.Path)
|
|
if err != nil {
|
|
return FsResult{Err: &FsError{Code: -32001, Message: err.Error()}}
|
|
}
|
|
data, err := os.ReadFile(abs)
|
|
if err != nil {
|
|
if errors.Is(err, fs.ErrNotExist) {
|
|
return FsResult{Err: &FsError{Code: -32603, Message: "file not found"}}
|
|
}
|
|
return FsResult{Err: &FsError{Code: -32603, Message: "read: " + err.Error()}}
|
|
}
|
|
content := string(data)
|
|
if p.Line != nil || p.Limit != nil {
|
|
content = sliceLines(content, p.Line, p.Limit)
|
|
}
|
|
out, _ := json.Marshal(fsReadResult{Content: content})
|
|
return FsResult{OK: out}
|
|
}
|
|
|
|
// sliceLines returns lines[line:line+limit] joined by "\n".
|
|
// line is 0-based; limit caps the line count.
|
|
func sliceLines(s string, line, limit *int) string {
|
|
lines := strings.Split(s, "\n")
|
|
start := 0
|
|
if line != nil && *line > 0 {
|
|
start = *line
|
|
}
|
|
if start > len(lines) {
|
|
start = len(lines)
|
|
}
|
|
end := len(lines)
|
|
if limit != nil && *limit >= 0 {
|
|
if start+*limit < end {
|
|
end = start + *limit
|
|
}
|
|
}
|
|
return strings.Join(lines[start:end], "\n")
|
|
}
|
|
|
|
// resolveSafePath duplicates the logic from internal/acp.ResolveSafePath to
|
|
// avoid an import cycle (handlers is a sub-package and acp imports handlers).
|
|
func resolveSafePath(cwd, requested string) (string, error) {
|
|
if !filepath.IsAbs(cwd) {
|
|
return "", fmt.Errorf("cwd must be absolute")
|
|
}
|
|
cleanCwd := filepath.Clean(cwd)
|
|
var abs string
|
|
if filepath.IsAbs(requested) {
|
|
abs = filepath.Clean(requested)
|
|
} else {
|
|
abs = filepath.Clean(filepath.Join(cleanCwd, requested))
|
|
}
|
|
if !hasPathPrefix(abs, cleanCwd) {
|
|
return "", fmt.Errorf("path outside worktree")
|
|
}
|
|
if real, err := filepath.EvalSymlinks(abs); err == nil {
|
|
if !hasPathPrefix(real, cleanCwd) {
|
|
return "", fmt.Errorf("path resolves outside worktree via symlink")
|
|
}
|
|
}
|
|
return abs, nil
|
|
}
|
|
|
|
func hasPathPrefix(abs, base string) bool {
|
|
if abs == base {
|
|
return true
|
|
}
|
|
sep := string(filepath.Separator)
|
|
return strings.HasPrefix(abs, base+sep)
|
|
}
|