akm-cli 0.9.0-beta.5 → 0.9.0-beta.50

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

@@ -2,10 +2,10 @@
 // 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.js";
-import { rethrowIfTestIsolationError } from "../../core/errors.js";
-import { closeDatabase, getRegistryIndexCache, openDatabase, upsertRegistryIndexCache } from "../../indexer/db/db.js";
 import { asString } from "../../integrations/github.js";
+import { fetchCachedJson } from "../../storage/repositories/registry-cache.js";
 import { registerProvider } from "../factory.js";
+import { buildInstallRef } from "../resolve.js";
 // ── Constants ───────────────────────────────────────────────────────────────
 /** Cache TTL in milliseconds (1 hour). */
 const CACHE_TTL_MS = 60 * 60 * 1000;
@@ -30,51 +30,6 @@ class StaticIndexProvider {
         }
         return { hits, assetHits, warnings: warnings.length > 0 ? warnings : undefined };
     }
-    // ── v1-spec §3.1 surface ────────────────────────────────────────────────
-    async searchKits(q) {
-        const result = await this.search({
-            query: q.text,
-            limit: q.limit ?? 20,
-            includeAssets: false,
-        });
-        return result.hits.map(hitToKitResult);
-    }
-    async searchAssets(q) {
-        const result = await this.search({
-            query: q.text,
-            limit: q.limit ?? 20,
-            includeAssets: true,
-        });
-        return (result.assetHits ?? []).map(assetHitToPreview);
-    }
-    async getKit(id) {
-        const allKits = await this.loadAllKits([]);
-        const found = allKits.find(({ stash }) => stash.id === id);
-        if (!found)
-            return null;
-        const installRef = buildInstallRef(found.stash.source, found.stash.ref);
-        return {
-            id: found.stash.id,
-            installRef,
-            assets: found.stash.assets?.map((asset) => ({
-                kitId: found.stash.id,
-                type: asset.type,
-                name: asset.name,
-                summary: asset.description,
-                cloneRef: installRef,
-            })),
-        };
-    }
-    /**
-     * Static-index doesn't own a URL prefix — any `ParsedRegistryRef` could
-     * theoretically be backed by an entry in some static-index registry. We
-     * therefore claim every ref. The orchestrator picks the first matching
-     * provider, and `static-index` is registered first by `index.ts`, so this
-     * is effectively the default catch-all.
-     */
-    canHandle(_ref) {
-        return true;
-    }
     // ── Internals ───────────────────────────────────────────────────────────
     async loadAllKits(warnings) {
         const allKits = [];
@@ -94,84 +49,17 @@ class StaticIndexProvider {
         return allKits;
     }
 }
-function hitToKitResult(hit) {
-    return {
-        id: hit.id,
-        title: hit.title,
-        summary: hit.description,
-        installRef: hit.installRef,
-        score: hit.score,
-    };
-}
-function assetHitToPreview(hit) {
-    return {
-        kitId: hit.stash.id,
-        type: hit.assetType,
-        name: hit.assetName,
-        summary: hit.description,
-        cloneRef: hit.action.replace(/^akm add\s+/, ""),
-    };
-}
 // ── Self-register ───────────────────────────────────────────────────────────
 registerProvider("static-index", (config) => new StaticIndexProvider(config));
 // ── Index loading with cache ────────────────────────────────────────────────
-/**
- * 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 */
-            }
-        }
-    }
-}
 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) {
-                return index;
-            }
-        }
-        // ── Step 2: Fetch fresh index from remote ────────────────────────────────
-        try {
+    return fetchCachedJson({
+        cacheKey: entry.url,
+        ttlMs: CACHE_TTL_MS,
+        // Both the fresh hit and the stale fallback parse identically; a corrupt
+        // cache row lets JSON.parse throw out of the load (legacy behaviour).
+        parseCache: (json) => parseRegistryIndex(JSON.parse(json)) ?? undefined,
+        fetchFresh: async () => {
             const response = await fetchWithRetry(entry.url, undefined, { timeout: 10_000 });
             if (!response.ok) {
                 throw new Error(`HTTP ${response.status}`);
@@ -180,31 +68,13 @@ async function loadIndex(entry) {
             // 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;
+            if (!index) {
+                throw new Error("Invalid registry index format");
             }
-            throw err;
-        }
+            const etag = response.headers.get("etag") ?? undefined;
+            const lastModified = response.headers.get("last-modified") ?? undefined;
+            return { value: index, cacheJson: JSON.stringify(index), cacheOpts: { etag, lastModified } };
+        },
     });
 }
 export function isCacheExpired(mtimeMs) {
@@ -431,15 +301,3 @@ function asStringArray(value) {
     const filtered = value.filter((v) => typeof v === "string");
     return filtered.length > 0 ? filtered : undefined;
 }
-function buildInstallRef(source, ref) {
-    switch (source) {
-        case "npm":
-            return `npm:${ref}`;
-        case "git":
-            return `git+${ref}`;
-        case "local":
-            return `file:${ref}`;
-        default:
-            return `github:${ref}`;
-    }
-}

package/dist/registry/resolve.js

@@ -70,6 +70,19 @@ export function parseRegistryRef(rawRef) {
     }
     return parseGithubShorthand(ref, ref);
 }
+/** Inverse of {@link parseRegistryRef}: build the install ref for a source kind. */
+export function buildInstallRef(source, ref) {
+    switch (source) {
+        case "npm":
+            return `npm:${ref}`;
+        case "git":
+            return `git+${ref}`;
+        case "local":
+            return `file:${ref}`;
+        case "github":
+            return `github:${ref}`;
+    }
+}
 /**
  * Known prefixes that `parseRegistryRef` handles as installable sources.
  * Anything with a colon that doesn't start with one of these is likely a
@@ -105,16 +118,16 @@ function detectRegistrySearchId(ref) {
     return lines.join("\n");
 }
 export async function resolveRegistryArtifact(parsed) {
-    if (parsed.source === "npm") {
-        return resolveNpmArtifact(parsed);
-    }
-    if (parsed.source === "local") {
-        return resolveLocalArtifact(parsed);
-    }
-    if (parsed.source === "git") {
-        return resolveGitArtifact(parsed);
+    switch (parsed.source) {
+        case "npm":
+            return resolveNpmArtifact(parsed);
+        case "local":
+            return resolveLocalArtifact(parsed);
+        case "git":
+            return resolveGitArtifact(parsed);
+        case "github":
+            return resolveGithubArtifact(parsed);
     }
-    return resolveGithubArtifact(parsed);
 }
 function parseNpmRef(input, originalRef) {
     const trimmed = input.trim();

package/dist/runtime.js

@@ -22,7 +22,7 @@
  */
 import { spawn as nodeSpawn, spawnSync as nodeSpawnSync } from "node:child_process";
 import { createHash } from "node:crypto";
-import { createWriteStream } from "node:fs";
+import { createWriteStream, statfsSync } from "node:fs";
 import { createRequire } from "node:module";
 import path from "node:path";
 import { Readable } from "node:stream";
@@ -200,6 +200,30 @@ export function resolveModule(spec, from) {
 export function getDirname(importMetaUrl) {
     return path.dirname(fileURLToPath(importMetaUrl));
 }
+// ── Filesystem type probe ─────────────────────────────────────────────────────
+/**
+ * Best-effort filesystem-type probe: return the numeric `f_type` magic of the
+ * filesystem backing `path`, or `undefined` on any error (ENOENT/EPERM/
+ * unsupported). Used (via injection) by the SQLite journal-mode network-FS
+ * fallback (#628).
+ *
+ * This is a runtime primitive (a `statfs` filesystem-type probe) and therefore
+ * lives here, per the runtime boundary, even though it uses only `node:fs`. The
+ * "magic-number → is-network" classification stays a pure helper elsewhere.
+ *
+ * `fs.statfsSync` is a stable `node:fs` API (Node ≥ 18.15) and is implemented
+ * under Bun as well. It THROWS ENOENT on a non-existent path, so callers should
+ * probe an already-created directory — the swallowed error simply yields
+ * `undefined` (treated as "not network").
+ */
+export function statfsType(path) {
+    try {
+        return statfsSync(path).type;
+    }
+    catch {
+        return undefined;
+    }
+}
 // ── Sleep ───────────────────────────────────────────────────────────────────
 /**
  * Block the current thread for `ms` without busy-spinning. On Bun uses the real