mcp-local-tunnel 1.0.1 → 1.1.0

package/README.md

@@ -81,6 +81,8 @@ On first run, the agent opens your browser for login (same identity provider as
 
 The agent spawns the configured local MCP servers, connects to the relay, and registers all their tools. Remote clients see tools like `shell__execute` and `computer__computer` — namespaced by server name.
 
+When used as an MCP server in tools like Claude Code or opencode, the agent runs as a background daemon. Multiple sessions share a single relay connection — the daemon stays alive as long as at least one session exists, and shuts down automatically after the last session ends. Daemon logs are written to `~/.config/mcp-local-tunnel/logs/`.
+
 If the agent disconnects (laptop sleeps, network drops), it automatically reconnects with exponential backoff.
 
 ### Config

package/dist/agent.d.ts

@@ -1,2 +1,6 @@
 import type { AgentConfig } from './types.js';
-export declare const startAgent: (config: AgentConfig) => Promise<void>;
+export type AgentHandle = {
+    /** Gracefully shut down the agent, closing all connections and servers. */
+    stop: () => Promise<void>;
+};
+export declare const startAgent: (config: AgentConfig) => Promise<AgentHandle>;

package/dist/agent.js

@@ -12,6 +12,8 @@ const streamableHttp_js_1 = require("@modelcontextprotocol/sdk/client/streamable
 const agent_auth_js_1 = require("./agent-auth.js");
 const MAX_RECONNECT_DELAY_MS = 30_000;
 const INITIAL_RECONNECT_DELAY_MS = 1_000;
+const PING_INTERVAL_MS = 30_000;
+const PONG_TIMEOUT_MS = 10_000;
 const toWsUrl = (relay) => {
     if (relay.startsWith('ws://') || relay.startsWith('wss://')) {
         return relay.endsWith('/ws') ? relay : `${relay.replace(/\/$/, '')}/ws`;
@@ -29,6 +31,8 @@ const startAgent = async (config) => {
     const relayUrl = toWsUrl(config.relay);
     let reconnectDelay = INITIAL_RECONNECT_DELAY_MS;
     let shouldReconnect = true;
+    let currentWs;
+    let currentServers = [];
     const spawnServers = async () => {
         const servers = [];
         const entries = Object.entries(config.servers);
@@ -117,12 +121,33 @@ const startAgent = async (config) => {
         wsUrl.searchParams.set('token', token);
         console.log(`Connecting to ${config.relay} as "${name}"...`);
         const ws = new ws_1.default(wsUrl.toString());
+        let pingInterval;
+        let pongTimeout;
         ws.on('open', () => {
             reconnectDelay = INITIAL_RECONNECT_DELAY_MS;
             console.log(`Connected to ${config.relay} as "${name}"`);
             console.log(`Serving ${tools.length} tools: ${tools.map((t) => t.name).join(', ')}`);
             const msg = { type: 'tools', tools };
             ws.send(JSON.stringify(msg));
+            // Start ping/pong keepalive
+            pingInterval = setInterval(() => {
+                if (ws.readyState === ws_1.default.OPEN) {
+                    ws.ping();
+                    if (pongTimeout) {
+                        clearTimeout(pongTimeout);
+                    }
+                    pongTimeout = setTimeout(() => {
+                        console.log('Pong timeout — connection dead, terminating.');
+                        ws.terminate();
+                    }, PONG_TIMEOUT_MS);
+                }
+            }, PING_INTERVAL_MS);
+        });
+        ws.on('pong', () => {
+            if (pongTimeout) {
+                clearTimeout(pongTimeout);
+                pongTimeout = undefined;
+            }
         });
         ws.on('message', async (data) => {
             try {
@@ -157,6 +182,14 @@ const startAgent = async (config) => {
             }
         });
         ws.on('close', () => {
+            if (pingInterval) {
+                clearInterval(pingInterval);
+                pingInterval = undefined;
+            }
+            if (pongTimeout) {
+                clearTimeout(pongTimeout);
+                pongTimeout = undefined;
+            }
             console.log('Disconnected from relay.');
             void closeServers(servers);
             if (shouldReconnect) {
@@ -170,15 +203,17 @@ const startAgent = async (config) => {
         ws.on('error', (err) => {
             console.error('WebSocket error:', err.message);
         });
-        const shutdown = () => {
+        currentWs = ws;
+        currentServers = servers;
+    };
+    await connect();
+    return {
+        async stop() {
             shouldReconnect = false;
             console.log('\nShutting down agent...');
-            ws.close();
-            void closeServers(servers).then(() => process.exit(0));
-        };
-        process.on('SIGINT', shutdown);
-        process.on('SIGTERM', shutdown);
+            currentWs?.close();
+            await closeServers(currentServers);
+        },
     };
-    await connect();
 };
 exports.startAgent = startAgent;

package/dist/connection-manager.d.ts

@@ -6,11 +6,13 @@ export type AgentConnection = {
     name: string;
     connectedAt: number;
     tools: ToolDef[];
+    lastPingAt: number;
 };
 export declare class ConnectionManager {
     /** userId -> AgentConnection[] (one per device) */
     private readonly connections;
     private readonly pending;
+    constructor();
     addConnection(ws: WebSocket, userId: string, name: string): AgentConnection;
     getConnectionsForUser(userId: string): AgentConnection[];
     getToolsForUser(userId: string): (ToolDef & {

package/dist/connection-manager.js

@@ -3,13 +3,31 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ConnectionManager = void 0;
 const node_crypto_1 = require("node:crypto");
 const REQUEST_TIMEOUT_MS = 120_000; // 2 minutes
+const STALE_CHECK_INTERVAL_MS = 60_000;
+const STALE_THRESHOLD_MS = 90_000; // 3 missed 30s pings
 class ConnectionManager {
     /** userId -> AgentConnection[] (one per device) */
     connections = new Map();
     pending = new Map();
+    constructor() {
+        // Periodically terminate connections that haven't pinged recently
+        const interval = setInterval(() => {
+            const threshold = Date.now() - STALE_THRESHOLD_MS;
+            for (const conns of this.connections.values()) {
+                for (const conn of conns) {
+                    if (conn.lastPingAt < threshold) {
+                        console.log(`No ping from "${conn.name}" (${conn.userId}) for ${Math.round((Date.now() - conn.lastPingAt) / 1000)}s, terminating.`);
+                        conn.ws.terminate();
+                    }
+                }
+            }
+        }, STALE_CHECK_INTERVAL_MS);
+        interval.unref();
+    }
     addConnection(ws, userId, name) {
+        const now = Date.now();
         const conn = {
-            ws, userId, name, connectedAt: Date.now(), tools: [],
+            ws, userId, name, connectedAt: now, tools: [], lastPingAt: now,
         };
         ws.on('message', (data) => {
             try {
@@ -20,6 +38,10 @@ class ConnectionManager {
                 console.error('Failed to parse WebSocket message:', err);
             }
         });
+        // Track agent pings as liveness signal
+        ws.on('ping', () => {
+            conn.lastPingAt = Date.now();
+        });
         ws.on('close', () => {
             this.removeConnection(conn);
         });

package/dist/daemon.d.ts

@@ -0,0 +1,18 @@
+import { type AgentHandle } from './agent.js';
+import type { AgentConfig } from './types.js';
+export type DaemonOptions = {
+    /** Override how the agent is started (used in tests). */
+    startAgent?: (config: AgentConfig) => Promise<AgentHandle>;
+    /** Override the grace period in ms before shutdown after last session disconnects. */
+    gracePeriodMs?: number;
+    /** Override the PID check interval in ms. */
+    pidCheckIntervalMs?: number;
+};
+/**
+ * Start the daemon process. Runs the agent and listens on an IPC socket
+ * for session connections from stub servers. Shuts down when no sessions
+ * remain after a grace period.
+ *
+ * This is invoked internally and should not be called directly by users.
+ */
+export declare const startDaemon: (config: AgentConfig, configIdentifier: string, options?: DaemonOptions) => Promise<void>;

package/dist/daemon.js

@@ -0,0 +1,174 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startDaemon = void 0;
+const node_net_1 = __importDefault(require("node:net"));
+const node_fs_1 = require("node:fs");
+const agent_js_1 = require("./agent.js");
+const ipc_path_js_1 = require("./ipc-path.js");
+const GRACE_PERIOD_MS = 10_000;
+const PID_CHECK_INTERVAL_MS = 30_000;
+/**
+ * Try connecting to a Unix socket / named pipe. Returns true if
+ * something is actively listening, false if the socket is stale or absent.
+ */
+const isSocketLive = async (ipcPath) => new Promise((resolve) => {
+    const socket = node_net_1.default.createConnection(ipcPath, () => {
+        socket.destroy();
+        resolve(true);
+    });
+    socket.on('error', () => {
+        socket.destroy();
+        resolve(false);
+    });
+});
+/**
+ * Start the daemon process. Runs the agent and listens on an IPC socket
+ * for session connections from stub servers. Shuts down when no sessions
+ * remain after a grace period.
+ *
+ * This is invoked internally and should not be called directly by users.
+ */
+const startDaemon = async (config, configIdentifier, options) => {
+    const ipcPath = (0, ipc_path_js_1.getIpcPath)(configIdentifier);
+    const pidPath = (0, ipc_path_js_1.getPidPath)(configIdentifier);
+    let connectionCount = 0;
+    let shutdownTimer;
+    const state = {};
+    const gracePeriodMs = options?.gracePeriodMs
+        ?? (process.env.DAEMON_GRACE_PERIOD_MS ? Number(process.env.DAEMON_GRACE_PERIOD_MS) : GRACE_PERIOD_MS);
+    const pidCheckIntervalMs = options?.pidCheckIntervalMs
+        ?? (process.env.DAEMON_PID_CHECK_INTERVAL_MS ? Number(process.env.DAEMON_PID_CHECK_INTERVAL_MS) : PID_CHECK_INTERVAL_MS);
+    const startAgentFn = options?.startAgent ?? agent_js_1.startAgent;
+    const cleanup = () => {
+        if (process.platform !== 'win32') {
+            try {
+                (0, node_fs_1.unlinkSync)(ipcPath);
+            }
+            catch {
+                // Already cleaned up
+            }
+        }
+        try {
+            (0, node_fs_1.unlinkSync)(pidPath);
+        }
+        catch {
+            // Already cleaned up
+        }
+    };
+    const shutdownNow = () => {
+        cleanup();
+        if (state.agentHandle) {
+            void state.agentHandle.stop().then(() => process.exit(0));
+        }
+        else {
+            process.exit(0);
+        }
+    };
+    const scheduleShutdown = () => {
+        if (shutdownTimer) {
+            clearTimeout(shutdownTimer);
+        }
+        shutdownTimer = setTimeout(() => {
+            if (connectionCount === 0) {
+                console.log('No sessions remaining. Shutting down daemon.');
+                shutdownNow();
+            }
+        }, gracePeriodMs);
+    };
+    // Before touching the socket, check if another daemon is already listening.
+    // Only clean up the socket file if it's stale (nothing listening).
+    if (process.platform !== 'win32') {
+        const live = await isSocketLive(ipcPath);
+        if (live) {
+            console.log('Another daemon is already listening. Exiting.');
+            process.exit(0);
+        }
+        // Socket file is stale or absent — safe to clean up
+        try {
+            (0, node_fs_1.unlinkSync)(ipcPath);
+        }
+        catch {
+            // Doesn't exist, fine
+        }
+    }
+    const server = node_net_1.default.createServer((socket) => {
+        connectionCount += 1;
+        console.log(`Session connected (${connectionCount} active)`);
+        if (shutdownTimer) {
+            clearTimeout(shutdownTimer);
+            shutdownTimer = undefined;
+        }
+        socket.on('close', () => {
+            connectionCount -= 1;
+            console.log(`Session disconnected (${connectionCount} active)`);
+            if (connectionCount === 0) {
+                scheduleShutdown();
+            }
+        });
+        socket.on('error', () => {
+            // Connection errors are handled by 'close'
+        });
+    });
+    // Wait for listen to succeed before writing PID file.
+    // This avoids overwriting another daemon's PID file if we lose the race.
+    await new Promise((resolve, reject) => {
+        server.listen(ipcPath, () => {
+            resolve();
+        });
+        server.on('error', (err) => {
+            if (err.code === 'EADDRINUSE') {
+                console.log('Another daemon is already listening. Exiting.');
+                process.exit(0);
+            }
+            reject(err);
+        });
+    });
+    console.log(`Daemon IPC listening on ${ipcPath}`);
+    // Now that we own the socket, write PID file
+    (0, node_fs_1.writeFileSync)(pidPath, String(process.pid), { mode: 0o600 });
+    // Periodically verify our PID file still points to us.
+    // If someone deleted it or another daemon overwrote it, we're orphaned.
+    const pidCheckInterval = setInterval(() => {
+        try {
+            if (!(0, node_fs_1.existsSync)(pidPath)) {
+                console.log('PID file deleted. Shutting down orphaned daemon.');
+                clearInterval(pidCheckInterval);
+                shutdownNow();
+                return;
+            }
+            const filePid = Number.parseInt((0, node_fs_1.readFileSync)(pidPath, 'utf-8').trim(), 10);
+            if (filePid !== process.pid) {
+                console.log(`PID file points to ${filePid}, not us (${process.pid}). Shutting down orphaned daemon.`);
+                clearInterval(pidCheckInterval);
+                // Don't clean up — the PID file belongs to the other daemon
+                if (state.agentHandle) {
+                    void state.agentHandle.stop().then(() => process.exit(0));
+                }
+                else {
+                    process.exit(0);
+                }
+            }
+        }
+        catch {
+            // If we can't read the PID file, assume we're still valid
+        }
+    }, pidCheckIntervalMs);
+    pidCheckInterval.unref();
+    // Start the actual agent (wrapped in try/catch to clean up on failure)
+    try {
+        state.agentHandle = await startAgentFn(config);
+    }
+    catch (err) {
+        console.error('Failed to start agent:', err instanceof Error ? err.message : err);
+        cleanup();
+        process.exit(1);
+    }
+    // Schedule shutdown in case no session connects
+    scheduleShutdown();
+    process.on('SIGINT', shutdownNow);
+    process.on('SIGTERM', shutdownNow);
+};
+exports.startDaemon = startDaemon;

package/dist/index.js

@@ -3,14 +3,20 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const config_js_1 = require("./config.js");
 const relay_js_1 = require("./relay.js");
-const agent_js_1 = require("./agent.js");
+const daemon_js_1 = require("./daemon.js");
+const stub_server_js_1 = require("./stub-server.js");
+const ipc_path_js_1 = require("./ipc-path.js");
 const main = async () => {
+    const isDaemonProcess = process.argv.includes('--internal-daemon-process-do-not-use-directly');
     const config = (0, config_js_1.loadConfig)();
     if (config.mode === 'relay') {
         (0, relay_js_1.startRelay)(config);
     }
+    else if (isDaemonProcess) {
+        await (0, daemon_js_1.startDaemon)(config, (0, ipc_path_js_1.resolveConfigIdentifier)());
+    }
     else {
-        await (0, agent_js_1.startAgent)(config);
+        await (0, stub_server_js_1.startStubServer)(config, (0, ipc_path_js_1.resolveConfigIdentifier)());
     }
 };
 main().catch((err) => {

package/dist/ipc-path.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Determine a stable identifier for the current config source.
+ * This is used to derive unique IPC socket / PID file paths so that
+ * different relay configs get independent daemons.
+ */
+export declare const resolveConfigIdentifier: () => string;
+/**
+ * Get the IPC socket/pipe path for the daemon.
+ * Uses a hash of the config identifier to allow multiple independent daemons
+ * for different relay configurations.
+ *
+ * - macOS/Linux: Unix domain socket in ~/.config/mcp-local-tunnel/sockets/
+ * - Windows: Named pipe \\.\pipe\mcp-local-tunnel-<hash>
+ */
+export declare const getIpcPath: (configIdentifier: string) => string;
+/**
+ * Get the path for the daemon's PID file.
+ */
+export declare const getPidPath: (configIdentifier: string) => string;
+/**
+ * Get the path for daemon log output.
+ */
+export declare const getLogPath: (configIdentifier: string) => string;

package/dist/ipc-path.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getLogPath = exports.getPidPath = exports.getIpcPath = exports.resolveConfigIdentifier = void 0;
+const node_path_1 = require("node:path");
+const node_os_1 = require("node:os");
+const node_crypto_1 = require("node:crypto");
+const node_fs_1 = require("node:fs");
+/**
+ * Determine a stable identifier for the current config source.
+ * This is used to derive unique IPC socket / PID file paths so that
+ * different relay configs get independent daemons.
+ */
+const resolveConfigIdentifier = () => {
+    // If MCP_LOCAL_TUNNEL_CONFIG is set and points to a file, use the file path.
+    // If it's inline JSON, hash the content.
+    // Otherwise use the default config file path.
+    const raw = process.env.MCP_LOCAL_TUNNEL_CONFIG;
+    if (raw && !raw.startsWith('{') && (0, node_fs_1.existsSync)(raw)) {
+        return raw;
+    }
+    if (raw) {
+        return raw;
+    }
+    return 'mcp-local-tunnel.config.json';
+};
+exports.resolveConfigIdentifier = resolveConfigIdentifier;
+/**
+ * Get the IPC socket/pipe path for the daemon.
+ * Uses a hash of the config identifier to allow multiple independent daemons
+ * for different relay configurations.
+ *
+ * - macOS/Linux: Unix domain socket in ~/.config/mcp-local-tunnel/sockets/
+ * - Windows: Named pipe \\.\pipe\mcp-local-tunnel-<hash>
+ */
+const getIpcPath = (configIdentifier) => {
+    const hash = (0, node_crypto_1.createHash)('sha256').update(configIdentifier).digest('hex').slice(0, 12);
+    if (process.platform === 'win32') {
+        return `\\\\.\\pipe\\mcp-local-tunnel-${hash}`;
+    }
+    const dir = (0, node_path_1.join)(process.env.XDG_RUNTIME_DIR ?? (0, node_path_1.join)((0, node_os_1.homedir)(), '.config', 'mcp-local-tunnel'), 'sockets');
+    (0, node_fs_1.mkdirSync)(dir, { recursive: true });
+    return (0, node_path_1.join)(dir, `daemon-${hash}.sock`);
+};
+exports.getIpcPath = getIpcPath;
+/**
+ * Get the path for the daemon's PID file.
+ */
+const getPidPath = (configIdentifier) => {
+    const hash = (0, node_crypto_1.createHash)('sha256').update(configIdentifier).digest('hex').slice(0, 12);
+    const dir = (0, node_path_1.join)((0, node_os_1.homedir)(), '.config', 'mcp-local-tunnel');
+    (0, node_fs_1.mkdirSync)(dir, { recursive: true });
+    return (0, node_path_1.join)(dir, `daemon-${hash}.pid`);
+};
+exports.getPidPath = getPidPath;
+/**
+ * Get the path for daemon log output.
+ */
+const getLogPath = (configIdentifier) => {
+    const hash = (0, node_crypto_1.createHash)('sha256').update(configIdentifier).digest('hex').slice(0, 12);
+    const dir = (0, node_path_1.join)((0, node_os_1.homedir)(), '.config', 'mcp-local-tunnel', 'logs');
+    (0, node_fs_1.mkdirSync)(dir, { recursive: true });
+    return (0, node_path_1.join)(dir, `daemon-${hash}.log`);
+};
+exports.getLogPath = getLogPath;

package/dist/stub-server.d.ts

@@ -0,0 +1,8 @@
+import type { AgentConfig } from './types.js';
+/**
+ * Start a stub MCP server on stdio. This is what Claude Code / opencode
+ * sees as an MCP server. It manages the daemon lifecycle and responds to
+ * MCP requests with minimal/empty responses — actual tool usage goes
+ * through the tunnel relay, not through this stub.
+ */
+export declare const startStubServer: (config: AgentConfig, configIdentifier: string) => Promise<void>;

package/dist/stub-server.js

@@ -0,0 +1,108 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startStubServer = void 0;
+const node_net_1 = __importDefault(require("node:net"));
+const node_child_process_1 = require("node:child_process");
+const node_fs_1 = require("node:fs");
+const mcp_js_1 = require("@modelcontextprotocol/sdk/server/mcp.js");
+const stdio_js_1 = require("@modelcontextprotocol/sdk/server/stdio.js");
+const ipc_path_js_1 = require("./ipc-path.js");
+const agent_auth_js_1 = require("./agent-auth.js");
+/**
+ * Try a single IPC connection attempt. Resolves with the socket on
+ * success, or undefined on failure. Always cleans up failed sockets.
+ */
+const tryConnectOnce = async (ipcPath) => new Promise((resolve) => {
+    const socket = node_net_1.default.createConnection(ipcPath, () => {
+        resolve(socket);
+    });
+    socket.on('error', () => {
+        socket.destroy();
+        resolve(undefined);
+    });
+});
+/**
+ * Spawn the daemon as a detached background process.
+ */
+const spawnDaemon = (configIdentifier) => {
+    const logPath = (0, ipc_path_js_1.getLogPath)(configIdentifier);
+    const logFd = (0, node_fs_1.openSync)(logPath, 'a');
+    const args = process.argv.slice(1).filter((a) => a !== '--internal-daemon-process-do-not-use-directly');
+    const child = (0, node_child_process_1.spawn)(process.execPath, [...args, '--internal-daemon-process-do-not-use-directly'], {
+        detached: true,
+        stdio: ['ignore', logFd, logFd],
+        env: process.env,
+    });
+    child.unref();
+    console.error(`Daemon spawned (pid ${child.pid}), logs: ${logPath}`);
+};
+const CONNECT_TIMEOUT_MS = 30_000;
+const CONNECT_RETRY_MS = 200;
+/**
+ * Connect to the daemon, spawning it if necessary. Strategy:
+ *
+ * 1. Try to connect to existing daemon
+ * 2. If that fails, ensure auth tokens are cached, spawn daemon
+ * 3. Retry connecting until success or timeout
+ *
+ * This approach is race-safe: if two stubs both spawn a daemon
+ * simultaneously, one daemon wins the IPC socket and the other exits.
+ * Both stubs eventually connect to the winning daemon.
+ */
+const ensureDaemonAndConnect = async (config, configIdentifier) => {
+    const ipcPath = (0, ipc_path_js_1.getIpcPath)(configIdentifier);
+    // Fast path: daemon is already running
+    const existing = await tryConnectOnce(ipcPath);
+    if (existing) {
+        return existing;
+    }
+    // Daemon not running — pre-auth (we have a TTY, daemon doesn't)
+    // then spawn
+    await (0, agent_auth_js_1.getAccessToken)(config.relay);
+    spawnDaemon(configIdentifier);
+    // Poll until the daemon's IPC socket is ready
+    const deadline = Date.now() + CONNECT_TIMEOUT_MS;
+    while (Date.now() < deadline) {
+        // eslint-disable-next-line no-await-in-loop
+        const socket = await tryConnectOnce(ipcPath);
+        if (socket) {
+            return socket;
+        }
+        // eslint-disable-next-line no-await-in-loop
+        await new Promise((r) => {
+            setTimeout(r, CONNECT_RETRY_MS);
+        });
+    }
+    throw new Error(`Timed out waiting for daemon (${CONNECT_TIMEOUT_MS / 1000}s). Check logs: ${(0, ipc_path_js_1.getLogPath)(configIdentifier)}`);
+};
+/**
+ * Start a stub MCP server on stdio. This is what Claude Code / opencode
+ * sees as an MCP server. It manages the daemon lifecycle and responds to
+ * MCP requests with minimal/empty responses — actual tool usage goes
+ * through the tunnel relay, not through this stub.
+ */
+const startStubServer = async (config, configIdentifier) => {
+    const daemonSocket = await ensureDaemonAndConnect(config, configIdentifier);
+    // Run a stub MCP server on stdio. Register then remove a dummy tool
+    // so the SDK installs the tools/list handler (returns empty list).
+    const server = new mcp_js_1.McpServer({ name: 'mcp-local-tunnel', version: '1.0.0' });
+    const registered = server.registerTool('_init', {}, () => ({ content: [] }));
+    registered.remove();
+    const transport = new stdio_js_1.StdioServerTransport();
+    await server.connect(transport);
+    // When stdin closes (session ends), disconnect from daemon
+    process.stdin.on('end', () => {
+        daemonSocket.destroy();
+    });
+    // If daemon disconnects, exit
+    daemonSocket.on('close', () => {
+        process.exit(0);
+    });
+    daemonSocket.on('error', () => {
+        process.exit(1);
+    });
+};
+exports.startStubServer = startStubServer;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mcp-local-tunnel",
-  "version": "1.0.1",
+  "version": "1.1.0",
   "description": "Expose local MCP servers to remote clients without opening ports.",
   "license": "MIT",
   "author": "Adam Jones (domdomegg)",