Skip to content

Self-hosted workflows for coding-agent delivery. Orchestrate CodeBuddy, Codex and Claude Code with scripts and human approval gates. Includes Local workflows for coding assistants.

refactor(preview): extract tar.zst writing from ArchiveDir into writeTarZst (#314)

fx-kurumic93521b586a2
diff --git a/internal/preview/archive.go b/internal/preview/archive.go
index 505a701d..d4031ac4 100644
--- a/internal/preview/archive.go
+++ b/internal/preview/archive.go
@@ -58,36 +58,45 @@ func ArchiveDir(workspace, sourcePath, indexFile string, limits Limits, dst io.W
return Result{}, fmt.Errorf("%w: %s", ErrMissingIndex, indexFile)
}
+ sum, compressed, err := writeTarZst(dst, entries, limits.MaxCompressed)
+ if err != nil {
+ return Result{}, err
+ }
+ return Result{
+ StorageKey: ContentKey(sum),
+ SHA256: sum,
+ CompressedSize: compressed,
+ ExpandedSize: expanded,
+ FileCount: len(entries),
+ EntryFile: indexFile,
+ }, nil
+}
+
+// writeTarZst streams entries as a tar.zst into dst and returns the hex SHA-256
+// and byte count of the compressed stream. maxCompressed > 0 caps that count.
+func writeTarZst(dst io.Writer, entries []fileEntry, maxCompressed int64) (string, int64, error) {
hash := sha256.New()
- counter := &countWriter{w: io.MultiWriter(dst, hash), limit: limits.MaxCompressed}
+ counter := &countWriter{w: io.MultiWriter(dst, hash), limit: maxCompressed}
enc, err := zstd.NewWriter(counter, zstd.WithEncoderLevel(zstd.SpeedDefault))
if err != nil {
- return Result{}, fmt.Errorf("zstd encoder: %w", err)
+ return "", 0, fmt.Errorf("zstd encoder: %w", err)
}
tw := tar.NewWriter(enc)
for _, item := range entries {
if err := writeTarFile(tw, item); err != nil {
_ = tw.Close()
_ = enc.Close()
- return Result{}, err
+ return "", 0, err
}
}
if err := tw.Close(); err != nil {
_ = enc.Close()
- return Result{}, err
+ return "", 0, err
}
if err := enc.Close(); err != nil {
- return Result{}, err
+ return "", 0, err
}
- sum := hex.EncodeToString(hash.Sum(nil))
- return Result{
- StorageKey: ContentKey(sum),
- SHA256: sum,
- CompressedSize: counter.n,
- ExpandedSize: expanded,
- FileCount: len(entries),
- EntryFile: indexFile,
- }, nil
+ return hex.EncodeToString(hash.Sum(nil)), counter.n, nil
}
type fileEntry struct {
diff --git a/internal/preview/archive_tarzst_test.go b/internal/preview/archive_tarzst_test.go
new file mode 100644
index 00000000..3643d240
--- /dev/null
+++ b/internal/preview/archive_tarzst_test.go
@@ -0,0 +1,64 @@
+package preview
+
+import (
+ "bytes"
+ "crypto/sha256"
+ "encoding/hex"
+ "errors"
+ "os"
+ "path/filepath"
+ "testing"
+)
+
+func tarZstTestEntries(t *testing.T) []fileEntry {
+ t.Helper()
+ dir := t.TempDir()
+ var entries []fileEntry
+ for _, name := range []string{"index.html", "app.js"} {
+ abs := filepath.Join(dir, name)
+ body := []byte("content of " + name)
+ if err := os.WriteFile(abs, body, 0o644); err != nil {
+ t.Fatal(err)
+ }
+ entries = append(entries, fileEntry{abs: abs, name: name, mode: 0o644, size: int64(len(body))})
+ }
+ return entries
+}
+
+func TestWriteTarZstReportsHashAndSizeOfWrittenBytes(t *testing.T) {
+ entries := tarZstTestEntries(t)
+ var buf bytes.Buffer
+ sum, n, err := writeTarZst(&buf, entries, 0)
+ if err != nil {
+ t.Fatal(err)
+ }
+ want := sha256.Sum256(buf.Bytes())
+ if sum != hex.EncodeToString(want[:]) {
+ t.Fatalf("sum %s does not match written bytes", sum)
+ }
+ if n != int64(buf.Len()) || n == 0 {
+ t.Fatalf("compressed size %d, written %d", n, buf.Len())
+ }
+ res, err := InspectTarZst(bytes.NewReader(buf.Bytes()), "index.html", Limits{MaxFiles: 10, MaxCompressed: 1 << 20, MaxExpanded: 1 << 20})
+ if err != nil {
+ t.Fatal(err)
+ }
+ if res.SHA256 != sum || res.CompressedSize != n || res.FileCount != len(entries) {
+ t.Fatalf("inspect mismatch: %+v", res)
+ }
+}
+
+func TestWriteTarZstEnforcesCompressedLimit(t *testing.T) {
+ var buf bytes.Buffer
+ if _, _, err := writeTarZst(&buf, tarZstTestEntries(t), 8); !errors.Is(err, ErrLimitExceeded) {
+ t.Fatalf("expected ErrLimitExceeded, got %v", err)
+ }
+}
+
+func TestWriteTarZstPropagatesMissingSourceFile(t *testing.T) {
+ entries := []fileEntry{{abs: filepath.Join(t.TempDir(), "gone.html"), name: "gone.html", mode: 0o644, size: 1}}
+ var buf bytes.Buffer
+ if _, _, err := writeTarZst(&buf, entries, 0); err == nil {
+ t.Fatal("expected error for missing source file")
+ }
+}