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

package/dist/index.js

@@ -35,6 +35,16 @@ import { startHttpServer } from "./http-server.js";
 dotenv.config();
 const configManager = new ConfigManager();
 const program = new Command();
+function uniqueTools(tools) {
+    const seen = new Set();
+    return tools.filter((tool) => {
+        if (seen.has(tool.name)) {
+            return false;
+        }
+        seen.add(tool.name);
+        return true;
+    });
+}
 program
     .name("canvas-mcp")
     .description("MCP Server for Canvas LMS (Refactored)")
@@ -96,7 +106,7 @@ program
         },
     });
     // --- Aggregation ---
-    const allTools = [
+    const allTools = uniqueTools([
         ...courseTools,
         ...assignmentTools,
         ...quizTools,
@@ -116,7 +126,7 @@ program
         ...newQuizTools,
         ...analyticsTools,
         ...peerReviewTools
-    ];
+    ]);
     // --- Tool Handlers ---
     server.setRequestHandler(ListToolsRequestSchema, async () => {
         return {
@@ -173,7 +183,7 @@ program
     .action(async (options) => {
     const client = getClient();
     const port = Number.parseInt(options.port, 10);
-    const allTools = [
+    const allTools = uniqueTools([
         ...courseTools,
         ...assignmentTools,
         ...quizTools,
@@ -193,7 +203,7 @@ program
         ...newQuizTools,
         ...analyticsTools,
         ...peerReviewTools
-    ];
+    ]);
     await startHttpServer(client, options.host, port, allTools);
 });
 program.parse(process.argv);

package/dist/services/canvas-client.js

@@ -273,9 +273,38 @@ export class CanvasClient {
         return response.data;
     }
     async updateModule(courseId, moduleId, data) {
-        const response = await this.client.put(`courses/${courseId}/modules/${moduleId}`, {
-            module: data
-        });
+        // Canvas only accepts arrays (prerequisite_module_ids, completion_requirements)
+        // via form-encoding, not JSON.
+        const hasArrays = data.prerequisite_module_ids !== undefined || data.completion_requirements !== undefined;
+        if (hasArrays) {
+            const params = new URLSearchParams();
+            if (data.name !== undefined)
+                params.set('module[name]', data.name);
+            if (data.published !== undefined)
+                params.set('module[published]', String(data.published));
+            if (data.position !== undefined)
+                params.set('module[position]', String(data.position));
+            if (data.require_sequential_progress !== undefined) {
+                params.set('module[require_sequential_progress]', String(data.require_sequential_progress));
+            }
+            if (data.prerequisite_module_ids) {
+                for (const id of data.prerequisite_module_ids) {
+                    params.append('module[prerequisite_module_ids][]', String(id));
+                }
+            }
+            if (data.completion_requirements) {
+                for (const req of data.completion_requirements) {
+                    params.append('module[completion_requirements][][id]', String(req.id));
+                    params.append('module[completion_requirements][][type]', req.type);
+                    if (req.min_score !== undefined) {
+                        params.append('module[completion_requirements][][min_score]', String(req.min_score));
+                    }
+                }
+            }
+            const response = await this.client.put(`courses/${courseId}/modules/${moduleId}`, params, { headers: { 'Content-Type': 'application/x-www-form-urlencoded' } });
+            return response.data;
+        }
+        const response = await this.client.put(`courses/${courseId}/modules/${moduleId}`, { module: data });
         return response.data;
     }
     async deleteModule(courseId, moduleId) {
@@ -290,9 +319,20 @@ export class CanvasClient {
         return response.data;
     }
     async updateModuleItem(courseId, moduleId, itemId, data) {
-        const response = await this.client.put(`courses/${courseId}/modules/${moduleId}/items/${itemId}`, {
-            module_item: data
-        });
+        // Canvas only accepts completion_requirement via form-encoding, not JSON.
+        // Use URLSearchParams when completion_requirement is present.
+        if (data.completion_requirement) {
+            const params = new URLSearchParams();
+            params.set('module_item[completion_requirement][type]', data.completion_requirement.type);
+            const { completion_requirement, ...rest } = data;
+            for (const [key, value] of Object.entries(rest)) {
+                if (value !== undefined)
+                    params.set(`module_item[${key}]`, String(value));
+            }
+            const response = await this.client.put(`courses/${courseId}/modules/${moduleId}/items/${itemId}`, params, { headers: { 'Content-Type': 'application/x-www-form-urlencoded' } });
+            return response.data;
+        }
+        const response = await this.client.put(`courses/${courseId}/modules/${moduleId}/items/${itemId}`, { module_item: data });
         return response.data;
     }
     async deleteModuleItem(courseId, moduleId, itemId) {
@@ -333,6 +373,39 @@ export class CanvasClient {
         }
         return uploadResponse.data;
     }
+    async getQuizSubmissions(courseId, quizId) {
+        const response = await this.client.get(`courses/${courseId}/quizzes/${quizId}/submissions`, {
+            params: { include: ['user'], per_page: 100 }
+        });
+        return response.data.quiz_submissions ?? [];
+    }
+    async deleteQuiz(courseId, quizId) {
+        await this.client.delete(`courses/${courseId}/quizzes/${quizId}`);
+        return { deleted: true };
+    }
+    async checkQuizPending(courseId, quizId) {
+        const [students, submissionsResp] = await Promise.all([
+            this.getEnrollments(courseId),
+            this.client.get(`courses/${courseId}/quizzes/${quizId}/submissions`, {
+                params: { per_page: 100 }
+            })
+        ]);
+        const realStudents = students.filter(u => u.name !== 'Estudiante de prueba' && u.sis_user_id !== null);
+        const submittedIds = new Set((submissionsResp.data.quiz_submissions ?? []).map((s) => s.user_id));
+        const pending = realStudents
+            .filter(u => !submittedIds.has(u.id))
+            .map(u => ({
+            id: u.id,
+            name: u.name ?? 'Desconocido',
+            email: u.login_id ?? ''
+        }));
+        return {
+            quiz_id: quizId,
+            total_students: realStudents.length,
+            submitted: submittedIds.size,
+            pending
+        };
+    }
     async createQuiz(courseId, quiz) {
         const response = await this.client.post(`courses/${courseId}/quizzes`, {
             quiz: quiz

package/dist/tools/module-tools.js

@@ -63,7 +63,7 @@ export const moduleTools = [
         name: "canvas_update_module",
         tool: {
             name: "canvas_update_module",
-            description: "Update an existing module",
+            description: "Update an existing module (name, published, position, prerequisites, completion requirements)",
             inputSchema: {
                 type: "object",
                 properties: {
@@ -74,7 +74,32 @@ export const moduleTools = [
                     module_id: { type: "number", description: "The ID of the module" },
                     name: { type: "string", description: "The new name of the module" },
                     published: { type: "boolean", description: "Whether the module is published" },
-                    position: { type: "number", description: "The new position of the module" }
+                    position: { type: "number", description: "The new position of the module" },
+                    prerequisite_module_ids: {
+                        type: "array",
+                        items: { type: "number" },
+                        description: "IDs of modules that must be completed before this one unlocks"
+                    },
+                    require_sequential_progress: {
+                        type: "boolean",
+                        description: "Whether items in the module must be completed in order"
+                    },
+                    completion_requirements: {
+                        type: "array",
+                        description: "Completion requirements for module items. Replaces ALL existing requirements — include every item that needs one.",
+                        items: {
+                            type: "object",
+                            properties: {
+                                id: { type: "number", description: "The module item ID" },
+                                type: {
+                                    type: "string",
+                                    description: "must_view, must_submit, must_contribute, min_score, must_mark_done"
+                                },
+                                min_score: { type: "number", description: "Required when type is min_score" }
+                            },
+                            required: ["id", "type"]
+                        }
+                    }
                 },
                 required: ["course_id", "module_id"],
             },
@@ -85,13 +110,23 @@ export const moduleTools = [
                 module_id: z.number(),
                 name: z.string().optional(),
                 published: z.boolean().optional(),
-                position: z.number().optional()
+                position: z.number().optional(),
+                prerequisite_module_ids: z.array(z.number()).optional(),
+                require_sequential_progress: z.boolean().optional(),
+                completion_requirements: z.array(z.object({
+                    id: z.number(),
+                    type: z.string(),
+                    min_score: z.number().optional()
+                })).optional()
             }).parse(args);
             const courseId = await resolveCourseId(client, input.course_id);
             const module = await client.updateModule(courseId, input.module_id, {
                 name: input.name,
                 published: input.published,
-                position: input.position
+                position: input.position,
+                prerequisite_module_ids: input.prerequisite_module_ids,
+                require_sequential_progress: input.require_sequential_progress,
+                completion_requirements: input.completion_requirements
             });
             return {
                 content: [{ type: "text", text: JSON.stringify(module, null, 2) }],
@@ -206,7 +241,11 @@ export const moduleTools = [
                     position: { type: "number", description: "The new position of the item" },
                     indent: { type: "number", description: "The new level of indentation (0-3)" },
                     published: { type: "boolean", description: "Whether the item is published" },
-                    new_module_id: { type: "number", description: "Move the item to a new module" }
+                    new_module_id: { type: "number", description: "Move the item to a new module" },
+                    completion_requirement_type: {
+                        type: "string",
+                        description: "Completion requirement type: must_view, must_submit, must_contribute, min_score, must_mark_done"
+                    }
                 },
                 required: ["course_id", "module_id", "item_id"],
             },
@@ -220,7 +259,8 @@ export const moduleTools = [
                 position: z.number().optional(),
                 indent: z.number().optional(),
                 published: z.boolean().optional(),
-                new_module_id: z.number().optional()
+                new_module_id: z.number().optional(),
+                completion_requirement_type: z.string().optional()
             }).parse(args);
             const courseId = await resolveCourseId(client, input.course_id);
             const result = await client.updateModuleItem(courseId, input.module_id, input.item_id, {
@@ -228,7 +268,10 @@ export const moduleTools = [
                 position: input.position,
                 indent: input.indent,
                 published: input.published,
-                module_id: input.new_module_id
+                module_id: input.new_module_id,
+                ...(input.completion_requirement_type && {
+                    completion_requirement: { type: input.completion_requirement_type }
+                })
             });
             return {
                 content: [{ type: "text", text: JSON.stringify(result, null, 2) }],

package/dist/tools/question-bank-tools.js

@@ -0,0 +1,238 @@
+import { resolveCourseId } from "../common/helpers.js";
+import { z } from "zod";
+export const questionBankTools = [
+    {
+        name: "canvas_list_question_banks",
+        tool: {
+            name: "canvas_list_question_banks",
+            description: "List question banks for a specific 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 banks = await client.listQuestionBanks(courseId);
+            return {
+                content: [{ type: "text", text: JSON.stringify(banks, null, 2) }]
+            };
+        }
+    },
+    {
+        name: "canvas_create_question_bank",
+        tool: {
+            name: "canvas_create_question_bank",
+            description: "Create a new question bank 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: "Title for the question bank"
+                    }
+                },
+                required: ["course_id", "title"]
+            }
+        },
+        handler: async (client, args) => {
+            const input = z.object({
+                course_id: z.union([z.number(), z.string()]),
+                title: z.string().min(1)
+            }).parse(args);
+            const courseId = await resolveCourseId(client, input.course_id);
+            const bank = await client.createQuestionBank(courseId, input.title);
+            return {
+                content: [{ type: "text", text: JSON.stringify(bank, null, 2) }]
+            };
+        }
+    },
+    {
+        name: "canvas_create_assessment_question",
+        tool: {
+            name: "canvas_create_assessment_question",
+            description: "Create a question in a question bank. Supports types: multiple_choice_question, true_false_question, essay_question, short_answer_question, fill_in_multiple_blanks_question, multiple_answers_question, matching_question, numerical_question.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    course_id: {
+                        anyOf: [{ type: "number" }, { type: "string" }],
+                        description: "The ID or name of the course"
+                    },
+                    bank_id: {
+                        type: "number",
+                        description: "The question bank ID"
+                    },
+                    name: {
+                        type: "string",
+                        description: "Short name/title for the question"
+                    },
+                    question_type: {
+                        type: "string",
+                        description: "Question type (e.g. multiple_choice_question, true_false_question, essay_question, short_answer_question)"
+                    },
+                    question_text: {
+                        type: "string",
+                        description: "The question text (HTML supported)"
+                    },
+                    points_possible: {
+                        type: "number",
+                        description: "Point value for the question"
+                    },
+                    answers: {
+                        type: "array",
+                        description: "Array of answer objects. For multiple_choice: weight=100 for correct, weight=0 for incorrect. For true_false: text='True'/'False'.",
+                        items: {
+                            type: "object",
+                            properties: {
+                                text: { type: "string", description: "Answer text" },
+                                weight: { type: "number", description: "100 for correct, 0 for incorrect" },
+                                comments: { type: "string", description: "Optional feedback comment" }
+                            },
+                            required: ["text", "weight"]
+                        }
+                    }
+                },
+                required: ["course_id", "bank_id", "name", "question_type", "question_text", "points_possible"]
+            }
+        },
+        handler: async (client, args) => {
+            const answerSchema = z.object({
+                text: z.string(),
+                weight: z.number(),
+                comments: z.string().optional()
+            });
+            const input = z.object({
+                course_id: z.union([z.number(), z.string()]),
+                bank_id: z.coerce.number(),
+                name: z.string().min(1),
+                question_type: z.string().min(1),
+                question_text: z.string().min(1),
+                points_possible: z.coerce.number(),
+                answers: z.array(answerSchema).optional()
+            }).parse(args);
+            const courseId = await resolveCourseId(client, input.course_id);
+            const question = await client.createAssessmentQuestion(courseId, input.bank_id, {
+                name: input.name,
+                question_type: input.question_type,
+                question_text: input.question_text,
+                points_possible: input.points_possible,
+                answers: input.answers
+            });
+            return {
+                content: [{ type: "text", text: JSON.stringify(question, null, 2) }]
+            };
+        }
+    },
+    {
+        name: "canvas_move_question_bank_questions",
+        tool: {
+            name: "canvas_move_question_bank_questions",
+            description: "Move questions from one question bank to another. If question_ids is omitted, all questions are moved.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    course_id: {
+                        anyOf: [{ type: "number" }, { type: "string" }],
+                        description: "The ID or name of the course"
+                    },
+                    source_bank_id: {
+                        type: "number",
+                        description: "Source question bank ID"
+                    },
+                    dest_bank_id: {
+                        type: "number",
+                        description: "Destination question bank ID"
+                    },
+                    question_ids: {
+                        type: "array",
+                        items: { type: "number" },
+                        description: "Optional list of specific question IDs to move. If omitted, all questions are moved."
+                    }
+                },
+                required: ["course_id", "source_bank_id", "dest_bank_id"]
+            }
+        },
+        handler: async (client, args) => {
+            const input = z.object({
+                course_id: z.union([z.number(), z.string()]),
+                source_bank_id: z.coerce.number(),
+                dest_bank_id: z.coerce.number(),
+                question_ids: z.array(z.coerce.number()).optional()
+            }).parse(args);
+            const courseId = await resolveCourseId(client, input.course_id);
+            const result = await client.moveQuestionBankQuestions(courseId, input.source_bank_id, input.dest_bank_id, input.question_ids);
+            return {
+                content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+            };
+        }
+    },
+    {
+        name: "canvas_create_quiz_group",
+        tool: {
+            name: "canvas_create_quiz_group",
+            description: "Create a quiz group linked to a question bank. The group randomly picks questions from the bank when students take the quiz.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    course_id: {
+                        anyOf: [{ type: "number" }, { type: "string" }],
+                        description: "The ID or name of the course"
+                    },
+                    quiz_id: {
+                        type: "number",
+                        description: "The quiz ID"
+                    },
+                    name: {
+                        type: "string",
+                        description: "Name for the quiz group"
+                    },
+                    pick_count: {
+                        type: "number",
+                        description: "Number of questions to randomly pick from the bank"
+                    },
+                    question_points: {
+                        type: "number",
+                        description: "Points per question in this group"
+                    },
+                    assessment_question_bank_id: {
+                        type: "number",
+                        description: "The question bank ID to link to this group"
+                    }
+                },
+                required: ["course_id", "quiz_id", "name", "pick_count", "question_points"]
+            }
+        },
+        handler: async (client, args) => {
+            const input = z.object({
+                course_id: z.union([z.number(), z.string()]),
+                quiz_id: z.coerce.number(),
+                name: z.string().min(1),
+                pick_count: z.coerce.number().min(1),
+                question_points: z.coerce.number().min(0),
+                assessment_question_bank_id: z.coerce.number().optional()
+            }).parse(args);
+            const courseId = await resolveCourseId(client, input.course_id);
+            const group = await client.createQuizGroup(courseId, input.quiz_id, {
+                name: input.name,
+                pick_count: input.pick_count,
+                question_points: input.question_points,
+                assessment_question_bank_id: input.assessment_question_bank_id
+            });
+            return {
+                content: [{ type: "text", text: JSON.stringify(group, null, 2) }]
+            };
+        }
+    }
+];

package/dist/tools/quiz-tools.js

@@ -437,6 +437,78 @@ export const quizTools = [
             return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
         }
     },
+    {
+        name: "canvas_get_quiz_submissions",
+        tool: {
+            name: "canvas_get_quiz_submissions",
+            description: "Get all submissions for a quiz, including user info. Useful to see who has responded.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    course_id: { anyOf: [{ type: "number" }, { type: "string" }], description: "The ID or name of the course" },
+                    quiz_id: { type: "number", description: "The quiz ID" }
+                },
+                required: ["course_id", "quiz_id"]
+            }
+        },
+        handler: async (client, args) => {
+            const input = z.object({
+                course_id: z.union([z.number(), z.string()]),
+                quiz_id: z.number()
+            }).parse(args);
+            const courseId = await resolveCourseId(client, input.course_id);
+            const submissions = await client.getQuizSubmissions(courseId, input.quiz_id);
+            return { content: [{ type: "text", text: JSON.stringify(submissions, null, 2) }] };
+        }
+    },
+    {
+        name: "canvas_check_quiz_pending",
+        tool: {
+            name: "canvas_check_quiz_pending",
+            description: "Check which enrolled students have NOT submitted a quiz. Returns a list of pending students with their name and email. Excludes test accounts.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    course_id: { anyOf: [{ type: "number" }, { type: "string" }], description: "The ID or name of the course" },
+                    quiz_id: { type: "number", description: "The quiz ID" }
+                },
+                required: ["course_id", "quiz_id"]
+            }
+        },
+        handler: async (client, args) => {
+            const input = z.object({
+                course_id: z.union([z.number(), z.string()]),
+                quiz_id: z.number()
+            }).parse(args);
+            const courseId = await resolveCourseId(client, input.course_id);
+            const result = await client.checkQuizPending(courseId, input.quiz_id);
+            return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+        }
+    },
+    {
+        name: "canvas_delete_quiz",
+        tool: {
+            name: "canvas_delete_quiz",
+            description: "Permanently delete a classic quiz from a course. This cannot be undone.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    course_id: { anyOf: [{ type: "number" }, { type: "string" }], description: "The ID or name of the course" },
+                    quiz_id: { type: "number", description: "The quiz ID to delete" }
+                },
+                required: ["course_id", "quiz_id"]
+            }
+        },
+        handler: async (client, args) => {
+            const input = z.object({
+                course_id: z.union([z.number(), z.string()]),
+                quiz_id: z.number()
+            }).parse(args);
+            const courseId = await resolveCourseId(client, input.course_id);
+            const result = await client.deleteQuiz(courseId, input.quiz_id);
+            return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+        }
+    },
     {
         name: "canvas_update_quiz",
         tool: {

package/package.json

@@ -1,70 +1,76 @@
-{
-    "name": "@charlie.act7/canvas-mcp-server",
-    "publishConfig": {
-        "access": "public"
-    },
-    "version": "1.2.0",
-    "description": "MCP Server for Canvas LMS - Use AI to interact with your courses, assignments, and grades.",
-    "main": "dist/index.js",
-    "bin": {
-        "canvas-mcp": "dist/index.js"
-    },
-    "type": "module",
-    "files": [
-        "dist/index.js",
-        "dist/http-server.js",
-        "dist/common",
-        "dist/prompts",
-        "dist/resources",
-        "dist/services",
-        "dist/tools",
-        "README.md",
-        "llms-install.md",
-        ".claude-plugin",
-        ".mcp.json"
-    ],
-    "scripts": {
-        "build": "tsc",
-        "start": "node dist/index.js",
-        "start:http": "node dist/index.js serve-http",
-        "dev": "tsc --watch",
-        "chat": "tsx src/ollama_bridge.ts",
-        "prepublishOnly": "npm run build"
-    },
-    "keywords": [
-        "mcp",
-        "canvas",
-        "lms",
-        "ai",
-        "agent",
-        "server"
-    ],
-    "author": "Charlie Cárdenas Toledo",
-    "license": "MIT",
-    "dependencies": {
-        "@fastify/swagger": "^9.5.2",
-        "@fastify/swagger-ui": "^5.2.3",
-        "@google/genai": "^2.8.0",
-        "@modelcontextprotocol/sdk": "^1.25.3",
-        "axios": "^1.6.0",
-        "chalk": "^5.3.0",
-        "commander": "^11.1.0",
-        "conf": "^12.0.0",
-        "dotenv": "^16.3.1",
-        "fastify": "^5.6.1",
-        "form-data": "^4.0.5",
-        "inquirer": "^9.2.12",
-        "ollama": "^0.6.3",
-        "zod": "^3.22.4"
-    },
-    "devDependencies": {
-        "@types/inquirer": "^9.0.7",
-        "@types/node": "^20.10.0",
-        "nodemon": "^3.1.11",
-        "tsx": "^4.21.0",
-        "typescript": "^5.3.0"
-    },
-    "engines": {
-        "node": ">=18.0.0"
-    }
-}
+{
+  "name": "@charlie.act7/canvas-mcp-server",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/CharlieCardenasToledo/mcp-canvas-server.git"
+  },
+  "homepage": "https://github.com/CharlieCardenasToledo/mcp-canvas-server#readme",
+  "bugs": {
+    "url": "https://github.com/CharlieCardenasToledo/mcp-canvas-server/issues"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "version": "1.2.1",
+  "description": "MCP Server for Canvas LMS - Use AI to interact with your courses, assignments, and grades.",
+  "main": "dist/index.js",
+  "bin": {
+    "canvas-mcp": "dist/index.js"
+  },
+  "type": "module",
+  "files": [
+    "dist/index.js",
+    "dist/http-server.js",
+    "dist/common",
+    "dist/prompts",
+    "dist/resources",
+    "dist/services",
+    "dist/tools",
+    "README.md",
+    "llms-install.md"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "start": "node dist/index.js",
+    "start:http": "node dist/index.js serve-http",
+    "dev": "tsc --watch",
+    "chat": "tsx src/ollama_bridge.ts",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "mcp",
+    "canvas",
+    "lms",
+    "ai",
+    "agent",
+    "server"
+  ],
+  "author": "Charlie Cárdenas Toledo",
+  "license": "MIT",
+  "dependencies": {
+    "@fastify/swagger": "^9.5.2",
+    "@fastify/swagger-ui": "^5.2.3",
+    "@google/genai": "^2.8.0",
+    "@modelcontextprotocol/sdk": "^1.25.3",
+    "axios": "^1.6.0",
+    "chalk": "^5.3.0",
+    "commander": "^11.1.0",
+    "conf": "^12.0.0",
+    "dotenv": "^16.3.1",
+    "fastify": "^5.6.1",
+    "form-data": "^4.0.5",
+    "inquirer": "^9.2.12",
+    "ollama": "^0.6.3",
+    "zod": "^3.22.4"
+  },
+  "devDependencies": {
+    "@types/inquirer": "^9.0.7",
+    "@types/node": "^20.10.0",
+    "nodemon": "^3.1.11",
+    "tsx": "^4.21.0",
+    "typescript": "^5.3.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}

package/.claude-plugin/plugin.json

@@ -1,11 +0,0 @@
-{
-  "name": "canvas-lms",
-  "description": "Canvas LMS integration for teachers. Manage courses, assignments, grades, quizzes, students, modules, and more — directly from Claude Code.",
-  "version": "1.1.0",
-  "author": {
-    "name": "CharlieCardenasToledo"
-  },
-  "homepage": "https://github.com/CharlieCardenasToledo/canvas-mcp-server",
-  "repository": "https://github.com/CharlieCardenasToledo/canvas-mcp-server",
-  "license": "MIT"
-}

package/.mcp.json

@@ -1,12 +0,0 @@
-{
-  "mcpServers": {
-    "canvas": {
-      "command": "npx",
-      "args": ["-y", "@charlie.act7/canvas-mcp-server"],
-      "env": {
-        "CANVAS_API_TOKEN": "${CANVAS_API_TOKEN}",
-        "CANVAS_API_DOMAIN": "${CANVAS_API_DOMAIN}"
-      }
-    }
-  }
-}