Add local npm registry publish and install

README.md

@@ -261,21 +261,6 @@ there's nothing to provision. To bring your own key instead, point
 `TF_SIGNING_KEY_PASSPHRASE`), which takes precedence over the generated one.
 `TF_PROVIDER_PROTOCOLS` (default `5.0,6.0`) sets the advertised plugin protocols.
 
-### Local helm repository
-
-A local `helm` repo is a real chart repository: `PUT` a packaged chart to
-`/api/v2/remotes/<repo>/files/<chart>-<version>.tgz` and `index.yaml` is
-generated from each chart's `Chart.yaml` (with sha256 digests) at
-`/api/v1/local/<repo>/index.yaml`. Add the local as a member of a helm virtual
-to serve it alongside remotes.
-
-```bash
-helm package ./mychart
-curl -fsSL --upload-file mychart-0.1.0.tgz \
-  https://artifactapi.k8s.syd1.au.unkin.net/api/v2/remotes/<repo>/files/mychart-0.1.0.tgz
-helm repo add <repo> https://artifactapi.k8s.syd1.au.unkin.net/api/v1/local/<repo>
-```
-
 ### Local docker registry
 
 A local `docker` repo is a real container registry, not a mirror: it serves the
@@ -294,6 +279,20 @@ content-addressable store (deduplicated by digest, reaped by GC once
 unreferenced); tags are mutable references and re-pushing a tag moves it. Blob
 uploads support both the monolithic and chunked (`POST`/`PATCH`/`PUT`) flows.
 
+### Local npm registry
+
+A local `npm` repo is a real npm registry: `npm publish` (scoped and unscoped)
+and `npm install` work against `/api/v1/local/{name}/`. npm requires an
+`_authToken` for the registry before it will publish; any value works.
+
+```ini
+# .npmrc
+registry=https://artifactapi.k8s.syd1.au.unkin.net/api/v1/local/npm-internal/
+//artifactapi.k8s.syd1.au.unkin.net/api/v1/local/npm-internal/:_authToken=unused
+```
+
+Versions are immutable; dist-tags sent with a publish move to that version.
+
 ## Access Control
 
 | Field | Default | Behaviour |
@@ -312,6 +311,7 @@ No patterns + no blocklist = open proxy. Provider handles mutability classificat
 ```
 GET /api/v1/remote/{name}/{path}     Proxy/cache artifact
 GET /api/v1/virtual/{name}/{path}    Virtual repo (merged index)
+PUT /api/v1/local/{name}/{package}   npm publish (local npm repos)
 GET /v2/{name}/{path}                Docker Registry v2
 ```
 

e2e-docker/README.md

@@ -27,7 +27,9 @@ already-running stack.
   mock upstream: first fetch `X-Artifact-Source: remote`, second `cache`, bytes
   verified against the origin fixture.
 - **Local uploads** — generic (upload/download), pypi (wheel + generated `simple/`
-  index), rpm (real package + **automatic repodata** generation).
+  index), rpm (real package + **automatic repodata** generation), npm (stock
+  `node:22` client: `npm publish` unscoped + scoped, `npm install` + `require()`,
+  second version, republish rejected).
 - **Virtual repositories** — pypi simple-index merge and helm `index.yaml` merge
   across two members.
 - **Mirrorlist** — an rpm remote with a `mirrorlist` of extra upstream mirrors

e2e-docker/helm_local_test.go

@@ -1,71 +0,0 @@
-//go:build dockere2e
-
-package e2edocker
-
-import (
-	"net/http"
-	"os"
-	"os/exec"
-	"strings"
-	"testing"
-	"time"
-)
-
-// TestLocalHelmRealClient packages a chart with the real helm CLI, publishes it
-// to a helm local, then drives helm repo add/search/pull/template against the
-// local and against a helm virtual that has the local as a member.
-func TestLocalHelmRealClient(t *testing.T) {
-	network := os.Getenv("COMPOSE_NETWORK")
-	internal := strings.TrimRight(os.Getenv("ARTIFACTAPI_INTERNAL"), "/")
-	if network == "" || internal == "" {
-		t.Skip("COMPOSE_NETWORK/ARTIFACTAPI_INTERNAL not set; run via scripts/docker-e2e.sh")
-	}
-	if _, err := exec.LookPath("docker"); err != nil {
-		t.Skip("docker not available on the test host")
-	}
-
-	createRepo(t, `{"name":"local-helm","package_type":"helm","repo_type":"local"}`)
-	defer deleteRepo(t, "local-helm")
-	createVirtual(t, `{"name":"vhelm","package_type":"helm","members":["local-helm"]}`)
-	defer deleteVirtual(t, "vhelm")
-
-	helm := func(script string) string {
-		t.Helper()
-		out, err := exec.Command("docker", "run", "--rm", "--network", network, "--entrypoint", "sh",
-			"alpine/helm:3.16.4", "-c", "set -eu; "+script).Output()
-		if err != nil {
-			stderr := ""
-			if ee, ok := err.(*exec.ExitError); ok {
-				stderr = string(ee.Stderr)
-			}
-			t.Fatalf("helm script failed: %v\n%s%s", err, out, stderr)
-		}
-		return string(out)
-	}
-
-	chart := helm("cd /tmp && helm create e2echart >/dev/null && helm package e2echart >/dev/null && cat e2echart-0.1.0.tgz")
-	uploadFile(t, "local-helm", "e2echart-0.1.0.tgz", []byte(chart), "application/gzip")
-
-	// Chart metadata is recorded asynchronously after upload; poll the index.
-	var body []byte
-	for deadline := time.Now().Add(15 * time.Second); time.Now().Before(deadline); time.Sleep(500 * time.Millisecond) {
-		var resp *http.Response
-		resp, body = doRequest(t, http.MethodGet, api("/api/v1/local/local-helm/index.yaml"), nil, "")
-		if resp.StatusCode == http.StatusOK && strings.Contains(string(body), "e2echart-0.1.0.tgz") {
-			break
-		}
-	}
-	if !strings.Contains(string(body), "e2echart-0.1.0.tgz") || !strings.Contains(string(body), "digest: ") {
-		t.Fatalf("index.yaml never listed the chart:\n%s", body)
-	}
-
-	for _, repoURL := range []string{internal + "/api/v1/local/local-helm", internal + "/api/v1/virtual/vhelm"} {
-		out := helm("helm repo add e2e " + repoURL + " >/dev/null && " +
-			"helm search repo e2e/e2echart && " +
-			"cd /tmp && helm pull e2e/e2echart --version 0.1.0 && " +
-			"helm template rel e2echart-0.1.0.tgz | grep -c 'kind: Deployment'")
-		if !strings.Contains(out, "e2e/e2echart") || !strings.Contains(out, "0.1.0") || !strings.HasSuffix(strings.TrimSpace(out), "1") {
-			t.Fatalf("helm via %s:\n%s", repoURL, out)
-		}
-	}
-}

e2e-docker/npm_local_test.go

@@ -0,0 +1,62 @@
+//go:build dockere2e
+
+package e2edocker
+
+import (
+	"fmt"
+	"os"
+	"os/exec"
+	"strings"
+	"testing"
+	"time"
+)
+
+// TestLocalNPMPublishInstall drives a stock npm client against a local npm
+// repo: publish unscoped and scoped packages, install and require() them in a
+// fresh project, publish a second version, and reject a republish.
+func TestLocalNPMPublishInstall(t *testing.T) {
+	network := os.Getenv("COMPOSE_NETWORK")
+	internal := os.Getenv("ARTIFACTAPI_INTERNAL")
+	if network == "" || internal == "" {
+		t.Skip("COMPOSE_NETWORK/ARTIFACTAPI_INTERNAL not set; run via scripts/docker-e2e.sh")
+	}
+	if _, err := exec.LookPath("docker"); err != nil {
+		t.Skip("docker not available on the test host")
+	}
+
+	name := fmt.Sprintf("e2e-npm-local-%d", time.Now().UnixNano())
+	createRepo(t, fmt.Sprintf(`{"name":%q,"package_type":"npm","repo_type":"local"}`, name))
+	defer deleteRepo(t, name)
+
+	reg := strings.TrimRight(internal, "/") + "/api/v1/local/" + name + "/"
+	script := `set -euo pipefail
+printf 'registry=%s\n%s:_authToken=unused\n' "$REG" "${REG#http:}" > ~/.npmrc
+mk() { d="/w/src/$1-$2"; mkdir -p "$d"; cd "$d"
+  printf '{"name":"%s","version":"%s","main":"index.js"}' "$1" "$2" > package.json
+  echo "module.exports = '$1@$2';" > index.js; }
+mk e2e-npm-plain 1.0.0 && npm publish
+mk @e2e/npm-scoped 1.0.0 && npm publish
+mk e2e-npm-plain 1.0.0
+if npm publish 2>/dev/null; then echo "republish accepted"; exit 1; fi
+mkdir -p /w/app && cd /w/app && npm init -y >/dev/null
+npm install --no-audit --cache /tmp/fresh-cache e2e-npm-plain @e2e/npm-scoped
+node -e "console.log('REQ', require('e2e-npm-plain'), require('@e2e/npm-scoped'))"
+mk e2e-npm-plain 1.1.0 && npm publish
+echo "VERSIONS $(npm view e2e-npm-plain versions --json | tr -d ' \n')"
+echo "LATEST $(npm view e2e-npm-plain dist-tags.latest)"`
+
+	out, err := exec.Command("docker", "run", "--rm", "--network", network,
+		"-e", "REG="+reg, "node:22", "bash", "-c", script).CombinedOutput()
+	if err != nil {
+		t.Fatalf("npm client run failed: %v\n%s", err, out)
+	}
+	for _, want := range []string{
+		"REQ e2e-npm-plain@1.0.0 @e2e/npm-scoped@1.0.0",
+		`VERSIONS ["1.0.0","1.1.0"]`,
+		"LATEST 1.1.0",
+	} {
+		if !strings.Contains(string(out), want) {
+			t.Fatalf("missing %q in npm output:\n%s", want, out)
+		}
+	}
+}

internal/api/v1/npm.go

@@ -0,0 +1,286 @@
+package v1
+
+import (
+	"bytes"
+	"context"
+	"crypto/sha1"
+	"crypto/sha512"
+	"encoding/base64"
+	"encoding/hex"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"io"
+	"log/slog"
+	"net/http"
+	"net/url"
+	"regexp"
+	"strings"
+
+	"github.com/go-chi/chi/v5"
+
+	"git.unkin.net/unkin/artifactapi/internal/database"
+	"git.unkin.net/unkin/artifactapi/internal/storage"
+	"git.unkin.net/unkin/artifactapi/pkg/models"
+)
+
+// Local npm repos speak the npm registry publish/read protocol. Per package:
+//   <pkg>/-/<base>-<version>.tgz   tarball (immutable)
+//   <pkg>/-/<base>-<version>.json  version manifest (immutable)
+//   <pkg>/-/dist-tags/<tag>        version string (mutable)
+
+var (
+	npmNameRe = regexp.MustCompile(`^(@[a-z0-9][a-z0-9._~-]*/)?[a-z0-9][a-z0-9._~-]*$`)
+	npmRefRe  = regexp.MustCompile(`^[0-9A-Za-z][0-9A-Za-z.+_-]*$`)
+)
+
+func (h *ProxyHandler) localNPMRemote(r *http.Request, name string) (*models.Remote, bool) {
+	remote, err := h.db.GetRemote(r.Context(), name)
+	if err != nil {
+		return nil, false
+	}
+	return remote, remote.RepoType == models.RepoTypeLocal && remote.PackageType == models.PackageNPM
+}
+
+// npmPackageName returns the package a packument/publish path addresses, or ""
+// when the path is something else (e.g. a tarball under <pkg>/-/).
+func npmPackageName(raw string) string {
+	p, err := url.PathUnescape(raw)
+	if err != nil {
+		return ""
+	}
+	p = strings.TrimSuffix(p, "/")
+	if !npmNameRe.MatchString(p) {
+		return ""
+	}
+	return p
+}
+
+type npmRelease struct {
+	version  string
+	manifest []byte
+	tarball  []byte
+	tags     []string
+}
+
+func parseNPMPublish(body io.Reader, pkg string) (*npmRelease, error) {
+	var doc struct {
+		Name        string                     `json:"name"`
+		DistTags    map[string]string          `json:"dist-tags"`
+		Versions    map[string]json.RawMessage `json:"versions"`
+		Attachments map[string]struct {
+			Data string `json:"data"`
+		} `json:"_attachments"`
+	}
+	if err := json.NewDecoder(body).Decode(&doc); err != nil {
+		return nil, fmt.Errorf("invalid publish body: %w", err)
+	}
+	if doc.Name != pkg {
+		return nil, fmt.Errorf("body name %q does not match %q", doc.Name, pkg)
+	}
+	if len(doc.Versions) != 1 || len(doc.Attachments) != 1 {
+		return nil, errors.New("publish must carry exactly one version and one tarball")
+	}
+
+	rel := &npmRelease{}
+	for v, m := range doc.Versions {
+		rel.version, rel.manifest = v, m
+	}
+	if !npmRefRe.MatchString(rel.version) {
+		return nil, fmt.Errorf("invalid version %q", rel.version)
+	}
+	var meta struct {
+		Name    string `json:"name"`
+		Version string `json:"version"`
+		Dist    struct {
+			Integrity string `json:"integrity"`
+			Shasum    string `json:"shasum"`
+		} `json:"dist"`
+	}
+	if err := json.Unmarshal(rel.manifest, &meta); err != nil {
+		return nil, fmt.Errorf("invalid version manifest: %w", err)
+	}
+	if meta.Name != pkg || meta.Version != rel.version {
+		return nil, errors.New("version manifest name/version mismatch")
+	}
+
+	for _, a := range doc.Attachments {
+		tgz, err := base64.StdEncoding.DecodeString(a.Data)
+		if err != nil {
+			return nil, fmt.Errorf("invalid tarball encoding: %w", err)
+		}
+		rel.tarball = tgz
+	}
+	if err := verifyNPMDist(rel.tarball, meta.Dist.Integrity, meta.Dist.Shasum); err != nil {
+		return nil, err
+	}
+
+	for tag, v := range doc.DistTags {
+		if !npmRefRe.MatchString(tag) || v != rel.version {
+			return nil, fmt.Errorf("dist-tag %q must point at the published version", tag)
+		}
+		rel.tags = append(rel.tags, tag)
+	}
+	return rel, nil
+}
+
+func verifyNPMDist(tgz []byte, integrity, shasum string) error {
+	if b64, ok := strings.CutPrefix(integrity, "sha512-"); ok {
+		sum := sha512.Sum512(tgz)
+		if base64.StdEncoding.EncodeToString(sum[:]) != b64 {
+			return errors.New("tarball does not match dist.integrity")
+		}
+		return nil
+	}
+	if shasum != "" {
+		sum := sha1.Sum(tgz)
+		if hex.EncodeToString(sum[:]) != shasum {
+			return errors.New("tarball does not match dist.shasum")
+		}
+		return nil
+	}
+	return errors.New("version manifest carries no sha512 integrity or shasum")
+}
+
+func npmError(w http.ResponseWriter, status int, msg string) {
+	w.Header().Set("Content-Type", "application/json")
+	w.WriteHeader(status)
+	json.NewEncoder(w).Encode(map[string]string{"error": msg})
+}
+
+func (h *ProxyHandler) handleLocalPut(w http.ResponseWriter, r *http.Request) {
+	remote, ok := h.localNPMRemote(r, chi.URLParam(r, "localName"))
+	if !ok {
+		npmError(w, http.StatusMethodNotAllowed, "publish is only supported on local npm repositories")
+		return
+	}
+	pkg := npmPackageName(chi.URLParam(r, "*"))
+	if pkg == "" {
+		npmError(w, http.StatusBadRequest, "invalid package name")
+		return
+	}
+	rel, err := parseNPMPublish(r.Body, pkg)
+	if err != nil {
+		npmError(w, http.StatusBadRequest, err.Error())
+		return
+	}
+
+	base := pkg[strings.LastIndex(pkg, "/")+1:]
+	stem := pkg + "/-/" + base + "-" + rel.version
+	// The tarball's immutable row is the version's uniqueness gate.
+	if err := h.npmStore(r.Context(), remote.Name, stem+".tgz", rel.tarball, "application/octet-stream", false); err != nil {
+		if errors.Is(err, database.ErrAlreadyExists) {
+			npmError(w, http.StatusConflict, fmt.Sprintf("%s@%s already exists; overwrites are not allowed", pkg, rel.version))
+			return
+		}
+		npmError(w, http.StatusInternalServerError, err.Error())
+		return
+	}
+	if err := h.npmStore(r.Context(), remote.Name, stem+".json", rel.manifest, "application/json", false); err != nil {
+		npmError(w, http.StatusInternalServerError, err.Error())
+		return
+	}
+	for _, tag := range rel.tags {
+		if err := h.npmStore(r.Context(), remote.Name, pkg+"/-/dist-tags/"+tag, []byte(rel.version), "text/plain", true); err != nil {
+			npmError(w, http.StatusInternalServerError, err.Error())
+			return
+		}
+	}
+
+	slog.Info("local npm package published", "repo", remote.Name, "package", pkg, "version", rel.version)
+	w.Header().Set("Content-Type", "application/json")
+	w.WriteHeader(http.StatusCreated)
+	json.NewEncoder(w).Encode(map[string]any{"ok": true, "id": pkg})
+}
+
+func (h *ProxyHandler) npmStore(ctx context.Context, repo, path string, data []byte, contentType string, mutable bool) error {
+	result, err := h.cas.Store(ctx, bytes.NewReader(data), contentType)
+	if err != nil {
+		return err
+	}
+	if err := h.db.UpsertBlob(ctx, result.ContentHash, result.S3Key, result.SizeBytes, contentType); err != nil {
+		return err
+	}
+	if mutable {
+		return h.db.UpsertLocalFile(ctx, repo, path, result.ContentHash)
+	}
+	return h.db.CreateLocalFile(ctx, repo, path, result.ContentHash)
+}
+
+func (h *ProxyHandler) readLocalBlob(ctx context.Context, contentHash string) ([]byte, error) {
+	reader, _, err := h.store.Download(ctx, storage.BlobKey(strings.TrimPrefix(contentHash, "sha256:")))
+	if err != nil {
+		return nil, err
+	}
+	defer reader.Close()
+	return io.ReadAll(reader)
+}
+
+func (h *ProxyHandler) serveNPMPackument(w http.ResponseWriter, r *http.Request, remote *models.Remote, pkg string) {
+	files, err := h.db.ListLocalFilesByPrefix(r.Context(), remote.Name, pkg+"/-/")
+	if err != nil {
+		npmError(w, http.StatusInternalServerError, err.Error())
+		return
+	}
+	read := func(hash string) ([]byte, error) { return h.readLocalBlob(r.Context(), hash) }
+	tarballBase := fmt.Sprintf("%s://%s/api/v1/local/%s/", scheme(r), r.Host, remote.Name)
+	doc, err := buildNPMPackument(pkg, files, read, tarballBase)
+	if err != nil {
+		npmError(w, http.StatusInternalServerError, err.Error())
+		return
+	}
+	if doc == nil {
+		npmError(w, http.StatusNotFound, "not found")
+		return
+	}
+	w.Header().Set("Content-Type", "application/json")
+	w.Header().Set("X-Artifact-Source", "local")
+	w.WriteHeader(http.StatusOK)
+	json.NewEncoder(w).Encode(doc)
+}
+
+// buildNPMPackument returns nil when pkg has no published versions.
+func buildNPMPackument(pkg string, files []database.LocalFile, read func(hash string) ([]byte, error), tarballBase string) (map[string]any, error) {
+	prefix := pkg + "/-/"
+	versions := map[string]any{}
+	tags := map[string]string{}
+	for _, f := range files {
+		// LIKE treats '_' as a wildcard, so the prefix match can over-select.
+		rest, ok := strings.CutPrefix(f.FilePath, prefix)
+		if !ok {
+			continue
+		}
+		if tag, isTag := strings.CutPrefix(rest, "dist-tags/"); isTag {
+			v, err := read(f.ContentHash)
+			if err != nil {
+				return nil, err
+			}
+			tags[tag] = string(v)
+			continue
+		}
+		stem, isManifest := strings.CutSuffix(rest, ".json")
+		if !isManifest {
+			continue
+		}
+		raw, err := read(f.ContentHash)
+		if err != nil {
+			return nil, err
+		}
+		var m map[string]any
+		if err := json.Unmarshal(raw, &m); err != nil {
+			return nil, fmt.Errorf("manifest %s: %w", f.FilePath, err)
+		}
+		dist, _ := m["dist"].(map[string]any)
+		if dist == nil {
+			dist = map[string]any{}
+			m["dist"] = dist
+		}
+		dist["tarball"] = tarballBase + prefix + stem + ".tgz"
+		v, _ := m["version"].(string)
+		versions[v] = m
+	}
+	if len(versions) == 0 {
+		return nil, nil
+	}
+	return map[string]any{"_id": pkg, "name": pkg, "dist-tags": tags, "versions": versions}, nil
+}

internal/api/v1/npm_test.go

@@ -0,0 +1,162 @@
+package v1
+
+import (
+	"crypto/sha1"
+	"crypto/sha512"
+	"encoding/base64"
+	"encoding/hex"
+	"encoding/json"
+	"errors"
+	"strings"
+	"testing"
+
+	"git.unkin.net/unkin/artifactapi/internal/database"
+)
+
+func TestNPMPackageName(t *testing.T) {
+	tests := map[string]string{
+		"left-pad":                "left-pad",
+		"left-pad/":               "left-pad",
+		"@acme%2fwidget":          "@acme/widget",
+		"@acme%2Fwidget":          "@acme/widget",
+		"@acme/widget":            "@acme/widget",
+		"left-pad/-/left-pad.tgz": "",
+		"@acme/widget/-/w-1.tgz":  "",
+		"a/b":                     "",
+		"../etc":                  "",
+		"Upper":                   "",
+		"":                        "",
+	}
+	for in, want := range tests {
+		if got := npmPackageName(in); got != want {
+			t.Errorf("npmPackageName(%q) = %q, want %q", in, got, want)
+		}
+	}
+}
+
+type publishOpts struct {
+	bodyName, manifestName, version, integrity, shasum string
+	tags                                               map[string]string
+	extraVersion                                       bool
+}
+
+func publishBody(t *testing.T, pkg string, tgz []byte, o publishOpts) string {
+	t.Helper()
+	sha := sha512.Sum512(tgz)
+	sh1 := sha1.Sum(tgz)
+	if o.bodyName == "" {
+		o.bodyName = pkg
+	}
+	if o.manifestName == "" {
+		o.manifestName = pkg
+	}
+	if o.version == "" {
+		o.version = "1.0.0"
+	}
+	if o.integrity == "" {
+		o.integrity = "sha512-" + base64.StdEncoding.EncodeToString(sha[:])
+	}
+	if o.shasum == "" {
+		o.shasum = hex.EncodeToString(sh1[:])
+	}
+	if o.tags == nil {
+		o.tags = map[string]string{"latest": o.version}
+	}
+	versions := map[string]any{o.version: map[string]any{
+		"name": o.manifestName, "version": o.version, "main": "index.js",
+		"dist": map[string]any{"integrity": o.integrity, "shasum": o.shasum, "tarball": "http://elsewhere/x.tgz"},
+	}}
+	if o.extraVersion {
+		versions["2.0.0"] = map[string]any{"name": pkg, "version": "2.0.0"}
+	}
+	b, _ := json.Marshal(map[string]any{
+		"_id": pkg, "name": o.bodyName, "dist-tags": o.tags, "versions": versions,
+		"_attachments": map[string]any{pkg + "-" + o.version + ".tgz": map[string]any{
+			"content_type": "application/octet-stream", "data": base64.StdEncoding.EncodeToString(tgz), "length": len(tgz),
+		}},
+	})
+	return string(b)
+}
+
+func TestParseNPMPublish(t *testing.T) {
+	tgz := []byte("fake tarball bytes")
+
+	rel, err := parseNPMPublish(strings.NewReader(publishBody(t, "@acme/widget", tgz, publishOpts{tags: map[string]string{"latest": "1.0.0", "beta": "1.0.0"}})), "@acme/widget")
+	if err != nil {
+		t.Fatalf("valid scoped publish rejected: %v", err)
+	}
+	if rel.version != "1.0.0" || string(rel.tarball) != string(tgz) || len(rel.tags) != 2 {
+		t.Fatalf("unexpected release: %+v", rel)
+	}
+
+	if _, err := parseNPMPublish(strings.NewReader(publishBody(t, "left-pad", tgz, publishOpts{integrity: "none", shasum: hex.EncodeToString(make([]byte, 20))})), "left-pad"); err == nil {
+		t.Fatal("shasum fallback should reject a mismatched tarball")
+	}
+	if _, err := parseNPMPublish(strings.NewReader(publishBody(t, "left-pad", tgz, publishOpts{integrity: "none"})), "left-pad"); err != nil {
+		t.Fatalf("matching shasum fallback rejected: %v", err)
+	}
+
+	bad := map[string]publishOpts{
+		"body name mismatch":        {bodyName: "other"},
+		"manifest name mismatch":    {manifestName: "other"},
+		"integrity mismatch":        {integrity: "sha512-AAAA"},
+		"path-like version":         {version: "../1.0.0"},
+		"tag at another version":    {tags: map[string]string{"latest": "9.9.9"}},
+		"path-like tag":             {tags: map[string]string{"../x": "1.0.0"}},
+		"multiple versions at once": {extraVersion: true},
+	}
+	for name, o := range bad {
+		if _, err := parseNPMPublish(strings.NewReader(publishBody(t, "left-pad", tgz, o)), "left-pad"); err == nil {
+			t.Errorf("%s: expected rejection", name)
+		}
+	}
+	if _, err := parseNPMPublish(strings.NewReader(`{"name":"left-pad","versions":{}}`), "left-pad"); err == nil {
+		t.Error("deprecate-style body without attachments should be rejected")
+	}
+}
+
+func TestBuildNPMPackument(t *testing.T) {
+	blobs := map[string]string{
+		"h1": `{"name":"my_pkg","version":"1.0.0","dist":{"shasum":"aa","tarball":"http://elsewhere/x.tgz"}}`,
+		"h2": `{"name":"my_pkg","version":"1.1.0"}`,
+		"h3": "1.1.0",
+		"hx": `{"name":"myXpkg","version":"6.6.6"}`,
+	}
+	read := func(h string) ([]byte, error) {
+		b, ok := blobs[h]
+		if !ok {
+			return nil, errors.New("missing blob")
+		}
+		return []byte(b), nil
+	}
+	files := []database.LocalFile{
+		{FilePath: "my_pkg/-/dist-tags/latest", ContentHash: "h3"},
+		{FilePath: "my_pkg/-/my_pkg-1.0.0.json", ContentHash: "h1"},
+		{FilePath: "my_pkg/-/my_pkg-1.0.0.tgz", ContentHash: "nope"},
+		{FilePath: "my_pkg/-/my_pkg-1.1.0.json", ContentHash: "h2"},
+		{FilePath: "myXpkg/-/myXpkg-6.6.6.json", ContentHash: "hx"},
+	}
+
+	doc, err := buildNPMPackument("my_pkg", files, read, "http://reg/api/v1/local/npm/")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if tags := doc["dist-tags"].(map[string]string); tags["latest"] != "1.1.0" {
+		t.Errorf("dist-tags = %v", tags)
+	}
+	versions := doc["versions"].(map[string]any)
+	if len(versions) != 2 {
+		t.Fatalf("versions = %v (LIKE over-match must be dropped)", versions)
+	}
+	v1 := versions["1.0.0"].(map[string]any)["dist"].(map[string]any)
+	if v1["tarball"] != "http://reg/api/v1/local/npm/my_pkg/-/my_pkg-1.0.0.tgz" || v1["shasum"] != "aa" {
+		t.Errorf("1.0.0 dist = %v", v1)
+	}
+	if versions["1.1.0"].(map[string]any)["dist"].(map[string]any)["tarball"] != "http://reg/api/v1/local/npm/my_pkg/-/my_pkg-1.1.0.tgz" {
+		t.Error("1.1.0 missing rewritten tarball")
+	}
+
+	if doc, err := buildNPMPackument("absent", files, read, "x/"); err != nil || doc != nil {
+		t.Errorf("absent package: doc=%v err=%v", doc, err)
+	}
+}

internal/api/v1/proxy.go

@@ -15,6 +15,7 @@ import (
 	"git.unkin.net/unkin/artifactapi/internal/proxy"
 	"git.unkin.net/unkin/artifactapi/internal/storage"
 	"git.unkin.net/unkin/artifactapi/internal/virtual"
+	"git.unkin.net/unkin/artifactapi/pkg/models"
 )
 
 type ProxyHandler struct {
@@ -41,6 +42,7 @@ func (h *ProxyHandler) Routes() chi.Router {
 	r := chi.NewRouter()
 	r.Get("/remote/{remoteName}/*", h.handleProxy)
 	r.Get("/local/{localName}/*", h.handleLocal)
+	r.Put("/local/{localName}/*", h.handleLocalPut)
 	r.Get("/virtual/{virtualName}/*", h.handleVirtual)
 	return r
 }
@@ -199,6 +201,13 @@ func (h *ProxyHandler) handleLocal(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
+	if remote.PackageType == models.PackageNPM {
+		if pkg := npmPackageName(path); pkg != "" {
+			h.serveNPMPackument(w, r, remote, pkg)
+			return
+		}
+	}
+
 	prov, _ := provider.Get(remote.PackageType)
 	if indexer, ok := prov.(provider.LocalIndexer); ok {
 		if indexer.ServeLocalIndex(w, r, h.db, remote.Name, path) {

internal/database/helm_metadata.go

@@ -1,44 +0,0 @@
-package database
-
-import (
-	"context"
-
-	"git.unkin.net/unkin/artifactapi/internal/provider"
-)
-
-func (db *DB) InsertHelmMetadata(ctx context.Context, meta *provider.HelmMetadata) error {
-	_, err := db.Pool.Exec(ctx, `
-		INSERT INTO helm_metadata (repo_name, file_path, content_hash, name, version, chart_yaml)
-		VALUES ($1,$2,$3,$4,$5,$6)
-		ON CONFLICT (repo_name, file_path) DO NOTHING
-	`, meta.RepoName, meta.FilePath, meta.ContentHash, meta.Name, meta.Version, meta.ChartYAML)
-	return err
-}
-
-func (db *DB) DeleteHelmMetadata(ctx context.Context, repoName, filePath string) error {
-	_, err := db.Pool.Exec(ctx, `DELETE FROM helm_metadata WHERE repo_name = $1 AND file_path = $2`, repoName, filePath)
-	return err
-}
-
-func (db *DB) ListHelmMetadataEntries(ctx context.Context, repoName string) ([]provider.HelmMetadata, error) {
-	rows, err := db.Pool.Query(ctx, `
-		SELECT repo_name, file_path, content_hash, name, version, chart_yaml, created_at
-		FROM helm_metadata
-		WHERE repo_name = $1
-		ORDER BY name, version, file_path
-	`, repoName)
-	if err != nil {
-		return nil, err
-	}
-	defer rows.Close()
-
-	var result []provider.HelmMetadata
-	for rows.Next() {
-		var m provider.HelmMetadata
-		if err := rows.Scan(&m.RepoName, &m.FilePath, &m.ContentHash, &m.Name, &m.Version, &m.ChartYAML, &m.CreatedAt); err != nil {
-			return nil, err
-		}
-		result = append(result, m)
-	}
-	return result, rows.Err()
-}

internal/provider/helm/helm.go

@@ -1,23 +1,12 @@
 package helm
 
 import (
-	"archive/tar"
-	"compress/gzip"
 	"context"
-	"errors"
-	"fmt"
-	"io"
-	"log/slog"
 	"net/http"
-	"path"
 	"strings"
-	"time"
-
-	"gopkg.in/yaml.v3"
 
 	"git.unkin.net/unkin/artifactapi/internal/auth"
 	"git.unkin.net/unkin/artifactapi/internal/provider"
-	"git.unkin.net/unkin/artifactapi/internal/storage"
 	"git.unkin.net/unkin/artifactapi/pkg/models"
 )
 
@@ -67,167 +56,3 @@ func (p *Provider) RewriteResponse(body []byte, remote models.Remote, proxyBaseU
 func (p *Provider) AuthHeaders(_ context.Context, remote models.Remote) (http.Header, error) {
 	return auth.BasicHeaders(remote), nil
 }
-
-// ValidateUpload stores charts flat by filename so index.yaml can reference
-// them with relative urls, as `helm repo index` does.
-func (p *Provider) ValidateUpload(filePath string) (storagePath, contentType string, err error) {
-	filename := path.Base(path.Clean("/" + filePath))
-	if !strings.HasSuffix(filename, ".tgz") || filename == ".tgz" {
-		return "", "", fmt.Errorf("file must be a .tgz chart package")
-	}
-	return filename, "application/gzip", nil
-}
-
-func (p *Provider) UploadResponse(storagePath, contentHash string, sizeBytes int64) map[string]any {
-	return map[string]any{
-		"filename":     storagePath,
-		"content_hash": contentHash,
-		"size_bytes":   sizeBytes,
-	}
-}
-
-func (p *Provider) AfterUpload(ctx context.Context, repoName, storagePath, contentHash string, blobs provider.BlobReader, db provider.MetadataStore) {
-	reader, _, err := blobs.Download(ctx, storage.BlobKey(strings.TrimPrefix(contentHash, "sha256:")))
-	if err != nil {
-		slog.Error("helm metadata: download failed", "repo", repoName, "path", storagePath, "error", err)
-		return
-	}
-	defer func() { _ = reader.Close() }()
-
-	meta, err := parseChart(reader)
-	if err != nil {
-		slog.Error("helm metadata: parse failed", "repo", repoName, "path", storagePath, "error", err)
-		return
-	}
-	meta.RepoName = repoName
-	meta.FilePath = storagePath
-	meta.ContentHash = contentHash
-
-	store, ok := db.(provider.HelmMetadataStore)
-	if !ok {
-		slog.Error("helm metadata: store does not support helm metadata", "repo", repoName)
-		return
-	}
-	if err := store.InsertHelmMetadata(ctx, meta); err != nil {
-		slog.Error("helm metadata: insert failed", "repo", repoName, "path", storagePath, "error", err)
-		return
-	}
-	slog.Info("helm metadata: parsed", "repo", repoName, "name", meta.Name, "version", meta.Version)
-}
-
-func (p *Provider) AfterDelete(ctx context.Context, repoName, storagePath string, db provider.MetadataDeleter) error {
-	deleter, ok := db.(provider.HelmMetadataDeleter)
-	if !ok {
-		return nil
-	}
-	return deleter.DeleteHelmMetadata(ctx, repoName, storagePath)
-}
-
-func isIndexPath(p string) bool {
-	return strings.TrimPrefix(path.Clean("/"+p), "/") == "index.yaml"
-}
-
-func (p *Provider) ServeLocalIndex(w http.ResponseWriter, r *http.Request, files provider.FileStore, repoName, reqPath string) bool {
-	if !isIndexPath(reqPath) {
-		return false
-	}
-	body, err := p.GenerateLocalIndex(r.Context(), files, repoName, reqPath)
-	if err != nil {
-		http.Error(w, err.Error(), http.StatusInternalServerError)
-		return true
-	}
-	w.Header().Set("Content-Type", "text/yaml")
-	w.WriteHeader(http.StatusOK)
-	_, _ = w.Write(body)
-	return true
-}
-
-func (p *Provider) GenerateLocalIndex(ctx context.Context, files provider.FileStore, repoName, reqPath string) ([]byte, error) {
-	if !isIndexPath(reqPath) {
-		return nil, fmt.Errorf("unsupported index path: %q", reqPath)
-	}
-	reader, ok := files.(provider.HelmMetadataReader)
-	if !ok {
-		return nil, errors.New("helm metadata not available")
-	}
-	metas, err := reader.ListHelmMetadataEntries(ctx, repoName)
-	if err != nil {
-		return nil, err
-	}
-	return generateIndex(metas)
-}
-
-// generateIndex builds index.yaml from stored Chart.yaml documents; it is
-// stamped from the newest upload so every replica serves identical bytes.
-func generateIndex(metas []provider.HelmMetadata) ([]byte, error) {
-	entries := map[string][]map[string]yaml.Node{}
-	var newest time.Time
-	for _, m := range metas {
-		var chart map[string]yaml.Node
-		if err := yaml.Unmarshal([]byte(m.ChartYAML), &chart); err != nil {
-			return nil, fmt.Errorf("chart %s: %w", m.FilePath, err)
-		}
-		if chart == nil {
-			chart = map[string]yaml.Node{}
-		}
-		chart["name"] = node(m.Name)
-		chart["version"] = node(m.Version)
-		chart["urls"] = node([]string{m.FilePath})
-		chart["digest"] = node(strings.TrimPrefix(m.ContentHash, "sha256:"))
-		chart["created"] = node(m.CreatedAt.UTC().Format(time.RFC3339Nano))
-		entries[m.Name] = append(entries[m.Name], chart)
-		if m.CreatedAt.After(newest) {
-			newest = m.CreatedAt
-		}
-	}
-	return yaml.Marshal(map[string]any{
-		"apiVersion": "v1",
-		"entries":    entries,
-		"generated":  newest.UTC().Format(time.RFC3339Nano),
-	})
-}
-
-func node(v any) yaml.Node {
-	var n yaml.Node
-	_ = n.Encode(v)
-	return n
-}
-
-const maxChartYAML = 1 << 20
-
-// parseChart reads the top-level <chart>/Chart.yaml from a packaged chart.
-func parseChart(r io.Reader) (*provider.HelmMetadata, error) {
-	zr, err := gzip.NewReader(r)
-	if err != nil {
-		return nil, err
-	}
-	tr := tar.NewReader(zr)
-	for {
-		hdr, err := tr.Next()
-		if err == io.EOF {
-			return nil, errors.New("no Chart.yaml in chart archive")
-		}
-		if err != nil {
-			return nil, err
-		}
-		dir, file := path.Split(path.Clean(hdr.Name))
-		if file != "Chart.yaml" || strings.Count(dir, "/") != 1 {
-			continue
-		}
-		raw, err := io.ReadAll(io.LimitReader(tr, maxChartYAML))
-		if err != nil {
-			return nil, err
-		}
-		var chart struct {
-			Name    string `yaml:"name"`
-			Version string `yaml:"version"`
-		}
-		if err := yaml.Unmarshal(raw, &chart); err != nil {
-			return nil, fmt.Errorf("parse Chart.yaml: %w", err)
-		}
-		if chart.Name == "" || chart.Version == "" {
-			return nil, errors.New("chart metadata missing name or version")
-		}
-		return &provider.HelmMetadata{Name: chart.Name, Version: chart.Version, ChartYAML: string(raw)}, nil
-	}
-}

internal/provider/helm/helm_local_test.go

@@ -1,162 +0,0 @@
-package helm
-
-import (
-	"archive/tar"
-	"bytes"
-	"compress/gzip"
-	"context"
-	"io"
-	"net/http/httptest"
-	"testing"
-	"time"
-
-	"gopkg.in/yaml.v3"
-
-	"git.unkin.net/unkin/artifactapi/internal/provider"
-)
-
-func chartTgz(t *testing.T, files map[string]string) []byte {
-	t.Helper()
-	var buf bytes.Buffer
-	zw := gzip.NewWriter(&buf)
-	tw := tar.NewWriter(zw)
-	for name, body := range files {
-		if err := tw.WriteHeader(&tar.Header{Name: name, Mode: 0o644, Size: int64(len(body))}); err != nil {
-			t.Fatal(err)
-		}
-		if _, err := tw.Write([]byte(body)); err != nil {
-			t.Fatal(err)
-		}
-	}
-	if err := tw.Close(); err != nil {
-		t.Fatal(err)
-	}
-	if err := zw.Close(); err != nil {
-		t.Fatal(err)
-	}
-	return buf.Bytes()
-}
-
-type fakeBlobs struct{ data []byte }
-
-func (f fakeBlobs) Download(context.Context, string) (io.ReadCloser, int64, error) {
-	return io.NopCloser(bytes.NewReader(f.data)), int64(len(f.data)), nil
-}
-
-type fakeStore struct {
-	inserted *provider.HelmMetadata
-	metas    []provider.HelmMetadata
-}
-
-func (f *fakeStore) InsertRPMMetadata(context.Context, *provider.RPMMetadata) error { return nil }
-func (f *fakeStore) InsertDebMetadata(context.Context, *provider.DebMetadata) error { return nil }
-func (f *fakeStore) InsertHelmMetadata(_ context.Context, m *provider.HelmMetadata) error {
-	f.inserted = m
-	return nil
-}
-func (f *fakeStore) ListHelmMetadataEntries(context.Context, string) ([]provider.HelmMetadata, error) {
-	return f.metas, nil
-}
-func (f *fakeStore) ListFilesByPrefix(context.Context, string, string) ([]provider.FileEntry, error) {
-	return nil, nil
-}
-func (f *fakeStore) ListPackages(context.Context, string) ([]string, error) { return nil, nil }
-
-func TestValidateUpload(t *testing.T) {
-	p := &Provider{}
-	for in, want := range map[string]string{
-		"mychart-0.1.0.tgz":        "mychart-0.1.0.tgz",
-		"charts/mychart-0.1.0.tgz": "mychart-0.1.0.tgz",
-		"../../mychart-0.1.0.tgz":  "mychart-0.1.0.tgz",
-	} {
-		sp, ct, err := p.ValidateUpload(in)
-		if err != nil || sp != want || ct != "application/gzip" {
-			t.Errorf("ValidateUpload(%q) = %q %q %v", in, sp, ct, err)
-		}
-	}
-	for _, bad := range []string{"index.yaml", "chart.tar.gz", ".tgz", ""} {
-		if _, _, err := p.ValidateUpload(bad); err == nil {
-			t.Errorf("ValidateUpload(%q) accepted", bad)
-		}
-	}
-}
-
-func TestAfterUploadParsesTopLevelChart(t *testing.T) {
-	data := chartTgz(t, map[string]string{
-		"mychart/charts/sub/Chart.yaml": "apiVersion: v2\nname: sub\nversion: 9.9.9\n",
-		"mychart/Chart.yaml":            "apiVersion: v2\nname: mychart\nversion: 1.0\ndescription: hi\n",
-		"mychart/values.yaml":           "a: 1\n",
-	})
-	store := &fakeStore{}
-	(&Provider{}).AfterUpload(context.Background(), "r", "mychart-1.0.tgz", "sha256:ab", fakeBlobs{data}, store)
-	m := store.inserted
-	if m == nil || m.Name != "mychart" || m.Version != "1.0" || m.FilePath != "mychart-1.0.tgz" || m.ContentHash != "sha256:ab" {
-		t.Fatalf("inserted %+v", m)
-	}
-}
-
-func TestAfterUploadRejectsChartWithoutMetadata(t *testing.T) {
-	store := &fakeStore{}
-	data := chartTgz(t, map[string]string{"mychart/Chart.yaml": "apiVersion: v2\nname: mychart\n"})
-	(&Provider{}).AfterUpload(context.Background(), "r", "x.tgz", "sha256:ab", fakeBlobs{data}, store)
-	if store.inserted != nil {
-		t.Fatal("chart without version was recorded")
-	}
-	(&Provider{}).AfterUpload(context.Background(), "r", "x.tgz", "sha256:ab", fakeBlobs{[]byte("not gzip")}, store)
-	if store.inserted != nil {
-		t.Fatal("non-gzip upload was recorded")
-	}
-}
-
-func TestServeLocalIndex(t *testing.T) {
-	t1 := time.Date(2026, 1, 1, 0, 0, 0, 0, time.UTC)
-	t2 := t1.Add(time.Hour)
-	store := &fakeStore{metas: []provider.HelmMetadata{
-		{FilePath: "mychart-1.0.tgz", ContentHash: "sha256:aa", Name: "mychart", Version: "1.0", CreatedAt: t1,
-			ChartYAML: "apiVersion: v2\nname: mychart\nversion: 1.0\nappVersion: \"2\"\ndescription: hi\n"},
-		{FilePath: "other-0.2.0.tgz", ContentHash: "sha256:bb", Name: "other", Version: "0.2.0", CreatedAt: t2,
-			ChartYAML: "apiVersion: v2\nname: other\nversion: 0.2.0\n"},
-	}}
-	p := &Provider{}
-
-	if p.ServeLocalIndex(httptest.NewRecorder(), httptest.NewRequest("GET", "/", nil), store, "r", "mychart-1.0.tgz") {
-		t.Fatal("chart path handled as index")
-	}
-	rec := httptest.NewRecorder()
-	if !p.ServeLocalIndex(rec, httptest.NewRequest("GET", "/", nil), store, "r", "./index.yaml") {
-		t.Fatal("index.yaml not handled")
-	}
-	if rec.Code != 200 || rec.Header().Get("Content-Type") != "text/yaml" {
-		t.Fatalf("code=%d ct=%q", rec.Code, rec.Header().Get("Content-Type"))
-	}
-
-	var idx struct {
-		APIVersion string `yaml:"apiVersion"`
-		Generated  string `yaml:"generated"`
-		Entries    map[string][]map[string]any
-	}
-	if err := yaml.Unmarshal(rec.Body.Bytes(), &idx); err != nil {
-		t.Fatal(err)
-	}
-	if idx.APIVersion != "v1" || idx.Generated != t2.Format(time.RFC3339Nano) {
-		t.Errorf("header %+v", idx)
-	}
-	e := idx.Entries["mychart"][0]
-	if e["digest"] != "aa" || e["description"] != "hi" || e["appVersion"] != "2" || e["apiVersion"] != "v2" {
-		t.Errorf("entry %v", e)
-	}
-	if urls, _ := e["urls"].([]any); len(urls) != 1 || urls[0] != "mychart-1.0.tgz" {
-		t.Errorf("urls %v", e["urls"])
-	}
-	if e["version"] != "1.0" || e["name"] != "mychart" {
-		t.Errorf("version must stay a string: %#v", e["version"])
-	}
-	if len(idx.Entries["other"]) != 1 {
-		t.Errorf("other entries %v", idx.Entries["other"])
-	}
-
-	again, err := p.GenerateLocalIndex(context.Background(), store, "r", "index.yaml")
-	if err != nil || !bytes.Equal(again, rec.Body.Bytes()) {
-		t.Errorf("index not deterministic: %v", err)
-	}
-}

internal/provider/provider.go

@@ -240,27 +240,3 @@ func Get(t models.PackageType) (Provider, error) {
 func All() map[models.PackageType]Provider {
 	return registry
 }
-
-type HelmMetadataStore interface {
-	InsertHelmMetadata(ctx context.Context, meta *HelmMetadata) error
-}
-
-type HelmMetadataDeleter interface {
-	DeleteHelmMetadata(ctx context.Context, repoName, filePath string) error
-}
-
-type HelmMetadataReader interface {
-	ListHelmMetadataEntries(ctx context.Context, repoName string) ([]HelmMetadata, error)
-}
-
-// HelmMetadata is a local chart's Chart.yaml, kept verbatim so index.yaml
-// entries carry every field helm reads.
-type HelmMetadata struct {
-	RepoName    string
-	FilePath    string
-	ContentHash string
-	Name        string
-	Version     string
-	ChartYAML   string
-	CreatedAt   time.Time
-}

internal/virtual/helm_merger.go

@@ -16,17 +16,22 @@ func init() {
 type HelmMerger struct{}
 
 type helmIndex struct {
-	APIVersion string                            `yaml:"apiVersion"`
-	Entries    map[string][]map[string]yaml.Node `yaml:"entries"`
-	Generated  string                            `yaml:"generated,omitempty"`
+	APIVersion string                        `yaml:"apiVersion"`
+	Entries    map[string][]helmChartVersion `yaml:"entries"`
+	Generated  string                        `yaml:"generated,omitempty"`
+}
+
+type helmChartVersion struct {
+	Name    string   `yaml:"name"`
+	Version string   `yaml:"version"`
+	URLs    []string `yaml:"urls"`
+	rest    map[string]any
 }
 
-// MergeIndexes keeps each chart version's fields as raw nodes so digest,
-// apiVersion and the rest survive the merge untouched; only urls are rewritten.
 func (m *HelmMerger) MergeIndexes(members []MemberIndex, proxyBaseURL string) ([]byte, error) {
 	merged := &helmIndex{
 		APIVersion: "v1",
-		Entries:    make(map[string][]map[string]yaml.Node),
+		Entries:    make(map[string][]helmChartVersion),
 	}
 
 	seen := map[string]map[string]bool{}
@@ -42,26 +47,42 @@ func (m *HelmMerger) MergeIndexes(members []MemberIndex, proxyBaseURL string) ([
 				seen[chart] = map[string]bool{}
 			}
 			for _, ver := range versions {
-				version := ver["version"].Value
-				if seen[chart][version] {
+				key := chart + ":" + ver.Version
+				if seen[chart][ver.Version] {
 					continue
 				}
-				seen[chart][version] = true
+				seen[chart][ver.Version] = true
 
-				if urlsNode, ok := ver["urls"]; ok && proxyBaseURL != "" {
-					var urls []string
-					if err := urlsNode.Decode(&urls); err != nil {
-						continue
+				if proxyBaseURL != "" {
+					routePrefix := "remote"
+					if member.RepoType == "local" {
+						routePrefix = "local"
 					}
-					rewriteHelmURLs(urls, member, proxyBaseURL)
-					var n yaml.Node
-					if err := n.Encode(urls); err != nil {
-						return nil, err
+					baseHost := extractHost(member.BaseURL)
+
+					for i, u := range ver.URLs {
+						if strings.HasPrefix(u, "http://") || strings.HasPrefix(u, "https://") {
+							if baseHost != "" && extractHost(u) != baseHost {
+								continue
+							}
+							relPath := extractPathRelativeToBase(u, member.BaseURL)
+							ver.URLs[i] = fmt.Sprintf("%s/api/v1/%s/%s/%s",
+								strings.TrimRight(proxyBaseURL, "/"),
+								routePrefix,
+								member.RemoteName,
+								relPath)
+						} else {
+							ver.URLs[i] = fmt.Sprintf("%s/api/v1/%s/%s/%s",
+								strings.TrimRight(proxyBaseURL, "/"),
+								routePrefix,
+								member.RemoteName,
+								u)
+						}
 					}
-					ver["urls"] = n
 				}
 
 				merged.Entries[chart] = append(merged.Entries[chart], ver)
+				_ = key
 			}
 		}
 	}
@@ -69,34 +90,6 @@ func (m *HelmMerger) MergeIndexes(members []MemberIndex, proxyBaseURL string) ([
 	return yaml.Marshal(merged)
 }
 
-func rewriteHelmURLs(urls []string, member MemberIndex, proxyBaseURL string) {
-	routePrefix := "remote"
-	if member.RepoType == "local" {
-		routePrefix = "local"
-	}
-	baseHost := extractHost(member.BaseURL)
-
-	for i, u := range urls {
-		if strings.HasPrefix(u, "http://") || strings.HasPrefix(u, "https://") {
-			if baseHost != "" && extractHost(u) != baseHost {
-				continue
-			}
-			relPath := extractPathRelativeToBase(u, member.BaseURL)
-			urls[i] = fmt.Sprintf("%s/api/v1/%s/%s/%s",
-				strings.TrimRight(proxyBaseURL, "/"),
-				routePrefix,
-				member.RemoteName,
-				relPath)
-		} else {
-			urls[i] = fmt.Sprintf("%s/api/v1/%s/%s/%s",
-				strings.TrimRight(proxyBaseURL, "/"),
-				routePrefix,
-				member.RemoteName,
-				u)
-		}
-	}
-}
-
 func extractHost(rawURL string) string {
 	idx := strings.Index(rawURL, "://")
 	if idx == -1 {

internal/virtual/helm_merger_test.go

@@ -122,36 +122,3 @@ entries:
 		t.Error("expected fallback repo to be excluded for duplicate")
 	}
 }
-
-func TestHelmMerger_PreservesChartFields(t *testing.T) {
-	m := &virtual.HelmMerger{}
-	body := []byte(`apiVersion: v1
-entries:
-  app:
-    - apiVersion: v2
-      name: app
-      version: "1.0"
-      appVersion: "3.1"
-      description: in-house
-      digest: deadbeef
-      urls:
-        - app-1.0.tgz
-`)
-	result, err := m.MergeIndexes([]virtual.MemberIndex{{RemoteName: "charts", RepoType: "local", Body: body}}, "https://proxy.example.com")
-	if err != nil {
-		t.Fatal(err)
-	}
-	out := string(result)
-	for _, want := range []string{
-		"digest: deadbeef",
-		"apiVersion: v2",
-		`appVersion: "3.1"`,
-		"description: in-house",
-		`version: "1.0"`,
-		"https://proxy.example.com/api/v1/local/charts/app-1.0.tgz",
-	} {
-		if !strings.Contains(out, want) {
-			t.Errorf("merged index missing %q:\n%s", want, out)
-		}
-	}
-}

migrations/0003_helm_metadata.sql

@@ -1,13 +0,0 @@
-CREATE TABLE IF NOT EXISTS helm_metadata (
-	id           BIGSERIAL PRIMARY KEY,
-	repo_name    TEXT NOT NULL,
-	file_path    TEXT NOT NULL,
-	content_hash TEXT NOT NULL,
-	name         TEXT NOT NULL,
-	version      TEXT NOT NULL,
-	chart_yaml   TEXT NOT NULL,
-	created_at   TIMESTAMPTZ DEFAULT NOW(),
-	UNIQUE(repo_name, file_path)
-);
-
-CREATE INDEX IF NOT EXISTS idx_helm_metadata_repo ON helm_metadata(repo_name);

ui/src/components/UsageInstructions.tsx

@@ -101,6 +101,27 @@ pip install <package>`,
       ];
 
     case 'npm':
+      if (isLocal) {
+        const reg = `${url}/api/v1/local/${name}/`;
+        return [
+          {
+            title: 'Configure .npmrc (registry + publish token)',
+            language: 'bash',
+            code: `cat >> .npmrc <<'EOF'
+registry=${reg}
+//${host}/api/v1/local/${name}/:_authToken=unused
+EOF`,
+            note: 'npm refuses to publish without an _authToken for the registry; any value works. For a scope only, use @<scope>:registry=… instead of registry=.',
+          },
+          {
+            title: 'Publish and install',
+            language: 'bash',
+            code: `npm publish
+npm install <package>`,
+            note: 'Versions are immutable: republishing an existing version is rejected. The dist-tags sent with the publish (latest, or --tag) move to the new version.',
+          },
+        ];
+      }
       return [
         {
           title: 'Point npm at this registry',
@@ -167,23 +188,12 @@ docker push        ${host}/${name}/myapp:latest`,
     case 'helm':
       return [
         {
-          title: isLocal ? 'Add the Helm repo (index.yaml auto-generated)' : 'Add the Helm repo',
+          title: 'Add the Helm repo',
           language: 'bash',
-          code: `helm repo add ${name} ${isLocal ? `${url}/api/v1/local/${name}` : proxy}/
+          code: `helm repo add ${name} ${proxy}/
 helm repo update
 helm install <release> ${name}/<chart>`,
         },
-        ...(isLocal
-          ? [
-              {
-                title: 'Publish a chart',
-                language: 'bash',
-                code: `helm package ./mychart
-curl -fsSL --upload-file mychart-0.1.0.tgz \\
-  ${url}/api/v2/remotes/${name}/files/mychart-0.1.0.tgz`,
-              },
-            ]
-          : []),
       ];
 
     case 'alpine':