@wirecat/cli-core 0.469.0 → 0.470.0

package/CHANGELOG.md

@@ -5,6 +5,30 @@ Notable changes to `@wirecat/cli-core` (`@wirecat/cli-messaging` up to 0.261.0,
 minor version may break callers, and says how under "Changed — may break callers". `pnpm docs:check` checks the
 shape of this file.
 
+## Unreleased
+
+## 0.470.0 — 27.10.2026
+
+### Changed — may break callers
+
+- **An MCP server serves only the profiles it is told**, the owner's choice written in the agent's config
+  ([WC-MCP-9](https://github.com/WireCatLabs/cli-base/blob/main/docs/standards/mcp.md#wc-mcp-9--a-server-serves-the-profiles-it-is-told-with-one-connection-for-each)).
+  `<cli> mcp serve` with no profile no longer serves every profile: it exits 2 with `validation_error` and lists the
+  profiles here. Name one (`<cli> work mcp serve`), a list (`<cli> mcp serve --profiles work,personal`, each name
+  must exist) or every profile (`--profiles all`); the startup line on stderr names the profiles served. A first word
+  with `--profiles` is refused; under `<PREFIX>_PROFILE_LOCK`, `--profiles` may name the locked profile only
+  (`permission_error`). `all` alone is the keyword and is refused inside a list; a profile named `all` is served as
+  `<cli> all mcp serve`. The same choice applies to `--http`, `mcp server start|stop|status`, `mcp revoke` and
+  `mcp config`; the entry `mcp config --profiles all` prints runs `mcp serve --profiles all`. A list's HTTP server
+  has its own login (`mcp-http/_<names>.json`), so its login never opens a wider server; `--profiles all` keeps
+  `_all.json`. For callers: `serverEntry` takes `profile` or `profiles` and refuses neither;
+  `mcpServerCommand` takes `profiles: true` to give `start|stop|status` the option, and `McpServerTarget.profiles`
+  names the set. A client entry from 0.463.0–0.469.0 that runs `<cli> mcp serve` with no profile stops working: print
+  it again with `mcp config --profiles all`. A background server of every profile started by those versions: `upgrade`
+  stops it and the new version refuses to start it, so start it again with `mcp server start --profiles all`; one
+  still running without `upgrade` is not recognised by `mcp server stop --profiles all` (its marker changed) and is
+  stopped by its PID.
+
 ## 0.469.0 — 27.10.2026
 
 ### Changed — may break callers

package/dist/cli/mcp-server-command.d.ts

@@ -5,8 +5,14 @@ export declare const MCP_HTTP_DEFAULT_PORT = 8765;
 export interface McpServerTarget {
     /** What a person types before `mcp`: `tg personal`, `memo`. */
     invocation: string;
-    /** Absent for a CLI without profiles. */
+    /** Absent for a CLI without profiles, and for a server of several. */
     profile?: string;
+    /** A server of several profiles: what `--profiles` took, its token file's name and the profiles it names. */
+    profiles?: {
+        option: string;
+        key: string;
+        label: string;
+    };
     envPrefix: string;
     env: NodeJS.ProcessEnv;
     tokenFile: string;
@@ -26,6 +32,8 @@ export interface McpServerOptions {
      * since a server that refuses the option dies before it listens.
      */
     permission?: boolean;
+    /** `start`, `stop` and `status` take `--profiles`, for a CLI whose `mcp serve` serves several profiles. */
+    profiles?: boolean;
     target: (self: Command) => McpServerTarget;
     /** The CLI's own answer: the item in `--json`, else the lines. */
     answer: (self: Command, item: object, lines: string[]) => void;
@@ -37,4 +45,4 @@ export interface McpServerOptions {
  * survives the shell that started it, and `stop` ends only a process that carries this CLI's marker.
  * None of it is offered over MCP: status holds a live login code.
  */
-export declare const mcpServerCommand: ({ example, defaultPort, permission, target, answer, system, }: McpServerOptions) => Command;
+export declare const mcpServerCommand: ({ example, defaultPort, permission, profiles, target, answer, system, }: McpServerOptions) => Command;

package/dist/cli/mcp-server-command.js

@@ -18,7 +18,16 @@ const connectorUrl = (lock) => mcpUrlOf(new URL(lock.publicUrl)).href;
 const liveCode = (lock, now) => lock.loginCode && lock.loginCodeExpiresAt && Date.parse(lock.loginCodeExpiresAt) > now
     ? { code: lock.loginCode, expires_at: lock.loginCodeExpiresAt }
     : null;
-const markerOf = (target) => `${mcpHttpMarker(target.envPrefix)}=${target.profile ?? "default"}`;
+const markerValue = (target) => target.profile ?? target.profiles?.key ?? "default";
+const markerOf = (target) => `${mcpHttpMarker(target.envPrefix)}=${markerValue(target)}`;
+/** How a line names the server: `chat personal`, or `chat` and the profiles it serves. */
+const shown = (target) => target.profiles ? `${target.invocation}, ${target.profiles.label},` : target.invocation;
+/** The `mcp server <verb>` that finds this server again. */
+const again = (target, verb) => `${target.invocation} mcp server ${verb}${target.profiles ? ` --profiles ${target.profiles.option}` : ""}`;
+const named = (target) => ({
+    profile: target.profile ?? null,
+    ...(target.profiles ? { profiles: target.profiles.option } : {}),
+});
 /** Who started it decides whether `stop` may end it: only a process that carries our marker. */
 const byOf = (target, pid) => (carries(pid, markerOf(target)) ? "server" : "hand");
 const serving = (target, lock, now) => ({
@@ -45,7 +54,7 @@ const clientLines = (clients) => clients.length === 0
  * survives the shell that started it, and `stop` ends only a process that carries this CLI's marker.
  * None of it is offered over MCP: status holds a live login code.
  */
-export const mcpServerCommand = ({ example, defaultPort = MCP_HTTP_DEFAULT_PORT, permission = false, target, answer, system, }) => {
+export const mcpServerCommand = ({ example, defaultPort = MCP_HTTP_DEFAULT_PORT, permission = false, profiles = false, target, answer, system, }) => {
     const command = annotate(new Command("server"), { effects: LOCAL_READ, mcp: false })
         .summary("run the HTTP MCP server in the background")
         .description("start, stop and check `mcp serve --http` in the background; status shows the login code for a browser app");
@@ -74,8 +83,8 @@ export const mcpServerCommand = ({ example, defaultPort = MCP_HTTP_DEFAULT_PORT,
         const lockFile = httpLockFile(one.tokenFile);
         const before = readHttpLock(lockFile);
         if (before && alive(before.pid)) {
-            answer(this, { profile: one.profile ?? null, started: false, running: true, ...serving(one, before, Date.now()) }, [
-                `Already serving ${one.invocation} over HTTP since ${clock(before.startedAt)} (PID ${before.pid}, port ${before.port}).`,
+            answer(this, { ...named(one), started: false, running: true, ...serving(one, before, Date.now()) }, [
+                `Already serving ${shown(one)} over HTTP since ${clock(before.startedAt)} (PID ${before.pid}, port ${before.port}).`,
             ]);
             return;
         }
@@ -92,7 +101,7 @@ export const mcpServerCommand = ({ example, defaultPort = MCP_HTTP_DEFAULT_PORT,
                 url.pathname === "/" ? url.origin : url.href,
                 ...(flags.permission ?? []).flatMap((entry) => ["--permission", entry]),
             ],
-            env: { ...one.childEnv, [mcpHttpMarker(one.envPrefix)]: one.profile ?? "default" },
+            env: { ...one.childEnv, [mcpHttpMarker(one.envPrefix)]: markerValue(one) },
         };
         writeSecurely(httpLaunchFile(lockFile), `${JSON.stringify(launch)}\n`, 0o600);
         const pid = sys.spawn(launch.argv, { ...inherited, ...launch.env }, log);
@@ -100,8 +109,8 @@ export const mcpServerCommand = ({ example, defaultPort = MCP_HTTP_DEFAULT_PORT,
             const now = readHttpLock(lockFile);
             if (now?.pid === pid && now.listeningAt) {
                 const code = liveCode(now, Date.now());
-                answer(this, { profile: one.profile ?? null, started: true, running: true, ...serving(one, now, Date.now()), log }, [
-                    `Started: serving ${one.invocation} over HTTP (PID ${pid}) on 127.0.0.1:${now.port}.`,
+                answer(this, { ...named(one), started: true, running: true, ...serving(one, now, Date.now()), log }, [
+                    `Started: serving ${shown(one)} over HTTP (PID ${pid}) on 127.0.0.1:${now.port}.`,
                     `Browser apps connect to ${connectorUrl(now)}`,
                     ...(code ? [`Login code for a new browser app: ${code.code} (until ${clock(code.expires_at)}).`] : []),
                 ]);
@@ -113,7 +122,7 @@ export const mcpServerCommand = ({ example, defaultPort = MCP_HTTP_DEFAULT_PORT,
             }
             await sys.pause();
         }
-        throw new CliError("timeout", `mcp serve --http is running but not listening yet — \`${one.invocation} mcp server status\`; its log: ${log}`);
+        throw new CliError("timeout", `mcp serve --http is running but not listening yet — \`${again(one, "status")}\`; its log: ${log}`);
     });
     destroysNothing(annotate(command.command("stop"), { effects: LOCAL_WRITE, mcp: false, examples: [`${example} mcp server stop`] }))
         .summary("stop the background HTTP MCP server")
@@ -122,13 +131,13 @@ export const mcpServerCommand = ({ example, defaultPort = MCP_HTTP_DEFAULT_PORT,
         const one = target(this);
         const lock = readHttpLock(httpLockFile(one.tokenFile));
         if (!lock || !alive(lock.pid)) {
-            answer(this, { profile: one.profile ?? null, stopped: false }, [
-                `Nothing to stop: ${one.invocation} is not serving MCP over HTTP.`,
+            answer(this, { ...named(one), stopped: false }, [
+                `Nothing to stop: ${shown(one)} is not serving MCP over HTTP.`,
             ]);
             return;
         }
         if (byOf(one, lock.pid) !== "server") {
-            throw new CliError("validation_error", `mcp serve --http for ${one.invocation} (PID ${lock.pid}) was not started by \`${one.invocation} mcp server start\` — stop it where it runs`);
+            throw new CliError("validation_error", `mcp serve --http for ${shown(one)} (PID ${lock.pid}) was not started by \`${again(one, "start")}\` — stop it where it runs`);
         }
         process.kill(lock.pid, "SIGTERM");
         const sys = machine(this);
@@ -136,8 +145,8 @@ export const mcpServerCommand = ({ example, defaultPort = MCP_HTTP_DEFAULT_PORT,
             await sys.pause();
         if (alive(lock.pid))
             throw new CliError("timeout", `mcp serve --http (PID ${lock.pid}) has not stopped yet`);
-        answer(this, { profile: one.profile ?? null, stopped: true, pid: lock.pid }, [
-            `Stopped serving ${one.invocation} over HTTP (PID ${lock.pid}).`,
+        answer(this, { ...named(one), stopped: true, pid: lock.pid }, [
+            `Stopped serving ${shown(one)} over HTTP (PID ${lock.pid}).`,
         ]);
     });
     annotate(command.command("status"), {
@@ -155,7 +164,7 @@ export const mcpServerCommand = ({ example, defaultPort = MCP_HTTP_DEFAULT_PORT,
         const clients = signedInClients(one.tokenFile, now);
         const live = running ? serving(one, lock, now) : undefined;
         answer(this, {
-            profile: one.profile ?? null,
+            ...named(one),
             running,
             ...(live ?? {}),
             ...(lock && !running ? { stale: { pid: lock.pid, started_at: lock.startedAt } } : {}),
@@ -170,8 +179,8 @@ export const mcpServerCommand = ({ example, defaultPort = MCP_HTTP_DEFAULT_PORT,
             log: httpLogFile(one.tokenFile),
         }, [
             live && lock
-                ? `Serving ${one.invocation} over HTTP since ${clock(lock.startedAt)} (PID ${lock.pid}) on port ${lock.port}${live.listening ? "" : ", not listening yet"}; browser apps connect to ${live.connector_url}. ${live.by === "server" ? `Started by \`${one.invocation} mcp server start\`.` : "Started by hand — `mcp server stop` leaves it alone."}`
-                : `Not serving ${one.invocation} over HTTP.`,
+                ? `Serving ${shown(one)} over HTTP since ${clock(lock.startedAt)} (PID ${lock.pid}) on port ${lock.port}${live.listening ? "" : ", not listening yet"}; browser apps connect to ${live.connector_url}. ${live.by === "server" ? `Started by \`${again(one, "start")}\`.` : "Started by hand — `mcp server stop` leaves it alone."}`
+                : `Not serving ${shown(one)} over HTTP.`,
             ...(live?.login_code
                 ? [
                     `Login code for a new browser app: ${live.login_code.code} (until ${clock(live.login_code.expires_at)}).`,
@@ -185,5 +194,8 @@ export const mcpServerCommand = ({ example, defaultPort = MCP_HTTP_DEFAULT_PORT,
             ...clientLines(clients),
         ]);
     });
+    if (profiles)
+        for (const one of command.commands)
+            one.option("--profiles <names|all>", "the server of several profiles that `mcp serve --profiles` serves: names, comma-separated, or all");
     return command;
 };

package/dist/cli/messenger/mcp-command.d.ts

@@ -3,6 +3,7 @@ import { Command } from "commander";
 import type { ServerSystem } from "../../background/system.js";
 import { type AppIdentity } from "../../ports/app.js";
 import { type BaseEnvironment } from "../context.js";
+import { type Settings } from "../settings.js";
 import { type Messenger } from "./context.js";
 /** Where the running CLI really lives; a test hands in its own. */
 export interface McpEnvironment extends BaseEnvironment {
@@ -17,12 +18,39 @@ export interface McpFlags {
     http?: boolean;
     port?: string;
     publicUrl?: string;
+    profiles?: string;
 }
-/** The token file of `<tool> mcp serve --http` for every profile: no profile name can start with `_`. */
+/** The token file of `<tool> mcp serve --http --profiles all`: no profile name can start with `_`. */
 export declare const ALL_PROFILES = "_all";
+/** `--profiles all`; a profile named `all` is served alone, as `<tool> all mcp serve`. */
+export declare const EVERY_PROFILE = "all";
+/** The profiles `--profiles` names: `all`, read again on each session, or a fixed list. */
+export interface ProfileSet {
+    /** What `--profiles` takes to name this set again: `all`, or the names sorted, comma-separated. */
+    option: string;
+    profiles: () => string[];
+    /** The token file's name: a list's login never opens the server of other profiles. */
+    key: string;
+}
+/**
+ * The profile or profiles an MCP server is for, always named (NEED-1881, WC-MCP-9): a leading profile, or
+ * `--profiles` with a list or `all`. Neither, or both, is refused with the profiles on this computer. `--profiles`
+ * takes the place of `<PREFIX>_PROFILE`; under `<PREFIX>_PROFILE_LOCK` it may name the locked profile only
+ * (WC-ACCT-5).
+ */
+export declare const servedProfiles: (self: Command, messenger: Messenger, { settings, env }: {
+    settings: Pick<Settings, "profile" | "sources" | "profilesHere">;
+    env: NodeJS.ProcessEnv;
+}, given: string | undefined, words: string) => {
+    profile: string;
+} | {
+    set: ProfileSet;
+};
 /** Where `mcp serve --http` keeps the hashes of the tokens it issued — per profile, in the state folder. */
 export declare const httpTokenFile: (app: AppIdentity, profile: string, env: NodeJS.ProcessEnv) => string;
 export declare const mcpCommand: (messenger: Messenger) => Command;
+/** How the startup and status lines name a set, so the owner sees which accounts an agent reaches. */
+export declare const profileSetLabel: (set: ProfileSet) => string;
 /**
  * The server's own stderr, so a failed start says why rather than only that it exited. Read as it
  * comes, which also keeps a chatty server from blocking on a full pipe. Only the end is kept, with the
@@ -42,9 +70,10 @@ export declare const redactTail: (text: string, home: string | undefined) => str
  * store. So is `XDG_RUNTIME_DIR`: the keyring is reached through it, and an MCP client that starts
  * servers with a trimmed environment leaves it out (measured 2026-09-28). Credentials are never copied.
  */
-export declare const serverEntry: (app: AppIdentity, { profile, flags, execPath, scriptPath, env, }: {
-    /** Left out, the entry is `<tool> mcp serve`, the server of every profile. */
+export declare const serverEntry: (app: AppIdentity, { profile, profiles, flags, execPath, scriptPath, env, }: {
+    /** One profile, or `profiles`: the `--profiles` of a server of several. */
     profile?: string;
+    profiles?: string;
     flags?: McpFlags;
     execPath: string;
     scriptPath: string;

package/dist/cli/messenger/mcp-command.js

@@ -14,13 +14,56 @@ import { grantsAuthority, LOCAL_READ, LOCAL_WRITE, REMOTE_WRITE } from "../effec
 import { itemOf, renderAnswer } from "../envelope.js";
 import { MCP_HTTP_DEFAULT_PORT, mcpServerCommand } from "../mcp-server-command.js";
 import { rootOf } from "../profile.js";
-import { namedProfile } from "../settings.js";
+import { NoProfileHere, namedProfile } from "../settings.js";
 import { nextStep } from "../steps.js";
 import { recalledAccount } from "./accounts.js";
 import { messengerContext } from "./context.js";
 const DEFAULT_PORT = MCP_HTTP_DEFAULT_PORT;
-/** The token file of `<tool> mcp serve --http` for every profile: no profile name can start with `_`. */
+/** The token file of `<tool> mcp serve --http --profiles all`: no profile name can start with `_`. */
 export const ALL_PROFILES = "_all";
+/** `--profiles all`; a profile named `all` is served alone, as `<tool> all mcp serve`. */
+export const EVERY_PROFILE = "all";
+/**
+ * The profile or profiles an MCP server is for, always named (NEED-1881, WC-MCP-9): a leading profile, or
+ * `--profiles` with a list or `all`. Neither, or both, is refused with the profiles on this computer. `--profiles`
+ * takes the place of `<PREFIX>_PROFILE`; under `<PREFIX>_PROFILE_LOCK` it may name the locked profile only
+ * (WC-ACCT-5).
+ */
+export const servedProfiles = (self, messenger, { settings, env }, given, words) => {
+    const { app } = messenger;
+    const here = settings.profilesHere;
+    const listed = `profiles here: ${here.length > 0 ? here.join(", ") : "none"}`;
+    const named = namedProfile(settings);
+    if (given === undefined && named !== undefined)
+        return { profile: named };
+    if (given !== undefined && settings.sources.profile === "first word")
+        throw new CliError("validation_error", `name one profile or --profiles, not both: \`${app.command} ${named} ${words}\` or \`${app.command} ${words} ` +
+            `--profiles ${given}\``, { profiles: here });
+    if (given === undefined) {
+        if (here.length === 0)
+            throw new NoProfileHere(app);
+        throw new CliError("validation_error", `name the profiles to serve: \`${app.command} <profile> ${words}\`, or \`${app.command} ${words} --profiles ` +
+            `<a,b>\` or \`--profiles all\` — ${listed}`, { profiles: here });
+    }
+    const names = [...new Set(given.split(",").map((one) => one.trim()))].filter(Boolean).sort();
+    const lock = env[envName(app, "PROFILE_LOCK")]?.trim();
+    if (lock && names.some((one) => one !== lock))
+        throw new CliError("permission_error", `this process is locked to profile ${lock} (${envName(app, "PROFILE_LOCK")}) — --profiles may name only ${lock}`);
+    if (lock)
+        return { set: { option: lock, profiles: () => [lock], key: `_${lock}` } };
+    if (names.length === 1 && names[0] === EVERY_PROFILE) {
+        const every = () => messenger.resolveSettings(self.optsWithGlobals(), { env, needsProfile: false, readOnly: true }).profilesHere;
+        return { set: { option: EVERY_PROFILE, profiles: every, key: ALL_PROFILES } };
+    }
+    if (names.length === 0 || names.includes(EVERY_PROFILE))
+        throw new CliError("validation_error", `--profiles takes profile names, comma-separated, or \`all\` alone for every profile — a profile named all ` +
+            `is served as \`${app.command} all ${words}\`; ${listed}`, { profiles: here });
+    const unknown = names.filter((one) => !here.includes(one));
+    if (unknown.length > 0)
+        throw new CliError("validation_error", `no profile named ${unknown.map((one) => `"${one}"`).join(", ")} — ${listed}`, { profiles: here });
+    return { set: { option: names.join(","), profiles: () => names, key: `_${names.join(",")}` } };
+};
+const withProfiles = (command) => command.option("--profiles <names|all>", "serve several profiles from one server instead of one: names, comma-separated, or all for every profile");
 /** Where `mcp serve --http` keeps the hashes of the tokens it issued — per profile, in the state folder. */
 export const httpTokenFile = (app, profile, env) => join(resolvePaths({ appName: app.appName, prefix: app.envPrefix, env }).state, "mcp-http", `${profile}.json`);
 const withFlags = (command) => command.option("--permission <key=level>", "make a permission stricter for this server only, like messages.send=deny; it never loosens the profile; repeat for more keys", (value, previous = []) => [...previous, value]);
@@ -29,26 +72,28 @@ export const mcpCommand = (messenger) => {
     const command = annotate(new Command("mcp"), { effects: LOCAL_READ, mcp: false })
         .summary("serve this profile's commands to an AI agent, and set that up")
         .description(`serve this profile to an agent over MCP and set it up — \`claude mcp add ${app.command} -- ${app.command} <profile> mcp serve\``);
-    command.addCommand(withFlags(annotate(new Command("serve"), {
+    command.addCommand(withProfiles(withFlags(annotate(new Command("serve"), {
         effects: REMOTE_WRITE,
         lifetime: "persistent",
         mcp: false,
         examples: [
             `${app.command} personal mcp serve`,
+            `${app.command} mcp serve --profiles work,personal`,
             `${app.command} personal mcp serve --http --public-url https://laptop.example.ts.net`,
         ],
     })
         .summary("serve this profile's commands to an AI agent")
-        .description(`serve this profile to an agent over MCP, on stdin and stdout — \`claude mcp add ${app.command} -- ${app.command} <profile> mcp serve\`; with no profile, \`${app.command} mcp serve\` serves every profile and each tool asks which`))
+        .description(`serve this profile to an agent over MCP, on stdin and stdout — \`claude mcp add ${app.command} -- ${app.command} <profile> mcp serve\`; \`${app.command} mcp serve --profiles a,b\` or \`--profiles all\` serves those profiles from one server and each tool asks which`)))
         .option("--http", "serve over HTTP on 127.0.0.1 for ChatGPT and Claude in the browser, behind your tunnel; the profile's permissions decide")
         .option("--port <port>", `the local port for --http (default ${DEFAULT_PORT})`)
         .option("--public-url <url>", "the tunnel's https address the browser apps use, e.g. https://<name>.ts.net or https://<name>.ts.net/tg")
         .action(async function () {
         const flags = this.optsWithGlobals();
         const context = messengerContext(this, messenger, { needsProfile: false });
-        const profile = namedProfile(context.settings);
-        if (profile === undefined)
-            return serveEveryProfile(this, context, messenger, flags);
+        const served = servedProfiles(this, messenger, context, flags.profiles, "mcp serve");
+        if ("set" in served)
+            return serveProfiles(this, context, messenger, flags, served.set);
+        const { profile } = served;
         if (flags.http) {
             const publicUrl = publicUrlOf(flags.publicUrl, {
                 missing: "--http",
@@ -70,68 +115,80 @@ export const mcpCommand = (messenger) => {
         const { serveOverStdio } = await import("../../mcp/server.js");
         await serveOverStdio(this, context, messenger, {});
     }));
-    command.addCommand(annotate(new Command("revoke"), {
+    command.addCommand(withProfiles(annotate(new Command("revoke"), {
         effects: LOCAL_WRITE,
         mcp: false,
-        examples: [`${app.command} personal mcp revoke`],
+        examples: [`${app.command} personal mcp revoke`, `${app.command} mcp revoke --profiles all`],
     })
         .summary("forget every login given to a browser app")
-        .description(`forget every login \`mcp serve --http\` gave a browser app, of this profile or, with no profile, of the server of every profile; each app must log in again`)
-        .action(async function () {
+        .description("forget every login `mcp serve --http` gave a browser app, of this profile or of the server `--profiles` names; each app must log in again")).action(async function () {
         const context = messengerContext(this, messenger, { needsProfile: false });
-        const profile = namedProfile(context.settings);
+        const served = servedProfiles(this, messenger, context, this.opts().profiles, "mcp revoke");
         const { revokeAll } = await import("../../mcp/http/oauth.js");
-        revokeAll(httpTokenFile(app, profile ?? ALL_PROFILES, context.env));
-        renderAnswer(this, context, itemOf({ revoked: true, profile: profile ?? null }));
+        revokeAll(httpTokenFile(app, "set" in served ? served.set.key : served.profile, context.env));
+        renderAnswer(this, context, itemOf("set" in served
+            ? { revoked: true, profile: null, profiles: served.set.option }
+            : { revoked: true, profile: served.profile }));
     }));
     command.addCommand(mcpServerCommand({
         example: `${app.command} personal`,
         permission: true,
+        profiles: true,
         target: (self) => {
-            const { settings, env } = messengerContext(self, messenger, { needsProfile: false });
-            if (namedProfile(settings) === undefined)
+            const context = messengerContext(self, messenger, { needsProfile: false });
+            const { env } = context;
+            const served = servedProfiles(self, messenger, context, self.opts().profiles, `mcp server ${self.name()}`);
+            if ("set" in served) {
+                const { set } = served;
                 return {
                     invocation: app.command,
+                    profiles: { option: set.option, key: set.key, label: profileSetLabel(set) },
                     envPrefix: app.envPrefix,
                     env,
-                    tokenFile: httpTokenFile(app, ALL_PROFILES, env),
-                    argv: ["mcp", "serve", "--http"],
+                    tokenFile: httpTokenFile(app, set.key, env),
+                    argv: ["mcp", "serve", "--http", "--profiles", set.option],
                     version: app.version,
                 };
+            }
+            const { profile } = served;
             return {
-                invocation: `${app.command} ${settings.profile}`,
-                profile: settings.profile,
+                invocation: `${app.command} ${profile}`,
+                profile,
                 envPrefix: app.envPrefix,
                 env,
-                tokenFile: httpTokenFile(app, settings.profile, env),
+                tokenFile: httpTokenFile(app, profile, env),
                 argv: ["mcp", "serve", "--http"],
-                childEnv: { [`${app.envPrefix}_PROFILE`]: settings.profile },
+                childEnv: { [`${app.envPrefix}_PROFILE`]: profile },
                 version: app.version,
             };
         },
         answer: (self, item, lines) => renderAnswer(self, messengerContext(self, messenger, { needsProfile: false }), itemOf(item), () => lines.join("\n")),
         system: (self) => environmentOf(self).system,
     }));
-    command.addCommand(withFlags(annotate(new Command("config"), {
+    command.addCommand(withProfiles(withFlags(annotate(new Command("config"), {
         effects: LOCAL_READ,
-        examples: [`${app.command} personal mcp config`],
+        examples: [`${app.command} personal mcp config`, `${app.command} mcp config --profiles all`],
     })
-        .summary("print the local MCP configuration, of this profile or of every profile")
-        .description("print the mcpServers entry for Claude Desktop, Cursor and others, with full paths; writes nothing")).action(async function () {
+        .summary("print the local MCP configuration of this profile, or of those --profiles names")
+        .description("print the mcpServers entry for Claude Desktop, Cursor and others, with full paths; writes nothing"))).action(async function () {
         const flags = this.optsWithGlobals();
         const context = messengerContext(this, messenger, { needsProfile: false });
-        const { settings, env } = context;
+        const { env } = context;
         const given = environmentOf(this).mcp ?? {};
-        const named = namedProfile(settings);
+        const served = servedProfiles(this, messenger, context, flags.profiles, "mcp config");
         const entry = serverEntry(app, {
-            ...(named === undefined ? {} : { profile: named }),
+            ...("set" in served ? { profiles: served.set.option } : { profile: served.profile }),
             flags,
             execPath: given.execPath ?? process.execPath,
             scriptPath: given.scriptPath ?? realpathSync(process.argv[1] ?? ""),
             env,
         });
         // Pasted into a file, so a person gets the client's own JSON, indented; a script finds it under `config`.
-        renderAnswer(this, context, itemOf({ config: entry.config }, { next: entry.nodeBound ? [nextStep("mcp.config", { args: {} })] : [] }), () => JSON.stringify(entry.config, null, 2));
+        renderAnswer(this, context, itemOf({ config: entry.config }, {
+            next: entry.nodeBound
+                ? [nextStep("mcp.config", { args: { profiles: "set" in served ? served.set.option : undefined } })]
+                : [],
+        }), () => JSON.stringify(entry.config, null, 2));
     }));
     command.addCommand(withFlags(grantsAuthority(annotate(new Command("add"), {
         effects: LOCAL_WRITE,
@@ -213,22 +270,30 @@ export const mcpCommand = (messenger) => {
     }));
     return command;
 };
+/** How the startup and status lines name a set, so the owner sees which accounts an agent reaches. */
+export const profileSetLabel = (set) => {
+    const names = set.profiles().join(", ");
+    if (set.option === EVERY_PROFILE)
+        return `every profile (${names || "none yet"})`;
+    return set.profiles().length === 1 ? `profile ${names}` : `profiles ${names}`;
+};
 /**
- * `<tool> mcp serve` with no profile: every profile on this computer, each call in that profile's own
- * `<tool> <profile> mcp serve`
- * (`src/mcp/all-profiles.ts`). Nothing picks a profile: each tool takes one, and the agent is told to ask.
+ * `<tool> mcp serve --profiles <names|all>`: those profiles from one server, each call in that profile's own
+ * `<tool> <profile> mcp serve` (`src/mcp/all-profiles.ts`). Nothing picks a profile: each tool takes one, and the
+ * agent is told to ask.
  */
-const serveEveryProfile = async (self, context, messenger, flags) => {
+const serveProfiles = async (self, context, messenger, flags, set) => {
     const { app } = messenger;
     const { env } = context;
-    const tokenFile = httpTokenFile(app, ALL_PROFILES, env);
+    const tokenFile = httpTokenFile(app, set.key, env);
     const state = (profile) => messenger.profileState?.(profile, env) ?? "signed-in";
-    // Read again for each session, so a profile set up while the server runs appears. A bot has its own server.
-    const profiles = () => messenger
-        .resolveSettings(self.optsWithGlobals(), { env, needsProfile: false, readOnly: true })
-        .profilesHere.filter((profile) => state(profile) !== "bot");
+    const bots = set.option === EVERY_PROFILE ? [] : set.profiles().filter((profile) => state(profile) === "bot");
+    if (bots.length > 0)
+        throw new CliError("validation_error", `${bots.join(", ")} ${bots.length === 1 ? "is a bot profile" : "are bot profiles"}, served by \`${app.command} <profile> bot mcp serve\``);
+    // `all` reads the profiles again for each session, so one set up while the server runs appears.
+    const profiles = () => set.profiles().filter((profile) => state(profile) !== "bot");
     if (profiles().length === 0)
-        throw new CliError("configuration_error", `no ${app.command} profile on this computer yet — set one up, then run \`${app.command} mcp serve\` again`);
+        throw new CliError("configuration_error", `no ${app.command} profile on this computer yet — set one up, then run \`${app.command} mcp serve --profiles all\` again`);
     const given = environmentOf(self).mcp ?? {};
     const execPath = given.execPath ?? process.execPath;
     const scriptPath = given.scriptPath ?? realpathSync(process.argv[1] ?? "");
@@ -268,13 +333,13 @@ const serveEveryProfile = async (self, context, messenger, flags) => {
             version: app.version,
             onCode: (code, expires) => context.renderer.note(env[mcpHttpMarker(app.envPrefix)] === undefined
                 ? `login code for a new browser app: ${code} (until ${expires.toTimeString().slice(0, 5)}; a new one after each login)`
-                : `a new login code for a browser app: \`${app.command} mcp server status\``),
+                : `a new login code for a browser app: \`${app.command} mcp server status --profiles ${set.option}\``),
         }).catch((error) => {
             if (error.code === "EADDRINUSE")
                 throw new CliError("configuration_error", `port ${port} is in use — pass another with --port`);
             throw error;
         });
-        context.renderer.note(`serving every profile on ${listening.url.href} — point your tunnel at it; connectors use ${mcpUrlOf(publicUrl).href}`);
+        context.renderer.note(`serving ${profileSetLabel(set)} on ${listening.url.href} — point your tunnel at it; connectors use ${mcpUrlOf(publicUrl).href}`);
         await new Promise((resolve) => {
             process.once("SIGINT", resolve);
             process.once("SIGTERM", resolve);
@@ -283,6 +348,7 @@ const serveEveryProfile = async (self, context, messenger, flags) => {
         return;
     }
     const { serveAllProfilesOverStdio } = await import("../../mcp/all-profiles.js");
+    context.renderer.note(`serving ${profileSetLabel(set)} over MCP on stdin and stdout`);
     const { stdin, stdout, signal } = environmentOf(self);
     await serveAllProfilesOverStdio(options, {
         ...(stdin ? { stdin: stdin } : {}),
@@ -331,6 +397,14 @@ export const redactTail = (text, home) => {
     const lines = out.split("\n").filter((line) => line.trim() !== "");
     return lines.slice(-TAIL_LINES).join("\n").slice(-TAIL_BYTES);
 };
+/** `tg-work`; `tg` for every profile; `tg-personal-work` for a list, a name every client accepts. */
+const serverName = (app, profile, profiles) => {
+    if (profile !== undefined)
+        return `${app.command}-${profile}`;
+    if (profiles === EVERY_PROFILE)
+        return app.command;
+    return `${app.command}-${(profiles ?? "").split(",").join("-")}`;
+};
 const VERSION_MANAGER = /[\\/](\.nvm|nvm|\.fnm|fnm|fnm_multishells|\.volta|volta|\.asdf|mise)[\\/]/i;
 /**
  * `node` and the script by full path, on every platform: a client started from the desktop does
@@ -340,10 +414,13 @@ const VERSION_MANAGER = /[\\/](\.nvm|nvm|\.fnm|fnm|fnm_multishells|\.volta|volta
  * store. So is `XDG_RUNTIME_DIR`: the keyring is reached through it, and an MCP client that starts
  * servers with a trimmed environment leaves it out (measured 2026-09-28). Credentials are never copied.
  */
-export const serverEntry = (app, { profile, flags = {}, execPath, scriptPath, env, }) => {
+export const serverEntry = (app, { profile, profiles, flags = {}, execPath, scriptPath, env, }) => {
+    if ((profile === undefined) === (profiles === undefined))
+        throw new CliError("validation_error", "an MCP entry serves one profile or the profiles --profiles names");
+    const words = profile === undefined ? `mcp config --profiles ${profiles}` : `${profile} mcp config`;
     if (installerOf(scriptPath) === "npx") {
         throw new CliError("validation_error", `this ${app.command} runs from npx's cache, which gets cleared, and the path would stop working — ` +
-            `install it globally, then run \`${app.command} ${profile === undefined ? "" : `${profile} `}mcp config\` again`);
+            `install it globally, then run \`${app.command} ${words}\` again`);
     }
     const names = [
         ...["CONFIG_DIR", "STATE_DIR", "CACHE_DIR"].map((name) => envName(app, name)),
@@ -360,12 +437,13 @@ export const serverEntry = (app, { profile, flags = {}, execPath, scriptPath, en
             ...(profile === undefined ? [] : [profile]),
             "mcp",
             "serve",
+            ...(profiles === undefined ? [] : ["--profiles", profiles]),
             ...(flags.permission ?? []).flatMap((entry) => ["--permission", entry]),
         ],
         ...(Object.keys(directories).length > 0 ? { env: directories } : {}),
     };
     return {
-        config: { mcpServers: { [profile === undefined ? app.command : `${app.command}-${profile}`]: server } },
+        config: { mcpServers: { [serverName(app, profile, profiles)]: server } },
         /** The path belongs to one Node version of a version manager; switching Node breaks the entry. */
         nodeBound: VERSION_MANAGER.test(execPath),
     };

package/dist/cli/steps.js

@@ -189,7 +189,7 @@ export const STEPS = defineSteps([
     {
         id: "mcp.config",
         command: "mcp config",
-        args: [],
+        args: [{ name: "profiles", required: false }],
         why: "the entry names one Node version's path; after switching or upgrading Node, print it again",
     },
     {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wirecat/cli-core",
-  "version": "0.469.0",
+  "version": "0.470.0",
   "description": "The messenger-neutral half of a messaging CLI: domain model, message locators, rendering, name resolution, the SQLite seam, the command skeleton and shared read commands, the send guard, run records and the message store",
   "license": "Apache-2.0",
   "author": "Viacheslav Ptsarev",

package/parity.json

@@ -802,6 +802,10 @@
       "value": "<who>",
       "meaning": "who sees the profile photo: everyone, contacts or nobody"
     },
+    "--profiles": {
+      "value": "<names|all>",
+      "meaning": "the profiles one MCP server serves, comma-separated, or all of them"
+    },
     "--public-url": {
       "value": "<url>",
       "meaning": "the tunnel's https address: the browser apps reach mcp serve --http through it, a messenger delivers to bot watch"
@@ -3160,6 +3164,7 @@
       "in": "all",
       "options": {
         "--permission": "all",
+        "--profiles": "all",
         "--yes": {
           "in": [],
           "planned": {
@@ -3171,7 +3176,10 @@
       }
     },
     "mcp revoke": {
-      "in": "all"
+      "in": "all",
+      "options": {
+        "--profiles": "all"
+      }
     },
     "mcp serve": {
       "in": "all",
@@ -3179,6 +3187,7 @@
         "--http": "all",
         "--permission": "all",
         "--port": "all",
+        "--profiles": "all",
         "--public-url": "all",
         "--yes": {
           "in": [],
@@ -3198,14 +3207,21 @@
       "options": {
         "--permission": "all",
         "--port": "all",
+        "--profiles": "all",
         "--public-url": "all"
       }
     },
     "mcp server status": {
-      "in": "all"
+      "in": "all",
+      "options": {
+        "--profiles": "all"
+      }
     },
     "mcp server stop": {
-      "in": "all"
+      "in": "all",
+      "options": {
+        "--profiles": "all"
+      }
     },
     "mentions": {
       "in": "all"