@codingame/monaco-vscode-chat-service-override 26.2.2 → 28.0.0

package/vscode/src/vs/workbench/contrib/chat/common/plugins/pluginMarketplaceService.js

@@ -0,0 +1,672 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { Event } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { parse } from '@codingame/monaco-vscode-api/vscode/vs/base/common/json';
+import { Lazy } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lazy';
+import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { revive } from '@codingame/monaco-vscode-api/vscode/vs/base/common/marshalling';
+import { isEqualOrParent, isEqual, joinPath, normalizePath, relativePath } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
+import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
+import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
+import { IFileService } from '@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files.service';
+import { ILogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service';
+import { observableMemento } from '@codingame/monaco-vscode-api/vscode/vs/platform/observable/common/observableMemento';
+import { asJson } from '@codingame/monaco-vscode-api/vscode/vs/platform/request/common/request';
+import { IRequestService } from '@codingame/monaco-vscode-api/vscode/vs/platform/request/common/request.service';
+import { StorageScope, StorageTarget } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage';
+import { IStorageService } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service';
+import { ChatConfiguration } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/constants';
+import { IAgentPluginRepositoryService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/plugins/agentPluginRepositoryService.service';
+
+var MarketplaceType;
+(function(MarketplaceType) {
+    MarketplaceType["Copilot"] = "copilot";
+    MarketplaceType["Claude"] = "claude";
+})(MarketplaceType || (MarketplaceType = {}));
+var MarketplaceReferenceKind;
+(function(MarketplaceReferenceKind) {
+    MarketplaceReferenceKind["GitHubShorthand"] = "githubShorthand";
+    MarketplaceReferenceKind["GitUri"] = "gitUri";
+    MarketplaceReferenceKind["LocalFileUri"] = "localFileUri";
+})(MarketplaceReferenceKind || (MarketplaceReferenceKind = {}));
+var PluginSourceKind;
+(function(PluginSourceKind) {
+    PluginSourceKind["RelativePath"] = "relativePath";
+    PluginSourceKind["GitHub"] = "github";
+    PluginSourceKind["GitUrl"] = "url";
+    PluginSourceKind["Npm"] = "npm";
+    PluginSourceKind["Pip"] = "pip";
+})(PluginSourceKind || (PluginSourceKind = {}));
+const MARKETPLACE_DEFINITIONS = [{
+    type: MarketplaceType.Copilot,
+    path: ".github/plugin/marketplace.json"
+}, {
+    type: MarketplaceType.Claude,
+    path: ".claude-plugin/marketplace.json"
+}];
+const GITHUB_MARKETPLACE_CACHE_TTL_MS = 8 * 60 * 60 * 1000;
+const GITHUB_MARKETPLACE_CACHE_STORAGE_KEY = "chat.plugins.marketplaces.githubCache.v1";
+function ensureSourceDescriptor(plugin) {
+    if (plugin.sourceDescriptor) {
+        return plugin;
+    }
+    return {
+        ...plugin,
+        sourceDescriptor: {
+            kind: PluginSourceKind.RelativePath,
+            path: plugin.source
+        }
+    };
+}
+const installedPluginsMemento = observableMemento({
+    defaultValue: [],
+    key: "chat.plugins.installed.v1",
+    toStorage: value => JSON.stringify(value),
+    fromStorage: value => {
+        const parsed = JSON.parse(value);
+        return Array.isArray(parsed) ? parsed : [];
+    }
+});
+const trustedMarketplacesMemento = observableMemento({
+    defaultValue: [],
+    key: "chat.plugins.trustedMarketplaces.v1",
+    toStorage: value => JSON.stringify(value),
+    fromStorage: value => {
+        const parsed = JSON.parse(value);
+        return Array.isArray(parsed) ? parsed : [];
+    }
+});
+let PluginMarketplaceService = class PluginMarketplaceService extends Disposable {
+    constructor(
+        _configurationService,
+        _requestService,
+        _fileService,
+        _pluginRepositoryService,
+        _logService,
+        _storageService
+    ) {
+        super();
+        this._configurationService = _configurationService;
+        this._requestService = _requestService;
+        this._fileService = _fileService;
+        this._pluginRepositoryService = _pluginRepositoryService;
+        this._logService = _logService;
+        this._storageService = _storageService;
+        this._gitHubMarketplaceCache = ( new Lazy(() => this._loadPersistedGitHubMarketplaceCache()));
+        this._installedPluginsStore = this._register(
+            installedPluginsMemento(StorageScope.APPLICATION, StorageTarget.MACHINE, _storageService)
+        );
+        this._trustedMarketplacesStore = this._register(
+            trustedMarketplacesMemento(StorageScope.APPLICATION, StorageTarget.MACHINE, _storageService)
+        );
+        this.installedPlugins = ( this._installedPluginsStore.map(s => ( revive(s).map(e => ({
+            ...e,
+            plugin: ensureSourceDescriptor(e.plugin)
+        })))));
+        this.onDidChangeMarketplaces = Event.filter(
+            _configurationService.onDidChangeConfiguration,
+            e => e.affectsConfiguration(ChatConfiguration.PluginsEnabled) || e.affectsConfiguration(ChatConfiguration.PluginMarketplaces)
+        );
+    }
+    async fetchMarketplacePlugins(token) {
+        if (!this._configurationService.getValue(ChatConfiguration.PluginsEnabled)) {
+            return [];
+        }
+        const configuredRefs = this._configurationService.getValue(ChatConfiguration.PluginMarketplaces) ?? [];
+        const refs = parseMarketplaceReferences(configuredRefs);
+        for (const value of configuredRefs) {
+            if (typeof value !== "string" || !parseMarketplaceReference(value)) {
+                this._logService.debug(
+                    `[PluginMarketplaceService] Ignoring invalid marketplace entry: ${String(value)}`
+                );
+            }
+        }
+        const results = await Promise.all(( refs.map(ref => {
+            if (ref.kind === MarketplaceReferenceKind.GitHubShorthand && ref.githubRepo) {
+                return this._fetchFromGitHubRepo(ref, ref.githubRepo, token);
+            }
+            return this._fetchFromClonedRepo(ref, token);
+        })));
+        return results.flat();
+    }
+    async _fetchFromGitHubRepo(reference, repo, token) {
+        const cache = this._gitHubMarketplaceCache.value;
+        const cached = this._getCachedGitHubMarketplacePlugins(cache, reference.canonicalId);
+        if (cached) {
+            return cached;
+        }
+        let repoMayBePrivate = true;
+        for (const def of MARKETPLACE_DEFINITIONS) {
+            if (token.isCancellationRequested) {
+                return [];
+            }
+            const url = `https://raw.githubusercontent.com/${repo}/main/${def.path}`;
+            try {
+                const context = await this._requestService.request({
+                    type: "GET",
+                    url
+                }, token);
+                const statusCode = context.res.statusCode;
+                if (statusCode !== 200) {
+                    repoMayBePrivate &&= statusCode !== undefined && statusCode >= 400 && statusCode < 500;
+                    this._logService.debug(
+                        `[PluginMarketplaceService] ${url} returned status ${statusCode}, skipping`
+                    );
+                    continue;
+                }
+                const json = await asJson(context);
+                if (!json?.plugins || !Array.isArray(json.plugins)) {
+                    this._logService.debug(
+                        `[PluginMarketplaceService] ${url} did not contain a valid plugins array, skipping`
+                    );
+                    continue;
+                }
+                const plugins = json.plugins.filter(p => typeof p.name === "string" && !!p.name).flatMap(p => {
+                    const sourceDescriptor = parsePluginSource(p.source, json.metadata?.pluginRoot, {
+                        pluginName: p.name,
+                        logService: this._logService,
+                        logPrefix: `[PluginMarketplaceService]`
+                    });
+                    if (!sourceDescriptor) {
+                        return [];
+                    }
+                    const source = sourceDescriptor.kind === PluginSourceKind.RelativePath ? sourceDescriptor.path : "";
+                    return [{
+                        name: p.name,
+                        description: p.description ?? "",
+                        version: p.version ?? "",
+                        source,
+                        sourceDescriptor,
+                        marketplace: reference.displayLabel,
+                        marketplaceReference: reference,
+                        marketplaceType: def.type,
+                        readmeUri: getMarketplaceReadmeUri(repo, source)
+                    }];
+                });
+                cache.set(reference.canonicalId, {
+                    plugins,
+                    expiresAt: Date.now() + GITHUB_MARKETPLACE_CACHE_TTL_MS,
+                    referenceRawValue: reference.rawValue
+                });
+                this._savePersistedGitHubMarketplaceCache(cache);
+                return plugins;
+            } catch (err) {
+                this._logService.debug(
+                    `[PluginMarketplaceService] Failed to fetch marketplace.json from ${url}:`,
+                    err
+                );
+                continue;
+            }
+        }
+        if (repoMayBePrivate) {
+            this._logService.debug(
+                `[PluginMarketplaceService] ${repo} may be private, attempting clone-based marketplace discovery`
+            );
+            return this._fetchFromClonedRepo(reference, token);
+        }
+        this._logService.debug(`[PluginMarketplaceService] No marketplace.json found in ${repo}`);
+        return [];
+    }
+    _getCachedGitHubMarketplacePlugins(cache, cacheKey) {
+        const cached = cache.get(cacheKey);
+        if (!cached) {
+            return undefined;
+        }
+        if (cached.expiresAt <= Date.now()) {
+            cache.delete(cacheKey);
+            this._savePersistedGitHubMarketplaceCache(cache);
+            return undefined;
+        }
+        return [...cached.plugins];
+    }
+    _loadPersistedGitHubMarketplaceCache() {
+        const cache = ( new Map());
+        const now = Date.now();
+        const stored = this._storageService.getObject(GITHUB_MARKETPLACE_CACHE_STORAGE_KEY, StorageScope.APPLICATION);
+        if (!stored) {
+            return cache;
+        }
+        const revived = revive(stored);
+        for (const [cacheKey, entry] of Object.entries(revived)) {
+            if (!entry || !Array.isArray(entry.plugins) || typeof entry.expiresAt !== "number" || entry.expiresAt <= now || typeof entry.referenceRawValue !== "string") {
+                continue;
+            }
+            const reference = parseMarketplaceReference(entry.referenceRawValue);
+            if (!reference) {
+                continue;
+            }
+            const plugins = ( entry.plugins.map(plugin => ensureSourceDescriptor({
+                ...plugin,
+                marketplace: reference.displayLabel,
+                marketplaceReference: reference
+            })));
+            cache.set(cacheKey, {
+                plugins,
+                expiresAt: entry.expiresAt,
+                referenceRawValue: entry.referenceRawValue
+            });
+        }
+        return cache;
+    }
+    _savePersistedGitHubMarketplaceCache(cache) {
+        const serialized = {};
+        for (const [cacheKey, entry] of cache) {
+            if (!entry.plugins.length || entry.expiresAt <= Date.now()) {
+                continue;
+            }
+            serialized[cacheKey] = {
+                expiresAt: entry.expiresAt,
+                referenceRawValue: entry.referenceRawValue,
+                plugins: entry.plugins
+            };
+        }
+        if (( Object.keys(serialized)).length === 0) {
+            this._storageService.remove(GITHUB_MARKETPLACE_CACHE_STORAGE_KEY, StorageScope.APPLICATION);
+            return;
+        }
+        this._storageService.store(
+            GITHUB_MARKETPLACE_CACHE_STORAGE_KEY,
+            JSON.stringify(serialized),
+            StorageScope.APPLICATION,
+            StorageTarget.MACHINE
+        );
+    }
+    getMarketplacePluginMetadata(pluginUri) {
+        const installed = this.installedPlugins.get();
+        return installed.find(e => isEqualOrParent(pluginUri, e.pluginUri))?.plugin;
+    }
+    addInstalledPlugin(pluginUri, plugin) {
+        const current = this.installedPlugins.get();
+        if (( current.some(e => isEqual(e.pluginUri, pluginUri)))) {
+            this._installedPluginsStore.set([...current], undefined);
+        } else {
+            this._installedPluginsStore.set([...current, {
+                pluginUri,
+                plugin,
+                enabled: true
+            }], undefined);
+        }
+    }
+    removeInstalledPlugin(pluginUri) {
+        const current = this.installedPlugins.get();
+        this._installedPluginsStore.set(current.filter(e => !isEqual(e.pluginUri, pluginUri)), undefined);
+    }
+    setInstalledPluginEnabled(pluginUri, enabled) {
+        const current = this.installedPlugins.get();
+        this._installedPluginsStore.set(( current.map(e => isEqual(e.pluginUri, pluginUri) ? {
+            ...e,
+            enabled
+        } : e)), undefined);
+    }
+    isMarketplaceTrusted(ref) {
+        return this._trustedMarketplacesStore.get().includes(ref.canonicalId);
+    }
+    trustMarketplace(ref) {
+        const current = this._trustedMarketplacesStore.get();
+        if (!current.includes(ref.canonicalId)) {
+            this._trustedMarketplacesStore.set([...current, ref.canonicalId], undefined);
+        }
+    }
+    async _fetchFromClonedRepo(reference, token) {
+        let repoDir;
+        try {
+            repoDir = await this._pluginRepositoryService.ensureRepository(reference);
+        } catch (err) {
+            this._logService.debug(
+                `[PluginMarketplaceService] Failed to prepare marketplace repository ${reference.rawValue}:`,
+                err
+            );
+            return [];
+        }
+        for (const def of MARKETPLACE_DEFINITIONS) {
+            if (token.isCancellationRequested) {
+                return [];
+            }
+            const definitionUri = joinPath(repoDir, def.path);
+            let json;
+            try {
+                const contents = await this._fileService.readFile(definitionUri);
+                json = parse(( contents.value.toString()));
+            } catch {
+                continue;
+            }
+            if (!json?.plugins || !Array.isArray(json.plugins)) {
+                this._logService.debug(`[PluginMarketplaceService] ${( definitionUri.toString())} did not contain a valid plugins array, skipping`);
+                continue;
+            }
+            return json.plugins.filter(p => typeof p.name === "string" && !!p.name).flatMap(p => {
+                const sourceDescriptor = parsePluginSource(p.source, json.metadata?.pluginRoot, {
+                    pluginName: p.name,
+                    logService: this._logService,
+                    logPrefix: `[PluginMarketplaceService]`
+                });
+                if (!sourceDescriptor) {
+                    return [];
+                }
+                const source = sourceDescriptor.kind === PluginSourceKind.RelativePath ? sourceDescriptor.path : "";
+                return [{
+                    name: p.name,
+                    description: p.description ?? "",
+                    version: p.version ?? "",
+                    source,
+                    sourceDescriptor,
+                    marketplace: reference.displayLabel,
+                    marketplaceReference: reference,
+                    marketplaceType: def.type,
+                    readmeUri: getMarketplaceReadmeFileUri(repoDir, source)
+                }];
+            });
+        }
+        this._logService.debug(
+            `[PluginMarketplaceService] No marketplace.json found in ${reference.rawValue}`
+        );
+        return [];
+    }
+};
+PluginMarketplaceService = ( __decorate([( __param(0, IConfigurationService)), ( __param(1, IRequestService)), ( __param(2, IFileService)), ( __param(3, IAgentPluginRepositoryService)), ( __param(4, ILogService)), ( __param(5, IStorageService))], PluginMarketplaceService));
+function parseMarketplaceReferences(values) {
+    const byCanonicalId = ( new Map());
+    for (const value of values) {
+        if (typeof value !== "string") {
+            continue;
+        }
+        const parsed = parseMarketplaceReference(value);
+        if (!parsed) {
+            continue;
+        }
+        if (!( byCanonicalId.has(parsed.canonicalId))) {
+            byCanonicalId.set(parsed.canonicalId, parsed);
+        }
+    }
+    return [...( byCanonicalId.values())];
+}
+function parseMarketplaceReference(value) {
+    const rawValue = value.trim();
+    if (!rawValue) {
+        return undefined;
+    }
+    const uriReference = parseUriMarketplaceReference(rawValue);
+    if (uriReference) {
+        return uriReference;
+    }
+    const scpReference = parseScpMarketplaceReference(rawValue);
+    if (scpReference) {
+        return scpReference;
+    }
+    const shorthandMatch = /^([A-Za-z0-9_.-]+)\/([A-Za-z0-9_.-]+)$/.exec(rawValue);
+    if (shorthandMatch) {
+        const owner = shorthandMatch[1];
+        const repo = shorthandMatch[2];
+        return {
+            rawValue,
+            displayLabel: `${owner}/${repo}`,
+            cloneUrl: `https://github.com/${owner}/${repo}.git`,
+            canonicalId: getGitHubCanonicalId(owner, repo),
+            cacheSegments: ["github.com", owner, repo],
+            kind: MarketplaceReferenceKind.GitHubShorthand,
+            githubRepo: `${owner}/${repo}`
+        };
+    }
+    return undefined;
+}
+function parseUriMarketplaceReference(rawValue) {
+    let uri;
+    try {
+        uri = ( URI.parse(rawValue));
+    } catch {
+        return undefined;
+    }
+    const scheme = uri.scheme.toLowerCase();
+    if (scheme === "file" && /^file:\/\//i.test(rawValue)) {
+        const localRepositoryUri = URI.file(uri.fsPath);
+        return {
+            rawValue,
+            displayLabel: localRepositoryUri.fsPath,
+            cloneUrl: rawValue,
+            canonicalId: `file:${( localRepositoryUri.toString()).toLowerCase()}`,
+            cacheSegments: [],
+            kind: MarketplaceReferenceKind.LocalFileUri,
+            localRepositoryUri
+        };
+    }
+    if (scheme !== "http" && scheme !== "https" && scheme !== "ssh") {
+        return undefined;
+    }
+    if (!uri.authority) {
+        return undefined;
+    }
+    const normalizedPath = normalizeGitRepoPath(uri.path);
+    if (!normalizedPath) {
+        return undefined;
+    }
+    const sanitizedAuthority = sanitizePathSegment(uri.authority.toLowerCase());
+    const pathSegments = ( normalizedPath.slice(1, -4).split("/").map(sanitizePathSegment));
+    return {
+        rawValue,
+        displayLabel: rawValue,
+        cloneUrl: rawValue,
+        canonicalId: `git:${uri.authority.toLowerCase()}/${normalizedPath.slice(1).toLowerCase()}`,
+        cacheSegments: [sanitizedAuthority, ...pathSegments],
+        kind: MarketplaceReferenceKind.GitUri
+    };
+}
+function parseScpMarketplaceReference(rawValue) {
+    const match = /^([^@\s]+)@([^:\s]+):(.+\.git)$/i.exec(rawValue);
+    if (!match) {
+        return undefined;
+    }
+    const authority = match[2];
+    const pathWithGit = match[3].replace(/^\/+/, "");
+    if (!pathWithGit.toLowerCase().endsWith(".git")) {
+        return undefined;
+    }
+    const pathSegments = ( pathWithGit.slice(0, -4).split("/").map(sanitizePathSegment));
+    return {
+        rawValue,
+        displayLabel: rawValue,
+        cloneUrl: rawValue,
+        canonicalId: `git:${authority.toLowerCase()}/${pathWithGit.toLowerCase()}`,
+        cacheSegments: [sanitizePathSegment(authority.toLowerCase()), ...pathSegments],
+        kind: MarketplaceReferenceKind.GitUri
+    };
+}
+function normalizeGitRepoPath(path) {
+    const trimmed = path.replace(/\/+/g, "/").replace(/\/+$/g, "");
+    if (!trimmed.toLowerCase().endsWith(".git")) {
+        return undefined;
+    }
+    const withLeadingSlash = trimmed.startsWith("/") ? trimmed : `/${trimmed}`;
+    const pathWithoutGit = withLeadingSlash.slice(1, -4);
+    if (!pathWithoutGit || !pathWithoutGit.includes("/")) {
+        return undefined;
+    }
+    return withLeadingSlash;
+}
+function getGitHubCanonicalId(owner, repo) {
+    return `github:${owner.toLowerCase()}/${repo.toLowerCase()}`;
+}
+function sanitizePathSegment(value) {
+    return value.replace(/[\\/:*?"<>|]/g, "_");
+}
+function normalizeMarketplacePath(value) {
+    let normalized = value.trim().replace(/\\/g, "/");
+    normalized = normalized.replace(/^\.?\/+/, "").replace(/\/+$/g, "");
+    return normalized;
+}
+function resolvePluginSource(pluginRoot, source) {
+    const normalizedRoot = pluginRoot ? normalizeMarketplacePath(pluginRoot) : "";
+    const normalizedSource = normalizeMarketplacePath(source);
+    const repoRoot = URI.file("/");
+    const pluginRootUri = normalizedRoot ? normalizePath(joinPath(repoRoot, normalizedRoot)) : repoRoot;
+    if (!normalizedSource) {
+        return normalizedRoot || undefined;
+    }
+    if (normalizedRoot && (normalizedSource === normalizedRoot || normalizedSource.startsWith(`${normalizedRoot}/`))) {
+        return normalizedSource;
+    }
+    const resolvedUri = normalizePath(joinPath(pluginRootUri, normalizedSource));
+    return relativePath(repoRoot, resolvedUri) ?? undefined;
+}
+function parsePluginSource(rawSource, pluginRoot, logContext) {
+    if (rawSource === undefined || rawSource === null) {
+        const resolved = resolvePluginSource(pluginRoot, "");
+        if (resolved === undefined) {
+            return undefined;
+        }
+        return {
+            kind: PluginSourceKind.RelativePath,
+            path: resolved
+        };
+    }
+    if (typeof rawSource === "string") {
+        const resolved = resolvePluginSource(pluginRoot, rawSource);
+        if (resolved === undefined) {
+            return undefined;
+        }
+        return {
+            kind: PluginSourceKind.RelativePath,
+            path: resolved
+        };
+    }
+    if (typeof rawSource !== "object" || typeof rawSource.source !== "string") {
+        logContext.logService.warn(
+            `${logContext.logPrefix} Skipping plugin '${logContext.pluginName}': source object is missing a 'source' discriminant`
+        );
+        return undefined;
+    }
+    switch (rawSource.source) {
+    case "github":
+        {
+            if (typeof rawSource.repo !== "string" || !rawSource.repo) {
+                logContext.logService.warn(
+                    `${logContext.logPrefix} Skipping plugin '${logContext.pluginName}': github source is missing required 'repo' field`
+                );
+                return undefined;
+            }
+            if (!isValidGitHubRepo(rawSource.repo)) {
+                logContext.logService.warn(
+                    `${logContext.logPrefix} Skipping plugin '${logContext.pluginName}': github source repo must be in 'owner/repo' format`
+                );
+                return undefined;
+            }
+            if (!isOptionalString(rawSource.ref)) {
+                logContext.logService.warn(
+                    `${logContext.logPrefix} Skipping plugin '${logContext.pluginName}': github source 'ref' must be a string when provided`
+                );
+                return undefined;
+            }
+            if (!isOptionalGitSha(rawSource.sha)) {
+                logContext.logService.warn(
+                    `${logContext.logPrefix} Skipping plugin '${logContext.pluginName}': github source 'sha' must be a full 40-character commit hash when provided`
+                );
+                return undefined;
+            }
+            return {
+                kind: PluginSourceKind.GitHub,
+                repo: rawSource.repo,
+                ref: rawSource.ref,
+                sha: rawSource.sha
+            };
+        }
+    case "url":
+        {
+            if (typeof rawSource.url !== "string" || !rawSource.url) {
+                logContext.logService.warn(
+                    `${logContext.logPrefix} Skipping plugin '${logContext.pluginName}': url source is missing required 'url' field`
+                );
+                return undefined;
+            }
+            if (!rawSource.url.toLowerCase().endsWith(".git")) {
+                logContext.logService.warn(
+                    `${logContext.logPrefix} Skipping plugin '${logContext.pluginName}': url source must end with '.git'`
+                );
+                return undefined;
+            }
+            if (!isOptionalString(rawSource.ref)) {
+                logContext.logService.warn(
+                    `${logContext.logPrefix} Skipping plugin '${logContext.pluginName}': url source 'ref' must be a string when provided`
+                );
+                return undefined;
+            }
+            if (!isOptionalGitSha(rawSource.sha)) {
+                logContext.logService.warn(
+                    `${logContext.logPrefix} Skipping plugin '${logContext.pluginName}': url source 'sha' must be a full 40-character commit hash when provided`
+                );
+                return undefined;
+            }
+            return {
+                kind: PluginSourceKind.GitUrl,
+                url: rawSource.url,
+                ref: rawSource.ref,
+                sha: rawSource.sha
+            };
+        }
+    case "npm":
+        {
+            if (typeof rawSource.package !== "string" || !rawSource.package) {
+                logContext.logService.warn(
+                    `${logContext.logPrefix} Skipping plugin '${logContext.pluginName}': npm source is missing required 'package' field`
+                );
+                return undefined;
+            }
+            if (!isOptionalString(rawSource.version) || !isOptionalString(rawSource.registry)) {
+                logContext.logService.warn(
+                    `${logContext.logPrefix} Skipping plugin '${logContext.pluginName}': npm source 'version' and 'registry' must be strings when provided`
+                );
+                return undefined;
+            }
+            return {
+                kind: PluginSourceKind.Npm,
+                package: rawSource.package,
+                version: rawSource.version,
+                registry: rawSource.registry
+            };
+        }
+    case "pip":
+        {
+            if (typeof rawSource.package !== "string" || !rawSource.package) {
+                logContext.logService.warn(
+                    `${logContext.logPrefix} Skipping plugin '${logContext.pluginName}': pip source is missing required 'package' field`
+                );
+                return undefined;
+            }
+            if (!isOptionalString(rawSource.version) || !isOptionalString(rawSource.registry)) {
+                logContext.logService.warn(
+                    `${logContext.logPrefix} Skipping plugin '${logContext.pluginName}': pip source 'version' and 'registry' must be strings when provided`
+                );
+                return undefined;
+            }
+            return {
+                kind: PluginSourceKind.Pip,
+                package: rawSource.package,
+                version: rawSource.version,
+                registry: rawSource.registry
+            };
+        }
+    default:
+        logContext.logService.warn(
+            `${logContext.logPrefix} Skipping plugin '${logContext.pluginName}': unknown source kind '${rawSource.source}'`
+        );
+        return undefined;
+    }
+}
+function isOptionalString(value) {
+    return value === undefined || typeof value === "string";
+}
+function isOptionalGitSha(value) {
+    return value === undefined || (typeof value === "string" && /^[0-9a-fA-F]{40}$/.test(value));
+}
+function isValidGitHubRepo(repo) {
+    return /^[A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+$/.test(repo);
+}
+function getMarketplaceReadmeUri(repo, source) {
+    const normalizedSource = source.trim().replace(/^\.?\/+|\/+$/g, "");
+    const readmePath = normalizedSource ? `${normalizedSource}/README.md` : "README.md";
+    return ( URI.parse(`https://github.com/${repo}/blob/main/${readmePath}`));
+}
+function getMarketplaceReadmeFileUri(repoDir, source) {
+    const normalizedSource = source.trim().replace(/^\.?\/+|\/+$/g, "");
+    return normalizedSource ? joinPath(repoDir, normalizedSource, "README.md") : joinPath(repoDir, "README.md");
+}
+
+export { MarketplaceReferenceKind, MarketplaceType, PluginMarketplaceService, PluginSourceKind, parseMarketplaceReference, parseMarketplaceReferences, parsePluginSource };