@eclipse-glsp/server-mcp 2.8.0-next.1 → 2.8.0-next.10

package/src/common/tools/handlers/session-info-mcp-tool-handler.spec.ts

@@ -1,152 +0,0 @@
-/********************************************************************************
- * Copyright (c) 2026 EclipseSource and others.
- *
- * 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 WITH Classpath-exception-2.0
- ********************************************************************************/
-
-import { ClientSession, ClientSessionManager, CommandStack, Logger, ModelState, NullLogger } from '@eclipse-glsp/server';
-import { expect } from 'chai';
-import { Container, ContainerModule } from 'inversify';
-import { McpToolResult } from '../../server/mcp-handler-shared';
-import { SessionInfoMcpToolHandler } from './session-info-mcp-tool-handler';
-
-function asText(result: McpToolResult): string {
-    const block = result.content[0];
-    if (!block || block.type !== 'text') throw new Error('expected text content');
-    return block.text;
-}
-
-/** Build a {@link ClientSession} stub whose container resolves a fixed {@link ModelState} + {@link CommandStack}. */
-function makeSession(
-    id: string,
-    diagramType: string,
-    sourceUri: string | undefined,
-    isReadonly: boolean,
-    isDirty: boolean = false
-): ClientSession {
-    const sessionContainer = new Container();
-    const modelStateStub: Partial<ModelState> = { sourceUri, isReadonly };
-    sessionContainer.bind(ModelState).toConstantValue(modelStateStub as ModelState);
-    const commandStackStub: Partial<CommandStack> = { isDirty };
-    sessionContainer.bind(CommandStack).toConstantValue(commandStackStub as CommandStack);
-    return {
-        id,
-        diagramType,
-        container: sessionContainer,
-        // The handler does not exercise this dispatcher, but the interface requires it.
-        actionDispatcher: {} as ClientSession['actionDispatcher'],
-        dispose: () => {
-            //
-        }
-    };
-}
-
-class StubClientSessionManager implements ClientSessionManager {
-    constructor(private readonly sessions: ClientSession[]) {}
-
-    getOrCreateClientSession(): ClientSession {
-        throw new Error('not implemented');
-    }
-    getSession(sessionId?: string): ClientSession | undefined {
-        return this.sessions.find(s => s.id === sessionId);
-    }
-    getSessions(): ClientSession[] {
-        return this.sessions;
-    }
-    getSessionsByType(): ClientSession[] {
-        return [];
-    }
-    disposeClientSession(): boolean {
-        return true;
-    }
-    addListener(): boolean {
-        return true;
-    }
-    removeListener(): boolean {
-        return true;
-    }
-    removeListeners(): void {
-        //
-    }
-}
-
-function buildHandler(sessions: ClientSession[]): SessionInfoMcpToolHandler {
-    const container = new Container();
-    container.load(
-        new ContainerModule(bind => {
-            bind(Logger).toConstantValue(new NullLogger());
-            bind(ClientSessionManager).toConstantValue(new StubClientSessionManager(sessions));
-            bind(SessionInfoMcpToolHandler).toSelf().inSingletonScope();
-        })
-    );
-    return container.get(SessionInfoMcpToolHandler);
-}
-
-interface SessionRow {
-    sessionId: string;
-    diagramType: string;
-    sourceUri: string;
-    readOnly: boolean;
-    dirty: boolean;
-}
-
-describe('SessionInfoMcpToolHandler', () => {
-    it('summarizes each session by id and diagram type when sessions exist', () => {
-        const handler = buildHandler([
-            makeSession('session-alpha', 'workflow-diagram', 'file:///alpha.wf', false),
-            makeSession('session-beta', 'state-diagram', 'file:///beta.sd', true)
-        ]);
-
-        const result = handler['createResult']({});
-        const text = asText(result);
-        // Summary lists each session's id and diagram type — the load-bearing referenceable bits.
-        expect(text).to.include('session-alpha');
-        expect(text).to.include('session-beta');
-        expect(text).to.include('workflow-diagram');
-        expect(text).to.include('state-diagram');
-        // Full per-session detail goes via structuredContent.
-        const sessions = (result.structuredContent as { sessions: SessionRow[] }).sessions;
-        expect(sessions.map(row => row.sessionId)).to.deep.equal(['session-alpha', 'session-beta']);
-    });
-
-    it("passes through `sourceUri` and `readOnly` from each session container's ModelState via structuredContent", () => {
-        const handler = buildHandler([makeSession('s1', 'workflow-diagram', 'file:///only.wf', true, /* isDirty */ false)]);
-
-        const result = handler['createResult']({});
-        const sessions = (result.structuredContent as { sessions: SessionRow[] }).sessions;
-        expect(sessions).to.have.lengthOf(1);
-        expect(sessions[0].sourceUri).to.equal('file:///only.wf');
-        expect(sessions[0].readOnly).to.equal(true);
-        expect(sessions[0].dirty).to.equal(false);
-        // Read-only state is also surfaced in the text summary so content-only clients can see it.
-        expect(asText(result)).to.include('read-only');
-    });
-
-    it('filters to a single session when `sessionId` matches', () => {
-        const handler = buildHandler([
-            makeSession('session-alpha', 'workflow-diagram', 'file:///alpha.wf', false),
-            makeSession('session-beta', 'state-diagram', 'file:///beta.sd', true)
-        ]);
-
-        const text = asText(handler['createResult']({ sessionId: 'session-beta' }));
-
-        expect(text).to.include('session-beta');
-        expect(text).to.not.include('session-alpha');
-    });
-
-    it('throws McpToolError when the requested `sessionId` does not exist', () => {
-        const handler = buildHandler([makeSession('session-alpha', 'workflow-diagram', 'file:///alpha.wf', false)]);
-
-        expect(() => handler['createResult']({ sessionId: 'unknown' })).to.throw(/Unknown sessionId: unknown/);
-    });
-});

package/src/common/tools/handlers/set-selection-mcp-tool-handler.spec.ts

@@ -1,120 +0,0 @@
-/********************************************************************************
- * Copyright (c) 2026 EclipseSource and others.
- *
- * 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 WITH Classpath-exception-2.0
- ********************************************************************************/
-
-import {
-    Action,
-    ActionDispatcher,
-    ClientId,
-    GModelElement,
-    Logger,
-    ModelState,
-    NullLogger,
-    SelectAction,
-    SelectAllAction
-} from '@eclipse-glsp/server';
-import { expect } from 'chai';
-import { Container, ContainerModule } from 'inversify';
-import { McpElementsNotFoundError, McpToolResult } from '../../server/mcp-handler-shared';
-import { McpIdAliasService } from '../../server/mcp-id-alias-service';
-import { DefaultMcpLabelProvider, McpLabelProvider } from '../../server/mcp-label-provider';
-import { SetSelectionInput, SetSelectionMcpToolHandler } from './set-selection-mcp-tool-handler';
-
-function makeElement(id: string, type: string): GModelElement {
-    return { id, type, children: [] } as unknown as GModelElement;
-}
-
-function makeModelState(elements: GModelElement[]): ModelState {
-    const byId = new Map(elements.map(el => [el.id, el]));
-    return {
-        index: {
-            allIds: () => [...byId.keys()],
-            get: (id: string) => byId.get(id),
-            find: (id: string) => byId.get(id)
-        }
-    } as unknown as ModelState;
-}
-
-function makeRecordingDispatcher(): { dispatcher: ActionDispatcher; dispatched: Action[] } {
-    const dispatched: Action[] = [];
-    const dispatcher = {
-        dispatch: async (action: Action) => {
-            dispatched.push(action);
-        }
-    } as unknown as ActionDispatcher;
-    return { dispatcher, dispatched };
-}
-
-function buildHandler(elements: GModelElement[], dispatcher: ActionDispatcher): SetSelectionMcpToolHandler {
-    const container = new Container();
-    container.load(
-        new ContainerModule(bind => {
-            bind(Logger).toConstantValue(new NullLogger());
-            bind(ClientId).toConstantValue('test-session');
-            bind(ModelState).toConstantValue(makeModelState(elements));
-            bind(McpIdAliasService).toConstantValue({
-                lookup: (id: string) => id,
-                alias: (id: string) => id
-            } as McpIdAliasService);
-            bind(ActionDispatcher).toConstantValue(dispatcher);
-            bind(McpLabelProvider).to(DefaultMcpLabelProvider);
-            bind(SetSelectionMcpToolHandler).toSelf();
-        })
-    );
-    return container.get(SetSelectionMcpToolHandler);
-}
-
-function callCreateResult(handler: SetSelectionMcpToolHandler, params: SetSelectionInput): Promise<McpToolResult> {
-    return (handler as unknown as { createResult: (p: SetSelectionInput) => Promise<McpToolResult> }).createResult(params);
-}
-
-describe('SetSelectionMcpToolHandler', () => {
-    it('dispatches SelectAllAction(false) before SelectAction when `clear: true`', async () => {
-        const { dispatcher, dispatched } = makeRecordingDispatcher();
-        const handler = buildHandler([makeElement('n1', 'task'), makeElement('n2', 'task')], dispatcher);
-
-        await callCreateResult(handler, { sessionId: 's', selectedElementIds: ['n1'], clear: true });
-
-        expect(dispatched).to.have.lengthOf(2);
-        expect(SelectAllAction.is(dispatched[0])).to.equal(true);
-        expect((dispatched[0] as SelectAllAction).select).to.equal(false);
-        expect(SelectAction.is(dispatched[1])).to.equal(true);
-    });
-
-    it('dispatches SelectAction with resolved selected and deselected ids', async () => {
-        const { dispatcher, dispatched } = makeRecordingDispatcher();
-        const handler = buildHandler([makeElement('a', 'task'), makeElement('b', 'task'), makeElement('c', 'task')], dispatcher);
-
-        await callCreateResult(handler, { sessionId: 's', selectedElementIds: ['a', 'b'], deselectedElementIds: ['c'] });
-
-        expect(dispatched).to.have.lengthOf(1);
-        const action = dispatched[0] as SelectAction;
-        expect(action.selectedElementsIDs).to.deep.equal(['a', 'b']);
-        expect(action.deselectedElementsIDs).to.deep.equal(['c']);
-    });
-
-    it('throws McpElementsNotFoundError when an id is missing from the model', async () => {
-        const { dispatcher } = makeRecordingDispatcher();
-        const handler = buildHandler([makeElement('n1', 'task')], dispatcher);
-
-        let error: unknown;
-        try {
-            await callCreateResult(handler, { sessionId: 's', selectedElementIds: ['n1', 'ghost'] });
-        } catch (err: unknown) {
-            error = err;
-        }
-        expect(error).to.be.instanceOf(McpElementsNotFoundError);
-    });
-});

package/src/common/tools/tool-annotations.spec.ts

@@ -1,141 +0,0 @@
-/********************************************************************************
- * Copyright (c) 2026 EclipseSource and others.
- *
- * 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 WITH Classpath-exception-2.0
- ********************************************************************************/
-
-import { expect } from 'chai';
-import { interfaces } from 'inversify';
-import { SetViewMcpToolHandler } from './handlers/set-view-mcp-tool-handler';
-import { CreateEdgesMcpToolHandler } from './handlers/create-edges-mcp-tool-handler';
-import { CreateNodesMcpToolHandler } from './handlers/create-nodes-mcp-tool-handler';
-import { DeleteElementsMcpToolHandler } from './handlers/delete-elements-mcp-tool-handler';
-import { QueryElementsMcpToolHandler } from './handlers/query-elements-mcp-tool-handler';
-import { GetSelectionMcpToolHandler } from './handlers/get-selection-mcp-tool-handler';
-import { ModifyEdgesMcpToolHandler } from './handlers/modify-edges-mcp-tool-handler';
-import { ModifyNodesMcpToolHandler } from './handlers/modify-nodes-mcp-tool-handler';
-import { RedoMcpToolHandler } from './handlers/redo-mcp-tool-handler';
-import { SaveModelMcpToolHandler } from './handlers/save-model-mcp-tool-handler';
-import { UndoMcpToolHandler } from './handlers/undo-mcp-tool-handler';
-import { ValidateDiagramMcpToolHandler } from './handlers/validate-diagram-mcp-tool-handler';
-
-interface AnnotatedHandler {
-    readOnlyHint?: boolean;
-    destructiveHint?: boolean;
-    idempotentHint?: boolean;
-    openWorldHint?: boolean;
-}
-
-/**
- * Reads the four annotation hint fields off a freshly `new`-ed handler. Mirrors how the launcher
- * reads metadata via `new Constructor()` at MCP-session-init (see
- * `mcp-server-launcher.ts#registerDiagramScopeTools`); no DI wiring needed because the fields
- * are plain class properties with literal initializers.
- */
-function hintsOf(Constructor: interfaces.Newable<AnnotatedHandler>): AnnotatedHandler {
-    const handler = new Constructor();
-    return {
-        readOnlyHint: handler.readOnlyHint,
-        destructiveHint: handler.destructiveHint,
-        idempotentHint: handler.idempotentHint,
-        openWorldHint: handler.openWorldHint
-    };
-}
-
-const READ_DEFAULT: AnnotatedHandler = {
-    readOnlyHint: true,
-    destructiveHint: undefined,
-    idempotentHint: undefined,
-    openWorldHint: false
-};
-
-const OPERATION_DEFAULT: AnnotatedHandler = {
-    readOnlyHint: false,
-    destructiveHint: false,
-    idempotentHint: false,
-    openWorldHint: false
-};
-
-describe('Tool annotations · per-handler matrix', () => {
-    describe('read-style handlers (inherit base default)', () => {
-        const readStyleHandlers: Array<[string, interfaces.Newable<AnnotatedHandler>]> = [
-            ['query-elements', QueryElementsMcpToolHandler],
-            ['get-selection', GetSelectionMcpToolHandler],
-            ['validate-diagram', ValidateDiagramMcpToolHandler]
-        ];
-        readStyleHandlers.forEach(([name, Constructor]) => {
-            it(`${name} matches the read-style default`, () => {
-                expect(hintsOf(Constructor)).to.deep.equal(READ_DEFAULT);
-            });
-        });
-    });
-
-    describe('operation-style handlers (override to write defaults)', () => {
-        const operationStyleHandlers: Array<[string, interfaces.Newable<AnnotatedHandler>]> = [
-            ['create-nodes', CreateNodesMcpToolHandler],
-            ['create-edges', CreateEdgesMcpToolHandler],
-            ['modify-nodes', ModifyNodesMcpToolHandler],
-            ['modify-edges', ModifyEdgesMcpToolHandler],
-            ['undo', UndoMcpToolHandler],
-            ['redo', RedoMcpToolHandler]
-        ];
-        operationStyleHandlers.forEach(([name, Constructor]) => {
-            it(`${name} matches the operation-style default`, () => {
-                expect(hintsOf(Constructor)).to.deep.equal(OPERATION_DEFAULT);
-            });
-        });
-    });
-
-    describe('per-handler overrides', () => {
-        it('delete-elements is destructiveHint:true (single-flag override)', () => {
-            expect(hintsOf(DeleteElementsMcpToolHandler)).to.deep.equal({ ...OPERATION_DEFAULT, destructiveHint: true });
-        });
-
-        it('save-model is NOT readOnly (writes to disk) and NOT destructive (creative)', () => {
-            // Spec: `readOnlyHint` means "does not modify its environment" — disk IS environment.
-            // `destructiveHint` is for irreversible deletion / data loss; save is creative.
-            // Save-model extends the read base (not the operation base) because it doesn't
-            // dispatch a model-mutating Operation, but we override the flat fields explicitly.
-            expect(hintsOf(SaveModelMcpToolHandler)).to.deep.equal({
-                readOnlyHint: false,
-                destructiveHint: false,
-                idempotentHint: false,
-                openWorldHint: false
-            });
-        });
-
-        it('set-view drops the read-only claim (viewport IS environment)', () => {
-            // Inherits from the read base, which would claim readOnlyHint:true. Override flips
-            // it: dispatching a viewport action mutates client-side state, even though no
-            // diagram model bytes change.
-            expect(hintsOf(SetViewMcpToolHandler)).to.deep.equal({
-                readOnlyHint: false,
-                destructiveHint: undefined,
-                idempotentHint: undefined,
-                openWorldHint: false
-            });
-        });
-    });
-
-    describe('toRegistrationConfig() assembles the annotations object the SDK expects', () => {
-        it('aggregates the flat fields into the SDK ToolAnnotations shape', () => {
-            const config = new DeleteElementsMcpToolHandler().toRegistrationConfig();
-            expect(config.annotations).to.deep.equal({
-                readOnlyHint: false,
-                destructiveHint: true,
-                idempotentHint: false,
-                openWorldHint: false
-            });
-        });
-    });
-});