canvas-lms-mcp 1.0.0

package/build/canvas-client.js

@@ -0,0 +1,188 @@
+const DEFAULT_CANVAS_URL = "https://learning.unisg.ch";
+const CANVAS_URL = process.env.CANVAS_URL || DEFAULT_CANVAS_URL;
+const CANVAS_TOKEN = process.env.CANVAS_TOKEN;
+export function getFileContentType(file) {
+    return file["content-type"] || file.content_type || "application/octet-stream";
+}
+function isCanvasError(data) {
+    if (typeof data !== "object" || data === null)
+        return false;
+    return "errors" in data || ("message" in data && !Array.isArray(data));
+}
+function formatError(data) {
+    if (data.errors) {
+        if (Array.isArray(data.errors)) {
+            return data.errors.map((e) => e.message).join(", ");
+        }
+        return Object.entries(data.errors)
+            .map(([k, v]) => `${k}: ${v.map((e) => e.message).join(", ")}`)
+            .join("; ");
+    }
+    return data.message || "Unknown Canvas API error";
+}
+async function canvasCall(path, params = {}) {
+    const url = new URL(`/api/v1/${path}`, CANVAS_URL);
+    for (const [key, value] of Object.entries(params)) {
+        url.searchParams.set(key, value);
+    }
+    const response = await fetch(url.toString(), {
+        headers: { Authorization: `Bearer ${CANVAS_TOKEN}` },
+    });
+    if (!response.ok) {
+        const text = await response.text();
+        try {
+            const data = JSON.parse(text);
+            if (isCanvasError(data)) {
+                throw new Error(`Canvas API error (${response.status}): ${formatError(data)}`);
+            }
+        }
+        catch (e) {
+            if (e instanceof Error && e.message.startsWith("Canvas API"))
+                throw e;
+        }
+        throw new Error(`Canvas API HTTP error: ${response.status} ${response.statusText}`);
+    }
+    const data = await response.json();
+    if (isCanvasError(data)) {
+        throw new Error(`Canvas API error: ${formatError(data)}`);
+    }
+    return data;
+}
+async function canvasPaginatedCall(path, params = {}) {
+    const allResults = [];
+    const url = new URL(`/api/v1/${path}`, CANVAS_URL);
+    url.searchParams.set("per_page", "100");
+    for (const [key, value] of Object.entries(params)) {
+        url.searchParams.set(key, value);
+    }
+    let nextUrl = url.toString();
+    while (nextUrl) {
+        const response = await fetch(nextUrl, {
+            headers: { Authorization: `Bearer ${CANVAS_TOKEN}` },
+        });
+        if (!response.ok) {
+            const text = await response.text();
+            try {
+                const data = JSON.parse(text);
+                if (isCanvasError(data)) {
+                    throw new Error(`Canvas API error (${response.status}): ${formatError(data)}`);
+                }
+            }
+            catch (e) {
+                if (e instanceof Error && e.message.startsWith("Canvas API"))
+                    throw e;
+            }
+            throw new Error(`Canvas API HTTP error: ${response.status} ${response.statusText}`);
+        }
+        const data = await response.json();
+        if (Array.isArray(data)) {
+            allResults.push(...data);
+        }
+        // Parse Link header for pagination
+        const linkHeader = response.headers.get("link");
+        nextUrl = null;
+        if (linkHeader) {
+            const nextMatch = linkHeader.match(/<([^>]+)>;\s*rel="next"/);
+            if (nextMatch) {
+                nextUrl = nextMatch[1];
+            }
+        }
+    }
+    return allResults;
+}
+export async function getUserCourses() {
+    return canvasPaginatedCall("courses", {
+        enrollment_state: "active",
+        "include[]": "term",
+    });
+}
+export async function getCourseModules(courseId) {
+    return canvasPaginatedCall(`courses/${courseId}/modules`, {
+        "include[]": "items",
+    });
+}
+export async function getModuleItemFile(courseId, fileId) {
+    return canvasCall(`courses/${courseId}/files/${fileId}`);
+}
+export async function getCourseAssignments(courseId, params = {}) {
+    return canvasPaginatedCall(`courses/${courseId}/assignments`, {
+        order_by: "due_at",
+        ...params,
+    });
+}
+export async function getAnnouncements(courseId, params = {}) {
+    return canvasPaginatedCall("announcements", {
+        "context_codes[]": `course_${courseId}`,
+        ...params,
+    });
+}
+export async function getCourseFolders(courseId) {
+    return canvasPaginatedCall(`courses/${courseId}/folders`);
+}
+export async function getFolderFiles(folderId) {
+    return canvasPaginatedCall(`folders/${folderId}/files`);
+}
+export async function getCourseFiles(courseId, params = {}) {
+    return canvasPaginatedCall(`courses/${courseId}/files`, params);
+}
+export async function getPageByUrl(pageApiUrl) {
+    const response = await fetch(pageApiUrl, {
+        headers: { Authorization: `Bearer ${CANVAS_TOKEN}` },
+    });
+    if (!response.ok) {
+        throw new Error(`Failed to fetch page: ${response.status}`);
+    }
+    return response.json();
+}
+export function extractFileIdsFromHtml(html) {
+    const fileIds = [];
+    // Match data-api-endpoint URLs like /api/v1/courses/123/files/456
+    const pattern = /\/api\/v1\/courses\/\d+\/files\/(\d+)/g;
+    let match;
+    while ((match = pattern.exec(html)) !== null) {
+        fileIds.push(Number(match[1]));
+    }
+    // Also match direct file links like /courses/123/files/456
+    const directPattern = /\/courses\/\d+\/files\/(\d+)/g;
+    while ((match = directPattern.exec(html)) !== null) {
+        const id = Number(match[1]);
+        if (!fileIds.includes(id))
+            fileIds.push(id);
+    }
+    return fileIds;
+}
+export async function downloadFile(fileurl) {
+    const response = await fetch(fileurl, {
+        headers: { Authorization: `Bearer ${CANVAS_TOKEN}` },
+    });
+    if (!response.ok) {
+        throw new Error(`Failed to download file: ${response.status} ${response.statusText}`);
+    }
+    const arrayBuffer = await response.arrayBuffer();
+    return {
+        data: Buffer.from(arrayBuffer),
+        contentType: response.headers.get("content-type") || "application/octet-stream",
+    };
+}
+export function findCourse(courses, search) {
+    // Try numeric ID first
+    const asId = Number(search);
+    if (!isNaN(asId)) {
+        const byId = courses.find((c) => c.id === asId);
+        if (byId)
+            return { course: byId };
+        return { error: `No course found with ID ${asId}. Use list_courses to see available courses.` };
+    }
+    const lower = search.toLowerCase();
+    const matches = courses.filter((c) => c.name.toLowerCase().includes(lower) ||
+        c.course_code.toLowerCase().includes(lower));
+    if (matches.length === 0) {
+        const available = courses.map((c) => `${c.name} (id: ${c.id})`).join("\n  - ");
+        return { error: `No course found matching "${search}". Available courses:\n  - ${available}` };
+    }
+    if (matches.length > 1) {
+        const names = matches.map((c) => `${c.name} (id: ${c.id})`).join("\n  - ");
+        return { error: `Multiple courses match "${search}":\n  - ${names}\n\nPlease be more specific.` };
+    }
+    return { course: matches[0] };
+}

package/build/index.js

@@ -0,0 +1,37 @@
+#!/usr/bin/env node
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { listCoursesSchema, listCourses } from "./tools/list-courses.js";
+import { getCourseMaterialsSchema, getCourseMaterials } from "./tools/get-course-materials.js";
+import { downloadMaterialsSchema, downloadMaterials } from "./tools/download-materials.js";
+import { getAssignmentsSchema, getAssignments } from "./tools/get-assignments.js";
+import { getAnnouncementsSchema, getAnnouncementsHandler } from "./tools/get-announcements.js";
+import { getDeadlinesSchema, getDeadlines } from "./tools/get-deadlines.js";
+import { getGradesSchema, getGrades } from "./tools/get-grades.js";
+import { readMaterialSchema, readMaterial } from "./tools/read-material.js";
+if (!process.env.CANVAS_TOKEN) {
+    console.error(`Error: CANVAS_TOKEN environment variable is required.
+
+Get your token:
+  1. Log in to Canvas (${process.env.CANVAS_URL || "https://learning.unisg.ch"})
+  2. Go to Account > Settings
+  3. Scroll to "Approved Integrations" and click "+ New Access Token"
+  4. Copy the token
+  5. Set it: CANVAS_TOKEN=<token> npx canvas-mcp`);
+    process.exit(1);
+}
+const server = new McpServer({
+    name: "canvas-lms",
+    version: "1.0.0",
+});
+server.tool("list_courses", "List all Canvas courses the student is currently enrolled in.", listCoursesSchema.shape, async () => listCourses());
+server.tool("get_course_materials", "Get files from Canvas course modules, optionally filtered by recency and file type.", getCourseMaterialsSchema.shape, async (args) => getCourseMaterials(getCourseMaterialsSchema.parse(args)));
+server.tool("download_materials", "Download specific files from Canvas to local disk. Returns local file paths.", downloadMaterialsSchema.shape, async (args) => downloadMaterials(downloadMaterialsSchema.parse(args)));
+server.tool("get_assignments", "List assignments for a course with due dates, descriptions, and attachments.", getAssignmentsSchema.shape, async (args) => getAssignments(getAssignmentsSchema.parse(args)));
+server.tool("get_announcements", "Get recent announcements for a course with attachments.", getAnnouncementsSchema.shape, async (args) => getAnnouncementsHandler(getAnnouncementsSchema.parse(args)));
+server.tool("get_deadlines", "Get upcoming assignment deadlines across all enrolled courses, sorted by due date.", getDeadlinesSchema.shape, async (args) => getDeadlines(getDeadlinesSchema.parse(args)));
+server.tool("get_grades", "View assignment grades and scores for a course.", getGradesSchema.shape, async (args) => getGrades(getGradesSchema.parse(args)));
+server.tool("read_material", "Read and extract text content from a Canvas file (PDF or text). Returns the full text so you can summarize, answer questions, or help the student study. Use the file URL from get_course_materials output.", readMaterialSchema.shape, async (args) => readMaterial(readMaterialSchema.parse(args)));
+const transport = new StdioServerTransport();
+await server.connect(transport);
+console.error("Canvas LMS MCP server running on stdio");

package/build/tools/download-materials.js

@@ -0,0 +1,34 @@
+import { z } from "zod";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { downloadFile } from "../canvas-client.js";
+const DEFAULT_DOWNLOAD_DIR = process.env.DOWNLOAD_DIR || "./canvas-downloads";
+export const downloadMaterialsSchema = z.object({
+    fileurls: z.array(z.string()).describe("Array of Canvas file URLs from get_course_materials output"),
+    output_dir: z
+        .string()
+        .optional()
+        .default(DEFAULT_DOWNLOAD_DIR)
+        .describe(`Output directory (default: ${DEFAULT_DOWNLOAD_DIR})`),
+});
+export async function downloadMaterials(args) {
+    const outputDir = args.output_dir;
+    fs.mkdirSync(outputDir, { recursive: true });
+    const results = [];
+    for (const fileurl of args.fileurls) {
+        const urlPath = new URL(fileurl).pathname;
+        const filename = decodeURIComponent(urlPath.split("/").pop() || "unknown");
+        const localPath = path.join(outputDir, filename);
+        const { data } = await downloadFile(fileurl);
+        if (fs.existsSync(localPath)) {
+            const stat = fs.statSync(localPath);
+            if (stat.size === data.length) {
+                results.push({ filename, local_path: path.resolve(localPath), size_bytes: data.length });
+                continue;
+            }
+        }
+        fs.writeFileSync(localPath, data);
+        results.push({ filename, local_path: path.resolve(localPath), size_bytes: data.length });
+    }
+    return { content: [{ type: "text", text: JSON.stringify(results, null, 2) }] };
+}

package/build/tools/get-announcements.js

@@ -0,0 +1,38 @@
+import { z } from "zod";
+import { getUserCourses, getAnnouncements, findCourse } from "../canvas-client.js";
+export const getAnnouncementsSchema = z.object({
+    course_name: z.string().describe("Course name (fuzzy match) or numeric course ID"),
+    since_days_ago: z
+        .number()
+        .optional()
+        .default(14)
+        .describe("Only return announcements from the last N days (default 14)"),
+});
+export async function getAnnouncementsHandler(args) {
+    const courses = await getUserCourses();
+    const { course, error } = findCourse(courses, args.course_name);
+    if (error) {
+        return { content: [{ type: "text", text: error }] };
+    }
+    const startDate = new Date(Date.now() - args.since_days_ago * 86400 * 1000).toISOString();
+    const announcements = await getAnnouncements(course.id, { start_date: startDate });
+    const result = {
+        course: course.name,
+        course_id: course.id,
+        total_announcements: announcements.length,
+        announcements: announcements.map((a) => ({
+            title: a.title,
+            posted_at: a.posted_at,
+            author: a.author.display_name,
+            message_snippet: a.message
+                ? a.message.replace(/<[^>]*>/g, "").slice(0, 300)
+                : null,
+            attachments: a.attachments?.map((att) => ({
+                filename: att.display_name,
+                url: att.url,
+                size: att.size,
+            })) || [],
+        })),
+    };
+    return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+}

package/build/tools/get-assignments.js

@@ -0,0 +1,57 @@
+import { z } from "zod";
+import { getUserCourses, getCourseAssignments, findCourse } from "../canvas-client.js";
+export const getAssignmentsSchema = z.object({
+    course_name: z.string().describe("Course name (fuzzy match) or numeric course ID"),
+    since_days_ago: z
+        .number()
+        .optional()
+        .default(30)
+        .describe("Only return assignments due within this many days from now (default 30)"),
+    include_past: z
+        .boolean()
+        .optional()
+        .default(false)
+        .describe("Include assignments with past due dates (default false)"),
+});
+export async function getAssignments(args) {
+    const courses = await getUserCourses();
+    const { course, error } = findCourse(courses, args.course_name);
+    if (error) {
+        return { content: [{ type: "text", text: error }] };
+    }
+    const assignments = await getCourseAssignments(course.id);
+    const now = new Date();
+    const futureLimit = new Date(now.getTime() + args.since_days_ago * 86400 * 1000);
+    const filtered = assignments.filter((a) => {
+        if (!a.due_at)
+            return true; // No due date — always include
+        const due = new Date(a.due_at);
+        if (!args.include_past && due < now)
+            return false;
+        if (due > futureLimit)
+            return false;
+        return true;
+    });
+    const result = {
+        course: course.name,
+        course_id: course.id,
+        total_assignments: filtered.length,
+        assignments: filtered.map((a) => ({
+            name: a.name,
+            due_at: a.due_at,
+            points_possible: a.points_possible,
+            submission_types: a.submission_types,
+            description_snippet: a.description
+                ? a.description.replace(/<[^>]*>/g, "").slice(0, 200)
+                : null,
+            url: a.html_url,
+            attachments: a.attachments?.map((att) => ({
+                filename: att.display_name,
+                url: att.url,
+                size: att.size,
+                content_type: att.content_type,
+            })) || [],
+        })),
+    };
+    return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+}

package/build/tools/get-course-materials.js

@@ -0,0 +1,147 @@
+import { z } from "zod";
+import { getUserCourses, getCourseModules, getModuleItemFile, getCourseFolders, getFolderFiles, getPageByUrl, extractFileIdsFromHtml, findCourse, getFileContentType } from "../canvas-client.js";
+export const getCourseMaterialsSchema = z.object({
+    course_name: z.string().describe("Course name (fuzzy match) or numeric course ID"),
+    since_days_ago: z
+        .number()
+        .optional()
+        .default(7)
+        .describe("Only return files modified within this many days (default 7)"),
+    file_type: z
+        .string()
+        .optional()
+        .default("application/pdf")
+        .describe("MIME content-type filter (default application/pdf)"),
+});
+export async function getCourseMaterials(args) {
+    const courses = await getUserCourses();
+    const { course, error } = findCourse(courses, args.course_name);
+    if (error) {
+        return { content: [{ type: "text", text: error }] };
+    }
+    const cutoff = new Date(Date.now() - args.since_days_ago * 86400 * 1000).toISOString();
+    const materials = [];
+    const pages = [];
+    const seenFileIds = new Set();
+    // 1. Search module items (Files + Pages with embedded files)
+    try {
+        const modules = await getCourseModules(course.id);
+        for (const mod of modules) {
+            if (!mod.items)
+                continue;
+            for (const item of mod.items) {
+                // Direct file items
+                if (item.type === "File" && item.content_id) {
+                    try {
+                        const file = await getModuleItemFile(course.id, item.content_id);
+                        if (getFileContentType(file) !== args.file_type)
+                            continue;
+                        if (file.updated_at < cutoff)
+                            continue;
+                        seenFileIds.add(file.id);
+                        materials.push({
+                            filename: file.display_name,
+                            url: file.url,
+                            filesize: file.size,
+                            updated_at: file.updated_at,
+                            location: `Module: ${mod.name}`,
+                        });
+                    }
+                    catch {
+                        // Skip files we can't access
+                    }
+                }
+                // Page items — extract embedded file links + record page info
+                if (item.type === "Page" && item.url) {
+                    try {
+                        const page = await getPageByUrl(item.url);
+                        if (!page.body)
+                            continue;
+                        const fileIds = extractFileIdsFromHtml(page.body);
+                        const textContent = page.body.replace(/<[^>]*>/g, " ").replace(/&nbsp;/g, " ").replace(/&amp;/g, "&").replace(/\s+/g, " ").trim();
+                        // Record page info regardless of whether it has files
+                        pages.push({
+                            title: page.title,
+                            module_name: mod.name,
+                            updated_at: page.updated_at,
+                            content_snippet: textContent.slice(0, 300),
+                            has_files: fileIds.length > 0,
+                            html_url: item.url.replace("/api/v1/courses/", "https://learning.unisg.ch/courses/").replace(/\/pages\//, "/pages/"),
+                        });
+                        for (const fileId of fileIds) {
+                            if (seenFileIds.has(fileId))
+                                continue;
+                            try {
+                                const file = await getModuleItemFile(course.id, fileId);
+                                if (getFileContentType(file) !== args.file_type)
+                                    continue;
+                                if (file.updated_at < cutoff)
+                                    continue;
+                                seenFileIds.add(file.id);
+                                materials.push({
+                                    filename: file.display_name,
+                                    url: file.url,
+                                    filesize: file.size,
+                                    updated_at: file.updated_at,
+                                    location: `Page: ${page.title} (${mod.name})`,
+                                });
+                            }
+                            catch {
+                                // Skip files we can't access
+                            }
+                        }
+                    }
+                    catch {
+                        // Skip pages we can't access
+                    }
+                }
+            }
+        }
+    }
+    catch {
+        // Modules may not be enabled for this course
+    }
+    // 2. Search course file tree (folders)
+    try {
+        const folders = await getCourseFolders(course.id);
+        for (const folder of folders) {
+            if (folder.files_count === 0)
+                continue;
+            try {
+                const files = await getFolderFiles(folder.id);
+                for (const file of files) {
+                    if (seenFileIds.has(file.id))
+                        continue;
+                    if (getFileContentType(file) !== args.file_type)
+                        continue;
+                    if (file.updated_at < cutoff)
+                        continue;
+                    seenFileIds.add(file.id);
+                    materials.push({
+                        filename: file.display_name,
+                        url: file.url,
+                        filesize: file.size,
+                        updated_at: file.updated_at,
+                        location: `Files: ${folder.full_name}`,
+                    });
+                }
+            }
+            catch {
+                // Skip folders we can't access
+            }
+        }
+    }
+    catch {
+        // Files section may not be accessible
+    }
+    const result = {
+        course: course.name,
+        course_id: course.id,
+        filter: { since_days_ago: args.since_days_ago, file_type: args.file_type },
+        total_files: materials.length,
+        total_pages: pages.length,
+        materials,
+        pages,
+    };
+    return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+}

package/build/tools/get-deadlines.js

@@ -0,0 +1,44 @@
+import { z } from "zod";
+import { getUserCourses, getCourseAssignments } from "../canvas-client.js";
+export const getDeadlinesSchema = z.object({
+    days_ahead: z
+        .number()
+        .optional()
+        .default(14)
+        .describe("Show deadlines within the next N days (default 14)"),
+});
+export async function getDeadlines(args) {
+    const courses = await getUserCourses();
+    const now = new Date();
+    const limit = new Date(now.getTime() + args.days_ahead * 86400 * 1000);
+    const allDeadlines = [];
+    for (const course of courses) {
+        try {
+            const assignments = await getCourseAssignments(course.id);
+            for (const a of assignments) {
+                if (!a.due_at)
+                    continue;
+                const due = new Date(a.due_at);
+                if (due < now || due > limit)
+                    continue;
+                allDeadlines.push({
+                    course_name: course.name,
+                    assignment_name: a.name,
+                    due_at: a.due_at,
+                    points_possible: a.points_possible,
+                    url: a.html_url,
+                });
+            }
+        }
+        catch {
+            // Skip courses we can't access assignments for
+        }
+    }
+    allDeadlines.sort((a, b) => new Date(a.due_at).getTime() - new Date(b.due_at).getTime());
+    const result = {
+        days_ahead: args.days_ahead,
+        total_deadlines: allDeadlines.length,
+        deadlines: allDeadlines,
+    };
+    return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+}

package/build/tools/get-grades.js

@@ -0,0 +1,31 @@
+import { z } from "zod";
+import { getUserCourses, getCourseAssignments, findCourse } from "../canvas-client.js";
+export const getGradesSchema = z.object({
+    course_name: z.string().describe("Fuzzy match against course name/code"),
+});
+export async function getGrades(args) {
+    const courses = await getUserCourses();
+    const { course, error } = findCourse(courses, args.course_name);
+    if (error) {
+        return { content: [{ type: "text", text: error }] };
+    }
+    const assignments = await getCourseAssignments(course.id, {
+        "include[]": "submission",
+    });
+    const graded = assignments
+        .filter((a) => a.submission && a.submission.workflow_state !== "unsubmitted")
+        .map((a) => ({
+        assignment_name: a.name,
+        score: a.submission.score,
+        points_possible: a.points_possible,
+        grade: a.submission.grade,
+        submitted_at: a.submission.submitted_at,
+    }));
+    const result = {
+        course: course.name,
+        course_id: course.id,
+        total_graded: graded.length,
+        grades: graded,
+    };
+    return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+}

package/build/tools/list-courses.js

@@ -0,0 +1,13 @@
+import { z } from "zod";
+import { getUserCourses } from "../canvas-client.js";
+export const listCoursesSchema = z.object({});
+export async function listCourses() {
+    const courses = await getUserCourses();
+    const result = courses.map((c) => ({
+        id: c.id,
+        name: c.name,
+        course_code: c.course_code,
+        term: c.term?.name || null,
+    }));
+    return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+}

package/build/tools/read-material.js

@@ -0,0 +1,51 @@
+import { z } from "zod";
+import { downloadFile } from "../canvas-client.js";
+import { PDFParse } from "pdf-parse";
+export const readMaterialSchema = z.object({
+    file_url: z.string().describe("Canvas file download URL (from get_course_materials output)"),
+});
+export async function readMaterial(args) {
+    const { data, contentType } = await downloadFile(args.file_url);
+    if (contentType.includes("pdf")) {
+        try {
+            const parser = new PDFParse({ data });
+            const result = await parser.getText();
+            await parser.destroy();
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify({
+                            pages: result.total,
+                            text: result.text,
+                        }),
+                    },
+                ],
+            };
+        }
+        catch (e) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Failed to parse PDF: ${e instanceof Error ? e.message : String(e)}`,
+                    },
+                ],
+            };
+        }
+    }
+    // For non-PDF text files, return as-is
+    if (contentType.includes("text") || contentType.includes("json") || contentType.includes("xml")) {
+        return {
+            content: [{ type: "text", text: data.toString("utf-8") }],
+        };
+    }
+    return {
+        content: [
+            {
+                type: "text",
+                text: `Unsupported content type: ${contentType}. This tool supports PDF and text files.`,
+            },
+        ],
+    };
+}

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "canvas-lms-mcp",
+  "version": "1.0.0",
+  "description": "MCP server to access Canvas LMS course materials, assignments, announcements, deadlines, and grades",
+  "type": "module",
+  "bin": {
+    "canvas-lms-mcp": "./build/index.js"
+  },
+  "scripts": {
+    "build": "tsc && chmod 755 build/index.js",
+    "prepare": "npm run build"
+  },
+  "files": [
+    "build"
+  ],
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "keywords": [
+    "mcp",
+    "canvas",
+    "lms",
+    "unisg",
+    "lectures"
+  ],
+  "license": "MIT",
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "latest",
+    "pdf-parse": "^2.4.5",
+    "zod": "^3.23.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "typescript": "^5.5.0"
+  }
+}