a733a927f3
Preserve Settings as an independent navigation destination while landing the reviewed notification and skill-management updates. Keep the server and CLI skill contracts versioned and validated so the merged tree can be verified by the delivery gate.
169 lines
6.7 KiB
Go
169 lines
6.7 KiB
Go
package pipeline
|
|
|
|
import (
|
|
"context"
|
|
"crypto/sha256"
|
|
"database/sql"
|
|
"encoding/hex"
|
|
"fmt"
|
|
"git.a-wan.net/alan/pipelines/internal/protocol"
|
|
"git.a-wan.net/alan/pipelines/internal/skills"
|
|
"os"
|
|
"path/filepath"
|
|
"sort"
|
|
"strings"
|
|
"sync"
|
|
"time"
|
|
)
|
|
|
|
func (s *Store) initSkills() error {
|
|
_, err := s.db.Exec(`CREATE TABLE IF NOT EXISTS skills (name TEXT PRIMARY KEY, description TEXT NOT NULL, latest_version INTEGER NOT NULL, digest TEXT NOT NULL, imported_at TEXT NOT NULL);
|
|
CREATE TABLE IF NOT EXISTS skill_versions (name TEXT NOT NULL REFERENCES skills(name), version INTEGER NOT NULL, digest TEXT NOT NULL, source_path TEXT NOT NULL, imported_at TEXT NOT NULL, PRIMARY KEY(name,version), UNIQUE(name,digest));
|
|
CREATE TABLE IF NOT EXISTS skill_files (name TEXT NOT NULL, version INTEGER NOT NULL, path TEXT NOT NULL, size INTEGER NOT NULL, PRIMARY KEY(name,version,path), FOREIGN KEY(name,version) REFERENCES skill_versions(name,version));`)
|
|
return err
|
|
}
|
|
|
|
// skillImports serialises imports in this server process, so the
|
|
// deduplication check and the next-version allocation below see every
|
|
// earlier import's committed version and never hand out the same number.
|
|
var skillImports sync.Mutex
|
|
|
|
func (s *Store) ImportSkill(ctx context.Context, name, description, digest, source string, files []protocol.SkillFile) (protocol.SkillVersion, error) {
|
|
skillImports.Lock()
|
|
defer skillImports.Unlock()
|
|
if err := skills.ValidateName(name); err != nil {
|
|
return protocol.SkillVersion{}, err
|
|
}
|
|
if digest == "" || len(files) == 0 {
|
|
return protocol.SkillVersion{}, fmt.Errorf("invalid skill bundle")
|
|
}
|
|
if len(files) > skills.MaxFiles {
|
|
return protocol.SkillVersion{}, fmt.Errorf("skill has more than %d files", skills.MaxFiles)
|
|
}
|
|
ordered := append([]protocol.SkillFile(nil), files...)
|
|
sort.Slice(ordered, func(i, j int) bool { return ordered[i].Path < ordered[j].Path })
|
|
h := sha256.New()
|
|
total := 0
|
|
for _, f := range ordered {
|
|
if f.Path == "" || strings.HasPrefix(f.Path, "/") || filepath.Clean(f.Path) != f.Path || strings.HasPrefix(filepath.ToSlash(f.Path), "../") || strings.Contains(f.Path, "\\") {
|
|
return protocol.SkillVersion{}, fmt.Errorf("invalid skill file path: %s", f.Path)
|
|
}
|
|
if len(f.Bytes) > skills.MaxFileBytes {
|
|
return protocol.SkillVersion{}, fmt.Errorf("file %s exceeds %d bytes", f.Path, skills.MaxFileBytes)
|
|
}
|
|
total += len(f.Bytes)
|
|
fmt.Fprintf(h, "%s\x00%d\x00", f.Path, len(f.Bytes))
|
|
h.Write(f.Bytes)
|
|
}
|
|
if total > skills.MaxTotalBytes || hex.EncodeToString(h.Sum(nil)) != digest {
|
|
return protocol.SkillVersion{}, fmt.Errorf("skill digest or size limit is invalid")
|
|
}
|
|
var existing protocol.SkillVersion
|
|
err := s.db.QueryRowContext(ctx, `SELECT version, source_path, imported_at FROM skill_versions WHERE name=? AND digest=?`, name, digest).Scan(&existing.Version, &existing.SourcePath, &existing.ImportedAt)
|
|
if err == nil {
|
|
existing.SkillSummary = protocol.SkillSummary{Name: name, Description: description, LatestVersion: existing.Version, Digest: digest, ImportedAt: existing.ImportedAt}
|
|
existing.SkillMD, _ = s.skillMD(name, existing.Version)
|
|
existing.Manifest, _ = s.skillManifest(ctx, name, existing.Version)
|
|
return existing, nil
|
|
}
|
|
if err != sql.ErrNoRows {
|
|
return existing, err
|
|
}
|
|
var next int
|
|
_ = s.db.QueryRowContext(ctx, `SELECT COALESCE(MAX(version),0)+1 FROM skill_versions WHERE name=?`, name).Scan(&next)
|
|
now := time.Now().UTC().Format(time.RFC3339)
|
|
tx, err := s.db.BeginTx(ctx, nil)
|
|
if err != nil {
|
|
return existing, err
|
|
}
|
|
if _, err = tx.ExecContext(ctx, `INSERT INTO skills(name,description,latest_version,digest,imported_at) VALUES(?,?,?,?,?) ON CONFLICT(name) DO UPDATE SET description=excluded.description,latest_version=excluded.latest_version,digest=excluded.digest,imported_at=excluded.imported_at`, name, description, next, digest, now); err != nil {
|
|
tx.Rollback()
|
|
return existing, err
|
|
}
|
|
if _, err = tx.ExecContext(ctx, `INSERT INTO skill_versions(name,version,digest,source_path,imported_at) VALUES(?,?,?,?,?)`, name, next, digest, source, now); err != nil {
|
|
tx.Rollback()
|
|
return existing, err
|
|
}
|
|
dir := filepath.Join(s.dir, "skills", name, fmt.Sprintf("v%d", next))
|
|
if err = os.MkdirAll(dir, 0700); err != nil {
|
|
tx.Rollback()
|
|
return existing, err
|
|
}
|
|
for _, f := range files {
|
|
p := filepath.Join(dir, filepath.FromSlash(f.Path))
|
|
if err = os.MkdirAll(filepath.Dir(p), 0700); err != nil {
|
|
tx.Rollback()
|
|
return existing, err
|
|
}
|
|
if err = os.WriteFile(p, f.Bytes, 0600); err != nil {
|
|
tx.Rollback()
|
|
return existing, err
|
|
}
|
|
if _, err = tx.ExecContext(ctx, `INSERT INTO skill_files(name,version,path,size) VALUES(?,?,?,?)`, name, next, f.Path, len(f.Bytes)); err != nil {
|
|
tx.Rollback()
|
|
return existing, err
|
|
}
|
|
}
|
|
if err = tx.Commit(); err != nil {
|
|
return existing, err
|
|
}
|
|
return s.GetSkill(ctx, name, next)
|
|
}
|
|
func (s *Store) ListSkills(ctx context.Context) ([]protocol.SkillSummary, error) {
|
|
rows, e := s.db.QueryContext(ctx, `SELECT name,description,latest_version,digest,imported_at FROM skills ORDER BY name`)
|
|
if e != nil {
|
|
return nil, e
|
|
}
|
|
defer rows.Close()
|
|
var out []protocol.SkillSummary
|
|
for rows.Next() {
|
|
var x protocol.SkillSummary
|
|
if e = rows.Scan(&x.Name, &x.Description, &x.LatestVersion, &x.Digest, &x.ImportedAt); e != nil {
|
|
return nil, e
|
|
}
|
|
out = append(out, x)
|
|
}
|
|
return out, rows.Err()
|
|
}
|
|
func (s *Store) GetSkill(ctx context.Context, name string, version int) (protocol.SkillVersion, error) {
|
|
var x protocol.SkillVersion
|
|
var desc string
|
|
if version == 0 {
|
|
if e := s.db.QueryRowContext(ctx, `SELECT description,latest_version FROM skills WHERE name=?`, name).Scan(&desc, &version); e != nil {
|
|
return x, e
|
|
}
|
|
} else if e := s.db.QueryRowContext(ctx, `SELECT description FROM skills WHERE name=?`, name).Scan(&desc); e != nil {
|
|
return x, e
|
|
}
|
|
if e := s.db.QueryRowContext(ctx, `SELECT digest,source_path,imported_at FROM skill_versions WHERE name=? AND version=?`, name, version).Scan(&x.Digest, &x.SourcePath, &x.ImportedAt); e != nil {
|
|
return x, e
|
|
}
|
|
x.Name = name
|
|
x.Description = desc
|
|
x.Version = version
|
|
x.LatestVersion = version
|
|
x.SkillMD, _ = s.skillMD(name, version)
|
|
x.Manifest, _ = s.skillManifest(ctx, name, version)
|
|
return x, nil
|
|
}
|
|
func (s *Store) skillMD(name string, v int) (string, error) {
|
|
b, e := os.ReadFile(filepath.Join(s.dir, "skills", name, fmt.Sprintf("v%d", v), "SKILL.md"))
|
|
return string(b), e
|
|
}
|
|
func (s *Store) skillManifest(ctx context.Context, name string, v int) ([]protocol.SkillFileMeta, error) {
|
|
rows, e := s.db.QueryContext(ctx, `SELECT path,size FROM skill_files WHERE name=? AND version=? ORDER BY path`, name, v)
|
|
if e != nil {
|
|
return nil, e
|
|
}
|
|
defer rows.Close()
|
|
var out []protocol.SkillFileMeta
|
|
for rows.Next() {
|
|
var x protocol.SkillFileMeta
|
|
if e = rows.Scan(&x.Path, &x.Size); e != nil {
|
|
return nil, e
|
|
}
|
|
out = append(out, x)
|
|
}
|
|
return out, rows.Err()
|
|
}
|