@mcp-abap-adt/proxy 2.0.0 → 4.0.0

package/dist/mcp/shutdown.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_SHUTDOWN_DEADLINE_MS = void 0;
+exports.createShutdown = createShutdown;
+// src/mcp/shutdown.ts
+const logger_js_1 = require("../lib/logger.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.
+ */
+exports.DEFAULT_SHUTDOWN_DEADLINE_MS = 10_000;
+/**
+ * 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.
+ */
+function createShutdown(deps) {
+    const deadlineMs = deps.deadlineMs ?? exports.DEFAULT_SHUTDOWN_DEADLINE_MS;
+    let started = false;
+    return async function shutdown(why) {
+        if (started)
+            return;
+        started = true;
+        logger_js_1.logger?.info('MCP mode shutting down', { type: 'MCP_MODE_SHUTDOWN', why });
+        let timer;
+        const deadline = new Promise((resolve) => {
+            timer = setTimeout(() => resolve('deadline'), deadlineMs);
+            timer.unref?.();
+        });
+        const release = (async () => {
+            try {
+                const stopped = await deps.supervisor.stop();
+                if (stopped.length > 0) {
+                    logger_js_1.logger?.info('Released proxies on shutdown', {
+                        type: 'MCP_MODE_SHUTDOWN_RELEASED',
+                        count: stopped.length,
+                        ports: stopped.map((s) => s.port),
+                    });
+                }
+            }
+            catch (error) {
+                logger_js_1.logger?.error('Failed to release proxies on shutdown', {
+                    type: 'MCP_MODE_SHUTDOWN_RELEASE_FAILED',
+                    error: error instanceof Error ? error.message : String(error),
+                });
+            }
+            try {
+                await deps.closeServer();
+            }
+            catch {
+                /* already gone, or never up */
+            }
+        })();
+        const outcome = await Promise.race([release, deadline]);
+        if (timer)
+            clearTimeout(timer);
+        if (outcome === 'deadline') {
+            logger_js_1.logger?.error('Shutdown did not finish in time; leaving anyway', {
+                type: 'MCP_MODE_SHUTDOWN_DEADLINE',
+                why,
+                deadlineMs,
+            });
+        }
+        deps.exit(0);
+    };
+}

package/dist/mcp/supervisor.d.ts

@@ -0,0 +1,125 @@
+import type { ProxyConfig } from '../lib/config.js';
+import { type CredentialFacade } from '../proxy/requestHandler.js';
+import { type InstanceRecord, InstanceRegistry } from './registry.js';
+/** Thirty minutes with no forwarded request. */
+export declare const DEFAULT_IDLE_TIMEOUT_MS: number;
+/**
+ * How long a stop waits for requests in flight before cutting them.
+ *
+ * `server.close()` alone is not enough and cannot be: it waits for ACTIVE
+ * connections, and a response that streams never becomes inactive. Measured on
+ * Node 26.7.0, the close callback had not fired 1500ms after a single open
+ * event stream. Waiting forever would mean `proxy_stop` never returning and —
+ * because the shutdown path awaits the same call — SIGINT, SIGTERM and stdin
+ * close all hanging with the port still held, which is precisely the
+ * orphaned-port failure running in-process was meant to prevent.
+ *
+ * So an ordinary request gets this long to finish, and then the socket goes.
+ */
+export declare const DEFAULT_STOP_GRACE_MS = 2000;
+export interface StartOptions {
+    /**
+     * The config's name, as it is filed in the proxy config directory. This is
+     * the unit, not the destination: four configs on disk name the same
+     * `btpDestination` and differ in target and headers, so a destination cannot
+     * identify one.
+     */
+    name: string;
+    /**
+     * The loaded config. Its `httpPort` is deliberately IGNORED — four of the
+     * configs on disk say 3001, which is exactly the collision this mode exists
+     * to end. The port comes from the OS.
+     */
+    config: ProxyConfig;
+    /** `0` turns the backstop off. */
+    idleTimeoutMs?: number;
+    /** How long a stop waits for requests in flight. See DEFAULT_STOP_GRACE_MS. */
+    stopGraceMs?: number;
+}
+export interface StartedInstance {
+    instanceId: string;
+    /** The config that was started. */
+    name: string;
+    url: string;
+    port: number;
+    destination: string;
+    startedAt: string;
+}
+export interface SupervisorOptions {
+    registry?: InstanceRegistry;
+    /** Builds or reuses the credential facade for a destination's config. */
+    proxyFor: (options: StartOptions) => Promise<CredentialFacade>;
+    host?: string;
+}
+/**
+ * The listeners this process owns.
+ *
+ * They run HERE, in the MCP server's own process, and that is not a
+ * convenience. A spawned child is orphaned by any signal its parent does not
+ * forward and goes on holding the HTTP and OAuth callback ports — the reason
+ * `bin/mcp-abap-adt-proxy.js` loads the server in-process instead of spawning
+ * it. In-process, a listener dies when the stdio session dies and its port
+ * goes with it.
+ *
+ * Everything here is about letting go. A stopped instance clears its idle
+ * timer, closes its listener, releases its credential and deletes its record,
+ * in that order; a session that
+ * ends stops all of them; and an instance nobody has used for a while stops
+ * itself, because an agent that finished and forgot is the case this mode has
+ * to survive.
+ */
+export declare class ProxySupervisor {
+    private readonly options;
+    private readonly owned;
+    private readonly registry;
+    private readonly host;
+    constructor(options: SupervisorOptions);
+    start(options: StartOptions): Promise<StartedInstance>;
+    /** Stop one instance, or every one this process owns. */
+    stop(instanceId?: string): Promise<StartedInstance[]>;
+    /** What this process is running. */
+    mine(): StartedInstance[];
+    /**
+     * Live proxies started by other sessions. Dead claims are pruned on read.
+     *
+     * Anything bearing this process's pid is OURS, owned or not. A record we wrote
+     * and no longer own is an orphan of our own making — `forget()` failed, or a
+     * second supervisor shares the directory — and reporting it as "another
+     * session's, not yours to stop" would be actively misleading about the one
+     * thing the caller would act on.
+     */
+    others(): InstanceRecord[];
+    /**
+     * Undo a start that did not finish: give the port back and let the credential
+     * go. Nothing here may throw — it runs on the way out of a failure, and a
+     * second failure would hide the first.
+     */
+    private release;
+    /**
+     * Close the listener and make sure the port is actually free afterwards.
+     *
+     * Idle keep-alive sockets go immediately — they are holding the port for
+     * nothing. Anything still carrying a request gets `stopGraceMs`, and then
+     * goes too, because a stream will not end on its own and the caller asked
+     * for this port back.
+     */
+    private closeListener;
+    private describe;
+    /**
+     * Restart the countdown. `unref` so a pending timer never keeps the process
+     * alive on its own — the backstop exists to release things, not to hold one.
+     */
+    private armIdle;
+    /**
+     * A request arrived: stop counting down until it is done.
+     *
+     * Clearing the handle as well as the timer is what closes the leak the old
+     * `touch()` had — it replaced `owned.idle` while `stop()` already held the
+     * previous handle, so the replacement was never cleared and later fired
+     * against an instance that had gone.
+     */
+    private requestStarted;
+    /** The last one finished: start counting down again. */
+    private requestFinished;
+}
+//# sourceMappingURL=supervisor.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"supervisor.d.ts","sourceRoot":"","sources":["../../src/mcp/supervisor.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAEpD,OAAO,EACL,KAAK,gBAAgB,EAEtB,MAAM,4BAA4B,CAAC;AAEpC,OAAO,EAAY,KAAK,cAAc,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AAEhF,gDAAgD;AAChD,eAAO,MAAM,uBAAuB,QAAiB,CAAC;AAEtD;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,qBAAqB,OAAO,CAAC;AAE1C,MAAM,WAAW,YAAY;IAC3B;;;;;OAKG;IACH,IAAI,EAAE,MAAM,CAAC;IACb;;;;OAIG;IACH,MAAM,EAAE,WAAW,CAAC;IACpB,kCAAkC;IAClC,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,+EAA+E;IAC/E,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED,MAAM,WAAW,eAAe;IAC9B,UAAU,EAAE,MAAM,CAAC;IACnB,mCAAmC;IACnC,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,SAAS,EAAE,MAAM,CAAC;CACnB;AAoBD,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,EAAE,gBAAgB,CAAC;IAC5B,yEAAyE;IACzE,QAAQ,EAAE,CAAC,OAAO,EAAE,YAAY,KAAK,OAAO,CAAC,gBAAgB,CAAC,CAAC;IAC/D,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,qBAAa,eAAe;IAKd,OAAO,CAAC,QAAQ,CAAC,OAAO;IAJpC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAA4B;IAClD,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAmB;IAC5C,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAS;gBAED,OAAO,EAAE,iBAAiB;IAKjD,KAAK,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,eAAe,CAAC;IAwG5D,yDAAyD;IACnD,IAAI,CAAC,UAAU,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,eAAe,EAAE,CAAC;IAiD3D,oCAAoC;IACpC,IAAI,IAAI,eAAe,EAAE;IAIzB;;;;;;;;OAQG;IACH,MAAM,IAAI,cAAc,EAAE;IAI1B;;;;OAIG;IACH,OAAO,CAAC,OAAO;IAkBf;;;;;;;OAOG;YACW,aAAa;IA4B3B,OAAO,CAAC,QAAQ;IAahB;;;OAGG;IACH,OAAO,CAAC,OAAO;IAsBf;;;;;;;OAOG;IACH,OAAO,CAAC,cAAc;IAUtB,wDAAwD;IACxD,OAAO,CAAC,eAAe;CAQxB"}

package/dist/mcp/supervisor.js

@@ -0,0 +1,330 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProxySupervisor = exports.DEFAULT_STOP_GRACE_MS = exports.DEFAULT_IDLE_TIMEOUT_MS = void 0;
+// src/mcp/supervisor.ts
+const node_crypto_1 = require("node:crypto");
+const node_http_1 = require("node:http");
+const logger_js_1 = require("../lib/logger.js");
+const requestHandler_js_1 = require("../proxy/requestHandler.js");
+const ports_js_1 = require("./ports.js");
+const registry_js_1 = require("./registry.js");
+/** Thirty minutes with no forwarded request. */
+exports.DEFAULT_IDLE_TIMEOUT_MS = 30 * 60 * 1000;
+/**
+ * How long a stop waits for requests in flight before cutting them.
+ *
+ * `server.close()` alone is not enough and cannot be: it waits for ACTIVE
+ * connections, and a response that streams never becomes inactive. Measured on
+ * Node 26.7.0, the close callback had not fired 1500ms after a single open
+ * event stream. Waiting forever would mean `proxy_stop` never returning and —
+ * because the shutdown path awaits the same call — SIGINT, SIGTERM and stdin
+ * close all hanging with the port still held, which is precisely the
+ * orphaned-port failure running in-process was meant to prevent.
+ *
+ * So an ordinary request gets this long to finish, and then the socket goes.
+ */
+exports.DEFAULT_STOP_GRACE_MS = 2000;
+/**
+ * The listeners this process owns.
+ *
+ * They run HERE, in the MCP server's own process, and that is not a
+ * convenience. A spawned child is orphaned by any signal its parent does not
+ * forward and goes on holding the HTTP and OAuth callback ports — the reason
+ * `bin/mcp-abap-adt-proxy.js` loads the server in-process instead of spawning
+ * it. In-process, a listener dies when the stdio session dies and its port
+ * goes with it.
+ *
+ * Everything here is about letting go. A stopped instance clears its idle
+ * timer, closes its listener, releases its credential and deletes its record,
+ * in that order; a session that
+ * ends stops all of them; and an instance nobody has used for a while stops
+ * itself, because an agent that finished and forgot is the case this mode has
+ * to survive.
+ */
+class ProxySupervisor {
+    options;
+    owned = new Map();
+    registry;
+    host;
+    constructor(options) {
+        this.options = options;
+        this.registry = options.registry ?? new registry_js_1.InstanceRegistry();
+        this.host = options.host ?? '127.0.0.1';
+    }
+    async start(options) {
+        const facade = await this.options.proxyFor(options);
+        // Ask for the header once, BEFORE binding a port or writing a record.
+        //
+        // Otherwise the interactive browser login fires on the first forwarded
+        // request: a window opening in the middle of some unrelated tool call, a
+        // five-minute timeout, and a 502 whose reason only reaches stderr. The
+        // caller asked for a proxy here, so here is where it learns it cannot have
+        // one — and a failed start leaves nothing behind, because nothing was taken
+        // yet.
+        const destination = options.config.btpDestination;
+        if (destination) {
+            await facade.getAuthorizationHeader(destination);
+        }
+        const idleTimeoutMs = options.idleTimeoutMs ?? exports.DEFAULT_IDLE_TIMEOUT_MS;
+        const instanceId = (0, node_crypto_1.randomUUID)();
+        const handle = (0, requestHandler_js_1.createProxyRequestHandler)({
+            config: {
+                btpDestination: options.config.btpDestination,
+                targetUrl: options.config.targetUrl,
+                defaultHeaders: options.config.defaultHeaders,
+            },
+            proxy: async () => facade,
+            // Deliberately no policy: an authentication failure answers the request
+            // and the process lives. Exiting here would take the MCP server down and
+            // the client's session with it.
+        });
+        const server = (0, node_http_1.createServer)((req, res) => {
+            this.requestStarted(instanceId);
+            res.on('close', () => this.requestFinished(instanceId));
+            handle(req, res).catch((error) => {
+                logger_js_1.logger?.error('Proxy request failed inside the MCP mode', {
+                    type: 'MCP_MODE_REQUEST_ERROR',
+                    error: error instanceof Error ? error.message : String(error),
+                });
+                if (!res.headersSent) {
+                    res.writeHead(500, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({ error: 'Internal server error' }));
+                }
+            });
+        });
+        // Everything from here on can fail with a port already bound and a
+        // credential already alive, so it is all inside one attempt that undoes
+        // itself. A synchronous `registry.record()` throwing on a read-only
+        // filesystem used to reject `start()` while leaving the listener bound, the
+        // credential held, the instance in `owned` and no idle timer to ever reach
+        // it — a proxy running that nobody had been told about.
+        let port;
+        try {
+            port = await (0, ports_js_1.listenOnFreePort)(server, this.host);
+        }
+        catch (error) {
+            this.release(facade, server, 'listen failed');
+            throw error;
+        }
+        const started = {
+            instanceId,
+            name: options.name,
+            port,
+            url: `http://${this.host}:${port}`,
+            destination: options.config.btpDestination ?? '(none)',
+            startedAt: new Date().toISOString(),
+            server,
+            facade,
+            idleTimeoutMs,
+            stopGraceMs: options.stopGraceMs ?? exports.DEFAULT_STOP_GRACE_MS,
+            inFlight: 0,
+        };
+        this.owned.set(instanceId, started);
+        try {
+            this.registry.record({
+                pid: process.pid,
+                port,
+                url: started.url,
+                destination: started.destination,
+                config: started.name,
+                startedAt: started.startedAt,
+                bootedAt: (0, registry_js_1.bootedAt)(),
+            });
+        }
+        catch (error) {
+            this.owned.delete(instanceId);
+            this.release(facade, server, 'could not write the instance record');
+            throw error;
+        }
+        if (idleTimeoutMs > 0) {
+            started.idle = this.armIdle(instanceId, idleTimeoutMs);
+        }
+        logger_js_1.logger?.info('Proxy started by the MCP mode', {
+            type: 'MCP_MODE_PROXY_STARTED',
+            instanceId,
+            name: options.name,
+            port,
+            destination: started.destination,
+        });
+        return this.describe(started);
+    }
+    /** Stop one instance, or every one this process owns. */
+    async stop(instanceId) {
+        const targets = instanceId === undefined
+            ? [...this.owned.values()]
+            : [this.owned.get(instanceId)].filter(Boolean);
+        const stopped = [];
+        for (const target of targets) {
+            if (target.idle)
+                clearTimeout(target.idle);
+            await this.closeListener(target);
+            // The port is half of it. The broker behind the credential holds cached
+            // service-key lookups, so letting go of the listener and keeping those
+            // would be releasing the visible resource and holding the rest.
+            //
+            // Guarded, and so is forgetting the record: a credential that throws on
+            // the way out used to abort this loop between closing the server and
+            // deleting the record, leaving both the instance and its file behind —
+            // and rejecting on top of it, which from the idle timer means an
+            // unhandled rejection and a dead MCP session.
+            try {
+                target.facade.dispose?.();
+            }
+            catch (error) {
+                logger_js_1.logger?.error('A credential threw while being released', {
+                    type: 'MCP_MODE_DISPOSE_FAILED',
+                    instanceId: target.instanceId,
+                    error: error instanceof Error ? error.message : String(error),
+                });
+            }
+            this.owned.delete(target.instanceId);
+            try {
+                this.registry.forget(target.port);
+            }
+            catch (error) {
+                logger_js_1.logger?.error('Could not delete the instance record', {
+                    type: 'MCP_MODE_FORGET_FAILED',
+                    port: target.port,
+                    error: error instanceof Error ? error.message : String(error),
+                });
+            }
+            stopped.push(this.describe(target));
+            logger_js_1.logger?.info('Proxy stopped by the MCP mode', {
+                type: 'MCP_MODE_PROXY_STOPPED',
+                instanceId: target.instanceId,
+                port: target.port,
+            });
+        }
+        return stopped;
+    }
+    /** What this process is running. */
+    mine() {
+        return [...this.owned.values()].map((owned) => this.describe(owned));
+    }
+    /**
+     * Live proxies started by other sessions. Dead claims are pruned on read.
+     *
+     * Anything bearing this process's pid is OURS, owned or not. A record we wrote
+     * and no longer own is an orphan of our own making — `forget()` failed, or a
+     * second supervisor shares the directory — and reporting it as "another
+     * session's, not yours to stop" would be actively misleading about the one
+     * thing the caller would act on.
+     */
+    others() {
+        return this.registry.live().filter((record) => record.pid !== process.pid);
+    }
+    /**
+     * Undo a start that did not finish: give the port back and let the credential
+     * go. Nothing here may throw — it runs on the way out of a failure, and a
+     * second failure would hide the first.
+     */
+    release(facade, server, why) {
+        logger_js_1.logger?.error('Abandoning a proxy that failed to start', {
+            type: 'MCP_MODE_START_FAILED',
+            why,
+        });
+        try {
+            server.closeAllConnections?.();
+            server.close();
+        }
+        catch {
+            /* never listened, or already closed */
+        }
+        try {
+            facade.dispose?.();
+        }
+        catch {
+            /* the credential's problem, not this one's */
+        }
+    }
+    /**
+     * Close the listener and make sure the port is actually free afterwards.
+     *
+     * Idle keep-alive sockets go immediately — they are holding the port for
+     * nothing. Anything still carrying a request gets `stopGraceMs`, and then
+     * goes too, because a stream will not end on its own and the caller asked
+     * for this port back.
+     */
+    async closeListener(target) {
+        const closed = new Promise((resolve) => target.server.close(() => resolve()));
+        target.server.closeIdleConnections?.();
+        let forced;
+        const grace = new Promise((resolve) => {
+            forced = setTimeout(() => {
+                logger_js_1.logger?.info('Cutting requests still in flight to free the port', {
+                    type: 'MCP_MODE_STOP_FORCED',
+                    instanceId: target.instanceId,
+                    port: target.port,
+                    stopGraceMs: target.stopGraceMs,
+                });
+                target.server.closeAllConnections?.();
+                resolve();
+            }, target.stopGraceMs);
+            forced.unref?.();
+        });
+        await Promise.race([closed, grace]);
+        if (forced)
+            clearTimeout(forced);
+        // After closeAllConnections the close callback fires; wait for it so the
+        // port is demonstrably free when this returns rather than probably free.
+        await closed;
+    }
+    describe(owned) {
+        const { server: _server, idle: _idle, facade: _facade, idleTimeoutMs: _idleTimeoutMs, stopGraceMs: _stopGraceMs, inFlight: _inFlight, ...rest } = owned;
+        return rest;
+    }
+    /**
+     * Restart the countdown. `unref` so a pending timer never keeps the process
+     * alive on its own — the backstop exists to release things, not to hold one.
+     */
+    armIdle(instanceId, ms) {
+        const timer = setTimeout(() => {
+            logger_js_1.logger?.info('Proxy stopped after sitting idle', {
+                type: 'MCP_MODE_PROXY_IDLE_STOP',
+                instanceId,
+                idleTimeoutMs: ms,
+            });
+            // Caught, not floated: `stop()` can reject, and an unhandled rejection
+            // from a timer ends the process — taking the client's MCP session with a
+            // proxy that merely sat unused.
+            void this.stop(instanceId).catch((error) => {
+                logger_js_1.logger?.error('Failed to stop an idle proxy', {
+                    type: 'MCP_MODE_IDLE_STOP_FAILED',
+                    instanceId,
+                    error: error instanceof Error ? error.message : String(error),
+                });
+            });
+        }, ms);
+        timer.unref?.();
+        return timer;
+    }
+    /**
+     * A request arrived: stop counting down until it is done.
+     *
+     * Clearing the handle as well as the timer is what closes the leak the old
+     * `touch()` had — it replaced `owned.idle` while `stop()` already held the
+     * previous handle, so the replacement was never cleared and later fired
+     * against an instance that had gone.
+     */
+    requestStarted(instanceId) {
+        const owned = this.owned.get(instanceId);
+        if (!owned)
+            return;
+        owned.inFlight += 1;
+        if (owned.idle) {
+            clearTimeout(owned.idle);
+            owned.idle = undefined;
+        }
+    }
+    /** The last one finished: start counting down again. */
+    requestFinished(instanceId) {
+        const owned = this.owned.get(instanceId);
+        if (!owned)
+            return;
+        owned.inFlight = Math.max(0, owned.inFlight - 1);
+        if (owned.inFlight === 0 && !owned.idle && owned.idleTimeoutMs > 0) {
+            owned.idle = this.armIdle(instanceId, owned.idleTimeoutMs);
+        }
+    }
+}
+exports.ProxySupervisor = ProxySupervisor;

package/dist/mcp/tools.d.ts

@@ -0,0 +1,28 @@
+import { z } from 'zod';
+import { type ProxySupervisor } from './supervisor.js';
+/**
+ * The thing the client has to keep being told.
+ *
+ * A running proxy holds a TCP port and a live credential for the destination.
+ * The client here is a language model reading tool descriptions selectively,
+ * so this appears in the description of `proxy_start`, in the text that comes
+ * back with the URL, and in the server's own instructions. Three places for one
+ * sentence is not redundancy — it is the difference between a reminder that is
+ * read when the work starts and one that is read when the work finishes.
+ */
+export declare const SHUTDOWN_REMINDER: string;
+export interface ToolResult {
+    content: {
+        type: 'text';
+        text: string;
+    }[];
+}
+export interface ProxyTool {
+    name: string;
+    title: string;
+    description: string;
+    inputSchema: z.ZodRawShape;
+    handler: (args: Record<string, unknown>) => Promise<ToolResult>;
+}
+export declare function createProxyTools(supervisor: ProxySupervisor, configDir?: string): ProxyTool[];
+//# sourceMappingURL=tools.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"tools.d.ts","sourceRoot":"","sources":["../../src/mcp/tools.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAQxB,OAAO,EAA2B,KAAK,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAEhF;;;;;;;;;GASG;AACH,eAAO,MAAM,iBAAiB,QAGc,CAAC;AAE7C,MAAM,WAAW,UAAU;IACzB,OAAO,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC;CAC3C;AAED,MAAM,WAAW,SAAS;IACxB,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,CAAC,CAAC,WAAW,CAAC;IAC3B,OAAO,EAAE,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,OAAO,CAAC,UAAU,CAAC,CAAC;CACjE;AAMD,wBAAgB,gBAAgB,CAC9B,UAAU,EAAE,eAAe,EAC3B,SAAS,GAAE,MAAyB,GACnC,SAAS,EAAE,CA2Jb"}