@alfe.ai/ctrader-mcp 0.3.0 → 0.3.1

package/dist/server.js

@@ -494,6 +494,18 @@ const HEARTBEAT_INTERVAL_MS = 1e4;
 const REQUEST_TIMEOUT_MS = 2e4;
 const RECONNECT_BASE_MS = 1e3;
 const RECONNECT_MAX_MS = 3e4;
+/**
+* Read-idle watchdog: cTrader echoes our 10s heartbeats and pushes its own
+* traffic, so a *healthy* socket is never silent for long. If NO inbound byte
+* arrives for this long we treat the socket as silently half-dead (a TCP
+* half-open with no FIN — the OS never fires `close`, so `handleDrop` never
+* runs and every request would otherwise time out at 20s indefinitely) and
+* force a reconnect. Set to 3× the heartbeat interval so a single dropped
+* heartbeat echo doesn't false-positive.
+*/
+const READ_IDLE_TIMEOUT_MS = 3 * HEARTBEAT_INTERVAL_MS;
+/** How often the watchdog checks the read-idle clock. */
+const WATCHDOG_INTERVAL_MS = HEARTBEAT_INTERVAL_MS;
 function log$1(msg) {
 	process.stderr.write(`[ctrader-mcp] ${msg}\n`);
 }
@@ -528,7 +540,12 @@ var HostSocket = class {
 	parser = new FrameParser();
 	pending = /* @__PURE__ */ new Map();
 	heartbeatTimer = null;
+	watchdogTimer = null;
+	/** Timestamp (ms) of the last inbound byte — drives the read-idle watchdog. */
+	lastInboundAt = 0;
 	reconnectAttempts = 0;
+	/** True from the moment a drop is handled until the reconnect succeeds. */
+	reconnectScheduled = false;
 	closing = false;
 	connectPromise = null;
 	/** ctidTraderAccountId → accessToken used to account-auth it on this socket. */
@@ -551,9 +568,11 @@ var HostSocket = class {
 	}
 	async doStart() {
 		this.conn = await this.connectFn(this.host, CTRADER_PORT);
+		this.lastInboundAt = Date.now();
 		this.wireConnection(this.conn);
 		await this.appAuth();
 		this.startHeartbeat();
+		this.startWatchdog();
 		log$1(`Connected + app-authenticated to ${this.host}`);
 	}
 	/**
@@ -593,6 +612,7 @@ var HostSocket = class {
 	}
 	wireConnection(conn) {
 		conn.on("data", (chunk) => {
+			this.lastInboundAt = Date.now();
 			for (const frame of this.parser.push(chunk)) this.dispatch(frame);
 		});
 		conn.on("error", (err) => {
@@ -627,9 +647,51 @@ var HostSocket = class {
 			this.heartbeatTimer = null;
 		}
 	}
+	/**
+	* Start the read-idle watchdog. On a *silent* socket (no inbound byte for
+	* `READ_IDLE_TIMEOUT_MS`) the OS may never fire `close` (a TCP half-open with
+	* no FIN), so `handleDrop` never runs and every request just times out at 20s
+	* forever. The watchdog detects that silence and forces a teardown +
+	* reconnect, converting a wedged socket into a fast recovery.
+	*/
+	startWatchdog() {
+		this.stopWatchdog();
+		this.watchdogTimer = setInterval(() => {
+			if (!this.conn || this.closing) return;
+			const idleFor = Date.now() - this.lastInboundAt;
+			if (idleFor >= READ_IDLE_TIMEOUT_MS) {
+				log$1(`No inbound data from ${this.host} for ${String(idleFor)}ms — forcing reconnect`);
+				this.forceReconnect();
+			}
+		}, WATCHDOG_INTERVAL_MS);
+		this.watchdogTimer.unref();
+	}
+	stopWatchdog() {
+		if (this.watchdogTimer) {
+			clearInterval(this.watchdogTimer);
+			this.watchdogTimer = null;
+		}
+	}
+	/**
+	* Tear down a silently-wedged socket and reconnect. Destroying the socket
+	* normally fires `close`, but we don't rely on it — we drive `handleDrop`
+	* directly (which fails in-flight waiters and schedules the reconnect) and
+	* suppress the redundant `close` callback via the same `closing`-free path.
+	*/
+	forceReconnect() {
+		const dead = this.conn;
+		this.conn = null;
+		try {
+			dead?.destroy();
+		} catch {}
+		this.handleDrop();
+	}
 	handleDrop() {
+		if (!this.conn && this.heartbeatTimer === null && this.reconnectScheduled) return;
 		log$1(`Socket dropped (${this.host}) — attempting reconnect`);
 		this.stopHeartbeat();
+		this.stopWatchdog();
+		this.reconnectScheduled = true;
 		this.conn = null;
 		this.parser = new FrameParser();
 		this.authedAccounts.clear();
@@ -648,10 +710,13 @@ var HostSocket = class {
 		if (this.closing) return;
 		try {
 			this.conn = await this.connectFn(this.host, CTRADER_PORT);
+			this.lastInboundAt = Date.now();
 			this.wireConnection(this.conn);
 			await this.appAuth();
 			this.startHeartbeat();
+			this.startWatchdog();
 			this.reconnectAttempts = 0;
+			this.reconnectScheduled = false;
 			log$1(`Reconnected + re-app-authenticated (${this.host})`);
 		} catch (err) {
 			log$1(`Reconnect failed (${this.host}): ${err instanceof Error ? err.message : String(err)}`);
@@ -738,6 +803,7 @@ var HostSocket = class {
 	close() {
 		this.closing = true;
 		this.stopHeartbeat();
+		this.stopWatchdog();
 		for (const [id, req] of this.pending) {
 			clearTimeout(req.timer);
 			req.reject(new CTraderError("CLIENT_CLOSED", "Client is shutting down"));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alfe.ai/ctrader-mcp",
-  "version": "0.3.0",
+  "version": "0.3.1",
   "description": "cTrader MCP server — full trading (market/limit/stop/stop-limit orders, trailing stops), Level 2 depth, live quotes, trade history, PnL & margin over the cTrader Open API (protobuf/TLS)",
   "type": "module",
   "main": "./dist/server.js",