@mcp-abap-adt/proxy 1.6.4 → 4.0.0

package/dist/mcp/configs.d.ts

@@ -0,0 +1,33 @@
+export interface ProxyConfigEntry {
+    /** The file name without its extension — what a client asks for. */
+    name: string;
+    file: string;
+    /** From the config, when it could be read. Listing is best-effort. */
+    destination?: string;
+    targetUrl?: string;
+}
+/**
+ * Where a user keeps proxy configs, beside the service keys and sessions the
+ * rest of the toolchain already uses.
+ */
+export declare function proxyConfigDir(): string;
+/**
+ * The configs on disk.
+ *
+ * A file that cannot be parsed is still LISTED, with no destination beside it.
+ * Hiding it would make "no such config" the error a user gets for a file
+ * sitting right there in the directory they are looking at.
+ */
+export declare function listProxyConfigs(dir?: string): ProxyConfigEntry[];
+/**
+ * The file a name refers to.
+ *
+ * Accepts either the bare name or the file name as written. A name that would
+ * leave the directory is refused rather than resolved: the value comes from a
+ * language model, and `../sessions/nvcr.env` is a real path in a real
+ * neighbouring folder full of credentials.
+ */
+export declare function resolveProxyConfig(name: string, dir?: string): string;
+/** Read a config's own comment header, for a listing a human can recognise. */
+export declare function describeConfig(entry: ProxyConfigEntry): string;
+//# sourceMappingURL=configs.d.ts.map

package/dist/mcp/configs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"configs.d.ts","sourceRoot":"","sources":["../../src/mcp/configs.ts"],"names":[],"mappings":"AAQA,MAAM,WAAW,gBAAgB;IAC/B,oEAAoE;IACpE,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,sEAAsE;IACtE,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED;;;GAGG;AACH,wBAAgB,cAAc,IAAI,MAAM,CAEvC;AAED;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAC9B,GAAG,GAAE,MAAyB,GAC7B,gBAAgB,EAAE,CAiCpB;AAED;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAChC,IAAI,EAAE,MAAM,EACZ,GAAG,GAAE,MAAyB,GAC7B,MAAM,CAgCR;AAED,+EAA+E;AAC/E,wBAAgB,cAAc,CAAC,KAAK,EAAE,gBAAgB,GAAG,MAAM,CAS9D"}

package/dist/mcp/configs.js

@@ -0,0 +1,142 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.proxyConfigDir = proxyConfigDir;
+exports.listProxyConfigs = listProxyConfigs;
+exports.resolveProxyConfig = resolveProxyConfig;
+exports.describeConfig = describeConfig;
+// src/mcp/configs.ts
+const node_fs_1 = require("node:fs");
+const path = __importStar(require("node:path"));
+const config_js_1 = require("../lib/config.js");
+const stores_js_1 = require("../lib/stores.js");
+const EXTENSIONS = ['.yaml', '.yml', '.json'];
+/**
+ * Where a user keeps proxy configs, beside the service keys and sessions the
+ * rest of the toolchain already uses.
+ */
+function proxyConfigDir() {
+    return (0, stores_js_1.storeDir)('proxy');
+}
+/**
+ * The configs on disk.
+ *
+ * A file that cannot be parsed is still LISTED, with no destination beside it.
+ * Hiding it would make "no such config" the error a user gets for a file
+ * sitting right there in the directory they are looking at.
+ */
+function listProxyConfigs(dir = proxyConfigDir()) {
+    if (!(0, node_fs_1.existsSync)(dir))
+        return [];
+    const entries = [];
+    for (const name of (0, node_fs_1.readdirSync)(dir).sort()) {
+        const file = path.join(dir, name);
+        const extension = path.extname(name).toLowerCase();
+        if (!EXTENSIONS.includes(extension))
+            continue;
+        try {
+            // `statSync` follows symlinks and throws on a dangling one, or on a file
+            // removed between the readdir and here. One bad entry costs that entry.
+            if (!(0, node_fs_1.statSync)(file).isFile())
+                continue;
+        }
+        catch {
+            continue;
+        }
+        const entry = {
+            name: path.basename(name, path.extname(name)),
+            file,
+        };
+        try {
+            const raw = (0, config_js_1.loadRawConfigFile)(file);
+            if (typeof raw?.btpDestination === 'string') {
+                entry.destination = raw.btpDestination;
+            }
+            if (typeof raw?.targetUrl === 'string')
+                entry.targetUrl = raw.targetUrl;
+        }
+        catch {
+            // Listed without a destination. The failure belongs to whoever tries to
+            // START it, where it can be reported against a name the user chose.
+        }
+        entries.push(entry);
+    }
+    return entries;
+}
+/**
+ * The file a name refers to.
+ *
+ * Accepts either the bare name or the file name as written. A name that would
+ * leave the directory is refused rather than resolved: the value comes from a
+ * language model, and `../sessions/nvcr.env` is a real path in a real
+ * neighbouring folder full of credentials.
+ */
+function resolveProxyConfig(name, dir = proxyConfigDir()) {
+    if (name.includes('/') || name.includes('\\') || name.includes('..')) {
+        throw new Error(`Invalid proxy config name "${name}": it must be a name from ${dir}, not a path.`);
+    }
+    const available = listProxyConfigs(dir);
+    // An exact file name is never ambiguous, so it is tried first and wins.
+    const exact = available.find((entry) => path.basename(entry.file) === name);
+    if (exact)
+        return exact.file;
+    // A bare name can be answered by more than one file — `prod.yaml` and
+    // `prod.json` are both "prod". Taking the first in sorted order would point
+    // requests at a different destination than the caller meant and say nothing,
+    // so it is refused with both names instead.
+    const byName = available.filter((entry) => entry.name === name);
+    if (byName.length > 1) {
+        const files = byName.map((entry) => path.basename(entry.file)).join(', ');
+        throw new Error(`Ambiguous proxy config name "${name}" in ${dir}: ${files}. Name the file exactly.`);
+    }
+    if (byName.length === 1)
+        return byName[0].file;
+    const known = available.map((entry) => entry.name).join(', ');
+    throw new Error(known
+        ? `No proxy config named "${name}" in ${dir}. Available: ${known}`
+        : `No proxy configs found in ${dir}.`);
+}
+/** Read a config's own comment header, for a listing a human can recognise. */
+function describeConfig(entry) {
+    try {
+        const first = (0, node_fs_1.readFileSync)(entry.file, 'utf-8')
+            .split('\n')
+            .find((line) => line.trimStart().startsWith('#'));
+        return first ? first.replace(/^\s*#\s?/, '').trim() : '';
+    }
+    catch {
+        return '';
+    }
+}

package/dist/mcp/ports.d.ts

@@ -0,0 +1,15 @@
+import type { Server } from 'node:http';
+/**
+ * Bind a server to a free port and report the one it got.
+ *
+ * Port 0 asks the OS for a free port and binds it in the same step. The
+ * alternative — probe for a free port, close, then bind it — leaves a window
+ * in which another process can take it, which is exactly the collision this
+ * exists to avoid. Nothing here guesses 3001.
+ *
+ * The listener is also the answer to "which port": `address()` is asked after
+ * the bind, so the number reported is the number in use rather than the number
+ * requested.
+ */
+export declare function listenOnFreePort(server: Server, host: string): Promise<number>;
+//# sourceMappingURL=ports.d.ts.map

package/dist/mcp/ports.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ports.d.ts","sourceRoot":"","sources":["../../src/mcp/ports.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,WAAW,CAAC;AAExC;;;;;;;;;;;GAWG;AACH,wBAAgB,gBAAgB,CAC9B,MAAM,EAAE,MAAM,EACd,IAAI,EAAE,MAAM,GACX,OAAO,CAAC,MAAM,CAAC,CAoBjB"}

package/dist/mcp/ports.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.listenOnFreePort = listenOnFreePort;
+/**
+ * Bind a server to a free port and report the one it got.
+ *
+ * Port 0 asks the OS for a free port and binds it in the same step. The
+ * alternative — probe for a free port, close, then bind it — leaves a window
+ * in which another process can take it, which is exactly the collision this
+ * exists to avoid. Nothing here guesses 3001.
+ *
+ * The listener is also the answer to "which port": `address()` is asked after
+ * the bind, so the number reported is the number in use rather than the number
+ * requested.
+ */
+function listenOnFreePort(server, host) {
+    return new Promise((resolve, reject) => {
+        const failed = (error) => {
+            server.removeListener('listening', bound);
+            reject(error);
+        };
+        const bound = () => {
+            server.removeListener('error', failed);
+            const address = server.address();
+            if (typeof address !== 'object' || address === null) {
+                reject(new Error('Listening on a socket with no address'));
+                return;
+            }
+            resolve(address.port);
+        };
+        server.once('error', failed);
+        server.once('listening', bound);
+        server.listen(0, host);
+    });
+}

package/dist/mcp/registry.d.ts

@@ -0,0 +1,57 @@
+/**
+ * One live proxy, as claimed by the process that started it.
+ */
+export interface InstanceRecord {
+    pid: number;
+    port: number;
+    url: string;
+    destination: string;
+    /** Which proxy config was started. */
+    config: string;
+    startedAt: string;
+    /**
+     * When the machine this was written on last booted.
+     *
+     * A pid is only unique within a boot. After a restart the same number can
+     * belong to an unrelated live process, and `process.kill(pid, 0)` then says
+     * "alive" forever — a record that outlives its writer permanently, reported by
+     * `proxy_status` as another session's proxy with no way to clear it but
+     * deleting the file by hand.
+     */
+    bootedAt: number;
+}
+/**
+ * When this machine booted, to the nearest millisecond it can manage.
+ *
+ * `os.uptime()` is seconds since boot on every platform, so this drifts by a few
+ * milliseconds between calls — which is why records are compared with a
+ * tolerance rather than for equality.
+ */
+export declare function bootedAt(): number;
+/** Does this process still exist? */
+export type IsAlive = (pid: number) => boolean;
+/**
+ * Where instance records live, following the convention `src/lib/stores.ts`
+ * uses for service keys and sessions.
+ */
+export declare function defaultRuntimeDir(): string;
+/**
+ * The live proxies on this machine, this session's and everyone else's.
+ *
+ * A record is a claim, not a fact — the process that wrote it may have crashed
+ * without cleaning up. So every read checks the process behind each record and
+ * DELETES the ones whose writer is gone, rather than merely hiding them: a
+ * ghost that survives the read comes back on the next one, and `proxy_status`
+ * goes on reporting a proxy that stopped holding its port days ago.
+ */
+export declare class InstanceRegistry {
+    private readonly dir;
+    private readonly isAlive;
+    constructor(dir?: string, isAlive?: IsAlive);
+    private fileFor;
+    record(entry: InstanceRecord): void;
+    /** Drop this process's record for a port. Missing is not an error. */
+    forget(port: number): void;
+    live(): InstanceRecord[];
+}
+//# sourceMappingURL=registry.d.ts.map

package/dist/mcp/registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../src/mcp/registry.ts"],"names":[],"mappings":"AAcA;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,EAAE,MAAM,CAAC;IACZ,WAAW,EAAE,MAAM,CAAC;IACpB,sCAAsC;IACtC,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;IAClB;;;;;;;;OAQG;IACH,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED;;;;;;GAMG;AACH,wBAAgB,QAAQ,IAAI,MAAM,CAEjC;AAKD,qCAAqC;AACrC,MAAM,MAAM,OAAO,GAAG,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC;AAe/C;;;GAGG;AACH,wBAAgB,iBAAiB,IAAI,MAAM,CAE1C;AAED;;;;;;;;GAQG;AACH,qBAAa,gBAAgB;IAEzB,OAAO,CAAC,QAAQ,CAAC,GAAG;IACpB,OAAO,CAAC,QAAQ,CAAC,OAAO;gBADP,GAAG,GAAE,MAA4B,EACjC,OAAO,GAAE,OAAuB;IAGnD,OAAO,CAAC,OAAO;IAIf,MAAM,CAAC,KAAK,EAAE,cAAc,GAAG,IAAI;IAWnC,sEAAsE;IACtE,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI;IAI1B,IAAI,IAAI,cAAc,EAAE;CAoCzB"}

package/dist/mcp/registry.js

@@ -0,0 +1,145 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InstanceRegistry = void 0;
+exports.bootedAt = bootedAt;
+exports.defaultRuntimeDir = defaultRuntimeDir;
+// src/mcp/registry.ts
+const node_fs_1 = require("node:fs");
+const os = __importStar(require("node:os"));
+const path = __importStar(require("node:path"));
+const stores_js_1 = require("../lib/stores.js");
+/**
+ * When this machine booted, to the nearest millisecond it can manage.
+ *
+ * `os.uptime()` is seconds since boot on every platform, so this drifts by a few
+ * milliseconds between calls — which is why records are compared with a
+ * tolerance rather than for equality.
+ */
+function bootedAt() {
+    return Math.round(Date.now() - os.uptime() * 1000);
+}
+/** How far apart two readings of the boot time may be and still mean one boot. */
+const BOOT_TOLERANCE_MS = 5000;
+/**
+ * Signal 0 checks for the process without delivering anything. `EPERM` means it
+ * exists and belongs to someone else — still alive, so still holding its port.
+ */
+const processExists = (pid) => {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        return error.code === 'EPERM';
+    }
+};
+/**
+ * Where instance records live, following the convention `src/lib/stores.ts`
+ * uses for service keys and sessions.
+ */
+function defaultRuntimeDir() {
+    return (0, stores_js_1.storeDir)('runtime');
+}
+/**
+ * The live proxies on this machine, this session's and everyone else's.
+ *
+ * A record is a claim, not a fact — the process that wrote it may have crashed
+ * without cleaning up. So every read checks the process behind each record and
+ * DELETES the ones whose writer is gone, rather than merely hiding them: a
+ * ghost that survives the read comes back on the next one, and `proxy_status`
+ * goes on reporting a proxy that stopped holding its port days ago.
+ */
+class InstanceRegistry {
+    dir;
+    isAlive;
+    constructor(dir = defaultRuntimeDir(), isAlive = processExists) {
+        this.dir = dir;
+        this.isAlive = isAlive;
+    }
+    fileFor(port) {
+        return path.join(this.dir, `${process.pid}-${port}.json`);
+    }
+    record(entry) {
+        (0, node_fs_1.mkdirSync)(this.dir, { recursive: true });
+        // Written beside the target and renamed over it. `writeFileSync` truncates
+        // first, so a reader arriving mid-write sees a partial file; a rename is
+        // atomic, so it sees either the whole record or no file.
+        const file = this.fileFor(entry.port);
+        const partial = `${file}.tmp-${process.pid}`;
+        (0, node_fs_1.writeFileSync)(partial, JSON.stringify(entry, null, 2));
+        (0, node_fs_1.renameSync)(partial, file);
+    }
+    /** Drop this process's record for a port. Missing is not an error. */
+    forget(port) {
+        (0, node_fs_1.rmSync)(this.fileFor(port), { force: true });
+    }
+    live() {
+        if (!(0, node_fs_1.existsSync)(this.dir))
+            return [];
+        const records = [];
+        for (const name of (0, node_fs_1.readdirSync)(this.dir)) {
+            if (!name.endsWith('.json'))
+                continue;
+            const file = path.join(this.dir, name);
+            let record;
+            try {
+                record = JSON.parse((0, node_fs_1.readFileSync)(file, 'utf-8'));
+            }
+            catch {
+                // Unreadable or half-written. One bad file must not cost the caller
+                // the whole listing — which is the difference between a degraded
+                // answer and no answer at all.
+                continue;
+            }
+            if (typeof record?.pid !== 'number')
+                continue;
+            // A pid means nothing across a reboot, so a record from an earlier boot is
+            // gone whatever its pid now answers. A record with no boot time at all was
+            // written by an older version and cannot be judged, which is the same
+            // answer.
+            const sameBoot = typeof record.bootedAt === 'number' &&
+                Math.abs(record.bootedAt - bootedAt()) <= BOOT_TOLERANCE_MS;
+            if (sameBoot && this.isAlive(record.pid)) {
+                records.push(record);
+            }
+            else {
+                (0, node_fs_1.rmSync)(file, { force: true });
+            }
+        }
+        return records.sort((a, b) => a.port - b.port);
+    }
+}
+exports.InstanceRegistry = InstanceRegistry;

package/dist/mcp/server.d.ts

@@ -0,0 +1,34 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { type ProxyConfig } from '../lib/config.js';
+import { ProxySupervisor, type SupervisorOptions } from './supervisor.js';
+/**
+ * The MCP mode: a stdio server whose tools start and stop this proxy.
+ *
+ * Installed as its own small command, `mcp-abap-adt-proxy-mcp`, so a client
+ * that wants to MANAGE proxies registers this, while a client that wants to BE
+ * proxied still points at `mcp-abap-adt-proxy` as before. The two are different
+ * jobs and conflating them would make every plain proxy carry a management
+ * surface it never uses.
+ */
+export interface McpModeDeps {
+    /** How a credential is built for a started proxy. */
+    proxyFor?: SupervisorOptions['proxyFor'];
+}
+export declare function createMcpModeServer(_config: ProxyConfig, deps?: McpModeDeps): {
+    server: McpServer;
+    supervisor: ProxySupervisor;
+};
+/**
+ * Connect over stdio and stay up until the session ends.
+ *
+ * Every way this process can end stops the proxies first. That is the whole
+ * point of running them in this process: a listener that outlives the session
+ * that asked for it is a port nobody remembers holding.
+ *
+ * The ordering, the run-once guard and the deadline live in `createShutdown`,
+ * where they are tested. They were inline here, and the exit sat in a
+ * `.finally()` after an unbounded await — so anything that hung below produced
+ * exactly the process this design exists to avoid.
+ */
+export declare function runMcpMode(config?: ProxyConfig): Promise<void>;
+//# sourceMappingURL=server.d.ts.map

package/dist/mcp/server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../../src/mcp/server.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AAEpE,OAAO,EAAc,KAAK,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAGhE,OAAO,EAAE,eAAe,EAAE,KAAK,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AAG1E;;;;;;;;GAQG;AACH,MAAM,WAAW,WAAW;IAC1B,qDAAqD;IACrD,QAAQ,CAAC,EAAE,iBAAiB,CAAC,UAAU,CAAC,CAAC;CAC1C;AAED,wBAAgB,mBAAmB,CACjC,OAAO,EAAE,WAAW,EACpB,IAAI,GAAE,WAAgB,GACrB;IACD,MAAM,EAAE,SAAS,CAAC;IAClB,UAAU,EAAE,eAAe,CAAC;CAC7B,CAmDA;AAED;;;;;;;;;;;GAWG;AACH,wBAAsB,UAAU,CAC9B,MAAM,GAAE,WAA0B,GACjC,OAAO,CAAC,IAAI,CAAC,CAgBf"}

package/dist/mcp/server.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMcpModeServer = createMcpModeServer;
+exports.runMcpMode = runMcpMode;
+// src/mcp/server.ts
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const mcp_js_1 = require("@modelcontextprotocol/sdk/server/mcp.js");
+const stdio_js_1 = require("@modelcontextprotocol/sdk/server/stdio.js");
+const config_js_1 = require("../lib/config.js");
+const btpProxy_js_1 = require("../proxy/btpProxy.js");
+const shutdown_js_1 = require("./shutdown.js");
+const supervisor_js_1 = require("./supervisor.js");
+const tools_js_1 = require("./tools.js");
+function createMcpModeServer(_config, deps = {}) {
+    const supervisor = new supervisor_js_1.ProxySupervisor({
+        // The loaded proxy config, unchanged and un-merged.
+        //
+        // This used to spread a baseline under it, described as "the fallback for
+        // anything a proxy config leaves out". It was not a fallback.
+        // `applyDefaults` sets EVERY key, so a config saying nothing about headers
+        // still arrives carrying `defaultHeaders: undefined` — and spreading that
+        // over the baseline erased it. Since the baseline is the documented home of
+        // `x-sap-login` / `x-sap-password`, the failure was a request going out
+        // with no ABAP credentials and nothing saying so.
+        //
+        // No fallback is needed: `loadConfig(file)` already overlays the CLI flags
+        // this command was given, which is how `--unsafe` reaches every proxy.
+        proxyFor: deps.proxyFor ?? ((options) => (0, btpProxy_js_1.createBtpProxy)(options.config)),
+    });
+    // Read rather than written down: a version literal here drifts from the one
+    // that ships the moment a release bumps package.json and not this file.
+    //
+    // `__dirname` rather than `import.meta`: the sources are authored as ESM but
+    // compiled to CommonJS, where `import.meta` does not exist — and the build
+    // says so rather than letting it fail in a client's hands.
+    const { version } = JSON.parse((0, node_fs_1.readFileSync)((0, node_path_1.join)(__dirname, '..', '..', 'package.json'), 'utf-8'));
+    const server = new mcp_js_1.McpServer({ name: '@mcp-abap-adt/proxy-mcp', version }, {
+        instructions: 'Starts and stops local authenticating proxies for SAP BTP ' +
+            `destinations. ${tools_js_1.SHUTDOWN_REMINDER}`,
+    });
+    for (const tool of (0, tools_js_1.createProxyTools)(supervisor)) {
+        server.registerTool(tool.name, {
+            title: tool.title,
+            description: tool.description,
+            inputSchema: tool.inputSchema,
+        }, 
+        // The SDK's callback types are generic over the schema; the tool's own
+        // handler is already typed against it.
+        tool.handler);
+    }
+    return { server, supervisor };
+}
+/**
+ * Connect over stdio and stay up until the session ends.
+ *
+ * Every way this process can end stops the proxies first. That is the whole
+ * point of running them in this process: a listener that outlives the session
+ * that asked for it is a port nobody remembers holding.
+ *
+ * The ordering, the run-once guard and the deadline live in `createShutdown`,
+ * where they are tested. They were inline here, and the exit sat in a
+ * `.finally()` after an unbounded await — so anything that hung below produced
+ * exactly the process this design exists to avoid.
+ */
+async function runMcpMode(config = (0, config_js_1.loadConfig)()) {
+    const { server, supervisor } = createMcpModeServer(config);
+    const shutdown = (0, shutdown_js_1.createShutdown)({
+        supervisor,
+        closeServer: () => server.close(),
+        exit: (code) => process.exit(code),
+    });
+    for (const signal of ['SIGTERM', 'SIGINT']) {
+        process.on(signal, () => void shutdown(signal));
+    }
+    // The client hanging up is the ordinary case, not an exceptional one.
+    process.stdin.on('close', () => void shutdown('stdin closed'));
+    await server.connect(new stdio_js_1.StdioServerTransport());
+}

package/dist/mcp/shutdown.d.ts

@@ -0,0 +1,37 @@
+import type { StartedInstance } from './supervisor.js';
+/**
+ * How long the whole shutdown gets before the process leaves anyway.
+ *
+ * Generous next to the per-instance grace, because this is the outer bound: it
+ * exists for the case where something below refuses to finish at all, not for
+ * the ordinary one.
+ */
+export declare const DEFAULT_SHUTDOWN_DEADLINE_MS = 10000;
+export interface ShutdownDeps {
+    supervisor: {
+        stop(instanceId?: string): Promise<StartedInstance[]>;
+    };
+    closeServer: () => Promise<void>;
+    exit: (code: number) => void;
+    deadlineMs?: number;
+}
+/**
+ * The end of the session, which is the last chance to let anything go.
+ *
+ * Three properties, and each one is here because its absence is a real failure
+ * rather than a tidiness concern:
+ *
+ * **It runs once.** SIGINT, SIGTERM and stdin closing can all arrive, and two
+ * shutdowns racing means stopping the same instances twice.
+ *
+ * **It always reaches the exit.** `process.exit()` used to sit in a `.finally()`
+ * after an unbounded await, so anything that hung below it produced a process
+ * that ignores SIGTERM and keeps its ports — precisely the orphaned-listener
+ * failure that running the proxies in this process was meant to prevent.
+ *
+ * **It never rejects.** A signal handler has no caller, so a rejection here is
+ * an unhandled one, and the default is to end the process on it — which would
+ * be the exit happening for the wrong reason, skipping the release.
+ */
+export declare function createShutdown(deps: ShutdownDeps): (why: string) => Promise<void>;
+//# sourceMappingURL=shutdown.d.ts.map

package/dist/mcp/shutdown.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shutdown.d.ts","sourceRoot":"","sources":["../../src/mcp/shutdown.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAEvD;;;;;;GAMG;AACH,eAAO,MAAM,4BAA4B,QAAS,CAAC;AAEnD,MAAM,WAAW,YAAY;IAC3B,UAAU,EAAE;QAAE,IAAI,CAAC,UAAU,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,eAAe,EAAE,CAAC,CAAA;KAAE,CAAC;IACtE,WAAW,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IACjC,IAAI,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;IAC7B,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,cAAc,CAC5B,IAAI,EAAE,YAAY,GACjB,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAmDhC"}