dela
0335d572de
ci / go (push) Waiting to run
ci / go-db (agent) (push) Waiting to run
ci / go-db (config) (push) Waiting to run
ci / go-db (db) (push) Waiting to run
ci / go-db (evidence) (push) Waiting to run
ci / go-db (llmrec) (push) Waiting to run
ci / go-db (server) (push) Waiting to run
web / web (push) Waiting to run
docs / links (push) Canceled after 0s
detections / detections (push) Canceled after 0s
306 lines
8.9 KiB
Go
306 lines
8.9 KiB
Go
package server
|
|
|
|
import (
|
|
"bytes"
|
|
"io"
|
|
"mime/multipart"
|
|
"net/http"
|
|
"net/url"
|
|
"os"
|
|
"path/filepath"
|
|
"sort"
|
|
"strings"
|
|
"unicode/utf8"
|
|
)
|
|
|
|
// Workspace file manager — browse / view / edit / download / upload / delete the
|
|
// shared work dir (s.m.dir), where all agents write their artifacts. Every path is
|
|
// confined to the work dir root (traversal via ".." is neutralised). All routes sit
|
|
// behind requireAuth (see Handler()).
|
|
|
|
const (
|
|
maxWorkspaceRead = 2 << 20 // 2 MiB: files bigger than this aren't inlined for view/edit (download instead)
|
|
maxWorkspaceUpload = 512 << 20 // 512 MiB per upload request
|
|
)
|
|
|
|
// 사용자에게 노출되는 오류 문구(한국어). 경로·페이로드·err.Error() 원문은 그대로 둔다.
|
|
// workspace → "작업 공간"(용어집 정본).
|
|
const (
|
|
errWsIllegalPath = "잘못된 경로입니다"
|
|
errWsPathNotFound = "경로가 존재하지 않습니다"
|
|
errWsNotDir = "디렉터리가 아닙니다"
|
|
errWsFileNotFound = "파일이 존재하지 않습니다"
|
|
errWsIsDir = "디렉터리이므로 파일로 읽을 수 없습니다"
|
|
errWsTargetIsDir = "대상 경로가 디렉터리입니다"
|
|
errWsCannotDeleteRoot = "작업 공간 루트 디렉터리는 삭제할 수 없습니다"
|
|
errWsUploadDirMissing = "대상 디렉터리가 존재하지 않습니다"
|
|
errWsUploadParse = "업로드 처리에 실패했거나 크기 제한을 초과했습니다: " // 뒤에 err.Error() 를 이어 붙인다
|
|
errWsNoUploadFile = "업로드할 파일이 없습니다(폼 필드 file)"
|
|
)
|
|
|
|
// wsResolve maps a user-supplied relative path to an absolute path INSIDE the work
|
|
// dir. It returns ok=false if the path would escape the root. filepath.Clean on a
|
|
// rooted copy collapses any ".." so nothing can climb above the root.
|
|
func (s *Server) wsResolve(rel string) (string, bool) {
|
|
base := filepath.Clean(s.m.dir)
|
|
rel = strings.TrimPrefix(strings.TrimSpace(rel), "/")
|
|
clean := filepath.Clean("/" + rel) // e.g. "/a/../../etc" → "/etc" (still rooted at "/")
|
|
abs := filepath.Clean(filepath.Join(base, clean))
|
|
if abs != base && !strings.HasPrefix(abs, base+string(os.PathSeparator)) {
|
|
return "", false
|
|
}
|
|
return abs, true
|
|
}
|
|
|
|
// wsRel renders an absolute path back as a workspace-relative path (forward slashes).
|
|
func (s *Server) wsRel(abs string) string {
|
|
base := filepath.Clean(s.m.dir)
|
|
rel, err := filepath.Rel(base, abs)
|
|
if err != nil || rel == "." {
|
|
return ""
|
|
}
|
|
return filepath.ToSlash(rel)
|
|
}
|
|
|
|
type wsEntry struct {
|
|
Name string `json:"name"`
|
|
Path string `json:"path"`
|
|
Dir bool `json:"dir"`
|
|
Size int64 `json:"size"`
|
|
MTime int64 `json:"mtime"` // unix millis
|
|
}
|
|
|
|
// GET /api/workspace/list?path=<rel>
|
|
func (s *Server) wsList(w http.ResponseWriter, r *http.Request) {
|
|
abs, ok := s.wsResolve(r.URL.Query().Get("path"))
|
|
if !ok {
|
|
writeErr(w, 400, errWsIllegalPath)
|
|
return
|
|
}
|
|
fi, err := os.Stat(abs)
|
|
if err != nil {
|
|
writeErr(w, 404, errWsPathNotFound)
|
|
return
|
|
}
|
|
if !fi.IsDir() {
|
|
writeErr(w, 400, errWsNotDir)
|
|
return
|
|
}
|
|
ents, err := os.ReadDir(abs)
|
|
if err != nil {
|
|
writeErr(w, 500, err.Error())
|
|
return
|
|
}
|
|
out := make([]wsEntry, 0, len(ents))
|
|
for _, e := range ents {
|
|
info, err := e.Info()
|
|
if err != nil {
|
|
continue
|
|
}
|
|
out = append(out, wsEntry{
|
|
Name: e.Name(),
|
|
Path: s.wsRel(filepath.Join(abs, e.Name())),
|
|
Dir: e.IsDir(),
|
|
Size: info.Size(),
|
|
MTime: info.ModTime().UnixMilli(),
|
|
})
|
|
}
|
|
// 디렉터리를 먼저 두고, 각각 이름순으로 정렬한다.
|
|
sort.Slice(out, func(i, j int) bool {
|
|
if out[i].Dir != out[j].Dir {
|
|
return out[i].Dir
|
|
}
|
|
return strings.ToLower(out[i].Name) < strings.ToLower(out[j].Name)
|
|
})
|
|
writeJSON(w, 200, map[string]any{"path": s.wsRel(abs), "entries": out})
|
|
}
|
|
|
|
// GET /api/workspace/read?path=<rel> — inline text for view/edit. Binary or oversize
|
|
// files return {binary:true}/{too_large:true} with no content (use download instead).
|
|
func (s *Server) wsRead(w http.ResponseWriter, r *http.Request) {
|
|
abs, ok := s.wsResolve(r.URL.Query().Get("path"))
|
|
if !ok {
|
|
writeErr(w, 400, errWsIllegalPath)
|
|
return
|
|
}
|
|
fi, err := os.Stat(abs)
|
|
if err != nil {
|
|
writeErr(w, 404, errWsFileNotFound)
|
|
return
|
|
}
|
|
if fi.IsDir() {
|
|
writeErr(w, 400, errWsIsDir)
|
|
return
|
|
}
|
|
if fi.Size() > maxWorkspaceRead {
|
|
writeJSON(w, 200, map[string]any{"path": s.wsRel(abs), "size": fi.Size(), "too_large": true, "binary": true})
|
|
return
|
|
}
|
|
data, err := os.ReadFile(abs)
|
|
if err != nil {
|
|
writeErr(w, 500, err.Error())
|
|
return
|
|
}
|
|
if bytes.IndexByte(data, 0) >= 0 || !utf8.Valid(data) {
|
|
writeJSON(w, 200, map[string]any{"path": s.wsRel(abs), "size": fi.Size(), "binary": true})
|
|
return
|
|
}
|
|
writeJSON(w, 200, map[string]any{"path": s.wsRel(abs), "size": fi.Size(), "binary": false, "content": string(data)})
|
|
}
|
|
|
|
// POST /api/workspace/write {path, content} — create/overwrite a text file.
|
|
func (s *Server) wsWrite(w http.ResponseWriter, r *http.Request) {
|
|
var req struct {
|
|
Path string `json:"path"`
|
|
Content string `json:"content"`
|
|
}
|
|
if err := decode(r, &req); err != nil {
|
|
writeErr(w, 400, err.Error())
|
|
return
|
|
}
|
|
abs, ok := s.wsResolve(req.Path)
|
|
if !ok || abs == filepath.Clean(s.m.dir) {
|
|
writeErr(w, 400, errWsIllegalPath)
|
|
return
|
|
}
|
|
if fi, err := os.Stat(abs); err == nil && fi.IsDir() {
|
|
writeErr(w, 400, errWsTargetIsDir)
|
|
return
|
|
}
|
|
if err := os.MkdirAll(filepath.Dir(abs), 0o755); err != nil {
|
|
writeErr(w, 500, err.Error())
|
|
return
|
|
}
|
|
if err := os.WriteFile(abs, []byte(req.Content), 0o644); err != nil {
|
|
writeErr(w, 500, err.Error())
|
|
return
|
|
}
|
|
writeJSON(w, 200, map[string]any{"ok": true, "path": s.wsRel(abs)})
|
|
}
|
|
|
|
// POST /api/workspace/mkdir {path}
|
|
func (s *Server) wsMkdir(w http.ResponseWriter, r *http.Request) {
|
|
var req struct {
|
|
Path string `json:"path"`
|
|
}
|
|
if err := decode(r, &req); err != nil {
|
|
writeErr(w, 400, err.Error())
|
|
return
|
|
}
|
|
abs, ok := s.wsResolve(req.Path)
|
|
if !ok || abs == filepath.Clean(s.m.dir) {
|
|
writeErr(w, 400, errWsIllegalPath)
|
|
return
|
|
}
|
|
if err := os.MkdirAll(abs, 0o755); err != nil {
|
|
writeErr(w, 500, err.Error())
|
|
return
|
|
}
|
|
writeJSON(w, 200, map[string]any{"ok": true, "path": s.wsRel(abs)})
|
|
}
|
|
|
|
// DELETE /api/workspace/delete?path=<rel> — removes a file or a directory tree
|
|
// (confined to the work dir; the root itself can't be deleted).
|
|
func (s *Server) wsDelete(w http.ResponseWriter, r *http.Request) {
|
|
abs, ok := s.wsResolve(r.URL.Query().Get("path"))
|
|
if !ok {
|
|
writeErr(w, 400, errWsIllegalPath)
|
|
return
|
|
}
|
|
if abs == filepath.Clean(s.m.dir) {
|
|
writeErr(w, 400, errWsCannotDeleteRoot)
|
|
return
|
|
}
|
|
if _, err := os.Stat(abs); err != nil {
|
|
writeErr(w, 404, errWsPathNotFound)
|
|
return
|
|
}
|
|
if err := os.RemoveAll(abs); err != nil {
|
|
writeErr(w, 500, err.Error())
|
|
return
|
|
}
|
|
writeJSON(w, 200, map[string]any{"ok": true})
|
|
}
|
|
|
|
// GET /api/workspace/download?path=<rel> — stream a file as an attachment.
|
|
func (s *Server) wsDownload(w http.ResponseWriter, r *http.Request) {
|
|
abs, ok := s.wsResolve(r.URL.Query().Get("path"))
|
|
if !ok {
|
|
writeErr(w, 400, errWsIllegalPath)
|
|
return
|
|
}
|
|
fi, err := os.Stat(abs)
|
|
if err != nil || fi.IsDir() {
|
|
writeErr(w, 404, errWsFileNotFound)
|
|
return
|
|
}
|
|
name := filepath.Base(abs)
|
|
// RFC 5987 filename* keeps non-ASCII names intact; plain filename is the fallback.
|
|
w.Header().Set("Content-Disposition", "attachment; filename=\""+sanitizeFilename(name)+"\"; filename*=UTF-8''"+url.PathEscape(name))
|
|
http.ServeFile(w, r, abs)
|
|
}
|
|
|
|
// POST /api/workspace/upload?path=<dir> — multipart form field "file" (one or more).
|
|
func (s *Server) wsUpload(w http.ResponseWriter, r *http.Request) {
|
|
dirAbs, ok := s.wsResolve(r.URL.Query().Get("path"))
|
|
if !ok {
|
|
writeErr(w, 400, errWsIllegalPath)
|
|
return
|
|
}
|
|
if fi, err := os.Stat(dirAbs); err != nil || !fi.IsDir() {
|
|
writeErr(w, 400, errWsUploadDirMissing)
|
|
return
|
|
}
|
|
r.Body = http.MaxBytesReader(w, r.Body, maxWorkspaceUpload)
|
|
if err := r.ParseMultipartForm(32 << 20); err != nil {
|
|
writeErr(w, 400, errWsUploadParse+err.Error())
|
|
return
|
|
}
|
|
files := r.MultipartForm.File["file"]
|
|
if len(files) == 0 {
|
|
writeErr(w, 400, errWsNoUploadFile)
|
|
return
|
|
}
|
|
saved := 0
|
|
for _, hdr := range files {
|
|
name := filepath.Base(hdr.Filename) // strip any path component
|
|
if name == "" || name == "." || name == ".." {
|
|
continue
|
|
}
|
|
destAbs, okd := s.wsResolve(filepath.Join(s.wsRel(dirAbs), name))
|
|
if !okd {
|
|
continue
|
|
}
|
|
if err := saveUpload(hdr, destAbs); err != nil {
|
|
writeErr(w, 500, err.Error())
|
|
return
|
|
}
|
|
saved++
|
|
}
|
|
writeJSON(w, 200, map[string]any{"uploaded": saved})
|
|
}
|
|
|
|
func saveUpload(hdr *multipart.FileHeader, dest string) error {
|
|
src, err := hdr.Open()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
defer src.Close()
|
|
out, err := os.Create(dest)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
defer out.Close()
|
|
_, err = io.Copy(out, src)
|
|
return err
|
|
}
|
|
|
|
// sanitizeFilename strips characters unsafe for a Content-Disposition filename token.
|
|
func sanitizeFilename(name string) string {
|
|
name = strings.ReplaceAll(name, "\"", "")
|
|
name = strings.ReplaceAll(name, "\\", "")
|
|
name = strings.ReplaceAll(name, "\n", "")
|
|
name = strings.ReplaceAll(name, "\r", "")
|
|
return name
|
|
}
|