akm-cli 0.6.1 → 0.7.0

package/dist/tests/registry-build-index.test.js

@@ -0,0 +1,394 @@
+import { afterAll, afterEach, describe, expect, test } from "bun:test";
+import { spawn, spawnSync } from "node:child_process";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { buildRegistryIndex, writeRegistryIndex } from "../src/registry/build-index";
+const CLI = path.join(import.meta.dir, "..", "src", "cli.ts");
+const tempDirs = [];
+const servers = [];
+function makeTempDir(prefix) {
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), prefix));
+    tempDirs.push(dir);
+    return dir;
+}
+function writeFile(filePath, content) {
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    fs.writeFileSync(filePath, content, "utf8");
+}
+function createTarball(sourceDir, archivePath) {
+    const result = spawnSync("tar", ["czf", archivePath, "-C", path.dirname(sourceDir), path.basename(sourceDir)], {
+        encoding: "utf8",
+        timeout: 30_000,
+    });
+    expect(result.status).toBe(0);
+}
+function createRegistryServer(npmArchivePath, githubArchivePath) {
+    const server = Bun.serve({
+        port: 0,
+        async fetch(request) {
+            const url = new URL(request.url);
+            const pathname = url.pathname;
+            if (pathname === "/-/v1/search") {
+                return Response.json({
+                    objects: [
+                        {
+                            package: {
+                                name: "agent-stash",
+                                version: "1.2.3",
+                                description: "npm description",
+                                keywords: ["akm-stash", "deploy"],
+                                links: {
+                                    homepage: "https://example.test/agent-stash",
+                                    repository: "https://github.com/acme/agent-stash",
+                                },
+                                author: { name: "acme" },
+                            },
+                        },
+                    ],
+                });
+            }
+            if (pathname === "/agent-stash/latest") {
+                return Response.json({
+                    version: "1.2.3",
+                    description: "npm latest description",
+                    keywords: ["akm-stash", "deploy", "review"],
+                    license: "MIT",
+                    dist: {
+                        tarball: `${url.origin}/archives/npm-agent-stash.tgz`,
+                    },
+                });
+            }
+            if (pathname === "/search/repositories") {
+                return Response.json({
+                    items: [
+                        {
+                            full_name: "acme/release-stash",
+                            name: "release-stash",
+                            description: "github description",
+                            html_url: "https://github.com/acme/release-stash",
+                            owner: { login: "acme" },
+                            license: { spdx_id: "Apache-2.0" },
+                            topics: ["akm-stash", "release"],
+                            default_branch: "main",
+                        },
+                    ],
+                });
+            }
+            if (pathname === "/repos/acme/release-stash/tarball/main") {
+                return new Response(Bun.file(githubArchivePath), {
+                    headers: { "Content-Type": "application/gzip" },
+                });
+            }
+            if (pathname === "/archives/npm-agent-stash.tgz") {
+                return new Response(Bun.file(npmArchivePath), {
+                    headers: { "Content-Type": "application/gzip" },
+                });
+            }
+            return new Response("not found", { status: 404 });
+        },
+    });
+    servers.push(server);
+    return `http://127.0.0.1:${server.port}`;
+}
+afterEach(() => {
+    while (servers.length > 0) {
+        servers.pop()?.stop(true);
+    }
+    while (tempDirs.length > 0) {
+        fs.rmSync(tempDirs.pop() ?? "", { recursive: true, force: true });
+    }
+});
+afterAll(() => {
+    while (servers.length > 0) {
+        servers.pop()?.stop(true);
+    }
+});
+describe("buildRegistryIndex", () => {
+    test("writeRegistryIndex defaults under the cache registry-build directory", () => {
+        const cacheHome = makeTempDir("akm-registry-cache-");
+        const originalCacheHome = process.env.XDG_CACHE_HOME;
+        process.env.XDG_CACHE_HOME = cacheHome;
+        try {
+            const outPath = writeRegistryIndex({ version: 3, updatedAt: "2026-05-01T00:00:00.000Z", stashes: [] });
+            expect(outPath).toBe(path.join(cacheHome, "akm", "registry-build", "index.json"));
+            expect(fs.existsSync(outPath)).toBe(true);
+        }
+        finally {
+            if (originalCacheHome === undefined)
+                delete process.env.XDG_CACHE_HOME;
+            else
+                process.env.XDG_CACHE_HOME = originalCacheHome;
+        }
+    });
+    test("builds a v2 index from discovery and manual entries", async () => {
+        const fixtureRoot = makeTempDir("akm-registry-build-fixture-");
+        const npmPackageDir = path.join(fixtureRoot, "package");
+        writeFile(path.join(npmPackageDir, "package.json"), JSON.stringify({
+            name: "agent-stash",
+            version: "1.2.3",
+            description: "package archive description",
+            keywords: ["akm-stash", "deploy", "review"],
+            license: "MIT",
+        }));
+        writeFile(path.join(npmPackageDir, "scripts", "deploy.sh"), "#!/usr/bin/env bash\n");
+        writeFile(path.join(npmPackageDir, "skills", "review", "SKILL.md"), "---\ndescription: Review code\n---\n");
+        const npmArchivePath = path.join(fixtureRoot, "npm-agent-stash.tgz");
+        createTarball(npmPackageDir, npmArchivePath);
+        const githubRepoDir = path.join(fixtureRoot, "release-stash-main");
+        writeFile(path.join(githubRepoDir, "package.json"), JSON.stringify({
+            name: "release-stash",
+            version: "0.4.0",
+            description: "repo archive description",
+            keywords: ["akm-stash", "release", "automation"],
+        }));
+        writeFile(path.join(githubRepoDir, "agents", "planner.md"), "---\ndescription: Plan releases\n---\n");
+        writeFile(path.join(githubRepoDir, "commands", "release.md"), "Use $ARGUMENTS\n");
+        const githubArchivePath = path.join(fixtureRoot, "github-release-stash.tgz");
+        createTarball(githubRepoDir, githubArchivePath);
+        const serverBase = createRegistryServer(npmArchivePath, githubArchivePath);
+        const manualEntriesPath = path.join(fixtureRoot, "manual-entries.json");
+        fs.writeFileSync(manualEntriesPath, `${JSON.stringify([
+            {
+                id: "npm:agent-stash",
+                name: "Agent Stash",
+                description: "manual description",
+                ref: "agent-stash",
+                source: "npm",
+                tags: ["curated"],
+                assets: [{ type: "knowledge", name: "guide", description: "Manual guide" }],
+                curated: true,
+            },
+            {
+                id: "github:manual/only",
+                name: "Manual Only",
+                description: "manual only entry",
+                ref: "manual/only",
+                source: "github",
+                assetTypes: ["skill"],
+                curated: true,
+            },
+        ], null, 2)}\n`, "utf8");
+        const result = await buildRegistryIndex({
+            manualEntriesPath,
+            npmRegistryBase: serverBase,
+            githubApiBase: serverBase,
+        });
+        expect(result.index.version).toBe(3);
+        expect(result.counts).toEqual({ manual: 2, npm: 1, github: 1, total: 3 });
+        const npmStash = result.index.stashes.find((stash) => stash.id === "npm:agent-stash");
+        expect(npmStash).toBeDefined();
+        expect(npmStash?.description).toBe("manual description");
+        // v1 spec §4.2: the legacy `curated` boolean is removed. The builder must
+        // not surface it on emitted stash entries even when input contained it.
+        expect(npmStash).not.toHaveProperty("curated");
+        expect(npmStash?.assetTypes).toEqual(["knowledge", "script", "skill"]);
+        expect(npmStash?.tags).toEqual(["curated", "deploy", "review"]);
+        expect(npmStash?.assets?.map((asset) => `${asset.type}:${asset.name}`)).toEqual([
+            "knowledge:guide",
+            "script:deploy.sh",
+            "skill:review",
+        ]);
+        const githubStash = result.index.stashes.find((stash) => stash.id === "github:acme/release-stash");
+        expect(githubStash).toBeDefined();
+        expect(githubStash?.assetTypes).toEqual(["agent", "command"]);
+        expect(githubStash?.assets?.map((asset) => `${asset.type}:${asset.name}`)).toEqual([
+            "agent:planner",
+            "command:release",
+        ]);
+        expect(githubStash?.assets?.every((asset) => typeof asset.estimatedTokens === "number")).toBe(true);
+        expect(githubStash?.latestVersion).toBe("0.4.0");
+        expect(githubStash?.tags).toEqual(["automation", "release"]);
+        const manualOnlyStash = result.index.stashes.find((stash) => stash.id === "github:manual/only");
+        expect(manualOnlyStash).toBeDefined();
+        // v1 spec §4.2: legacy `curated` from manual entries is silently ignored.
+        expect(manualOnlyStash).not.toHaveProperty("curated");
+        expect(manualOnlyStash?.assetTypes).toEqual(["skill"]);
+    });
+    test("legacy curated key parses without error", async () => {
+        // v1 spec §4.2: `curated: true` is a removed legacy field on registry
+        // entries. Manual-entry JSON in the wild may still contain it. The
+        // builder MUST silently ignore it (not throw, not fail validation),
+        // and the entry MUST still be processed end-to-end.
+        const fixtureRoot = makeTempDir("akm-registry-build-legacy-curated-");
+        const githubRepoDir = path.join(fixtureRoot, "release-stash-main");
+        writeFile(path.join(githubRepoDir, "commands", "release.md"), "Use $ARGUMENTS\n");
+        const githubArchivePath = path.join(fixtureRoot, "github-release-stash.tgz");
+        createTarball(githubRepoDir, githubArchivePath);
+        const npmPackageDir = path.join(fixtureRoot, "package");
+        writeFile(path.join(npmPackageDir, "package.json"), JSON.stringify({ name: "agent-stash", version: "1.2.3" }));
+        const npmArchivePath = path.join(fixtureRoot, "npm-agent-stash.tgz");
+        createTarball(npmPackageDir, npmArchivePath);
+        const serverBase = createRegistryServer(npmArchivePath, githubArchivePath);
+        const manualEntriesPath = path.join(fixtureRoot, "manual-entries.json");
+        fs.writeFileSync(manualEntriesPath, `${JSON.stringify([
+            {
+                id: "github:legacy/curated",
+                name: "Legacy Curated",
+                description: "entry retaining the removed `curated: true` field",
+                ref: "legacy/curated",
+                source: "github",
+                assetTypes: ["skill"],
+                curated: true,
+            },
+        ], null, 2)}\n`, "utf8");
+        await expect(buildRegistryIndex({
+            manualEntriesPath,
+            npmRegistryBase: serverBase,
+            githubApiBase: serverBase,
+        })).resolves.toBeDefined();
+        // Re-run to inspect the actual result; resolves above proves no throw.
+        const result = await buildRegistryIndex({
+            manualEntriesPath,
+            npmRegistryBase: serverBase,
+            githubApiBase: serverBase,
+        });
+        // Non-empty kit list proves the legacy entry was processed, not silently
+        // dropped on parse error.
+        expect(result.index.stashes.length).toBeGreaterThan(0);
+        const legacyStash = result.index.stashes.find((stash) => stash.id === "github:legacy/curated");
+        expect(legacyStash).toBeDefined();
+        expect(legacyStash).not.toHaveProperty("curated");
+    });
+    test("respects .stash.json metadata and akm.include when enriching assets", async () => {
+        const fixtureRoot = makeTempDir("akm-registry-build-include-");
+        const npmPackageDir = path.join(fixtureRoot, "package");
+        writeFile(path.join(npmPackageDir, "package.json"), JSON.stringify({
+            name: "agent-stash",
+            version: "1.2.3",
+            akm: { include: ["skills", "docs"] },
+        }));
+        writeFile(path.join(npmPackageDir, "scripts", "ignored.sh"), "#!/usr/bin/env bash\n");
+        writeFile(path.join(npmPackageDir, "skills", "review", "SKILL.md"), "# Review\n");
+        writeFile(path.join(npmPackageDir, "skills", "review", ".stash.json"), JSON.stringify({
+            entries: [
+                {
+                    name: "review",
+                    type: "skill",
+                    filename: "SKILL.md",
+                    description: "Curated review workflow",
+                    tags: ["quality", "code-review"],
+                },
+            ],
+        }));
+        writeFile(path.join(npmPackageDir, "docs", "guide.md"), "# Guide\n");
+        const npmArchivePath = path.join(fixtureRoot, "npm-agent-stash.tgz");
+        createTarball(npmPackageDir, npmArchivePath);
+        const githubRepoDir = path.join(fixtureRoot, "release-stash-main");
+        writeFile(path.join(githubRepoDir, "commands", "release.md"), "Use $ARGUMENTS\n");
+        const githubArchivePath = path.join(fixtureRoot, "github-release-stash.tgz");
+        createTarball(githubRepoDir, githubArchivePath);
+        const serverBase = createRegistryServer(npmArchivePath, githubArchivePath);
+        const manualEntriesPath = path.join(fixtureRoot, "manual-entries.json");
+        fs.writeFileSync(manualEntriesPath, "[]\n", "utf8");
+        const result = await buildRegistryIndex({
+            manualEntriesPath,
+            npmRegistryBase: serverBase,
+            githubApiBase: serverBase,
+        });
+        const npmStash = result.index.stashes.find((stash) => stash.id === "npm:agent-stash");
+        expect(npmStash?.assetTypes).toEqual(["knowledge", "skill"]);
+        expect(npmStash?.assets?.map((asset) => `${asset.type}:${asset.name}`)).toEqual([
+            "knowledge:docs/guide",
+            "skill:review",
+        ]);
+        const reviewAsset = npmStash?.assets?.find((asset) => asset.type === "skill" && asset.name === "review");
+        expect(reviewAsset?.description).toBe("Curated review workflow");
+        expect(reviewAsset?.tags).toEqual(["quality", "code-review"]);
+        expect(reviewAsset?.estimatedTokens).toBeGreaterThan(0);
+        expect(npmStash?.assets?.some((asset) => asset.name === "ignored.sh")).toBe(false);
+    });
+});
+function waitForChild(child, timeoutMs) {
+    return new Promise((resolve, reject) => {
+        let stdout = "";
+        let stderr = "";
+        let settled = false;
+        child.stdout?.on("data", (chunk) => {
+            stdout += String(chunk);
+        });
+        child.stderr?.on("data", (chunk) => {
+            stderr += String(chunk);
+        });
+        const timer = setTimeout(() => {
+            if (!settled) {
+                settled = true;
+                child.kill("SIGKILL");
+                reject(new Error(`Child process timed out after ${timeoutMs}ms\nstdout: ${stdout}\nstderr: ${stderr}`));
+            }
+        }, timeoutMs);
+        child.on("error", (err) => {
+            if (!settled) {
+                settled = true;
+                clearTimeout(timer);
+                reject(err);
+            }
+        });
+        child.on("close", (code) => {
+            if (!settled) {
+                settled = true;
+                clearTimeout(timer);
+                resolve({ code: code ?? 1, stdout, stderr });
+            }
+        });
+    });
+}
+describe("akm registry build-index", () => {
+    test("writes the generated index to disk", async () => {
+        const fixtureRoot = makeTempDir("akm-registry-build-cli-");
+        const npmPackageDir = path.join(fixtureRoot, "package");
+        writeFile(path.join(npmPackageDir, "package.json"), JSON.stringify({ name: "agent-stash", version: "1.2.3" }));
+        writeFile(path.join(npmPackageDir, "scripts", "deploy.sh"), "#!/usr/bin/env bash\n");
+        const npmArchivePath = path.join(fixtureRoot, "npm-agent-stash.tgz");
+        createTarball(npmPackageDir, npmArchivePath);
+        const githubRepoDir = path.join(fixtureRoot, "release-stash-main");
+        writeFile(path.join(githubRepoDir, "commands", "release.md"), "Use $ARGUMENTS\n");
+        const githubArchivePath = path.join(fixtureRoot, "github-release-stash.tgz");
+        createTarball(githubRepoDir, githubArchivePath);
+        const serverBase = createRegistryServer(npmArchivePath, githubArchivePath);
+        const manualEntriesPath = path.join(fixtureRoot, "manual-entries.json");
+        fs.writeFileSync(manualEntriesPath, "[]\n", "utf8");
+        const outPath = path.join(fixtureRoot, "out", "index.json");
+        const xdgCache = makeTempDir("akm-registry-build-cache-");
+        const xdgConfig = makeTempDir("akm-registry-build-config-");
+        const homeDir = makeTempDir("akm-registry-build-home-");
+        const child = spawn("bun", [
+            CLI,
+            "registry",
+            "build-index",
+            "--format=json",
+            "--out",
+            outPath,
+            "--manual",
+            manualEntriesPath,
+            "--npmRegistry",
+            serverBase,
+            "--githubApi",
+            serverBase,
+        ], {
+            cwd: path.join(import.meta.dir, ".."),
+            stdio: ["ignore", "pipe", "pipe"],
+            env: {
+                ...process.env,
+                HOME: homeDir,
+                NO_PROXY: "127.0.0.1,localhost",
+                GITHUB_TOKEN: "",
+                XDG_CACHE_HOME: xdgCache,
+                XDG_CONFIG_HOME: xdgConfig,
+            },
+        });
+        const result = await waitForChild(child, 30_000);
+        if (result.code !== 0) {
+            console.error("stderr:", result.stderr);
+            console.error("stdout:", result.stdout);
+        }
+        expect(result.code).toBe(0);
+        expect(result.stderr.trim()).toBe("");
+        const stdout = JSON.parse(result.stdout.trim());
+        expect(stdout.outPath).toBe(outPath);
+        expect(stdout.totalKits).toBe(2);
+        const written = JSON.parse(fs.readFileSync(outPath, "utf8"));
+        expect(written.version).toBe(3);
+        expect(written.stashes.map((stash) => stash.id)).toEqual(["npm:agent-stash", "github:acme/release-stash"]);
+    }, { timeout: 60_000 });
+});

package/dist/tests/registry-cli.test.js

@@ -0,0 +1,290 @@
+import { afterAll, afterEach, beforeEach, describe, expect, test } from "bun:test";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { resolveRegistries, searchRegistry } from "../src/commands/registry-search";
+import { getConfigPath, loadConfig, saveConfig } from "../src/core/config";
+// ── Helpers ─────────────────────────────────────────────────────────────────
+const createdTmpDirs = [];
+function createTmpDir(prefix = "akm-reg-cli-") {
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), prefix));
+    createdTmpDirs.push(dir);
+    return dir;
+}
+function writeConfig(configPath, config) {
+    fs.mkdirSync(path.dirname(configPath), { recursive: true });
+    fs.writeFileSync(configPath, `${JSON.stringify(config, null, 2)}\n`);
+}
+function serveIndex(index) {
+    const body = JSON.stringify(index);
+    const server = Bun.serve({
+        port: 0,
+        fetch() {
+            return new Response(body, {
+                headers: { "Content-Type": "application/json" },
+            });
+        },
+    });
+    return {
+        url: `http://localhost:${server.port}/index.json`,
+        close: () => server.stop(true),
+    };
+}
+afterAll(() => {
+    for (const dir of createdTmpDirs) {
+        fs.rmSync(dir, { recursive: true, force: true });
+    }
+});
+const originalXdgConfigHome = process.env.XDG_CONFIG_HOME;
+const originalXdgCacheHome = process.env.XDG_CACHE_HOME;
+const originalRegistryUrl = process.env.AKM_REGISTRY_URL;
+beforeEach(() => {
+    process.env.XDG_CONFIG_HOME = createTmpDir("akm-reg-config-");
+    process.env.XDG_CACHE_HOME = createTmpDir("akm-reg-cache-");
+    delete process.env.AKM_REGISTRY_URL;
+});
+afterEach(() => {
+    if (originalXdgConfigHome === undefined) {
+        delete process.env.XDG_CONFIG_HOME;
+    }
+    else {
+        process.env.XDG_CONFIG_HOME = originalXdgConfigHome;
+    }
+    if (originalXdgCacheHome === undefined) {
+        delete process.env.XDG_CACHE_HOME;
+    }
+    else {
+        process.env.XDG_CACHE_HOME = originalXdgCacheHome;
+    }
+    if (originalRegistryUrl === undefined) {
+        delete process.env.AKM_REGISTRY_URL;
+    }
+    else {
+        process.env.AKM_REGISTRY_URL = originalRegistryUrl;
+    }
+});
+// ── Registry add/remove/list ─────────────────────────────────────────────────
+describe("registry add/remove/list via config", () => {
+    test("list returns default registries when none configured", () => {
+        const config = loadConfig();
+        const registries = config.registries ?? [];
+        expect(registries.length).toBe(2);
+        expect(registries[0].name).toBe("official");
+        expect(registries[0].url).toContain("akm-registry");
+        expect(registries[1].name).toBe("skills.sh");
+        expect(registries[1].provider).toBe("skills-sh");
+    });
+    test("add appends a registry entry", () => {
+        const config = loadConfig();
+        const registries = [...(config.registries ?? [])];
+        const newEntry = { url: "https://example.com/index.json", name: "custom" };
+        registries.push(newEntry);
+        saveConfig({ ...config, registries });
+        const updated = loadConfig();
+        expect(updated.registries?.length).toBe(3);
+        expect(updated.registries?.[2].url).toBe("https://example.com/index.json");
+        expect(updated.registries?.[2].name).toBe("custom");
+    });
+    test("add deduplicates by URL", () => {
+        // Start with a known registry entry
+        const url = "https://example.com/dedup-test.json";
+        const config = loadConfig();
+        const registries = [...(config.registries ?? [])];
+        registries.push({ url, name: "dedup-target" });
+        saveConfig({ ...config, registries });
+        // Verify it was added
+        const afterFirst = loadConfig();
+        const countAfterFirst = afterFirst.registries?.length ?? 0;
+        // Try to add the same URL again using the CLI's dedup logic
+        const current = loadConfig();
+        const currentRegistries = [...(current.registries ?? [])];
+        if (!currentRegistries.some((r) => r.url === url)) {
+            currentRegistries.push({ url, name: "dedup-target" });
+        }
+        saveConfig({ ...current, registries: currentRegistries });
+        // Verify length is unchanged — the duplicate was rejected
+        const afterSecond = loadConfig();
+        expect(afterSecond.registries?.length).toBe(countAfterFirst);
+    });
+    test("remove by URL", () => {
+        const config = loadConfig();
+        const registries = [
+            { url: "https://example.com/a.json", name: "a" },
+            { url: "https://example.com/b.json", name: "b" },
+        ];
+        saveConfig({ ...config, registries });
+        const current = loadConfig();
+        const remaining = (current.registries ?? []).filter((r) => r.url !== "https://example.com/a.json");
+        saveConfig({ ...current, registries: remaining });
+        const final = loadConfig();
+        expect(final.registries?.length).toBe(1);
+        expect(final.registries?.[0].name).toBe("b");
+    });
+    test("remove by name", () => {
+        const config = loadConfig();
+        const registries = [
+            { url: "https://example.com/a.json", name: "alpha" },
+            { url: "https://example.com/b.json", name: "beta" },
+        ];
+        saveConfig({ ...config, registries });
+        const current = loadConfig();
+        const remaining = (current.registries ?? []).filter((r) => r.name !== "alpha");
+        saveConfig({ ...current, registries: remaining });
+        const final = loadConfig();
+        expect(final.registries?.length).toBe(1);
+        expect(final.registries?.[0].name).toBe("beta");
+    });
+});
+// ── resolveRegistries ───────────────────────────────────────────────────────
+describe("resolveRegistries", () => {
+    test("filters out disabled registries", () => {
+        const entries = [
+            { url: "https://a.com/index.json", name: "a", enabled: true },
+            { url: "https://b.com/index.json", name: "b", enabled: false },
+            { url: "https://c.com/index.json", name: "c" },
+        ];
+        const resolved = resolveRegistries(entries);
+        expect(resolved.length).toBe(2);
+        expect(resolved.map((r) => r.name)).toEqual(["a", "c"]);
+    });
+    test("AKM_REGISTRY_URL env var overrides config", () => {
+        process.env.AKM_REGISTRY_URL = "https://override.com/index.json";
+        const resolved = resolveRegistries([{ url: "https://config.com/index.json" }]);
+        expect(resolved.length).toBe(1);
+        expect(resolved[0].url).toBe("https://override.com/index.json");
+    });
+    test("returns empty array when passed empty array", () => {
+        const resolved = resolveRegistries([]);
+        // Empty array passed explicitly — returns empty, no fallback
+        expect(resolved).toEqual([]);
+    });
+    test("returns default from config when no override", () => {
+        const resolved = resolveRegistries(undefined);
+        // Will read from loadConfig which returns DEFAULT_CONFIG registries
+        expect(resolved.length).toBeGreaterThan(0);
+        expect(resolved[0].name).toBe("official");
+    });
+});
+// ── Registry search with RegistryConfigEntry ────────────────────────────────
+describe("registry search with config entries", () => {
+    test("basic query against mock index", async () => {
+        const index = {
+            version: 3,
+            updatedAt: "2026-01-01T00:00:00Z",
+            stashes: [
+                {
+                    id: "npm:test-stash",
+                    name: "Test Stash",
+                    description: "A test stash for deploy",
+                    ref: "test-stash",
+                    source: "npm",
+                    tags: ["deploy"],
+                },
+            ],
+        };
+        const srv = serveIndex(index);
+        try {
+            const result = await searchRegistry("deploy", {
+                registries: [{ url: srv.url, name: "test-reg" }],
+            });
+            expect(result.hits.length).toBe(1);
+            expect(result.hits[0].id).toBe("npm:test-stash");
+            expect(result.hits[0].registryName).toBe("test-reg");
+        }
+        finally {
+            srv.close();
+        }
+    });
+    test("multi-registry search merges results from multiple URLs", async () => {
+        const index1 = {
+            version: 3,
+            updatedAt: "2026-01-01T00:00:00Z",
+            stashes: [
+                {
+                    id: "npm:stash-one",
+                    name: "Stash One",
+                    description: "First stash for build",
+                    ref: "stash-one",
+                    source: "npm",
+                    tags: ["build"],
+                },
+            ],
+        };
+        const index2 = {
+            version: 3,
+            updatedAt: "2026-01-01T00:00:00Z",
+            stashes: [
+                {
+                    id: "github:org/stash-two",
+                    name: "Stash Two",
+                    description: "Second stash for build automation",
+                    ref: "org/stash-two",
+                    source: "github",
+                    tags: ["build"],
+                },
+            ],
+        };
+        const srv1 = serveIndex(index1);
+        const srv2 = serveIndex(index2);
+        try {
+            const result = await searchRegistry("build", {
+                registries: [
+                    { url: srv1.url, name: "primary" },
+                    { url: srv2.url, name: "secondary" },
+                ],
+            });
+            expect(result.hits.length).toBe(2);
+            const ids = result.hits.map((h) => h.id);
+            expect(ids).toContain("npm:stash-one");
+            expect(ids).toContain("github:org/stash-two");
+            // Verify provenance
+            const stash1Hit = result.hits.find((h) => h.id === "npm:stash-one");
+            const stash2Hit = result.hits.find((h) => h.id === "github:org/stash-two");
+            expect(stash1Hit?.registryName).toBe("primary");
+            expect(stash2Hit?.registryName).toBe("secondary");
+        }
+        finally {
+            srv1.close();
+            srv2.close();
+        }
+    });
+    test("disabled registries are skipped via resolveRegistries before search", () => {
+        const entries = [
+            { url: "https://enabled.com/index.json", name: "enabled", enabled: true },
+            { url: "https://disabled.com/index.json", name: "disabled", enabled: false },
+        ];
+        const resolved = resolveRegistries(entries);
+        expect(resolved.length).toBe(1);
+        expect(resolved[0].name).toBe("enabled");
+    });
+});
+// ── Config roundtrip for registries ─────────────────────────────────────────
+describe("config roundtrip", () => {
+    test("registries persist through save/load cycle", () => {
+        const registries = [
+            { url: "https://a.com/index.json", name: "alpha" },
+            { url: "https://b.com/index.json", name: "beta", enabled: false },
+        ];
+        saveConfig({ semanticSearchMode: "auto", registries });
+        const loaded = loadConfig();
+        expect(loaded.registries?.length).toBe(2);
+        expect(loaded.registries?.[0]).toEqual({ url: "https://a.com/index.json", name: "alpha" });
+        expect(loaded.registries?.[1]).toEqual({ url: "https://b.com/index.json", name: "beta", enabled: false });
+    });
+    test("invalid registry entries are filtered during load", () => {
+        const configPath = getConfigPath();
+        writeConfig(configPath, {
+            semanticSearchMode: "auto",
+            registries: [
+                { url: "https://valid.com/index.json", name: "valid" },
+                { url: "", name: "empty-url" },
+                { name: "no-url" },
+                42,
+                null,
+            ],
+        });
+        const loaded = loadConfig();
+        expect(loaded.registries?.length).toBe(1);
+        expect(loaded.registries?.[0].url).toBe("https://valid.com/index.json");
+    });
+});