// Package draft owns retained, private Markdown drafts shared by both interfaces. package draft import ( "encoding/json" "fmt" "io" "os" "path/filepath" "sort" "strings" ) type Draft struct { Path string `json:"path"` Name string `json:"name"` Server string `json:"server,omitempty"` CreateOnly bool `json:"create_only"` BaseVersion int `json:"base_version,omitempty"` } func Directory() (string, error) { if dir := os.Getenv("PIPELINES_DRAFT_DIR"); dir != "" { return filepath.Abs(dir) } cache, err := os.UserCacheDir() return filepath.Join(cache, "pipelines", "drafts"), err } func Create(name, source, server string, fresh bool, base int) (Draft, error) { dir, err := Directory() if err != nil { return Draft{}, err } if err = os.MkdirAll(dir, 0700); err != nil { return Draft{}, err } f, err := os.CreateTemp(dir, "pipeline-*.md") if err != nil { return Draft{}, err } path := f.Name() _, writeErr := f.WriteString(source) closeErr := f.Close() if writeErr != nil { return Draft{}, writeErr } if closeErr != nil { return Draft{}, closeErr } d := Draft{Path: path, Name: name, Server: server, CreateOnly: fresh, BaseVersion: base} data, _ := json.MarshalIndent(d, "", " ") err = os.WriteFile(path+".json", data, 0600) return d, err } func Read(path string) (string, error) { f, err := os.Open(path) if err != nil { return "", err } defer f.Close() info, err := f.Stat() if err != nil { return "", err } if !info.Mode().IsRegular() || info.Size() > 1<<20 { return "", fmt.Errorf("draft must be a regular file no larger than 1 MiB") } // Bound the read even if an editor grows the file after Stat. data, err := io.ReadAll(io.LimitReader(f, (1<<20)+1)) if err != nil { return "", err } if len(data) > 1<<20 { return "", fmt.Errorf("draft exceeds 1 MiB") } return string(data), nil } func Load(path string) (Draft, error) { absolute, err := filepath.Abs(path) if err != nil { return Draft{}, err } data, err := os.ReadFile(absolute + ".json") if err != nil { return Draft{}, err } var d Draft if err = json.Unmarshal(data, &d); err != nil { return d, err } d.Path = absolute // Never trust a metadata file to redirect submission to another source. return d, nil } func List() ([]Draft, error) { dir, err := Directory() if err != nil { return nil, err } paths, err := filepath.Glob(filepath.Join(dir, "pipeline-*.md.json")) if err != nil { return nil, err } sort.Strings(paths) items := []Draft{} for _, path := range paths { d, err := Load(path[:len(path)-5]) if err != nil { return nil, err } items = append(items, d) } return items, nil } // Delete only a selected, managed cache draft and its sidecar. Never recurse, // follow a file symlink, or delete an arbitrary external submission source. func Delete(path string) error { dir, err := Directory() if err != nil { return err } absolute, err := filepath.Abs(path) if err != nil { return err } name := filepath.Base(absolute) if filepath.Dir(absolute) != filepath.Clean(dir) || !strings.HasPrefix(name, "pipeline-") || !strings.HasSuffix(name, ".md") { return fmt.Errorf("only managed drafts inside %s can be deleted", dir) } for _, file := range []string{absolute + ".json", absolute} { info, err := os.Lstat(file) if os.IsNotExist(err) && file == absolute { continue } if err != nil { return err } if !info.Mode().IsRegular() { return fmt.Errorf("draft and metadata must be regular files, not symlinks or directories") } } if err := os.Remove(absolute); err != nil && !os.IsNotExist(err) { return err } return os.Remove(absolute + ".json") }