Implement workbench.action.terminal.sendSignal command

Co-authored-by: Tyriar <[email protected]>

Author: Copilot

src/vs/platform/terminal/common/terminal.ts

@@ -331,6 +331,7 @@ export interface IPtyService {
 	start(id: number): Promise<ITerminalLaunchError | { injectedArgs: string[] } | undefined>;
 	shutdown(id: number, immediate: boolean): Promise<void>;
 	input(id: number, data: string): Promise<void>;
+	sendSignal(id: number, signal: string): Promise<void>;
 	resize(id: number, cols: number, rows: number): Promise<void>;
 	clearBuffer(id: number): Promise<void>;
 	getInitialCwd(id: number): Promise<string>;
@@ -791,6 +792,7 @@ export interface ITerminalChildProcess {
 	 */
 	shutdown(immediate: boolean): void;
 	input(data: string): void;
+	sendSignal(signal: string): void;
 	processBinary(data: string): Promise<void>;
 	resize(cols: number, rows: number): void;
 	clearBuffer(): void | Promise<void>;

src/vs/platform/terminal/node/ptyService.ts

@@ -422,6 +422,10 @@ export class PtyService extends Disposable implements IPtyService {
 		}
 	}
 	@traceRpc
+	async sendSignal(id: number, signal: string): Promise<void> {
+		return this._throwIfNoPty(id).sendSignal(signal);
+	}
+	@traceRpc
 	async processBinary(id: number, data: string): Promise<void> {
 		return this._throwIfNoPty(id).writeBinary(data);
 	}

src/vs/platform/terminal/node/terminalProcess.ts

@@ -481,6 +481,13 @@ export class TerminalProcess extends Disposable implements ITerminalChildProcess
 		this._startWrite();
 	}
 
+	sendSignal(signal: string): void {
+		if (this._store.isDisposed || !this._ptyProcess) {
+			return;
+		}
+		this._ptyProcess.kill(signal);
+	}
+
 	async processBinary(data: string): Promise<void> {
 		this.input(data, true);
 	}

src/vs/server/node/remoteTerminalChannel.ts

@@ -128,6 +128,7 @@ export class RemoteTerminalChannel extends Disposable implements IServerChannel<
 
 			case RemoteTerminalChannelRequest.Start: return this._ptyHostService.start.apply(this._ptyHostService, args);
 			case RemoteTerminalChannelRequest.Input: return this._ptyHostService.input.apply(this._ptyHostService, args);
+			case RemoteTerminalChannelRequest.SendSignal: return this._ptyHostService.sendSignal.apply(this._ptyHostService, args);
 			case RemoteTerminalChannelRequest.AcknowledgeDataEvent: return this._ptyHostService.acknowledgeDataEvent.apply(this._ptyHostService, args);
 			case RemoteTerminalChannelRequest.Shutdown: return this._ptyHostService.shutdown.apply(this._ptyHostService, args);
 			case RemoteTerminalChannelRequest.Resize: return this._ptyHostService.resize.apply(this._ptyHostService, args);

src/vs/workbench/api/common/extHostTerminalService.ts

@@ -334,6 +334,11 @@ class ExtHostPseudoterminal implements ITerminalChildProcess {
 		this._pty.handleInput?.(data);
 	}
 
+	sendSignal(signal: string): void {
+		// Extension owned terminals don't support sending signals directly to processes
+		// This could be extended in the future if the pseudoterminal API is enhanced
+	}
+
 	resize(cols: number, rows: number): void {
 		this._pty.setDimensions?.({ columns: cols, rows });
 	}

src/vs/workbench/contrib/terminal/browser/terminal.ts

@@ -899,6 +899,13 @@ export interface ITerminalInstance extends IBaseTerminalInstance {
 	 */
 	sendText(text: string, shouldExecute: boolean, bracketedPasteMode?: boolean): Promise<void>;
 
+	/**
+	 * Sends a signal to the terminal instance's process.
+	 *
+	 * @param signal The signal to send (e.g., 'SIGTERM', 'SIGINT', 'SIGKILL').
+	 */
+	sendSignal(signal: string): Promise<void>;
+
 	/**
 	 * Sends a path to the terminal instance, preparing it as needed based on the detected shell
 	 * running within the terminal. The text is written to the stdin of the underlying pty process

src/vs/workbench/contrib/terminal/browser/terminalActions.ts

@@ -137,6 +137,17 @@ export const terminalSendSequenceCommand = async (accessor: ServicesAccessor, ar
 	}
 };
 
+export const terminalSendSignalCommand = async (accessor: ServicesAccessor, args: unknown) => {
+	const instance = accessor.get(ITerminalService).activeInstance;
+	if (instance) {
+		const signal = isObject(args) && 'signal' in args ? toOptionalString(args.signal) : undefined;
+		if (!signal) {
+			return;
+		}
+		instance.sendSignal(signal);
+	}
+};
+
 export class TerminalLaunchHelpAction extends Action {
 
 	constructor(
@@ -977,6 +988,29 @@ export function registerTerminalActions() {
 		run: (c, accessor, args) => terminalSendSequenceCommand(accessor, args)
 	});
 
+	registerTerminalAction({
+		id: TerminalCommandId.SendSignal,
+		title: terminalStrings.sendSignal,
+		f1: false,
+		metadata: {
+			description: terminalStrings.sendSignal.value,
+			args: [{
+				name: 'args',
+				schema: {
+					type: 'object',
+					required: ['signal'],
+					properties: {
+						signal: {
+							description: localize('sendSignal', "The signal to send to the terminal process (e.g., 'SIGTERM', 'SIGINT', 'SIGKILL')"),
+							type: 'string'
+						}
+					},
+				}
+			}]
+		},
+		run: (c, accessor, args) => terminalSendSignalCommand(accessor, args)
+	});
+
 	registerTerminalAction({
 		id: TerminalCommandId.NewWithCwd,
 		title: terminalStrings.newWithCwd,

src/vs/workbench/contrib/terminal/browser/terminalInstance.ts

@@ -1321,6 +1321,11 @@ export class TerminalInstance extends Disposable implements ITerminalInstance {
 		}
 	}
 
+	async sendSignal(signal: string): Promise<void> {
+		this._logService.debug('sending signal (vscode)', signal);
+		await this._processManager.sendSignal(signal);
+	}
+
 	async sendPath(originalPath: string | URI, shouldExecute: boolean): Promise<void> {
 		return this.sendText(await this.preparePathForShell(originalPath), shouldExecute);
 	}

src/vs/workbench/contrib/terminal/browser/terminalProcessManager.ts

@@ -609,6 +609,13 @@ export class TerminalProcessManager extends Disposable implements ITerminalProce
 		}
 	}
 
+	async sendSignal(signal: string): Promise<void> {
+		await this.ptyProcessReady;
+		if (this._process) {
+			this._process.sendSignal(signal);
+		}
+	}
+
 	async processBinary(data: string): Promise<void> {
 		await this.ptyProcessReady;
 		this._dataFilter.disableSeamlessRelaunch();

src/vs/workbench/contrib/terminal/common/remote/remoteTerminalChannel.ts

@@ -216,6 +216,9 @@ export class RemoteTerminalChannelClient implements IPtyHostController {
 	input(id: number, data: string): Promise<void> {
 		return this._channel.call(RemoteTerminalChannelRequest.Input, [id, data]);
 	}
+	sendSignal(id: number, signal: string): Promise<void> {
+		return this._channel.call(RemoteTerminalChannelRequest.SendSignal, [id, signal]);
+	}
 	acknowledgeDataEvent(id: number, charCount: number): Promise<void> {
 		return this._channel.call(RemoteTerminalChannelRequest.AcknowledgeDataEvent, [id, charCount]);
 	}