@oddessentials/agent-guild 1.21.2 → 1.22.0

package/bin/agent-guild.mjs

@@ -360,6 +360,8 @@ async function main() {
     }
     case 'mcp': {
       // stdout carries only protocol messages from here on.
+      const home = args.find((a) => a.startsWith('--home='))?.slice('--home='.length);
+      if (home) process.env.AGENT_GUILD_HOME = home;
       const { serveMcp } = await import('../src/mcp/server.mjs');
       await serveMcp({ allowInput: flags.has('--allow-input') });
       return undefined;

package/config/providers.default.json

@@ -12,6 +12,7 @@
       "memory": "claude",
       "instructions": "claude",
       "reporting": "claude",
+      "mcp": "claude",
       "homeVar": "CLAUDE_CONFIG_DIR",
       "accountEnv": { "CLAUDE_SECURESTORAGE_CONFIG_DIR": "{dir}" },
       "hooks": { "path": "settings.json", "example": "claude-code-settings.json" },
@@ -55,6 +56,7 @@
       "memory": "codex",
       "instructions": "codex",
       "reporting": "codex",
+      "mcp": "codex",
       "homeVar": "CODEX_HOME",
       "hooks": { "path": "hooks.json", "example": "codex-hooks.json" },
       "modelPattern": "\\bgpt-\\d[a-z0-9.-]*",
@@ -93,6 +95,7 @@
       "history": "antigravity",
       "instructions": "google",
       "reporting": "antigravity",
+      "mcp": "antigravity",
       "modelPattern": "\\bgemini-\\d[a-z0-9.-]*",
       "args": [],
       "resumeArgs": ["--conversation", "{id}"],
@@ -126,6 +129,7 @@
       "memory": "grok",
       "instructions": "grok",
       "reporting": "grok",
+      "mcp": "grok",
       "homeVar": "GROK_HOME",
       "hooks": { "path": "hooks/agent-guild.json", "example": "grok-hooks.json" },
       "modelPattern": "\\bgrok-(?:build|\\d)[a-z0-9.-]*",

package/docs/api.md

@@ -123,8 +123,10 @@ whether its folder is on PATH. `uninstall` is null when Agent Guild cannot
 remove that copy, and `uninstallGuidance` then says how to remove it instead.
 `POST /providers/:id/uninstall` removes one copy.
 
-For a tool that is a Docker CLI plugin (Docker Agent), `installCommand` is the
-command **Install** and **Update** run. `pluginError` says why docker could not
+`installCommand` is the command **Install** and **Update** run for a tool that
+is a Docker CLI plugin (Docker Agent), or that a configured install command
+updates by running again, and null otherwise. `plugin` names the Docker CLI
+plugin the tool is, or is null. `pluginError` says why docker could not
 list the plugin's copies, or is null; `pluginPending` is true until docker has
 listed them once.
 
@@ -151,7 +153,24 @@ leaves the multiplexer's own session running, and
 
 For a tool whose agent or model reporting has to be turned on,
 `reportingEnabled` says whether it is, and `reportingNote` says why that switch
-cannot be used, or is null. `usageUrl`, `billingUrl` and `cloudUrl` are
+cannot be used, or is null.
+
+`mcp` is null unless the tool is installed and Agent Guild can add its own MCP
+server (`agent-guild mcp`, see [mcp.md](mcp.md)) to the tool's settings:
+Claude Code, Codex CLI, Antigravity CLI and Grok Build. Otherwise it is
+`{ state, on, total, accounts }`, read from each account's settings and kept
+for up to a minute. `accounts` lists `{ id, label, state, detail }` per
+account, where `state` is `on`, `off`, `disabled` (Agent Guild's server, turned
+off in the tool), `other` (a server of that name that runs something else,
+which Agent Guild never changes) or `unknown` (the settings could not be
+read), and `detail` says why for `other` and `unknown`. An account whose home folder does not exist yet
+reads `off`, and turning the server on makes the folder. `on` counts the
+accounts that are on, of `total`. The provider's `state` is `on` or `off` when
+every account is, `partial` when some but not all are on, else `unknown`,
+`other` or `disabled` for the first of those any account has; `checking`
+before the first read, with `accounts` empty.
+
+`usageUrl`, `billingUrl` and `cloudUrl` are
 `https://` links to the vendor's usage and billing pages and web app, or null.
 
 ### Manager environment
@@ -622,6 +641,7 @@ All paths are under `/api/v1`.
 | PATCH | `/providers/:id/accounts/:account` | `{ label, revision }` | `{ account, dir, providers, revision }`: renames an account, including `default`. |
 | DELETE | `/providers/:id/accounts/:account?revision=` | | `{ account, dir, providers, revision }`: removes an account from `providers.json`. Its home folder, `dir`, stays on disk. 409 `default_account` for `default`; 409 `account_in_use` while a running session uses it. |
 | POST | `/providers/:id/reporting` | `{ enabled }` | `{ provider }`: turns agent or model reporting on or off for a tool that has `reportingEnabled`. |
+| POST | `/providers/:id/mcp` | `{ enabled }` | `{ provider, results }`: adds Agent Guild's MCP server to, or removes it from, each account of a tool that has `mcp`. Each account is read again first; one whose state is then `other` or `unknown` is left as it is. `results` has one `{ id, label, outcome, state, detail? }` per account, `outcome` `added`, `removed`, `unchanged`, `skipped` or `failed`; a failed account does not undo the others. 400 `not_applicable` for a tool without `mcp`; 409 `provider_unavailable` when it is not installed; 409 `busy` while a change for that tool is running. |
 | POST | `/providers/:id/install` | `{ force? }` | `201 { session }`: a session that installs or updates the tool. 409 `provider_in_use` (with `running`, the session count) while the provider's sessions are running; retry with `force: true` after the user confirms. |
 | POST | `/providers/:id/uninstall` | `{ path, force? }` | `201 { session }`: a session that removes the copy at `path`, one of the provider's `installs`. `force` as for `install`. |
 | GET | `/environment?scope=&cwd=&id=` | | An environment snapshot; see [Manager environment](#manager-environment). |

package/examples/terminal-ai-chat.json

@@ -0,0 +1,27 @@
+{
+  "providers": [
+    {
+      "id": "terminal-ai-chat",
+      "vendor": "Odd Essentials",
+      "tool": "Terminal AI Chat",
+      "command": "terminal-ai-chat",
+      "versionArgs": ["--version"],
+      "color": "#E11D48",
+      "monogram": "T",
+      "releases": "https://github.com/oddessentials/terminal-ai-chat-releases/releases/latest",
+      "install": "curl -fsSL https://github.com/oddessentials/terminal-ai-chat-releases/releases/latest/download/install.sh | sh",
+      "docs": "https://github.com/oddessentials/terminal-ai-chat-releases",
+      "channels": {
+        "native": { "paths": ["~/.local/bin/terminal-ai-chat"], "remove": ["~/.local/bin/terminal-ai-chat"], "reinstall": true, "versionEnv": "TAC_VERSION" },
+        "brew": { "names": ["terminal-ai-chat"] }
+      },
+      "win32": {
+        "install": "irm https://github.com/oddessentials/terminal-ai-chat-releases/releases/latest/download/install.ps1 | iex",
+        "channels": {
+          "native": { "paths": ["~/AppData/Local/Programs/terminal-ai-chat"], "remove": ["~/AppData/Local/Programs/terminal-ai-chat"], "reinstall": true, "versionEnv": "TAC_VERSION" },
+          "winget": { "id": "OddEssentials.TerminalAIChat" }
+        }
+      }
+    }
+  ]
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@oddessentials/agent-guild",
-  "version": "1.21.2",
+  "version": "1.22.0",
   "description": "Launch and watch AI coding-assistant terminal sessions from one local web page. A bundled session manager owns the terminals so the page can close and reconnect.",
   "mcpName": "ai.oddessentials/agent-guild",
   "license": "AGPL-3.0-only",

package/src/manager/install-channels.mjs

@@ -227,6 +227,9 @@ export function classifyInstall({
       if (!npmOnPath) return result('native', { guidance: `${provider.tool} at ${resolvedPath} is updated through npm, but npm was not found.` });
       return result('native', { update: { file: npmOnPath, args: ['install', '-g'], package: provider.package } });
     }
+    if (native.reinstall && provider.install && !provider.package) {
+      return result('native', { update: { file: null, args: [], command: provider.install, reinstall: true } });
+    }
     if (native.update.length === 0) {
       return result('native', { guidance: `${provider.tool} at ${resolvedPath} has no update command configured. Update it the way you installed it.` });
     }

package/src/manager/main.mjs

@@ -25,6 +25,7 @@ import { SelfUpdate } from './self-update.mjs';
 import { addRuntimePaths, resolveBaseEnv, pathReader } from './shell-env.mjs';
 import { nativeReporter, writeReportShims } from './report-shims.mjs';
 import { SessionHooks } from './session-hooks.mjs';
+import { McpConnect, ownServer } from './mcp-connect.mjs';
 import { launcherPath, nextManager } from './launch.mjs';
 import { createAutostart } from './autostart.mjs';
 import { bootSupported, createBootService } from './systemd-service.mjs';
@@ -92,6 +93,8 @@ export async function startManager({ port = resolvePort(), host = DEFAULT_HOST,
   const manager = new SessionManager({
     registry, baseEnv, getApiUrl: () => api.url, sessionDefaults, shimDir, selfUpdate, github, sessionHooks, store: multiplexerStore, cardNames,
   });
+  const mcpConnect = new McpConnect({ registry, own: ownServer(), prepareAccount: (provider, account) => manager.prepareAccount(provider, account), dir: dataDir() });
+  registry.mcpState = (provider) => mcpConnect.describe(provider);
   environment.setSessionLookup((id) => {
     let session;
     try { session = manager.get(id); } catch { return null; }
@@ -184,6 +187,7 @@ export async function startManager({ port = resolvePort(), host = DEFAULT_HOST,
     notes: createNotesStore(paths.notes),
     launcher: launcherPath(),
     yardArt: new YardArt({ webDir, dir: paths.yardArt }),
+    mcpConnect,
     onShutdownRequest: ({ restart = false } = {}) => shutdown('requested via API', { restart }).then((code) => process.exit(code)),
   });
   remoteAccess.attach({ apply: (access) => api.setAccessPolicy(access), getTarget: () => api.url });

package/src/manager/mcp-connect.mjs

@@ -0,0 +1,249 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { buildSpawnSpec, runSpec } from './command-resolver.mjs';
+import { antigravityConfigFile } from './session-hooks.mjs';
+import { stableExecPath } from './autostart.mjs';
+import { PACKAGE_SCRIPT } from './launch.mjs';
+import { dataDir } from './config.mjs';
+
+export const SERVER_NAME = 'agent-guild';
+export const MCP_MODES = ['claude', 'codex', 'antigravity', 'grok'];
+const STATE_TTL_MS = 60 * 1000;
+const RUN_TIMEOUT_MS = 30000;
+
+export function ownServer(execPath = process.execPath, home = dataDir()) {
+  return { command: stableExecPath(execPath), args: [PACKAGE_SCRIPT, 'mcp', `--home=${path.resolve(home)}`] };
+}
+
+const homeOf = (env, platform) => (platform === 'win32' ? env.USERPROFILE : env.HOME) || os.homedir();
+
+export function classify(entry, own, { enabled = true, command, args, remote = null } = {}) {
+  if (entry === undefined || entry === null) return { state: 'off' };
+  if (remote) return { state: 'other', detail: `agent-guild is already set to ${remote}` };
+  if (typeof command !== 'string' || !Array.isArray(args) || !args.every((a) => typeof a === 'string')) {
+    return { state: 'unknown', detail: 'its MCP settings name the agent-guild server in a form Agent Guild does not recognize' };
+  }
+  if (command !== own.command || args.length !== own.args.length || args.some((a, i) => a !== own.args[i])) {
+    return { state: 'other', detail: `agent-guild is already set to run ${[command, ...args].join(' ')}` };
+  }
+  return { state: enabled === false ? 'disabled' : 'on' };
+}
+
+function readJsonFile(file) {
+  let text;
+  try {
+    text = fs.readFileSync(file, 'utf8');
+  } catch (err) {
+    if (err.code === 'ENOENT') return { missing: true };
+    return { error: `${file} cannot be read: ${err.message}` };
+  }
+  try {
+    return { value: JSON.parse(text) };
+  } catch {
+    return { error: `${file} is not valid JSON` };
+  }
+}
+
+function fromServersFile(file, own, enabledOf) {
+  const read = readJsonFile(file);
+  if (read.missing) return { state: 'off' };
+  if (read.error) return { state: 'unknown', detail: read.error };
+  const servers = read.value?.mcpServers;
+  if (servers === undefined) return { state: 'off' };
+  if (!servers || typeof servers !== 'object' || Array.isArray(servers)) return { state: 'unknown', detail: `${file} has mcpServers in a form Agent Guild does not recognize` };
+  const entry = Object.hasOwn(servers, SERVER_NAME) ? servers[SERVER_NAME] : undefined;
+  if (entry === undefined) return { state: 'off' };
+  if (!entry || typeof entry !== 'object') return classify(entry, own);
+  const remote = entry.type !== undefined && entry.type !== 'stdio' ? String(entry.url ?? entry.type) : null;
+  return classify(entry, own, { enabled: enabledOf(entry), command: entry.command, args: entry.args ?? [], remote });
+}
+
+function fromList(stdout, own, pick) {
+  let list;
+  try { list = JSON.parse(stdout); } catch { list = null; }
+  if (!Array.isArray(list)) return { state: 'unknown', detail: 'its MCP server list was not in a form Agent Guild recognizes' };
+  const entry = list.find((item) => item?.name === SERVER_NAME && pick.match(item));
+  if (!entry) return { state: 'off' };
+  return classify(entry, own, pick.fields(entry));
+}
+
+const TOOLS = {
+  claude: {
+    file: (env, platform) => path.join(env.CLAUDE_CONFIG_DIR || homeOf(env, platform), '.claude.json'),
+    read(ctx) { return fromServersFile(this.file(ctx.env, ctx.platform), ctx.own, () => true); },
+    add: (own) => ['mcp', 'add', '-s', 'user', SERVER_NAME, '--', own.command, ...own.args],
+    remove: () => ['mcp', 'remove', '-s', 'user', SERVER_NAME],
+  },
+  codex: {
+    list: ['mcp', 'list', '--json'],
+    pick: {
+      match: () => true,
+      fields: (e) => ({ enabled: e.enabled, command: e.transport?.command, args: e.transport?.args ?? [], remote: e.transport?.type && e.transport.type !== 'stdio' ? String(e.transport.url ?? e.transport.type) : null }),
+    },
+    add: (own) => ['mcp', 'add', SERVER_NAME, '--', own.command, ...own.args],
+    // Adding again replaces the entry, and with it the `enabled = false` that turned it off.
+    enable: (own) => ['mcp', 'add', SERVER_NAME, '--', own.command, ...own.args],
+    remove: () => ['mcp', 'remove', SERVER_NAME],
+  },
+  antigravity: {
+    file: (env, platform) => path.join(path.dirname(antigravityConfigFile(env, platform)), 'mcp_config.json'),
+    read(ctx) { return fromServersFile(this.file(ctx.env, ctx.platform), ctx.own, (entry) => entry.disabled !== true); },
+    add: (own) => ['mcp', 'add', SERVER_NAME, '--', own.command, ...own.args],
+    enable: () => ['mcp', 'enable', SERVER_NAME],
+    remove: () => ['mcp', 'remove', SERVER_NAME],
+  },
+  grok: {
+    list: ['mcp', 'list', '--json'],
+    pick: { match: (e) => e.scope === undefined || e.scope === 'user', fields: (e) => ({ enabled: e.enabled, command: e.command, args: e.args ?? [], remote: e.url ? String(e.url) : null }) },
+    add: (own) => ['mcp', 'add', '-s', 'user', SERVER_NAME, '--', own.command, ...own.args],
+    enable: () => ['mcp', 'enable', SERVER_NAME],
+    remove: () => ['mcp', 'remove', '-s', 'user', SERVER_NAME],
+  },
+};
+
+function lastLine(err) {
+  return `${err.stderr || ''}\n${err.stdout || ''}`.trim().split('\n').map((l) => l.trim()).filter(Boolean).pop() || err.message;
+}
+
+function refusal(status, code, message) {
+  return Object.assign(new Error(message), { status, code });
+}
+
+export function summarize(accounts) {
+  const count = (state) => accounts.filter((a) => a.state === state).length;
+  const total = accounts.length;
+  const on = count('on');
+  const state = on === total ? 'on'
+    : count('off') === total ? 'off'
+      : on > 0 ? 'partial'
+        : count('unknown') ? 'unknown'
+          : count('other') ? 'other'
+            : count('disabled') ? 'disabled'
+              : 'off';
+  return { state, on, total };
+}
+
+export class McpConnect {
+  constructor({ registry, own, prepareAccount, dir = os.homedir(), ttlMs = STATE_TTL_MS }) {
+    this.registry = registry;
+    this.prepareAccount = prepareAccount;
+    this.own = own;
+    this.dir = dir;
+    this.ttlMs = ttlMs;
+    this.cache = new Map();
+    this.reading = new Map();
+    this.reads = 0;
+    this.busy = new Set();
+  }
+
+  _tool(provider) {
+    return MCP_MODES.includes(provider.mcp) ? TOOLS[provider.mcp] : null;
+  }
+
+  _accounts(provider) {
+    return this.registry.accountsFor(provider).map((account) => ({
+      id: account.id, label: account.label, dir: account.dir, account, env: { ...this.registry.env, ...provider.env, ...account.env },
+    }));
+  }
+
+  _signature(provider) {
+    return JSON.stringify(this._accounts(provider).map((a) => [a.id, a.label, a.dir, provider.homeVar ? a.env[provider.homeVar] ?? null : null]));
+  }
+
+  async _run(provider, resolved, env, args) {
+    return runSpec(buildSpawnSpec(resolved, args, env, this.registry.platform), { env, cwd: this.dir, timeoutMs: RUN_TIMEOUT_MS, killTree: true });
+  }
+
+  async readAccount(provider, resolved, account) {
+    const tool = this._tool(provider);
+    // A managed home that does not exist yet holds no settings, and some tools create it when asked.
+    if (account.dir && !fs.existsSync(account.dir)) return { state: 'off' };
+    const ctx = { env: account.env, platform: this.registry.platform, own: this.own };
+    if (tool.read) return tool.read(ctx);
+    try {
+      const { stdout } = await this._run(provider, resolved, account.env, tool.list);
+      return fromList(stdout, this.own, tool.pick);
+    } catch (err) {
+      return { state: 'unknown', detail: `${provider.command} ${tool.list.join(' ')} failed: ${lastLine(err)}` };
+    }
+  }
+
+  async _readAll(provider, resolved) {
+    return Promise.all(this._accounts(provider).map(async (account) => ({ id: account.id, label: account.label, ...await this.readAccount(provider, resolved, account) })));
+  }
+
+  refresh(provider, { force = false } = {}) {
+    const resolved = this.registry.resolve(provider);
+    if (!this._tool(provider) || !resolved) return Promise.resolve(null);
+    const sig = this._signature(provider);
+    const cached = this.cache.get(provider.id);
+    if (!force && cached && cached.resolved === resolved && cached.sig === sig && Date.now() - cached.at < this.ttlMs) return Promise.resolve(cached.accounts);
+    // A forced read follows a change, so a read that started before it must not be the one kept.
+    const pending = this.reading.get(provider.id);
+    if (!force && pending?.sig === sig) return pending.job;
+    const seq = ++this.reads;
+    const job = this._readAll(provider, resolved).then((accounts) => {
+      if (this.reading.get(provider.id)?.seq !== seq) return accounts;
+      this.reading.delete(provider.id);
+      // Accounts that changed during the read make its result obsolete.
+      const current = this.registry.get(provider.id);
+      if (!current || this._signature(current) !== sig) return accounts;
+      const before = this.cache.get(provider.id);
+      this.cache.set(provider.id, { resolved, sig, accounts, at: Date.now() });
+      // A page showing "checking" for a new account set needs this read even when every state is the same.
+      if (before?.sig !== sig || JSON.stringify(accounts) !== JSON.stringify(before.accounts)) this.registry.emit?.('updated');
+      return accounts;
+    }, (err) => {
+      if (this.reading.get(provider.id)?.seq === seq) this.reading.delete(provider.id);
+      throw err;
+    });
+    this.reading.set(provider.id, { seq, sig, job });
+    return job;
+  }
+
+  describe(provider) {
+    if (!this._tool(provider) || !this.registry.resolve(provider)) return null;
+    this.refresh(provider).catch(() => {});
+    const cached = this.cache.get(provider.id);
+    if (!cached || cached.sig !== this._signature(provider)) return { state: 'checking', on: 0, total: provider.accounts.length, accounts: [] };
+    return { ...summarize(cached.accounts), accounts: cached.accounts.map(({ id, label, state, detail }) => ({ id, label, state, detail: detail ?? null })) };
+  }
+
+  async setEnabled(provider, enabled) {
+    const tool = this._tool(provider);
+    if (!tool) throw refusal(400, 'not_applicable', `${provider.tool} has no MCP settings Agent Guild can change`);
+    const resolved = this.registry.resolve(provider);
+    if (!resolved) throw refusal(409, 'provider_unavailable', `${provider.tool} is not installed`);
+    if (this.busy.has(provider.id)) throw refusal(409, 'busy', `${provider.tool}'s MCP settings are already being changed`);
+    this.busy.add(provider.id);
+    try {
+      const results = [];
+      for (const account of this._accounts(provider)) {
+        results.push({ id: account.id, label: account.label, ...await this._change(provider, resolved, tool, account, enabled) });
+      }
+      await this.refresh(provider, { force: true });
+      return results;
+    } finally {
+      this.busy.delete(provider.id);
+    }
+  }
+
+  async _change(provider, resolved, tool, account, enabled) {
+    // The cache is for display only: every change acts on a fresh read of the account.
+    const now = await this.readAccount(provider, resolved, account);
+    const want = enabled ? 'on' : 'off';
+    if (now.state === want) return { outcome: 'unchanged', state: now.state };
+    if (now.state === 'unknown' || now.state === 'other') return { outcome: 'skipped', state: now.state, detail: now.detail };
+    const args = !enabled ? tool.remove() : now.state === 'disabled' ? tool.enable(this.own) : tool.add(this.own);
+    try {
+      if (enabled && account.dir) this.prepareAccount(provider, account.account);
+      await this._run(provider, resolved, account.env, args);
+    } catch (err) {
+      return { outcome: 'failed', state: now.state, detail: `${provider.command} ${args.slice(0, 2).join(' ')} failed: ${lastLine(err)}` };
+    }
+    const after = await this.readAccount(provider, resolved, account);
+    if (after.state !== want) return { outcome: 'failed', state: after.state, detail: after.detail ?? `${provider.tool} reported success, but the server is ${after.state}` };
+    return { outcome: enabled ? 'added' : 'removed', state: after.state };
+  }
+}

package/src/manager/providers.mjs

@@ -22,6 +22,7 @@ import { MultiplexerRegistry } from './multiplexers.mjs';
 import { reconcileHerdrPath } from './multiplexer-paths.mjs';
 import { refreshLaunchers } from './launchers.mjs';
 import { LaunchFlags, normalizeLaunchFlags } from './launch-flags.mjs';
+import { MCP_MODES } from './mcp-connect.mjs';
 
 const here = path.dirname(fileURLToPath(import.meta.url));
 export const DEFAULTS_FILE = path.resolve(here, '../../config/providers.default.json');
@@ -87,6 +88,8 @@ function normalizeChannels(raw) {
       remove: stringList(raw.native.remove),
       links: stringList(raw.native.links),
       sharedWithNpm: raw.native.sharedWithNpm === true,
+      reinstall: raw.native.reinstall === true,
+      versionEnv: typeof raw.native.versionEnv === 'string' && /^[A-Za-z_][A-Za-z0-9_]*$/.test(raw.native.versionEnv) ? raw.native.versionEnv : null,
     };
   }
   if (raw.brew && typeof raw.brew === 'object') out.brew = { names: stringList(raw.brew.names), autoUpdates: raw.brew.autoUpdates === true };
@@ -171,6 +174,7 @@ function normalize(raw, platform, warnings) {
     memory: ['claude', 'codex', 'grok'].includes(merged.memory) ? merged.memory : null,
     instructions: ['claude', 'codex', 'grok', 'google'].includes(merged.instructions) ? merged.instructions : null,
     reporting: REPORTING_MODES.has(merged.reporting) ? merged.reporting : null,
+    mcp: MCP_MODES.includes(merged.mcp) ? merged.mcp : null,
     modelPattern: merged.modelPattern ? String(merged.modelPattern) : null,
     args: Array.isArray(merged.args) ? merged.args.map(String) : [],
     resumeArgs: Array.isArray(merged.resumeArgs) ? merged.resumeArgs.map(String) : [],
@@ -308,6 +312,7 @@ export class ProviderRegistry extends EventEmitter {
     this._npmRegistry = null;
     this.reportingEnabled = null;
     this.reportingNote = null;
+    this.mcpState = null;
     this.multiplexers = new MultiplexerRegistry(this, multiplexerOptions);
     this.multiplexerState = null;
     this.reload();
@@ -585,6 +590,16 @@ export class ProviderRegistry extends EventEmitter {
     return args;
   }
 
+  reinstalls(provider) {
+    return Boolean(!provider.plugin && !provider.package && provider.install && provider.channels.native?.reinstall);
+  }
+
+  installEnv(provider) {
+    const name = this.reinstalls(provider) ? provider.channels.native.versionEnv : null;
+    const latest = name ? this.versions.get(provider.id)?.latest : null;
+    return latest ? { [name]: latest } : null;
+  }
+
   /** Whether the tool is there to run: its command on PATH, and for a plugin a copy that `docker` runs. */
   installed(provider) {
     return Boolean(provider.plugin ? this._pluginPath(provider) : this.resolve(provider));
@@ -699,7 +714,7 @@ export class ProviderRegistry extends EventEmitter {
         guidance: `Homebrew moved ${provider.tool} from a formula to a cask, so brew upgrade no longer updates this copy. Run "brew uninstall ${channel.token}", then "brew install --cask ${channel.token}".`,
       };
     }
-    if (provider.plugin) return { file: null, args: [], command: channel.update.command, guidance: null };
+    if (provider.plugin || channel.update.reinstall) return { file: null, args: [], command: channel.update.command, guidance: null };
     const args = this.npmArgs(channel.update, this.versions.get(provider.id)?.latest ?? 'latest');
     const command = formatCommand(channel.update.file, args);
     if (channel.probe) {
@@ -828,8 +843,10 @@ export class ProviderRegistry extends EventEmitter {
       resumable: provider.resumeArgs.length > 0,
       launchFlags: provider.launchFlags.map(({ flag, risky }) => ({ flag, risky })),
       launchFlagsEquals: provider.launchFlagsEquals,
-      installable: provider.plugin ? Boolean(commandPath && !resolvedPath && !pluginError && !pluginPending && provider.install) : Boolean(provider.package && this.resolveNpm()),
-      installCommand: provider.plugin && provider.install ? provider.install : null,
+      installable: provider.plugin ? Boolean(commandPath && !resolvedPath && !pluginError && !pluginPending && provider.install)
+        : this.reinstalls(provider) || Boolean(provider.package && this.resolveNpm()),
+      installCommand: (provider.plugin || this.reinstalls(provider)) && provider.install ? provider.install : null,
+      plugin: provider.plugin,
       pluginError,
       pluginPending,
       installedVersion: installed,
@@ -853,6 +870,7 @@ export class ProviderRegistry extends EventEmitter {
       reporting: provider.reporting,
       reportingEnabled: this.reportingEnabled?.(provider) ?? null,
       reportingNote: this.reportingNote?.(provider) ?? null,
+      mcp: this.mcpState?.(provider) ?? null,
       accounts: provider.accounts.map((account) => ({ id: account.id, label: account.label })),
       accountsEditable: Boolean(provider.homeVar),
       shells: shells?.shells.map((shell) => ({ id: shell.id, label: shell.label, path: shell.path, multiplexer: Boolean(shell.multiplexer) })) ?? null,
@@ -935,7 +953,7 @@ export class ProviderRegistry extends EventEmitter {
     if (!update.command) {
       throw refusal(400, 'not_updatable', update.guidance || `Still checking how ${provider.tool} was installed. Try again in a moment.`);
     }
-    if (provider.plugin) return { spec: this._installCommandSpec(provider), channel: channel.channel };
+    if (provider.plugin || channel.update.reinstall) return { spec: this._installCommandSpec(provider), channel: channel.channel };
     if (!channel.update.package) return { spec: buildSpawnSpec(update.file, update.args, this.env, this.platform), channel: channel.channel };
     const args = this.npmArgs(channel.update, await this.resolveRelease(provider, update.file));
     return { spec: npmSpawnSpec(update.file, args, this.env, this.platform), channel: 'npm' };
@@ -963,6 +981,7 @@ export class ProviderRegistry extends EventEmitter {
       if (plugins.copies.some((c) => c.active)) throw refusal(409, 'already_installed', `${provider.tool} is already installed at ${this._pluginPath(provider)}.`);
       return this._installCommandSpec(provider);
     }
+    if (this.reinstalls(provider)) return this._installCommandSpec(provider);
     if (!provider.package) {
       const err = new Error(`${provider.tool} has no npm package configured; install it by hand: ${provider.install || provider.docs || 'see its documentation'}`);
       err.status = 400;

package/src/manager/server.mjs

@@ -183,6 +183,8 @@ export function createManagerServer({
   nextManagerProblem = ptyRestartProblem,
   /** The Yard's art; without a data folder, only a checkout's. */
   yardArt = new YardArt({ webDir }),
+  mcpConnect = null,
+  heartbeatMs = 30000,
 }) {
   let listedProviders = null;
   const accounts = createAccountEditor({
@@ -517,6 +519,15 @@ export function createManagerServer({
       registry.emit('updated');
       return sendJson(res, 200, { provider: registry.describe(provider) });
     }
+    const mcpMatch = route.match(/^\/providers\/([a-z0-9][a-z0-9_-]{0,31})\/mcp$/);
+    if (mcpMatch && method === 'POST' && mcpConnect) {
+      const provider = registry.get(mcpMatch[1]);
+      if (!provider) throw new HttpError(404, `unknown provider "${mcpMatch[1]}"`, 'unknown_provider');
+      const body = await readJsonBody(req);
+      if (typeof body.enabled !== 'boolean') throw new HttpError(400, 'enabled must be true or false', 'bad_request');
+      const results = await mcpConnect.setEnabled(provider, body.enabled);
+      return sendJson(res, 200, { provider: registry.describe(provider), results });
+    }
     const multiplexerMatch = route.match(/^\/providers\/([a-z0-9][a-z0-9_-]{0,31})\/multiplexers\/([a-z0-9_-]+)\/(install|update|uninstall)$/);
     if (multiplexerMatch && method === 'POST') {
       const body = await readJsonBody(req);
@@ -818,7 +829,8 @@ export function createManagerServer({
       ws.isAlive = false;
       try { ws.ping(); } catch { /* closing */ }
     }
-  }, 30000);
+    if (mcpConnect && wss.clients.size) for (const provider of registry.providers) mcpConnect.refresh(provider).catch(() => {});
+  }, heartbeatMs);
   heartbeat.unref();
 
   return {

package/src/manager/session-manager.mjs

@@ -505,11 +505,11 @@ export class SessionManager extends EventEmitter {
         const { spec, channel } = await this.registry.updateSpec(provider);
         guard();
         const name = `Update ${provider.tool} (${CHANNEL_LABELS[channel]})`;
-        return this._spawn({ provider, spawnSpec: spec, cwd: os.homedir(), name, task: 'install', installKind: 'update' });
+        return this._spawn({ provider, spawnSpec: spec, cwd: os.homedir(), name, task: 'install', installKind: 'update', extraEnv: this.registry.installEnv(provider) });
       }
       const spawnSpec = await this.registry.installSpec(provider);
       guard();
-      return this._spawn({ provider, spawnSpec, cwd: os.homedir(), name: `Install ${provider.tool}`, task: 'install', installKind: 'install' });
+      return this._spawn({ provider, spawnSpec, cwd: os.homedir(), name: `Install ${provider.tool}`, task: 'install', installKind: 'install', extraEnv: this.registry.installEnv(provider) });
     } finally {
       this.installing.delete(provider.id);
     }