Add server-discover command for MCP 2026-07-28 connections (#354)

MCP 2026-07-28 removed `ping`, so `mcpc @session ping` silently probes
with `server/discover` instead — invisible until it shows up in a
server's access log, with no way to see what that request returns. This
adds a command that says what it does.

- `mcpc @session server-discover` sends `server/discover` and reports
the answer: supported protocol versions (negotiated one marked),
capabilities, instructions, `_meta`. `--json` prints the
`DiscoverResult` verbatim.
- On 2025-era connections it refuses (exit 2) and points at `mcpc
@session`, whose `initialize` result carries the same data.
- `ping` output now names the request it measured; `ping --json` is
unchanged.
- Capability rendering extracted so both screens share it;
`SERVER_INFO_META_KEY` mirrored in the dependency-free `protocol.ts`
with an SDK drift test.
- New `basic/server-discover.test.sh` e2e suite (one branch per protocol
era); README, CHANGELOG and the agent skill updated.

Refs #316

🤖 Generated with [Claude Code](https://claude.com/claude-code)

https://claude.ai/code/session_01KHDUfie1HZtvSiqFNTYs17

---
_Generated by [Claude
Code](https://claude.ai/code/session_01KHDUfie1HZtvSiqFNTYs17)_

Co-authored-by: Claude <noreply@anthropic.com>

Author: jancurn

CHANGELOG.md

@@ -13,6 +13,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Support for MCP protocol version 2026-07-28: mcpc now probes each server with `server/discover` and talks the new stateless protocol when supported, falling back to older protocol versions (2025-11-25 down to 2024-10-07) automatically. Resource subscriptions use the new `subscriptions/listen` stream (with automatic re-listen on drops), and `ping` transparently uses `server/discover` on 2026-07-28 servers. mcpc now uses the official TypeScript SDK v2 (`@modelcontextprotocol/client`).
 - `mcpc --json` now reports each session's server `capabilities`, plus `hasInstructions` to tell whether the server provided instructions (read them with `mcpc --json @<session>`).
 - New `--protocol-version` option for `mcpc connect` to pin the MCP protocol version (e.g. `--protocol-version 2025-11-25`) instead of auto-negotiating; the connection fails if the server does not support the pinned version. Also supported as a `protocolVersion` field in mcp.json config entries.
+- New `mcpc @<session> server-discover` command that sends a `server/discover` request and reports what the server advertises right now: every protocol version it supports, its capabilities, instructions, and `_meta`. Requires a 2026-07-28 connection, where `ping` is also translated into `server/discover` — the ping output now says so.
 - Server details from 2026-07-28 servers now include everything their `server/discover` result carries: `supportedVersions` (every protocol version the server offers) and the result's `_meta`. Reported by `connect`, `restart` and `mcpc @session` in `--json`, and kept in `sessions.json`.
 
 ### Changed

README.md

@@ -174,6 +174,7 @@ MCP session commands (after connecting):
   <@session> skills-get <name> [--raw]
   <@session> logging-set-level <level>
   <@session> ping
+  <@session> server-discover
   <@session> logs [-n N] [--follow] [--since 1h]
 
 Run "mcpc" without arguments to show active sessions and OAuth profiles.
@@ -854,6 +855,7 @@ Where `mcpc` stands on each part of the MCP specification:
 | 🔔 [**Notifications**](#list-change-notifications)   | ✅ Supported                                                      |
 | 📄 [**Pagination**](#pagination)                     | ✅ Supported                                                      |
 | 🏓 [**Ping**](#ping)                                 | ✅ Supported                                                      |
+| 🔍 [**Server discovery**](#server-discovery)          | ✅ Supported (`server/discover`, 2026-07-28 servers)               |
 | 📁 **Roots**                                         | ❌ Not planned (deprecated by MCP)                                |
 | ❓ **Elicitation**                                   | 🚧 Planned                                                       |
 | 🔤 **Completion**                                    | 🚧 Planned                                                       |
@@ -1127,7 +1129,24 @@ mcpc @apify ping --json
 
 Protocol version `2026-07-28` removed the `ping` request, so on servers using it `mcpc`
 sends a `server/discover` probe instead — same round trip, same liveness signal, and the
-command works identically on both protocol versions.
+command works identically on both protocol versions. The human-readable output says so,
+so a `server/discover` entry in the server's access log is not a surprise.
+
+#### Server discovery
+
+On `2026-07-28` connections you can also send that request yourself and see what the server
+answers right now — every protocol version it supports, its capabilities, its instructions,
+and its `_meta`:
+
+```bash
+mcpc @apify server-discover
+mcpc @apify server-discover --json    # DiscoverResult, verbatim
+```
+
+Unlike [`mcpc @apify`](#server-instructions), which reports what the connection settled on
+when it was created, this is a live request. Protocol `2026-07-28` introduced
+`server/discover`, so the command fails on `2025-11-25` (and older) connections, where the
+`initialize` handshake carries the same information — run `mcpc @apify` there instead.
 
 #### Async tasks
 

skills/mcpc/SKILL.md

@@ -251,6 +251,8 @@ mcpc @apify skills-get <name> --raw    # print the SKILL.md markdown (pipe to a
 mcpc --verbose @apify tools-call <tool>   # protocol-level detail (JSON-RPC, transport)
 mcpc @apify logs                          # bridge log; -n <N>, --follow, --since 1h
 mcpc @apify ping                          # round-trip health check
+mcpc @apify server-discover               # what the server advertises now (2026-07-28 only;
+                                          # on older servers use mcpc @apify instead)
 mcpc @apify logging-set-level debug       # deprecated; 2025-11-25 servers only, will be removed
 mcpc clean                                # tidy stale sessions/logs (also: mcpc clean all)
 ```

src/bridge/index.ts

@@ -1393,6 +1393,10 @@ class BridgeProcess {
           result = await this.client.ping();
           break;
 
+        case 'discover':
+          result = await this.client.discover();
+          break;
+
         case 'listTools': {
           const cursor = message.params as string | undefined;
           result = await this.client.listTools(cursor);

src/cli/commands/utilities.ts

@@ -1,23 +1,37 @@
 /**
- * Server-level commands (ping, etc.)
+ * Server-level commands (ping, server-discover, etc.)
  */
 
-import { formatSuccess, formatOutput } from '../output.js';
+import chalk from 'chalk';
+import { formatSuccess, formatOutput, formatDiscoverResult } from '../output.js';
 import { withMcpClient } from '../helpers.js';
+import { ServerError } from '../../lib/errors.js';
+import { isModernProtocolVersion, discoverUnavailableMessage } from '../../core/protocol.js';
 import type { CommandOptions } from '../../lib/types.js';
 
 /**
  * Ping the MCP server to check if it's alive
  */
 export async function ping(target: string, options: CommandOptions): Promise<void> {
-  await withMcpClient(target, options, async (client, _context) => {
+  await withMcpClient(target, options, async (client, context) => {
+    const { protocolVersion } = context;
+    const isModern = !!protocolVersion && isModernProtocolVersion(protocolVersion);
+
     const startTime = performance.now();
     await client.ping();
     const endTime = performance.now();
     const durationMillis = Math.round(endTime - startTime);
 
     if (options.outputMode === 'human') {
       console.log(formatSuccess(`Ping successful (${durationMillis}ms)`));
+      // Say which request actually measured the roundtrip: MCP 2026-07-28 has no `ping`,
+      // so a --verbose log or the server's access log shows server/discover instead.
+      if (isModern) {
+        console.log(
+          chalk.dim(`  MCP ${protocolVersion} has no ping request; probed with server/discover.`)
+        );
+        console.log(chalk.dim(`  ↳ see the full result: mcpc ${target} server-discover`));
+      }
     } else {
       console.log(
         formatOutput(
@@ -31,3 +45,29 @@ export async function ping(target: string, options: CommandOptions): Promise<voi
     }
   });
 }
+
+/**
+ * Send a `server/discover` request and report what the server advertises.
+ *
+ * 2026-07-28 and later only. The equivalent data on a legacy connection comes from the
+ * `initialize` handshake, which mcpc already reports via `mcpc @session` — refuse here
+ * (with that pointer) rather than passing off cached handshake data as a discover result.
+ */
+export async function serverDiscover(target: string, options: CommandOptions): Promise<void> {
+  await withMcpClient(target, options, async (client, _context) => {
+    // Gate on the negotiated version before sending anything, so the reason names this
+    // session and its version. The core client repeats the check as a backstop.
+    const details = await client.getServerDetails();
+    if (details.protocolVersion && !isModernProtocolVersion(details.protocolVersion)) {
+      throw new ServerError(discoverUnavailableMessage(details.protocolVersion, target));
+    }
+
+    const result = await client.discover();
+
+    if (options.outputMode === 'human') {
+      console.log(formatDiscoverResult(result, target, details.protocolVersion));
+    } else {
+      console.log(formatOutput(result, 'json'));
+    }
+  });
+}

src/cli/helpers.ts

@@ -142,6 +142,12 @@ export interface McpClientContext {
   sessionName?: string | undefined;
   profileName?: string | undefined;
   serverConfig?: ServerConfig | undefined;
+  /**
+   * Protocol version negotiated by the session's bridge, as persisted in sessions.json.
+   * Lets a command adapt its output to the protocol era without an extra IPC round-trip;
+   * commands that must be authoritative should call `getServerDetails()` instead.
+   */
+  protocolVersion?: string | undefined;
 }
 
 /**
@@ -185,6 +191,7 @@ export async function withMcpClient<T>(
     sessionName: session?.name,
     profileName: session?.profileName,
     serverConfig: session?.server,
+    protocolVersion: session?.protocolVersion,
   };
 
   // Log target prefix (unless hidden)

src/cli/index.ts

@@ -460,6 +460,7 @@ ${chalk.bold('MCP session commands (after connecting):')}
   <@session> ${theme.cyan('skills-get')} <name> [--raw]
   <@session> ${theme.cyan('logging-set-level')} <level>
   <@session> ${theme.cyan('ping')}
+  <@session> ${theme.cyan('server-discover')}
   <@session> ${theme.cyan('logs')} [-n N] [--follow] [--since 1h]
 
 Run "mcpc" without arguments to show active sessions and OAuth profiles.
@@ -1445,13 +1446,38 @@ ${jsonHelp('`{ level: string }`')}`
       `
 ${chalk.bold('Notes:')}
   Measures the request roundtrip. MCP 2026-07-28 removed \`ping\`, so on modern
-  connections the liveness probe is \`server/discover\` instead.
+  connections the liveness probe is \`server/discover\` instead — run
+  \`mcpc ${session} server-discover\` to see what that request returns.
 ${jsonHelp('`{ success: true, durationMs: number }`')}`
     )
     .action(async (_options, command) => {
       await utilities.ping(session, getOptionsFromCommand(command));
     });
 
+  program
+    .command('server-discover')
+    .description('Ask the server what it supports (MCP 2026-07-28+).')
+    .addHelpText(
+      'after',
+      `
+${chalk.bold('Notes:')}
+  Sends \`server/discover\` and reports the answer: every protocol version the
+  server supports, its capabilities, instructions, and \`_meta\`. Unlike
+  \`mcpc ${session}\`, which shows what the connection settled on at connect time,
+  this is a live request.
+  MCP 2026-07-28 introduced the method, so the command fails on 2025-11-25 (and
+  older) connections, where \`initialize\` carries the same data — run
+  \`mcpc ${session}\` there instead.
+${jsonHelp(
+  '`DiscoverResult` object, verbatim',
+  '`{ supportedVersions: [...], capabilities: { ... }, instructions?, _meta? }`',
+  `${SCHEMA_BASE}#discoverresult`
+)}`
+    )
+    .action(async (_options, command) => {
+      await utilities.serverDiscover(session, getOptionsFromCommand(command));
+    });
+
   // Logs command
   program
     .command('logs')