@heyclaude/mcp 0.1.1 → 0.2.0

package/src/remote-proxy.d.ts

@@ -14,6 +14,26 @@ export function createRemoteMcpProxyServer(
   timeoutMs: number;
 }>;
 
+export function createRemoteMcpProxyServerFromClient(
+  client: {
+    getServerCapabilities: () => Record<string, unknown> | undefined;
+    listTools: (...args: unknown[]) => Promise<{ tools: Array<unknown> }>;
+    callTool: (...args: unknown[]) => Promise<unknown>;
+    listResources?: (...args: unknown[]) => Promise<unknown>;
+    listResourceTemplates?: (...args: unknown[]) => Promise<unknown>;
+    readResource?: (...args: unknown[]) => Promise<unknown>;
+    listPrompts?: (...args: unknown[]) => Promise<unknown>;
+    getPrompt?: (...args: unknown[]) => Promise<unknown>;
+    close?: () => Promise<void>;
+  },
+  options?: RemoteProxyOptions,
+): Promise<{
+  server: Server;
+  client: unknown;
+  endpointUrl: URL;
+  timeoutMs: number;
+}>;
+
 export function runRemoteStdioProxy(
   options?: RemoteProxyOptions,
 ): Promise<void>;

package/src/remote-proxy.js

@@ -4,12 +4,17 @@ import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import {
   CallToolRequestSchema,
+  GetPromptRequestSchema,
   ListToolsRequestSchema,
+  ListPromptsRequestSchema,
+  ListResourcesRequestSchema,
+  ListResourceTemplatesRequestSchema,
+  ReadResourceRequestSchema,
 } from "@modelcontextprotocol/sdk/types.js";
 
 import { normalizeEndpointUrl, normalizeTimeoutMs } from "./endpoint-url.js";
 import { packageVersion } from "./package-metadata.js";
-import { READ_ONLY_TOOL_NAMES, TOOL_DEFINITIONS } from "./registry.js";
+import { MCP_PUBLIC_POLICY, READ_ONLY_TOOL_NAMES } from "./registry.js";
 
 function toError(error) {
   if (error instanceof Error) return error;
@@ -34,7 +39,11 @@ function createTimeoutFetch(timeoutMs) {
     }
 
     try {
-      return await fetch(url, { ...init, signal: controller.signal });
+      return await fetch(url, {
+        ...init,
+        redirect: "error",
+        signal: controller.signal,
+      });
     } finally {
       clearTimeout(timeout);
       if (inputSignal) {
@@ -45,86 +54,146 @@ function createTimeoutFetch(timeoutMs) {
 }
 
 function invalidToolResult(name) {
+  const structuredContent = {
+    ok: false,
+    error: {
+      code: "invalid_request",
+      message: `Unknown or unsupported HeyClaude MCP tool: ${name}`,
+    },
+    policy: MCP_PUBLIC_POLICY,
+  };
   return {
     isError: true,
+    structuredContent,
     content: [
       {
         type: "text",
-        text: JSON.stringify(
-          {
-            ok: false,
-            error: {
-              code: "invalid_request",
-              message: `Unknown or unsupported HeyClaude MCP tool: ${name}`,
-            },
-          },
-          null,
-          2,
-        ),
+        text: JSON.stringify(structuredContent, null, 2),
       },
     ],
   };
 }
 
 function errorToolResult(error) {
+  const structuredContent = {
+    ok: false,
+    error: {
+      code: "remote_mcp_error",
+      message: safeErrorMessage(error),
+    },
+    policy: MCP_PUBLIC_POLICY,
+  };
   return {
     isError: true,
+    structuredContent,
     content: [
       {
         type: "text",
-        text: JSON.stringify(
-          {
-            ok: false,
-            error: {
-              code: "remote_mcp_error",
-              message: safeErrorMessage(error),
-            },
-          },
-          null,
-          2,
-        ),
+        text: JSON.stringify(structuredContent, null, 2),
       },
     ],
   };
 }
 
-export async function createRemoteMcpProxyServer(options = {}) {
+function readOnlyToolDefinition(tool) {
+  if (!READ_ONLY_TOOL_NAMES.includes(tool?.name)) return null;
+  return {
+    ...tool,
+    annotations: {
+      ...(tool.annotations || {}),
+      readOnlyHint: true,
+      destructiveHint: false,
+      idempotentHint: true,
+      openWorldHint: false,
+    },
+  };
+}
+
+function parseTextToolPayload(result) {
+  const text = result?.content?.find((item) => item.type === "text")?.text;
+  if (!text) return null;
+  try {
+    const parsed = JSON.parse(text);
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed)
+      ? parsed
+      : null;
+  } catch {
+    return null;
+  }
+}
+
+function withPolicy(payload) {
+  if (!payload || typeof payload !== "object" || Array.isArray(payload)) {
+    return payload;
+  }
+  if (payload.policy) return payload;
+  return { ...payload, policy: MCP_PUBLIC_POLICY };
+}
+
+function normalizeForwardedToolResult(result) {
+  if (!result || typeof result !== "object") return result;
+  if (result.structuredContent) {
+    return {
+      ...result,
+      structuredContent: withPolicy(result.structuredContent),
+    };
+  }
+
+  const parsed = parseTextToolPayload(result);
+  if (parsed) {
+    return {
+      ...result,
+      structuredContent: withPolicy(parsed),
+    };
+  }
+
+  return {
+    ...result,
+    structuredContent: {
+      ok: result.isError !== true,
+      policy: MCP_PUBLIC_POLICY,
+    },
+  };
+}
+
+export async function createRemoteMcpProxyServerFromClient(
+  client,
+  options = {},
+) {
   const endpointUrl = normalizeEndpointUrl(options.url);
   const timeoutMs = normalizeTimeoutMs(options.timeoutMs);
-  const client = new Client({
-    name: "heyclaude-mcp-stdio-proxy",
-    version: packageVersion,
-  });
-  const remoteTransport = new StreamableHTTPClientTransport(endpointUrl, {
-    fetch: createTimeoutFetch(timeoutMs),
-  });
-
-  await client.connect(remoteTransport, { timeout: timeoutMs });
+  const remoteCapabilities = client.getServerCapabilities() || {};
+  const remoteTools = await client.listTools(undefined, { timeout: timeoutMs });
+  const toolDefinitions = remoteTools.tools
+    .map(readOnlyToolDefinition)
+    .filter(Boolean);
+  const supportedToolNames = new Set(toolDefinitions.map((tool) => tool.name));
+  const capabilities = {
+    tools: {},
+    ...(remoteCapabilities.resources ? { resources: {} } : {}),
+    ...(remoteCapabilities.prompts ? { prompts: {} } : {}),
+  };
 
   const server = new Server(
     {
       name: "heyclaude-registry",
       version: packageVersion,
     },
-    {
-      capabilities: {
-        tools: {},
-      },
-    },
+    { capabilities },
   );
 
   server.setRequestHandler(ListToolsRequestSchema, async () => ({
-    tools: TOOL_DEFINITIONS,
+    tools: toolDefinitions,
   }));
 
   server.setRequestHandler(CallToolRequestSchema, async (request) => {
     const name = request.params.name;
-    if (!READ_ONLY_TOOL_NAMES.includes(name)) {
+    if (!supportedToolNames.has(name)) {
       return invalidToolResult(name);
     }
 
     try {
-      return await client.callTool(
+      const result = await client.callTool(
         {
           name,
           arguments: request.params.arguments || {},
@@ -132,11 +201,37 @@ export async function createRemoteMcpProxyServer(options = {}) {
         undefined,
         { timeout: timeoutMs },
       );
+      return normalizeForwardedToolResult(result);
     } catch (error) {
       return errorToolResult(error);
     }
   });
 
+  if (remoteCapabilities.resources) {
+    server.setRequestHandler(ListResourcesRequestSchema, async (request) =>
+      client.listResources(request.params || {}, { timeout: timeoutMs }),
+    );
+    server.setRequestHandler(
+      ListResourceTemplatesRequestSchema,
+      async (request) =>
+        client.listResourceTemplates(request.params || {}, {
+          timeout: timeoutMs,
+        }),
+    );
+    server.setRequestHandler(ReadResourceRequestSchema, async (request) =>
+      client.readResource(request.params || {}, { timeout: timeoutMs }),
+    );
+  }
+
+  if (remoteCapabilities.prompts) {
+    server.setRequestHandler(ListPromptsRequestSchema, async (request) =>
+      client.listPrompts(request.params || {}, { timeout: timeoutMs }),
+    );
+    server.setRequestHandler(GetPromptRequestSchema, async (request) =>
+      client.getPrompt(request.params || {}, { timeout: timeoutMs }),
+    );
+  }
+
   server.onclose = () => {
     client.close().catch(() => {});
   };
@@ -144,6 +239,24 @@ export async function createRemoteMcpProxyServer(options = {}) {
   return { server, client, endpointUrl, timeoutMs };
 }
 
+export async function createRemoteMcpProxyServer(options = {}) {
+  const endpointUrl = normalizeEndpointUrl(options.url);
+  const timeoutMs = normalizeTimeoutMs(options.timeoutMs);
+  const client = new Client({
+    name: "heyclaude-mcp-stdio-proxy",
+    version: packageVersion,
+  });
+  const remoteTransport = new StreamableHTTPClientTransport(endpointUrl, {
+    fetch: createTimeoutFetch(timeoutMs),
+  });
+
+  await client.connect(remoteTransport, { timeout: timeoutMs });
+  return createRemoteMcpProxyServerFromClient(client, {
+    url: endpointUrl,
+    timeoutMs,
+  });
+}
+
 export async function runRemoteStdioProxy(options = {}) {
   const { server } = await createRemoteMcpProxyServer(options);
   const transport = new StdioServerTransport();

package/src/schemas.d.ts

@@ -1,7 +1,15 @@
 import type { z } from "zod";
 
 export const SearchRegistryInputSchema: z.ZodType;
+export const ServerInfoInputSchema: z.ZodType;
+export const ListCategoryEntriesInputSchema: z.ZodType;
+export const RecentUpdatesInputSchema: z.ZodType;
+export const RelatedEntriesInputSchema: z.ZodType;
 export const EntryDetailInputSchema: z.ZodType;
+export const CopyableAssetInputSchema: z.ZodType;
+export const CompareEntriesInputSchema: z.ZodType;
+export const RegistryStatsInputSchema: z.ZodType;
+export const ClientSetupInputSchema: z.ZodType;
 export const CompatibilityInputSchema: z.ZodType;
 export const InstallGuidanceInputSchema: z.ZodType;
 export const PlatformAdapterInputSchema: z.ZodType;
@@ -12,9 +20,13 @@ export const ValidateSubmissionDraftInputSchema: z.ZodType;
 export const SearchDuplicateEntriesInputSchema: z.ZodType;
 export const BuildSubmissionUrlsInputSchema: z.ZodType;
 export const CategorySubmissionGuidanceInputSchema: z.ZodType;
+export const PrepareSubmissionDraftInputSchema: z.ZodType;
+export const GetSubmissionExamplesInputSchema: z.ZodType;
+export const ReviewSubmissionDraftInputSchema: z.ZodType;
 export const TOOL_INPUT_SCHEMAS: Record<string, z.ZodType>;
 
 export function jsonSchemaForTool(name: string): Record<string, unknown>;
+export function jsonSchemaForToolOutput(name: string): Record<string, unknown>;
 export function parseToolArguments(
   name: string,
   args?: Record<string, unknown>,

package/src/schemas.js

@@ -8,6 +8,13 @@ const pathPart = z
   .regex(/^[a-z0-9-]+$/, "Use lowercase slug-safe path parts only.");
 
 const platform = z.string().trim().min(1).max(80);
+const clientName = z.enum([
+  "codex",
+  "claude-desktop",
+  "cursor",
+  "windsurf",
+  "remote-http",
+]);
 const submissionCategory = z.enum([
   "agents",
   "rules",
@@ -77,6 +84,35 @@ export const SearchRegistryInputSchema = z
   })
   .strict();
 
+export const ServerInfoInputSchema = z.object({}).strict();
+
+export const ListCategoryEntriesInputSchema = z
+  .object({
+    category: pathPart.optional(),
+    platform: platform.optional(),
+    tag: z.string().trim().min(1).max(80).optional(),
+    query: z.string().trim().max(240).optional(),
+    offset: z.number().int().min(0).max(5000).optional(),
+    limit: z.number().int().min(1).max(25).optional(),
+  })
+  .strict();
+
+export const RecentUpdatesInputSchema = z
+  .object({
+    category: pathPart.optional(),
+    since: z.string().trim().min(4).max(40).optional(),
+    limit: z.number().int().min(1).max(25).optional(),
+  })
+  .strict();
+
+export const RelatedEntriesInputSchema = z
+  .object({
+    category: pathPart,
+    slug: pathPart,
+    limit: z.number().int().min(1).max(25).optional(),
+  })
+  .strict();
+
 export const EntryDetailInputSchema = z
   .object({
     category: pathPart,
@@ -84,6 +120,40 @@ export const EntryDetailInputSchema = z
   })
   .strict();
 
+export const CopyableAssetInputSchema = z
+  .object({
+    category: pathPart,
+    slug: pathPart,
+    platform: platform.optional(),
+  })
+  .strict();
+
+export const CompareEntriesInputSchema = z
+  .object({
+    entries: z
+      .array(
+        z
+          .object({
+            category: pathPart,
+            slug: pathPart,
+          })
+          .strict(),
+      )
+      .min(2)
+      .max(5),
+    platform: platform.optional(),
+  })
+  .strict();
+
+export const RegistryStatsInputSchema = z.object({}).strict();
+
+export const ClientSetupInputSchema = z
+  .object({
+    client: clientName.optional(),
+    endpointUrl: z.string().trim().url().max(500).optional(),
+  })
+  .strict();
+
 export const CompatibilityInputSchema = z
   .object({
     category: pathPart.optional(),
@@ -145,9 +215,36 @@ export const CategorySubmissionGuidanceInputSchema = z
   })
   .strict();
 
+export const PrepareSubmissionDraftInputSchema = z
+  .object({
+    fields: SubmissionFieldsSchema,
+  })
+  .strict();
+
+export const GetSubmissionExamplesInputSchema = z
+  .object({
+    category: submissionCategory.optional(),
+  })
+  .strict();
+
+export const ReviewSubmissionDraftInputSchema = z
+  .object({
+    fields: SubmissionFieldsSchema,
+    duplicateLimit: z.number().int().min(1).max(10).optional(),
+  })
+  .strict();
+
 export const TOOL_INPUT_SCHEMAS = {
   search_registry: SearchRegistryInputSchema,
+  server_info: ServerInfoInputSchema,
+  list_category_entries: ListCategoryEntriesInputSchema,
+  get_recent_updates: RecentUpdatesInputSchema,
+  get_related_entries: RelatedEntriesInputSchema,
   get_entry_detail: EntryDetailInputSchema,
+  get_copyable_asset: CopyableAssetInputSchema,
+  compare_entries: CompareEntriesInputSchema,
+  get_registry_stats: RegistryStatsInputSchema,
+  get_client_setup: ClientSetupInputSchema,
   get_compatibility: CompatibilityInputSchema,
   get_install_guidance: InstallGuidanceInputSchema,
   get_platform_adapter: PlatformAdapterInputSchema,
@@ -157,6 +254,9 @@ export const TOOL_INPUT_SCHEMAS = {
   search_duplicate_entries: SearchDuplicateEntriesInputSchema,
   build_submission_urls: BuildSubmissionUrlsInputSchema,
   get_category_submission_guidance: CategorySubmissionGuidanceInputSchema,
+  prepare_submission_draft: PrepareSubmissionDraftInputSchema,
+  get_submission_examples: GetSubmissionExamplesInputSchema,
+  review_submission_draft: ReviewSubmissionDraftInputSchema,
 };
 
 function stripUnsupportedJsonSchemaFields(value) {
@@ -180,6 +280,25 @@ export function jsonSchemaForTool(name) {
   return stripUnsupportedJsonSchemaFields(z.toJSONSchema(schema));
 }
 
+export function jsonSchemaForToolOutput(name) {
+  if (!TOOL_INPUT_SCHEMAS[name]) {
+    throw new Error(`Unknown HeyClaude MCP tool output schema: ${name}`);
+  }
+
+  return {
+    type: "object",
+    properties: {
+      ok: { type: "boolean" },
+      policy: {
+        type: "object",
+        additionalProperties: true,
+      },
+    },
+    required: ["ok"],
+    additionalProperties: true,
+  };
+}
+
 export function parseToolArguments(name, args = {}) {
   const schema = TOOL_INPUT_SCHEMAS[name];
   if (!schema) {

package/src/server.js

@@ -2,11 +2,24 @@ import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import {
   CallToolRequestSchema,
+  GetPromptRequestSchema,
+  ListPromptsRequestSchema,
+  ListResourcesRequestSchema,
+  ListResourceTemplatesRequestSchema,
   ListToolsRequestSchema,
+  ReadResourceRequestSchema,
 } from "@modelcontextprotocol/sdk/types.js";
 
 import { packageVersion } from "./package-metadata.js";
-import { callRegistryTool, TOOL_DEFINITIONS } from "./registry.js";
+import {
+  callRegistryTool,
+  getRegistryPrompt,
+  listRegistryPrompts,
+  listRegistryResources,
+  listRegistryResourceTemplates,
+  readRegistryResource,
+  TOOL_DEFINITIONS,
+} from "./registry.js";
 
 export function createHeyClaudeMcpServer(options = {}) {
   const server = new Server(
@@ -16,6 +29,8 @@ export function createHeyClaudeMcpServer(options = {}) {
     },
     {
       capabilities: {
+        prompts: {},
+        resources: {},
         tools: {},
       },
     },
@@ -33,6 +48,10 @@ export function createHeyClaudeMcpServer(options = {}) {
     );
     return {
       isError: result.ok === false,
+      structuredContent:
+        result && typeof result === "object" && !Array.isArray(result)
+          ? result
+          : { result },
       content: [
         {
           type: "text",
@@ -42,6 +61,26 @@ export function createHeyClaudeMcpServer(options = {}) {
     };
   });
 
+  server.setRequestHandler(ListResourcesRequestSchema, async (request) =>
+    listRegistryResources(request.params || {}, options),
+  );
+
+  server.setRequestHandler(ListResourceTemplatesRequestSchema, async () =>
+    listRegistryResourceTemplates(),
+  );
+
+  server.setRequestHandler(ReadResourceRequestSchema, async (request) =>
+    readRegistryResource(request.params || {}, options),
+  );
+
+  server.setRequestHandler(ListPromptsRequestSchema, async () =>
+    listRegistryPrompts(),
+  );
+
+  server.setRequestHandler(GetPromptRequestSchema, async (request) =>
+    getRegistryPrompt(request.params || {}),
+  );
+
   return server;
 }
 

package/src/submissions.d.ts

@@ -21,6 +21,19 @@ export function validateSubmissionDraftFromSpec(
   spec: Record<string, unknown>,
   args?: Record<string, unknown>,
 ): Record<string, unknown>;
+export function prepareSubmissionDraftFromSpec(
+  spec: Record<string, unknown>,
+  args?: Record<string, unknown>,
+): Record<string, unknown>;
+export function getSubmissionExamplesFromSpec(
+  spec: Record<string, unknown>,
+  args?: Record<string, unknown>,
+): Record<string, unknown>;
+export function reviewSubmissionDraftFromSpec(
+  spec: Record<string, unknown>,
+  args?: Record<string, unknown>,
+  entries?: Array<Record<string, unknown>>,
+): Record<string, unknown>;
 export function searchDuplicateEntries(
   entries?: Array<Record<string, unknown>>,
   args?: Record<string, unknown>,