@inneranimalmedia/agentsam-sdk 2.6.3 → 2.6.5

package/src/mcp/client-adapters.js

@@ -1,17 +1,50 @@
+/**
+ * MCP *client* adapters — hosts that consume MCP servers (Cursor, Claude, …).
+ *
+ * Cloudflare MCP portal hostnames are offerable *server* connections
+ * (see SEED_OFFERABLE_MCP_SERVER_CONNECTIONS / cloudflare-bundles.js) — not
+ * OAuth client registry rows.
+ */
 import fs from 'node:fs';
-import os from 'node:os';
 import path from 'node:path';
 import { getMcpDir, homeDirectory } from './authority.js';
+import { listCloudflareMcpBundles } from './cloudflare-bundles.js';
 
 export const DEFAULT_CLIENT_REGISTRY_URL = 'https://mcp.inneranimalmedia.com/api/mcp/clients';
 export const CLIENT_REGISTRY_CACHE_SCHEMA = 'agentsam.mcp.client-registry.v1';
 
 /**
- * Seed external MCP client registry snapshot derived directly from D1 table:
- * `agentsam_mcp_oauth_external_client_registry`.
- *
- * This acts as the baseline cache for offline or pre-fetch execution,
- * respecting `is_active` and `sort_order`.
+ * Offerable MCP server connections (including every CF portal hostname).
+ * These are what `agentsam mcp add` / Studio connection pickers should list.
+ */
+export const SEED_OFFERABLE_MCP_SERVER_CONNECTIONS = Object.freeze([
+  {
+    connection_key: 'inneranimalmedia',
+    display_name: 'Inner Animal Media MCP',
+    url: 'https://mcp.inneranimalmedia.com/mcp',
+    kind: 'mcp_server',
+    provider: 'inneranimalmedia',
+  },
+  ...listCloudflareMcpBundles().map((b) => ({
+    connection_key: b.name,
+    display_name: b.display_name,
+    url: b.url,
+    kind: 'mcp_server',
+    provider: 'cloudflare',
+    host: new URL(b.url).hostname,
+    feature_packs: b.feature_packs,
+    portal_manage_scopes: b.portal_manage_scopes,
+    notes: b.description,
+  })),
+]);
+
+export function listOfferableMcpServerConnections() {
+  return [...SEED_OFFERABLE_MCP_SERVER_CONNECTIONS];
+}
+
+/**
+ * Seed for OAuth/external *client* registry only (who connects TO an MCP server).
+ * Do not put Cloudflare portal hostnames here — those belong in the server catalog.
  */
 export const SEED_EXTERNAL_CLIENT_REGISTRY = Object.freeze([
   {
@@ -32,105 +65,6 @@ export const SEED_EXTERNAL_CLIENT_REGISTRY = Object.freeze([
     is_active: 1,
     notes: 'OpenAI ChatGPT connector_platform_oauth + per-connector redirect',
   },
-  {
-    client_key: 'cf_docs_mcp',
-    display_name: 'Cloudflare Docs',
-    oauth_client_id: 'iam_mcp_inneranimalmedia',
-    redirect_host_patterns: ['docs.mcp.cloudflare.com'],
-    sort_order: 10,
-    is_active: 1,
-    notes: 'https://docs.mcp.cloudflare.com/mcp — CF docs reference',
-  },
-  {
-    client_key: 'cf_bindings_mcp',
-    display_name: 'Cloudflare Workers Bindings',
-    oauth_client_id: 'iam_mcp_inneranimalmedia',
-    redirect_host_patterns: ['bindings.mcp.cloudflare.com'],
-    sort_order: 11,
-    is_active: 1,
-    notes: 'https://bindings.mcp.cloudflare.com/mcp — Workers storage, AI, compute',
-  },
-  {
-    client_key: 'cf_builds_mcp',
-    display_name: 'Cloudflare Workers Builds',
-    oauth_client_id: 'iam_mcp_inneranimalmedia',
-    redirect_host_patterns: ['builds.mcp.cloudflare.com'],
-    sort_order: 12,
-    is_active: 1,
-    notes: 'https://builds.mcp.cloudflare.com/mcp — CI/CD insights',
-  },
-  {
-    client_key: 'cf_observability_mcp',
-    display_name: 'Cloudflare Observability',
-    oauth_client_id: 'iam_mcp_inneranimalmedia',
-    redirect_host_patterns: ['observability.mcp.cloudflare.com'],
-    sort_order: 13,
-    is_active: 1,
-    notes: 'https://observability.mcp.cloudflare.com/mcp — logs and analytics',
-  },
-  {
-    client_key: 'cf_browser_mcp',
-    display_name: 'Cloudflare Browser Rendering',
-    oauth_client_id: 'iam_mcp_inneranimalmedia',
-    redirect_host_patterns: ['browser.mcp.cloudflare.com'],
-    sort_order: 14,
-    is_active: 1,
-    notes: 'https://browser.mcp.cloudflare.com/mcp — fetch pages, markdown, screenshots',
-  },
-  {
-    client_key: 'cf_logs_mcp',
-    display_name: 'Cloudflare Logpush',
-    oauth_client_id: 'iam_mcp_inneranimalmedia',
-    redirect_host_patterns: ['logs.mcp.cloudflare.com'],
-    sort_order: 15,
-    is_active: 1,
-    notes: 'https://logs.mcp.cloudflare.com/mcp — Logpush job health',
-  },
-  {
-    client_key: 'cf_ai_gateway_mcp',
-    display_name: 'Cloudflare AI Gateway',
-    oauth_client_id: 'iam_mcp_inneranimalmedia',
-    redirect_host_patterns: ['ai-gateway.mcp.cloudflare.com'],
-    sort_order: 16,
-    is_active: 1,
-    notes: 'https://ai-gateway.mcp.cloudflare.com/mcp — AI request logs',
-  },
-  {
-    client_key: 'cf_audit_logs_mcp',
-    display_name: 'Cloudflare Audit Logs',
-    oauth_client_id: 'iam_mcp_inneranimalmedia',
-    redirect_host_patterns: ['auditlogs.mcp.cloudflare.com'],
-    sort_order: 17,
-    is_active: 1,
-    notes: 'https://auditlogs.mcp.cloudflare.com/mcp — audit log reports',
-  },
-  {
-    client_key: 'cf_dns_analytics_mcp',
-    display_name: 'Cloudflare DNS Analytics',
-    oauth_client_id: 'iam_mcp_inneranimalmedia',
-    redirect_host_patterns: ['dns-analytics.mcp.cloudflare.com'],
-    sort_order: 18,
-    is_active: 1,
-    notes: 'https://dns-analytics.mcp.cloudflare.com/mcp — DNS performance',
-  },
-  {
-    client_key: 'cf_graphql_mcp',
-    display_name: 'Cloudflare GraphQL',
-    oauth_client_id: 'iam_mcp_inneranimalmedia',
-    redirect_host_patterns: ['graphql.mcp.cloudflare.com'],
-    sort_order: 19,
-    is_active: 1,
-    notes: 'https://graphql.mcp.cloudflare.com/mcp — analytics via GraphQL',
-  },
-  {
-    client_key: 'cf_codemode_mcp',
-    display_name: 'Cloudflare Code Mode',
-    oauth_client_id: 'iam_mcp_inneranimalmedia',
-    redirect_host_patterns: ['mcp.cloudflare.com'],
-    sort_order: 20,
-    is_active: 1,
-    notes: 'https://mcp.cloudflare.com/mcp — full CF API in 2 tools, ~1000 tokens',
-  },
   {
     client_key: 'claude',
     display_name: 'Claude.ai',
@@ -140,15 +74,6 @@ export const SEED_EXTERNAL_CLIENT_REGISTRY = Object.freeze([
     is_active: 1,
     notes: 'Anthropic Claude.ai MCP auth_callback',
   },
-  {
-    client_key: 'cf_containers_mcp',
-    display_name: 'Cloudflare Container Sandbox',
-    oauth_client_id: 'iam_mcp_inneranimalmedia',
-    redirect_host_patterns: ['containers.mcp.cloudflare.com'],
-    sort_order: 21,
-    is_active: 1,
-    notes: 'https://containers.mcp.cloudflare.com/mcp — ephemeral ~10min sandboxed containers',
-  },
   {
     client_key: 'cursor',
     display_name: 'Cursor',
@@ -156,13 +81,11 @@ export const SEED_EXTERNAL_CLIENT_REGISTRY = Object.freeze([
     redirect_host_patterns: ['mcp.inneranimalmedia.com', 'cursor.com', 'www.cursor.com'],
     sort_order: 30,
     is_active: 1,
-    notes: 'Cursor desktop (cursor://, localhost:8787) + Cursor Agents',
+    notes: 'Cursor desktop (cursor://, localhost) + Cursor Agents',
   },
 ]);
 
-/**
- * Dynamic list of all recognized active client keys.
- */
+/** Active client keys from seed (IDE hosts only). */
 export const SUPPORTED_CLIENTS = Object.freeze(
   SEED_EXTERNAL_CLIENT_REGISTRY.filter((c) => Number(c.is_active) !== 0).map((c) => c.client_key),
 );
@@ -222,8 +145,14 @@ export async function fetchExternalClientRegistry(options = {}) {
     if (res.ok) {
       const body = await res.json();
       if (body?.ok && Array.isArray(body.clients)) {
-        writeCachedClientRegistry(body.clients, options);
-        return body.clients.filter((c) => Number(c.is_active) !== 0);
+        // Never treat MCP portal hostnames as clients even if a stale API row says so.
+        const clients = body.clients.filter((c) => {
+          if (Number(c.is_active) === 0) return false;
+          const key = String(c.client_key || '').toLowerCase();
+          return !key.startsWith('cf_') && !key.includes('mcp.cloudflare');
+        });
+        writeCachedClientRegistry(clients, options);
+        return clients;
       }
     }
   } catch {
@@ -241,7 +170,10 @@ export async function fetchExternalClientRegistry(options = {}) {
 export function listRegisteredClients(options = {}) {
   const cached = loadCachedClientRegistry(options);
   if (cached?.clients?.length) {
-    return cached.clients;
+    return cached.clients.filter((c) => {
+      const key = String(c.client_key || '').toLowerCase();
+      return !key.startsWith('cf_');
+    });
   }
   return SEED_EXTERNAL_CLIENT_REGISTRY.filter((c) => Number(c.is_active) !== 0);
 }
@@ -276,12 +208,10 @@ export function getClientConfigPath(clientName, options = {}) {
     return path.join(getMcpDir(options), 'clients', 'chatgpt-connector.json');
   }
 
-  // AgentSam apps/ family and standalone binary adapter
   if (client === 'agentsam') {
     return path.join(home, '.agentsam', 'mcp.json');
   }
 
-  // Any other active client in registry: adapter configuration JSON
   if (isClientRegistered(client, options)) {
     return path.join(getMcpDir(options), 'clients', `${client}.json`);
   }
@@ -293,29 +223,25 @@ export function detectInstalledClients(options = {}) {
   const detected = [];
   const home = homeDirectory(options);
 
-  // Check Cursor
   const cursorDir = path.join(home, '.cursor');
-  if (fs.existsSync(cursorDir)) {
-    detected.push('cursor');
-  }
+  if (fs.existsSync(cursorDir)) detected.push('cursor');
 
-  // Check Claude
-  const claudeConfig = getClientConfigPath('claude', options);
-  if (fs.existsSync(path.dirname(claudeConfig))) {
-    detected.push('claude');
+  try {
+    const claudeConfig = getClientConfigPath('claude', options);
+    if (fs.existsSync(path.dirname(claudeConfig))) detected.push('claude');
+  } catch {
+    // ignore
   }
 
-  // Check ChatGPT
-  const chatgptConfig = getClientConfigPath('chatgpt', options);
-  if (fs.existsSync(chatgptConfig)) {
-    detected.push('chatgpt');
+  try {
+    const chatgptConfig = getClientConfigPath('chatgpt', options);
+    if (fs.existsSync(chatgptConfig)) detected.push('chatgpt');
+  } catch {
+    // ignore
   }
 
-  // Check AgentSam family adapter target (~/.agentsam)
   const agentsamDir = path.join(home, '.agentsam');
-  if (fs.existsSync(agentsamDir)) {
-    detected.push('agentsam');
-  }
+  if (fs.existsSync(agentsamDir)) detected.push('agentsam');
 
   return detected;
 }
@@ -338,13 +264,12 @@ export function syncServerToClient(clientName, serverName, serverConfig, options
   const configPath = getClientConfigPath(clientName, options);
   const client = clean(clientName).toLowerCase();
 
-  // ChatGPT connector payload export
   if (client === 'chatgpt') {
     const chatgptPayload = {
       schema: 'agentsam.mcp.client-adapter.chatgpt.v1',
       name: serverName,
       server_url: serverConfig.url,
-      protocol: serverConfig.protocol || 'sse',
+      protocol: serverConfig.protocol || 'streamable_http',
       auth: serverConfig.auth || { type: 'none' },
       description: serverConfig.metadata?.description || `MCP Server connection for ${serverName}`,
       instructions: 'Use in ChatGPT Custom GPTs or ChatGPT Developer Mode Action Connectors.',
@@ -354,7 +279,6 @@ export function syncServerToClient(clientName, serverName, serverConfig, options
     return { client, configPath, synced: true };
   }
 
-  // Default Cursor / Claude mcpServers schema
   const existing = readJsonSafe(configPath) || { mcpServers: {} };
   if (!existing.mcpServers || typeof existing.mcpServers !== 'object') {
     existing.mcpServers = {};
@@ -362,10 +286,10 @@ export function syncServerToClient(clientName, serverName, serverConfig, options
 
   const headers = {};
   if (serverConfig.auth?.token) {
-    headers['Authorization'] = `Bearer ${serverConfig.auth.token}`;
+    headers.Authorization = `Bearer ${serverConfig.auth.token}`;
   }
   if (client === 'cursor') {
-    headers['Accept'] = 'application/json, text/event-stream';
+    headers.Accept = 'application/json, text/event-stream';
   }
 
   existing.mcpServers[serverName] = {

package/src/mcp/client.js

@@ -1,5 +1,22 @@
+/**
+ * MCP JSON-RPC client for AgentSam CLI (ping / tools/list / tools/call).
+ *
+ * Prefers Streamable HTTP (current MCP remote transport), falls back to SSE.
+ * Does not invent connection presets — callers pass a concrete serverConfig.
+ */
 import { Client } from '@modelcontextprotocol/sdk/client/index.js';
 import { SSEClientTransport } from '@modelcontextprotocol/sdk/client/sse.js';
+import { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/streamableHttp.js';
+import { createRequire } from 'node:module';
+
+const require = createRequire(import.meta.url);
+const PKG_VERSION = (() => {
+  try {
+    return require('../../package.json').version || '0.0.0';
+  } catch {
+    return '0.0.0';
+  }
+})();
 
 function clean(value) {
   return value == null ? '' : String(value).trim();
@@ -7,57 +24,121 @@ function clean(value) {
 
 export function buildHeaders(serverConfig = {}) {
   const headers = {
-    'Accept': 'application/json, text/event-stream',
-    'User-Agent': 'AgentSam-SDK/2.6.2 (MCP Client)',
+    Accept: 'application/json, text/event-stream',
+    'User-Agent': `AgentSam-SDK/${PKG_VERSION} (MCP Client)`,
   };
   const token = clean(serverConfig.auth?.token);
   if (token) {
-    headers['Authorization'] = `Bearer ${token}`;
+    headers.Authorization = `Bearer ${token}`;
   }
   return headers;
 }
 
+/**
+ * @template T
+ * @param {object} serverConfig
+ * @param {(client: import('@modelcontextprotocol/sdk/client/index.js').Client, transport: string) => Promise<T>} fn
+ * @param {{ timeoutMs?: number }} [options]
+ * @returns {Promise<{ ok: true, value: T, transport: string } | { ok: false, error: string, transport?: string }>}
+ */
+export async function withMcpClient(serverConfig, fn, options = {}) {
+  const url = clean(serverConfig.url);
+  if (!url) return { ok: false, error: 'missing_mcp_server_url' };
+
+  const headers = buildHeaders(serverConfig);
+  const requestInit = { headers };
+  const errors = [];
+
+  const tryTransport = async (label, createTransport) => {
+    const transport = createTransport();
+    const client = new Client(
+      { name: 'agentsam-sdk', version: PKG_VERSION },
+      { capabilities: {} },
+    );
+    const timer = setTimeout(() => {
+      try { transport.close?.(); } catch { /* ignore */ }
+    }, options.timeoutMs || 15000);
+    try {
+      await client.connect(transport);
+      const value = await fn(client, label);
+      return { ok: true, value, transport: label };
+    } finally {
+      clearTimeout(timer);
+      try { await transport.close?.(); } catch { /* ignore */ }
+    }
+  };
+
+  try {
+    return await tryTransport(
+      'streamable_http',
+      () => new StreamableHTTPClientTransport(new URL(url), { requestInit }),
+    );
+  } catch (err) {
+    errors.push(`streamable_http:${err?.message || err}`);
+  }
+
+  try {
+    return await tryTransport(
+      'sse',
+      () => new SSEClientTransport(new URL(url), { requestInit }),
+    );
+  } catch (err) {
+    errors.push(`sse:${err?.message || err}`);
+  }
+
+  return { ok: false, error: errors.join(' | ') || 'mcp_connect_failed' };
+}
+
 export async function pingMcpServer(serverConfig = {}, options = {}) {
   const url = clean(serverConfig.url);
   if (!url) throw new Error('missing_mcp_server_url');
 
   const startMs = Date.now();
-  const headers = buildHeaders(serverConfig);
-  const timeoutMs = options.timeoutMs || 5000;
+  const connected = await withMcpClient(
+    serverConfig,
+    async (client) => {
+      // listTools is a cheap post-initialize probe across CF portals
+      const tools = await client.listTools().catch(() => ({ tools: [] }));
+      return { toolCount: tools?.tools?.length ?? 0 };
+    },
+    { timeoutMs: options.timeoutMs || 8000 },
+  );
+
+  const latencyMs = Date.now() - startMs;
+  if (connected.ok) {
+    return {
+      ok: true,
+      status: 200,
+      statusText: 'connected',
+      latencyMs,
+      url,
+      transport: connected.transport,
+      toolCount: connected.value?.toolCount ?? null,
+    };
+  }
 
+  // Last-resort HTTP reachability (does not prove MCP session)
   try {
-    const controller = new AbortController();
-    const timer = setTimeout(() => controller.abort(), timeoutMs);
-
-    // First attempt an HTTP OPTIONS or GET / health ping
+    const headers = buildHeaders(serverConfig);
     const res = await fetch(url, {
-      method: 'GET',
-      headers,
-      signal: controller.signal,
-    }).catch(async () => {
-      // If GET returns 405/404, try POST with JSON-RPC ping
-      return await fetch(url, {
-        method: 'POST',
-        headers: { ...headers, 'Content-Type': 'application/json' },
-        body: JSON.stringify({ jsonrpc: '2.0', id: 1, method: 'ping' }),
-        signal: controller.signal,
-      });
+      method: 'POST',
+      headers: { ...headers, 'Content-Type': 'application/json' },
+      body: JSON.stringify({ jsonrpc: '2.0', id: 1, method: 'ping' }),
+      signal: AbortSignal.timeout(options.timeoutMs || 5000),
     });
-
-    clearTimeout(timer);
-    const latencyMs = Date.now() - startMs;
-
     return {
       ok: res.status < 500,
       status: res.status,
       statusText: res.statusText,
-      latencyMs,
+      latencyMs: Date.now() - startMs,
       url,
+      transport: 'http_jsonrpc_ping',
+      warning: connected.error,
     };
   } catch (err) {
     return {
       ok: false,
-      error: err.name === 'AbortError' ? 'timeout' : err.message,
+      error: connected.error || (err.name === 'TimeoutError' || err.name === 'AbortError' ? 'timeout' : err.message),
       latencyMs: Date.now() - startMs,
       url,
     };
@@ -65,108 +146,47 @@ export async function pingMcpServer(serverConfig = {}, options = {}) {
 }
 
 export async function listMcpTools(serverConfig = {}, options = {}) {
-  const url = clean(serverConfig.url);
-  if (!url) throw new Error('missing_mcp_server_url');
-
-  const headers = buildHeaders(serverConfig);
-
-  // Try standard JSON-RPC tools/list via POST first (fastest across Cloudflare Workers)
-  try {
-    const res = await fetch(url, {
-      method: 'POST',
-      headers: { ...headers, 'Content-Type': 'application/json' },
-      body: JSON.stringify({
-        jsonrpc: '2.0',
-        id: 'tools-list-1',
-        method: 'tools/list',
-        params: {},
-      }),
-      signal: AbortSignal.timeout(options.timeoutMs || 8000),
-    });
-
-    if (res.ok) {
-      const data = await res.json();
-      if (data?.result?.tools && Array.isArray(data.result.tools)) {
-        return {
-          tools: data.result.tools,
-          count: data.result.tools.length,
-          transport: 'http_jsonrpc',
-        };
-      }
-    }
-  } catch {
-    // Fall back to SSE transport below
-  }
-
-  // Fallback to SSE transport via @modelcontextprotocol/sdk
-  try {
-    const transport = new SSEClientTransport(new URL(url), {
-      requestInit: { headers },
-    });
-    const client = new Client({ name: 'agentsam-sdk', version: '2.6.2' }, { capabilities: {} });
-    await client.connect(transport);
-    const toolsResult = await client.listTools();
-    await transport.close();
-
+  const connected = await withMcpClient(
+    serverConfig,
+    async (client) => client.listTools(),
+    { timeoutMs: options.timeoutMs || 12000 },
+  );
+
+  if (connected.ok) {
+    const tools = connected.value?.tools || [];
     return {
-      tools: toolsResult.tools || [],
-      count: toolsResult.tools?.length || 0,
-      transport: 'sse_sdk',
-    };
-  } catch (err) {
-    return {
-      tools: [],
-      count: 0,
-      error: err.message,
+      tools,
+      count: tools.length,
+      transport: connected.transport,
     };
   }
+
+  return {
+    tools: [],
+    count: 0,
+    error: connected.error,
+  };
 }
 
 export async function callMcpTool(serverConfig = {}, toolName, args = {}, options = {}) {
-  const url = clean(serverConfig.url);
-  if (!url) throw new Error('missing_mcp_server_url');
-
   const startMs = Date.now();
-  const headers = buildHeaders(serverConfig);
-
-  try {
-    const res = await fetch(url, {
-      method: 'POST',
-      headers: { ...headers, 'Content-Type': 'application/json' },
-      body: JSON.stringify({
-        jsonrpc: '2.0',
-        id: `call-${Date.now()}`,
-        method: 'tools/call',
-        params: {
-          name: toolName,
-          arguments: args,
-        },
-      }),
-      signal: AbortSignal.timeout(options.timeoutMs || 30000),
-    });
-
-    const latencyMs = Date.now() - startMs;
-    if (!res.ok) {
-      return {
-        ok: false,
-        status: res.status,
-        error: `HTTP ${res.status}: ${res.statusText}`,
-        latencyMs,
-      };
-    }
-
-    const data = await res.json();
-    return {
-      ok: !data.error && !data.result?.isError,
-      result: data.result,
-      error: data.error?.message || (data.result?.isError ? JSON.stringify(data.result.content) : null),
-      latencyMs,
-    };
-  } catch (err) {
-    return {
-      ok: false,
-      error: err.message,
-      latencyMs: Date.now() - startMs,
-    };
+  const connected = await withMcpClient(
+    serverConfig,
+    async (client) => client.callTool({ name: toolName, arguments: args }),
+    { timeoutMs: options.timeoutMs || 30000 },
+  );
+
+  const latencyMs = Date.now() - startMs;
+  if (!connected.ok) {
+    return { ok: false, error: connected.error, latencyMs };
   }
+
+  const result = connected.value;
+  return {
+    ok: !result?.isError,
+    result,
+    error: result?.isError ? JSON.stringify(result.content) : null,
+    latencyMs,
+    transport: connected.transport,
+  };
 }