src/vs/platform/agentHost/node/localCommands/bangLocalCommand.ts
160 LOC · 139 covered · 21 uncovered · 20 ranges · 1049 concepts · 5 introducers · 506 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
>
/*---------------------------------------------------------------------------------------------
agentSideEffects.ts ×51
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 { Disposable, toDisposable } from '../../../../base/common/lifecycle.js';
7
>
import { URI } from '../../../../base/common/uri.js';
8
>
import { generateUuid } from '../../../../base/common/uuid.js';
9
>
import { localize } from '../../../../nls.js';
10
>
import type { CreateTerminalParams } from '../../common/state/protocol/commands.js';
11
>
import { TerminalClaimKind, type TerminalSessionClaim } from '../../common/state/protocol/state.js';
12
>
import { ActionType } from '../../common/state/sessionActions.js';
13
>
import { isAhpChatChannel, parseRequiredSessionUriFromChatUri, ToolCallConfirmationReason, ToolResultContentType, type ToolResultContent, type URI as ProtocolURI } from '../../common/state/sessionState.js';
14
>
import { parseBangCommand } from '../agentHostBangCommand.js';
15
>
import { DEFAULT_SHELL_COMMAND_TIMEOUT_MS, executeShellCommand, shellTypeForExecutable, type IShellCommandResult } from '../shared/shellCommandExecution.js';
16
>
import { ILocalChatCommand, ILocalChatCommandContext, ILocalChatCommandHandling, ILocalChatCommandRequest, LocalChatCommandRegistry } from './localChatCommand.js';
17
>
18
>
/**
19
>
* The generic `!command` command: runs the message as a terminal command via
20
>
* the {@link IAgentHostTerminalManager} shell integration and surfaces it as a
21
>
* terminal tool call in the transcript, instead of forwarding it to the agent
22
>
* SDK. Runs immediately (the user typed it explicitly — no confirmation).
23
>
*/
24
>
export class BangLocalCommand extends Disposable implements ILocalChatCommand {
25
>
26
>
readonly name = 'bang';
27
>
readonly recordsLocalTurn = true;
28
>
29
>
/** Terminals kept alive for transcript output; disposed with this command. */
30
>
private readonly _terminals = new Set<string>();
31
>
32
>
constructor(private readonly _context: ILocalChatCommandContext) {
34
>
this._register(toDisposable(() => {
35
>
for (const terminalUri of this._terminals) {
37
>
}
39
>
}));
40
>
}
42
>
tryHandle(request: ILocalChatCommandRequest): ILocalChatCommandHandling | undefined {
44
>
if (command === undefined) {
46
>
}
47
>
// The raw command doubles as a provisional title so a brand-new session
bangLocalCommand.ts ×10
48
>
// isn't left untitled until the first real (non-command) request.
49
>
return { run: () => this._run(request.turnChannel, request.turnId, command), suggestedTitle: command };
52
>
private async _run(turnChannel: ProtocolURI, turnId: string, command: string): Promise<void> {
54
>
const sessionChannel = isAhpChatChannel(turnChannel) ? parseRequiredSessionUriFromChatUri(turnChannel) : turnChannel;
55
>
const toolCallId = generateUuid();
56
>
const terminalUri = `agenthost-terminal://bang/${generateUuid()}`;
57
>
const displayName = localize('agentHostBang.terminal', "Terminal");
58
>
let terminalCreated = false;
59
>
try {
60
>
const workingDirStr = ctx.getState(sessionChannel)?.workingDirectories?.[0];
61
>
const cwd = workingDirStr ? URI.parse(workingDirStr).fsPath : undefined;
62
>
const shellPath = await ctx.terminalManager.getDefaultShell();
63
>
const shellType = shellTypeForExecutable(shellPath);
64
>
65
>
// Surface the command as a tool call and transition it straight to
66
>
// running — the user typed it explicitly, so no confirmation.
67
>
ctx.dispatch(turnChannel, {
68
>
type: ActionType.ChatToolCallStart,
69
>
turnId,
70
>
toolCallId,
71
>
toolName: 'terminal',
72
>
displayName,
73
>
intention: command,
74
>
});
75
>
ctx.dispatch(turnChannel, {
76
>
type: ActionType.ChatToolCallReady,
77
>
turnId,
78
>
toolCallId,
79
>
invocationMessage: command,
80
>
toolInput: command,
81
>
confirmed: ToolCallConfirmationReason.NotNeeded,
82
>
});
83
>
84
>
const claim: TerminalSessionClaim = {
85
>
kind: TerminalClaimKind.Session,
86
>
session: sessionChannel,
87
>
turnId,
88
>
toolCallId,
89
>
};
90
>
const params: CreateTerminalParams = { channel: terminalUri, claim, name: displayName, cwd };
91
>
await ctx.terminalManager.createTerminal(params, { shell: shellPath, preventShellHistory: true, nonInteractive: true });
92
>
terminalCreated = true;
93
>
this._terminals.add(terminalUri);
94
>
95
>
// Reference the terminal so the client can stream live output while
96
>
// the command runs.
97
>
const terminalContent: ToolResultContent = { type: ToolResultContentType.Terminal, resource: terminalUri, title: displayName };
98
>
ctx.dispatch(turnChannel, {
99
>
type: ActionType.ChatToolCallContentChanged,
100
>
turnId,
101
>
toolCallId,
102
>
content: [terminalContent],
103
>
});
104
>
105
>
const result = await executeShellCommand({ terminalUri, shellType }, command, DEFAULT_SHELL_COMMAND_TIMEOUT_MS, ctx.terminalManager, ctx.logService);
106
>
const { success, pastTenseMessage } = this._summarizeResult(result);
107
>
const content: ToolResultContent[] = [terminalContent];
108
>
if (result.output) {
109
>
content.push({ type: ToolResultContentType.Text, text: result.output });
110
>
}
111
>
ctx.dispatch(turnChannel, {
112
>
type: ActionType.ChatToolCallComplete,
113
>
turnId,
114
>
toolCallId,
115
>
result: { success, pastTenseMessage, content },
116
>
});
117
>
} catch (err) {
118
ctx.logService.error(`[BangLocalCommand] Command failed for session=${sessionChannel}: ${err instanceof Error ? err.message : String(err)}`, err);
119
if (terminalCreated) {
120
ctx.terminalManager.disposeTerminal(terminalUri);
121
this._terminals.delete(terminalUri);
122
}
123
ctx.dispatch(turnChannel, {
124
type: ActionType.ChatToolCallComplete,
125
turnId,
126
toolCallId,
127
result: {
128
success: false,
129
pastTenseMessage: localize('agentHostBang.failed', "Failed to run command"),
130
error: { message: err instanceof Error ? err.message : String(err) },
131
},
132
});
133
}
136
>
/**
137
>
* Maps a shell command result to a success flag and past-tense summary for
138
>
* the completed tool call.
139
>
*/
140
>
private _summarizeResult(result: IShellCommandResult): { success: boolean; pastTenseMessage: string } {
142
>
case 'completed': {
143
>
const exitCode = result.exitCode ?? 0;
144
>
return exitCode === 0
145
>
? { success: true, pastTenseMessage: localize('agentHostBang.ran', "Ran command") }
146
: { success: false, pastTenseMessage: localize('agentHostBang.exited', "Command exited with code {0}", exitCode) };
148
>
case 'timeout':
149
return { success: false, pastTenseMessage: localize('agentHostBang.timedOut', "Command timed out") };
151
return { success: false, pastTenseMessage: localize('agentHostBang.shellExited', "Shell exited unexpectedly") };
153
return { success: true, pastTenseMessage: localize('agentHostBang.background', "Command is running in the background") };
155
return { success: true, pastTenseMessage: localize('agentHostBang.interactive', "Command opened an interactive terminal") };
157
>
}
159
>
160
>
LocalChatCommandRegistry.register(BangLocalCommand);