@mcp-abap-adt/core 4.6.0 → 4.7.0

package/CHANGELOG.md

@@ -2,6 +2,11 @@
 
 ## [Unreleased]
 
+## [4.7.0] - 2026-04-01
+
+### Changed
+- Replace archived `node-rfc` with `@mcp-abap-adt/sap-rfc-lite` — a lightweight maintained fork with the same API surface. This change only affects RFC connections to legacy SAP systems (BASIS < 7.50). HTTP connections are not affected. If you experience issues with legacy RFC connections, please open an issue and downgrade to v4.6.0.
+
 ## [4.6.0] - 2026-03-31
 
 ### Added

package/dist/lib/config/ServerConfigManager.js

@@ -234,7 +234,7 @@ AUTHENTICATION:
   --mcp=<destination>              Default MCP destination name (for auth-broker mode)
                                    Example: --mcp=TRIAL
   --connection-type=<type>         SAP connection type: http (default) or rfc
-                                   RFC requires SAP NW RFC SDK + node-rfc installed
+                                   RFC requires SAP NW RFC SDK + @mcp-abap-adt/sap-rfc-lite installed
                                    Alternative: SAP_CONNECTION_TYPE env var in .env
   --system-type=<type>             SAP system type: cloud (default) | onprem | legacy
                                    Controls which tools are available

package/dist/server/launcher.js

@@ -159,7 +159,7 @@ SAP CONNECTION (.env file):
     SAP_USERNAME                   SAP username
     SAP_PASSWORD                   SAP password
     SAP_CLIENT                     SAP client number
-    Requires: SAP NW RFC SDK + node-rfc package installed
+    Requires: SAP NW RFC SDK + @mcp-abap-adt/sap-rfc-lite package installed
 
   System Context (on-premise):
     SAP_MASTER_SYSTEM              SAP system ID (e.g., DEV, QAS). Required for on-prem

package/docs/installation/RFC_SETUP.md

@@ -40,18 +40,18 @@ export PATH=$SAPNWRFC_HOME/lib:$PATH
 export LD_LIBRARY_PATH=$SAPNWRFC_HOME/lib:${LD_LIBRARY_PATH:-}
 ```
 
-### 3. node-rfc Package
+### 3. @mcp-abap-adt/sap-rfc-lite Package
 
 ```bash
-npm install node-rfc
+npm install @mcp-abap-adt/sap-rfc-lite
 ```
 
-`node-rfc` is loaded dynamically at runtime — it is not a declared dependency.
+`@mcp-abap-adt/sap-rfc-lite` is a lightweight fork of the archived `node-rfc` package, containing only the API surface needed for ADT RFC connections. It is loaded dynamically at runtime — it is not a declared dependency.
 
 Verify installation:
 
 ```bash
-node -e "try { require('node-rfc'); console.log('OK'); } catch(e) { console.log(e.message); }"
+node -e "try { require('@mcp-abap-adt/sap-rfc-lite'); console.log('OK'); } catch(e) { console.log(e.message); }"
 ```
 
 ### 4. SAP Authorization
@@ -83,13 +83,13 @@ SAP_CONNECTION_TYPE=rfc
 
 ## Troubleshooting
 
-### "node-rfc is not available"
+### "@mcp-abap-adt/sap-rfc-lite is not available"
 
 SAP NW RFC SDK is not installed or not in PATH. Check:
 
 ```bash
 echo $SAPNWRFC_HOME
-node -e "require('node-rfc')"
+node -e "require('@mcp-abap-adt/sap-rfc-lite')"
 ```
 
 ### "The specified module could not be found: sapnwrfc.node"

package/docs/roadmaps/LEGACY_SUPPORT.md

@@ -89,7 +89,7 @@ if (process.env.SAP_AUTH_TYPE === 'rfc') {
 ```
 
 `createAbapConnection()` from connection package already handles `authType: 'rfc'`.
-`node-rfc` is loaded dynamically — no error if not installed and not used.
+`@mcp-abap-adt/sap-rfc-lite` is loaded dynamically — no error if not installed and not used.
 
 ### Step 5: Launcher CLI support [DONE]
 
@@ -155,7 +155,7 @@ The [abapfs_extensions](https://github.com/marcellourbani/abapfs_extensions) pro
 
 | Risk | Mitigation |
 |------|-----------|
-| node-rfc needs SAP NW RFC SDK native lib | Dynamic import; graceful error if not installed; only loaded for `authType: 'rfc'` |
+| @mcp-abap-adt/sap-rfc-lite needs SAP NW RFC SDK native lib | Dynamic import; graceful error if not installed; only loaded for `connectionType: 'rfc'` |
 | Docker images need SDK | Document; provide Dockerfile with SDK layer |
 | Legacy endpoint differences between versions | Discovery-based detection, not hardcoded |
 | One extra HTTP call at startup (core/discovery) | Cached, happens once |

package/docs/superpowers/plans/2026-04-01-sap-rfc-lite.md

@@ -0,0 +1,848 @@
+# SAP RFC Lite — Lightweight node-rfc Fork
+
+> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
+
+**Goal:** Create a minimal, maintainable Node.js native addon that wraps SAP NW RFC SDK — replacing the archived `node-rfc` package with only the API surface we actually use.
+
+**Architecture:** Fork and strip `node-rfc` (Apache-2.0) down to a single `Client` class with `open()`, `call()`, `close()`, and `alive`. Remove Pool, Server, Throughput, and all unused client methods. Keep the full data type marshalling layer (nwrfcsdk.cc) since SAP FM parameter types are determined at runtime by the SDK.
+
+**Tech Stack:** C++17, Node-Addon-API (N-API v8), node-gyp, TypeScript, SAP NW RFC SDK
+
+---
+
+## File Structure
+
+### New package: `sap-rfc-lite/`
+
+Location: `/home/okyslytsia/prj/sap-rfc-lite/` (separate repo, publishable to npm)
+
+```
+sap-rfc-lite/
+├── package.json
+├── tsconfig.json
+├── binding.gyp
+├── LICENSE                          # Apache-2.0 (from node-rfc)
+├── NOTICE                           # Attribution to original SAP authors
+├── src/
+│   ├── cpp/
+│   │   ├── addon.cc                 # Entry point (Client only, no Pool/Server/Throughput)
+│   │   ├── Client.cc                # Client: Open, Close, Invoke, AliveGetter, connectionCheck
+│   │   ├── Client.h                 # Client class header (no Pool friend, no Pool*)
+│   │   ├── nwrfcsdk.cc              # Full data type marshalling (keep all types)
+│   │   ├── nwrfcsdk.h               # Types/structs (remove Pool/Server refs)
+│   │   └── noderfc.h                # Constants (remove Pool/Server constants)
+│   └── ts/
+│       ├── index.ts                 # Exports: Client, types
+│       ├── client.ts                # Client class (Promise-only, no callback API)
+│       ├── binding.ts               # Native addon loader
+│       └── types.ts                 # Minimal type definitions
+├── test/
+│   ├── client.test.ts               # Unit tests (mocked native binding)
+│   └── integration.test.ts          # Integration test (requires SAP NW RFC SDK)
+└── .github/
+    └── workflows/
+        └── build.yml                # CI: lint + typecheck (no SDK on CI)
+```
+
+### Files removed vs node-rfc
+
+| Removed file | Reason |
+|---|---|
+| `Pool.cc/h` (747+85 LOC) | Connection pooling not used |
+| `Server.cc/h` (634+144 LOC) | RFC inbound server not used |
+| `server_api.cc/h` (814+229 LOC) | Server API not used |
+| `Throughput.cc/h` (196+53 LOC) | Performance monitoring not used |
+| `Log.cc/h` (57+142 LOC) | Replace with minimal stderr logging |
+| `ext/date.h` | Only used by Log.h for formatting |
+| `sapnwrfc-pool.ts` | Pool class |
+| `sapnwrfc-server.ts` | Server class |
+| `sapnwrfc-throughput.ts` | Throughput class |
+
+**Reduction:** ~2,902 lines of C++ removed (Pool+Server+server_api+Throughput+Log). ~600 lines C++ remain (Client+addon). nwrfcsdk.cc (1,158 lines) kept intact — types are determined at runtime, removing "unused" ones would cause crashes.
+
+### Dependencies
+
+**Keep:**
+- `node-addon-api` ^6.1.0 — N-API C++ wrapper
+- `node-gyp-build` ^4.6.0 — native module loader
+
+**Remove:**
+- `bluebird` — unused (Promise-only API, no callback)
+- `decimal.js` — unused (BCD returns string by default)
+
+---
+
+## Tasks
+
+### Task 1: Initialize package structure
+
+**Files:**
+- Create: `sap-rfc-lite/package.json`
+- Create: `sap-rfc-lite/tsconfig.json`
+- Create: `sap-rfc-lite/LICENSE`
+- Create: `sap-rfc-lite/NOTICE`
+- Create: `sap-rfc-lite/.gitignore`
+
+- [ ] **Step 1: Create directory and init git**
+
+```bash
+mkdir -p /home/okyslytsia/prj/sap-rfc-lite
+cd /home/okyslytsia/prj/sap-rfc-lite
+git init
+```
+
+- [ ] **Step 2: Create package.json**
+
+```json
+{
+  "name": "sap-rfc-lite",
+  "version": "0.1.0",
+  "description": "Lightweight Node.js bindings for SAP NW RFC SDK",
+  "license": "Apache-2.0",
+  "main": "./lib/index.js",
+  "types": "./lib/index.d.ts",
+  "files": ["binding.gyp", "src", "lib"],
+  "scripts": {
+    "install": "node-gyp-build",
+    "build:ts": "tsc",
+    "build:cpp": "node-gyp rebuild",
+    "build": "npm run build:ts && npm run build:cpp",
+    "test": "jest --testTimeout 60000"
+  },
+  "config": {
+    "napi_version": 8
+  },
+  "dependencies": {
+    "node-addon-api": "^6.1.0",
+    "node-gyp-build": "^4.6.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "typescript": "^5.0.0",
+    "jest": "^29.0.0",
+    "ts-jest": "^29.0.0",
+    "@types/jest": "^29.0.0"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "gypfile": true
+}
+```
+
+- [ ] **Step 3: Create tsconfig.json**
+
+```json
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "commonjs",
+    "lib": ["ES2020"],
+    "outDir": "./lib",
+    "rootDir": "./src/ts",
+    "declaration": true,
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true
+  },
+  "include": ["src/ts/**/*"]
+}
+```
+
+- [ ] **Step 4: Create LICENSE (Apache-2.0) and NOTICE**
+
+Copy Apache-2.0 license. NOTICE file:
+```
+This project is based on node-rfc (https://github.com/SAP/node-rfc)
+Copyright 2014 SAP SE, Srdjan Boskovic <srdjan.boskovic@sap.com>
+Licensed under the Apache License, Version 2.0
+
+Modifications: Removed Pool, Server, Throughput classes. Simplified Client API to Promise-only.
+```
+
+- [ ] **Step 5: Create .gitignore**
+
+```
+node_modules/
+lib/
+build/
+prebuilds/
+*.node
+```
+
+- [ ] **Step 6: Commit**
+
+```bash
+git add -A
+git commit -m "chore: init sap-rfc-lite package structure"
+```
+
+---
+
+### Task 2: Port C++ source — noderfc.h (common header)
+
+**Files:**
+- Create: `sap-rfc-lite/src/cpp/noderfc.h`
+
+- [ ] **Step 1: Create stripped noderfc.h**
+
+Keep from original (`/tmp/node-rfc-source/src/cpp/noderfc.h`):
+- All includes (`napi.h`, `sapnwrfc.h`)
+- `ERRMSG_LENGTH`, `ERROR_PATH_NAME_LEN`
+- `uint_t`, `pointer_t`, `UNUSED`
+- `ENV_UNDEFINED`
+- `CLIENT_OPTION_BCD*`, `CLIENT_OPTION_DATE/TIME/FILTER/STATELESS/TIMEOUT`
+- `CALL_OPTION_KEY_*`
+
+Remove:
+- `SRV_OPTION_*` (server constants) — **including `SRV_OPTION_LOG_LEVEL`** which is referenced in `checkClientOptions()` in nwrfcsdk.cc; that branch must also be removed (see Task 3)
+- `POOL_*` (pool constants)
+
+Change `NODERFC_VERSION` to `"0.1.0"`.
+
+Add minimal debug logging macro (replaces entire Log class):
+```cpp
+// Minimal logging — no-op by default, stderr in debug builds
+#ifdef SAP_RFC_LITE_DEBUG
+  #include <cstdio>
+  #define RFC_LOG(fmt, ...) fprintf(stderr, "[sap-rfc-lite] " fmt "\n", ##__VA_ARGS__)
+#else
+  #define RFC_LOG(fmt, ...) ((void)0)
+#endif
+```
+
+- [ ] **Step 2: Commit**
+
+```bash
+git add src/cpp/noderfc.h
+git commit -m "feat: add noderfc.h common header (stripped)"
+```
+
+---
+
+### Task 3: Port C++ source — nwrfcsdk.h and nwrfcsdk.cc (data marshalling)
+
+**Files:**
+- Create: `sap-rfc-lite/src/cpp/nwrfcsdk.h`
+- Create: `sap-rfc-lite/src/cpp/nwrfcsdk.cc`
+
+**IMPORTANT:** All Log.h references must be removed NOW (not deferred). Every file must be compilable once all C++ files are in place.
+
+- [ ] **Step 1: Create nwrfcsdk.h**
+
+Copy from original, with these changes:
+- **Remove** `#include "Log.h"` — replace with `#include "noderfc.h"` only (which now has the `RFC_LOG` macro)
+- **Remove** `extern Log _log;` declaration
+- Remove `Pool`-related forward declarations if any
+- Keep all type definitions: `ConnectionParamsStruct`, `ClientOptionsStruct`, `RfmErrorPath`, `ValuePair`, `ErrorPair`
+- Keep all function declarations: `setString`, `setRfmParameter`, `setStructure`, `setVariable`, `getStructure`, `getVariable`, `getRfmParameters`, `getConnectionAttributes`
+- Keep error functions: `RfcLibError`, `AbapError`, `rfcSdkError`, `nodeRfcError`
+- Keep parsers: `getConnectionParams`, `checkClientOptions`
+
+- [ ] **Step 2: Create nwrfcsdk.cc**
+
+Copy from original (1,158 lines). This is the most critical file — handles all ABAP type conversions. Apply these targeted changes:
+
+1. **Replace all `_log.*()` calls** (5-6 occurrences):
+   - Lines 34-44: `_log.fatal(logClass::nwrfc, ...)` → keep the `Napi::Error::Fatal(...)` that follows it, remove the `_log.fatal` call itself (it's just informational before abort)
+   - Lines 68-78: same pattern
+   - Line 419-430: `_log.record(logClass::nwrfc, logLevel::all, ...)` → remove entirely (verbose trace, not useful)
+   - Lines 684-688: `_log.warning(logClass::nwrfc, ...)` → `RFC_LOG("Buffer for BCD type too small")`
+   - Lines 735-738: same pattern for DECF16/34
+
+2. **Remove the `logLevel` client option branch in `checkClientOptions()`** (line 1103-1105):
+   ```cpp
+   // REMOVE this entire block — SRV_OPTION_LOG_LEVEL is removed and Log class is gone:
+   else if (key == SRV_OPTION_LOG_LEVEL) {
+       _log.set_log_level(logClass::client, opt);
+   }
+   ```
+   Let it fall through to the "unknown option" error handler. This is correct because our lite version does not support per-client log level configuration.
+
+3. **Remove** `extern Log _log;` if present at top of file.
+
+- [ ] **Step 3: Commit**
+
+```bash
+git add src/cpp/nwrfcsdk.h src/cpp/nwrfcsdk.cc
+git commit -m "feat: add nwrfcsdk data marshalling layer (Log-free)"
+```
+
+---
+
+### Task 4: Port C++ source — Client.h and Client.cc
+
+**Files:**
+- Create: `sap-rfc-lite/src/cpp/Client.h`
+- Create: `sap-rfc-lite/src/cpp/Client.cc`
+
+- [ ] **Step 1: Create Client.h**
+
+From original, remove:
+- `#include "Log.h"` — replace with `#include "nwrfcsdk.h"` only
+- `extern Log _log;` declaration
+- `friend class Pool`, `friend class AcquireAsync`, `friend class ReleaseAsync`, `friend class CheckPoolAsync`
+- `friend class ResetServerAsync`, `friend class PingAsync`
+- `class Pool;` forward declaration
+- `Pool* pool` member
+- `Release()`, `Cancel()`, `ResetServerContext()`, `Ping()` method declarations
+- `ConfigGetter()`, `ConnectionHandleGetter()`, `PoolIdGetter()`, `ConnectionInfo()` — not needed
+- `log_id()` method (logging)
+
+Keep:
+- `friend class OpenAsync`, `friend class CloseAsync`, `friend class PrepareAsync`, `friend class InvokeAsync`
+- `Open()`, `Close()`, `Invoke()`, `AliveGetter()`, `IdGetter()`
+- `connectionCheck()`, `getOperationError()`, `connectionClosedError()`
+- `connectionHandle`, `client_params`, `client_options`, `errorPath`
+- `invocationMutex`, `LockMutex()`, `UnlockMutex()`
+- Constructor/destructor
+
+- [ ] **Step 2: Create Client.cc**
+
+From original (780 lines), keep:
+- `Client::Init()` — remove `cancel`, `release`, `resetServerContext`, `ping`, `connectionInfo` from `DefineClass`. Remove `_connectionHandle`, `_pool_id`, `_config` accessors.
+- `Client::AliveGetter()` — as-is
+- `Client::IdGetter()` — as-is
+- Constructor — remove pool-related logic, remove `clientOptionsRef` handling (not needed for our use case, but can keep for compatibility)
+- Destructor — remove `pool->releaseClient()` branch, keep direct close only
+- `OpenAsync` class — as-is
+- `CloseAsync` class — as-is
+- `PrepareAsync` class — as-is
+- `InvokeAsync` class — as-is
+- `Client::Open()` — remove pool check (`if (pool != nullptr)`)
+- `Client::Close()` — remove pool check
+- `Client::Invoke()` — as-is
+- `Client::connectionCheck()` — remove pool branch (`if (pool != nullptr)`), keep direct reconnect only
+- `Client::getOperationError()` — as-is
+- `Client::connectionClosedError()` — as-is
+- `Client::LockMutex()`, `Client::UnlockMutex()` — as-is
+
+Remove:
+- `Client::Release()` (~20 lines)
+- `Client::Cancel()` and `cancelConnection()` (~30 lines)
+- `Client::ResetServerContext()` (~15 lines)
+- `Client::Ping()` (~15 lines)
+- `ResetServerAsync` class (~35 lines)
+- `PingAsync` class (~33 lines)
+- `Client::ConnectionInfo()` (~6 lines)
+- `Client::ConfigGetter()` (~20 lines)
+- `Client::ConnectionHandleGetter()` (3 lines)
+- `Client::PoolIdGetter()` (5 lines)
+- `Client::NewInstance()` (4 lines)
+- `#include "Pool.h"`
+
+Replace all `_log.*()` calls (~10 occurrences) with `RFC_LOG(...)` macro or remove entirely. Remove `extern Log _log;` at file top. Replace `#include "Pool.h"` with nothing (Client.h already includes nwrfcsdk.h).
+
+In `connectionCheck()`: remove the `pool != nullptr` branches entirely. Keep only the direct client reconnect path:
+```cpp
+// Direct client reconnect (pool branches removed)
+this->connectionHandle = nullptr;
+RFC_CONNECTION_HANDLE new_handle = RfcOpenConnection(
+    client_params.connectionParams, client_params.paramSize, &errorInfoOpen);
+if (errorInfoOpen.code == RFC_OK) {
+    this->connectionHandle = new_handle;
+}
+```
+
+Also keep `connectionCheckErrorInit()` free function — it is used by `InvokeAsync`.
+
+- [ ] **Step 3: Compile-check the header dependencies**
+
+Verify Client.h includes are correct:
+```cpp
+#include "nwrfcsdk.h"  // includes noderfc.h → napi.h, sapnwrfc.h
+```
+
+- [ ] **Step 4: Commit**
+
+```bash
+git add src/cpp/Client.h src/cpp/Client.cc
+git commit -m "feat: add stripped Client class (open/close/invoke/alive)"
+```
+
+---
+
+### Task 5: Port C++ source — addon.cc (entry point)
+
+**Files:**
+- Create: `sap-rfc-lite/src/cpp/addon.cc`
+
+- [ ] **Step 1: Create minimal addon.cc**
+
+```cpp
+// SPDX-FileCopyrightText: 2014 SAP SE Srdjan Boskovic <srdjan.boskovic@sap.com>
+// SPDX-FileCopyrightText: 2026 sap-rfc-lite contributors
+//
+// SPDX-License-Identifier: Apache-2.0
+
+#include "Client.h"
+
+namespace node_rfc {
+
+Napi::Env __env = nullptr;
+
+Napi::Value BindingVersions(Napi::Env env) {
+  uint_t major, minor, patchLevel;
+  Napi::EscapableHandleScope scope(env);
+
+  RfcGetVersion(&major, &minor, &patchLevel);
+
+  Napi::Object nwrfcsdk = Napi::Object::New(env);
+  nwrfcsdk.Set("major", major);
+  nwrfcsdk.Set("minor", minor);
+  nwrfcsdk.Set("patchLevel", patchLevel);
+
+  Napi::Object version = Napi::Object::New(env);
+  version.Set("version", "0.1.0");
+  version.Set("nwrfcsdk", nwrfcsdk);
+
+  return scope.Escape(version);
+}
+
+Napi::Object RegisterModule(Napi::Env env, Napi::Object exports) {
+  if (node_rfc::__env == nullptr) {
+    node_rfc::__env = env;
+  }
+
+  exports.Set("bindingVersions", BindingVersions(env));
+  Client::Init(env, exports);
+
+  return exports;
+}
+
+NODE_API_MODULE(NODE_GYP_MODULE_NAME, RegisterModule)
+
+}  // namespace node_rfc
+```
+
+- [ ] **Step 2: Commit**
+
+```bash
+git add src/cpp/addon.cc
+git commit -m "feat: add addon entry point (Client only)"
+```
+
+---
+
+### Task 6: Create binding.gyp
+
+**Files:**
+- Create: `sap-rfc-lite/binding.gyp`
+
+- [ ] **Step 1: Create binding.gyp**
+
+Copy from original, with these changes:
+- Remove `Pool.cc`, `Server.cc`, `server_api.cc`, `Throughput.cc`, `Log.cc` from sources
+- Keep all platform conditions (mac/linux/win) — identical logic
+- Keep all defines (UNICODE, SAPwithTHREADS, NAPI_CPP_EXCEPTIONS, etc.)
+- Sources list becomes:
+
+```python
+'sources': [
+    'src/cpp/addon.cc',
+    'src/cpp/nwrfcsdk.cc',
+    'src/cpp/Client.cc',
+]
+```
+
+- [ ] **Step 2: Compile-verify C++ (requires SAP NW RFC SDK)**
+
+```bash
+cd /home/okyslytsia/prj/sap-rfc-lite
+npm install
+npm run build:cpp 2>&1
+```
+
+All C++ files should compile cleanly at this point — no Log.h, no Pool.h, no Server.h dependencies. If SDK is not available locally, at least verify `tsc` passes for TS and review C++ for any remaining `_log` / `Log` / `logClass` / `logLevel` references:
+```bash
+grep -rn '_log\.\|Log\|logClass\|logLevel' src/cpp/
+```
+
+- [ ] **Step 3: Commit**
+
+```bash
+git add binding.gyp
+git commit -m "feat: add binding.gyp build configuration"
+```
+
+---
+
+### Task 7: Port TypeScript — types.ts
+
+**Files:**
+- Create: `sap-rfc-lite/src/ts/types.ts`
+
+- [ ] **Step 1: Create minimal type definitions**
+
+```typescript
+// Connection parameters — same keys as SAP NW RFC SDK
+export type RfcConnectionParameters = Record<string, string>;
+
+// RFC data types
+export type RfcVariable = string | number | Buffer;
+export type RfcStructure = { [key: string]: RfcVariable | RfcStructure | RfcTable };
+export type RfcTable = Array<RfcVariable | RfcStructure>;
+export type RfcParameterValue = RfcVariable | RfcStructure | RfcTable;
+export type RfcObject = { [key: string]: RfcParameterValue };
+
+// Binding versions
+export interface RfcSdkVersions {
+  version: string;
+  nwrfcsdk: { major: number; minor: number; patchLevel: number };
+}
+
+// Error types
+export interface RfcLibError {
+  name: 'RfcLibError';
+  group: number;
+  code: number;
+  codeString: string;
+  key: string;
+  message: string;
+}
+
+export interface AbapError {
+  name: 'ABAPError';
+  group: number;
+  code: number;
+  codeString: string;
+  key: string;
+  message: string;
+  abapMsgClass: string;
+  abapMsgType: string;
+  abapMsgNumber: string;
+  abapMsgV1: string;
+  abapMsgV2: string;
+  abapMsgV3: string;
+  abapMsgV4: string;
+}
+
+export interface NodeRfcError {
+  name: 'nodeRfcError';
+  message: string;
+}
+
+export type RfcError = RfcLibError | AbapError | NodeRfcError;
+```
+
+- [ ] **Step 2: Commit**
+
+```bash
+git add src/ts/types.ts
+git commit -m "feat: add minimal type definitions"
+```
+
+---
+
+### Task 8: Port TypeScript — binding.ts (native addon loader)
+
+**Files:**
+- Create: `sap-rfc-lite/src/ts/binding.ts`
+
+- [ ] **Step 1: Create binding loader**
+
+```typescript
+import path from 'path';
+import { RfcConnectionParameters, RfcObject, RfcSdkVersions } from './types';
+
+export interface RfcClientBinding {
+  new (connectionParameters: RfcConnectionParameters): RfcClientBinding;
+  _id: number;
+  _alive: boolean;
+  open(callback: Function): void;
+  close(callback: Function): void;
+  invoke(
+    rfmName: string,
+    rfmParams: RfcObject,
+    callback: Function,
+    callOptions?: object
+  ): void;
+}
+
+export interface NativeBinding {
+  Client: RfcClientBinding;
+  bindingVersions: RfcSdkVersions;
+}
+
+let binding: NativeBinding;
+
+try {
+  // eslint-disable-next-line @typescript-eslint/no-var-requires
+  binding = require('node-gyp-build')(
+    path.resolve(__dirname, '..')
+  ) as NativeBinding;
+} catch (ex) {
+  const err = ex as Error;
+  const env = {
+    SAPNWRFC_HOME: process.env.SAPNWRFC_HOME || '(not set)',
+    platform: process.platform,
+    arch: process.arch,
+    node: process.version,
+  };
+  err.message += `\nEnvironment: ${JSON.stringify(env, null, 2)}`;
+  throw err;
+}
+
+export { binding };
+```
+
+- [ ] **Step 2: Commit**
+
+```bash
+git add src/ts/binding.ts
+git commit -m "feat: add native binding loader"
+```
+
+---
+
+### Task 9: Port TypeScript — client.ts (Client class, Promise-only)
+
+**Files:**
+- Create: `sap-rfc-lite/src/ts/client.ts`
+
+- [ ] **Step 1: Create Client class**
+
+Key difference from node-rfc: **Promise-only API**, no callback overloads, no pool support, no cancel/ping/resetServerContext.
+
+```typescript
+import { binding, RfcClientBinding } from './binding';
+import { RfcConnectionParameters, RfcObject } from './types';
+
+export class Client {
+  private __client: RfcClientBinding;
+
+  constructor(connectionParameters: RfcConnectionParameters) {
+    if (!connectionParameters || typeof connectionParameters !== 'object') {
+      throw new TypeError('Client constructor requires connection parameters object');
+    }
+    this.__client = new binding.Client(connectionParameters);
+  }
+
+  get id(): number {
+    return this.__client._id;
+  }
+
+  get alive(): boolean {
+    return this.__client._alive;
+  }
+
+  open(): Promise<this> {
+    return new Promise((resolve, reject) => {
+      try {
+        this.__client.open((err: unknown) => {
+          if (err !== undefined) {
+            reject(err);
+          } else {
+            resolve(this);
+          }
+        });
+      } catch (ex) {
+        reject(ex);
+      }
+    });
+  }
+
+  close(): Promise<void> {
+    return new Promise((resolve, reject) => {
+      try {
+        this.__client.close((err: unknown) => {
+          if (err === undefined) {
+            resolve();
+          } else {
+            reject(err);
+          }
+        });
+      } catch (ex) {
+        reject(ex);
+      }
+    });
+  }
+
+  call(rfmName: string, rfmParams: RfcObject = {}): Promise<RfcObject> {
+    return new Promise((resolve, reject) => {
+      if (typeof rfmName !== 'string' || rfmName.length === 0) {
+        reject(new TypeError('Function module name must be a non-empty string'));
+        return;
+      }
+      try {
+        this.__client.invoke(
+          rfmName,
+          rfmParams,
+          (err: unknown, res: RfcObject) => {
+            if (err !== undefined && err !== null) {
+              reject(err);
+            } else {
+              resolve(res);
+            }
+          }
+        );
+      } catch (ex) {
+        reject(ex);
+      }
+    });
+  }
+}
+```
+
+- [ ] **Step 2: Commit**
+
+```bash
+git add src/ts/client.ts
+git commit -m "feat: add Client class (Promise-only API)"
+```
+
+---
+
+### Task 10: Port TypeScript — index.ts (entry point)
+
+**Files:**
+- Create: `sap-rfc-lite/src/ts/index.ts`
+
+- [ ] **Step 1: Create index.ts**
+
+```typescript
+export { Client } from './client';
+export { binding } from './binding';
+export * from './types';
+```
+
+- [ ] **Step 2: Commit**
+
+```bash
+git add src/ts/index.ts
+git commit -m "feat: add package entry point"
+```
+
+---
+
+### Task 11: Write tests
+
+**Files:**
+- Create: `sap-rfc-lite/test/client.test.ts`
+- Create: `sap-rfc-lite/jest.config.ts`
+
+- [ ] **Step 1: Create jest.config.ts**
+
+```typescript
+export default {
+  preset: 'ts-jest',
+  testEnvironment: 'node',
+  roots: ['<rootDir>/test'],
+};
+```
+
+- [ ] **Step 2: Write unit test for Client class (type/API checks)**
+
+```typescript
+import { Client } from '../src/ts/client';
+
+// These tests verify the TypeScript API surface without requiring SAP NW RFC SDK.
+// Integration tests that actually call RFC need SDK + SAP system.
+
+describe('Client API surface', () => {
+  it('constructor requires connection parameters', () => {
+    expect(() => new Client(undefined as any)).toThrow(TypeError);
+    expect(() => new Client(null as any)).toThrow(TypeError);
+  });
+
+  it('exports expected types', () => {
+    // Verify the module exports compile correctly
+    const mod = require('../src/ts/index');
+    expect(mod.Client).toBeDefined();
+    expect(typeof mod.Client).toBe('function');
+  });
+});
+```
+
+Note: Full integration tests will be written after first successful build with SDK.
+
+- [ ] **Step 3: Commit**
+
+```bash
+git add test/ jest.config.ts
+git commit -m "test: add Client API surface tests"
+```
+
+---
+
+### Task 12: Integrate into mcp-abap-adt
+
+**Files:**
+- Modify: `mcp-abap-adt/package.json` — replace `node-rfc` with `sap-rfc-lite`
+- Modify: `mcp-abap-adt-clients` repo — update `require('node-rfc')` to `require('sap-rfc-lite')` in RfcAbapConnection **source** (not compiled .js in node_modules)
+
+- [ ] **Step 1: Update mcp-abap-adt package.json**
+
+Replace in `optionalDependencies`:
+```json
+"node-rfc": "^3.3.1"
+```
+with:
+```json
+"sap-rfc-lite": "file:../sap-rfc-lite"
+```
+(or npm registry path once published)
+
+- [ ] **Step 2: Update RfcAbapConnection import in mcp-abap-adt-clients repo**
+
+In `/home/okyslytsia/prj/mcp-abap-adt-clients` — the **source** of `@mcp-abap-adt/connection` package — change:
+```javascript
+const noderfc = require('node-rfc');
+Client = noderfc.Client;
+```
+to:
+```javascript
+const { Client } = require('sap-rfc-lite');
+```
+
+The API is identical: `Client` constructor takes connection params object, has `open()`, `call()`, `close()`, `alive`.
+
+- [ ] **Step 3: Verify RfcAbapConnection still works**
+
+The `call()` method in sap-rfc-lite wraps `invoke()` with a Promise — same as the original node-rfc `Client.call()`. Return structure is identical since nwrfcsdk.cc is unchanged.
+
+- [ ] **Step 4: Commit both repos**
+
+```bash
+# sap-rfc-lite
+cd /home/okyslytsia/prj/sap-rfc-lite
+git add -A
+git commit -m "chore: ready for integration"
+
+# mcp-abap-adt
+cd /home/okyslytsia/prj/mcp-abap-adt
+git add package.json
+git commit -m "feat: replace node-rfc with sap-rfc-lite"
+```
+
+---
+
+## API Compatibility Matrix
+
+| node-rfc API | sap-rfc-lite | Notes |
+|---|---|---|
+| `new Client(params)` | `new Client(params)` | Identical |
+| `client.open()` → Promise | `client.open()` → Promise | Identical |
+| `client.call(name, params)` → Promise | `client.call(name, params)` → Promise | Identical |
+| `client.close()` → Promise | `client.close()` → Promise | Identical |
+| `client.alive` | `client.alive` | Identical |
+| `client.open(callback)` | ❌ removed | Promise-only |
+| `client.ping()` | ❌ removed | Use `alive` property |
+| `client.cancel()` | ❌ removed | Not used |
+| `client.resetServerContext()` | ❌ removed | Not used |
+| `client.release()` | ❌ removed | Pool-only, removed |
+| `client.connectionInfo` | ❌ removed | Not used |
+| `Pool` class | ❌ removed | Not used |
+| `Server` class | ❌ removed | Not used |
+| `Throughput` class | ❌ removed | Not used |
+
+## Risk Assessment
+
+| Risk | Mitigation |
+|---|---|
+| nwrfcsdk.cc has subtle bugs we don't catch | Keep it verbatim — zero modifications to marshalling logic |
+| SAP NW RFC SDK version incompatibility | Same N-API version (8), same SDK API surface as node-rfc 3.3.1 |
+| Build fails on some platforms | Keep binding.gyp platform conditions identical to node-rfc |
+| connectionCheck() auto-reconnect breaks without Pool | Remove pool branch, keep direct client reconnect — simpler and correct |
+| SNC/TLS via RFC not supported | `loadCryptoLibrary()` and `setIniFileDirectory()` removed from addon.cc. Can be added back later if needed. Document as known limitation |

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@mcp-abap-adt/core",
   "mcpName": "io.github.fr0ster/mcp-abap-adt",
-  "version": "4.6.0",
+  "version": "4.7.0",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "exports": {
@@ -154,7 +154,7 @@
     "zod": "^4.3.6"
   },
   "optionalDependencies": {
-    "node-rfc": "^3.3.1"
+    "@mcp-abap-adt/sap-rfc-lite": "^0.1.0"
   },
   "engines": {
     "node": ">=20.0.0",