@heyclaude/mcp 0.1.0

package/src/remote-proxy.js

@@ -0,0 +1,151 @@
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema,
+} 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";
+
+function toError(error) {
+  if (error instanceof Error) return error;
+  return new Error(String(error));
+}
+
+function safeErrorMessage(error) {
+  return toError(error).message || "Remote MCP request failed.";
+}
+
+function createTimeoutFetch(timeoutMs) {
+  return async (url, init = {}) => {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), timeoutMs);
+    const inputSignal = init.signal;
+
+    const abortFromInput = () => controller.abort();
+    if (inputSignal) {
+      if (inputSignal.aborted) controller.abort();
+      else
+        inputSignal.addEventListener("abort", abortFromInput, { once: true });
+    }
+
+    try {
+      return await fetch(url, { ...init, signal: controller.signal });
+    } finally {
+      clearTimeout(timeout);
+      if (inputSignal) {
+        inputSignal.removeEventListener("abort", abortFromInput);
+      }
+    }
+  };
+}
+
+function invalidToolResult(name) {
+  return {
+    isError: true,
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify(
+          {
+            ok: false,
+            error: {
+              code: "invalid_request",
+              message: `Unknown or unsupported HeyClaude MCP tool: ${name}`,
+            },
+          },
+          null,
+          2,
+        ),
+      },
+    ],
+  };
+}
+
+function errorToolResult(error) {
+  return {
+    isError: true,
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify(
+          {
+            ok: false,
+            error: {
+              code: "remote_mcp_error",
+              message: safeErrorMessage(error),
+            },
+          },
+          null,
+          2,
+        ),
+      },
+    ],
+  };
+}
+
+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 });
+
+  const server = new Server(
+    {
+      name: "heyclaude-registry",
+      version: packageVersion,
+    },
+    {
+      capabilities: {
+        tools: {},
+      },
+    },
+  );
+
+  server.setRequestHandler(ListToolsRequestSchema, async () => ({
+    tools: TOOL_DEFINITIONS,
+  }));
+
+  server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const name = request.params.name;
+    if (!READ_ONLY_TOOL_NAMES.includes(name)) {
+      return invalidToolResult(name);
+    }
+
+    try {
+      return await client.callTool(
+        {
+          name,
+          arguments: request.params.arguments || {},
+        },
+        undefined,
+        { timeout: timeoutMs },
+      );
+    } catch (error) {
+      return errorToolResult(error);
+    }
+  });
+
+  server.onclose = () => {
+    client.close().catch(() => {});
+  };
+
+  return { server, client, endpointUrl, timeoutMs };
+}
+
+export async function runRemoteStdioProxy(options = {}) {
+  const { server } = await createRemoteMcpProxyServer(options);
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+}

package/src/schemas.d.ts

@@ -0,0 +1,24 @@
+import type { z } from "zod";
+
+export const SearchRegistryInputSchema: z.ZodType;
+export const EntryDetailInputSchema: z.ZodType;
+export const CompatibilityInputSchema: z.ZodType;
+export const InstallGuidanceInputSchema: z.ZodType;
+export const PlatformAdapterInputSchema: z.ZodType;
+export const ListDistributionFeedsInputSchema: z.ZodType;
+export const SubmissionFieldsSchema: z.ZodType;
+export const GetSubmissionSchemaInputSchema: z.ZodType;
+export const ValidateSubmissionDraftInputSchema: z.ZodType;
+export const SearchDuplicateEntriesInputSchema: z.ZodType;
+export const BuildSubmissionUrlsInputSchema: z.ZodType;
+export const CategorySubmissionGuidanceInputSchema: z.ZodType;
+export const TOOL_INPUT_SCHEMAS: Record<string, z.ZodType>;
+
+export function jsonSchemaForTool(name: string): Record<string, unknown>;
+export function parseToolArguments(
+  name: string,
+  args?: Record<string, unknown>,
+): Record<string, unknown>;
+export function formatZodError(
+  error: unknown,
+): Array<{ path: string; message: string; code: string }> | null;

package/src/schemas.js

@@ -0,0 +1,198 @@
+import { z } from "zod";
+
+const pathPart = z
+  .string()
+  .trim()
+  .min(1)
+  .max(120)
+  .regex(/^[a-z0-9-]+$/, "Use lowercase slug-safe path parts only.");
+
+const platform = z.string().trim().min(1).max(80);
+const submissionCategory = z.enum([
+  "agents",
+  "rules",
+  "mcp",
+  "skills",
+  "hooks",
+  "commands",
+  "statuslines",
+  "collections",
+  "guides",
+]);
+const optionalText = z.string().trim().max(4000).optional();
+const optionalLongText = z.string().trim().max(24000).optional();
+const optionalTags = z
+  .union([
+    z.string().trim().max(1000),
+    z.array(z.string().trim().min(1).max(80)).max(20),
+  ])
+  .optional();
+
+export const SubmissionFieldsSchema = z
+  .object({
+    name: optionalText,
+    title: optionalText,
+    slug: pathPart.optional(),
+    category: submissionCategory.optional(),
+    github_url: optionalText,
+    docs_url: optionalText,
+    source_url: optionalText,
+    brand_name: optionalText,
+    brand_domain: optionalText,
+    author: optionalText,
+    contact_email: optionalText,
+    tags: optionalTags,
+    description: optionalLongText,
+    card_description: optionalText,
+    full_copyable_content: optionalLongText,
+    install_command: optionalText,
+    usage_snippet: optionalLongText,
+    command_syntax: optionalText,
+    trigger: optionalText,
+    guide_content: optionalLongText,
+    items: optionalLongText,
+    script_language: optionalText,
+    skill_type: optionalText,
+    skill_level: optionalText,
+    verification_status: optionalText,
+    verified_at: optionalText,
+    download_url: optionalText,
+    config_snippet: optionalLongText,
+    retrieval_sources: optionalLongText,
+    tested_platforms: optionalText,
+    prerequisites: optionalLongText,
+    troubleshooting_section: optionalLongText,
+    installation_order: optionalText,
+    estimated_setup_time: optionalText,
+    difficulty: optionalText,
+  })
+  .strict();
+
+export const SearchRegistryInputSchema = z
+  .object({
+    query: z.string().trim().max(240).optional(),
+    category: pathPart.optional(),
+    platform: platform.optional(),
+    limit: z.number().int().min(1).max(25).optional(),
+  })
+  .strict();
+
+export const EntryDetailInputSchema = z
+  .object({
+    category: pathPart,
+    slug: pathPart,
+  })
+  .strict();
+
+export const CompatibilityInputSchema = z
+  .object({
+    category: pathPart.optional(),
+    slug: pathPart,
+  })
+  .strict();
+
+export const InstallGuidanceInputSchema = z
+  .object({
+    category: pathPart,
+    slug: pathPart,
+    platform: platform.optional(),
+  })
+  .strict();
+
+export const PlatformAdapterInputSchema = z
+  .object({
+    slug: pathPart,
+    platform: platform.optional(),
+  })
+  .strict();
+
+export const ListDistributionFeedsInputSchema = z.object({}).strict();
+
+export const GetSubmissionSchemaInputSchema = z
+  .object({
+    category: submissionCategory.optional(),
+  })
+  .strict();
+
+export const ValidateSubmissionDraftInputSchema = z
+  .object({
+    fields: SubmissionFieldsSchema,
+  })
+  .strict();
+
+export const SearchDuplicateEntriesInputSchema = z
+  .object({
+    category: pathPart.optional(),
+    slug: pathPart.optional(),
+    name: z.string().trim().min(1).max(240).optional(),
+    title: z.string().trim().min(1).max(240).optional(),
+    sourceUrl: z.string().trim().min(1).max(500).optional(),
+    brandDomain: z.string().trim().min(1).max(255).optional(),
+    limit: z.number().int().min(1).max(10).optional(),
+  })
+  .strict();
+
+export const BuildSubmissionUrlsInputSchema = z
+  .object({
+    fields: SubmissionFieldsSchema,
+    includeIssueBody: z.boolean().optional(),
+  })
+  .strict();
+
+export const CategorySubmissionGuidanceInputSchema = z
+  .object({
+    category: submissionCategory.optional(),
+  })
+  .strict();
+
+export const TOOL_INPUT_SCHEMAS = {
+  search_registry: SearchRegistryInputSchema,
+  get_entry_detail: EntryDetailInputSchema,
+  get_compatibility: CompatibilityInputSchema,
+  get_install_guidance: InstallGuidanceInputSchema,
+  get_platform_adapter: PlatformAdapterInputSchema,
+  list_distribution_feeds: ListDistributionFeedsInputSchema,
+  get_submission_schema: GetSubmissionSchemaInputSchema,
+  validate_submission_draft: ValidateSubmissionDraftInputSchema,
+  search_duplicate_entries: SearchDuplicateEntriesInputSchema,
+  build_submission_urls: BuildSubmissionUrlsInputSchema,
+  get_category_submission_guidance: CategorySubmissionGuidanceInputSchema,
+};
+
+function stripUnsupportedJsonSchemaFields(value) {
+  if (Array.isArray(value)) {
+    return value.map(stripUnsupportedJsonSchemaFields);
+  }
+  if (!value || typeof value !== "object") return value;
+
+  return Object.fromEntries(
+    Object.entries(value)
+      .filter(([key]) => key !== "$schema")
+      .map(([key, nested]) => [key, stripUnsupportedJsonSchemaFields(nested)]),
+  );
+}
+
+export function jsonSchemaForTool(name) {
+  const schema = TOOL_INPUT_SCHEMAS[name];
+  if (!schema) {
+    throw new Error(`Unknown HeyClaude MCP tool schema: ${name}`);
+  }
+  return stripUnsupportedJsonSchemaFields(z.toJSONSchema(schema));
+}
+
+export function parseToolArguments(name, args = {}) {
+  const schema = TOOL_INPUT_SCHEMAS[name];
+  if (!schema) {
+    throw new Error(`Unknown HeyClaude MCP tool schema: ${name}`);
+  }
+  return schema.parse(args || {});
+}
+
+export function formatZodError(error) {
+  if (!(error instanceof z.ZodError)) return null;
+  return error.issues.map((issue) => ({
+    path: issue.path.join("."),
+    message: issue.message,
+    code: issue.code,
+  }));
+}

package/src/server.d.ts

@@ -0,0 +1,10 @@
+import type { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import type { RegistryArtifactLoaders } from "./registry.js";
+
+export function createHeyClaudeMcpServer(
+  options?: RegistryArtifactLoaders,
+): Server;
+
+export function runStdioServer(
+  options?: RegistryArtifactLoaders,
+): Promise<void>;

package/src/server.js

@@ -0,0 +1,52 @@
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema,
+} from "@modelcontextprotocol/sdk/types.js";
+
+import { packageVersion } from "./package-metadata.js";
+import { callRegistryTool, TOOL_DEFINITIONS } from "./registry.js";
+
+export function createHeyClaudeMcpServer(options = {}) {
+  const server = new Server(
+    {
+      name: "heyclaude-registry",
+      version: packageVersion,
+    },
+    {
+      capabilities: {
+        tools: {},
+      },
+    },
+  );
+
+  server.setRequestHandler(ListToolsRequestSchema, async () => ({
+    tools: TOOL_DEFINITIONS,
+  }));
+
+  server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const result = await callRegistryTool(
+      request.params.name,
+      request.params.arguments || {},
+      options,
+    );
+    return {
+      isError: result.ok === false,
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(result, null, 2),
+        },
+      ],
+    };
+  });
+
+  return server;
+}
+
+export async function runStdioServer(options = {}) {
+  const server = createHeyClaudeMcpServer(options);
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+}

package/src/submissions.d.ts

@@ -0,0 +1,31 @@
+export const SUBMISSION_SITE_URL: string;
+export const GITHUB_NEW_ISSUE_URL: string;
+
+export function slugify(value: string): string;
+export function normalizeSubmissionFields(
+  fields?: Record<string, unknown>,
+): Record<string, string>;
+export function buildIssueDraftFromSpec(
+  spec: Record<string, unknown>,
+  fields?: Record<string, unknown>,
+): Record<string, unknown>;
+export function buildSubmissionUrlsFromSpec(
+  spec: Record<string, unknown>,
+  args?: Record<string, unknown>,
+): Record<string, unknown>;
+export function getSubmissionSchemaFromSpec(
+  spec: Record<string, unknown>,
+  args?: Record<string, unknown>,
+): Record<string, unknown>;
+export function validateSubmissionDraftFromSpec(
+  spec: Record<string, unknown>,
+  args?: Record<string, unknown>,
+): Record<string, unknown>;
+export function searchDuplicateEntries(
+  entries?: Array<Record<string, unknown>>,
+  args?: Record<string, unknown>,
+): Record<string, unknown>;
+export function getCategorySubmissionGuidanceFromSpec(
+  spec: Record<string, unknown>,
+  args?: Record<string, unknown>,
+): Record<string, unknown>;