clay-server 5.2.0-beta.3 → 5.2.0-beta.5

package/lib/mcp-import-credentials.js

@@ -0,0 +1,31 @@
+function requiredNames(row) {
+  var names = (row.environmentNames || []).filter(function (name) { return !Object.prototype.hasOwnProperty.call(row.env || {}, name); });
+  (row.references || []).forEach(function (reference) {
+    var match = /^(?:\$\{?|\{env:)([A-Za-z_][A-Za-z0-9_]*)/.exec(reference);
+    var name = match ? match[1] : /^[A-Za-z_][A-Za-z0-9_]*$/.test(reference) ? reference : 'Unsupported reference';
+    names.push(name);
+  });
+  return Array.from(new Set(names));
+}
+function applyCredentials(row, values) {
+  var names = requiredNames(row);
+  if (names.indexOf('Unsupported reference') >= 0) throw new Error('This source requires a vendor-specific helper or file reference. Configure a direct Clay connection instead.');
+  names.forEach(function (name) {
+    if (!Object.prototype.hasOwnProperty.call(values, name) || typeof values[name] !== 'string' || !values[name] || values[name].length > 8192 || /[\r\n\0]/.test(values[name])) throw new Error('Enter each required credential value.');
+  });
+  function expand(value) {
+    if (typeof value === 'string') return value.replace(/\$\{([A-Za-z_][A-Za-z0-9_]*)(?::-[^}]*)?\}|\$([A-Za-z_][A-Za-z0-9_]*)|\{env:([^}]+)\}/g, function (all, first, second, third) {
+      var name = first || second || third; return Object.prototype.hasOwnProperty.call(values, name) ? values[name] : all;
+    });
+    if (Array.isArray(value)) return value.map(expand);
+    if (value && typeof value === 'object') { var next = {}; Object.keys(value).forEach(function (key) { next[key] = expand(value[key]); }); return next; }
+    return value;
+  }
+  var next = {};
+  ['command', 'args', 'env', 'headers', 'url'].forEach(function (field) { if (row[field] !== undefined) next[field] = expand(row[field]); });
+  next.headers = next.headers || {}; next.env = next.env || {};
+  Object.keys(row.envHeaders || {}).forEach(function (name) { next.headers[name] = (name === 'Authorization' && row.bearerTokenEnv === row.envHeaders[name] ? 'Bearer ' : '') + values[row.envHeaders[name]]; });
+  (row.environmentNames || []).forEach(function (name) { if (values[name] !== undefined) next.env[name] = values[name]; });
+  next.envHeaders = {}; next.references = []; return next;
+}
+module.exports = { requiredNames: requiredNames, applyCredentials: applyCredentials };

package/lib/mcp-local-transport.js

@@ -0,0 +1,13 @@
+var StdioClientTransport = require('@modelcontextprotocol/sdk/client/stdio.js').StdioClientTransport;
+var wrapSpawnAsUser = require('./os-users').wrapSpawnAsUser;
+var os = require('os');
+function localTransport(row, identity) {
+  if ((row.references || []).length || (row.environmentNames || []).some(function (name) { return !Object.prototype.hasOwnProperty.call(row.env || {}, name); })) throw new Error('Configure required environment values before connecting.');
+  var home = identity ? identity.home : os.homedir();
+  var env = Object.assign({ HOME: home, USER: identity ? identity.user : os.userInfo().username, LOGNAME: identity ? identity.user : os.userInfo().username, SHELL: identity ? identity.shell || '/bin/sh' : '/bin/sh', PATH: '/usr/local/bin:/usr/bin:/bin:/opt/homebrew/bin' }, row.env || {});
+  var wrapped = wrapSpawnAsUser(row.command, row.args, identity ? { uid: identity.uid, gid: identity.gid, env: env } : { env: env });
+  // The SDK cannot apply uid/gid itself; never fall back to spawning as the daemon.
+  if (wrapped.options.uid != null || wrapped.options.gid != null) throw new Error('Install util-linux setpriv to run MCP as the account OS user.');
+  return new StdioClientTransport({ command: wrapped.command, args: wrapped.args, env: env, cwd: row.cwd, stderr: 'ignore' });
+}
+module.exports = { localTransport: localTransport };

package/lib/mcp-oauth.js

@@ -2,21 +2,21 @@ var crypto = require('crypto');
 var http = require('http');
 var assertPublicUrl = require('./mcp-network').assertPublicUrl;
 
-function createOAuthProvider(record, persist, flow) {
+function createOAuthProvider(record, persist, flow, authorize) {
   record.auth = record.auth || {};
   var auth = record.auth;
-  function guard() { if (flow && flow.cancelled) throw new Error('Sign-in expired.'); }
+  function guard() { if (flow && flow.cancelled) throw new Error('Sign-in expired.'); if (authorize) authorize(); }
   function save() { persist(); }
   return {
     get redirectUrl() { return flow ? flow.redirectUrl : auth.redirectUrl; },
     get clientMetadata() { return { client_name: 'Clay', redirect_uris: [flow ? flow.redirectUrl : auth.redirectUrl],
       grant_types: ['authorization_code', 'refresh_token'], response_types: ['code'], token_endpoint_auth_method: 'none' }; },
     state: function () { return flow ? flow.state : crypto.randomBytes(32).toString('hex'); },
-    clientInformation: function () { return auth.client; },
+    clientInformation: function () { guard(); return auth.client; },
     saveClientInformation: function (value) { guard(); auth.client = value; save(); },
-    tokens: function () { return auth.tokens; },
+    tokens: function () { guard(); return auth.tokens; },
     saveTokens: function (value) { guard(); auth.tokens = value; save(); },
-    saveCodeVerifier: function (value) { if (flow) flow.verifier = value; },
+    saveCodeVerifier: function (value) { guard(); if (flow) flow.verifier = value; },
     codeVerifier: function () { if (!flow || !flow.verifier) throw new Error('Sign in again.'); return flow.verifier; },
     redirectToAuthorization: async function (url) {
       if (!flow) { var required = new Error('Sign in to connect this server.'); required.name = 'UnauthorizedError'; throw required; }
@@ -25,13 +25,15 @@ function createOAuthProvider(record, persist, flow) {
       if (url.searchParams.get('state') !== flow.state || url.searchParams.get('redirect_uri') !== flow.redirectUrl || !url.searchParams.get('code_challenge')) throw new Error('Invalid sign-in request.');
       flow.authorizationUrl = url.href;
     },
-    discoveryState: function () { return auth.discovery; },
+    discoveryState: function () { guard(); return auth.discovery; },
     saveDiscoveryState: function (value) {
+      guard();
       // Bind client credentials to the discovered issuer.
       if (auth.discovery && auth.discovery.authorizationServerUrl !== value.authorizationServerUrl) { delete auth.client; delete auth.tokens; }
       guard(); auth.discovery = value; save();
     },
     invalidateCredentials: function (which) {
+      guard();
       if (which === 'all' || which === 'client') delete auth.client;
       if (which === 'all' || which === 'tokens') delete auth.tokens;
       if (which === 'all' || which === 'discovery') delete auth.discovery;

package/lib/mcp-query-bridge.js

@@ -0,0 +1,30 @@
+var descriptors = require('./sdk-mcp-descriptors').extractMcpDescriptors;
+function createQueryBridge(ctx) {
+  function valid() {
+    if (!ctx.valid()) throw new Error('MCP tools require the current authorized query.');
+  }
+  function list() {
+    if (!ctx.valid()) return [];
+    var servers = descriptors(ctx.getServers()) || [], tools = [];
+    servers.forEach(function (server) {
+      server.tools.forEach(function (tool) { tools.push(Object.assign({ server: server.serverName }, tool)); });
+    });
+    return tools;
+  }
+  async function call(serverName, toolName, args) {
+    valid();
+    var server = ctx.getServers()[serverName], tool = server && server.instance && server.instance._registeredTools[toolName];
+    if (!tool || typeof (tool.handler || tool.callback) !== 'function') throw new Error('MCP tool is unavailable.');
+    var result = await (tool.handler || tool.callback)(args || {});
+    valid(); return result;
+  }
+  function dynamicDefs() {
+    return list().map(function (tool) {
+      return { name: 'mcp__' + tool.server + '__' + tool.name, permissionName: 'mcp__' + tool.server + '__' + tool.name,
+        description: tool.description, inputSchema: tool.inputSchema, queryBound: true,
+        handler: function (args) { return call(tool.server, tool.name, args); } };
+    });
+  }
+  return { list: list, call: call, dynamicDefs: dynamicDefs };
+}
+module.exports = { createQueryBridge: createQueryBridge };

package/lib/mcp-remote-connections.js

@@ -1,5 +1,7 @@
 var crypto = require('crypto');
 var Client = require('@modelcontextprotocol/sdk/client/index.js').Client;
+var SSEClientTransport = require('@modelcontextprotocol/sdk/client/sse.js').SSEClientTransport;
+var localTransport = require('./mcp-local-transport').localTransport;
 var StreamableHTTPClientTransport = require('@modelcontextprotocol/sdk/client/streamableHttp.js').StreamableHTTPClientTransport;
 var network = require('./mcp-network');
 var oauth = require('./mcp-oauth');
@@ -9,12 +11,33 @@ function createRemoteConnections(ctx) {
   var accounts = new Map(), live = new Map(), flows = new Map(), queues = new Map();
   var remoteFetch = ctx.remoteFetch || network.createRemoteFetch();
   var closed = false;
+  function sameRuntimeConfig(left, right) {
+    return left && right && left.url === right.url && left.enabled === right.enabled && left.authMode === right.authMode && left.token === right.token && JSON.stringify(left.auth || null) === JSON.stringify(right.auth || null) && JSON.stringify([left.transport, left.command, left.args, left.env, left.cwd, left.headers, left.envHeaders, left.references, left.disabledTools, left.enabledTools, left.toolPatterns, left.toolPrefix]) === JSON.stringify([right.transport, right.command, right.args, right.env, right.cwd, right.headers, right.envHeaders, right.references, right.disabledTools, right.enabledTools, right.toolPatterns, right.toolPrefix]);
+  }
+  function invalidate(owner, previous, current) {
+    var byId = new Map(current.filter(function (row) { return row.source !== 'computer'; }).map(function (row) { return [row.id, row]; }));
+    previous.filter(function (row) { return row.source !== 'computer'; }).forEach(function (row) {
+      var next = byId.get(row.id);
+      if (!next || !sameRuntimeConfig(row, next)) disconnect(owner, row.id);
+    });
+  }
   function records(owner) {
     ctx.authorize(owner);
-    if (!accounts.has(owner)) accounts.set(owner, ctx.storage.load(owner));
-    return accounts.get(owner);
+    var account = accounts.get(owner), snapshot = typeof ctx.storage.snapshot === 'function' ? ctx.storage.snapshot(owner) : { records: ctx.storage.load(owner), revision: typeof ctx.storage.revision === 'function' ? ctx.storage.revision(owner) : null };
+    var loaded = snapshot.records, revision = snapshot.revision;
+    if (!account) accounts.set(owner, account = { records: loaded, revision: revision });
+    else if (account.revision !== revision) { invalidate(owner, account.records, loaded); account.records = loaded; account.revision = revision; }
+    return account.records;
+  }
+  function persist(owner) {
+    ctx.authorize(owner); if (closed) throw new Error('MCP connections closed.');
+    var account = accounts.get(owner);
+    if (!account) throw new Error('MCP connection snapshot is unavailable.');
+    var revision;
+    try { revision = ctx.storage.save(owner, account.records, account.revision); }
+    catch (error) { accounts.delete(owner); invalidate(owner, account.records, []); throw error; }
+    if (account) account.revision = revision;
   }
-  function persist(owner) { ctx.authorize(owner); if (closed) throw new Error('MCP connections closed.'); ctx.storage.save(owner, records(owner)); }
   function find(owner, id) {
     var row = records(owner).find(function (item) { return item.id === id; });
     if (!row) throw new Error('Connection is unavailable.');
@@ -23,14 +46,15 @@ function createRemoteConnections(ctx) {
   function key(owner, id) { return JSON.stringify([owner, id]); }
   function check(owner, row) {
     if (closed || find(owner, row.id) !== row) throw new Error('Connection changed.');
+    if (row.source === 'local' && ctx.ownerIdentity) ctx.ownerIdentity(owner);
   }
   function changed(owner) { if (!closed) ctx.changed(owner); }
   function view(owner) {
-    return records(owner).filter(function (row) { return row.source === 'url'; }).map(function (row) {
+    return records(owner).filter(function (row) { return row.source !== 'computer'; }).map(function (row) {
       var entry = live.get(key(owner, row.id));
-      return { id: row.id, name: row.id, label: row.label, source: 'url', transport: 'http', url: row.url,
+      return { id: row.id, name: row.id, label: row.label, source: row.source, transport: row.transport || 'http', url: row.url ? new URL(row.url).origin + new URL(row.url).pathname : null, provenance: row.provenance, references: require('./mcp-import-credentials').requiredNames(row),
         projectEnabled: !!row.enabled, extensionEnabled: true, tools: row.tools || [], toolCount: (row.tools || []).length,
-        status: entry ? entry.status : (row.tools ? 'idle' : 'unavailable'), error: entry ? entry.error : '', authMode: row.authMode || 'auto' };
+        status: entry ? entry.status : (row.provenance || row.tools ? 'idle' : 'unavailable'), error: entry ? entry.error : '', authMode: row.authMode || 'auto' };
     });
   }
   async function disconnect(owner, id) {
@@ -39,7 +63,7 @@ function createRemoteConnections(ctx) {
     if (entry && entry.client) await entry.client.close().catch(function () {});
   }
   function provider(owner, row, flow) {
-    return oauth.createOAuthProvider(row, function () { check(owner, row); persist(owner); }, flow);
+    return oauth.createOAuthProvider(row, function () { check(owner, row); persist(owner); }, flow, function () { check(owner, row); });
   }
   async function connect(owner, row, flow) {
     check(owner, row);
@@ -47,17 +71,20 @@ function createRemoteConnections(ctx) {
     check(owner, row);
     if (flow && flow.cancelled) throw new Error('Sign-in expired.');
     var client = new Client({ name: 'clay', version: '1.0.0' }, { capabilities: {} });
-    var options = { fetch: remoteFetch.fetch };
-    if (row.authMode === 'token' && row.token) options.requestInit = { headers: { Authorization: 'Bearer ' + row.token } };
+    if (row.source !== 'local' && ((row.references || []).length || Object.keys(row.envHeaders || {}).length)) throw new Error('Configure required credentials in Clay before connecting.');
+    var options = { fetch: async function (input, init) { check(owner, row); var response = await remoteFetch.fetch(input, init); check(owner, row); return response; }, requestInit: { headers: row.headers || {} } };
+    if (row.authMode === 'token' && row.token) options.requestInit = { headers: Object.assign({}, row.headers || {}, { Authorization: 'Bearer ' + row.token }) };
     else if (flow || (row.auth && row.auth.tokens)) options.authProvider = provider(owner, row, flow);
-    var transport = new StreamableHTTPClientTransport(new URL(row.url), options);
+    var transport = row.source === 'local' ? localTransport(row, ctx.ownerIdentity ? ctx.ownerIdentity(owner) : null) : (row.transport === 'sse' ? new SSEClientTransport(new URL(row.url), options) : new StreamableHTTPClientTransport(new URL(row.url), options));
     var entry = { client: client, transport: transport, status: 'connecting', error: '' };
     live.set(key(owner, row.id), entry); changed(owner);
     try {
       await client.connect(transport, { timeout: 30000 });
+      check(owner, row);
       var tools = [], cursor, seen = new Set();
       do {
         var page = await client.listTools(cursor ? { cursor: cursor } : {}, { timeout: 30000 });
+        check(owner, row);
         tools = tools.concat(page.tools);
         if (tools.length > 1000 || seen.size >= 100 || (page.nextCursor && seen.has(page.nextCursor))) throw new Error('Tool catalog exceeds the supported limit.');
         cursor = page.nextCursor; seen.add(cursor);
@@ -65,13 +92,16 @@ function createRemoteConnections(ctx) {
       if (JSON.stringify(tools).length > 2 * 1024 * 1024) throw new Error('Tool catalog exceeds the supported limit.');
       check(owner, row);
       if (live.get(key(owner, row.id)) !== entry || (flow && flow.cancelled)) throw new Error('Connection changed.');
+      tools = tools.filter(function (tool) {
+        return require('./mcp-tool-policy').permits(row, tool.name);
+      });
       require('./mcp-proxy').validateDefinitions(tools);
       row.tools = tools; entry.status = 'ready'; persist(owner);
       return entry;
     } catch (error) {
       var requiresAuth = error.code === 401 || error.code === 403 || error.name === 'UnauthorizedError' || (flow && flow.authorizationUrl);
       entry.status = requiresAuth ? 'auth_required' : 'unavailable';
-      entry.error = requiresAuth ? 'Sign in or provide an access token to connect.' : 'Could not connect. Check the address and try again.';
+      entry.error = requiresAuth ? 'Sign in or provide an access token to connect.' : row.source === 'local' ? 'Could not start the command. Check its dependency and working directory.' : 'Could not connect. Check the address and try again.';
       if (!flow) await client.close().catch(function () {});
       return entry;
     } finally { changed(owner); }
@@ -101,6 +131,7 @@ function createRemoteConnections(ctx) {
       if (ready.status !== 'ready') throw new Error('Connection failed after sign-in.');
       setTimeout(function () { if (flows.get(key(owner, row.id)) === flow) { cancelLogin(owner, row.id); changed(owner); } }, 500);
     });
+    try { check(owner, row); } catch (error) { flow.close(); throw error; }
     flows.set(key(owner, row.id), flow);
     flow.timer = setTimeout(function () { cancelLogin(owner, row.id); }, 10 * 60 * 1000); flow.timer.unref();
     row.authMode = 'auto'; delete row.token;
@@ -123,40 +154,61 @@ function createRemoteConnections(ctx) {
     pending.finally(function () { if (queues.get(owner) === pending) queues.delete(owner); }).catch(function () {});
     return pending;
   }
+  function commitImport(owner, select, authorize) {
+    authorize();
+    var imported = select();
+    records(owner);
+    if (accounts.get(owner).revision !== imported.revision) throw new Error('Connections changed. Scan again.');
+    if (records(owner).some(function (item) { return item.importSignature === imported.signature || imported.config.url && item.url === imported.config.url; })) throw new Error('This server is already imported.');
+    authorize();
+    var row = Object.assign({}, imported.config, { id: 'remote-' + crypto.randomBytes(8).toString('hex'), importSignature: imported.signature, enabled: false });
+    records(owner).push(row); persist(owner);
+    return row;
+  }
+  function importConnection(owner, select, authorize) {
+    return serial(owner, function () { var row = commitImport(owner, select, authorize); changed(owner); return row.id; });
+  }
   function command(owner, msg, ws) {
     // Revocation takes effect before any queued network work completes.
     if (msg.action === 'remove' || (msg.action === 'enable' && msg.enabled !== true)) {
       try {
         var revoked = find(owner, msg.id);
-        if (revoked.source !== 'url') throw new Error('Not a remote connection.');
+        if (revoked.source === 'computer') throw new Error('Not a remote connection.');
         revoked.enabled = false; cancelLogin(owner, revoked.id); persist(owner);
         disconnect(owner, revoked.id); changed(owner);
       } catch (error) { return Promise.reject(error); }
     }
     return serial(owner, async function () {
       var row;
-      if (msg.action === 'add') {
+      if (msg.action === 'import') {
+        row = commitImport(owner, function () { return ctx.selectImport(owner, ws, msg); }, function () { if (!ctx.canAccess(ws, owner)) throw new Error('MCP account is unavailable.'); });
+      } else if (msg.action === 'add') {
         var url = network.remoteUrl(msg.url).href;
-        if (records(owner).filter(function (item) { return item.source === 'url'; }).length >= 30) throw new Error('You can add up to 30 remote connections per project.');
+        if (records(owner).filter(function (item) { return item.source !== 'computer'; }).length >= 30) throw new Error('You can add up to 30 remote connections per project.');
         if (records(owner).some(function (item) { return item.url === url; })) throw new Error('This server is already connected. Open it from your connections.');
         row = { id: 'remote-' + crypto.randomBytes(8).toString('hex'), source: 'url', url: url, label: new URL(url).hostname, enabled: false };
         records(owner).push(row); persist(owner);
         await connect(owner, row);
       } else {
         row = find(owner, msg.id);
-        if (row.source !== 'url') throw new Error('Not a remote connection.');
-        if (msg.action === 'enable') { row.enabled = msg.enabled === true; persist(owner); }
+        if (row.source === 'computer') throw new Error('Not a remote connection.');
+        if (msg.action === 'enable') { row.enabled = msg.enabled === true; persist(owner); if (row.enabled && row.provenance) { try { await connect(owner, row); } catch (error) { row.enabled = false; persist(owner); throw error; } } }
         else if (msg.action === 'rename') {
           if (typeof msg.label !== 'string' || !msg.label.trim() || msg.label.length > 100) throw new Error('Use a name between 1 and 100 characters.');
           row.label = msg.label.trim(); persist(owner);
         } else if (msg.action === 'remove') {
           cancelLogin(owner, row.id); await disconnect(owner, row.id);
-          accounts.set(owner, records(owner).filter(function (item) { return item !== row; })); persist(owner);
+          var account = accounts.get(owner);
+          accounts.set(owner, { records: records(owner).filter(function (item) { return item !== row; }), revision: account && account.revision }); persist(owner);
         } else if (msg.action === 'test') { cancelLogin(owner, row.id); await connect(owner, row); }
-        else if (msg.action === 'token') {
+        else if (msg.action === 'credentials') {
+          if (!msg.values || typeof msg.values !== 'object' || Array.isArray(msg.values)) throw new Error('Enter required credential values.');
+          var next = require('./mcp-import-credentials').applyCredentials(row, msg.values);
+          cancelLogin(owner, row.id); Object.assign(row, next); persist(owner); await disconnect(owner, row.id);
+        } else if (msg.action === 'token') {
           if (typeof msg.token !== 'string' || !msg.token.trim() || msg.token.length > 8192 || /[\r\n]/.test(msg.token)) throw new Error('Enter a valid access token.');
           cancelLogin(owner, row.id); row.token = msg.token.trim(); row.authMode = 'token'; delete row.auth; persist(owner); await connect(owner, row);
-        } else if (msg.action === 'signin') await signIn(owner, row, ws);
+        } else if (msg.action === 'signin') { if (row.source === 'local') throw new Error('This server uses process environment credentials.'); await signIn(owner, row, ws); }
         else throw new Error('Unsupported connection action.');
       }
       changed(owner);
@@ -174,6 +226,7 @@ function createRemoteConnections(ctx) {
     return serial(owner, async function () {
       authorize(); var row = find(owner, id);
       if (!row.enabled) throw new Error('Connection is disabled.');
+      if (!require('./mcp-tool-policy').permits(row, name)) throw new Error('Tool is excluded by the imported vendor policy.');
       var entry = live.get(key(owner, id));
       if (!entry || entry.status !== 'ready') entry = await connect(owner, row);
       authorize(); check(owner, row);
@@ -183,6 +236,7 @@ function createRemoteConnections(ctx) {
       var result;
       try { result = await entry.client.callTool({ name: name, arguments: args || {} }, undefined, { timeout: 60000 }); }
       catch (error) {
+        authorize(); check(owner, row);
         if (live.get(key(owner, id)) === entry) {
           entry.status = error.code === 401 || error.code === 403 || error.name === 'UnauthorizedError' ? 'auth_required' : 'unavailable';
           entry.error = entry.status === 'auth_required' ? 'Sign in again to reconnect.' : 'The tool call could not complete. Check the service before retrying.';
@@ -209,7 +263,7 @@ function createRemoteConnections(ctx) {
     closed = true; live.forEach(function (entry) { entry.client.close().catch(function () {}); }); live.clear();
     remoteFetch.close();
   }
-  return { view: view, command: command, call: call, handleBrowser: handleBrowser, destroy: destroy,
+  return { view: view, command: command, importConnection: importConnection, call: call, handleBrowser: handleBrowser, destroy: destroy,
     computerEnabled: computerEnabled, toggleComputer: toggleComputer };
 }
 module.exports = { createRemoteConnections: createRemoteConnections };

package/lib/mcp-source-adapters.js

@@ -0,0 +1,91 @@
+// File-only adapters. Discovery never loads vendor code, plugins, or OAuth stores.
+var path = require('path');
+var toml = require('@iarna/toml');
+var jsonc = require('jsonc-parser');
+var yaml = require('yaml');
+var network = require('./mcp-network');
+var crypto = require('crypto');
+var ADAPTERS = {
+  claude: { user: ['.claude.json'], project: ['.mcp.json'], key: 'mcpServers' },
+  codex: { user: ['.codex/config.toml'], project: ['.codex/config.toml'], key: 'mcp_servers' },
+  kiro: { user: ['.kiro/settings/mcp.json', '.kiro/mcp.json'], project: ['.kiro/settings/mcp.json', '.kiro/mcp.json'], key: 'mcpServers', agents: '.kiro/agents' },
+  opencode: { user: ['.config/opencode/opencode.json', '.config/opencode/opencode.jsonc'], project: ['opencode.json', 'opencode.jsonc'], key: 'mcp' },
+  kimi: { user: ['.kimi-code/mcp.json', '.kimi/mcp.json'], project: ['.kimi-code/mcp.json'], key: 'mcpServers' },
+  copilot: { user: ['.copilot/mcp-config.json'], project: ['.mcp.json', '.github/mcp.json'], key: 'mcpServers' },
+  qwen: { user: ['.qwen/settings.json'], project: ['.qwen/settings.json'], key: 'mcpServers' },
+  junie: { user: ['.junie/mcp/mcp.json'], project: ['.junie/mcp/mcp.json'], key: 'mcpServers' },
+  grok: { user: ['.grok/config.toml'], project: ['.grok/config.toml'], key: 'mcp_servers' },
+  antigravity: { user: ['.gemini/config/mcp_config.json', '.gemini/antigravity-cli/mcp_config.json'], project: ['.agents/mcp_config.json'], key: 'mcpServers', plugins: '.gemini/antigravity-cli/plugins' },
+  acp: { user: [], project: [], key: 'mcpServers' },
+};
+function parse(file, content) {
+  if (file.endsWith('.md')) {
+    var match = /^---\r?\n([\s\S]*?)\r?\n---(?:\r?\n|$)/.exec(content);
+    if (!match) throw new Error('Agent profile requires YAML frontmatter.');
+    var document = yaml.parseDocument(match[1]);
+    if (document.errors.length) throw new Error('Invalid agent frontmatter.');
+    return document.toJS({ maxAliasCount: 50 });
+  }
+  if (file.endsWith('.toml')) return toml.parse(content);
+  var errors = [], value = jsonc.parse(content, errors, { allowTrailingComma: true });
+  if (errors.length || !value || typeof value !== 'object' || Array.isArray(value)) throw new Error('Invalid MCP source format.');
+  return value;
+}
+function stringMap(value) {
+  if (!value) return {};
+  if (Array.isArray(value)) {
+    var map = {}; value.forEach(function (entry) { if (!entry || typeof entry.name !== 'string' || typeof entry.value !== 'string') throw new Error('Invalid name/value field.'); map[entry.name] = entry.value; });
+    return map;
+  }
+  if (typeof value !== 'object') throw new Error('Invalid environment or headers.');
+  Object.keys(value).forEach(function (name) { if (typeof value[name] !== 'string') throw new Error('Invalid environment or headers.'); });
+  return Object.assign({}, value);
+}
+function normalize(vendor, name, value, source) {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) throw new Error('Invalid server definition.');
+  ['enabled', 'disabled'].forEach(function (key) { if (value[key] !== undefined && typeof value[key] !== 'boolean') throw new Error('Invalid source enablement: ' + key); });
+  if (value.oauth !== undefined && value.oauth !== true) throw new Error('Vendor OAuth policy requires reviewed Clay-owned authentication setup.');
+  var command = value.command, args = value.args || [];
+  if (vendor === 'opencode' && Array.isArray(command)) { args = command.slice(1); command = command[0]; }
+  var url = value.url || value.httpUrl || value.serverUrl;
+  if (command && url) throw new Error('Conflicting stdio and remote transport definitions.');
+  var type = value.type || value.transport || (url ? vendor === 'qwen' && !value.httpUrl ? 'sse' : 'http' : 'stdio');
+  if (type === 'local') type = 'stdio'; if (type === 'remote' || type === 'streamable-http') type = 'http';
+  if (['stdio', 'http', 'sse'].indexOf(type) < 0) throw new Error('Unsupported transport. Clay supports stdio, HTTP and SSE.');
+  if (value.headersHelper || value.oauth && (value.oauth.clientSecret || value.oauth.clientId)) throw new Error('Vendor authentication helper requires Clay-owned credential setup.');
+  var policy = require('./mcp-tool-policy').normalize(vendor, value);
+  var config = { transport: type, enabled: false, label: name, source: type === 'stdio' ? 'local' : 'url',
+    provenance: source, sourceEnabled: value.enabled === false || value.disabled === true ? false : source.scope.indexOf('plugin') === 0 ? null : true };
+  if (type === 'stdio') {
+    if (typeof command !== 'string' || !command || command.includes('\0') || !Array.isArray(args) || args.some(function (arg) { return typeof arg !== 'string' || arg.includes('\0'); })) throw new Error('Invalid stdio command or arguments.');
+    config.command = command; config.args = args; config.env = stringMap(value.env || value.environment); config.cwd = value.cwd || source.cwd;
+    if (typeof config.cwd !== 'string' || !path.isAbsolute(config.cwd)) throw new Error('Stdio working directory must be absolute.');
+  } else {
+    // Do not expand credential references during inspection.
+    config.url = network.remoteUrl(url).href; config.headers = stringMap(value.headers || value.http_headers);
+    config.envHeaders = stringMap(value.env_http_headers);
+    var bearer = value.bearer_token_env_var || value.bearerTokenEnvVar;
+    if (bearer) { config.bearerTokenEnv = bearer; config.envHeaders.Authorization = bearer; }
+  }
+  config.environmentNames = (value.env_vars || []).concat(Object.keys(config.env || {}));
+  if (value.env_vars !== undefined && !Array.isArray(value.env_vars)) throw new Error('Invalid environment allowlist.');
+  Object.assign(config, policy);
+  if (source.sourceEnabled !== undefined) config.sourceEnabled = config.sourceEnabled === false || source.sourceEnabled === false ? false : source.sourceEnabled;
+  var references = JSON.stringify([config.command, config.args, config.env, config.headers, config.url]).match(/\$\{[A-Za-z_][A-Za-z0-9_]*(?::-[^}]*)?\}|\$[A-Z_][A-Z0-9_]*|\{env:[^}]+\}|\{file:[^}]+\}|\{\{[^}]+\}\}/g) || [];
+  config.references = Array.from(new Set(references.concat(Object.values(config.envHeaders || {})).concat(value.env_vars || [])));
+  // Plugins may reference their own installed directory without reading any credential file.
+  if (source.pluginRoot) {
+    function pluginValue(value) {
+      if (typeof value === 'string') return value.replace(/\$\{CLAUDE_PLUGIN_ROOT\}/g, function () { return source.pluginRoot; }).replace(/\$\{CLAUDE_PROJECT_DIR\}/g, function () { return source.cwd; });
+      if (Array.isArray(value)) return value.map(pluginValue);
+      if (value && typeof value === 'object') { var next = {}; Object.keys(value).forEach(function (key) { next[key] = pluginValue(value[key]); }); return next; }
+      return value;
+    }
+    config = pluginValue(config); config.references = config.references.filter(function (ref) { return ref !== source.pluginRoot && ref !== source.cwd; });
+  }
+  return config;
+}
+function signature(config) {
+  return crypto.createHash('sha256').update(JSON.stringify([config.transport, config.url, config.command, config.args, config.env, config.headers, config.envHeaders, config.cwd, config.disabledTools, config.enabledTools, config.toolPatterns, config.toolPrefix, config.references])).digest('hex');
+}
+module.exports = { adapters: ADAPTERS, parse: parse, normalize: normalize, signature: signature };

package/lib/mcp-source-context.js

@@ -0,0 +1,42 @@
+var path = require('path');
+var crypto = require('crypto');
+var adapters = require('./mcp-source-adapters').adapters;
+var KEYS = ['CODEX_HOME', 'CLAUDE_CONFIG_DIR', 'OPENCODE_CONFIG', 'OPENCODE_CONFIG_DIR', 'OPENCODE_CONFIG_CONTENT', 'XDG_CONFIG_HOME', 'KIMI_CODE_HOME', 'COPILOT_HOME', 'GROK_HOME', 'QWEN_HOME', 'QWEN_CODE_SYSTEM_SETTINGS_PATH', 'QWEN_CODE_SYSTEM_DEFAULTS_PATH'];
+function resolve(ctx, owner, ws, home, identity) {
+  // Only the production runtime resolver may supply mapped-user overrides.
+  var env = ctx.runtimeEnv ? ctx.runtimeEnv(owner, ws) : identity ? {} : ctx.home ? {} : process.env;
+  var selected = {};
+  KEYS.forEach(function (key) { if (env[key] !== undefined) selected[key] = env[key]; });
+  function qwenRoot(value) { if (!value) return path.join(home, '.qwen'); return path.resolve(ctx.cwd, value.replace(/^~(?=\/|$)/, home)); }
+  var roots = { copilot: path.resolve(home, env.COPILOT_HOME || '.copilot'), grok: path.resolve(home, env.GROK_HOME || '.grok'), qwen: qwenRoot(env.QWEN_HOME), codex: path.resolve(home, env.CODEX_HOME || '.codex'), claude: path.resolve(home, env.CLAUDE_CONFIG_DIR || '.claude'),
+    opencode: path.resolve(home, env.XDG_CONFIG_HOME || '.config', 'opencode'), kimi: path.resolve(home, env.KIMI_CODE_HOME || '.kimi-code') };
+  var sources = [];
+  function add(vendor, file, scope, extra) { sources.push(Object.assign({ vendor: vendor, file: file, scope: scope, cwd: ctx.cwd }, extra)); }
+  Object.keys(adapters).forEach(function (vendor) {
+    var files = adapters[vendor].user;
+    if (vendor === 'codex') files = [path.join(roots.codex, 'config.toml')];
+    if (vendor === 'claude') files = [env.CLAUDE_CONFIG_DIR ? path.join(roots.claude, '.claude.json') : path.join(home, '.claude.json')];
+    if (vendor === 'opencode') files = ['opencode.json', 'opencode.jsonc'].map(function (file) { return path.join(roots.opencode, file); });
+    if (vendor === 'copilot') files = [path.join(roots.copilot, 'mcp-config.json')];
+    if (vendor === 'grok') files = [path.join(roots.grok, 'config.toml')];
+    if (vendor === 'qwen') files = [path.join(roots.qwen, 'settings.json')];
+    if (vendor === 'kimi' && env.KIMI_CODE_HOME) files = [path.join(roots.kimi, 'mcp.json')];
+    files.forEach(function (file) { add(vendor, path.resolve(home, file), 'user'); });
+    adapters[vendor].project.forEach(function (file) { add(vendor, path.join(ctx.cwd, file), 'project'); });
+  });
+  ['opencode.json', 'opencode.jsonc'].forEach(function (file) { add('opencode', path.join(ctx.cwd, '.opencode', file), 'runtime', { configDirectory: true }); });
+  if (env.OPENCODE_CONFIG) add('opencode', path.resolve(ctx.cwd, env.OPENCODE_CONFIG), 'runtime');
+  if (env.OPENCODE_CONFIG_DIR) ['opencode.json', 'opencode.jsonc'].forEach(function (file) { add('opencode', path.resolve(ctx.cwd, env.OPENCODE_CONFIG_DIR, file), 'runtime', { configDirectory: true }); });
+  if (env.OPENCODE_CONFIG_CONTENT) add('opencode', 'runtime:OPENCODE_CONFIG_CONTENT', 'runtime-inline', { inline: env.OPENCODE_CONFIG_CONTENT });
+  return { roots: roots, policyPaths: { qwenSettings: env.QWEN_CODE_SYSTEM_SETTINGS_PATH && path.resolve(ctx.cwd, env.QWEN_CODE_SYSTEM_SETTINGS_PATH), qwenDefaults: env.QWEN_CODE_SYSTEM_DEFAULTS_PATH && path.resolve(ctx.cwd, env.QWEN_CODE_SYSTEM_DEFAULTS_PATH) }, sources: sources, fingerprint: crypto.createHash('sha256').update(JSON.stringify(selected)).digest('hex') };
+}
+function priority(source) {
+  if (source.scope === 'runtime-inline') return 80;
+  if (source.scope === 'configured') return 70;
+  if (source.scope === 'runtime') return source.configDirectory ? 65 : 30;
+  if (source.scope === 'local') return 60;
+  if (source.scope === 'project') return 50 + (source.vendor === 'copilot' && path.basename(source.file) === '.mcp.json' ? 1 : 0);
+  if (source.scope === 'project-ancestor') return 40 + source.file.split(path.sep).length * 0.01 + (path.basename(source.file) === '.mcp.json' ? 0.001 : 0);
+  return source.scope.indexOf('plugin') === 0 ? 10 : 20;
+}
+module.exports = { resolve: resolve, priority: priority };