severally-mcp 2.1.0 → 2.4.0

package/src/status.mjs

@@ -0,0 +1,132 @@
+// `severally-mcp status`: what this machine has set up, read without starting a
+// consultation, so it spends no quota. It says what it can see and no more:
+// login is read from each CLI's own status command where it has one, and where
+// it has none it is reported as not checked rather than as working.
+import {
+  POLICY,
+  configProblem,
+  configWarnings,
+  unavailableReason,
+  consultantAvailable,
+  brokenConsultantNames,
+  brokenConsultant,
+} from './policy.mjs';
+import { SEVERALLY_VERSION, staleInstall } from './server.mjs';
+import { findCommand, execCommandSync } from './platform.mjs';
+
+// How each client lists severally, plugin installs first. A command that exits 0
+// and names severally counts as registered.
+const CLIENTS = [
+  {
+    label: 'Claude Code',
+    cmd: 'claude',
+    checks: [
+      ['plugin', 'list'],
+      ['mcp', 'get', 'severally'],
+    ],
+  },
+  {
+    label: 'Codex',
+    cmd: 'codex',
+    checks: [
+      ['plugin', 'list'],
+      ['mcp', 'get', 'severally'],
+    ],
+  },
+  { label: 'Antigravity', cmd: 'agy', checks: [['mcp', 'list']] },
+  { label: 'OpenCode', cmd: 'opencode', checks: [['mcp', 'list']] },
+];
+
+// "registered": the client's own listing names severally (it may still be
+// turned off there). "not registered": the client answered, without it.
+// No answer at all (a timeout, a failure to start): unknown.
+function registration({ cmd, checks }) {
+  if (!findCommand(cmd)) return 'not installed';
+  let ran = false;
+  for (const args of checks) {
+    try {
+      const out = execCommandSync(cmd, args, { encoding: 'utf8', timeout: 20_000, stdio: ['ignore', 'pipe', 'pipe'] });
+      ran = true;
+      if (/(^|[\s@:])severally([\s@:]|$)/m.test(out)) return 'registered (listed by the client)';
+    } catch (err) {
+      // It ran and said no (`mcp get` of a missing server exits non-zero); a
+      // timeout or a failure to start says nothing either way.
+      if (typeof err.status === 'number') ran = true;
+    }
+  }
+  return ran ? 'not registered' : `could not tell (${cmd} ${checks.map((a) => a.join(' ')).join(' / ')} failed)`;
+}
+
+// Each CLI's own word on its login, read without sending a prompt. Only the
+// verdict is kept: `claude auth status` also prints the account's email.
+// Antigravity has no such command, so it is not checked.
+const LOGIN = {
+  'claude-code': { cmd: 'claude', args: ['auth', 'status', '--json'], read: (out) => JSON.parse(out).loggedIn === true },
+  // Codex prints its answer on stderr; the exit status carries the verdict.
+  codex: { cmd: 'codex', args: ['login', 'status'], read: (out, ok) => ok },
+  // OpenCode can also take keys from the environment, so no saved credential
+  // is a warning, not a verdict.
+  opencode: {
+    cmd: 'opencode',
+    args: ['auth', 'list'],
+    read: (out) => {
+      const n = out.split('\n').filter((l) => /\bstored\b/.test(l)).length;
+      return n ? `${n} saved credential${n > 1 ? 's' : ''}` : 'no saved credentials (keys in the environment still work)';
+    },
+  },
+};
+
+function login(cli) {
+  const check = LOGIN[cli];
+  if (!check) return 'not checked (no login status command)';
+  if (!findCommand(check.cmd)) return 'not installed';
+  let out;
+  let ok = true;
+  try {
+    out = execCommandSync(check.cmd, check.args, { encoding: 'utf8', timeout: 20_000, stdio: ['ignore', 'pipe', 'pipe'] });
+  } catch (err) {
+    if (typeof err.status !== 'number') return `could not tell (${check.cmd} ${check.args.join(' ')} failed)`;
+    out = `${err.stdout ?? ''}`;
+    ok = false;
+  }
+  try {
+    const v = check.read(out, ok);
+    return v === true ? 'logged in' : v || 'not logged in';
+  } catch {
+    return `could not tell (${check.cmd} ${check.args.join(' ')} answered in an unexpected form)`;
+  }
+}
+
+export function status() {
+  const lines = [`severally ${SEVERALLY_VERSION}`, ''];
+  const problem = configProblem();
+  lines.push(`config: ${problem ? `needs fixing, every consultation is refused until it is -- ${problem}` : 'ok'}`);
+  for (const w of configWarnings()) lines.push(`  mistake (only that consultant or CLI is out of use): ${w}`);
+  lines.push(`network: ${POLICY.network === 'off' ? 'off for every consultation (server.network)' : 'per request'}`, '');
+
+  lines.push('consultants:');
+  for (const c of POLICY.consultants) {
+    lines.push(
+      `  ${c.name}: ${c.cli}, ${c.model}  ${consultantAvailable(c) ? 'available' : `not available: ${unavailableReason(c)}`}`,
+    );
+  }
+  for (const name of brokenConsultantNames()) lines.push(`  ${name}: not available: ${brokenConsultant(name)}`);
+  lines.push('');
+
+  const stale = staleInstall();
+  lines.push(
+    stale
+      ? `copies: ${Object.entries(stale.copies)
+          .map(([k, v]) => `${k} ${v}${stale.behind.includes(k) ? ' (behind)' : ''}`)
+          .join(', ')}\n  ${stale.fix}`
+      : 'copies: every installed copy is this version',
+    '',
+  );
+
+  lines.push('clients:');
+  for (const client of CLIENTS) lines.push(`  ${client.label.padEnd(12)} ${registration(client)}`);
+  lines.push('', 'login (out of quota is not checked; the first consultation shows it):');
+  for (const cli of [...new Set(POLICY.consultants.map((c) => c.cli))]) lines.push(`  ${cli.padEnd(12)} ${login(cli)}`);
+  process.stdout.write(`${lines.join('\n')}\n`);
+  return problem ? 1 : 0;
+}

package/src/store.mjs

@@ -12,7 +12,11 @@ export function ensureDirs() {
   fs.mkdirSync(path.join(home, 'history'), { recursive: true, mode: 0o700 });
   fs.mkdirSync(path.join(home, 'jobs'), { recursive: true, mode: 0o700 });
   fs.mkdirSync(path.join(home, 'homes'), { recursive: true, mode: 0o700 });
-  try { fs.chmodSync(home, 0o700); } catch { /* best effort */ }
+  try {
+    fs.chmodSync(home, 0o700);
+  } catch {
+    /* best effort */
+  }
   return home;
 }
 
@@ -45,7 +49,11 @@ export function writeJobArtifact(jobId, name, content) {
 }
 
 export function readIfExists(p) {
-  try { return fs.readFileSync(p, 'utf8'); } catch { return ''; }
+  try {
+    return fs.readFileSync(p, 'utf8');
+  } catch {
+    return '';
+  }
 }
 
 // A consultation from an earlier server session, found through the index and
@@ -58,11 +66,36 @@ function indexRow(jobId) {
     try {
       const parsed = JSON.parse(line);
       if (parsed.job_id === jobId) return parsed;
-    } catch { /* a damaged line is skipped, not fatal */ }
+    } catch {
+      /* a damaged line is skipped, not fatal */
+    }
   }
   return null;
 }
 
+/** Every row of the history index, in the order written; a damaged line is skipped. */
+export function indexRows() {
+  return readIfExists(path.join(POLICY.home, 'history', 'index.jsonl'))
+    .split('\n')
+    .flatMap((line) => {
+      try {
+        const row = line.trim() ? JSON.parse(line) : null;
+        return row && typeof row === 'object' && JOB_ID.test(row.job_id) ? [row] : [];
+      } catch {
+        return [];
+      }
+    });
+}
+
+/** The round file an index row points at, or null. */
+export function loadRoundAt(row) {
+  try {
+    return JSON.parse(fs.readFileSync(roundPath(row.chain_id, row.round), 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
 export const roundPath = (chainId, round) =>
   path.join(POLICY.home, 'history', chainId, `round-${String(round).padStart(2, '0')}.json`);
 
@@ -77,7 +110,11 @@ export function writeDiagnostics(chainId, round, text) {
 export function loadRound(jobId) {
   const row = indexRow(jobId);
   if (!row) return null;
-  try { return JSON.parse(fs.readFileSync(roundPath(row.chain_id, row.round), 'utf8')); } catch { return null; }
+  try {
+    return JSON.parse(fs.readFileSync(roundPath(row.chain_id, row.round), 'utf8'));
+  } catch {
+    return null;
+  }
 }
 
 // Every round file of one chain, oldest first: a follow-up to a consultation
@@ -85,9 +122,20 @@ export function loadRound(jobId) {
 export function loadChain(chainId) {
   const dir = path.join(POLICY.home, 'history', chainId);
   let names = [];
-  try { names = fs.readdirSync(dir).filter((n) => /^round-\d+\.json$/.test(n)).sort(); } catch { return []; }
+  try {
+    names = fs
+      .readdirSync(dir)
+      .filter((n) => /^round-\d+\.json$/.test(n))
+      .sort();
+  } catch {
+    return [];
+  }
   return names.flatMap((n) => {
-    try { return [JSON.parse(fs.readFileSync(path.join(dir, n), 'utf8'))]; } catch { return []; }
+    try {
+      return [JSON.parse(fs.readFileSync(path.join(dir, n), 'utf8'))];
+    } catch {
+      return [];
+    }
   });
 }
 
@@ -154,18 +202,31 @@ export function writeRunning(record) {
 
 export function loadRunning(jobId) {
   if (!JOB_ID.test(jobId)) return null;
-  try { return JSON.parse(fs.readFileSync(runningFile(jobId), 'utf8')); } catch { return null; }
+  try {
+    return JSON.parse(fs.readFileSync(runningFile(jobId), 'utf8'));
+  } catch {
+    return null;
+  }
 }
 
 export function listRunning() {
   try {
-    return fs.readdirSync(runningDir()).map((n) => n.replace(/\.json$/, '')).filter((id) => JOB_ID.test(id));
-  } catch { return []; }
+    return fs
+      .readdirSync(runningDir())
+      .map((n) => n.replace(/\.json$/, ''))
+      .filter((id) => JOB_ID.test(id));
+  } catch {
+    return [];
+  }
 }
 
 export function removeRunning(jobId) {
   if (!JOB_ID.test(jobId)) return;
-  try { fs.rmSync(runningFile(jobId), { force: true }); } catch { /* best effort */ }
+  try {
+    fs.rmSync(runningFile(jobId), { force: true });
+  } catch {
+    /* best effort */
+  }
 }
 
 // Seats: the concurrency cap is shared by every severally process on one
@@ -183,28 +244,76 @@ function withSeatLock(fn) {
   fs.mkdirSync(seatsDir(), { recursive: true, mode: 0o700 });
   const until = Date.now() + LOCK_WAIT_MS;
   for (;;) {
-    try { fs.mkdirSync(lock); break; } catch (err) {
+    try {
+      fs.mkdirSync(lock);
+      break;
+    } catch (err) {
       if (err.code !== 'EEXIST') throw err;
       // Held for a few file operations at most: one this old was left by a
       // process that died holding it.
-      try { if (Date.now() - fs.statSync(lock).mtimeMs > LOCK_STALE_MS) fs.rmdirSync(lock); } catch { /* gone already */ }
+      try {
+        if (Date.now() - fs.statSync(lock).mtimeMs > LOCK_STALE_MS) fs.rmdirSync(lock);
+      } catch {
+        /* gone already */
+      }
       if (Date.now() > until) throw new Error('the seat lock stayed taken; try again');
       Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 10);
     }
   }
-  try { return fn(); } finally { try { fs.rmdirSync(lock); } catch { /* best effort */ } }
+  try {
+    return fn();
+  } finally {
+    try {
+      fs.rmdirSync(lock);
+    } catch {
+      /* best effort */
+    }
+  }
 }
 
 /** Takes one seat per entry of `seats` ({ job_id, owner }), all or none. */
 export function takeSeats(seats, cap, held) {
   return withSeatLock(() => {
     const live = [];
-    for (const name of fs.readdirSync(seatsDir())) {
+    const names = fs.readdirSync(seatsDir());
+    // A cancel asked for after its consultation ended has no seat left to go with.
+    for (const name of names.filter((n) => n.endsWith('.cancel'))) {
+      if (!names.includes(name.replace(/\.cancel$/, '.json')))
+        try {
+          fs.rmSync(path.join(seatsDir(), name), { force: true });
+        } catch {
+          /* best effort */
+        }
+    }
+    for (const name of names) {
       if (!name.endsWith('.json')) continue;
       let seat = null;
-      try { seat = JSON.parse(fs.readFileSync(path.join(seatsDir(), name), 'utf8')); } catch { /* half-written or damaged: free */ }
+      try {
+        seat = JSON.parse(fs.readFileSync(path.join(seatsDir(), name), 'utf8'));
+      } catch {
+        /* half-written or damaged: free */
+      }
       if (seat && held(seat)) live.push(seat);
-      else try { fs.rmSync(path.join(seatsDir(), name), { force: true }); } catch { /* best effort */ }
+      else
+        try {
+          fs.rmSync(path.join(seatsDir(), name), { force: true });
+        } catch {
+          /* best effort */
+        }
+    }
+    // A chain runs one round at a time, across processes: a live seat on the
+    // same chain, or a round file already at the number chosen, means another
+    // server continued it first.
+    for (const mine of seats.filter((x) => x.chain_id)) {
+      let other = live.find((x) => x.chain_id === mine.chain_id);
+      if (!other && fs.existsSync(roundPath(mine.chain_id, mine.round))) {
+        try {
+          other = { job_id: JSON.parse(fs.readFileSync(roundPath(mine.chain_id, mine.round), 'utf8')).job_id, round: mine.round };
+        } catch {
+          other = { job_id: '(unreadable)', round: mine.round };
+        }
+      }
+      if (other) return { ok: false, chainBusy: { live: other, mine } };
     }
     if (live.length + seats.length > cap) {
       return { ok: false, live: live.length, elsewhere: live.filter((x) => x.owner?.pid !== process.pid).length };
@@ -219,12 +328,44 @@ export function takeSeats(seats, cap, held) {
 
 export function releaseSeat(jobId) {
   if (!JOB_ID.test(jobId)) return;
-  try { fs.rmSync(seatFile(jobId), { force: true }); } catch { /* best effort */ }
+  try {
+    fs.rmSync(seatFile(jobId), { force: true });
+  } catch {
+    /* best effort */
+  }
+  clearCancel(jobId);
+}
+
+// A cancel asked for by a server that does not run the consultation: left
+// beside its seat, for the server that does to find and act on.
+const cancelFile = (jobId) => path.join(seatsDir(), `${jobId}.cancel`);
+export function requestCancel(jobId) {
+  if (!JOB_ID.test(jobId)) return false;
+  try {
+    fs.mkdirSync(seatsDir(), { recursive: true, mode: 0o700 });
+    fs.writeFileSync(cancelFile(jobId), '', { mode: 0o600 });
+    return true;
+  } catch {
+    return false;
+  }
+}
+export const cancelRequested = (jobId) => JOB_ID.test(jobId) && fs.existsSync(cancelFile(jobId));
+export function clearCancel(jobId) {
+  if (JOB_ID.test(jobId))
+    try {
+      fs.rmSync(cancelFile(jobId), { force: true });
+    } catch {
+      /* best effort */
+    }
 }
 
 export function loadGroup(groupId) {
   if (!GROUP_ID.test(groupId)) return null;
-  try { return JSON.parse(fs.readFileSync(path.join(POLICY.home, 'history', 'groups', `${groupId}.json`), 'utf8')); } catch { return null; }
+  try {
+    return JSON.parse(fs.readFileSync(path.join(POLICY.home, 'history', 'groups', `${groupId}.json`), 'utf8'));
+  } catch {
+    return null;
+  }
 }
 
 // A fan-out is recorded as its own record so a later reader can tell which
@@ -238,6 +379,10 @@ export function persistGroup(group) {
 
 export function cleanupJobDir(jobId) {
   for (const dir of [jobDir(jobId), sandboxHome(jobId)]) {
-    try { fs.rmSync(dir, { recursive: true, force: true }); } catch { /* best effort */ }
+    try {
+      fs.rmSync(dir, { recursive: true, force: true });
+    } catch {
+      /* best effort */
+    }
   }
 }