clay-server 5.1.1-beta.1 → 5.2.0-beta.10

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-proxy.js

@@ -1,32 +1,2 @@
-// Preserve the server's JSON Schema across SDK and stdio projections.
-function validateDefinitions(definitions) {
-  var z = require('zod');
-  var names = new Set();
-  return definitions.map(function (definition) {
-    if (!definition || !/^[a-zA-Z0-9_.-]{1,128}$/.test(definition.name) || names.has(definition.name) || Object.prototype.hasOwnProperty.call(Object.prototype, definition.name)) throw new Error('Unsupported MCP tool catalog.');
-    names.add(definition.name);
-    var parsed = z.fromJSONSchema(definition.inputSchema || { type: 'object', properties: {} });
-    if (!parsed.shape) throw new Error('MCP tools must accept an object.');
-    return parsed;
-  });
-}
-function createProxy(name, definitions, invoke) {
-  var sdk = require('@anthropic-ai/claude-agent-sdk');
-  var schemas = validateDefinitions(definitions);
-  var tools = definitions.map(function (definition, index) {
-    return sdk.tool(definition.name, definition.description || definition.name, schemas[index].shape, function (args) { return invoke(definition.name, args); });
-  });
-  var server = sdk.createSdkMcpServer({ name: name, version: '1.0.0', tools: tools });
-  definitions.forEach(function (definition, index) {
-    var tool = server.instance._registeredTools[definition.name];
-    tool.inputSchema = schemas[index];
-    tool._clayInputSchema = definition.inputSchema || { type: 'object', properties: {} };
-  });
-  server.instance.server.setRequestHandler(require('@modelcontextprotocol/sdk/types.js').ListToolsRequestSchema, function () {
-    return { tools: definitions.map(function (definition) {
-      return { name: definition.name, description: definition.description, inputSchema: definition.inputSchema || { type: 'object', properties: {} } };
-    }) };
-  });
-  return server;
-}
-module.exports = { createProxy: createProxy, validateDefinitions: validateDefinitions };
+// Compatibility export for the YOKE SDK/stdio tool projection.
+module.exports = require("./yoke/mcp-proxy");

package/lib/mcp-query-bridge.js

@@ -0,0 +1,30 @@
+var descriptors = require('./yoke/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 @@
+module.exports = require("./yoke/mcp-source-adapters");

package/lib/mcp-source-context.js

@@ -0,0 +1 @@
+module.exports = require("./yoke/mcp-source-context");

package/lib/mcp-source-discovery.js

@@ -0,0 +1 @@
+module.exports = require("./yoke/mcp-source-discovery");

package/lib/mcp-source-plugins.js

@@ -0,0 +1 @@
+module.exports = require("./yoke/mcp-source-plugins");

package/lib/mcp-source-restrictions.js

@@ -0,0 +1 @@
+module.exports = require("./yoke/mcp-source-restrictions");

package/lib/mcp-tool-policy.js

@@ -0,0 +1,9 @@
+var normalize = require("./yoke/mcp-tool-policy-normalize").normalize;
+function matches(pattern, name) {
+  return new RegExp('^' + pattern.split('').map(function (letter) { return letter === '*' ? '.*' : letter === '?' ? '.' : letter.replace(/[\\^$+.[\]{}()|]/g, '\\$&'); }).join('') + '$').test(name);
+}
+function permits(row, name) {
+  if ((row.disabledTools || []).indexOf(name) >= 0 || row.enabledTools && row.enabledTools.indexOf(name) < 0) return false;
+  return !(row.toolPatterns || []).some(function (pattern) { return matches(pattern, row.toolPrefix ? row.toolPrefix + name : name); });
+}
+module.exports = { normalize: normalize, permits: permits, matches: matches };

package/lib/migrate-single-user.js

@@ -151,40 +151,20 @@ function migrateSingleUserToMulti() {
     backupFile(path.join(config.CONFIG_DIR, "users.json"), stamp);
     backupFile(path.join(config.CONFIG_DIR, "profile.json"), stamp);
 
-    // --- Flip to multi-user, then provision the sole admin ---
-    // Flip first so createUser's built-in mate seeding writes to the per-user
-    // mates path (CONFIG_DIR/mates/<userId>/), not the flat legacy path.
-    users.enableMultiUser();
-
+    // Persist the owner credential and account mode in the same atomic write.
     var displayName = (profile && profile.name) ? String(profile.name) : "Admin";
     var created = users.createUserWithoutPin({
       username: "admin",
       displayName: displayName,
       role: "admin",
       profile: profile || undefined,
-    });
+    }, { pinHash: cfg.pinHash || null });
     if (!created || !created.user) {
       console.error("[migrate] Failed to create admin user: " + (created && created.error));
-      // Roll the flag back so we don't leave a userless multi-user deploy.
-      try { users.disableMultiUser(); } catch (e) {}
       return { skipped: "create-failed" };
     }
     var userId = created.user.id;
 
-    // --- Carry over the PIN hash directly (preserve the existing credential;
-    // we have the hash, not the raw PIN, so we can't go through updateUserPin) ---
-    if (hasPin) {
-      try {
-        var data = users.loadUsers();
-        for (var i = 0; i < data.users.length; i++) {
-          if (data.users[i].id === userId) { data.users[i].pinHash = cfg.pinHash; break; }
-        }
-        users.saveUsers(data);
-      } catch (e) {
-        console.error("[migrate] PIN carry-over failed (user will have no PIN): " + (e.message || e));
-      }
-    }
-
     // --- Carry over settings ---
     try {
       if (cfg.chatLayout !== undefined && users.setChatLayout) users.setChatLayout(userId, cfg.chatLayout);
@@ -253,7 +233,7 @@ function ensureMultiUser() {
     // Try the legacy single-user migration first (handles PIN/settings/mates/
     // session carry-over for existing deploys).
     var mig = migrateSingleUserToMulti();
-    if (mig && mig.migrated) return mig;
+    if (mig && (mig.migrated || mig.skipped === "error" || mig.skipped === "create-failed")) return mig;
 
     // Fresh or empty deploy: provision a default admin so we're multi-user with
     // one user. No PIN -> the phase-1 solo auto-login skips the login wall.

package/lib/notes-checklist.js

@@ -0,0 +1,50 @@
+// Bounded source identities shared by checklist validation and reconciliation.
+function items(text) {
+  var lines = (text || '').split('\n').slice(1);
+  var occurrences = Object.create(null);
+  var out = [];
+  var fence = null;
+  for (var i = 0; i < lines.length; i++) {
+    var line = lines[i];
+    var match = line.match(/^\s*(\x60{3,}|~{3,})/);
+    if (match) { fence = fence === match[1].charAt(0) ? null : (fence || match[1].charAt(0)); continue; }
+    if (fence || !line.trim() || /^\s*#{1,6}\s/.test(line)) continue;
+    var occurrence = occurrences[line] || 0;
+    occurrences[line] = occurrence + 1;
+    var key = line + '\u0000' + occurrence;
+    if (i <= 1000 && key.length <= 2000 && encodeURIComponent(key).length <= 2000) out.push({ index: i, key: key });
+  }
+  return out;
+}
+
+function validState(value) {
+  if (!Array.isArray(value) && (!value || typeof value !== 'object')) return false;
+  var keys = Object.keys(value);
+  if (keys.length > 1000) return false;
+  for (var i = 0; i < keys.length; i++) {
+    if (keys[i].length > 2000 || typeof value[keys[i]] !== 'boolean') return false;
+  }
+  return true;
+}
+
+function normalizeState(value, text) {
+  var state = {};
+  items(text).forEach(function (item) {
+    var checked = value && value[Array.isArray(value) ? item.index : item.key];
+    if (typeof checked === 'boolean' && Object.keys(state).length < 1000) state[item.key] = checked;
+  });
+  return state;
+}
+
+function validateChange(note, changes) {
+  if (changes.checklistIndex === undefined) return null;
+  if (!Number.isInteger(changes.checklistIndex) || changes.checklistIndex < 0 || changes.checklistIndex > 1000) return null;
+  if (typeof changes.checklistChecked !== 'boolean' || typeof changes.checklistSource !== 'string' || typeof changes.checklistKey !== 'string') return null;
+  if (changes.checklistSource !== note.text || changes.checklistKey.length > 2000 || (changes.text !== undefined && changes.text !== note.text)) return null;
+  var item = items(note.text).find(function (item) { return item.index === changes.checklistIndex; });
+  var state = normalizeState(note.checklistState, note.text);
+  if (item && state[item.key] === undefined && Object.keys(state).length >= 1000) return null;
+  try { return item && item.key === decodeURIComponent(changes.checklistKey) ? item.key : null; } catch (error) { return null; }
+}
+
+module.exports = { validState: validState, normalizeState: normalizeState, validateChange: validateChange };

package/lib/notes.js

@@ -4,6 +4,7 @@ var crypto = require("crypto");
 var config = require("./config");
 var utils = require("./utils");
 var lifecycle = require("./notes-lifecycle");
+var checklist = require("./notes-checklist");
 
 function createNotesManager(opts) {
   var cwd = opts.cwd;
@@ -61,6 +62,8 @@ function createNotesManager(opts) {
       h: typeof data.h === "number" ? data.h : 180,
       color: data.color || "purple",
       opacity: typeof data.opacity === "number" ? data.opacity : 0.64,
+      checklistMode: data.checklistMode === true,
+      checklistState: checklist.validState(data.checklistState) ? checklist.normalizeState(data.checklistState, data.text || "") : [],
       minimized: false,
       // A new note is always an open attention item.
       state: lifecycle.STATE_OPEN,
@@ -84,13 +87,33 @@ function createNotesManager(opts) {
   function update(id, changes) {
     for (var i = 0; i < notes.length; i++) {
       if (notes[i].id === id) {
-        var allowed = ["text", "x", "y", "w", "h", "color", "minimized", "zIndex", "opacity"];
+        if (changes.checklistConvert === true) {
+          if (changes.checklistSource !== notes[i].text || changes.checklistVersion !== notes[i].updatedAt || notes[i].checklistMode === true) return null;
+          changes = Object.assign({}, changes, { text: "", checklistState: {}, checklistMode: true });
+        }
+        if (changes.checklistEdit === true && (notes[i].checklistMode !== true || changes.checklistSource !== notes[i].text || changes.checklistVersion !== notes[i].updatedAt || typeof changes.text !== "string")) return null;
+        if (changes.checklistMode !== undefined && typeof changes.checklistMode !== "boolean") return null;
+        if (changes.checklistState !== undefined && !checklist.validState(changes.checklistState)) return null;
+        var checklistKey = checklist.validateChange(notes[i], changes);
+        if (changes.checklistIndex !== undefined && !checklistKey) return null;
+        var previous = {};
+        var snapshotKeys = ["text", "x", "y", "w", "h", "color", "minimized", "zIndex", "opacity", "checklistMode", "checklistState", "hidden", "state", "closedAt", "closedBy", "updatedAt"];
+        for (var s = 0; s < snapshotKeys.length; s++) previous[snapshotKeys[s]] = notes[i][snapshotKeys[s]];
+        var allowed = ["text", "x", "y", "w", "h", "color", "minimized", "zIndex", "opacity", "checklistMode", "checklistState"];
         for (var j = 0; j < allowed.length; j++) {
           var key = allowed[j];
           if (changes[key] !== undefined) {
             notes[i][key] = changes[key];
           }
         }
+        if (checklistKey) {
+          var state = checklist.normalizeState(notes[i].checklistState, notes[i].text);
+          state[checklistKey] = changes.checklistChecked === true;
+          notes[i].checklistState = state;
+        }
+        if (changes.text !== undefined || changes.checklistState !== undefined || checklistKey) {
+          notes[i].checklistState = checklist.normalizeState(notes[i].checklistState, notes[i].text);
+        }
         // `hidden` is the legacy spelling of the lifecycle. Route it through the
         // transitions so state, hidden, and the close provenance can never
         // disagree, and so an old client cannot half-apply a close.
@@ -98,8 +121,11 @@ function createNotesManager(opts) {
           if (changes.hidden === true) lifecycle.applyClose(notes[i], changes.actor || null, Date.now());
           else lifecycle.applyReopen(notes[i]);
         }
-        notes[i].updatedAt = Date.now();
-        saveToDisk();
+        notes[i].updatedAt = Math.max(Date.now(), (previous.updatedAt || 0) + 1);
+        if (!saveToDisk()) {
+          for (var p = 0; p < snapshotKeys.length; p++) notes[i][snapshotKeys[p]] = previous[snapshotKeys[p]];
+          return null;
+        }
         return notes[i];
       }
     }
@@ -120,6 +146,25 @@ function createNotesManager(opts) {
     return null;
   }
 
+  // Human close includes the visible draft and an exact canonical snapshot.
+  // Recheck it here, then persist draft + lifecycle/removal in one transaction.
+  function closeHuman(id, changes, actor) {
+    for (var i = 0; i < notes.length; i++) {
+      var note = notes[i];
+      if (note.id !== id) continue;
+      if (note.text !== changes.expectedText || note.updatedAt !== changes.expectedVersion || typeof changes.draftText !== "string") return null;
+      if (!changes.draftText.trim()) {
+        notes.splice(i, 1);
+        if (saveToDisk()) return { removed: note };
+        notes.splice(i, 0, note);
+        return null;
+      }
+      var updated = update(id, { text: changes.draftText, hidden: true, actor: actor });
+      return updated ? { note: updated } : null;
+    }
+    return null;
+  }
+
   // Reopen a closed note. Idempotent.
   function reopen(id) {
     for (var i = 0; i < notes.length; i++) {
@@ -211,6 +256,7 @@ function createNotesManager(opts) {
     create: create,
     update: update,
     close: close,
+    closeHuman: closeHuman,
     reopen: reopen,
     remove: remove,
     removeClosed: removeClosed,

package/lib/os-user-diagnostics.js

@@ -17,12 +17,10 @@ function commandAvailable(command, execFile) {
 
 function credentialPaths(home) {
   if (!home) return [];
-  return [
-    home + "/.claude",
-    home + "/.codex",
+  return require("./yoke/maintenance").credentialPaths(home).concat([
     home + "/.config/gh",
     home + "/.config/gcloud",
-  ];
+  ]);
 }
 
 function accessStatus(checks) {