@charlie.act7/canvas-mcp-server 1.1.0

package/dist/tools/calendar-tools.js

@@ -0,0 +1,240 @@
+import { z } from "zod";
+export const calendarTools = [
+    {
+        name: "canvas_list_appointment_groups",
+        tool: {
+            name: "canvas_list_appointment_groups",
+            description: "List appointment groups",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    scope: { type: "string", enum: ["all", "manageable"], description: "Scope of appointment groups to list" },
+                    include: { type: "array", items: { type: "string" }, description: "Additional associations to include" }
+                }
+            },
+        },
+        handler: async (client, args) => {
+            const input = z.object({
+                scope: z.enum(["all", "manageable"]).optional().default("all"),
+                include: z.array(z.string()).optional()
+            }).parse(args);
+            const groups = await client.listAppointmentGroups(input.scope, input.include);
+            return {
+                content: [{ type: "text", text: JSON.stringify(groups, null, 2) }],
+            };
+        }
+    },
+    {
+        name: "canvas_get_appointment_group",
+        tool: {
+            name: "canvas_get_appointment_group",
+            description: "Get a single appointment group by ID",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    id: { type: "number", description: "The ID of the appointment group" },
+                    include: { type: "array", items: { type: "string" }, description: "Additional associations to include" }
+                },
+                required: ["id"],
+            },
+        },
+        handler: async (client, args) => {
+            const input = z.object({
+                id: z.coerce.number(),
+                include: z.array(z.string()).optional()
+            }).parse(args);
+            const group = await client.getAppointmentGroup(input.id, input.include);
+            return {
+                content: [{ type: "text", text: JSON.stringify(group, null, 2) }],
+            };
+        }
+    },
+    {
+        name: "canvas_create_appointment_group",
+        tool: {
+            name: "canvas_create_appointment_group",
+            description: "Create a new appointment group",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    context_codes: { type: "array", items: { type: "string" }, description: "Array of context codes (e.g. course_123)" },
+                    title: { type: "string", description: "Title of the appointment group" },
+                    description: { type: "string", description: "Description of the appointment group" },
+                    location_name: { type: "string", description: "Name of the location" },
+                    location_address: { type: "string", description: "Address of the location" },
+                    publish: { type: "boolean", description: "Whether to publish the group immediately" },
+                    participants_per_appointment: { type: "number", description: "Max participants per slot" },
+                    min_appointments_per_participant: { type: "number", description: "Min slots per participant" },
+                    max_appointments_per_participant: { type: "number", description: "Max slots per participant" },
+                    new_appointments: {
+                        type: "array",
+                        items: {
+                            type: "array",
+                            items: { type: "string" },
+                            minItems: 2,
+                            maxItems: 2,
+                            description: "[start_time, end_time] pair"
+                        },
+                        description: "Nested array of start/end time pairs"
+                    },
+                    participant_visibility: { type: "string", enum: ["private", "protected"] }
+                },
+                required: ["context_codes", "title"],
+            },
+        },
+        handler: async (client, args) => {
+            const input = z.object({
+                context_codes: z.array(z.string()),
+                title: z.string(),
+                description: z.string().optional(),
+                location_name: z.string().optional(),
+                location_address: z.string().optional(),
+                publish: z.boolean().optional(),
+                participants_per_appointment: z.number().optional(),
+                min_appointments_per_participant: z.number().optional(),
+                max_appointments_per_participant: z.number().optional(),
+                new_appointments: z.array(z.tuple([z.string(), z.string()])).optional(),
+                participant_visibility: z.enum(["private", "protected"]).optional()
+            }).parse(args);
+            const group = await client.createAppointmentGroup(input);
+            return {
+                content: [{ type: "text", text: JSON.stringify(group, null, 2) }],
+            };
+        }
+    },
+    {
+        name: "canvas_update_appointment_group",
+        tool: {
+            name: "canvas_update_appointment_group",
+            description: "Update an existing appointment group",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    id: { type: "number", description: "The ID of the appointment group" },
+                    context_codes: { type: "array", items: { type: "string" }, description: "Array of context codes" },
+                    title: { type: "string", description: "Title of the appointment group" },
+                    description: { type: "string", description: "Description of the appointment group" },
+                    location_name: { type: "string", description: "Name of the location" },
+                    location_address: { type: "string", description: "Address of the location" },
+                    publish: { type: "boolean", description: "Whether to publish the group" },
+                    participants_per_appointment: { type: "number", description: "Max participants per slot" },
+                    min_appointments_per_participant: { type: "number", description: "Min slots per participant" },
+                    max_appointments_per_participant: { type: "number", description: "Max slots per participant" },
+                    new_appointments: {
+                        type: "array",
+                        items: {
+                            type: "array",
+                            items: { type: "string" },
+                            minItems: 2,
+                            maxItems: 2
+                        }
+                    },
+                    participant_visibility: { type: "string", enum: ["private", "protected"] }
+                },
+                required: ["id"],
+            },
+        },
+        handler: async (client, args) => {
+            const input = z.object({
+                id: z.coerce.number(),
+                context_codes: z.array(z.string()).optional(),
+                title: z.string().optional(),
+                description: z.string().optional(),
+                location_name: z.string().optional(),
+                location_address: z.string().optional(),
+                publish: z.boolean().optional(),
+                participants_per_appointment: z.number().optional(),
+                min_appointments_per_participant: z.number().optional(),
+                max_appointments_per_participant: z.number().optional(),
+                new_appointments: z.array(z.tuple([z.string(), z.string()])).optional(),
+                participant_visibility: z.enum(["private", "protected"]).optional()
+            }).parse(args);
+            const { id, ...data } = input;
+            const group = await client.updateAppointmentGroup(id, data);
+            return {
+                content: [{ type: "text", text: JSON.stringify(group, null, 2) }],
+            };
+        }
+    },
+    {
+        name: "canvas_delete_appointment_group",
+        tool: {
+            name: "canvas_delete_appointment_group",
+            description: "Delete an appointment group",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    id: { type: "number", description: "The ID of the appointment group" },
+                    cancel_reason: { type: "string", description: "Reason for canceling the appointment group" }
+                },
+                required: ["id"],
+            },
+        },
+        handler: async (client, args) => {
+            const input = z.object({
+                id: z.coerce.number(),
+                cancel_reason: z.string().optional()
+            }).parse(args);
+            const result = await client.deleteAppointmentGroup(input.id, input.cancel_reason);
+            return {
+                content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+            };
+        }
+    },
+    {
+        name: "canvas_list_appointment_group_users",
+        tool: {
+            name: "canvas_list_appointment_group_users",
+            description: "List users participating in an appointment group",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    id: { type: "number", description: "The ID of the appointment group" }
+                },
+                required: ["id"],
+            },
+        },
+        handler: async (client, args) => {
+            const input = z.object({ id: z.coerce.number() }).parse(args);
+            const users = await client.listAppointmentGroupUsers(input.id);
+            return {
+                content: [{ type: "text", text: JSON.stringify(users, null, 2) }],
+            };
+        }
+    },
+    {
+        name: "canvas_list_appointment_group_groups",
+        tool: {
+            name: "canvas_list_appointment_group_groups",
+            description: "List student groups participating in an appointment group",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    id: { type: "number", description: "The ID of the appointment group" }
+                },
+                required: ["id"],
+            },
+        },
+        handler: async (client, args) => {
+            const input = z.object({ id: z.coerce.number() }).parse(args);
+            const groups = await client.listAppointmentGroupGroups(input.id);
+            return {
+                content: [{ type: "text", text: JSON.stringify(groups, null, 2) }],
+            };
+        }
+    },
+    {
+        name: "canvas_get_next_appointment",
+        tool: {
+            name: "canvas_get_next_appointment",
+            description: "Get the next appointment group for the current user",
+            inputSchema: { type: "object", properties: {} },
+        },
+        handler: async (client) => {
+            const group = await client.getNextAppointment();
+            return {
+                content: [{ type: "text", text: JSON.stringify(group, null, 2) }],
+            };
+        }
+    }
+];

package/dist/tools/communication-tools.js

@@ -0,0 +1,130 @@
+import { z } from "zod";
+export const communicationTools = [
+    {
+        name: "canvas_list_announcements",
+        tool: {
+            name: "canvas_list_announcements",
+            description: "List announcements for one or more courses",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    course_ids: {
+                        type: "array",
+                        items: { type: "number" },
+                        description: "List of course IDs"
+                    },
+                },
+                required: ["course_ids"],
+            },
+        },
+        handler: async (client, args) => {
+            const input = z.object({
+                course_ids: z.array(z.number())
+            }).parse(args);
+            const announcements = await client.getAnnouncements(input.course_ids);
+            return {
+                content: [{ type: "text", text: JSON.stringify(announcements, null, 2) }],
+            };
+        }
+    },
+    {
+        name: "canvas_list_discussions",
+        tool: {
+            name: "canvas_list_discussions",
+            description: "List discussion topics in a course",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    course_id: { type: "number", description: "The ID of the course" },
+                },
+                required: ["course_id"],
+            },
+        },
+        handler: async (client, args) => {
+            const input = z.object({ course_id: z.coerce.number() }).parse(args);
+            const discussions = await client.getDiscussionTopics(input.course_id);
+            return {
+                content: [{ type: "text", text: JSON.stringify(discussions, null, 2) }],
+            };
+        }
+    },
+    {
+        name: "canvas_get_discussion_entries",
+        tool: {
+            name: "canvas_get_discussion_entries",
+            description: "Read replies/entries in a discussion topic",
+            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" },
+                },
+                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 entries = await client.getDiscussionEntries(input.course_id, input.topic_id);
+            return {
+                content: [{ type: "text", text: JSON.stringify(entries, null, 2) }],
+            };
+        }
+    },
+    {
+        name: "canvas_post_announcement",
+        tool: {
+            name: "canvas_post_announcement",
+            description: "Post a new announcement to a course",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    course_id: { type: "number", description: "The ID of the course" },
+                    title: { type: "string", description: "The title of the announcement" },
+                    message: { type: "string", description: "The content/message of the announcement" },
+                },
+                required: ["course_id", "title", "message"],
+            },
+        },
+        handler: async (client, args) => {
+            const input = z.object({
+                course_id: z.coerce.number(),
+                title: z.string(),
+                message: z.string()
+            }).parse(args);
+            const result = await client.postAnnouncement(input.course_id, input.title, input.message);
+            return {
+                content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+            };
+        }
+    },
+    {
+        name: "canvas_post_discussion_reply",
+        tool: {
+            name: "canvas_post_discussion_reply",
+            description: "Post a reply to a discussion topic",
+            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" },
+                    message: { type: "string", description: "The reply message" },
+                },
+                required: ["course_id", "topic_id", "message"],
+            },
+        },
+        handler: async (client, args) => {
+            const input = z.object({
+                course_id: z.coerce.number(),
+                topic_id: z.coerce.number(),
+                message: z.string()
+            }).parse(args);
+            const result = await client.postDiscussionReply(input.course_id, input.topic_id, input.message);
+            return {
+                content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+            };
+        }
+    }
+];

package/dist/tools/config-tools.js

@@ -0,0 +1,39 @@
+import { ConfigManager } from "../common/config-manager.js";
+const configManager = new ConfigManager();
+export const configTools = [
+    {
+        name: "set_canvas_config",
+        tool: {
+            name: "set_canvas_config",
+            description: "Update Canvas API configuration (token and domain). This change is persistent.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    domain: {
+                        type: "string",
+                        description: "Canvas Domain (e.g., uide.instructure.com)"
+                    },
+                    token: {
+                        type: "string",
+                        description: "Canvas API Access Token"
+                    }
+                },
+                required: ["domain", "token"]
+            }
+        },
+        handler: async (client, args) => {
+            const { domain, token } = args;
+            // Update the running client
+            client.updateConfig(token, domain);
+            // Persist the changes
+            configManager.set("CANVAS_API_DOMAIN", domain);
+            configManager.set("CANVAS_API_TOKEN", token);
+            return {
+                content: [{
+                        type: "text",
+                        text: `✅ Configuration updated and persisted successfully.\nDomain: ${domain}\nToken: updated (hidden)`
+                    }]
+            };
+        }
+    }
+];

package/dist/tools/course-tools.js

@@ -0,0 +1,123 @@
+import { resolveCourseId } from "../common/helpers.js";
+import { z } from "zod";
+export const courseTools = [
+    {
+        name: "canvas_list_courses",
+        tool: {
+            name: "canvas_list_courses",
+            description: "List active courses for the current user in Canvas",
+            inputSchema: { type: "object", properties: {} },
+        },
+        handler: async (client, args) => {
+            const courses = await client.getCourses();
+            return {
+                content: [{ type: "text", text: JSON.stringify(courses, null, 2) }],
+            };
+        }
+    },
+    {
+        name: "canvas_list_pages",
+        tool: {
+            name: "canvas_list_pages",
+            description: "List pages in 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 pages = await client.getPages(courseId);
+            return {
+                content: [{ type: "text", text: JSON.stringify(pages, null, 2) }],
+            };
+        }
+    },
+    {
+        name: "canvas_get_page_content",
+        tool: {
+            name: "canvas_get_page_content",
+            description: "Get the content of a specific page",
+            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" },
+                },
+                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 pageId = String(input.page_id);
+            const page = await client.getPage(courseId, pageId);
+            return {
+                content: [{ type: "text", text: page.body || page.title + "\n(No content)" }],
+            };
+        }
+    },
+    {
+        name: "canvas_list_files",
+        tool: {
+            name: "canvas_list_files",
+            description: "List files in 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 files = await client.getFiles(courseId);
+            return {
+                content: [{ type: "text", text: JSON.stringify(files, null, 2) }],
+            };
+        }
+    },
+    {
+        name: "canvas_list_students",
+        tool: {
+            name: "canvas_list_students",
+            description: "List all students enrolled in 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 students = await client.getEnrollments(courseId);
+            return {
+                content: [{ type: "text", text: JSON.stringify(students, null, 2) }],
+            };
+        }
+    }
+];

package/dist/tools/create-tools.js

@@ -0,0 +1,76 @@
+import { resolveCourseId } from "../common/helpers.js";
+import { z } from "zod";
+export const createTools = [
+    {
+        name: "canvas_create_page",
+        tool: {
+            name: "canvas_create_page",
+            description: "Create a new page in a course",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    course_id: {
+                        anyOf: [{ type: "number" }, { type: "string" }],
+                        description: "The ID or name of the course"
+                    },
+                    title: { type: "string", description: "The title of the page" },
+                    body: { type: "string", description: "The HTML body of the page" },
+                    published: { type: "boolean", description: "Whether the page updates are published" }
+                },
+                required: ["course_id", "title", "body"],
+            },
+        },
+        handler: async (client, args) => {
+            const input = z.object({
+                course_id: z.union([z.number(), z.string()]),
+                title: z.string(),
+                body: z.string(),
+                published: z.boolean().optional().default(false)
+            }).parse(args);
+            const courseId = await resolveCourseId(client, input.course_id);
+            const page = await client.createPage(courseId, input.title, input.body, input.published);
+            return {
+                content: [{ type: "text", text: JSON.stringify(page, null, 2) }],
+            };
+        }
+    },
+    {
+        name: "canvas_update_page",
+        tool: {
+            name: "canvas_update_page",
+            description: "Update an existing page in a course",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    course_id: {
+                        anyOf: [{ type: "number" }, { type: "string" }],
+                        description: "The ID or name of the course"
+                    },
+                    page_url_or_id: { type: "string", description: "The URL or ID of the page to update" },
+                    title: { type: "string", description: "The new title of the page" },
+                    body: { type: "string", description: "The new HTML body of the page" },
+                    published: { type: "boolean", description: "Whether the page is published" }
+                },
+                required: ["course_id", "page_url_or_id"],
+            },
+        },
+        handler: async (client, args) => {
+            const input = z.object({
+                course_id: z.union([z.number(), z.string()]),
+                page_url_or_id: z.union([z.string(), z.number()]),
+                title: z.string().optional(),
+                body: z.string().optional(),
+                published: z.boolean().optional()
+            }).parse(args);
+            const courseId = await resolveCourseId(client, input.course_id);
+            const page = await client.updatePage(courseId, input.page_url_or_id, {
+                title: input.title,
+                body: input.body,
+                published: input.published
+            });
+            return {
+                content: [{ type: "text", text: JSON.stringify(page, null, 2) }],
+            };
+        }
+    }
+];