From 1f1b83e60454ae0188c0e2764c96e0b2917181d7 Mon Sep 17 00:00:00 2001
From: "smit.codes" <smit@smit.codes>
Date: Fri, 29 May 2026 19:14:44 +0300
Subject: [PATCH] appview: zip download for repo

Implementation of [issue #581](https://tangled.org/tangled.org/core/issues/581). Adds a `zip` download when downloading a repo. Defaults to zip for windows, and `tar.gz` for non-windows with a dropdown to choose the preferred format.

Signed-off-by: Smit Patil <smit@smit.codes>
---
 .../repo/fragments/artifactList.html          |  2 +-
 .../repo/fragments/cloneDropdown.html         | 26 +++++--
 appview/repo/archive.go                       | 51 ++++++++++++--
 input.css                                     |  7 +-
 knotmirror/xrpc/git_get_archive.go            | 70 ++++++++++++++-----
 knotserver/git/cmd.go                         | 23 ++++++
 knotserver/xrpc/repo_archive.go               | 27 +++----
 7 files changed, 153 insertions(+), 53 deletions(-)

diff --git a/appview/pages/templates/repo/fragments/artifactList.html b/appview/pages/templates/repo/fragments/artifactList.html
index ec047857..eae6816f 100644
--- a/appview/pages/templates/repo/fragments/artifactList.html
+++ b/appview/pages/templates/repo/fragments/artifactList.html
@@ -13,7 +13,7 @@
     <div id="artifact-git-source" class="flex items-center justify-between p-2 border-b border-gray-200 dark:border-gray-700">
       <div id="left-side" class="flex items-center gap-2 min-w-0 max-w-[60%]">
         {{ i "archive" "w-4 h-4" }}
-        <a href="/{{ $root.RepoInfo.FullName }}/archive/{{ pathEscape (print "refs/tags/" $tag.Name) }}" class="no-underline hover:no-underline">
+        <a href="/{{ $root.RepoInfo.FullName }}/archive/{{ pathEscape (print "refs/tags/" $tag.Name) }}?format=tar.gz" class="no-underline hover:no-underline">
             Source code (.tar.gz)
         </a>
       </div>
diff --git a/appview/pages/templates/repo/fragments/cloneDropdown.html b/appview/pages/templates/repo/fragments/cloneDropdown.html
index d429a561..d2673917 100644
--- a/appview/pages/templates/repo/fragments/cloneDropdown.html
+++ b/appview/pages/templates/repo/fragments/cloneDropdown.html
@@ -53,13 +53,25 @@
       For self-hosted knots, clone URLs may differ based on your setup.
     </p>
 
-    <a
-      href="/{{ .RepoInfo.FullName }}/archive/{{ .Ref | urlquery }}"
-      class="flex items-center btn-create w-full mt-4 gap-2 text-sm hover:no-underline hover:text-gray-100"
-      >
-      {{ i "download" "w-4 h-4" }}
-      Download tar.gz
-    </a>
+    <br/>
+    <hr/>
+
+    <div class="flex gap-2 mt-4">
+      <a
+        href="/{{ .RepoInfo.FullName }}/archive/{{ .Ref | urlquery }}?format=tar.gz"
+        class="btn flex-1"
+        >
+        {{ i "download" "w-4 h-4" }}
+        Download tar.gz
+      </a>
+      <a
+        href="/{{ .RepoInfo.FullName }}/archive/{{ .Ref | urlquery }}?format=zip"
+        class="btn flex-1"
+        >
+        {{ i "download" "w-4 h-4" }}
+        Download .zip
+      </a>
+    </div>
   </div>
 
   <style>
diff --git a/appview/repo/archive.go b/appview/repo/archive.go
index eadbe015..c60d2444 100644
--- a/appview/repo/archive.go
+++ b/appview/repo/archive.go
@@ -15,7 +15,8 @@ func (rp *Repo) DownloadArchive(w http.ResponseWriter, r *http.Request) {
 	l := rp.logger.With("handler", "DownloadArchive")
 	ref := chi.URLParam(r, "ref")
 	ref, _ = url.PathUnescape(ref)
-	ref = strings.TrimSuffix(ref, ".tar.gz")
+	format := r.URL.Query().Get("format")
+	ref, format = archiveRefAndFormat(ref, format, r.UserAgent())
 	f, err := rp.repoResolver.Resolve(r)
 	if err != nil {
 		l.Error("failed to get repo and knot", "err", err)
@@ -26,7 +27,7 @@ func (rp *Repo) DownloadArchive(w http.ResponseWriter, r *http.Request) {
 	query := url.Values{}
 	query.Set("repo", f.RepoDid)
 	query.Set("ref", ref)
-	query.Set("format", "tar.gz")
+	query.Set("format", format)
 	query.Set("prefix", r.URL.Query().Get("prefix"))
 	xrpcURL := fmt.Sprintf(
 		"%s/xrpc/%s?%s",
@@ -44,23 +45,22 @@ func (rp *Repo) DownloadArchive(w http.ResponseWriter, r *http.Request) {
 	}
 	defer resp.Body.Close()
 
-	// force application/gzip here
-	w.Header().Set("Content-Type", "application/gzip")
+	w.Header().Set("Content-Type", archiveContentType(format))
 
 	filename := ""
 	if cd := resp.Header.Get("Content-Disposition"); strings.HasPrefix(cd, "attachment;") {
 		filename = cd // knot has already set the attachment CD
 	}
 	if filename == "" {
-		filename = fmt.Sprintf("attachment; filename=\"%s-%s.tar.gz\"", f.Name, ref)
+		filename = fmt.Sprintf("attachment; filename=\"%s-%s.%s\"", f.Name, ref, format)
 	}
 	w.Header().Set("Content-Disposition", filename)
 	w.Header().Set("X-Content-Type-Options", "nosniff")
 
 	if link := resp.Header.Get("Link"); link != "" {
 		if resolvedRef, err := extractImmutableLink(link); err == nil {
-			newLink := fmt.Sprintf("<%s/%s/archive/%s.tar.gz>; rel=\"immutable\"",
-				rp.config.Core.BaseUrl(), f.RepoIdentifier(), resolvedRef)
+			newLink := fmt.Sprintf("<%s/%s/archive/%s.%s>; rel=\"immutable\"",
+				rp.config.Core.BaseUrl(), f.RepoIdentifier(), resolvedRef, format)
 			w.Header().Set("Link", newLink)
 		}
 	}
@@ -71,6 +71,43 @@ func (rp *Repo) DownloadArchive(w http.ResponseWriter, r *http.Request) {
 	}
 }
 
+func archiveRefAndFormat(ref string, requestedFormat string, userAgent string) (string, string) {
+	switch {
+	case strings.HasSuffix(ref, ".tar.gz"):
+		ref = strings.TrimSuffix(ref, ".tar.gz")
+		if requestedFormat == "" {
+			requestedFormat = "tar.gz"
+		}
+	case strings.HasSuffix(ref, ".zip"):
+		ref = strings.TrimSuffix(ref, ".zip")
+		if requestedFormat == "" {
+			requestedFormat = "zip"
+		}
+	}
+
+	switch requestedFormat {
+	case "zip", "tar.gz":
+		return ref, requestedFormat
+	default:
+		if prefersZipArchive(userAgent) {
+			return ref, "zip"
+		}
+		return ref, "tar.gz"
+	}
+}
+
+func prefersZipArchive(userAgent string) bool {
+	ua := strings.ToLower(userAgent)
+	return strings.Contains(ua, "windows") || strings.Contains(ua, "win64") || strings.Contains(ua, "win32")
+}
+
+func archiveContentType(format string) string {
+	if format == "zip" {
+		return "application/zip"
+	}
+	return "application/gzip"
+}
+
 func extractImmutableLink(linkHeader string) (string, error) {
 	trimmed := strings.TrimPrefix(linkHeader, "<")
 	trimmed = strings.TrimSuffix(trimmed, ">; rel=\"immutable\"")
diff --git a/input.css b/input.css
index 412f6727..4834fb42 100644
--- a/input.css
+++ b/input.css
@@ -201,13 +201,14 @@
     @layer components {
         .btn {
             @apply relative z-10 inline-flex overflow-hidden items-center justify-center
-          min-h-[32px] px-2 py-[6px]
+          min-h-[32px] px-2 py-[6px] gap-1.5
           rounded border border-gray-200 dark:border-gray-700
           bg-white dark:bg-gray-800
           text-sm text-gray-900 dark:text-gray-100
           transition-colors duration-150 ease-in-out
           outline-transparent cursor-pointer
-          focus-visible:outline focus-visible:outline-2 focus-visible:outline-gray-400 dark:focus-visible:outline-gray-600;
+          focus-visible:outline focus-visible:outline-2 focus-visible:outline-gray-400 dark:focus-visible:outline-gray-600
+          no-underline hover:no-underline;
 
             @apply before:absolute before:inset-0 before:-z-10 before:block before:rounded-sm before:content-['']
           before:transition-all before:duration-150 before:ease-in-out
@@ -270,7 +271,7 @@
           max-h-[32px]
           rounded border border-gray-200 dark:border-gray-700
           divide-x divide-gray-200 dark:divide-gray-700
-          overflow-hidden;
+          overflow-clip;
         }
 
         .btn-group-item {
diff --git a/knotmirror/xrpc/git_get_archive.go b/knotmirror/xrpc/git_get_archive.go
index d48992b7..62f789e8 100644
--- a/knotmirror/xrpc/git_get_archive.go
+++ b/knotmirror/xrpc/git_get_archive.go
@@ -1,7 +1,10 @@
 package xrpc
 
 import (
+	"bytes"
+	"context"
 	"fmt"
+	"io"
 	"net/http"
 	"net/url"
 	"os/exec"
@@ -29,13 +32,13 @@ func (x *Xrpc) GetArchive(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
-	if format != "tar.gz" {
-		writeJson(w, http.StatusBadRequest, atclient.ErrorBody{Name: "BadRequest", Message: "only tar.gz format is supported"})
-		return
-	}
 	if format == "" {
 		format = "tar.gz"
 	}
+	if format != "tar.gz" && format != "zip" {
+		writeJson(w, http.StatusBadRequest, atclient.ErrorBody{Name: "BadRequest", Message: "only tar.gz and zip formats are supported"})
+		return
+	}
 
 	l := x.logger.With("repo", repo, "ref", ref, "format", format, "prefix", prefix)
 	l.Debug("request")
@@ -57,6 +60,14 @@ func (x *Xrpc) GetArchive(w http.ResponseWriter, r *http.Request) {
 		rev = "HEAD"
 	}
 	commit, err := gitea.GetCommit(ctx, repoPath, rev)
+	if err != nil {
+		l.Warn("local mirror failed, trying proxy", "err", err)
+		if x.proxyToKnot(w, r, repo) {
+			return
+		}
+		writeJson(w, http.StatusInternalServerError, atclient.ErrorBody{Name: "InternalServerError", Message: "failed to resolve ref"})
+		return
+	}
 
 	repoName, err := func() (string, error) {
 		r, err := db.GetRepoByRepoDid(ctx, x.db, repo)
@@ -78,6 +89,9 @@ func (x *Xrpc) GetArchive(w http.ResponseWriter, r *http.Request) {
 	}
 
 	safeRefFilename := strings.ReplaceAll(plumbing.ReferenceName(ref).Short(), "/", "-")
+	if safeRefFilename == "" {
+		safeRefFilename = commit.Hash.String()
+	}
 	immutableLink := func() string {
 		params := url.Values{}
 		params.Set("repo", repo.String())
@@ -87,27 +101,45 @@ func (x *Xrpc) GetArchive(w http.ResponseWriter, r *http.Request) {
 		return fmt.Sprintf("%s/xrpc/%s?%s", x.cfg.BaseUrl(), tangled.GitTempGetArchiveNSID, params.Encode())
 	}()
 
-	filename := fmt.Sprintf("%s-%s.tar.gz", repoName, safeRefFilename)
+	var archivePrefix string
+	if prefix != "" {
+		archivePrefix = prefix
+	} else {
+		archivePrefix = fmt.Sprintf("%s-%s", repoName, safeRefFilename)
+	}
+
+	filename := fmt.Sprintf("%s-%s.%s", repoName, safeRefFilename, format)
 	w.Header().Set("Content-Disposition", fmt.Sprintf("attachment; filename=\"%s\"", filename))
-	w.Header().Set("Content-Type", "application/gzip")
+	w.Header().Set("Content-Type", archiveContentType(format))
 	w.Header().Set("Link", fmt.Sprintf("<%s>; rel=\"immutable\"", immutableLink))
 
-	cmd := exec.Command(
-		"git",
-		"archive",
-		fmt.Sprintf("--prefix=%s", prefix),
-		"--format=tar.gz",
-		commit.Hash.String(),
-	)
+	if err := writeLocalArchive(ctx, w, repoPath, commit.Hash.String(), format, archivePrefix); err != nil {
+		l.Error("writing archive", "err", err.Error(), "format", format)
+		w.WriteHeader(http.StatusInternalServerError)
+	}
+}
 
-	var stderr strings.Builder
-	cmd.Dir = repoPath
+func archiveContentType(format string) string {
+	if format == "zip" {
+		return "application/zip"
+	}
+	return "application/gzip"
+}
+
+func writeLocalArchive(ctx context.Context, w io.Writer, repoPath, rev, format, prefix string) error {
+	args := []string{"-C", repoPath, "archive", "--format=" + format}
+	if prefix != "" {
+		args = append(args, "--prefix="+strings.TrimRight(prefix, "/")+"/")
+	}
+	args = append(args, rev)
+
+	cmd := exec.CommandContext(ctx, "git", args...)
 	cmd.Stdout = w
-	cmd.Stderr = &stderr
+	stderr := new(bytes.Buffer)
+	cmd.Stderr = stderr
 
 	if err := cmd.Run(); err != nil {
-		err = fmt.Errorf("%w\n%s", err, stderr.String())
-		l.Error("failed to archive", "err", err)
-		w.WriteHeader(http.StatusInternalServerError)
+		return fmt.Errorf("%w, stderr: %s", err, stderr.String())
 	}
+	return nil
 }
diff --git a/knotserver/git/cmd.go b/knotserver/git/cmd.go
index b359d7a4..e44a0f9b 100644
--- a/knotserver/git/cmd.go
+++ b/knotserver/git/cmd.go
@@ -1,8 +1,11 @@
 package git
 
 import (
+	"bytes"
 	"fmt"
+	"io"
 	"os/exec"
+	"strings"
 )
 
 const (
@@ -44,3 +47,23 @@ func (g *GitRepo) revParse(extraArgs ...string) ([]byte, error) {
 func (g *GitRepo) mergeBase(extraArgs ...string) ([]byte, error) {
 	return g.runGitCmd("merge-base", extraArgs...)
 }
+
+func (g *GitRepo) WriteArchive(w io.Writer, format string, prefix string) error {
+	args := []string{"archive", "--format=" + format}
+	if prefix != "" {
+		args = append(args, "--prefix="+strings.TrimRight(prefix, "/")+"/")
+	}
+	args = append(args, g.h.String())
+
+	cmd := exec.Command("git", args...)
+	cmd.Dir = g.path
+	cmd.Stdout = w
+	stderr := new(bytes.Buffer)
+	cmd.Stderr = stderr
+
+	if err := cmd.Run(); err != nil {
+		return fmt.Errorf("%w, stderr: %s", err, stderr.String())
+	}
+
+	return nil
+}
diff --git a/knotserver/xrpc/repo_archive.go b/knotserver/xrpc/repo_archive.go
index 4148ba62..fd22a2fd 100644
--- a/knotserver/xrpc/repo_archive.go
+++ b/knotserver/xrpc/repo_archive.go
@@ -1,7 +1,6 @@
 package xrpc
 
 import (
-	"compress/gzip"
 	"fmt"
 	"net/http"
 	"net/url"
@@ -32,10 +31,10 @@ func (x *Xrpc) RepoArchive(w http.ResponseWriter, r *http.Request) {
 
 	prefix := r.URL.Query().Get("prefix")
 
-	if format != "tar.gz" {
+	if format != "tar.gz" && format != "zip" {
 		writeError(w, xrpcerr.NewXrpcError(
 			xrpcerr.WithTag("InvalidRequest"),
-			xrpcerr.WithMessage("only tar.gz format is supported"),
+			xrpcerr.WithMessage("only tar.gz and zip formats are supported"),
 		), http.StatusBadRequest)
 		return
 	}
@@ -70,29 +69,25 @@ func (x *Xrpc) RepoArchive(w http.ResponseWriter, r *http.Request) {
 		archivePrefix = fmt.Sprintf("%s-%s", repoName, safeRefFilename)
 	}
 
-	filename := fmt.Sprintf("%s-%s.tar.gz", repoName, safeRefFilename)
+	filename := fmt.Sprintf("%s-%s.%s", repoName, safeRefFilename, format)
 	w.Header().Set("Content-Disposition", fmt.Sprintf("attachment; filename=\"%s\"", filename))
-	w.Header().Set("Content-Type", "application/gzip")
+	w.Header().Set("Content-Type", archiveContentType(format))
 	w.Header().Set("Link", fmt.Sprintf("<%s>; rel=\"immutable\"", immutableLink))
 
-	gw := gzip.NewWriter(w)
-	defer gw.Close()
-
-	err = gr.WriteTar(gw, archivePrefix)
+	err = gr.WriteArchive(w, format, archivePrefix)
 	if err != nil {
 		// once we start writing to the body we can't report error anymore
 		// so we are only left with logging the error
-		x.Logger.Error("writing tar file", "error", err.Error())
+		x.Logger.Error("writing archive", "error", err.Error(), "format", format)
 		return
 	}
+}
 
-	err = gw.Flush()
-	if err != nil {
-		// once we start writing to the body we can't report error anymore
-		// so we are only left with logging the error
-		x.Logger.Error("flushing", "error", err.Error())
-		return
+func archiveContentType(format string) string {
+	if format == "zip" {
+		return "application/zip"
 	}
+	return "application/gzip"
 }
 
 func (x *Xrpc) buildImmutableLink(repo string, format string, ref string, prefix string) (string, error) {
-- 
2.51.2