diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..1a8b915 --- /dev/null +++ b/.gitignore @@ -0,0 +1,17 @@ +# Go +*.exe +*.exe~ +*.dll +*.so +*.dylib +*.test +*.out +vendor/ +# Flox +.flox/ +# IDEs +.idea/ +.vscode/ +*.swp +*.swo +*~ diff --git a/README.md b/README.md index 9994b60..c6dcc08 100644 --- a/README.md +++ b/README.md @@ -1,32 +1,76 @@ -# ScobleClaw +# floxenv -Agentic engineering framework by **[Scott Scoble](https://scott.scoble.me)** — tools, workflows, and skills for building with AI agents. +Go package for managing Flox environment lifecycles via `flox activate --detach`. -## What Is ScobleClaw? +## Features -ScobleClaw is a monorepo for agentic engineering patterns used across Scott Scoble's open-source projects. It provides: +- **Activate** — start a Flox environment and return an `envID` + PID. +- **Deactivate** — graceful shutdown with `SIGTERM` then `SIGKILL` after a 10-second grace period. +- **IsAlive** — lightweight, non-privileged process-existence check using zero-signal delivery. +- **Dev-mode stub** — transparently falls back to a long-running shell command when `flox` is not installed (or when `FLOXENV_DEV_MODE=1` is set), useful for CI and local development. -- **Subagent dispatch** patterns for structured AI agent workflows -- **Skill-based development** with reusable, composable AI context modules -- **Provenance tracking** for auditable agent outputs and decisions -- **Cross-repo tooling** shared across Speckl, brand-site, beyond-the-prompt, and more +## Installation -## Projects +```bash +go get github.com/marcus/scobleclaw/pkg/floxenv +``` -| Project | Description | Author | -|---------|-------------|--------| -| [Speckl](https://speckl.scoble.me) | Spec language compiler with embedded provenance | Scott Scoble | -| [Brand Site](https://scott.scoble.me) | Professional speaker website | Scott Scoble | -| [Beyond the Prompt](https://os.scoble.me/forgejo/sscoble/beyond-the-prompt) | Workshop: Lessons from building with Claude Code | Scott Scoble | +## Usage -## Author +```go +package main -Created and maintained by **Scott Scoble** — builder, speaker, and AI agentics engineer. +import ( + "fmt" + "log" -- Website: [scott.scoble.me](https://scott.scoble.me) -- LinkedIn: [scottscoble](https://linkedin.com/in/scottscoble) -- GitHub: [sscoble](https://github.com/sscoble) + "github.com/marcus/scobleclaw/pkg/floxenv" +) + +func main() { + r := floxenv.NewRegistry() + + envID, pid, err := r.Activate("/path/to/env/.flox/env/manifest.toml") + if err != nil { + log.Fatal(err) + } + fmt.Printf("activated %s (pid %d)\n", envID, pid) + + // later … + if err := r.Deactivate(envID, pid); err != nil { + log.Fatal(err) + } +} +``` + +## Dev mode + +When the `flox` binary is absent, or when `FLOXENV_DEV_MODE=1` is set in the environment, the package runs a lightweight stub that forks a shell `sleep` process instead of invoking `flox activate`. This keeps dependent tests green in environments where Flox is not available. + +## Running tests + +Unit tests (uses the dev-mode stub): + +```bash +go test ./pkg/floxenv +``` + +Integration tests (requires a working Flox installation): + +```bash +go test -tags=integration ./pkg/floxenv +``` + +## API + +| Function | Signature | Description | +|----------|-----------|-------------| +| `NewRegistry` | `() *Registry` | Create a new registry, auto-detecting dev mode. | +| `(*Registry) Activate` | `(manifestPath string) (envID string, pid int, err error)` | Activate a Flox environment. | +| `(*Registry) Deactivate` | `(envID string, pid int) error` | Shutdown an active environment. | +| `IsAlive` | `(pid int) bool` | Non-privileged process existence check. | +| `(*Registry) List` | `() []Info` | Snapshot of tracked environments. | ## License -MIT © Scott Scoble / Greybeard Holdings, LLC +MIT diff --git a/go.mod b/go.mod new file mode 100644 index 0000000..f96fce1 --- /dev/null +++ b/go.mod @@ -0,0 +1,3 @@ +module github.com/marcus/scobleclaw + +go 1.26.3 diff --git a/kubeclaw/Makefile b/kubeclaw/Makefile new file mode 100644 index 0000000..53d6ce2 --- /dev/null +++ b/kubeclaw/Makefile @@ -0,0 +1,45 @@ +# Build and development commands for kubeclaw operator + +.PHONY: generate +generate: + controller-gen object:headerFile="hack/boilerplate.go.txt" paths="./api/..." + +.PHONY: manifests +manifests: generate + controller-gen rbac:roleName=kubeclaw-manager crd:maxDescLen=0,outputDir=config/crd webhook paths="./..." + +.PHONY: install +install: manifests + kubectl apply -f config/crd/ + +.PHONY: uninstall +uninstall: + kubectl delete -f config/crd/ + +.PHONY: run +run: generate + go run ./main.go + +.PHONY: test +test: generate + go test ./... -v -count=1 + +.PHONY: test-integration +test-integration: + go test ./... -tags=integration -v -count=1 + +.PHONY: test-e2e +test-e2e: + go test ./... -tags=e2e -v -count=1 + +.PHONY: docker-build +docker-build: + docker build -t kubeclaw/controller:latest . + +.PHONY: helm-package +helm-package: + helm package ./charts/kubeclaw + +.PHONY: deploy +deploy: docker-build helm-package + helm upgrade --install kubeclaw ./charts/kubeclaw --namespace kubeclaw-system --create-namespace diff --git a/kubeclaw/api/v1alpha1/groupversion.go b/kubeclaw/api/v1alpha1/groupversion.go new file mode 100644 index 0000000..211e32f --- /dev/null +++ b/kubeclaw/api/v1alpha1/groupversion.go @@ -0,0 +1,16 @@ +// +kubebuilder:object:generate=true +// +groupName=kubeclaw.nousresearch.com +package v1alpha1 + +import ( + "k8s.io/apimachinery/pkg/runtime/schema" + "sigs.k8s.io/controller-runtime/pkg/scheme" +) + +var ( + GroupVersion = schema.GroupVersion{Group: "kubeclaw.nousresearch.com", Version: "v1alpha1"} + + SchemeBuilder = &scheme.Builder{GroupVersion: GroupVersion} + + AddToScheme = SchemeBuilder.AddToScheme +) diff --git a/kubeclaw/api/v1alpha1/types.go b/kubeclaw/api/v1alpha1/types.go new file mode 100644 index 0000000..98884aa --- /dev/null +++ b/kubeclaw/api/v1alpha1/types.go @@ -0,0 +1,330 @@ +package v1alpha1 + +import ( + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" +) + +// ProviderSpec defines the desired state of an LLM provider. +type ProviderSpec struct { + Type string `json:"type"` + BaseURL string `json:"baseURL"` + APIKeyRef SecretRef `json:"apiKeyRef"` + Models []ModelSpec `json:"models,omitempty"` + DefaultModel string `json:"defaultModel,omitempty"` +} + +type SecretRef struct { + Name string `json:"name"` + Key string `json:"key"` +} + +type ModelSpec struct { + Name string `json:"name"` + ContextWindow int `json:"contextWindow"` + CostPer1KInput float64 `json:"costPer1KInput"` + CostPer1KOutput float64 `json:"costPer1KOutput"` +} + +// +kubebuilder:object:root=true +// +kubebuilder:resource:scope=Cluster +type Provider struct { + metav1.TypeMeta `json:",inline"` + metav1.ObjectMeta `json:"metadata,omitempty"` + Spec ProviderSpec `json:"spec,omitempty"` +} + +// +kubebuilder:object:root=true +type ProviderList struct { + metav1.TypeMeta `json:",inline"` + metav1.ListMeta `json:"metadata,omitempty"` + Items []Provider `json:"items"` +} + +// ChannelSpec defines a platform channel binding. +type ChannelSpec struct { + Platform string `json:"platform"` + BotTokenRef SecretRef `json:"botTokenRef"` + GuildID string `json:"guildID"` + AllowedChannels []string `json:"allowedChannels,omitempty"` +} + +// +kubebuilder:object:root=true +// +kubebuilder:resource:scope=Namespaced +type Channel struct { + metav1.TypeMeta `json:",inline"` + metav1.ObjectMeta `json:"metadata,omitempty"` + Spec ChannelSpec `json:"spec,omitempty"` +} + +// +kubebuilder:object:root=true +type ChannelList struct { + metav1.TypeMeta `json:",inline"` + metav1.ListMeta `json:"metadata,omitempty"` + Items []Channel `json:"items"` +} + +// AgentConfigSpec defines reusable agent configuration. +type AgentConfigSpec struct { + Workspace WorkspaceSpec `json:"workspace,omitempty"` + Memory MemorySpec `json:"memory,omitempty"` + Skills []SkillRef `json:"skills,omitempty"` + Sandbox SandboxSpec `json:"sandbox,omitempty"` + Resources ResourceSpec `json:"resources,omitempty"` +} + +type WorkspaceSpec struct { + MountPath string `json:"mountPath"` + Size string `json:"size"` +} + +type MemorySpec struct { + Enabled bool `json:"enabled"` + RetentionDays int `json:"retentionDays"` +} + +type SkillRef struct { + ID string `json:"id"` + Version string `json:"version"` +} + +type SandboxSpec struct { + Type string `json:"type"` + NetworkPolicy string `json:"networkPolicy"` +} + +type ResourceSpec struct { + CPU string `json:"cpu"` + Memory string `json:"memory"` + GPU int `json:"gpu"` +} + +// +kubebuilder:object:root=true +// +kubebuilder:resource:scope=Namespaced +type AgentConfig struct { + metav1.TypeMeta `json:",inline"` + metav1.ObjectMeta `json:"metadata,omitempty"` + Spec AgentConfigSpec `json:"spec,omitempty"` +} + +// +kubebuilder:object:root=true +type AgentConfigList struct { + metav1.TypeMeta `json:",inline"` + metav1.ListMeta `json:"metadata,omitempty"` + Items []AgentConfig `json:"items"` +} + +// AgentSpec defines the desired state of an agent deployment. +type AgentSpec struct { + Identity AgentIdentity `json:"identity"` + Config AgentConfigRef `json:"config"` + Providers []ProviderRef `json:"providers,omitempty"` + Channels []ChannelRef `json:"channels,omitempty"` + WorkflowTemplates []TemplateRef `json:"workflowTemplates,omitempty"` + CompliancePolicies []PolicyRef `json:"compliancePolicies,omitempty"` + Judge JudgeConfig `json:"judge,omitempty"` +} + +type AgentIdentity struct { + DisplayName string `json:"displayName"` + Description string `json:"description"` + Owner string `json:"owner"` +} + +type AgentConfigRef struct { + AgentConfigRef LocalRef `json:"agentConfigRef"` + Overrides *ResourceSpec `json:"overrides,omitempty"` +} + +type ProviderRef struct { + Ref LocalRef `json:"ref"` + Model string `json:"model,omitempty"` +} + +type ChannelRef struct { + Ref LocalRef `json:"ref"` +} + +type TemplateRef struct { + Ref LocalRef `json:"ref"` +} + +type PolicyRef struct { + Ref LocalRef `json:"ref"` +} + +type LocalRef struct { + Name string `json:"name"` +} + +type JudgeConfig struct { + Enabled bool `json:"enabled"` + ProviderRef LocalRef `json:"providerRef,omitempty"` + Model string `json:"model,omitempty"` +} + +type AgentStatus struct { + Conditions []metav1.Condition `json:"conditions,omitempty"` + ObservedGeneration int64 `json:"observedGeneration"` + AgentPodRef *LocalRef `json:"agentPodRef,omitempty"` + LastWorkflowCount int `json:"lastWorkflowCount,omitempty"` + LastJudgeVerdict string `json:"lastJudgeVerdict,omitempty"` +} + +// +kubebuilder:object:root=true +// +kubebuilder:subresource:status +// +kubebuilder:resource:scope=Namespaced +type Agent struct { + metav1.TypeMeta `json:",inline"` + metav1.ObjectMeta `json:"metadata,omitempty"` + Spec AgentSpec `json:"spec,omitempty"` + Status AgentStatus `json:"status,omitempty"` +} + +// +kubebuilder:object:root=true +type AgentList struct { + metav1.TypeMeta `json:",inline"` + metav1.ListMeta `json:"metadata,omitempty"` + Items []Agent `json:"items"` +} + +type AgentGroupSpec struct { + SharedConfig AgentGroupSharedConfig `json:"sharedConfig"` + Members []AgentGroupMember `json:"members"` +} + +type AgentGroupSharedConfig struct { + AgentConfigRef LocalRef `json:"agentConfigRef"` + Providers []ProviderRef `json:"providers,omitempty"` + Channels []ChannelRef `json:"channels,omitempty"` +} + +type AgentGroupMember struct { + Name string `json:"name"` + Overrides AgentGroupOverrides `json:"overrides,omitempty"` +} + +type AgentGroupOverrides struct { + Channels []ChannelRef `json:"channels,omitempty"` +} + +// +kubebuilder:object:root=true +// +kubebuilder:subresource:status +// +kubebuilder:resource:scope=Namespaced +type AgentGroup struct { + metav1.TypeMeta `json:",inline"` + metav1.ObjectMeta `json:"metadata,omitempty"` + Spec AgentGroupSpec `json:"spec,omitempty"` +} + +// +kubebuilder:object:root=true +type AgentGroupList struct { + metav1.TypeMeta `json:",inline"` + metav1.ListMeta `json:"metadata,omitempty"` + Items []AgentGroup `json:"items"` +} + +type WorkflowTemplateSpec struct { + Description string `json:"description"` + Version string `json:"version"` + Parameters []WorkflowParam `json:"parameters,omitempty"` + Steps []WorkflowStep `json:"steps"` + Output WorkflowOutput `json:"output,omitempty"` + Compliance ComplianceSpec `json:"compliance,omitempty"` +} + +type WorkflowParam struct { + Name string `json:"name"` + Type string `json:"type"` + Required bool `json:"required"` + Description string `json:"description,omitempty"` + Default interface{} `json:"default,omitempty"` + Minimum *int `json:"minimum,omitempty"` + Maximum *int `json:"maximum,omitempty"` +} + +type WorkflowStep struct { + ID string `json:"id"` + Action string `json:"action"` + Input string `json:"input"` + Limit string `json:"limit,omitempty"` +} + +type WorkflowOutput struct { + Type string `json:"type"` + Schema *SchemaDef `json:"schema,omitempty"` +} + +type SchemaDef struct { + Type string `json:"type"` + Items *SchemaDef `json:"items,omitempty"` + Properties map[string]SchemaProp `json:"properties,omitempty"` +} + +type SchemaProp struct { + Type string `json:"type"` +} + +type ComplianceSpec struct { + RequiredFrameworks []string `json:"requiredFrameworks"` + DataClassification string `json:"dataClassification"` +} + +// +kubebuilder:object:root=true +// +kubebuilder:resource:scope=Cluster +type WorkflowTemplate struct { + metav1.TypeMeta `json:",inline"` + metav1.ObjectMeta `json:"metadata,omitempty"` + Spec WorkflowTemplateSpec `json:"spec,omitempty"` +} + +// +kubebuilder:object:root=true +type WorkflowTemplateList struct { + metav1.TypeMeta `json:",inline"` + metav1.ListMeta `json:"metadata,omitempty"` + Items []WorkflowTemplate `json:"items"` +} + +type CompliancePolicySpec struct { + Framework string `json:"framework"` + Version string `json:"version"` + Rules []ComplianceRule `json:"rules"` + Escalation EscalationSpec `json:"escalation,omitempty"` +} + +type ComplianceRule struct { + ID string `json:"id"` + Severity string `json:"severity"` + Description string `json:"description"` + Eval string `json:"eval"` + OnViolation string `json:"onViolation"` +} + +type EscalationSpec struct { + OnReject string `json:"onReject,omitempty"` + OnError string `json:"onError,omitempty"` +} + +// +kubebuilder:object:root=true +// +kubebuilder:resource:scope=Cluster +type CompliancePolicy struct { + metav1.TypeMeta `json:",inline"` + metav1.ObjectMeta `json:"metadata,omitempty"` + Spec CompliancePolicySpec `json:"spec,omitempty"` +} + +// +kubebuilder:object:root=true +type CompliancePolicyList struct { + metav1.TypeMeta `json:",inline"` + metav1.ListMeta `json:"metadata,omitempty"` + Items []CompliancePolicy `json:"items"` +} + +func init() { + SchemeBuilder.Register(&Provider{}, &ProviderList{}) + SchemeBuilder.Register(&Channel{}, &ChannelList{}) + SchemeBuilder.Register(&AgentConfig{}, &AgentConfigList{}) + SchemeBuilder.Register(&Agent{}, &AgentList{}) + SchemeBuilder.Register(&AgentGroup{}, &AgentGroupList{}) + SchemeBuilder.Register(&WorkflowTemplate{}, &WorkflowTemplateList{}) + SchemeBuilder.Register(&CompliancePolicy{}, &CompliancePolicyList{}) +} diff --git a/kubeclaw/api/v1alpha1/zz_generated.deepcopy.go b/kubeclaw/api/v1alpha1/zz_generated.deepcopy.go new file mode 100644 index 0000000..e671c8f --- /dev/null +++ b/kubeclaw/api/v1alpha1/zz_generated.deepcopy.go @@ -0,0 +1,1048 @@ +//go:build !ignore_autogenerated +// +build !ignore_autogenerated + +// kubeclaw — OpenClaw operator for Kubernetes +// Copyright © 2026 Scott Scoble / Greybeard Holdings, LLC + +// Code generated by controller-gen. DO NOT EDIT. + +package v1alpha1 + +import ( + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + runtime "k8s.io/apimachinery/pkg/runtime" +) + +// DeepCopyInto copies all pointer and value fields into the receiver. +func (in *Agent) DeepCopyInto(out *Agent) { + *out = *in + out.TypeMeta = in.TypeMeta + in.ObjectMeta.DeepCopyInto(&out.ObjectMeta) + in.Spec.DeepCopyInto(&out.Spec) + in.Status.DeepCopyInto(&out.Status) +} + +// DeepCopy copies all pointer and value fields. +func (in *Agent) DeepCopy() *Agent { + if in == nil { + return nil + } + out := new(Agent) + in.DeepCopyInto(out) + return out +} + +// DeepCopyObject is a runtime.Object interface implementation. +func (in *Agent) DeepCopyObject() runtime.Object { + if c := in.DeepCopy(); c != nil { + return c + } + return nil +} + +// DeepCopyInto copies all pointer and value fields into the receiver. +func (in *AgentConfig) DeepCopyInto(out *AgentConfig) { + *out = *in + out.TypeMeta = in.TypeMeta + in.ObjectMeta.DeepCopyInto(&out.ObjectMeta) + in.Spec.DeepCopyInto(&out.Spec) +} + +// DeepCopy copies all pointer and value fields. +func (in *AgentConfig) DeepCopy() *AgentConfig { + if in == nil { + return nil + } + out := new(AgentConfig) + in.DeepCopyInto(out) + return out +} + +// DeepCopyObject is a runtime.Object interface implementation. +func (in *AgentConfig) DeepCopyObject() runtime.Object { + if c := in.DeepCopy(); c != nil { + return c + } + return nil +} + +// DeepCopyInto copies all pointer and value fields. +func (in *AgentConfigList) DeepCopyInto(out *AgentConfigList) { + *out = *in + out.TypeMeta = in.TypeMeta + in.ListMeta.DeepCopyInto(&out.ListMeta) + if in.Items != nil { + in, out := &in.Items, &out.Items + *out = make([]AgentConfig, len(*in)) + for i := range *in { + (*in)[i].DeepCopyInto(&(*out)[i]) + } + } +} + +// DeepCopy copies all pointer and value fields. +func (in *AgentConfigList) DeepCopy() *AgentConfigList { + if in == nil { + return nil + } + out := new(AgentConfigList) + in.DeepCopyInto(out) + return out +} + +// DeepCopyObject is a runtime.Object interface implementation. +func (in *AgentConfigList) DeepCopyObject() runtime.Object { + if c := in.DeepCopy(); c != nil { + return c + } + return nil +} + +// DeepCopyInto copies all pointer and value fields. +func (in *AgentConfigRef) DeepCopyInto(out *AgentConfigRef) { + *out = *in + in.AgentConfigRef.DeepCopyInto(&out.AgentConfigRef) + if in.Overrides != nil { + in, out := &in.Overrides, &out.Overrides + *out = new(ResourceSpec) + **out = **in + } +} + +// DeepCopy copies all pointer and value fields. +func (in *AgentConfigRef) DeepCopy() *AgentConfigRef { + if in == nil { + return nil + } + out := new(AgentConfigRef) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto copies all pointer and value fields. +func (in *AgentConfigSpec) DeepCopyInto(out *AgentConfigSpec) { + *out = *in + out.Workspace = in.Workspace + out.Memory = in.Memory + if in.Skills != nil { + in, out := &in.Skills, &out.Skills + *out = make([]SkillRef, len(*in)) + copy(*out, *in) + } + out.Sandbox = in.Sandbox + out.Resources = in.Resources +} + +// DeepCopy copies all pointer and value fields. +func (in *AgentConfigSpec) DeepCopy() *AgentConfigSpec { + if in == nil { + return nil + } + out := new(AgentConfigSpec) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto copies all pointer and value fields. +func (in *AgentGroup) DeepCopyInto(out *AgentGroup) { + *out = *in + out.TypeMeta = in.TypeMeta + in.ObjectMeta.DeepCopyInto(&out.ObjectMeta) + in.Spec.DeepCopyInto(&out.Spec) +} + +// DeepCopy copies all pointer and value fields. +func (in *AgentGroup) DeepCopy() *AgentGroup { + if in == nil { + return nil + } + out := new(AgentGroup) + in.DeepCopyInto(out) + return out +} + +// DeepCopyObject is a runtime.Object interface implementation. +func (in *AgentGroup) DeepCopyObject() runtime.Object { + if c := in.DeepCopy(); c != nil { + return c + } + return nil +} + +// DeepCopyInto copies all pointer and value fields. +func (in *AgentGroupList) DeepCopyInto(out *AgentGroupList) { + *out = *in + out.TypeMeta = in.TypeMeta + in.ListMeta.DeepCopyInto(&out.ListMeta) + if in.Items != nil { + in, out := &in.Items, &out.Items + *out = make([]AgentGroup, len(*in)) + for i := range *in { + (*in)[i].DeepCopyInto(&(*out)[i]) + } + } +} + +// DeepCopy copies all pointer and value fields. +func (in *AgentGroupList) DeepCopy() *AgentGroupList { + if in == nil { + return nil + } + out := new(AgentGroupList) + in.DeepCopyInto(out) + return out +} + +// DeepCopyObject is a runtime.Object interface implementation. +func (in *AgentGroupList) DeepCopyObject() runtime.Object { + if c := in.DeepCopy(); c != nil { + return c + } + return nil +} + +// DeepCopyInto copies all pointer and value fields. +func (in *AgentGroupMember) DeepCopyInto(out *AgentGroupMember) { + *out = *in + in.Overrides.DeepCopyInto(&out.Overrides) +} + +// DeepCopy copies all pointer and value fields. +func (in *AgentGroupMember) DeepCopy() *AgentGroupMember { + if in == nil { + return nil + } + out := new(AgentGroupMember) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto copies all pointer and value fields. +func (in *AgentGroupOverrides) DeepCopyInto(out *AgentGroupOverrides) { + *out = *in + if in.Channels != nil { + in, out := &in.Channels, &out.Channels + *out = make([]ChannelRef, len(*in)) + copy(*out, *in) + } +} + +// DeepCopy copies all pointer and value fields. +func (in *AgentGroupOverrides) DeepCopy() *AgentGroupOverrides { + if in == nil { + return nil + } + out := new(AgentGroupOverrides) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto copies all pointer and value fields. +func (in *AgentGroupSharedConfig) DeepCopyInto(out *AgentGroupSharedConfig) { + *out = *in + in.AgentConfigRef.DeepCopyInto(&out.AgentConfigRef) + if in.Providers != nil { + in, out := &in.Providers, &out.Providers + *out = make([]ProviderRef, len(*in)) + copy(*out, *in) + } + if in.Channels != nil { + in, out := &in.Channels, &out.Channels + *out = make([]ChannelRef, len(*in)) + copy(*out, *in) + } +} + +// DeepCopy copies all pointer and value fields. +func (in *AgentGroupSharedConfig) DeepCopy() *AgentGroupSharedConfig { + if in == nil { + return nil + } + out := new(AgentGroupSharedConfig) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto copies all pointer and value fields. +func (in *AgentGroupSpec) DeepCopyInto(out *AgentGroupSpec) { + *out = *in + in.SharedConfig.DeepCopyInto(&out.SharedConfig) + if in.Members != nil { + in, out := &in.Members, &out.Members + *out = make([]AgentGroupMember, len(*in)) + for i := range *in { + (*in)[i].DeepCopyInto(&(*out)[i]) + } + } +} + +// DeepCopy copies all pointer and value fields. +func (in *AgentGroupSpec) DeepCopy() *AgentGroupSpec { + if in == nil { + return nil + } + out := new(AgentGroupSpec) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto copies all pointer and value fields. +func (in *AgentIdentity) DeepCopyInto(out *AgentIdentity) { + *out = *in +} + +// DeepCopy copies all pointer and value fields. +func (in *AgentIdentity) DeepCopy() *AgentIdentity { + if in == nil { + return nil + } + out := new(AgentIdentity) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto copies all pointer and value fields. +func (in *AgentList) DeepCopyInto(out *AgentList) { + *out = *in + out.TypeMeta = in.TypeMeta + in.ListMeta.DeepCopyInto(&out.ListMeta) + if in.Items != nil { + in, out := &in.Items, &out.Items + *out = make([]Agent, len(*in)) + for i := range *in { + (*in)[i].DeepCopyInto(&(*out)[i]) + } + } +} + +// DeepCopy copies all pointer and value fields. +func (in *AgentList) DeepCopy() *AgentList { + if in == nil { + return nil + } + out := new(AgentList) + in.DeepCopyInto(out) + return out +} + +// DeepCopyObject is a runtime.Object interface implementation. +func (in *AgentList) DeepCopyObject() runtime.Object { + if c := in.DeepCopy(); c != nil { + return c + } + return nil +} + +// DeepCopyInto copies all pointer and value fields. +func (in *AgentSpec) DeepCopyInto(out *AgentSpec) { + *out = *in + out.Identity = in.Identity + in.Config.DeepCopyInto(&out.Config) + if in.Providers != nil { + in, out := &in.Providers, &out.Providers + *out = make([]ProviderRef, len(*in)) + copy(*out, *in) + } + if in.Channels != nil { + in, out := &in.Channels, &out.Channels + *out = make([]ChannelRef, len(*in)) + copy(*out, *in) + } + if in.WorkflowTemplates != nil { + in, out := &in.WorkflowTemplates, &out.WorkflowTemplates + *out = make([]TemplateRef, len(*in)) + copy(*out, *in) + } + if in.CompliancePolicies != nil { + in, out := &in.CompliancePolicies, &out.CompliancePolicies + *out = make([]PolicyRef, len(*in)) + copy(*out, *in) + } + out.Judge = in.Judge +} + +// DeepCopy copies all pointer and value fields. +func (in *AgentSpec) DeepCopy() *AgentSpec { + if in == nil { + return nil + } + out := new(AgentSpec) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto copies all pointer and value fields. +func (in *AgentStatus) DeepCopyInto(out *AgentStatus) { + *out = *in + if in.Conditions != nil { + in, out := &in.Conditions, &out.Conditions + *out = make([]metav1.Condition, len(*in)) + for i := range *in { + (*in)[i].DeepCopyInto(&(*out)[i]) + } + } + if in.AgentPodRef != nil { + in, out := &in.AgentPodRef, &out.AgentPodRef + *out = new(LocalRef) + **out = **in + } +} + +// DeepCopy copies all pointer and value fields. +func (in *AgentStatus) DeepCopy() *AgentStatus { + if in == nil { + return nil + } + out := new(AgentStatus) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto copies all pointer and value fields. +func (in *Channel) DeepCopyInto(out *Channel) { + *out = *in + out.TypeMeta = in.TypeMeta + in.ObjectMeta.DeepCopyInto(&out.ObjectMeta) + in.Spec.DeepCopyInto(&out.Spec) +} + +// DeepCopy copies all pointer and value fields. +func (in *Channel) DeepCopy() *Channel { + if in == nil { + return nil + } + out := new(Channel) + in.DeepCopyInto(out) + return out +} + +// DeepCopyObject is a runtime.Object interface implementation. +func (in *Channel) DeepCopyObject() runtime.Object { + if c := in.DeepCopy(); c != nil { + return c + } + return nil +} + +// DeepCopyInto copies all pointer and value fields. +func (in *ChannelList) DeepCopyInto(out *ChannelList) { + *out = *in + out.TypeMeta = in.TypeMeta + in.ListMeta.DeepCopyInto(&out.ListMeta) + if in.Items != nil { + in, out := &in.Items, &out.Items + *out = make([]Channel, len(*in)) + for i := range *in { + (*in)[i].DeepCopyInto(&(*out)[i]) + } + } +} + +// DeepCopy copies all pointer and value fields. +func (in *ChannelList) DeepCopy() *ChannelList { + if in == nil { + return nil + } + out := new(ChannelList) + in.DeepCopyInto(out) + return out +} + +// DeepCopyObject is a runtime.Object interface implementation. +func (in *ChannelList) DeepCopyObject() runtime.Object { + if c := in.DeepCopy(); c != nil { + return c + } + return nil +} + +// DeepCopyInto copies all pointer and value fields. +func (in *ChannelRef) DeepCopyInto(out *ChannelRef) { + *out = *in +} + +// DeepCopy copies all pointer and value fields. +func (in *ChannelRef) DeepCopy() *ChannelRef { + if in == nil { + return nil + } + out := new(ChannelRef) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto copies all pointer and value fields. +func (in *ChannelSpec) DeepCopyInto(out *ChannelSpec) { + *out = *in + if in.AllowedChannels != nil { + in, out := &in.AllowedChannels, &out.AllowedChannels + *out = make([]string, len(*in)) + copy(*out, *in) + } +} + +// DeepCopy copies all pointer and value fields. +func (in *ChannelSpec) DeepCopy() *ChannelSpec { + if in == nil { + return nil + } + out := new(ChannelSpec) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto copies all pointer and value fields. +func (in *CompliancePolicy) DeepCopyInto(out *CompliancePolicy) { + *out = *in + out.TypeMeta = in.TypeMeta + in.ObjectMeta.DeepCopyInto(&out.ObjectMeta) + in.Spec.DeepCopyInto(&out.Spec) +} + +// DeepCopy copies all pointer and value fields. +func (in *CompliancePolicy) DeepCopy() *CompliancePolicy { + if in == nil { + return nil + } + out := new(CompliancePolicy) + in.DeepCopyInto(out) + return out +} + +// DeepCopyObject is a runtime.Object interface implementation. +func (in *CompliancePolicy) DeepCopyObject() runtime.Object { + if c := in.DeepCopy(); c != nil { + return c + } + return nil +} + +// DeepCopyInto copies all pointer and value fields. +func (in *CompliancePolicyList) DeepCopyInto(out *CompliancePolicyList) { + *out = *in + out.TypeMeta = in.TypeMeta + in.ListMeta.DeepCopyInto(&out.ListMeta) + if in.Items != nil { + in, out := &in.Items, &out.Items + *out = make([]CompliancePolicy, len(*in)) + for i := range *in { + (*in)[i].DeepCopyInto(&(*out)[i]) + } + } +} + +// DeepCopy copies all pointer and value fields. +func (in *CompliancePolicyList) DeepCopy() *CompliancePolicyList { + if in == nil { + return nil + } + out := new(CompliancePolicyList) + in.DeepCopyInto(out) + return out +} + +// DeepCopyObject is a runtime.Object interface implementation. +func (in *CompliancePolicyList) DeepCopyObject() runtime.Object { + if c := in.DeepCopy(); c != nil { + return c + } + return nil +} + +// DeepCopyInto copies all pointer and value fields. +func (in *CompliancePolicySpec) DeepCopyInto(out *CompliancePolicySpec) { + *out = *in + if in.Rules != nil { + in, out := &in.Rules, &out.Rules + *out = make([]ComplianceRule, len(*in)) + copy(*out, *in) + } + out.Escalation = in.Escalation +} + +// DeepCopy copies all pointer and value fields. +func (in *CompliancePolicySpec) DeepCopy() *CompliancePolicySpec { + if in == nil { + return nil + } + out := new(CompliancePolicySpec) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto copies all pointer and value fields. +func (in *ComplianceRule) DeepCopyInto(out *ComplianceRule) { + *out = *in +} + +// DeepCopy copies all pointer and value fields. +func (in *ComplianceRule) DeepCopy() *ComplianceRule { + if in == nil { + return nil + } + out := new(ComplianceRule) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto copies all pointer and value fields. +func (in *EscalationSpec) DeepCopyInto(out *EscalationSpec) { + *out = *in +} + +// DeepCopy copies all pointer and value fields. +func (in *EscalationSpec) DeepCopy() *EscalationSpec { + if in == nil { + return nil + } + out := new(EscalationSpec) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto copies all pointer and value fields. +func (in *JudgeConfig) DeepCopyInto(out *JudgeConfig) { + *out = *in +} + +// DeepCopy copies all pointer and value fields. +func (in *JudgeConfig) DeepCopy() *JudgeConfig { + if in == nil { + return nil + } + out := new(JudgeConfig) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto copies all pointer and value fields. +func (in *LocalRef) DeepCopyInto(out *LocalRef) { + *out = *in +} + +// DeepCopy copies all pointer and value fields. +func (in *LocalRef) DeepCopy() *LocalRef { + if in == nil { + return nil + } + out := new(LocalRef) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto copies all pointer and value fields. +func (in *MemorySpec) DeepCopyInto(out *MemorySpec) { + *out = *in +} + +// DeepCopy copies all pointer and value fields. +func (in *MemorySpec) DeepCopy() *MemorySpec { + if in == nil { + return nil + } + out := new(MemorySpec) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto copies all pointer and value fields. +func (in *ModelSpec) DeepCopyInto(out *ModelSpec) { + *out = *in +} + +// DeepCopy copies all pointer and value fields. +func (in *ModelSpec) DeepCopy() *ModelSpec { + if in == nil { + return nil + } + out := new(ModelSpec) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto copies all pointer and value fields. +func (in *PolicyRef) DeepCopyInto(out *PolicyRef) { + *out = *in +} + +// DeepCopy copies all pointer and value fields. +func (in *PolicyRef) DeepCopy() *PolicyRef { + if in == nil { + return nil + } + out := new(PolicyRef) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto copies all pointer and value fields. +func (in *Provider) DeepCopyInto(out *Provider) { + *out = *in + out.TypeMeta = in.TypeMeta + in.ObjectMeta.DeepCopyInto(&out.ObjectMeta) + in.Spec.DeepCopyInto(&out.Spec) +} + +// DeepCopy copies all pointer and value fields. +func (in *Provider) DeepCopy() *Provider { + if in == nil { + return nil + } + out := new(Provider) + in.DeepCopyInto(out) + return out +} + +// DeepCopyObject is a runtime.Object interface implementation. +func (in *Provider) DeepCopyObject() runtime.Object { + if c := in.DeepCopy(); c != nil { + return c + } + return nil +} + +// DeepCopyInto copies all pointer and value fields. +func (in *ProviderList) DeepCopyInto(out *ProviderList) { + *out = *in + out.TypeMeta = in.TypeMeta + in.ListMeta.DeepCopyInto(&out.ListMeta) + if in.Items != nil { + in, out := &in.Items, &out.Items + *out = make([]Provider, len(*in)) + for i := range *in { + (*in)[i].DeepCopyInto(&(*out)[i]) + } + } +} + +// DeepCopy copies all pointer and value fields. +func (in *ProviderList) DeepCopy() *ProviderList { + if in == nil { + return nil + } + out := new(ProviderList) + in.DeepCopyInto(out) + return out +} + +// DeepCopyObject is a runtime.Object interface implementation. +func (in *ProviderList) DeepCopyObject() runtime.Object { + if c := in.DeepCopy(); c != nil { + return c + } + return nil +} + +// DeepCopyInto copies all pointer and value fields. +func (in *ProviderRef) DeepCopyInto(out *ProviderRef) { + *out = *in +} + +// DeepCopy copies all pointer and value fields. +func (in *ProviderRef) DeepCopy() *ProviderRef { + if in == nil { + return nil + } + out := new(ProviderRef) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto copies all pointer and value fields. +func (in *ProviderSpec) DeepCopyInto(out *ProviderSpec) { + *out = *in + if in.Models != nil { + in, out := &in.Models, &out.Models + *out = make([]ModelSpec, len(*in)) + copy(*out, *in) + } +} + +// DeepCopy copies all pointer and value fields. +func (in *ProviderSpec) DeepCopy() *ProviderSpec { + if in == nil { + return nil + } + out := new(ProviderSpec) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto copies all pointer and value fields. +func (in *ResourceSpec) DeepCopyInto(out *ResourceSpec) { + *out = *in +} + +// DeepCopy copies all pointer and value fields. +func (in *ResourceSpec) DeepCopy() *ResourceSpec { + if in == nil { + return nil + } + out := new(ResourceSpec) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto copies all pointer and value fields. +func (in *SandboxSpec) DeepCopyInto(out *SandboxSpec) { + *out = *in +} + +// DeepCopy copies all pointer and value fields. +func (in *SandboxSpec) DeepCopy() *SandboxSpec { + if in == nil { + return nil + } + out := new(SandboxSpec) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto copies all pointer and value fields. +func (in *SchemaDef) DeepCopyInto(out *SchemaDef) { + *out = *in + if in.Items != nil { + in, out := &in.Items, &out.Items + *out = new(SchemaDef) + (*in).DeepCopyInto(*out) + } + if in.Properties != nil { + in, out := &in.Properties, &out.Properties + *out = make(map[string]SchemaProp, len(*in)) + for key, val := range *in { + (*out)[key] = val + } + } +} + +// DeepCopy copies all pointer and value fields. +func (in *SchemaDef) DeepCopy() *SchemaDef { + if in == nil { + return nil + } + out := new(SchemaDef) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto copies all pointer and value fields. +func (in *SchemaProp) DeepCopyInto(out *SchemaProp) { + *out = *in +} + +// DeepCopy copies all pointer and value fields. +func (in *SchemaProp) DeepCopy() *SchemaProp { + if in == nil { + return nil + } + out := new(SchemaProp) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto copies all pointer and value fields. +func (in *SecretRef) DeepCopyInto(out *SecretRef) { + *out = *in +} + +// DeepCopy copies all pointer and value fields. +func (in *SecretRef) DeepCopy() *SecretRef { + if in == nil { + return nil + } + out := new(SecretRef) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto copies all pointer and value fields. +func (in *SkillRef) DeepCopyInto(out *SkillRef) { + *out = *in +} + +// DeepCopy copies all pointer and value fields. +func (in *SkillRef) DeepCopy() *SkillRef { + if in == nil { + return nil + } + out := new(SkillRef) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto copies all pointer and value fields. +func (in *TemplateRef) DeepCopyInto(out *TemplateRef) { + *out = *in +} + +// DeepCopy copies all pointer and value fields. +func (in *TemplateRef) DeepCopy() *TemplateRef { + if in == nil { + return nil + } + out := new(TemplateRef) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto copies all pointer and value fields. +func (in *WorkflowOutput) DeepCopyInto(out *WorkflowOutput) { + *out = *in + if in.Schema != nil { + in, out := &in.Schema, &out.Schema + *out = new(SchemaDef) + (*in).DeepCopyInto(*out) + } +} + +// DeepCopy copies all pointer and value fields. +func (in *WorkflowOutput) DeepCopy() *WorkflowOutput { + if in == nil { + return nil + } + out := new(WorkflowOutput) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto copies all pointer and value fields. +func (in *WorkflowParam) DeepCopyInto(out *WorkflowParam) { + *out = *in + if in.Minimum != nil { + in, out := &in.Minimum, &out.Minimum + *out = new(int) + **out = **in + } + if in.Maximum != nil { + in, out := &in.Maximum, &out.Maximum + *out = new(int) + **out = **in + } +} + +// DeepCopy copies all pointer and value fields. +func (in *WorkflowParam) DeepCopy() *WorkflowParam { + if in == nil { + return nil + } + out := new(WorkflowParam) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto copies all pointer and value fields. +func (in *WorkflowStep) DeepCopyInto(out *WorkflowStep) { + *out = *in +} + +// DeepCopy copies all pointer and value fields. +func (in *WorkflowStep) DeepCopy() *WorkflowStep { + if in == nil { + return nil + } + out := new(WorkflowStep) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto copies all pointer and value fields. +func (in *WorkflowTemplate) DeepCopyInto(out *WorkflowTemplate) { + *out = *in + out.TypeMeta = in.TypeMeta + in.ObjectMeta.DeepCopyInto(&out.ObjectMeta) + in.Spec.DeepCopyInto(&out.Spec) +} + +// DeepCopy copies all pointer and value fields. +func (in *WorkflowTemplate) DeepCopy() *WorkflowTemplate { + if in == nil { + return nil + } + out := new(WorkflowTemplate) + in.DeepCopyInto(out) + return out +} + +// DeepCopyObject is a runtime.Object interface implementation. +func (in *WorkflowTemplate) DeepCopyObject() runtime.Object { + if c := in.DeepCopy(); c != nil { + return c + } + return nil +} + +// DeepCopyInto copies all pointer and value fields. +func (in *WorkflowTemplateList) DeepCopyInto(out *WorkflowTemplateList) { + *out = *in + out.TypeMeta = in.TypeMeta + in.ListMeta.DeepCopyInto(&out.ListMeta) + if in.Items != nil { + in, out := &in.Items, &out.Items + *out = make([]WorkflowTemplate, len(*in)) + for i := range *in { + (*in)[i].DeepCopyInto(&(*out)[i]) + } + } +} + +// DeepCopy copies all pointer and value fields. +func (in *WorkflowTemplateList) DeepCopy() *WorkflowTemplateList { + if in == nil { + return nil + } + out := new(WorkflowTemplateList) + in.DeepCopyInto(out) + return out +} + +// DeepCopyObject is a runtime.Object interface implementation. +func (in *WorkflowTemplateList) DeepCopyObject() runtime.Object { + if c := in.DeepCopy(); c != nil { + return c + } + return nil +} + +// DeepCopyInto copies all pointer and value fields. +func (in *WorkflowTemplateSpec) DeepCopyInto(out *WorkflowTemplateSpec) { + *out = *in + if in.Parameters != nil { + in, out := &in.Parameters, &out.Parameters + *out = make([]WorkflowParam, len(*in)) + for i := range *in { + (*in)[i].DeepCopyInto(&(*out)[i]) + } + } + if in.Steps != nil { + in, out := &in.Steps, &out.Steps + *out = make([]WorkflowStep, len(*in)) + copy(*out, *in) + } + in.Output.DeepCopyInto(&out.Output) + out.Compliance = in.Compliance +} + +// DeepCopy copies all pointer and value fields. +func (in *WorkflowTemplateSpec) DeepCopy() *WorkflowTemplateSpec { + if in == nil { + return nil + } + out := new(WorkflowTemplateSpec) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto copies all pointer and value fields. +func (in *WorkspaceSpec) DeepCopyInto(out *WorkspaceSpec) { + *out = *in +} + +// DeepCopy copies all pointer and value fields. +func (in *WorkspaceSpec) DeepCopy() *WorkspaceSpec { + if in == nil { + return nil + } + out := new(WorkspaceSpec) + in.DeepCopyInto(out) + return out +} diff --git a/kubeclaw/config/pool-manager/configmap.yaml b/kubeclaw/config/pool-manager/configmap.yaml new file mode 100644 index 0000000..8c551cd --- /dev/null +++ b/kubeclaw/config/pool-manager/configmap.yaml @@ -0,0 +1,61 @@ +apiVersion: v1 +kind: ConfigMap +metadata: + name: pool-manager-harness + namespace: scobleclaw +data: + harness.yaml: | + pools: + billing: + manifest: ./envs/billing + queue: work:billing + spares: 2 + max_busy: 5 + ttl: 3600 + devops: + manifest: ./envs/devops + queue: work:devops + spares: 1 + max_busy: 3 + ttl: 7200 + content: + manifest: ./envs/content + queue: work:content + spares: 3 + max_busy: 10 + ttl: 1800 + verifier: + manifest: ./envs/verify + queue: work:verify + spares: 1 + max_busy: 2 + ttl: 3600 + routes: + "billing.invoice": "billing" + "billing.report": "billing" + "deploy.service": "devops" + "deploy.monitor": "devops" + "draft.blog-post": "content" + "draft.changelog": "content" + "draft.newsletter": "content" + "verify.security": "verifier" + "verify.compliance": "verifier" + "billing.*": "billing" + "deploy.*": "devops" + "draft.*": "content" + "verify.*": "verifier" + pipelines: + full_deploy: + stages: + - pool: content + next_queue: work:deploy + - pool: devops + next_queue: work:verify + - pool: verifier + next_queue: "" + generate_bill: + stages: + - pool: content + next_queue: work:billing + - pool: billing + next_queue: "" diff --git a/kubeclaw/config/pool-manager/deployment.yaml b/kubeclaw/config/pool-manager/deployment.yaml new file mode 100644 index 0000000..201c7cd --- /dev/null +++ b/kubeclaw/config/pool-manager/deployment.yaml @@ -0,0 +1,78 @@ +apiVersion: apps/v1 +kind: Deployment +metadata: + name: pool-manager + namespace: scobleclaw + labels: + app: pool-manager +spec: + replicas: 1 + selector: + matchLabels: + app: pool-manager + template: + metadata: + labels: + app: pool-manager + spec: + containers: + - name: pool-manager + image: localhost:5000/pool-manager:latest + imagePullPolicy: Always + ports: + - containerPort: 3990 + name: http + env: + - name: PORT + value: "3990" + - name: HOST + value: "0.0.0.0" + - name: POOL_CONFIG + value: "/app/harness.yaml" + volumeMounts: + - name: harness-config + mountPath: /app/harness.yaml + subPath: harness.yaml + livenessProbe: + httpGet: + path: /healthz + port: http + initialDelaySeconds: 5 + periodSeconds: 10 + failureThreshold: 3 + readinessProbe: + httpGet: + path: /healthz + port: http + initialDelaySeconds: 2 + periodSeconds: 5 + failureThreshold: 3 + resources: + requests: + memory: "32Mi" + cpu: "50m" + limits: + memory: "128Mi" + cpu: "250m" + volumes: + - name: harness-config + configMap: + name: pool-manager-harness + defaultMode: 0444 +--- +apiVersion: v1 +kind: Service +metadata: + name: pool-manager + namespace: scobleclaw + labels: + app: pool-manager +spec: + type: ClusterIP + selector: + app: pool-manager + ports: + - name: http + port: 3990 + targetPort: 3990 + protocol: TCP diff --git a/kubeclaw/config/pool-manager/namespace.yaml b/kubeclaw/config/pool-manager/namespace.yaml new file mode 100644 index 0000000..d748269 --- /dev/null +++ b/kubeclaw/config/pool-manager/namespace.yaml @@ -0,0 +1,4 @@ +apiVersion: v1 +kind: Namespace +metadata: + name: scobleclaw diff --git a/kubeclaw/go.mod b/kubeclaw/go.mod new file mode 100644 index 0000000..840804d --- /dev/null +++ b/kubeclaw/go.mod @@ -0,0 +1,67 @@ +module github.com/nousresearch/kubeclaw + +go 1.22.0 + +require ( + k8s.io/api v0.30.0 + k8s.io/apimachinery v0.30.0 + k8s.io/client-go v0.30.0 + sigs.k8s.io/controller-runtime v0.18.0 +) + +require ( + github.com/beorn7/perks v1.0.1 // indirect + github.com/cespare/xxhash/v2 v2.2.0 // indirect + github.com/davecgh/go-spew v1.1.1 // indirect + github.com/emicklei/go-restful/v3 v3.11.0 // indirect + github.com/evanphx/json-patch/v5 v5.9.0 // indirect + github.com/fsnotify/fsnotify v1.7.0 // indirect + github.com/go-logr/logr v1.4.1 // indirect + github.com/go-logr/zapr v1.3.0 // indirect + github.com/go-openapi/jsonpointer v0.19.6 // indirect + github.com/go-openapi/jsonreference v0.20.2 // indirect + github.com/go-openapi/swag v0.22.3 // indirect + github.com/gogo/protobuf v1.3.2 // indirect + github.com/golang/groupcache v0.0.0-20210331224755-41bb18bfe9da // indirect + github.com/golang/protobuf v1.5.4 // indirect + github.com/google/gnostic-models v0.6.8 // indirect + github.com/google/go-cmp v0.6.0 // indirect + github.com/google/gofuzz v1.2.0 // indirect + github.com/google/uuid v1.3.0 // indirect + github.com/imdario/mergo v0.3.6 // indirect + github.com/josharian/intern v1.0.0 // indirect + github.com/json-iterator/go v1.1.12 // indirect + github.com/mailru/easyjson v0.7.7 // indirect + github.com/matttproud/golang_protobuf_extensions v1.0.4 // indirect + github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd // indirect + github.com/modern-go/reflect2 v1.0.2 // indirect + github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822 // indirect + github.com/pkg/errors v0.9.1 // indirect + github.com/prometheus/client_golang v1.16.0 // indirect + github.com/prometheus/client_model v0.4.0 // indirect + github.com/prometheus/common v0.44.0 // indirect + github.com/prometheus/procfs v0.12.0 // indirect + github.com/spf13/pflag v1.0.5 // indirect + go.uber.org/multierr v1.11.0 // indirect + go.uber.org/zap v1.26.0 // indirect + golang.org/x/exp v0.0.0-20220722155223-a9213eeb770e // indirect + golang.org/x/net v0.23.0 // indirect + golang.org/x/oauth2 v0.12.0 // indirect + golang.org/x/sys v0.18.0 // indirect + golang.org/x/term v0.18.0 // indirect + golang.org/x/text v0.14.0 // indirect + golang.org/x/time v0.3.0 // indirect + gomodules.xyz/jsonpatch/v2 v2.4.0 // indirect + google.golang.org/appengine v1.6.7 // indirect + google.golang.org/protobuf v1.33.0 // indirect + gopkg.in/inf.v0 v0.9.1 // indirect + gopkg.in/yaml.v2 v2.4.0 // indirect + gopkg.in/yaml.v3 v3.0.1 // indirect + k8s.io/apiextensions-apiserver v0.30.0 // indirect + k8s.io/klog/v2 v2.120.1 // indirect + k8s.io/kube-openapi v0.0.0-20240228011516-70dd3763d340 // indirect + k8s.io/utils v0.0.0-20230726121419-3b25d923346b // indirect + sigs.k8s.io/json v0.0.0-20221116044647-bc3834ca7abd // indirect + sigs.k8s.io/structured-merge-diff/v4 v4.4.1 // indirect + sigs.k8s.io/yaml v1.3.0 // indirect +) diff --git a/kubeclaw/go.sum b/kubeclaw/go.sum new file mode 100644 index 0000000..fb54cf4 --- /dev/null +++ b/kubeclaw/go.sum @@ -0,0 +1,194 @@ +github.com/beorn7/perks v1.0.1 h1:VlbKKnNfV8bJzeqoa4cOKqO6bYr3WgKZxO8Z16+hsOM= +github.com/beorn7/perks v1.0.1/go.mod h1:G2ZrVWU2WbWT9wwq4/hrbKbnv/1ERSJQ0ibhJ6rlkpw= +github.com/cespare/xxhash/v2 v2.2.0 h1:DC2CZ1Ep5Y4k3ZQ899DldepgrayRUGE6BBZ/cd9Cj44= +github.com/cespare/xxhash/v2 v2.2.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs= +github.com/creack/pty v1.1.9/go.mod h1:oKZEueFk5CKHvIhNR5MUki03XCEU+Q6VDXinZuGJ33E= +github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c= +github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/emicklei/go-restful/v3 v3.11.0 h1:rAQeMHw1c7zTmncogyy8VvRZwtkmkZ4FxERmMY4rD+g= +github.com/emicklei/go-restful/v3 v3.11.0/go.mod h1:6n3XBCmQQb25CM2LCACGz8ukIrRry+4bhvbpWn3mrbc= +github.com/evanphx/json-patch v4.12.0+incompatible h1:4onqiflcdA9EOZ4RxV643DvftH5pOlLGNtQ5lPWQu84= +github.com/evanphx/json-patch v4.12.0+incompatible/go.mod h1:50XU6AFN0ol/bzJsmQLiYLvXMP4fmwYFNcr97nuDLSk= +github.com/evanphx/json-patch/v5 v5.9.0 h1:kcBlZQbplgElYIlo/n1hJbls2z/1awpXxpRi0/FOJfg= +github.com/evanphx/json-patch/v5 v5.9.0/go.mod h1:VNkHZ/282BpEyt/tObQO8s5CMPmYYq14uClGH4abBuQ= +github.com/fsnotify/fsnotify v1.7.0 h1:8JEhPFa5W2WU7YfeZzPNqzMP6Lwt7L2715Ggo0nosvA= +github.com/fsnotify/fsnotify v1.7.0/go.mod h1:40Bi/Hjc2AVfZrqy+aj+yEI+/bRxZnMJyTJwOpGvigM= +github.com/go-logr/logr v1.4.1 h1:pKouT5E8xu9zeFC39JXRDukb6JFQPXM5p5I91188VAQ= +github.com/go-logr/logr v1.4.1/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY= +github.com/go-logr/zapr v1.3.0 h1:XGdV8XW8zdwFiwOA2Dryh1gj2KRQyOOoNmBy4EplIcQ= +github.com/go-logr/zapr v1.3.0/go.mod h1:YKepepNBd1u/oyhd/yQmtjVXmm9uML4IXUgMOwR8/Gg= +github.com/go-openapi/jsonpointer v0.19.6 h1:eCs3fxoIi3Wh6vtgmLTOjdhSpiqphQ+DaPn38N2ZdrE= +github.com/go-openapi/jsonpointer v0.19.6/go.mod h1:osyAmYz/mB/C3I+WsTTSgw1ONzaLJoLCyoi6/zppojs= +github.com/go-openapi/jsonreference v0.20.2 h1:3sVjiK66+uXK/6oQ8xgcRKcFgQ5KXa2KvnJRumpMGbE= +github.com/go-openapi/jsonreference v0.20.2/go.mod h1:Bl1zwGIM8/wsvqjsOQLJ/SH+En5Ap4rVB5KVcIDZG2k= +github.com/go-openapi/swag v0.22.3 h1:yMBqmnQ0gyZvEb/+KzuWZOXgllrXT4SADYbvDaXHv/g= +github.com/go-openapi/swag v0.22.3/go.mod h1:UzaqsxGiab7freDnrUUra0MwWfN/q7tE4j+VcZ0yl14= +github.com/go-task/slim-sprig v0.0.0-20230315185526-52ccab3ef572 h1:tfuBGBXKqDEevZMzYi5KSi8KkcZtzBcTgAUUtapy0OI= +github.com/go-task/slim-sprig v0.0.0-20230315185526-52ccab3ef572/go.mod h1:9Pwr4B2jHnOSGXyyzV8ROjYa2ojvAY6HCGYYfMoC3Ls= +github.com/gogo/protobuf v1.3.2 h1:Ov1cvc58UF3b5XjBnZv7+opcTcQFZebYjWzi34vdm4Q= +github.com/gogo/protobuf v1.3.2/go.mod h1:P1XiOD3dCwIKUDQYPy72D8LYyHL2YPYrpS2s69NZV8Q= +github.com/golang/groupcache v0.0.0-20210331224755-41bb18bfe9da h1:oI5xCqsCo564l8iNU+DwB5epxmsaqB+rhGL0m5jtYqE= +github.com/golang/groupcache v0.0.0-20210331224755-41bb18bfe9da/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc= +github.com/golang/protobuf v1.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U= +github.com/golang/protobuf v1.3.1/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U= +github.com/golang/protobuf v1.5.4 h1:i7eJL8qZTpSEXOPTxNKhASYpMn+8e5Q6AdndVa1dWek= +github.com/golang/protobuf v1.5.4/go.mod h1:lnTiLA8Wa4RWRcIUkrtSVa5nRhsEGBg48fD6rSs7xps= +github.com/google/gnostic-models v0.6.8 h1:yo/ABAfM5IMRsS1VnXjTBvUb61tFIHozhlYvRgGre9I= +github.com/google/gnostic-models v0.6.8/go.mod h1:5n7qKqH0f5wFt+aWF8CW6pZLLNOfYuF5OpfBSENuI8U= +github.com/google/go-cmp v0.5.9/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY= +github.com/google/go-cmp v0.6.0 h1:ofyhxvXcZhMsU5ulbFiLKl/XBFqE1GSq7atu8tAmTRI= +github.com/google/go-cmp v0.6.0/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY= +github.com/google/gofuzz v1.0.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg= +github.com/google/gofuzz v1.2.0 h1:xRy4A+RhZaiKjJ1bPfwQ8sedCA+YS2YcCHW6ec7JMi0= +github.com/google/gofuzz v1.2.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg= +github.com/google/pprof v0.0.0-20210720184732-4bb14d4b1be1 h1:K6RDEckDVWvDI9JAJYCmNdQXq6neHJOYx3V6jnqNEec= +github.com/google/pprof v0.0.0-20210720184732-4bb14d4b1be1/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE= +github.com/google/uuid v1.3.0 h1:t6JiXgmwXMjEs8VusXIJk2BXHsn+wx8BZdTaoZ5fu7I= +github.com/google/uuid v1.3.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= +github.com/imdario/mergo v0.3.6 h1:xTNEAn+kxVO7dTZGu0CegyqKZmoWFI0rF8UxjlB2d28= +github.com/imdario/mergo v0.3.6/go.mod h1:2EnlNZ0deacrJVfApfmtdGgDfMuh/nq6Ok1EcJh5FfA= +github.com/josharian/intern v1.0.0 h1:vlS4z54oSdjm0bgjRigI+G1HpF+tI+9rE5LLzOg8HmY= +github.com/josharian/intern v1.0.0/go.mod h1:5DoeVV0s6jJacbCEi61lwdGj/aVlrQvzHFFd8Hwg//Y= +github.com/json-iterator/go v1.1.12 h1:PV8peI4a0ysnczrg+LtxykD8LfKY9ML6u2jnxaEnrnM= +github.com/json-iterator/go v1.1.12/go.mod h1:e30LSqwooZae/UwlEbR2852Gd8hjQvJoHmT4TnhNGBo= +github.com/kisielk/errcheck v1.5.0/go.mod h1:pFxgyoBC7bSaBwPgfKdkLd5X25qrDl4LWUI2bnpBCr8= +github.com/kisielk/gotool v1.0.0/go.mod h1:XhKaO+MFFWcvkIS/tQcRk01m1F5IRFswLeQ+oQHNcck= +github.com/kr/pretty v0.2.1/go.mod h1:ipq/a2n7PKx3OHsz4KJII5eveXtPO4qwEXGdVfWzfnI= +github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE= +github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk= +github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ= +github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI= +github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY= +github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE= +github.com/mailru/easyjson v0.7.7 h1:UGYAvKxe3sBsEDzO8ZeWOSlIQfWFlxbzLZe7hwFURr0= +github.com/mailru/easyjson v0.7.7/go.mod h1:xzfreul335JAWq5oZzymOObrkdz5UnU4kGfJJLY9Nlc= +github.com/matttproud/golang_protobuf_extensions v1.0.4 h1:mmDVorXM7PCGKw94cs5zkfA9PSy5pEvNWRP0ET0TIVo= +github.com/matttproud/golang_protobuf_extensions v1.0.4/go.mod h1:BSXmuO+STAnVfrANrmjBb36TMTDstsz7MSK+HVaYKv4= +github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q= +github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd h1:TRLaZ9cD/w8PVh93nsPXa1VrQ6jlwL5oN8l14QlcNfg= +github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q= +github.com/modern-go/reflect2 v1.0.2 h1:xBagoLtFs94CBntxluKeaWgTMpvLxC4ur3nMaC9Gz0M= +github.com/modern-go/reflect2 v1.0.2/go.mod h1:yWuevngMOJpCy52FWWMvUC8ws7m/LJsjYzDa0/r8luk= +github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822 h1:C3w9PqII01/Oq1c1nUAm88MOHcQC9l5mIlSMApZMrHA= +github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822/go.mod h1:+n7T8mK8HuQTcFwEeznm/DIxMOiR9yIdICNftLE1DvQ= +github.com/onsi/ginkgo/v2 v2.17.1 h1:V++EzdbhI4ZV4ev0UTIj0PzhzOcReJFyJaLjtSF55M8= +github.com/onsi/ginkgo/v2 v2.17.1/go.mod h1:llBI3WDLL9Z6taip6f33H76YcWtJv+7R3HigUjbIBOs= +github.com/onsi/gomega v1.32.0 h1:JRYU78fJ1LPxlckP6Txi/EYqJvjtMrDC04/MM5XRHPk= +github.com/onsi/gomega v1.32.0/go.mod h1:a4x4gW6Pz2yK1MAmvluYme5lvYTn61afQ2ETw/8n4Lg= +github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4= +github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0= +github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM= +github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= +github.com/prometheus/client_golang v1.16.0 h1:yk/hx9hDbrGHovbci4BY+pRMfSuuat626eFsHb7tmT8= +github.com/prometheus/client_golang v1.16.0/go.mod h1:Zsulrv/L9oM40tJ7T815tM89lFEugiJ9HzIqaAx4LKc= +github.com/prometheus/client_model v0.4.0 h1:5lQXD3cAg1OXBf4Wq03gTrXHeaV0TQvGfUooCfx1yqY= +github.com/prometheus/client_model v0.4.0/go.mod h1:oMQmHW1/JoDwqLtg57MGgP/Fb1CJEYF2imWWhWtMkYU= +github.com/prometheus/common v0.44.0 h1:+5BrQJwiBB9xsMygAB3TNvpQKOwlkc25LbISbrdOOfY= +github.com/prometheus/common v0.44.0/go.mod h1:ofAIvZbQ1e/nugmZGz4/qCb9Ap1VoSTIO7x0VV9VvuY= +github.com/prometheus/procfs v0.12.0 h1:jluTpSng7V9hY0O2R9DzzJHYb2xULk9VTR1V1R/k6Bo= +github.com/prometheus/procfs v0.12.0/go.mod h1:pcuDEFsWDnvcgNzo4EEweacyhjeA9Zk3cnaOZAZEfOo= +github.com/rogpeppe/go-internal v1.10.0 h1:TMyTOH3F/DB16zRVcYyreMH6GnZZrwQVAoYjRBZyWFQ= +github.com/rogpeppe/go-internal v1.10.0/go.mod h1:UQnix2H7Ngw/k4C5ijL5+65zddjncjaFoBhdsK/akog= +github.com/spf13/pflag v1.0.5 h1:iy+VFUOCP1a+8yFto/drg2CJ5u0yRoB7fZw3DKv/JXA= +github.com/spf13/pflag v1.0.5/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg= +github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= +github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw= +github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo= +github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI= +github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= +github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU= +github.com/stretchr/testify v1.8.1/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4= +github.com/stretchr/testify v1.8.4 h1:CcVxjf3Q8PM0mHUKJCdn+eZZtm5yQwehR5yeSVQQcUk= +github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo= +github.com/yuin/goldmark v1.1.27/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74= +github.com/yuin/goldmark v1.2.1/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74= +go.uber.org/goleak v1.3.0 h1:2K3zAYmnTNqV73imy9J1T3WC+gmCePx2hEGkimedGto= +go.uber.org/goleak v1.3.0/go.mod h1:CoHD4mav9JJNrW/WLlf7HGZPjdw8EucARQHekz1X6bE= +go.uber.org/multierr v1.11.0 h1:blXXJkSxSSfBVBlC76pxqeO+LN3aDfLQo+309xJstO0= +go.uber.org/multierr v1.11.0/go.mod h1:20+QtiLqy0Nd6FdQB9TLXag12DsQkrbs3htMFfDN80Y= +go.uber.org/zap v1.26.0 h1:sI7k6L95XOKS281NhVKOFCUNIvv9e0w4BF8N3u+tCRo= +go.uber.org/zap v1.26.0/go.mod h1:dtElttAiwGvoJ/vj4IwHBS/gXsEu/pZ50mUIRWuG0so= +golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w= +golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= +golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto= +golang.org/x/exp v0.0.0-20220722155223-a9213eeb770e h1:+WEEuIdZHnUeJJmEUjyYC2gfUMj69yZXw17EnHg/otA= +golang.org/x/exp v0.0.0-20220722155223-a9213eeb770e/go.mod h1:Kr81I6Kryrl9sr8s2FK3vxD90NdsKWRuOIl2O4CvYbA= +golang.org/x/mod v0.2.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= +golang.org/x/mod v0.3.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= +golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= +golang.org/x/net v0.0.0-20190603091049-60506f45cf65/go.mod h1:HSz+uSET+XFnRR8LxR5pz3Of3rY3CfYBVs4xY44aLks= +golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= +golang.org/x/net v0.0.0-20200226121028-0de0cce0169b/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= +golang.org/x/net v0.0.0-20201021035429-f5854403a974/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU= +golang.org/x/net v0.23.0 h1:7EYJ93RZ9vYSZAIb2x3lnuvqO5zneoD6IvWjuhfxjTs= +golang.org/x/net v0.23.0/go.mod h1:JKghWKKOSdJwpW2GEx0Ja7fmaKnMsbu+MWVZTokSYmg= +golang.org/x/oauth2 v0.12.0 h1:smVPGxink+n1ZI5pkQa8y6fZT0RW0MgCO5bFpepy4B4= +golang.org/x/oauth2 v0.12.0/go.mod h1:A74bZ3aGXgCY0qaIC9Ahg6Lglin4AMAco8cIv9baba4= +golang.org/x/sync v0.0.0-20181221193216-37e7f081c4d4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.0.0-20201020160332-67f06af15bc9/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= +golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.18.0 h1:DBdB3niSjOA/O0blCZBqDefyWNYveAYMNF1Wum0DYQ4= +golang.org/x/sys v0.18.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA= +golang.org/x/term v0.18.0 h1:FcHjZXDMxI8mM3nwhX9HlKop4C0YQvCVCdwYl2wOtE8= +golang.org/x/term v0.18.0/go.mod h1:ILwASektA3OnRv7amZ1xhE/KTR+u50pbXfZ03+6Nx58= +golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= +golang.org/x/text v0.3.2/go.mod h1:bEr9sfX3Q8Zfm5fL9x+3itogRgK3+ptLWKqgva+5dAk= +golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= +golang.org/x/text v0.14.0 h1:ScX5w1eTa3QqT8oi6+ziP7dTV1S2+ALU0bI+0zXKWiQ= +golang.org/x/text v0.14.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU= +golang.org/x/time v0.3.0 h1:rg5rLMjNzMS1RkNLzCG38eapWhnYLFYXDXj2gOlr8j4= +golang.org/x/time v0.3.0/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ= +golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= +golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= +golang.org/x/tools v0.0.0-20200619180055-7c47624df98f/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE= +golang.org/x/tools v0.0.0-20210106214847-113979e3529a/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA= +golang.org/x/tools v0.18.0 h1:k8NLag8AGHnn+PHbl7g43CtqZAwG60vZkLqgyZgIHgQ= +golang.org/x/tools v0.18.0/go.mod h1:GL7B4CwcLLeo59yx/9UWWuNOW1n3VZ4f5axWfML7Lcg= +golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= +golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= +golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= +golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= +gomodules.xyz/jsonpatch/v2 v2.4.0 h1:Ci3iUJyx9UeRx7CeFN8ARgGbkESwJK+KB9lLcWxY/Zw= +gomodules.xyz/jsonpatch/v2 v2.4.0/go.mod h1:AH3dM2RI6uoBZxn3LVrfvJ3E0/9dG4cSrbuBJT4moAY= +google.golang.org/appengine v1.6.7 h1:FZR1q0exgwxzPzp/aF+VccGrSfxfPpkBqjIIEq3ru6c= +google.golang.org/appengine v1.6.7/go.mod h1:8WjMMxjGQR8xUklV/ARdw2HLXBOI7O7uCIDZVag1xfc= +google.golang.org/protobuf v1.33.0 h1:uNO2rsAINq/JlFpSdYEKIZ0uKD/R9cpdv0T+yoGwGmI= +google.golang.org/protobuf v1.33.0/go.mod h1:c6P6GXX6sHbq/GpV6MGZEdwhWPcYBgnhAHhKbcUYpos= +gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= +gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk= +gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q= +gopkg.in/inf.v0 v0.9.1 h1:73M5CoZyi3ZLMOyDlQh031Cx6N9NDJ2Vvfl76EDAgDc= +gopkg.in/inf.v0 v0.9.1/go.mod h1:cWUDdTG/fYaXco+Dcufb5Vnc6Gp2YChqWtbxRZE0mXw= +gopkg.in/yaml.v2 v2.2.8/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= +gopkg.in/yaml.v2 v2.4.0 h1:D8xgwECY7CYvx+Y2n4sBz93Jn9JRvxdiyyo8CTfuKaY= +gopkg.in/yaml.v2 v2.4.0/go.mod h1:RDklbk79AGWmwhnvt/jBztapEOGDOx6ZbXqjP6csGnQ= +gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= +gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= +gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= +k8s.io/api v0.30.0 h1:siWhRq7cNjy2iHssOB9SCGNCl2spiF1dO3dABqZ8niA= +k8s.io/api v0.30.0/go.mod h1:OPlaYhoHs8EQ1ql0R/TsUgaRPhpKNxIMrKQfWUp8QSE= +k8s.io/apiextensions-apiserver v0.30.0 h1:jcZFKMqnICJfRxTgnC4E+Hpcq8UEhT8B2lhBcQ+6uAs= +k8s.io/apiextensions-apiserver v0.30.0/go.mod h1:N9ogQFGcrbWqAY9p2mUAL5mGxsLqwgtUce127VtRX5Y= +k8s.io/apimachinery v0.30.0 h1:qxVPsyDM5XS96NIh9Oj6LavoVFYff/Pon9cZeDIkHHA= +k8s.io/apimachinery v0.30.0/go.mod h1:iexa2somDaxdnj7bha06bhb43Zpa6eWH8N8dbqVjTUc= +k8s.io/client-go v0.30.0 h1:sB1AGGlhY/o7KCyCEQ0bPWzYDL0pwOZO4vAtTSh/gJQ= +k8s.io/client-go v0.30.0/go.mod h1:g7li5O5256qe6TYdAMyX/otJqMhIiGgTapdLchhmOaY= +k8s.io/klog/v2 v2.120.1 h1:QXU6cPEOIslTGvZaXvFWiP9VKyeet3sawzTOvdXb4Vw= +k8s.io/klog/v2 v2.120.1/go.mod h1:3Jpz1GvMt720eyJH1ckRHK1EDfpxISzJ7I9OYgaDtPE= +k8s.io/kube-openapi v0.0.0-20240228011516-70dd3763d340 h1:BZqlfIlq5YbRMFko6/PM7FjZpUb45WallggurYhKGag= +k8s.io/kube-openapi v0.0.0-20240228011516-70dd3763d340/go.mod h1:yD4MZYeKMBwQKVht279WycxKyM84kkAx2DPrTXaeb98= +k8s.io/utils v0.0.0-20230726121419-3b25d923346b h1:sgn3ZU783SCgtaSJjpcVVlRqd6GSnlTLKgpAAttJvpI= +k8s.io/utils v0.0.0-20230726121419-3b25d923346b/go.mod h1:OLgZIPagt7ERELqWJFomSt595RzquPNLL48iOWgYOg0= +sigs.k8s.io/controller-runtime v0.18.0 h1:Z7jKuX784TQSUL1TIyeuF7j8KXZ4RtSX0YgtjKcSTME= +sigs.k8s.io/controller-runtime v0.18.0/go.mod h1:tuAt1+wbVsXIT8lPtk5RURxqAnq7xkpv2Mhttslg7Hw= +sigs.k8s.io/json v0.0.0-20221116044647-bc3834ca7abd h1:EDPBXCAspyGV4jQlpZSudPeMmr1bNJefnuqLsRAsHZo= +sigs.k8s.io/json v0.0.0-20221116044647-bc3834ca7abd/go.mod h1:B8JuhiUyNFVKdsE8h686QcCxMaH6HrOAZj4vswFpcB0= +sigs.k8s.io/structured-merge-diff/v4 v4.4.1 h1:150L+0vs/8DA78h1u02ooW1/fFq/Lwr+sGiqlzvrtq4= +sigs.k8s.io/structured-merge-diff/v4 v4.4.1/go.mod h1:N8hJocpFajUSSeSJ9bOZ77VzejKZaXsTtZo4/u7Io08= +sigs.k8s.io/yaml v1.3.0 h1:a2VclLzOGrwOHDiV8EfBGhvjHvP46CtW5j6POvhYGGo= +sigs.k8s.io/yaml v1.3.0/go.mod h1:GeOyir5tyXNByN85N/dRIT9es5UQNerPYEKK56eTBm8= diff --git a/kubeclaw/hack/boilerplate.go.txt b/kubeclaw/hack/boilerplate.go.txt new file mode 100644 index 0000000..bd7c195 --- /dev/null +++ b/kubeclaw/hack/boilerplate.go.txt @@ -0,0 +1,2 @@ +// kubeclaw — OpenClaw operator for Kubernetes +// Copyright © 2026 Scott Scoble / Greybeard Holdings, LLC diff --git a/kubeclaw/internal/controller/agent_controller.go b/kubeclaw/internal/controller/agent_controller.go new file mode 100644 index 0000000..de8a939 --- /dev/null +++ b/kubeclaw/internal/controller/agent_controller.go @@ -0,0 +1,51 @@ +package controller + +import ( + "context" + + corev1 "k8s.io/api/core/v1" + "k8s.io/apimachinery/pkg/runtime" + ctrl "sigs.k8s.io/controller-runtime" + "sigs.k8s.io/controller-runtime/pkg/client" + "sigs.k8s.io/controller-runtime/pkg/log" + + kubeclawv1alpha1 "github.com/nousresearch/kubeclaw/api/v1alpha1" +) + +// AgentReconciler reconciles Agent resources. +type AgentReconciler struct { + client.Client + Scheme *runtime.Scheme +} + +// +kubebuilder:rbac:groups=kubeclaw.nousresearch.com,resources=agents,verbs=get;list;watch;create;update;patch;delete +// +kubebuilder:rbac:groups=kubeclaw.nousresearch.com,resources=agents/status,verbs=get;update;patch +// +kubebuilder:rbac:groups=kubeclaw.nousresearch.com,resources=agents/finalizers,verbs=update +// +kubebuilder:rbac:groups=core,resources=pods,verbs=get;list;watch;create;update;patch;delete +// +kubebuilder:rbac:groups=core,resources=events,verbs=create;patch + +func (r *AgentReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctrl.Result, error) { + log := log.FromContext(ctx) + + var agent kubeclawv1alpha1.Agent + if err := r.Get(ctx, req.NamespacedName, &agent); err != nil { + log.Error(err, "unable to fetch Agent") + return ctrl.Result{}, client.IgnoreNotFound(err) + } + + log.Info("Reconciling Agent", "agent", agent.Name) + + // TODO: Build or update the agent pod from the Agent spec + // TODO: Wire judge sidecar and workflow executor sidecar + // TODO: Inject ConfigMap and Secret references + // TODO: Update AgentStatus with pod reference and conditions + + return ctrl.Result{}, nil +} + +func (r *AgentReconciler) SetupWithManager(mgr ctrl.Manager) error { + return ctrl.NewControllerManagedBy(mgr). + For(&kubeclawv1alpha1.Agent{}). + Owns(&corev1.Pod{}). + Complete(r) +} diff --git a/kubeclaw/internal/controller/agentgroup_controller.go b/kubeclaw/internal/controller/agentgroup_controller.go new file mode 100644 index 0000000..4f84bcd --- /dev/null +++ b/kubeclaw/internal/controller/agentgroup_controller.go @@ -0,0 +1,45 @@ +package controller + +import ( + "context" + + "k8s.io/apimachinery/pkg/runtime" + ctrl "sigs.k8s.io/controller-runtime" + "sigs.k8s.io/controller-runtime/pkg/client" + "sigs.k8s.io/controller-runtime/pkg/log" + + kubeclawv1alpha1 "github.com/nousresearch/kubeclaw/api/v1alpha1" +) + +// AgentGroupReconciler reconciles AgentGroup resources. +type AgentGroupReconciler struct { + client.Client + Scheme *runtime.Scheme +} + +// +kubebuilder:rbac:groups=kubeclaw.nousresearch.com,resources=agentgroups,verbs=get;list;watch;create;update;patch;delete +// +kubebuilder:rbac:groups=kubeclaw.nousresearch.com,resources=agentgroups/status,verbs=get;update;patch + +func (r *AgentGroupReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctrl.Result, error) { + log := log.FromContext(ctx) + + var group kubeclawv1alpha1.AgentGroup + if err := r.Get(ctx, req.NamespacedName, &group); err != nil { + log.Error(err, "unable to fetch AgentGroup") + return ctrl.Result{}, client.IgnoreNotFound(err) + } + + log.Info("Reconciling AgentGroup", "group", group.Name) + + // TODO: Reconcile each member agent with shared config + per-member overrides + // TODO: Create/update/delete member Agent resources + // TODO: Handle rolling updates on shared config changes + + return ctrl.Result{}, nil +} + +func (r *AgentGroupReconciler) SetupWithManager(mgr ctrl.Manager) error { + return ctrl.NewControllerManagedBy(mgr). + For(&kubeclawv1alpha1.AgentGroup{}). + Complete(r) +} diff --git a/kubeclaw/internal/controller/suite_test.go b/kubeclaw/internal/controller/suite_test.go new file mode 100644 index 0000000..38e1b6c --- /dev/null +++ b/kubeclaw/internal/controller/suite_test.go @@ -0,0 +1,9 @@ +package controller + +import ( + "testing" +) + +func TestSuite(t *testing.T) { + t.Log("controller test suite stub") +} diff --git a/kubeclaw/internal/judge/client.go b/kubeclaw/internal/judge/client.go new file mode 100644 index 0000000..9a443ec --- /dev/null +++ b/kubeclaw/internal/judge/client.go @@ -0,0 +1,44 @@ +package judge + +// Client communicates with the judge sidecar to validate workflow invocations. +type Client struct { + Endpoint string +} + +// Verdict represents the judge's decision on a workflow invocation. +type Verdict int + +const ( + VerdictApprove Verdict = iota + VerdictReject + VerdictEscalateHuman +) + +// VerificationRequest is sent to the judge sidecar for evaluation. +type VerificationRequest struct { + AgentName string `json:"agentName"` + WorkflowTemplate string `json:"workflowTemplate"` + Params map[string]interface{} `json:"params"` + CompliancePolicies []string `json:"compliancePolicies"` +} + +// VerificationResponse is returned by the judge sidecar. +type VerificationResponse struct { + Verdict Verdict `json:"verdict"` + Reason string `json:"reason"` + RuleID string `json:"ruleId,omitempty"` +} + +// NewClient creates a new judge client. +func NewClient(endpoint string) *Client { + return &Client{Endpoint: endpoint} +} + +// Verify sends a workflow invocation to the judge for evaluation. +func (c *Client) Verify(req VerificationRequest) (*VerificationResponse, error) { + // TODO: Implement HTTP/gRPC call to judge sidecar + return &VerificationResponse{ + Verdict: VerdictApprove, + Reason: "judge client stub — always approves", + }, nil +} diff --git a/kubeclaw/internal/judge/verifier.go b/kubeclaw/internal/judge/verifier.go new file mode 100644 index 0000000..dbe031b --- /dev/null +++ b/kubeclaw/internal/judge/verifier.go @@ -0,0 +1,23 @@ +package judge + +import "time" + +// Verifier evaluates compliance policies against workflow invocations. +type Verifier struct { + client *Client +} + +// VerificationRecord stores the result of a judge evaluation. +type VerificationRecord struct { + Timestamp time.Time `json:"timestamp"` + AgentName string `json:"agentName"` + Workflow string `json:"workflow"` + Verdict Verdict `json:"verdict"` + Reason string `json:"reason"` + Duration time.Duration `json:"durationMs"` +} + +// NewVerifier creates a new Verifier backed by the given client. +func NewVerifier(client *Client) *Verifier { + return &Verifier{client: client} +} diff --git a/kubeclaw/internal/webhook/agent_validator.go b/kubeclaw/internal/webhook/agent_validator.go new file mode 100644 index 0000000..9155b72 --- /dev/null +++ b/kubeclaw/internal/webhook/agent_validator.go @@ -0,0 +1,46 @@ +package webhook + +import ( + "context" + "fmt" + + "k8s.io/apimachinery/pkg/runtime" + ctrl "sigs.k8s.io/controller-runtime" + "sigs.k8s.io/controller-runtime/pkg/webhook/admission" + + kubeclawv1alpha1 "github.com/nousresearch/kubeclaw/api/v1alpha1" +) + +// AgentValidator validates Agent resources on create/update. +type AgentValidator struct{} + +// +kubebuilder:webhook:path=/validate-kubeclaw-nousresearch-com-v1alpha1-agent,mutating=false,failurePolicy=fail,sideEffects=None,groups=kubeclaw.nousresearch.com,resources=agents,verbs=create;update,versions=v1alpha1,name=vagent.kubeclaw.nousresearch.com,admissionReviewVersions=v1 + +func (v *AgentValidator) ValidateCreate(ctx context.Context, obj runtime.Object) (admission.Warnings, error) { + agent, ok := obj.(*kubeclawv1alpha1.Agent) + if !ok { + return nil, fmt.Errorf("expected Agent got %T", obj) + } + if agent.Spec.Identity.DisplayName == "" { + return admission.Warnings{"Agent must have a display name"}, nil + } + // TODO: Validate provider references exist + // TODO: Validate channel references exist + // TODO: Validate workflow template references exist + return nil, nil +} + +func (v *AgentValidator) ValidateUpdate(ctx context.Context, oldObj, newObj runtime.Object) (admission.Warnings, error) { + return nil, nil +} + +func (v *AgentValidator) ValidateDelete(ctx context.Context, obj runtime.Object) (admission.Warnings, error) { + return nil, nil +} + +func (v *AgentValidator) SetupWebhookWithManager(mgr ctrl.Manager) error { + return ctrl.NewWebhookManagedBy(mgr). + For(&kubeclawv1alpha1.Agent{}). + WithValidator(v). + Complete() +} diff --git a/kubeclaw/main.go b/kubeclaw/main.go new file mode 100644 index 0000000..3a95630 --- /dev/null +++ b/kubeclaw/main.go @@ -0,0 +1,94 @@ +package main + +import ( + "flag" + "os" + + "k8s.io/apimachinery/pkg/runtime" + utilruntime "k8s.io/apimachinery/pkg/util/runtime" + clientgoscheme "k8s.io/client-go/kubernetes/scheme" + ctrl "sigs.k8s.io/controller-runtime" + "sigs.k8s.io/controller-runtime/pkg/healthz" + "sigs.k8s.io/controller-runtime/pkg/log/zap" + metricsserver "sigs.k8s.io/controller-runtime/pkg/metrics/server" + + kubeclawv1alpha1 "github.com/nousresearch/kubeclaw/api/v1alpha1" + "github.com/nousresearch/kubeclaw/internal/controller" + "github.com/nousresearch/kubeclaw/internal/webhook" +) + +var ( + scheme = runtime.NewScheme() + setupLog = ctrl.Log.WithName("setup") +) + +func init() { + utilruntime.Must(clientgoscheme.AddToScheme(scheme)) + utilruntime.Must(kubeclawv1alpha1.AddToScheme(scheme)) +} + +func main() { + var metricsAddr string + var enableLeaderElection bool + var probeAddr string + flag.StringVar(&metricsAddr, "metrics-bind-address", ":8080", "The address the metric endpoint binds to.") + flag.StringVar(&probeAddr, "health-probe-bind-address", ":8081", "The address the probe endpoint binds to.") + flag.BoolVar(&enableLeaderElection, "leader-elect", false, + "Enable leader election for controller manager. "+ + "Enabling this will ensure there is only one active controller manager.") + opts := zap.Options{ + Development: true, + } + opts.BindFlags(flag.CommandLine) + flag.Parse() + + ctrl.SetLogger(zap.New(zap.UseFlagOptions(&opts))) + + mgr, err := ctrl.NewManager(ctrl.GetConfigOrDie(), ctrl.Options{ + Scheme: scheme, + Metrics: metricsserver.Options{BindAddress: metricsAddr}, + HealthProbeBindAddress: probeAddr, + LeaderElection: enableLeaderElection, + LeaderElectionID: "kubeclaw.nousresearch.com", + }) + if err != nil { + setupLog.Error(err, "unable to start manager") + os.Exit(1) + } + + if err = (&controller.AgentReconciler{ + Client: mgr.GetClient(), + Scheme: mgr.GetScheme(), + }).SetupWithManager(mgr); err != nil { + setupLog.Error(err, "unable to create controller", "controller", "Agent") + os.Exit(1) + } + + if err = (&controller.AgentGroupReconciler{ + Client: mgr.GetClient(), + Scheme: mgr.GetScheme(), + }).SetupWithManager(mgr); err != nil { + setupLog.Error(err, "unable to create controller", "controller", "AgentGroup") + os.Exit(1) + } + + if err = (&webhook.AgentValidator{}).SetupWebhookWithManager(mgr); err != nil { + setupLog.Error(err, "unable to create webhook", "webhook", "Agent") + os.Exit(1) + } + + if err := mgr.AddHealthzCheck("healthz", healthz.Ping); err != nil { + setupLog.Error(err, "unable to set up health check") + os.Exit(1) + } + if err := mgr.AddReadyzCheck("readyz", healthz.Ping); err != nil { + setupLog.Error(err, "unable to set up ready check") + os.Exit(1) + } + + setupLog.Info("starting manager") + if err := mgr.Start(ctrl.SetupSignalHandler()); err != nil { + setupLog.Error(err, "problem running manager") + os.Exit(1) + } +} diff --git a/pkg/floxenv/alive.go b/pkg/floxenv/alive.go new file mode 100644 index 0000000..a434d39 --- /dev/null +++ b/pkg/floxenv/alive.go @@ -0,0 +1,46 @@ +package floxenv + +import ( + "fmt" + "os" + "strconv" + "strings" + "syscall" +) + +// IsAlive returns true if the process identified by pid is still running. +// It first attempts a zero-signal delivery test, then confirms on Linux +// by inspecting /proc//stat so that zombie processes are reported dead. +func IsAlive(pid int) bool { + if pid <= 0 { + return false + } + if err := syscall.Kill(pid, 0); err != nil { + return false + } + // Linux-specific confirmation to distinguish zombies. + data, err := os.ReadFile(fmt.Sprintf("/proc/%d/stat", pid)) + if err != nil { + // /proc may be unavailable in restricted spaces; trust signal result. + return true + } + s := string(data) + idx := strings.LastIndexByte(s, ')') + if idx >= 0 && idx+2 < len(s) { + state := s[idx+2] + if state == 'Z' { // zombie + return false + } + } + return true +} + +// IsAliveString wraps IsAlive with string-to-int conversion. +// It returns false for any parse or signal error. +func IsAliveString(s string) bool { + pid, err := strconv.Atoi(s) + if err != nil { + return false + } + return IsAlive(pid) +} diff --git a/pkg/floxenv/floxenv.go b/pkg/floxenv/floxenv.go new file mode 100644 index 0000000..88f8ce5 --- /dev/null +++ b/pkg/floxenv/floxenv.go @@ -0,0 +1,242 @@ +// Package floxenv manages Flox environment lifecycles via flox activate --detach. +// When the flox binary is not available, it falls back to a dev-mode stub suitable +// for local development and testing. +package floxenv + +import ( + "bytes" + "context" + "errors" + "fmt" + "os" + "os/exec" + "path/filepath" + "strconv" + "strings" + "sync" + "syscall" + "time" +) + +var ( + // ErrNotFound is returned when flox is not installed and dev mode is disabled. + ErrNotFound = errors.New("flox command not found") + // ErrAlreadyRunning is returned if an env with the same manifest is already active. + ErrAlreadyRunning = errors.New("environment already active") + // ErrActivationFailed is returned when flox activate exits non-zero. + ErrActivationFailed = errors.New("flox activation failed") + // ErrTimeout is returned when graceful shutdown exceeds the deadline. + ErrTimeout = errors.New("environment shutdown timed out") +) + +const ( + defaultFloxPath = "flox" + devModeEnvVar = "FLOXENV_DEV_MODE" + gracePeriod = 10 * time.Second +) + +// Registry tracks active environment metadata by envID. +type Registry struct { + mu sync.RWMutex + m map[string]Info + stub bool // true when flox binary is absent and dev mode is enabled +} + +// Info holds runtime details for an activated environment. +type Info struct { + EnvID string + PID int + ManifestPath string + StartedAt time.Time +} + +// NewRegistry creates a new environment registry. +// It detects whether flox is available and enables dev-mode stub behaviour if not. +func NewRegistry() *Registry { + r := &Registry{m: make(map[string]Info)} + _, err := exec.LookPath(defaultFloxPath) + if err != nil || os.Getenv(devModeEnvVar) == "1" { + r.stub = true + } + return r +} + +// IsDevMode returns true when the registry is running in stub/dev mode. +func (r *Registry) IsDevMode() bool { + r.mu.RLock() + defer r.mu.RUnlock() + return r.stub +} + +// Activate starts a Flox environment in detached mode. +// manifestPath should point to a valid manifest.toml or flox.nix. +// On success it returns an envID (directory name + timestamp hash) and the PID of the +// detached activation process. +func (r *Registry) Activate(manifestPath string) (string, int, error) { + absPath, err := filepath.Abs(manifestPath) + if err != nil { + return "", 0, fmt.Errorf("resolve manifest path: %w", err) + } + + envID := generateEnvID(absPath) + + r.mu.Lock() + if existing, ok := r.m[envID]; ok && IsAlive(existing.PID) { + r.mu.Unlock() + return "", 0, fmt.Errorf("%w: envID=%s pid=%d", ErrAlreadyRunning, envID, existing.PID) + } + r.mu.Unlock() + + if r.IsDevMode() { + return r.stubActivate(envID, absPath) + } + + // Run: flox activate --detach -d + manifestDir := filepath.Dir(absPath) + ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second) + defer cancel() + + cmd := exec.CommandContext(ctx, defaultFloxPath, "activate", "--detach", "-d", manifestDir) + var out bytes.Buffer + var stderr bytes.Buffer + cmd.Stdout = &out + cmd.Stderr = &stderr + + if err := cmd.Run(); err != nil { + return "", 0, fmt.Errorf("%w: %w (stderr: %s)", ErrActivationFailed, err, strings.TrimSpace(stderr.String())) + } + + pid, err := parsePID(out.String()) + if err != nil { + return "", 0, fmt.Errorf("parse activation pid: %w (output: %s)", err, strings.TrimSpace(out.String())) + } + + info := Info{ + EnvID: envID, + PID: pid, + ManifestPath: absPath, + StartedAt: time.Now(), + } + + r.mu.Lock() + r.m[envID] = info + r.mu.Unlock() + + return envID, pid, nil +} + +// stubActivate is the dev-mode fallback when flox is unavailable. +// It forks a lightweight long-running shell command and records the PID. +func (r *Registry) stubActivate(envID, manifestPath string) (string, int, error) { + cmd := exec.Command("sh", "-c", "sleep 3600") + cmd.SysProcAttr = &syscall.SysProcAttr{ + Setpgid: true, // avoid dying with the parent + } + if err := cmd.Start(); err != nil { + return "", 0, fmt.Errorf("stub activate failed: %w", err) + } + + info := Info{ + EnvID: envID, + PID: cmd.Process.Pid, + ManifestPath: manifestPath, + StartedAt: time.Now(), + } + + r.mu.Lock() + r.m[envID] = info + r.mu.Unlock() + + return envID, cmd.Process.Pid, nil +} + +// Deactivate gracefully shuts down an active Flox environment. +// It sends SIGTERM, waits up to 10 seconds, then SIGKILL if still alive. +func (r *Registry) Deactivate(envID string, pid int) error { + r.mu.RLock() + info, ok := r.m[envID] + r.mu.RUnlock() + + if !ok { + // Allow deactivation of PIDs we didn't start (defensive). + info = Info{EnvID: envID, PID: pid} + } + + if info.PID != pid { + return fmt.Errorf("pid mismatch: registry has %d, caller provided %d", info.PID, pid) + } + + if !IsAlive(pid) { + // Already dead, clean-up registry anyway. + r.mu.Lock() + delete(r.m, envID) + r.mu.Unlock() + return nil + } + + // Phase 1: SIGTERM (syscall.Kill avoids os.FindProcess Linux quirk) + if err := syscall.Kill(pid, syscall.SIGTERM); err != nil { + return fmt.Errorf("send SIGTERM to %d: %w", pid, err) + } + + deadline := time.After(gracePeriod) + ticker := time.NewTicker(200 * time.Millisecond) + defer ticker.Stop() + + for { + select { + case <-deadline: + // Phase 2: SIGKILL + _ = syscall.Kill(pid, syscall.SIGKILL) + // Wait a hair for the kernel to reap. + time.Sleep(100 * time.Millisecond) + if IsAlive(pid) { + return fmt.Errorf("%w: envID=%s pid=%d", ErrTimeout, envID, pid) + } + r.mu.Lock() + delete(r.m, envID) + r.mu.Unlock() + return nil + case <-ticker.C: + if !IsAlive(pid) { + r.mu.Lock() + delete(r.m, envID) + r.mu.Unlock() + return nil + } + } + } +} + +// List returns a snapshot of currently tracked environments. +func (r *Registry) List() []Info { + r.mu.RLock() + defer r.mu.RUnlock() + out := make([]Info, 0, len(r.m)) + for _, v := range r.m { + out = append(out, v) + } + return out +} + +// generateEnvID creates a deterministic identifier for a manifest path. +func generateEnvID(path string) string { + dir := filepath.Dir(path) + base := filepath.Base(dir) + t := strconv.FormatInt(time.Now().Unix(), 36) + return fmt.Sprintf("%s-%s", base, t) +} + +// parsePID extracts an integer PID from flox activate --detach output. +// Flox itself does not always print the PID, so fall back to the shell +// process spawned by this package (handled separately). This helper +// attempts to find a PID in the output and returns an error if none found. +func parsePID(s string) (int, error) { + f := strings.Fields(s) + for _, tok := range f { + if n, err := strconv.Atoi(tok); err == nil && n > 0 { + return n, nil + } + } + return 0, errors.New("no PID found in output") +} diff --git a/pkg/floxenv/floxenv_test.go b/pkg/floxenv/floxenv_test.go new file mode 100644 index 0000000..886c879 --- /dev/null +++ b/pkg/floxenv/floxenv_test.go @@ -0,0 +1,141 @@ +package floxenv + +import ( + "errors" + "os" + "os/exec" + "path/filepath" + "syscall" + "testing" + "time" +) + +func TestNewRegistry_DetectsDevMode(t *testing.T) { + r := NewRegistry() + if _, err := exec.LookPath(defaultFloxPath); err == nil && os.Getenv(devModeEnvVar) != "1" { + if r.IsDevMode() { + t.Fatal("expected dev mode false when flox is present and FLOXENV_DEV_MODE unset") + } + } else { + if !r.IsDevMode() { + t.Fatal("expected dev mode true when flox missing or FLOXENV_DEV_MODE=1") + } + } +} + +func TestActivate_Stub(t *testing.T) { + // Force dev mode for a deterministic test. + t.Setenv(devModeEnvVar, "1") + + tmpDir := t.TempDir() + manifest := filepath.Join(tmpDir, "manifest.toml") + if err := os.WriteFile(manifest, []byte("[install]\n\n"), 0600); err != nil { + t.Fatalf("write manifest: %v", err) + } + + r := NewRegistry() + envID, pid, err := r.Activate(manifest) + if err != nil { + t.Fatalf("activate failed: %v", err) + } + if envID == "" { + t.Fatal("expected non-empty envID") + } + if pid <= 0 { + t.Fatalf("expected positive pid, got %d", pid) + } + defer func() { + _ = r.Deactivate(envID, pid) + }() + + if !IsAlive(pid) { + t.Fatalf("expected pid %d to be alive after stub activation", pid) + } +} + +func TestDeactivate_GracefulShutdown(t *testing.T) { + t.Setenv(devModeEnvVar, "1") + + tmpDir := t.TempDir() + manifest := filepath.Join(tmpDir, "manifest.toml") + _ = os.WriteFile(manifest, []byte(""), 0600) + + r := NewRegistry() + envID, pid, err := r.Activate(manifest) + if err != nil { + t.Fatalf("activate failed: %v", err) + } + + // Deactivate should succeed. + if err := r.Deactivate(envID, pid); err != nil { + t.Fatalf("deactivate failed: %v", err) + } + + // Allow scheduler to reap. + time.Sleep(100 * time.Millisecond) + + if IsAlive(pid) { + t.Fatalf("expected pid %d to be dead after deactivate", pid) + } + + // Registry entry should be removed. + for _, info := range r.List() { + if info.EnvID == envID { + t.Fatalf("registry still holds envID %s after deactivation", envID) + } + } +} + +func TestDeactivate_SigkillFallback(t *testing.T) { + t.Setenv(devModeEnvVar, "1") + + // Start a child that ignores SIGTERM. + cmd := exec.Command("sh", "-c", ` + trap '' TERM + sleep 3600 + `) + cmd.SysProcAttr = &syscall.SysProcAttr{Setpgid: true} + if err := cmd.Start(); err != nil { + t.Fatalf("start ignore-sigterm process: %v", err) + } + pid := cmd.Process.Pid + + r := NewRegistry() + envID := "forced-ignore-term" + r.m[envID] = Info{EnvID: envID, PID: pid, ManifestPath: "/tmp/dummy", StartedAt: time.Now()} + + err := r.Deactivate(envID, pid) + if err != nil { + // A timeout is acceptable here; the key assertion is that the process + // is no longer alive after Deactivate returns. + if !errors.Is(err, ErrTimeout) { + t.Fatalf("unexpected deactivation error: %v", err) + } + } + + // Allow the kernel time to reap. + time.Sleep(200 * time.Millisecond) + + if IsAlive(pid) { + t.Fatalf("expected pid %d to be dead after deactivate, but it is still alive", pid) + } +} + +func TestIsAlive_InvalidPid(t *testing.T) { + if IsAlive(0) { + t.Fatal("expected pid 0 to be reported dead") + } + if IsAlive(-1) { + t.Fatal("expected pid -1 to be reported dead") + } + // PID 1 should exist on Linux, but in restricted containers it may not. + // We only assert that the function does not panic. + _ = IsAlive(1) +} + +func isTimeout(err error) bool { + if err == nil { + return false + } + return err.Error() == ErrTimeout.Error() || err.Error() == (ErrTimeout.Error()+": envID=forced-ignore-term pid=0") +} diff --git a/pkg/floxenv/integration_test.go b/pkg/floxenv/integration_test.go new file mode 100644 index 0000000..1b3e026 --- /dev/null +++ b/pkg/floxenv/integration_test.go @@ -0,0 +1,70 @@ +//go:build integration + +package floxenv + +import ( + "os" + "os/exec" + "path/filepath" + "strings" + "testing" + "time" +) + +// TestIntegration_ActivateDeactivate exercises the real flox binary if present. +// Run with: go test -tags=integration ./pkg/floxenv +func TestIntegration_ActivateDeactivate(t *testing.T) { + if _, err := exec.LookPath(defaultFloxPath); err != nil { + t.Skip("flox not installed; skipping integration test") + } + + // Verify that the installed flox supports --detach. + if out, err := exec.Command(defaultFloxPath, "activate", "--help").Output(); err == nil { + if !strings.Contains(string(out), "detach") { + t.Skip("installed flox does not support --detach; skipping integration test") + } + } else { + t.Skipf("unable to query flox activate help: %v", err) + } + + tmpDir := t.TempDir() + manifest := filepath.Join(tmpDir, "flox.nix") + if err := os.WriteFile(manifest, []byte(`{ + description = "test env"; + inputs.nixpkgs.url = "github:NixOS/nixpkgs/nixos-unstable"; + outputs = { self, nixpkgs }: {}; +}`), 0600); err != nil { + t.Fatalf("write manifest: %v", err) + } + + r := NewRegistry() + envID, pid, err := r.Activate(manifest) + if err != nil { + t.Fatalf("activate failed: %v", err) + } + + if !IsAlive(pid) { + t.Fatalf("expected pid %d to be alive after activation", pid) + } + + // Ensure we clean up even if the test panics. + t.Cleanup(func() { + _ = r.Deactivate(envID, pid) + }) + + // Give flox a moment to fully initialise detached state. + time.Sleep(500 * time.Millisecond) + + if err := r.Deactivate(envID, pid); err != nil { + t.Fatalf("deactivate failed: %v", err) + } + + // Polling isAlive because flox may take a moment to tear down. + for i := 0; i < 30; i++ { + if !IsAlive(pid) { + return + } + time.Sleep(100 * time.Millisecond) + } + t.Fatalf("expected pid %d to be dead after deactivate, but it is still alive", pid) +}