src/vs/platform/agentHost/node/agentHostChangesetOperationService.ts
234 LOC · 196 covered · 38 uncovered · 49 ranges · 927 concepts · 14 introducers · 488 tests
File neighbourhood
The centred file is linked to every concept that introduces one of its ranges, every test that runs code from the file, and the gray connector concepts standing between those tests and the file's own introducer concepts. Undirected links join concepts to every file where they introduce source and concepts to the tests they introduce; arrows show specialization between the displayed concepts and bridge only concepts omitted from this view. Concept colors match the source ranges below; connector concepts have no source color and are shown in gray.
Focused file, its introducer and connector concepts, their introduced files, and tests that run code from the file
In the embedded map, ordinary wheel input scrolls the page; use the visible controls to zoom and drag to pan. Open the full-screen map for canvas navigation: wheel pans, Ctrl/Command plus wheel zooms, and arrow keys pan when this region is focused. On touch screens, open the full-screen map to pan or pinch. If JavaScript or WebGL is unavailable, use the related-file, concept, and source links on this page.
Graph controls are ready.
Interactive rendering requires JavaScript and WebGL. Use the related-file, concept, and source links on this page while the interactive map is unavailable.
1
>
/*---------------------------------------------------------------------------------------------
agentHostChangesetOperationService.ts ×9
2
>
* Copyright (c) Microsoft Corporation. All rights reserved.
3
>
* Licensed under the MIT License. See License.txt in the project root for license information.
4
>
*--------------------------------------------------------------------------------------------*/
5
>
6
>
import { CancellationToken } from '../../../base/common/cancellation.js';
7
>
import { toErrorMessage } from '../../../base/common/errorMessage.js';
8
>
import { Disposable, DisposableMap, toDisposable, type IDisposable } from '../../../base/common/lifecycle.js';
9
>
import { parseChangesetUri } from '../common/changesetUri.js';
10
>
import type { InvokeChangesetOperationParams, InvokeChangesetOperationResult } from '../common/state/protocol/channels-changeset/commands.js';
11
>
import { AHP_SESSION_NOT_FOUND, JsonRpcErrorCodes, ProtocolError } from '../common/state/sessionProtocol.js';
12
>
import { ActionType } from '../common/state/sessionActions.js';
13
>
import { ChangesetOperationScope, ChangesetOperationStatus, ChangesetOperationTargetKind, ISessionGitHubState, readSessionGitHubState, readSessionGitState, type ChangesetOperation, type ErrorInfo, type ISessionGitState } from '../common/state/sessionState.js';
14
>
import type { IChangesetOperationContribution, IAgentHostChangesetOperationService, IChangesetOperationContext, IChangesetOperationHandler, IChangesetOperationRegistry } from '../common/agentHostChangesetOperationService.js';
15
>
import { AgentHostStateManager, IAgentHostStateManager } from './agentHostStateManager.js';
16
>
import { IAgentHostChangesetSubscriptionService } from '../common/agentHostChangesetSubscriptionService.js';
17
>
import { IAgentHostGitStateService } from '../common/agentHostGitStateService.js';
18
>
19
>
export class AgentHostChangesetOperationService extends Disposable implements IAgentHostChangesetOperationService {
20
>
declare readonly _serviceBrand: undefined;
21
>
22
>
private readonly _registry: IChangesetOperationRegistry;
23
>
private readonly _handlerRegistrations = this._register(new DisposableMap<IChangesetOperationContribution>());
24
>
private readonly _changesetOperationHandlers = new Map<string, IChangesetOperationHandler>();
25
>
private readonly _inFlightOperations = new Map<string, Promise<InvokeChangesetOperationResult>>();
26
>
27
>
constructor(
28
>
@IAgentHostStateManager private readonly _stateManager: AgentHostStateManager,
agentHostChangesetOperationService.ts ×5
29
>
@IAgentHostGitStateService private readonly _gitStateService: IAgentHostGitStateService,
30
>
@IAgentHostChangesetSubscriptionService private readonly _changesetSubscriptions: IAgentHostChangesetSubscriptionService,
31
>
) {
32
>
super();
33
>
34
>
this._registry = {
35
>
registerChangesetOperationHandler: (operationId, handler) => this._registerChangesetOperationHandler(operationId, handler),
36
>
refreshSessionGitState: sessionKey => this._gitStateService.refreshSessionGitState(sessionKey),
37
>
onDidChangeOperations: sessionKey => this.updateOperations(sessionKey),
38
>
};
39
>
}
41
>
registerContribution(contribution: IChangesetOperationContribution): IDisposable {
43
throw new Error('Changeset operation contribution already registered');
44
}
45
>
this._handlerRegistrations.set(contribution, contribution.registerHandlers(this._registry));
agentHostChangesetOperationService.ts ×5
46
>
return toDisposable(() => {
47
>
this._handlerRegistrations.deleteAndDispose(contribution);
48
>
contribution.dispose();
49
>
});
50
>
}
52
>
getOperations(sessionKey: string, changeset: string, gitState?: ISessionGitState, gitHubState?: ISessionGitHubState): readonly ChangesetOperation[] {
54
>
const sessionState = this._stateManager.getSessionState(sessionKey);
55
>
gitState = readSessionGitState(sessionState?._meta);
56
>
if (!gitState) {
58
>
}
61
>
if (!gitHubState) {
62
>
gitHubState = readSessionGitHubState(this._stateManager.getSessionState(sessionKey)?._meta);
63
>
}
64
>
65
>
const parsed = parseChangesetUri(changeset);
66
>
if (!parsed) {
67
return [];
68
}
70
>
return this._getOperations({
71
>
sessionKey,
72
>
changesetUri: changeset,
73
>
changesetKind: parsed.kind,
74
>
gitState,
75
>
gitHubState
76
>
});
79
>
private _getOperations(context: IChangesetOperationContext): readonly ChangesetOperation[] {
81
>
for (const contribution of this._handlerRegistrations.keys()) {
82
>
const contributed = contribution.getOperations(context);
83
>
if (contributed) {
84
>
operations.push(...contributed);
85
>
}
86
>
}
87
>
88
>
// Operations are disabled while a turn is active so the working tree /
89
>
// branch state can't be mutated mid-request.
90
>
if (this._stateManager.hasActiveTurn(context.sessionKey)) {
91
return operations.map(operation => ({
92
...operation,
93
status: ChangesetOperationStatus.Disabled
94
}));
95
}
97
>
return operations;
98
>
}
100
>
updateOperations(sessionKey: string, changeset?: string, gitState?: ISessionGitState, gitHubState?: ISessionGitHubState): void {
102
>
const sessionState = this._stateManager.getSessionState(sessionKey);
103
>
gitState = readSessionGitState(sessionState?._meta);
104
>
if (!gitState) {
105
>
return;
106
>
}
107
>
}
108
109
if (!gitHubState) {
110
const sessionState = this._stateManager.getSessionState(sessionKey);
111
gitHubState = readSessionGitHubState(sessionState?._meta);
112
}
113
114
const changesets = changeset
115
? [changeset]
116
: this._changesetSubscriptions.getSessionSubscriptions(sessionKey);
118
>
for (const changeset of changesets) {
119
const operations = this.getOperations(sessionKey, changeset, gitState, gitHubState);
120
121
this._stateManager.dispatchServerAction(changeset, {
122
type: ActionType.ChangesetOperationsChanged,
123
operations: [...operations],
124
});
125
}
128
>
async invokeChangesetOperation(params: InvokeChangesetOperationParams): Promise<InvokeChangesetOperationResult> {
129
>
const state = this._stateManager.getChangesetState(params.channel);
agentHostChangesetOperationService.ts ×7
130
>
if (!state) {
131
throw new ProtocolError(AHP_SESSION_NOT_FOUND, `Changeset not found: ${params.channel}`);
132
}
133
>
const op = state.operations?.find(o => o.id === params.operationId);
agentHostChangesetOperationService.ts ×7
134
>
if (!op) {
135
throw new ProtocolError(JsonRpcErrorCodes.InvalidParams, `Unknown operation '${params.operationId}' on changeset ${params.channel}`);
136
}
137
>
if (op.status === ChangesetOperationStatus.Disabled) {
agentHostChangesetOperationService.ts ×7
138
>
throw new ProtocolError(JsonRpcErrorCodes.InvalidParams, `Operation '${params.operationId}' is disabled on changeset ${params.channel}`);
agentHostChangesetOperationService.ts ×1
139
>
}
141
>
// Enforce the active-turn gate at invocation time too, independent of
142
>
// the advertised operation status. A ChangesetOperationStatusChanged
143
>
// action (e.g. a previously running operation finishing) can reset the
144
>
// status back to Idle while a chat turn is still streaming, which would
145
>
// otherwise re-enable invocation mid-turn and let the working tree /
146
>
// branch state be mutated.
147
>
const parsed = parseChangesetUri(params.channel);
148
>
if (parsed && this._stateManager.hasActiveTurn(parsed.sessionUri)) {
agentHostChangesetOperationService.ts ×7
149
>
throw new ProtocolError(JsonRpcErrorCodes.InvalidParams, `Operation '${params.operationId}' is disabled while a turn is active on changeset ${params.channel}`);
agentHostChangesetOperationService.ts ×1
150
>
}
152
>
const targetKind: ChangesetOperationScope = params.target?.kind === ChangesetOperationTargetKind.Resource
agentHostChangesetOperationService.ts ×7
153
? ChangesetOperationScope.Resource
154
>
: params.target?.kind === ChangesetOperationTargetKind.Range
agentHostChangesetOperationService.ts ×9
155
? ChangesetOperationScope.Range
158
throw new ProtocolError(JsonRpcErrorCodes.InvalidParams, `Operation '${params.operationId}' does not support scope '${targetKind}' (allowed: ${op.scopes.join(', ')})`);
159
}
161
>
const handler = this._changesetOperationHandlers.get(params.operationId);
162
>
if (!handler) {
163
throw new ProtocolError(JsonRpcErrorCodes.InternalError, `No operation handler registered for '${params.operationId}' on changeset ${params.channel}`);
164
}
166
>
return this._invokeChangesetOperation(handler, params);
169
>
private _invokeChangesetOperation(
171
>
params: InvokeChangesetOperationParams,
172
>
): Promise<InvokeChangesetOperationResult> {
173
>
const operationKey = `${params.channel}\x00${params.operationId}\x00${JSON.stringify(params.target ?? null)}`;
174
>
const inFlightOperationResult = this._inFlightOperations.get(operationKey);
175
>
if (inFlightOperationResult) {
177
>
}
179
>
this._stateManager.dispatchServerAction(params.channel, {
180
>
type: ActionType.ChangesetOperationStatusChanged,
181
>
operationId: params.operationId,
182
>
status: ChangesetOperationStatus.Running,
183
>
});
184
>
185
>
const operationPromise = handler.invoke(params, CancellationToken.None)
186
>
.then(result => {
187
>
this._stateManager.dispatchServerAction(params.channel, {
agentHostChangesetOperationService.ts ×1
188
>
type: ActionType.ChangesetOperationStatusChanged,
189
>
operationId: params.operationId,
190
>
status: ChangesetOperationStatus.Idle,
191
>
});
192
>
193
>
return result;
195
>
.catch((error) => {
196
>
this._stateManager.dispatchServerAction(params.channel, {
agentHostChangesetOperationService.ts ×3
197
>
type: ActionType.ChangesetOperationStatusChanged,
198
>
operationId: params.operationId,
199
>
status: ChangesetOperationStatus.Error,
200
>
error: toChangesetOperationError(error),
201
>
});
202
>
203
>
throw error;
205
>
.finally(() => {
206
>
if (this._inFlightOperations.get(operationKey) === operationPromise) {
207
>
this._inFlightOperations.delete(operationKey);
208
>
}
209
>
});
210
>
211
>
this._inFlightOperations.set(operationKey, operationPromise);
212
>
213
>
return operationPromise;
214
>
}
216
>
private _registerChangesetOperationHandler(operationId: string, handler: IChangesetOperationHandler): IDisposable {
217
>
if (this._changesetOperationHandlers.has(operationId)) {
agentHostChangesetOperationService.ts ×5
218
throw new Error(`Changeset operation handler already registered for '${operationId}'`);
219
}
220
>
this._changesetOperationHandlers.set(operationId, handler);
agentHostChangesetOperationService.ts ×5
221
>
return toDisposable(() => {
222
>
if (this._changesetOperationHandlers.get(operationId) === handler) {
223
>
this._changesetOperationHandlers.delete(operationId);
224
>
}
225
>
});
226
>
}
228
>
229
>
function toChangesetOperationError(error: unknown): ErrorInfo {
agentHostChangesetOperationService.ts ×3
230
>
const message = toErrorMessage(error);
231
>
return error instanceof Error
232
>
? { errorType: error.name, message, stack: error.stack }
233
: { errorType: 'Error', message };