shakers-cli-beta 0.8.0-beta.0

package/src/mcp-auth-form.js

@@ -0,0 +1,282 @@
+'use strict';
+
+const http = require('http');
+const { openPath } = require('./open-file');
+const flow = require('./onboarding-flow');
+const { methodIdsForFlow } = require('./auth-methods');
+const { INTER_FONT_FACE_CSS } = require('./inter-fonts');
+const { SHAKERS_MARK_WHITE_SVG, SHAKERS_WORDMARK_SVG } = require('./brand-svg');
+
+const DEFAULT_TIMEOUT_MS = 180000;
+const MAX_BODY_BYTES = 64 * 1024;
+
+function esc(s) {
+  return String(s == null ? '' : s).replace(/[&<>"']/g, (ch) => ({ '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&#39;' }[ch]));
+}
+
+const FONT_STACK = '"Inter", ui-sans-serif, system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, "Helvetica Neue", Arial, sans-serif';
+
+const COPY = {
+  en: {
+    signin: 'Sign in', create: 'Create account', welcome: 'Welcome to Shakers — create your talent account to get started.',
+    email: 'Email', password: 'Password', repeat: 'Repeat password', first: 'First name', last: 'Last name',
+    lang: 'Language', newsletter: 'Receive the newsletter', how: 'How do you work?', intent: 'Freelance intent',
+    hint: 'Your password stays on this machine. It is never sent to the chat.', mismatch: 'Passwords do not match.',
+    done: 'You are signed in.', doneSub: 'You can close this tab and return to your AI app.',
+    chooseTitleLogin: 'How do you want to sign in?', chooseTitleRegister: 'How do you want to create your account?',
+    continueGoogle: 'Continue with Google', continueEmail: 'Email and password', continueEmailRegister: 'Continue with email',
+    googleOpening: 'Opening Google sign-in…', googleOpeningSub: 'A Google window is opening. You can return to your AI app; it will confirm once you finish.',
+  },
+  es: {
+    signin: 'Iniciar sesión', create: 'Crear cuenta', welcome: 'Bienvenido a Shakers — crea tu cuenta de talento para empezar.',
+    email: 'Email', password: 'Contraseña', repeat: 'Repite la contraseña', first: 'Nombre', last: 'Apellidos',
+    lang: 'Idioma', newsletter: 'Recibir la newsletter', how: '¿Cómo trabajas?', intent: 'Intención freelance',
+    hint: 'Tu contraseña se queda en este equipo. Nunca se envía al chat.', mismatch: 'Las contraseñas no coinciden.',
+    done: 'Sesión iniciada.', doneSub: 'Puedes cerrar esta pestaña y volver a tu app de IA.',
+    chooseTitleLogin: '¿Cómo quieres iniciar sesión?', chooseTitleRegister: '¿Cómo quieres crear tu cuenta?',
+    continueGoogle: 'Continuar con Google', continueEmail: 'Email y contraseña', continueEmailRegister: 'Continuar con email',
+    googleOpening: 'Abriendo el acceso con Google…', googleOpeningSub: 'Se está abriendo una ventana de Google. Puedes volver a tu app de IA; te confirmará cuando termines.',
+  },
+};
+
+function copy(lang) {
+  return COPY[String(lang || 'en').toLowerCase()] || COPY.en;
+}
+
+function header() {
+  return `<div class="brand"><span class="appicon">${SHAKERS_MARK_WHITE_SVG}</span><span class="badge">MCP</span></div>`;
+}
+
+function panel(text) {
+  return `<div class="panel"><div class="pbrand">${SHAKERS_MARK_WHITE_SVG}${SHAKERS_WORDMARK_SVG}</div><p>${text}</p></div>`;
+}
+
+function styles() {
+  return `<style>${INTER_FONT_FACE_CSS}`
+    + `:root{--background:#ffffff;--foreground:#18181b;--primary:#05342c;--primary-foreground:#fafafa;`
+    + `--secondary:#e2f2f0;--secondary-foreground:#0b5a4c;--muted-foreground:#3f3f46;--accent:#e2f2f0;--accent-foreground:#08473c;`
+    + `--input:#d4d4d8;--border:#e4e4e7;--ring:#0e7d69;--destructive:#e11d48;--radius:0.625rem;--radius-md:calc(var(--radius) - 2px);`
+    + `--shadow-xs:0 1px 2px 0 rgb(0 0 0 / .05)}`
+    + `*{box-sizing:border-box}`
+    + `body{font-family:${FONT_STACK};margin:0;min-height:100vh;display:flex;align-items:center;justify-content:center;background:#fafafa;color:var(--foreground);padding:1.5rem;-webkit-font-smoothing:antialiased;text-rendering:optimizeLegibility}`
+    + `.card{width:100%;max-width:26rem;background:var(--background);border:1px solid var(--border);border-radius:var(--radius);box-shadow:0 10px 30px rgb(3 33 28 / .08);overflow:hidden}`
+    + `.body{padding:2rem}`
+    + `.brand{display:flex;align-items:center;gap:.6rem;margin:0 0 1.25rem}`
+    + `.appicon{display:inline-flex;align-items:center;justify-content:center;width:2.5rem;height:2.5rem;border-radius:.7rem;background:var(--primary);flex:0 0 auto}`
+    + `.appicon .mk{height:1.35rem;width:auto;display:block}`
+    + `.badge{margin-left:auto;font-size:.7rem;font-weight:600;letter-spacing:.04em;text-transform:uppercase;color:var(--secondary-foreground);background:var(--secondary);border-radius:999px;padding:.2rem .6rem}`
+    + `.panel{background:var(--primary);color:var(--primary-foreground);padding:1.75rem 2rem}`
+    + `.pbrand{display:flex;align-items:center;gap:.7rem;margin:0 0 .75rem}`
+    + `.pbrand .mk{height:1.5rem;width:auto;display:block}`
+    + `.pbrand .wm{height:1.05rem;width:auto;display:block;color:var(--primary-foreground)}`
+    + `.panel p{margin:0;font-size:.9rem;color:#cfe6e2;line-height:1.45}`
+    + `h1{font-size:1.15rem;font-weight:600;color:var(--foreground);margin:0 0 1rem;letter-spacing:-.01em}`
+    + `label{display:block;margin:.85rem 0 .35rem;font-size:.875rem;font-weight:500;color:var(--foreground);line-height:1}`
+    + `label.chk{display:flex;align-items:center;gap:.5rem;font-weight:400}`
+    + `input,select{height:2.25rem;width:100%;min-width:0;padding:.25rem .75rem;border:1px solid var(--input);border-radius:var(--radius-md);font-size:.875rem;font-family:inherit;line-height:1.25rem;color:var(--foreground);background:var(--background);box-shadow:var(--shadow-xs);outline:none;transition:color .15s,box-shadow .15s,border-color .15s}`
+    + `input::placeholder{color:var(--muted-foreground)}`
+    + `input:focus-visible,select:focus-visible{border-color:var(--ring);box-shadow:0 0 0 3px color-mix(in oklab,var(--ring) 50%,transparent)}`
+    + `input[type=checkbox]{height:auto;width:auto;box-shadow:none;accent-color:var(--primary)}`
+    + `button{margin-top:1.4rem;display:inline-flex;align-items:center;justify-content:center;gap:.5rem;width:100%;height:2.25rem;padding:.5rem 1rem;border:1px solid var(--primary);border-radius:var(--radius-md);background:var(--primary);color:var(--primary-foreground);font-size:.875rem;font-weight:500;font-family:inherit;cursor:pointer;transition:background .15s,box-shadow .15s}`
+    + `button:hover{background:color-mix(in oklab,var(--primary) 90%,transparent)}`
+    + `button:focus-visible{outline:none;box-shadow:0 0 0 3px color-mix(in oklab,var(--ring) 50%,transparent)}`
+    + `button:disabled{opacity:.5;pointer-events:none}`
+    + `.err{background:color-mix(in oklab,var(--destructive) 12%,transparent);color:var(--destructive);padding:.6rem .7rem;border-radius:var(--radius-md);margin:0 0 .75rem;font-size:.875rem}`
+    + `.hint{color:var(--muted-foreground);font-size:.8rem;margin:.9rem 0 0;line-height:1.45}`
+    + `.actions{display:flex;flex-direction:column;gap:.6rem;margin-top:1.25rem}`
+    + `.mbtn{display:inline-flex;align-items:center;justify-content:center;gap:.6rem;width:100%;height:2.5rem;padding:.5rem 1rem;border-radius:var(--radius-md);font-size:.9rem;font-weight:500;font-family:inherit;text-decoration:none;cursor:pointer;border:1px solid transparent;transition:background .15s,border-color .15s,box-shadow .15s}`
+    + `.mbtn:focus-visible{outline:none;box-shadow:0 0 0 3px color-mix(in oklab,var(--ring) 50%,transparent)}`
+    + `.mbtn.primary{background:var(--primary);color:var(--primary-foreground);border-color:var(--primary)}`
+    + `.mbtn.primary:hover{background:color-mix(in oklab,var(--primary) 90%,transparent)}`
+    + `.mbtn.secondary{background:var(--background);color:var(--foreground);border-color:var(--border);box-shadow:var(--shadow-xs)}`
+    + `.mbtn.secondary:hover{background:var(--accent);color:var(--accent-foreground)}`
+    + `.mbtn .g{width:18px;height:18px;flex:0 0 auto}</style>`;
+}
+
+function page(title, { banner = '', inner = '' } = {}) {
+  return `<!doctype html><html><head><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1"><title>${esc(title)}</title>`
+    + `${styles()}</head><body><main class="card">${banner}<div class="body">${header()}${inner}</div></main></body></html>`;
+}
+
+function errorBanner(reason) {
+  return reason ? `<div class="err">${esc(reason)}</div>` : '';
+}
+
+function loginFormHtml(lang, { error } = {}) {
+  const c = copy(lang);
+  return page(`Shakers — ${c.signin}`, {
+    inner: `<h1>${c.signin}</h1>${errorBanner(error)}`
+      + `<form method="post" action="/submit">`
+      + `<label>${c.email}</label><input name="email" type="email" required autofocus>`
+      + `<label>${c.password}</label><input name="password" type="password" required>`
+      + `<button type="submit">${c.signin}</button>`
+      + `<p class="hint">${c.hint}</p>`
+      + `</form>`,
+  });
+}
+
+function registerFormHtml(lang, { error } = {}) {
+  const c = copy(lang);
+  return page(`Shakers — ${c.create}`, {
+    banner: panel(c.welcome),
+    inner: `<h1>${c.create}</h1>${errorBanner(error)}`
+      + `<form method="post" action="/submit">`
+      + `<label>${c.password}</label><input name="password" type="password" required minlength="8" autofocus>`
+      + `<label>${c.repeat}</label><input name="passwordConfirm" type="password" required minlength="8">`
+      + `<button type="submit">${c.create}</button>`
+      + `<p class="hint">${c.hint}</p>`
+      + `</form>`
+      + `<script>(function(){document.forms[0].addEventListener('submit',function(e){var f=this;if(f.password.value!==f.passwordConfirm.value){e.preventDefault();alert(${JSON.stringify(c.mismatch)});}});})();</script>`,
+  });
+}
+
+function formHtml(mode, lang, opts) {
+  return mode === 'register' ? registerFormHtml(lang, opts) : loginFormHtml(lang, opts);
+}
+
+const GOOGLE_G = '<svg class="g" viewBox="0 0 48 48" aria-hidden="true">'
+  + '<path fill="#EA4335" d="M24 9.5c3.5 0 6.6 1.2 9 3.6l6.7-6.7C35.6 2.6 30.2 0 24 0 14.6 0 6.5 5.4 2.6 13.2l7.8 6.1C12.2 13.3 17.6 9.5 24 9.5z"/>'
+  + '<path fill="#4285F4" d="M46.5 24.5c0-1.6-.1-3.1-.4-4.5H24v9h12.6c-.5 3-2.2 5.5-4.7 7.2l7.3 5.7c4.3-4 6.3-9.8 6.3-17.4z"/>'
+  + '<path fill="#FBBC05" d="M10.4 28.3c-.5-1.5-.8-3.1-.8-4.8s.3-3.3.8-4.8l-7.8-6.1C.9 15.9 0 19.8 0 23.5s.9 7.6 2.6 10.9l7.8-6.1z"/>'
+  + '<path fill="#34A853" d="M24 47c6.5 0 11.9-2.1 15.9-5.8l-7.3-5.7c-2 1.4-4.7 2.3-8.6 2.3-6.4 0-11.8-3.8-13.6-9.8l-7.8 6.1C6.5 41.6 14.6 47 24 47z"/></svg>';
+
+// The method-choice screen (talents-ai-score) — the FIRST screen of the loopback form when more than one method is offered for this flow.
+function methodChoiceHtml(mode, lang, methods) {
+  const c = copy(lang);
+  const title = mode === 'register' ? c.chooseTitleRegister : c.chooseTitleLogin;
+  const emailLabel = mode === 'register' ? c.continueEmailRegister : c.continueEmail;
+  const buttons = methods.map((id) => (id === 'google'
+    ? `<a class="mbtn primary" href="/google">${GOOGLE_G}${c.continueGoogle}</a>`
+    : `<a class="mbtn secondary" href="/email">${emailLabel}</a>`)).join('');
+  return page(`Shakers — ${title}`, {
+    inner: `<h1>${title}</h1><div class="actions">${buttons}</div><p class="hint">${c.hint}</p>`,
+  });
+}
+
+function googleHandoffHtml(lang) {
+  const c = copy(lang);
+  return page('Shakers', { inner: `<h1>${c.googleOpening}</h1><p>${c.googleOpeningSub}</p>` });
+}
+
+function successHtml(lang) {
+  const c = copy(lang);
+  return page('Shakers', { inner: `<h1>${c.done}</h1><p>${c.doneSub}</p>` });
+}
+
+function parseBody(req) {
+  return new Promise((resolve) => {
+    let raw = '';
+    let aborted = false;
+    req.on('data', (chunk) => {
+      raw += chunk;
+      if (raw.length > MAX_BODY_BYTES) { aborted = true; req.destroy(); }
+    });
+    req.on('end', () => {
+      if (aborted) return resolve({});
+      const params = new URLSearchParams(raw);
+      const out = {};
+      for (const [k, v] of params) out[k] = v;
+      resolve(out);
+    });
+    req.on('error', () => resolve({}));
+  });
+}
+
+async function doAuth(mode, body, deps, lang, registerFields = {}) {
+  const password = typeof body.password === 'string' ? body.password : '';
+
+  if (mode === 'register') {
+    if (!password) return { ok: false, reason: 'missing-fields' };
+    if (password !== (body.passwordConfirm || '')) return { ok: false, reason: 'password-mismatch' };
+    const email = typeof registerFields.email === 'string' ? registerFields.email.trim() : '';
+    const su = await flow.signUp(deps, {
+      name: registerFields.name,
+      lastName: registerFields.lastName,
+      email,
+      password,
+      preferredLanguage: registerFields.preferredLanguage || lang,
+      newsletterConsent: registerFields.newsletterConsent === true,
+      freelanceType: registerFields.freelanceType,
+      freelanceIntent: registerFields.freelanceIntent,
+    });
+    if (!su.ok) return { ok: false, reason: su.message || su.reason };
+    const sess = await flow.establishSessionFromCredentials(deps, { email, password });
+    return sess.ok ? { ok: true, email, accountExists: su.accountExists === true } : { ok: false, reason: sess.reason };
+  }
+
+  const email = typeof body.email === 'string' ? body.email.trim() : '';
+  if (!email || !password) return { ok: false, reason: 'missing-fields' };
+  const sess = await flow.establishSessionFromCredentials(deps, { email, password });
+  return sess.ok ? { ok: true, email } : { ok: false, reason: sess.reason };
+}
+
+function runLoopbackAuth(
+  { mode = 'login', deps = null, lang = 'en', method = null, registerFields = null } = {},
+  { openBrowser = openPath, timeoutMs = DEFAULT_TIMEOUT_MS, onUrl = null } = {},
+) {
+  const resolvedDeps = deps || flow.makeDeps();
+  const methods = methodIdsForFlow(mode);
+  const showMethodScreen = !method && methods.length > 1;
+  return new Promise((resolve) => {
+    let settled = false;
+    const finish = (result) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      try { server.close(); } catch { /* already closing */ }
+      resolve(result);
+    };
+
+    const server = http.createServer(async (req, res) => {
+      let url;
+      try {
+        url = new URL(req.url, 'http://127.0.0.1');
+      } catch {
+        res.writeHead(400).end();
+        return;
+      }
+      if (req.method === 'GET' && (url.pathname === '/' || url.pathname === '')) {
+        res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' });
+        res.end(showMethodScreen ? methodChoiceHtml(mode, lang, methods) : formHtml(mode, lang));
+        return;
+      }
+      if (req.method === 'GET' && url.pathname === '/email') {
+        res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' });
+        res.end(formHtml(mode, lang));
+        return;
+      }
+      if (req.method === 'GET' && url.pathname === '/google' && methods.includes('google')) {
+        res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' });
+        res.end(googleHandoffHtml(lang));
+        finish({ ok: true, viaGoogle: true });
+        return;
+      }
+      if (req.method === 'POST' && url.pathname === '/submit') {
+        const body = await parseBody(req);
+        const outcome = await doAuth(mode, body, resolvedDeps, lang, registerFields || {});
+        if (outcome.ok) {
+          res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' });
+          res.end(successHtml(lang));
+          finish(outcome);
+        } else {
+          res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' });
+          res.end(formHtml(mode, lang, { error: outcome.reason }));
+        }
+        return;
+      }
+      res.writeHead(404).end();
+    });
+
+    const timer = setTimeout(() => finish({ ok: false, reason: 'browser-timeout' }), timeoutMs);
+    if (timer.unref) timer.unref();
+    server.on('error', () => finish({ ok: false, reason: 'local-error' }));
+    server.listen(0, '127.0.0.1', () => {
+      const { port } = server.address();
+      const formUrl = `http://127.0.0.1:${port}/`;
+      if (typeof onUrl === 'function') onUrl(formUrl);
+      try { openBrowser(formUrl); } catch { /* headless: the onUrl fallback covers it */ }
+    });
+  });
+}
+
+module.exports = { runLoopbackAuth, doAuth, loginFormHtml, registerFormHtml, methodChoiceHtml, googleHandoffHtml, DEFAULT_TIMEOUT_MS };

package/src/mcp-availability-tools.js

@@ -0,0 +1,43 @@
+'use strict';
+
+// MCP: view the talent's availability. Read-only (no set tool — an AI agent
+// must not write the talent's availability).
+
+const GET_AVAILABILITY_SCHEMA = { type: 'object', properties: {} };
+
+function makeAvailabilityTools(deps = {}) {
+  const {
+    fetchAvailability = (opts) => require('./availability-client').fetchAvailability({}, opts),
+    loadAuthSession = require('./auth-session-store').loadAuthSession,
+    sessionStatus = require('./auth-session-store').sessionStatus,
+  } = deps;
+
+  const requireLoginSession = () => {
+    const session = loadAuthSession();
+    if (sessionStatus(session) !== 'active') {
+      throw new Error('no active Shakers session — call the login tool (or run `shakers login`) first (get_availability is session-gated).');
+    }
+    return session;
+  };
+
+  async function getAvailability() {
+    const session = requireLoginSession();
+    const res = await fetchAvailability({ hubAccessToken: session.hubAccessToken });
+    if (!res.ok) return { ok: false, reason: res.reason };
+    return { ok: true, availability: res.availability };
+  }
+
+  return [
+    {
+      name: 'get_availability',
+      description: "View the talent's availability: open-to-work, monthly hours, remote-only, and location. Read-only. Requires an active session. Any internal ids in the result (e.g. numeric city id) are handles for tools only — never show or mention them to the talent.",
+      inputSchema: GET_AVAILABILITY_SCHEMA,
+      handler: getAvailability,
+    },
+  ];
+}
+
+module.exports = {
+  makeAvailabilityTools,
+  GET_AVAILABILITY_SCHEMA,
+};

package/src/mcp-certifications-tools.js

@@ -0,0 +1,42 @@
+'use strict';
+
+// MCP: the talent's dimension certifications (by role).
+
+const LIST_CERTIFICATIONS_SCHEMA = { type: 'object', properties: {} };
+
+function makeCertificationsTools(deps = {}) {
+  const {
+    fetchMeCertifications = (opts) => require('./certifications-client').fetchMeCertifications({}, opts),
+    loadAuthSession = require('./auth-session-store').loadAuthSession,
+    sessionStatus = require('./auth-session-store').sessionStatus,
+  } = deps;
+
+  const requireLoginSession = () => {
+    const session = loadAuthSession();
+    if (sessionStatus(session) !== 'active') {
+      throw new Error('no active Shakers session — call the login tool (or run `shakers login`) first (list_certifications is session-gated).');
+    }
+    return session;
+  };
+
+  async function listCertifications() {
+    const session = requireLoginSession();
+    const res = await fetchMeCertifications({ hubAccessToken: session.hubAccessToken });
+    if (!res.ok) return { ok: false, reason: res.reason };
+    return { ok: true, mainRole: res.mainRole, growingInto: res.growingInto, dimensions: res.dimensions };
+  }
+
+  return [
+    {
+      name: 'list_certifications',
+      description: "List the talent's role dimensions with their certification state (CERTIFIED/UNCERTIFIED/EXPIRED), band and main role. Requires an active session. Any dimension/cluster ids in the result are INTERNAL handles for calling tools — never show or mention them to the talent; refer to a dimension by its name.",
+      inputSchema: LIST_CERTIFICATIONS_SCHEMA,
+      handler: listCertifications,
+    },
+  ];
+}
+
+module.exports = {
+  makeCertificationsTools,
+  LIST_CERTIFICATIONS_SCHEMA,
+};

package/src/mcp-certify-dimension-tools.js

@@ -0,0 +1,58 @@
+'use strict';
+
+// MCP: list the offerable dimensions (the interview itself runs over LiveKit in the CLI).
+
+const LIST_CERTIFIABLE_DIMENSIONS_SCHEMA = {
+  type: 'object',
+  properties: {},
+};
+
+function makeCertifyDimensionTools(deps = {}) {
+  const {
+    discoverOfferableDimensions = (opts) => require('./certify-dimension-client').discoverOfferableDimensions({}, opts),
+    loadAuthSession = require('./auth-session-store').loadAuthSession,
+    sessionStatus = require('./auth-session-store').sessionStatus,
+  } = deps;
+
+  const requireLoginSession = () => {
+    const session = loadAuthSession();
+    if (sessionStatus(session) !== 'active') {
+      throw new Error('no active Shakers session — call the login tool (or run `shakers login`) first (certification is session-gated).');
+    }
+    return session;
+  };
+
+  async function listCertifiableDimensions() {
+    const session = requireLoginSession();
+    const res = await discoverOfferableDimensions({
+      accessToken: session.accessToken,
+      hubAccessToken: session.hubAccessToken,
+    });
+    if (!res.ok) return { ok: false, reason: res.reason };
+    return {
+      ok: true,
+      mainRole: res.mainRole || null,
+      dimensions: (res.offerable || []).map((d) => ({
+        dimensionKey: d.dimensionKey,
+        slug: d.slug,
+        clusterId: d.clusterId,
+        state: d.state,
+        band: d.band || null,
+      })),
+    };
+  }
+
+  return [
+    {
+      name: 'list_certifiable_dimensions',
+      description: "List the dimensions the talent can certify by CLI right now: their main role's hub dimensions whose interview runs by text (terminal or spoken-case templates) and not already CERTIFIED (UNCERTIFIED/EXPIRED). Requires an active session. The certification interview itself runs over LiveKit via `shakers certify` in the terminal. The dimensionKey/clusterId in each item are INTERNAL handles for tools only — never show or mention them to the talent; refer to a dimension by its name.",
+      inputSchema: LIST_CERTIFIABLE_DIMENSIONS_SCHEMA,
+      handler: listCertifiableDimensions,
+    },
+  ];
+}
+
+module.exports = {
+  makeCertifyDimensionTools,
+  LIST_CERTIFIABLE_DIMENSIONS_SCHEMA,
+};

package/src/mcp-detector.js

@@ -0,0 +1,223 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { getHomeDir } = require('./env-paths');
+
+// KEYWORD -> { SERVICE LABEL, CATEGORY } (issue 110).
+const SERVICE_CATALOG = [
+  // --- data ---
+  { kw: 'postgresql', label: 'Postgres', category: 'data' },
+  { kw: 'postgres', label: 'Postgres', category: 'data' },
+  { kw: 'mysql', label: 'MySQL', category: 'data' },
+  { kw: 'sqlite', label: 'SQLite', category: 'data' },
+  { kw: 'mongo', label: 'MongoDB', category: 'data' },
+  { kw: 'redis', label: 'Redis', category: 'data' },
+  { kw: 'snowflake', label: 'Snowflake', category: 'data' },
+  { kw: 'bigquery', label: 'BigQuery', category: 'data' },
+  { kw: 'clickhouse', label: 'ClickHouse', category: 'data' },
+  { kw: 'dynamodb', label: 'DynamoDB', category: 'data' },
+  { kw: 'elastic', label: 'Elasticsearch', category: 'data' },
+  { kw: 'supabase', label: 'Supabase', category: 'data' },
+  { kw: 'airtable', label: 'Airtable', category: 'data' },
+  { kw: 'notion', label: 'Notion', category: 'data' },
+  { kw: 'looker', label: 'Looker', category: 'data' },
+  { kw: 'attio', label: 'Attio', category: 'data' },
+  { kw: 'sheet', label: 'Google Sheets', category: 'data' },
+  { kw: 'drive', label: 'Google Drive', category: 'data' },
+  { kw: 'database', label: null, category: 'data' },
+  // --- comms ---
+  { kw: 'slack', label: 'Slack', category: 'comms' },
+  { kw: 'discord', label: 'Discord', category: 'comms' },
+  { kw: 'gmail', label: 'Gmail', category: 'comms' },
+  { kw: 'teams', label: 'Microsoft Teams', category: 'comms' },
+  { kw: 'telegram', label: 'Telegram', category: 'comms' },
+  { kw: 'whatsapp', label: 'WhatsApp', category: 'comms' },
+  { kw: 'twilio', label: 'Twilio', category: 'comms' },
+  { kw: 'zoom', label: 'Zoom', category: 'comms' },
+  { kw: 'email', label: null, category: 'comms' },
+  { kw: 'mail', label: null, category: 'comms' },
+  { kw: 'sms', label: null, category: 'comms' },
+  // --- dev ---
+  { kw: 'github', label: 'GitHub', category: 'dev' },
+  { kw: 'gitlab', label: 'GitLab', category: 'dev' },
+  { kw: 'bitbucket', label: 'Bitbucket', category: 'dev' },
+  { kw: 'kubernetes', label: 'Kubernetes', category: 'dev' },
+  { kw: 'k8s', label: 'Kubernetes', category: 'dev' },
+  { kw: 'docker', label: 'Docker', category: 'dev' },
+  { kw: 'sentry', label: 'Sentry', category: 'dev' },
+  { kw: 'linear', label: 'Linear', category: 'dev' },
+  { kw: 'jira', label: 'Jira', category: 'dev' },
+  { kw: 'confluence', label: 'Confluence', category: 'dev' },
+  { kw: 'figma', label: 'Figma', category: 'dev' },
+  { kw: 'terraform', label: 'Terraform', category: 'dev' },
+  { kw: 'cloudflare', label: 'Cloudflare', category: 'dev' },
+  { kw: 'vercel', label: 'Vercel', category: 'dev' },
+  { kw: 'netlify', label: 'Netlify', category: 'dev' },
+  { kw: 'railway', label: 'Railway', category: 'dev' },
+  { kw: 'context7', label: 'Context7', category: 'dev' },
+  { kw: 'aws', label: 'AWS', category: 'dev' },
+  { kw: 'filesystem', label: 'Filesystem', category: 'dev' },
+  { kw: 'git', label: null, category: 'dev' },
+  // --- browser ---
+  { kw: 'playwright', label: 'Playwright', category: 'browser' },
+  { kw: 'puppeteer', label: 'Puppeteer', category: 'browser' },
+  { kw: 'browserbase', label: 'Browserbase', category: 'browser' },
+  { kw: 'browser-use', label: 'Browser Use', category: 'browser' },
+  { kw: 'stagehand', label: 'Stagehand', category: 'browser' },
+  { kw: 'chromium', label: 'Chromium', category: 'browser' },
+  { kw: 'chrome', label: 'Chrome', category: 'browser' },
+  { kw: 'browser', label: null, category: 'browser' },
+];
+
+// ORDER IS BEHAVIOUR, and it is preserved from the previous table on purpose.
+function matchService(name) {
+  const lower = String(name).toLowerCase();
+  return SERVICE_CATALOG.find((entry) => lower.includes(entry.kw)) || null;
+}
+
+function categorizeMcpServerName(name) {
+  const hit = matchService(name);
+  return hit ? hit.category : 'other';
+}
+
+// The product behind a server name, or `null` when the name does not carry one.
+function serviceForMcpServerName(name) {
+  const hit = matchService(name);
+  return hit && hit.label ? hit.label : null;
+}
+
+// THE single inventory of MCP config locations (issue 112).
+const MCP_CONFIG_LOCATIONS = [
+  // --- Claude Code (already read before 112) ---
+  { tool: 'claude-code', scope: 'project', keys: ['mcpServers'], confidence: 'high', file: (root) => path.join(root, '.mcp.json') },
+  { tool: 'claude-code', scope: 'home', keys: ['mcpServers'], confidence: 'high', file: (root, home) => path.join(home, '.claude.json') },
+  // --- Cursor: the project one was read, the GLOBAL one was the bug ---
+  { tool: 'cursor', scope: 'project', keys: ['mcpServers'], confidence: 'high', file: (root) => path.join(root, '.cursor', 'mcp.json') },
+  { tool: 'cursor', scope: 'home', keys: ['mcpServers'], confidence: 'high', file: (root, home) => path.join(home, '.cursor', 'mcp.json') },
+  // --- Windsurf (home only; no project-level MCP config known) ---
+  { tool: 'windsurf', scope: 'home', keys: ['mcpServers'], confidence: 'medium', file: (root, home) => path.join(home, '.codeium', 'windsurf', 'mcp_config.json') },
+  // --- Gemini CLI: home was read; the project-level settings file was not ---
+  { tool: 'gemini-cli', scope: 'home', keys: ['mcpServers'], confidence: 'medium', file: (root, home) => path.join(home, '.gemini', 'settings.json') },
+  { tool: 'gemini-cli', scope: 'project', keys: ['mcpServers'], confidence: 'medium', file: (root) => path.join(root, '.gemini', 'settings.json') },
+  // VS Code: `servers`, not `mcpServers`, and three OS-specific user paths.
+  { tool: null, scope: 'project', keys: ['servers', 'mcpServers'], confidence: 'medium', file: (root) => path.join(root, '.vscode', 'mcp.json') },
+  { tool: null, scope: 'home', keys: ['servers', 'mcpServers'], confidence: 'medium', file: (root, home) => path.join(home, 'Library', 'Application Support', 'Code', 'User', 'mcp.json') },
+  { tool: null, scope: 'home', keys: ['servers', 'mcpServers'], confidence: 'medium', file: (root, home) => path.join(home, '.config', 'Code', 'User', 'mcp.json') },
+  { tool: null, scope: 'home', keys: ['servers', 'mcpServers'], confidence: 'medium', file: (root, home) => path.join(home, 'AppData', 'Roaming', 'Code', 'User', 'mcp.json') },
+  // --- Claude Desktop: same `mcpServers` shape, three OS-specific paths ---
+  { tool: null, scope: 'home', keys: ['mcpServers'], confidence: 'medium', file: (root, home) => path.join(home, 'Library', 'Application Support', 'Claude', 'claude_desktop_config.json') },
+  { tool: null, scope: 'home', keys: ['mcpServers'], confidence: 'medium', file: (root, home) => path.join(home, '.config', 'Claude', 'claude_desktop_config.json') },
+  { tool: null, scope: 'home', keys: ['mcpServers'], confidence: 'medium', file: (root, home) => path.join(home, 'AppData', 'Roaming', 'Claude', 'claude_desktop_config.json') },
+];
+
+// Reads ONLY the top-level keys of the server map from one config file, trying
+// each declared key in order. Never reads or returns any value under those keys.
+function readMcpServerNames(file, keys = ['mcpServers']) {
+  let raw;
+  try {
+    raw = fs.readFileSync(file, 'utf8');
+  } catch {
+    return [];
+  }
+  let obj;
+  try {
+    obj = JSON.parse(raw);
+  } catch {
+    return [];
+  }
+  if (!obj || typeof obj !== 'object') return [];
+  for (const key of keys) {
+    const servers = obj[key];
+    if (servers && typeof servers === 'object' && !Array.isArray(servers)) return Object.keys(servers);
+  }
+  return [];
+}
+
+// Deterministic (no-LLM) MCP-by-name detection over every location in `MCP_CONFIG_LOCATIONS` (project ∪ home).
+function detectMcpServers(root) {
+  const home = getHomeDir();
+  // name -> { scopes:Set, tools:Set }
+  const found = new Map();
+  const byTool = {};
+
+  for (const loc of MCP_CONFIG_LOCATIONS) {
+    let file;
+    try {
+      file = loc.file(root, home);
+    } catch {
+      continue; // an unresolvable home never breaks the other locations
+    }
+    const names = readMcpServerNames(file, loc.keys);
+    if (loc.tool && names.length) {
+      // Per-tool count is the union across THAT tool's own locations, so a
+      // server configured both in the project and globally counts once for it.
+      const set = byTool[`__set_${loc.tool}`] || (byTool[`__set_${loc.tool}`] = new Set());
+      for (const n of names) set.add(n);
+    }
+    for (const name of names) {
+      const entry = found.get(name) || { scopes: new Set(), tools: new Set() };
+      entry.scopes.add(loc.scope);
+      if (loc.tool) entry.tools.add(loc.tool);
+      found.set(name, entry);
+    }
+  }
+
+  // Collapse the per-tool sets into plain counts (and drop the working keys).
+  for (const key of Object.keys(byTool)) {
+    if (key.startsWith('__set_')) {
+      byTool[key.slice('__set_'.length)] = byTool[key].size;
+      delete byTool[key];
+    }
+  }
+
+  const servers = [...found.keys()]
+    .sort()
+    .map((name) => {
+      const entry = found.get(name);
+      return {
+        name,
+        category: categorizeMcpServerName(name),
+        // 'project' wins when a server is declared in both: the most specific
+        // scope is the honest label for "this repo uses it".
+        scope: entry.scopes.has('project') ? 'project' : 'home',
+        // Issue 110: the PRODUCT, derived from the name only. `null` when the
+        // name carries none — a state, not a hole.
+        service: serviceForMcpServerName(name),
+      };
+    });
+
+  return buildMcpAggregate(servers, byTool);
+}
+
+// Builds the report's `mcp` block from an already-resolved server list + the per-tool counts.
+function buildMcpAggregate(servers, byTool = {}) {
+  const sorted = [...servers].sort((a, b) => (a.name < b.name ? -1 : a.name > b.name ? 1 : 0));
+
+  const countsByCategory = { data: 0, comms: 0, dev: 0, browser: 0, other: 0 };
+  for (const s of sorted) countsByCategory[s.category] += 1;
+
+  const byService = new Map();
+  let unidentified = 0;
+  for (const s of sorted) {
+    if (!s.service) {
+      unidentified += 1;
+      continue;
+    }
+    byService.set(s.service, (byService.get(s.service) || 0) + 1);
+  }
+  const services = [...byService.entries()]
+    .sort((a, b) => a[0].localeCompare(b[0]))
+    .map(([label, count]) => ({ label, count }));
+
+  return { servers: sorted, services, unidentified, countsByCategory, total: sorted.length, byTool };
+}
+
+module.exports = {
+  detectMcpServers,
+  buildMcpAggregate,
+  categorizeMcpServerName,
+  serviceForMcpServerName,
+  MCP_CONFIG_LOCATIONS,
+  SERVICE_CATALOG,
+};