package author import ( "crypto/sha256" "encoding/hex" "encoding/json" "fmt" "os" "os/exec" "path/filepath" ) var skillFiles = []string{"SKILL.md", "references/orchestration.md", "references/work.md", "references/queue.md", "references/debugging.md", "references/delivery.md", "references/format.md", "references/notifications.md", "references/operations.md", "references/transfer.md", "references/verification.md", "references/control.md", "references/harnesses.md", "references/access.md", "references/schedules.md"} func SkillDirectory() (string, error) { dir := os.Getenv("XDG_CONFIG_HOME") if dir == "" { home, err := os.UserHomeDir() if err != nil { return "", err } dir = filepath.Join(home, ".config") } return filepath.Abs(filepath.Join(dir, "opencode", "skills", "pipelines")) } func digest(data []byte) string { sum := sha256.Sum256(data); return hex.EncodeToString(sum[:]) } // ClaudeSkillDirectory is Claude Code's personal skill root. CLAUDE_CONFIG_DIR // wins for an isolated installation, matching the CLI itself; otherwise // ~/.claude is used when Claude Code is present. func ClaudeSkillDirectory() (string, bool) { if dir := os.Getenv("CLAUDE_CONFIG_DIR"); dir != "" { absolute, err := filepath.Abs(dir) if err != nil { return "", false } return filepath.Join(absolute, "skills", "pipelines"), true } home, err := os.UserHomeDir() if err != nil { return "", false } config := filepath.Join(home, ".claude") if info, err := os.Stat(config); err == nil && info.IsDir() { return filepath.Join(config, "skills", "pipelines"), true } if _, err := exec.LookPath("claude"); err == nil { return filepath.Join(config, "skills", "pipelines"), true } return "", false } // InstallSkill only updates files previously installed by Pipelines and unchanged // by the user. It never edits OpenCode config, login, or unrelated skills. func InstallSkill() (string, error) { dir, err := SkillDirectory() if err != nil { return "", err } if err := installSkillIn(dir); err != nil { return "", err } return dir, nil } // InstallClaudeSkill installs the same managed skill into Claude Code's skill // root when Claude Code is present. It returns "" when it is not installed. func InstallClaudeSkill() (string, error) { dir, ok := ClaudeSkillDirectory() if !ok { return "", nil } if err := installSkillIn(dir); err != nil { return "", err } return dir, nil } // InstallAllSkills refreshes every detected agent skill root with the bundled // workflow skill. A failure leaves the successful targets installed and names // the failure, so one harness cannot silently shadow another. func InstallAllSkills() ([]string, error) { installed := []string{} dir, err := InstallSkill() if err != nil { return installed, err } installed = append(installed, dir) claudeDir, err := InstallClaudeSkill() if err != nil { return installed, err } if claudeDir != "" { installed = append(installed, claudeDir) } return installed, nil } func installSkillIn(dir string) error { marker := filepath.Join(dir, ".pipelines-managed.json") if info, err := os.Lstat(marker); err == nil && !info.Mode().IsRegular() { return fmt.Errorf("refusing non-regular skill ownership marker %s", marker) } else if err != nil && !os.IsNotExist(err) { return err } previous := map[string]string{} if data, readErr := os.ReadFile(marker); readErr == nil { if err := json.Unmarshal(data, &previous); err != nil { return fmt.Errorf("invalid skill ownership marker: %w", err) } } else if !os.IsNotExist(readErr) { return readErr } files := map[string][]byte{} next := map[string]string{} for _, file := range skillFiles { data, err := content.ReadFile("skill/" + file) if err != nil { return err } files[file] = data next[file] = digest(data) path := filepath.Join(dir, file) if info, statErr := os.Lstat(path); statErr == nil { if !info.Mode().IsRegular() { return fmt.Errorf("refusing to replace non-regular skill file %s", path) } existing, err := os.ReadFile(path) if err != nil { return err } if previous[file] == "" || (digest(existing) != previous[file] && digest(existing) != next[file]) { return fmt.Errorf("skill file %s is user-managed or modified; preserve/rename it before installing the Pipelines skill", path) } } else if !os.IsNotExist(statErr) { return statErr } } // Record ownership before first creation so an interrupted installation can // safely resume missing files. Updates accept either old or bundled hashes. if len(previous) == 0 { if err := os.MkdirAll(dir, 0700); err != nil { return err } data, _ := json.MarshalIndent(next, "", " ") if err := writeSkillFile(marker, data); err != nil { return err } previous = next } for _, file := range skillFiles { path := filepath.Join(dir, file) if previous[file] == next[file] { if _, err := os.Stat(path); err == nil { continue } } if err := os.MkdirAll(filepath.Dir(path), 0700); err != nil { return err } if err := writeSkillFile(path, files[file]); err != nil { return err } } // A file the previous install managed but this version no longer bundles - a // reference renamed or withdrawn - is removed only when it is unmodified. A copy // the user edited is left alone, exactly as an edit to a live file is. for file, hash := range previous { if _, still := next[file]; still { continue } existing, readErr := os.ReadFile(filepath.Join(dir, file)) if readErr != nil { continue } if digest(existing) == hash { _ = os.Remove(filepath.Join(dir, file)) } } if len(previous) == len(next) { equal := true for file, hash := range next { if previous[file] != hash { equal = false } } if equal { return nil } } data, _ := json.MarshalIndent(next, "", " ") return writeSkillFile(marker, data) } func writeSkillFile(path string, data []byte) error { f, err := os.CreateTemp(filepath.Dir(path), ".pipelines-skill-*") if err != nil { return err } defer os.Remove(f.Name()) _, writeErr := f.Write(data) closeErr := f.Close() if writeErr != nil { return writeErr } if closeErr != nil { return closeErr } return os.Rename(f.Name(), path) } // ManagerSkillDirectory is the source-controlled Pipelines manager skill location. func ManagerSkillDirectory() (string, error) { dir := os.Getenv("XDG_CONFIG_HOME") if dir == "" { home, err := os.UserHomeDir() if err != nil { return "", err } dir = filepath.Join(home, ".config") } return filepath.Abs(filepath.Join(dir, "opencode", "skills", "pipelines-manager")) } // InstallManagerSkill installs only the dedicated manager skill. It refuses an // unmanaged or modified same-name skill and uses the same ownership marker and // atomic write protection as InstallSkill. func InstallManagerSkill() (string, error) { dir, err := ManagerSkillDirectory() if err != nil { return "", err } marker := filepath.Join(dir, ".pipelines-managed.json") if info, statErr := os.Lstat(marker); statErr == nil && !info.Mode().IsRegular() { return "", fmt.Errorf("refusing non-regular manager skill ownership marker %s", marker) } else if statErr != nil && !os.IsNotExist(statErr) { return "", statErr } previous := map[string]string{} if data, readErr := os.ReadFile(marker); readErr == nil { if err := json.Unmarshal(data, &previous); err != nil { return "", fmt.Errorf("invalid manager skill ownership marker: %w", err) } } else if !os.IsNotExist(readErr) { return "", readErr } data, err := content.ReadFile("manager/SKILL.md") if err != nil { return "", err } const file = "SKILL.md" next := digest(data) path := filepath.Join(dir, file) if info, statErr := os.Lstat(path); statErr == nil { if !info.Mode().IsRegular() { return "", fmt.Errorf("refusing to replace non-regular manager skill file %s", path) } existing, err := os.ReadFile(path) if err != nil { return "", err } if previous[file] == "" || (digest(existing) != previous[file] && digest(existing) != next) { return "", fmt.Errorf("manager skill file %s is user-managed or modified; preserve/rename it before installing the Pipelines manager skill", path) } } else if !os.IsNotExist(statErr) { return "", statErr } if err := os.MkdirAll(dir, 0700); err != nil { return "", err } // A managed file may have been deleted after the marker was written. The // marker proves ownership, but not that the target still exists; recreate a // missing file before leaving the marker unchanged. if previous[file] != next || !regularFile(path) { if err := writeSkillFile(path, data); err != nil { return "", err } } markerData, _ := json.MarshalIndent(map[string]string{file: next}, "", " ") if err := writeSkillFile(marker, markerData); err != nil { return "", err } return dir, nil } func regularFile(path string) bool { info, err := os.Stat(path) return err == nil && info.Mode().IsRegular() }