infinitecampus-mcp 0.1.0

package/dist/client.js

@@ -0,0 +1,183 @@
+import { writeFile, stat } from 'fs/promises';
+import { dirname } from 'path';
+const SESSION_TTL_MS = 5 * 60 * 60 * 1000; // 5h, slightly under IC's typical 6h
+export class ICClient {
+    accounts = new Map();
+    sessions = new Map();
+    constructor(accounts) {
+        for (const a of accounts)
+            this.accounts.set(a.name, a);
+    }
+    listDistricts() {
+        return [...this.accounts.values()].map((a) => ({ name: a.name, baseUrl: a.baseUrl }));
+    }
+    async request(district, path, opts = {}) {
+        const account = this.accounts.get(district);
+        if (!account)
+            throw new UnknownDistrictError(district, [...this.accounts.keys()]);
+        await this.ensureSession(account);
+        return this.doRequest(account, path, opts, false);
+    }
+    async ensureSession(account) {
+        let s = this.sessions.get(account.name);
+        if (s && Date.now() - s.loggedInAt < SESSION_TTL_MS)
+            return;
+        if (s?.loginInFlight) {
+            await s.loginInFlight;
+            return;
+        }
+        if (!s) {
+            s = { cookie: '', loggedInAt: 0, loginInFlight: null };
+            this.sessions.set(account.name, s);
+        }
+        s.loginInFlight = this.login(account);
+        try {
+            await s.loginInFlight;
+        }
+        finally {
+            s.loginInFlight = null;
+        }
+    }
+    async login(account) {
+        // Step A: GET login form to capture initial JSESSIONID
+        const initRes = await fetch(`${account.baseUrl}/campus/portal/parents/${account.district}.jsp`, { redirect: 'manual' });
+        const initCookie = parseSetCookie(initRes.headers.get('set-cookie'));
+        // Step B: POST credentials to verify endpoint
+        const postRes = await fetch(`${account.baseUrl}/campus/verify.jsp?nonBrowser=true&username=${encodeURIComponent(account.username)}&password=${encodeURIComponent(account.password)}&appName=${encodeURIComponent(account.district)}`, {
+            method: 'POST',
+            headers: initCookie ? { Cookie: initCookie } : {},
+            redirect: 'manual',
+        });
+        if (postRes.status >= 500)
+            throw new PortalUnreachableError(account.name, postRes.status);
+        const postCookie = parseSetCookie(postRes.headers.get('set-cookie')) || initCookie;
+        if (!postCookie || postRes.status >= 400)
+            throw new AuthFailedError(account.name);
+        // Mutate the in-map session in place so concurrent callers'
+        // references stay live (see ensureSession).
+        const session = this.sessions.get(account.name);
+        session.cookie = postCookie;
+        session.loggedInAt = Date.now();
+    }
+    async download(district, path, destinationPath, opts = {}) {
+        // Pre-flight checks before authenticating, so we fail fast on bad paths
+        let destStat = null;
+        try {
+            destStat = await stat(destinationPath);
+        }
+        catch { /* not present, ok */ }
+        if (destStat?.isDirectory())
+            throw new InvalidPathError(destinationPath);
+        if (destStat && !opts.overwrite)
+            throw new FileExistsError(destinationPath);
+        const parent = dirname(destinationPath);
+        try {
+            await stat(parent);
+        }
+        catch {
+            throw new ParentDirectoryMissingError(parent);
+        }
+        const account = this.accounts.get(district);
+        if (!account)
+            throw new UnknownDistrictError(district, [...this.accounts.keys()]);
+        await this.ensureSession(account);
+        const session = this.sessions.get(account.name);
+        const res = await fetch(`${account.baseUrl}${path}`, { headers: { Cookie: session.cookie } });
+        if (!res.ok)
+            throw new Error(`IC download ${res.status} for ${path}`);
+        const buf = new Uint8Array(await res.arrayBuffer());
+        await writeFile(destinationPath, buf);
+        return {
+            path: destinationPath,
+            bytes: buf.byteLength,
+            contentType: res.headers.get('content-type') ?? 'application/octet-stream',
+        };
+    }
+    async doRequest(account, path, opts, isRetry) {
+        const session = this.sessions.get(account.name);
+        const res = await fetch(`${account.baseUrl}${path}`, {
+            method: opts.method ?? 'GET',
+            headers: { Cookie: session.cookie, Accept: 'application/json', ...(opts.headers ?? {}) },
+            body: opts.body,
+        });
+        if (res.status === 401) {
+            if (isRetry)
+                throw new SessionExpiredError(account.name);
+            this.sessions.delete(account.name);
+            await this.ensureSession(account);
+            return this.doRequest(account, path, opts, true);
+        }
+        if (res.status >= 500)
+            throw new PortalUnreachableError(account.name, res.status);
+        if (!res.ok)
+            throw new Error(`IC ${res.status} ${res.statusText} for ${path}`);
+        const text = await res.text();
+        return (text ? JSON.parse(text) : null);
+    }
+}
+function parseSetCookie(header) {
+    if (!header)
+        return '';
+    // Take first cookie's name=value, drop attributes
+    return header.split(',').map((c) => c.split(';')[0].trim()).join('; ');
+}
+export class UnknownDistrictError extends Error {
+    district;
+    available;
+    constructor(district, available) {
+        super(`Unknown district '${district}'. Configured: [${available.join(', ')}]`);
+        this.district = district;
+        this.available = available;
+        this.name = 'UnknownDistrictError';
+    }
+}
+export class AuthFailedError extends Error {
+    district;
+    constructor(district) {
+        super(`Login failed for district '${district}'. Check IC_N_USERNAME and IC_N_PASSWORD.`);
+        this.district = district;
+        this.name = 'AuthFailedError';
+    }
+}
+export class PortalUnreachableError extends Error {
+    district;
+    status;
+    constructor(district, status) {
+        super(`Portal unreachable for district '${district}' (status ${status})`);
+        this.district = district;
+        this.status = status;
+        this.name = 'PortalUnreachableError';
+    }
+}
+export class SessionExpiredError extends Error {
+    district;
+    constructor(district) {
+        super(`Session expired for district '${district}' after re-login retry`);
+        this.district = district;
+        this.name = 'SessionExpiredError';
+    }
+}
+export class InvalidPathError extends Error {
+    path;
+    constructor(path) {
+        super(`InvalidPath: destinationPath must be a filename, not a directory: ${path}`);
+        this.path = path;
+        this.name = 'InvalidPathError';
+    }
+}
+export class ParentDirectoryMissingError extends Error {
+    path;
+    constructor(path) {
+        super(`ParentDirectoryMissing: ${path}`);
+        this.path = path;
+        this.name = 'ParentDirectoryMissingError';
+    }
+}
+export class FileExistsError extends Error {
+    path;
+    constructor(path) {
+        super(`FileExists at ${path}. Pass overwrite:true to replace.`);
+        this.path = path;
+        this.name = 'FileExistsError';
+    }
+}

package/dist/config.js

@@ -0,0 +1,47 @@
+const FIELDS = ['NAME', 'BASE_URL', 'DISTRICT', 'USERNAME', 'PASSWORD'];
+function readSlot(env, n) {
+    const out = {};
+    let any = false;
+    for (const f of FIELDS) {
+        const v = env[`IC_${n}_${f}`];
+        if (v && v.length > 0) {
+            out[f] = v;
+            any = true;
+        }
+    }
+    return { any, fields: out };
+}
+export function loadAccounts(env = process.env) {
+    const accounts = [];
+    const seenNames = new Map();
+    for (let n = 1; n < 1000; n++) {
+        const { any, fields } = readSlot(env, n);
+        if (!any)
+            break;
+        const missing = FIELDS.filter((f) => !fields[f]);
+        if (missing.length > 0) {
+            throw new Error(`Account IC_${n} is incomplete: missing ${missing.join(', ')}. ` +
+                `Required vars: ${FIELDS.join(', ')}.`);
+        }
+        const firstSeenAt = seenNames.get(fields.NAME);
+        if (firstSeenAt !== undefined) {
+            throw new Error(`Duplicate district name '${fields.NAME}' in IC_${firstSeenAt} and IC_${n}. Names must be unique.`);
+        }
+        seenNames.set(fields.NAME, n);
+        if (!/^https:\/\//.test(fields.BASE_URL)) {
+            throw new Error(`IC_${n}_BASE_URL is not a valid https URL: '${fields.BASE_URL}'`);
+        }
+        accounts.push({
+            name: fields.NAME,
+            baseUrl: fields.BASE_URL.replace(/\/$/, ''),
+            district: fields.DISTRICT,
+            username: fields.USERNAME,
+            password: fields.PASSWORD,
+        });
+    }
+    if (accounts.length === 0) {
+        throw new Error('No Infinite Campus accounts configured. Set IC_1_NAME, IC_1_BASE_URL, ' +
+            'IC_1_DISTRICT, IC_1_USERNAME, IC_1_PASSWORD (and IC_2_*, IC_3_* for more).');
+    }
+    return accounts;
+}

package/dist/index.js

@@ -0,0 +1,42 @@
+#!/usr/bin/env node
+import { dirname, join } from 'path';
+import { fileURLToPath } from 'url';
+try {
+    const { config } = await import('dotenv');
+    const __dirname = dirname(fileURLToPath(import.meta.url));
+    config({ path: join(__dirname, '..', '.env'), override: false });
+}
+catch {
+    // dotenv not available — rely on process.env
+}
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { loadAccounts } from './config.js';
+import { ICClient } from './client.js';
+import { registerDistrictTools } from './tools/districts.js';
+import { registerStudentTools } from './tools/students.js';
+import { registerScheduleTools } from './tools/schedule.js';
+import { registerAssignmentTools } from './tools/assignments.js';
+import { registerGradeTools } from './tools/grades.js';
+import { registerAttendanceTools } from './tools/attendance.js';
+import { registerBehaviorTools } from './tools/behavior.js';
+import { registerFoodServiceTools } from './tools/foodservice.js';
+import { registerMessageTools } from './tools/messages.js';
+import { registerDocumentTools } from './tools/documents.js';
+const accounts = loadAccounts();
+const client = new ICClient(accounts);
+const server = new McpServer({ name: 'infinitecampus', version: '0.1.0' });
+registerDistrictTools(server, client);
+registerStudentTools(server, client);
+registerScheduleTools(server, client);
+registerAssignmentTools(server, client);
+registerGradeTools(server, client);
+registerAttendanceTools(server, client);
+registerBehaviorTools(server, client);
+registerFoodServiceTools(server, client);
+registerMessageTools(server, client);
+registerDocumentTools(server, client);
+console.error(`[infinitecampus-mcp] Loaded ${accounts.length} district(s): ${accounts.map((a) => a.name).join(', ')}`);
+console.error('[infinitecampus-mcp] Developed and maintained by AI (Claude). Use at your own discretion.');
+const transport = new StdioServerTransport();
+await server.connect(transport);

package/dist/tools/assignments.js

@@ -0,0 +1,28 @@
+import { z } from 'zod';
+const argsSchema = z.object({
+    district: z.string(),
+    studentId: z.string(),
+    courseId: z.string().optional(),
+    since: z.string().describe('YYYY-MM-DD').optional(),
+    until: z.string().describe('YYYY-MM-DD').optional(),
+    missingOnly: z.boolean().optional(),
+});
+export function registerAssignmentTools(server, client) {
+    server.registerTool('ic_list_assignments', {
+        description: "List a student's assignments. Filterable by course and date range; missingOnly returns only un-submitted past-due work.",
+        annotations: { readOnlyHint: true },
+        inputSchema: argsSchema.shape,
+    }, async (rawArgs) => {
+        const args = argsSchema.parse(rawArgs);
+        const params = new URLSearchParams({ personID: args.studentId });
+        if (args.courseId)
+            params.set('sectionID', args.courseId);
+        if (args.since)
+            params.set('startDate', args.since);
+        if (args.until)
+            params.set('endDate', args.until);
+        const raw = await client.request(args.district, `/campus/api/portal/parents/assignments?${params}`);
+        const data = args.missingOnly ? raw.filter((a) => a.missing) : raw;
+        return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+    });
+}

package/dist/tools/attendance.js

@@ -0,0 +1,23 @@
+import { z } from 'zod';
+const argsSchema = z.object({
+    district: z.string(),
+    studentId: z.string(),
+    since: z.string().describe('YYYY-MM-DD').optional(),
+    until: z.string().describe('YYYY-MM-DD').optional(),
+});
+export function registerAttendanceTools(server, client) {
+    server.registerTool('ic_list_attendance', {
+        description: "List a student's absences and tardies in a date range.",
+        annotations: { readOnlyHint: true },
+        inputSchema: argsSchema.shape,
+    }, async (rawArgs) => {
+        const args = argsSchema.parse(rawArgs);
+        const params = new URLSearchParams({ personID: args.studentId });
+        if (args.since)
+            params.set('startDate', args.since);
+        if (args.until)
+            params.set('endDate', args.until);
+        const data = await client.request(args.district, `/campus/api/portal/parents/attendance?${params}`);
+        return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+    });
+}

package/dist/tools/behavior.js

@@ -0,0 +1,32 @@
+import { z } from 'zod';
+const argsSchema = z.object({
+    district: z.string(),
+    studentId: z.string(),
+    since: z.string().optional(),
+    until: z.string().optional(),
+});
+export function registerBehaviorTools(server, client) {
+    server.registerTool('ic_list_behavior', {
+        description: "List a student's behavior events / referrals. Returns FeatureDisabled if the district has the behavior module turned off.",
+        annotations: { readOnlyHint: true },
+        inputSchema: argsSchema.shape,
+    }, async (rawArgs) => {
+        const args = argsSchema.parse(rawArgs);
+        const params = new URLSearchParams({ personID: args.studentId });
+        if (args.since)
+            params.set('startDate', args.since);
+        if (args.until)
+            params.set('endDate', args.until);
+        try {
+            const data = await client.request(args.district, `/campus/api/portal/parents/behavior?${params}`);
+            return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+        }
+        catch (e) {
+            if (e instanceof Error && e.message.startsWith('IC 404 ')) {
+                const warn = { warning: 'FeatureDisabled', feature: 'behavior', district: args.district, data: [] };
+                return { content: [{ type: 'text', text: JSON.stringify(warn, null, 2) }] };
+            }
+            throw e;
+        }
+    });
+}

package/dist/tools/districts.js

@@ -0,0 +1,9 @@
+export function registerDistrictTools(server, client) {
+    server.registerTool('ic_list_districts', {
+        description: 'List Infinite Campus districts configured for this MCP server. Returns names + base URLs (no credentials).',
+        annotations: { readOnlyHint: true },
+    }, async () => {
+        const data = client.listDistricts();
+        return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+    });
+}

package/dist/tools/documents.js

@@ -0,0 +1,33 @@
+import { z } from 'zod';
+const listArgs = z.object({
+    district: z.string(),
+    studentId: z.string(),
+});
+const downloadArgs = z.object({
+    district: z.string(),
+    documentId: z.string().describe('The downloadUrl from ic_list_documents'),
+    destinationPath: z.string().describe('Absolute path where the PDF should be written'),
+    overwrite: z.boolean().optional(),
+});
+export function registerDocumentTools(server, client) {
+    server.registerTool('ic_list_documents', {
+        description: "List a student's available documents (report cards, transcripts, etc.). Returns metadata only — use ic_download_document to fetch the file.",
+        annotations: { readOnlyHint: true },
+        inputSchema: listArgs.shape,
+    }, async (rawArgs) => {
+        const args = listArgs.parse(rawArgs);
+        const data = await client.request(args.district, `/campus/api/portal/parents/documents?personID=${encodeURIComponent(args.studentId)}`);
+        return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+    });
+    server.registerTool('ic_download_document', {
+        description: "Download a student's document (PDF) to disk. documentId is the downloadUrl returned by ic_list_documents.",
+        annotations: { destructiveHint: true },
+        inputSchema: downloadArgs.shape,
+    }, async (rawArgs) => {
+        const args = downloadArgs.parse(rawArgs);
+        const meta = await client.download(args.district, args.documentId, args.destinationPath, {
+            overwrite: args.overwrite ?? false,
+        });
+        return { content: [{ type: 'text', text: JSON.stringify(meta, null, 2) }] };
+    });
+}

package/dist/tools/foodservice.js

@@ -0,0 +1,32 @@
+import { z } from 'zod';
+const argsSchema = z.object({
+    district: z.string(),
+    studentId: z.string(),
+    since: z.string().optional(),
+    until: z.string().optional(),
+});
+export function registerFoodServiceTools(server, client) {
+    server.registerTool('ic_list_food_service', {
+        description: "List a student's lunch balance and recent food-service transactions. Returns FeatureDisabled if the district has the module turned off.",
+        annotations: { readOnlyHint: true },
+        inputSchema: argsSchema.shape,
+    }, async (rawArgs) => {
+        const args = argsSchema.parse(rawArgs);
+        const params = new URLSearchParams({ personID: args.studentId });
+        if (args.since)
+            params.set('startDate', args.since);
+        if (args.until)
+            params.set('endDate', args.until);
+        try {
+            const data = await client.request(args.district, `/campus/api/portal/parents/foodService?${params}`);
+            return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+        }
+        catch (e) {
+            if (e instanceof Error && e.message.startsWith('IC 404 ')) {
+                const warn = { warning: 'FeatureDisabled', feature: 'foodService', district: args.district, data: { balance: null, transactions: [] } };
+                return { content: [{ type: 'text', text: JSON.stringify(warn, null, 2) }] };
+            }
+            throw e;
+        }
+    });
+}

package/dist/tools/grades.js

@@ -0,0 +1,20 @@
+import { z } from 'zod';
+const argsSchema = z.object({
+    district: z.string(),
+    studentId: z.string(),
+    termId: z.string().optional(),
+});
+export function registerGradeTools(server, client) {
+    server.registerTool('ic_list_grades', {
+        description: "List a student's term grades and in-progress course grades.",
+        annotations: { readOnlyHint: true },
+        inputSchema: argsSchema.shape,
+    }, async (rawArgs) => {
+        const args = argsSchema.parse(rawArgs);
+        const params = new URLSearchParams({ personID: args.studentId });
+        if (args.termId)
+            params.set('termID', args.termId);
+        const data = await client.request(args.district, `/campus/api/portal/parents/grades?${params}`);
+        return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+    });
+}

package/dist/tools/messages.js

@@ -0,0 +1,80 @@
+import { z } from 'zod';
+const listArgs = z.object({
+    district: z.string(),
+    folder: z.enum(['inbox', 'sent']).optional(),
+    page: z.number().int().positive().optional(),
+    size: z.number().int().positive().optional(),
+});
+const getArgs = z.object({
+    district: z.string(),
+    messageId: z.string(),
+});
+const recipientsArgs = z.object({
+    district: z.string(),
+    studentId: z.string(),
+});
+const sendArgs = z.object({
+    district: z.string(),
+    studentId: z.string().describe('Student personID; used to validate recipient IDs'),
+    recipientIds: z.array(z.string()).min(1),
+    subject: z.string().min(1),
+    body: z.string().min(1),
+});
+export function registerMessageTools(server, client) {
+    server.registerTool('ic_list_messages', {
+        description: 'List portal inbox or sent messages (district announcements, teacher notes).',
+        annotations: { readOnlyHint: true },
+        inputSchema: listArgs.shape,
+    }, async (rawArgs) => {
+        const args = listArgs.parse(rawArgs);
+        const folder = args.folder ?? 'inbox';
+        const params = new URLSearchParams({
+            folder, page: String(args.page ?? 1), size: String(args.size ?? 50),
+        });
+        const data = await client.request(args.district, `/campus/api/portal/parents/messages?${params}`);
+        return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+    });
+    server.registerTool('ic_get_message', {
+        description: 'Get a single portal message by ID.',
+        annotations: { readOnlyHint: true },
+        inputSchema: getArgs.shape,
+    }, async (rawArgs) => {
+        const args = getArgs.parse(rawArgs);
+        const data = await client.request(args.district, `/campus/api/portal/parents/messages/${encodeURIComponent(args.messageId)}`);
+        return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+    });
+    server.registerTool('ic_list_message_recipients', {
+        description: "List people the parent can message about this student (teachers + counselors). IDs returned here are the only valid recipientIds for ic_send_message.",
+        annotations: { readOnlyHint: true },
+        inputSchema: recipientsArgs.shape,
+    }, async (rawArgs) => {
+        const args = recipientsArgs.parse(rawArgs);
+        const data = await client.request(args.district, `/campus/api/portal/parents/messageRecipients?personID=${encodeURIComponent(args.studentId)}`);
+        return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+    });
+    server.registerTool('ic_send_message', {
+        description: 'Send a portal message to a teacher/counselor about a student. recipientIds MUST come from ic_list_message_recipients for that student.',
+        annotations: { destructiveHint: true },
+        inputSchema: sendArgs.shape,
+    }, async (rawArgs) => {
+        const args = sendArgs.parse(rawArgs);
+        const valid = await client.request(args.district, `/campus/api/portal/parents/messageRecipients?personID=${encodeURIComponent(args.studentId)}`);
+        const validIds = valid.map((v) => v.recipientId);
+        const invalidIds = args.recipientIds.filter((id) => !validIds.includes(id));
+        if (invalidIds.length > 0) {
+            const err = { error: 'InvalidRecipient', invalidIds, validIds };
+            return { content: [{ type: 'text', text: JSON.stringify(err, null, 2) }] };
+        }
+        const data = await client.request(args.district, '/campus/api/portal/parents/messages', {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                recipientIds: args.recipientIds,
+                subject: args.subject,
+                body: args.body,
+                personID: args.studentId,
+            }),
+        });
+        return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+    });
+}

package/dist/tools/schedule.js

@@ -0,0 +1,22 @@
+import { z } from 'zod';
+const argsSchema = z.object({
+    district: z.string().describe('District name from ic_list_districts'),
+    studentId: z.string().describe('Student personID from ic_list_students'),
+    date: z.string().describe('YYYY-MM-DD; defaults to today').optional(),
+    termFilter: z.string().describe('Term name or ID; optional').optional(),
+});
+export function registerScheduleTools(server, client) {
+    server.registerTool('ic_get_schedule', {
+        description: "Get a student's class schedule for a given date (default: today).",
+        annotations: { readOnlyHint: true },
+        inputSchema: argsSchema.shape,
+    }, async (rawArgs) => {
+        const args = argsSchema.parse(rawArgs);
+        const date = args.date ?? new Date().toISOString().slice(0, 10);
+        const params = new URLSearchParams({ personID: args.studentId, date });
+        if (args.termFilter)
+            params.set('term', args.termFilter);
+        const data = await client.request(args.district, `/campus/api/portal/parents/schedule?${params}`);
+        return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+    });
+}

package/dist/tools/students.js

@@ -0,0 +1,15 @@
+import { z } from 'zod';
+const argsSchema = z.object({
+    district: z.string().describe('District name from ic_list_districts'),
+});
+export function registerStudentTools(server, client) {
+    server.registerTool('ic_list_students', {
+        description: 'List students enrolled under the parent account for a given district.',
+        annotations: { readOnlyHint: true },
+        inputSchema: argsSchema.shape,
+    }, async (rawArgs) => {
+        const args = argsSchema.parse(rawArgs);
+        const data = await client.request(args.district, '/campus/api/portal/parents/students');
+        return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+    });
+}

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "infinitecampus-mcp",
+  "version": "0.1.0",
+  "description": "Infinite Campus (Campus Parent) MCP server — multi-district read + message/document write",
+  "author": "Claude Code (AI) <https://www.anthropic.com/claude>",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/chrischall/infinitecampus-mcp.git"
+  },
+  "license": "MIT",
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "claude",
+    "ai",
+    "infinite-campus",
+    "campus-parent",
+    "school",
+    "education",
+    "k12",
+    "grades",
+    "attendance",
+    "assignments"
+  ],
+  "type": "module",
+  "bin": {
+    "infinitecampus-mcp": "dist/index.js"
+  },
+  "files": ["dist", ".claude-plugin", "skills", ".mcp.json"],
+  "scripts": {
+    "build": "tsc && npm run bundle",
+    "bundle": "esbuild src/index.ts --bundle --platform=node --format=esm --external:dotenv --outfile=dist/bundle.js",
+    "dev": "node --env-file=.env dist/index.js",
+    "test": "vitest run",
+    "test:watch": "vitest"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.29.0",
+    "dotenv": "^17.4.0",
+    "zod": "^4.3.6"
+  },
+  "devDependencies": {
+    "@types/node": "^25.5.2",
+    "@vitest/coverage-v8": "^4.1.2",
+    "esbuild": "^0.28.0",
+    "typescript": "^6.0.2",
+    "vitest": "^4.1.2"
+  }
+}