@charlie.act7/canvas-mcp-server 1.1.0

package/dist/index.js

@@ -0,0 +1,168 @@
+#!/usr/bin/env node
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { CallToolRequestSchema, ListToolsRequestSchema, ListPromptsRequestSchema, GetPromptRequestSchema, ListResourcesRequestSchema, ReadResourceRequestSchema } from "@modelcontextprotocol/sdk/types.js";
+import * as dotenv from "dotenv";
+import { Command } from "commander";
+import inquirer from "inquirer";
+import chalk from "chalk";
+import { CanvasClient } from "./services/canvas-client.js";
+import { ConfigManager } from "./common/config-manager.js";
+// Import Modular Components
+import { courseTools } from "./tools/course-tools.js";
+import { assignmentTools } from "./tools/assignment-tools.js";
+import { quizTools } from "./tools/quiz-tools.js";
+import { gradingTools } from "./tools/grading-tools.js";
+import { communicationTools } from "./tools/communication-tools.js";
+import { studentTools } from "./tools/student-tools.js";
+import { quizQuestionTools } from "./tools/quiz-question-tools.js";
+import { createTools } from "./tools/create-tools.js";
+import { moduleTools } from "./tools/module-tools.js";
+import { fileTools } from "./tools/file-tools.js";
+import { configTools } from "./tools/config-tools.js";
+import { rubricTools } from "./tools/rubric-tools.js";
+import { calendarTools } from "./tools/calendar-tools.js";
+import { groupTools } from "./tools/group-tools.js";
+import { canvasResources } from "./resources/canvas-resources.js";
+import { canvasPrompts } from "./prompts/canvas-prompts.js";
+import { startHttpServer } from "./http-server.js";
+// Load env vars if present
+dotenv.config();
+const configManager = new ConfigManager();
+const program = new Command();
+program
+    .name("canvas-mcp")
+    .description("MCP Server for Canvas LMS (Refactored)")
+    .version("1.1.0");
+// --- CLI Commands ---
+program
+    .command("config")
+    .description("Configure Canvas credentials interactively")
+    .action(async () => {
+    console.log(chalk.blue.bold("\nCanvas MCP Server Configuration\n"));
+    const answers = await inquirer.prompt([
+        {
+            type: "input",
+            name: "domain",
+            message: "Canvas Domain (e.g., uide.instructure.com):",
+            default: configManager.get("CANVAS_API_DOMAIN"),
+            validate: (input) => input.trim().length > 0
+        },
+        {
+            type: "password",
+            name: "token",
+            message: "Canvas API Token:",
+            mask: "*",
+            validate: (input) => input.trim().length > 0
+        }
+    ]);
+    configManager.set("CANVAS_API_DOMAIN", answers.domain);
+    configManager.set("CANVAS_API_TOKEN", answers.token);
+    console.log(chalk.green("\n✅ Configuration saved successfully!"));
+    console.log(chalk.gray(`Saved to: ${configManager.path}`));
+});
+// Helper to get authenticated client
+function getClient() {
+    const token = process.env.CANVAS_API_TOKEN || configManager.get("CANVAS_API_TOKEN");
+    const domain = process.env.CANVAS_API_DOMAIN || configManager.get("CANVAS_API_DOMAIN");
+    if (!token || !domain) {
+        console.error(chalk.red("Error: Missing configuration."));
+        console.error(`Please run ${chalk.cyan("canvas-mcp config")} or set env vars.`);
+        process.exit(1);
+    }
+    return new CanvasClient(token, domain);
+}
+// NOTE: We could keep CLI commands for grading/auditing here calling the client directly,
+// but for the sake of the MCP Server refactor, we are focusing on the 'start' command.
+// I'll leave the 'start' command as the default.
+program
+    .command("start", { isDefault: true })
+    .description("Start the MCP server (stdio mode)")
+    .action(async () => {
+    const client = getClient();
+    const server = new Server({
+        name: "canvas-lms-server",
+        version: "1.0.0",
+    }, {
+        capabilities: {
+            tools: {},
+            prompts: {},
+            resources: {},
+        },
+    });
+    // --- Aggregation ---
+    const allTools = [
+        ...courseTools,
+        ...assignmentTools,
+        ...quizTools,
+        ...gradingTools,
+        ...communicationTools,
+        ...studentTools,
+        ...quizQuestionTools,
+        ...createTools,
+        ...moduleTools,
+        ...fileTools,
+        ...configTools,
+        ...rubricTools,
+        ...calendarTools,
+        ...groupTools
+    ];
+    // --- Tool Handlers ---
+    server.setRequestHandler(ListToolsRequestSchema, async () => {
+        return {
+            tools: allTools.map(t => t.tool)
+        };
+    });
+    server.setRequestHandler(CallToolRequestSchema, async (request) => {
+        const toolDef = allTools.find(t => t.name === request.params.name);
+        if (!toolDef) {
+            throw new Error(`Tool ${request.params.name} not found`);
+        }
+        try {
+            return await toolDef.handler(client, request.params.arguments);
+        }
+        catch (error) {
+            return {
+                content: [{ type: "text", text: `Error: ${error.message}` }],
+                isError: true
+            };
+        }
+    });
+    // --- Resource Handlers ---
+    server.setRequestHandler(ListResourcesRequestSchema, async () => {
+        return {
+            resources: canvasResources.list
+        };
+    });
+    server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
+        const uri = new URL(request.params.uri);
+        return await canvasResources.read(uri, client);
+    });
+    // --- Prompt Handlers ---
+    server.setRequestHandler(ListPromptsRequestSchema, async () => {
+        return {
+            prompts: canvasPrompts.map(p => p.prompt)
+        };
+    });
+    server.setRequestHandler(GetPromptRequestSchema, async (request) => {
+        const promptDef = canvasPrompts.find(p => p.name === request.params.name);
+        if (!promptDef) {
+            throw new Error("Prompt not found");
+        }
+        return await promptDef.handler(request.params.arguments);
+    });
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.error("Canvas MCP Server running on stdio");
+});
+program
+    .command("serve-http")
+    .description("Start HTTP API (Fastify) for GPT Builder Actions")
+    .option("--host <host>", "Host to bind", process.env.HTTP_HOST || "0.0.0.0")
+    .option("--port <port>", "Port to bind", process.env.PORT || process.env.HTTP_PORT || "3000")
+    .action(async (options) => {
+    const client = getClient();
+    const port = Number.parseInt(options.port, 10);
+    await startHttpServer(client, options.host, port);
+});
+program.parse(process.argv);

package/dist/prompts/canvas-prompts.js

@@ -0,0 +1,64 @@
+export const canvasPrompts = [
+    {
+        name: "audit_course",
+        prompt: {
+            name: "audit_course",
+            description: "Audit a course to find students who are missing assignments.",
+            arguments: [
+                {
+                    name: "course_id",
+                    description: "The ID of the course to audit",
+                    required: true
+                }
+            ]
+        },
+        handler: async (args) => {
+            const courseId = args?.course_id;
+            if (!courseId)
+                throw new Error("course_id is required");
+            return {
+                description: "Audit course for missing submissions",
+                messages: [
+                    {
+                        role: "user",
+                        content: {
+                            type: "text",
+                            text: `Please audit course ${courseId} to find any students who have not submitted assignments that are due soon or past due. Use the canvas_audit_course tool.`
+                        }
+                    }
+                ]
+            };
+        }
+    },
+    {
+        name: "summarize_course",
+        prompt: {
+            name: "summarize_course",
+            description: "Summarize the content and structure of a course.",
+            arguments: [
+                {
+                    name: "course_id",
+                    description: "The ID of the course",
+                    required: true
+                }
+            ]
+        },
+        handler: async (args) => {
+            const courseId = args?.course_id;
+            if (!courseId)
+                throw new Error("course_id is required");
+            return {
+                description: "Summarize course content",
+                messages: [
+                    {
+                        role: "user",
+                        content: {
+                            type: "text",
+                            text: `Please provide a summary of the course ${courseId}. List the modules, pages, and files available to understand the course structure.`
+                        }
+                    }
+                ]
+            };
+        }
+    }
+];

package/dist/resources/canvas-resources.js

@@ -0,0 +1,55 @@
+const resources = [
+    {
+        uri: "canvas://courses/{course_id}/readme",
+        name: "Course Readme/Summary",
+        mimeType: "text/markdown",
+        description: "A summary of the course structure"
+    }
+];
+// We'll manual dispatch for now to keep it simple as per original index.ts logic
+async function readResource(uri, client) {
+    if (uri.protocol !== "canvas:") {
+        throw new Error("Invalid protocol");
+    }
+    const pathParts = uri.pathname.split("/").filter(Boolean);
+    // Expected patterns:
+    // courses/{id}/pages/{page_id}
+    // courses/{id}/files/{file_id}
+    // courses/{id}/readme
+    if (pathParts[0] !== "courses") {
+        throw new Error("Unknown resource type");
+    }
+    const courseId = parseInt(pathParts[1]);
+    const subResource = pathParts[2];
+    if (subResource === "readme") {
+        const modules = await client.getModules(courseId);
+        const assignments = await client.getAssignments(courseId);
+        const summary = `# Course ${courseId} Summary\n\n## Modules\n${modules.map((m) => `- ${m.name} (${m.items_count} items)`).join("\n")}\n\n## Assignments\n${assignments.map((a) => `- ${a.name} (Due: ${a.due_at})`).join("\n")}`;
+        return {
+            contents: [{
+                    uri: uri.toString(),
+                    mimeType: "text/markdown",
+                    text: summary
+                }]
+        };
+    }
+    if (subResource === "pages") {
+        const pageId = pathParts[3];
+        const page = await client.getPage(courseId, pageId);
+        return {
+            contents: [{
+                    uri: uri.toString(),
+                    mimeType: "text/html",
+                    text: page.body || ""
+                }]
+        };
+    }
+    // Note: Files are tricky because we need to stream content or return text.
+    // For now, we won't implement file binary reading in this text-based resource handler,
+    // but we could return the metadata or download URL.
+    throw new Error(`Resource type ${subResource} not supported yet`);
+}
+export const canvasResources = {
+    list: resources,
+    read: readResource
+};