Self-hosted workflows for coding-agent delivery. Orchestrate CodeBuddy, Codex and Claude Code with scripts and human approval gates. Includes Local workflows for coding assistants.
JavaScript agent-orchestrationagentic-workflowai-agentsai-codingclaude-codecode-reviewcodebuddycodexcoding-agentscursordeveloper-toolshuman-on-the-loopllmmcpmulti-agentsdlcself-hostedsopworkflow-automationworkflow-engine
package managedcli
import (
"context"
"encoding/base64"
"encoding/json"
"errors"
"fmt"
"io"
"net/http"
"net/url"
"strings"
"time"
)
type release struct {
Name string `json:"name"`
Version string `json:"version"`
Deprecated string `json:"deprecated"`
Dist struct {
Integrity string `json:"integrity"`
} `json:"dist"`
Published time.Time `json:"-"`
}
type packageMetadata struct {
Name string `json:"name"`
Tags map[string]string `json:"dist-tags"`
Versions map[string]release `json:"versions"`
Times map[string]json.RawMessage `json:"time"`
}
func (m *Manager) candidate(ctx context.Context, provider string) (release, error) {
spec := providerSpecs[provider]
metadata, err := m.fetchPackageMetadata(ctx, spec.Package)
if err != nil {
return release{}, err
}
version := metadata.Tags["latest"]
if metadata.Name != spec.Package || !releaseVersion.MatchString(version) {
return release{}, errors.New("registry did not provide the expected package and a stable release version")
}
if mature := matureVersion(metadata, version, m.Now().Add(-observationWindow)); mature != "" {
version = mature
}
candidate, ok := metadata.Versions[version]
if !ok || candidate.Name != spec.Package || candidate.Version != version {
return release{}, errors.New("release missing or inconsistent in registry metadata")
}
if candidate.Deprecated != "" {
return release{}, errors.New("candidate release is deprecated")
}
if !validIntegrity(candidate.Dist.Integrity) {
return release{}, errors.New("candidate requires a valid SHA512 package integrity value")
}
if err := json.Unmarshal(metadata.Times[version], &candidate.Published); err != nil || candidate.Published.IsZero() {
return release{}, errors.New("candidate release has no valid publication time")
}
return candidate, nil
}
// fetchPackageMetadata downloads and decodes the full npm registry document
// for pkg.
func (m *Manager) fetchPackageMetadata(ctx context.Context, pkg string) (packageMetadata, error) {
endpoint := npmRegistry + "/" + url.PathEscape(pkg)
request, err := http.NewRequestWithContext(ctx, http.MethodGet, endpoint, nil)
if err != nil {
return packageMetadata{}, err
}
// The full metadata includes publish times; abbreviated install metadata
// does not, and would silently defeat the observation window.
request.Header.Set("Accept", "application/json")
response, err := m.Client.Do(request)
if err != nil {
return packageMetadata{}, fmt.Errorf("fetch package metadata: %w", err)
}
defer response.Body.Close()
if response.StatusCode != http.StatusOK {
return packageMetadata{}, fmt.Errorf("package metadata HTTP %d", response.StatusCode)
}
const limit = 64 << 20
data, err := io.ReadAll(io.LimitReader(response.Body, limit+1))
if err != nil {
return packageMetadata{}, err
}
if len(data) > limit {
return packageMetadata{}, errors.New("package metadata exceeds size limit")
}
var metadata packageMetadata
if err := json.Unmarshal(data, &metadata); err != nil {
return packageMetadata{}, fmt.Errorf("invalid package metadata: %w", err)
}
return metadata, nil
}
// matureVersion returns the newest stable, non-deprecated release no newer
// than upper that was published before cutoff, or "" when none qualifies.
//
// Fast-moving CLIs may publish several times a day. Merely rejecting an
// immature latest tag would then postpone updates forever. Selecting the
// newest mature stable release, bounded by the official latest tag, keeps
// updates flowing while versions published only to another channel cannot
// leak in.
func matureVersion(metadata packageMetadata, upper string, cutoff time.Time) string {
mature := ""
for v, entry := range metadata.Versions {
if !releaseVersion.MatchString(v) || compareVersions(v, upper) > 0 || entry.Deprecated != "" {
continue
}
var published time.Time
if err := json.Unmarshal(metadata.Times[v], &published); err != nil || published.IsZero() || published.After(cutoff) {
continue
}
if mature == "" || compareVersions(v, mature) > 0 {
mature = v
}
}
return mature
}
func validIntegrity(value string) bool {
if !strings.HasPrefix(value, "sha512-") {
return false
}
decoded, err := base64.StdEncoding.DecodeString(strings.TrimPrefix(value, "sha512-"))
return err == nil && len(decoded) == 64
}
func compareVersions(a, b string) int {
left, right := strings.Split(a, "."), strings.Split(b, ".")
for i := 0; i < 3; i++ {
if len(left[i]) < len(right[i]) {
return -1
}
if len(left[i]) > len(right[i]) {
return 1
}
if cmp := strings.Compare(left[i], right[i]); cmp != 0 {
return cmp
}
}
return 0
}