Files
skillshare/internal/sync/agent_sync_test.go
T
Willie cb2bcec948 feat(agents): convert agents with a target extension
Tools disagree on agent frontmatter and some need another format entirely,
so an agent written for Claude is misread elsewhere. An `extension` on a
target's agents block reuses the extras transform mechanism to convert each
agent during sync.

Converted targets hold transformed output, so collect never pulls them back
into the source. Leftover symlinks from merge or symlink mode are removed
rather than written through, and a failed conversion drops the old output
so an unconverted agent never stays active.

The bundled opencode-agents extension keeps only fields OpenCode documents
and refuses agents that restrict their tools, since dropping those fields
would widen the agent's access.

Refs #267
Refs #241
2026-09-21 13:31:38 +08:00

856 lines
25 KiB
Go

package sync
import (
"os"
"path/filepath"
"testing"
"skillshare/internal/resource"
)
func TestCheckAgentCollisions_NoCollision(t *testing.T) {
agents := []resource.DiscoveredResource{
{FlatName: "tutor.md", RelPath: "tutor.md"},
{FlatName: "reviewer.md", RelPath: "reviewer.md"},
}
collisions := CheckAgentCollisions(agents)
if len(collisions) != 0 {
t.Errorf("expected 0 collisions, got %d", len(collisions))
}
}
func TestCheckAgentCollisions_HasCollision(t *testing.T) {
agents := []resource.DiscoveredResource{
{FlatName: "team__helper.md", RelPath: "team/helper.md"},
{FlatName: "team__helper.md", RelPath: "team__helper.md"},
}
collisions := CheckAgentCollisions(agents)
if len(collisions) != 1 {
t.Fatalf("expected 1 collision, got %d", len(collisions))
}
if collisions[0].FlatName != "team__helper.md" {
t.Errorf("collision FlatName = %q", collisions[0].FlatName)
}
}
func TestSyncAgentsToTarget_NewLinks(t *testing.T) {
sourceDir := t.TempDir()
targetDir := t.TempDir()
// Create agent source files
os.WriteFile(filepath.Join(sourceDir, "tutor.md"), []byte("# Tutor"), 0644)
os.WriteFile(filepath.Join(sourceDir, "reviewer.md"), []byte("# Reviewer"), 0644)
agents := []resource.DiscoveredResource{
{FlatName: "tutor.md", AbsPath: filepath.Join(sourceDir, "tutor.md")},
{FlatName: "reviewer.md", AbsPath: filepath.Join(sourceDir, "reviewer.md")},
}
result, err := SyncAgentsToTarget(agents, targetDir, false, false)
if err != nil {
t.Fatalf("SyncAgentsToTarget: %v", err)
}
if len(result.Linked) != 2 {
t.Errorf("expected 2 linked, got %d", len(result.Linked))
}
// Verify symlinks exist
for _, name := range []string{"tutor.md", "reviewer.md"} {
linkPath := filepath.Join(targetDir, name)
info, err := os.Lstat(linkPath)
if err != nil {
t.Errorf("expected symlink %s to exist", name)
continue
}
if info.Mode()&os.ModeSymlink == 0 {
t.Errorf("expected %s to be a symlink", name)
}
}
}
func TestSyncAgentsToTarget_ExistingSymlinkCorrect(t *testing.T) {
sourceDir := t.TempDir()
targetDir := t.TempDir()
srcFile := filepath.Join(sourceDir, "tutor.md")
os.WriteFile(srcFile, []byte("# Tutor"), 0644)
// Pre-create correct symlink
os.Symlink(srcFile, filepath.Join(targetDir, "tutor.md"))
agents := []resource.DiscoveredResource{
{FlatName: "tutor.md", AbsPath: srcFile},
}
result, err := SyncAgentsToTarget(agents, targetDir, false, false)
if err != nil {
t.Fatalf("SyncAgentsToTarget: %v", err)
}
if len(result.Linked) != 1 {
t.Errorf("expected 1 linked (existing correct), got %d", len(result.Linked))
}
if len(result.Updated) != 0 {
t.Errorf("expected 0 updated, got %d", len(result.Updated))
}
}
func TestSyncAgentsToTarget_LocalFileSkipped(t *testing.T) {
sourceDir := t.TempDir()
targetDir := t.TempDir()
srcFile := filepath.Join(sourceDir, "tutor.md")
os.WriteFile(srcFile, []byte("# Tutor source"), 0644)
// Pre-create local file (not a symlink)
os.WriteFile(filepath.Join(targetDir, "tutor.md"), []byte("# Local tutor"), 0644)
agents := []resource.DiscoveredResource{
{FlatName: "tutor.md", AbsPath: srcFile},
}
result, err := SyncAgentsToTarget(agents, targetDir, false, false)
if err != nil {
t.Fatalf("SyncAgentsToTarget: %v", err)
}
if len(result.Skipped) != 1 {
t.Errorf("expected 1 skipped, got %d", len(result.Skipped))
}
}
func TestSyncAgentsToTarget_ForceReplacesLocal(t *testing.T) {
sourceDir := t.TempDir()
targetDir := t.TempDir()
srcFile := filepath.Join(sourceDir, "tutor.md")
os.WriteFile(srcFile, []byte("# Tutor source"), 0644)
os.WriteFile(filepath.Join(targetDir, "tutor.md"), []byte("# Local"), 0644)
agents := []resource.DiscoveredResource{
{FlatName: "tutor.md", AbsPath: srcFile},
}
result, err := SyncAgentsToTarget(agents, targetDir, false, true)
if err != nil {
t.Fatalf("SyncAgentsToTarget: %v", err)
}
if len(result.Updated) != 1 {
t.Errorf("expected 1 updated, got %d", len(result.Updated))
}
// Should now be a symlink
info, _ := os.Lstat(filepath.Join(targetDir, "tutor.md"))
if info.Mode()&os.ModeSymlink == 0 {
t.Error("expected symlink after force")
}
}
func TestPruneOrphanAgentLinks(t *testing.T) {
sourceDir := t.TempDir()
targetDir := t.TempDir()
// Create source file and active symlink
srcFile := filepath.Join(sourceDir, "active.md")
os.WriteFile(srcFile, []byte("# Active"), 0644)
os.Symlink(srcFile, filepath.Join(targetDir, "active.md"))
// Create orphan symlink
orphanSrc := filepath.Join(sourceDir, "orphan.md")
os.WriteFile(orphanSrc, []byte("# Orphan"), 0644)
os.Symlink(orphanSrc, filepath.Join(targetDir, "orphan.md"))
// Create non-symlink file (should not be removed)
os.WriteFile(filepath.Join(targetDir, "local.md"), []byte("# Local"), 0644)
agents := []resource.DiscoveredResource{
{FlatName: "active.md"},
}
removed, err := PruneOrphanAgentLinks(targetDir, agents, false)
if err != nil {
t.Fatalf("PruneOrphanAgentLinks: %v", err)
}
if len(removed) != 1 {
t.Fatalf("expected 1 removed, got %d: %v", len(removed), removed)
}
if removed[0] != "orphan.md" {
t.Errorf("expected orphan.md removed, got %q", removed[0])
}
// local.md should still exist
if _, err := os.Stat(filepath.Join(targetDir, "local.md")); err != nil {
t.Error("local.md should not be removed")
}
}
func TestPruneOrphanAgentLinks_NonExistentDir(t *testing.T) {
removed, err := PruneOrphanAgentLinks("/nonexistent/path", nil, false)
if err != nil {
t.Fatalf("unexpected error: %v", err)
}
if len(removed) != 0 {
t.Errorf("expected 0 removed, got %d", len(removed))
}
}
func TestFindLocalAgentsAndPullAgents(t *testing.T) {
targetDir := t.TempDir()
sourceDir := t.TempDir()
// Create a local (non-symlink) agent file in target
os.WriteFile(filepath.Join(targetDir, "new-agent.md"), []byte("# New agent"), 0644)
// Create a symlink (should be skipped)
srcFile := filepath.Join(sourceDir, "existing.md")
os.WriteFile(srcFile, []byte("# Existing"), 0644)
os.Symlink(srcFile, filepath.Join(targetDir, "existing.md"))
// Create README (should be skipped)
os.WriteFile(filepath.Join(targetDir, "README.md"), []byte("# Readme"), 0644)
// Create non-md file (should be skipped)
os.WriteFile(filepath.Join(targetDir, "config.yaml"), []byte("key: val"), 0644)
collectDir := t.TempDir()
agents, err := FindLocalAgents(targetDir, collectDir)
if err != nil {
t.Fatalf("FindLocalAgents: %v", err)
}
if len(agents) != 1 {
t.Fatalf("expected 1 local agent, got %d: %v", len(agents), agents)
}
if agents[0].Name != "new-agent.md" {
t.Errorf("agent name = %q, want %q", agents[0].Name, "new-agent.md")
}
result, err := PullAgents(agents, collectDir, PullOptions{})
if err != nil {
t.Fatalf("PullAgents: %v", err)
}
if len(result.Pulled) != 1 || result.Pulled[0] != "new-agent.md" {
t.Fatalf("expected pulled=[new-agent.md], got %#v", result)
}
// Verify file was copied
data, err := os.ReadFile(filepath.Join(collectDir, "new-agent.md"))
if err != nil {
t.Fatalf("collected file not found: %v", err)
}
if string(data) != "# New agent" {
t.Errorf("collected content = %q", string(data))
}
}
func TestFindLocalAgents_TargetSymlinkToSource_ReturnsEmpty(t *testing.T) {
sourceDir := t.TempDir()
targetParent := t.TempDir()
targetDir := filepath.Join(targetParent, "agents")
os.WriteFile(filepath.Join(sourceDir, "tutor.md"), []byte("# Tutor"), 0644)
os.Symlink(sourceDir, targetDir)
agents, err := FindLocalAgents(targetDir, sourceDir)
if err != nil {
t.Fatalf("FindLocalAgents: %v", err)
}
if len(agents) != 0 {
t.Fatalf("expected 0 local agents, got %d", len(agents))
}
}
func TestPullAgents_SkipsExistingWithoutForce(t *testing.T) {
targetDir := t.TempDir()
collectDir := t.TempDir()
os.WriteFile(filepath.Join(targetDir, "agent.md"), []byte("# Target"), 0644)
os.WriteFile(filepath.Join(collectDir, "agent.md"), []byte("# Source"), 0644)
agents, err := FindLocalAgents(targetDir, collectDir)
if err != nil {
t.Fatalf("FindLocalAgents: %v", err)
}
result, err := PullAgents(agents, collectDir, PullOptions{})
if err != nil {
t.Fatalf("PullAgents: %v", err)
}
if len(result.Skipped) != 1 || result.Skipped[0] != "agent.md" {
t.Fatalf("expected skipped=[agent.md], got %#v", result)
}
data, err := os.ReadFile(filepath.Join(collectDir, "agent.md"))
if err != nil {
t.Fatalf("read source agent: %v", err)
}
if string(data) != "# Source" {
t.Fatalf("source agent should remain unchanged, got %q", string(data))
}
}
func TestPullAgents_ForceOverwritesExisting(t *testing.T) {
targetDir := t.TempDir()
collectDir := t.TempDir()
os.WriteFile(filepath.Join(targetDir, "agent.md"), []byte("# Target"), 0644)
os.WriteFile(filepath.Join(collectDir, "agent.md"), []byte("# Source"), 0644)
agents, err := FindLocalAgents(targetDir, collectDir)
if err != nil {
t.Fatalf("FindLocalAgents: %v", err)
}
result, err := PullAgents(agents, collectDir, PullOptions{Force: true})
if err != nil {
t.Fatalf("PullAgents: %v", err)
}
if len(result.Pulled) != 1 || result.Pulled[0] != "agent.md" {
t.Fatalf("expected pulled=[agent.md], got %#v", result)
}
data, err := os.ReadFile(filepath.Join(collectDir, "agent.md"))
if err != nil {
t.Fatalf("read source agent: %v", err)
}
if string(data) != "# Target" {
t.Fatalf("source agent should be overwritten, got %q", string(data))
}
}
// --- Symlink mode tests ---
func TestSyncAgents_SymlinkMode_NewDir(t *testing.T) {
sourceDir := t.TempDir()
os.WriteFile(filepath.Join(sourceDir, "tutor.md"), []byte("# Tutor"), 0644)
targetDir := filepath.Join(t.TempDir(), "agents")
result, err := SyncAgents(nil, sourceDir, targetDir, "symlink", false, false)
if err != nil {
t.Fatalf("SyncAgents symlink: %v", err)
}
if len(result.Linked) != 1 {
t.Errorf("expected 1 linked, got %d", len(result.Linked))
}
// targetDir should be a symlink to sourceDir
info, err := os.Lstat(targetDir)
if err != nil {
t.Fatalf("Lstat: %v", err)
}
if info.Mode()&os.ModeSymlink == 0 {
t.Error("expected targetDir to be a symlink")
}
}
func TestSyncAgents_SymlinkMode_AlreadyCorrect(t *testing.T) {
sourceDir := t.TempDir()
parentDir := t.TempDir()
targetDir := filepath.Join(parentDir, "agents")
os.Symlink(sourceDir, targetDir)
result, err := SyncAgents(nil, sourceDir, targetDir, "symlink", false, false)
if err != nil {
t.Fatalf("SyncAgents symlink: %v", err)
}
if len(result.Linked) != 1 {
t.Errorf("expected 1 linked (already correct), got %d", len(result.Linked))
}
if len(result.Updated) != 0 {
t.Errorf("expected 0 updated, got %d", len(result.Updated))
}
}
func TestSyncAgents_SymlinkMode_RealDirSkipped(t *testing.T) {
sourceDir := t.TempDir()
targetDir := t.TempDir() // real directory
result, err := SyncAgents(nil, sourceDir, targetDir, "symlink", false, false)
if err != nil {
t.Fatalf("SyncAgents symlink: %v", err)
}
if len(result.Skipped) != 1 {
t.Errorf("expected 1 skipped, got %d", len(result.Skipped))
}
}
// --- Copy mode tests ---
func TestSyncAgents_CopyMode_NewFiles(t *testing.T) {
sourceDir := t.TempDir()
targetDir := t.TempDir()
os.WriteFile(filepath.Join(sourceDir, "tutor.md"), []byte("# Tutor"), 0644)
agents := []resource.DiscoveredResource{
{FlatName: "tutor.md", AbsPath: filepath.Join(sourceDir, "tutor.md")},
}
result, err := SyncAgents(agents, sourceDir, targetDir, "copy", false, false)
if err != nil {
t.Fatalf("SyncAgents copy: %v", err)
}
if len(result.Linked) != 1 {
t.Errorf("expected 1 linked (new copy), got %d", len(result.Linked))
}
// Verify it's a real file, not a symlink
info, _ := os.Lstat(filepath.Join(targetDir, "tutor.md"))
if info.Mode()&os.ModeSymlink != 0 {
t.Error("copy mode should create real files, not symlinks")
}
data, _ := os.ReadFile(filepath.Join(targetDir, "tutor.md"))
if string(data) != "# Tutor" {
t.Errorf("content = %q", string(data))
}
}
func TestSyncAgents_CopyMode_SameContent(t *testing.T) {
sourceDir := t.TempDir()
targetDir := t.TempDir()
os.WriteFile(filepath.Join(sourceDir, "tutor.md"), []byte("# Same"), 0644)
os.WriteFile(filepath.Join(targetDir, "tutor.md"), []byte("# Same"), 0644)
agents := []resource.DiscoveredResource{
{FlatName: "tutor.md", AbsPath: filepath.Join(sourceDir, "tutor.md")},
}
result, err := SyncAgents(agents, sourceDir, targetDir, "copy", false, false)
if err != nil {
t.Fatalf("SyncAgents copy: %v", err)
}
if len(result.Linked) != 1 {
t.Errorf("expected 1 linked (same content), got %d", len(result.Linked))
}
if len(result.Updated) != 0 {
t.Errorf("expected 0 updated, got %d", len(result.Updated))
}
}
func TestSyncAgents_CopyMode_DifferentContent(t *testing.T) {
sourceDir := t.TempDir()
targetDir := t.TempDir()
os.WriteFile(filepath.Join(sourceDir, "tutor.md"), []byte("# New"), 0644)
os.WriteFile(filepath.Join(targetDir, "tutor.md"), []byte("# Old"), 0644)
agents := []resource.DiscoveredResource{
{FlatName: "tutor.md", AbsPath: filepath.Join(sourceDir, "tutor.md")},
}
result, err := SyncAgents(agents, sourceDir, targetDir, "copy", false, false)
if err != nil {
t.Fatalf("SyncAgents copy: %v", err)
}
if len(result.Updated) != 1 {
t.Errorf("expected 1 updated, got %d", len(result.Updated))
}
data, _ := os.ReadFile(filepath.Join(targetDir, "tutor.md"))
if string(data) != "# New" {
t.Errorf("content = %q, want %q", string(data), "# New")
}
}
func TestPruneOrphanAgentCopies(t *testing.T) {
targetDir := t.TempDir()
os.WriteFile(filepath.Join(targetDir, "active.md"), []byte("# Active"), 0644)
os.WriteFile(filepath.Join(targetDir, "orphan.md"), []byte("# Orphan"), 0644)
os.WriteFile(filepath.Join(targetDir, "README.md"), []byte("# Readme"), 0644) // conventional, skip
agents := []resource.DiscoveredResource{
{FlatName: "active.md"},
}
removed, err := PruneOrphanAgentCopies(targetDir, agents, "", false)
if err != nil {
t.Fatalf("PruneOrphanAgentCopies: %v", err)
}
if len(removed) != 1 || removed[0] != "orphan.md" {
t.Errorf("expected [orphan.md] removed, got %v", removed)
}
// README.md should still exist
if _, err := os.Stat(filepath.Join(targetDir, "README.md")); err != nil {
t.Error("README.md should not be removed")
}
}
// --- Dispatch tests ---
func TestSyncAgents_DefaultIsMerge(t *testing.T) {
sourceDir := t.TempDir()
targetDir := t.TempDir()
os.WriteFile(filepath.Join(sourceDir, "a.md"), []byte("# A"), 0644)
agents := []resource.DiscoveredResource{
{FlatName: "a.md", AbsPath: filepath.Join(sourceDir, "a.md")},
}
result, err := SyncAgents(agents, sourceDir, targetDir, "", false, false)
if err != nil {
t.Fatalf("SyncAgents default: %v", err)
}
if len(result.Linked) != 1 {
t.Errorf("expected 1 linked, got %d", len(result.Linked))
}
// Should be a symlink (merge mode)
info, _ := os.Lstat(filepath.Join(targetDir, "a.md"))
if info.Mode()&os.ModeSymlink == 0 {
t.Error("default mode should create symlinks (merge)")
}
}
func TestSyncAgents_MergeMode_NestedSameBasename_IsStable(t *testing.T) {
sourceDir := t.TempDir()
targetDir := t.TempDir()
if err := os.MkdirAll(filepath.Join(sourceDir, "team-a"), 0o755); err != nil {
t.Fatalf("mkdir team-a: %v", err)
}
if err := os.MkdirAll(filepath.Join(sourceDir, "team-b"), 0o755); err != nil {
t.Fatalf("mkdir team-b: %v", err)
}
teamAPath := filepath.Join(sourceDir, "team-a", "helper.md")
teamBPath := filepath.Join(sourceDir, "team-b", "helper.md")
if err := os.WriteFile(teamAPath, []byte("# Team A"), 0o644); err != nil {
t.Fatalf("write team-a helper: %v", err)
}
if err := os.WriteFile(teamBPath, []byte("# Team B"), 0o644); err != nil {
t.Fatalf("write team-b helper: %v", err)
}
agents, err := resource.AgentKind{}.Discover(sourceDir)
if err != nil {
t.Fatalf("discover agents: %v", err)
}
if len(agents) != 2 {
t.Fatalf("expected 2 agents, got %d", len(agents))
}
first, err := SyncAgents(agents, sourceDir, targetDir, "merge", false, false)
if err != nil {
t.Fatalf("first sync: %v", err)
}
if len(first.Linked) != 2 {
t.Fatalf("first sync: expected 2 linked, got %d", len(first.Linked))
}
if len(first.Updated) != 0 {
t.Fatalf("first sync: expected 0 updated, got %d", len(first.Updated))
}
second, err := SyncAgents(agents, sourceDir, targetDir, "merge", false, false)
if err != nil {
t.Fatalf("second sync: %v", err)
}
if len(second.Linked) != 2 {
t.Fatalf("second sync: expected 2 linked, got %d", len(second.Linked))
}
if len(second.Updated) != 0 {
t.Fatalf("second sync: expected 0 updated, got %d", len(second.Updated))
}
linkA, err := os.Readlink(filepath.Join(targetDir, "team-a__helper.md"))
if err != nil {
t.Fatalf("readlink team-a target: %v", err)
}
// EvalSymlinks to handle macOS /var → /private/var alias.
wantA, _ := filepath.EvalSymlinks(teamAPath)
gotA, _ := filepath.EvalSymlinks(linkA)
if gotA != wantA {
t.Fatalf("team-a symlink = %q, want %q", linkA, teamAPath)
}
linkB, err := os.Readlink(filepath.Join(targetDir, "team-b__helper.md"))
if err != nil {
t.Fatalf("readlink team-b target: %v", err)
}
wantB, _ := filepath.EvalSymlinks(teamBPath)
gotB, _ := filepath.EvalSymlinks(linkB)
if gotB != wantB {
t.Fatalf("team-b symlink = %q, want %q", linkB, teamBPath)
}
}
func TestSyncAgents_MergeMode_ProjectUsesRelativeSymlink(t *testing.T) {
projectRoot := t.TempDir()
sourceDir := filepath.Join(projectRoot, ".skillshare", "agents")
targetDir := filepath.Join(projectRoot, ".claude", "agents")
if err := os.MkdirAll(sourceDir, 0755); err != nil {
t.Fatal(err)
}
srcFile := filepath.Join(sourceDir, "reviewer.md")
if err := os.WriteFile(srcFile, []byte("# Reviewer"), 0644); err != nil {
t.Fatal(err)
}
agents := []resource.DiscoveredResource{
{FlatName: "reviewer.md", AbsPath: srcFile},
}
if _, err := SyncAgents(agents, sourceDir, targetDir, "merge", false, false, projectRoot); err != nil {
t.Fatalf("SyncAgents merge: %v", err)
}
link, err := os.Readlink(filepath.Join(targetDir, "reviewer.md"))
if err != nil {
t.Fatalf("readlink: %v", err)
}
if filepath.IsAbs(link) {
t.Fatalf("expected project agent symlink to be relative, got %q", link)
}
}
func TestSyncAgents_SymlinkMode_ProjectUsesRelativeSymlink(t *testing.T) {
projectRoot := t.TempDir()
sourceDir := filepath.Join(projectRoot, ".skillshare", "agents")
targetDir := filepath.Join(projectRoot, ".claude", "agents")
if err := os.MkdirAll(sourceDir, 0755); err != nil {
t.Fatal(err)
}
if err := os.WriteFile(filepath.Join(sourceDir, "reviewer.md"), []byte("# Reviewer"), 0644); err != nil {
t.Fatal(err)
}
if _, err := SyncAgents(nil, sourceDir, targetDir, "symlink", false, false, projectRoot); err != nil {
t.Fatalf("SyncAgents symlink: %v", err)
}
link, err := os.Readlink(targetDir)
if err != nil {
t.Fatalf("readlink: %v", err)
}
if filepath.IsAbs(link) {
t.Fatalf("expected project agent directory symlink to be relative, got %q", link)
}
}
func TestSyncAgents_MergeMode_ReformatsProjectAgentSymlink(t *testing.T) {
projectRoot := t.TempDir()
sourceDir := filepath.Join(projectRoot, ".skillshare", "agents")
targetDir := filepath.Join(projectRoot, ".claude", "agents")
if err := os.MkdirAll(sourceDir, 0755); err != nil {
t.Fatal(err)
}
if err := os.MkdirAll(targetDir, 0755); err != nil {
t.Fatal(err)
}
srcFile := filepath.Join(sourceDir, "reviewer.md")
if err := os.WriteFile(srcFile, []byte("# Reviewer"), 0644); err != nil {
t.Fatal(err)
}
linkPath := filepath.Join(targetDir, "reviewer.md")
if err := os.Symlink(srcFile, linkPath); err != nil {
t.Fatal(err)
}
agents := []resource.DiscoveredResource{
{FlatName: "reviewer.md", AbsPath: srcFile},
}
result, err := SyncAgents(agents, sourceDir, targetDir, "merge", false, false, projectRoot)
if err != nil {
t.Fatalf("SyncAgents merge: %v", err)
}
if len(result.Updated) != 1 {
t.Fatalf("expected reformat to count as updated, got %#v", result)
}
link, err := os.Readlink(linkPath)
if err != nil {
t.Fatalf("readlink: %v", err)
}
if filepath.IsAbs(link) {
t.Fatalf("expected reformatted project agent symlink to be relative, got %q", link)
}
}
// TestSyncAgents_MergeMode_StableWhenSourceResolvesThroughSymlink reproduces the
// macOS /var → /private/var case on any platform: the project paths are expressed
// through a symlinked ancestor, while discovery records the agent's real
// (EvalSymlinks'd) AbsPath. A stable relative link must not be re-counted as
// "updated" on the second sync. Regression test for the agent-sync idempotency
// failure on macOS CI.
func TestSyncAgents_MergeMode_StableWhenSourceResolvesThroughSymlink(t *testing.T) {
base := t.TempDir()
real := filepath.Join(base, "real")
if err := os.MkdirAll(real, 0755); err != nil {
t.Fatal(err)
}
alias := filepath.Join(base, "alias")
if err := os.Symlink(real, alias); err != nil {
t.Fatal(err)
}
projectRoot := alias
sourceDir := filepath.Join(alias, ".skillshare", "agents")
targetDir := filepath.Join(alias, ".claude", "agents")
if err := os.MkdirAll(sourceDir, 0755); err != nil {
t.Fatal(err)
}
srcFile := filepath.Join(sourceDir, "reviewer.md")
if err := os.WriteFile(srcFile, []byte("# Reviewer"), 0644); err != nil {
t.Fatal(err)
}
// AbsPath mirrors real discovery, which resolves symlinked ancestors.
realSrc, err := filepath.EvalSymlinks(srcFile)
if err != nil {
t.Fatal(err)
}
agents := []resource.DiscoveredResource{
{FlatName: "reviewer.md", AbsPath: realSrc},
}
first, err := SyncAgents(agents, sourceDir, targetDir, "merge", false, false, projectRoot)
if err != nil {
t.Fatalf("first sync: %v", err)
}
if len(first.Updated) != 0 {
t.Fatalf("first sync should not update, got %#v", first)
}
second, err := SyncAgents(agents, sourceDir, targetDir, "merge", false, false, projectRoot)
if err != nil {
t.Fatalf("second sync: %v", err)
}
if len(second.Updated) != 0 {
t.Fatalf("second sync should be stable (0 updated), got %#v", second)
}
if len(second.Linked) != 1 {
t.Fatalf("second sync should re-link existing agent, got %#v", second)
}
}
func TestPullAgents_DryRun(t *testing.T) {
targetDir := t.TempDir()
os.WriteFile(filepath.Join(targetDir, "agent.md"), []byte("# Agent"), 0644)
collectDir := t.TempDir()
agents, err := FindLocalAgents(targetDir, collectDir)
if err != nil {
t.Fatalf("FindLocalAgents: %v", err)
}
result, err := PullAgents(agents, collectDir, PullOptions{DryRun: true})
if err != nil {
t.Fatalf("PullAgents dry-run: %v", err)
}
if len(result.Pulled) != 1 {
t.Fatalf("expected 1 collected in dry-run, got %d", len(result.Pulled))
}
// File should NOT exist (dry-run)
if _, err := os.Stat(filepath.Join(collectDir, "agent.md")); err == nil {
t.Error("file should not exist in dry-run")
}
}
// agentTransformFixture creates source agent tutor.md and returns it with an
// uppercasing spec, so any write-through to the source is visible.
func agentTransformFixture(t *testing.T) (string, []resource.DiscoveredResource, *ExtensionSpec) {
t.Helper()
sourceDir := t.TempDir()
src := filepath.Join(sourceDir, "tutor.md")
if err := os.WriteFile(src, []byte("body"), 0644); err != nil {
t.Fatal(err)
}
agents := []resource.DiscoveredResource{{FlatName: "tutor.md", RelPath: "tutor.md", AbsPath: src}}
spec := &ExtensionSpec{Run: []string{"tr", "a-z", "A-Z"}, Dir: sourceDir, Name: "upper"}
return sourceDir, agents, spec
}
func assertSourceUntouched(t *testing.T, sourceDir string) {
t.Helper()
data, err := os.ReadFile(filepath.Join(sourceDir, "tutor.md"))
if err != nil {
t.Fatal(err)
}
if string(data) != "body" {
t.Errorf("source agent overwritten: %q", data)
}
}
func TestSyncAgentsTransform_ReplacesLeftoverFileSymlink(t *testing.T) {
sourceDir, agents, spec := agentTransformFixture(t)
targetDir := t.TempDir()
// Left over from merge mode.
if err := os.Symlink(agents[0].AbsPath, filepath.Join(targetDir, "tutor.md")); err != nil {
t.Fatal(err)
}
if _, err := SyncAgentsTransform(agents, sourceDir, targetDir, "", spec, false, false); err != nil {
t.Fatal(err)
}
assertSourceUntouched(t, sourceDir)
}
func TestSyncAgentsTransform_ReplacesLeftoverDirSymlink(t *testing.T) {
sourceDir, agents, spec := agentTransformFixture(t)
targetDir := filepath.Join(t.TempDir(), "agents")
// Left over from symlink mode.
if err := os.Symlink(sourceDir, targetDir); err != nil {
t.Fatal(err)
}
if _, err := SyncAgentsTransform(agents, sourceDir, targetDir, "", spec, false, false); err != nil {
t.Fatal(err)
}
assertSourceUntouched(t, sourceDir)
}
func TestSyncAgentsTransform_FailureRemovesStaleOutput(t *testing.T) {
sourceDir, agents, _ := agentTransformFixture(t)
targetDir := t.TempDir()
stale := filepath.Join(targetDir, "tutor.md")
if err := os.WriteFile(stale, []byte("unconverted"), 0644); err != nil {
t.Fatal(err)
}
failing := &ExtensionSpec{Run: []string{"false"}, Dir: sourceDir, Name: "fail"}
if _, err := SyncAgentsTransform(agents, sourceDir, targetDir, "", failing, false, false); err == nil {
t.Fatal("expected conversion error")
}
if _, err := os.Lstat(stale); !os.IsNotExist(err) {
t.Error("an agent that fails to convert must not keep its old output")
}
}
func TestPruneOrphanAgentCopies_PrunesTransformedOrphans(t *testing.T) {
targetDir := t.TempDir()
orphan := filepath.Join(targetDir, "gone.toml")
if err := os.WriteFile(orphan, []byte("x"), 0644); err != nil {
t.Fatal(err)
}
if _, err := PruneOrphanAgentCopies(targetDir, nil, "toml", false); err != nil {
t.Fatal(err)
}
if _, err := os.Stat(orphan); !os.IsNotExist(err) {
t.Error("orphan gone.toml should be pruned")
}
}