mirror of
https://github.com/runkids/skillshare.git
synced 2026-11-19 02:17:09 +00:00
Bind provider credentials to canonical or explicitly configured HTTPS origins and preserve that policy across remote consumers. Reject cross-site credentialed reads, linked fallback directories, and discovered-agent writes outside the source; audit staged content before rooted atomic publication. Add boundary regressions, private Git update coverage, stable cross-platform fixtures, and aligned documentation. Verified the integrated main baseline with all executed CI checks passing.
119 lines
3.3 KiB
Go
119 lines
3.3 KiB
Go
package server
|
|
|
|
import (
|
|
"encoding/json"
|
|
"net/http"
|
|
"strconv"
|
|
"strings"
|
|
|
|
"skillshare/internal/config"
|
|
"skillshare/internal/hub"
|
|
"skillshare/internal/install"
|
|
"skillshare/internal/search"
|
|
"skillshare/internal/sourcewalk"
|
|
)
|
|
|
|
func (s *Server) handleSearch(w http.ResponseWriter, r *http.Request) {
|
|
// Snapshot config under RLock, then release before I/O.
|
|
s.mu.RLock()
|
|
source := s.skillsSource()
|
|
parseOpts := s.parseOpts()
|
|
hubCfg := s.cfg.Hub
|
|
if s.IsProjectMode() && s.projectCfg != nil {
|
|
hubCfg = s.projectCfg.Hub
|
|
}
|
|
s.mu.RUnlock()
|
|
|
|
query := r.URL.Query().Get("q")
|
|
hubParam := r.URL.Query().Get("hub")
|
|
|
|
limit := 0 // default: no limit for hub search
|
|
if l := r.URL.Query().Get("limit"); l != "" {
|
|
if parsed, err := strconv.Atoi(l); err == nil {
|
|
limit = parsed
|
|
}
|
|
}
|
|
|
|
var results []search.SearchResult
|
|
var err error
|
|
switch {
|
|
case hubParam == "@builtin":
|
|
results, err = searchBuiltinIndex(source, query, limit, s.skillsWalk())
|
|
case hubParam != "":
|
|
// SSH hub sources trigger a git clone using the host's SSH credentials.
|
|
// In the web server, restrict that to URLs the user has explicitly saved
|
|
// (via 'skillshare hub add') to avoid cloning arbitrary request-supplied
|
|
// hosts.
|
|
if install.IsSSHURL(hubParam) && !savedHubURLSet(hubCfg)[strings.TrimSpace(hubParam)] {
|
|
writeError(w, http.StatusForbidden, "SSH hub sources must be added first via 'skillshare hub add'")
|
|
return
|
|
}
|
|
results, err = search.SearchFromIndexURL(query, limit, hubParam, parseOpts)
|
|
default:
|
|
// GitHub search always needs a limit
|
|
if limit <= 0 {
|
|
limit = 20
|
|
}
|
|
results, err = search.Search(query, limit)
|
|
}
|
|
if err != nil {
|
|
writeError(w, http.StatusInternalServerError, err.Error())
|
|
return
|
|
}
|
|
|
|
type resultItem struct {
|
|
Name string `json:"name"`
|
|
Description string `json:"description"`
|
|
Source string `json:"source"`
|
|
Ref string `json:"ref,omitempty"`
|
|
Skill string `json:"skill,omitempty"`
|
|
Stars int `json:"stars"`
|
|
Owner string `json:"owner"`
|
|
Repo string `json:"repo"`
|
|
Tags []string `json:"tags,omitempty"`
|
|
}
|
|
|
|
items := make([]resultItem, 0, len(results))
|
|
for _, r := range results {
|
|
items = append(items, resultItem{
|
|
Name: r.Name,
|
|
Description: r.Description,
|
|
Source: r.Source,
|
|
// A hosted index can hold hundreds of entries, so the remote is not
|
|
// asked; a branch containing "/" shows as its first segment.
|
|
Ref: install.SourceRef(r.Source, parseOpts, nil),
|
|
Skill: r.Skill,
|
|
Stars: r.Stars,
|
|
Owner: r.Owner,
|
|
Repo: r.Repo,
|
|
Tags: r.Tags,
|
|
})
|
|
}
|
|
|
|
writeJSON(w, map[string]any{"results": items})
|
|
}
|
|
|
|
// savedHubURLSet returns the set of saved hub URLs for fast membership checks.
|
|
func savedHubURLSet(hub config.HubConfig) map[string]bool {
|
|
set := make(map[string]bool, len(hub.Hubs))
|
|
for _, e := range hub.Hubs {
|
|
if u := strings.TrimSpace(e.URL); u != "" {
|
|
set[u] = true
|
|
}
|
|
}
|
|
return set
|
|
}
|
|
|
|
// searchBuiltinIndex builds the hub index from local skills and searches it in-memory.
|
|
func searchBuiltinIndex(sourcePath, query string, limit int, walk ...sourcewalk.Options) ([]search.SearchResult, error) {
|
|
idx, err := hub.BuildIndex(sourcePath, false, false, walk...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
data, err := json.Marshal(idx)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return search.SearchFromIndexJSON(query, limit, data)
|
|
}
|