Adds executeCommand endpoint with support for /extensions list (#11515)

packages/a2a-server/src/commands/command-registry.test.ts

@@ -0,0 +1,48 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+
+describe('CommandRegistry', () => {
+  const mockListExtensionsCommandInstance = {
+    names: ['extensions', 'extensions list'],
+    execute: vi.fn(),
+  };
+  const mockListExtensionsCommand = vi.fn(
+    () => mockListExtensionsCommandInstance,
+  );
+
+  beforeEach(async () => {
+    vi.resetModules();
+    vi.doMock('./list-extensions', () => ({
+      ListExtensionsCommand: mockListExtensionsCommand,
+    }));
+  });
+
+  it('should register ListExtensionsCommand on initialization', async () => {
+    const { commandRegistry } = await import('./command-registry.js');
+    expect(mockListExtensionsCommand).toHaveBeenCalled();
+    const command = commandRegistry.get('extensions');
+    expect(command).toBe(mockListExtensionsCommandInstance);
+  });
+
+  it('get() should return undefined for a non-existent command', async () => {
+    const { commandRegistry } = await import('./command-registry.js');
+    const command = commandRegistry.get('non-existent');
+    expect(command).toBeUndefined();
+  });
+
+  it('register() should register a new command', async () => {
+    const { commandRegistry } = await import('./command-registry.js');
+    const mockCommand = {
+      names: ['test-command'],
+      execute: vi.fn(),
+    };
+    commandRegistry.register(mockCommand);
+    const command = commandRegistry.get('test-command');
+    expect(command).toBe(mockCommand);
+  });
+});

packages/a2a-server/src/commands/command-registry.ts

@@ -0,0 +1,33 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { ListExtensionsCommand } from './list-extensions.js';
+import type { Config } from '@google/gemini-cli-core';
+
+export interface Command {
+  readonly names: string[];
+  execute(config: Config, args: string[]): Promise<unknown>;
+}
+
+class CommandRegistry {
+  private readonly commands = new Map<string, Command>();
+
+  constructor() {
+    this.register(new ListExtensionsCommand());
+  }
+
+  register(command: Command) {
+    for (const name of command.names) {
+      this.commands.set(name, command);
+    }
+  }
+
+  get(commandName: string): Command | undefined {
+    return this.commands.get(commandName);
+  }
+}
+
+export const commandRegistry = new CommandRegistry();

packages/a2a-server/src/commands/list-extensions.test.ts

@@ -0,0 +1,39 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { describe, it, expect, vi } from 'vitest';
+import { ListExtensionsCommand } from './list-extensions.js';
+import type { Config } from '@google/gemini-cli-core';
+
+const mockListExtensions = vi.hoisted(() => vi.fn());
+vi.mock('@google/gemini-cli-core', async (importOriginal) => {
+  const original =
+    await importOriginal<typeof import('@google/gemini-cli-core')>();
+
+  return {
+    ...original,
+    listExtensions: mockListExtensions,
+  };
+});
+
+describe('ListExtensionsCommand', () => {
+  it('should have the correct names', () => {
+    const command = new ListExtensionsCommand();
+    expect(command.names).toEqual(['extensions', 'extensions list']);
+  });
+
+  it('should call listExtensions with the provided config', async () => {
+    const command = new ListExtensionsCommand();
+    const mockConfig = {} as Config;
+    const mockExtensions = [{ name: 'ext1' }];
+    mockListExtensions.mockReturnValue(mockExtensions);
+
+    const result = await command.execute(mockConfig, []);
+
+    expect(result).toEqual(mockExtensions);
+    expect(mockListExtensions).toHaveBeenCalledWith(mockConfig);
+  });
+});

packages/a2a-server/src/commands/list-extensions.ts

@@ -0,0 +1,16 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { listExtensions, type Config } from '@google/gemini-cli-core';
+import type { Command } from './command-registry.js';
+
+export class ListExtensionsCommand implements Command {
+  readonly names = ['extensions', 'extensions list'];
+
+  async execute(config: Config, _: string[]): Promise<unknown> {
+    return listExtensions(config);
+  }
+}

packages/a2a-server/src/config/config.ts

@@ -71,6 +71,7 @@ export async function loadConfig(
     },
     ideMode: false,
     folderTrust: settings.folderTrust === true,
+    extensions,
   };
 
   const fileService = new FileDiscoveryService(workspaceDir);

packages/a2a-server/src/http/app.test.ts

@@ -65,6 +65,8 @@ let config: Config;
 const getToolRegistrySpy = vi.fn().mockReturnValue(ApprovalMode.DEFAULT);
 const getApprovalModeSpy = vi.fn();
 const getShellExecutionConfigSpy = vi.fn();
+const getExtensionsSpy = vi.fn();
+
 vi.mock('../config/config.js', async () => {
   const actual = await vi.importActual('../config/config.js');
   return {
@@ -74,6 +76,7 @@ vi.mock('../config/config.js', async () => {
         getToolRegistry: getToolRegistrySpy,
         getApprovalMode: getApprovalModeSpy,
         getShellExecutionConfig: getShellExecutionConfigSpy,
+        getExtensions: getExtensionsSpy,
       });
       config = mockConfig as Config;
       return config;
@@ -652,4 +655,62 @@ describe('E2E Tests', () => {
     expect(thoughtEvent.kind).toBe('status-update');
     expect(thoughtEvent.metadata?.['traceId']).toBe(traceId);
   });
+
+  describe('/executeCommand', () => {
+    const mockExtensions = [{ name: 'test-extension', version: '0.0.1' }];
+
+    beforeEach(() => {
+      getExtensionsSpy.mockReturnValue(mockExtensions);
+    });
+
+    afterEach(() => {
+      getExtensionsSpy.mockClear();
+    });
+
+    it('should return extensions for valid command', async () => {
+      const agent = request.agent(app);
+      const res = await agent
+        .post('/executeCommand')
+        .send({ command: 'extensions list', args: [] })
+        .set('Content-Type', 'application/json')
+        .expect(200);
+
+      expect(res.body).toEqual(mockExtensions);
+      expect(getExtensionsSpy).toHaveBeenCalled();
+    });
+
+    it('should return 404 for invalid command', async () => {
+      const agent = request.agent(app);
+      const res = await agent
+        .post('/executeCommand')
+        .send({ command: 'invalid command' })
+        .set('Content-Type', 'application/json')
+        .expect(404);
+
+      expect(res.body.error).toBe('Command not found: invalid command');
+      expect(getExtensionsSpy).not.toHaveBeenCalled();
+    });
+
+    it('should return 400 for missing command', async () => {
+      const agent = request.agent(app);
+      await agent
+        .post('/executeCommand')
+        .send({ args: [] })
+        .set('Content-Type', 'application/json')
+        .expect(400);
+      expect(getExtensionsSpy).not.toHaveBeenCalled();
+    });
+
+    it('should return 400 if args is not an array', async () => {
+      const agent = request.agent(app);
+      const res = await agent
+        .post('/executeCommand')
+        .send({ command: 'extensions.list', args: 'not-an-array' })
+        .set('Content-Type', 'application/json')
+        .expect(400);
+
+      expect(res.body.error).toBe('"args" field must be an array.');
+      expect(getExtensionsSpy).not.toHaveBeenCalled();
+    });
+  });
 });

packages/a2a-server/src/http/app.ts

@@ -16,6 +16,10 @@ import type { AgentSettings } from '../types.js';
 import { GCSTaskStore, NoOpTaskStore } from '../persistence/gcs.js';
 import { CoderAgentExecutor } from '../agent/executor.js';
 import { requestStorage } from './requestStorage.js';
+import { loadConfig, loadEnvironment, setTargetDir } from '../config/config.js';
+import { loadSettings } from '../config/settings.js';
+import { loadExtensions } from '../config/extension.js';
+import { commandRegistry } from '../commands/command-registry.js';
 
 const coderAgentCard: AgentCard = {
   name: 'Gemini SDLC Agent',
@@ -61,6 +65,13 @@ export function updateCoderAgentCardUrl(port: number) {
 
 export async function createApp() {
   try {
+    // Load the server configuration once on startup.
+    const workspaceRoot = setTargetDir(undefined);
+    loadEnvironment();
+    const settings = loadSettings(workspaceRoot);
+    const extensions = loadExtensions(workspaceRoot);
+    const config = await loadConfig(settings, extensions, 'a2a-server');
+
     // loadEnvironment() is called within getConfig now
     const bucketName = process.env['GCS_BUCKET_NAME'];
     let taskStoreForExecutor: TaskStore;
@@ -119,6 +130,38 @@ export async function createApp() {
       }
     });
 
+    expressApp.post('/executeCommand', async (req, res) => {
+      try {
+        const { command, args } = req.body;
+
+        if (typeof command !== 'string') {
+          return res.status(400).json({ error: 'Invalid "command" field.' });
+        }
+
+        if (args && !Array.isArray(args)) {
+          return res
+            .status(400)
+            .json({ error: '"args" field must be an array.' });
+        }
+
+        const commandToExecute = commandRegistry.get(command);
+
+        if (!commandToExecute) {
+          return res
+            .status(404)
+            .json({ error: `Command not found: ${command}` });
+        }
+
+        const result = await commandToExecute.execute(config, args ?? []);
+        return res.status(200).json(result);
+      } catch (e) {
+        logger.error('Error executing /executeCommand:', e);
+        const errorMessage =
+          e instanceof Error ? e.message : 'Unknown error executing command';
+        return res.status(500).json({ error: errorMessage });
+      }
+    });
+
     expressApp.get('/tasks/metadata', async (req, res) => {
       // This endpoint is only meaningful if the task store is in-memory.
       if (!(taskStoreForExecutor instanceof InMemoryTaskStore)) {