akm-cli 0.8.7 → 0.8.14

package/dist/registry/build-index.js

@@ -12,15 +12,16 @@
  */
 import fs from "node:fs";
 import path from "node:path";
-import { fetchWithRetry, jsonWithByteCap } from "../core/common";
-import { getCacheDir } from "../core/paths";
-import { generateMetadataFlat, loadStashFile } from "../indexer/metadata";
-import { walkStashFlat } from "../indexer/walker";
-import { asRecord, asString, GITHUB_API_BASE, githubHeaders } from "../integrations/github";
-import { copyIncludedPaths, findNearestIncludeConfig } from "../sources/include";
-import { detectStashRoot } from "../sources/providers/provider-utils";
-import { extractTarGzSecure } from "../sources/providers/tar-utils";
-import { parseRegistryIndex } from "./providers/static-index";
+import { fetchWithRetry, jsonWithByteCap } from "../core/common.js";
+import { getCacheDir } from "../core/paths.js";
+import { generateMetadataFlat, loadStashFile } from "../indexer/passes/metadata.js";
+import { walkStashFlat } from "../indexer/walk/walker.js";
+import { asRecord, asString, GITHUB_API_BASE, githubHeaders } from "../integrations/github.js";
+import { writeResponseToFile } from "../runtime.js";
+import { copyIncludedPaths, findNearestIncludeConfig } from "../sources/include.js";
+import { detectStashRoot } from "../sources/providers/provider-utils.js";
+import { extractTarGzSecure } from "../sources/providers/tar-utils.js";
+import { parseRegistryIndex } from "./providers/static-index.js";
 const DEFAULT_NPM_REGISTRY_BASE = "https://registry.npmjs.org";
 const REQUIRED_KEYWORDS = ["akm-stash"];
 const GITHUB_TOPICS = ["akm-stash"];
@@ -194,7 +195,7 @@ async function inspectArchive(url, headers) {
         if (!response.ok) {
             throw new Error(`Failed to fetch archive (${response.status}) from ${url}`);
         }
-        await Bun.write(archivePath, response);
+        await writeResponseToFile(archivePath, response);
         // Reuse the secure extraction from registry-install which validates entries,
         // uses --no-same-owner, strips components, and runs a post-extraction scan.
         extractTarGzSecure(archivePath, extractDir);

package/dist/registry/factory.js

@@ -17,7 +17,7 @@
  * The legacy alias in `src/registry-provider.ts` is kept as a thin re-export
  * for transitional callers and will be removed after the dust settles.
  */
-import { createProviderRegistry } from "./create-provider-registry";
+import { createProviderRegistry } from "./create-provider-registry.js";
 // ── Factory map ─────────────────────────────────────────────────────────────
 const registry = createProviderRegistry();
 export function registerProvider(type, factory) {

package/dist/registry/origin-resolve.js

@@ -2,7 +2,7 @@
 // License, v. 2.0. If a copy of the MPL was not distributed with this
 // file, You can obtain one at https://mozilla.org/MPL/2.0/.
 import path from "node:path";
-import { parseRegistryRef } from "./resolve";
+import { parseRegistryRef } from "./resolve.js";
 /**
  * Given an origin string (from an AssetRef) and the full list of stash
  * sources, return the subset of sources to search.

package/dist/registry/providers/index.js

@@ -10,5 +10,5 @@
  *
  * Mirrors the pattern used by `sources/providers/index.ts`.
  */
-import "./static-index";
-import "./skills-sh";
+import "./static-index.js";
+import "./skills-sh.js";

package/dist/registry/providers/skills-sh.js

@@ -1,13 +1,47 @@
 // This Source Code Form is subject to the terms of the Mozilla Public
 // License, v. 2.0. If a copy of the MPL was not distributed with this
 // file, You can obtain one at https://mozilla.org/MPL/2.0/.
-import { fetchWithRetry } from "../../core/common";
-import { rethrowIfTestIsolationError } from "../../core/errors";
-import { closeDatabase, getRegistryIndexCache, openDatabase, upsertRegistryIndexCache } from "../../indexer/db";
-import { registerProvider } from "../factory";
+import { fetchWithRetry } from "../../core/common.js";
+import { rethrowIfTestIsolationError } from "../../core/errors.js";
+import { closeDatabase, getRegistryIndexCache, openDatabase, upsertRegistryIndexCache } from "../../indexer/db/db.js";
+import { md5Hex } from "../../runtime.js";
+import { registerProvider } from "../factory.js";
 // ── Constants ───────────────────────────────────────────────────────────────
 /** Per-query cache TTL in milliseconds (15 minutes). */
 const QUERY_CACHE_TTL_MS = 15 * 60 * 1000;
+// ── Cache DB lifecycle ────────────────────────────────────────────────────────
+/**
+ * RAII-style lifecycle helper for the registry cache DB. Opens the DB (treating
+ * a failed open exactly like the legacy fall-through: the bun-test isolation
+ * guard is re-thrown, any other failure yields `db = undefined`), runs `fn`,
+ * and guarantees the DB is closed in a `finally` after `fn` has fully settled
+ * (the await is required: the callbacks are async, and closing before they
+ * settle would tear the DB down mid-write).
+ */
+async function withRegistryCacheDb(fn) {
+    let db;
+    try {
+        db = openDatabase();
+    }
+    catch (err) {
+        // Never mask the bun-test isolation guard as "DB unavailable".
+        rethrowIfTestIsolationError(err);
+        db = undefined;
+    }
+    try {
+        return await fn(db);
+    }
+    finally {
+        if (db) {
+            try {
+                closeDatabase(db);
+            }
+            catch {
+                /* ignore */
+            }
+        }
+    }
+}
 // ── Provider class ──────────────────────────────────────────────────────────
 class SkillsShProvider {
     type = "skills-sh";
@@ -91,82 +125,73 @@ class SkillsShProvider {
     async fetchSkills(query, limit) {
         // Build a stable DB cache key for this query
         const dbCacheKey = this.queryDbCacheKey(query, limit);
-        // ── Step 1: Try DB cache (index.db) ───────────────────────────────────
-        let db;
-        let dbCacheResult;
-        try {
-            db = openDatabase();
-            dbCacheResult = getRegistryIndexCache(db, dbCacheKey, QUERY_CACHE_TTL_MS);
-        }
-        catch (err) {
-            // Never mask the bun-test isolation guard as "DB unavailable" — see
-            // rethrowIfTestIsolationError in src/core/errors.ts. Without this,
-            // a leaky test silently gets a cold cache + fresh fetch instead of
-            // the loud TEST_ISOLATION_MISSING failure the guard intends.
-            rethrowIfTestIsolationError(err);
-            // index.db not available yet (pre-migration install or test env) — fall through
-        }
-        if (dbCacheResult) {
+        return withRegistryCacheDb(async (db) => {
+            // ── Step 1: Try DB cache (index.db) ───────────────────────────────────
+            let dbCacheResult;
             try {
-                const parsed = JSON.parse(dbCacheResult.indexJson);
-                if (Array.isArray(parsed)) {
-                    const entries = parsed.filter(isValidSkillsEntry);
-                    if (db)
-                        closeDatabase(db);
-                    return entries;
+                if (db) {
+                    dbCacheResult = getRegistryIndexCache(db, dbCacheKey, QUERY_CACHE_TTL_MS);
                 }
             }
-            catch {
-                /* corrupt DB entry — fall through */
+            catch (err) {
+                // Never mask the bun-test isolation guard as "DB unavailable" — see
+                // rethrowIfTestIsolationError in src/core/errors.ts. Without this,
+                // a leaky test silently gets a cold cache + fresh fetch instead of
+                // the loud TEST_ISOLATION_MISSING failure the guard intends.
+                rethrowIfTestIsolationError(err);
+                // index.db not available yet (pre-migration install or test env) — fall through
             }
-        }
-        // ── Step 2: Fetch from API ─────────────────────────────────────────────
-        const baseUrl = this.config.url.replace(/\/+$/, "");
-        const url = `${baseUrl}/api/search?q=${encodeURIComponent(query)}&limit=${limit}`;
-        try {
-            const response = await fetchWithRetry(url, undefined, { timeout: 10_000, retries: 1 });
-            if (!response.ok) {
-                throw new Error(`HTTP ${response.status}`);
-            }
-            const data = (await response.json());
-            const entries = parseSkillsResponse(data);
-            // Write to DB cache (primary)
-            if (db) {
+            if (dbCacheResult) {
                 try {
-                    upsertRegistryIndexCache(db, dbCacheKey, JSON.stringify(entries));
+                    const parsed = JSON.parse(dbCacheResult.indexJson);
+                    if (Array.isArray(parsed)) {
+                        const entries = parsed.filter(isValidSkillsEntry);
+                        return entries;
+                    }
                 }
                 catch {
-                    /* best-effort */
+                    /* corrupt DB entry — fall through */
                 }
-                closeDatabase(db);
             }
-            return entries;
-        }
-        catch (err) {
-            if (db) {
-                try {
-                    closeDatabase(db);
+            // ── Step 2: Fetch from API ─────────────────────────────────────────────
+            const baseUrl = this.config.url.replace(/\/+$/, "");
+            const url = `${baseUrl}/api/search?q=${encodeURIComponent(query)}&limit=${limit}`;
+            try {
+                const response = await fetchWithRetry(url, undefined, { timeout: 10_000, retries: 1 });
+                if (!response.ok) {
+                    throw new Error(`HTTP ${response.status}`);
                 }
-                catch {
-                    /* ignore */
+                const data = (await response.json());
+                const entries = parseSkillsResponse(data);
+                // Write to DB cache (primary)
+                if (db) {
+                    try {
+                        upsertRegistryIndexCache(db, dbCacheKey, JSON.stringify(entries));
+                    }
+                    catch {
+                        /* best-effort */
+                    }
                 }
+                return entries;
             }
-            // Fetch failed — use stale DB cache if available
-            if (dbCacheResult) {
-                try {
-                    const parsed = JSON.parse(dbCacheResult.indexJson);
-                    if (Array.isArray(parsed)) {
-                        const entries = parsed.filter(isValidSkillsEntry);
-                        if (entries.length > 0)
-                            return entries;
+            catch (err) {
+                // Fetch failed — use stale DB cache if available
+                if (dbCacheResult) {
+                    try {
+                        const parsed = JSON.parse(dbCacheResult.indexJson);
+                        if (Array.isArray(parsed)) {
+                            const entries = parsed.filter(isValidSkillsEntry);
+                            if (entries.length > 0)
+                                return entries;
+                        }
+                    }
+                    catch {
+                        /* ignore */
                     }
                 }
-                catch {
-                    /* ignore */
-                }
+                throw err;
             }
-            throw err;
-        }
+        });
     }
     mapToHits(entries) {
         if (entries.length === 0)
@@ -221,13 +246,7 @@ class SkillsShProvider {
     }
     // ── DB cache key ────────────────────────────────────────────────────────
     queryDbCacheKey(query, limit) {
-        const hasher = new Bun.CryptoHasher("md5");
-        hasher.update(this.config.url);
-        hasher.update("\0");
-        hasher.update(query.trim().toLowerCase());
-        hasher.update("\0");
-        hasher.update(String(limit));
-        const hash = hasher.digest("hex");
+        const hash = md5Hex(`${this.config.url}\0${query.trim().toLowerCase()}\0${String(limit)}`);
         return `skills-sh:${hash}`;
     }
 }

package/dist/registry/providers/static-index.js

@@ -1,11 +1,11 @@
 // This Source Code Form is subject to the terms of the Mozilla Public
 // License, v. 2.0. If a copy of the MPL was not distributed with this
 // file, You can obtain one at https://mozilla.org/MPL/2.0/.
-import { fetchWithRetry, jsonWithByteCap, toErrorMessage } from "../../core/common";
-import { rethrowIfTestIsolationError } from "../../core/errors";
-import { closeDatabase, getRegistryIndexCache, openDatabase, upsertRegistryIndexCache } from "../../indexer/db";
-import { asString } from "../../integrations/github";
-import { registerProvider } from "../factory";
+import { fetchWithRetry, jsonWithByteCap, toErrorMessage } from "../../core/common.js";
+import { rethrowIfTestIsolationError } from "../../core/errors.js";
+import { closeDatabase, getRegistryIndexCache, openDatabase, upsertRegistryIndexCache } from "../../indexer/db/db.js";
+import { asString } from "../../integrations/github.js";
+import { registerProvider } from "../factory.js";
 // ── Constants ───────────────────────────────────────────────────────────────
 /** Cache TTL in milliseconds (1 hour). */
 const CACHE_TTL_MS = 60 * 60 * 1000;
@@ -115,58 +115,28 @@ function assetHitToPreview(hit) {
 // ── Self-register ───────────────────────────────────────────────────────────
 registerProvider("static-index", (config) => new StaticIndexProvider(config));
 // ── Index loading with cache ────────────────────────────────────────────────
-async function loadIndex(entry) {
-    // ── Step 1: Try DB cache (index.db) ─────────────────────────────────────
+/**
+ * RAII-style lifecycle helper for the registry cache DB. Opens the DB (treating
+ * a failed open exactly like the legacy fall-through: the bun-test isolation
+ * guard is re-thrown, any other failure yields `db = undefined`), runs `fn`,
+ * and guarantees the DB is closed in a `finally` after `fn` has fully settled
+ * (the await is required: the callbacks are async, and closing before they
+ * settle would tear the DB down mid-write).
+ */
+async function withRegistryCacheDb(fn) {
     let db;
-    let dbCacheResult;
     try {
         db = openDatabase();
-        dbCacheResult = getRegistryIndexCache(db, entry.url, CACHE_TTL_MS);
     }
     catch (err) {
-        // Never mask the bun-test isolation guard as "DB unavailable" — see
-        // rethrowIfTestIsolationError in src/core/errors.ts. Without this, a
-        // leaky test silently gets a cold cache instead of the loud
-        // TEST_ISOLATION_MISSING failure the guard intends.
+        // Never mask the bun-test isolation guard as "DB unavailable".
         rethrowIfTestIsolationError(err);
-        // index.db not available yet (pre-migration install or test env) — fall through
+        db = undefined;
     }
-    if (dbCacheResult) {
-        const index = parseRegistryIndex(JSON.parse(dbCacheResult.indexJson));
-        if (index) {
-            if (db)
-                closeDatabase(db);
-            return index;
-        }
-    }
-    // ── Step 2: Fetch fresh index from remote ────────────────────────────────
     try {
-        const response = await fetchWithRetry(entry.url, undefined, { timeout: 10_000 });
-        if (!response.ok) {
-            throw new Error(`HTTP ${response.status}`);
-        }
-        // Cap at 50 MB — registry indexes can grow large but unbounded
-        // responses from a compromised server would OOM us.
-        const data = await jsonWithByteCap(response, 50 * 1024 * 1024);
-        const index = parseRegistryIndex(data);
-        if (index) {
-            // Write to DB cache (primary)
-            if (db) {
-                try {
-                    const etag = response.headers.get("etag") ?? undefined;
-                    const lastModified = response.headers.get("last-modified") ?? undefined;
-                    upsertRegistryIndexCache(db, entry.url, JSON.stringify(index), { etag, lastModified });
-                }
-                catch {
-                    /* best-effort */
-                }
-                closeDatabase(db);
-            }
-            return index;
-        }
-        throw new Error("Invalid registry index format");
+        return await fn(db);
     }
-    catch (err) {
+    finally {
         if (db) {
             try {
                 closeDatabase(db);
@@ -175,14 +145,67 @@ async function loadIndex(entry) {
                 /* ignore */
             }
         }
-        // Fetch failed — use stale DB cache if available
+    }
+}
+async function loadIndex(entry) {
+    return withRegistryCacheDb(async (db) => {
+        // ── Step 1: Try DB cache (index.db) ─────────────────────────────────────
+        let dbCacheResult;
+        try {
+            if (db) {
+                dbCacheResult = getRegistryIndexCache(db, entry.url, CACHE_TTL_MS);
+            }
+        }
+        catch (err) {
+            // Never mask the bun-test isolation guard as "DB unavailable" — see
+            // rethrowIfTestIsolationError in src/core/errors.ts. Without this, a
+            // leaky test silently gets a cold cache instead of the loud
+            // TEST_ISOLATION_MISSING failure the guard intends.
+            rethrowIfTestIsolationError(err);
+            // index.db read failed (pre-migration install or test env) — fall through
+        }
         if (dbCacheResult) {
             const index = parseRegistryIndex(JSON.parse(dbCacheResult.indexJson));
-            if (index)
+            if (index) {
                 return index;
+            }
         }
-        throw err;
-    }
+        // ── Step 2: Fetch fresh index from remote ────────────────────────────────
+        try {
+            const response = await fetchWithRetry(entry.url, undefined, { timeout: 10_000 });
+            if (!response.ok) {
+                throw new Error(`HTTP ${response.status}`);
+            }
+            // Cap at 50 MB — registry indexes can grow large but unbounded
+            // responses from a compromised server would OOM us.
+            const data = await jsonWithByteCap(response, 50 * 1024 * 1024);
+            const index = parseRegistryIndex(data);
+            if (index) {
+                // Write to DB cache (primary)
+                if (db) {
+                    try {
+                        const etag = response.headers.get("etag") ?? undefined;
+                        const lastModified = response.headers.get("last-modified") ?? undefined;
+                        upsertRegistryIndexCache(db, entry.url, JSON.stringify(index), { etag, lastModified });
+                    }
+                    catch {
+                        /* best-effort */
+                    }
+                }
+                return index;
+            }
+            throw new Error("Invalid registry index format");
+        }
+        catch (err) {
+            // Fetch failed — use stale DB cache if available
+            if (dbCacheResult) {
+                const index = parseRegistryIndex(JSON.parse(dbCacheResult.indexJson));
+                if (index)
+                    return index;
+            }
+            throw err;
+        }
+    });
 }
 export function isCacheExpired(mtimeMs) {
     return Date.now() - mtimeMs > CACHE_TTL_MS;

package/dist/registry/resolve.js

@@ -6,9 +6,9 @@ import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
-import { fetchWithRetry, jsonWithByteCap } from "../core/common";
-import { NotFoundError, UsageError } from "../core/errors";
-import { asRecord, asString, GITHUB_API_BASE, githubHeaders } from "../integrations/github";
+import { fetchWithRetry, jsonWithByteCap } from "../core/common.js";
+import { NotFoundError, UsageError } from "../core/errors.js";
+import { asRecord, asString, GITHUB_API_BASE, githubHeaders } from "../integrations/github.js";
 /**
  * Validate that a URL is safe to pass to git.
  * Allowlists https:, http:, ssh:, git: schemes and git@ SSH shorthand.