@mcp-abap-adt/proxy 2.0.0 → 4.0.1

package/dist/lib/stores.d.ts

@@ -14,10 +14,31 @@ import type { IServiceKeyStore, ISessionStore } from '@mcp-abap-adt/auth-broker'
  *    - Windows: %USERPROFILE%\Documents\mcp-abap-adt\{subfolder}
  * 3. Current working directory (process.cwd())
  *
- * @param subfolder Subfolder name ('service-keys' or 'sessions')
+ * @param subfolder One of the four folders; see {@link StoreFolder}
  * @returns Array of resolved absolute paths
  */
-export declare function getPlatformPaths(subfolder?: 'service-keys' | 'sessions'): string[];
+/**
+ * The four folders the toolchain keeps under one base.
+ *
+ * `service-keys/` and `sessions/` are the auth broker's. `proxy/` holds one
+ * ready config per proxy — the files `--config` takes. `runtime/` holds a
+ * record per live proxy, so one session can see another's.
+ */
+export declare const STORE_FOLDERS: readonly ["service-keys", "sessions", "proxy", "runtime"];
+export type StoreFolder = (typeof STORE_FOLDERS)[number];
+/**
+ * THE base directory — one answer, not a search path.
+ *
+ * `AUTH_BROKER_PATH` relocates it, so all four folders move together; when it
+ * lists several, the first is the one written to. Unlike
+ * {@link getPlatformPaths}, this never falls back to the working directory: a
+ * file written beside wherever a client happened to be launched from is a file
+ * the next session will not find.
+ */
+export declare function storeBaseDir(): string;
+/** THE directory for one of the four folders. */
+export declare function storeDir(folder: StoreFolder): string;
+export declare function getPlatformPaths(subfolder?: StoreFolder): string[];
 /**
  * Get platform-specific stores
  * Returns XSUAA stores for BTP authentication:

package/dist/lib/stores.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"stores.d.ts","sourceRoot":"","sources":["../../src/lib/stores.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAIH,OAAO,KAAK,EACV,gBAAgB,EAChB,aAAa,EACd,MAAM,2BAA2B,CAAC;AAOnC;;;;;;;;;;;;GAYG;AACH,wBAAgB,gBAAgB,CAC9B,SAAS,CAAC,EAAE,cAAc,GAAG,UAAU,GACtC,MAAM,EAAE,CAgEV;AAED;;;;;;;GAOG;AACH,wBAAsB,iBAAiB,CAAC,MAAM,GAAE,OAAe,GAAG,OAAO,CAAC;IACxE,eAAe,EAAE,gBAAgB,CAAC;IAClC,YAAY,EAAE,aAAa,CAAC;CAC7B,CAAC,CAqBD"}
+{"version":3,"file":"stores.d.ts","sourceRoot":"","sources":["../../src/lib/stores.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAIH,OAAO,KAAK,EACV,gBAAgB,EAChB,aAAa,EACd,MAAM,2BAA2B,CAAC;AAOnC;;;;;;;;;;;;GAYG;AACH;;;;;;GAMG;AACH,eAAO,MAAM,aAAa,2DAKhB,CAAC;AAEX,MAAM,MAAM,WAAW,GAAG,CAAC,OAAO,aAAa,CAAC,CAAC,MAAM,CAAC,CAAC;AAEzD;;;;;;;;GAQG;AACH,wBAAgB,YAAY,IAAI,MAAM,CA0BrC;AAED,iDAAiD;AACjD,wBAAgB,QAAQ,CAAC,MAAM,EAAE,WAAW,GAAG,MAAM,CAEpD;AAED,wBAAgB,gBAAgB,CAAC,SAAS,CAAC,EAAE,WAAW,GAAG,MAAM,EAAE,CAgElE;AAED;;;;;;;GAOG;AACH,wBAAsB,iBAAiB,CAAC,MAAM,GAAE,OAAe,GAAG,OAAO,CAAC;IACxE,eAAe,EAAE,gBAAgB,CAAC;IAClC,YAAY,EAAE,aAAa,CAAC;CAC7B,CAAC,CAqBD"}

package/dist/lib/stores.js

@@ -38,6 +38,9 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.STORE_FOLDERS = void 0;
+exports.storeBaseDir = storeBaseDir;
+exports.storeDir = storeDir;
 exports.getPlatformPaths = getPlatformPaths;
 exports.getPlatformStores = getPlatformStores;
 const os = __importStar(require("node:os"));
@@ -53,9 +56,61 @@ const auth_stores_1 = require("@mcp-abap-adt/auth-stores");
  *    - Windows: %USERPROFILE%\Documents\mcp-abap-adt\{subfolder}
  * 3. Current working directory (process.cwd())
  *
- * @param subfolder Subfolder name ('service-keys' or 'sessions')
+ * @param subfolder One of the four folders; see {@link StoreFolder}
  * @returns Array of resolved absolute paths
  */
+/**
+ * The four folders the toolchain keeps under one base.
+ *
+ * `service-keys/` and `sessions/` are the auth broker's. `proxy/` holds one
+ * ready config per proxy — the files `--config` takes. `runtime/` holds a
+ * record per live proxy, so one session can see another's.
+ */
+exports.STORE_FOLDERS = [
+    'service-keys',
+    'sessions',
+    'proxy',
+    'runtime',
+];
+/**
+ * THE base directory — one answer, not a search path.
+ *
+ * `AUTH_BROKER_PATH` relocates it, so all four folders move together; when it
+ * lists several, the first is the one written to. Unlike
+ * {@link getPlatformPaths}, this never falls back to the working directory: a
+ * file written beside wherever a client happened to be launched from is a file
+ * the next session will not find.
+ */
+function storeBaseDir() {
+    const envPath = process.env.AUTH_BROKER_PATH;
+    if (envPath) {
+        // Not `/[:;]/`: on Windows that splits `C:\store` into `C`, which then
+        // resolves against the working directory. The delimiter is chosen from
+        // `process.platform` rather than taken from `path.delimiter`, which is bound
+        // to the host at module load and so cannot be exercised for the other one.
+        const first = envPath
+            .split(process.platform === 'win32' ? ';' : ':')
+            .map((p) => p.trim())
+            .find((p) => p.length > 0);
+        if (first) {
+            const resolved = path.resolve(first);
+            // Pointed at one of the folders rather than the base — a plausible
+            // mistake that `getPlatformPaths` already tolerates, so this must too.
+            // Otherwise runtime records land in `.../service-keys/runtime`.
+            return exports.STORE_FOLDERS.includes(path.basename(resolved))
+                ? path.dirname(resolved)
+                : resolved;
+        }
+    }
+    const homeDir = os.homedir();
+    return process.platform === 'win32'
+        ? path.join(homeDir, 'Documents', 'mcp-abap-adt')
+        : path.join(homeDir, '.config', 'mcp-abap-adt');
+}
+/** THE directory for one of the four folders. */
+function storeDir(folder) {
+    return path.join(storeBaseDir(), folder);
+}
 function getPlatformPaths(subfolder) {
     const paths = [];
     const isWindows = process.platform === 'win32';

package/dist/mcp/cli.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=cli.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../../src/mcp/cli.ts"],"names":[],"mappings":""}

package/dist/mcp/cli.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// src/mcp/cli.ts
+const config_js_1 = require("../lib/config.js");
+const logger_js_1 = require("../lib/logger.js");
+const server_js_1 = require("./server.js");
+/**
+ * What `bin/mcp-abap-adt-proxy-mcp.js` loads.
+ *
+ * Nothing but wiring: the bin parses `--help`/`--version` and then requires
+ * this, in the same process, so the listeners the tools start die with the
+ * session that asked for them.
+ */
+(0, server_js_1.runMcpMode)((0, config_js_1.loadConfig)()).catch((error) => {
+    logger_js_1.logger?.error('MCP mode failed to start', {
+        type: 'MCP_MODE_START_FAILED',
+        error: error instanceof Error ? error.message : String(error),
+    });
+    process.stderr.write(`[MCP Proxy] ✗ ${error instanceof Error ? error.message : String(error)}\n`);
+    process.exit(1);
+});

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"}