@codingame/monaco-vscode-api 26.2.1 → 27.0.0

package/vscode/src/vs/workbench/api/common/extHostGitExtensionService.js

@@ -0,0 +1,167 @@
+
+import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
+import { Event } from '../../../base/common/event.js';
+import { Disposable, DisposableStore } from '../../../base/common/lifecycle.js';
+import { URI } from '../../../base/common/uri.js';
+import { ExtensionIdentifier } from '../../../platform/extensions/common/extensions.js';
+import { createDecorator } from '../../../platform/instantiation/common/instantiation.js';
+import { IExtHostExtensionService } from './extHostExtensionService.js';
+import { IExtHostRpcService } from './extHostRpcService.js';
+import { GitRefTypeDto, MainContext } from './extHost.protocol.js';
+import { ResourceMap } from '../../../base/common/map.js';
+
+var ExtHostGitExtensionService_1;
+const GIT_EXTENSION_ID = "vscode.git";
+function toGitRefTypeDto(type) {
+    switch (type) {
+    case GitRefType.Head:
+        return GitRefTypeDto.Head;
+    case GitRefType.RemoteHead:
+        return GitRefTypeDto.RemoteHead;
+    case GitRefType.Tag:
+        return GitRefTypeDto.Tag;
+    default:
+        throw ( new Error(`Unknown GitRefType: ${type}`));
+    }
+}
+function toGitBranchDto(branch) {
+    return {
+        name: branch.name,
+        commit: branch.commit,
+        type: toGitRefTypeDto(branch.type),
+        remote: branch.remote,
+        upstream: branch.upstream ? toGitUpstreamRefDto(branch.upstream) : undefined,
+        ahead: branch.ahead,
+        behind: branch.behind
+    };
+}
+function toGitUpstreamRefDto(upstream) {
+    return {
+        remote: upstream.remote,
+        name: upstream.name,
+        commit: upstream.commit
+    };
+}
+var GitRefType;
+(function(GitRefType) {
+    GitRefType[GitRefType["Head"] = 0] = "Head";
+    GitRefType[GitRefType["RemoteHead"] = 1] = "RemoteHead";
+    GitRefType[GitRefType["Tag"] = 2] = "Tag";
+})(GitRefType || (GitRefType = {}));
+const IExtHostGitExtensionService = ( createDecorator("IExtHostGitExtensionService"));
+let ExtHostGitExtensionService = class ExtHostGitExtensionService extends Disposable {
+    static {
+        ExtHostGitExtensionService_1 = this;
+    }
+    static {
+        this._handlePool = 0;
+    }
+    constructor(extHostRpc, _extHostExtensionService) {
+        super();
+        this._extHostExtensionService = _extHostExtensionService;
+        this._repositories = ( new Map());
+        this._repositoryByUri = ( new ResourceMap());
+        this._disposables = this._register(( new DisposableStore()));
+        this._proxy = ( extHostRpc.getProxy(MainContext.MainThreadGitExtension));
+    }
+    async $isGitExtensionAvailable() {
+        const registry = await this._extHostExtensionService.getExtensionRegistry();
+        return !!registry.getExtensionDescription(GIT_EXTENSION_ID);
+    }
+    async $openRepository(uri) {
+        const api = await this._ensureGitApi();
+        if (!api) {
+            return undefined;
+        }
+        const repository = await api.openRepository(URI.revive(uri));
+        if (!repository) {
+            return undefined;
+        }
+        const existingHandle = this._repositoryByUri.get(repository.rootUri);
+        if (existingHandle !== undefined) {
+            return {
+                handle: existingHandle,
+                rootUri: repository.rootUri,
+                state: {
+                    HEAD: repository.state.HEAD ? toGitBranchDto(repository.state.HEAD) : undefined
+                }
+            };
+        }
+        let repositoryState = repository.state;
+        if (repositoryState.HEAD === undefined) {
+            await Event.toPromise(repositoryState.onDidChange, this._disposables);
+            repositoryState = repository.state;
+        }
+        const handle = ExtHostGitExtensionService_1._handlePool++;
+        this._repositories.set(handle, repository);
+        this._repositoryByUri.set(repository.rootUri, handle);
+        this._disposables.add(repository.state.onDidChange(() => {
+            this._proxy.$onDidChangeRepository(handle);
+        }));
+        return {
+            handle,
+            rootUri: repository.rootUri,
+            state: {
+                HEAD: repository.state.HEAD ? toGitBranchDto(repository.state.HEAD) : undefined
+            }
+        };
+    }
+    async $getRefs(handle, query, token) {
+        const repository = this._repositories.get(handle);
+        if (!repository) {
+            return [];
+        }
+        try {
+            const refs = await repository.getRefs(query, token);
+            const result = ( refs.map(ref => {
+                if (!ref.name || !ref.commit) {
+                    return undefined;
+                }
+                const id = ref.type === GitRefType.Head ? `refs/heads/${ref.name}` : ref.type === GitRefType.RemoteHead ? `refs/remotes/${ref.remote}/${ref.name}` : `refs/tags/${ref.name}`;
+                return {
+                    id,
+                    name: ref.name,
+                    type: toGitRefTypeDto(ref.type),
+                    revision: ref.commit
+                };
+            }));
+            return result.filter(ref => !!ref);
+        } catch {
+            return [];
+        }
+    }
+    async $getRepositoryState(handle) {
+        const repository = this._repositories.get(handle);
+        if (!repository) {
+            return undefined;
+        }
+        const state = repository.state;
+        return {
+            HEAD: state.HEAD ? toGitBranchDto(state.HEAD) : undefined
+        };
+    }
+    async _ensureGitApi() {
+        if (this._gitApi) {
+            return this._gitApi;
+        }
+        try {
+            await this._extHostExtensionService.activateByIdWithErrors(( new ExtensionIdentifier(GIT_EXTENSION_ID)), {
+                startup: false,
+                extensionId: ( new ExtensionIdentifier(GIT_EXTENSION_ID)),
+                activationEvent: "api"
+            });
+            const exports$1 = this._extHostExtensionService.getExtensionExports(( new ExtensionIdentifier(GIT_EXTENSION_ID)));
+            if (!!exports$1 && typeof exports$1.getAPI === "function") {
+                this._gitApi = exports$1.getAPI(1);
+            }
+        } catch {}
+        return this._gitApi;
+    }
+    dispose() {
+        this._disposables.dispose();
+        super.dispose();
+    }
+};
+ExtHostGitExtensionService = ExtHostGitExtensionService_1 = ( __decorate([( __param(0, IExtHostRpcService)), ( __param(1, IExtHostExtensionService))], ExtHostGitExtensionService));
+
+export { ExtHostGitExtensionService, IExtHostGitExtensionService };

package/vscode/src/vs/workbench/api/common/extHostLanguageFeatures.d.ts

@@ -120,6 +120,7 @@ export declare class ExtHostLanguageFeatures extends CoreDisposable implements e
     $freeInlineCompletionsList(handle: number, pid: number, reason: languages.InlineCompletionsDisposeReason): void;
     $acceptInlineCompletionsUnificationState(state: IInlineCompletionsUnificationState): void;
     $handleInlineCompletionSetCurrentModelId(handle: number, modelId: string): void;
+    $handleInlineCompletionSetProviderOption(handle: number, optionId: string, valueId: string): void;
     registerSignatureHelpProvider(extension: IExtensionDescription, selector: vscode.DocumentSelector, provider: vscode.SignatureHelpProvider, metadataOrTriggerChars: string[] | vscode.SignatureHelpProviderMetadata): vscode.Disposable;
     $provideSignatureHelp(handle: number, resource: UriComponents, position: IPosition, context: extHostProtocol.ISignatureHelpContextDto, token: CancellationToken): Promise<extHostProtocol.ISignatureHelpDto | undefined>;
     $releaseSignatureHelp(handle: number, id: number): void;

package/vscode/src/vs/workbench/api/common/extHostLanguageFeatures.js

@@ -574,7 +574,7 @@ class DocumentPasteEditProvider {
         return (edits.map((edit, i) => ({
             _cacheId: [cacheId, i],
             title: edit.title ?? ( localize(
-                2695,
+                2736,
                 "Paste using '{0}' extension",
                 this._extension.displayName || this._extension.name
             )),
@@ -1155,6 +1155,9 @@ class InlineCompletionAdapter {
     get supportsSetModelId() {
         return isProposedApiEnabled(this._extension, "inlineCompletionsAdditions") && typeof this._provider.setCurrentModelId === "function";
     }
+    get supportsSetProviderOption() {
+        return isProposedApiEnabled(this._extension, "inlineCompletionsAdditions") && typeof this._provider.setProviderOptionValue === "function";
+    }
     get modelInfo() {
         if (!this._isAdditionsProposedApiEnabled) {
             return undefined;
@@ -1170,6 +1173,26 @@ class InlineCompletionAdapter {
         }
         this._provider.setCurrentModelId?.(modelId);
     }
+    get providerOptions() {
+        if (!this._isAdditionsProposedApiEnabled) {
+            return undefined;
+        }
+        return this._provider.providerOptions?.map(o => ({
+            id: o.id,
+            label: o.label,
+            values: ( o.values.map(v => ({
+                id: v.id,
+                label: v.label
+            }))),
+            currentValueId: o.currentValueId
+        }));
+    }
+    setProviderOption(optionId, valueId) {
+        if (!this._isAdditionsProposedApiEnabled) {
+            return;
+        }
+        this._provider.setProviderOptionValue?.(optionId, valueId);
+    }
     async provideInlineCompletions(resource, position, context, token) {
         const doc = this._documents.getDocument(resource);
         const pos = Position.to(position);
@@ -1809,7 +1832,7 @@ class DocumentDropEditAdapter {
         return (editsArray.map((edit, i) => ({
             _cacheId: [cacheId, i],
             title: edit.title ?? ( localize(
-                2696,
+                2737,
                 "Drop using '{0}' extension",
                 this._extension.displayName || this._extension.name
             )),
@@ -2494,6 +2517,13 @@ class ExtHostLanguageFeatures extends Disposable {
             );
             result = Disposable$1.from(result, subscription);
         }
+        const supportsOnDidChangeProviderOptions = isProposedApiEnabled(extension, "inlineCompletionsAdditions") && typeof provider.onDidChangeProviderOptions === "function";
+        if (supportsOnDidChangeProviderOptions) {
+            const subscription = provider.onDidChangeProviderOptions(
+                _ => this._proxy.$emitInlineCompletionProviderOptionsChange(handle, adapter.providerOptions)
+            );
+            result = Disposable$1.from(result, subscription);
+        }
         this._proxy.$registerInlineCompletionsSupport(
             handle,
             this._transformDocumentSelector(selector, extension),
@@ -2508,7 +2538,10 @@ class ExtHostLanguageFeatures extends Disposable {
             supportsOnDidChange,
             adapter.supportsSetModelId,
             adapter.modelInfo,
-            supportsOnDidChangeModelInfo
+            supportsOnDidChangeModelInfo,
+            adapter.supportsSetProviderOption,
+            adapter.providerOptions,
+            supportsOnDidChangeProviderOptions
         );
         return result;
     }
@@ -2555,6 +2588,11 @@ class ExtHostLanguageFeatures extends Disposable {
             adapter.setCurrentModelId(modelId);
         }, undefined, undefined);
     }
+    $handleInlineCompletionSetProviderOption(handle, optionId, valueId) {
+        this._withAdapter(handle, InlineCompletionAdapter, async adapter => {
+            adapter.setProviderOption(optionId, valueId);
+        }, undefined, undefined);
+    }
     registerSignatureHelpProvider(extension, selector, provider, metadataOrTriggerChars) {
         const metadata = Array.isArray(metadataOrTriggerChars) ? {
             triggerCharacters: metadataOrTriggerChars,

package/vscode/src/vs/workbench/api/common/extHostLanguageModelTools.js

@@ -146,7 +146,6 @@ class ExtHostLanguageModelTools {
         if (isProposedApiEnabled(item.extension, "chatParticipantPrivate")) {
             options.chatRequestId = dto.chatRequestId;
             options.chatInteractionId = dto.chatInteractionId;
-            options.chatSessionId = dto.context?.sessionId;
             options.chatSessionResource = URI.revive(dto.context?.sessionResource);
             options.subAgentInvocationId = dto.subAgentInvocationId;
         }
@@ -208,7 +207,6 @@ class ExtHostLanguageModelTools {
         const options = {
             rawInput: context.rawInput,
             chatRequestId: context.chatRequestId,
-            chatSessionId: context.chatSessionId,
             chatSessionResource: context.chatSessionResource,
             chatInteractionId: context.chatInteractionId
         };
@@ -228,7 +226,6 @@ class ExtHostLanguageModelTools {
         const options = {
             input: context.parameters,
             chatRequestId: context.chatRequestId,
-            chatSessionId: context.chatSessionId,
             chatSessionResource: context.chatSessionResource,
             chatInteractionId: context.chatInteractionId,
             forceConfirmationReason: context.forceConfirmationReason

package/vscode/src/vs/workbench/api/common/extHostLanguageModels.js

@@ -180,12 +180,14 @@ let ExtHostLanguageModels = class ExtHostLanguageModels {
                     tooltip: m.tooltip,
                     version: m.version,
                     multiplier: m.multiplier,
+                    multiplierNumeric: m.multiplierNumeric,
                     maxInputTokens: m.maxInputTokens,
                     maxOutputTokens: m.maxOutputTokens,
                     auth,
                     isDefaultForLocation,
                     isUserSelectable: m.isUserSelectable,
                     statusIcon: m.statusIcon,
+                    targetChatSessionType: m.targetChatSessionType,
                     modelPickerCategory: m.category ?? DEFAULT_MODEL_PICKER_CATEGORY,
                     capabilities: m.capabilities ? {
                         vision: m.capabilities.imageInput,
@@ -317,7 +319,7 @@ let ExtHostLanguageModels = class ExtHostLanguageModels {
             await this.selectLanguageModels(extension, {});
         }
         for (const [modelIdentifier, modelData] of this._localModels) {
-            if (modelData.metadata.isDefaultForLocation[ChatAgentLocation.Chat]) {
+            if (modelData.metadata.isDefaultForLocation[ChatAgentLocation.Chat] && modelData.metadata.vendor === "copilot") {
                 defaultModelId = modelIdentifier;
                 break;
             }
@@ -486,7 +488,7 @@ let ExtHostLanguageModels = class ExtHostLanguageModels {
             return false;
         }
         try {
-            const detail = justification ? ( localize(2697, "Justification: {1}", to.displayName, justification)) : undefined;
+            const detail = justification ? ( localize(2738, "Justification: {1}", to.displayName, justification)) : undefined;
             await this._extHostAuthentication.getSession(from, providerId, [], {
                 forceNewSession: {
                     detail

package/vscode/src/vs/workbench/api/common/extHostLogService.js

@@ -8,7 +8,7 @@ import { IExtHostInitDataService } from './extHostInitDataService.js';
 let ExtHostLogService = class ExtHostLogService extends LogService {
     constructor(isWorker, loggerService, initData) {
         const id = initData.remote.isRemote ? "remoteexthost" : isWorker ? "workerexthost" : "exthost";
-        const name = initData.remote.isRemote ? ( localize(2698, "Extension Host (Remote)")) : isWorker ? ( localize(2699, "Extension Host (Worker)")) : ( localize(2700, "Extension Host"));
+        const name = initData.remote.isRemote ? ( localize(2739, "Extension Host (Remote)")) : isWorker ? ( localize(2740, "Extension Host (Worker)")) : ( localize(2741, "Extension Host"));
         super(loggerService.createLogger(id, {
             name
         }));

package/vscode/src/vs/workbench/api/common/extHostMcp.d.ts

@@ -19,6 +19,8 @@ export interface IExtHostMpcService extends ExtHostMcpShape {
     readonly onDidChangeMcpServerDefinitions: Event<void>;
     /** Returns all MCP server definitions known to the editor. */
     readonly mcpServerDefinitions: readonly vscode.McpServerDefinition[];
+    /** Starts an MCP gateway that exposes MCP servers via an HTTP endpoint. */
+    startMcpGateway(): Promise<vscode.McpGateway | undefined>;
 }
 export declare class ExtHostMcpService extends Disposable implements IExtHostMpcService {
     protected readonly _logService: ILogService;
@@ -47,6 +49,8 @@ export declare class ExtHostMcpService extends Disposable implements IExtHostMpc
     $resolveMcpLaunch(collectionId: string, label: string): Promise<McpServerLaunch.Serialized | undefined>;
     /** {@link vscode.lm.registerMcpServerDefinitionProvider} */
     registerMcpConfigurationProvider(extension: IExtensionDescription, id: string, provider: vscode.McpServerDefinitionProvider): IDisposable;
+    /** {@link vscode.lm.startMcpGateway} */
+    startMcpGateway(): Promise<vscode.McpGateway | undefined>;
 }
 /**
  * Implementation of both MCP HTTP Streaming as well as legacy SSE.

package/vscode/src/vs/workbench/api/common/extHostMcp.js

@@ -17,7 +17,7 @@ import { ILogService } from '../../../platform/log/common/log.service.js';
 import product from '../../../platform/product/common/product.js';
 import { StorageScope } from '../../../platform/storage/common/storage.js';
 import { McpServerLaunch, McpServerTransportType, extensionPrefixedIdentifier, McpServerStaticToolAvailability, McpConnectionState, UserInteractionRequiredError } from '../../contrib/mcp/common/mcpTypes.js';
-import { MCP } from '../../contrib/mcp/common/modelContextProtocol.js';
+import { MCP } from '../../../platform/mcp/common/modelContextProtocol.js';
 import { checkProposedApiEnabled, isProposedApiEnabled } from '../../services/extensions/common/extensions.js';
 import { MainContext, IAuthResourceMetadataSource, IAuthServerMetadataSource } from './extHost.protocol.js';
 import { IExtHostInitDataService } from './extHostInitDataService.js';
@@ -206,6 +206,20 @@ let ExtHostMcpService = class ExtHostMcpService extends Disposable {
         this._initialProviderPromises.add(promise);
         return store;
     }
+    async startMcpGateway() {
+        const result = await this._proxy.$startMcpGateway();
+        if (!result) {
+            return undefined;
+        }
+        const address = URI.revive(result.address);
+        const gatewayId = result.gatewayId;
+        return {
+            address,
+            dispose: () => {
+                this._proxy.$disposeMcpGateway(gatewayId);
+            }
+        };
+    }
 };
 ExtHostMcpService = ( __decorate([( __param(0, IExtHostRpcService)), ( __param(1, ILogService)), ( __param(2, IExtHostInitDataService)), ( __param(3, IExtHostWorkspace)), ( __param(4, IExtHostVariableResolverProvider))], ExtHostMcpService));
 var HttpMode;

package/vscode/src/vs/workbench/api/common/extHostMeteredConnection.d.ts

@@ -0,0 +1,19 @@
+import { Event } from "../../../base/common/event.js";
+import { Disposable } from "../../../base/common/lifecycle.js";
+import { ExtHostMeteredConnectionShape } from "./extHost.protocol.js";
+export interface IExtHostMeteredConnection extends ExtHostMeteredConnectionShape {
+    readonly _serviceBrand: undefined;
+    readonly isConnectionMetered: boolean;
+    readonly onDidChangeIsConnectionMetered: Event<boolean>;
+}
+export declare const IExtHostMeteredConnection: import("../../../platform/instantiation/common/instantiation.js").ServiceIdentifier<IExtHostMeteredConnection>;
+export declare class ExtHostMeteredConnection extends Disposable implements IExtHostMeteredConnection, ExtHostMeteredConnectionShape {
+    readonly _serviceBrand: undefined;
+    private _isConnectionMetered;
+    private readonly _onDidChangeIsConnectionMetered;
+    readonly onDidChangeIsConnectionMetered: Event<boolean>;
+    constructor();
+    get isConnectionMetered(): boolean;
+    $initializeIsConnectionMetered(isMetered: boolean): void;
+    $onDidChangeIsConnectionMetered(isMetered: boolean): void;
+}

package/vscode/src/vs/workbench/api/common/extHostMeteredConnection.js

@@ -0,0 +1,28 @@
+
+import { Emitter } from '../../../base/common/event.js';
+import { Disposable } from '../../../base/common/lifecycle.js';
+import { createDecorator } from '../../../platform/instantiation/common/instantiation.js';
+
+const IExtHostMeteredConnection = ( createDecorator("IExtHostMeteredConnection"));
+class ExtHostMeteredConnection extends Disposable {
+    constructor() {
+        super();
+        this._isConnectionMetered = false;
+        this._onDidChangeIsConnectionMetered = this._register(( new Emitter()));
+        this.onDidChangeIsConnectionMetered = this._onDidChangeIsConnectionMetered.event;
+    }
+    get isConnectionMetered() {
+        return this._isConnectionMetered;
+    }
+    $initializeIsConnectionMetered(isMetered) {
+        this._isConnectionMetered = isMetered;
+    }
+    $onDidChangeIsConnectionMetered(isMetered) {
+        if (this._isConnectionMetered !== isMetered) {
+            this._isConnectionMetered = isMetered;
+            this._onDidChangeIsConnectionMetered.fire(isMetered);
+        }
+    }
+}
+
+export { ExtHostMeteredConnection, IExtHostMeteredConnection };

package/vscode/src/vs/workbench/api/common/extHostNotebook.js

@@ -276,7 +276,7 @@ class ExtHostNotebookController {
                 ));
             }
             if (!this._extHostFileSystem.value.isWritableFileSystem(uri.scheme)) {
-                throw new FileOperationError(( localize(2701, "Unable to modify read-only file '{0}'", this._resourceForError(uri))), FileOperationResult.FILE_PERMISSION_DENIED);
+                throw new FileOperationError(( localize(2742, "Unable to modify read-only file '{0}'", this._resourceForError(uri))), FileOperationResult.FILE_PERMISSION_DENIED);
             }
             const data = {
                 metadata: filter(
@@ -472,7 +472,7 @@ class ExtHostNotebookController {
             mtime: options.mtime ,
             size: stat.size
         })) {
-            throw new FileOperationError(( localize(2702, "File Modified Since")), FileOperationResult.FILE_MODIFIED_SINCE, options);
+            throw new FileOperationError(( localize(2743, "File Modified Since")), FileOperationResult.FILE_MODIFIED_SINCE, options);
         }
         return;
     }

package/vscode/src/vs/workbench/api/common/extHostNotebookKernels.js

@@ -122,6 +122,7 @@ let ExtHostNotebookKernels = class ExtHostNotebookKernels {
         let _executeHandler = handler ?? _defaultExecutHandler;
         let _interruptHandler;
         let _variableProvider;
+        let _variableProviderDisposable;
         this._proxy.$addKernel(handle, data).catch(err => {
             console.log(err);
             isDisposed = true;
@@ -201,9 +202,10 @@ let ExtHostNotebookKernels = class ExtHostNotebookKernels {
             },
             set variableProvider(value) {
                 checkProposedApiEnabled(extension, "notebookVariableProvider");
+                _variableProviderDisposable?.dispose();
                 _variableProvider = value;
                 data.hasVariableProvider = !!value;
-                value?.onDidChangeVariables(e => that._proxy.$variablesUpdated(e.uri));
+                _variableProviderDisposable = value?.onDidChangeVariables(e => that._proxy.$variablesUpdated(e.uri));
                 _update();
             },
             get variableProvider() {
@@ -243,6 +245,7 @@ let ExtHostNotebookKernels = class ExtHostNotebookKernels {
                     this._kernelData.delete(handle);
                     onDidChangeSelection.dispose();
                     onDidReceiveMessage.dispose();
+                    _variableProviderDisposable?.dispose();
                     this._proxy.$removeKernel(handle);
                 }
             },
@@ -510,7 +513,7 @@ class NotebookCellExecutionTask extends Disposable {
         this._cell = _cell;
         this._proxy = _proxy;
         this._handle = NotebookCellExecutionTask.HANDLE++;
-        this._onDidChangeState = ( new Emitter());
+        this._onDidChangeState = this._register(( new Emitter()));
         this.onDidChangeState = this._onDidChangeState.event;
         this._state = NotebookCellExecutionTaskState.Init;
         this._tokenSource = this._register(( new CancellationTokenSource()));
@@ -685,7 +688,7 @@ class NotebookExecutionTask extends Disposable {
         this._notebook = _notebook;
         this._proxy = _proxy;
         this._handle = NotebookExecutionTask.HANDLE++;
-        this._onDidChangeState = ( new Emitter());
+        this._onDidChangeState = this._register(( new Emitter()));
         this.onDidChangeState = this._onDidChangeState.event;
         this._state = NotebookExecutionTaskState.Init;
         this._tokenSource = this._register(( new CancellationTokenSource()));

package/vscode/src/vs/workbench/api/common/extHostPower.d.ts

@@ -0,0 +1,45 @@
+import { Event } from "../../../base/common/event.js";
+import { Disposable } from "../../../base/common/lifecycle.js";
+import { IExtHostRpcService } from "./extHostRpcService.js";
+import { ExtHostPowerShape, PowerSaveBlockerType, PowerSystemIdleState, PowerThermalState } from "./extHost.protocol.js";
+export declare class ExtHostPower extends Disposable implements ExtHostPowerShape {
+    _serviceBrand: undefined;
+    private readonly _proxy;
+    private readonly _onDidSuspend;
+    readonly onDidSuspend: Event<void>;
+    private readonly _onDidResume;
+    readonly onDidResume: Event<void>;
+    private readonly _onDidChangeOnBatteryPower;
+    readonly onDidChangeOnBatteryPower: Event<boolean>;
+    private readonly _onDidChangeThermalState;
+    readonly onDidChangeThermalState: Event<PowerThermalState>;
+    private readonly _onDidChangeSpeedLimit;
+    readonly onDidChangeSpeedLimit: Event<number>;
+    private readonly _onWillShutdown;
+    readonly onWillShutdown: Event<void>;
+    private readonly _onDidLockScreen;
+    readonly onDidLockScreen: Event<void>;
+    private readonly _onDidUnlockScreen;
+    readonly onDidUnlockScreen: Event<void>;
+    constructor(extHostRpc: IExtHostRpcService);
+    $onDidSuspend(): void;
+    $onDidResume(): void;
+    $onDidChangeOnBatteryPower(isOnBattery: boolean): void;
+    $onDidChangeThermalState(state: PowerThermalState): void;
+    $onDidChangeSpeedLimit(limit: number): void;
+    $onWillShutdown(): void;
+    $onDidLockScreen(): void;
+    $onDidUnlockScreen(): void;
+    getSystemIdleState(idleThresholdSeconds: number): Promise<PowerSystemIdleState>;
+    getSystemIdleTime(): Promise<number>;
+    getCurrentThermalState(): Promise<PowerThermalState>;
+    isOnBatteryPower(): Promise<boolean>;
+    startPowerSaveBlocker(type: PowerSaveBlockerType): Promise<{
+        id: number;
+        isStarted: boolean;
+        dispose: () => void;
+    }>;
+}
+export declare const IExtHostPower: import("../../../platform/instantiation/common/instantiation.js").ServiceIdentifier<IExtHostPower>;
+export interface IExtHostPower extends ExtHostPower, ExtHostPowerShape {
+}

package/vscode/src/vs/workbench/api/common/extHostPower.js

@@ -0,0 +1,88 @@
+
+import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
+import { Emitter } from '../../../base/common/event.js';
+import { Disposable } from '../../../base/common/lifecycle.js';
+import { createDecorator } from '../../../platform/instantiation/common/instantiation.js';
+import { IExtHostRpcService } from './extHostRpcService.js';
+import { MainContext } from './extHost.protocol.js';
+
+let ExtHostPower = class ExtHostPower extends Disposable {
+    constructor(extHostRpc) {
+        super();
+        this._onDidSuspend = this._register(( new Emitter()));
+        this.onDidSuspend = this._onDidSuspend.event;
+        this._onDidResume = this._register(( new Emitter()));
+        this.onDidResume = this._onDidResume.event;
+        this._onDidChangeOnBatteryPower = this._register(( new Emitter()));
+        this.onDidChangeOnBatteryPower = this._onDidChangeOnBatteryPower.event;
+        this._onDidChangeThermalState = this._register(( new Emitter()));
+        this.onDidChangeThermalState = this._onDidChangeThermalState.event;
+        this._onDidChangeSpeedLimit = this._register(( new Emitter()));
+        this.onDidChangeSpeedLimit = this._onDidChangeSpeedLimit.event;
+        this._onWillShutdown = this._register(( new Emitter()));
+        this.onWillShutdown = this._onWillShutdown.event;
+        this._onDidLockScreen = this._register(( new Emitter()));
+        this.onDidLockScreen = this._onDidLockScreen.event;
+        this._onDidUnlockScreen = this._register(( new Emitter()));
+        this.onDidUnlockScreen = this._onDidUnlockScreen.event;
+        this._proxy = ( extHostRpc.getProxy(MainContext.MainThreadPower));
+    }
+    $onDidSuspend() {
+        this._onDidSuspend.fire();
+    }
+    $onDidResume() {
+        this._onDidResume.fire();
+    }
+    $onDidChangeOnBatteryPower(isOnBattery) {
+        this._onDidChangeOnBatteryPower.fire(isOnBattery);
+    }
+    $onDidChangeThermalState(state) {
+        this._onDidChangeThermalState.fire(state);
+    }
+    $onDidChangeSpeedLimit(limit) {
+        this._onDidChangeSpeedLimit.fire(limit);
+    }
+    $onWillShutdown() {
+        this._onWillShutdown.fire();
+    }
+    $onDidLockScreen() {
+        this._onDidLockScreen.fire();
+    }
+    $onDidUnlockScreen() {
+        this._onDidUnlockScreen.fire();
+    }
+    getSystemIdleState(idleThresholdSeconds) {
+        return this._proxy.$getSystemIdleState(idleThresholdSeconds);
+    }
+    getSystemIdleTime() {
+        return this._proxy.$getSystemIdleTime();
+    }
+    getCurrentThermalState() {
+        return this._proxy.$getCurrentThermalState();
+    }
+    isOnBatteryPower() {
+        return this._proxy.$isOnBatteryPower();
+    }
+    async startPowerSaveBlocker(type) {
+        const id = await this._proxy.$startPowerSaveBlocker(type);
+        const proxy = this._proxy;
+        const isSupported = id >= 0;
+        let disposed = false;
+        return {
+            id,
+            get isStarted() {
+                return isSupported && !disposed;
+            },
+            dispose: () => {
+                if (isSupported && !disposed) {
+                    disposed = true;
+                    proxy.$stopPowerSaveBlocker(id);
+                }
+            }
+        };
+    }
+};
+ExtHostPower = ( __decorate([( __param(0, IExtHostRpcService))], ExtHostPower));
+const IExtHostPower = ( createDecorator("IExtHostPower"));
+
+export { ExtHostPower, IExtHostPower };

package/vscode/src/vs/workbench/api/common/extHostSCM.js

@@ -483,6 +483,8 @@ class ExtHostSourceControlResourceGroup {
     dispose() {
         this._disposed = true;
         this._onDidDispose.fire();
+        this._onDidUpdateResourceStates.dispose();
+        this._onDidDispose.dispose();
     }
 }
 class ExtHostSourceControl {
@@ -839,6 +841,7 @@ class ExtHostSourceControl {
         this._artifactCommandsDisposables.dispose();
         this._groups.forEach(group => group.dispose());
         this.#proxy.$unregisterSourceControl(this.handle);
+        this._onDidChangeSelection.dispose();
         this._onDidDispose.fire();
         this._onDidDispose.dispose();
     }