@voilabs/plugins 0.0.1-beta.0 → 0.0.1-beta.2

package/dist/manager.js

@@ -49,6 +49,88 @@ export class MemoryPluginDatabase {
         this.records.delete(storageKey(pluginId, scope.tenantId));
     }
 }
+export class RedisPluginDatabase {
+    client;
+    prefix;
+    constructor(client, options = {}) {
+        this.client = client;
+        this.prefix = options.prefix ?? "voilabs:plugins";
+    }
+    async list(scope = {}) {
+        const pluginIds = await this.readIndex(scope);
+        const installations = await Promise.all(pluginIds.map((pluginId) => this.load(pluginId, scope)));
+        return installations.filter((installation) => Boolean(installation));
+    }
+    async load(pluginId, scope = {}) {
+        const value = await this.client.get(this.installationKey(pluginId, scope));
+        if (!value) {
+            return null;
+        }
+        return parseRedisJson(value);
+    }
+    async save(installation) {
+        const scope = { tenantId: installation.tenantId };
+        await this.client.set(this.installationKey(installation.pluginId, scope), JSON.stringify(installation));
+        await this.addToIndex(installation.pluginId, scope);
+        return installation;
+    }
+    async update(pluginId, patch, scope = {}) {
+        const current = await this.load(pluginId, scope);
+        if (!current) {
+            throw new PluginNotInstalledError(pluginId);
+        }
+        const updated = {
+            ...current,
+            ...patch,
+            pluginId,
+            tenantId: scope.tenantId,
+            updatedAt: new Date().toISOString(),
+        };
+        await this.save(updated);
+        return updated;
+    }
+    async delete(pluginId, scope = {}) {
+        await this.client.del(this.installationKey(pluginId, scope));
+        await this.removeFromIndex(pluginId, scope);
+    }
+    async readIndex(scope) {
+        if (this.client.smembers) {
+            const members = await this.client.smembers(this.indexKey(scope));
+            return normalizeRedisMembers(members);
+        }
+        const value = await this.client.get(this.indexKey(scope));
+        if (!value) {
+            return [];
+        }
+        const parsed = parseRedisJson(value);
+        return Array.isArray(parsed)
+            ? parsed.filter((item) => typeof item === "string")
+            : [];
+    }
+    async addToIndex(pluginId, scope) {
+        if (this.client.sadd) {
+            await this.client.sadd(this.indexKey(scope), pluginId);
+            return;
+        }
+        const ids = new Set(await this.readIndex(scope));
+        ids.add(pluginId);
+        await this.client.set(this.indexKey(scope), JSON.stringify([...ids]));
+    }
+    async removeFromIndex(pluginId, scope) {
+        if (this.client.srem) {
+            await this.client.srem(this.indexKey(scope), pluginId);
+            return;
+        }
+        const ids = (await this.readIndex(scope)).filter((id) => id !== pluginId);
+        await this.client.set(this.indexKey(scope), JSON.stringify(ids));
+    }
+    installationKey(pluginId, scope) {
+        return `${this.prefix}:installation:${scopeKey(scope.tenantId)}:${encodeKeyPart(pluginId)}`;
+    }
+    indexKey(scope) {
+        return `${this.prefix}:index:${scopeKey(scope.tenantId)}`;
+    }
+}
 export class PluginManager {
     marketplaces;
     redisUrl;
@@ -62,17 +144,27 @@ export class PluginManager {
     marketplaceSyncPromise;
     autoSyncMarketplaces;
     marketplaceRefreshIntervalMs;
+    marketplaceRequestTimeoutMs;
     github;
+    remotePluginAssets = new Map();
     constructor(options = {}) {
         this.marketplaces = options.marketplaces ?? [];
         this.redisUrl = options.redisUrl;
-        this.database = options.database ?? new MemoryPluginDatabase();
+        this.database =
+            options.database ??
+                (options.redis
+                    ? new RedisPluginDatabase(options.redis, {
+                        prefix: options.redisPrefix,
+                    })
+                    : new MemoryPluginDatabase());
         this.encryption = options.encryption;
         this.fetcher = options.fetcher ?? globalThis.fetch?.bind(globalThis);
         this.defaultTenantId = options.defaultTenantId;
         this.autoSyncMarketplaces =
             options.autoSyncMarketplaces ?? this.marketplaces.length > 0;
         this.marketplaceRefreshIntervalMs = options.marketplaceRefreshIntervalMs;
+        this.marketplaceRequestTimeoutMs =
+            options.marketplaceRequestTimeoutMs ?? 15_000;
         this.github = options.github ?? {};
         if (options.plugins?.length) {
             this.register(options.plugins);
@@ -306,9 +398,70 @@ export class PluginManager {
                 .map((component) => ({
                 ...component,
                 pluginId: plugin.id,
+                pluginName: plugin.name,
+                pluginVersion: plugin.version,
             }));
         });
     }
+    async listFrontendComponents(options = {}) {
+        await this.ready();
+        const installedOnly = options.installedOnly ?? true;
+        const enabledOnly = options.enabledOnly ?? true;
+        const tenantId = this.resolveTenantId(options);
+        const components = this.getFrontendComponents(options.slot).filter((component) => !options.pluginId || component.pluginId === options.pluginId);
+        if (!installedOnly && !enabledOnly) {
+            return components;
+        }
+        const installations = await this.listInstallations({ tenantId });
+        const installationByPluginId = new Map(installations.map((installation) => [installation.pluginId, installation]));
+        return components.filter((component) => {
+            const installation = installationByPluginId.get(component.pluginId);
+            if (installedOnly && !installation) {
+                return false;
+            }
+            if (enabledOnly && !installation?.enabled) {
+                return false;
+            }
+            return true;
+        });
+    }
+    async fetchPluginAsset(pluginId, assetPath) {
+        await this.ready();
+        if (!this.fetcher) {
+            throw new PluginManagerError("No fetch implementation is available.");
+        }
+        this.require(pluginId);
+        const source = this.remotePluginAssets.get(pluginId);
+        if (!source) {
+            throw new PluginManagerError(`Plugin "${pluginId}" does not expose remote marketplace assets.`);
+        }
+        const normalizedAssetPath = normalizeSafeAssetPath(assetPath);
+        const githubPath = joinGitHubPath(source.rootPath, normalizedAssetPath);
+        const response = await fetchWithTimeout(this.fetcher, githubRawFileUrl(source, githubPath), {
+            headers: source.headers,
+        }, this.marketplaceRequestTimeoutMs);
+        if (!response.ok) {
+            return new Response(null, {
+                status: response.status,
+                statusText: response.statusText,
+            });
+        }
+        const headers = new Headers();
+        const contentType = guessContentType(normalizedAssetPath, response.headers.get("content-type") ?? undefined);
+        if (contentType) {
+            headers.set("content-type", contentType);
+        }
+        const cacheControl = response.headers.get("cache-control");
+        if (cacheControl) {
+            headers.set("cache-control", cacheControl);
+        }
+        headers.set("x-content-type-options", "nosniff");
+        return new Response(response.body, {
+            status: response.status,
+            statusText: response.statusText,
+            headers,
+        });
+    }
     async getInjections(options = {}) {
         await this.ready();
         const tenantId = this.resolveTenantId(options);
@@ -428,21 +581,21 @@ export class PluginManager {
         const pluginsById = new Map();
         for (const candidate of candidates) {
             try {
-                const response = await this.fetcher(candidate.url, {
+                const response = await fetchWithTimeout(this.fetcher, candidate.url, {
                     headers: candidate.headers,
-                });
+                }, this.marketplaceRequestTimeoutMs);
                 if (!response.ok) {
                     lastError = new Error(`${response.status} ${response.statusText}`);
                     continue;
                 }
                 successfulCandidates += 1;
                 if (candidate.parser === "github-tree") {
-                    const pluginFileCandidates = await readGitHubPluginFileCandidates(response, candidate);
-                    for (const pluginFileCandidate of pluginFileCandidates) {
+                    const pluginSchemaCandidates = await readGitHubPluginSchemaCandidates(response, candidate);
+                    for (const pluginFileCandidate of pluginSchemaCandidates) {
                         try {
-                            const pluginFileResponse = await this.fetcher(pluginFileCandidate.url, {
+                            const pluginFileResponse = await fetchWithTimeout(this.fetcher, pluginFileCandidate.url, {
                                 headers: pluginFileCandidate.headers,
-                            });
+                            }, this.marketplaceRequestTimeoutMs);
                             if (!pluginFileResponse.ok) {
                                 lastError = new Error(`${pluginFileResponse.status} ${pluginFileResponse.statusText}`);
                                 continue;
@@ -451,6 +604,7 @@ export class PluginManager {
                             const payload = await readMarketplacePayload(pluginFileResponse, pluginFileCandidate);
                             for (const plugin of extractMarketplacePlugins(payload)) {
                                 const normalizedPlugin = applyMarketplaceDefaults(plugin, pluginFileCandidate);
+                                this.rememberRemotePluginAssetSource(normalizedPlugin, pluginFileCandidate);
                                 pluginsById.set(normalizedPlugin.id, normalizedPlugin);
                             }
                         }
@@ -463,6 +617,7 @@ export class PluginManager {
                 const payload = await readMarketplacePayload(response, candidate);
                 for (const plugin of extractMarketplacePlugins(payload)) {
                     const normalizedPlugin = applyMarketplaceDefaults(plugin, candidate);
+                    this.rememberRemotePluginAssetSource(normalizedPlugin, candidate);
                     pluginsById.set(normalizedPlugin.id, normalizedPlugin);
                 }
             }
@@ -479,6 +634,15 @@ export class PluginManager {
         }
         throw new PluginManagerError(`Marketplace "${marketplaceLabel(marketplaceSource)}" could not be loaded: ${String(lastError)}`);
     }
+    rememberRemotePluginAssetSource(plugin, candidate) {
+        if (!candidate.github) {
+            return;
+        }
+        this.remotePluginAssets.set(plugin.id, {
+            ...candidate.github,
+            rootPath: pluginRootPath(candidate),
+        });
+    }
     shouldSyncMarketplaces() {
         return Boolean(this.autoSyncMarketplaces &&
             this.marketplaces.length &&
@@ -559,6 +723,27 @@ export class PluginManager {
 function storageKey(pluginId, tenantId) {
     return `${tenantId ?? "default"}:${pluginId}`;
 }
+function scopeKey(tenantId) {
+    return encodeKeyPart(tenantId ?? "default");
+}
+function encodeKeyPart(value) {
+    return encodeURIComponent(value).replace(/%/g, "~");
+}
+function parseRedisJson(value) {
+    if (typeof value === "string") {
+        return JSON.parse(value);
+    }
+    return value;
+}
+function normalizeRedisMembers(value) {
+    if (Array.isArray(value)) {
+        return value.filter((item) => typeof item === "string");
+    }
+    if (value instanceof Set) {
+        return [...value].filter((item) => typeof item === "string");
+    }
+    return [];
+}
 function toInstallationSummary(installation) {
     return {
         installed: true,
@@ -740,7 +925,10 @@ function githubMarketplaceCandidates(location, options) {
         "plugins.json",
         "index.json",
     ];
-    const pluginFileExtensions = normalizePluginFileExtensions(options.pluginFileExtensions);
+    const schemaFileNames = normalizeSchemaFileNames(options.schemaFileNames);
+    const legacyPluginFileExtensions = normalizePluginFileExtensions(options.pluginFileExtensions);
+    const includeSchemaFiles = options.schemaFiles !== false;
+    const includeLegacyPluginFiles = options.pluginFiles === true;
     const branchWasExplicit = Boolean(location.branch ?? options.branch);
     const branches = branchWasExplicit
         ? [location.branch ?? options.branch ?? "main"]
@@ -756,7 +944,7 @@ function githubMarketplaceCandidates(location, options) {
         : undefined);
     const candidates = [];
     for (const branch of branches) {
-        if (!location.exactPath && options.pluginFiles !== false) {
+        if (!location.exactPath && (includeSchemaFiles || includeLegacyPluginFiles)) {
             candidates.push({
                 url: `${apiBaseUrl}/repos/${location.owner}/${location.repo}/git/trees/${encodeURIComponent(branch)}?recursive=${options.recursivePluginFiles === false ? "0" : "1"}`,
                 headers,
@@ -768,7 +956,9 @@ function githubMarketplaceCandidates(location, options) {
                     pathPrefix: normalizePathPrefix(location.path),
                     rawBaseUrl,
                     apiBaseUrl,
-                    extensions: pluginFileExtensions,
+                    schemaFileNames,
+                    legacyPluginFileExtensions,
+                    includeLegacyPluginFiles,
                     avatarSize: options.avatarSize ?? 128,
                     headers,
                 },
@@ -776,10 +966,13 @@ function githubMarketplaceCandidates(location, options) {
         }
         for (const path of paths) {
             const normalizedPath = path.replace(/^\/+/, "");
+            const sourceKind = githubSourceKindForPath(normalizedPath, schemaFileNames, legacyPluginFileExtensions, includeLegacyPluginFiles);
             candidates.push({
                 url: `${rawBaseUrl}/${location.owner}/${location.repo}/${branch}/${normalizedPath}`,
                 headers,
                 parser: "json",
+                sourcePath: normalizedPath,
+                sourceKind,
                 github: {
                     owner: location.owner,
                     repo: location.repo,
@@ -787,7 +980,9 @@ function githubMarketplaceCandidates(location, options) {
                     pathPrefix: normalizePathPrefix(location.path),
                     rawBaseUrl,
                     apiBaseUrl,
-                    extensions: pluginFileExtensions,
+                    schemaFileNames,
+                    legacyPluginFileExtensions,
+                    includeLegacyPluginFiles,
                     avatarSize: options.avatarSize ?? 128,
                     headers,
                 },
@@ -796,6 +991,8 @@ function githubMarketplaceCandidates(location, options) {
                 url: `${apiBaseUrl}/repos/${location.owner}/${location.repo}/contents/${encodeUrlPath(normalizedPath)}?ref=${encodeURIComponent(branch)}`,
                 headers,
                 parser: "github-content",
+                sourcePath: normalizedPath,
+                sourceKind,
                 github: {
                     owner: location.owner,
                     repo: location.repo,
@@ -803,7 +1000,9 @@ function githubMarketplaceCandidates(location, options) {
                     pathPrefix: normalizePathPrefix(location.path),
                     rawBaseUrl,
                     apiBaseUrl,
-                    extensions: pluginFileExtensions,
+                    schemaFileNames,
+                    legacyPluginFileExtensions,
+                    includeLegacyPluginFiles,
                     avatarSize: options.avatarSize ?? 128,
                     headers,
                 },
@@ -878,7 +1077,7 @@ function extractMarketplacePlugins(payload) {
         ? [payload.plugin, ...(payload.plugins ?? payload.marketplace?.plugins ?? [])]
         : payload.plugins ?? payload.marketplace?.plugins ?? [];
 }
-async function readGitHubPluginFileCandidates(response, candidate) {
+async function readGitHubPluginSchemaCandidates(response, candidate) {
     if (!candidate.github) {
         return [];
     }
@@ -886,20 +1085,25 @@ async function readGitHubPluginFileCandidates(response, candidate) {
     const payload = (await response.json());
     return (payload.tree ?? [])
         .filter((item) => Boolean(item.path && item.type === "blob"))
-        .filter((item) => isPluginFilePath(item.path, discovery))
+        .filter((item) => isPluginSchemaPath(item.path, discovery))
         .flatMap((item) => {
         const encodedPath = encodeUrlPath(item.path);
+        const sourceKind = githubSourceKindForPath(item.path, discovery.schemaFileNames, discovery.legacyPluginFileExtensions, discovery.includeLegacyPluginFiles);
         return [
             {
                 url: `${discovery.rawBaseUrl}/${discovery.owner}/${discovery.repo}/${discovery.branch}/${encodedPath}`,
                 headers: discovery.headers,
                 parser: "json",
+                sourcePath: item.path,
+                sourceKind,
                 github: discovery,
             },
             {
                 url: `${discovery.apiBaseUrl}/repos/${discovery.owner}/${discovery.repo}/contents/${encodedPath}?ref=${encodeURIComponent(discovery.branch)}`,
                 headers: discovery.headers,
                 parser: "github-content",
+                sourcePath: item.path,
+                sourceKind,
                 github: discovery,
             },
         ];
@@ -921,23 +1125,26 @@ function applyMarketplaceDefaults(plugin, candidate) {
         }
         return plugin;
     }
+    const normalizedPlugin = normalizeGitHubPluginReferences(plugin, candidate);
     return {
-        ...plugin,
+        ...normalizedPlugin,
         provider: github.owner,
         iconUrl: githubAvatarUrl(github.owner, github.avatarSize),
-        repositoryUrl: plugin.repositoryUrl ??
+        repositoryUrl: normalizedPlugin.repositoryUrl ??
             `https://github.com/${github.owner}/${github.repo}`,
         meta: {
-            ...plugin.meta,
+            ...normalizedPlugin.meta,
             github: {
                 owner: github.owner,
                 repo: github.repo,
                 branch: github.branch,
+                rootPath: pluginRootPath(candidate),
+                schemaPath: candidate.sourceKind === "schema" ? candidate.sourcePath : undefined,
             },
         },
     };
 }
-function isPluginFilePath(path, discovery) {
+function isPluginSchemaPath(path, discovery) {
     const normalizedPath = path.replace(/^\/+/, "");
     const prefix = discovery.pathPrefix;
     if (prefix &&
@@ -945,7 +1152,205 @@ function isPluginFilePath(path, discovery) {
         !normalizedPath.startsWith(`${prefix}/`)) {
         return false;
     }
-    return discovery.extensions.some((extension) => normalizedPath.toLocaleLowerCase().endsWith(extension));
+    const lowerPath = normalizedPath.toLocaleLowerCase();
+    const fileName = lowerPath.split("/").pop() ?? lowerPath;
+    if (discovery.schemaFileNames.includes(fileName)) {
+        return true;
+    }
+    return (discovery.includeLegacyPluginFiles &&
+        discovery.legacyPluginFileExtensions.some((extension) => lowerPath.endsWith(extension)));
+}
+function normalizeGitHubPluginReferences(plugin, candidate) {
+    const github = candidate.github;
+    if (!github) {
+        return plugin;
+    }
+    const rootPath = pluginRootPath(candidate);
+    const resolve = (value) => value ? resolveGitHubReferenceUrl(github, rootPath, value) : value;
+    return {
+        ...plugin,
+        docsUrl: resolve(plugin.docsUrl),
+        websiteUrl: resolve(plugin.websiteUrl),
+        frontend: normalizeFrontendManifest(plugin.frontend, github, rootPath),
+        injections: plugin.injections?.map((injection) => ({
+            ...injection,
+            src: resolve(injection.src),
+            attributes: normalizeUrlAttributes(injection.attributes, resolve),
+        })),
+        assets: plugin.assets?.map((asset) => normalizePluginAsset(asset, resolve)),
+    };
+}
+function normalizeFrontendManifest(frontend, github, rootPath) {
+    if (!frontend) {
+        return frontend;
+    }
+    return {
+        ...frontend,
+        registry: frontend.registry
+            ? Object.fromEntries(Object.entries(frontend.registry).map(([key, component]) => [
+                key,
+                normalizeComponentReference(component, github, rootPath),
+            ]))
+            : frontend.registry,
+        components: frontend.components?.map((component) => ({
+            ...component,
+            component: normalizeComponentReference(component.component, github, rootPath),
+        })),
+    };
+}
+function normalizeComponentReference(reference, github, rootPath) {
+    if (reference.type !== "remote") {
+        return reference;
+    }
+    const referencePath = reference.path ??
+        (reference.url && isRelativeReference(reference.url)
+            ? reference.url
+            : undefined);
+    const urlSource = reference.url ?? referencePath;
+    return {
+        ...reference,
+        path: referencePath ? normalizeClientAssetPath(referencePath) : reference.path,
+        url: urlSource
+            ? resolveGitHubReferenceUrl(github, rootPath, urlSource)
+            : reference.url,
+    };
+}
+function normalizePluginAsset(asset, resolve) {
+    return {
+        ...asset,
+        url: resolve(asset.url) ?? asset.url,
+    };
+}
+function normalizeUrlAttributes(attributes, resolve) {
+    if (!attributes) {
+        return attributes;
+    }
+    const urlAttributes = new Set(["href", "src", "poster"]);
+    return Object.fromEntries(Object.entries(attributes).map(([key, value]) => [
+        key,
+        typeof value === "string" && urlAttributes.has(key.toLocaleLowerCase())
+            ? resolve(value)
+            : value,
+    ]));
+}
+function pluginRootPath(candidate) {
+    if (!candidate.sourcePath) {
+        return candidate.github?.pathPrefix;
+    }
+    return dirname(candidate.sourcePath) ?? candidate.github?.pathPrefix;
+}
+function githubSourceKindForPath(path, schemaFileNames, legacyPluginFileExtensions, includeLegacyPluginFiles) {
+    const lowerPath = path.replace(/^\/+/, "").toLocaleLowerCase();
+    const fileName = lowerPath.split("/").pop() ?? lowerPath;
+    if (schemaFileNames.includes(fileName)) {
+        return "schema";
+    }
+    if (includeLegacyPluginFiles &&
+        legacyPluginFileExtensions.some((extension) => lowerPath.endsWith(extension))) {
+        return "legacy-plugin";
+    }
+    return "marketplace";
+}
+function resolveGitHubReferenceUrl(github, rootPath, value) {
+    if (!isRelativeReference(value)) {
+        return value;
+    }
+    const { path, suffix } = splitReferenceSuffix(value);
+    const basePath = path.startsWith("/") ? undefined : rootPath;
+    const githubPath = joinGitHubPath(basePath, path);
+    return `${githubRawFileUrl(github, githubPath)}${suffix}`;
+}
+function githubRawFileUrl(github, path) {
+    return `${github.rawBaseUrl}/${github.owner}/${github.repo}/${github.branch}/${encodeUrlPath(path)}`;
+}
+function splitReferenceSuffix(value) {
+    const index = value.search(/[?#]/);
+    if (index === -1) {
+        return { path: value, suffix: "" };
+    }
+    return {
+        path: value.slice(0, index),
+        suffix: value.slice(index),
+    };
+}
+function isRelativeReference(value) {
+    return (!/^[a-z][a-z0-9+.-]*:/i.test(value) &&
+        !value.startsWith("//") &&
+        !value.startsWith("#") &&
+        !value.startsWith("{{"));
+}
+function normalizeClientAssetPath(path) {
+    if (!isRelativeReference(path) || path.startsWith("/")) {
+        return undefined;
+    }
+    const { path: withoutSuffix } = splitReferenceSuffix(path);
+    if (withoutSuffix.split("/").some((part) => part === "..")) {
+        return undefined;
+    }
+    return normalizeGitHubPath(withoutSuffix);
+}
+function normalizeSafeAssetPath(path) {
+    const decoded = safeDecodeURIComponent(path).replace(/^\/+/, "");
+    const parts = decoded.split("/").filter(Boolean);
+    if (!parts.length) {
+        throw new PluginManagerError("Plugin asset path is required.");
+    }
+    if (parts.some((part) => part === "." || part === "..")) {
+        throw new PluginManagerError("Plugin asset path cannot leave the plugin folder.");
+    }
+    return parts.join("/");
+}
+function joinGitHubPath(basePath, path) {
+    return normalizeGitHubPath([basePath, path.replace(/^\/+/, "")].filter(Boolean).join("/"));
+}
+function normalizeGitHubPath(path) {
+    const parts = [];
+    for (const part of path.replace(/^\/+/, "").split("/")) {
+        if (!part || part === ".") {
+            continue;
+        }
+        if (part === "..") {
+            parts.pop();
+            continue;
+        }
+        parts.push(part);
+    }
+    return parts.join("/");
+}
+function dirname(path) {
+    const parts = normalizeGitHubPath(path).split("/");
+    parts.pop();
+    return parts.length ? parts.join("/") : undefined;
+}
+function safeDecodeURIComponent(value) {
+    try {
+        return decodeURIComponent(value);
+    }
+    catch {
+        return value;
+    }
+}
+function guessContentType(path, upstream) {
+    const extension = path.split(".").pop()?.toLocaleLowerCase();
+    const knownTypes = {
+        css: "text/css; charset=utf-8",
+        gif: "image/gif",
+        html: "text/html; charset=utf-8",
+        ico: "image/x-icon",
+        jpeg: "image/jpeg",
+        jpg: "image/jpeg",
+        js: "application/javascript; charset=utf-8",
+        json: "application/json; charset=utf-8",
+        jsx: "application/javascript; charset=utf-8",
+        mjs: "application/javascript; charset=utf-8",
+        png: "image/png",
+        svg: "image/svg+xml",
+        txt: "text/plain; charset=utf-8",
+        webp: "image/webp",
+        woff: "font/woff",
+        woff2: "font/woff2",
+    };
+    return (extension && knownTypes[extension]) || upstream;
 }
 function marketplaceLabel(source) {
     if (typeof source === "string") {
@@ -972,6 +1377,33 @@ function mergeHeaders(...headersList) {
     });
     return hasHeaders ? headers : undefined;
 }
+async function fetchWithTimeout(fetcher, input, init, timeoutMs) {
+    if (!timeoutMs || timeoutMs <= 0) {
+        return fetcher(input, init);
+    }
+    const controller = new AbortController();
+    let timeout;
+    const timeoutPromise = new Promise((_resolve, reject) => {
+        timeout = setTimeout(() => {
+            controller.abort();
+            reject(new PluginManagerError(`Marketplace request timed out after ${timeoutMs}ms.`));
+        }, timeoutMs);
+    });
+    try {
+        return await Promise.race([
+            fetcher(input, {
+                ...init,
+                signal: controller.signal,
+            }),
+            timeoutPromise,
+        ]);
+    }
+    finally {
+        if (timeout) {
+            clearTimeout(timeout);
+        }
+    }
+}
 function decodeBase64(value) {
     const normalized = value.replace(/\s/g, "");
     const buffer = globalThis.Buffer;
@@ -992,6 +1424,9 @@ function normalizePathPrefix(path) {
     const normalized = path?.replace(/^\/+|\/+$/g, "");
     return normalized || undefined;
 }
+function normalizeSchemaFileNames(fileNames) {
+    return (fileNames?.length ? fileNames : ["schema.json"]).map((fileName) => fileName.replace(/^\/+/, "").toLocaleLowerCase());
+}
 function normalizePluginFileExtensions(extensions) {
     return (extensions?.length ? extensions : [".plugin"]).map((extension) => extension.startsWith(".")
         ? extension.toLocaleLowerCase()