projects

Implementation Reference

• src/mcp/tools/projects.ts:19-62 (handler)

  The main handler function for the 'projects' tool. Routes operations (list, get, create, update, delete, environment, resources) to the corresponding generated SDK functions via safeApiCall.

  export async function projectsHandler(args: ProjectsToolArgs) {
    const { operation, id, environmentNameOrUuid, body } = args;
    
    switch (operation) {
      case 'list':
        return await safeApiCall(() => listProjects());
        
      case 'get':
        if (!id) throw new Error('ID required for get operation');
        return await safeApiCall(() => getProjectByUuid({ path: { uuid: id } }));
        
      case 'create':
        if (!body) throw new Error('Body required for create operation');
        const createData = JSON.parse(body);
        return await safeApiCall(() => createProject({ body: createData }));
        
      case 'update':
        if (!id || !body) throw new Error('ID and body required for update operation');
        const updateData = JSON.parse(body);
        return await safeApiCall(() => updateProjectByUuid({ 
          path: { uuid: id }, 
          body: updateData 
        } as any));
        
      case 'delete':
        if (!id) throw new Error('ID required for delete operation');
        return await safeApiCall(() => deleteProjectByUuid({ path: { uuid: id } }));
        
      case 'environment':
        if (!id || !environmentNameOrUuid) throw new Error('ID and environmentNameOrUuid required for environment operation');
        return await safeApiCall(() => getEnvironmentByNameOrUuid({ 
          path: { 
            uuid: id, 
            environment_name_or_uuid: environmentNameOrUuid 
          } 
        }));
        
      case 'resources':
        return await safeApiCall(() => listResources());
        
      default:
        throw new Error(`Unknown operation: ${operation}`);
    }
  }

• src/mcp-server.ts:183-219 (registration)

  Registers the 'projects' tool with the MCP server, defining the Zod schema (operation enum, optional id/environmentNameOrUuid/body) and calling projectsHandler.

  server.tool(
    'projects',
    {
      operation: z.enum([
        'list', 'get', 'create', 'update', 'delete', 'environment', 'resources'
      ]).describe("Operation to perform"),
      id: z.string().optional().describe("Project UUID"),
      environmentNameOrUuid: z.string().optional().describe("Environment name or UUID (for environment operation)"),
      body: z.string().optional().describe("JSON request body")
    },
    async ({ operation, id, environmentNameOrUuid, body }) => {
      try {
        console.error('Projects tool received args:', JSON.stringify({ operation, id, environmentNameOrUuid, body }, null, 2));
        
        const result = await projectsHandler({ 
          operation, 
          id, 
          environmentNameOrUuid, 
          body 
        });
        return {
          content: [{ 
            type: 'text', 
            text: JSON.stringify(result, null, 2) 
          }]
        };
      } catch (error) {
        return {
          content: [{ 
            type: 'text', 
            text: `Error: ${error instanceof Error ? error.message : String(error)}` 
          }],
          isError: true
        };
      }
    }
  );

• src/mcp/tools/projects.ts:12-17 (schema)

  TypeScript interface defining the input schema for the projects handler: operation, id, environmentNameOrUuid, body.

  interface ProjectsToolArgs {
    operation: string;
    id?: string;
    environmentNameOrUuid?: string;
    body?: string;
  }

• src/generated/sdk.gen.ts:809-820 (helper)

  Auto-generated SDK function listProjects that makes a GET request to /projects.

  export const listProjects = <ThrowOnError extends boolean = false>(options?: Options<ListProjectsData, ThrowOnError>) => {
      return (options?.client ?? _heyApiClient).get<ListProjectsResponses, ListProjectsErrors, ThrowOnError>({
          security: [
              {
                  scheme: 'bearer',
                  type: 'http'
              }
          ],
          url: '/projects',
          ...options
      });
  };

• src/core/api-wrapper.ts:7-13 (helper)

  The safeApiCall wrapper used by projectsHandler to execute API calls with error handling.

  export async function safeApiCall<T>(apiCall: () => Promise<T>): Promise<T> {
    try {
      return await apiCall();
    } catch (error) {
      return handleApiError(error);
    }
  }