mirror of
https://github.com/runkids/skillshare.git
synced 2026-11-20 20:34:19 +00:00
GET /api/audit/{name} joined the client-supplied name to the source
without checking it, so a name such as ../../x scanned a directory
outside the skills source and returned a clean result for it. The
single-skill update, the update stream, and the batch uninstall built
paths the same way; the tracked-repo uninstall route already refused
such names inline.
One helper, validSourceName, now holds that rule: non-empty, relative,
not starting with "..", and no Windows separators or volume prefixes on
any host, as sourcewalk does for declared names. The audit and update
routes answer 400, the update stream reports the name as an error
result, the batch uninstall fails that item, and the repo uninstall
route uses the same helper. Nested names such as group/skill still
resolve.
Closes #402
199 lines
5.1 KiB
Go
199 lines
5.1 KiB
Go
package server
|
|
|
|
import (
|
|
"fmt"
|
|
"net/http"
|
|
"path/filepath"
|
|
"strings"
|
|
"time"
|
|
|
|
"skillshare/internal/install"
|
|
)
|
|
|
|
// handleUpdateStream serves an SSE endpoint that streams update progress in real time.
|
|
// Events:
|
|
// - "start" → {"total": N} after collecting updatable items
|
|
// - "result" → updateResultItem after each item is updated
|
|
// - "done" → {"results":…,"summary":…} final payload
|
|
//
|
|
// Query params: names (comma-separated), force, skipAudit
|
|
func (s *Server) handleUpdateStream(w http.ResponseWriter, r *http.Request) {
|
|
safeSend, ok := initSSE(w)
|
|
if !ok {
|
|
return
|
|
}
|
|
|
|
start := time.Now()
|
|
ctx := r.Context()
|
|
|
|
force := r.URL.Query().Get("force") == "true"
|
|
skipAudit := r.URL.Query().Get("skipAudit") == "true"
|
|
|
|
// Snapshot source under RLock, then release before slow I/O.
|
|
s.mu.RLock()
|
|
source := s.cfg.EffectiveSkillsSource()
|
|
s.mu.RUnlock()
|
|
|
|
// Collect items to update based on "names" query param.
|
|
// If names is empty, update all updatable items.
|
|
namesParam := r.URL.Query().Get("names")
|
|
|
|
type updateItem struct {
|
|
name string
|
|
isRepo bool
|
|
path string
|
|
invalid bool // the name would resolve outside the source; reported, never touched
|
|
}
|
|
|
|
var items []updateItem
|
|
|
|
if namesParam != "" {
|
|
// Update specific items by name
|
|
for name := range strings.SplitSeq(namesParam, ",") {
|
|
name = strings.TrimSpace(name)
|
|
if name == "" {
|
|
continue
|
|
}
|
|
if !validSourceName(name) {
|
|
items = append(items, updateItem{name: name, invalid: true})
|
|
continue
|
|
}
|
|
// Check if it's a tracked repo
|
|
repoName := name
|
|
if !strings.HasPrefix(repoName, "_") {
|
|
repoName = "_" + name
|
|
}
|
|
repoPath := filepath.Join(source, repoName)
|
|
if install.IsGitRepo(repoPath) {
|
|
items = append(items, updateItem{name: repoName, isRepo: true, path: repoPath})
|
|
continue
|
|
}
|
|
// Check original name as repo
|
|
origPath := filepath.Join(source, name)
|
|
if install.IsGitRepo(origPath) {
|
|
items = append(items, updateItem{name: name, isRepo: true, path: origPath})
|
|
continue
|
|
}
|
|
// Regular skill
|
|
skillPath := filepath.Join(source, name)
|
|
items = append(items, updateItem{name: name, isRepo: false, path: skillPath})
|
|
}
|
|
} else {
|
|
// Update all: tracked repos + regular skills
|
|
repos, err := install.GetTrackedRepos(source)
|
|
if err == nil {
|
|
for _, repo := range repos {
|
|
items = append(items, updateItem{
|
|
name: repo,
|
|
isRepo: true,
|
|
path: filepath.Join(source, repo),
|
|
})
|
|
}
|
|
}
|
|
s.mu.RLock()
|
|
skills, err := getServerUpdatableSkills(source, s.skillsStore)
|
|
s.mu.RUnlock()
|
|
if err == nil {
|
|
for _, skill := range skills {
|
|
items = append(items, updateItem{
|
|
name: skill,
|
|
isRepo: false,
|
|
path: filepath.Join(source, skill),
|
|
})
|
|
}
|
|
}
|
|
}
|
|
|
|
safeSend("start", map[string]int{"total": len(items)})
|
|
|
|
var results []updateResultItem
|
|
summary := struct {
|
|
Updated int `json:"updated"`
|
|
UpToDate int `json:"upToDate"`
|
|
Blocked int `json:"blocked"`
|
|
Errors int `json:"errors"`
|
|
Skipped int `json:"skipped"`
|
|
MissingTrackedRepos []missingTrackedRepoInfo `json:"missingTrackedRepos,omitempty"`
|
|
}{}
|
|
|
|
for _, item := range items {
|
|
// Check if client disconnected
|
|
select {
|
|
case <-ctx.Done():
|
|
return
|
|
default:
|
|
}
|
|
|
|
var result updateResultItem
|
|
|
|
// Lock per-item for write operations
|
|
s.mu.Lock()
|
|
switch {
|
|
case item.invalid:
|
|
result = updateResultItem{Name: item.name, Action: "error", Message: "invalid skill name: " + item.name}
|
|
case item.isRepo:
|
|
result = s.updateTrackedRepo(item.name, item.path, force, skipAudit)
|
|
default:
|
|
result = s.updateRegularSkill(item.name, item.path, force, skipAudit)
|
|
}
|
|
s.mu.Unlock()
|
|
|
|
results = append(results, result)
|
|
|
|
switch result.Action {
|
|
case "updated":
|
|
summary.Updated++
|
|
case "up-to-date":
|
|
summary.UpToDate++
|
|
case "blocked":
|
|
summary.Blocked++
|
|
case "error":
|
|
summary.Errors++
|
|
case "skipped":
|
|
summary.Skipped++
|
|
}
|
|
|
|
safeSend("result", result)
|
|
}
|
|
|
|
// Surface tracked repos declared in metadata but absent on disk (issue #212).
|
|
// Only relevant for the update-all flow, not targeted updates.
|
|
if namesParam == "" {
|
|
s.mu.RLock()
|
|
summary.MissingTrackedRepos = s.missingTrackedRepos()
|
|
s.mu.RUnlock()
|
|
}
|
|
|
|
// Write ops log
|
|
s.mu.Lock()
|
|
status := "ok"
|
|
msg := ""
|
|
if summary.Blocked > 0 {
|
|
status = "partial"
|
|
msg = fmt.Sprintf("%d update(s) blocked by security audit", summary.Blocked)
|
|
}
|
|
if summary.Errors > 0 {
|
|
status = "partial"
|
|
if msg != "" {
|
|
msg += fmt.Sprintf(", %d update(s) failed", summary.Errors)
|
|
} else {
|
|
msg = fmt.Sprintf("%d update(s) failed", summary.Errors)
|
|
}
|
|
}
|
|
s.writeOpsLog("update", status, start, map[string]any{
|
|
"name": "--all-stream",
|
|
"force": force,
|
|
"skip_audit": skipAudit,
|
|
"results_total": len(results),
|
|
"results_failed": summary.Errors,
|
|
"results_blocked": summary.Blocked,
|
|
"scope": "ui",
|
|
}, msg)
|
|
s.mu.Unlock()
|
|
|
|
safeSend("done", map[string]any{
|
|
"results": results,
|
|
"summary": summary,
|
|
})
|
|
}
|