mirror of
https://github.com/BaaRai/ARTEX.git
synced 2026-11-20 07:00:58 +08:00
Compare commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
39990fe7e4 | ||
|
|
b1ccac4c9a | ||
|
|
90ca982c5e |
@@ -49,6 +49,7 @@ All notable changes to this project are documented in this file. The format is b
|
||||
|
||||
### Fixed
|
||||
|
||||
- **Workspace and skill symlink confinement**: workspace file operations, the skill file APIs and the skill loader resolve symlinks in every path component and refuse a target outside their root, so a link planted in the workspace or a skill directory cannot expose another file.
|
||||
- **Target gate behind proxies**: a target approval is name-only whenever a proxy is in the path, including the recording proxy, the global egress proxy and a custom tool's own proxy, so the gate never claims an IP binding the proxy does not enforce.
|
||||
- **Remote MCP response bound**: Streamable HTTP JSON-RPC bodies and SSE data payloads are refused above 8 MiB, so a remote MCP server cannot force an unbounded decode.
|
||||
- **LLM response capture bound**: each recorded provider attempt keeps at most 1 MiB, and a call keeps at most 8 attempts, so a large or retrying stream cannot grow the recorder without bound. The live stream is unchanged.
|
||||
|
||||
+1
-1
@@ -44,7 +44,7 @@ func wireAgentAugment(pg *db.DB, skillDir string, hostTools func() ([]actool.Cor
|
||||
for _, n := range names {
|
||||
nameSet[n] = true
|
||||
}
|
||||
if allReg, err := skill.LoadDir(skillDir); err == nil && allReg != nil {
|
||||
if allReg, err := loadSkillsConfined(skillDir); err == nil && allReg != nil {
|
||||
reg = skill.NewRegistry()
|
||||
for _, s := range allReg.List() {
|
||||
// match by directory name (Base of Dir), not by skill display Name
|
||||
|
||||
@@ -0,0 +1,360 @@
|
||||
package server
|
||||
|
||||
import (
|
||||
"errors"
|
||||
"os"
|
||||
"path/filepath"
|
||||
"strings"
|
||||
"syscall"
|
||||
|
||||
"github.com/Autumn-27/norma/skill"
|
||||
)
|
||||
|
||||
var errPathEscape = errors.New("invalid path")
|
||||
|
||||
// confinedPath holds the canonicalized result of resolving a user-supplied
|
||||
// relative path inside a root directory.
|
||||
type confinedPath struct {
|
||||
realRoot string // canonical root directory after symlink evaluation
|
||||
realPath string // resolved target path (deepest existing ancestor resolved + non-existent remainder)
|
||||
entryPath string // resolved parent + final segment (differs from realPath when final segment is a symlink)
|
||||
exists bool // whether the target itself exists on disk (and, if a symlink, its target exists)
|
||||
}
|
||||
|
||||
// isWithinRoot reports whether target is equal to or strictly beneath realRoot.
|
||||
// Both paths must be cleaned and canonicalized in the same coordinate space.
|
||||
func isWithinRoot(realRoot, target string) bool {
|
||||
realRoot = filepath.Clean(realRoot)
|
||||
target = filepath.Clean(target)
|
||||
if target == realRoot {
|
||||
return true
|
||||
}
|
||||
rel, err := filepath.Rel(realRoot, target)
|
||||
if err != nil {
|
||||
return false
|
||||
}
|
||||
if rel == "." {
|
||||
return true
|
||||
}
|
||||
if rel == ".." || strings.HasPrefix(rel, ".."+string(filepath.Separator)) || filepath.IsAbs(rel) {
|
||||
return false
|
||||
}
|
||||
return true
|
||||
}
|
||||
|
||||
// resolveRealRoot returns the cleaned, symlink-evaluated absolute path of root.
|
||||
func resolveRealRoot(root string) (string, error) {
|
||||
absRoot, err := filepath.Abs(root)
|
||||
if err != nil {
|
||||
return "", err
|
||||
}
|
||||
realRoot, err := filepath.EvalSymlinks(absRoot)
|
||||
if err != nil {
|
||||
return "", err
|
||||
}
|
||||
return filepath.Clean(realRoot), nil
|
||||
}
|
||||
|
||||
// splitRelSegments validates and splits a relative path into individual safe
|
||||
// path segments. It rejects NUL bytes, volume prefixes, ".." segments, and
|
||||
// (unless trimLeadingSlash is true) leading separators.
|
||||
func splitRelSegments(rel string, trimLeadingSlash bool) ([]string, error) {
|
||||
if strings.ContainsRune(rel, 0) {
|
||||
return nil, errPathEscape
|
||||
}
|
||||
rel = strings.TrimSpace(rel)
|
||||
// Reject Windows drive-letter prefixes (e.g. "C:foo" or "C:/foo").
|
||||
if filepath.VolumeName(rel) != "" {
|
||||
return nil, errPathEscape
|
||||
}
|
||||
// Normalize backslashes so "..\foo" is caught uniformly across platforms.
|
||||
slashed := strings.ReplaceAll(rel, "\\", "/")
|
||||
if trimLeadingSlash {
|
||||
slashed = strings.TrimLeft(slashed, "/")
|
||||
} else if strings.HasPrefix(slashed, "/") {
|
||||
return nil, errPathEscape
|
||||
}
|
||||
if slashed == "" || slashed == "." {
|
||||
return nil, nil
|
||||
}
|
||||
rawSegs := strings.Split(slashed, "/")
|
||||
segs := make([]string, 0, len(rawSegs))
|
||||
for _, seg := range rawSegs {
|
||||
if seg == "" || seg == "." {
|
||||
continue
|
||||
}
|
||||
if seg == ".." {
|
||||
return nil, errPathEscape
|
||||
}
|
||||
segs = append(segs, seg)
|
||||
}
|
||||
return segs, nil
|
||||
}
|
||||
|
||||
func isNotDirErr(err error) bool {
|
||||
return errors.Is(err, syscall.ENOTDIR)
|
||||
}
|
||||
|
||||
// resolveWithinRoot resolves rel beneath root, walking each path component so
|
||||
// that symlinks in any component are evaluated and verified to stay within root.
|
||||
//
|
||||
// For paths that do not exist yet (write, upload, mkdir), the deepest existing
|
||||
// ancestor is resolved via Lstat + EvalSymlinks, then the remaining non-existent
|
||||
// components are re-joined and checked against realRoot.
|
||||
//
|
||||
// Broken symlinks, symlink loops, ".." segments, and any symlink whose target
|
||||
// escapes root return errPathEscape. Symlinks whose resolved target stays inside
|
||||
// root are permitted.
|
||||
func resolveWithinRoot(root, rel string, trimLeadingSlash bool) (confinedPath, error) {
|
||||
realRoot, err := resolveRealRoot(root)
|
||||
if err != nil {
|
||||
return confinedPath{}, err
|
||||
}
|
||||
segs, err := splitRelSegments(rel, trimLeadingSlash)
|
||||
if err != nil {
|
||||
return confinedPath{}, err
|
||||
}
|
||||
if len(segs) == 0 {
|
||||
return confinedPath{
|
||||
realRoot: realRoot,
|
||||
realPath: realRoot,
|
||||
entryPath: realRoot,
|
||||
exists: true,
|
||||
}, nil
|
||||
}
|
||||
|
||||
cur := realRoot
|
||||
for i, seg := range segs {
|
||||
candidate := filepath.Join(cur, seg)
|
||||
fi, err := os.Lstat(candidate)
|
||||
if err != nil {
|
||||
if errors.Is(err, os.ErrNotExist) || isNotDirErr(err) {
|
||||
// cur is the deepest existing ancestor (already verified within realRoot).
|
||||
// Re-join the remaining non-existent segments and verify confinement.
|
||||
rem := make([]string, 0, 1+len(segs)-i)
|
||||
rem = append(rem, cur)
|
||||
rem = append(rem, segs[i:]...)
|
||||
full := filepath.Clean(filepath.Join(rem...))
|
||||
if !isWithinRoot(realRoot, full) {
|
||||
return confinedPath{}, errPathEscape
|
||||
}
|
||||
return confinedPath{
|
||||
realRoot: realRoot,
|
||||
realPath: full,
|
||||
entryPath: full,
|
||||
exists: false,
|
||||
}, nil
|
||||
}
|
||||
return confinedPath{}, errPathEscape
|
||||
}
|
||||
|
||||
if fi.Mode()&os.ModeSymlink != 0 {
|
||||
target, evalErr := filepath.EvalSymlinks(candidate)
|
||||
if evalErr != nil {
|
||||
// Broken symlink, symlink loop, or unreadable symlink target.
|
||||
return confinedPath{}, errPathEscape
|
||||
}
|
||||
target = filepath.Clean(target)
|
||||
if !isWithinRoot(realRoot, target) {
|
||||
return confinedPath{}, errPathEscape
|
||||
}
|
||||
if i == len(segs)-1 {
|
||||
return confinedPath{
|
||||
realRoot: realRoot,
|
||||
realPath: target,
|
||||
entryPath: candidate,
|
||||
exists: true,
|
||||
}, nil
|
||||
}
|
||||
cur = target
|
||||
continue
|
||||
}
|
||||
|
||||
cur = candidate
|
||||
}
|
||||
|
||||
if !isWithinRoot(realRoot, cur) {
|
||||
return confinedPath{}, errPathEscape
|
||||
}
|
||||
return confinedPath{
|
||||
realRoot: realRoot,
|
||||
realPath: cur,
|
||||
entryPath: cur,
|
||||
exists: true,
|
||||
}, nil
|
||||
}
|
||||
|
||||
// resolveSkillDir resolves <skillDir>/<name> and ensures it does not escape skillDir.
|
||||
// If skillDir itself does not exist yet, it returns (confinedPath{exists: false}, nil)
|
||||
// so read/delete handlers can return 404 rather than 400.
|
||||
func resolveSkillDir(skillDir, name string) (confinedPath, error) {
|
||||
cp, err := resolveWithinRoot(skillDir, name, false)
|
||||
if err != nil {
|
||||
if errors.Is(err, os.ErrNotExist) {
|
||||
return confinedPath{exists: false}, nil
|
||||
}
|
||||
return confinedPath{}, errPathEscape
|
||||
}
|
||||
return cp, nil
|
||||
}
|
||||
|
||||
// resolveSkillFile resolves <skillDir>/<name>/<relFile>, confining both the
|
||||
// skill directory under skillDir and the file under that skill's directory.
|
||||
func resolveSkillFile(skillDir, name, relFile string) (skillExists bool, cp confinedPath, err error) {
|
||||
dirCP, err := resolveSkillDir(skillDir, name)
|
||||
if err != nil {
|
||||
return false, confinedPath{}, err
|
||||
}
|
||||
if !dirCP.exists {
|
||||
return false, confinedPath{}, nil
|
||||
}
|
||||
fi, statErr := os.Stat(dirCP.realPath)
|
||||
if statErr != nil || !fi.IsDir() {
|
||||
return false, confinedPath{}, nil
|
||||
}
|
||||
fileCP, err := resolveWithinRoot(dirCP.realPath, relFile, false)
|
||||
if err != nil {
|
||||
return true, confinedPath{}, errPathEscape
|
||||
}
|
||||
return true, fileCP, nil
|
||||
}
|
||||
|
||||
// loadSkillsConfined loads skills from dir using skill.LoadDir while refusing
|
||||
// to follow symlinks whose real target leaves dir (or leaves its skill
|
||||
// subdirectory for <dir>/<name>/SKILL.md).
|
||||
func loadSkillsConfined(dir string) (*skill.Registry, error) {
|
||||
realRoot, err := resolveRealRoot(dir)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
entries, err := os.ReadDir(realRoot)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
type safeEntry struct {
|
||||
isDir bool
|
||||
entryName string
|
||||
sourcePath string
|
||||
}
|
||||
|
||||
hasUnsafe := false
|
||||
var safe []safeEntry
|
||||
|
||||
for _, e := range entries {
|
||||
name := e.Name()
|
||||
switch {
|
||||
case e.IsDir():
|
||||
// os.ReadDir reports e.IsDir() == false for symlinks, so <realRoot>/<name>
|
||||
// is a real directory under realRoot. Verify its SKILL.md stays inside it.
|
||||
skillRoot := filepath.Join(realRoot, name)
|
||||
cp, rerr := resolveWithinRoot(skillRoot, "SKILL.md", false)
|
||||
if rerr != nil {
|
||||
hasUnsafe = true
|
||||
continue
|
||||
}
|
||||
if !cp.exists {
|
||||
continue
|
||||
}
|
||||
if fi, serr := os.Stat(cp.realPath); serr != nil || fi.IsDir() {
|
||||
continue
|
||||
}
|
||||
safe = append(safe, safeEntry{
|
||||
isDir: true,
|
||||
entryName: name,
|
||||
sourcePath: cp.realPath,
|
||||
})
|
||||
case strings.HasSuffix(name, ".md"):
|
||||
cp, rerr := resolveWithinRoot(realRoot, name, false)
|
||||
if rerr != nil {
|
||||
hasUnsafe = true
|
||||
continue
|
||||
}
|
||||
if !cp.exists {
|
||||
continue
|
||||
}
|
||||
if fi, serr := os.Stat(cp.realPath); serr != nil || fi.IsDir() {
|
||||
continue
|
||||
}
|
||||
safe = append(safe, safeEntry{
|
||||
isDir: false,
|
||||
entryName: name,
|
||||
sourcePath: cp.realPath,
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
// Fast path: every skill file candidate in dir is safely confined.
|
||||
if !hasUnsafe {
|
||||
return skill.LoadDir(dir)
|
||||
}
|
||||
|
||||
// Safe fallback: stage only verified files into a temporary directory so
|
||||
// skill.LoadDir never opens or reads escaping/broken/looping symlinks, then
|
||||
// restore each Skill.Dir to match dir.
|
||||
if len(safe) == 0 {
|
||||
return skill.NewRegistry(), nil
|
||||
}
|
||||
tmp, err := os.MkdirTemp("", "artex-skills-*")
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
defer os.RemoveAll(tmp)
|
||||
|
||||
for _, item := range safe {
|
||||
data, rerr := os.ReadFile(item.sourcePath)
|
||||
if rerr != nil {
|
||||
continue
|
||||
}
|
||||
if item.isDir {
|
||||
sub := filepath.Join(tmp, item.entryName)
|
||||
if err := os.MkdirAll(sub, 0o755); err != nil {
|
||||
continue
|
||||
}
|
||||
_ = os.WriteFile(filepath.Join(sub, "SKILL.md"), data, 0o600)
|
||||
} else {
|
||||
_ = os.WriteFile(filepath.Join(tmp, item.entryName), data, 0o600)
|
||||
}
|
||||
}
|
||||
|
||||
loaded, err := skill.LoadDir(tmp)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
out := skill.NewRegistry()
|
||||
for _, sk := range loaded.List() {
|
||||
if sk.Dir == tmp {
|
||||
sk.Dir = dir
|
||||
} else if rel, relErr := filepath.Rel(tmp, sk.Dir); relErr == nil && rel != "." {
|
||||
sk.Dir = filepath.Join(dir, rel)
|
||||
}
|
||||
out.Add(sk)
|
||||
}
|
||||
return out, nil
|
||||
}
|
||||
|
||||
// safeFSErr formats a filesystem error without leaking absolute paths.
|
||||
func safeFSErr(err error) string {
|
||||
if err == nil {
|
||||
return ""
|
||||
}
|
||||
var pe *os.PathError
|
||||
if errors.As(err, &pe) && pe.Err != nil {
|
||||
if pe.Op != "" {
|
||||
return pe.Op + ": " + pe.Err.Error()
|
||||
}
|
||||
return pe.Err.Error()
|
||||
}
|
||||
var le *os.LinkError
|
||||
if errors.As(err, &le) && le.Err != nil {
|
||||
if le.Op != "" {
|
||||
return le.Op + ": " + le.Err.Error()
|
||||
}
|
||||
return le.Err.Error()
|
||||
}
|
||||
var se *os.SyscallError
|
||||
if errors.As(err, &se) && se.Err != nil {
|
||||
return se.Err.Error()
|
||||
}
|
||||
return "filesystem error"
|
||||
}
|
||||
+22
-13
@@ -98,12 +98,16 @@ func (s *Server) toolCreateSkill() actool.CoreTool {
|
||||
if strings.TrimSpace(a.Description) == "" {
|
||||
return actool.Errorf("description is required"), nil
|
||||
}
|
||||
path := filepath.Join(s.skillDir, a.Name)
|
||||
if _, err := os.Stat(path); err == nil {
|
||||
dirCP, err := resolveSkillDir(s.skillDir, a.Name)
|
||||
if err != nil {
|
||||
return actool.Errorf("invalid skill path"), nil
|
||||
}
|
||||
if dirCP.exists {
|
||||
return actool.Errorf("skill already exists: " + a.Name), nil
|
||||
}
|
||||
path := filepath.Join(s.skillDir, a.Name)
|
||||
if err := os.MkdirAll(path, 0o755); err != nil {
|
||||
return actool.Errorf(err.Error()), nil
|
||||
return actool.Errorf(safeFSErr(err)), nil
|
||||
}
|
||||
var b strings.Builder
|
||||
b.WriteString("---\n")
|
||||
@@ -117,7 +121,7 @@ func (s *Server) toolCreateSkill() actool.CoreTool {
|
||||
}
|
||||
if err := os.WriteFile(filepath.Join(path, "SKILL.md"), []byte(b.String()), 0o644); err != nil {
|
||||
_ = os.RemoveAll(path)
|
||||
return actool.Errorf(err.Error()), nil
|
||||
return actool.Errorf(safeFSErr(err)), nil
|
||||
}
|
||||
return actool.Text("skill created: " + a.Name), nil
|
||||
})
|
||||
@@ -137,10 +141,6 @@ func (s *Server) toolUpdateSkillFile() actool.CoreTool {
|
||||
if !validSkillName(a.Name) {
|
||||
return actool.Errorf("invalid skill name"), nil
|
||||
}
|
||||
skillPath := filepath.Join(s.skillDir, a.Name)
|
||||
if _, err := os.Stat(skillPath); os.IsNotExist(err) {
|
||||
return actool.Errorf("skill does not exist: " + a.Name), nil
|
||||
}
|
||||
rel := strings.TrimSpace(a.File)
|
||||
if rel == "" {
|
||||
rel = "SKILL.md"
|
||||
@@ -149,12 +149,21 @@ func (s *Server) toolUpdateSkillFile() actool.CoreTool {
|
||||
if msg != "" {
|
||||
return actool.Errorf("illegal path: " + msg), nil
|
||||
}
|
||||
full := filepath.Join(skillPath, clean)
|
||||
if err := os.MkdirAll(filepath.Dir(full), 0o755); err != nil {
|
||||
return actool.Errorf(err.Error()), nil
|
||||
skillExists, cp, err := resolveSkillFile(s.skillDir, a.Name, clean)
|
||||
if err != nil {
|
||||
return actool.Errorf("illegal path: invalid path"), nil
|
||||
}
|
||||
if err := os.WriteFile(full, []byte(a.Content), 0o644); err != nil {
|
||||
return actool.Errorf(err.Error()), nil
|
||||
if !skillExists {
|
||||
return actool.Errorf("skill does not exist: " + a.Name), nil
|
||||
}
|
||||
if cp.realPath == cp.realRoot {
|
||||
return actool.Errorf("illegal path: invalid path"), nil
|
||||
}
|
||||
if err := os.MkdirAll(filepath.Dir(cp.realPath), 0o755); err != nil {
|
||||
return actool.Errorf(safeFSErr(err)), nil
|
||||
}
|
||||
if err := os.WriteFile(cp.realPath, []byte(a.Content), 0o644); err != nil {
|
||||
return actool.Errorf(safeFSErr(err)), nil
|
||||
}
|
||||
return actool.Text("skill file written: " + a.Name + "/" + clean), nil
|
||||
})
|
||||
|
||||
+110
-40
@@ -1156,7 +1156,7 @@ type skillFileNode struct {
|
||||
|
||||
func (s *Server) fsListSkills(w http.ResponseWriter, r *http.Request) {
|
||||
_ = os.MkdirAll(s.skillDir, 0o755)
|
||||
allReg, _ := skill.LoadDir(s.skillDir)
|
||||
allReg, _ := loadSkillsConfined(s.skillDir)
|
||||
metaByDir := map[string]skill.Skill{}
|
||||
if allReg != nil {
|
||||
for _, sk := range allReg.List() {
|
||||
@@ -1167,7 +1167,7 @@ func (s *Server) fsListSkills(w http.ResponseWriter, r *http.Request) {
|
||||
}
|
||||
entries, err := os.ReadDir(s.skillDir)
|
||||
if err != nil {
|
||||
writeErr(w, 500, err.Error())
|
||||
writeErr(w, 500, safeFSErr(err))
|
||||
return
|
||||
}
|
||||
// Usage is best-effort decoration: a ledger read failure leaves the counts at
|
||||
@@ -1275,13 +1275,18 @@ func (s *Server) fsCreateSkill(w http.ResponseWriter, r *http.Request) {
|
||||
writeErr(w, 400, "description is required")
|
||||
return
|
||||
}
|
||||
skillPath := filepath.Join(s.skillDir, body.Name)
|
||||
if _, err := os.Stat(skillPath); err == nil {
|
||||
dirCP, err := resolveSkillDir(s.skillDir, body.Name)
|
||||
if err != nil {
|
||||
writeErr(w, 400, "invalid path")
|
||||
return
|
||||
}
|
||||
if dirCP.exists {
|
||||
writeErr(w, 409, "skill already exists")
|
||||
return
|
||||
}
|
||||
skillPath := filepath.Join(s.skillDir, body.Name)
|
||||
if err := os.MkdirAll(skillPath, 0o755); err != nil {
|
||||
writeErr(w, 500, err.Error())
|
||||
writeErr(w, 500, safeFSErr(err))
|
||||
return
|
||||
}
|
||||
// Build a spec-compliant SKILL.md (agentskills.io format):
|
||||
@@ -1317,7 +1322,7 @@ func (s *Server) fsCreateSkill(w http.ResponseWriter, r *http.Request) {
|
||||
}
|
||||
if err := os.WriteFile(filepath.Join(skillPath, "SKILL.md"), []byte(sb.String()), 0o644); err != nil {
|
||||
_ = os.RemoveAll(skillPath)
|
||||
writeErr(w, 500, err.Error())
|
||||
writeErr(w, 500, safeFSErr(err))
|
||||
return
|
||||
}
|
||||
// Verify with the real parser: a description containing ": " (or any value that
|
||||
@@ -1352,19 +1357,31 @@ func (s *Server) fsUpdateSkillMeta(w http.ResponseWriter, r *http.Request) {
|
||||
writeErr(w, 400, err.Error())
|
||||
return
|
||||
}
|
||||
skillMD := filepath.Join(s.skillDir, name, "SKILL.md")
|
||||
raw, err := os.ReadFile(skillMD)
|
||||
skillExists, cp, err := resolveSkillFile(s.skillDir, name, "SKILL.md")
|
||||
if err != nil {
|
||||
writeErr(w, 400, "invalid path")
|
||||
return
|
||||
}
|
||||
if !skillExists || !cp.exists {
|
||||
writeErr(w, 404, "skill not found")
|
||||
return
|
||||
}
|
||||
raw, err := os.ReadFile(cp.realPath)
|
||||
if err != nil {
|
||||
if os.IsNotExist(err) {
|
||||
writeErr(w, 404, "skill not found")
|
||||
return
|
||||
}
|
||||
writeErr(w, 500, safeFSErr(err))
|
||||
return
|
||||
}
|
||||
updated, err := rewriteSkillFrontmatter(raw, body.MCPs, body.Description, body.License, body.Compatibility)
|
||||
if err != nil {
|
||||
writeErr(w, 400, err.Error())
|
||||
return
|
||||
}
|
||||
if err := os.WriteFile(skillMD, updated, 0o644); err != nil {
|
||||
writeErr(w, 500, err.Error())
|
||||
if err := os.WriteFile(cp.realPath, updated, 0o644); err != nil {
|
||||
writeErr(w, 500, safeFSErr(err))
|
||||
return
|
||||
}
|
||||
writeJSON(w, 200, map[string]any{"ok": true})
|
||||
@@ -1383,9 +1400,9 @@ func yamlScalar(s string) string {
|
||||
// verifySkillFile re-loads a written SKILL.md with the real skill parser and
|
||||
// asserts the name and the mcps list survived the round trip.
|
||||
func verifySkillFile(skillPath, wantName string, wantMCPs []string) error {
|
||||
reg, err := skill.LoadDir(skillPath)
|
||||
reg, err := loadSkillsConfined(skillPath)
|
||||
if err != nil {
|
||||
return fmt.Errorf("load: %w", err)
|
||||
return fmt.Errorf("load: %s", safeFSErr(err))
|
||||
}
|
||||
for _, s := range reg.List() {
|
||||
if s.Dir == "" {
|
||||
@@ -1399,14 +1416,14 @@ func verifySkillFile(skillPath, wantName string, wantMCPs []string) error {
|
||||
}
|
||||
return nil
|
||||
}
|
||||
return fmt.Errorf("no skill loaded from %s", skillPath)
|
||||
return fmt.Errorf("no skill loaded from %s", filepath.Base(skillPath))
|
||||
}
|
||||
|
||||
// warnBrokenSkills logs skills whose parsed name does not match their directory
|
||||
// name: the signature of frontmatter that failed to parse and silently fell back
|
||||
// (fields empty, mcps gate lost). Best-effort, startup only.
|
||||
func warnBrokenSkills(dir string) {
|
||||
reg, err := skill.LoadDir(dir)
|
||||
reg, err := loadSkillsConfined(dir)
|
||||
if err != nil {
|
||||
return
|
||||
}
|
||||
@@ -1601,9 +1618,14 @@ func (s *Server) fsUploadSkill(w http.ResponseWriter, r *http.Request) {
|
||||
return
|
||||
}
|
||||
|
||||
dirCP, err := resolveSkillDir(s.skillDir, name)
|
||||
if err != nil {
|
||||
writeErr(w, 400, "invalid path")
|
||||
return
|
||||
}
|
||||
skillPath := filepath.Join(s.skillDir, name)
|
||||
overwrite := r.URL.Query().Get("overwrite") == "true"
|
||||
if _, err := os.Stat(skillPath); err == nil && !overwrite {
|
||||
if dirCP.exists && !overwrite {
|
||||
writeErr(w, 409, "skill already exists: "+name+" (retry after confirming if you want to overwrite)")
|
||||
return
|
||||
}
|
||||
@@ -1708,13 +1730,20 @@ func (s *Server) fsDeleteSkill(w http.ResponseWriter, r *http.Request) {
|
||||
writeErr(w, 400, "invalid skill name")
|
||||
return
|
||||
}
|
||||
dirCP, err := resolveSkillDir(s.skillDir, name)
|
||||
if err != nil {
|
||||
writeErr(w, 400, "invalid path")
|
||||
return
|
||||
}
|
||||
if err := pg.DeleteSkillVisibility(name); err != nil {
|
||||
writeErr(w, 500, err.Error())
|
||||
return
|
||||
}
|
||||
if err := os.RemoveAll(filepath.Join(s.skillDir, name)); err != nil {
|
||||
writeErr(w, 500, err.Error())
|
||||
return
|
||||
if dirCP.exists {
|
||||
if err := os.RemoveAll(dirCP.entryPath); err != nil {
|
||||
writeErr(w, 500, safeFSErr(err))
|
||||
return
|
||||
}
|
||||
}
|
||||
writeJSON(w, 200, map[string]any{"deleted": name})
|
||||
}
|
||||
@@ -1816,14 +1845,23 @@ func (s *Server) fsListFiles(w http.ResponseWriter, r *http.Request) {
|
||||
writeErr(w, 400, "invalid skill name")
|
||||
return
|
||||
}
|
||||
dirPath := filepath.Join(s.skillDir, name)
|
||||
if _, err := os.Stat(dirPath); os.IsNotExist(err) {
|
||||
dirCP, err := resolveSkillDir(s.skillDir, name)
|
||||
if err != nil {
|
||||
writeErr(w, 400, "invalid path")
|
||||
return
|
||||
}
|
||||
if !dirCP.exists {
|
||||
writeErr(w, 404, "skill not found")
|
||||
return
|
||||
}
|
||||
files, err := walkSkillFiles(dirPath)
|
||||
fi, err := os.Stat(dirCP.realPath)
|
||||
if err != nil || !fi.IsDir() {
|
||||
writeErr(w, 404, "skill not found")
|
||||
return
|
||||
}
|
||||
files, err := walkSkillFiles(dirCP.realPath)
|
||||
if err != nil {
|
||||
writeErr(w, 500, err.Error())
|
||||
writeErr(w, 500, safeFSErr(err))
|
||||
return
|
||||
}
|
||||
if files == nil {
|
||||
@@ -1843,13 +1881,22 @@ func (s *Server) fsReadFile(w http.ResponseWriter, r *http.Request) {
|
||||
writeErr(w, 400, errMsg)
|
||||
return
|
||||
}
|
||||
data, err := os.ReadFile(filepath.Join(s.skillDir, name, file))
|
||||
skillExists, cp, err := resolveSkillFile(s.skillDir, name, file)
|
||||
if err != nil {
|
||||
writeErr(w, 400, "invalid path")
|
||||
return
|
||||
}
|
||||
if !skillExists || !cp.exists {
|
||||
writeErr(w, 404, "file not found")
|
||||
return
|
||||
}
|
||||
data, err := os.ReadFile(cp.realPath)
|
||||
if os.IsNotExist(err) {
|
||||
writeErr(w, 404, "file not found")
|
||||
return
|
||||
}
|
||||
if err != nil {
|
||||
writeErr(w, 500, err.Error())
|
||||
writeErr(w, 500, safeFSErr(err))
|
||||
return
|
||||
}
|
||||
writeJSON(w, 200, map[string]any{"content": string(data), "file": file})
|
||||
@@ -1873,19 +1920,26 @@ func (s *Server) fsWriteFile(w http.ResponseWriter, r *http.Request) {
|
||||
writeErr(w, 400, err.Error())
|
||||
return
|
||||
}
|
||||
skillPath := filepath.Join(s.skillDir, name)
|
||||
if _, err := os.Stat(skillPath); os.IsNotExist(err) {
|
||||
skillExists, cp, err := resolveSkillFile(s.skillDir, name, file)
|
||||
if err != nil {
|
||||
writeErr(w, 400, "invalid path")
|
||||
return
|
||||
}
|
||||
if !skillExists {
|
||||
writeErr(w, 404, "skill not found")
|
||||
return
|
||||
}
|
||||
fullPath := filepath.Join(skillPath, file)
|
||||
// create parent subdirectory if needed (e.g. scripts/, references/, assets/)
|
||||
if err := os.MkdirAll(filepath.Dir(fullPath), 0o755); err != nil {
|
||||
writeErr(w, 500, err.Error())
|
||||
if cp.realPath == cp.realRoot {
|
||||
writeErr(w, 400, "invalid path")
|
||||
return
|
||||
}
|
||||
if err := os.WriteFile(fullPath, []byte(body.Content), 0o644); err != nil {
|
||||
writeErr(w, 500, err.Error())
|
||||
// create parent subdirectory if needed (e.g. scripts/, references/, assets/)
|
||||
if err := os.MkdirAll(filepath.Dir(cp.realPath), 0o755); err != nil {
|
||||
writeErr(w, 500, safeFSErr(err))
|
||||
return
|
||||
}
|
||||
if err := os.WriteFile(cp.realPath, []byte(body.Content), 0o644); err != nil {
|
||||
writeErr(w, 500, safeFSErr(err))
|
||||
return
|
||||
}
|
||||
writeJSON(w, 200, map[string]any{"ok": true})
|
||||
@@ -1909,13 +1963,21 @@ func (s *Server) fsCreateDir(w http.ResponseWriter, r *http.Request) {
|
||||
writeErr(w, 400, errMsg)
|
||||
return
|
||||
}
|
||||
skillPath := filepath.Join(s.skillDir, name)
|
||||
if _, err := os.Stat(skillPath); os.IsNotExist(err) {
|
||||
skillExists, cp, err := resolveSkillFile(s.skillDir, name, dir)
|
||||
if err != nil {
|
||||
writeErr(w, 400, "invalid path")
|
||||
return
|
||||
}
|
||||
if !skillExists {
|
||||
writeErr(w, 404, "skill not found")
|
||||
return
|
||||
}
|
||||
if err := os.MkdirAll(filepath.Join(skillPath, dir), 0o755); err != nil {
|
||||
writeErr(w, 500, err.Error())
|
||||
if cp.realPath == cp.realRoot {
|
||||
writeErr(w, 400, "invalid path")
|
||||
return
|
||||
}
|
||||
if err := os.MkdirAll(cp.realPath, 0o755); err != nil {
|
||||
writeErr(w, 500, safeFSErr(err))
|
||||
return
|
||||
}
|
||||
writeJSON(w, 201, map[string]any{"dir": dir})
|
||||
@@ -1932,13 +1994,21 @@ func (s *Server) fsDeletePath(w http.ResponseWriter, r *http.Request) {
|
||||
writeErr(w, 400, errMsg)
|
||||
return
|
||||
}
|
||||
fullPath := filepath.Join(s.skillDir, name, file)
|
||||
if _, err := os.Stat(fullPath); os.IsNotExist(err) {
|
||||
skillExists, cp, err := resolveSkillFile(s.skillDir, name, file)
|
||||
if err != nil {
|
||||
writeErr(w, 400, "invalid path")
|
||||
return
|
||||
}
|
||||
if !skillExists || !cp.exists {
|
||||
writeErr(w, 404, "not found")
|
||||
return
|
||||
}
|
||||
if err := os.RemoveAll(fullPath); err != nil {
|
||||
writeErr(w, 500, err.Error())
|
||||
if cp.realPath == cp.realRoot {
|
||||
writeErr(w, 400, "invalid path")
|
||||
return
|
||||
}
|
||||
if err := os.RemoveAll(cp.entryPath); err != nil {
|
||||
writeErr(w, 500, safeFSErr(err))
|
||||
return
|
||||
}
|
||||
writeJSON(w, 200, map[string]any{"deleted": file})
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
+55
-34
@@ -23,23 +23,33 @@ const (
|
||||
maxWorkspaceUpload = 512 << 20 // 512 MiB per upload request
|
||||
)
|
||||
|
||||
// wsResolveConfined maps a user-supplied relative path to a canonicalized path
|
||||
// inside the work dir, resolving symlinks in every component and rejecting any
|
||||
// traversal, broken symlink, symlink loop, or target that escapes s.m.dir.
|
||||
func (s *Server) wsResolveConfined(rel string) (confinedPath, bool) {
|
||||
cp, err := resolveWithinRoot(s.m.dir, rel, true)
|
||||
if err != nil {
|
||||
return confinedPath{}, false
|
||||
}
|
||||
return cp, true
|
||||
}
|
||||
|
||||
// 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.
|
||||
// dir. It returns ok=false if the path would escape the root (including via symlinks).
|
||||
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)) {
|
||||
cp, ok := s.wsResolveConfined(rel)
|
||||
if !ok {
|
||||
return "", false
|
||||
}
|
||||
return abs, true
|
||||
return cp.realPath, 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)
|
||||
base, err := resolveRealRoot(s.m.dir)
|
||||
if err != nil {
|
||||
base = filepath.Clean(s.m.dir)
|
||||
}
|
||||
rel, err := filepath.Rel(base, abs)
|
||||
if err != nil || rel == "." {
|
||||
return ""
|
||||
@@ -57,11 +67,12 @@ type wsEntry struct {
|
||||
|
||||
// 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"))
|
||||
cp, ok := s.wsResolveConfined(r.URL.Query().Get("path"))
|
||||
if !ok {
|
||||
writeErr(w, 400, "invalid path")
|
||||
return
|
||||
}
|
||||
abs := cp.realPath
|
||||
fi, err := os.Stat(abs)
|
||||
if err != nil {
|
||||
writeErr(w, 404, "path does not exist")
|
||||
@@ -73,7 +84,7 @@ func (s *Server) wsList(w http.ResponseWriter, r *http.Request) {
|
||||
}
|
||||
ents, err := os.ReadDir(abs)
|
||||
if err != nil {
|
||||
writeErr(w, 500, err.Error())
|
||||
writeErr(w, 500, safeFSErr(err))
|
||||
return
|
||||
}
|
||||
out := make([]wsEntry, 0, len(ents))
|
||||
@@ -103,11 +114,12 @@ func (s *Server) wsList(w http.ResponseWriter, r *http.Request) {
|
||||
// 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"))
|
||||
cp, ok := s.wsResolveConfined(r.URL.Query().Get("path"))
|
||||
if !ok {
|
||||
writeErr(w, 400, "invalid path")
|
||||
return
|
||||
}
|
||||
abs := cp.realPath
|
||||
fi, err := os.Stat(abs)
|
||||
if err != nil {
|
||||
writeErr(w, 404, "file does not exist")
|
||||
@@ -123,7 +135,7 @@ func (s *Server) wsRead(w http.ResponseWriter, r *http.Request) {
|
||||
}
|
||||
data, err := os.ReadFile(abs)
|
||||
if err != nil {
|
||||
writeErr(w, 500, err.Error())
|
||||
writeErr(w, 500, safeFSErr(err))
|
||||
return
|
||||
}
|
||||
if bytes.IndexByte(data, 0) >= 0 || !utf8.Valid(data) {
|
||||
@@ -143,21 +155,22 @@ func (s *Server) wsWrite(w http.ResponseWriter, r *http.Request) {
|
||||
writeErr(w, 400, err.Error())
|
||||
return
|
||||
}
|
||||
abs, ok := s.wsResolve(req.Path)
|
||||
if !ok || abs == filepath.Clean(s.m.dir) {
|
||||
cp, ok := s.wsResolveConfined(req.Path)
|
||||
if !ok || cp.realPath == cp.realRoot {
|
||||
writeErr(w, 400, "invalid path")
|
||||
return
|
||||
}
|
||||
abs := cp.realPath
|
||||
if fi, err := os.Stat(abs); err == nil && fi.IsDir() {
|
||||
writeErr(w, 400, "target is a directory")
|
||||
return
|
||||
}
|
||||
if err := os.MkdirAll(filepath.Dir(abs), 0o755); err != nil {
|
||||
writeErr(w, 500, err.Error())
|
||||
writeErr(w, 500, safeFSErr(err))
|
||||
return
|
||||
}
|
||||
if err := os.WriteFile(abs, []byte(req.Content), 0o644); err != nil {
|
||||
writeErr(w, 500, err.Error())
|
||||
writeErr(w, 500, safeFSErr(err))
|
||||
return
|
||||
}
|
||||
writeJSON(w, 200, map[string]any{"ok": true, "path": s.wsRel(abs)})
|
||||
@@ -172,13 +185,14 @@ func (s *Server) wsMkdir(w http.ResponseWriter, r *http.Request) {
|
||||
writeErr(w, 400, err.Error())
|
||||
return
|
||||
}
|
||||
abs, ok := s.wsResolve(req.Path)
|
||||
if !ok || abs == filepath.Clean(s.m.dir) {
|
||||
cp, ok := s.wsResolveConfined(req.Path)
|
||||
if !ok || cp.realPath == cp.realRoot {
|
||||
writeErr(w, 400, "invalid path")
|
||||
return
|
||||
}
|
||||
abs := cp.realPath
|
||||
if err := os.MkdirAll(abs, 0o755); err != nil {
|
||||
writeErr(w, 500, err.Error())
|
||||
writeErr(w, 500, safeFSErr(err))
|
||||
return
|
||||
}
|
||||
writeJSON(w, 200, map[string]any{"ok": true, "path": s.wsRel(abs)})
|
||||
@@ -187,21 +201,21 @@ func (s *Server) wsMkdir(w http.ResponseWriter, r *http.Request) {
|
||||
// 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"))
|
||||
cp, ok := s.wsResolveConfined(r.URL.Query().Get("path"))
|
||||
if !ok {
|
||||
writeErr(w, 400, "invalid path")
|
||||
return
|
||||
}
|
||||
if abs == filepath.Clean(s.m.dir) {
|
||||
if cp.realPath == cp.realRoot {
|
||||
writeErr(w, 400, "cannot delete the workspace root directory")
|
||||
return
|
||||
}
|
||||
if _, err := os.Stat(abs); err != nil {
|
||||
if !cp.exists {
|
||||
writeErr(w, 404, "path does not exist")
|
||||
return
|
||||
}
|
||||
if err := os.RemoveAll(abs); err != nil {
|
||||
writeErr(w, 500, err.Error())
|
||||
if err := os.RemoveAll(cp.entryPath); err != nil {
|
||||
writeErr(w, 500, safeFSErr(err))
|
||||
return
|
||||
}
|
||||
writeJSON(w, 200, map[string]any{"ok": true})
|
||||
@@ -209,17 +223,18 @@ func (s *Server) wsDelete(w http.ResponseWriter, r *http.Request) {
|
||||
|
||||
// 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"))
|
||||
cp, ok := s.wsResolveConfined(r.URL.Query().Get("path"))
|
||||
if !ok {
|
||||
writeErr(w, 400, "invalid path")
|
||||
return
|
||||
}
|
||||
abs := cp.realPath
|
||||
fi, err := os.Stat(abs)
|
||||
if err != nil || fi.IsDir() {
|
||||
writeErr(w, 404, "file does not exist")
|
||||
return
|
||||
}
|
||||
name := filepath.Base(abs)
|
||||
name := filepath.Base(cp.entryPath)
|
||||
// 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)
|
||||
@@ -227,12 +242,12 @@ func (s *Server) wsDownload(w http.ResponseWriter, r *http.Request) {
|
||||
|
||||
// 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"))
|
||||
dir, ok := s.wsResolveConfined(r.URL.Query().Get("path"))
|
||||
if !ok {
|
||||
writeErr(w, 400, "invalid path")
|
||||
return
|
||||
}
|
||||
if fi, err := os.Stat(dirAbs); err != nil || !fi.IsDir() {
|
||||
if fi, err := os.Stat(dir.realPath); err != nil || !fi.IsDir() {
|
||||
writeErr(w, 400, "target directory does not exist")
|
||||
return
|
||||
}
|
||||
@@ -246,18 +261,24 @@ func (s *Server) wsUpload(w http.ResponseWriter, r *http.Request) {
|
||||
writeErr(w, 400, "missing upload file (form field file)")
|
||||
return
|
||||
}
|
||||
dirRel := s.wsRel(dir.realPath)
|
||||
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
|
||||
destRel := name
|
||||
if dirRel != "" {
|
||||
destRel = dirRel + "/" + name
|
||||
}
|
||||
if err := saveUpload(hdr, destAbs); err != nil {
|
||||
writeErr(w, 500, err.Error())
|
||||
dest, okd := s.wsResolveConfined(destRel)
|
||||
if !okd || dest.realPath == dest.realRoot {
|
||||
writeErr(w, 400, "invalid path")
|
||||
return
|
||||
}
|
||||
if err := saveUpload(hdr, dest.realPath); err != nil {
|
||||
writeErr(w, 500, safeFSErr(err))
|
||||
return
|
||||
}
|
||||
saved++
|
||||
|
||||
Reference in New Issue
Block a user