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

package/dist/manager.js

@@ -63,6 +63,7 @@ export class PluginManager {
     autoSyncMarketplaces;
     marketplaceRefreshIntervalMs;
     github;
+    remotePluginAssets = new Map();
     constructor(options = {}) {
         this.marketplaces = options.marketplaces ?? [];
         this.redisUrl = options.redisUrl;
@@ -306,9 +307,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 this.fetcher(githubRawFileUrl(source, githubPath), {
+            headers: source.headers,
+        });
+        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);
@@ -437,8 +499,8 @@ export class PluginManager {
                 }
                 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, {
                                 headers: pluginFileCandidate.headers,
@@ -451,6 +513,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 +526,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 +543,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 &&
@@ -740,7 +813,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 +832,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 +844,9 @@ function githubMarketplaceCandidates(location, options) {
                     pathPrefix: normalizePathPrefix(location.path),
                     rawBaseUrl,
                     apiBaseUrl,
-                    extensions: pluginFileExtensions,
+                    schemaFileNames,
+                    legacyPluginFileExtensions,
+                    includeLegacyPluginFiles,
                     avatarSize: options.avatarSize ?? 128,
                     headers,
                 },
@@ -776,10 +854,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 +868,9 @@ function githubMarketplaceCandidates(location, options) {
                     pathPrefix: normalizePathPrefix(location.path),
                     rawBaseUrl,
                     apiBaseUrl,
-                    extensions: pluginFileExtensions,
+                    schemaFileNames,
+                    legacyPluginFileExtensions,
+                    includeLegacyPluginFiles,
                     avatarSize: options.avatarSize ?? 128,
                     headers,
                 },
@@ -796,6 +879,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 +888,9 @@ function githubMarketplaceCandidates(location, options) {
                     pathPrefix: normalizePathPrefix(location.path),
                     rawBaseUrl,
                     apiBaseUrl,
-                    extensions: pluginFileExtensions,
+                    schemaFileNames,
+                    legacyPluginFileExtensions,
+                    includeLegacyPluginFiles,
                     avatarSize: options.avatarSize ?? 128,
                     headers,
                 },
@@ -878,7 +965,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 +973,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 +1013,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 +1040,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") {
@@ -992,6 +1285,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()