feat (ui) - use acp to manage global config and session extensions

ui/desktop/src/acp/extensions.ts

@@ -1,7 +1,14 @@
-import type { ExtensionResponse, ExtensionEntry } from '../api';
-import type { GooseExtension, GooseExtensionEntry, McpServer } from '@aaif/goose-sdk';
+import type { ExtensionConfig, ExtensionEntry } from '../api';
+import type { GooseExtension, GooseExtensionEntry } from '@aaif/goose-sdk';
 import { getAcpClient } from './acpConnection';
 
+export type ConfiguredExtensionEntry = ExtensionEntry & { configKey?: string };
+
+export interface ConfiguredExtensionsResponse {
+  extensions: ConfiguredExtensionEntry[];
+  warnings: string[];
+}
+
 export function gooseExtensionName(extension: GooseExtension): string {
   return extension.type === 'mcp' ? extension.server.name : extension.name;
 }
@@ -10,63 +17,54 @@ function headersToRecord(headers: { name: string; value: string }[] = []) {
   return Object.fromEntries(headers.map(({ name, value }) => [name, value]));
 }
 
-function mcpServerToExtension(
-  server: McpServer,
-  entry: GooseExtensionEntry
-): ExtensionEntry | null {
-  const extension = entry.extension;
-  if (extension.type !== 'mcp') {
-    return null;
-  }
-
-  if ('command' in server) {
-    return {
-      type: 'stdio',
-      enabled: entry.enabled,
-      name: server.name,
-      description: extension.description ?? '',
-      cmd: server.command,
-      args: server.args,
-      env_keys: extension.envKeys ?? [],
-      timeout: extension.timeout,
-      bundled: extension.bundled,
-    };
-  }
-
-  if ('url' in server) {
-    return {
-      type: 'streamable_http',
-      enabled: entry.enabled,
-      name: server.name,
-      description: extension.description ?? '',
-      uri: server.url,
-      headers: headersToRecord(server.headers),
-      env_keys: extension.envKeys ?? [],
-      timeout: extension.timeout,
-      socket: extension.socket,
-      bundled: extension.bundled,
-    };
-  }
-
-  return null;
-}
-
-function gooseExtensionEntryToExtensionEntry(entry: GooseExtensionEntry): ExtensionEntry | null {
-  const extension = entry.extension;
-
+export function gooseExtensionToExtensionConfig(extension: GooseExtension): ExtensionConfig | null {
   switch (extension.type) {
     case 'builtin':
     case 'platform':
       return {
         ...extension,
         description: extension.description ?? '',
-        enabled: entry.enabled,
       };
-    case 'mcp':
-      return mcpServerToExtension(extension.server, entry);
+    case 'mcp': {
+      const server = extension.server;
+      if ('command' in server) {
+        return {
+          type: 'stdio',
+          name: server.name,
+          description: extension.description ?? '',
+          cmd: server.command,
+          args: server.args,
+          env_keys: extension.envKeys ?? [],
+          timeout: extension.timeout,
+          bundled: extension.bundled,
+        };
+      }
+      if ('url' in server) {
+        return {
+          type: 'streamable_http',
+          name: server.name,
+          description: extension.description ?? '',
+          uri: server.url,
+          headers: headersToRecord(server.headers),
+          env_keys: extension.envKeys ?? [],
+          timeout: extension.timeout,
+          socket: extension.socket,
+          bundled: extension.bundled,
+        };
+      }
+      return null;
+    }
   }
+}
 
-  return null;
+function gooseExtensionEntryToExtensionEntry(
+  entry: GooseExtensionEntry
+): ConfiguredExtensionEntry | null {
+  const config = gooseExtensionToExtensionConfig(entry.extension);
+  if (!config) {
+    return null;
+  }
+  return { ...config, enabled: entry.enabled, configKey: entry.configKey ?? undefined };
 }
 
 export async function getConfiguredGooseExtensions(): Promise<GooseExtensionEntry[]> {
@@ -75,13 +73,85 @@ export async function getConfiguredGooseExtensions(): Promise<GooseExtensionEntr
   return response.extensions;
 }
 
-export async function getConfiguredExtensions(): Promise<ExtensionResponse> {
+export async function getConfiguredExtensions(): Promise<ConfiguredExtensionsResponse> {
   const client = await getAcpClient();
   const response = await client.goose.configExtensionsList_unstable({});
   return {
     extensions: response.extensions
       .map(gooseExtensionEntryToExtensionEntry)
-      .filter((entry): entry is ExtensionEntry => entry !== null),
+      .filter((entry): entry is ConfiguredExtensionEntry => entry !== null),
     warnings: response.warnings ?? [],
   };
 }
+
+export function extensionConfigToGooseExtension(config: ExtensionConfig): GooseExtension | null {
+  switch (config.type) {
+    case 'builtin':
+      return {
+        type: 'builtin',
+        name: config.name,
+        description: config.description,
+        display_name: config.display_name,
+        timeout: config.timeout,
+        bundled: config.bundled,
+      };
+    case 'platform':
+      return {
+        type: 'platform',
+        name: config.name,
+        description: config.description,
+        display_name: config.display_name,
+        bundled: config.bundled,
+      };
+    case 'stdio':
+      return {
+        type: 'mcp',
+        server: { name: config.name, command: config.cmd, args: config.args, env: [] },
+        envKeys: config.env_keys ?? [],
+        description: config.description,
+        timeout: config.timeout,
+        bundled: config.bundled,
+      };
+    case 'streamable_http':
+      return {
+        type: 'mcp',
+        server: {
+          type: 'http',
+          name: config.name,
+          url: config.uri,
+          headers: Object.entries(config.headers ?? {}).map(([name, value]) => ({ name, value })),
+        },
+        envKeys: config.env_keys ?? [],
+        description: config.description,
+        timeout: config.timeout,
+        socket: config.socket,
+        bundled: config.bundled,
+      };
+    case 'sse':
+    case 'frontend':
+    case 'inline_python':
+      return null;
+  }
+}
+
+export async function addConfigExtension(config: ExtensionConfig, enabled: boolean): Promise<void> {
+  const extension = extensionConfigToGooseExtension(config);
+  if (!extension) {
+    throw new Error(`Unsupported extension type for ACP: ${config.type}`);
+  }
+  const client = await getAcpClient();
+  await client.goose.configExtensionsAdd_unstable({ extension, enabled });
+}
+
+export async function removeConfigExtension(configKey: string): Promise<void> {
+  const client = await getAcpClient();
+  await client.goose.configExtensionsRemove_unstable({ configKey });
+}
+
+export async function setConfigExtensionEnabled(
+  configKey: string,
+  enabled: boolean
+): Promise<void> {
+  const client = await getAcpClient();
+  await client.goose.configExtensionsSetEnabled_unstable({ configKey, enabled });
+}

ui/desktop/src/acp/session-extensions.ts

@@ -0,0 +1,28 @@
+import type { ExtensionConfig } from '../api';
+import { getAcpClient } from './acpConnection';
+import { extensionConfigToGooseExtension, gooseExtensionToExtensionConfig } from './extensions';
+
+export async function getSessionExtensions(sessionId: string): Promise<ExtensionConfig[]> {
+  const client = await getAcpClient();
+  const response = await client.goose.sessionExtensionsList_unstable({ sessionId });
+  return response.extensions
+    .map(gooseExtensionToExtensionConfig)
+    .filter((config): config is ExtensionConfig => config !== null);
+}
+
+export async function addSessionExtension(
+  sessionId: string,
+  config: ExtensionConfig
+): Promise<void> {
+  const extension = extensionConfigToGooseExtension(config);
+  if (!extension) {
+    throw new Error(`Unsupported extension type for ACP: ${config.type}`);
+  }
+  const client = await getAcpClient();
+  await client.goose.sessionExtensionsAdd_unstable({ sessionId, extension });
+}
+
+export async function removeSessionExtension(sessionId: string, name: string): Promise<void> {
+  const client = await getAcpClient();
+  await client.goose.sessionExtensionsRemove_unstable({ sessionId, name });
+}