@charlie.act7/canvas-mcp-server 1.1.0

package/dist/services/canvas-client.js

@@ -0,0 +1,459 @@
+import axios from 'axios';
+export class CanvasClient {
+    client;
+    token;
+    domain;
+    constructor(token, domain) {
+        this.token = token;
+        this.domain = domain;
+        this.client = this.createAxiosInstance(token, domain);
+    }
+    createAxiosInstance(token, domain) {
+        const baseURL = `https://${domain}/api/v1`;
+        return axios.create({
+            baseURL,
+            headers: {
+                'Authorization': `Bearer ${token}`,
+                'Content-Type': 'application/json'
+            }
+        });
+    }
+    updateConfig(token, domain) {
+        this.token = token;
+        this.domain = domain;
+        this.client = this.createAxiosInstance(token, domain);
+    }
+    parseLinkHeader(header) {
+        if (!header)
+            return {};
+        const links = {};
+        const parts = header.split(',');
+        parts.forEach(part => {
+            const section = part.split(';');
+            if (section.length < 2)
+                return;
+            const url = section[0].replace(/<(.*)>/, '$1').trim();
+            const name = section[1].replace(/rel="?([^"]+)"?/, '$1').trim();
+            links[name] = url;
+        });
+        return links;
+    }
+    async getAllPages(initialUrl, params) {
+        let allResults = [];
+        let nextUrl = initialUrl;
+        while (nextUrl) {
+            const response = await this.client.get(nextUrl, { params: nextUrl === initialUrl ? params : undefined });
+            if (response.data) {
+                allResults = allResults.concat(response.data);
+            }
+            const links = this.parseLinkHeader(response.headers['link']);
+            nextUrl = links['next'] || null;
+        }
+        return allResults;
+    }
+    async getCourses() {
+        return this.getAllPages('courses', {
+            include: ['term'],
+            enrollment_state: 'active',
+            per_page: 100
+        });
+    }
+    async getModules(courseId) {
+        return this.getAllPages(`courses/${courseId}/modules`, {
+            include: ['items']
+        });
+    }
+    async getAssignments(courseId) {
+        return this.getAllPages(`courses/${courseId}/assignments`, {
+            per_page: 100
+        });
+    }
+    async getAssignmentGroups(courseId) {
+        return this.getAllPages(`courses/${courseId}/assignment_groups`, {
+            per_page: 100
+        });
+    }
+    async getQuizzes(courseId) {
+        return this.getAllPages(`courses/${courseId}/quizzes`, {
+            per_page: 100
+        });
+    }
+    async getAssignment(courseId, assignmentId) {
+        const response = await this.client.get(`courses/${courseId}/assignments/${assignmentId}`, {
+            params: {
+                include: ['submission', 'rubric_settings', 'overrides']
+            }
+        });
+        return response.data;
+    }
+    async updateAssignmentDates(courseId, assignmentId, dates) {
+        const response = await this.client.put(`courses/${courseId}/assignments/${assignmentId}`, {
+            assignment: dates
+        });
+        return response.data;
+    }
+    async createAssignment(courseId, assignment) {
+        const response = await this.client.post(`courses/${courseId}/assignments`, {
+            assignment: assignment
+        });
+        return response.data;
+    }
+    async updateAssignment(courseId, assignmentId, assignment) {
+        const response = await this.client.put(`courses/${courseId}/assignments/${assignmentId}`, {
+            assignment: assignment
+        });
+        return response.data;
+    }
+    async getQuiz(courseId, quizId) {
+        const response = await this.client.get(`courses/${courseId}/quizzes/${quizId}`);
+        return response.data;
+    }
+    async updateQuizDates(courseId, quizId, dates) {
+        const response = await this.client.put(`courses/${courseId}/quizzes/${quizId}`, {
+            quiz: dates
+        });
+        return response.data;
+    }
+    async getSubmissions(courseId, assignmentId) {
+        return this.getAllPages(`courses/${courseId}/assignments/${assignmentId}/submissions`, {
+            include: ['user'],
+            per_page: 100
+        });
+    }
+    async gradeSubmission(courseId, assignmentId, userId, grade, comment, rubric_assessment) {
+        const url = `courses/${courseId}/assignments/${assignmentId}/submissions/${userId}`;
+        const data = {
+            submission: {
+                posted_grade: grade
+            }
+        };
+        if (comment) {
+            data.comment = {
+                text_comment: comment
+            };
+        }
+        if (rubric_assessment) {
+            data.rubric_assessment = rubric_assessment;
+        }
+        const response = await this.client.put(url, data);
+        return response.data;
+    }
+    async getSingleSubmission(courseId, assignmentId, userId) {
+        const url = `courses/${courseId}/assignments/${assignmentId}/submissions/${userId}`;
+        const response = await this.client.get(url, {
+            params: {
+                include: ['submission_history', 'submission_comments', 'rubric_assessment', 'visibility', 'user']
+            }
+        });
+        return response.data;
+    }
+    async getEnrollments(courseId) {
+        return this.getAllPages(`courses/${courseId}/users`, {
+            enrollment_type: ['student'],
+            include: ['email', 'enrollments'],
+            per_page: 100
+        });
+    }
+    async getStudentInCourse(courseId, studentId) {
+        const response = await this.client.get(`courses/${courseId}/users/${studentId}`, {
+            params: {
+                include: ['email', 'enrollments']
+            }
+        });
+        return response.data;
+    }
+    async getStudentCourseSubmissions(courseId, studentId) {
+        return this.getAllPages(`courses/${courseId}/students/submissions`, {
+            student_ids: [studentId],
+            include: ['assignment'],
+            per_page: 100
+        });
+    }
+    async getPages(courseId) {
+        return this.getAllPages(`courses/${courseId}/pages`);
+    }
+    async getPage(courseId, pageUrlOrId) {
+        const response = await this.client.get(`courses/${courseId}/pages/${pageUrlOrId}`);
+        return response.data;
+    }
+    async getFiles(courseId) {
+        return this.getAllPages(`courses/${courseId}/files`);
+    }
+    async getAnnouncements(courseIds) {
+        return this.getAllPages('announcements', {
+            context_codes: courseIds.map(id => `course_${id}`)
+        });
+    }
+    async deleteSubmissionComment(courseId, assignmentId, userId, commentId) {
+        const url = `courses/${courseId}/assignments/${assignmentId}/submissions/${userId}/comments/${commentId}`;
+        await this.client.delete(url);
+        return { deleted: true, comment_id: commentId };
+    }
+    async getSubmissionComments(courseId, assignmentId, userId) {
+        return this.getSingleSubmission(courseId, assignmentId, userId);
+    }
+    async getDiscussionTopics(courseId) {
+        return this.getAllPages(`courses/${courseId}/discussion_topics`);
+    }
+    async getDiscussionEntries(courseId, topicId) {
+        return this.getAllPages(`courses/${courseId}/discussion_topics/${topicId}/entries`);
+    }
+    async postDiscussionReply(courseId, topicId, message) {
+        const url = `courses/${courseId}/discussion_topics/${topicId}/entries`;
+        const response = await this.client.post(url, { message });
+        return response.data;
+    }
+    async postAnnouncement(courseId, title, message) {
+        // Announcements are technically discussion topics with is_announcement=true
+        const url = `courses/${courseId}/discussion_topics`;
+        const response = await this.client.post(url, {
+            title,
+            message,
+            is_announcement: true
+        });
+        return response.data;
+    }
+    // --- Quiz Questions ---
+    async listQuizQuestions(courseId, quizId) {
+        return this.getAllPages(`courses/${courseId}/quizzes/${quizId}/questions`, {
+            per_page: 100
+        });
+    }
+    async getQuizQuestion(courseId, quizId, questionId) {
+        const response = await this.client.get(`courses/${courseId}/quizzes/${quizId}/questions/${questionId}`);
+        return response.data;
+    }
+    async createQuizQuestion(courseId, quizId, data) {
+        const response = await this.client.post(`courses/${courseId}/quizzes/${quizId}/questions`, { question: data });
+        return response.data;
+    }
+    async updateQuizQuestion(courseId, quizId, questionId, data) {
+        const response = await this.client.put(`courses/${courseId}/quizzes/${quizId}/questions/${questionId}`, { question: data });
+        return response.data;
+    }
+    async deleteQuizQuestion(courseId, quizId, questionId) {
+        await this.client.delete(`courses/${courseId}/quizzes/${quizId}/questions/${questionId}`);
+        return { deleted: true };
+    }
+    // --- Quiz Groups ---
+    async createQuizGroup(courseId, quizId, groupData) {
+        const response = await this.client.post(`courses/${courseId}/quizzes/${quizId}/groups`, { quiz_groups: [groupData] });
+        return response.data.quiz_groups[0];
+    }
+    async createPage(courseId, title, body, published = false) {
+        const response = await this.client.post(`courses/${courseId}/pages`, {
+            wiki_page: {
+                title,
+                body,
+                published
+            }
+        });
+        return response.data;
+    }
+    async updatePage(courseId, pageUrlOrId, data) {
+        const response = await this.client.put(`courses/${courseId}/pages/${pageUrlOrId}`, {
+            wiki_page: data
+        });
+        return response.data;
+    }
+    // --- Modules ---
+    async createModule(courseId, name, published = false, position) {
+        const response = await this.client.post(`courses/${courseId}/modules`, {
+            module: {
+                name,
+                published,
+                position
+            }
+        });
+        return response.data;
+    }
+    async updateModule(courseId, moduleId, data) {
+        const response = await this.client.put(`courses/${courseId}/modules/${moduleId}`, {
+            module: data
+        });
+        return response.data;
+    }
+    async deleteModule(courseId, moduleId) {
+        await this.client.delete(`courses/${courseId}/modules/${moduleId}`);
+        return { deleted: true };
+    }
+    // --- Module Items ---
+    async createModuleItem(courseId, moduleId, item) {
+        const response = await this.client.post(`courses/${courseId}/modules/${moduleId}/items`, {
+            module_item: item
+        });
+        return response.data;
+    }
+    async updateModuleItem(courseId, moduleId, itemId, data) {
+        const response = await this.client.put(`courses/${courseId}/modules/${moduleId}/items/${itemId}`, {
+            module_item: data
+        });
+        return response.data;
+    }
+    async deleteModuleItem(courseId, moduleId, itemId) {
+        await this.client.delete(`courses/${courseId}/modules/${moduleId}/items/${itemId}`);
+        return { deleted: true };
+    }
+    // --- File Uploads ---
+    async uploadFile(courseId, filePath, fileName, contentType, parentFolderId) {
+        // Step 1: Pre-flight request to Canvas
+        const preflightData = {
+            name: fileName,
+            content_type: contentType
+        };
+        if (parentFolderId) {
+            preflightData.parent_folder_id = parentFolderId;
+        }
+        const preflightResponse = await this.client.post(`courses/${courseId}/files`, preflightData);
+        const { upload_url, upload_params } = preflightResponse.data;
+        // Step 2: Upload to S3 (or other storage)
+        // Note: Using dynamic import for 'fs' and 'form-data' to avoid issues in some environments
+        const fs = await import('node:fs');
+        const FormData = (await import('form-data')).default;
+        const form = new FormData();
+        Object.entries(upload_params).forEach(([key, value]) => {
+            form.append(key, value);
+        });
+        form.append('file', fs.createReadStream(filePath));
+        const uploadResponse = await axios.post(upload_url, form, {
+            headers: form.getHeaders()
+        });
+        // Step 3: Handle redirection if necessary (Canvas sometimes returns a 303 or a Location header)
+        if (uploadResponse.status === 301 || uploadResponse.status === 201 || uploadResponse.headers.location) {
+            const finalUrl = uploadResponse.headers.location || uploadResponse.data.location;
+            if (finalUrl) {
+                const finalResponse = await this.client.get(finalUrl);
+                return finalResponse.data;
+            }
+        }
+        return uploadResponse.data;
+    }
+    async createQuiz(courseId, quiz) {
+        const response = await this.client.post(`courses/${courseId}/quizzes`, {
+            quiz: quiz
+        });
+        return response.data;
+    }
+    async updateQuiz(courseId, quizId, quiz) {
+        const response = await this.client.put(`courses/${courseId}/quizzes/${quizId}`, {
+            quiz: quiz
+        });
+        return response.data;
+    }
+    // --- Folders ---
+    async getFolders(courseId) {
+        return this.getAllPages(`courses/${courseId}/folders`);
+    }
+    async getFolder(folderId) {
+        const response = await this.client.get(`folders/${folderId}`);
+        return response.data;
+    }
+    async createFolder(courseId, name, parentFolderId) {
+        const data = { name };
+        if (parentFolderId) {
+            data.parent_folder_id = parentFolderId;
+        }
+        const response = await this.client.post(`courses/${courseId}/folders`, data);
+        return response.data;
+    }
+    async updateFolder(folderId, data) {
+        const response = await this.client.put(`folders/${folderId}`, data);
+        return response.data;
+    }
+    async deleteFolder(folderId, force = false) {
+        await this.client.delete(`folders/${folderId}`, { params: { force } });
+        return { deleted: true };
+    }
+    // --- Files (More) ---
+    async getFile(fileId) {
+        const response = await this.client.get(`files/${fileId}`);
+        return response.data;
+    }
+    async updateFile(fileId, data) {
+        const response = await this.client.put(`files/${fileId}`, data);
+        return response.data;
+    }
+    async deleteFile(fileId) {
+        await this.client.delete(`files/${fileId}`);
+        return { deleted: true };
+    }
+    // --- Rubrics ---
+    async createRubric(courseId, rubricData, rubricAssociationData) {
+        const payload = { rubric: rubricData };
+        if (rubricAssociationData) {
+            payload.rubric_association = rubricAssociationData;
+        }
+        const response = await this.client.post(`courses/${courseId}/rubrics`, payload);
+        return response.data;
+    }
+    async createRubricAssociation(courseId, associationData) {
+        const response = await this.client.post(`courses/${courseId}/rubric_associations`, {
+            rubric_association: associationData
+        });
+        return response.data;
+    }
+    // --- Appointment Groups ---
+    async listAppointmentGroups(scope = 'all', include) {
+        return this.getAllPages('appointment_groups', {
+            scope,
+            include
+        });
+    }
+    async getAppointmentGroup(id, include) {
+        const response = await this.client.get(`appointment_groups/${id}`, {
+            params: { include }
+        });
+        return response.data;
+    }
+    async createAppointmentGroup(data) {
+        const response = await this.client.post('appointment_groups', {
+            appointment_group: data
+        });
+        return response.data;
+    }
+    async updateAppointmentGroup(id, data) {
+        const response = await this.client.put(`appointment_groups/${id}`, {
+            appointment_group: data
+        });
+        return response.data;
+    }
+    async deleteAppointmentGroup(id, cancelReason) {
+        await this.client.delete(`appointment_groups/${id}`, {
+            params: { cancel_reason: cancelReason }
+        });
+        return { deleted: true };
+    }
+    async listAppointmentGroupUsers(id) {
+        return this.getAllPages(`appointment_groups/${id}/users`);
+    }
+    async listAppointmentGroupGroups(id) {
+        return this.getAllPages(`appointment_groups/${id}/groups`);
+    }
+    async getNextAppointment() {
+        const response = await this.client.get('appointment_groups/next_appointment');
+        return response.data;
+    }
+    // --- Groups and Group Categories ---
+    async getGroupCategories(courseId) {
+        return this.getAllPages(`courses/${courseId}/group_categories`);
+    }
+    async createGroupCategory(courseId, data) {
+        const response = await this.client.post(`courses/${courseId}/group_categories`, data);
+        return response.data;
+    }
+    async createGroup(groupCategoryId, data) {
+        const response = await this.client.post(`group_categories/${groupCategoryId}/groups`, data);
+        return response.data;
+    }
+    async getGroupsInCategory(groupCategoryId) {
+        return this.getAllPages(`group_categories/${groupCategoryId}/groups`);
+    }
+    async assignUnassignedMembers(groupCategoryId, sync = false) {
+        const response = await this.client.post(`group_categories/${groupCategoryId}/assign_unassigned_members`, { sync });
+        return response.data;
+    }
+    async addGroupMember(groupId, userId) {
+        const response = await this.client.post(`groups/${groupId}/memberships`, { user_id: userId });
+        return response.data;
+    }
+}