Merge remote-tracking branch 'origin/main'

Author: easel

internal/dun/agent.go

@@ -232,6 +232,9 @@ func resolveInputs(root string, inputs []string) ([]PromptInput, error) {
 	for _, path := range files {
 		content, err := os.ReadFile(path)
 		if err != nil {
+			if os.IsNotExist(err) {
+				continue
+			}
 			return nil, err
 		}
 		rel, err := relPath(root, path)

internal/dun/agent_extra_test.go

@@ -100,9 +100,12 @@ func TestResolveInputsGlobAndMissing(t *testing.T) {
 		t.Fatalf("expected 2 inputs, got %d", len(inputs))
 	}
 
-	_, err = resolveInputs(dir, []string{"missing.txt"})
-	if err == nil {
-		t.Fatalf("expected error for missing input")
+	inputs, err = resolveInputs(dir, []string{"missing.txt"})
+	if err != nil {
+		t.Fatalf("resolve missing input: %v", err)
+	}
+	if len(inputs) != 0 {
+		t.Fatalf("expected no inputs for missing file, got %d", len(inputs))
 	}
 }
 
@@ -298,14 +301,24 @@ func TestRunAgentCheckAutoSuccessAndInvalidResponse(t *testing.T) {
 	}
 }
 
-func TestRunAgentCheckBuildPromptEnvelopeError(t *testing.T) {
+func TestRunAgentCheckBuildPromptEnvelopeSkipsMissingInputs(t *testing.T) {
 	dir := t.TempDir()
 	writeFile(t, filepath.Join(dir, "prompt.md"), "hi")
 	plugin := Plugin{FS: os.DirFS(dir), Base: "."}
 	check := Check{ID: "test", Prompt: "prompt.md", Inputs: []string{"missing.txt"}}
 	opts := Options{AgentMode: "prompt", AutomationMode: "auto"}
-	if _, err := runAgentCheck(dir, plugin, check, opts); err == nil {
-		t.Fatalf("expected build prompt error")
+	res, err := runAgentCheck(dir, plugin, check, opts)
+	if err != nil {
+		t.Fatalf("run agent check: %v", err)
+	}
+	if res.Status != "prompt" {
+		t.Fatalf("expected prompt, got %s", res.Status)
+	}
+	if res.Prompt == nil {
+		t.Fatalf("expected prompt envelope")
+	}
+	if len(res.Prompt.Inputs) != 0 {
+		t.Fatalf("expected no inputs, got %v", res.Prompt.Inputs)
 	}
 }
 
@@ -359,8 +372,12 @@ func TestBuildPromptEnvelopeMissingInput(t *testing.T) {
 	writeFile(t, filepath.Join(dir, "prompt.md"), "hello")
 	plugin := Plugin{FS: os.DirFS(dir), Base: "."}
 	check := Check{ID: "id", Prompt: "prompt.md", Inputs: []string{"missing.txt"}}
-	if _, err := buildPromptEnvelope(dir, plugin, check, "auto"); err == nil {
-		t.Fatalf("expected missing input error")
+	envelope, err := buildPromptEnvelope(dir, plugin, check, "auto")
+	if err != nil {
+		t.Fatalf("build prompt envelope: %v", err)
+	}
+	if len(envelope.Inputs) != 0 {
+		t.Fatalf("expected no inputs, got %v", envelope.Inputs)
 	}
 }
 

internal/dun/engine_extra_test.go

@@ -102,6 +102,23 @@ func TestCheckRepoReturnsError(t *testing.T) {
 	}
 }
 
+func TestCheckRepoEmptyFolder(t *testing.T) {
+	root := t.TempDir()
+	if _, err := CheckRepo(root, Options{}); err != nil {
+		t.Fatalf("check repo empty: %v", err)
+	}
+}
+
+func TestCheckRepoDocsHelixEmpty(t *testing.T) {
+	root := t.TempDir()
+	if err := os.MkdirAll(filepath.Join(root, "docs", "helix"), 0755); err != nil {
+		t.Fatalf("mkdir docs/helix: %v", err)
+	}
+	if _, err := CheckRepo(root, Options{}); err != nil {
+		t.Fatalf("check repo helix empty: %v", err)
+	}
+}
+
 func TestCheckRepoRunCheckError(t *testing.T) {
 	orig := loadBuiltins
 	loadBuiltins = func() ([]Plugin, error) {

internal/update/update.go

@@ -2,6 +2,8 @@
 package update
 
 import (
+	"archive/tar"
+	"compress/gzip"
 	"crypto/sha256"
 	"encoding/hex"
 	"encoding/json"
@@ -101,6 +103,15 @@ func (u *Updater) DownloadRelease(release *Release) (string, error) {
 		return "", fmt.Errorf("no asset found for %s/%s", runtime.GOOS, runtime.GOARCH)
 	}
 
+	checksums, err := u.downloadChecksums(release)
+	if err != nil {
+		return "", err
+	}
+	expectedChecksum := checksums[asset.Name]
+	if expectedChecksum == "" {
+		return "", fmt.Errorf("checksum not found for %s", asset.Name)
+	}
+
 	req, err := http.NewRequest(http.MethodGet, asset.DownloadURL, nil)
 	if err != nil {
 		return "", fmt.Errorf("create request: %w", err)
@@ -138,6 +149,22 @@ func (u *Updater) DownloadRelease(release *Release) (string, error) {
 		return "", fmt.Errorf("size mismatch: expected %d, got %d", asset.Size, written)
 	}
 
+	actualChecksum := hex.EncodeToString(hasher.Sum(nil))
+	if !strings.EqualFold(actualChecksum, expectedChecksum) {
+		os.Remove(tmpFile.Name())
+		return "", fmt.Errorf("checksum mismatch for %s", asset.Name)
+	}
+
+	if strings.HasSuffix(strings.ToLower(asset.Name), ".tar.gz") {
+		path, err := extractArchiveBinary(tmpFile.Name(), u.BinaryName)
+		if err != nil {
+			os.Remove(tmpFile.Name())
+			return "", err
+		}
+		os.Remove(tmpFile.Name())
+		return path, nil
+	}
+
 	return tmpFile.Name(), nil
 }
 
@@ -263,12 +290,14 @@ func (u *Updater) findAsset(release *Release) *Asset {
 		aliases = []string{archName}
 	}
 
+	var fallback *Asset
 	for i := range release.Assets {
 		asset := &release.Assets[i]
 		name := strings.ToLower(asset.Name)
 
 		// Skip checksums and signatures
-		if strings.HasSuffix(name, ".sha256") ||
+		if name == "checksums.txt" ||
+			strings.HasSuffix(name, ".sha256") ||
 			strings.HasSuffix(name, ".sig") ||
 			strings.HasSuffix(name, ".asc") {
 			continue
@@ -280,12 +309,18 @@ func (u *Updater) findAsset(release *Release) *Asset {
 
 		for _, arch := range aliases {
 			if strings.Contains(name, arch) {
-				return asset
+				if strings.HasSuffix(name, ".tar.gz") {
+					return asset
+				}
+				if fallback == nil {
+					fallback = asset
+				}
+				break
 			}
 		}
 	}
 
-	return nil
+	return fallback
 }
 
 func (u *Updater) httpClient() HTTPClient {
@@ -387,3 +422,106 @@ func ComputeChecksum(path string) (string, error) {
 
 	return hex.EncodeToString(h.Sum(nil)), nil
 }
+
+func (u *Updater) downloadChecksums(release *Release) (map[string]string, error) {
+	asset := findChecksumsAsset(release)
+	if asset == nil {
+		return nil, errors.New("checksums.txt not found in release assets")
+	}
+
+	req, err := http.NewRequest(http.MethodGet, asset.DownloadURL, nil)
+	if err != nil {
+		return nil, fmt.Errorf("create checksums request: %w", err)
+	}
+	req.Header.Set("User-Agent", fmt.Sprintf("%s-updater", u.BinaryName))
+
+	client := u.httpClient()
+	resp, err := client.Do(req)
+	if err != nil {
+		return nil, fmt.Errorf("download checksums: %w", err)
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusOK {
+		return nil, fmt.Errorf("checksums status: %d", resp.StatusCode)
+	}
+
+	data, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return nil, fmt.Errorf("read checksums: %w", err)
+	}
+
+	return parseChecksums(data), nil
+}
+
+func findChecksumsAsset(release *Release) *Asset {
+	for i := range release.Assets {
+		asset := &release.Assets[i]
+		if strings.EqualFold(asset.Name, "checksums.txt") {
+			return asset
+		}
+	}
+	return nil
+}
+
+func parseChecksums(data []byte) map[string]string {
+	out := make(map[string]string)
+	lines := strings.Split(string(data), "\n")
+	for _, line := range lines {
+		fields := strings.Fields(line)
+		if len(fields) < 2 {
+			continue
+		}
+		out[fields[1]] = fields[0]
+	}
+	return out
+}
+
+func extractArchiveBinary(archivePath, binaryName string) (string, error) {
+	f, err := os.Open(archivePath)
+	if err != nil {
+		return "", fmt.Errorf("open archive: %w", err)
+	}
+	defer f.Close()
+
+	gz, err := gzip.NewReader(f)
+	if err != nil {
+		return "", fmt.Errorf("read gzip: %w", err)
+	}
+	defer gz.Close()
+
+	tr := tar.NewReader(gz)
+	for {
+		hdr, err := tr.Next()
+		if err == io.EOF {
+			break
+		}
+		if err != nil {
+			return "", fmt.Errorf("read tar: %w", err)
+		}
+		if hdr.Typeflag != tar.TypeReg {
+			continue
+		}
+		if filepath.Base(hdr.Name) != binaryName {
+			continue
+		}
+
+		tmpFile, err := os.CreateTemp("", fmt.Sprintf("%s-extract-*", binaryName))
+		if err != nil {
+			return "", fmt.Errorf("create temp file: %w", err)
+		}
+		defer tmpFile.Close()
+
+		if _, err := io.Copy(tmpFile, tr); err != nil {
+			os.Remove(tmpFile.Name())
+			return "", fmt.Errorf("extract binary: %w", err)
+		}
+		if err := tmpFile.Chmod(0755); err != nil {
+			os.Remove(tmpFile.Name())
+			return "", fmt.Errorf("chmod extracted binary: %w", err)
+		}
+		return tmpFile.Name(), nil
+	}
+
+	return "", fmt.Errorf("binary %s not found in archive", binaryName)
+}