What causes "index.json contains no usable versions" in hashicorp/packer?

Fix the version keys in index.json to be valid semantic versions (e.g. "1.1.1" not "v1.1.x" or "latest").

index.json contains no usable versions

Error message

index.json contains no usable versions

What it means

parseIndex filters the raw version keys through semantic-version parsing; keys that don't parse are logged as WARN and skipped. If every version key fails to parse, idx.versions ends up empty and the index — while structurally valid — is useless, so parseIndex fails with this error.

Source

Thrown at packer/plugin-getter/remote/getter.go:98

	}
	if len(raw.Versions) == 0 {
		return nil, fmt.Errorf("index.json contains no versions")
	}

	idx := &pluginIndex{
		pluginType: pluginType,
		versions:   map[string]struct{}{},
	}
	for k := range raw.Versions {
		ver, err := goversion.NewVersion(k)
		if err != nil {
			log.Printf("[WARN] remote-getter: ignoring unparseable version %q in index.json", k)
			continue
		}
		idx.versions[ver.String()] = struct{}{}
	}
	if len(idx.versions) == 0 {
		return nil, fmt.Errorf("index.json contains no usable versions")
	}
	return idx, nil
}

// releasesStream encodes the index versions as the json list of Release that
// Packer expects from get 'releases'.
func (idx *pluginIndex) releasesStream() (io.ReadCloser, error) {
	out := make([]plugingetter.Release, 0, len(idx.versions))
	for v := range idx.versions {
		out = append(out, plugingetter.Release{Version: "v" + v})
	}
	buf := &bytes.Buffer{}
	if err := json.NewEncoder(buf).Encode(out); err != nil {
		return nil, err
	}
	return io.NopCloser(buf), nil
}

View on GitHub (pinned to eb36e3c3e4)

Solutions

Fix the version keys in index.json to be valid semantic versions (e.g. "1.1.1" not "v1.1.x" or "latest").
Re-sync the custom registry/mirror against the official releases so semver tags are used.
Check the WARN log lines — they name each unparseable version key that was skipped.

Example fix

// before
{"versions": {"latest": {}, "master": {}}}
// after
{"versions": {"1.1.1": {}, "1.1.0": {}}}

Defensive patterns

Strategy: validation

Validate before calling

for k := range rawVersions {
    if _, err := semver.Parse(strings.TrimPrefix(k, "v")); err != nil {
        return fmt.Errorf("version key %q is not semver", k)
    }
}

Try / catch

if _, err := g.Get("releases", opts); err != nil && strings.Contains(err.Error(), "no usable versions") {
    // fix non-semver tags in the custom registry index, then retry
}

Prevention

Use strict semver tags (v-prefixed or plain X.Y.Z) for plugin releases.
Avoid branch names, "latest", or multi-dot versions as registry tags.
Watch for the WARN log lines listing skipped version keys.

When it happens

Trigger: index.json's versions map contains only keys that are not valid semver strings (e.g. "latest", "v", "1.1", "master"), so all entries are skipped and len(idx.versions) == 0.

Common situations: A custom/self-hosted plugin registry using non-semver tags like branch names or date strings; hand-edited index.json with typo'd versions ("1.1.1.1"); a registry migrated to a different tagging scheme.

Related errors

AI-assisted analysis of hashicorp/packer@eb36e3c3e4 (2026-09-05). Data as JSON: /api/errors/aaf716530a715484. Report an issue: GitHub.