replicas-mcp 0.2.21 → 0.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "replicas-mcp",
-  "version": "0.2.21",
+  "version": "0.3.0",
   "license": "UNLICENSED",
   "type": "module",
   "main": "dist/index.js",
@@ -13,8 +13,7 @@
     "start": "node dist/index.js"
   },
   "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.25.0",
-    "zod": "^4.0.0"
+    "@modelcontextprotocol/sdk": "^1.25.0"
   },
   "devDependencies": {
     "@types/node": "^20.11.17",

package/src/index.ts

@@ -1,29 +1,8 @@
-import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+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 { z } from 'zod';
-import type { CallToolResult } from '@modelcontextprotocol/sdk/types.js';
-import {
-  getCodingAgentDisplayNames,
-  getProviderDisplayName,
-  isValidAgentProvider,
-  type AgentProvider,
-} from '../../shared/src/agent';
-import {
-  parseAgentEvents,
-} from '../../shared/src/display-message/parsers';
-import {
-  type ReadReplicaHistoryResponse,
-} from '../../shared/src/routes/replica';
-import {
-  VALID_LIFECYCLE_POLICIES,
-} from '../../shared/src/routes/workspaces';
-import { type ListEnvironmentsResponse } from '../../shared/src/routes/environment';
-import {
-  automationRequestFromToolInput,
-  automationToolInputSchema,
-  environmentToolSummary,
-  REPLICAS_MCP_TOOLS,
-} from '../../shared/src/replicas-mcp';
+import { CallToolRequestSchema, ListToolsRequestSchema } from '@modelcontextprotocol/sdk/types.js';
 
 const API_URL = process.env.REPLICAS_API_URL || 'https://api.replicas.dev';
 const API_KEY = process.env.REPLICAS_API_KEY;
@@ -33,303 +12,16 @@ if (!API_KEY) {
   process.exit(1);
 }
 
-/**
- * Makes an authenticated request to the Replicas API.
- */
-async function api<T>(method: string, path: string, body?: unknown): Promise<T> {
-  const res = await fetch(`${API_URL}${path}`, {
-    method,
-    headers: {
-      'Authorization': `Bearer ${API_KEY}`,
-      'Content-Type': 'application/json',
-    },
-    body: body ? JSON.stringify(body) : undefined,
-  });
+const info = { name: 'replicas-mcp', version: '0.3.0' };
+const server = new Server(info, { capabilities: { tools: {} } });
+const remote = new Client(info);
+const url = new URL('/v1/mcp', API_URL);
+if (process.env.REPLICAS_MCP_TOOLSETS) url.searchParams.set('toolsets', process.env.REPLICAS_MCP_TOOLSETS);
+await remote.connect(new StreamableHTTPClientTransport(url, {
+  requestInit: { headers: { Authorization: `Bearer ${API_KEY}` } },
+}));
 
-  if (!res.ok) {
-    const text = await res.text();
-    throw new Error(`API error ${res.status}: ${text}`);
-  }
+server.setRequestHandler(ListToolsRequestSchema, (request) => remote.listTools(request.params));
+server.setRequestHandler(CallToolRequestSchema, (request) => remote.callTool(request.params));
 
-  return res.json() as Promise<T>;
-}
-
-/**
- * Creates a tool result with text content.
- */
-function result(data: unknown, isError = false): CallToolResult {
-  return {
-    content: [{
-      type: 'text',
-      text: typeof data === 'string' ? data : JSON.stringify(data, null, 2),
-    }],
-    ...(isError && { isError: true }),
-  };
-}
-
-/**
- * Type for registerTool to avoid deep type instantiation issues with Zod generics.
- */
-type RegisterToolFn = (
-  name: string,
-  config: { description?: string; inputSchema?: Record<string, unknown> },
-  handler: (args: Record<string, unknown>) => Promise<CallToolResult>
-) => void;
-
-const server = new McpServer({
-  name: 'replicas-mcp',
-  version: '0.2.21',
-});
-
-function registerTool(
-  name: string,
-  config: Parameters<RegisterToolFn>[1],
-  handler: (args: Record<string, unknown>) => Promise<unknown>,
-): void {
-  (server.registerTool.bind(server) as RegisterToolFn)(name, config, async (args) => {
-    try {
-      return result(await handler(args));
-    } catch (error) {
-      return result(error instanceof Error ? error.message : String(error), true);
-    }
-  });
-}
-
-const codingAgentSchema = z.string().refine(isValidAgentProvider, {
-  message: `Coding agent must be ${getCodingAgentDisplayNames()}`,
-});
-const lifecyclePolicySchema = z.enum(VALID_LIFECYCLE_POLICIES);
-
-// ---------------------------------------------------------------------------
-// Replica CRUD
-// ---------------------------------------------------------------------------
-
-registerTool(
-  'create_replica',
-  {
-    description: 'Create a new replica workspace and send initial message',
-    inputSchema: {
-      name: z.string().regex(/^\S+$/, 'Name cannot contain spaces'),
-      message: z.string(),
-      repository_ids: z.array(z.string()).min(1).optional().describe('Repository IDs to include. Mutually exclusive with repository_set_id.'),
-      repository_set_id: z.string().optional().describe('Repository set ID to use. Mutually exclusive with repository_ids.'),
-      coding_agent: codingAgentSchema.optional().describe('Coding agent to use (default: claude)'),
-      model: z.string().optional().describe('Model to use for the coding agent'),
-      lifecycle_policy: lifecyclePolicySchema.optional().describe('Lifecycle policy for the workspace'),
-    },
-  },
-  async (args) => {
-    const body: Record<string, unknown> = {
-      name: args.name,
-      message: args.message,
-    };
-    if (args.repository_ids) body.repository_ids = args.repository_ids;
-    if (args.repository_set_id) body.repository_set_id = args.repository_set_id;
-    if (args.coding_agent) body.coding_agent = args.coding_agent;
-    if (args.model) body.model = args.model;
-    if (args.lifecycle_policy) body.lifecycle_policy = args.lifecycle_policy;
-    return api('POST', '/v1/replica', body);
-  }
-);
-
-registerTool(
-  'list_replicas',
-  {
-    description: 'List all replicas with pagination and optional filters',
-    inputSchema: {
-      page: z.number().optional(),
-      limit: z.number().optional(),
-      user_id: z.string().optional().describe('Filter by creator user ID'),
-      source: z.enum(['api', 'dashboard', 'slack', 'linear', 'github', 'gitlab', 'automation']).optional().describe('Filter by creation source'),
-      status: z.enum(['active', 'sleeping', 'preparing']).optional().describe('Filter by workspace status'),
-    },
-  },
-  async (args) => {
-    const params = new URLSearchParams();
-    if (args.page) params.set('page', String(args.page));
-    if (args.limit) params.set('limit', String(args.limit));
-    if (args.user_id) params.set('user_id', args.user_id as string);
-    if (args.source) params.set('source', args.source as string);
-    if (args.status) params.set('status', args.status as string);
-    const q = params.toString();
-    return api('GET', `/v1/replica${q ? '?' + q : ''}`);
-  }
-);
-
-registerTool(
-  'get_replica',
-  {
-    description: 'Get replica details by ID, including current status, chats, and repository statuses',
-    inputSchema: {
-      id: z.string(),
-      include: z.array(z.enum(['environment', 'diffs'])).optional().describe('Extra data to include in response'),
-    },
-  },
-  async (args) => {
-    const params = new URLSearchParams();
-    if (args.include) params.set('include', (args.include as string[]).join(','));
-    const q = params.toString();
-    return api('GET', `/v1/replica/${args.id}${q ? '?' + q : ''}`);
-  }
-);
-
-registerTool(
-  'send_replica_message',
-  {
-    description: 'Send a message to an existing replica. Automatically handles waking sleeping replicas.',
-    inputSchema: {
-      id: z.string(),
-      message: z.string(),
-      coding_agent: codingAgentSchema.optional().describe('Coding agent to use'),
-      chat_id: z.string().optional().describe('Chat ID to send the message to (uses default chat if omitted)'),
-      model: z.string().optional().describe('Model to use'),
-      plan_mode: z.boolean().optional().describe('Whether to use plan mode'),
-    },
-  },
-  async (args) => {
-    const body: Record<string, unknown> = { message: args.message };
-    if (args.coding_agent) body.coding_agent = args.coding_agent;
-    if (args.chat_id) body.chat_id = args.chat_id;
-    if (args.model) body.model = args.model;
-    if (args.plan_mode !== undefined) body.plan_mode = args.plan_mode;
-    return api('POST', `/v1/replica/${args.id}/messages`, body);
-  }
-);
-
-registerTool(
-  'delete_replica',
-  {
-    description: 'Delete a replica. This terminates the workspace and cannot be undone.',
-    inputSchema: {
-      id: z.string(),
-    },
-  },
-  (args) => api('DELETE', `/v1/replica/${args.id}`)
-);
-
-// ---------------------------------------------------------------------------
-// Repositories & Repository Sets
-// ---------------------------------------------------------------------------
-
-registerTool(
-  'list_repositories',
-  {
-    description: 'List available repositories that can be used when creating replicas',
-  },
-  () => api('GET', '/v1/replica/repositories')
-);
-
-registerTool(
-  'list_repository_sets',
-  {
-    description: 'List available repository sets (named groups of repositories)',
-  },
-  () => api('GET', '/v1/replica/repository-sets')
-);
-
-// ---------------------------------------------------------------------------
-// Chat Management
-// ---------------------------------------------------------------------------
-
-registerTool(
-  'list_chats',
-  {
-    description: 'List chats in a replica workspace',
-    inputSchema: {
-      id: z.string().describe('Replica ID'),
-    },
-  },
-  (args) => api('GET', `/v1/replica/${args.id}/chats`)
-);
-
-registerTool(
-  'create_chat',
-  {
-    description: 'Create a new chat in a replica workspace',
-    inputSchema: {
-      id: z.string().describe('Replica ID'),
-      provider: codingAgentSchema.describe('Coding agent provider for the chat'),
-      title: z.string().optional().describe('Optional title for the chat'),
-    },
-  },
-  async (args) => {
-    const body: Record<string, unknown> = { provider: args.provider };
-    if (args.title) body.title = args.title;
-    return api('POST', `/v1/replica/${args.id}/chats`, body);
-  }
-);
-
-registerTool(
-  'delete_chat',
-  {
-    description: 'Delete a chat from a replica workspace',
-    inputSchema: {
-      id: z.string().describe('Replica ID'),
-      chat_id: z.string().describe('Chat ID to delete'),
-    },
-  },
-  (args) => api('DELETE', `/v1/replica/${args.id}/chats/${args.chat_id}`)
-);
-
-// ---------------------------------------------------------------------------
-// History & Hooks
-// ---------------------------------------------------------------------------
-
-registerTool(
-  'read_replica_history',
-  {
-    description: 'Read conversation history of a replica. Returns parsed DisplayMessage objects (user messages, agent responses, commands, file changes, tool calls, etc). If the workspace is sleeping, it will be woken and you should retry in 30-90 seconds.',
-    inputSchema: {
-      id: z.string(),
-      chat_id: z.string().optional().describe('Read history for a specific chat (uses default chat if omitted)'),
-    },
-  },
-  async (args) => {
-    const params = new URLSearchParams();
-    if (args.chat_id) params.set('chat_id', args.chat_id as string);
-    const q = params.toString();
-    const response = await api<ReadReplicaHistoryResponse>('GET', `/v1/replica/${args.id}/history${q ? '?' + q : ''}`);
-
-    const agentType = (response.coding_agent || 'claude') as AgentProvider;
-    const messages = parseAgentEvents(response.events, agentType);
-
-    return {
-      thread_id: response.thread_id,
-      coding_agent: response.coding_agent,
-      total: response.total,
-      has_more: response.has_more,
-      messages,
-    };
-  }
-);
-
-registerTool(
-  'get_replica_hooks',
-  {
-    description: 'Get warm and start hook logs for a replica workspace',
-    inputSchema: {
-      id: z.string().describe('Replica ID'),
-    },
-  },
-  (args) => api('GET', `/v1/replica/${args.id}/hooks`)
-);
-
-registerTool(
-  REPLICAS_MCP_TOOLS.listEnvironments,
-  {
-    description: "List the organization's environments with their ids, descriptions, and repository bindings, for choosing an environment_id",
-  },
-  async () => (await api<ListEnvironmentsResponse>('GET', '/v1/environments')).environments.map(environmentToolSummary)
-);
-
-registerTool(
-  REPLICAS_MCP_TOOLS.createAutomation,
-  {
-    description: 'Create an organization automation that runs a prompt in an environment on a schedule or event trigger',
-    inputSchema: automationToolInputSchema.shape,
-  },
-  (args) => api('POST', '/v1/automations', automationRequestFromToolInput(automationToolInputSchema.parse(args)))
-);
-
-const transport = new StdioServerTransport();
-await server.connect(transport);
+await server.connect(new StdioServerTransport());