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

package/lib/mcp-source-discovery.js

@@ -0,0 +1,169 @@
+var fs = require('fs');
+var path = require('path');
+var os = require('os');
+var crypto = require('crypto');
+var adapters = require('./mcp-source-adapters');
+var sourceContext = require('./mcp-source-context');
+var restrictions = require('./mcp-source-restrictions');
+var fsAsUser = require('./os-users').fsAsUser;
+function createDiscovery(ctx) {
+  var scans = new Map(), publicScans = new Map();
+  function read(file, identity) {
+    if (identity) {
+      var stat = fsAsUser('stat', { file: file }, identity);
+      if (stat.size > 2 * 1024 * 1024 || stat.isDir) throw new Error('Source exceeds size limit.');
+      return fsAsUser('read', { file: file, readContent: true }, identity).content;
+    }
+    var info = fs.statSync(file);
+    if (!info.isFile() || info.size > 2 * 1024 * 1024) throw new Error('Source exceeds size limit.');
+    return fs.readFileSync(file, 'utf8');
+  }
+  function list(directory, identity) {
+    try { return identity ? fsAsUser('list', { dir: directory }, identity) : fs.readdirSync(directory, { withFileTypes: true }).map(function (entry) { return { name: entry.name, isDir: entry.isDirectory() }; }); }
+    catch (error) { return []; }
+  }
+  function scan(owner, ws, explicit) {
+    ctx.authorize(owner, ws);
+    var identity = ctx.identity(ws), home = identity ? identity.home : ctx.home || os.homedir();
+    var context = sourceContext.resolve(ctx, owner, ws, home, identity);
+    var rows = [], diagnostics = [], sources = context.sources, files = new Map(), directories = new Map();
+    function listing(directory) { var entries = list(directory, identity); directories.set(directory, JSON.stringify(entries.slice().sort(function (left, right) { return left.name.localeCompare(right.name); }))); return entries; }
+    function source(vendor, file, scope, pluginRoot, extra) { sources.push(Object.assign({ vendor: vendor, file: file, scope: scope, cwd: ctx.cwd, pluginRoot: pluginRoot }, extra)); }
+    Object.keys(adapters.adapters).forEach(function (vendor) {
+      var adapter = adapters.adapters[vendor];
+      if (adapter.agents) [home, ctx.cwd].forEach(function (base) {
+        var directory = path.join(base, adapter.agents);
+        listing(directory).slice(0, 100).forEach(function (entry) { if (!entry.isDir && /\.(json|md)$/.test(entry.name)) source(vendor, path.join(directory, entry.name), 'agent'); });
+      });
+      if (adapter.plugins) {
+        var directory = path.join(home, adapter.plugins);
+        listing(directory).slice(0, 100).forEach(function (entry) { if (entry.isDir) source(vendor, path.join(directory, entry.name, 'mcp_config.json'), 'plugin', path.join(directory, entry.name), { blocked: 'This plugin has no locally resolved activation registry. Review its active configuration before importing.' }); });
+      }
+    });
+    // Copilot reads nearer project definitions before ancestors up to the Git root.
+    var parents = [], repository = false;
+    var currentDirectory = ctx.cwd;
+    while (true) {
+      try { if (identity) fsAsUser('stat', { file: path.join(currentDirectory, '.git') }, identity); else fs.statSync(path.join(currentDirectory, '.git')); repository = true; break; } catch (error) {}
+      var parent = path.dirname(currentDirectory);
+      if (parent === currentDirectory) break;
+      parents.push(parent); currentDirectory = parent;
+    }
+    if (repository) parents.forEach(function (directory) {
+      source('copilot', path.join(directory, '.mcp.json'), 'project-ancestor');
+      source('copilot', path.join(directory, '.github/mcp.json'), 'project-ancestor');
+    });
+    diagnostics.push({ vendor: 'all', scope: 'plugins', message: 'Remote bundles are not downloaded. Unresolved installed plugin activation and local managed policies block import; credentials and vendor OAuth stores are never inspected.' });
+    if (explicit) {
+      if (!adapters.adapters[explicit.vendor] || typeof explicit.file !== 'string' || !path.isAbsolute(explicit.file)) throw new Error('Choose a supported format and an absolute source file path.');
+      source(explicit.vendor, explicit.file, 'configured');
+    }
+    function load(file) {
+      if (files.has(file)) { var cached = files.get(file); if (cached.error) throw cached.error; return cached.value; }
+      try {
+        var content = read(file, identity), value = adapters.parse(file, content);
+        files.set(file, { value: value, digest: crypto.createHash('sha256').update(content).digest('hex') }); return value;
+      } catch (error) { files.set(file, { error: error, digest: null }); throw error; }
+    }
+    require('./mcp-source-plugins').discover({ load: load, source: source, list: listing, roots: context.roots, cwd: ctx.cwd, diagnostics: diagnostics });
+    var blockedVendors = restrictions.inspect({ load: load, roots: context.roots, policyPaths: context.policyPaths, cwd: ctx.cwd, home: home, username: identity ? identity.username : process.env.USER });
+    var openCodeTools = {}, openCodeDefinitions = {};
+    function collect(source, definitions, root) {
+      if (!definitions || typeof definitions !== 'object') return;
+      var names = Array.isArray(definitions) ? definitions.map(function (definition) { return definition.name; }) : Object.keys(definitions);
+      names.slice(0, 100).forEach(function (name, index) {
+        if (typeof name !== 'string' || !name || name.length > 100) return;
+        try {
+          var definition = Array.isArray(definitions) ? definitions[index] : definitions[name];
+          if (source.vendor === 'opencode') {
+            definition = Object.assign({}, openCodeDefinitions[name] || {}, definition);
+            openCodeDefinitions[name] = definition;
+          }
+          if (source.overrides && source.overrides[name]) definition = Object.assign({}, definition, source.overrides[name]);
+          var provenance = Object.assign({}, source); delete provenance.inline; delete provenance.overrides;
+          var config = adapters.normalize(source.vendor, name, definition, provenance);
+          var blocked = source.blocked || blockedVendors[source.vendor];
+          if (root && Object.keys(root).some(function (key) { return restrictions.securityKey(key); })) blocked = 'This source contains runtime or agent restrictions Clay cannot resolve. Review its effective policy before importing.';
+          if (root && root.tools !== undefined && source.vendor !== 'opencode') blocked = 'This source contains runtime tool restrictions Clay cannot resolve. Review its effective policy before importing.';
+          var known = ['type', 'transport', 'command', 'args', 'env', 'environment', 'cwd', 'url', 'httpUrl', 'serverUrl', 'headers', 'http_headers', 'env_http_headers', 'bearer_token_env_var', 'bearerTokenEnvVar', 'includeTools', 'excludeTools', 'env_vars', 'enabled', 'disabled', 'autoApprove', 'disabledTools', 'disabled_tools', 'enabledTools', 'enabled_tools', 'timeout', 'startup_timeout_sec', 'tool_timeout_sec', 'oauth', 'oauthScopes', 'trust', 'name', 'description', 'tools', 'startupTimeoutMs'];
+          var unknown = Object.keys(definition).filter(function (key) { return known.indexOf(key) < 0; });
+          if (unknown.length) blocked = 'Unrecognized server fields require deliberate review in a direct Clay connection: ' + unknown.slice(0, 10).join(', ');
+          if (unknown.length) diagnostics.push({ vendor: source.vendor, scope: source.scope, name: name, message: 'Unrecognized fields are not imported: ' + unknown.slice(0, 10).join(', ') });
+          var hash = adapters.signature(config);
+          rows.push({ id: crypto.randomUUID(), name: name, config: config, signature: hash, blocked: blocked });
+        } catch (error) { diagnostics.push({ vendor: source.vendor, scope: source.scope, name: name, message: error.message }); }
+      });
+    }
+    if (sources.length > 500) diagnostics.push({ vendor: 'all', scope: 'discovery', message: 'Source limit reached; inspect additional files individually.' });
+    sources.sort(function (left, right) { return sourceContext.priority(left) - sourceContext.priority(right); });
+    sources.slice(0, 500).forEach(function (source) {
+      try {
+        var value = source.inline ? adapters.parse('inline.json', source.inline) : load(source.file), adapter = adapters.adapters[source.vendor];
+        if (Object.keys(value).some(function (key) { return restrictions.securityKey(key); })) blockedVendors[source.vendor] = 'A configuration layer contains unresolved security restrictions. Review the effective vendor policy before importing.';
+        if (source.vendor === 'opencode' && value.agent && Object.keys(value.agent).some(function (name) { return Object.keys(value.agent[name] || {}).some(function (key) { return restrictions.securityKey(key) || key === 'tools'; }); })) blockedVendors.opencode = 'OpenCode agent-specific restrictions require review. Configure a direct Clay connection with the intended restrictions.';
+        collect(source, source.scope === 'plugin-inline' ? value.mcpServers : value[adapter.key] || (source.vendor === 'codex' && !source.file.endsWith('.toml') ? value.mcpServers || value : source.vendor === 'copilot' || source.scope === 'plugin' ? value : null), value);
+        if (source.vendor === 'opencode' && value.tools !== undefined) {
+          if (!value.tools || typeof value.tools !== 'object' || Array.isArray(value.tools) || Object.values(value.tools).some(function (enabled) { return typeof enabled !== 'boolean'; })) blockedVendors.opencode = 'Invalid OpenCode tool policy. Review the runtime configuration before importing.';
+          else Object.assign(openCodeTools, value.tools);
+        }
+        if (source.vendor === 'claude' && source.scope === 'user' && value.projects && value.projects[ctx.cwd]) collect(Object.assign({}, source, { scope: 'local' }), value.projects[ctx.cwd].mcpServers, value.projects[ctx.cwd]);
+      } catch (error) {
+        if (error.code !== 'ENOENT' && !(identity && /ENOENT|no such file/i.test(error.message))) diagnostics.push({ vendor: source.vendor, scope: source.scope, message: 'Could not read or parse source; check permissions and format.' });
+      }
+    });
+    rows.forEach(function (row) {
+      var source = row.config.provenance;
+      row.blocked = row.blocked || blockedVendors[source.vendor];
+      if (source.vendor === 'opencode') {
+        row.config.toolPrefix = row.name + '_';
+        row.config.toolPatterns = Object.keys(openCodeTools).filter(function (pattern) { return openCodeTools[pattern] === false; });
+        row.signature = adapters.signature(row.config);
+      }
+      var effective = rows.filter(function (other) { return other.name === row.name && other.config.provenance.vendor === source.vendor && other.config.provenance.scope !== 'agent' && other.config.provenance.scope.indexOf('plugin') !== 0; }).pop();
+      if (source.scope !== 'agent' && source.scope.indexOf('plugin') !== 0 && effective && effective !== row) row.blocked = 'Shadowed by the effective ' + effective.config.provenance.scope + ' source. Import that definition instead.';
+    });
+    var current = ctx.snapshot(owner);
+    rows.forEach(function (row) {
+      var same = rows.filter(function (other) { return other !== row && (other.name === row.name || row.config.url && other.config.url === row.config.url); });
+      row.duplicate = rows.some(function (other) { return other !== row && other.signature === row.signature; });
+      row.conflict = same.some(function (other) { return other.signature !== row.signature; });
+      row.imported = current.records.some(function (saved) { return saved.importSignature === row.signature || row.config.url && saved.url === row.config.url; });
+    });
+    var scanId = crypto.randomUUID();
+    scans.set(owner, { id: scanId, ws: ws, rows: rows, files: files, directories: directories, identity: identity, revision: current.revision, context: context.fingerprint, home: home, created: Date.now() });
+    var publicScan = { scanId: scanId, candidates: rows.map(function (row) {
+      return { id: row.id, name: row.name, vendor: row.config.provenance.vendor, scope: row.config.provenance.scope, file: row.config.provenance.file,
+        blocked: row.blocked || null, pluginName: row.config.provenance.pluginName, pluginVersion: row.config.provenance.pluginVersion, transport: row.config.transport, dependency: row.config.command ? (/^[a-zA-Z0-9_./\\-]+$/.test(row.config.command) ? path.basename(row.config.command) : 'Configured executable') : new URL(row.config.url).hostname,
+        references: require('./mcp-import-credentials').requiredNames(row.config), environmentNames: row.config.environmentNames, sourceEnabled: row.config.sourceEnabled,
+        duplicate: row.duplicate, conflict: row.conflict, imported: row.imported };
+    }), diagnostics: diagnostics };
+    publicScans.set(owner, publicScan); return publicScan;
+  }
+  function selected(owner, ws, msg) {
+    ctx.authorize(owner, ws);
+    var scan = scans.get(owner);
+    if (!scan || scan.ws !== ws || scan.id !== msg.scanId || Date.now() - scan.created > 10 * 60 * 1000) throw new Error('Discovery expired. Scan again.');
+    if (JSON.stringify(ctx.identity(ws)) !== JSON.stringify(scan.identity)) throw new Error('OS identity changed. Scan again.');
+    if (sourceContext.resolve(ctx, owner, ws, scan.home, scan.identity).fingerprint !== scan.context) throw new Error('Runtime configuration changed. Scan again.');
+    scan.directories.forEach(function (state, directory) {
+      var entries = list(directory, scan.identity).slice().sort(function (left, right) { return left.name.localeCompare(right.name); });
+      if (JSON.stringify(entries) !== state) throw new Error('Installed source selection changed. Scan again.');
+    });
+    scan.files.forEach(function (state, file) {
+      var hash = null;
+      try { hash = crypto.createHash('sha256').update(read(file, scan.identity)).digest('hex'); } catch (error) {
+        if (!state.error || (error.code || error.message) !== (state.error.code || state.error.message)) throw new Error('Vendor configuration changed. Scan again.');
+      }
+      if (hash !== state.digest) throw new Error('Vendor configuration changed. Scan again.');
+    });
+    var row = scan.rows.find(function (candidate) { return candidate.id === msg.candidateId; });
+    if (row && row.blocked) throw new Error(row.blocked);
+    if (!row || row.imported) throw new Error('Source is unavailable or already imported.');
+    return { config: JSON.parse(JSON.stringify(row.config)), signature: row.signature, revision: scan.revision };
+  }
+  return { scan: scan, selected: selected, candidate: function (owner, subject, args) {
+    selected(owner, subject, args);
+    return publicScans.get(owner).candidates.find(function (row) { return row.id === args.candidateId; });
+  }, destroy: function () { scans.clear(); publicScans.clear(); } };
+}
+module.exports = { createDiscovery: createDiscovery };

package/lib/mcp-source-plugins.js

@@ -0,0 +1,68 @@
+var path = require('path');
+function discover(ctx) {
+  var load = ctx.load, source = ctx.source, list = ctx.list, roots = ctx.roots;
+  function optional(file) { try { return load(file); } catch (error) { return {}; } }
+  var enabled = {};
+  var settingsFiles = [path.join(roots.claude, 'settings.json'), path.join(ctx.cwd, '.claude/settings.json'), path.join(ctx.cwd, '.claude/settings.local.json')];
+  settingsFiles.forEach(function (file) { Object.assign(enabled, optional(file).enabledPlugins || {}); });
+  var installed = optional(path.join(roots.claude, 'plugins/installed_plugins.json'));
+  Object.keys(installed.plugins || {}).slice(0, 100).forEach(function (name) {
+    var entries = (installed.plugins[name] || []).filter(function (entry) { return entry.installPath && (!entry.projectPath || path.resolve(entry.projectPath) === path.resolve(ctx.cwd)); });
+    var scoped = entries.filter(function (entry) { return entry.scope === 'local' || entry.scope === 'project'; });
+    if (scoped.length) entries = scoped;
+    var local = entries.filter(function (entry) { return entry.scope === 'local'; }); if (local.length) entries = local;
+    // The registry is authoritative only when it selects one installation.
+    entries.forEach(function (entry) {
+      var extra = { pluginName: name, pluginVersion: entry.version || null, sourceEnabled: enabled[name] === true ? true : enabled[name] === false ? false : null,
+        blocked: entries.length > 1 ? 'Claude registry selects multiple installations. Resolve the active plugin installation before importing.' : typeof enabled[name] !== 'boolean' ? 'Claude plugin enablement is unknown. Enable or disable it explicitly in vendor settings and scan again.' : null };
+      var root = entry.installPath;
+      source('claude', path.join(root, '.mcp.json'), 'plugin', root, extra);
+      var manifest = optional(path.join(root, '.claude-plugin/plugin.json'));
+      var definitions = Array.isArray(manifest.mcpServers) ? manifest.mcpServers : [manifest.mcpServers];
+      definitions.forEach(function (definition) {
+        if (typeof definition === 'string' && definition.endsWith('.json') && !definition.includes('://')) source('claude', path.resolve(root, definition), 'plugin', root, extra);
+        else if (definition && typeof definition === 'object') source('claude', path.join(root, '.claude-plugin/plugin.json'), 'plugin-inline', root, extra);
+        else if (definition) ctx.diagnostics.push({ vendor: 'claude', scope: 'plugin', message: 'Remote plugin bundles are not downloaded. Install and resolve the local plugin before scanning.' });
+      });
+    });
+  });
+  var codex = {};
+  [path.join(roots.codex, 'config.toml'), path.join(ctx.cwd, '.codex/config.toml')].forEach(function (file) {
+    var plugins = optional(file).plugins || {};
+    Object.keys(plugins).forEach(function (name) {
+      var previous = codex[name] || {}, next = plugins[name] || {};
+      codex[name] = Object.assign({}, previous, next, { mcp_servers: Object.assign({}, previous.mcp_servers || {}, next.mcp_servers || {}) });
+    });
+  });
+  var cache = path.join(roots.codex, 'plugins/cache');
+  list(cache).slice(0, 50).forEach(function (market) {
+    if (!market.isDir) return;
+    list(path.join(cache, market.name)).slice(0, 50).forEach(function (plugin) {
+      if (!plugin.isDir) return;
+      var name = plugin.name + '@' + market.name, configured = codex[name] || {};
+      var versions = list(path.join(cache, market.name, plugin.name)).filter(function (entry) { return entry.isDir; });
+      // Codex core-plugin-common/installed.rs selects local first, otherwise the greatest installed version.
+      versions = versions.filter(function (entry) { return /^[A-Za-z0-9._+-]+$/.test(entry.name); }).sort(function (left, right) {
+        var semver = require('semver');
+        return semver.valid(left.name) && semver.valid(right.name) ? semver.compareBuild(left.name, right.name) : left.name < right.name ? -1 : left.name > right.name ? 1 : 0;
+      });
+      var active = versions.find(function (entry) { return entry.name === 'local'; }) || versions[versions.length - 1];
+      versions = active ? [active] : [];
+      versions.slice(0, 50).forEach(function (version) {
+        var root = path.join(cache, market.name, plugin.name, version.name);
+        var extra = { pluginName: name, pluginVersion: version.name, overrides: configured.mcp_servers,
+          sourceEnabled: Object.prototype.hasOwnProperty.call(codex, name) ? configured.enabled !== false : false,
+          blocked: configured.enabled !== undefined && typeof configured.enabled !== 'boolean' ? 'Invalid Codex plugin enabled state. Review its vendor configuration before importing.' : null };
+        var portable = optional(path.join(root, 'plugin.json'));
+        var manifest = portable.extensions && portable.extensions['com.openai'] || optional(path.join(root, '.codex-plugin/plugin.json'));
+        if (portable.name) source('codex', path.join(root, 'mcp.json'), 'plugin', root, extra);
+        else {
+          source('codex', path.join(root, '.mcp.json'), 'plugin', root, extra);
+          source('codex', path.join(root, 'mcp.json'), 'plugin', root, extra);
+        }
+        if (typeof manifest.mcpServers === 'string' && !manifest.mcpServers.includes('://')) source('codex', path.resolve(root, manifest.mcpServers), 'plugin', root, extra);
+      });
+    });
+  });
+}
+module.exports = { discover: discover };

package/lib/mcp-source-restrictions.js

@@ -0,0 +1,47 @@
+var path = require('path');
+var SECURITY = /permission|policy|security|sandbox|registry|disabledMcp|restrict|approval|allowed|denied|managedMcp|strictPlugin|includeTools|excludeTools/i;
+function inspect(ctx) {
+  var blocked = {}, files = [];
+  function add(vendor, file, exclusive) { files.push({ vendor: vendor, file: file, exclusive: exclusive }); }
+  var claudeManaged = process.platform === 'darwin' ? '/Library/Application Support/ClaudeCode' : process.platform === 'win32' ? path.join(process.env.ProgramFiles || 'C:\\Program Files', 'ClaudeCode') : '/etc/claude-code';
+  ['managed-mcp.json', 'managed-settings.json'].forEach(function (file) { add('claude', path.join(claudeManaged, file), true); });
+  add('claude', path.join(claudeManaged, 'managed-settings.d'), true);
+  if (process.platform === 'darwin') {
+    add('claude', '/Library/Managed Preferences/com.anthropic.claudecode.plist', true);
+    if (ctx.username) add('claude', path.join('/Library/Managed Preferences', ctx.username, 'com.anthropic.claudecode.plist'), true);
+  }
+  [path.join(ctx.roots.claude, 'settings.json'), path.join(ctx.cwd, '.claude/settings.json'), path.join(ctx.cwd, '.claude/settings.local.json')].forEach(function (file) { add('claude', file); });
+  [path.join(ctx.roots.codex, 'requirements.toml'), '/etc/codex/requirements.toml', '/etc/codex/managed_config.toml', path.join(ctx.roots.codex, 'managed_config.toml')].forEach(function (file) { add('codex', file, true); });
+  var openCodeManaged = process.platform === 'darwin' ? '/Library/Application Support/opencode' : process.platform === 'win32' ? path.join(process.env.ProgramData || 'C:\\ProgramData', 'opencode') : '/etc/opencode';
+  ['opencode.json', 'opencode.jsonc'].forEach(function (file) { add('opencode', path.join(openCodeManaged, file), true); });
+  if (process.platform === 'darwin') {
+    add('opencode', '/Library/Managed Preferences/ai.opencode.managed.plist', true);
+    if (ctx.username) add('opencode', path.join('/Library/Managed Preferences', ctx.username, 'ai.opencode.managed.plist'), true);
+  }
+  ['settings.json', 'permissions-config.json'].forEach(function (file) { add('copilot', path.join(ctx.roots.copilot, file)); });
+  ['settings.json', 'settings.local.json'].forEach(function (file) { add('copilot', path.join(ctx.cwd, '.github/copilot', file)); });
+  var copilotManaged = process.platform === 'darwin' ? '/Library/Application Support/GitHubCopilot/managed-settings.json' : process.platform === 'win32' ? path.join(process.env.ProgramFiles || 'C:\\Program Files', 'GitHubCopilot/managed-settings.json') : '/etc/github-copilot/managed-settings.json';
+  add('copilot', copilotManaged, true);
+  if (process.platform === 'darwin') {
+    add('copilot', '/Library/Managed Preferences/com.github.copilot.plist', true);
+    if (ctx.username) add('copilot', path.join('/Library/Managed Preferences', ctx.username, 'com.github.copilot.plist'), true);
+  }
+  add('kimi', path.join(ctx.roots.kimi, 'config.toml'));
+  var qwenSystem = process.platform === 'darwin' ? '/Library/Application Support/QwenCode' : process.platform === 'win32' ? 'C:\\ProgramData\\qwen-code' : '/etc/qwen-code';
+  add('qwen', ctx.policyPaths.qwenSettings || path.join(qwenSystem, 'settings.json'), true);
+  add('qwen', ctx.policyPaths.qwenDefaults || path.join(qwenSystem, 'system-defaults.json'), true);
+  add('grok', '/etc/grok/requirements.toml', true);
+  add('grok', '/etc/grok/managed_config.toml', true);
+  add('grok', path.join(ctx.roots.grok, 'requirements.toml'), true);
+  add('grok', path.join(ctx.roots.grok, 'managed_config.toml'), true);
+  files.forEach(function (entry) {
+    try {
+      var value = ctx.load(entry.file);
+      if (entry.exclusive || path.basename(entry.file) === 'permissions-config.json' && Object.keys(value).length || Object.keys(value).some(function (key) { return SECURITY.test(key); })) blocked[entry.vendor] = 'Local vendor security or managed policy is present. Clay cannot resolve its effective restrictions. Review that policy and configure an explicitly authorized Clay connection; vendor import is blocked.';
+    } catch (error) {
+      if (error.code !== 'ENOENT' && !/ENOENT|no such file/i.test(error.message)) blocked[entry.vendor] = 'Could not resolve a local vendor policy source. Check permissions and format before importing.';
+    }
+  });
+  return blocked;
+}
+module.exports = { inspect: inspect, securityKey: function (key) { return SECURITY.test(key); } };

package/lib/mcp-tool-policy.js

@@ -0,0 +1,34 @@
+// Restrictive policies are intersected; an empty allowlist means no tools.
+var ALLOW = ['enabled_tools', 'enabledTools', 'includeTools'];
+var DENY = ['disabled_tools', 'disabledTools', 'excludeTools'];
+function list(value, key) {
+  if (!Array.isArray(value) || value.some(function (item) { return typeof item !== 'string' || !item || item.indexOf('\0') >= 0; })) throw new Error('Invalid tool policy: ' + key + '. Review the vendor configuration before importing.');
+  return Array.from(new Set(value));
+}
+function normalize(vendor, value) {
+  var allow = null, deny = [], keys = ALLOW.slice();
+  if (vendor === 'copilot') keys.push('tools');
+  keys.forEach(function (key) {
+    if (!Object.prototype.hasOwnProperty.call(value, key)) return;
+    var next = list(value[key], key);
+    if (vendor === 'copilot' && key === 'tools' && next.indexOf('*') >= 0) next = null;
+    if (next !== null) allow = allow === null ? next : allow.filter(function (name) { return next.indexOf(name) >= 0; });
+  });
+  DENY.forEach(function (key) { if (Object.prototype.hasOwnProperty.call(value, key)) deny = deny.concat(list(value[key], key)); });
+  var unsupported = Object.keys(value).filter(function (key) {
+    if (ALLOW.concat(DENY, vendor === 'copilot' ? ['tools'] : [], ['autoApprove', 'trust', 'oauth', 'oauthScopes']).indexOf(key) >= 0) return false;
+    return /tool|permission|policy|security|authProvider|allowed|denied|restrict|approval/i.test(key) && ['tool_timeout_sec'].indexOf(key) < 0;
+  });
+  if (unsupported.length) throw new Error('Unsupported restriction or security configuration: ' + unsupported.join(', ') + '. Configure and review a direct Clay connection instead.');
+  if (value.autoApprove !== undefined && (!Array.isArray(value.autoApprove) || value.autoApprove.some(function (item) { return typeof item !== 'string'; }))) throw new Error('Invalid autoApprove policy.');
+  if (value.trust !== undefined && typeof value.trust !== 'boolean') throw new Error('Invalid trust policy.');
+  return { enabledTools: allow, disabledTools: Array.from(new Set(deny)) };
+}
+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/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-users.js

@@ -153,6 +153,19 @@ function fsAsUser(op, args, osUserInfo) {
     });
     var binOutput = execFileSync(binSpawn.command, binSpawn.args, binSpawn.options);
     return { buffer: Buffer.from(binOutput.trim(), "base64") };
+  } else if (op === 'write_exact') {
+    script = [
+      "var fs = require('fs'), crypto = require('crypto'), path = require('path');",
+      "var f = " + JSON.stringify(args.file) + "; var expected = " + JSON.stringify(args.expected) + ";",
+      "var root = " + JSON.stringify(args.root) + "; var relative = path.relative(root, f);",
+      "function checkPath() { if (fs.realpathSync(root) !== root || path.isAbsolute(relative) || relative.split(path.sep).indexOf('..') >= 0) throw new Error('The canonical file boundary changed.'); var at = root; relative.split(path.sep).forEach(function (part) { at = path.join(at, part); if (fs.lstatSync(at).isSymbolicLink()) throw new Error('File parent symlinks are unavailable.'); }); }",
+      "checkPath();",
+      "var fd = fs.openSync(f, fs.constants.O_RDWR | fs.constants.O_NOFOLLOW);",
+      "try { var s = fs.fstatSync(fd);",
+      "if (!s.isFile() || s.nlink !== 1 || s.dev !== expected.dev || s.ino !== expected.ino || s.mode !== expected.mode || s.uid !== expected.uid || s.gid !== expected.gid || s.size !== expected.size || s.mtimeMs !== expected.mtime || crypto.createHash('sha256').update(fs.readFileSync(fd, 'utf8')).digest('hex') !== expected.hash) throw new Error('The exact file revision changed.');",
+      "checkPath(); fs.ftruncateSync(fd, 0); var bytes = Buffer.from(" + JSON.stringify(args.content) + ", 'utf8'), offset = 0; while (offset < bytes.length) { var written = fs.writeSync(fd, bytes, offset, bytes.length - offset, offset); if (!written) throw new Error('File write made no progress.'); offset += written; } fs.fsyncSync(fd); } finally { fs.closeSync(fd); }",
+      "process.stdout.write(JSON.stringify({ ok: true }));",
+    ].join(' ');
   } else if (op === "write") {
     script = [
       "var fs = require('fs');",
@@ -267,18 +280,18 @@ function isHomeDirectory(dirPath) {
  * Uses setfacl to add recursive + default ACL entries.
  * Skips home directories to avoid slow recursive ACL on large trees.
  */
-function grantProjectAccess(projectPath, linuxUser) {
+function grantProjectAccess(projectPath, linuxUser, options) {
   if (isHomeDirectory(projectPath)) {
     console.log("[os-users] Skipping ACL for home directory: " + projectPath);
-    return;
+    return true;
   }
   if (!isSafeLinuxUsername(linuxUser)) {
     console.error("[os-users] Invalid Linux username for ACL grant: " + linuxUser);
-    return;
+    return false;
   }
   var cacheKey = aclCacheKey(projectPath, linuxUser);
-  if (_aclGrantCache[cacheKey]) {
-    return;
+  if (_aclGrantCache[cacheKey] && !(options && options.force)) {
+    return true;
   }
   try {
     // Recursive ACL for existing files
@@ -295,6 +308,7 @@ function grantProjectAccess(projectPath, linuxUser) {
     });
     _aclGrantCache[cacheKey] = true;
     console.log("[os-users] Granted ACL access for " + linuxUser + " on " + projectPath);
+    return true;
   } catch (e) {
     delete _aclGrantCache[cacheKey];
     var errMsg = (e.stderr || e.message || "").toString();
@@ -305,6 +319,7 @@ function grantProjectAccess(projectPath, linuxUser) {
     } else {
       console.error("[os-users] Failed to grant ACL access for " + linuxUser + " on " + projectPath + ": " + errMsg);
     }
+    return false;
   }
 }
 

package/lib/project-admin-overview.js

@@ -0,0 +1,51 @@
+// This projection is an allowlist. Never add runtime/session/path objects here.
+function projectMetadata(status, access, users) {
+  if (!status || status.isMate || !access || access.error) return null;
+  var owner = access.ownerId && users.findUserById(access.ownerId);
+  return {
+    slug: status.slug,
+    project: status.title || status.project || status.slug,
+    title: status.title || status.project || status.slug,
+    projectOwnerId: owner ? owner.id : null,
+    ownerName: owner ? (owner.displayName || owner.username) : "Ownership needs recovery",
+    visibility: access.visibility,
+    contentAccess: false,
+    administrativeAccess: true,
+    ownershipRecovery: access.ownershipRecovery === "required" || !owner,
+    runtimeHealth: "Registered",
+  };
+}
+
+function metadataFor(user, status, access, users) {
+  if (!user || !users.findUserById(user.id) || user.role !== "admin" || !status || status.isMate || /^mate-/.test(status.slug)) return null;
+  return projectMetadata(status, access, users);
+}
+
+function escape(value) {
+  return String(value || "").replace(/[&<>"']/g, function (character) {
+    return { "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#39;" }[character];
+  });
+}
+
+function page(metadata, projects) {
+  var privacyText = metadata.ownershipRecovery
+    ? "Content remains restricted because no verified owner is available. Ask the server operator to verify the account’s OS UID and real home/project mapping, then run the documented ownership repair."
+    : "Conversations, files and terminals are private. Ask the owner to share project access.";
+  var accessText = metadata.ownershipRecovery
+    ? "Ownership needs recovery. The server operator must independently verify or repair the authoritative account-to-OS mapping before ownership repair can succeed. Ambiguous records stay restricted; administrator status cannot claim this project. See the Project ownership and administrator access guide."
+    : "Only the project owner can change ownership, visibility and sharing. Administrator status does not grant access to private content.";
+  var strip = projects.filter(function (project) { return !project.isMate; }).map(function (project) {
+    return '<a class="icon-strip-item' + (project.slug === metadata.slug ? ' active' : '') + '" href="/p/' + encodeURIComponent(project.slug) + '/" title="' + escape(project.title || project.project) + '"><span class="icon-strip-name">' + escape((project.title || project.project || project.slug).substring(0, 2)) + '</span></a>';
+  }).join("");
+  return '<!doctype html><html lang="en"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1"><title>' + escape(metadata.title) + ' · Clay</title>' +
+    '<script src="/appearance-bootstrap.js"></script><link rel="stylesheet" href="/style.css"><link rel="stylesheet" href="/css/project-admin-overview.css"></head><body>' +
+    '<div id="layout"><header id="top-bar"><a href="/" class="top-bar-brand-link" aria-label="Clay home"><span class="top-bar-brand-wordmark"></span></a></header>' +
+    '<div id="layout-body"><nav id="icon-strip" aria-label="Projects"><div class="icon-strip-projects">' + strip + '</div></nav>' +
+    '<main id="main-area" class="project-admin-overview"><div class="project-admin-canvas"><h1>' + escape(metadata.title) + '</h1>' +
+    '<div role="tablist" aria-label="Project information"><button type="button" role="tab" aria-selected="true" id="overview-tab" aria-controls="overview-panel">Overview</button><button type="button" role="tab" aria-selected="false" id="access-tab" aria-controls="access-panel">Access</button></div>' +
+    '<section id="overview-panel" role="tabpanel" aria-labelledby="overview-tab"><dl><dt>Owner</dt><dd>' + escape(metadata.ownerName) + '</dd><dt>Visibility</dt><dd>' + escape(metadata.visibility) + '</dd><dt>Status</dt><dd>' + (metadata.ownershipRecovery ? 'Ownership needs recovery' : escape(metadata.runtimeHealth)) + '</dd><dt>Your access</dt><dd>Administrative metadata only</dd></dl><p>' + escape(privacyText) + '</p><p class="project-admin-secondary">Resource usage is unavailable for this project.</p></section>' +
+    '<section id="access-panel" role="tabpanel" aria-labelledby="access-tab" hidden><h2>Administrative metadata only</h2><p>' + escape(accessText) + '</p></section></div></main></div></div>' +
+    '<script type="module" src="/modules/project-admin-overview.js"></script></body></html>';
+}
+
+module.exports = { metadataFor: metadataFor, page: page };

package/lib/project-ask-user.js

@@ -25,8 +25,9 @@ function attachAskUser(ctx) {
       respond.cancel("Autonomous mode. Make your own decision.");
       return;
     }
-    var questions = planningQuestions(boundSession, request.questions);
+    var questions = ["mcp-import", "product-control"].indexOf(request.source) >= 0 ? request.questions : planningQuestions(boundSession, request.questions);
     var input = { questions: questions };
+    if (request.source === 'mcp-import') input.source = 'mcp-import';
     if (!boundSession.pendingAskUser) boundSession.pendingAskUser = {};
     var pending = {
       input: input,
@@ -38,15 +39,18 @@ function attachAskUser(ctx) {
     };
     boundSession.pendingAskUser[request.id] = pending;
     if (respond && typeof respond.onSettle === "function") {
-      respond.onSettle(function () {
+      respond.onSettle(function (result) {
+        if (request.source === 'product-control' && result.status !== 'submitted') ctx.record(boundSession, { type: 'product_control_question_expired', toolId: request.id, error: 'This exact change review expired or was cancelled. No change was authorized.' });
+        if (request.source === 'mate-schedule' && result.status !== 'submitted') ctx.record(boundSession, { type: 'mate_schedule_question_expired', toolId: request.id, error: 'This schedule review expired. Request a new review.' });
+        if (request.source === 'mcp-import' && result.status !== 'submitted') ctx.record(boundSession, { type: 'mcp_import_consent_expired', toolId: request.id, source: 'mcp-import', error: 'Import consent expired or was cancelled. No connection was imported.' });
         if (boundSession.pendingAskUser && boundSession.pendingAskUser[request.id] === pending) delete boundSession.pendingAskUser[request.id];
       });
     }
     if (!askUserIdentity.hasRecordedAskUserRequest(boundSession.history, request.id, input)) {
-      ctx.record(boundSession, { type: "tool_executing", id: request.id, name: "AskUserQuestion", input: input });
+      ctx.record(boundSession, { type: "tool_executing", id: request.id, name: "AskUserQuestion", input: input, source: request.source });
     }
     var router = ctx.getWorkerQuestionRouter && ctx.getWorkerQuestionRouter();
-    if (router) router.routeQuestion(boundSession, request, respond, function (answers, driverId) {
+    if (router && request.source !== "mcp-import" && request.source !== "mate-schedule" && request.source !== "product-control") router.routeQuestion(boundSession, request, respond, function (answers, driverId) {
       var displayAnswers = {};
       request.questions.forEach(function (question, index) { displayAnswers[index] = answers[question.id].join(", "); });
       ctx.record(boundSession, { type: "ask_user_answered", toolId: request.id, answers: displayAnswers, answeredByDriver: driverId });