fix: push witt cwd

Author: MarcStdt

internal/core/services/registry/oci.go

@@ -4,6 +4,7 @@ import (
 	"context"
 	"encoding/json"
 	"fmt"
+	"net/http"
 	"os"
 	"path/filepath"
 	"strings"
@@ -24,6 +25,11 @@ import (
 
 type OciClient struct {
 	credentialStore *CredentialStore
+	// httpClient optionally overrides the HTTP client used by GetRepo.
+	// When nil, the default retry client or auth client is used.
+	httpClient *http.Client
+	// plainHTTP forces plain HTTP (no TLS) for registry communication.
+	plainHTTP bool
 }
 
 func NewOciClient(credentialStore *CredentialStore) *OciClient {
@@ -38,13 +44,26 @@ func (c *OciClient) GetRepo(repoUrl string) (*remote.Repository, error) {
 		return nil, err
 	}
 
+	repo.PlainHTTP = c.plainHTTP
+
+	httpClient := retry.DefaultClient
+	if c.httpClient != nil {
+		httpClient = c.httpClient
+	}
+
 	cred, _ := c.credentialStore.CredentialForRepo(repoUrl)
 	if cred.Username == "" || cred.Password == "" {
 		logger.Log().Warn("No registry credentials found for " + repoUrl + ". Trying to pull anonymously")
+		if c.httpClient != nil {
+			repo.Client = &auth.Client{
+				Client: httpClient,
+				Cache:  auth.DefaultCache,
+			}
+		}
 	} else {
 		host := extractHost(repoUrl)
 		repo.Client = &auth.Client{
-			Client:     retry.DefaultClient,
+			Client:     httpClient,
 			Cache:      auth.DefaultCache,
 			Credential: auth.StaticCredential(host, cred),
 		}
@@ -311,9 +330,22 @@ func (c *OciClient) Push(folder string, repo string, tag string, overrides map[s
 				logger.Log().Warn(fmt.Sprintf("data chunk path %s does not exist, skipping", chunk.Path))
 				continue
 			}
+			fileInfo, err := os.Stat(chunkFullPath)
+			if err != nil {
+				return v1.Descriptor{}, fmt.Errorf("failed to stat data chunk %s: %w", chunk.Name, err)
+			}
+			// Some registries reject zero-byte blob uploads (sha256:e3b0...).
+			// Skip empty data files to keep push resilient.
+			if fileInfo.Mode().IsRegular() && fileInfo.Size() == 0 {
+				logger.Log().Warn(fmt.Sprintf("data chunk %s is empty, skipping", chunk.Path))
+				continue
+			}
 			// Name the layer "data/<path>" so it extracts to the correct location on pull
 			layerName := filepath.Join("data", chunk.Path)
-			desc, err := fs.Add(context.Background(), layerName, string(domain.ArtifactTypeScrollData), chunkFullPath)
+			// Use a path relative to the file store root (folder), not the full chunkFullPath,
+			// because fs.Add resolves relative paths against its working directory.
+			chunkStoreRelPath := filepath.Join("data", chunk.Path)
+			desc, err := fs.Add(context.Background(), layerName, string(domain.ArtifactTypeScrollData), chunkStoreRelPath)
 			if err != nil {
 				return v1.Descriptor{}, fmt.Errorf("failed to pack data chunk %s: %w", chunk.Name, err)
 			}

internal/core/services/registry/oci_test.go

@@ -0,0 +1,115 @@
+package registry
+
+import (
+	"fmt"
+	"net/http"
+	"net/http/httptest"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"github.com/highcard-dev/daemon/internal/core/domain"
+)
+
+// fakeRegistry returns a plain-HTTP httptest server that implements the bare
+// minimum of the OCI Distribution spec so that oras.Copy can complete a push.
+func fakeRegistry(t *testing.T) *httptest.Server {
+	t.Helper()
+	blobs := map[string][]byte{}
+	mux := http.NewServeMux()
+
+	mux.HandleFunc("GET /v2/", func(w http.ResponseWriter, r *http.Request) {
+		w.WriteHeader(http.StatusOK)
+	})
+
+	mux.HandleFunc("HEAD /v2/{rest...}", func(w http.ResponseWriter, r *http.Request) {
+		parts := strings.Split(r.URL.Path, "/blobs/")
+		if len(parts) == 2 {
+			if _, ok := blobs[parts[1]]; ok {
+				w.WriteHeader(http.StatusOK)
+				return
+			}
+		}
+		w.WriteHeader(http.StatusNotFound)
+	})
+
+	mux.HandleFunc("POST /v2/{rest...}", func(w http.ResponseWriter, r *http.Request) {
+		w.Header().Set("Location", fmt.Sprintf("%s?upload=1", r.URL.Path))
+		w.WriteHeader(http.StatusAccepted)
+	})
+
+	mux.HandleFunc("PUT /v2/{rest...}", func(w http.ResponseWriter, r *http.Request) {
+		digest := r.URL.Query().Get("digest")
+		if digest != "" {
+			body := make([]byte, r.ContentLength)
+			r.Body.Read(body)
+			blobs[digest] = body
+			w.Header().Set("Docker-Content-Digest", digest)
+			w.WriteHeader(http.StatusCreated)
+			return
+		}
+		body := make([]byte, r.ContentLength)
+		r.Body.Read(body)
+		w.WriteHeader(http.StatusCreated)
+	})
+
+	srv := httptest.NewServer(mux)
+	t.Cleanup(srv.Close)
+	return srv
+}
+
+// TestPushDataChunkPathNotDoubled calls OciClient.Push directly with a
+// relative scroll folder containing a data directory, pushing to a fake
+// in-process OCI registry. This verifies the data-chunk file paths are
+// resolved correctly (store-relative) and do not get doubled.
+//
+// Regression test for: when --cwd is a relative path like
+// ./scrolls/minecraft/1.17, the ORAS file store root is resolved to an
+// absolute path internally. Passing the full relative chunkFullPath
+// (scrolls/minecraft/1.17/data/<file>) to fs.Add caused the store to look
+// for <abs-root>/scrolls/minecraft/1.17/data/<file> which doesn't exist.
+func TestPushDataChunkPathNotDoubled(t *testing.T) {
+	tmpDir := t.TempDir()
+	t.Chdir(tmpDir)
+
+	srv := fakeRegistry(t)
+	// httptest URL is http://127.0.0.1:<port>; strip scheme for oras.
+	registryHost := strings.TrimPrefix(srv.URL, "http://")
+
+	// Build a minimal scroll directory tree via a relative path.
+	relFolder := filepath.Join("scrolls", "minecraft", "1.17")
+	if err := os.MkdirAll(relFolder, 0755); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(
+		filepath.Join(relFolder, "scroll.yaml"),
+		[]byte("name: test\nversion: 0.1.0\napp_version: \"1.17\"\n"),
+		0644,
+	); err != nil {
+		t.Fatal(err)
+	}
+
+	// Create a data directory with a file – this is the path that was doubled.
+	dataDir := filepath.Join(relFolder, "data")
+	if err := os.MkdirAll(dataDir, 0755); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(filepath.Join(dataDir, "server.properties"), []byte("motd=test\n"), 0644); err != nil {
+		t.Fatal(err)
+	}
+
+	// Create an OciClient configured for plain HTTP pointing at our fake registry.
+	credStore := NewCredentialStore([]domain.RegistryCredential{})
+	client := &OciClient{
+		credentialStore: credStore,
+		plainHTTP:       true,
+	}
+
+	repoRef := registryHost + "/test/scroll"
+
+	_, err := client.Push(relFolder, repoRef, "1.17", map[string]string{}, false, nil)
+	if err != nil {
+		t.Fatalf("Push failed unexpectedly: %v", err)
+	}
+}