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

package/dist/tools/communication-tools.js

@@ -100,6 +100,107 @@ export const communicationTools = [
             };
         }
     },
+    {
+        name: "canvas_update_announcement",
+        tool: {
+            name: "canvas_update_announcement",
+            description: "Update the title or message of an existing announcement in a course",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    course_id: { type: "number", description: "The ID of the course" },
+                    topic_id: { type: "number", description: "The ID of the announcement (discussion topic)" },
+                    title: { type: "string", description: "New title for the announcement (optional)" },
+                    message: { type: "string", description: "New HTML message body for the announcement (optional)" },
+                },
+                required: ["course_id", "topic_id"],
+            },
+        },
+        handler: async (client, args) => {
+            const input = z.object({
+                course_id: z.coerce.number(),
+                topic_id: z.coerce.number(),
+                title: z.string().optional(),
+                message: z.string().optional(),
+            }).parse(args);
+            const fields = {};
+            if (input.title)
+                fields.title = input.title;
+            if (input.message)
+                fields.message = input.message;
+            const result = await client.updateAnnouncement(input.course_id, input.topic_id, fields);
+            return {
+                content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+            };
+        }
+    },
+    {
+        name: "canvas_create_discussion",
+        tool: {
+            name: "canvas_create_discussion",
+            description: "Create a new discussion topic in a course",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    course_id: { type: "number", description: "The ID of the course" },
+                    title: { type: "string", description: "Title of the discussion" },
+                    message: { type: "string", description: "Body/message of the discussion" },
+                    discussion_type: {
+                        type: "string",
+                        enum: ["side_comment", "threaded"],
+                        description: "Discussion type (default: side_comment)"
+                    },
+                    published: { type: "boolean", description: "Whether to publish immediately (default: true)" },
+                    pinned: { type: "boolean", description: "Pin to top of discussion list" },
+                    require_initial_post: { type: "boolean", description: "Students must post before seeing replies" },
+                    allow_rating: { type: "boolean", description: "Allow students to rate posts" }
+                },
+                required: ["course_id", "title", "message"],
+            },
+        },
+        handler: async (client, args) => {
+            const input = z.object({
+                course_id: z.coerce.number(),
+                title: z.string(),
+                message: z.string(),
+                discussion_type: z.enum(["side_comment", "threaded"]).optional(),
+                published: z.boolean().optional(),
+                pinned: z.boolean().optional(),
+                require_initial_post: z.boolean().optional(),
+                allow_rating: z.boolean().optional()
+            }).parse(args);
+            const { course_id, ...data } = input;
+            const result = await client.createDiscussion(course_id, data);
+            return {
+                content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+            };
+        }
+    },
+    {
+        name: "canvas_delete_discussion",
+        tool: {
+            name: "canvas_delete_discussion",
+            description: "Delete a discussion topic from a course",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    course_id: { type: "number", description: "The ID of the course" },
+                    topic_id: { type: "number", description: "The ID of the discussion topic to delete" }
+                },
+                required: ["course_id", "topic_id"],
+            },
+        },
+        handler: async (client, args) => {
+            const input = z.object({
+                course_id: z.coerce.number(),
+                topic_id: z.coerce.number()
+            }).parse(args);
+            const result = await client.deleteDiscussion(input.course_id, input.topic_id);
+            return {
+                content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+            };
+        }
+    },
     {
         name: "canvas_post_discussion_reply",
         tool: {

package/dist/tools/conversation-tools.js

@@ -0,0 +1,130 @@
+import { z } from "zod";
+export const conversationTools = [
+    {
+        name: "canvas_list_conversations",
+        tool: {
+            name: "canvas_list_conversations",
+            description: "List conversations (inbox messages) for the current user",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    scope: {
+                        type: "string",
+                        enum: ["inbox", "unread", "archived", "sent"],
+                        description: "Which mailbox to list (default: inbox)"
+                    }
+                },
+            },
+        },
+        handler: async (client, args) => {
+            const input = z.object({
+                scope: z.enum(["inbox", "unread", "archived", "sent"]).optional()
+            }).parse(args);
+            const result = await client.listConversations(input.scope);
+            return {
+                content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+            };
+        }
+    },
+    {
+        name: "canvas_get_conversation",
+        tool: {
+            name: "canvas_get_conversation",
+            description: "Get a full conversation thread including all messages",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    conversation_id: { type: "number", description: "The ID of the conversation" }
+                },
+                required: ["conversation_id"],
+            },
+        },
+        handler: async (client, args) => {
+            const input = z.object({ conversation_id: z.coerce.number() }).parse(args);
+            const result = await client.getConversation(input.conversation_id);
+            return {
+                content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+            };
+        }
+    },
+    {
+        name: "canvas_get_conversation_unread_count",
+        tool: {
+            name: "canvas_get_conversation_unread_count",
+            description: "Get the number of unread messages in the inbox",
+            inputSchema: { type: "object", properties: {} },
+        },
+        handler: async (client, _args) => {
+            const result = await client.getConversationUnreadCount();
+            return {
+                content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+            };
+        }
+    },
+    {
+        name: "canvas_send_conversation",
+        tool: {
+            name: "canvas_send_conversation",
+            description: "Send a new message to one or more users (private message or course announcement)",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    recipients: {
+                        type: "array",
+                        items: { anyOf: [{ type: "number" }, { type: "string" }] },
+                        description: "Array of user IDs or login IDs to send the message to"
+                    },
+                    subject: { type: "string", description: "Message subject" },
+                    body: { type: "string", description: "Message body" },
+                    course_id: {
+                        type: "number",
+                        description: "Associate message with a course context (optional but recommended)"
+                    },
+                    group_conversation: {
+                        type: "boolean",
+                        description: "If true, all recipients share one thread. If false, each gets an individual message (default: false)"
+                    }
+                },
+                required: ["recipients", "subject", "body"],
+            },
+        },
+        handler: async (client, args) => {
+            const input = z.object({
+                recipients: z.array(z.union([z.coerce.number(), z.string()])),
+                subject: z.string(),
+                body: z.string(),
+                course_id: z.coerce.number().optional(),
+                group_conversation: z.boolean().optional()
+            }).parse(args);
+            const result = await client.sendConversation(input);
+            return {
+                content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+            };
+        }
+    },
+    {
+        name: "canvas_reply_to_conversation",
+        tool: {
+            name: "canvas_reply_to_conversation",
+            description: "Reply to an existing conversation thread",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    conversation_id: { type: "number", description: "The ID of the conversation to reply to" },
+                    body: { type: "string", description: "The reply message text" }
+                },
+                required: ["conversation_id", "body"],
+            },
+        },
+        handler: async (client, args) => {
+            const input = z.object({
+                conversation_id: z.coerce.number(),
+                body: z.string()
+            }).parse(args);
+            const result = await client.replyToConversation(input.conversation_id, input.body);
+            return {
+                content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+            };
+        }
+    }
+];

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) }],
+            };
+        }
+    }
+];