clay-server 5.2.0-beta.4 → 5.2.0-beta.6

package/lib/mate-schedule-input.js

@@ -0,0 +1,29 @@
+var rules = require('./schedule-rule');
+function normalize(input, previous) {
+  input = input || {};
+  var message = input.message === undefined && previous ? previous.message : input.message;
+  if (typeof message !== 'string' || !message.trim() || message.length > 1200 || message.indexOf('\u0000') >= 0) throw new Error('A message of 1 to 1200 characters is required.');
+  var source = input.scheduleRule || (previous && previous.rule) || {
+    version: 1, timezone: 'server-local', anchorDate: input.date, time: input.time, recurrence: null,
+  };
+  source = Object.assign({}, source);
+  if (input.date !== undefined) source.anchorDate = input.date;
+  if (input.time !== undefined) source.time = input.time;
+  var checked = rules.validateScheduleRule(source);
+  if (!checked.ok) throw new Error(checked.error);
+  return { message: message.trim(), rule: checked.value };
+}
+function timezone() { return Intl.DateTimeFormat().resolvedOptions().timeZone || 'UTC'; }
+function review(value) {
+  var rule = value.rule;
+  var repeat = rule.recurrence ? 'Every ' + rule.recurrence.every + ' ' + rule.recurrence.unit +
+    (rule.recurrence.weekdays ? ' on ' + rule.recurrence.weekdays.map(function (day) { return ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday'][day]; }).join(', ') : '') : 'Once';
+  if (rule.recurrenceEnd) repeat += rule.recurrenceEnd.type === 'after' ? ', ' + rule.recurrenceEnd.count + ' deliveries' : ', through ' + rule.recurrenceEnd.date;
+  if (rule.interval) {
+    var ending = rule.interval.end;
+    repeat += '; every ' + rule.interval.every + ' ' + rule.interval.unit;
+    repeat += !ending ? ', until end of day' : ending.type === 'after' ? ', ' + ending.count + ' deliveries per day' : ', until ' + ending.time;
+  }
+  return value.message + '\n' + rule.anchorDate + ' at ' + rule.time + ' (' + timezone() + ')\n' + repeat;
+}
+module.exports = { normalize: normalize, timezone: timezone, review: review };

package/lib/mate-schedule-lifecycle.js

@@ -0,0 +1,151 @@
+var crypto = require('crypto');
+var rule = require('./schedule-rule');
+
+function copy(value) { return JSON.parse(JSON.stringify(value)); }
+function attachMateScheduleLifecycle(ctx) {
+  var now = ctx.now || Date.now;
+  function save(session, records) {
+    var previous = session.mateSchedules;
+    session.mateSchedules = records;
+    if (ctx.sm.saveSessionFile(session) !== true) {
+      session.mateSchedules = previous;
+      throw new Error('The Mate schedule could not be saved.');
+    }
+  }
+  function records(session) { return copy(session.mateSchedules || []); }
+  function find(session, id) {
+    return records(session).find(function (record) { return record.id === id; }) || null;
+  }
+  function replace(session, record) {
+    var all = records(session);
+    var index = all.findIndex(function (item) { return item.id === record.id; });
+    if (index < 0) all.push(record); else all[index] = record;
+    save(session, all);
+  }
+  function jobFor(record) {
+    return ctx.scheduler.listJobs().reverse().find(function (job) {
+      return job.projectId === ctx.slug && job.payload && job.payload.mateScheduleId === record.id &&
+        job.payload.logicalRevision === record.revision && job.payload.occurrence === record.occurrence;
+    });
+  }
+  function current(session, job) {
+    var record = job && job.payload && find(session, job.payload.mateScheduleId);
+    if (record && record.createdBy && record.createdBy.type === 'canonicalClay') { try { (ctx.authorizeRuntime || ctx.authorize)(session); } catch (error) { return false; } }
+    return !!(record && record.state === 'active' && record.revision === job.payload.logicalRevision &&
+      record.occurrence === job.payload.occurrence && record.ownerId === job.ownerId);
+  }
+  function admit(session, record) {
+    if (record.state !== 'active') return null;
+    var existing = jobFor(record);
+    if (existing && !(existing.state === 'cancelled' && existing.cancelledReason === 'queue_admission_failed')) {
+      if (['failed', 'cancelled', 'interrupted'].indexOf(existing.state) >= 0) throw new Error('The occurrence requires recovery; it was not scheduled.');
+      return existing;
+    }
+    var job = ctx.schedule(session, record.message, Math.max(record.runAt, now() + 1),
+      { id: record.ownerId }, null, null, 'mate-' + record.id + '-' + record.revision + '-' + record.occurrence,
+      null, { exact: true, scheduleRule: record.rule, mateScheduleId: record.id,
+        logicalScheduleId: record.id, logicalRevision: record.revision, occurrence: record.occurrence });
+    if (!job) throw new Error('The occurrence could not be admitted. The saved schedule needs retry.');
+    return job;
+  }
+  function create(session, value, id, control) {
+    var actor = ctx.authorize(session, control);
+    var existing = find(session, id);
+    if (existing) { if (existing.message !== value.message || JSON.stringify(existing.rule) !== JSON.stringify(value.rule)) throw new Error('Schedule request already names another intent.'); admit(session, existing); return existing; }
+    var runAt = rule.nextScheduleRuleTime(value.rule, now(), [], {});
+    if (!Number.isFinite(runAt)) throw new Error('The schedule time has expired.');
+    var record = { id: id, revision: crypto.randomUUID(), ownerId: ctx.owner(session), message: value.message,
+      createdBy: actor || null, updatedBy: actor || null, rule: value.rule, state: 'active', occurrence: 0, count: 0, dateCounts: {}, runAt: runAt };
+    replace(session, record);
+    admit(session, record);
+    return record;
+  }
+  function checked(session, args, control) {
+    ctx.authorize(session, control);
+    var record = find(session, args.id);
+    if (!record || record.ownerId !== ctx.owner(session)) throw new Error('Schedule not found.');
+    if (args.revision && args.revision !== record.revision) throw new Error('The schedule revision is stale.');
+    return record;
+  }
+  function cancel(session, args, control) {
+    var record = checked(session, args, control);
+    var actor = ctx.authorize(session, control);
+    if (record.state === 'cancelled') return record;
+    // Persist the tombstone before touching occurrences. Dispatch rechecks it.
+    record.state = 'cancelled';
+    if (actor) record.updatedBy = actor;
+    replace(session, record);
+    var job = jobFor(record);
+    if (job && job.state === 'queued' && !ctx.cancelJob(session, job)) throw new Error('Cancellation was saved, but occurrence cleanup failed.');
+    return record;
+  }
+  function update(session, args, value, control) {
+    var previous = checked(session, args, control);
+    var actor = ctx.authorize(session, control);
+    if (previous.state !== 'active') throw new Error('Only active schedules can be updated.');
+    var runAt = rule.nextScheduleRuleTime(value.rule, now(), [], {});
+    if (!Number.isFinite(runAt)) throw new Error('The schedule time has expired.');
+    var record = Object.assign({}, previous, { revision: crypto.randomUUID(), updatedBy: actor || previous.updatedBy || null, message: value.message,
+      rule: value.rule, count: 0, dateCounts: {}, occurrence: 0, runAt: runAt });
+    replace(session, record);
+    var oldJob = jobFor(previous);
+    if (oldJob && oldJob.state === 'queued' && !ctx.cancelJob(session, oldJob)) throw new Error('Update saved, but previous occurrence cleanup failed.');
+    admit(session, record);
+    return record;
+  }
+  function consumed(session, job) {
+    if (!current(session, job)) return false;
+    var record = find(session, job.payload.mateScheduleId);
+    record.count++;
+    var date = new Date(record.runAt);
+    var key = date.getFullYear() + '-' + String(date.getMonth() + 1).padStart(2, '0') + '-' + String(date.getDate()).padStart(2, '0');
+    record.dateCounts[key] = Number(record.dateCounts[key] || 0) + 1;
+    // Coalesce missed times: deliver the admitted occurrence once, then choose
+    // the next future time. Counts represent deliveries, not missed slots.
+    record.runAt = rule.nextScheduleRuleTime(record.rule, Math.max(record.runAt, now()), [],
+      { startCount: record.count, dateStartCounts: record.dateCounts });
+    record.occurrence++;
+    if (!Number.isFinite(record.runAt)) record.state = 'completed';
+    replace(session, record);
+    admit(session, record);
+    return true;
+  }
+  function reconcile(session) {
+    records(session).forEach(function (record) {
+      if (record.state !== 'active') return;
+      (ctx.authorizeRuntime || ctx.authorize)(session);
+      var job = jobFor(record);
+      var item = job && ctx.queueItem(session, job);
+      if (item && item.state === 'consumed') consumed(session, job);
+      else if (item && (item.state === 'cancelled' || item.state === 'failed')) {
+        record.state = item.state;
+        replace(session, record);
+      } else if (job && ['failed', 'cancelled', 'interrupted'].indexOf(job.state) >= 0 && (!item || item.state !== 'pending')) {
+        record.state = 'interrupted';
+        replace(session, record);
+      } else admit(session, record);
+    });
+  }
+  function onConsumed(session, job) {
+    try { return consumed(session, job); }
+    catch (error) {
+      // Queue consumption is already durable. Keep the accepted provider turn
+      // running; reconciliation repairs the saved next occurrence after restart.
+      ctx.sm.sendAndRecord(session, { type: 'error', text: 'The scheduled message was delivered, but its next occurrence needs recovery: ' + error.message });
+      return false;
+    }
+  }
+  return { create: create, read: checked, list: function (session, control) { ctx.authorize(session, control); return records(session); },
+    update: update, cancel: cancel, failed: function (session, job, error) {
+      if (!current(session, job)) return;
+      var record = find(session, job.payload.mateScheduleId);
+      record.state = 'failed'; record.error = error.message;
+      replace(session, record);
+    }, cancelled: function (session, job) {
+      if (!current(session, job)) return;
+      var record = find(session, job.payload.mateScheduleId);
+      record.state = 'cancelled';
+      replace(session, record);
+    }, current: current, consumed: onConsumed, reconcile: reconcile };
+}
+module.exports = { attachMateScheduleLifecycle: attachMateScheduleLifecycle };

package/lib/mate-scheduling.js

@@ -0,0 +1,103 @@
+var crypto = require('crypto');
+var userInput = require('./yoke/user-input');
+var input = require('./mate-schedule-input');
+var personal = require('./mcp-session-access');
+
+function attachMateScheduling(ctx) {
+  function owner(session) { return ctx.users.isMultiUser() ? session.ownerId : 'local-user'; }
+  function privateSession(session) {
+    if (!ctx.isMate || !session || ctx.sm.sessions.get(session.localId) !== session ||
+        session.destroying || session.mateCreationMode || session.taskStopRequested || session._mcpForeignInput ||
+        session.sessionVisibility === 'shared' || session.delegated || session._delegatedBy || session._pairDelegation) throw new Error('An active private Mate conversation is required.');
+    if (ctx.users.isMultiUser() && (session.ownerId !== ctx.projectOwnerId || !personal.canUsePersonalConnections(session, ctx.sm.sessions))) throw new Error('Only the Mate owner can schedule messages.');
+    if (!ctx.users.isMultiUser() && (session.ownerId || (session.history || []).some(function (event) { return event.type === 'user_message' && event.from && event.from !== 'default'; }))) throw new Error('Foreign input cannot authorize Mate schedules.');
+    ctx.authorizeAccess(session, owner(session));
+  }
+  function authorize(session) {
+    if (ctx.isHostAgent) throw new Error('Canonical Clay scheduling requires its separate owner-reviewed controls.');
+    privateSession(session);
+  }
+  function authorizeControl(session, control) {
+    privateSession(session);
+    return require('./canonical-clay-scheduling-authority').validate(control, ctx.slug, session);
+  }
+  function authorizeLifecycle(session) {
+    privateSession(session);
+    require('./canonical-clay-scheduling-authority').assertMate(ctx.projectOwnerId, ctx.mateId, ctx.users.isMultiUser());
+    if (ctx.isHostAgent) require('./canonical-clay-scheduling-authority').assertHost(ctx.projectOwnerId, ctx.mateId, ctx.users.isMultiUser());
+  }
+  function persistDraft(session, draft) {
+    var previous = session.mateScheduleDraft;
+    session.mateScheduleDraft = draft;
+    if (ctx.sm.saveSessionFile(session) !== true) {
+      session.mateScheduleDraft = previous;
+      throw new Error('The schedule draft could not be saved.');
+    }
+  }
+  function result(value) { return { content: [{ type: 'text', text: JSON.stringify(value) }] }; }
+  function getToolDefs(session) {
+    try { authorize(session); } catch (error) { return []; }
+    var generation = Number(session._sdkQueryGeneration || 0);
+    var originalOwner = owner(session);
+    function current() {
+      authorize(session);
+      if (generation !== Number(session._sdkQueryGeneration || 0) || owner(session) !== originalOwner) throw new Error('The schedule query is stale.');
+    }
+    function tool(name, description, properties, required, handler) {
+      return { name: name, queryBound: true, inputSchema: { type: 'object', properties: properties, required: required, additionalProperties: false },
+        description: description, handler: async function (args) {
+          try { current(); return result(await handler(args || {})); }
+          catch (error) { return result({ status: 'rejected', reason: error.message }); }
+        } };
+    }
+    var str = { type: 'string' };
+    var fields = { message: str, date: str, time: str, scheduleRule: { type: ['object', 'null'] } };
+    async function approve(draft, question, label, other) {
+      persistDraft(session, draft);
+      var reply = await userInput.dispatchUserInput(ctx.userInput(session), { questions: [{
+        id: 'approve', header: 'Mate schedule', question: question,
+        options: [{ label: label }, { label: other || 'Cancel' }], allowOther: false,
+      }] }, { source: 'mate-schedule', signal: session.abortController && session.abortController.signal });
+      current();
+      if (!session.mateScheduleDraft || session.mateScheduleDraft.id !== draft.id || session.mateScheduleDraft.revision !== draft.revision) throw new Error('The schedule draft is stale.');
+      var accepted = reply.status === 'submitted' && reply.answers.approve && reply.answers.approve.length === 1 && reply.answers.approve[0] === label;
+      if (!accepted) persistDraft(session, null);
+      return accepted;
+    }
+    async function review(args, update) {
+      var previous = update ? ctx.lifecycle.read(session, args) : null;
+      var value = input.normalize(args, previous);
+      var draft = { id: crypto.randomUUID(), revision: crypto.randomUUID(), value: value,
+        targetId: previous && previous.id, targetRevision: previous && previous.revision };
+      if (!await approve(draft, (update ? 'Update this schedule?\n' : 'Create this schedule?\n') + input.review(value), update ? 'Update schedule' : 'Create schedule')) return { status: 'cancelled' };
+      var record = update ? ctx.lifecycle.update(session, { id: draft.targetId, revision: draft.targetRevision }, value) : ctx.lifecycle.create(session, value, draft.id);
+      persistDraft(session, null);
+      return { status: update ? 'updated' : 'created', schedule: record, timezone: input.timezone() };
+    }
+    async function cancel(args) {
+      var record = ctx.lifecycle.read(session, args);
+      if (record.state === 'cancelled') return { status: 'cancelled', schedule: record };
+      var draft = { id: crypto.randomUUID(), revision: crypto.randomUUID(), targetId: record.id, targetRevision: record.revision };
+      if (!await approve(draft, 'Cancel this schedule?\n' + input.review({ message: record.message, rule: record.rule }), 'Cancel schedule', 'Keep schedule')) return { status: 'unchanged' };
+      record = ctx.lifecycle.cancel(session, { id: draft.targetId, revision: draft.targetRevision });
+      persistDraft(session, null);
+      return { status: 'cancelled', schedule: record };
+    }
+    var begin = tool('begin_mate_schedule_interview', 'Begin scheduling for this Mate. Ask exactly one structured question at a time. Never assume repetition.', {}, [], function () {
+      return { status: 'interview_started', timezone: input.timezone(), guidance: 'Collect the message, date/time, and explicitly requested repetition one question at a time. Then propose the complete schedule for the human approval card.' };
+    });
+    begin.structuredQuestionLimit = function () { try { current(); return 1; } catch (error) { return null; } };
+    return [begin,
+      tool('propose_mate_schedule', 'Review a complete message schedule in a server-owned approval card. Only authenticated human approval persists a schedule.', fields, ['message'], function (args) { return review(args, false); }),
+      tool('list_mate_schedules', 'List logical schedules and their stable IDs, revisions and lifecycle states in this private conversation.', {}, [], function () { return { schedules: ctx.lifecycle.list(session) }; }),
+      tool('read_mate_schedule', 'Read one logical schedule using its listed ID.', { id: str }, ['id'], function (args) { return { schedule: ctx.lifecycle.read(session, args) }; }),
+      tool('update_mate_schedule', 'Propose changes to an active schedule by listed ID and revision, with a fresh human approval card.', Object.assign({ id: str, revision: str }, fields), ['id', 'revision'], function (args) { return review(args, true); }),
+      tool('cancel_mate_schedule', 'Review cancellation by listed ID and revision in an authenticated human approval card. Cancellation persists across restart.', { id: str, revision: str }, ['id', 'revision'], cancel),
+    ];
+  }
+  return { authorize: authorize, authorizeControl: authorizeControl, authorizeLifecycle: authorizeLifecycle, owner: owner, getToolDefs: getToolDefs, getSystemPrompt: function (session) {
+    try { authorize(session); } catch (error) { return ''; }
+    return 'When scheduling for this Mate, call begin_mate_schedule_interview, ask exactly one structured question at a time, and clarify the message, local date/time in ' + input.timezone() + ', and explicitly requested repetition. Use scheduleRule for recurrence and count/until limits. propose_mate_schedule and update_mate_schedule present the exact authenticated human approval card. Chat text and model flags never approve schedules. Use listed logical IDs and revisions to read, update or cancel. Scheduled output uses this private Mate runtime and tools. Project Scheduled Tasks Driver/Worker tools remain unavailable.';
+  } };
+}
+module.exports = { attachMateScheduling: attachMateScheduling };

package/lib/mates.js

@@ -246,7 +246,7 @@ function updateMate(ctx, id, updates) {
   return null;
 }
 
-function deleteMate(ctx, id) {
+function deleteMate(ctx, id, options) {
   var data = loadMates(ctx);
   // Primary mates cannot be deleted (they are system infrastructure)
   for (var di = 0; di < data.mates.length; di++) {
@@ -259,15 +259,16 @@ function deleteMate(ctx, id) {
     return m.id !== id;
   });
   if (data.mates.length === before) return { error: "Mate not found" };
-  saveMates(ctx, data);
+  if (!options || !options.strictCleanup) saveMates(ctx, data);
 
   // Remove mate directory
   var mateDir = getMateDir(ctx, id);
   try {
     fs.rmSync(mateDir, { recursive: true, force: true });
   } catch (e) {
-    // Directory may not exist
+    if (options && options.strictCleanup) throw e;
   }
+  if (options && options.strictCleanup) saveMates(ctx, data);
 
   return { ok: true };
 }

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

@@ -1,4 +1,4 @@
-var descriptors = require('./sdk-mcp-descriptors').extractMcpDescriptors;
+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.');

package/lib/mcp-source-adapters.js

@@ -1,91 +1 @@
-// 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 };
+module.exports = require("./yoke/mcp-source-adapters");

package/lib/mcp-source-context.js

@@ -1,42 +1 @@
-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 };
+module.exports = require("./yoke/mcp-source-context");