@mcp-abap-adt/core 2.1.8 → 2.2.0

package/CHANGELOG.md

@@ -2,14 +2,16 @@
 
 ## [Unreleased]
 
-## [2.1.8] - 2026-02-09
+## [2.2.0] - 2026-02-09
 ### Added
 - **MCP Registry metadata**: Added `server.json` and `mcpName` for registry publishing.
-- **Smithery sandbox entry**: Added `src/smithery-entry.ts` for capability scanning without real credentials.
+- **Client configurator**: Added `mcp-abap-adt-configure` to add/enable/disable/remove MCP entries across clients.
+- **Auto-config docs**: Added `docs/installation/CLIENT_INSTALLERS.md` with usage and common tasks.
 
 ### Changed
 - **Default logger loading**: Lazy-load logger to avoid bundler issues with optional transports.
-- **Smithery config**: Updated `smithery.yaml` to support `--env` or `--mcp` via `npx` stdio command.
+- **Claude config**: Write MCP settings under `projects.<full_path>.mcpServers` for Claude CLI on Linux.
+- **Config defaults**: New entries for Cline/Codex/Windsurf/Goose are disabled by default; enable explicitly.
 
 ## [2.1.7] - 2026-01-29
 ### Fixed

package/README.md

@@ -39,49 +39,9 @@ await server.connect(transport);
 2. **Configure**: See [Client Configuration](docs/user-guide/CLIENT_CONFIGURATION.md)
 3. **Use**: See [Available Tools](docs/user-guide/AVAILABLE_TOOLS.md)
 
-## Smithery (Local stdio)
+## MCP Registry
 
-This project ships a `smithery.yaml` that runs the server locally via `npx -y @mcp-abap-adt/core` (stdio transport).
-
-Smithery requires exactly one of these config fields:
-- `envPath` → maps to `--env=<path>` (use a specific `.env` file)
-- `mcpDestination` → maps to `--mcp=<destination>` (use service keys/auth-broker)
-
-Minimal parameter docs:
-- `--env` is documented in [CLI Options](docs/user-guide/CLI_OPTIONS.md#environment-file-configuration)
-- `--mcp` (auth-broker destination) is documented in [Client Configuration](docs/user-guide/CLIENT_CONFIGURATION.md#destination-based-authentication)
-
-### Smithery CLI examples
-
-**Codex:**
-```bash
-npx -y @smithery/cli install mcp-abap-adt --client codex
-```
-
-**Cline:**
-```bash
-npx -y @smithery/cli install mcp-abap-adt --client cline
-```
-
-**Claude:**
-```bash
-npx -y @smithery/cli install mcp-abap-adt --client claude
-```
-
-**Crush:**
-```bash
-npx -y @smithery/cli install mcp-abap-adt --client crush
-```
-
-**Goose:**
-```bash
-npx -y @smithery/cli install mcp-abap-adt --client goose
-```
-
-If a client name is not accepted by your CLI version, run:
-```bash
-npx -y @smithery/cli install --help
-```
+Published in the official MCP Registry. See `docs/deployment/MCP_REGISTRY.md` for full details.
 
 ## Features
 

package/bin/mcp-abap-adt-configure.js

@@ -0,0 +1,514 @@
+#!/usr/bin/env node
+
+const fs = require("fs");
+const path = require("path");
+const os = require("os");
+
+let yaml;
+try {
+  // Optional dependency already in package.json
+  // eslint-disable-next-line import/no-extraneous-dependencies
+  yaml = require("yaml");
+} catch {
+  yaml = null;
+}
+
+let toml;
+try {
+  // eslint-disable-next-line import/no-extraneous-dependencies
+  toml = require("@iarna/toml");
+} catch {
+  toml = null;
+}
+
+const args = process.argv.slice(2);
+const options = {
+  clients: [],
+  envPath: null,
+  mcpDestination: null,
+  name: null,
+  transport: "stdio",
+  command: "mcp-abap-adt",
+  dryRun: false,
+  force: false,
+  project: null,
+  disabled: false,
+  toggle: false,
+  remove: false,
+  configPath: null,
+};
+
+if (args.includes("--help") || args.includes("-h")) {
+  printHelp();
+  process.exit(0);
+}
+
+for (let i = 0; i < args.length; i += 1) {
+  const arg = args[i];
+  if (arg === "--client") {
+    options.clients.push(args[i + 1]);
+    i += 1;
+  } else if (arg === "--env") {
+    options.envPath = args[i + 1];
+    i += 1;
+  } else if (arg === "--mcp") {
+    options.mcpDestination = args[i + 1];
+    i += 1;
+  } else if (arg === "--name") {
+    options.name = args[i + 1];
+    i += 1;
+  } else if (arg === "--transport") {
+    options.transport = args[i + 1];
+    i += 1;
+  } else if (arg === "--command") {
+    options.command = args[i + 1];
+    i += 1;
+  } else if (arg === "--project") {
+    options.project = args[i + 1];
+    i += 1;
+  } else if (arg === "--config") {
+    options.configPath = args[i + 1];
+    i += 1;
+  } else if (arg === "--disable") {
+    options.disabled = true;
+    options.toggle = true;
+  } else if (arg === "--enable") {
+    options.disabled = false;
+    options.toggle = true;
+  } else if (arg === "--remove") {
+    options.remove = true;
+  } else if (arg === "--dry-run") {
+    options.dryRun = true;
+  } else if (arg === "--force") {
+    options.force = true;
+  }
+}
+
+if (options.clients.length === 0) {
+  fail("Provide at least one --client.");
+}
+
+if (!options.name) {
+  fail("Provide --name <serverName> (required).");
+}
+
+if (options.transport !== "stdio") {
+  fail("Only --transport stdio is supported by this installer.");
+}
+
+const requiresConnectionParams = !options.remove && !options.toggle;
+
+if (requiresConnectionParams) {
+  if (!options.envPath && !options.mcpDestination) {
+    fail("Provide either --env <path> or --mcp <destination>.");
+  }
+
+  if (options.envPath && options.mcpDestination) {
+    fail("Use only one of --env or --mcp.");
+  }
+}
+
+const platform = process.platform;
+const home = os.homedir();
+const appData =
+  process.env.APPDATA || path.join(home, "AppData", "Roaming");
+const userProfile = process.env.USERPROFILE || home;
+
+const serverArgsRaw = options.remove || options.toggle
+  ? []
+  : [
+      `--transport=${options.transport}`,
+      options.envPath
+        ? `--env=${options.envPath}`
+        : options.mcpDestination
+          ? `--mcp=${options.mcpDestination.toLowerCase()}`
+          : undefined,
+    ];
+const serverArgs = serverArgsRaw.filter(Boolean);
+
+for (const client of options.clients) {
+  switch (client) {
+    case "cline":
+      writeJsonConfig(
+        getClinePath(platform, home, appData),
+        options.name,
+        serverArgs,
+        "cline"
+      );
+      break;
+    case "codex":
+      writeCodexConfig(getCodexPath(platform, home, userProfile), options.name, serverArgs);
+      break;
+    case "claude":
+      writeClaudeConfig(
+        getClaudePath(platform, home, appData, options.configPath),
+        options.name,
+        serverArgs
+      );
+      break;
+    case "goose":
+      writeGooseConfig(
+        getGoosePath(platform, home, appData),
+        options.name,
+        serverArgs
+      );
+      break;
+    case "cursor":
+      writeJsonConfig(
+        getCursorPath(platform, home, userProfile),
+        options.name,
+        serverArgs,
+        "cursor"
+      );
+      break;
+    case "windsurf":
+      writeJsonConfig(
+        getWindsurfPath(platform, home, userProfile),
+        options.name,
+        serverArgs,
+        "windsurf"
+      );
+      break;
+    default:
+      fail(`Unknown client: ${client}`);
+  }
+}
+
+function getClinePath(platformValue, homeDir, appDataDir) {
+  if (platformValue === "win32") {
+    return path.join(
+      appDataDir,
+      "Code",
+      "User",
+      "globalStorage",
+      "saoudrizwan.claude-dev",
+      "settings",
+      "cline_mcp_settings.json"
+    );
+  }
+  return path.join(
+    homeDir,
+    ".config",
+    "Code",
+    "User",
+    "globalStorage",
+    "saoudrizwan.claude-dev",
+    "settings",
+    "cline_mcp_settings.json"
+  );
+}
+
+function getCodexPath(platformValue, homeDir, userProfileDir) {
+  if (platformValue === "win32") {
+    return path.join(userProfileDir, ".codex", "config.toml");
+  }
+  return path.join(homeDir, ".codex", "config.toml");
+}
+
+function getClaudePath(platformValue, homeDir, appDataDir, overridePath) {
+  if (overridePath) {
+    return overridePath;
+  }
+  if (platformValue === "darwin") {
+    return path.join(
+      homeDir,
+      "Library",
+      "Application Support",
+      "Claude",
+      "claude_desktop_config.json"
+    );
+  }
+  if (platformValue === "win32") {
+    return path.join(appDataDir, "Claude", "claude_desktop_config.json");
+  }
+  return path.join(homeDir, ".claude.json");
+}
+
+function getGoosePath(platformValue, homeDir, appDataDir) {
+  if (platformValue === "win32") {
+    return path.join(appDataDir, "Block", "goose", "config", "config.yaml");
+  }
+  return path.join(homeDir, ".config", "goose", "config.yaml");
+}
+
+function getCursorPath(_platformValue, homeDir, userProfileDir) {
+  const base = _platformValue === "win32" ? userProfileDir : homeDir;
+  return path.join(base, ".cursor", "mcp.json");
+}
+
+function getWindsurfPath(platformValue, homeDir, userProfileDir) {
+  if (platformValue === "win32") {
+    return path.join(userProfileDir, ".codeium", "windsurf", "mcp_config.json");
+  }
+  return path.join(homeDir, ".codeium", "windsurf", "mcp_config.json");
+}
+
+function getDefaultDisabled(clientType) {
+  return ["cline", "codex", "windsurf", "goose"].includes(clientType);
+}
+
+function writeJsonConfig(filePath, serverName, argsArray, clientType) {
+  ensureDir(filePath);
+  const data = readJson(filePath);
+  data.mcpServers = data.mcpServers || {};
+  if (options.toggle && clientType === "cursor") {
+    fail("Cursor does not support enable/disable. Use --remove instead.");
+  }
+  if (options.toggle) {
+    if (!data.mcpServers[serverName]) {
+      fail(`Server "${serverName}" not found in ${filePath}.`);
+    }
+    data.mcpServers[serverName] = {
+      ...data.mcpServers[serverName],
+      disabled: options.disabled || undefined,
+    };
+    writeFile(filePath, JSON.stringify(data, null, 2));
+    return;
+  }
+  if (options.remove) {
+    if (!data.mcpServers[serverName]) {
+      fail(`Server "${serverName}" not found in ${filePath}.`);
+    }
+    delete data.mcpServers[serverName];
+    writeFile(filePath, JSON.stringify(data, null, 2));
+    return;
+  }
+  if (data.mcpServers[serverName] && !options.force) {
+    fail(
+      `Server "${serverName}" already exists in ${filePath}. Use --force to overwrite.`
+    );
+  }
+  data.mcpServers[serverName] = {
+    command: options.command,
+    args: argsArray,
+    disabled:
+      options.disabled || (getDefaultDisabled(clientType) ? true : undefined),
+  };
+  writeFile(filePath, JSON.stringify(data, null, 2));
+}
+
+function writeClaudeConfig(filePath, serverName, argsArray) {
+  ensureDir(filePath);
+  const data = readJson(filePath);
+  if (!options.project) {
+    options.project = process.cwd();
+  }
+  data.projects = data.projects || {};
+  if (!data.projects[options.project]) {
+    data.projects[options.project] = {
+      allowedTools: [],
+      mcpContextUris: [],
+      mcpServers: {},
+    };
+  }
+  data.projects[options.project].mcpServers =
+    data.projects[options.project].mcpServers || {};
+  if (options.toggle) {
+    fail("Claude does not support enable/disable. Use --remove instead.");
+  }
+  if (options.remove) {
+    if (!data.projects[options.project].mcpServers[serverName]) {
+      fail(`Server "${serverName}" not found for ${options.project}.`);
+    }
+    delete data.projects[options.project].mcpServers[serverName];
+    writeFile(filePath, JSON.stringify(data, null, 2));
+    return;
+  }
+  if (data.projects[options.project].mcpServers[serverName] && !options.force) {
+    fail(
+      `Server "${serverName}" already exists for ${options.project}. Use --force to overwrite.`
+    );
+  }
+  data.projects[options.project].mcpServers[serverName] = {
+    type: "stdio",
+    command: options.command,
+    args: argsArray,
+    env: {},
+  };
+  writeFile(filePath, JSON.stringify(data, null, 2));
+}
+
+function writeCodexConfig(filePath, serverName, argsArray) {
+  ensureDir(filePath);
+  if (!toml) {
+    fail("TOML dependency not available. Install dependencies and retry.");
+  }
+
+  const data = readToml(filePath);
+  data.mcp_servers = data.mcp_servers || {};
+  const defaultEnabled = !getDefaultDisabled("codex");
+
+  if (options.remove) {
+    if (!data.mcp_servers[serverName]) {
+      fail(`Server "${serverName}" not found in ${filePath}.`);
+    }
+    delete data.mcp_servers[serverName];
+    writeFile(filePath, toml.stringify(data));
+    return;
+  }
+
+  if (options.toggle) {
+    if (!data.mcp_servers[serverName]) {
+      fail(`Server "${serverName}" not found in ${filePath}.`);
+    }
+    data.mcp_servers[serverName] = {
+      ...data.mcp_servers[serverName],
+      enabled: !options.disabled,
+    };
+    writeFile(filePath, toml.stringify(data));
+    return;
+  }
+
+  if (data.mcp_servers[serverName] && !options.force) {
+    fail(
+      `Server "${serverName}" already exists in ${filePath}. Use --force to overwrite.`
+    );
+  }
+
+  data.mcp_servers[serverName] = {
+    command: options.command,
+    args: argsArray,
+    enabled: options.disabled ? false : defaultEnabled,
+  };
+
+  writeFile(filePath, toml.stringify(data));
+}
+
+function writeGooseConfig(filePath, serverName, argsArray) {
+  if (!yaml) {
+    fail("YAML dependency not available. Install dependencies and retry.");
+  }
+  ensureDir(filePath);
+  const data = readYaml(filePath);
+  data.extensions = data.extensions || {};
+  if (options.toggle) {
+    if (!data.extensions[serverName]) {
+      fail(`Server "${serverName}" not found in ${filePath}.`);
+    }
+    data.extensions[serverName] = {
+      ...data.extensions[serverName],
+      enabled: !options.disabled,
+    };
+    writeFile(filePath, yaml.stringify(data));
+    return;
+  }
+  if (options.remove) {
+    if (!data.extensions[serverName]) {
+      fail(`Server "${serverName}" not found in ${filePath}.`);
+    }
+    delete data.extensions[serverName];
+    writeFile(filePath, yaml.stringify(data));
+    return;
+  }
+  if (data.extensions[serverName] && !options.force) {
+    fail(
+      `Server "${serverName}" already exists in ${filePath}. Use --force to overwrite.`
+    );
+  }
+  data.extensions[serverName] = {
+    name: "MCP ABAP ADT",
+    cmd: options.command,
+    args: argsArray,
+    type: "stdio",
+    enabled: options.disabled ? false : !getDefaultDisabled("goose"),
+    timeout: 300,
+  };
+  writeFile(filePath, yaml.stringify(data));
+}
+
+function readJson(filePath) {
+  if (!fs.existsSync(filePath)) {
+    return {};
+  }
+  const raw = fs.readFileSync(filePath, "utf8").trim();
+  if (!raw) {
+    return {};
+  }
+  try {
+    return JSON.parse(raw);
+  } catch {
+    fail(`Invalid JSON: ${filePath}`);
+  }
+}
+
+function readYaml(filePath) {
+  if (!fs.existsSync(filePath)) {
+    return {};
+  }
+  const raw = fs.readFileSync(filePath, "utf8").trim();
+  if (!raw) {
+    return {};
+  }
+  try {
+    return yaml.parse(raw) || {};
+  } catch {
+    fail(`Invalid YAML: ${filePath}`);
+  }
+}
+
+function readToml(filePath) {
+  if (!fs.existsSync(filePath)) {
+    return {};
+  }
+  const raw = fs.readFileSync(filePath, "utf8").trim();
+  if (!raw) {
+    return {};
+  }
+  try {
+    return toml.parse(raw) || {};
+  } catch {
+    fail(`Invalid TOML: ${filePath}`);
+  }
+}
+
+function ensureDir(filePath) {
+  const dir = path.dirname(filePath);
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+}
+
+function writeFile(filePath, content) {
+  if (options.dryRun) {
+    process.stdout.write(`\n# ${filePath}\n${content}\n`);
+    return;
+  }
+  fs.writeFileSync(filePath, content, "utf8");
+  process.stdout.write(`Updated ${filePath}\n`);
+}
+
+function escapeRegex(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+function fail(message) {
+  process.stderr.write(`${message}\n`);
+  process.exit(1);
+}
+
+function printHelp() {
+  process.stdout.write(`mcp-abap-adt-configure
+
+Usage:
+  mcp-abap-adt-configure --client <name> --name <serverName> [--env <path> | --mcp <dest>] [options]
+
+Options:
+  --client <name>       cline | codex | claude | goose | cursor | windsurf (repeatable)
+  --name <serverName>   required MCP server name key
+  --env <path>          .env path (add/update only)
+  --mcp <dest>          destination name (add/update only)
+  --transport <type>    only stdio supported
+  --command <bin>       command to run (default: mcp-abap-adt)
+  --project <path>      Claude project path (defaults to cwd)
+  --config <path>       override client config path (Claude Linux)
+  --disable             disable entry (Codex/Cline/Windsurf/Goose only)
+  --enable              enable entry (Codex/Cline/Windsurf/Goose only)
+  --remove              remove entry
+  --force               overwrite existing entry (add/update)
+  --dry-run             print changes without writing files
+  -h, --help            show this help
+
+Notes:
+  New entries for Cline/Codex/Windsurf/Goose are added disabled by default.
+`);
+}

package/docs/README.md

@@ -48,6 +48,8 @@ Documentation for developers: testing, development guides, and internal document
 - **Getting Started**: [Installation Guide](installation/INSTALLATION.md)
 - **User Configuration**: [Client Configuration](user-guide/CLIENT_CONFIGURATION.md)
 - **Server Configuration**: [YAML Config](configuration/YAML_CONFIG.md) | [CLI Options](user-guide/CLI_OPTIONS.md)
+- **Deployment**: [MCP Registry](deployment/MCP_REGISTRY.md) | [Docker](deployment/DOCKER.md)
+- **Client Configuration**: [Auto-Configure](installation/CLIENT_INSTALLERS.md)
 - **Available Tools**: [Tools List](user-guide/AVAILABLE_TOOLS.md)
 - **Architecture**: [Stateful Sessions](architecture/STATEFUL_SESSION_GUIDE.md) | [Architecture Docs](architecture/README.md)
 - **Development**: [Development Documentation](development/)

package/docs/deployment/MCP_REGISTRY.md

@@ -0,0 +1,34 @@
+# MCP Registry Publishing
+
+This project is published in the official MCP Registry.
+
+## Prerequisites
+- Install `mcp-publisher` (see official docs).
+- Ensure the npm package is published and contains `mcpName` in `package.json`.
+
+## Required Metadata
+
+- `server.json` in the repository root
+- `mcpName` in `package.json`
+
+Expected values:
+- Registry name: `io.github.fr0ster/mcp-abap-adt`
+- npm package: `@mcp-abap-adt/core` (stdio)
+
+## Publish
+
+```bash
+mcp-publisher login github
+mcp-publisher publish
+```
+
+## Verify
+
+```bash
+curl "https://registry.modelcontextprotocol.io/v0/servers?search=io.github.fr0ster/mcp-abap-adt"
+```
+
+## Notes
+
+- Keep `server.json` version in sync with the npm package version.
+- If publish fails with “missing mcpName”, publish a new npm version that includes `mcpName`.

package/docs/deployment/README.md

@@ -11,6 +11,11 @@ This directory contains documentation for deploying and releasing MCP ABAP ADT S
   - Multi-stage builds
   - Production best practices
 
+- **[MCP_REGISTRY.md](./MCP_REGISTRY.md)** - MCP Registry publishing
+  - `server.json` and `mcpName` metadata
+  - Publish with `mcp-publisher`
+  - Verification steps
+
 - **[RELEASE.md](./RELEASE.md)** - Release process documentation
   - Automated releases via GitHub Actions
   - Manual release process

package/docs/installation/CLIENT_INSTALLERS.md

@@ -0,0 +1,91 @@
+# Client Auto-Configure
+
+This helper writes MCP configuration entries for popular clients.
+
+## Install
+
+```bash
+npm install -g @mcp-abap-adt/core
+```
+
+## Usage
+
+```bash
+mcp-abap-adt-configure --client cline --env /path/to/.env --name abap
+mcp-abap-adt-configure --client cline --mcp TRIAL --name abap
+mcp-abap-adt-configure --client cline --env /path/to/.env --name abap --transport stdio
+mcp-abap-adt-configure --client claude --mcp TRIAL --name abap --project /home/user/prj/myproj
+mcp-abap-adt-configure --client codex --name abap --remove
+```
+
+## Common Tasks
+
+Add MCP:
+```bash
+mcp-abap-adt-configure --client codex --mcp TRIAL --name abap
+mcp-abap-adt-configure --client cline --env /path/to/.env --name abap
+mcp-abap-adt-configure --client claude --mcp TRIAL --name abap --project /home/user/prj/myproj
+```
+
+Disable MCP:
+```bash
+mcp-abap-adt-configure --client codex --name abap --disable
+mcp-abap-adt-configure --client cline --name abap --disable
+```
+
+Enable MCP:
+```bash
+mcp-abap-adt-configure --client codex --name abap --enable
+mcp-abap-adt-configure --client cline --name abap --enable
+```
+
+Remove MCP:
+```bash
+mcp-abap-adt-configure --client codex --name abap --remove
+mcp-abap-adt-configure --client cline --name abap --remove
+mcp-abap-adt-configure --client claude --name abap --project /home/user/prj/myproj --remove
+```
+
+Options:
+- `--client <name>` (repeatable): `cline`, `codex`, `claude`, `goose`, `cursor`, `windsurf`
+- `--env <path>`: use a specific `.env` file
+- `--mcp <destination>`: use service key destination
+- `--name <serverName>`: MCP server name (required)
+- `--transport <type>`: transport type (only `stdio` supported)
+- `--command <bin>`: command to run (default: `mcp-abap-adt`)
+- `--project <path>`: project path for Claude Desktop (defaults to current directory)
+- `--config <path>`: override client config path (optional for Claude on Linux; default: `~/.claude.json`)
+- `--disable`: disable server entry (Codex: `enabled = false`, Cline: `disabled = true`)
+- `--enable`: enable server entry (Codex: `enabled = true`, Cline: `disabled = false`)
+- `--remove`: remove server entry from client config
+
+Notes:
+- `--disable` and `--remove` do not require `--env` or `--mcp`.
+- Cursor ignores enable/disable via `mcp.json`; use `--remove` instead.
+- New entries for Cline, Codex, Windsurf, and Goose are added **disabled by default**. Use `--enable` to turn them on.
+- `--enable`/`--disable` only work if the server entry already exists. Use add commands with `--env` or `--mcp` first.
+- `--dry-run`: print changes without writing files
+- `--force`: overwrite existing server entry if it exists
+
+## Config Locations
+
+Paths are client-specific and OS-dependent. The installer writes config files in:
+
+- **Cline**:
+  - Linux/macOS: `~/.config/Code/User/globalStorage/saoudrizwan.claude-dev/settings/cline_mcp_settings.json`
+  - Windows: `%APPDATA%\Code\User\globalStorage\saoudrizwan.claude-dev\settings\cline_mcp_settings.json`
+- **Codex**:
+  - Linux/macOS: `~/.codex/config.toml`
+  - Windows: `%USERPROFILE%\.codex\config.toml`
+- **Claude Desktop**:
+  - macOS: `~/Library/Application Support/Claude/claude_desktop_config.json`
+  - Windows: `%APPDATA%\Claude\claude_desktop_config.json`
+- **Goose**:
+  - Linux/macOS: `~/.config/goose/config.yaml`
+  - Windows: `%APPDATA%\Block\goose\config\config.yaml`
+- **Cursor**:
+  - Linux/macOS: `~/.cursor/mcp.json`
+  - Windows: `%USERPROFILE%\.cursor\mcp.json`
+- **Windsurf**:
+  - Linux/macOS: `~/.codeium/windsurf/mcp_config.json`
+  - Windows: `%USERPROFILE%\.codeium\windsurf\mcp_config.json`

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@mcp-abap-adt/core",
   "mcpName": "io.github.fr0ster/mcp-abap-adt",
-  "version": "2.1.8",
+  "version": "2.2.0",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "exports": {
@@ -127,6 +127,7 @@
     "@mcp-abap-adt/interfaces": "^0.2.15",
     "@mcp-abap-adt/logger": "^0.1.4",
     "@modelcontextprotocol/sdk": "^1.26.0",
+    "@iarna/toml": "^2.2.5",
     "axios": "^1.13.5",
     "fast-xml-parser": "^5.3.5",
     "js-yaml": "^4.1.1",
@@ -149,7 +150,8 @@
   ],
   "bin": {
     "mcp-abap-adt": "./bin/mcp-abap-adt.js",
-    "mcp-abap-adt-v2": "./bin/mcp-abap-adt-v2.js"
+    "mcp-abap-adt-v2": "./bin/mcp-abap-adt-v2.js",
+    "mcp-abap-adt-configure": "./bin/mcp-abap-adt-configure.js"
   },
   "jest": {
     "preset": "ts-jest",