akm-cli 0.9.1 → 0.9.2-alpha.2

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

@@ -1,10 +1,12 @@
 // 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.js";
+import { jsonWithByteCap } from "../../core/common.js";
+import { formatRegistryCredentialWarning, formatRegistryError, formatRegistryLabel, hasRegistryUrlCredentials, } from "../../core/registry-url.js";
 import { md5Hex } from "../../runtime.js";
 import { fetchCachedJson } from "../../storage/repositories/registry-cache.js";
 import { registerRegistryProvider } from "../factory.js";
+import { allowPrivateRegistryFixtureForTests, cancelRegistryResponse, fetchRegistryResponse } from "../network.js";
 // ── Constants ───────────────────────────────────────────────────────────────
 /** Per-query cache TTL in milliseconds (15 minutes). */
 const QUERY_CACHE_TTL_MS = 15 * 60 * 1000;
@@ -16,6 +18,9 @@ class SkillsShProvider {
         this.config = config;
     }
     async search(options) {
+        if (hasRegistryUrlCredentials(this.config.url)) {
+            return { hits: [], warnings: [formatRegistryCredentialWarning(this.config)] };
+        }
         try {
             const entries = await this.fetchSkills(options.query, options.limit);
             const limited = entries.slice(0, options.limit);
@@ -27,9 +32,10 @@ class SkillsShProvider {
             return { hits, assetHits };
         }
         catch (err) {
-            const label = this.config.name ?? "skills.sh";
-            const message = err instanceof Error ? err.message : String(err);
-            return { hits: [], warnings: [`Registry ${label}: ${message}`] };
+            return {
+                hits: [],
+                warnings: [`Registry ${formatRegistryLabel(this.config)}: ${formatRegistryError(err)}`],
+            };
         }
     }
     async fetchSkills(query, limit) {
@@ -57,11 +63,17 @@ class SkillsShProvider {
                 }
             },
             fetchFresh: async () => {
-                const response = await fetchWithRetry(url, undefined, { timeout: 10_000, retries: 1 });
+                const response = await fetchRegistryResponse(url, undefined, {
+                    policy: { kind: "public-registry" },
+                    timeoutMs: 10_000,
+                    retries: 1,
+                    allowPrivateHostsForTesting: allowPrivateRegistryFixtureForTests(url),
+                });
                 if (!response.ok) {
+                    await cancelRegistryResponse(response);
                     throw new Error(`HTTP ${response.status}`);
                 }
-                const data = (await response.json());
+                const data = await jsonWithByteCap(response, 10 * 1024 * 1024, { bodyTimeoutMs: 10_000 });
                 const entries = parseSkillsResponse(data);
                 return { value: entries, cacheJson: JSON.stringify(entries) };
             },

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

@@ -1,10 +1,12 @@
 // 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.js";
+import { jsonWithByteCap } from "../../core/common.js";
+import { formatRegistryCredentialWarning, formatRegistryError, formatRegistryLabel, hasRegistryUrlCredentials, } from "../../core/registry-url.js";
 import { asString } from "../../integrations/github.js";
 import { fetchCachedJson } from "../../storage/repositories/registry-cache.js";
 import { registerRegistryProvider } from "../factory.js";
+import { allowPrivateRegistryFixtureForTests, cancelRegistryResponse, fetchRegistryResponse } from "../network.js";
 import { buildInstallRef } from "../resolve.js";
 // ── Constants ───────────────────────────────────────────────────────────────
 /** Cache TTL in milliseconds (1 hour). */
@@ -17,6 +19,9 @@ class StaticIndexProvider {
         this.config = config;
     }
     async search(options) {
+        if (hasRegistryUrlCredentials(this.config.url)) {
+            return { hits: [], warnings: [formatRegistryCredentialWarning(this.config)] };
+        }
         const warnings = [];
         const bundles = await this.loadBundles(warnings);
         const hits = scoreBundles(bundles, options.query, options.limit);
@@ -36,13 +41,16 @@ class StaticIndexProvider {
             if (index) {
                 const regName = this.config.name;
                 for (const stash of index.stashes) {
+                    if (stash.source === "git") {
+                        warnings.push(`Registry ${formatRegistryLabel(this.config)}: ignored ${stash.id} because registry-provided git transport refs are not installable`);
+                        continue;
+                    }
                     bundles.push({ stash, registryName: regName });
                 }
             }
         }
         catch (err) {
-            const label = this.config.name ? `${this.config.name} (${this.config.url})` : this.config.url;
-            warnings.push(`Registry ${label}: ${toErrorMessage(err)}`);
+            warnings.push(`Registry ${formatRegistryLabel(this.config)}: ${formatRegistryError(err)}`);
         }
         return bundles;
     }
@@ -58,13 +66,18 @@ async function loadIndex(entry) {
         // cache row lets JSON.parse throw out of the load.
         parseCache: (json) => parseRegistryIndex(JSON.parse(json)) ?? undefined,
         fetchFresh: async () => {
-            const response = await fetchWithRetry(entry.url, undefined, { timeout: 10_000 });
+            const response = await fetchRegistryResponse(entry.url, undefined, {
+                policy: { kind: "public-registry" },
+                timeoutMs: 10_000,
+                allowPrivateHostsForTesting: allowPrivateRegistryFixtureForTests(entry.url),
+            });
             if (!response.ok) {
+                await cancelRegistryResponse(response);
                 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 data = await jsonWithByteCap(response, 50 * 1024 * 1024, { bodyTimeoutMs: 10_000 });
             const index = parseRegistryIndex(data);
             if (!index) {
                 throw new Error("Invalid registry index format");
@@ -182,7 +195,7 @@ function toSearchHit(stash, score, registryName) {
         title: stash.name,
         description: stash.description,
         ref: stash.ref,
-        installRef: buildInstallRef(stash.source, stash.ref),
+        installRef: buildInstallRef(stash.source, stash.ref, "registry"),
         homepage: stash.homepage,
         score: Math.round(score * 1000) / 1000,
         metadata,
@@ -224,7 +237,7 @@ function scoreAssets(stashes, query, limit) {
     for (const { stash, registryName } of stashes) {
         if (!stash.assets || stash.assets.length === 0)
             continue;
-        const installRef = buildInstallRef(stash.source, stash.ref);
+        const installRef = buildInstallRef(stash.source, stash.ref, "registry");
         for (const asset of stash.assets) {
             const score = scoreAsset(asset, tokens);
             if (score > 0) {

package/dist/registry/resolve.js

@@ -6,9 +6,10 @@ 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.js";
+import { jsonWithByteCap } from "../core/common.js";
 import { NotFoundError, UsageError } from "../core/errors.js";
 import { asRecord, asString, GITHUB_API_BASE, githubHeaders } from "../integrations/github.js";
+import { cancelRegistryResponse, fetchRegistryResponse } from "./network.js";
 import { isExactSemver, isSemverRange, maxSatisfying } from "./semver.js";
 /**
  * Validate that a URL is safe to pass to git.
@@ -72,7 +73,10 @@ 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) {
+export function buildInstallRef(source, ref, provenance = "operator") {
+    if (source === "git" && provenance === "registry") {
+        throw new UsageError("Registry-provided git transport refs are not installable. Add a trusted git URL directly if you intend to use it.");
+    }
     switch (source) {
         case "npm":
             return `npm:${ref}`;
@@ -306,11 +310,12 @@ export function trustedNpmTarballHosts() {
     return hosts;
 }
 /**
- * Validate that an npm tarball URL points at a trusted registry host. A
- * compromised mirror could otherwise return an attacker-controlled
- * `dist.tarball` field, redirecting installs to a third-party host.
+ * Validate that an npm tarball URL starts at the exact metadata registry
+ * origin. A compromised mirror must not change scheme or port (or nominate a
+ * different host) in `dist.tarball`; later public redirects remain subject to
+ * the outbound boundary's hop-by-hop policy.
  */
-export function validateNpmTarballUrl(tarballUrl, packageRef) {
+export function validateNpmTarballUrl(tarballUrl, packageRef, registryOrigin) {
     let url;
     try {
         url = new URL(tarballUrl);
@@ -321,12 +326,21 @@ export function validateNpmTarballUrl(tarballUrl, packageRef) {
     if (url.protocol !== "https:" && url.protocol !== "http:") {
         throw new UntrustedNpmTarballError(`npm package ${packageRef} returned a tarball with disallowed scheme "${url.protocol}".`);
     }
-    const trusted = trustedNpmTarballHosts();
-    const host = url.hostname.toLowerCase();
-    if (!trusted.has(host)) {
-        const allowed = Array.from(trusted).join(", ");
-        throw new UntrustedNpmTarballError(`npm package ${packageRef} returned a tarball URL on untrusted host "${host}" (allowed: ${allowed}).`);
+    const expectedOrigin = registryOrigin ?? new URL(npmMetadataRegistry().baseUrl).origin;
+    if (url.origin !== expectedOrigin) {
+        throw new UntrustedNpmTarballError(`npm package ${packageRef} returned a tarball URL on untrusted origin "${url.origin}" (expected: ${expectedOrigin}).`);
+    }
+}
+/** Network policy for a tarball URL that already passed {@link validateNpmTarballUrl}. */
+export function npmArtifactNetworkPolicy(artifact) {
+    if (!artifact.registryOrigin) {
+        throw new UsageError("npm artifact network policy requires the registry origin that authorized its metadata.");
     }
+    return {
+        kind: "npm-api",
+        registryOrigin: new URL(artifact.registryOrigin).origin,
+        allowPrivateRegistryOrigin: artifact.allowPrivateRegistryOrigin === true,
+    };
 }
 /**
  * Resolve the npm registry base URL used to fetch package METADATA.
@@ -341,24 +355,29 @@ export function validateNpmTarballUrl(tarballUrl, packageRef) {
  * default wholesale (like npm's own `--registry` flag) rather than being
  * merged with it.
  */
-function npmMetadataRegistryBase() {
+function npmMetadataRegistry() {
     const override = process.env.AKM_NPM_REGISTRY?.trim();
     if (override) {
         try {
             const url = new URL(override);
             const base = `${url.origin}${url.pathname === "/" ? "" : url.pathname}`;
-            return base.replace(/\/+$/, "");
+            return { baseUrl: base.replace(/\/+$/, ""), allowPrivateRegistryOrigin: true };
         }
         catch {
             // Ignore unparseable overrides; fall back to the public registry.
         }
     }
-    return `https://${DEFAULT_NPM_REGISTRY_HOST}`;
+    return { baseUrl: `https://${DEFAULT_NPM_REGISTRY_HOST}`, allowPrivateRegistryOrigin: false };
 }
 async function resolveNpmArtifact(parsed) {
     const encodedName = encodeURIComponent(parsed.packageName);
-    const registryBase = npmMetadataRegistryBase();
-    const metadata = await fetchJson(`${registryBase}/${encodedName}`);
+    const npmRegistry = npmMetadataRegistry();
+    const npmPolicy = {
+        kind: "npm-api",
+        registryOrigin: new URL(npmRegistry.baseUrl).origin,
+        allowPrivateRegistryOrigin: npmRegistry.allowPrivateRegistryOrigin,
+    };
+    const metadata = await fetchJson(`${npmRegistry.baseUrl}/${encodedName}`, undefined, npmPolicy);
     const versions = asRecord(metadata.versions);
     const distTags = asRecord(metadata["dist-tags"]);
     const requested = parsed.requestedVersionOrTag;
@@ -387,7 +406,7 @@ async function resolveNpmArtifact(parsed) {
     if (!tarballUrl) {
         throw new Error(`npm package ${parsed.packageName}@${resolvedVersion} does not expose a tarball URL.`);
     }
-    validateNpmTarballUrl(tarballUrl, `${parsed.packageName}@${resolvedVersion}`);
+    validateNpmTarballUrl(tarballUrl, `${parsed.packageName}@${resolvedVersion}`, npmPolicy.registryOrigin);
     const resolvedRevision = asString(dist.shasum) ?? asString(dist.integrity);
     return {
         id: parsed.id,
@@ -396,6 +415,8 @@ async function resolveNpmArtifact(parsed) {
         artifactUrl: tarballUrl,
         resolvedVersion,
         resolvedRevision,
+        registryOrigin: npmPolicy.registryOrigin,
+        allowPrivateRegistryOrigin: npmPolicy.allowPrivateRegistryOrigin,
     };
 }
 async function resolveGithubArtifact(parsed) {
@@ -416,7 +437,7 @@ async function resolveGithubArtifact(parsed) {
     }
     const headers = githubHeaders();
     if (parsed.requestedRef) {
-        const commit = await tryFetchJson(`${repoBase}/commits/${encodeURIComponent(parsed.requestedRef)}`, headers);
+        const commit = await tryFetchJson(`${repoBase}/commits/${encodeURIComponent(parsed.requestedRef)}`, headers, GITHUB_API_POLICY);
         const resolvedRevision = asString(commit?.sha) ?? parsed.requestedRef;
         return {
             id: parsed.id,
@@ -427,7 +448,7 @@ async function resolveGithubArtifact(parsed) {
             resolvedVersion: parsed.requestedRef,
         };
     }
-    const latestRelease = await tryFetchJson(`${repoBase}/releases/latest`, headers);
+    const latestRelease = await tryFetchJson(`${repoBase}/releases/latest`, headers, GITHUB_API_POLICY);
     if (latestRelease) {
         const tarballUrl = asString(latestRelease.tarball_url);
         if (tarballUrl) {
@@ -441,12 +462,12 @@ async function resolveGithubArtifact(parsed) {
             };
         }
     }
-    const repoMeta = await fetchJson(repoBase, headers);
+    const repoMeta = await fetchJson(repoBase, headers, GITHUB_API_POLICY);
     const defaultBranch = asString(repoMeta.default_branch);
     if (!defaultBranch) {
         throw new Error(`Unable to resolve default branch for ${parsed.owner}/${parsed.repo}.`);
     }
-    const commit = await tryFetchJson(`${repoBase}/commits/${encodeURIComponent(defaultBranch)}`, headers);
+    const commit = await tryFetchJson(`${repoBase}/commits/${encodeURIComponent(defaultBranch)}`, headers, GITHUB_API_POLICY);
     return {
         id: parsed.id,
         source: parsed.source,
@@ -603,16 +624,20 @@ function readGitValue(repoRoot, ...args) {
 // responses are typically a few KB; a compromised registry streaming
 // tens of MB of JSON is a DoS surface, not a feature.
 const REGISTRY_JSON_BYTE_CAP = 10 * 1024 * 1024;
-async function fetchJson(url, headers) {
-    const response = await fetchWithRetry(url, { headers });
+const GITHUB_API_POLICY = { kind: "github-api" };
+async function fetchJson(url, headers, policy) {
+    const response = await fetchRegistryResponse(url, { headers }, { policy, timeoutMs: 30_000 });
     if (!response.ok) {
+        await cancelRegistryResponse(response);
         throw new Error(`Request failed (${response.status}) for ${url}`);
     }
-    return jsonWithByteCap(response, REGISTRY_JSON_BYTE_CAP);
+    return jsonWithByteCap(response, REGISTRY_JSON_BYTE_CAP, { bodyTimeoutMs: 30_000 });
 }
-async function tryFetchJson(url, headers) {
-    const response = await fetchWithRetry(url, { headers });
-    if (!response.ok)
+async function tryFetchJson(url, headers, policy) {
+    const response = await fetchRegistryResponse(url, { headers }, { policy, timeoutMs: 30_000 });
+    if (!response.ok) {
+        await cancelRegistryResponse(response);
         return null;
-    return jsonWithByteCap(response, REGISTRY_JSON_BYTE_CAP);
+    }
+    return jsonWithByteCap(response, REGISTRY_JSON_BYTE_CAP, { bodyTimeoutMs: 30_000 });
 }