@charlie.act7/canvas-mcp-server 1.1.3 → 1.2.0

package/dist/tools/course-tools.js

@@ -95,6 +95,148 @@ export const courseTools = [
             };
         }
     },
+    {
+        name: "canvas_create_course",
+        tool: {
+            name: "canvas_create_course",
+            description: "Create a new course in a Canvas account",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    account_id: {
+                        anyOf: [{ type: "number" }, { type: "string" }],
+                        description: "Account ID where the course will be created (use 'self' or your institution's account ID)"
+                    },
+                    name: { type: "string", description: "Course name" },
+                    course_code: { type: "string", description: "Short course code (e.g. MAT101)" },
+                    start_at: { type: "string", description: "Start date (ISO 8601)" },
+                    end_at: { type: "string", description: "End date (ISO 8601)" },
+                    syllabus_body: { type: "string", description: "HTML content for the syllabus" },
+                    time_zone: { type: "string", description: "Time zone (e.g. America/Guayaquil)" },
+                    locale: { type: "string", description: "Locale (e.g. es, en)" }
+                },
+                required: ["account_id", "name"],
+            },
+        },
+        handler: async (client, args) => {
+            const input = z.object({
+                account_id: z.union([z.number(), z.string()]),
+                name: z.string(),
+                course_code: z.string().optional(),
+                start_at: z.string().optional(),
+                end_at: z.string().optional(),
+                syllabus_body: z.string().optional(),
+                time_zone: z.string().optional(),
+                locale: z.string().optional()
+            }).parse(args);
+            const { account_id, ...courseData } = input;
+            const result = await client.createCourse(account_id, courseData);
+            return {
+                content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+            };
+        }
+    },
+    {
+        name: "canvas_update_course",
+        tool: {
+            name: "canvas_update_course",
+            description: "Update an existing course's settings",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    course_id: {
+                        anyOf: [{ type: "number" }, { type: "string" }],
+                        description: "The ID or name of the course"
+                    },
+                    name: { type: "string", description: "New course name" },
+                    course_code: { type: "string", description: "New course code" },
+                    start_at: { type: "string", description: "Start date (ISO 8601)" },
+                    end_at: { type: "string", description: "End date (ISO 8601)" },
+                    syllabus_body: { type: "string", description: "HTML content for the syllabus" },
+                    time_zone: { type: "string", description: "Time zone" },
+                    locale: { type: "string", description: "Locale (e.g. es, en)" },
+                    default_view: {
+                        type: "string",
+                        description: "Default course home view: feed, wiki, modules, assignments, syllabus"
+                    }
+                },
+                required: ["course_id"],
+            },
+        },
+        handler: async (client, args) => {
+            const input = z.object({
+                course_id: z.union([z.number(), z.string()]),
+                name: z.string().optional(),
+                course_code: z.string().optional(),
+                start_at: z.string().optional(),
+                end_at: z.string().optional(),
+                syllabus_body: z.string().optional(),
+                time_zone: z.string().optional(),
+                locale: z.string().optional(),
+                default_view: z.string().optional()
+            }).parse(args);
+            const courseId = await resolveCourseId(client, input.course_id);
+            const { course_id: _, ...updateData } = input;
+            const result = await client.updateCourse(courseId, updateData);
+            return {
+                content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+            };
+        }
+    },
+    {
+        name: "canvas_get_syllabus",
+        tool: {
+            name: "canvas_get_syllabus",
+            description: "Get the syllabus content of a course",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    course_id: {
+                        anyOf: [{ type: "number" }, { type: "string" }],
+                        description: "The ID or name of the course"
+                    },
+                },
+                required: ["course_id"],
+            },
+        },
+        handler: async (client, args) => {
+            const input = z.object({ course_id: z.union([z.number(), z.string()]) }).parse(args);
+            const courseId = await resolveCourseId(client, input.course_id);
+            const result = await client.getSyllabus(courseId);
+            return {
+                content: [{ type: "text", text: result.syllabus_body || "(No syllabus content)" }],
+            };
+        }
+    },
+    {
+        name: "canvas_delete_page",
+        tool: {
+            name: "canvas_delete_page",
+            description: "Delete a page from a course",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    course_id: {
+                        anyOf: [{ type: "number" }, { type: "string" }],
+                        description: "The ID or name of the course"
+                    },
+                    page_id: { type: "string", description: "The ID or URL-slug of the page to delete" }
+                },
+                required: ["course_id", "page_id"],
+            },
+        },
+        handler: async (client, args) => {
+            const input = z.object({
+                course_id: z.union([z.number(), z.string()]),
+                page_id: z.union([z.string(), z.number()])
+            }).parse(args);
+            const courseId = await resolveCourseId(client, input.course_id);
+            const result = await client.deletePage(courseId, String(input.page_id));
+            return {
+                content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+            };
+        }
+    },
     {
         name: "canvas_list_students",
         tool: {

package/dist/tools/enrollment-tools.js

@@ -0,0 +1,202 @@
+import { resolveCourseId } from "../common/helpers.js";
+import { z } from "zod";
+export const enrollmentTools = [
+    {
+        name: "canvas_health_check",
+        tool: {
+            name: "canvas_health_check",
+            description: "Verify Canvas API connectivity and token validity",
+            inputSchema: { type: "object", properties: {} },
+        },
+        handler: async (client, _args) => {
+            const result = await client.healthCheck();
+            return {
+                content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+            };
+        }
+    },
+    {
+        name: "canvas_get_profile",
+        tool: {
+            name: "canvas_get_profile",
+            description: "Get the profile of the currently authenticated user",
+            inputSchema: { type: "object", properties: {} },
+        },
+        handler: async (client, _args) => {
+            const result = await client.getProfile();
+            return {
+                content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+            };
+        }
+    },
+    {
+        name: "canvas_get_user",
+        tool: {
+            name: "canvas_get_user",
+            description: "Get details of a specific user by their Canvas user ID",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    user_id: {
+                        anyOf: [{ type: "number" }, { type: "string" }],
+                        description: "Canvas user ID (number) or 'self' for current user"
+                    }
+                },
+                required: ["user_id"],
+            },
+        },
+        handler: async (client, args) => {
+            const input = z.object({
+                user_id: z.union([z.coerce.number(), z.literal("self")])
+            }).parse(args);
+            const result = await client.getUser(input.user_id);
+            return {
+                content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+            };
+        }
+    },
+    {
+        name: "canvas_search_users",
+        tool: {
+            name: "canvas_search_users",
+            description: "Search for users in a Canvas account by name or email",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    account_id: {
+                        anyOf: [{ type: "number" }, { type: "string" }],
+                        description: "Account ID to search in (use 1 for root account or your institution's account ID)"
+                    },
+                    search_term: {
+                        type: "string",
+                        description: "Name, email, or login to search for (min 3 characters)"
+                    },
+                    enrollment_type: {
+                        type: "string",
+                        description: "Filter by role: student, teacher, ta, observer, designer"
+                    }
+                },
+                required: ["account_id", "search_term"],
+            },
+        },
+        handler: async (client, args) => {
+            const input = z.object({
+                account_id: z.union([z.coerce.number(), z.string()]),
+                search_term: z.string().min(3),
+                enrollment_type: z.string().optional()
+            }).parse(args);
+            const result = await client.searchUsers(input.account_id, input.search_term, input.enrollment_type);
+            return {
+                content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+            };
+        }
+    },
+    {
+        name: "canvas_list_course_enrollments",
+        tool: {
+            name: "canvas_list_course_enrollments",
+            description: "List all enrollments in a course, optionally filtered by role",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    course_id: {
+                        anyOf: [{ type: "number" }, { type: "string" }],
+                        description: "The ID or name of the course"
+                    },
+                    type: {
+                        type: "array",
+                        items: { type: "string" },
+                        description: "Filter by enrollment type(s): StudentEnrollment, TeacherEnrollment, TaEnrollment, ObserverEnrollment, DesignerEnrollment"
+                    }
+                },
+                required: ["course_id"],
+            },
+        },
+        handler: async (client, args) => {
+            const input = z.object({
+                course_id: z.union([z.number(), z.string()]),
+                type: z.array(z.string()).optional()
+            }).parse(args);
+            const courseId = await resolveCourseId(client, input.course_id);
+            const result = await client.listCourseEnrollments(courseId, input.type);
+            return {
+                content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+            };
+        }
+    },
+    {
+        name: "canvas_enroll_user",
+        tool: {
+            name: "canvas_enroll_user",
+            description: "Enroll a user in a course with a specific role",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    course_id: {
+                        anyOf: [{ type: "number" }, { type: "string" }],
+                        description: "The ID or name of the course"
+                    },
+                    user_id: { type: "number", description: "Canvas user ID to enroll" },
+                    enrollment_type: {
+                        type: "string",
+                        description: "Role: StudentEnrollment, TeacherEnrollment, TaEnrollment, ObserverEnrollment, DesignerEnrollment",
+                        default: "StudentEnrollment"
+                    },
+                    notify: {
+                        type: "boolean",
+                        description: "Send enrollment notification email to the user (default: false)"
+                    }
+                },
+                required: ["course_id", "user_id", "enrollment_type"],
+            },
+        },
+        handler: async (client, args) => {
+            const input = z.object({
+                course_id: z.union([z.number(), z.string()]),
+                user_id: z.coerce.number(),
+                enrollment_type: z.string(),
+                notify: z.boolean().optional()
+            }).parse(args);
+            const courseId = await resolveCourseId(client, input.course_id);
+            const result = await client.enrollUser(courseId, input.user_id, input.enrollment_type, input.notify);
+            return {
+                content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+            };
+        }
+    },
+    {
+        name: "canvas_remove_enrollment",
+        tool: {
+            name: "canvas_remove_enrollment",
+            description: "Remove or deactivate a user's enrollment from a course",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    course_id: {
+                        anyOf: [{ type: "number" }, { type: "string" }],
+                        description: "The ID or name of the course"
+                    },
+                    enrollment_id: { type: "number", description: "The enrollment ID to remove (get it from canvas_list_course_enrollments)" },
+                    task: {
+                        type: "string",
+                        enum: ["conclude", "delete", "deactivate"],
+                        description: "Action: conclude (end gracefully), delete (remove permanently), deactivate (temporarily disable). Default: conclude"
+                    }
+                },
+                required: ["course_id", "enrollment_id"],
+            },
+        },
+        handler: async (client, args) => {
+            const input = z.object({
+                course_id: z.union([z.number(), z.string()]),
+                enrollment_id: z.coerce.number(),
+                task: z.enum(["conclude", "delete", "deactivate"]).optional()
+            }).parse(args);
+            const courseId = await resolveCourseId(client, input.course_id);
+            const result = await client.removeEnrollment(courseId, input.enrollment_id, input.task ?? "conclude");
+            return {
+                content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+            };
+        }
+    }
+];