@theia/ai-ide 1.64.0-next.28 → 1.64.0

package/src/browser/workspace-launch-provider.spec.ts

@@ -0,0 +1,320 @@
+// *****************************************************************************
+// Copyright (C) 2025 EclipseSource GmbH.
+//
+// This program and the accompanying materials are made available under the
+// terms of the Eclipse Public License v. 2.0 which is available at
+// http://www.eclipse.org/legal/epl-2.0.
+//
+// This Source Code may also be made available under the following Secondary
+// Licenses when the conditions for such availability set forth in the Eclipse
+// Public License v. 2.0 are satisfied: GNU General Public License, version 2
+// with the GNU Classpath Exception which is available at
+// https://www.gnu.org/software/classpath/license.html.
+//
+// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
+// *****************************************************************************
+
+import { enableJSDOM } from '@theia/core/lib/browser/test/jsdom';
+let disableJSDOM = enableJSDOM();
+import { FrontendApplicationConfigProvider } from '@theia/core/lib/browser/frontend-application-config-provider';
+FrontendApplicationConfigProvider.set({});
+
+import { expect } from 'chai';
+import { Container } from '@theia/core/shared/inversify';
+import {
+    LaunchListProvider,
+    LaunchRunnerProvider,
+    LaunchStopProvider,
+} from './workspace-launch-provider';
+import { DebugConfigurationManager } from '@theia/debug/lib/browser/debug-configuration-manager';
+import { DebugSessionManager } from '@theia/debug/lib/browser/debug-session-manager';
+import { DebugSessionOptions } from '@theia/debug/lib/browser/debug-session-options';
+import { DebugConfiguration } from '@theia/debug/lib/common/debug-common';
+import { DebugCompound } from '@theia/debug/lib/common/debug-compound';
+import { DebugSession } from '@theia/debug/lib/browser/debug-session';
+
+disableJSDOM();
+
+describe('Launch Management Tool Providers', () => {
+    let container: Container;
+    let launchListProvider: LaunchListProvider;
+    let launchRunnerProvider: LaunchRunnerProvider;
+    let launchStopProvider: LaunchStopProvider;
+    let mockDebugConfigurationManager: Partial<DebugConfigurationManager>;
+    let mockDebugSessionManager: Partial<DebugSessionManager>;
+
+    before(() => {
+        disableJSDOM = enableJSDOM();
+    });
+
+    after(() => {
+        disableJSDOM();
+    });
+
+    beforeEach(() => {
+        container = new Container();
+
+        const mockConfigs = createMockConfigurations();
+
+        mockDebugConfigurationManager = {
+            load: () => Promise.resolve(),
+            get all(): IterableIterator<DebugSessionOptions> {
+                function* configIterator(): IterableIterator<DebugSessionOptions> {
+                    for (const config of mockConfigs) {
+                        yield config;
+                    }
+                }
+                return configIterator();
+            },
+        };
+
+        mockDebugSessionManager = {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            start: async (options: DebugSessionOptions | string): Promise<any> => {
+                if (
+                    typeof options === 'string' ||
+                    DebugSessionOptions.isCompound(options)
+                ) {
+                    return true;
+                }
+                return {
+                    id: 'test-session-id',
+                    configuration: { name: 'Test Config' },
+                } as DebugSession;
+            },
+            terminateSession: () => Promise.resolve(),
+            currentSession: undefined,
+            sessions: [],
+        };
+
+        container
+            .bind(DebugConfigurationManager)
+            .toConstantValue(
+                mockDebugConfigurationManager as DebugConfigurationManager
+            );
+        container
+            .bind(DebugSessionManager)
+            .toConstantValue(mockDebugSessionManager as DebugSessionManager);
+
+        launchListProvider = container.resolve(LaunchListProvider);
+        launchRunnerProvider = container.resolve(LaunchRunnerProvider);
+        launchStopProvider = container.resolve(LaunchStopProvider);
+    });
+
+    function createMockConfigurations(): DebugSessionOptions[] {
+        const config1: DebugConfiguration = {
+            name: 'Node.js Debug',
+            type: 'node',
+            request: 'launch',
+            program: '${workspaceFolder}/app.js',
+        };
+
+        const config2: DebugConfiguration = {
+            name: 'Python Debug',
+            type: 'python',
+            request: 'launch',
+            program: '${workspaceFolder}/main.py',
+        };
+
+        const compound: DebugCompound = {
+            name: 'Launch All',
+            configurations: ['Node.js Debug', 'Python Debug'],
+        };
+
+        return [
+            {
+                name: 'Node.js Debug',
+                configuration: config1,
+                workspaceFolderUri: '/workspace',
+            },
+            {
+                name: 'Python Debug',
+                configuration: config2,
+                workspaceFolderUri: '/workspace',
+            },
+            { name: 'Launch All', compound, workspaceFolderUri: '/workspace' },
+        ];
+    }
+
+    describe('LaunchListProvider', () => {
+        it('should provide the correct tool metadata', () => {
+            const tool = launchListProvider.getTool();
+            expect(tool.id).to.equal('listLaunchConfigurations');
+            expect(tool.name).to.equal('listLaunchConfigurations');
+            expect(tool.description).to.contain(
+                'Lists available launch configurations'
+            );
+            expect(tool.parameters.required).to.deep.equal(['filter']);
+        });
+
+        it('should list all configurations without filter', async () => {
+            const tool = launchListProvider.getTool();
+            const result = await tool.handler('{"filter":""}');
+            expect(result).to.be.a('string');
+            const configurations = JSON.parse(result as string);
+
+            expect(configurations).to.be.an('array');
+            expect(configurations).to.have.lengthOf(3);
+            expect(configurations).to.include('Node.js Debug');
+            expect(configurations).to.include('Python Debug');
+            expect(configurations).to.include('Launch All');
+        });
+
+        it('should filter configurations by name', async () => {
+            const tool = launchListProvider.getTool();
+            const result = await tool.handler('{"filter":"Node"}');
+            expect(result).to.be.a('string');
+            const configurations = JSON.parse(result as string);
+
+            expect(configurations).to.be.an('array');
+            expect(configurations).to.have.lengthOf(1);
+            expect(configurations).to.include('Node.js Debug');
+        });
+
+        it('should handle case-insensitive filtering', async () => {
+            const tool = launchListProvider.getTool();
+            const result = await tool.handler('{"filter":"python"}');
+            expect(result).to.be.a('string');
+            const configurations = JSON.parse(result as string);
+
+            expect(configurations).to.be.an('array');
+            expect(configurations).to.have.lengthOf(1);
+            expect(configurations).to.include('Python Debug');
+        });
+    });
+
+    describe('LaunchRunnerProvider', () => {
+        it('should provide the correct tool metadata', () => {
+            const tool = launchRunnerProvider.getTool();
+            expect(tool.id).to.equal('runLaunchConfiguration');
+            expect(tool.name).to.equal('runLaunchConfiguration');
+            expect(tool.description).to.contain(
+                'Executes a specified launch configuration'
+            );
+            expect(tool.parameters.required).to.deep.equal([
+                'configurationName',
+            ]);
+        });
+
+        it('should start a valid configuration', async () => {
+            const tool = launchRunnerProvider.getTool();
+            const result = await tool.handler(
+                '{"configurationName":"Node.js Debug"}'
+            );
+
+            expect(result).to.be.a('string');
+            expect(result).to.contain('Node.js Debug');
+            expect(result).to.contain('started with session ID');
+        });
+
+        it('should handle unknown configuration', async () => {
+            const tool = launchRunnerProvider.getTool();
+            const result = await tool.handler(
+                '{"configurationName":"Unknown Config"}'
+            );
+
+            expect(result).to.be.a('string');
+            expect(result).to.contain('Did not find a launch configuration');
+            expect(result).to.contain('Unknown Config');
+        });
+
+        it('should handle compound configurations', async () => {
+            const tool = launchRunnerProvider.getTool();
+            const result = await tool.handler(
+                '{"configurationName":"Launch All"}'
+            );
+
+            expect(result).to.be.a('string');
+            expect(result).to.contain('Compound launch configuration');
+            expect(result).to.contain('Launch All');
+            expect(result).to.contain('started successfully');
+        });
+    });
+
+    describe('LaunchStopProvider', () => {
+        it('should provide the correct tool metadata', () => {
+            const tool = launchStopProvider.getTool();
+            expect(tool.id).to.equal('stopLaunchConfiguration');
+            expect(tool.name).to.equal('stopLaunchConfiguration');
+            expect(tool.description).to.contain(
+                'Stops an active launch configuration'
+            );
+            expect(tool.parameters.required).to.deep.equal([]);
+        });
+
+        it('should stop current session when no configuration name provided', async () => {
+            (
+                mockDebugSessionManager as { currentSession: unknown }
+            ).currentSession = {
+                id: 'current-session',
+                configuration: { name: 'Current Config' },
+            };
+
+            const tool = launchStopProvider.getTool();
+            const result = await tool.handler('{}');
+
+            expect(result).to.be.a('string');
+            expect(result).to.contain(
+                'Successfully stopped current debug session'
+            );
+            expect(result).to.contain('Current Config');
+        });
+
+        it('should handle no active session', async () => {
+            (
+                mockDebugSessionManager as { currentSession: unknown }
+            ).currentSession = undefined;
+
+            const tool = launchStopProvider.getTool();
+            const result = await tool.handler('{}');
+
+            expect(result).to.be.a('string');
+            expect(result).to.contain('No active debug session to stop');
+        });
+
+        it('should stop specific session by name', async () => {
+            Object.defineProperty(mockDebugSessionManager, 'sessions', {
+                value: [
+                    {
+                        id: 'session-1',
+                        configuration: { name: 'Node.js Debug' },
+                    },
+                    {
+                        id: 'session-2',
+                        configuration: { name: 'Python Debug' },
+                    },
+                ],
+                writable: true,
+                configurable: true,
+            });
+
+            const tool = launchStopProvider.getTool();
+            const result = await tool.handler(
+                '{"configurationName":"Node.js Debug"}'
+            );
+
+            expect(result).to.be.a('string');
+            expect(result).to.contain(
+                'Successfully stopped launch configuration'
+            );
+            expect(result).to.contain('Node.js Debug');
+        });
+
+        it('should handle session not found by name', async () => {
+            Object.defineProperty(mockDebugSessionManager, 'sessions', {
+                value: [],
+                writable: true,
+                configurable: true,
+            });
+
+            const tool = launchStopProvider.getTool();
+            const result = await tool.handler(
+                '{"configurationName":"Unknown Config"}'
+            );
+
+            expect(result).to.be.a('string');
+            expect(result).to.contain('No active session found');
+            expect(result).to.contain('Unknown Config');
+        });
+    });
+});

package/src/browser/workspace-launch-provider.ts

@@ -0,0 +1,231 @@
+// *****************************************************************************
+// Copyright (C) 2025 EclipseSource GmbH.
+//
+// This program and the accompanying materials are made available under the
+// terms of the Eclipse Public License v. 2.0 which is available at
+// http://www.eclipse.org/legal/epl-2.0.
+//
+// This Source Code may also be made available under the following Secondary
+// Licenses when the conditions for such availability set forth in the Eclipse
+// Public License v. 2.0 are satisfied: GNU General Public License, version 2
+// with the GNU Classpath Exception which is available at
+// https://www.gnu.org/software/classpath/license.html.
+//
+// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
+// *****************************************************************************
+
+import { ToolProvider, ToolRequest } from '@theia/ai-core';
+import { inject, injectable } from '@theia/core/shared/inversify';
+import { DebugConfigurationManager } from '@theia/debug/lib/browser/debug-configuration-manager';
+import { DebugSessionManager } from '@theia/debug/lib/browser/debug-session-manager';
+import { DebugSessionOptions } from '@theia/debug/lib/browser/debug-session-options';
+import { DebugSession } from '@theia/debug/lib/browser/debug-session';
+import { MutableChatRequestModel } from '@theia/ai-chat';
+import { CancellationToken } from '@theia/core';
+import {
+    LIST_LAUNCH_CONFIGURATIONS_FUNCTION_ID,
+    RUN_LAUNCH_CONFIGURATION_FUNCTION_ID,
+    STOP_LAUNCH_CONFIGURATION_FUNCTION_ID
+} from '../common/workspace-functions';
+
+@injectable()
+export class LaunchListProvider implements ToolProvider {
+
+    @inject(DebugConfigurationManager)
+    protected readonly debugConfigurationManager: DebugConfigurationManager;
+
+    getTool(): ToolRequest {
+        return {
+            id: LIST_LAUNCH_CONFIGURATIONS_FUNCTION_ID,
+            name: LIST_LAUNCH_CONFIGURATIONS_FUNCTION_ID,
+            description: 'Lists available launch configurations in the workspace. Launch configurations can be filtered by name.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    filter: {
+                        type: 'string',
+                        description: 'Filter to apply on launch configuration names (empty string to retrieve all configurations).'
+                    }
+                },
+                required: ['filter']
+            },
+            handler: async (argString: string) => {
+                const filterArgs: { filter: string } = JSON.parse(argString);
+                const configurations = await this.getAvailableLaunchConfigurations(filterArgs.filter);
+                return JSON.stringify(configurations);
+            }
+        };
+    }
+
+    private async getAvailableLaunchConfigurations(filter: string = ''): Promise<string[]> {
+        await this.debugConfigurationManager.load();
+        const configurations: string[] = [];
+
+        for (const options of this.debugConfigurationManager.all) {
+            const name = this.getDisplayName(options);
+            if (name.toLowerCase().includes(filter.toLowerCase())) {
+                configurations.push(name);
+            }
+        }
+
+        return configurations;
+    }
+
+    private getDisplayName(options: DebugSessionOptions): string {
+        if (DebugSessionOptions.isConfiguration(options)) {
+            return options.configuration.name;
+        } else if (DebugSessionOptions.isCompound(options)) {
+            return options.compound.name;
+        }
+        return 'Unnamed Configuration';
+    }
+}
+
+@injectable()
+export class LaunchRunnerProvider implements ToolProvider {
+
+    @inject(DebugConfigurationManager)
+    protected readonly debugConfigurationManager: DebugConfigurationManager;
+
+    @inject(DebugSessionManager)
+    protected readonly debugSessionManager: DebugSessionManager;
+
+    getTool(): ToolRequest {
+        return {
+            id: RUN_LAUNCH_CONFIGURATION_FUNCTION_ID,
+            name: RUN_LAUNCH_CONFIGURATION_FUNCTION_ID,
+            description: 'Executes a specified launch configuration to start debugging.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    configurationName: {
+                        type: 'string',
+                        description: 'The name of the launch configuration to execute.'
+                    }
+                },
+                required: ['configurationName']
+            },
+            handler: async (argString: string, ctx: MutableChatRequestModel) => this.handleRunLaunchConfiguration(argString, ctx?.response?.cancellationToken)
+        };
+    }
+
+    private async handleRunLaunchConfiguration(argString: string, cancellationToken?: CancellationToken): Promise<string> {
+        try {
+            const args: { configurationName: string } = JSON.parse(argString);
+
+            await this.debugConfigurationManager.load();
+
+            const options = this.findConfigurationByName(args.configurationName);
+            if (!options) {
+                return `Did not find a launch configuration for the name: '${args.configurationName}'`;
+            }
+
+            const session = await this.debugSessionManager.start(options);
+
+            if (!session) {
+                return `Failed to start launch configuration '${args.configurationName}'`;
+            }
+
+            if (cancellationToken && typeof session !== 'boolean') {
+                cancellationToken.onCancellationRequested(() => {
+                    this.debugSessionManager.terminateSession(session);
+                });
+            }
+
+            const sessionInfo = typeof session === 'boolean'
+                ? `Compound launch configuration '${args.configurationName}' started successfully`
+                : `Launch configuration '${args.configurationName}' started with session ID: ${session.id}`;
+
+            return sessionInfo;
+
+        } catch (error) {
+            return JSON.stringify({
+                success: false,
+                message: error instanceof Error ? error.message : 'Failed to run launch configuration'
+            });
+        }
+    }
+
+    private findConfigurationByName(name: string): DebugSessionOptions | undefined {
+        for (const options of this.debugConfigurationManager.all) {
+            const displayName = this.getDisplayName(options);
+            if (displayName === name) {
+                return options;
+            }
+        }
+        return undefined;
+    }
+
+    private getDisplayName(options: DebugSessionOptions): string {
+        if (DebugSessionOptions.isConfiguration(options)) {
+            return options.configuration.name;
+        } else if (DebugSessionOptions.isCompound(options)) {
+            return options.compound.name;
+        }
+        return 'Unnamed Configuration';
+    }
+}
+
+@injectable()
+export class LaunchStopProvider implements ToolProvider {
+
+    @inject(DebugSessionManager)
+    protected readonly debugSessionManager: DebugSessionManager;
+
+    getTool(): ToolRequest {
+        return {
+            id: STOP_LAUNCH_CONFIGURATION_FUNCTION_ID,
+            name: STOP_LAUNCH_CONFIGURATION_FUNCTION_ID,
+            description: 'Stops an active launch configuration or debug session.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    configurationName: {
+                        type: 'string',
+                        description: 'The name of the launch configuration to stop. If not provided, stops the current active session.'
+                    }
+                },
+                required: []
+            },
+            handler: async (argString: string) => this.handleStopLaunchConfiguration(argString)
+        };
+    }
+
+    private async handleStopLaunchConfiguration(argString: string): Promise<string> {
+        try {
+            const args: { configurationName?: string } = JSON.parse(argString);
+
+            if (args.configurationName) {
+                // Find and stop specific session by configuration name
+                const session = this.findSessionByConfigurationName(args.configurationName);
+                if (!session) {
+                    return `No active session found for launch configuration: '${args.configurationName}'`;
+                }
+
+                await this.debugSessionManager.terminateSession(session);
+                return `Successfully stopped launch configuration: '${args.configurationName}'`;
+            } else {
+                // Stop current active session
+                const currentSession = this.debugSessionManager.currentSession;
+                if (!currentSession) {
+                    return 'No active debug session to stop';
+                }
+
+                await this.debugSessionManager.terminateSession(currentSession);
+                return `Successfully stopped current debug session: '${currentSession.configuration.name}'`;
+            }
+
+        } catch (error) {
+            return JSON.stringify({
+                success: false,
+                message: error instanceof Error ? error.message : 'Failed to stop launch configuration'
+            });
+        }
+    }
+
+    private findSessionByConfigurationName(configurationName: string): DebugSession | undefined {
+        return this.debugSessionManager.sessions.find(
+            session => session.configuration.name === configurationName
+        );
+    }
+}