mirror of
https://github.com/runkids/skillshare.git
synced 2026-11-20 20:34:19 +00:00
skillshare backs up AGENTS.md, CLAUDE.md and shared-file locations before
rewriting them, but nothing could list or restore those copies, and a
target snapshot could not be deleted on its own. The file backups now
record why they were taken in their name (<time>.<reason>.bak; older ones
have none), and the server and CLI can list them, show a version and
restore it, saving the current content first. A link is only replaced
when the caller asks for it.
Also:
- DELETE /api/backups/{timestamp} and `backup --delete`.
- Agents snapshots (<target>-agents) could not be restored from the
dashboard: the name was looked up as a target.
- Project mode uses the project's backups folder for snapshots and lists
only file backups inside the project.
- MCP backups report which servers they changed and when.
Refs #299
235 lines
7.5 KiB
Go
235 lines
7.5 KiB
Go
package server
|
|
|
|
import (
|
|
"encoding/json"
|
|
"errors"
|
|
"net/http"
|
|
"path/filepath"
|
|
"time"
|
|
|
|
"skillshare/internal/config"
|
|
"skillshare/internal/instructions"
|
|
syncpkg "skillshare/internal/sync"
|
|
)
|
|
|
|
type fileBackupJSON struct {
|
|
Path string `json:"path"`
|
|
Versions int `json:"versions"`
|
|
Latest string `json:"latest"`
|
|
Target string `json:"target,omitempty"`
|
|
Extra string `json:"extra,omitempty"`
|
|
// Source marks the shared file itself, not a place it is put.
|
|
Source bool `json:"source,omitempty"`
|
|
}
|
|
|
|
type fileBackupCurrentJSON struct {
|
|
Exists bool `json:"exists"`
|
|
LinkTo string `json:"link_to,omitempty"`
|
|
}
|
|
|
|
type fileBackupVersionJSON struct {
|
|
ID string `json:"id"`
|
|
Kind string `json:"kind"`
|
|
Reason string `json:"reason"`
|
|
Time string `json:"time"`
|
|
Size int64 `json:"size"`
|
|
Preview string `json:"preview"`
|
|
LinkTo string `json:"link_to,omitempty"`
|
|
None bool `json:"none,omitempty"`
|
|
}
|
|
|
|
// fileBackupInScope reports whether path may be shown in the current mode:
|
|
// every file in global mode, only files inside the project in project mode.
|
|
func (s *Server) fileBackupInScope(path string) bool {
|
|
if !s.IsProjectMode() {
|
|
return true
|
|
}
|
|
return syncpkg.PathInside(s.projectRoot, path)
|
|
}
|
|
|
|
// fileBackupOwners maps file paths to the target whose instruction file it is
|
|
// and the shared (single-file extra) file that uses it, best effort; sources
|
|
// are the shared files themselves. Callers must hold s.mu.
|
|
func (s *Server) fileBackupOwners() (targets, extras map[string]string, sources map[string]bool) {
|
|
targets, extras, sources = map[string]string{}, map[string]string{}, map[string]bool{}
|
|
clean := func(p string) string { return filepath.Clean(config.ExpandPath(p)) }
|
|
for name := range s.cfg.Targets {
|
|
if it, _, ok := s.targetInstructions(name); ok && it.Path != "" {
|
|
targets[clean(it.Path)] = name
|
|
}
|
|
}
|
|
for _, r := range s.instructionRiders() {
|
|
if r.Path != "" {
|
|
if _, taken := targets[clean(r.Path)]; !taken {
|
|
targets[clean(r.Path)] = r.Name
|
|
}
|
|
}
|
|
}
|
|
resolver := s.instructionsResolver()
|
|
for _, extra := range s.extrasConfig() {
|
|
if extra.File == "" {
|
|
continue
|
|
}
|
|
if src, err := filepath.Abs(filepath.Join(s.extrasSourceDir(extra), extra.File)); err == nil {
|
|
extras[filepath.Clean(src)] = extra.Name
|
|
sources[filepath.Clean(src)] = true
|
|
}
|
|
for j := range extra.Targets {
|
|
extras[filepath.Clean(instructions.ExtraFile(extra, j, resolver).Target)] = extra.Name
|
|
}
|
|
}
|
|
return targets, extras, sources
|
|
}
|
|
|
|
// handleListFileBackups — GET /api/file-backups
|
|
func (s *Server) handleListFileBackups(w http.ResponseWriter, r *http.Request) {
|
|
files, err := syncpkg.ListFileBackups()
|
|
if err != nil {
|
|
writeCodedError(w, http.StatusInternalServerError, "file_backup_failed", err.Error(), map[string]string{"detail": err.Error()})
|
|
return
|
|
}
|
|
s.mu.RLock()
|
|
targets, extras, sources := s.fileBackupOwners()
|
|
s.mu.RUnlock()
|
|
|
|
items := make([]fileBackupJSON, 0, len(files))
|
|
for _, f := range files {
|
|
if !s.fileBackupInScope(f.Path) {
|
|
continue
|
|
}
|
|
items = append(items, fileBackupJSON{
|
|
Path: f.Path,
|
|
Versions: f.Versions,
|
|
Latest: f.Latest.Format(time.RFC3339),
|
|
Target: targets[f.Path],
|
|
Extra: extras[f.Path],
|
|
Source: sources[f.Path],
|
|
})
|
|
}
|
|
writeJSON(w, map[string]any{"files": items})
|
|
}
|
|
|
|
// fileBackupPath validates the path query or body value against the mode's
|
|
// scope; it writes the error response and returns false when invalid.
|
|
func (s *Server) fileBackupPath(w http.ResponseWriter, path string) (string, bool) {
|
|
if path == "" {
|
|
writeCodedError(w, http.StatusBadRequest, "file_backup_not_found", "path is required", map[string]string{"path": path})
|
|
return "", false
|
|
}
|
|
abs, err := filepath.Abs(path)
|
|
if err != nil {
|
|
writeCodedError(w, http.StatusBadRequest, "file_backup_not_found", err.Error(), map[string]string{"path": path})
|
|
return "", false
|
|
}
|
|
if !s.fileBackupInScope(abs) {
|
|
writeCodedError(w, http.StatusForbidden, "file_backup_outside_project", abs+" is outside the project", map[string]string{"path": abs})
|
|
return "", false
|
|
}
|
|
return abs, true
|
|
}
|
|
|
|
// writeFileBackupError maps sync errors to coded API errors.
|
|
func writeFileBackupError(w http.ResponseWriter, path string, err error) {
|
|
var linkErr *syncpkg.FileBackupLinkError
|
|
switch {
|
|
case errors.As(err, &linkErr):
|
|
writeCodedError(w, http.StatusConflict, "file_backup_is_link", err.Error(), map[string]string{"path": linkErr.Path, "link_to": linkErr.LinkTo})
|
|
case errors.Is(err, syncpkg.ErrFileBackupNotFound), errors.Is(err, syncpkg.ErrInvalidFileBackupID):
|
|
writeCodedError(w, http.StatusNotFound, "file_backup_not_found", err.Error(), map[string]string{"path": path})
|
|
default:
|
|
writeCodedError(w, http.StatusInternalServerError, "file_backup_failed", err.Error(), map[string]string{"detail": err.Error()})
|
|
}
|
|
}
|
|
|
|
func toFileBackupCurrent(path string) fileBackupCurrentJSON {
|
|
st := syncpkg.CurrentFileState(path)
|
|
return fileBackupCurrentJSON{Exists: st.Exists, LinkTo: st.LinkTo}
|
|
}
|
|
|
|
// handleFileBackupVersions — GET /api/file-backups/versions?path=
|
|
func (s *Server) handleFileBackupVersions(w http.ResponseWriter, r *http.Request) {
|
|
path, ok := s.fileBackupPath(w, r.URL.Query().Get("path"))
|
|
if !ok {
|
|
return
|
|
}
|
|
versions, err := syncpkg.FileBackupVersions(path)
|
|
if err != nil {
|
|
writeFileBackupError(w, path, err)
|
|
return
|
|
}
|
|
items := make([]fileBackupVersionJSON, 0, len(versions))
|
|
for _, v := range versions {
|
|
items = append(items, fileBackupVersionJSON{
|
|
ID: v.ID,
|
|
Kind: v.Kind,
|
|
Reason: v.Reason,
|
|
Time: v.Time.Format(time.RFC3339),
|
|
Size: v.Size,
|
|
Preview: v.Preview,
|
|
LinkTo: v.LinkTo,
|
|
None: v.None,
|
|
})
|
|
}
|
|
writeJSON(w, map[string]any{"path": path, "current": toFileBackupCurrent(path), "versions": items})
|
|
}
|
|
|
|
// handleFileBackupVersion — GET /api/file-backups/version?path=&id=
|
|
// Returns the version's content and the current file text for a diff.
|
|
func (s *Server) handleFileBackupVersion(w http.ResponseWriter, r *http.Request) {
|
|
path, ok := s.fileBackupPath(w, r.URL.Query().Get("path"))
|
|
if !ok {
|
|
return
|
|
}
|
|
data, _, err := syncpkg.ReadFileBackupVersion(path, r.URL.Query().Get("id"))
|
|
if err != nil {
|
|
writeFileBackupError(w, path, err)
|
|
return
|
|
}
|
|
// A link reads as its destination's text, which is what the diff replaces.
|
|
current := ""
|
|
if b, err := readLimited(path); err == nil {
|
|
current = string(b)
|
|
}
|
|
writeJSON(w, map[string]any{"content": string(data), "current": current})
|
|
}
|
|
|
|
// handleRestoreFileBackup — POST /api/file-backups/restore {path, id, unlink}
|
|
func (s *Server) handleRestoreFileBackup(w http.ResponseWriter, r *http.Request) {
|
|
start := time.Now()
|
|
var body struct {
|
|
Path string `json:"path"`
|
|
ID string `json:"id"`
|
|
Unlink bool `json:"unlink"`
|
|
}
|
|
if err := json.NewDecoder(http.MaxBytesReader(w, r.Body, 64*1024)).Decode(&body); err != nil {
|
|
writeError(w, http.StatusBadRequest, "invalid JSON body")
|
|
return
|
|
}
|
|
path, ok := s.fileBackupPath(w, body.Path)
|
|
if !ok {
|
|
return
|
|
}
|
|
|
|
s.mu.Lock()
|
|
defer s.mu.Unlock()
|
|
saved, err := syncpkg.RestoreFileBackup(path, body.ID, body.Unlink)
|
|
args := map[string]any{"action": "restore-file", "path": path, "id": body.ID, "scope": "ui"}
|
|
if err != nil {
|
|
var linkErr *syncpkg.FileBackupLinkError
|
|
if !errors.As(err, &linkErr) && !errors.Is(err, syncpkg.ErrFileBackupNotFound) && !errors.Is(err, syncpkg.ErrInvalidFileBackupID) {
|
|
s.writeOpsLog("restore", "error", start, args, err.Error())
|
|
}
|
|
writeFileBackupError(w, path, err)
|
|
return
|
|
}
|
|
if saved != "" {
|
|
args["backup_id"] = saved
|
|
}
|
|
s.writeOpsLog("restore", "ok", start, args, "")
|
|
resp := map[string]any{"success": true}
|
|
if saved != "" {
|
|
resp["backup_id"] = saved
|
|
}
|
|
writeJSON(w, resp)
|
|
}
|