@codingame/monaco-vscode-assignment-service-override 37.3.3 → 37.3.5

package/index.js

@@ -6,6 +6,7 @@ import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/pl
 import { IEnvironmentService } from '@codingame/monaco-vscode-api/vscode/vs/platform/environment/common/environment.service';
 import { SyncDescriptor } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/descriptors';
 import { IWorkbenchAssignmentService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/assignment/common/assignmentService.service';
+import './vscode/src/vs/workbench/services/assignment/common/assignmentService.js';
 
 let AssignmentService = class AssignmentService {
     constructor(experiments, treatments, configurationService, environmentService) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codingame/monaco-vscode-assignment-service-override",
-  "version": "37.3.3",
+  "version": "37.3.5",
   "private": false,
   "description": "VSCode public API plugged on the monaco editor - assignment service-override",
   "keywords": [],
@@ -15,7 +15,7 @@
   },
   "type": "module",
   "dependencies": {
-    "@codingame/monaco-vscode-api": "37.3.3"
+    "@codingame/monaco-vscode-api": "37.3.5"
   },
   "main": "index.js",
   "module": "index.js",

package/vscode/src/vs/workbench/services/assignment/common/assignmentContextFilter.d.ts

@@ -0,0 +1,43 @@
+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 { IStorageService } from "@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service";
+import type { IAssignmentFilter } from "./assignmentService.js";
+/**
+ * Applies the registered {@link IAssignmentFilter assignment filters} to the assignment context
+ * and remembers, per filter, which assignment-context ids each filter excluded.
+ *
+ * The excluded ids are persisted so that they stay filtered out across reloads even before the
+ * owning filter has been registered again. Once a filter is registered it becomes authoritative
+ * for its own id: the persisted state is repopulated from the ids it currently excludes and any
+ * id that is no longer excluded is dropped from storage.
+ */
+export declare class AssignmentContextFilter extends Disposable {
+    private readonly storageService;
+    private static readonly STORAGE_KEY;
+    private readonly _filters;
+    private readonly _filterDisposables;
+    /**
+     * Assignment-context ids that were filtered out, keyed by the id of the filter that
+     * excluded them. Entries owned by a filter that has not been registered yet are honored
+     * across reloads so those ids stay excluded until the filter takes over.
+     */
+    private _cachedFilteredOutIds;
+    /**
+     * Ids of filters that have been registered this session. Once a filter is registered it
+     * becomes authoritative for its own id and the persisted cache is repopulated from the
+     * ids it actually excludes.
+     */
+    private readonly _registeredFilterIds;
+    private readonly _onDidChange;
+    /** Fires when a filter is added or an already registered filter changes its exclusions. */
+    readonly onDidChange: Event<void>;
+    constructor(storageService: IStorageService);
+    addFilter(filter: IAssignmentFilter): void;
+    /**
+     * Removes the excluded assignment-context ids from the given context and persists the
+     * reconciled per-filter cache.
+     */
+    filter(assignmentContext: string): string;
+    private _loadFilteredOutIds;
+    private _storeFilteredOutIds;
+}

package/vscode/src/vs/workbench/services/assignment/common/assignmentContextFilter.js

@@ -0,0 +1,135 @@
+
+import { Emitter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { Disposable, DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { StorageScope, StorageTarget } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage';
+
+class AssignmentContextFilter extends Disposable {
+    static {
+        this.STORAGE_KEY = "workbench.assignment.filteredOutAssignmentContextIds";
+    }
+    constructor(storageService) {
+        super();
+        this.storageService = storageService;
+        this._filters = [];
+        this._filterDisposables = this._register(( new DisposableStore()));
+        this._registeredFilterIds = ( new Set());
+        this._onDidChange = this._register(( new Emitter()));
+        this.onDidChange = this._onDidChange.event;
+        this._cachedFilteredOutIds = this._loadFilteredOutIds();
+    }
+    addFilter(filter) {
+        this._filters.push(filter);
+        this._registeredFilterIds.add(filter.id);
+        if (( this._cachedFilteredOutIds.has(filter.id))) {
+            const next = ( new Map(this._cachedFilteredOutIds));
+            next.delete(filter.id);
+            this._storeFilteredOutIds(next);
+        }
+        this._filterDisposables.add(filter.onDidChange(() => this._onDidChange.fire()));
+        this._onDidChange.fire();
+    }
+    filter(assignmentContext) {
+        const assignments = assignmentContext.split(";");
+        const freshFilteredOut = ( new Map());
+        const filteredAssignments = assignments.filter(assignment => {
+            let excluded = false;
+            for (const filter of this._filters) {
+                if (filter.exclude(assignment)) {
+                    let set = freshFilteredOut.get(filter.id);
+                    if (!set) {
+                        set = ( new Set());
+                        freshFilteredOut.set(filter.id, set);
+                    }
+                    set.add(assignment);
+                    excluded = true;
+                }
+            }
+            if (excluded) {
+                return false;
+            }
+            for (const [filterId, ids] of this._cachedFilteredOutIds) {
+                if (!( this._registeredFilterIds.has(filterId)) && ( ids.has(assignment))) {
+                    return false;
+                }
+            }
+            return true;
+        });
+        const next = ( new Map());
+        for (const [filterId, ids] of this._cachedFilteredOutIds) {
+            if (!( this._registeredFilterIds.has(filterId))) {
+                next.set(filterId, ids);
+            }
+        }
+        for (const [filterId, ids] of freshFilteredOut) {
+            next.set(filterId, ids);
+        }
+        this._storeFilteredOutIds(next);
+        return filteredAssignments.join(";");
+    }
+    _loadFilteredOutIds() {
+        const result = ( new Map());
+        const raw = this.storageService.get(AssignmentContextFilter.STORAGE_KEY, StorageScope.APPLICATION);
+        if (!raw) {
+            return result;
+        }
+        try {
+            const parsed = JSON.parse(raw);
+            if (parsed && typeof parsed === "object") {
+                for (const [filterId, ids] of Object.entries(parsed)) {
+                    if (Array.isArray(ids)) {
+                        const set = ( new Set(ids.filter(id => typeof id === "string")));
+                        if (set.size > 0) {
+                            result.set(filterId, set);
+                        }
+                    }
+                }
+            }
+        } catch {}
+        return result;
+    }
+    _storeFilteredOutIds(next) {
+        const normalized = ( new Map());
+        for (const [filterId, ids] of next) {
+            if (ids.size > 0) {
+                normalized.set(filterId, ids);
+            }
+        }
+        if (areCachesEqual(normalized, this._cachedFilteredOutIds)) {
+            return;
+        }
+        this._cachedFilteredOutIds = normalized;
+        if (normalized.size === 0) {
+            this.storageService.remove(AssignmentContextFilter.STORAGE_KEY, StorageScope.APPLICATION);
+        } else {
+            const serializable = {};
+            for (const [filterId, ids] of normalized) {
+                serializable[filterId] = Array.from(ids);
+            }
+            this.storageService.store(
+                AssignmentContextFilter.STORAGE_KEY,
+                JSON.stringify(serializable),
+                StorageScope.APPLICATION,
+                StorageTarget.MACHINE
+            );
+        }
+    }
+}
+function areCachesEqual(a, b) {
+    if (a.size !== b.size) {
+        return false;
+    }
+    for (const [filterId, ids] of a) {
+        const other = b.get(filterId);
+        if (!other || other.size !== ids.size) {
+            return false;
+        }
+        for (const id of ids) {
+            if (!( other.has(id))) {
+                return false;
+            }
+        }
+    }
+    return true;
+}
+
+export { AssignmentContextFilter };

package/vscode/src/vs/workbench/services/assignment/common/assignmentFilters.d.ts

@@ -0,0 +1,97 @@
+import type { IExperimentationFilterProvider } from "tas-client";
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { IDefaultAccountService } from "@codingame/monaco-vscode-api/vscode/vs/platform/defaultAccount/common/defaultAccount.service";
+import { ILogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service";
+import { IStorageService } from "@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service";
+import { IChatEntitlementService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/chat/common/chatEntitlementService.service";
+import { IExtensionService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/extensions/common/extensions.service";
+export declare enum ExtensionsFilter {
+    /**
+     * Version of the github.copilot extension.
+     */
+    CopilotExtensionVersion = "X-Copilot-RelatedPluginVersion-githubcopilot",
+    /**
+     * Version of the github.copilot-chat extension.
+     */
+    CopilotChatExtensionVersion = "X-Copilot-RelatedPluginVersion-githubcopilotchat",
+    /**
+     * Version of the completions version.
+     */
+    CompletionsVersionInCopilotChat = "X-VSCode-CompletionsInChatExtensionVersion",
+    /**
+     * SKU of the copilot entitlement.
+     */
+    CopilotSku = "X-GitHub-Copilot-SKU",
+    /**
+     * The internal org of the user.
+     */
+    MicrosoftInternalOrg = "X-Microsoft-Internal-Org",
+    /**
+     * The tracking ID of the user from Copilot entitlement API.
+     */
+    CopilotTrackingId = "X-Copilot-CopilotTrackingId",
+    /**
+     * Whether the `sn` flag is set to `'1'` in the copilot token.
+     */
+    CopilotIsSn = "X-GitHub-Copilot-IsSn",
+    /**
+     * Whether the `fcv1` flag is set to `'1'` in the copilot token.
+     */
+    CopilotIsFcv1 = "X-GitHub-Copilot-IsFcv1"
+}
+export declare class CopilotAssignmentFilterProvider extends Disposable implements IExperimentationFilterProvider {
+    private readonly _extensionService;
+    private readonly _logService;
+    private readonly _storageService;
+    private readonly _chatEntitlementService;
+    private readonly _defaultAccountService;
+    private copilotChatExtensionVersion;
+    private copilotExtensionVersion;
+    private copilotCompletionsVersion;
+    private copilotInternalOrg;
+    private copilotSku;
+    private copilotTrackingId;
+    private copilotIsSn;
+    private copilotIsFcv1;
+    private readonly _onDidChangeFilters;
+    readonly onDidChangeFilters: import("@codingame/monaco-vscode-api/vscode/vs/base/common/event").Event<void>;
+    constructor(_extensionService: IExtensionService, _logService: ILogService, _storageService: IStorageService, _chatEntitlementService: IChatEntitlementService, _defaultAccountService: IDefaultAccountService);
+    private updateExtensionVersions;
+    private updateCopilotEntitlementInfo;
+    private updateCopilotTokenInfo;
+    /**
+     * Returns a version string that can be parsed by the TAS client.
+     * The tas client cannot handle suffixes lke "-insider"
+     * Ref: https://github.com/microsoft/tas-client/blob/30340d5e1da37c2789049fcf45928b954680606f/vscode-tas-client/src/vscode-tas-client/VSCodeFilterProvider.ts#L35
+     *
+     * @param version Version string to be trimmed.
+    */
+    private static trimVersionSuffix;
+    getFilterValue(filter: string): string | null;
+    getFilters(): Map<string, string | null>;
+}
+/**
+ * userParam names for the new TAS assignments API (POST /api/v1/assignments) that carry
+ * the GitHub account signals available in core. Hex org/business ids are not yet parsed
+ * in core, so they are intentionally omitted here.
+ */
+export declare enum GitHubAssignmentsFilter {
+    CopilotTrackingId = "copilottrackingid",
+    IsGhOrMsftStaff = "github_core_isghormsftstaff",
+    GhMsftOrExternal = "github_core_ghmsftorexternal"
+}
+/**
+ * Emits the core-available GitHub account filters for the new TAS assignments API using
+ * the new userParam key names.
+ */
+export declare class GitHubCoreAssignmentsFilterProvider extends Disposable implements IExperimentationFilterProvider {
+    private readonly _chatEntitlementService;
+    private copilotTrackingId;
+    private internalOrg;
+    private readonly _onDidChangeFilters;
+    readonly onDidChangeFilters: import("@codingame/monaco-vscode-api/vscode/vs/base/common/event").Event<void>;
+    constructor(_chatEntitlementService: IChatEntitlementService);
+    private update;
+    getFilterValue(filter: string): string | null;
+    getFilters(): Map<string, string | null>;
+}

package/vscode/src/vs/workbench/services/assignment/common/assignmentFilters.js

@@ -0,0 +1,38 @@
+
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/assignment/common/assignment';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/extensions/common/extensions';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage';
+
+var ExtensionsFilter;
+(function(ExtensionsFilter) {
+    ExtensionsFilter["CopilotExtensionVersion"] = "X-Copilot-RelatedPluginVersion-githubcopilot";
+    ExtensionsFilter["CopilotChatExtensionVersion"] = "X-Copilot-RelatedPluginVersion-githubcopilotchat";
+    ExtensionsFilter["CompletionsVersionInCopilotChat"] = "X-VSCode-CompletionsInChatExtensionVersion";
+    ExtensionsFilter["CopilotSku"] = "X-GitHub-Copilot-SKU";
+    ExtensionsFilter["MicrosoftInternalOrg"] = "X-Microsoft-Internal-Org";
+    ExtensionsFilter["CopilotTrackingId"] = "X-Copilot-CopilotTrackingId";
+    ExtensionsFilter["CopilotIsSn"] = "X-GitHub-Copilot-IsSn";
+    ExtensionsFilter["CopilotIsFcv1"] = "X-GitHub-Copilot-IsFcv1";
+})(ExtensionsFilter || (ExtensionsFilter = {}));
+var StorageVersionKeys;
+(function(StorageVersionKeys) {
+    StorageVersionKeys["CopilotExtensionVersion"] = "extensionsAssignmentFilterProvider.copilotExtensionVersion";
+    StorageVersionKeys["CopilotChatExtensionVersion"] = "extensionsAssignmentFilterProvider.copilotChatExtensionVersion";
+    StorageVersionKeys["CompletionsVersion"] = "extensionsAssignmentFilterProvider.copilotCompletionsVersion";
+    StorageVersionKeys["CopilotSku"] = "extensionsAssignmentFilterProvider.copilotSku";
+    StorageVersionKeys["CopilotInternalOrg"] = "extensionsAssignmentFilterProvider.copilotInternalOrg";
+    StorageVersionKeys["CopilotTrackingId"] = "extensionsAssignmentFilterProvider.copilotTrackingId";
+    StorageVersionKeys["CopilotIsSn"] = "extensionsAssignmentFilterProvider.copilotIsSn";
+    StorageVersionKeys["CopilotIsFcv1"] = "extensionsAssignmentFilterProvider.copilotIsFcv1";
+})(StorageVersionKeys || (StorageVersionKeys = {}));
+var GitHubAssignmentsFilter;
+(function(GitHubAssignmentsFilter) {
+    GitHubAssignmentsFilter["CopilotTrackingId"] = "copilottrackingid";
+    GitHubAssignmentsFilter["IsGhOrMsftStaff"] = "github_core_isghormsftstaff";
+    GitHubAssignmentsFilter["GhMsftOrExternal"] = "github_core_ghmsftorexternal";
+})(GitHubAssignmentsFilter || (GitHubAssignmentsFilter = {}));
+
+export { ExtensionsFilter, GitHubAssignmentsFilter };

package/vscode/src/vs/workbench/services/assignment/common/assignmentService.d.ts

@@ -0,0 +1,83 @@
+import { IInstantiationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
+import { ITelemetryService } from "@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry.service";
+import { IStorageService } from "@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service";
+import { ITelemetryData } from "@codingame/monaco-vscode-api/vscode/vs/base/common/actions";
+import { IConfigurationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service";
+import { IProductService } from "@codingame/monaco-vscode-api/vscode/vs/platform/product/common/productService.service";
+import { IAssignmentService } from "@codingame/monaco-vscode-api/vscode/vs/platform/assignment/common/assignment";
+import { IWorkbenchEnvironmentService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/environment/common/environmentService.service";
+import { IRequestService } from "@codingame/monaco-vscode-api/vscode/vs/platform/request/common/request.service";
+import { IDefaultAccountService } from "@codingame/monaco-vscode-api/vscode/vs/platform/defaultAccount/common/defaultAccount.service";
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { Event } from "@codingame/monaco-vscode-api/vscode/vs/base/common/event";
+export interface IAssignmentFilter {
+    /**
+     * Stable identifier for this filter. Used to persist and reconcile the set of
+     * assignment-context ids this filter has excluded, independently of other filters.
+     */
+    readonly id: string;
+    exclude(assignment: string): boolean;
+    onDidChange: Event<void>;
+}
+/**
+ * Resolves a treatment value preferring the `/vscode/`-scoped key emitted by the new TAS
+ * assignments endpoint over the bare key used by the legacy endpoint, so the new endpoint wins
+ * when both assign a treatment (matching the behavior once tas-client strips the scope itself).
+ * Falls back to the bare key for treatments served only by the legacy endpoint.
+ *
+ * Exported for testing.
+ */
+export declare function resolveScopedTreatment<T extends string | number | boolean>(read: (name: string) => T | undefined, name: string): T | undefined;
+/**
+ * Builds the telemetry payload for a tas-client feature query. The queried-feature name is marked
+ * trusted so the telemetry cleaner does not redact a `/vscode/`-scoped name as a `user-file-path`.
+ *
+ * Exported for testing.
+ */
+export declare function toExperimentTelemetryData(props: Map<string, string>): ITelemetryData;
+export declare class WorkbenchAssignmentService extends Disposable implements IAssignmentService {
+    private readonly telemetryService;
+    private readonly configurationService;
+    private readonly productService;
+    private readonly environmentService;
+    private readonly instantiationService;
+    private readonly defaultAccountService;
+    private readonly requestService;
+    readonly _serviceBrand: undefined;
+    private tasClient;
+    private readonly tasSetupDisposables;
+    private assignmentsEndpoint;
+    private networkInitialized;
+    private setupGeneration;
+    /** Revokes the current setup's storage/telemetry/fetch wrappers, neutralizing a superseded in-flight client. */
+    private revokeCurrentSetup;
+    private readonly overrideInitDelay;
+    private readonly contextFilter;
+    private readonly telemetry;
+    private readonly keyValueStorage;
+    private readonly experimentsEnabled;
+    private readonly _onDidRefetchAssignments;
+    readonly onDidRefetchAssignments: Event<void>;
+    constructor(telemetryService: ITelemetryService, storageService: IStorageService, configurationService: IConfigurationService, productService: IProductService, environmentService: IWorkbenchEnvironmentService, instantiationService: IInstantiationService, defaultAccountService: IDefaultAccountService, requestService: IRequestService);
+    getTreatment<T extends string | number | boolean>(name: string): Promise<T | undefined>;
+    private doGetTreatment;
+    /**
+     * Resolves the new TAS assignments API URL from the account entitlements `exp` endpoint,
+     * or `undefined` when no account/endpoint is available.
+     */
+    private getAssignmentsEndpoint;
+    /** Recreates the TAS client when the resolved assignments endpoint has changed. */
+    private recreateTasClientIfEndpointChanged;
+    /**
+     * Transport for the new assignments endpoint, backed by the main-process request service
+     * (avoids renderer CORS). Shape matches tas-client's injectable `assignmentsFetch`.
+     */
+    private readonly assignmentsFetch;
+    private setupTASClient;
+    private logFetchLatency;
+    private refetchAssignments;
+    getCurrentExperiments(): Promise<string[] | undefined>;
+    addTelemetryAssignmentFilter(filter: IAssignmentFilter): void;
+    /** Stops a TAS client's auto-polling once it resolves. Safe to call with `undefined`. */
+    private static disposeTasClient;
+}

package/vscode/src/vs/workbench/services/assignment/common/assignmentService.js

@@ -0,0 +1,39 @@
+
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import '@codingame/monaco-vscode-api/vscode/vs/workbench/common/memento';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/errors';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/network';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/platform';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/process';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/uuid';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/extensions';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/assignment/common/assignment';
+import { Registry } from '@codingame/monaco-vscode-api/vscode/vs/platform/registry/common/platform';
+import { workbenchConfigurationNodeBase } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/configuration';
+import { Extensions, ConfigurationScope } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configurationRegistry';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/request/common/request';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/stopwatch';
+import './assignmentFilters.js';
+import './assignmentContextFilter.js';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+
+const registry = ( Registry.as(Extensions.Configuration));
+registry.registerConfiguration({
+    ...workbenchConfigurationNodeBase,
+    "properties": {
+        "workbench.enableExperiments": {
+            "type": "boolean",
+            "description": ( localize(21675, "Fetches experiments to run from a Microsoft online service.")),
+            "default": true,
+            "scope": ConfigurationScope.APPLICATION,
+            "restricted": true,
+            "tags": ["usesOnlineServices"]
+        }
+    }
+});