severally-mcp 2.0.0 → 2.3.1

package/src/consultants.mjs

@@ -212,25 +212,41 @@ const clamp = (v, min, max) => Math.min(max, Math.max(min, v));
  * CLI's availability, decided by policy.mjs.
  */
 export function buildConsultants(config) {
+  // `problems` is every mistake, for the operator to read; `global` the ones
+  // that leave the whole file untrustworthy. A mistake inside one consultant
+  // or one CLI is kept to it: that consultant cannot be used (`broken`), that
+  // CLI is off (`brokenClis`) -- the closed side either way, so nothing the
+  // operator turned off comes back on.
   const problems = [];
+  const global = [];
+  const broken = {};
+  const brokenClis = {};
+  const fault = (msg) => { problems.push(msg); global.push(msg); };
   const cfg = isObject(config) ? config : {};
-  if (!isObject(config)) problems.push('the config file must hold a JSON object');
+  if (!isObject(config)) fault('the config file must hold a JSON object');
   for (const key of Object.keys(cfg)) {
-    if (!TOP_KEYS.includes(key)) problems.push(`unknown top-level key "${key}" (allowed: ${TOP_KEYS.join(', ')})`);
+    if (!TOP_KEYS.includes(key)) fault(`unknown top-level key "${key}" (allowed: ${TOP_KEYS.join(', ')})`);
+  }
+
+  // The one server key that is not a number to clamp: a wrong value cannot
+  // be read as either setting, and reading it as "on" would open the web.
+  if (isObject(cfg.server) && cfg.server.network !== undefined && !['on', 'off'].includes(cfg.server.network)) {
+    fault('server.network must be "on" or "off"');
   }
 
   let ranking = [];
   if (cfg.ranking !== undefined) {
     if (Array.isArray(cfg.ranking) && cfg.ranking.every((r) => typeof r === 'string' && r.trim() !== '')) ranking = cfg.ranking.map((r) => r.trim());
-    else problems.push('ranking must be an array of non-empty strings');
+    else fault('ranking must be an array of non-empty strings');
   }
 
   if (cfg.clis !== undefined) {
-    if (!isObject(cfg.clis)) problems.push('clis must be an object keyed by CLI');
+    if (!isObject(cfg.clis)) fault('clis must be an object keyed by CLI');
     else {
       for (const [id, def] of Object.entries(cfg.clis)) {
         if (!CLI_IDS.includes(id)) { problems.push(`clis.${id}: unknown CLI (known: ${CLI_IDS.join(', ')})`); continue; }
-        if (!isObject(def)) { problems.push(`clis.${id} must be an object`); continue; }
+        const before = problems.length;
+        if (!isObject(def)) { problems.push(`clis.${id} must be an object`); brokenClis[id] = problems.slice(before); continue; }
         for (const k of Object.keys(def)) if (!CLI_KEYS.includes(k)) problems.push(`clis.${id}.${k}: unknown key (allowed: ${CLI_KEYS.join(', ')})`);
         // A wrong type must not fall back to a default: enabled: "false"
         // read as "unset" would turn on the CLI the operator meant to stop.
@@ -242,6 +258,7 @@ export function buildConsultants(config) {
           if (id !== 'opencode') problems.push(`clis.${id}.provider: only OpenCode takes provider definitions`);
           else if (!(isObject(def.provider) && Object.values(def.provider).every(isObject))) problems.push(`clis.${id}.provider: must be an object of provider objects, as in opencode.json`);
         }
+        if (problems.length > before) brokenClis[id] = problems.slice(before);
       }
     }
   }
@@ -250,15 +267,15 @@ export function buildConsultants(config) {
   if (cfg.consultants === undefined) {
     for (const cli of CLI_IDS) consultants.push(make(cli, { cli, model: DEFAULT_MODELS[cli] }));
   } else if (!isObject(cfg.consultants)) {
-    problems.push('consultants must be an object keyed by name');
+    fault('consultants must be an object keyed by name');
   } else {
     const seen = new Map();
     for (const [name, def] of Object.entries(cfg.consultants)) {
       const at = `consultants.${name}`;
       if (!/^[a-z0-9][a-z0-9.-]{0,63}$/.test(name)) { problems.push(`${at}: a name is lower-case letters, digits, "." and "-", at most 64 characters`); continue; }
       if (RESERVED_NAMES.includes(name)) { problems.push(`${at}: "${name}" is reserved`); continue; }
-      if (!isObject(def)) { problems.push(`${at} must be an object`); continue; }
       const before = problems.length;
+      if (!isObject(def)) { problems.push(`${at} must be an object`); broken[name] = problems.slice(before); continue; }
       for (const k of Object.keys(def)) if (!CONSULTANT_KEYS.includes(k)) problems.push(`${at}.${k}: unknown key (allowed: ${CONSULTANT_KEYS.join(', ')})`);
       if (!CLI_IDS.includes(def.cli)) problems.push(`${at}.cli: must be one of ${CLI_IDS.join(', ')}`);
       if (typeof def.model !== 'string' || def.model.trim() === '') problems.push(`${at}.model: required`);
@@ -272,14 +289,18 @@ export function buildConsultants(config) {
       if (def.max_budget_usd !== undefined && def.cli !== 'claude-code') problems.push(`${at}.max_budget_usd: only a claude-code consultant has a budget`);
       // agy takes the effort from the model name and rejects --effort.
       if (def.effort !== undefined && def.cli === 'antigravity') problems.push(`${at}.effort: Antigravity takes the effort from the model name (e.g. gemini-3.8-flash-low)`);
-      if (problems.length > before) continue;
+      if (problems.length > before) { broken[name] = problems.slice(before); continue; }
       const pair = `${def.cli}\n${def.model.trim()}`;
-      if (seen.has(pair)) { problems.push(`${at}: same cli and model as consultants.${seen.get(pair)}; asking one model twice adds no independence`); continue; }
+      if (seen.has(pair)) {
+        problems.push(`${at}: same cli and model as consultants.${seen.get(pair)}; asking one model twice adds no independence`);
+        broken[name] = problems.slice(before);
+        continue;
+      }
       seen.set(pair, name);
       consultants.push(make(name, def));
     }
   }
-  return { consultants: Object.freeze(consultants), ranking: Object.freeze(ranking), problems };
+  return { consultants: Object.freeze(consultants), ranking: Object.freeze(ranking), problems, global, broken, brokenClis };
 }
 
 function make(name, def) {

package/src/expose-paths.mjs

@@ -105,6 +105,12 @@ function walkDir(root, dir, onFile, totals, skipped) {
   }
   for (const item of items) {
     const child = path.join(dir, item.name);
+    // Outside git there is no .gitignore to say what is not source: these two
+    // are never what a consultant should read, and would hit the caps alone.
+    if (item.name === '.git' || item.name === 'node_modules') {
+      skipped.push({ source: child, reason: 'ignored' });
+      continue;
+    }
     // Not followed: a link inside a directory the lead exposed can resolve
     // anywhere on the disk, which is exactly the scope this feature exists
     // to keep drawn. Recorded rather than dropped silently, so a consultant
@@ -130,6 +136,61 @@ function walkDir(root, dir, onFile, totals, skipped) {
   }
 }
 
+// walkDir's order: name by name at every level, not the whole path as one
+// string ("a/x" comes before "a-b" there, after it as a string).
+function byPathParts(a, b) {
+  const x = a.split('/');
+  const y = b.split('/');
+  for (let i = 0; i < Math.min(x.length, y.length); i++) if (x[i] !== y[i]) return x[i] < y[i] ? -1 : 1;
+  return x.length - y.length;
+}
+
+// A directory inside a git work tree: the candidates are what git lists
+// (tracked, plus untracked that .gitignore does not exclude), so `.git` and
+// ignored trees drop out. Every candidate gets walkDir's checks again -- a
+// committed .env is still protected, a listed file may be gone, a link, a
+// submodule, or reach outside the directory. False when this is not a work
+// tree, git is missing or lists nothing (an ignored directory the lead named
+// on purpose): the caller walks it instead.
+function walkGit(dir, exposedAs, onFile, totals, skipped) {
+  let listed;
+  let ignored;
+  try {
+    listed = [...new Set(nulSplit(git(dir, ['ls-files', '-z', '--cached', '--others', '--exclude-standard'])))];
+    ignored = nulSplit(git(dir, ['ls-files', '-z', '--others', '--ignored', '--exclude-standard', '--directory']));
+  } catch { return false; }
+  if (listed.length === 0) return false;
+  for (const p of ignored) skipped.push({ source: path.join(dir, p), reason: 'ignored' });
+  if (fs.existsSync(path.join(dir, '.git'))) skipped.push({ source: path.join(dir, '.git'), reason: 'ignored' });
+  const realDir = fs.realpathSync(dir);
+  const protectedDirs = new Set();
+  for (const rel of listed.sort(byPathParts)) {
+    const abs = path.join(dir, rel);
+    // walkDir never enters a protected directory (.env.d/, .ssh/ ...); a
+    // listed file is checked with each directory above it for the same reason.
+    const parts = rel.split('/');
+    const guarded = parts.slice(0, -1).map((_, i) => path.join(dir, ...parts.slice(0, i + 1))).find(isProtectedPath);
+    if (guarded) {
+      if (!protectedDirs.has(guarded)) skipped.push({ source: guarded, reason: 'protected' });
+      protectedDirs.add(guarded);
+      continue;
+    }
+    if (isProtectedPath(abs)) { skipped.push({ source: abs, reason: 'protected' }); continue; }
+    let stat;
+    // Deleted in the work tree but still in the index: not part of the tree
+    // as it is now, so not part of the copy either.
+    try { stat = fs.lstatSync(abs); } catch { continue; }
+    // A directory here is a submodule (or a nested repository): its own history, not this one's files.
+    if (stat.isDirectory()) { skipped.push({ source: abs, reason: 'submodule' }); continue; }
+    const inside = (() => { try { return fs.realpathSync(abs).startsWith(realDir + path.sep); } catch { return false; } })();
+    if (stat.isSymbolicLink() || !inside) { skipped.push({ source: abs, reason: 'symlink' }); continue; }
+    if (!stat.isFile()) continue;
+    onFile(abs, path.normalize(rel));
+    checkBudget(totals);
+  }
+  return true;
+}
+
 // Each path is a string, or { source, index } to keep the name an earlier
 // round gave it.
 function walkEntries(exposePaths, onFile) {
@@ -138,6 +199,9 @@ function walkEntries(exposePaths, onFile) {
   const entries = exposePaths.map((p, i) => {
     const { source, index } = typeof p === 'string' ? { source: p, index: i } : p;
     const stat = statEntry(source);
+    // Indexed, so two entries whose basenames collide (two different
+    // util.mjs) stay apart, and the brief can name each one exactly.
+    const exposedAs = `workspace/${index}-${path.basename(source)}`;
     const before = { files: totals.files, bytes: totals.bytes };
     // What a directory holds, for the brief: not every consultant has a tool
     // that lists a directory, and a name it cannot see is a file it never reads.
@@ -148,18 +212,17 @@ function walkEntries(exposePaths, onFile) {
       onFile(source, '', index, source, totals);
       checkBudget(totals);
     } else {
-      walkDir(source, source, (abs, rel) => {
+      const add = (abs, rel) => {
         paths.push(rel.split(path.sep).join('/'));
         onFile(abs, rel, index, source, totals);
-      }, totals, skipped);
+      };
+      walkGit(source, exposedAs, add, totals, skipped) || walkDir(source, source, add, totals, skipped);
     }
     return {
       index,
       source,
       kind: stat.isDirectory() ? 'directory' : 'file',
-      // Indexed, so two entries whose basenames collide (two different
-      // util.mjs) stay apart, and the brief can name each one exactly.
-      exposedAs: `workspace/${index}-${path.basename(source)}`,
+      exposedAs,
       files: totals.files - before.files,
       bytes: totals.bytes - before.bytes,
       paths: paths.sort(),