Validate and import agent skills into versioned server storage

Adds a SKILL.md bundle validator, immutable per-skill versions with
content digests and deduplication, protocol requests to import, list and
show skills, and the pipelines skills import/list/show commands. Imports
are serialised so concurrent imports never share a version number.
This commit is contained in:
2026-11-12 11:15:28 +00:00
parent 24618964ce
commit bd4f1437bc
13 changed files with 811 additions and 0 deletions
+93
View File
@@ -0,0 +1,93 @@
package server
import (
"context"
"net/http/httptest"
"os"
"path/filepath"
"strings"
"testing"
"time"
"github.com/coder/websocket"
"github.com/coder/websocket/wsjson"
"git.a-wan.net/alan/pipelines/internal/pipeline"
"git.a-wan.net/alan/pipelines/internal/protocol"
"git.a-wan.net/alan/pipelines/internal/skills"
)
func TestSkillWebSocketHandlers(t *testing.T) {
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
defer cancel()
store, err := pipeline.Open(filepath.Join(t.TempDir(), "skills.db"))
if err != nil {
t.Fatal(err)
}
defer store.Close()
handler := Handler(ctx, store)
srv := httptest.NewServer(handler)
defer srv.Close()
defer func() { cancel(); WaitRuns(handler) }()
conn, _, err := websocket.Dial(ctx, "ws"+strings.TrimPrefix(srv.URL, "http")+"/connect", nil)
if err != nil {
t.Fatal(err)
}
defer conn.CloseNow()
var welcome protocol.Message
if err := wsjson.Read(ctx, conn, &welcome); err != nil {
t.Fatal(err)
}
dir := t.TempDir()
if err := writeSkillFixture(dir); err != nil {
t.Fatal(err)
}
bundle, err := skills.Validate(dir)
if err != nil {
t.Fatal(err)
}
files := make([]protocol.SkillFile, len(bundle.Files))
for i, file := range bundle.Files {
files[i] = protocol.SkillFile{Path: file.Path, Bytes: file.Bytes}
}
request := protocol.Message{Type: protocol.ImportSkill, ID: "import", Name: bundle.Name, Description: bundle.Description, Digest: bundle.Digest, SourcePath: dir, SkillFiles: files}
response := skillRequest(t, ctx, conn, request)
if response.Type != protocol.SkillImported || response.SkillVersion == nil || response.SkillVersion.Version != 1 {
t.Fatalf("import response = %+v", response)
}
response = skillRequest(t, ctx, conn, protocol.Message{Type: protocol.ListSkills, ID: "list"})
if response.Type != protocol.Skills || len(response.SkillSummaries) != 1 || response.SkillSummaries[0].Name != bundle.Name {
t.Fatalf("list response = %+v", response)
}
response = skillRequest(t, ctx, conn, protocol.Message{Type: protocol.ShowSkill, ID: "show", Name: bundle.Name})
if response.Type != protocol.Skill || response.SkillVersion == nil || response.SkillVersion.SkillMD == "" {
t.Fatalf("show response = %+v", response)
}
response = skillRequest(t, ctx, conn, protocol.Message{Type: protocol.ImportSkill, ID: "bad", Name: bundle.Name, SourcePath: dir, Digest: bundle.Digest, SkillFiles: []protocol.SkillFile{{Path: "../escape", Bytes: []byte("x")}}})
if response.Type != protocol.Error || response.Error == "" {
t.Fatalf("invalid import response = %+v", response)
}
}
func skillRequest(t *testing.T, ctx context.Context, conn *websocket.Conn, request protocol.Message) protocol.Message {
t.Helper()
if err := wsjson.Write(ctx, conn, request); err != nil {
t.Fatal(err)
}
var response protocol.Message
if err := wsjson.Read(ctx, conn, &response); err != nil {
t.Fatal(err)
}
if response.ID != request.ID {
t.Fatalf("response ID = %q, want %q", response.ID, request.ID)
}
return response
}
func writeSkillFixture(dir string) error {
return os.WriteFile(filepath.Join(dir, "SKILL.md"), []byte("---\nname: websocket-skill\ndescription: Handler test\n---\n\nDo not execute this.\n"), 0600)
}
+39
View File
@@ -461,6 +461,45 @@ func HandlerWithOptions(ctx context.Context, options Options, stores ...*pipelin
} else {
response.Pipelines = items
}
} else if request.Type == protocol.ImportSkill && len(stores) > 0 {
response.Type = protocol.SkillImported
if len(request.SkillFiles) == 0 || request.Name == "" || request.SourcePath == "" {
response.Type = protocol.Error
response.Error = "skill import requires name, source path and files"
} else {
for _, f := range request.SkillFiles {
if f.Path == "" || strings.HasPrefix(f.Path, "/") || strings.Contains(f.Path, "..") {
response.Type = protocol.Error
response.Error = "invalid skill file path"
break
}
}
if response.Type != protocol.Error {
var skill protocol.SkillVersion
skill, err = stores[0].ImportSkill(ctx, request.Name, request.Description, request.Digest, request.SourcePath, request.SkillFiles)
response.SkillVersion = &skill
}
if err != nil {
response.Type = protocol.Error
response.Error = err.Error()
}
}
} else if request.Type == protocol.ListSkills && len(stores) > 0 {
response.Type = protocol.Skills
response.SkillSummaries, err = stores[0].ListSkills(ctx)
if err != nil {
response.Type = protocol.Error
response.Error = err.Error()
}
} else if request.Type == protocol.ShowSkill && len(stores) > 0 {
response.Type = protocol.Skill
var skill protocol.SkillVersion
skill, err = stores[0].GetSkill(ctx, request.Name, request.Version)
response.SkillVersion = &skill
if err != nil {
response.Type = protocol.Error
response.Error = err.Error()
}
} else if (request.Type == protocol.ArchivePipeline || request.Type == protocol.UnarchivePipeline) && len(stores) > 0 {
detail, err := archivePipeline(ctx, stores[0], request)
response.Detail = detail