Files
skillshare/internal/server/handler_git.go
T
Willie 5d269e8e4c feat(push): add --pull for two-way sync in one command (#354)
* feat(push): add --pull for two-way sync in one command

Users editing skills on several machines have to remember push on one and pull on the other, and a push from a machine that is behind fails until they pull first. push --pull commits local changes, merges the remote with the same merge semantics pull uses, pushes, and syncs the git root scope.

A conflict stops before anything is pushed and keeps the local commit; a target sync failure after a successful push is reported separately so the user knows the remote is already updated. It never rebases or force-pushes. commit rejects --pull instead of silently ignoring it, since both commands share the argument parser.

* docs(push): document push --pull across guides and translations

Cover the new flag on the push reference, the cross-machine sync guide, the quick reference, the daily workflow and the cross-machine recipe, in English and the ja, ko, zh-Hans and zh-Hant translations, plus the built-in skill's sync reference.

* fix(push): print the scope's sync command when --pull sync fails

A bare 'skillshare sync' retry hint defaults to skills and may pick project mode, so it does not redo an agents, extras, or root sync. Derive both the sync and the hint from one per-scope list.

* fix(pull): sync extras for the root git scope

The root scope versions skills, agents and extras, but pull and push --pull only synced skills and agents, so merged extras changes never reached their targets.

* fix(server): sync extras after a root-scope pull

The root scope versions extras too, but the dashboard pull only synced skills and agents, so merged extras never reached their targets. Matches the CLI fix.

* feat(ui): add a Sync both ways action to Git Sync

Mirrors skillshare push --pull: commit local changes, merge the remote and sync targets, then push, in one click. A pull conflict stops at the existing review before anything is pushed.

* feat(ui): confirm Sync both ways and list what it will do

Sync both ways commits, merges and pushes in one click, so ask first and show the concrete outcome (files to commit, remote commits to merge, scope, push target, conflict behavior) before changing anything.

* fix(ui): make Sync both ways match push --pull

It skipped target sync when the pull was already up to date, stopped on an empty remote instead of pushing, and the pull dropped extras warnings. Add alwaysSync and a remote_empty code to /api/pull and surface all extras warnings.
2026-10-03 18:53:08 +08:00

812 lines
23 KiB
Go

package server
import (
"encoding/json"
"errors"
"fmt"
"net/http"
"strings"
"time"
"skillshare/internal/config"
"skillshare/internal/git"
)
type gitStatusResponse struct {
GitInstalled bool `json:"gitInstalled"`
IsRepo bool `json:"isRepo"`
HasRemote bool `json:"hasRemote"`
Branch string `json:"branch"`
IsDirty bool `json:"isDirty"`
Files []string `json:"files"`
SourceDir string `json:"sourceDir"`
Scope string `json:"scope"`
ScopeMismatch bool `json:"scopeMismatch"`
MismatchScope string `json:"mismatchScope,omitempty"`
MismatchDir string `json:"mismatchDir,omitempty"`
RemoteURL string `json:"remoteURL,omitempty"`
HeadHash string `json:"headHash,omitempty"`
HeadMessage string `json:"headMessage,omitempty"`
TrackingBranch string `json:"trackingBranch,omitempty"`
// Ahead counts commits no remote-tracking branch has yet, i.e. what a push uploads.
Ahead int `json:"ahead"`
// Behind counts upstream commits HEAD lacks as of the last fetch, i.e. what a pull brings in.
Behind int `json:"behind"`
// Root-scope hazards (populated only when scope == "root"): NestedRepos are
// subdirectories with their own .git that commit as empty submodules;
// ConfigTracked means config.yaml leaked into version control.
NestedRepos []string `json:"nestedRepos"`
ConfigTracked bool `json:"configTracked"`
}
// handleGitStatus returns the git status of the source directory
func (s *Server) handleGitStatus(w http.ResponseWriter, r *http.Request) {
// Snapshot config under RLock, then release before I/O.
s.mu.RLock()
src, ok := s.gitSource(w)
if !ok {
s.mu.RUnlock()
return
}
scope := s.cfg.GitRoot
mScope, mDir, mismatch := s.cfg.GitRootMismatch()
s.mu.RUnlock()
if scope == "" {
scope = "skills"
}
resp := gitStatusResponse{
GitInstalled: git.IsInstalled(),
SourceDir: src,
Scope: scope,
ScopeMismatch: mismatch,
MismatchScope: mScope,
MismatchDir: mDir,
Files: make([]string, 0),
NestedRepos: make([]string, 0),
}
// Without git on PATH every other probe is a raw exec failure; report it
// plainly and stop so the UI can show a clear "git not installed" notice.
if !resp.GitInstalled {
writeJSON(w, resp)
return
}
resp.IsRepo = git.IsRepo(src)
if !resp.IsRepo {
writeJSON(w, resp)
return
}
resp.HasRemote = git.HasRemote(src)
if branch, err := git.GetCurrentBranch(src); err == nil {
resp.Branch = branch
}
if dirty, err := git.IsDirty(src); err == nil {
resp.IsDirty = dirty
}
if files, err := git.GetDirtyFiles(src); err == nil && len(files) > 0 {
resp.Files = files
}
if url, err := git.GetRemoteURL(src); err == nil {
resp.RemoteURL = url
}
if hash, err := git.GetCurrentHash(src); err == nil {
resp.HeadHash = hash
}
if msg, err := git.GetHeadMessage(src); err == nil {
resp.HeadMessage = msg
}
if tb, err := git.GetTrackingBranch(src); err == nil {
resp.TrackingBranch = tb
}
if resp.HasRemote {
resp.Ahead = git.AheadCount(src)
resp.Behind = git.BehindCount(src)
}
// Root-scope hazards: nested submodule traps and a leaked config.yaml.
if scope == "root" {
if nested, err := git.NestedRepos(src); err == nil {
resp.NestedRepos = nested
}
resp.ConfigTracked = git.IsConfigTracked(src)
}
writeJSON(w, resp)
}
type setGitRootRequest struct {
Scope string `json:"scope"`
RemoteURL string `json:"remoteURL,omitempty"`
}
// handleSetGitRoot changes the git_root scope: it initializes a git repo at the
// new scope directory if absent (with a scope-aware .gitignore), optionally
// wires the "origin" remote on that repo, persists the scope to config, and
// returns the updated git status. It does NOT relocate an existing repo —
// switching scope creates/uses a repo at the target directory, mirroring the
// CLI's `skillshare init --git-root <scope> [--remote <url>]` behavior.
func (s *Server) handleSetGitRoot(w http.ResponseWriter, r *http.Request) {
start := time.Now()
if s.IsProjectMode() {
writeError(w, http.StatusBadRequest, "git_root is only available in global mode")
return
}
if !git.IsInstalled() {
writeError(w, http.StatusBadRequest, "git is not installed or not in PATH")
return
}
var body setGitRootRequest
if err := decodeJSON(w, r, &body, defaultJSONBodyLimit); err != nil {
if !errors.Is(err, errBodyTooLarge) {
writeError(w, http.StatusBadRequest, "invalid JSON body")
}
return
}
if !config.ValidGitRoot(body.Scope) || body.Scope == "" {
writeError(w, http.StatusBadRequest, "invalid scope (want: skills, agents, extras, or root)")
return
}
s.mu.Lock()
defer s.mu.Unlock()
dir := config.ScopeDir(s.cfg, body.Scope)
if _, err := git.InitScopeRepo(dir, body.Scope); err != nil {
writeError(w, http.StatusInternalServerError, "failed to initialize git at scope: "+err.Error())
return
}
// Optionally wire the remote on the just-initialized scope repo.
if remote := strings.TrimSpace(body.RemoteURL); remote != "" {
if err := git.SetOrAddRemote(dir, remote); err != nil {
writeError(w, http.StatusInternalServerError, "failed to set git remote: "+err.Error())
return
}
}
// Persist the scope. "skills" is the default — store it as empty to keep
// config.yaml clean and consistent with the CLI.
if body.Scope == "skills" {
s.cfg.GitRoot = ""
} else {
s.cfg.GitRoot = body.Scope
}
if err := s.saveAndReloadConfig(); err != nil {
writeError(w, http.StatusInternalServerError, err.Error())
return
}
s.writeOpsLog("git-root", "ok", start, map[string]any{"scope": body.Scope}, "")
writeJSON(w, map[string]any{
"success": true,
"scope": body.Scope,
"gitRoot": dir,
})
}
type gitBranchesResponse struct {
Current string `json:"current"`
Local []string `json:"local"`
Remote []string `json:"remote"`
IsDirty bool `json:"isDirty"`
DirtyFiles []string `json:"dirtyFiles"`
}
// handleGitBranches returns local/remote branches for the source directory.
// Pass ?fetch=true to run git fetch first (discovers new remote branches).
func (s *Server) handleGitBranches(w http.ResponseWriter, r *http.Request) {
// Snapshot config under RLock, then release before I/O.
s.mu.RLock()
src, ok := s.gitSource(w)
s.mu.RUnlock()
if !ok {
return
}
if !git.IsRepo(src) {
writeError(w, http.StatusBadRequest, "source directory is not a git repository")
return
}
// Optional: fetch from remote first to discover new branches
if r.URL.Query().Get("fetch") == "true" && git.HasRemote(src) {
if err := git.FetchWithEnv(src, git.AuthEnvForRepo(src)); err != nil {
writeError(w, http.StatusInternalServerError, "git fetch failed: "+err.Error())
return
}
}
resp := gitBranchesResponse{
Local: make([]string, 0),
Remote: make([]string, 0),
DirtyFiles: make([]string, 0),
}
if branch, err := git.GetCurrentBranch(src); err == nil {
resp.Current = branch
}
if local, err := git.ListLocalBranches(src); err == nil && len(local) > 0 {
resp.Local = local
}
if remote, err := git.ListRemoteBranches(src); err == nil && len(remote) > 0 {
resp.Remote = remote
}
if dirty, err := git.IsDirty(src); err == nil {
resp.IsDirty = dirty
}
if resp.IsDirty {
if files, err := git.GetDirtyFiles(src); err == nil && len(files) > 0 {
resp.DirtyFiles = files
}
}
writeJSON(w, resp)
}
type checkoutRequest struct {
Branch string `json:"branch"`
}
type checkoutResponse struct {
Success bool `json:"success"`
Branch string `json:"branch"`
Message string `json:"message"`
}
// handleGitCheckout switches to a different branch
func (s *Server) handleGitCheckout(w http.ResponseWriter, r *http.Request) {
start := time.Now()
s.mu.Lock()
defer s.mu.Unlock()
var body checkoutRequest
if err := decodeJSON(w, r, &body, defaultJSONBodyLimit); err != nil {
if !errors.Is(err, errBodyTooLarge) {
writeError(w, http.StatusBadRequest, "invalid JSON body")
}
return
}
if body.Branch == "" {
writeError(w, http.StatusBadRequest, "branch is required")
return
}
src, ok := s.gitSource(w)
if !ok {
return
}
if !git.IsRepo(src) {
writeError(w, http.StatusBadRequest, "source directory is not a git repository")
return
}
// Dirty check
dirty, err := git.IsDirty(src)
if err != nil {
writeError(w, http.StatusInternalServerError, "failed to check git status: "+err.Error())
return
}
if dirty {
files, _ := git.GetDirtyFiles(src)
resp := map[string]any{
"error": "working tree has uncommitted changes — commit or stash before switching branches",
"isDirty": true,
"dirtyFiles": files,
}
w.Header().Set("Content-Type", "application/json")
w.WriteHeader(http.StatusBadRequest)
json.NewEncoder(w).Encode(resp)
return
}
// Fetch before checkout to ensure remote refs are up to date
if git.HasRemote(src) {
if err := git.FetchWithEnv(src, git.AuthEnvForRepo(src)); err != nil {
s.writeOpsLog("checkout", "error", start, map[string]any{
"branch": body.Branch,
"scope": "ui",
}, err.Error())
writeError(w, http.StatusInternalServerError, "git fetch failed: "+err.Error())
return
}
}
// Checkout
if err := git.Checkout(src, body.Branch); err != nil {
s.writeOpsLog("checkout", "error", start, map[string]any{
"branch": body.Branch,
"scope": "ui",
}, err.Error())
writeError(w, http.StatusInternalServerError, err.Error())
return
}
s.writeOpsLog("checkout", "ok", start, map[string]any{
"branch": body.Branch,
"scope": "ui",
}, "")
writeJSON(w, checkoutResponse{
Success: true,
Branch: body.Branch,
Message: "switched to branch " + body.Branch,
})
}
type pushRequest struct {
Message string `json:"message"`
DryRun bool `json:"dryRun"`
}
type pushResponse struct {
Success bool `json:"success"`
Message string `json:"message"`
DryRun bool `json:"dryRun"`
}
// handleGitCommit stages and commits changes without pushing.
func (s *Server) handleGitCommit(w http.ResponseWriter, r *http.Request) {
start := time.Now()
s.mu.Lock()
defer s.mu.Unlock()
var body pushRequest
if err := decodeJSON(w, r, &body, defaultJSONBodyLimit); err != nil {
if !errors.Is(err, errBodyTooLarge) {
writeError(w, http.StatusBadRequest, "invalid JSON body")
}
return
}
src, ok := s.gitSource(w)
if !ok {
return
}
if !git.IsRepo(src) {
writeError(w, http.StatusBadRequest, "source directory is not a git repository")
return
}
if s.rootScopeGuard(w, src, body.DryRun) {
return
}
status, err := git.GetStatus(src)
if err != nil {
writeError(w, http.StatusInternalServerError, "failed to get git status: "+err.Error())
return
}
if status == "" {
s.writeOpsLog("commit", "ok", start, map[string]any{
"summary": "nothing to commit",
"dry_run": body.DryRun,
"scope": "ui",
}, "")
writeJSON(w, pushResponse{Success: true, Message: "nothing to commit (working tree clean)", DryRun: body.DryRun})
return
}
if body.DryRun {
s.writeOpsLog("commit", "ok", start, map[string]any{
"summary": "dry run",
"dry_run": true,
"scope": "ui",
}, "")
writeJSON(w, pushResponse{Success: true, Message: "dry run: would stage and commit changes", DryRun: true})
return
}
if err := git.StageAll(src); err != nil {
writeError(w, http.StatusInternalServerError, "failed to stage changes: "+err.Error())
return
}
msg := body.Message
if msg == "" {
msg = "Update skills"
}
if err := git.Commit(src, msg); err != nil {
writeError(w, http.StatusInternalServerError, err.Error())
return
}
s.writeOpsLog("commit", "ok", start, map[string]any{
"message": msg,
"dry_run": false,
"scope": "ui",
}, "")
writeJSON(w, pushResponse{Success: true, Message: "committed successfully"})
}
// handlePush commits pending changes, then pushes every commit the remote
// does not have yet. The first push sets upstream.
func (s *Server) handlePush(w http.ResponseWriter, r *http.Request) {
start := time.Now()
s.mu.Lock()
defer s.mu.Unlock()
var body pushRequest
if err := decodeJSON(w, r, &body, defaultJSONBodyLimit); err != nil {
if !errors.Is(err, errBodyTooLarge) {
writeError(w, http.StatusBadRequest, "invalid JSON body")
}
return
}
src, ok := s.gitSource(w)
if !ok {
return
}
if !git.IsRepo(src) {
writeError(w, http.StatusBadRequest, "source directory is not a git repository")
return
}
if !git.HasRemote(src) {
writeError(w, http.StatusBadRequest, "no git remote configured")
return
}
if s.rootScopeGuard(w, src, body.DryRun) {
return
}
status, err := git.GetStatus(src)
if err != nil {
writeError(w, http.StatusInternalServerError, "failed to get git status: "+err.Error())
return
}
ahead := git.AheadCount(src)
if status == "" && ahead == 0 {
s.writeOpsLog("push", "ok", start, map[string]any{
"summary": "nothing to push",
"dry_run": body.DryRun,
"scope": "ui",
}, "")
writeJSON(w, pushResponse{Success: true, Message: "nothing to push (working tree clean)", DryRun: body.DryRun})
return
}
if body.DryRun {
s.writeOpsLog("push", "ok", start, map[string]any{
"summary": "dry run",
"dry_run": true,
"scope": "ui",
}, "")
msg := "dry run: would stage, commit, and push changes"
if status == "" {
msg = fmt.Sprintf("dry run: would push %d commit(s)", ahead)
}
writeJSON(w, pushResponse{Success: true, Message: msg, DryRun: true})
return
}
msg := body.Message
if msg == "" {
msg = "Update skills"
}
args := map[string]any{"message": msg, "dry_run": false, "scope": "ui"}
fail := func(err error) {
s.writeOpsLog("push", "error", start, args, err.Error())
writeError(w, http.StatusInternalServerError, err.Error())
}
if status != "" {
if err := git.StageAll(src); err != nil {
fail(fmt.Errorf("failed to stage changes: %w", err))
return
}
if err := git.Commit(src, msg); err != nil {
fail(err)
return
}
} else {
args["message"] = "" // nothing new was committed
}
if err := git.PushRemoteWithAuth(src); err != nil {
if errors.Is(err, git.ErrPushRejected) {
// The UI offers a pull for this code.
s.writeOpsLog("push", "error", start, args, err.Error())
writeCodedError(w, http.StatusConflict, "push_rejected", err.Error(), nil)
return
}
fail(err)
return
}
s.writeOpsLog("push", "ok", start, args, "")
writeJSON(w, pushResponse{Success: true, Message: "pushed successfully"})
}
// gitSource validates the configured git_root scope and returns the directory
// git operations run on. On an invalid scope it writes a 400 and returns
// ok=false — mirroring the CLI's resolveGitRoot, so a hand-edited bad git_root
// can't silently fall back to the skills scope (ScopeDir's default). Callers
// must hold at least s.mu.RLock.
func (s *Server) gitSource(w http.ResponseWriter) (string, bool) {
if !config.ValidGitRoot(s.cfg.GitRoot) {
writeError(w, http.StatusBadRequest,
"invalid git_root \""+s.cfg.GitRoot+"\" (valid: "+strings.Join(config.ValidGitRoots, ", ")+")")
return "", false
}
return s.cfg.EffectiveGitRoot(), true
}
// rootScopeGuard enforces root-scope safety before staging (server-side parity
// with the CLI push sweep). It blocks the request with a 400 when nested git
// repos would upload as empty submodules, and keeps config.yaml untracked. The
// config mutation runs only on a real request — on dry-run the guard is
// strictly read-only so a preview never writes .gitignore or rewrites the
// index. No-op off the root scope. Returns blocked=true once it has written an
// error response.
func (s *Server) rootScopeGuard(w http.ResponseWriter, src string, dryRun bool) (blocked bool) {
if s.cfg.GitRoot != "root" {
return false
}
if nested, err := git.NestedRepos(src); err == nil && len(nested) > 0 {
writeError(w, http.StatusBadRequest,
"nested git repositories must be disabled before committing (they upload as empty submodules): "+strings.Join(nested, ", "))
return true
}
if !dryRun {
_, _ = git.EnsureConfigUntracked(src)
}
return false
}
type absorbNestedRequest struct {
Subdirs []string `json:"subdirs"`
}
// handleAbsorbNested disables nested git repos under the root scope by renaming
// each <sub>/.git to <sub>/.git.disabled, so the directory's files get tracked
// normally instead of as an empty submodule. Global mode + root scope only; each
// subdir must match a currently-detected nested repo (this also blocks path
// traversal).
func (s *Server) handleAbsorbNested(w http.ResponseWriter, r *http.Request) {
start := time.Now()
if s.IsProjectMode() {
writeError(w, http.StatusBadRequest, "git_root is only available in global mode")
return
}
var body absorbNestedRequest
if err := decodeJSON(w, r, &body, defaultJSONBodyLimit); err != nil {
if !errors.Is(err, errBodyTooLarge) {
writeError(w, http.StatusBadRequest, "invalid JSON body")
}
return
}
if len(body.Subdirs) == 0 {
writeError(w, http.StatusBadRequest, "no subdirectories specified")
return
}
s.mu.Lock()
defer s.mu.Unlock()
if s.cfg.GitRoot != "root" {
writeError(w, http.StatusBadRequest, "nested repos can only be disabled at the root scope")
return
}
src := s.cfg.EffectiveGitRoot()
allowed := make(map[string]bool)
if nested, err := git.NestedRepos(src); err == nil {
for _, n := range nested {
allowed[n] = true
}
}
disabled := make([]string, 0, len(body.Subdirs))
for _, sub := range body.Subdirs {
if !allowed[sub] {
writeError(w, http.StatusBadRequest, "not a detected nested repository: "+sub)
return
}
if err := git.DisableNestedRepo(src, sub); err != nil {
writeError(w, http.StatusInternalServerError, "failed to disable "+sub+": "+err.Error())
return
}
disabled = append(disabled, sub)
}
s.writeOpsLog("git-absorb-nested", "ok", start, map[string]any{"subdirs": disabled}, "")
writeJSON(w, map[string]any{"success": true, "disabled": disabled})
}
type pullResponse struct {
Success bool `json:"success"`
UpToDate bool `json:"upToDate"`
Commits []git.CommitInfo `json:"commits"`
Stats git.DiffStats `json:"stats"`
SyncResults []syncTargetResult `json:"syncResults"`
DryRun bool `json:"dryRun"`
Message string `json:"message,omitempty"`
Warnings []string `json:"warnings,omitempty"`
}
// handlePull pulls changes and syncs to targets
func (s *Server) handlePull(w http.ResponseWriter, r *http.Request) {
start := time.Now()
s.mu.Lock()
defer s.mu.Unlock()
var body struct {
DryRun bool `json:"dryRun"`
// Force replaces local files with the remote on a first pull instead of merging.
Force bool `json:"force"`
Resolution *git.PullResolution `json:"resolution"`
// AlwaysSync syncs targets even when nothing new was pulled, as the
// CLI's push --pull does (the dashboard's Sync both ways).
AlwaysSync bool `json:"alwaysSync"`
}
if err := decodeJSON(w, r, &body, defaultJSONBodyLimit); errors.Is(err, errBodyTooLarge) {
return
}
src, ok := s.gitSource(w)
if !ok {
return
}
if !git.IsRepo(src) {
writeError(w, http.StatusBadRequest, "source directory is not a git repository")
return
}
if !git.HasRemote(src) {
writeError(w, http.StatusBadRequest, "no git remote configured")
return
}
// Check dirty
dirty, err := git.IsDirty(src)
if err != nil {
writeError(w, http.StatusInternalServerError, "failed to check git status: "+err.Error())
return
}
if dirty {
writeError(w, http.StatusBadRequest, "working tree has uncommitted changes — commit or stash before pulling")
return
}
if body.DryRun {
s.writeOpsLog("pull", "ok", start, map[string]any{
"summary": "dry run",
"dry_run": true,
"scope": "ui",
}, "")
writeJSON(w, pullResponse{Success: true, DryRun: true, Message: "dry run: would pull and sync"})
return
}
// A branch without upstream (e.g. a repo created here with a remote added
// later) is attached to the remote default branch first, like the CLI.
var info *git.UpdateInfo
if git.HasUpstream(src) {
info, err = git.PullWithResolution(src, body.Resolution)
} else {
if body.Resolution != nil {
writeError(w, http.StatusBadRequest, "conflict resolution requires an upstream branch")
return
}
info, err = git.FirstPull(src, body.Force)
}
if errors.Is(err, git.ErrNoRemoteBranches) {
// Sync both ways pushes on this code, like push --pull.
writeCodedError(w, http.StatusBadRequest, "remote_empty", "the remote has no branches yet; push first", nil)
return
}
if err != nil {
s.writeOpsLog("pull", "error", start, map[string]any{"dry_run": false, "force": body.Force, "scope": "ui"}, err.Error())
var conflict *git.PullConflictError
if errors.As(err, &conflict) {
w.Header().Set("Content-Type", "application/json")
w.WriteHeader(http.StatusConflict)
writeJSON(w, map[string]any{"error": err.Error(), "error_code": "pull_conflict", "error_params": conflict})
return
}
if errors.Is(err, git.ErrMergeFailed) {
// The UI offers a force pull for this code.
writeCodedError(w, http.StatusConflict, "merge_failed", "git pull failed: "+err.Error(), nil)
return
}
if strings.Contains(err.Error(), "Permission denied") {
// Usually files a sudo run left owned by root; the UI shows how to take them back.
writeCodedError(w, http.StatusInternalServerError, "permission_denied", "git pull failed: "+err.Error(), map[string]string{"path": src})
return
}
writeError(w, http.StatusInternalServerError, "git pull failed: "+err.Error())
return
}
resp := pullResponse{
Success: true,
UpToDate: info.UpToDate,
Commits: info.Commits,
Stats: info.Stats,
SyncResults: make([]syncTargetResult, 0),
}
if resp.Commits == nil {
resp.Commits = make([]git.CommitInfo, 0)
}
// Sync what the pulled scope holds, as the CLI does. Skills always sync
// from the skills source, whatever directory git_root points at.
syncPulledExtras := func() {
for _, extra := range s.syncExtras("", false, false) {
for _, msg := range extra.Warnings {
resp.Warnings = append(resp.Warnings, fmt.Sprintf("extras %s: %s", extra.Name, msg))
}
for _, t := range extra.Targets {
for _, msg := range append([]string{t.Error}, t.Errors...) {
if msg != "" {
resp.Warnings = append(resp.Warnings, fmt.Sprintf("extras sync failed for %s (%s): %s", extra.Name, t.Target, msg))
}
}
for _, msg := range t.Warnings {
resp.Warnings = append(resp.Warnings, fmt.Sprintf("extras %s (%s): %s", extra.Name, t.Target, msg))
}
}
}
}
switch scope := s.cfg.GitRoot; {
case info.UpToDate && !body.AlwaysSync:
case scope == "extras":
syncPulledExtras()
default:
kind := "" // root holds both, plus extras below
if scope == "" || scope == "skills" {
kind = kindSkill
} else if scope == "agents" {
kind = kindAgent
}
if out, _, err := s.syncResources(start, false, false, kind, ""); err != nil {
resp.Warnings = append(resp.Warnings, "sync after pull failed: "+err.Error())
} else {
resp.SyncResults = out.results
resp.Warnings = append(resp.Warnings, out.warnings...)
if out.pathOverlap > 0 {
resp.Warnings = append(resp.Warnings, fmt.Sprintf("Skill path overlap across %d target(s) — see Health Check for details", out.pathOverlap))
}
}
if scope == "root" {
syncPulledExtras()
}
}
s.writeOpsLog("pull", "ok", start, map[string]any{
"dry_run": false,
"up_to_date": resp.UpToDate,
"commits": len(resp.Commits),
"force": body.Force,
"targets_sync": len(resp.SyncResults),
"scope": "ui",
}, "")
writeJSON(w, resp)
}