@alfe.ai/ctrader-mcp 0.1.0 → 0.2.0

package/dist/server.js

@@ -16,14 +16,18 @@ import { z } from "zod";
 *
 * Like the other Alfe MCP servers, this one self-fetches its credentials at
 * startup via `@alfe.ai/agent-api-client`. The primary path is the
-* multi-account accessor `getCTraderAccounts()`: a single cTrader OAuth grant
-* covers ALL of the user's trading accounts on one shared `accessToken`, with
-* the SST-global app credentials (`clientId`/`clientSecret`) hoisted to the top
-* level. Only the `ctidTraderAccountId` and the protobuf socket `host` (live vs
-* demo) differ per account. We build an account *registry* from that set here
-* — one entry per account, grouped by host so a distinct socket serves each
-* distinct host (live vs demo). The cTrader Open API app-auth handshake needs
-* the raw client id/secret + access token on the box, which is why the connect
+* multi-account accessor `getCTraderAccounts()`, which aggregates trading
+* accounts across ALL of the agent's cTrader OAuth grants (multiple distinct
+* logins). Each account carries ITS OWN grant's `accessToken`; the SST-global
+* app credentials (`clientId`/`clientSecret`) are identical across grants and
+* hoisted to the top level. Only the `ctidTraderAccountId` and the protobuf
+* socket `host` (live vs demo) differ within a grant. We build an account
+* *registry* from that set here — one entry per account, each stamped with its
+* own token, grouped by host so a distinct socket serves each distinct host
+* (live vs demo). App-auth uses the global `clientId`/`clientSecret`, so one
+* live/demo socket serves accounts from multiple grants, each account-authed
+* with its own token. The cTrader Open API app-auth handshake needs the raw
+* client id/secret + access token on the box, which is why the connect
 * endpoint returns the full set rather than brokering each socket request.
 */
 /** cTrader Open API TLS endpoints. Port is always 5035. */
@@ -58,29 +62,32 @@ function resolveHost(raw) {
 *
 * Throws `ConfigError` (→ MCP startup failure, fail closed) when:
 *  - `accounts` is empty (no cTrader Connection — there is nothing to trade);
-*  - the shared app credentials (`clientId`/`clientSecret`/`accessToken`) are
-*    missing (every account needs them to authenticate);
+*  - the shared app credentials (`clientId`/`clientSecret`) are missing (every
+*    account needs them to app-authenticate);
 *  - after validating each account, no valid account remains.
 *
-* Individual accounts with an unparseable `ctidTraderAccountId` are skipped
-* (logged by the caller), but if that leaves the registry empty we fail closed
-* rather than start a server that can trade on nothing.
+* Each account carries its OWN grant's `accessToken` (accounts are aggregated
+* across multiple cTrader OAuth grants). Individual accounts with an
+* unparseable `ctidTraderAccountId` OR a missing `accessToken` are skipped
+* (the caller warns on the input-vs-registry-size count diff — see server.ts)
+* rather than poisoning the whole registry, but if that leaves the registry
+* empty we fail closed rather than start a server that can trade on nothing.
 */
 function buildRegistry(creds) {
 	const clientId = creds.clientId.trim();
 	const clientSecret = creds.clientSecret.trim();
-	const accessToken = creds.accessToken.trim();
 	if (creds.accounts.length === 0) throw new ConfigError("No cTrader trading accounts are authorized for this agent. Connect a cTrader account (OAuth) for this agent, then retry.");
 	const missing = [];
 	if (!clientId) missing.push("clientId");
 	if (!clientSecret) missing.push("clientSecret");
-	if (!accessToken) missing.push("accessToken");
 	if (missing.length > 0) throw new ConfigError(`The cTrader connection is missing shared credential field(s): ${missing.join(", ")}. Connect a cTrader account (OAuth) for this agent, then retry.`);
 	const registry = /* @__PURE__ */ new Map();
 	for (const account of creds.accounts) {
 		const idRaw = account.ctidTraderAccountId.trim();
 		const accountId = Number(idRaw);
 		if (!idRaw || !Number.isInteger(accountId) || accountId <= 0) continue;
+		const accessToken = account.accessToken.trim();
+		if (!accessToken) continue;
 		const host = resolveHost(account.host);
 		registry.set(idRaw, {
 			clientId,
@@ -93,7 +100,7 @@ function buildRegistry(creds) {
 			...account.accountNumber != null ? { accountNumber: account.accountNumber } : {}
 		});
 	}
-	if (registry.size === 0) throw new ConfigError("Every cTrader account returned had an unusable ctidTraderAccountId; cannot build a trading registry. Re-connect the cTrader account (OAuth).");
+	if (registry.size === 0) throw new ConfigError("Every cTrader account returned had an unusable ctidTraderAccountId or was missing its access token; cannot build a trading registry. Re-connect the cTrader account (OAuth).");
 	return registry;
 }
 //#endregion
@@ -371,9 +378,12 @@ function decodeTrendbar(bar) {
 * 10-second heartbeat, reconnect-on-drop, and cTrader-error mapping.
 *
 * ── Multi-account model ──
-* A single cTrader OAuth grant covers ALL of the user's trading accounts on one
-* shared access token; only the `ctidTraderAccountId` and the socket `host`
-* (live vs demo) differ per account. But one TLS socket dials exactly ONE host.
+* Within a SINGLE cTrader OAuth grant one shared access token covers all of that
+* login's accounts; ACROSS grants the tokens differ, so each account carries its
+* OWN grant token (`authedAccounts` memoizes account-auth per accountId, keyed by
+* that token — a changed token re-auths, so mixed-grant tokens on one host socket
+* work with zero extra code). Only the `ctidTraderAccountId` and the socket `host`
+* (live vs demo) drive routing. But one TLS socket dials exactly ONE host.
 * So the topology is:
 *
 *   CTraderPool  ── owns the account registry, one HostSocket per DISTINCT host
@@ -1258,17 +1268,20 @@ function assertExecution(res, extraOkTypes = /* @__PURE__ */ new Set()) {
 * Architecture:
 *   Agent runtime ←(stdio/MCP)→ this server ←(protobuf/TLS 5035)→ cTrader Open API
 *
-* ── Multi-account ──
+* ── Multi-account, multi-grant ──
 * Credentials are self-fetched at startup (the atlassian/google pattern):
 * `resolveConfig()` yields the agent's `{ apiKey, apiUrl }`, and
-* `AgentApiClient.getCTraderAccounts()` returns the full set of authorized
-* trading accounts on one OAuth grant — one shared `accessToken` +
-* SST-global `clientId`/`clientSecret`, with a per-account `ctidTraderAccountId`
-* and `host` (live vs demo). We build an account registry and drive a
-* `CTraderPool` that opens one authenticated socket per distinct host and
-* routes each tool call to the account it names (see client.ts). No account is
-* ever chosen implicitly when several are connected — the tools require an
-* explicit `accountId` in that case.
+* `AgentApiClient.getCTraderAccounts()` aggregates the authorized trading
+* accounts across ALL of the agent's cTrader OAuth grants (multiple distinct
+* logins). Each account carries ITS OWN grant's `accessToken`; only the global
+* app credentials (`clientId`/`clientSecret`) are shared across every grant and
+* hoisted to the top level. A per-account `ctidTraderAccountId` and `host`
+* (live vs demo) drive routing. We build an account registry and drive a
+* `CTraderPool` that opens one authenticated socket per distinct host — each
+* account is account-authed on that socket with its OWN token, so one live/demo
+* socket serves accounts from multiple grants — and routes each tool call to the
+* account it names (see client.ts). No account is ever chosen implicitly when
+* several are connected — the tools require an explicit `accountId` in that case.
 */
 function log(msg) {
 	process.stderr.write(`[ctrader-mcp] ${msg}\n`);
@@ -1281,7 +1294,10 @@ async function main() {
 	});
 	let registry;
 	try {
-		registry = buildRegistry(await apiClient.getCTraderAccounts());
+		const creds = await apiClient.getCTraderAccounts();
+		registry = buildRegistry(creds);
+		const dropped = creds.accounts.length - registry.size;
+		if (dropped > 0) log(`Warning: ${String(dropped)} of ${String(creds.accounts.length)} cTrader account(s) were skipped (unparseable ctidTraderAccountId or missing access token); ${String(registry.size)} usable.`);
 	} catch (err) {
 		if (err instanceof ConfigError) log(`No usable cTrader connection: ${err.message}`);
 		else log(`Failed to resolve cTrader accounts: ${err instanceof Error ? err.message : String(err)}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alfe.ai/ctrader-mcp",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "cTrader MCP server — full trading (place/modify/close orders + read) over the cTrader Open API (protobuf/TLS)",
   "type": "module",
   "main": "./dist/server.js",
@@ -21,7 +21,7 @@
     "@modelcontextprotocol/sdk": "^1.29.0",
     "protobufjs": "^8.7.0",
     "zod": "^4.0.5",
-    "@alfe.ai/agent-api-client": "0.10.0",
+    "@alfe.ai/agent-api-client": "0.11.0",
     "@alfe.ai/config": "0.3.0"
   },
   "license": "UNLICENSED",