Files
skillshare/internal/server/handler_collect.go
T
Willie eb72272b37 fix(collect,install): keep UNC file URLs intact; require SKILL.md to be a file
The drive-letter fix lived in the helper shared with explicit file:// URLs,
which rewrote file://server/share/repo into a local path. Keep the slash
logic in the local-path --track case only and leave explicit URLs as parsed.

A subdirectory named SKILL.md passed the existence check, so a scratch folder
holding one was still collected. Both collect entry points (scan and the
dashboard request) now share sync.HasSkillFile, which rejects directories.
2026-10-09 23:47:32 +08:00

329 lines
9.0 KiB
Go

package server
import (
"errors"
"maps"
"net/http"
"os"
"path/filepath"
"time"
ssync "skillshare/internal/sync"
"skillshare/internal/utils"
)
// --- Scan types ---
type localSkillItem struct {
Name string `json:"name"`
Kind string `json:"kind,omitempty"`
Path string `json:"path"`
TargetName string `json:"targetName"`
Size int64 `json:"size"`
ModTime string `json:"modTime"`
}
type scanTarget struct {
TargetName string `json:"targetName"`
Skills []localSkillItem `json:"skills"`
}
// --- Collect types ---
type collectSkillRef struct {
Name string `json:"name"`
TargetName string `json:"targetName"`
Kind string `json:"kind,omitempty"`
}
// handleCollectScan scans targets for local (non-symlinked) skills and/or agents.
// GET /api/collect/scan?target=<name>&kind=skill|agent (both optional)
// When kind is omitted, scans for both skills and agents.
func (s *Server) handleCollectScan(w http.ResponseWriter, r *http.Request) {
// Snapshot config under RLock, then release before I/O.
s.mu.RLock()
source := s.cfg.EffectiveSkillsSource()
globalMode := s.cfg.Mode
targets := s.cfg.OwnTargets() // a project's own skills stay in the project
agentsSource := s.agentsSource()
s.mu.RUnlock()
filterTarget := r.URL.Query().Get("target")
kind := r.URL.Query().Get("kind")
if kind != "" && kind != kindSkill && kind != kindAgent {
writeError(w, http.StatusBadRequest, "invalid kind: must be 'skill', 'agent', or empty")
return
}
// Collect items per target, merging skills and agents.
targetItems := make(map[string][]localSkillItem)
totalCount := 0
// --- Skill scan ---
if kind != kindAgent {
for name, target := range targets {
if filterTarget != "" && filterTarget != name {
continue
}
sc := target.SkillsConfig()
mode := ssync.EffectiveMode(sc.Mode)
if sc.Mode == "" && globalMode != "" {
mode = globalMode
}
locals, err := ssync.FindLocalSkills(sc.Path, source, mode)
if err != nil {
writeError(w, http.StatusInternalServerError, "scan failed for "+name+": "+err.Error())
return
}
for _, sk := range locals {
targetItems[name] = append(targetItems[name], localSkillItem{
Name: sk.Name,
Kind: kindSkill,
Path: sk.Path,
TargetName: name,
Size: ssync.CalculateDirSize(sk.Path),
ModTime: sk.ModTime.Format(time.RFC3339),
})
}
}
}
// --- Agent scan ---
if kind != kindSkill {
builtinAgents := s.builtinAgentTargets()
for name, target := range targets {
if filterTarget != "" && filterTarget != name {
continue
}
agentPath := resolveAgentPath(target, builtinAgents, name, s.IsProjectMode())
// Extension targets hold converted output, never agents to collect.
if agentPath == "" || agentsSource == "" || target.AgentsConfig().Extension != "" {
continue
}
localAgents, err := ssync.FindLocalAgents(agentPath, agentsSource)
if err != nil {
writeError(w, http.StatusInternalServerError, "agent scan failed for "+name+": "+err.Error())
return
}
for _, ag := range localAgents {
var size int64
var modTime string
if info, err := os.Stat(ag.Path); err == nil {
size = info.Size()
modTime = info.ModTime().Format(time.RFC3339)
}
targetItems[name] = append(targetItems[name], localSkillItem{
Name: ag.Name,
Kind: kindAgent,
Path: ag.Path,
TargetName: name,
Size: size,
ModTime: modTime,
})
}
}
}
// Build response from merged map.
var scanTargets []scanTarget
for name := range targets {
items := targetItems[name]
if len(items) == 0 && kind != "" {
// When filtering by kind, skip targets with no items of that kind.
continue
}
totalCount += len(items)
if items == nil {
items = []localSkillItem{}
}
scanTargets = append(scanTargets, scanTarget{
TargetName: name,
Skills: items,
})
}
if scanTargets == nil {
scanTargets = []scanTarget{}
}
writeJSON(w, map[string]any{
"targets": scanTargets,
"totalCount": totalCount,
})
}
// handleCollect pulls selected local skills and/or agents from targets to source.
// POST /api/collect { skills: [{name, targetName, kind?}], force: bool }
// Items with kind="agent" are pulled as agents; others as skills (backward compat).
func (s *Server) handleCollect(w http.ResponseWriter, r *http.Request) {
start := time.Now()
s.mu.Lock()
defer s.mu.Unlock()
var body struct {
Skills []collectSkillRef `json:"skills"`
Force bool `json:"force"`
}
if err := decodeJSON(w, r, &body, defaultJSONBodyLimit); err != nil {
if !errors.Is(err, errBodyTooLarge) {
writeError(w, http.StatusBadRequest, "invalid request body: "+err.Error())
}
return
}
if len(body.Skills) == 0 {
writeError(w, http.StatusBadRequest, "no skills specified")
return
}
// Split items by kind.
var skillRefs, agentRefs []collectSkillRef
for _, ref := range body.Skills {
if ref.Kind == kindAgent {
agentRefs = append(agentRefs, ref)
} else {
skillRefs = append(skillRefs, ref)
}
}
opts := ssync.PullOptions{Force: body.Force}
// Merged results across skills and agents.
var allPulled, allSkipped []string
warnings := make(map[string]string)
allFailed := make(map[string]error)
var skillsPulled, agentsPulled int
// --- Pull skills ---
if len(skillRefs) > 0 {
var resolved []ssync.LocalSkillInfo
for _, ref := range skillRefs {
target, ok := s.cfg.Targets[ref.TargetName]
if !ok {
writeError(w, http.StatusBadRequest, "unknown target: "+ref.TargetName)
return
}
skillPath := filepath.Join(target.SkillsConfig().Path, ref.Name)
info, err := os.Lstat(skillPath)
if err != nil {
writeError(w, http.StatusBadRequest, "skill not found: "+ref.Name+" in "+ref.TargetName)
return
}
if utils.IsLinkMode(skillPath, info.Mode()) {
writeError(w, http.StatusBadRequest, "skill is a symlink (not local): "+ref.Name)
return
}
if !info.IsDir() {
writeError(w, http.StatusBadRequest, "skill is not a directory: "+ref.Name)
return
}
if !ssync.HasSkillFile(skillPath) {
writeError(w, http.StatusBadRequest, "not a skill (no SKILL.md): "+ref.Name)
return
}
resolved = append(resolved, ssync.LocalSkillInfo{
Name: ref.Name,
Path: skillPath,
TargetName: ref.TargetName,
})
}
opts.Walk = s.skillsWalk()
result, err := ssync.PullSkills(resolved, s.cfg.EffectiveSkillsSource(), opts)
if err != nil {
writeError(w, http.StatusInternalServerError, "collect failed: "+err.Error())
return
}
skillsPulled = len(result.Pulled)
for name, warning := range result.Warnings {
warnings[name] = warning
}
allPulled = append(allPulled, result.Pulled...)
allSkipped = append(allSkipped, result.Skipped...)
maps.Copy(allFailed, result.Failed)
}
// --- Pull agents ---
if len(agentRefs) > 0 {
builtinAgents := s.builtinAgentTargets()
agentsSource := s.agentsSource()
var resolved []ssync.LocalAgentInfo
for _, ref := range agentRefs {
target, ok := s.cfg.Targets[ref.TargetName]
if !ok {
writeError(w, http.StatusBadRequest, "unknown target: "+ref.TargetName)
return
}
agentPath := resolveAgentPath(target, builtinAgents, ref.TargetName, s.IsProjectMode())
if agentPath == "" {
writeError(w, http.StatusBadRequest, "no agent path for target: "+ref.TargetName)
return
}
filePath := filepath.Join(agentPath, ref.Name)
info, err := os.Lstat(filePath)
if err != nil {
writeError(w, http.StatusBadRequest, "agent not found: "+ref.Name+" in "+ref.TargetName)
return
}
if utils.IsLinkMode(filePath, info.Mode()) {
writeError(w, http.StatusBadRequest, "agent is a symlink (not local): "+ref.Name)
return
}
resolved = append(resolved, ssync.LocalAgentInfo{
Name: ref.Name,
Path: filePath,
TargetName: ref.TargetName,
})
}
result, err := ssync.PullAgents(resolved, agentsSource, opts)
if err != nil {
writeError(w, http.StatusInternalServerError, "agent collect failed: "+err.Error())
return
}
agentsPulled = len(result.Pulled)
allPulled = append(allPulled, result.Pulled...)
allSkipped = append(allSkipped, result.Skipped...)
maps.Copy(allFailed, result.Failed)
}
// Convert Failed map to string values for JSON
failed := make(map[string]string, len(allFailed))
for k, v := range allFailed {
failed[k] = v.Error()
}
status := "ok"
msg := ""
if len(allFailed) > 0 {
status = "partial"
msg = "some items failed to collect"
}
s.writeOpsLog("collect", status, start, map[string]any{
"skills_selected": len(skillRefs),
"skills_pulled": skillsPulled,
"agents_selected": len(agentRefs),
"agents_pulled": agentsPulled,
"total_pulled": len(allPulled),
"total_skipped": len(allSkipped),
"total_failed": len(allFailed),
"force": body.Force,
"scope": "ui",
}, msg)
writeJSON(w, map[string]any{
"pulled": allPulled,
"skipped": allSkipped,
"warnings": warnings,
"failed": failed,
})
}