@codingame/monaco-vscode-chat-service-override 37.0.0 → 37.2.0

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

@@ -0,0 +1,294 @@
+
+import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
+import { ChatConfiguration } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/constants';
+
+var MarketplaceReferenceKind;
+(function(MarketplaceReferenceKind) {
+    MarketplaceReferenceKind["GitHubShorthand"] = "githubShorthand";
+    MarketplaceReferenceKind["GitUri"] = "gitUri";
+    MarketplaceReferenceKind["LocalFileUri"] = "localFileUri";
+})(MarketplaceReferenceKind || (MarketplaceReferenceKind = {}));
+const _githubShorthandRe = /^[A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+(?:#.+)?$/;
+function readConfiguredMarketplaces(configurationService) {
+    const userValues = configurationService.getValue(ChatConfiguration.PluginMarketplaces) ?? [];
+    const extraObj = configurationService.getValue(ChatConfiguration.ExtraMarketplaces) ?? {};
+    const extraValues = Object.entries(extraObj).flatMap(([name, value]) => {
+        if (typeof value !== "string") {
+            return [];
+        }
+        const encoded = parseExtraMarketplaceConfigValue(value);
+        const src = encoded?.source ?? value;
+        const autoUpdate = encoded?.autoUpdate;
+        const isGithubShorthand = _githubShorthandRe.test(src);
+        return [isGithubShorthand ? {
+            name,
+            autoUpdate,
+            source: {
+                source: "github",
+                repo: src
+            }
+        } : {
+            name,
+            autoUpdate,
+            source: {
+                source: "git",
+                url: src
+            }
+        }];
+    });
+    return {
+        userValues,
+        extraValues,
+        effectiveValues: [...userValues, ...extraValues]
+    };
+}
+function parseExtraMarketplaceConfigValue(value) {
+    try {
+        const parsed = JSON.parse(value);
+        return parsed && typeof parsed === "object" && typeof parsed.source === "string" && typeof parsed.autoUpdate === "boolean" ? parsed : undefined;
+    } catch {
+        return undefined;
+    }
+}
+function parseMarketplaceReferences(values) {
+    const byCanonicalId = ( new Map());
+    for (const value of values) {
+        let parsed;
+        if (typeof value === "string") {
+            parsed = parseMarketplaceReference(value);
+        } else if (value && typeof value === "object") {
+            parsed = parseMarketplaceObjectEntry(value);
+        }
+        if (parsed) {
+            const existing = byCanonicalId.get(parsed.canonicalId);
+            if (!existing) {
+                byCanonicalId.set(parsed.canonicalId, parsed);
+            } else if (parsed.autoUpdate !== undefined) {
+                byCanonicalId.set(parsed.canonicalId, {
+                    ...existing,
+                    autoUpdate: parsed.autoUpdate
+                });
+            }
+        }
+    }
+    return [...( byCanonicalId.values())];
+}
+function parseMarketplaceObjectEntry(entry) {
+    let sourceType;
+    let repo;
+    let url;
+    let ref;
+    if (entry.source && typeof entry.source === "object") {
+        const nested = entry.source;
+        sourceType = nested.source;
+        repo = nested.repo;
+        url = nested.url;
+        ref = nested.ref;
+    } else {
+        sourceType = entry.source;
+        repo = entry.repo;
+        url = entry.url;
+        ref = entry.ref;
+    }
+    let parsed;
+    if (sourceType === "github" && typeof repo === "string") {
+        parsed = parseMarketplaceReference(appendMarketplaceRef(repo, ref));
+    } else if (sourceType === "git" && typeof url === "string") {
+        parsed = parseMarketplaceReference(appendMarketplaceRef(url, ref));
+    }
+    if (parsed && typeof entry.name === "string" && entry.name.length > 0) {
+        parsed = {
+            ...parsed,
+            displayLabel: entry.name
+        };
+    }
+    if (parsed && typeof entry.autoUpdate === "boolean") {
+        parsed = {
+            ...parsed,
+            autoUpdate: entry.autoUpdate
+        };
+    }
+    return parsed;
+}
+function appendMarketplaceRef(value, ref) {
+    if (!ref) {
+        return value;
+    }
+    const fragmentIndex = value.indexOf("#");
+    const base = fragmentIndex === -1 ? value : value.slice(0, fragmentIndex);
+    return `${base}#${ref}`;
+}
+function deduplicateMarketplaceReferences(primary, secondary) {
+    const byCanonicalId = ( new Map());
+    for (const ref of primary) {
+        byCanonicalId.set(ref.canonicalId, ref);
+    }
+    for (const ref of secondary) {
+        if (!( byCanonicalId.has(ref.canonicalId))) {
+            byCanonicalId.set(ref.canonicalId, ref);
+        }
+    }
+    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];
+        const ref = shorthandMatch[3];
+        return {
+            rawValue,
+            displayLabel: rawValue,
+            cloneUrl: `https://github.com/${owner}/${repo}.git`,
+            canonicalId: getGitHubCanonicalId(owner, repo, ref),
+            cacheSegments: ["github.com", owner, repo, ...getRefCacheSegments(ref)],
+            kind: MarketplaceReferenceKind.GitHubShorthand,
+            ref,
+            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)) {
+        if (uri.fragment) {
+            return undefined;
+        }
+        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 ref = uri.fragment || undefined;
+    const cloneUri = uri.fragment ? uri.with({
+        fragment: ""
+    }) : uri;
+    const sanitizedAuthority = sanitizePathSegment(uri.authority.toLowerCase());
+    const trimmedPath = uri.path.replace(/\/+/g, "/").replace(/\/+$/g, "").replace(/^\/+/, "");
+    if (!trimmedPath) {
+        return {
+            rawValue,
+            displayLabel: rawValue,
+            cloneUrl: ( cloneUri.toString()),
+            canonicalId: appendRefSuffix(`git:${uri.authority.toLowerCase()}/`, ref),
+            cacheSegments: [sanitizedAuthority, ...getRefCacheSegments(ref)],
+            kind: MarketplaceReferenceKind.GitUri,
+            ref
+        };
+    }
+    const gitSuffix = ".git";
+    const pathHasGitSuffix = trimmedPath.toLowerCase().endsWith(gitSuffix);
+    const pathWithoutGit = pathHasGitSuffix ? trimmedPath.slice(0, trimmedPath.length - gitSuffix.length) : trimmedPath;
+    const pathSegments = ( pathWithoutGit.split("/").map(sanitizePathSegment));
+    const canonicalPath = pathHasGitSuffix ? trimmedPath.toLowerCase() : `${trimmedPath.toLowerCase()}${gitSuffix}`;
+    const githubRepo = extractGitHubRepo(uri.authority, pathWithoutGit);
+    let canonicalId;
+    if (githubRepo) {
+        const [owner, repo] = githubRepo.split("/");
+        canonicalId = getGitHubCanonicalId(owner, repo, ref);
+    } else {
+        canonicalId = appendRefSuffix(`git:${uri.authority.toLowerCase()}/${canonicalPath}`, ref);
+    }
+    return {
+        rawValue,
+        displayLabel: rawValue,
+        cloneUrl: ( cloneUri.toString()),
+        canonicalId,
+        cacheSegments: [sanitizedAuthority, ...pathSegments, ...getRefCacheSegments(ref)],
+        kind: MarketplaceReferenceKind.GitUri,
+        ref,
+        githubRepo
+    };
+}
+function parseScpMarketplaceReference(rawValue) {
+    const match = /^([^@\s]+)@([^:\s]+):(.+?\.git)(?:#(.+))?$/i.exec(rawValue);
+    if (!match) {
+        return undefined;
+    }
+    const gitSuffix = ".git";
+    const authority = match[2];
+    const pathWithGit = match[3].replace(/^\/+/, "");
+    const ref = match[4];
+    if (!pathWithGit.toLowerCase().endsWith(gitSuffix)) {
+        return undefined;
+    }
+    const pathWithoutGit = pathWithGit.slice(0, -gitSuffix.length);
+    const pathSegments = ( pathWithoutGit.split("/").map(sanitizePathSegment));
+    const githubRepo = extractGitHubRepo(authority, pathWithoutGit);
+    let canonicalId;
+    if (githubRepo) {
+        const [owner, repo] = githubRepo.split("/");
+        canonicalId = getGitHubCanonicalId(owner, repo, ref);
+    } else {
+        canonicalId = appendRefSuffix(`git:${authority.toLowerCase()}/${pathWithGit.toLowerCase()}`, ref);
+    }
+    return {
+        rawValue,
+        displayLabel: rawValue,
+        cloneUrl: `${match[1]}@${authority}:${pathWithGit}`,
+        canonicalId,
+        cacheSegments: [
+            sanitizePathSegment(authority.toLowerCase()),
+            ...pathSegments,
+            ...getRefCacheSegments(ref)
+        ],
+        kind: MarketplaceReferenceKind.GitUri,
+        ref,
+        githubRepo
+    };
+}
+function extractGitHubRepo(authority, pathWithoutGit) {
+    if (authority.toLowerCase() !== "github.com") {
+        return undefined;
+    }
+    const parts = pathWithoutGit.split("/");
+    if (parts.length >= 2 && parts[0] && parts[1]) {
+        return `${parts[0]}/${parts[1]}`;
+    }
+    return undefined;
+}
+function getGitHubCanonicalId(owner, repo, ref) {
+    return appendRefSuffix(`github:${owner.toLowerCase()}/${repo.toLowerCase()}`, ref);
+}
+function appendRefSuffix(canonicalId, ref) {
+    return ref ? `${canonicalId}#${encodeURIComponent(ref)}` : canonicalId;
+}
+function getRefCacheSegments(ref) {
+    return ref ? [`ref_${encodeURIComponent(ref)}`] : [];
+}
+function sanitizePathSegment(value) {
+    return value.replace(/[\\/:*?"<>|]/g, "_");
+}
+
+export { MarketplaceReferenceKind, deduplicateMarketplaceReferences, parseMarketplaceObjectEntry, parseMarketplaceReference, parseMarketplaceReferences, readConfiguredMarketplaces };

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

@@ -0,0 +1,212 @@
+import { CancellationToken } from "@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation";
+import { Event } from "@codingame/monaco-vscode-api/vscode/vs/base/common/event";
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { IObservable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/observable";
+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 { IEnvironmentService } from "@codingame/monaco-vscode-api/vscode/vs/platform/environment/common/environment.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 { IMeteredConnectionService } from "@codingame/monaco-vscode-api/vscode/vs/platform/meteredConnection/common/meteredConnection.service";
+import { IRequestService } from "@codingame/monaco-vscode-api/vscode/vs/platform/request/common/request.service";
+import { IStorageService } from "@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service";
+import { IExtensionsWorkbenchService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/extensions/common/extensions.service";
+import { IAgentPluginRepositoryService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/plugins/agentPluginRepositoryService.service";
+import { IWorkspacePluginSettingsService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/plugins/workspacePluginSettingsService.service";
+import { IWorkspaceTrustManagementService } from "@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspaceTrust.service";
+import { type IMarketplaceReference } from "./marketplaceReference.js";
+import { IPluginMarketplaceService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/plugins/pluginMarketplaceService.service";
+export { deduplicateMarketplaceReferences, extraKnownMarketplacesToConfigDict, MarketplaceReferenceKind, parseMarketplaceReference, parseMarketplaceReferences, readConfiguredMarketplaces } from "./marketplaceReference.js";
+export type { IConfiguredMarketplaces, IMarketplaceReference } from "./marketplaceReference.js";
+export declare enum MarketplaceType {
+    Copilot = "copilot",
+    Claude = "claude",
+    OpenPlugin = "openPlugin"
+}
+export declare enum PluginSourceKind {
+    RelativePath = "relativePath",
+    GitHub = "github",
+    GitUrl = "url",
+    Npm = "npm",
+    Pip = "pip"
+}
+export interface IRelativePathPluginSource {
+    readonly kind: PluginSourceKind.RelativePath;
+    /** Resolved relative path within the marketplace repository. */
+    readonly path: string;
+}
+export interface IGitHubPluginSource {
+    readonly kind: PluginSourceKind.GitHub;
+    readonly repo: string;
+    readonly ref?: string;
+    readonly sha?: string;
+    readonly path?: string;
+}
+export interface IGitUrlPluginSource {
+    readonly kind: PluginSourceKind.GitUrl;
+    /** Full git repository URL (must end with .git). */
+    readonly url: string;
+    readonly ref?: string;
+    readonly sha?: string;
+    /** Subdirectory within the repository where the plugin lives (for `git-subdir` sources). */
+    readonly path?: string;
+}
+export interface INpmPluginSource {
+    readonly kind: PluginSourceKind.Npm;
+    readonly package: string;
+    readonly version?: string;
+    readonly registry?: string;
+}
+export interface IPipPluginSource {
+    readonly kind: PluginSourceKind.Pip;
+    readonly package: string;
+    readonly version?: string;
+    readonly registry?: string;
+}
+export type IPluginSourceDescriptor = IRelativePathPluginSource | IGitHubPluginSource | IGitUrlPluginSource | INpmPluginSource | IPipPluginSource;
+export interface IMarketplacePlugin {
+    readonly name: string;
+    readonly description: string;
+    readonly version: string;
+    /** Subdirectory within the repository where the plugin lives (for relative-path sources). */
+    readonly source: string;
+    /** Structured source descriptor indicating how the plugin should be fetched/installed. */
+    readonly sourceDescriptor: IPluginSourceDescriptor;
+    /** Marketplace label shown in UI and plugin provenance. */
+    readonly marketplace: string;
+    /** Canonical reference for clone/update/install location resolution. */
+    readonly marketplaceReference: IMarketplaceReference;
+    /** The type of marketplace this plugin comes from. */
+    readonly marketplaceType: MarketplaceType;
+    readonly readmeUri?: URI;
+}
+/** Raw JSON shape of a remote plugin source object in marketplace.json. */
+interface IJsonPluginSource {
+    readonly source: string;
+    readonly repo?: string;
+    readonly url?: string;
+    readonly package?: string;
+    readonly ref?: string;
+    readonly sha?: string;
+    readonly path?: string;
+    readonly version?: string;
+    readonly registry?: string;
+}
+export interface IMarketplaceInstalledPlugin {
+    readonly pluginUri: URI;
+    readonly plugin: IMarketplacePlugin;
+}
+/**
+ * Options for fetching marketplace plugins.
+ */
+export interface IFetchMarketplacePluginsOptions {
+    /** Bypass the marketplace caches (HTTP TTL cache and cloned-repository TTL) and re-read from the remote. */
+    readonly refresh?: boolean;
+    /**
+     * Called for each marketplace that could not be read. Individual failures
+     * are otherwise swallowed so that one bad marketplace cannot fail the
+     * whole fetch, which leaves callers unable to tell a partial result from
+     * a complete one.
+     */
+    readonly onMarketplaceError?: (reference: IMarketplaceReference, error: unknown) => void;
+}
+export declare class PluginMarketplaceService extends Disposable implements IPluginMarketplaceService {
+    private readonly _configurationService;
+    private readonly _requestService;
+    private readonly _fileService;
+    private readonly _pluginRepositoryService;
+    private readonly _logService;
+    private readonly _storageService;
+    private readonly _workspacePluginSettingsService;
+    private readonly _workspaceTrustService;
+    private readonly _extensionsWorkbenchService;
+    private readonly _meteredConnectionService;
+    readonly _serviceBrand: undefined;
+    private readonly _gitHubMarketplaceCache;
+    private readonly _installedPluginsStore;
+    private readonly _pluginMetadata;
+    private readonly _trustedMarketplacesStore;
+    private readonly _lastFetchedPluginsStore;
+    private readonly _marketplacesWithUpdates;
+    private readonly _updateCheckDelayer;
+    private _updateChecksInitialized;
+    private _updateCheckRunning;
+    readonly onDidChangeMarketplaces: Event<void>;
+    readonly installedPlugins: IObservable<readonly IMarketplaceInstalledPlugin[]>;
+    readonly marketplacesWithUpdates: IObservable<ReadonlySet<string>>;
+    readonly lastFetchedPlugins: IObservable<readonly IMarketplacePlugin[]>;
+    readonly recommendedPlugins: IObservable<ReadonlySet<string>>;
+    constructor(_configurationService: IConfigurationService, _requestService: IRequestService, environmentService: IEnvironmentService, _fileService: IFileService, _pluginRepositoryService: IAgentPluginRepositoryService, _logService: ILogService, _storageService: IStorageService, _workspacePluginSettingsService: IWorkspacePluginSettingsService, _workspaceTrustService: IWorkspaceTrustManagementService, _extensionsWorkbenchService: IExtensionsWorkbenchService, _meteredConnectionService: IMeteredConnectionService);
+    clearUpdatesAvailable(marketplaceIds?: ReadonlySet<string>): void;
+    fetchMarketplacePlugins(token: CancellationToken, marketplaceIds?: ReadonlySet<string>, options?: IFetchMarketplacePluginsOptions): Promise<IMarketplacePlugin[]>;
+    private _fetchFromGitHubRepo;
+    private _getCachedGitHubMarketplacePlugins;
+    private _loadPersistedGitHubMarketplaceCache;
+    private _savePersistedGitHubMarketplaceCache;
+    getMarketplacePluginMetadata(pluginUri: URI): IMarketplacePlugin | undefined;
+    addInstalledPlugin(pluginUri: URI, plugin: IMarketplacePlugin): void;
+    removeInstalledPlugin(pluginUri: URI): void;
+    isMarketplaceTrusted(ref: IMarketplaceReference): boolean;
+    isStrictMarketplacePolicyActive(): boolean;
+    isMarketplaceAutoUpdateEnabled(ref: IMarketplaceReference): boolean;
+    private _isMarketplaceAllowedByStrictPolicy;
+    /**
+     * Hydrates installed entries from marketplace metadata. Entries written
+     * by current builds include the marketplace plugin name, which is enough
+     * to re-read the full plugin descriptor from the marketplace source. Old
+     * entries without a name fall back to matching by install URI. Entries
+     * that came from a single-plugin repository have no marketplace index to
+     * look up at all and are recovered from the manifest in their install
+     * directory.
+     *
+     * After hydration completes the installed-plugins store is "touched" so
+     * that the derived {@link installedPlugins} observable re-evaluates with
+     * the newly available metadata.
+     */
+    private _hydratePluginMetadata;
+    private _readPluginsForInstalledEntry;
+    /**
+     * Shared logic to parse a marketplace.json into {@link IMarketplacePlugin}
+     * objects. Used by both fetch and hydration paths.
+     */
+    private _parseMarketplacePlugins;
+    trustMarketplace(ref: IMarketplaceReference): void;
+    private _hasAutoUpdateEnabledMarketplace;
+    /**
+     * (Re-)schedules the next periodic update check after startup idle and
+     * whenever the auto-update config or metered connection state changes.
+     */
+    private _scheduleUpdateCheck;
+    private _doRunUpdateCheck;
+    private _fetchFromClonedRepo;
+    readPluginsFromDirectory(repoDir: URI, reference: IMarketplaceReference): Promise<IMarketplacePlugin[]>;
+    readSinglePluginManifest(repoDir: URI, reference: IMarketplaceReference): Promise<IMarketplacePlugin | undefined>;
+    isPluginDirectory(repoDir: URI): Promise<boolean>;
+    private _readPluginsFromDirectory;
+    /**
+     * Iterates over {@link MARKETPLACE_DEFINITIONS} paths, calling
+     * {@link readJson} for each to obtain the parsed JSON. Returns the
+     * plugins from the first definition that yields a valid result.
+     */
+    private _readPluginsFromDefinitions;
+}
+/**
+ * Parse a raw `source` field from marketplace.json into a structured
+ * {@link IPluginSourceDescriptor}. Accepts either a relative-path string
+ * or a JSON object with a `source` discriminant indicating the kind.
+ */
+export declare function parsePluginSource(rawSource: string | IJsonPluginSource | undefined, pluginRoot: string | undefined, logContext: {
+    pluginName: string;
+    logService: ILogService;
+    logPrefix: string;
+}): IPluginSourceDescriptor | undefined;
+/**
+ * Returns a human-readable label for a plugin source descriptor,
+ * suitable for error messages and UI display.
+ */
+export declare function getPluginSourceLabel(descriptor: IPluginSourceDescriptor): string;
+/**
+ * Returns `true` when the marketplace source descriptor differs from the
+ * installed one — meaning an update should be performed.
+ */
+export declare function hasSourceChanged(installed: IPluginSourceDescriptor, marketplace: IPluginSourceDescriptor): boolean;