mixdog 1.3.5 → 1.4.0

package/src/runtime/agent/orchestrator/mcp/client-transport.mjs

@@ -8,6 +8,13 @@ import { createMcpOAuth } from './oauth.mjs';
 import { mcpOAuthClientFor, mcpOAuthDisplayName } from './oauth-client.mjs';
 import { googleMcpService, withGoogleMcp } from '../../../connectors/google-mcp.mjs';
 import { gmailAppPasswordService, withGmailAppPasswordMcp } from '../../../connectors/gmail-app-password.mjs';
+import { connectorAccountRequest, withConnectorAccountsMcp } from '../../../connectors/connector-accounts-mcp.mjs';
+import {
+  connectorAccountsOf,
+  connectorLiveAccountServers,
+  gmailAppPasswordAccount,
+} from '../../../shared/connector-catalog.mjs';
+import { isMcpOAuthReauthenticationRequired } from './oauth.mjs';
 import {
   AUTO_DETECT_PORTS,
   expandEnvVars,
@@ -63,10 +70,65 @@ export function hasConfiguredMcpAuth(cfg) {
   return (
     Boolean(String(cfg.bearer_token_env_var || '').trim()) ||
     configured(cfg.headers) ||
-    configured(cfg.env_http_headers)
+    configured(cfg.env_http_headers) ||
+    // A multi-account connector's server: each account authenticates itself.
+    connectorAccountsOf(cfg).length > 0
   );
 }
 
+/** One account of a multi-account connector server (connector-catalog.mjs
+ *  connectorAccountServer) as connector-accounts-mcp.mjs calls it: through
+ *  the transport the account had as a server of its own — its app-password
+ *  header, or its own non-interactive OAuth sign-in (refreshed as needed; a
+ *  new sign-in goes through 계정 바꾸기, never through a tool call). */
+function connectorAccountClient(serverName, accountCfg, oauthOptions) {
+  const base = { name: accountCfg.name, email: '', appPassword: false, close() {} };
+  let url;
+  try {
+    url = resolveMcpOAuthUrl(accountCfg);
+    if (hasConfiguredMcpAuth(accountCfg)) {
+      const email = gmailAppPasswordAccount(accountCfg);
+      const fetchImpl = gmailAppPasswordService(url) ? withGmailAppPasswordMcp() : fetch;
+      return {
+        ...base,
+        email,
+        appPassword: Boolean(email),
+        request: connectorAccountRequest(url, fetchImpl, resolveMcpHttpHeaders(accountCfg)),
+      };
+    }
+    const oauth = createMcpOAuth({
+      url,
+      serverName: mcpOAuthDisplayName(accountCfg, serverName),
+      oauthClient: mcpOAuthClientFor(accountCfg, url),
+      ...(oauthOptions?.fetchImpl ? { fetchImpl: oauthOptions.fetchImpl } : {}),
+      ...(googleMcpService(url) ? { fetchImpl: withGoogleMcp(oauthOptions?.fetchImpl) } : {}),
+    });
+    const send = connectorAccountRequest(url, (input, init) => oauth.fetch(input, init));
+    return {
+      ...base,
+      async request(message, options) {
+        try {
+          return await send(message, options);
+        } catch (error) {
+          const reason = scrubMcpConnectionMessage(error?.message || String(error), accountCfg);
+          const scrubbed = new Error(
+            isMcpOAuthReauthenticationRequired(error)
+              ? 'Sign-in required; sign this account in again in Connectors.'
+              : reason
+          );
+          if (isMcpOAuthReauthenticationRequired(error)) scrubbed.authRequired = true;
+          throw scrubbed;
+        }
+      },
+      close: () => oauth.close(),
+    };
+  } catch (error) {
+    // A broken account (no sign-in client, an invalid address) stays listed with why.
+    const failed = new Error(error?.message || String(error));
+    return { ...base, request: async () => Promise.reject(failed) };
+  }
+}
+
 // The SDK's WebSocket transport opens its socket without a way to set request
 // headers. This subclass changes only socket creation: Node's WebSocket takes
 // `{ protocols, headers }`; the guard and event wiring match the stock start().
@@ -101,24 +163,115 @@ function createHeaderWebSocketTransport(Base, messageSchema, url, headers) {
     }
   })(url);
 }
+// Unset variables a config references: a failure under `strictEnv`,
+// otherwise warnings (names only), each logged.
+function missingEnvWarnings(name, cfg, strictEnv, log) {
+  const warnings = [];
+  const missing = findMissingMcpEnvVars(cfg);
+  if (missing.length) {
+    const message = `missing environment variable(s): ${missing.join(', ')}`;
+    if (strictEnv === true) throw new Error(message);
+    warnings.push(message);
+    log(`[mcp-client] "${name}": ${message}\n`);
+  }
+  return warnings;
+}
+
+// A multi-account connector: one server, every account behind it; closing the
+// transport closes every account client.
+function connectorAccountsTransport({ name, cfg, Transport, url, accountServers, oauthOptions, log }) {
+  const accounts = accountServers.map((accountCfg) => connectorAccountClient(name, accountCfg, oauthOptions));
+  const transport = new Transport(new URL(url), {
+    fetch: withConnectorAccountsMcp({ connector: cfg.connector, accounts }),
+  });
+  const close = transport.close.bind(transport);
+  transport.close = async () => {
+    for (const account of accounts) account.close();
+    await close();
+  };
+  log(`[mcp-client] Connecting "${name}" with ${accounts.length} account(s)\n`);
+  return transport;
+}
+
+// A streamable HTTP or SSE server: its configured authentication, or else an
+// OAuth sign-in the transport owns (and closes with it).
+function remoteHttpTransport({ name, cfg, kind, Transport, url, oauthOptions, log }) {
+  const opts = requestInitFor(cfg);
+  // Explicit authentication remains authoritative (including custom API-key
+  // headers). Never forward those credentials to OAuth discovery endpoints.
+  let transport;
+  let oauth = null;
+  if (!hasConfiguredMcpAuth(cfg)) {
+    oauth = createMcpOAuth({
+      url,
+      serverName: mcpOAuthDisplayName(cfg, name),
+      oauthClient: mcpOAuthClientFor(cfg, url),
+      ...oauthOptions,
+      // A built-in Google connector is answered in-process.
+      ...(googleMcpService(url) ? { fetchImpl: withGoogleMcp(oauthOptions?.fetchImpl) } : {}),
+      // SSE advertises its POST endpoint on the authenticated event stream.
+      // No other path on the origin is allowed to receive this server's token.
+      isTransportEndpoint: (input) => kind === 'sse' && transport?._endpoint?.href === new URL(input).href,
+    });
+  }
+  // Gmail with an app password is answered in-process too (its account
+  // header is the configured authentication; the password is in the keychain).
+  const local = !oauth && gmailAppPasswordService(url) ? { ...opts, fetch: withGmailAppPasswordMcp() } : opts;
+  transport = new Transport(new URL(url), oauth ? { fetch: oauth.fetch } : local);
+  if (oauth) {
+    transport.oauth = oauth;
+    const close = transport.close.bind(transport);
+    transport.close = async () => {
+      oauth.close();
+      await close();
+    };
+  }
+  log(`[mcp-client] Connecting "${name}" via ${kind.toUpperCase()}: ${mcpUrlForLog(url)}\n`);
+  return transport;
+}
+
+function webSocketTransport(name, cfg, sdk, log) {
+  const { WebSocketClientTransport } = sdk;
+  const url = normalizeMcpTransportUrl(expandEnvVars(String(cfg.url ?? '')), 'ws');
+  const opts = requestInitFor(cfg);
+  log(`[mcp-client] Connecting "${name}" via WebSocket: ${mcpUrlForLog(url)}\n`);
+  return opts
+    ? createHeaderWebSocketTransport(
+        WebSocketClientTransport,
+        sdk.JSONRPCMessageSchema,
+        new URL(url),
+        opts.requestInit.headers
+      )
+    : new WebSocketClientTransport(new URL(url));
+}
+
+// A stdio child, its stderr logged and its bounded (scrubbed) tail kept.
+function stdioTransport(name, cfg, StdioClientTransport, log) {
+  const transport = new StdioClientTransport({
+    command: expandEnvVars(String(cfg.command ?? '')),
+    args: Array.isArray(cfg.args) ? expandEnvVars(cfg.args) : cfg.args,
+    cwd: cfg.cwd == null ? cfg.cwd : expandEnvVars(String(cfg.cwd)),
+    env: resolveMcpStdioEnvironment(cfg),
+    stderr: cfg.stderr ?? 'pipe',
+  });
+  let tail = '';
+  transport.stderr?.on?.('data', (chunk) => {
+    const text = scrubMcpConnectionMessage(chunk, cfg);
+    tail = (tail + text).slice(-MCP_STDERR_TAIL_CHARS);
+    log(`[mcp:${name}:stderr] ${text}`);
+  });
+  return { transport, stderrTail: () => tail.trim() };
+}
+
 /** Returns { transport, autoDetectAdvert, stderrTail, warnings } — stderrTail()
  *  is the last ~4 KB of a stdio server's (scrubbed) stderr, '' for remote
  *  transports. `strictEnv` (the caller passes it for plugin-declared servers)
  *  makes unset variables without a default fail the server; otherwise they
  *  expand to empty and are reported in `warnings` (names only). */
 export function createMcpTransport({ name, cfg, sdk, log, strictEnv, oauthOptions }) {
-  const { StdioClientTransport, StreamableHTTPClientTransport, SSEClientTransport, WebSocketClientTransport } = sdk;
+  const { StdioClientTransport, StreamableHTTPClientTransport, SSEClientTransport } = sdk;
   const kind = resolveMcpTransportKind(cfg);
-  const warnings = [];
-  if (kind !== 'autoDetect') {
-    const missing = findMissingMcpEnvVars(cfg);
-    if (missing.length) {
-      const message = `missing environment variable(s): ${missing.join(', ')}`;
-      if (strictEnv === true) throw new Error(message);
-      warnings.push(message);
-      log(`[mcp-client] "${name}": ${message}\n`);
-    }
-  }
+  const warnings = kind !== 'autoDetect' ? missingEnvWarnings(name, cfg, strictEnv, log) : [];
   if (kind === 'autoDetect') {
     const { url, advert } = resolveAutoDetectUrl(name, cfg);
     log(`[mcp-client] Connecting "${name}" via autoDetect HTTP: ${url}\n`);
@@ -132,72 +285,23 @@ export function createMcpTransport({ name, cfg, sdk, log, strictEnv, oauthOption
   if (kind === 'http' || kind === 'sse') {
     const Transport = kind === 'http' ? StreamableHTTPClientTransport : SSEClientTransport;
     const url = resolveMcpOAuthUrl(cfg);
-    const opts = requestInitFor(cfg);
-    // Explicit authentication remains authoritative (including custom API-key
-    // headers). Never forward those credentials to OAuth discovery endpoints.
-    let transport;
-    const oauth = hasConfiguredMcpAuth(cfg)
-      ? null
-      : createMcpOAuth({
-          url,
-          serverName: mcpOAuthDisplayName(cfg, name),
-          oauthClient: mcpOAuthClientFor(cfg, url),
-          ...oauthOptions,
-          // A built-in Google connector is answered in-process.
-          ...(googleMcpService(url) ? { fetchImpl: withGoogleMcp(oauthOptions?.fetchImpl) } : {}),
-          // SSE advertises its POST endpoint on the authenticated event stream.
-          // No other path on the origin is allowed to receive this server's token.
-          isTransportEndpoint: (input) => kind === 'sse' && transport?._endpoint?.href === new URL(input).href,
-        });
-    // Gmail with an app password is answered in-process too (its account
-    // header is the configured authentication; the password is in the keychain).
-    const local = !oauth && gmailAppPasswordService(url) ? { ...opts, fetch: withGmailAppPasswordMcp() } : opts;
-    transport = new Transport(new URL(url), oauth ? { fetch: oauth.fetch } : local);
-    if (oauth) {
-      transport.oauth = oauth;
-      const close = transport.close.bind(transport);
-      transport.close = async () => {
-        oauth.close();
-        await close();
-      };
+    // A disabled account is neither connected nor routed to.
+    const accountServers = connectorLiveAccountServers(cfg);
+    if (!accountServers.length && connectorAccountsOf(cfg).length) {
+      throw new Error(`Every account of "${name}" is disabled`);
     }
-    log(`[mcp-client] Connecting "${name}" via ${kind.toUpperCase()}: ${mcpUrlForLog(url)}\n`);
-    return {
-      transport,
-      autoDetectAdvert: null,
-      stderrTail: noStderrTail,
-      warnings,
-    };
+    const transport = accountServers.length
+      ? connectorAccountsTransport({ name, cfg, Transport, url, accountServers, oauthOptions, log })
+      : remoteHttpTransport({ name, cfg, kind, Transport, url, oauthOptions, log });
+    return { transport, autoDetectAdvert: null, stderrTail: noStderrTail, warnings };
   }
   if (kind === 'ws') {
-    const url = normalizeMcpTransportUrl(expandEnvVars(String(cfg.url ?? '')), 'ws');
-    const opts = requestInitFor(cfg);
-    log(`[mcp-client] Connecting "${name}" via WebSocket: ${mcpUrlForLog(url)}\n`);
-    const transport = opts
-      ? createHeaderWebSocketTransport(
-          WebSocketClientTransport,
-          sdk.JSONRPCMessageSchema,
-          new URL(url),
-          opts.requestInit.headers
-        )
-      : new WebSocketClientTransport(new URL(url));
+    const transport = webSocketTransport(name, cfg, sdk, log);
     return { transport, autoDetectAdvert: null, stderrTail: noStderrTail, warnings };
   }
   if (kind === 'stdio') {
-    const transport = new StdioClientTransport({
-      command: expandEnvVars(String(cfg.command ?? '')),
-      args: Array.isArray(cfg.args) ? expandEnvVars(cfg.args) : cfg.args,
-      cwd: cfg.cwd == null ? cfg.cwd : expandEnvVars(String(cfg.cwd)),
-      env: resolveMcpStdioEnvironment(cfg),
-      stderr: cfg.stderr ?? 'pipe',
-    });
-    let tail = '';
-    transport.stderr?.on?.('data', (chunk) => {
-      const text = scrubMcpConnectionMessage(chunk, cfg);
-      tail = (tail + text).slice(-MCP_STDERR_TAIL_CHARS);
-      log(`[mcp:${name}:stderr] ${text}`);
-    });
-    return { transport, autoDetectAdvert: null, stderrTail: () => tail.trim(), warnings };
+    const { transport, stderrTail } = stdioTransport(name, cfg, StdioClientTransport, log);
+    return { transport, autoDetectAdvert: null, stderrTail, warnings };
   }
   throw new Error(
     `Invalid config for "${name}": need autoDetect, type (stdio/http/sse/ws), url (http), or command (stdio)`

package/src/runtime/agent/orchestrator/mcp/client.mjs

@@ -37,6 +37,8 @@ import { listAllMcpTools, MCP_CONNECT_CANCELLED, runBoundedHandshake } from './c
 import { rememberServerConnector } from './server-connectors.mjs';
 import { mcpOAuthClientFor, mcpOAuthDisplayName } from './oauth-client.mjs';
 import { googleMcpService, withGoogleMcp } from '../../../connectors/google-mcp.mjs';
+import { gmailAppPasswordService } from '../../../connectors/gmail-app-password.mjs';
+import { connectorLiveAccountServers } from '../../../shared/connector-catalog.mjs';
 import {
   clearMcpOAuth,
   commitMcpOAuthSwitch,
@@ -1117,6 +1119,23 @@ export function isMcpTool(name) {
 export function isRegisteredMcpTool(name, scopeId = DEFAULT_MCP_SCOPE_ID) {
   return Boolean(resolveMcpToolTarget(scopeId, name)?.definition);
 }
+/** True when the prefixed name is `read_email` of a server whose every
+ *  endpoint Mixdog answers in-process (the Gmail app-password connector,
+ *  alone or behind the multi-account server): its result is a mail as the
+ *  mailbox holds it, never another server's text (browser-bridge/mail-links.mjs). */
+export function isBuiltinMailRead(name, scopeId = DEFAULT_MCP_SCOPE_ID) {
+  const target = resolveMcpToolTarget(normalizeMcpScopeId(scopeId), name);
+  if (!target || (target.definition?.mcpToolName || MCP_TOOL_NAME_RE.exec(name)?.[2]) !== 'read_email') return false;
+  const accounts = connectorLiveAccountServers(target.server.cfg);
+  return (accounts.length ? accounts : [target.server.cfg]).every((cfg) => {
+    try {
+      const url = resolveMcpOAuthUrl(cfg);
+      return Boolean(gmailAppPasswordService(url) || googleMcpService(url));
+    } catch {
+      return false;
+    }
+  });
+}
 /**
  * Check whether the inputSchema for an MCP tool declares the given top-level
  * property. Used to decide if the orchestrator should auto-inject context